¿Cómo uso la función printf en STM32?

Estoy tratando de descubrir cómo usar la función printf para imprimir en el puerto serie.

Mi configuración actual es código generado por STM32CubeMX y SystemWorkbench32 con la placa de descubrimiento STM32F407 .

Veo en stdio.h que el prototipo printf se define como:

int _EXFUN(printf, (const char *__restrict, ...)
               _ATTRIBUTE ((__format__ (__printf__, 1, 2))));

Qué significa eso? ¿Dónde está la ubicación exacta de esta definición de función? ¿Cuál sería el punto general de descubrir cómo usar este tipo de función para generar?

Obtuve el primer método de esta página trabajando en mi STM32F072.

http://www.openstm32.org/forumthread1055

Como se indica allí,

La forma en que hice que printf (y todas las demás funciones estándar orientadas a la consola) funcionara fue creando implementaciones personalizadas de las funciones de E / S de bajo nivel como _read()y _write().

La biblioteca GCC C realiza llamadas a las siguientes funciones para realizar E / S de bajo nivel:

int _read(int file, char *data, int len)
int _write(int file, char *data, int len)
int _close(int file)
int _lseek(int file, int ptr, int dir)
int _fstat(int file, struct stat *st)
int _isatty(int file)

Estas funciones se implementan dentro de la biblioteca GCC C como rutinas de código auxiliar con enlace "débil". Si aparece una declaración de cualquiera de las funciones anteriores en su propio código, su rutina sustituta anulará la declaración en la biblioteca y se utilizará en lugar de la rutina predeterminada (no funcional).

Utilicé STM32CubeMX para configurar USART1 ( huart1) como puerto serie. Como solo quería printf(), solo necesitaba llenar la _write()función, lo que hice de la siguiente manera. Esto está contenido convencionalmente en syscalls.c.

#include  <errno.h>
#include  <sys/unistd.h> // STDOUT_FILENO, STDERR_FILENO

int _write(int file, char *data, int len)
{
   if ((file != STDOUT_FILENO) && (file != STDERR_FILENO))
   {
      errno = EBADF;
      return -1;
   }

   // arbitrary timeout 1000
   HAL_StatusTypeDef status =
      HAL_UART_Transmit(&huart1, (uint8_t*)data, len, 1000);

   // return # of bytes written - as best we can tell
   return (status == HAL_OK ? len : 0);
}

_EXFUN es una macro, que probablemente contenga algunas directivas interesantes que le dicen al compilador que debe verificar que la cadena de formato sea compatible con printf y garantizar que los argumentos para printf coincidan con la cadena de formato.

Para aprender a usar printf, sugiero la página de manual y un poco más de google. Escriba algunos programas C simples que usen printf y ejecútelos en su computadora antes de intentar hacer la transición para usarlos en el micro.

La pregunta interesante será "¿a dónde va el texto impreso?". En un sistema similar a Unix, pasa a "salida estándar", pero un microcontrolador no tiene tal cosa. Las bibliotecas de depuración CMSIS pueden enviar texto printf al puerto de depuración semihosting del brazo, es decir, a su sesión gdb u openocd, pero no tengo idea de lo que hará SystemWorkbench32.

Si no está trabajando en un depurador, podría tener más sentido usar sprintf para formatear las cadenas que desea imprimir y luego enviar esas cadenas a través de un puerto serie o a cualquier pantalla que haya conectado.

Cuidado: printf y su código relacionado son muy grandes. Eso probablemente no importa mucho en un 32F407, pero es un problema real en dispositivos con poco flash.

La respuesta de @ AdamHaun es todo lo que necesita, ya sprintf()que es fácil crear una cadena y luego enviarla. Pero si realmente quieres una printf()función propia, entonces las Funciones de Argumento Variable (va_list) son el camino.

Con va_listuna función de impresión personalizada se ve así:

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

void vprint(const char *fmt, va_list argp)
{
    char string[200];
    if(0 < vsprintf(string,fmt,argp)) // build string
    {
        HAL_UART_Transmit(&huart1, (uint8_t*)string, strlen(string), 0xffffff); // send message via UART
    }
}

void my_printf(const char *fmt, ...) // custom printf() function
{
    va_list argp;
    va_start(argp, fmt);
    vprint(fmt, argp);
    va_end(argp);
}

Ejemplo de uso:

uint16_t year = 2015;
uint8_t month = 12;
uint8_t day   = 18;
char* date = "date";

// "Today's date: 2015-12-18"
my_printf("Today's %s: %d-%d-%d\r\n", date, year, month, day);

Tenga en cuenta que, si bien esta solución le brinda una función conveniente para usar, es más lenta que enviar datos sin procesar o incluso usar sprintf(). Con altas tasas de datos, creo que no será suficiente.

Otra opción, y probablemente una mejor opción, es utilizar ST-Link, depurador de SWD junto con ST-Link Utility. Y use Printf a través del visor SWO , aquí está el manual de la utilidad ST-Link , la parte relevante comienza en la página 31.

Printf via SWO Viewer muestra los datos de printf enviados desde el objetivo a través de SWO. Permite mostrar información útil sobre el firmware en ejecución.

printf () es (generalmente) parte de la biblioteca estándar de C. Si su versión de la biblioteca viene con código fuente, es posible que encuentre una implementación allí.

Probablemente sería más fácil usar sprintf () para generar una cadena, luego usar otra función para enviar la cadena a través del puerto serie. De esa manera, todo el formato difícil se realiza por usted y no tiene que piratear la biblioteca estándar.

Para aquellos que luchan, agregue lo siguiente a syscalls.c:

extern UART_HandleTypeDef huart1; // access huart1 instance
//extern int __io_putchar(int ch) __attribute__((weak)); // comment this out

__attribute__((weak)) int __io_putchar(int ch)
{
    HAL_StatusTypeDef status = HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
    return (status == HAL_OK ? ch : 0);
}

Conéctese a su puerto COM a través de masilla y debería ser bueno.

Si desea un enfoque diferente y no desea sobrescribir las funciones o declarar las suyas, simplemente puede usar snprintfpara archivar el mismo objetivo. Pero no es tan elegante.

char buf[100];
snprintf(buf, 100, "%X %X", val1, val2);
HAL_UART_Transmit(&huart1, (uint8_t*)buf, strlen(buf), 1000);