410 lines
13 KiB
C++
410 lines
13 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 "ovms_log.h"
|
|
static const char *TAG = "test";
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "esp_system.h"
|
|
#include "esp_event.h"
|
|
#include "esp_event_loop.h"
|
|
#include "esp_sleep.h"
|
|
#include "test_framework.h"
|
|
#include "ovms_command.h"
|
|
#include "ovms_peripherals.h"
|
|
#include "ovms_script.h"
|
|
#include "metrics_standard.h"
|
|
#include "ovms_config.h"
|
|
#include "can.h"
|
|
#include "strverscmp.h"
|
|
|
|
void test_deepsleep(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
int sleeptime = 60;
|
|
if (argc==1)
|
|
{
|
|
sleeptime = atoi(argv[0]);
|
|
}
|
|
writer->puts("Entering deep sleep...");
|
|
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
|
esp_deep_sleep(1000000LL * sleeptime);
|
|
}
|
|
|
|
void test_javascript(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
#ifdef CONFIG_OVMS_SC_JAVASCRIPT_NONE
|
|
writer->puts("No javascript engine enabled");
|
|
#endif //#ifdef CONFIG_OVMS_SC_JAVASCRIPT_NONE
|
|
|
|
#ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
|
|
writer->printf("Javascript 1+2=%d\n", MyDuktape.DuktapeEvalIntResult("1+2"));
|
|
#endif //#ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
|
|
}
|
|
|
|
#ifdef CONFIG_OVMS_COMP_SDCARD
|
|
void test_sdcard(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
sdcard *sd = MyPeripherals->m_sdcard;
|
|
|
|
if (!sd->isinserted())
|
|
{
|
|
writer->puts("Error: No SD CARD inserted");
|
|
return;
|
|
}
|
|
if (!sd->ismounted())
|
|
{
|
|
writer->puts("Error: SD CARD not mounted");
|
|
return;
|
|
}
|
|
|
|
unlink("/sd/ovmstest.txt");
|
|
char buffer[512];
|
|
memset(buffer,'A',sizeof(buffer));
|
|
|
|
FILE *fd = fopen("/sd/ovmstest.txt","w");
|
|
if (fd == NULL)
|
|
{
|
|
writer->puts("Error: /sd/ovmstest.txt could not be opened for writing");
|
|
return;
|
|
}
|
|
|
|
writer->puts("SD CARD test starts...");
|
|
for (int k=0;k<2048;k++)
|
|
{
|
|
fwrite(buffer, sizeof(buffer), 1, fd);
|
|
if ((k % 128)==0)
|
|
writer->printf("SD CARD written %d/%d\n",k,2048);
|
|
}
|
|
fclose(fd);
|
|
|
|
writer->puts("Cleaning up");
|
|
unlink("/sd/ovmstest.txt");
|
|
|
|
writer->puts("SD CARD test completes");
|
|
}
|
|
#endif // #ifdef CONFIG_OVMS_COMP_SDCARD
|
|
|
|
// Spew lines of the ASCII printable characters in the style of RFC 864.
|
|
void test_chargen(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
int numlines = 1000;
|
|
int delay = 0;
|
|
if (argc>=1)
|
|
{
|
|
numlines = atoi(argv[0]);
|
|
}
|
|
if (argc>=2)
|
|
{
|
|
delay = atoi(argv[1]);
|
|
}
|
|
char buf[74];
|
|
buf[72] = '\n';
|
|
buf[73] = '\0';
|
|
char start = '!';
|
|
for (int line = 0; line < numlines; ++line)
|
|
{
|
|
char ch = start;
|
|
for (int col = 0; col < 72; ++col)
|
|
{
|
|
buf[col] = ch;
|
|
if (++ch == 0x7F)
|
|
ch = ' ';
|
|
}
|
|
if (writer->write(buf, 73) <= 0)
|
|
break;
|
|
if (delay)
|
|
vTaskDelay(delay/portTICK_PERIOD_MS);
|
|
if (++start == 0x7F)
|
|
start = ' ';
|
|
}
|
|
}
|
|
|
|
bool test_echo_insert(OvmsWriter* writer, void* ctx, char ch)
|
|
{
|
|
if (ch == '\n')
|
|
return false;
|
|
writer->write(&ch, 1);
|
|
return true;
|
|
}
|
|
|
|
void test_echo(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
writer->puts("Type characters to be echoed, end with newline.");
|
|
writer->RegisterInsertCallback(test_echo_insert, NULL);
|
|
}
|
|
|
|
void test_watchdog(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
writer->puts("Spinning now (watchdog should fire in a few minutes)");
|
|
for (;;) {}
|
|
writer->puts("Error: We should never get here");
|
|
}
|
|
|
|
void test_stackoverflow(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
uint8_t data[256];
|
|
memset(data, verbosity & 255, sizeof data);
|
|
writer->printf("Stack bytes remaining: %u\n", uxTaskGetStackHighWaterMark(NULL));
|
|
vTaskDelay(pdMS_TO_TICKS(250));
|
|
test_stackoverflow(verbosity+1, writer, cmd, argc, argv);
|
|
// never reached, just to inhibit tail recursion optimization:
|
|
writer->printf("%x\n", data[0]);
|
|
}
|
|
|
|
void test_realloc(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
void* buf;
|
|
void *interfere = NULL;
|
|
|
|
writer->puts("First check heap integrity...");
|
|
heap_caps_check_integrity_all(true);
|
|
|
|
writer->puts("Now allocate 4KB RAM...");
|
|
buf = ExternalRamMalloc(4096);
|
|
|
|
writer->puts("Check heap integrity...");
|
|
heap_caps_check_integrity_all(true);
|
|
|
|
writer->puts("Now re-allocate bigger, 1,000 times...");
|
|
for (int k=1; k<1001; k++)
|
|
{
|
|
buf = ExternalRamRealloc(buf, 4096+k);
|
|
if (interfere == NULL)
|
|
{
|
|
interfere = ExternalRamMalloc(1024);
|
|
}
|
|
else
|
|
{
|
|
free(interfere);
|
|
interfere = NULL;
|
|
}
|
|
}
|
|
|
|
writer->puts("Check heap integrity...");
|
|
heap_caps_check_integrity_all(true);
|
|
|
|
writer->puts("Now re-allocate smaller, 1,000 times...");
|
|
for (int k=1001; k>0; k--)
|
|
{
|
|
buf = ExternalRamRealloc(buf, 4096+k);
|
|
if (interfere == NULL)
|
|
{
|
|
interfere = ExternalRamMalloc(1024);
|
|
}
|
|
else
|
|
{
|
|
free(interfere);
|
|
interfere = NULL;
|
|
}
|
|
}
|
|
|
|
writer->puts("Check heap integrity...");
|
|
heap_caps_check_integrity_all(true);
|
|
|
|
writer->puts("And free the buffer...");
|
|
free(buf);
|
|
if (interfere != NULL) free(interfere);
|
|
|
|
writer->puts("Final check of heap integrity...");
|
|
heap_caps_check_integrity_all(true);
|
|
}
|
|
|
|
void test_spiram(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
writer->printf("Metrics (%p) are in %s RAM (%d bytes for a base metric)\n",
|
|
StandardMetrics.ms_m_version,
|
|
(((unsigned int)StandardMetrics.ms_m_version >= 0x3f800000)&&
|
|
((unsigned int)StandardMetrics.ms_m_version <= 0x3fbfffff))?
|
|
"SPI":"INTERNAL",
|
|
sizeof(OvmsMetric));
|
|
}
|
|
|
|
void test_strverscmp(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
int c = strverscmp(argv[0],argv[1]);
|
|
writer->printf("%s %s %s\n",
|
|
argv[0],
|
|
(c<0)?"<":((c==0)?"=":">"),
|
|
argv[1]
|
|
);
|
|
}
|
|
|
|
void test_can(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
int64_t started = esp_timer_get_time();
|
|
int64_t elapsed;
|
|
bool tx = (strcmp(cmd->GetName(), "cantx")==0);
|
|
|
|
int frames = 1000;
|
|
if (argc>1) frames = atoi(argv[1]);
|
|
|
|
canbus *can;
|
|
if (argc>0)
|
|
can = (canbus*)MyPcpApp.FindDeviceByName(argv[0]);
|
|
else
|
|
can = (canbus*)MyPcpApp.FindDeviceByName("can1");
|
|
if (can == NULL)
|
|
{
|
|
writer->puts("Error: Cannot find specified can bus");
|
|
return;
|
|
}
|
|
|
|
writer->printf("Testing %d frames on %s\n",frames,can->GetName());
|
|
|
|
CAN_frame_t frame;
|
|
memset(&frame,0,sizeof(frame));
|
|
frame.origin = can;
|
|
frame.FIR.U = 0;
|
|
frame.FIR.B.DLC = 8;
|
|
frame.FIR.B.FF = CAN_frame_std;
|
|
|
|
for (int k=0;k<frames;k++)
|
|
{
|
|
frame.MsgID = k % 2048;
|
|
frame.data.u64 = k+1;
|
|
if (tx)
|
|
can->Write(&frame, pdMS_TO_TICKS(10));
|
|
else
|
|
MyCan.IncomingFrame(&frame);
|
|
}
|
|
|
|
elapsed = esp_timer_get_time() - started;
|
|
int uspt = elapsed / frames;
|
|
writer->printf("Transmitted %d frames in %lld.%06llds = %dus/frame\n",
|
|
frames, elapsed / 1000000, elapsed % 1000000, uspt);
|
|
}
|
|
|
|
void test_mkstemp(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
int fd1, e1, fd2, e2;
|
|
char tn1[100], tn2[100];
|
|
snprintf(tn1, sizeof(tn1), "%s.XXXXXX", argv[0]);
|
|
snprintf(tn2, sizeof(tn2), "%s.XXXXXX", argv[0]);
|
|
errno = 0;
|
|
fd1 = mkstemp(tn1); e1 = errno;
|
|
fd2 = mkstemp(tn2); e2 = errno;
|
|
writer->printf("tempfile 1: '%s' => fd=%d error='%s'\n", tn1, fd1, (fd1<0) ? strerror(e1) : "-");
|
|
writer->printf("tempfile 2: '%s' => fd=%d error='%s'\n", tn2, fd2, (fd2<0) ? strerror(e2) : "-");
|
|
if (fd1 >= 0) { close(fd1); unlink(tn1); }
|
|
if (fd2 >= 0) { close(fd2); unlink(tn2); }
|
|
}
|
|
|
|
void test_string(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
int loopcnt = atoi(argv[0]);
|
|
int mode = (argc > 1) ? atoi(argv[1]) : 1;
|
|
int stdlen = 0, errcnt = 0;
|
|
size_t pos;
|
|
OvmsMetric* m;
|
|
const char* t5 = "0123456789-abcdefghijk-";
|
|
std::string t6(t5);
|
|
|
|
int64_t time_start_us = esp_timer_get_time();
|
|
for (int j = 1; j <= loopcnt; j++)
|
|
{
|
|
std::string msg;
|
|
msg.reserve(2048);
|
|
for (m = MyMetrics.m_first; msg.size() < 1024; m = m->m_next ? m->m_next : MyMetrics.m_first)
|
|
{
|
|
if (mode == 1)
|
|
msg += m->AsJSON();
|
|
else if (mode == 2)
|
|
msg += m->AsString();
|
|
else if (mode == 3)
|
|
msg += m->m_name;
|
|
else if (mode == 4)
|
|
msg += MyConfig.GetParamValue("module", "cfgversion", m->m_name);
|
|
else if (mode == 5)
|
|
msg += t5;
|
|
else if (mode == 6)
|
|
msg += t6;
|
|
|
|
// check for NUL bytes:
|
|
if ((pos = msg.rfind('\0')) != std::string::npos)
|
|
{
|
|
writer->printf("loop #%d: corruption detected at pos=%u size=%u\n%s\n\n", j, pos, msg.size(), msg.c_str());
|
|
if (++errcnt == 20)
|
|
{
|
|
writer->puts("too many errors, abort");
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// display reference:
|
|
if (msg.size() > stdlen)
|
|
{
|
|
stdlen = msg.size();
|
|
writer->printf("#%d: stdlen = %d\n%s\n\n", j, stdlen, msg.c_str());
|
|
}
|
|
}
|
|
writer->printf("finished %d loops for mode %d using %s in %d ms\n", loopcnt, mode,
|
|
(t6.data() >= (void*)0x3F800000 && t6.data() < (void*)0x3FC00000) ? "extram" : "intram",
|
|
(int)((esp_timer_get_time() - time_start_us) / 1000));
|
|
}
|
|
|
|
void test_command(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
|
|
{
|
|
MyCommandApp.Display(writer);
|
|
}
|
|
|
|
class TestFrameworkInit
|
|
{
|
|
public: TestFrameworkInit();
|
|
} MyTestFrameworkInit __attribute__ ((init_priority (5000)));
|
|
|
|
TestFrameworkInit::TestFrameworkInit()
|
|
{
|
|
ESP_LOGI(TAG, "Initialising TEST (5000)");
|
|
|
|
OvmsCommand* cmd_test = MyCommandApp.RegisterCommand("test","Test framework");
|
|
cmd_test->RegisterCommand("sleep","Test Deep Sleep",test_deepsleep,"[<seconds>]",0,1);
|
|
#ifdef CONFIG_OVMS_COMP_SDCARD
|
|
cmd_test->RegisterCommand("sdcard","Test CD CARD",test_sdcard);
|
|
#endif // #ifdef CONFIG_OVMS_COMP_SDCARD
|
|
cmd_test->RegisterCommand("javascript","Test Javascript",test_javascript);
|
|
cmd_test->RegisterCommand("chargen","Character generator",test_chargen,"[<#lines>] [<delay_ms>]",0,2);
|
|
cmd_test->RegisterCommand("echo", "Test getchar", test_echo);
|
|
cmd_test->RegisterCommand("watchdog", "Test task spinning (and watchdog firing)", test_watchdog);
|
|
cmd_test->RegisterCommand("stackoverflow", "Test stack overflow detection (crashes)", test_stackoverflow);
|
|
cmd_test->RegisterCommand("realloc", "Test memory re-allocations", test_realloc);
|
|
cmd_test->RegisterCommand("spiram", "Test SPI RAM memory usage", test_spiram);
|
|
cmd_test->RegisterCommand("strverscmp", "Test strverscmp function", test_strverscmp, "", 2, 2);
|
|
cmd_test->RegisterCommand("cantx", "Test CAN bus transmission", test_can, "[<port>] [<number>]", 0, 2);
|
|
cmd_test->RegisterCommand("canrx", "Test CAN bus reception", test_can, "[<port>] [<number>]", 0, 2);
|
|
cmd_test->RegisterCommand("mkstemp", "Test mkstemp function", test_mkstemp, "<file>", 1, 1);
|
|
cmd_test->RegisterCommand("string", "Test std::string memory corruption", test_string, "<loopcnt> <mode>\n"
|
|
"mode: 1=m.AsJSON, 2=m.AsString, 3=m.name, 4=const cfg string, 5=const local cstr, 6=const local string", 2, 2);
|
|
cmd_test->RegisterCommand("commands", "List command tree", test_command);
|
|
}
|