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

static unsigned short function_file_stats(char* buffer, int bufsize) {    unsigned short len = 0;    // list as many files as fit into the buffer    for (int i = 0; len < bufsize; i++) {        // name fo the file        char* name = httpd_fs_getName(i);        // break if there is no file left anmyore        if (name == 0) {            break;        }        // we cant simply pass the filename to snprintf because it is in        // program memory and snprintf requires strings in RAM.        strncpy_P(buffer + len, file_stat_formatter1, bufsize - len);        len += sizeof (file_stat_formatter1);        if (len < bufsize - len) {            char* name = httpd_fs_getName(i);            strncpy_P(buffer + len, name, bufsize - len);            len += strlen_P(name);        }        if (len < bufsize - len) {            int count = httpd_fs_getCount(i);            len += snprintf_P(buffer + len, bufsize - len, file_stat_formatter2, count);        }    }    return len;}

static voidjabber_main(void){  if (uip_aborted() || uip_timedout())  {    JABDEBUG("connection aborted/n");    jabber_conn = NULL;  }  if (uip_closed())  {    JABDEBUG("connection closed/n");    jabber_conn = NULL;  }  if (uip_connected())  {    JABDEBUG("new connection/n");    STATE->stage = JABBER_OPEN_STREAM;    STATE->sent = JABBER_INIT;#ifdef JABBER_STARTUP_MESSAGE_SUPPORT    strncpy_P(STATE->target, PSTR(CONF_JABBER_BUDDY), sizeof(STATE->target));    strncpy_P(STATE->outbuf, jabber_startup_text, sizeof(STATE->outbuf));    STATE->action = JABBER_ACTION_MESSAGE;#endif /* JABBER_STARTUP_MESSAGE_SUPPORT */  }  if (uip_acked() && STATE->stage == JABBER_CONNECTED)  {    STATE->action = JABBER_ACTION_NONE;    *STATE->outbuf = 0;  }  if (uip_newdata() && uip_len)  {    /* Zero-terminate */    ((char *) uip_appdata)[uip_len] = 0;    JABDEBUG("received data: %s/n", uip_appdata);    if (jabber_parse())    {      uip_close();              /* Parse error */      return;    }  }  if (uip_rexmit())    jabber_send_data(STATE->stage, STATE->action);  else if ((STATE->stage > STATE->sent || STATE->stage == JABBER_CONNECTED)           && (uip_newdata() || uip_acked() || uip_connected()))    jabber_send_data(STATE->stage, STATE->action);  else if (STATE->stage == JABBER_CONNECTED && uip_poll() && STATE->action)    jabber_send_data(STATE->stage, STATE->action);}

/*  write a structure format to the log */void DataFlash_Class::Log_Fill_Format(const struct LogStructure *s, struct log_Format &pkt){    memset(&pkt, 0, sizeof(pkt));    pkt.head1 = HEAD_BYTE1;    pkt.head2 = HEAD_BYTE2;    pkt.msgid = LOG_FORMAT_MSG;    pkt.type = PGM_UINT8(&s->msg_type);    pkt.length = PGM_UINT8(&s->msg_len);    strncpy_P(pkt.name, s->name, sizeof(pkt.name));    strncpy_P(pkt.format, s->format, sizeof(pkt.format));    strncpy_P(pkt.labels, s->labels, sizeof(pkt.labels));}

static inline uint8_t otoa(uint16_t val, char* buff) {	struct Operand op;	DECODE_OP(val, &op);	if(op.type == OP_REGISTER) {		strncpy_P(buff, Register[op.reg], REG_LEN);	} else if(op.type == OP_PORT) {		strncpy_P(buff, Port[op.port], PORT_LEN);	} else if(op.type == OP_LITERAL) {		itoa(op.litValue, buff, 10);	}	return strlen(buff);}

void ESP8266_Simple::getErrorMessage(byte responseCode, char *bufferWithMinLength50Char){  memset(bufferWithMinLength50Char, 0, 50);  switch(responseCode)  {    case ESP8266_ERROR:    strncpy_P(bufferWithMinLength50Char, PSTR("General Error"), 49); break;    case ESP8266_TIMEOUT:  strncpy_P(bufferWithMinLength50Char, PSTR("Timeout Waiting For Response"), 49); break;    case ESP8266_OVERFLOW: strncpy_P(bufferWithMinLength50Char, PSTR("Overflow In Serial Buffer"), 49); break;    case ESP8266_BUSY:     strncpy_P(bufferWithMinLength50Char, PSTR("Device Is Busy"), 49); break;    case ESP8266_READY:    strncpy_P(bufferWithMinLength50Char, PSTR("Device issued /"ready/" unexpectedly (rebooted)"), 49); break;  }}

static unsigned short function_tcp_connections(char* buffer, int bufsize) {    unsigned short len = 0;    // list as many connections as fit into the buffer    for (int i = 0; len < bufsize && i<UIP_CONF_MAX_CONNECTIONS; i++) {        len+=snprintf_P(buffer+len, bufsize-len, tcp_conn_formatter1,                htons(uip_conns[i].lport),                htons(uip_conns[i].ripaddr[0]) >> 8,                htons(uip_conns[i].ripaddr[0]) & 0xff,                htons(uip_conns[i].ripaddr[1]) >> 8,                htons(uip_conns[i].ripaddr[1]) & 0xff,                htons(uip_conns[i].rport));        switch (uip_conns[i].tcpstateflags & UIP_TS_MASK) {            case UIP_CLOSED:                strncpy_P(buffer+len,tcp_closed,bufsize-len);                len+=sizeof(tcp_closed)-1;                break;            case UIP_SYN_RCVD:                strncpy_P(buffer+len,tcp_syn_rcvd,bufsize-len);                len+=sizeof(tcp_syn_rcvd)-1;                break;            case UIP_SYN_SENT:                strncpy_P(buffer+len,tcp_syn_sent,bufsize-len);                len+=sizeof(tcp_syn_sent)-1;                break;            case UIP_ESTABLISHED:                strncpy_P(buffer+len,tcp_established,bufsize-len);                len+=sizeof(tcp_established)-1;                break;            case UIP_FIN_WAIT_1:                strncpy_P(buffer+len,tcp_fin_wait_1,bufsize-len);                len+=sizeof(tcp_fin_wait_1)-1;                break;            case UIP_FIN_WAIT_2:                strncpy_P(buffer+len,tcp_fin_wait_2,bufsize-len);                len+=sizeof(tcp_fin_wait_1)-1;                break;            case UIP_CLOSING:                strncpy_P(buffer+len,tcp_closing,bufsize-len);                len+=sizeof(tcp_closing);                break;            case UIP_TIME_WAIT:                strncpy_P(buffer+len,tcp_time_wait,bufsize-len);                len+=sizeof(tcp_time_wait)-1;                break;            case UIP_LAST_ACK:                strncpy_P(buffer+len,tcp_last_ack,bufsize-len);                len+=sizeof(tcp_last_ack)-1;                break;        }        len+=snprintf_P(buffer+len, bufsize-len, tcp_conn_formatter2,                uip_conns[i].nrtx,                uip_conns[i].timer,                (uip_outstanding(&uip_conns[i])) ? '*' : ' ',                (uip_stopped(&uip_conns[i])) ? '!' : ' ');    }    return len;}

void menu_draw(menu_t *menu, u8g_t *u8g){	uint8_t i, h;	static char ramstr[32];	menu_buttons_t *b;	u8g_uint_t w, d;		if(!menu)		return;		// Calculate text size	u8g_SetFont(u8g, u8g_font_5x7);	u8g_SetFontRefHeightText(u8g);	u8g_SetFontPosTop(u8g);	h = u8g_GetFontAscent(u8g)-u8g_GetFontDescent(u8g);	w = u8g_GetWidth(u8g);	for( i = 0;; i++ ) {        // draw all menu items		// Copy string from program memory to a work string in RAM		strncpy_P(ramstr, (PGM_P)pgm_read_word(&(menu->strings[i])), sizeof(ramstr));		ramstr[31] = 0;		// Zero length string marks end of string list. 		if(!ramstr[0])			break;		// Get its length in pixels		d = (w-u8g_GetStrWidth(u8g, ramstr))/2;		// Set foreground color		u8g_SetDefaultForegroundColor(u8g);		// If item selected		if ( i == menu->selected ) {            // current selected menu item			u8g_DrawBox(u8g, 0, i*h+1, w, h);   // draw cursor bar			u8g_SetDefaultBackgroundColor(u8g);		}		// Display the string		u8g_DrawStr(u8g, d, i*h, ramstr);	}		// Remember menu item count	menu->item_count = i;		// Ensure text and background are set back to normal	u8g_SetDefaultForegroundColor(u8g);		// If there are soft buttons, draw them here	if(menu->buttons){			for(b = menu->buttons; b; b = b->next){			strncpy_P(ramstr, b->label, sizeof(ramstr));			ramstr[31] = 0;			u8g_DrawStr(u8g, b->col, b->row, ramstr);		}	}}

/**************************************************************************************************** Process an incoming packet*/void KBUS_process_command(const KBUS_PACKET_t *cmd, KBUS_PACKET_t *res){	res->command = cmd->command | 0x80;	res->length = 0;	memset(&res->data, 0, KBUS_PACKET_DATA_SIZE);		if (cmd->length > KBUS_PACKET_DATA_SIZE)		return;		switch(cmd->command)	{		case KCMD_LOOPBACK:			memcpy(&res->data, &cmd->data, cmd->length);			res->length = cmd->length;			break;		case KCMD_READ_STRING:			if (cmd->data[0] == KSTRING_DEVICE_NAME)				strncpy_P((char *)&res->data, PSTR(USB_DEVICE_PRODUCT_NAME), KBUS_PACKET_DATA_SIZE);			else if (cmd->data[0] == KSTRING_MANUFACTURER)				strncpy_P((char *)&res->data, PSTR(USB_DEVICE_MANUFACTURE_NAME), KBUS_PACKET_DATA_SIZE);			else if (cmd->data[0] == KSTRING_SERIAL_NUMBER)				strncpy((char *)&res->data, (char *)USB_serial_number, KBUS_PACKET_DATA_SIZE);			// otherwise empty string			res->length = strnlen((char *)&res->data, KBUS_PACKET_DATA_SIZE);			break;			case KCMD_READ_VID_PID:			*(uint16_t *)&res->data[0] = USB_DEVICE_VENDOR_ID;			*(uint16_t *)&res->data[2] = USB_DEVICE_PRODUCT_ID;			break;		case KCMD_ENTER_BOOTLOADER:			{				uint32_t load = 0x4c4f4144;					// "LOAD"				EEP_DisableMapping();				EEP_WriteBuffer(&load, sizeof(load), 31);				_delay_ms(100);								// ensure all writes have definitely finished				HW_CCPWrite(&RST.CTRL, RST_SWRST_bm);		// reset MCU into bootloader				NOP();				break;			}				default:			res->command = 0;	// unknown command response			break;	}}

/* * Write the configuration parameters to EEPROM */void ConfigParms::commit(bool forced){  if (_stationName[0] == '/0') {    // It was probably not initialized.    return;  }  if (!forced && !needCommit) {    return;  }  //DIAGPRINTLN(F("ConfigParms::commit"));  // Fill in the magic and CRC, and write to EEPROM  const size_t crc_size = sizeof(uint16_t);  const size_t magic_len = sizeof(magic);  size_t size = magic_len + sizeof(*this) + crc_size;  uint8_t buffer[size];  strncpy_P((char *)buffer, magic, magic_len);  memcpy(buffer + magic_len, (uint8_t *)this, sizeof(*this));  uint16_t crc = crc16_ccitt(buffer, size - crc_size);  *(uint16_t *)(buffer + size - crc_size) = crc;  //dumpBuffer(buffer, size);  eeprom_write_block((const void *)buffer, eepromAddr(), size);  needCommit = false;}

void ConfigParms::reset(){  //DIAGPRINTLN(F("ConfigParms::reset"));  memset(this, 0, sizeof(*this));  // Initialize a few parameters that have default values  _b = PARM_B;  _s = PARM_S;  strncpy_P(_stationName, stationName_Default, sizeof(_stationName) - 1);  strncpy_P(_pwssrv, serverName_Default, sizeof(_pwssrv) - 1);  _pwsport = serverPort_Default;  needCommit = true;}

void lcd_material_reset_defaults(){    //Fill in the defaults    SERIAL_ECHO_START;    SERIAL_ECHOLNPGM("Materials reset");    char buffer[MATERIAL_NAME_LENGTH];    for (int a= 0; a< MATERIAL_PRESETS; a++)        {            strncpy_P(buffer, (char PROGMEM *) presets[a].name,MATERIAL_NAME_LENGTH);		// this will pad out the whole length with 0 as needed.            eeprom_write_block(buffer                                  , EEPROM_MATERIAL_NAME_OFFSET(a), MATERIAL_NAME_LENGTH);            material_preset temp;            memcpy_P((void*) &temp,&presets[a],sizeof (material_preset));            eeprom_write_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(a)    ,temp.temperature);            eeprom_write_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(a),temp.bed);            eeprom_write_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(a)      ,temp.fan_speed);            eeprom_write_word(EEPROM_MATERIAL_FLOW_OFFSET(a)           ,temp.flow);            eeprom_write_float(EEPROM_MATERIAL_DIAMETER_OFFSET(a)      ,temp.diameter);        }    uint8_t e;    for(e=0; e<EXTRUDERS; e++)        {            makeCustomName(e);            strcpy(material_name[e],material_name_buf);            lcd_material_store_current_material();        }    eeprom_write_byte(EEPROM_MATERIAL_COUNT_OFFSET(), MATERIAL_PRESETS);    lcd_lib_beep_ext(500,150);    lcd_lib_beep_ext(750,100);}

 void lcd_setstatuspgm(const char* message, uint8_t level) {   if (level >= lcd_status_message_level && NextionON) {     strncpy_P(lcd_status_message, message, 30);     lcd_status_message_level = level;     LedStatus.setText(lcd_status_message);   } }

char* Menu::GetBuffer_P(const int StringIndex, char* pBuffer, int bufSize) {  strncpy_P(pBuffer, (char*)pgm_read_word(&(WManagement_string_table[StringIndex])), bufSize);  return pBuffer; }

void lcd_setstatuspgm(const char* message){    if (lcd_status_message_level > 0)        return;    strncpy_P(lcd_status_message, message, LCD_WIDTH);    lcd_finishstatus();}

static voidjabber_parse_ecmd(char *message){  int16_t remain = sizeof(STATE->outbuf) - 1;  int16_t written = 0;  while (remain > 0)  {    int16_t len = ecmd_parse_command(message, STATE->outbuf + written, remain);    if (is_ECMD_AGAIN(len))    {      len = ECMD_AGAIN(len);      written += len;      remain -= len;      if (remain)      {        STATE->outbuf[written++] = '/n';        remain--;      }      continue;    }    else if (is_ECMD_ERR(len))    {      strncpy_P(STATE->outbuf, PSTR("parse error"), sizeof(STATE->outbuf));      len = 11;    }    written = len;    break;  }  STATE->outbuf[written] = 0;}

void lcd_setstatuspgm(const char* message){    if (lcd_status_message_level > 0)        return;    strncpy_P(lcd_status_message, message, LCD_WIDTH);    lcdDrawUpdate = 2;}

void initBitlash(unsigned long baud) {#if defined(TINY_BUILD)	beginSerial(9600);#else	beginSerial(baud);#endif#if defined(ARM_BUILD)	eeinit();#endif	initTaskList();	vinit();	displayBanner();#if !defined(TINY_BUILD)	// Run the script named "startup" if there is one	strncpy_P(lbuf, getmsg(M_startup), STRVALLEN);	// get the name "startup" in our cmd buf	//if (findKey(lbuf) >= 0) doCommand(lbuf);		// look it up.  exists?  call it.	if (findscript(lbuf)) doCommand(lbuf);			// look it up.  exists?  call it.#endif	initlbuf();}

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

/* ---------------------------------------------------------------------------- * send an ArtDmx packet */voidartnet_sendDmxPacket(void){  static unsigned char sequence = 1;  /* prepare artnet Dmx packet */  struct artnet_dmx *msg =    (struct artnet_dmx *) &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];  memset(msg, 0, sizeof(struct artnet_dmx));  strncpy_P((char *) msg->id, artnet_ID, 8);  msg->opcode = OP_OUTPUT;  msg->versionH = 0;  msg->version = PROTOCOL_VERSION;  msg->sequence = sequence++;  if (sequence == 0)    sequence = 1;  msg->physical = 1;  msg->universe = ((artnet_subNet << 4) | artnet_inputUniverse);  msg->lengthHi = HI8(DMX_STORAGE_CHANNELS);  msg->length = LO8(DMX_STORAGE_CHANNELS);  for (uint8_t i = 0; i < DMX_STORAGE_CHANNELS; i++)    msg->dataStart[i] =      get_dmx_channel_slot(artnet_inputUniverse, i, artnet_conn_id);  /* send packet to artnet_outputTarget */  artnet_send(&artnet_outputTarget, sizeof(struct artnet_dmx) + DMX_STORAGE_CHANNELS);}

uint8_t ATDev::readLine(char* readBuf, uint16_t readBufSize){    // CR LF to end buffer    strncpy_P(m_endBuffer, ATDEV_END_LINE, ATDEV_BUFF_END_SIZE);        return this->sendATCmdAbrupt(readBuf, readBufSize);}

size_t SerialUI::print_P(PGM_P message) {	char p_buffer[SUI_SERIALUI_PROGMEM_STRING_ABS_MAXLEN + 1];	strncpy_P(p_buffer, message, SUI_SERIALUI_PROGMEM_STRING_ABS_MAXLEN);	SUI_PRINTANDRETURN(print, p_buffer);}

void prompt(void) {char buf[IDLEN+1];	// Run the script named "prompt" if there is one else print "> "	strncpy_P(buf, getmsg(M_promptid), IDLEN);	// get the name "prompt" in our cmd buf	if (findscript(buf)) doCommand(buf);	else msgp(M_prompt);							// else print default prompt}

void drawInstr(uint8_t i) {	buffLen = 0;	buff[0] = '/0';	uint8_t y = (i * 13) + BOX_TOP + 2;	uint8_t x = BOX_LEFT + 2;	if(i == GET_REG(REG_PC)) {		fg = 0x0000;		bg = 0xFFFF;	} else {		fg = 0xFFFF;		bg = 0x0000;	}	ili9340_fillRect(x-1, y-1, CODE_WIDTH - 1, 14, bg);	ili9340_setBackColor(bg);	ili9340_setFrontColor(fg);	if(labels[i][0] != '/0') {		buffLen += strlen(strcpy(buff + buffLen, labels[i]));		buff[buffLen++] = ':';	}	if(GET_OPC_AT(i) == 0) {		buff[buffLen++] = '/0';		ili9340_drawString(x, y, buff); //Just draw the label and continue		return;	}	strncpy_P(buff + buffLen, Instruction[GET_OPC_AT(i)-1], OPC_LEN);	buffLen += 3; //All instrctions are 3 bytes long;	switch(GET_OPC_AT(i)) {		case OPC_MOV:			buff[buffLen++] = ' ';			buffLen += otoa(GET_B_AT(i), buff + buffLen);			buff[buffLen++] = ' ';			buffLen += otoa(GET_A_AT(i), buff + buffLen);			break;		case OPC_ADD:		case OPC_SUB:		case OPC_JRO:			buff[buffLen++] = ' ';			buffLen += otoa(GET_A_AT(i), buff + buffLen);			break;		case OPC_JMP:		case OPC_JEZ:		case OPC_JNZ:		case OPC_JGZ:		case OPC_JLZ: {						  buff[buffLen++] = ' ';						  struct Operand dst;						  DECODE_OP(GET_A_AT(i), &dst);						  buffLen += strlen(strcpy(buff + buffLen, labels[dst.litValue]));						  break;					  }		default:					  break;	}	ili9340_drawString(x, y, buff);}

void prompt(void) {char buf[IDLEN+1];	// Run the script named "prompt" if there is one else print "> "	strncpy_P(buf, getmsg(M_promptid), IDLEN);	// get the name "prompt" in our cmd buf	int entry = findKey(buf);	if (entry >= 0) doCommand(kludge(findend(entry)));	else msgp(M_prompt);							// else print default prompt}

/** *	/ingroup time *   GetUSdate gibt Datum kompatibel mit Internet Datumsangabe zurück */char *GetUSdate(char *datestring){	char month[4];	strncpy_P(month,&US_Monate[(TM_MM-1)*3],3);	month[3] = '/0';	sprintf_P(datestring,PSTR("%2d %s %4d"),TM_DD,month,GetYearYYYY());	return datestring;}

// Find a variable by name.//AP_Param *AP_Param::find_P(const prog_char_t *name, enum ap_var_type *ptype){    char param_name[AP_MAX_NAME_SIZE+1];    strncpy_P(param_name, name, AP_MAX_NAME_SIZE);    param_name[AP_MAX_NAME_SIZE] = 0;    return find(param_name, ptype);}

void ATSMS::setCMGLEndBuffer(){    // Prepare answer end    strncpy_P(m_endBuffer, ATDEV_STR_CMGL, ATDEV_BUFF_END_SIZE);    // Timeout    m_timeOut       = ATDEV_SMS_TIMEOUT_LIST;}

int WebServer_put_notfound(int socket){    char req_pool[50];    memset(req_pool, 0, sizeof(req_pool));    strncpy_P(req_pool, PSTR("HTTP/1.0 404 Not Found/r/n"), sizeof(req_pool));    WebServer_put_response(socket, req_pool, strlen(req_pool));    memset(req_pool, 0, sizeof(req_pool));    strncpy_P(req_pool, PSTR("Content-Type: text/html/r/n"), sizeof(req_pool));    WebServer_put_response(socket, req_pool, strlen(req_pool));    memset(req_pool, 0, sizeof(req_pool));    strncpy_P(req_pool, PSTR("Connection: close/r/n/r/n"), sizeof(req_pool));    WebServer_put_response(socket, req_pool, strlen(req_pool));    return 0;}

void tx_aprs(int32_t lat, int32_t lon, int32_t alt){	char slat[5];	char slng[5];	char stlm[9];	static uint16_t seq = 0;		/* Convert the UBLOX-style coordinates to	 * the APRS compressed format */	lat = 900000000 - lat;	lat = lat / 26 - lat / 2710 + lat / 15384615;		lon = 900000000 + lon / 2;	lon = lon / 26 - lon / 2710 + lon / 15384615;		alt = alt / 1000 * 32808 / 10000;		/* Construct the compressed telemetry format */	ax25_base91enc(stlm + 0, 2, seq);	ax25_base91enc(stlm + 2, 2, adc_read());		ax25_frame(		APRS_CALLSIGN, APRS_SSID,		"APRS", 0,		0, 0, 0, 0,		//"WIDE1", 1,		//"WIDE2", 1,		"!/%s%sO   /A=%06ld|%s|",		ax25_base91enc(slat, 4, lat),		ax25_base91enc(slng, 4, lon),		alt, stlm	);		if(seq % 60 == 0)	{		char s[10];				/* Make up the callsign */		strncpy_P(s, PSTR(APRS_CALLSIGN), 7);		if(APRS_SSID) snprintf_P(s + strlen(s), 4, PSTR("-%i"), APRS_SSID);				/* Transmit telemetry definitions */		ax25_frame(			APRS_CALLSIGN, APRS_SSID,			"APRS", 0,			0, 0, 0, 0,			":%-9s:PARM.Battery", s		);		ax25_frame(			APRS_CALLSIGN, APRS_SSID,			"APRS", 0,			0, 0, 0, 0,			":%-9s:UNIT.mV", s		);	}		seq++;}

void modelDefault(uint8_t id){  memset(&g_model,0,sizeof(g_model));  strncpy_P(g_model.name,PSTR("MODEL     "), 10);  g_model.name[5]='0'+(id+1)/10;  g_model.name[6]='0'+(id+1)%10;  g_model.mdVers = 0; //MDVERS143;  modelMixerDefault(id==0 ? 1 : 0);}