void hwDebugPrint(const char *fmt, ... ) { char fmtBuffer[MY_SERIAL_OUTPUT_SIZE]; #ifdef MY_GATEWAY_FEATURE // prepend debug message to be handled correctly by controller (C_INTERNAL, I_LOG_MESSAGE) snprintf_P(fmtBuffer, sizeof(fmtBuffer), PSTR("0;255;%d;0;%d;"), C_INTERNAL, I_LOG_MESSAGE); MY_SERIALDEVICE.print(fmtBuffer); #else // prepend timestamp (AVR nodes) MY_SERIALDEVICE.print(hwMillis()); MY_SERIALDEVICE.print(" "); #endif va_list args; va_start (args, fmt ); #ifdef MY_GATEWAY_FEATURE // Truncate message if this is gateway node vsnprintf_P(fmtBuffer, sizeof(fmtBuffer), fmt, args); fmtBuffer[sizeof(fmtBuffer) - 2] = '\n'; fmtBuffer[sizeof(fmtBuffer) - 1] = '\0'; #else vsnprintf_P(fmtBuffer, sizeof(fmtBuffer), fmt, args); #endif va_end (args); MY_SERIALDEVICE.print(fmtBuffer); MY_SERIALDEVICE.flush(); //MY_SERIALDEVICE.write(freeRam()); }
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()); }
/** * Output a variable argument list log string with the specified priority level. * Only defined for Arduino as depicted below. * * @param level - DEBUG, INFO, WARNING, ERROR, FATAL * @param tag - Module name * @param format - variadic log string */ void OCLogv(LogLevel level, PROGMEM const char * tag, PROGMEM const char * format, ...) { char buffer[LINE_BUFFER_SIZE]; va_list ap; va_start(ap, format); GET_PROGMEM_BUFFER(buffer, &(LEVEL[level])); Serial.print(buffer); char c; Serial.print(F(": ")); while ((c = pgm_read_byte(tag))) { Serial.write(c); tag++; } Serial.print(F(": ")); #ifdef __AVR__ vsnprintf_P(buffer, sizeof(buffer), format, ap); #else vsnprintf(buffer, sizeof(buffer), format, ap); #endif for(char *p = &buffer[0]; *p; p++) // emulate cooked mode for newlines { if(*p == '\n') { Serial.write('\r'); } Serial.write(*p); } Serial.println(); va_end(ap); }
// this gets rid of snprintf_P void mysnprintf_P(char* buf, int len, const char* fmt, ...) { va_list args; va_start (args, fmt ); vsnprintf_P(buf, len, fmt, args); va_end (args); }
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 }
// create a printf like interface to the Arduino Serial function. Format string stored in PROGMEM void PiLink::print_P(const char *fmt, ... ){ char tmp[128]; // resulting string limited to 128 chars va_list args; va_start (args, fmt ); vsnprintf_P(tmp, 128, fmt, args); va_end (args); Serial.print(tmp); }
void _TM_DEBUG (char *fmt, ... ) { char tmp[128]; // resulting string limited to 128 chars va_list args; va_start (args, fmt ); vsnprintf_P(tmp, 128, fmt, args); va_end (args); Serial.print(tmp); }
void PiLink::printFridgeAnnotation(const char * annotation, ...){ char tempString[128]; // resulting string limited to 128 chars va_list args; // Using print_P for the Annotation fails. Arguments are not passed correctly. Use Serial directly as a work around. va_start (args, annotation ); vsnprintf_P(tempString, 128, annotation, args); va_end (args); printTemperaturesJSON(0, tempString); }
void lcd_Printf_P(PGM_P format, ...) { va_list arg; va_start(arg, format); vsnprintf_P((char *)LCDWorkBuffer, portLCD_BUFFER, format, arg); lcd_Print((uint8_t *)LCDWorkBuffer); va_end(arg); }
// create a printf like interface to the Arduino Serial function. Format string stored in PROGMEM void PiLink::print_P(const char *fmt, ... ){ va_list args; va_start (args, fmt ); vsnprintf_P(printfBuff, PRINTF_BUFFER_SIZE, fmt, args); va_end (args); if(SERIAL_READY(piStream)){ // if Serial connected (on Leonardo) piStream.print(printfBuff); } }
void avrSerialPrintf_P(PGM_P format, ...) { va_list arg; va_start(arg, format); vsnprintf_P((char *)serialWorkBuffer, portSERIAL_BUFFER, format, arg); avrSerialPrint(serialWorkBuffer); va_end(arg); }
void ArduinoPrintf::printf_P( const prog_uint8_t* fmt, ... ) { char tmp[PRINTF_BUFFER]; va_list args; va_start (args, fmt ); vsnprintf_P(tmp, PRINTF_BUFFER, (const prog_char*)fmt, args); va_end (args); interface->print(tmp); }
void usart_xfprintf_P_arg(USART_ID usartId, PGM_P format, va_list arg) { while(usartComBuf[usartId].workBufferInUse == USART_ENGAGED ) taskYIELD(); usartComBuf[usartId].workBufferInUse = USART_ENGAGED; vsnprintf_P((char *)(usartComBuf[usartId].workBuffer), usartComBuf[usartId].workBufferSize, format, arg); usart_xfprint(usartId, (uint8_t *)(usartComBuf[usartId].workBuffer)); usartComBuf[usartId].workBufferInUse = USART_VACANT; }
int sprintf_P(char* str, PGM_P formatP, ...) { int ret; va_list arglist; va_start(arglist, formatP); ret = vsnprintf_P(str, SIZE_IRRELEVANT, formatP, arglist); va_end(arglist); return ret; }
int snprintf_P(char* str, size_t strSize, PGM_P formatP, ...) { int ret; va_list arglist; va_start(arglist, formatP); ret = vsnprintf_P(str, strSize, formatP, arglist); va_end(arglist); return ret; }
void usart_fprintf_P_arg(USART_ID usartId, PGM_P format, va_list arg) { while(usartComBuf[usartId].workBufferInUse == USART_ENGAGED ) _delay_us(25); usartComBuf[usartId].workBufferInUse = USART_ENGAGED; vsnprintf_P((char *)(usartComBuf[usartId].workBuffer), usartComBuf[usartId].workBufferSize, format, arg); usart_fprint(usartId,usartComBuf[usartId].workBuffer); usartComBuf[usartId].workBufferInUse = USART_VACANT; }
void MyGateway::serial(const char *fmt, ... ) { va_list args; va_start (args, fmt ); vsnprintf_P(serialBuffer, MAX_SEND_LENGTH, fmt, args); va_end (args); Serial.print(serialBuffer); if (useWriteCallback) { // We have a registered write callback (probably Ethernet) dataCallback(serialBuffer); } }
void serial_printf(const __FlashStringHelper *fmt, ... ) { va_list args; va_start (args, fmt); #ifdef __AVR__ vsnprintf_P(buf, sizeof(buf), (const char *)fmt, args); // progmem for AVR #else vsnprintf(buf, sizeof(buf), (const char *)fmt, args); #endif va_end(args); Serial.println(buf); }
bool MsgQueue::addMessage(const char * msg, va_list args) { if (message_count == MSGQUEUE_MAX_MESSAGES) { return false; } if (strlen_P(msg) >= MSGQUEUE_MAX_MESSAGE_LEN) { return false; } memset(messages[message_count], 0, MSGQUEUE_MAX_MESSAGE_LEN); vsnprintf_P(messages[message_count], MSGQUEUE_MAX_MESSAGE_LEN, msg, args); message_count++; queue_processing = true; return true; }
/* for documentation check os_test.h */ void test_debug_printf(const OS_PROGMEM char* format, ...) { va_list vargs; char buff[OS_STACK_MINSIZE / 2]; /* half of stack size */ va_start(vargs, format); /* use +_P version of vsnpintf since format is from program memory */ vsnprintf_P(buff, sizeof(buff) - 1, format, vargs); buff[sizeof(buff) - 1] = '\0'; va_end(vargs); uart_tx_rammem(buff); }
void EIoTCloudRestApi::printDebug(const char *fmt, ...) { char buff[300]; va_list args; va_start(args, fmt); va_end(args); vsnprintf_P(buff, 299, fmt, args); va_end(args); Serial.print(buff); Serial.flush(); }
size_t Print::printf_P(PGM_P format, ...) { va_list arg; va_start(arg, format); char temp[64]; char* buffer = temp; size_t len = vsnprintf_P(temp, sizeof(temp), format, arg); va_end(arg); if (len > sizeof(temp) - 1) { buffer = new char[len + 1]; if (!buffer) { return 0; } va_start(arg, format); vsnprintf_P(buffer, len + 1, format, arg); va_end(arg); } len = write((const uint8_t*) buffer, len); if (buffer != temp) { delete[] buffer; } return len; }
void PiLink::debugMessage(const char * message, ...){ va_list args; //print 'D:' as prefix printResponse('D'); // Using print_P for the Annotation fails. Arguments are not passed correctly. Use Serial directly as a work around. va_start (args, message ); vsnprintf_P(printfBuff, PRINTF_BUFFER_SIZE, message, args); va_end (args); piStream.print(printfBuff); printNewLine(); }
void PiLink::debugMessage(const char * message, ...){ char tempString[128]; // resulting string limited to 128 chars va_list args; //print 'D:' as prefix print_P(PSTR("D:")); // Using print_P for the Annotation fails. Arguments are not passed correctly. Use Serial directly as a work around. va_start (args, message ); vsnprintf_P(tempString, 128, message, args); va_end (args); Serial.print(tempString); print_P(PSTR("\n")); // print newline }
void hwDebugPrint(const char *fmt, ... ) { char fmtBuffer[300]; #ifdef MY_GATEWAY_FEATURE // prepend debug message to be handled correctly by controller (C_INTERNAL, I_LOG_MESSAGE) snprintf_P(fmtBuffer, 299, PSTR("0;255;%d;0;%d;"), C_INTERNAL, I_LOG_MESSAGE); MY_SERIALDEVICE.print(fmtBuffer); #endif va_list args; va_start (args, fmt ); va_end (args); #ifdef MY_GATEWAY_FEATURE // Truncate message if this is gateway node vsnprintf_P(fmtBuffer, MY_GATEWAY_MAX_SEND_LENGTH, fmt, args); fmtBuffer[MY_GATEWAY_MAX_SEND_LENGTH-1] = '\n'; fmtBuffer[MY_GATEWAY_MAX_SEND_LENGTH] = '\0'; #else vsnprintf_P(fmtBuffer, 299, fmt, args); #endif va_end (args); MY_SERIALDEVICE.print(fmtBuffer); MY_SERIALDEVICE.flush(); //MY_SERIALDEVICE.write(freeRam()); }
void hwDebugPrint(const char *fmt, ... ) { char fmtBuffer[300]; #ifdef MY_GATEWAY_FEATURE // prepend debug message to be handled correctly by controller (C_INTERNAL, I_LOG_MESSAGE) snprintf_P(fmtBuffer, 299, PSTR("0;0;%d;0;%d;"), C_INTERNAL, I_LOG_MESSAGE); Serial.print(fmtBuffer); #endif va_list args; va_start (args, fmt ); va_end (args); #ifdef MY_GATEWAY_FEATURE // 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); #endif va_end (args); Serial.print(fmtBuffer); Serial.flush(); //Serial.write(freeRam()); }
/* usart_printf_p() Send a format string stored in flash memory to the USART. */ uint8_t usart_printf_p(const char *fmt, ...) { va_list args; char printbuffer[USART_TXBUFFERSIZE]; va_start (args, fmt); /* For this to work, printbuffer must be larger than * anything we ever want to print. */ vsnprintf_P (printbuffer, USART_TXBUFFERSIZE, fmt, args); va_end (args); /* Print the string */ usart_puts(printbuffer); return 0; }
void avrSerialxPrintf_P(xComPortHandlePtr pxPort, PGM_P format, ...) { va_list arg; va_start(arg, format); while(pxPort->serialWorkBufferInUse == ENGAGED ) _delay_us(25); pxPort->serialWorkBufferInUse = ENGAGED; vsnprintf_P((char *)(pxPort->serialWorkBuffer), pxPort->serialWorkBufferSize, format, arg); avrSerialxPrint(pxPort, pxPort->serialWorkBuffer); pxPort->serialWorkBufferInUse = VACANT; va_end(arg); }
uint8_t httplog_P(const char *message, ...) { uint8_t result = httplog_buffer_empty(); if (result) { va_list va; va_start(va, message); vsnprintf_P(httplog_tmp_buf, HTTPLOG_BUFFER_LEN, message, va); va_end(va); httplog_tmp_buf[HTTPLOG_BUFFER_LEN - 1] = 0; httplog_resolve_address(); } return result; }
void wprintw_P (WINDOW *win, const char *fmt, ...) { char buf[COLS + 1]; va_list va; va_start (va, fmt); TTYDEBUG ("wprintw: win=%p, %s to y=%d,x=%d ", win, fmt, win->y, win->x); vsnprintf_P (buf, COLS + 1, fmt, va); TTYDEBUG ("--> '%s'\n", buf); waddstr (win, buf); va_end (va); }