/**
* Debug: sets a setting (key/value) / part 1
*/
void cmd_keyvalset(char *line) {
serial_write_string("|| Enter KEY=VAL, end with a single = on a new line.\r\n");
serial_write_string("#>");
command_stack[command_stack_size] = serial_setkeyval_run;
command_stack_size++;
}
/**
* Very simplistic output of a json structure as:
* { "key": "val" }
*/
void json_keyval(const char *cmd, const char *val) {
serial_write_string("{ \"");
serial_write_string(cmd);
serial_write_string("\": \"");
serial_write_string(val);
serial_write_string("\"}");
}
void cmd_readadc(char *line) {
adc_init(PIN_MAP[12].adc_device); // all on ADC1
adc_set_extsel(PIN_MAP[12].adc_device, ADC_SWSTART);
adc_set_exttrig(PIN_MAP[12].adc_device, true);
adc_enable(PIN_MAP[12].adc_device);
adc_calibrate(PIN_MAP[12].adc_device);
adc_set_sample_rate(PIN_MAP[12].adc_device, ADC_SMPR_55_5);
gpio_set_mode (PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit, GPIO_INPUT_ANALOG);
gpio_set_mode (PIN_MAP[19].gpio_device,PIN_MAP[19].gpio_bit, GPIO_INPUT_ANALOG);
gpio_set_mode (PIN_MAP[20].gpio_device,PIN_MAP[20].gpio_bit, GPIO_INPUT_ANALOG);
uint16 value1 = adc_read(PIN_MAP[12].adc_device,PIN_MAP[12].adc_channel);
uint16 value2 = adc_read(PIN_MAP[19].adc_device,PIN_MAP[19].adc_channel);
uint16 value3 = adc_read(PIN_MAP[20].adc_device,PIN_MAP[20].adc_channel);
char values[50];
sprintf(values,"PA6 ADC Read: %u\r\n",value1);
serial_write_string(values);
sprintf(values,"PC4 ADC Read: %u\r\n",value2);
serial_write_string(values);
sprintf(values,"PC5 ADC Read: %u\r\n",value3);
serial_write_string(values);
}
void serial_displayparams() {
serial_write_string("DISPLAY REINIT MODE\r\n");
serial_write_string("COMMAND IS: <CLOCK> <MULTIPLEX> <FUNCTIONSELECT> <VSL> <PHASELEN> <PRECHARGEVOLT> <PRECHARGEPERIOD> <VCOMH>\r\n");
serial_write_string("e.g: 241 127 1 1 50 23 8 5\r\n");
serial_write_string("#>");
in_displayparams=true;
}
void serial_setrtc() {
char info[100];
sprintf(info,"Current unixtime is %u\r\n",realtime_get_unixtime());
serial_write_string(info);
serial_write_string("#>");
in_setrtc=true;
}
/**
* Sets the device tag (part 1 of command)
*/
void cmd_setdevicetag(char *line) {
serial_write_string("SETDEVICETAG:\r\n");
serial_write_string("#>");
command_stack[command_stack_size] = serial_setdevicetag_run;
command_stack_size++;
}
void cmd_captouchparams(char *line) {
serial_write_string("CAPTOUCH PARAMS TEST\r\n");
serial_write_string("COMMAND IS: <MHD_R> <NHD_R> <NCL_R> <FDL_R> <MHD_F> <NHD_F> <NCL_F> <FDL_F> <DBR> <TOUCHTHRES> <RELTHRES>\r\n");
serial_write_string("#>");
command_stack[command_stack_size] = cmd_captouchparams_run;
command_stack_size++;
}
/**
* Sets the real time clock (unix time). Part 1
*/
void cmd_setrtc(char *line) {
char info[100];
sprintf(info,"Current unixtime is %"PRIu32"\r\n",realtime_get_unixtime());
serial_write_string(info);
serial_write_string("#>");
command_stack[command_stack_size] = serial_setrtc_run;
command_stack_size++;
}
void cmd_captouchdump(char *line) {
serial_write_string("CAPTOUCH ELECTRODE STATE\r\n");
serial_write_string("ELECV ELECBASELINE KEYSTATE THISKEYSTATE\r\n");
for(int n=0;n<11;n++) {
char *s = cap_diagdata(n);
serial_write_string(s);
serial_write_string("\r\n");
}
}
/**
* Debugging command: changes the OLED display drive parameters.
* Use with caution, you can probably damage the screen if you use wrong
* parameters.
*
* This is part 1 of the command gets user input
*/
void cmd_displayparams(char *line) {
serial_write_string("DISPLAY REINIT MODE\r\n");
serial_write_string("COMMAND IS: <CLOCK> <MULTIPLEX> <FUNCTIONSELECT> <VSL> <PHASELEN> <PRECHARGEVOLT> <PRECHARGEPERIOD> <VCOMH>\r\n");
serial_write_string("e.g: 241 127 1 1 50 23 8 5\r\n");
serial_write_string("#>");
command_stack[command_stack_size] = serial_displayparams_run;
command_stack_size++;
}
/**
* Outputs a list of supported commands
*/
void cmd_help(char *line) {
serial_write_string("Available commands:\r\n\t");
for(int n=0;n<command_list_size;n++) {
serial_write_string(command_list[n]);
serial_write_string(", ");
if ((n%10 == 0) && (n > 0))
serial_write_string("\r\n\t"); // put 10 commands per line
}
serial_write_string("\n");
}
/**
* Debug command: dumps all settings (key/value).
* Output in this format:
* { "keys" {
* "key1": "value1",
* "key2": "value2",
* ...
* }
* }
*/
void cmd_keyvaldump(char *line) {
char key[50];
char val[50];
serial_write_string("{ \"keys\": {\n");
char str[110];
for(int n=0;;n++) {
flashstorage_keyval_by_idx(n,key,val);
if(key[0] == 0) break;
if (n>0) serial_write_string(",\n");
sprintf(str," \"%s\": \"%s\"",key,val);
serial_write_string(str);
}
serial_write_string(" }\n\n}\n");
}
void cmd_setmiciphone(char *line) {
gpio_set_mode (PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit, GPIO_OUTPUT_PP); // MICREVERSE
gpio_set_mode (PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit, GPIO_OUTPUT_PP); // MICIPHONE
gpio_write_bit(PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit,0); // MICREVERSE
gpio_write_bit(PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit,1); // MICIPHONE
serial_write_string("Set MICREVERSE to 0, MICIPHONE to 1\r\n");
}
void serial_keyvaldump() {
char key[100];
char val[100];
char str[200];
sprintf(str,"key=val\r\n");
serial_write_string(str);
for(int n=0;;n++) {
flashstorage_keyval_by_idx(n,key,val);
if(key[0] == 0) return;
sprintf(str,"%s=%s\r\n",key,val);
serial_write_string(str);
}
}
/**
* Gets current time on the device
*/
void cmd_getrtc() {
JSONNODE *n = json_new(JSON_NODE);
json_push_back(n, json_new_i("rtc", realtime_get_unixtime()));
json_char *jc = json_write_formatted(n);
serial_write_string(jc);
json_free(jc);
json_delete(n);
}
/**
* hello: a simple "ping" command to check that the
* device is responsive
*/
void cmd_hello(char *line) {
JSONNODE *n = json_new(JSON_NODE);
json_push_back(n, json_new_a("hello", "Greetings professor Falken"));
json_char *jc = json_write_formatted(n);
serial_write_string(jc);
json_free(jc);
json_delete(n);
}
/**
* Outputs firmware version
*/
void cmd_version(char *line) {
JSONNODE *n = json_new(JSON_NODE);
json_push_back(n, json_new_a("version", OS100VERSION));
json_char *jc = json_write_formatted(n);
serial_write_string(jc);
json_free(jc);
json_delete(n);
}
/**
* This function is called by default with the latest received
* command line as argument.
*/
void cmd_main_menu(char *line) {
for(int n=0;n<command_list_size;n++) {
if(strcmp(line,command_list[n]) == 0) {
(*command_funcs[n])(line);
}
}
if (command_stack_size == 1)
serial_write_string("\r\n>");
}
void serial_displayparams_run(char *line) {
uint32_t clock, multiplex, functionselect,vsl,phaselen,prechargevolt,prechargeperiod,vcomh;
sscanf(line,"%u %u %u %u %u %u %u %u",&clock,&multiplex,&functionselect,&vsl,&phaselen,&prechargevolt,&prechargeperiod,&vcomh);
char outline[1024];
sprintf(outline,"Received values: %u %u %u %u %u %u %u %u, calling reinit\r\n",clock,multiplex,functionselect,vsl,phaselen,prechargevolt,prechargeperiod,vcomh);
serial_write_string(outline);
oled_reinit(clock,multiplex,functionselect,vsl,phaselen,prechargevolt,prechargeperiod,vcomh);
}
void cmd_logstress(char *line) {
serial_write_string("Log stress testing - 5000 writes\r\n");
log_data_t data;
data.time = rtc_get_time(RTC);
data.cpm = 1;
data.accel_x_start = 2;
data.accel_y_start = 3;
data.accel_z_start = 4;
data.log_type = UINT_MAX;
char err[50];
for(int n=0;n<5000;n++) {
data.cpm = n;
int r = flashstorage_log_pushback((uint8_t *) &data,sizeof(log_data_t));
sprintf(err,"return code: %d\r\n",r);
serial_write_string(err);
}
serial_write_string("Complete\r\n");
}
/**
* Outputs device tag
*/
void cmd_getdevicetag(char *line) {
const char *devicetag = flashstorage_keyval_get("DEVICETAG");
JSONNODE *n = json_new(JSON_NODE);
if(devicetag != 0) {
json_push_back(n, json_new_a("devicetag", devicetag));
} else {
json_push_back(n, json_new_a("devicetag", "No device tag set"));
}
json_char *jc = json_write_formatted(n);
serial_write_string(jc);
json_free(jc);
json_delete(n);
}
void serial_sendlog() {
flashstorage_log_pause();
log_read_start();
char buffer[1024];
int size = log_read_block(buffer);
for(;size!=0;) {
if(size != 0) serial_write_string(buffer);
size = log_read_block(buffer);
}
flashstorage_log_resume();
}
/**
* Dumps the data log as a comma-separated stream. Pauses
* logging at the beginning and restarts afterwards.
*/
void cmd_logcsv(char *line) {
flashstorage_log_pause();
log_read_start();
char buffer[1024];
int size = log_read_csv(buffer);
for(;size!=0;) {
if(size != 0) serial_write_string(buffer);
size = log_read_csv(buffer);
}
flashstorage_log_resume();
}
/**
* Gets the current CPM reading as
* { "cpm": {
* "value": val, // Actual value
* "valid": boolean, // Valid flag
* "raw": val, // Uncompensated value
* "cpm30": val // 30 second window
* }
* }
*
* See Geiger.cpp for a more in-depth explanation of
* raw and compensated CPM values.
*/
void cmd_cpm(char *line) {
JSONNODE *n = json_new(JSON_NODE);
JSONNODE *reading = json_new(JSON_NODE);
json_set_name(reading, "cpm");
json_push_back(reading, json_new_f("value", system_geiger->get_cpm_deadtime_compensated()));
json_push_back(reading, json_new_b("valid", system_geiger->is_cpm_valid()));
json_push_back(reading, json_new_f("raw", system_geiger->get_cpm()));
json_push_back(reading, json_new_f("cpm30", system_geiger->get_cpm30()));
json_push_back(n, reading);
json_char *jc = json_write_formatted(n);
serial_write_string(jc);
json_free(jc);
json_delete(n);
}
void cmd_writedac(char *line) {
dac_init(DAC,DAC_CH2);
int8_t idelta=1;
uint8_t i=0;
for(int n=0;n<1000000;n++) {
if(i == 254) idelta = -1;
if(i == 0 ) idelta = 1;
i += idelta;
dac_write_channel(DAC,2,i);
}
serial_write_string("WRITEDACFIN");
}
void cmd_magread(char *line) {
gpio_set_mode (PIN_MAP[41].gpio_device,PIN_MAP[41].gpio_bit, GPIO_OUTPUT_PP); // MAGPOWER
gpio_set_mode (PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit, GPIO_INPUT_PU); // MAGSENSE
// Power up magsense
gpio_write_bit(PIN_MAP[41].gpio_device,PIN_MAP[41].gpio_bit,1);
// wait...
delay_us(1000);
// Read magsense
int magsense = gpio_read_bit(PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit);
char magsenses[50];
sprintf(magsenses,"%u\r\n",magsense);
serial_write_string(magsenses);
}
/**
* Displays status of log area: records used, total records
* and logging interval (in seconds)
*/
void cmd_logstatus(char *line) {
JSONNODE *n = json_new(JSON_NODE);
JSONNODE *n2 = json_new(JSON_NODE);
json_set_name(n2, "logstatus");
json_push_back(n2, json_new_i("used", flashstorage_log_currentrecords()));
json_push_back(n2, json_new_i("total", flashstorage_log_maxrecords()));
const char *sloginter = flashstorage_keyval_get("LOGINTERVAL");
uint32_t c = 0;
if(sloginter != 0) {
sscanf(sloginter, "%"PRIu32"", &c);
} else {
c = 30 * 60;
}
json_push_back(n2, json_new_i("interval", c));
json_push_back(n, n2);
json_char *jc = json_write_formatted(n);
serial_write_string(jc);
json_free(jc);
json_delete(n);
}
void serial_eventloop() {
char buf[1024];
uint32_t read_size = usart_rx(USART1,(uint8 *) buf,1024);
if(read_size == 0) return;
if(read_size > 1024) return; // something went wrong
for(uint32_t n=0;n<read_size;n++) {
// echo
usart_putc(USART1, buf[n]);
if((buf[n] == 13) || (buf[n] == 10)) {
serial_write_string("\r\n");
currentline[currentline_position]=0;
serial_process_command(currentline);
currentline_position=0;
} else {
currentline[currentline_position] = buf[n];
currentline_position++;
}
}
}
void serial_writeprivatekey() {
// TODO: Will add code to read from serial and write data to flash region here.
serial_write_string("Writing incrementing private key data\r\n");
uint8_t pagedata[2048];
for(int n=0;n<2048;n++) pagedata[n] = n;
uint8_t *source_data_programmable = (uint8_t *) 0x8000800;
flashstorage_unlock();
flashstorage_erasepage(source_data_programmable);
flashstorage_lock();
flashstorage_unlock();
flashstorage_writepage(pagedata,source_data_programmable);
flashstorage_lock();
source_data_programmable += 2048;
flashstorage_unlock();
flashstorage_erasepage(source_data_programmable);
flashstorage_lock();
flashstorage_unlock();
flashstorage_writepage(pagedata,source_data_programmable);
flashstorage_lock();
}
void cmd_captouchparams_run(char *line) {
uint32_t mhd_r, nhd_r, ncl_r, fdl_r;
uint32_t mhd_f, nhd_f, ncl_f, fdl_f;
uint32_t dbr,touchthres,relthres;
sscanf(line,"%"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32""
,&mhd_r,&nhd_r,&ncl_r,&fdl_r
,&mhd_f,&nhd_f,&ncl_f,&fdl_f
,&dbr,&touchthres,&relthres);
char outline[1024];
sprintf(outline,"Read values: %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32"\n"
,mhd_r,nhd_r,ncl_r,fdl_r
,mhd_f,nhd_f,ncl_f,fdl_f
,dbr,touchthres,relthres);
serial_write_string(outline);
cap_set_mhd_r(mhd_r);
cap_set_nhd_r(nhd_r);
cap_set_ncl_r(ncl_r);
cap_set_fdl_r(fdl_r);
cap_set_mhd_f(mhd_f);
cap_set_nhd_f(nhd_f);
cap_set_ncl_f(ncl_f);
cap_set_fdl_f(fdl_f);
cap_set_dbr (dbr);
cap_set_touch_threshold (touchthres);
cap_set_release_threshold(relthres);
cap_deinit();
cap_init();
command_stack_pop();
}
