OVMS3/OVMS.V3/main/ovms_console.cpp

255 lines
7.2 KiB
C++

/*
; Project: Open Vehicle Monitor System
; Date: 14th March 2017
;
; Changes:
; 1.0 Initial release
;
; (C) 2011 Michael Stegen / Stegen Electronics
; (C) 2011-2017 Mark Webb-Johnson
; (C) 2011 Sonny Chen @ EPRO/DX
;
; Permission is hereby granted, free of charge, to any person obtaining a copy
; of this software and associated documentation files (the "Software"), to deal
; in the Software without restriction, including without limitation the rights
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
; copies of the Software, and to permit persons to whom the Software is
; furnished to do so, subject to the following conditions:
;
; The above copyright notice and this permission notice shall be included in
; all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
; THE SOFTWARE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ovms_log.h"
#include "ovms_console.h"
#include "ovms_version.h"
#include "log_buffers.h"
//static const char *TAG = "Console";
static char CRbuf[4] = { '\r', '\033', '[', 'K' };
static char NLbuf[2] = { '\r', '\n' };
static char ctrlRbuf[1] = { 'R'-0100 };
char ** Complete (microrl_t* rl, int argc, const char * const * argv )
{
return MyCommandApp.Complete((OvmsWriter*)rl->userdata, argc, argv);
}
OvmsConsole::OvmsConsole()
: OvmsShell(COMMAND_RESULT_VERBOSE)
{
m_ready = false;
m_deferred = NULL;
m_discarded = 0;
m_state = AT_PROMPT;
m_lost = m_acked = 0;
}
OvmsConsole::~OvmsConsole()
{
m_ready = false;
MyCommandApp.DeregisterConsole(this);
}
void OvmsConsole::Initialize(const char* console)
{
OvmsShell::Initialize(console != NULL);
microrl_set_complete_callback(&m_rl, Complete);
if (console)
{
printf("\nWelcome to the Open Vehicle Monitoring System (OVMS) - %s Console\n", console);
printf("Firmware: %s\nHardware: %s\n",GetOVMSVersion().c_str(),GetOVMSHardware().c_str());
ProcessChar('\n');
MyCommandApp.RegisterConsole(this);
}
m_ready = true;
}
char** OvmsConsole::SetCompletion(int index, const char* token)
{
if (index < COMPLETION_MAX_TOKENS+1)
{
if (index == COMPLETION_MAX_TOKENS)
token = "...";
if (token)
{
strncpy(m_space[index], token, TOKEN_MAX_LENGTH-1);
m_space[index][TOKEN_MAX_LENGTH-1] = '\0';
m_completions[index] = m_space[index];
++index;
}
m_completions[index] = NULL;
}
return m_completions;
}
void OvmsConsole::Log(LogBuffers* message)
{
if (!m_ready)
{
message->release();
return;
}
Event event;
event.type = ALERT_MULTI;
event.multi = message;
BaseType_t ret = xQueueSendToBack(m_queue, (void * )&event, 0);
if (ret != pdPASS)
{
message->release();
++m_lost;
}
}
void OvmsConsole::Service()
{
vTaskDelay(50 / portTICK_PERIOD_MS);
for (;;)
{
Poll(portMAX_DELAY);
}
}
void OvmsConsole::Poll(portTickType ticks, QueueHandle_t queue)
{
Event event;
if (!queue)
queue = m_queue;
for (;;)
{
// Waiting for UART RX event or async log message event
if (xQueueReceive(queue, (void*)&event, ticks))
{
if (event.type <= RECV)
{
if (m_state != AT_PROMPT)
ProcessChars(ctrlRbuf, 1); // Restore the prompt plus any type-in on a new line
m_state = AT_PROMPT;
HandleDeviceEvent(&event);
continue;
}
// While a command that takes input is executing, put alert events into a
// separate "deferred" queue. If that queue fills, keep only the last N
// events and count those discarded.
if (m_insert)
{
if (!m_deferred)
m_deferred = xQueueCreate(CONFIG_OVMS_HW_CONSOLE_QUEUE_SIZE, sizeof(Event));
if (xQueueSendToBack(m_deferred, (void *)&event, 0) != pdPASS)
{
Event discard;
xQueueReceive(m_deferred, (void*)&discard, 0);
xQueueSendToBack(m_deferred, (void *)&event, 0);
if (discard.type == ALERT_MULTI)
discard.multi->release();
else
free(discard.buffer);
++m_discarded;
}
continue;
}
// We remove the newline from the end of a log message so that we can later
// output a newline as part of restoring the command prompt and its line
// without leaving a blank line above it. So before we display a new log
// message we need to output a newline if the last action was displaying a
// log message, or output a carriage return to back over the prompt.
if (m_monitoring &&
(event.type != ALERT_MULTI || event.multi->begin() != event.multi->end()))
{
if (m_state == AWAITING_NL)
write(NLbuf, 2);
else if (m_state == AT_PROMPT)
write(CRbuf, 4);
char* buffer;
size_t len;
if (event.type == ALERT_MULTI)
{
LogBuffers::iterator before = event.multi->begin(), after;
while (true)
{
buffer = *before;
len = strlen(buffer);
after = before;
++after;
if (after == event.multi->end())
break;
write(buffer, len);
before = after;
}
}
else
{
buffer = event.buffer;
len = strlen(buffer);
}
if (buffer[len-1] == '\n')
{
--len;
if (buffer[len-1] == '\r') // Omit CR, too, in case of \r\n
--len;
m_state = AWAITING_NL;
write(buffer, len);
}
else
{
m_state = NO_NL;
write(buffer, len);
}
}
if (event.type == ALERT_MULTI)
event.multi->release();
else
free(event.buffer);
ticks = 200 / portTICK_PERIOD_MS;
}
else
{
// Timeout indicates the queue is empty
unsigned int lost = m_lost - m_acked; // Modulo 2^32 arithmetic
if (lost > 0)
{
if (m_state == AWAITING_NL)
write(NLbuf, 2);
else if (m_state == AT_PROMPT)
write(CRbuf, 4);
printf("\033[33m[%d log messages lost]\033[0m", lost);
m_state = AWAITING_NL;
m_acked += lost;
continue;
}
if (m_state != AT_PROMPT)
ProcessChars(ctrlRbuf, 1); // Restore the prompt plus any type-in on a new line
m_state = AT_PROMPT;
return;
}
}
}
void OvmsConsole::finalise()
{
if (m_deferred)
{
if (m_discarded)
{
printf("\033[33m[%d log messages discarded]\033[0m", m_discarded);
m_state = AWAITING_NL;
m_discarded = 0;
}
Poll(0, m_deferred);
vQueueDelete(m_deferred);
m_deferred = NULL;
}
}