自学教程：C++ ECMD_FINAL函数代码示例

int16_tparse_cmd_sram_memtest(char *cmd, char *output, uint16_t len){	if (sram_memtest())        return ECMD_FINAL_OK;    else        return ECMD_FINAL( snprintf_P(output, len,               PSTR("memtest error: see debugging output for more information")));}

int16_t parse_cmd_ntp_status(char *cmd, char *output, uint16_t len){    uint32_t last_sync = clock_last_sync();    int16_t  last_delta = clock_last_delta();    uint16_t ntp_timer = clock_last_ntp();    uint16_t dcf_counter = clock_dcf_count();    uint16_t ntp_counter = clock_ntp_count();    return ECMD_FINAL(snprintf_P(output,len,PSTR("Update:%lu/ndelta:%d/nOCR1A:%u/nDCF/NTP:%d/%d/nResyn:%d"), last_sync, last_delta, OCR1A, dcf_counter, ntp_counter, ntp_timer));}

int16_tparse_cmd_sht_temp(char *cmd, char *output, uint16_t len){  uint16_t raw_temp = 0;  int8_t ret;  // the longest error message is 9 bytes + /0, all possible temp/hex values fit  if (len < 10)    return ECMD_FINAL(ECMD_ERR_PARSE_ERROR);  ret = sht_get(&raw_temp, NULL);  if (ret == SHT_OK)    return      ECMD_FINAL(itoa_fixedpoint(sht_convert_temp(&raw_temp), 2, output, len));  else    return ECMD_FINAL(output_sht_error(ret, output));}

int16_tparse_cmd_sd_rm(char *cmd, char *output, uint16_t len){  while (*cmd == ' ')    cmd++;  return (vfs_sd_unlink(cmd) == 0 ?          ECMD_FINAL_OK : ECMD_FINAL(snprintf_P(output, len, PSTR("write error"))));}

int16_tparse_cmd_version(char *cmd, char *output, uint16_t len){  (void) cmd;  strncpy_P(output, pstr_E6_VERSION_STRING_LONG, len);  return ECMD_FINAL(strlen(output));}

int16_t parse_cmd_date(char *cmd, char *output, uint16_t len){  struct clock_datetime_t date;  clock_current_localtime(&date);  return ECMD_FINAL(snprintf_P(output, len, PSTR("%s %02d.%02d.%04d %02d:%02d:%02d"),                               weekdays[date.dow],                               date.day, date.month, date.year + 1900,                               date.hour, date.min, date.sec, date.day));}

int16_t parse_cmd_i2c_max7311_getINw(char *cmd, char *output, uint16_t len){  uint8_t adr;  uint16_t data;  uint8_t ret;  sscanf_P(cmd, PSTR("%hhu"), &adr);  if (adr > 0x6F)    return ECMD_ERR_PARSE_ERROR;  ret = i2c_max7311_getINw(adr, &data);  if (ret == 0) {#ifdef ECMD_MIRROR_REQUEST	return ECMD_FINAL(snprintf_P(output, len, PSTR("max7311 getINw %u 0x%X"), adr, data));#else    return ECMD_FINAL(snprintf_P(output, len, PSTR("%X"), data));#endif  }else{    return ECMD_FINAL(snprintf_P(output, len, PSTR("no sensor detected")));  }}

int16_tparse_cmd_sd_info(char *cmd, char *output, uint16_t len){  struct sd_raw_info info;  if (sd_raw_get_info(&info) == 0)    return ECMD_FINAL(snprintf_P(output, len, PSTR("read error")));  uint16_t cap = info.capacity / 1000000UL;  return ECMD_FINAL(snprintf_P(output, len,                               PSTR("%3s %6s %d/20%02d %uMB %d %d %d"),                               &info.oem, &info.product,                               info.manufacturing_month,                               info.manufacturing_year,                               cap,                               info.flag_copy,                               info.flag_write_protect,                               info.format));}

int16_tparse_cmd_rfm12_status(char *cmd, char *output, uint16_t len){  uint16_t s;  rfm12_prologue(RFM12_MODUL_IP);  s = rfm12_get_status();  rfm12_epilogue();  return ECMD_FINAL(snprintf_P(output, len, PSTR("rfm12 status: %04x"), s));}

int16_t parse_cmd_yport_stats(char *cmd, char *output, uint16_t len){    int16_t chars = snprintf_P(output, len,		               PSTR("rx fe=%u, ov=%u, pe=%u, bf=%u"),                               yport_rx_frameerror,                               yport_rx_overflow,                               yport_rx_parityerror,                               yport_rx_bufferfull);    return ECMD_FINAL(chars);}

int16_t parse_cmd_date(char *cmd, char *output, uint16_t len){  char *weekdays = "Sun/0Mon/0Tue/0Wed/0Thu/0Fri/0Sat";  struct clock_datetime_t date;  clock_current_localtime(&date);  return ECMD_FINAL(snprintf_P(output, len, PSTR("%.2d:%.2d:%.2d %.2d.%.2d.%.2d %s"),                    date.hour, date.min, date.sec, date.day, date.month, date.year % 100,                    weekdays + date.dow * 4));}

// output error messages to ECMDs output bufferstatic int16_toutput_sht_error(int8_t returncode, char *output){  switch (returncode)  {    case SHT_ERR_CRC:#define SHT_ERR_CRC_MSG "crc error"      strcpy_P(output, PSTR(SHT_ERR_CRC_MSG));      return ECMD_FINAL(sizeof(SHT_ERR_CRC_MSG));    case SHT_ERR_TIMEOUT:#define SHT_ERR_TIMEOUT_MSG "timeout"      strcpy_P(output, PSTR(SHT_ERR_TIMEOUT_MSG));      return ECMD_FINAL(sizeof(SHT_ERR_TIMEOUT_MSG));    case SHT_ERR_PROTOCOL:    default:#define SHT_ERR_PROTOCOL_MSG "no sht"      strcpy_P(output, PSTR(SHT_ERR_PROTOCOL_MSG));      return ECMD_FINAL(sizeof(SHT_ERR_PROTOCOL_MSG));  }}

int16_t parse_cmd_i2c_max7311_set(char *cmd, char *output, uint16_t len){  uint8_t adr;  uint8_t bit;  uint8_t state;  uint8_t ret;  sscanf_P(cmd, PSTR("%hhu %hhu %hhu"), &adr, &bit, &state);  if (adr > 0x6F || bit > 15)    return ECMD_ERR_PARSE_ERROR;  ret = i2c_max7311_set(adr, bit, state);  if (ret == 0) {#ifdef ECMD_MIRROR_REQUEST	return ECMD_FINAL(snprintf_P(output, len, PSTR("max7311 set %u %u %u"), adr, bit, state));#else    return ECMD_FINAL_OK;#endif  }else{    return ECMD_FINAL(snprintf_P(output, len, PSTR("no sensor detected")));  }}

int16_tparse_cmd_irmp_receive (char *cmd, char *output, uint16_t len){  irmp_data_t irmp_data;  return (irmp_read (&irmp_data)	  ? ECMD_FINAL (sprintf_P (output, PSTR ("%d:%04X:%04X:%02X/n"),				   irmp_data.protocol,				   irmp_data.address,				   irmp_data.command,				   irmp_data.flags)) : ECMD_FINAL_OK);}

int16_tparse_cmd_get(char *cmd, char *output, uint16_t len){  uint8_t pos;  sscanf_P(cmd, PSTR("%hhu"), &pos);  if (pos >= ECMD_SCRIPT_MAX_VARIABLES)  {    return to_many_vars_error_message(output, len);  }  return ECMD_FINAL(snprintf_P(output, len, PSTR("%s"), vars[pos].value));}

int16_tparse_cmd_crc_calc(char *cmd, char *output, uint16_t len){  uint8_t *p;  uint16_t crc = 0xffff;  for (p = 0; p < (uint8_t *) CRC_BYTE_POS; p++)    crc = _crc16_update(crc, pgm_read_byte(p));  return ECMD_FINAL(sprintf_P(output, PSTR("%.4X"), crc));}

int16_t parse_cmd_msr1_get(char *cmd, char *output, uint16_t len) {  uint8_t i;  MSR1_DEBUG("called msr1 get ecmd");  while(*cmd == ' ') cmd ++;  if (*cmd == 0 || *cmd == '0') {    for (i = 0; i < 21; i++) {      output = output + sprintf(output, "%02x", msr1_e8_data.data[i]);    }    return ECMD_FINAL(21 * 2);  } else {    /* Here we do all 76 byte long messages */    struct msr1_generic_info *info;    if (*cmd == '1')       info = &msr1_c0_data;    else if (*cmd == '2')      info = &msr1_48_data;    else if (*cmd == '3')      info = &msr1_50_data;    else       return ECMD_ERR_PARSE_ERROR;    /* trick: use bytes on cmd as "connection specific static variables" */    if (cmd[1] != 23) {		/* indicator flag: real invocation:  0 */        cmd[1] = 23;		/*                 continuing call: 23 */        cmd[2] = 0;		/* counter for data blocks */    }    for (i = 0; i < 20; i++) {      sprintf(output, "%02x", info->data[cmd[2] * 20 + i]);      output += 2;    }    cmd[2] ++;    if (cmd[2] == 4) {      return ECMD_FINAL(15 * 2);    }    else      return ECMD_AGAIN(20 * 2 + 1);   }   return ECMD_ERR_PARSE_ERROR;}

int16_t parse_cmd_zacwire_raw(char *cmd, char *output, uint16_t len){    uint16_t raw_temp=0;    uint8_t *pin_ptr;    uint8_t bitno;    int8_t ret;    // the longest error message is 12 bytes + /0, all possible temp/hex values fit    if (len < 13)        return ECMD_FINAL(ECMD_ERR_PARSE_ERROR);    if (zacwire_parse_arguments(cmd, &pin_ptr, &bitno) != ECMD_FINAL_OK)        return ECMD_FINAL(ECMD_ERR_PARSE_ERROR);    ret=zacwire_get(&raw_temp,pin_ptr,bitno);    if (ret == ZACWIRE_OK)        return ECMD_FINAL(strlen(itoa(raw_temp,output,16)));    else        return output_zac_error(ret,output);}

int16_tparse_cmd_dmx_get_universe(char *cmd, char *output, uint16_t len){  uint16_t ret = 0;  uint8_t value = 0, universe = 0;  /* trick: use bytes on cmd as "connection specific static variables" */  if (cmd[0] != ECMD_STATE_MAGIC) /* indicator flag: real invocation:  0 */  {    /* read universe */    ret = sscanf_P(cmd, PSTR("%hhu"), &universe);    if (ret != 1 || universe >= DMX_STORAGE_UNIVERSES)      return ECMD_ERR_PARSE_ERROR;    cmd[0] = ECMD_STATE_MAGIC;    /* continuing call: 23 */    cmd[1] = universe;            /* universe */    cmd[2] = 0;                   /* reserved for chan */    cmd[3] = 0;                   /* reserved for chan */  }  /* retrieve universe from *cmd */  universe = cmd[1];  /* retrieve chan from *cmd. chan is 16 bit.      cmd[1] in 16 bit is cmd[2] and cmd[3] in 8-bit */  uint16_t chan = *((uint16_t *) (cmd) + 1);  /* request value from dmx-storage */  value = get_dmx_channel(universe, chan);  /* write the value to *output with leading 0 so that the output      will be like this:     255     044     003     000  */  /* ones */  output[2] = value % 10 + 48;  value /= 10;  /* tens */  output[1] = value % 10 + 48;  value /= 10;  /* hundreds */  output[0] = value % 10 + 48;  /* Newline to be better parseable with http */  output[3] = '/n' ;  /* terminate string */  output[4] = '/0';  ret = 5;  if (chan < DMX_STORAGE_CHANNELS - 1)  {    chan++;    *((uint16_t *) (cmd) + 1) = chan;    return ECMD_AGAIN(ret);  }  else    return ECMD_FINAL(ret);}

int16_tparse_cmd_bt_at(char *cmd, char *output, uint16_t len){  while (*cmd == ' ')    cmd++;  /* send command to and return status from BT module */  if (*cmd == '/0')    return ECMD_ERR_PARSE_ERROR;  return ECMD_FINAL(bt_send_with_response(output, len, cmd));}

int16_t parse_cmd_tz(char *cmd, char *output, uint16_t len) {    uint8_t zone;    uint8_t ret = sscanf_P (cmd, PSTR ("%i"), &zone);    if (ret == 1) {	 tz = zone;	 eeprom_save_int( timezone, tz );	 eeprom_update_chksum();    }        return ECMD_FINAL(snprintf_P(output, len, PSTR("%i"), tz));}

int16_tparse_cmd_bt_stats(char *cmd, char *output, uint16_t len){  return ECMD_FINAL(snprintf_P(output, len,                             PSTR                             ("rx fe=%u, ov=%u, pe=%u, bf=%u, #=%u, tx #=%u"),                             bt_rx_frameerror,                             bt_rx_overflow,                             bt_rx_parityerror,                             bt_rx_bufferfull,                             bt_rx_count,                             bt_tx_count));}

int16_t parse_cmd_getstatus (char *cmd, char *output, uint16_t len){   char* rtstr[] = {PSTR("np"), PSTR("up"), PSTR("down")};   uint8_t ret;   if (is_button_up == 1)      ret =  1;   else if (is_button_down == 1)      ret =  2;   else      ret =  0;   return ECMD_FINAL(snprintf_P(output, len, PSTR("%s -> %d"),rtstr[ret], timervalue));}

int16_tparse_cmd_exit(char *cmd, char *output, uint16_t len){  if (current_script.handle == NULL)  {    return ECMD_FINAL(snprintf_P(output, len, PSTR("no script")));  }  vfs_close(current_script.handle);  current_script.handle = NULL;  current_script.linenumber = 0;  current_script.filepointer = 0;  return ECMD_FINAL_OK;}

int16_t parse_cmd_pin_toggle(char *cmd, char *output, uint16_t len){  uint16_t port, pin;  /* Parse String */  uint8_t ret = sscanf_P(cmd, PSTR("%u %u"), &port, &pin);  /* Fallback to named pins */  if ( ret != 2 && *cmd) {    uint8_t pincfg = named_pin_by_name(cmd + 1);    if (pincfg != 255) {        port = pgm_read_byte(&portio_pincfg[pincfg].port);        pin = pgm_read_byte(&portio_pincfg[pincfg].pin);        ret = 2;    }  }  if (ret == 2 && port < IO_PORTS && pin < 8) {    /* Toggle only if it is output */    if (vport[port].read_ddr(port) & _BV(pin)) {      uint8_t on = vport[port].read_port(port) & _BV(pin);      uint8_t pincfg = named_pin_by_pin(port, pin);      uint8_t active_high = 1;      if (pincfg != 255)          active_high = pgm_read_byte(&portio_pincfg[pincfg].active_high);      if (on)         vport[port].write_port(port, vport[port].read_port(port) & ~_BV(pin));      else        vport[port].write_port(port, vport[port].read_port(port) | _BV(pin));      return ECMD_FINAL(snprintf_P(output, len, XOR_LOG(!on, !active_high)                        ? PSTR("on") : PSTR("off")));    } else       return ECMD_FINAL(snprintf_P(output, len, PSTR("error: pin is input")));  } else    return ECMD_ERR_PARSE_ERROR;}

int16_tparse_cmd_fuse(char *cmd, char *output, uint16_t len){  (void) cmd;#ifdef _SPMCR  _SPMCR = 1 << BLBSET | 1 << SPMEN;  uint8_t lo = pgm_read_byte(0);  _SPMCR = 1 << BLBSET | 1 << SPMEN;  uint8_t hi = pgm_read_byte(3);  _SPMCR = 1 << BLBSET | 1 << SPMEN;  uint8_t ex = pgm_read_byte(2);  _SPMCR = 1 << BLBSET | 1 << SPMEN;  uint8_t lock = pgm_read_byte(1);  return    ECMD_FINAL(snprintf_P               (output, len,                PSTR("Fuses: low=%02X high=%02X ex=%02X lock=%02X"), lo, hi,                ex, lock));#else  return ECMD_FINAL(snprintf_P(output, len, PSTR("Fuses: unsupported")));#endif}

int16_t parse_cmd_i2c_pcf8574x_read(char *cmd, char *output, uint16_t len){	uint8_t adr;	uint8_t chip;	sscanf_P(cmd, PSTR("%u %u"), &adr, &chip);	if (chip == 0)	{		adr += I2C_SLA_PCF8574;	}	else	{		adr += I2C_SLA_PCF8574A;	}#ifdef DEBUG_I2C	debug_printf("I2C PCF8574X IC address 0x%X/n", adr);#endif#ifdef ECMD_MIRROR_REQUEST	return ECMD_FINAL(snprintf_P(output, len, PSTR("pcf8574x read %u %u %X"), adr, chip, i2c_pcf8574x_read(adr)));#else	return ECMD_FINAL(snprintf_P(output, len, PSTR("0x%X"), i2c_pcf8574x_read(adr)));#endif}

int16_t parse_cmd_srf05_command(char *cmd, char *output, uint16_t len) {  uint16_t distance = srf05_get();   if (distance == 0 ) {	return ECMD_ERR_PARSE_ERROR;  }#if !SRF05_FAKTOR#error SRF05_FAKTOR has to be non-zero!#endif // only metric values so far // metric divisor is 58 for cm // imperial divisor is 148 for inches  return ECMD_FINAL(snprintf_P(output, len, PSTR("%i"), distance / SRF05_FAKTOR ));}

int16_t parse_cmd_fs20_ws300(char *cmd, char *output, uint16_t len){#ifdef ECMD_MIRROR_REQUEST    return ECMD_FINAL(snprintf_P(output, len,                                 PSTR("fs20 ws300 %d.%u %u %u.%u %u %u"),                                 fs20_global.ws300.temp,                                 fs20_global.ws300.temp_frac,                                 fs20_global.ws300.hygro,                                 fs20_global.ws300.wind,                                 fs20_global.ws300.wind_frac,                                 fs20_global.ws300.rain,                                 fs20_global.ws300.rain_value));#else    return ECMD_FINAL(snprintf_P(output, len,                                 PSTR("deg: %d.%u C, hyg: %u%%, wind: %u.%u km/h, rain: %u, counter: %u"),                                 fs20_global.ws300.temp,                                 fs20_global.ws300.temp_frac,                                 fs20_global.ws300.hygro,                                 fs20_global.ws300.wind,                                 fs20_global.ws300.wind_frac,                                 fs20_global.ws300.rain,                                 fs20_global.ws300.rain_value));#endif}

int16_t parse_cmd_i2c_max7311_setOUTw(char *cmd, char *output, uint16_t len){  uint8_t adr;  uint16_t data;  uint8_t ret;  sscanf_P(cmd, PSTR("%hhu %hX"), &adr, &data);  if (adr > 0x6F)    return ECMD_ERR_PARSE_ERROR;  ret = i2c_max7311_setOUTw(adr, data);  if (ret == 0) {    return ECMD_FINAL_OK;  }else{    return ECMD_FINAL(snprintf_P(output, len, PSTR("no sensor detected")));  }}