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

int16_t parse_cmd_i2c_read_word_data(char *cmd, char *output, uint16_t len){	uint8_t cadr;	uint8_t dadr;	sscanf_P(cmd, PSTR("%u %u"), &cadr, &dadr);	if (cadr < 7 || cadr > 127)		return ECMD_ERR_PARSE_ERROR;	uint16_t val = i2c_read_word_data(cadr, dadr);#ifdef ECMD_MIRROR_REQUEST		return ECMD_FINAL(snprintf_P(output, len, PSTR("i2c rwd %d %d 0x%X"), cadr, dadr, val));#else		return ECMD_FINAL(snprintf_P(output, len, PSTR("0x%X"), val));#endif}

int16_tparse_cmd_i2c_lm75(char *cmd, char *output, uint16_t len){	while(*cmd == ' ') cmd++;	if (*cmd < '0' || *cmd > '7') return ECMD_ERR_PARSE_ERROR;	int16_t temp = i2c_lm75_read_temp(I2C_SLA_LM75 + (cmd[0] - '0'));	if (temp == 0xffff)	return ECMD_FINAL(snprintf_P(output, len, PSTR("no sensor detected")));#ifdef ECMD_MIRROR_REQUEST	return ECMD_FINAL(snprintf_P(output, len, PSTR("lm75 %d %d.%d"), (cmd[0] - '0'), temp / 10, temp % 10));#else	return ECMD_FINAL(snprintf_P(output, len, PSTR("%d.%d"), temp / 10, temp % 10));#endif}

int16_t parse_cmd_i2c_write_byte(char *cmd, char *output, uint16_t len){	uint8_t adr;	uint8_t data;	sscanf_P(cmd, PSTR("%u %x"), &adr, &data);	if (adr < 7 || adr > 127)		return ECMD_ERR_PARSE_ERROR;	uint16_t ret = i2c_write_byte(adr, data);#ifdef ECMD_MIRROR_REQUEST	return ECMD_FINAL(snprintf_P(output, len, PSTR("i2c wbb %d 0x%X"), adr, ret));#else	return ECMD_FINAL(snprintf_P(output, len, PSTR("0x%X"), ret));#endif}

int16_tparse_cmd_fs_format (char *cmd, char *output, uint16_t len){  (void) cmd;  (void) output;  (void) len;  if (fs_format (&fs) != FS_OK)     return ECMD_FINAL(snprintf_P(output, len, PSTR("fs: error while formating")));  if (fs_init () != FS_OK)     return ECMD_FINAL(snprintf_P(output, len, PSTR("fs: error while initializing")));  return ECMD_FINAL_OK;}

int16_tparse_cmd_free(char *cmd, char *output, uint16_t len){  /* trick: use bytes on cmd as "connection specific static variables" */  if (cmd[0] != ECMD_STATE_MAGIC)  {                             /* indicator flag: real invocation:  0 */    cmd[0] = ECMD_STATE_MAGIC;  /*                 continuing call: 23 */    cmd[1] = 0;                 /* counter for output lines */  }  /* Docu March 2009: http://www.nongnu.org/avr-libc/user-manual/malloc.html   * Stack size: RAMEND-SP   * Heap size: __brkval-__heap_start   * Space between stack and heap: SP-__brkval   * Caution: __brkval is 0 when malloc was not called yet (use __heap_start instead)   *    * Size of network packet frames is stored in NET_MAX_FRAME_LENGTH   */  size_t f =    (size_t) (__brkval ? (size_t) __brkval : (size_t) & __heap_start);  /* we want an output like this:   * free: 16234/32768   * heap: 10234   * net: 500   */  switch (cmd[1]++)  {    case 0:      return ECMD_AGAIN(snprintf_P(output, len,                                   PSTR("free: %u/%u"),                                   SP - f, RAM_SIZE));#ifndef UIP_SUPPORT    default:      return ECMD_FINAL(snprintf_P(output, len,                                   PSTR("heap: %u"),                                   f - (size_t) & __heap_start));#else    case 1:      return ECMD_AGAIN(snprintf_P(output, len,                                   PSTR("heap: %u"),                                   f - (size_t) & __heap_start));    default:      return ECMD_FINAL(snprintf_P(output, len,                                   PSTR("net: " xstr(NET_MAX_FRAME_LENGTH))));#endif  }}

int16_t parse_cmd_i2c_write_word_data(char *cmd, char *output, uint16_t len){	uint8_t cadr;	uint8_t dadr;	uint16_t data;	sscanf_P(cmd, PSTR("%u %u %x"), &cadr, &dadr, &data);	if (cadr < 7 || cadr > 127)		return ECMD_ERR_PARSE_ERROR;	uint16_t ret = i2c_write_word_data(cadr, dadr, data);#ifdef ECMD_MIRROR_REQUEST	return ECMD_FINAL(snprintf_P(output, len, PSTR("i2c wwd %d %d 0x%02X"), cadr, dadr, ret));#else	return ECMD_FINAL(snprintf_P(output, len, PSTR("0x%02X"), ret));#endif}

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) {    return ECMD_FINAL(snprintf_P(output, len, PSTR("%X"), data));  }else{    return ECMD_FINAL(snprintf_P(output, len, PSTR("no sensor detected")));  }}

int16_t parse_cmd_i2c_ds1631_stop(char *cmd, char *output, uint16_t len){	uint8_t adr;	sscanf_P(cmd, PSTR("%u"), &adr);	if (adr > 7)		return ECMD_ERR_PARSE_ERROR;	uint16_t temp = i2c_ds1631_start_stop(I2C_SLA_DS1631 + adr,0);	if (temp == 0xffff)		return ECMD_FINAL(snprintf_P(output, len, PSTR("no sensor detected")));#ifdef ECMD_MIRROR_REQUEST	return ECMD_FINAL(snprintf_P(output, len, PSTR("ds1631 stop %d ok"),adr));#else	return ECMD_FINAL(snprintf_P(output, len, PSTR("ok")));#endif}

//------------------------------------------------------------------------------------static int cTR_CC06(void){	// Aplico un pulso de cierre de regulacion y salgo a	// esperar 1 minuto por otro ciclo.	pv_DCsetValvulas(V_CERRAR, V_CERRAR);	snprintf_P( cons_printfBuff,sizeof(cons_printfBuff),PSTR(" fuzzy_VALVES: A-CLOSE, B-CLOSE/r/n/0"));	u_debugPrint(D_CONSIGNA, cons_printfBuff, sizeof(cons_printfBuff) );	snprintf_P( cons_printfBuff,sizeof(cons_printfBuff),PSTR(" fuzzy END/r/n/0"));	u_debugPrint(D_CONSIGNA, cons_printfBuff, sizeof(cons_printfBuff) );	pv_consignaPrintExitMsg(6);	return(ccST_01);}

int16_t parse_cmd_lcd_backlight(char *cmd, char *output, uint16_t len){  if (strlen(cmd) < 1) #ifdef HD44780_BACKLIGHT_INV    return ECMD_FINAL(snprintf_P(output, len, back_light ? PSTR("off") : PSTR("on")));#else    return ECMD_FINAL(snprintf_P(output, len, back_light ? PSTR("on") : PSTR("off")));#endif  if (!strncmp_P(cmd + 1, PSTR("on"), 2))#ifdef HD44780_BACKLIGHT_INV    hd44780_backlight(0);#else    hd44780_backlight(1);#endif  else if (!strncmp_P(cmd + 1, PSTR("off"), 3)) 

int16_tparse_cmd_fs_mkfile (char *cmd, char *output, uint16_t len){  /* ignore leading spaces */  while (*cmd == ' ')    cmd ++;  fs_status_t ret = fs_create (&fs, cmd);    if (ret != FS_OK)    return ECMD_FINAL(snprintf_P(output, len, PSTR("fs_create: returned 0x%02x"), ret));  fs_inode_t i = fs_get_inode (&fs, cmd);  return ECMD_FINAL(snprintf_P(output, len, PSTR("fs_create: inode 0x%04x"), i));}

void powerport_page_print_page(eds_powerport_page_block_t *p){	char s[40];	canix_frame message;	// LCD Bildschirm loeschen	lcd_clrscr();	// 1. Zeile	snprintf_P(s,sizeof(s), PSTR("%s"), p->line0); 	lcd_gotoxy(0,0);	lcd_puts(s);	snprintf_P(s,sizeof(s), PSTR("%s"), p->line1); 	lcd_gotoxy(0,1);	lcd_puts(s);	// In powerport_page_state wird spaeter der State gespeichert; sollte	// keine Meldung eintreffen, so nuetzt es nichts, wenn der User OK	// drueckt - man weiss ja den State nicht und kann ihn nicht aendern!	// Das erkennt man am Wert -1	powerport_page_state = -1;	powerport_page_timer = -1;	// nun den Status des Powerports erfragen und (asynchron)	// in powerport_page_can_callback weitermachen	message.src = canix_selfaddr();	message.dst = HCAN_MULTICAST_CONTROL;	message.proto = HCAN_PROTO_SFP;	message.data[0] = HCAN_SRV_HES;	message.data[1] = HCAN_HES_POWER_GROUP_STATE_QUERY;	message.data[2] = p->gruppe;	message.size = 3;	canix_frame_send_with_prio(&message, HCAN_PRIO_HI);	canix_sleep_100th(1);	message.src = canix_selfaddr();	message.dst = HCAN_MULTICAST_CONTROL;	message.proto = HCAN_PROTO_SFP;	message.data[0] = HCAN_SRV_HES;	message.data[1] = HCAN_HES_POWER_GROUP_TIMER_QUERY;	message.data[2] = p->gruppe;	message.size = 3;	canix_frame_send_with_prio(&message, HCAN_PRIO_HI);}

/*------------------------------------------------------------------------------------*/static int anTR_02(void){	// Tengo un mensaje que debo polear.	AN_flags.msgPollNow = FALSE;	AN_flags.start2poll = FALSE;	// Es service: no salvo en EE	AN_flags.saveFrameInBD = FALSE;	// Para no tener problemas con el timer	AN_counters.secs4poll = 60;	AN_counters.secs4save = 60;	// Por las dudas, siempre prendo	pv_PrenderSensores();	AN_counters.cTimer = SECS2PWRSETTLE;	// Aqui los sensores deben estar prendidos.	// Si por alguna razon los sensores estan apagados los prendo.	if ( ! sensoresPrendidos ) {		snprintf_P( aIn_printfBuff,sizeof(aIn_printfBuff),PSTR("WARN: Sensores apagados !!!/r/n/0"));		FreeRTOS_write( &pdUART1, aIn_printfBuff, sizeof(aIn_printfBuff) );		pv_PrenderSensores();	}	pv_AINprintExitMsg(2);	return(anST_A02);}

int16_t parse_cmd_free(char *cmd, char *output, uint16_t len){	/* Docu March 2009: http://www.nongnu.org/avr-libc/user-manual/malloc.html	Stack size: RAMEND-SP	Heap size: __brkval-__heap_start	Space between stack and heap: SP-__brkval	Caution: __brkval is 0 when malloc was not called yet (use __heap_start instead)	Size of network packet frames is stored in NET_MAX_FRAME_LENGTH	*/	extern char *__brkval;	extern unsigned char __heap_start;	size_t f = (size_t)(__brkval ? (size_t)__brkval : (size_t)&__heap_start);	size_t allram = RAMEND;	/* we want an output like this:	free: 16234/32768	heap: 10234	net: 500	*/	return ECMD_FINAL(snprintf_P(output, len,		PSTR("free: %d/%d/nheap: %d/nnet: " xstr(NET_MAX_FRAME_LENGTH)),		SP-f, allram, f-(size_t)&__heap_start));}

char * protocolFormat(MyMessage &message){	snprintf_P(_fmtBuffer, MY_GATEWAY_MAX_SEND_LENGTH, PSTR("%d;%d;%d;%d;%d;%s/n"), message.sender,	           message.sensor, (uint8_t)mGetCommand(message), (uint8_t)mGetAck(message), message.type,	           message.getString(_convBuffer));	return _fmtBuffer;}

void rolladen_page_print_page(eds_rolladen_page_block_t *p){	char s[32];	// LCD Bildschirm loeschen	lcd_clrscr();	// 1. Zeile	snprintf_P(s,sizeof(s)-1, PSTR("%s"), p->line0);	lcd_gotoxy(0,0);	lcd_puts(s);	snprintf_P(s,sizeof(s)-1, PSTR("%s"), p->line1);	lcd_gotoxy(0,1);	lcd_puts(s);}

void MySensor::debugPrint(const char *fmt, ... ) {	char fmtBuffer[300];	if (isGateway) {		// prepend debug message to be handled correctly by gw (C_INTERNAL, I_LOG_MESSAGE)		snprintf_P(fmtBuffer, 299, PSTR("0;0;%d;0;%d;"), C_INTERNAL, I_LOG_MESSAGE);#ifdef __Raspberry_Pi		printf(fmtBuffer);#else		Serial.print(fmtBuffer);#endif	}	va_list args;	va_start (args, fmt );	va_end (args);	if (isGateway) {		// Truncate message if this is gateway node		vsnprintf_P(fmtBuffer, 60, fmt, args);		fmtBuffer[59] = '/n';		fmtBuffer[60] = '/0';	} else {		vsnprintf_P(fmtBuffer, 299, fmt, args);	}	va_end (args);#ifdef __Raspberry_Pi	printf(fmtBuffer);	fflush(stdout);#else	Serial.print(fmtBuffer);	Serial.flush();#endif	//Serial.write(freeRam());}

CommandStatusIdType CommandExecLogMem(char* OutMessage){    snprintf_P(OutMessage, TERMINAL_BUFFER_SIZE,        PSTR("%S,%S"), PSTR(COMMAND_LOGMEM_LOADBIN), PSTR(COMMAND_LOGMEM_CLEAR) );    return COMMAND_INFO_OK_WITH_TEXT_ID;}

int16_t parse_cmd_pin_get(char *cmd, char *output, uint16_t len){  uint16_t port, pin;  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) {    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);    return ECMD_FINAL(snprintf_P(output, len,                      XOR_LOG(vport[port].read_pin(port) & _BV(pin), !(active_high))                      ? PSTR("on") : PSTR("off")));  } else    return ECMD_ERR_PARSE_ERROR;}

//------------------------------------------------------------------------------bool HttpClient::createPostRequest(char* buffer, size_t bufferSize,    const char* host, const char* path, const char* content, uint8_t flags) {    // check flags    if ((flags & F_KEEP_ALIVE) == (flags & F_CLOSE)) {        return false;    }    else if ((flags & F_HEAD) == (flags & F_POST)) {        return false;    }    // determine request type    PGM_P request;    if (flags & F_HEAD) {        request = HTTP_REQUEST_HEAD;    }    else if (flags & F_POST) {        request = HTTP_REQUEST_POST;    }    // determine connection type    bool keepAlive = (flags & F_KEEP_ALIVE);    PGM_P connection = keepAlive ? HTTP_FIELD_KEEP_ALIVE : HTTP_FIELD_CLOSE;    // print the request to the buffer    memset(buffer, 0x00, bufferSize);    snprintf_P(        buffer,        bufferSize,        request,        path,        host,        connection,        strlen(content),        content    );    return true;}

static int16_tgenerate_time_string(clock_datetime_t * date, char *output, uint16_t len){  const char *dow = clock_dow_string(date->dow);  div_t tz = div(_TZ_OFFSET + (date->isdst ? DST_OFFSET : 0), 60);  return ECMD_FINAL(snprintf_P(output, len,                               PSTR("%c%c%c %02d.%02d.%04d %02d:%02d:%02d"                                    _TZ_FORMAT_STRING#ifdef CLOCK_DEBUG                                    " (doy=%d,woy=%d,dst=%d)"#endif				    ),                               pgm_read_byte(dow),                               pgm_read_byte(dow + 1),                               pgm_read_byte(dow + 2),                               date->day,                               date->month,                               date->year + 1900,                               date->hour,                               date->min,                               date->sec,			       tz.quot, tz.rem#ifdef CLOCK_DEBUG                               ,date->yday + 1,                               clock_woy(date->day, date->month, date->year),                               date->isdst#endif			       ));}

bool gatewayTransportSend(MyMessage &message) {	if (!_client.connected())		return false;	snprintf_P(_fmtBuffer, MY_GATEWAY_MAX_SEND_LENGTH, PSTR(MY_MQTT_TOPIC_PREFIX "/%d/%d/%d/%d/%d"), message.sender, message.sensor, mGetCommand(message), mGetAck(message), message.type);	debug(PSTR("Sending message on topic: %s/n"), _fmtBuffer);	return _client.publish(_fmtBuffer, message.getString(_convBuffer));}

int16_tparse_cmd_goto(char *cmd, char *output, uint16_t len){  uint8_t gotoline = 0;  char line[ECMD_INPUTBUF_LENGTH];  if (current_script.handle == NULL)  {    return ECMD_FINAL(snprintf_P(output, len, PSTR("no script")));  }  sscanf_P(cmd, PSTR("%hhu"), &gotoline);  SCRIPTDEBUG("current %u goto line %u/n", current_script.linenumber,              gotoline);  if (gotoline < current_script.linenumber)  {    SCRIPTDEBUG("seek to 0/n");    vfs_fseek(current_script.handle, 0, SEEK_SET);    current_script.linenumber = 0;    current_script.filepointer = 0;  }  while ((current_script.linenumber != gotoline) &&         (current_script.linenumber < ECMD_SCRIPT_MAXLINES))  {    SCRIPTDEBUG("seeking: current %i goto line %i/n",                current_script.linenumber, gotoline);    if (readline(line) == 0)    {      SCRIPTDEBUG("leaving/n");      break;    }  }  return ECMD_FINAL_OK;}

/*------------------------------------------------------------------------------------*/static int gTR_A00(void){static s08 inicio = TRUE;	// Evento inicial. Solo salta al primer estado operativo.	// Inicializo el sistema aqui	vTaskDelay( (portTickType)( 500 / portTICK_RATE_MS ) );	strncpy_P(systemVars.dlgIp, PSTR("000.000.000.000/0"),16);	systemVars.csq = 0;	systemVars.dbm = 0;	//	// Arranque del equipo	if ( inicio ) {		// Cuando recien estoy arrancando espero solo 15s para prender.		// No importa el pwrSave.		inicio = FALSE;		pv_configCTimer(TINIT_INIT);	} else {		pv_configCTimer(TINIT_NORMAL);	}	// Apago el modem	MODEM_HWpwrOff();	snprintf_P( gprs_printfBuff,sizeof(gprs_printfBuff),PSTR("GPRS: Modem Apagado/r/n/0"));	u_logPrint(gprs_printfBuff, sizeof(gprs_printfBuff) );	g_printExitMsg("A00/0");	return(gSST_MODEMAPAGADO_01);}

uint16_t ir_send_improper_input(uint8_t* buf, uint16_t maxlen){	return snprintf_P(buf, maxlen, PSTR(				"<h1>Improper input.</h1><br>"				"<br>"				"Expected format:"				"<pre>http://[HOST]/ir/send/[frequency]_[bit_0_length]_[bit_1_length]_ ... [bit_n-th_length]</pre>"				"where:"				"<div id=/"l/"><ul>"				"<li>frequency"				"<li>length of each bit"				"</ul><ul>"				"<li>- in kilohertz"				"<li>- in units of 1/frequency"				"</ul></div>"				"<div></div><br>"				"<br>"				"<br>"				"<br>"				"Bits with even numbers are ones (carrier is produced),<br>"				"bits with odd numbers are zeros (no carrier is produced).<br>"				"All numbers must be <= 2^16 ( = 65536), since they are<br>"				"stored as uint16_t numbers, and > 0, since 0 is an error code.<br>"				"<br>"				"<br>"				"<h4><a href=/"..//">Return</a></h4>"));}

static state_t menuNumberEdit(button_t button, unsigned char increment,  int minVal, int maxVal, const prog_char *format){  char buffer[17];  rgb.set(WHITE);    if (button == BUTTON_ENTER)    isEditing = false;  else if (button == BUTTON_CENTER)    isEditing = !isEditing;  lcd.setCursor(0, 1);  if (isEditing)  {    if (button == BUTTON_RIGHT)      editInt += increment;    else if (button == BUTTON_LEFT)      editInt -= increment;    if (editInt < minVal)      editInt = minVal;    if (editInt > maxVal)      editInt = maxVal;    lcd.print(RTARROW[0]);  }  else    lcd.print(' ');  snprintf_P(buffer, sizeof(buffer), format, editInt, g_Units);  lcd.print(buffer);  return menuEditCommon(button);}

void hwDebugPrint(const char *fmt, ...){#ifndef MY_DEBUGDEVICE#define MY_DEBUGDEVICE MY_SERIALDEVICE#endif#ifndef MY_DISABLED_SERIAL	char fmtBuffer[MY_SERIAL_OUTPUT_SIZE];#ifdef MY_GATEWAY_SERIAL	// prepend debug message to be handled correctly by controller (C_INTERNAL, I_LOG_MESSAGE)	snprintf_P(fmtBuffer, sizeof(fmtBuffer), PSTR("0;255;%" PRIu8 ";0;%" PRIu8 ";%" PRIu32 " "),	           C_INTERNAL, I_LOG_MESSAGE, hwMillis());	MY_DEBUGDEVICE.print(fmtBuffer);#else	// prepend timestamp	MY_DEBUGDEVICE.print(hwMillis());	MY_DEBUGDEVICE.print(F(" "));#endif	va_list args;	va_start(args, fmt);	vsnprintf_P(fmtBuffer, sizeof(fmtBuffer), fmt, args);#ifdef MY_GATEWAY_SERIAL	// Truncate message if this is gateway node	fmtBuffer[sizeof(fmtBuffer) - 2] = '/n';	fmtBuffer[sizeof(fmtBuffer) - 1] = '/0';#endif	va_end(args);	MY_DEBUGDEVICE.print(fmtBuffer);#else	(void)fmt;#endif}

// ------------------------------------------------------------------------------------void compute_degree_of_membership(struct mf_type *mf,float xin ){	// Asumimos que las funciones de membresia son triangulares y calculo	// el valor de esta, para una entrada dada.float xa = mf->xA;float xb = mf->xB;float xc = mf->xC;float xd = mf->xD;float res;	if ( xin < xa) {		res = 0;	} else if ( ( xa <= xin ) && ( xin < xb) ) {		res = ( (xin - xa) / ( xb - xa));	} else if ( ( xb <= xin ) && ( xin < xc ) ) {		res = 1;	} else if ( ( xc <= xin ) && ( xin < xd ) ) {		res = ( ( xd - xin ) / ( xd - xc ));	} else {		res = 0;	}	mf->value = res;	snprintf_P( cons_printfBuff,sizeof(cons_printfBuff),PSTR(" fuzzy_membership:: [%s](%.03f,%.03f,%.03f,%.03f)->(%.03f::%.03f)/r/n/0"), mf->name, mf->xA, mf->xB, mf->xC,mf->xD, xin, mf->value );	u_debugPrint(D_CONSIGNA, cons_printfBuff, sizeof(cons_printfBuff) );}