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_t parse_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_t parse_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_t parse_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_t parse_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_t generate_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_t parse_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); }
static void menuNumberEdit(button_t button, unsigned char increment, int minVal, int maxVal, const char PROGMEM *format) { char buffer[17]; // If button is being held down, accelerate the increment unsigned char repCnt = Menus.getButtonRepeatCnt(); if (repCnt > 10) increment *= 4; else if (repCnt > 5) increment *= 2; if (button == BUTTON_UP) editInt += increment; else if (button == BUTTON_DOWN) editInt -= increment; if (editInt < minVal) editInt = minVal; if (editInt > maxVal) editInt = maxVal; lcd.setCursor(0, 1); snprintf_P(buffer, sizeof(buffer), format, editInt, pid.getUnits()); lcd.print(buffer); }
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>")); }
/** * Create an HTTP request and store it in the provided buffer. * * \param[out] buffer The buffer where the request will be stored. * \param[in] bufferSize The size of the output buffer. * \param[in] host The remote host where the resource is located * \param[in] path The path of the desired resource on the host. * \param[in] flags Flags used to determine the request type and connection * mode (see values above). * \param[in] firstByte Index of the first byte of the requested range. * \param[in] lastByte Index of the last byte of the requested range. */ bool HttpClient::createGetRequest(char* buffer, size_t bufferSize, const char* host, const char* path, uint8_t flags, uint32_t firstByte, uint32_t lastByte) { // check flags if ((flags & F_HEAD) == (flags & F_GET)) return false; else if ((flags & F_KEEP_ALIVE) == (flags & F_CLOSE)) return false; // determine request type PGM_P request; if (flags & F_HEAD) request = HTTP_REQUEST_HEAD; else if (flags & F_GET) { bool partial = !(firstByte == 0 && lastByte == 0); request = partial ? HTTP_REQUEST_PARTIAL_GET : HTTP_REQUEST_GET; } // 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, firstByte, lastByte ); return true; }
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) ); }