/** * 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(); }