Come si usa la funzione printf su STM32?

Sto cercando di capire come utilizzare la funzione printf per stampare sulla porta seriale.

La mia configurazione attuale è il codice generato da STM32CubeMX e SystemWorkbench32 con la scheda di rilevamento STM32F407 .

Vedo in stdio.h che il prototipo di printf è definito come:

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

Cosa significa? Dov'è la posizione esatta di questa definizione di funzione? Quale sarebbe il punto generale di scoprire come utilizzare questo tipo di funzione per l'output?

Ho ottenuto il primo metodo da questa pagina lavorando sul mio STM32F072.

http://www.openstm32.org/forumthread1055

Come affermato lì,

Il modo in cui ho fatto funzionare printf (e tutte le altre funzioni stdio orientate alla console) è stato creando implementazioni personalizzate delle funzioni I / O di basso livello come _read()e _write().

La libreria GCC C chiama le seguenti funzioni per eseguire operazioni di I / O di basso livello:

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)

Queste funzioni sono implementate con la libreria GCC C come routine di stub con collegamento "debole". Se nel proprio codice appare una dichiarazione di una delle funzioni sopra indicate, la routine sostitutiva sovrascriverà la dichiarazione nella libreria e verrà utilizzata al posto della routine predefinita (non funzionale).

Ho usato STM32CubeMX per configurare USART1 ( huart1) come porta seriale. Dal momento che volevo solo printf(), avevo solo bisogno di popolare la _write()funzione, cosa che ho fatto come segue. Questo è convenzionalmente contenuto in 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 è una macro, probabilmente contenente alcune direttive interessanti che dicono al compilatore che dovrebbe controllare la stringa di formato per essere compatibile con printf e assicurarsi che gli argomenti per printf corrispondano alla stringa di formato.

Per imparare a usare printf, suggerisco la pagina man e un po 'più googling. Scrivi alcuni semplici programmi C che utilizzano printf ed eseguili sul tuo computer prima di provare a passare al suo utilizzo sul micro.

La domanda interessante sarà "dove va il testo stampato?". Su un sistema simile a unix, va "fuori standard", ma un microcontrollore non ha nulla del genere. Le librerie di debug CMSIS possono inviare il testo printf alla porta di debug del semihosting arm, ovvero nella sessione gdb o openocd, ma non ho idea di cosa farà SystemWorkbench32.

Se non stai lavorando in un debugger, potrebbe essere più sensato utilizzare sprintf per formattare le stringhe che desideri stampare e quindi inviare quelle stringhe su una porta seriale o su qualsiasi schermo che potresti aver collegato.

Attenzione: printf e il relativo codice sono molto grandi. Questo probabilmente non ha molta importanza su un 32F407, ma è un vero problema su dispositivi con poco flash.

@La risposta di AdamHaun è tutto ciò di cui hai bisogno, con sprintf()cui è facile creare una stringa e inviarla. Ma se vuoi davvero una printf()tua funzione, allora Variable Argument Functions (va_list) è la strada giusta .

Con va_listuna funzione di stampa personalizzata è simile al seguente:

#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);
}

Esempio di utilizzo:

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);

Si noti che mentre questa soluzione offre una comoda funzione da utilizzare, ma è più lenta rispetto all'invio di dati non elaborati o all'utilizzo uniforme sprintf(). Con alti datarati penso che non sarà sufficiente.

Un'altra opzione, e probabilmente migliore, è quella di utilizzare ST-Link, debugger SWD insieme a ST-Link Utility. E utilizzare Printf tramite il visualizzatore SWO , ecco il manuale dell'utilità ST-Link , la parte pertinente inizia a pagina 31.

Printf tramite SWO Viewer visualizza i dati printf inviati dalla destinazione tramite SWO. Permette di visualizzare alcune informazioni utili sul firmware in esecuzione.

printf () fa parte (di solito) della libreria standard C. Se la tua versione della libreria viene fornita con il codice sorgente, potresti trovare un'implementazione lì.

Probabilmente sarebbe più facile usare sprintf () per generare una stringa, quindi usare un'altra funzione per inviare la stringa attraverso la porta seriale. In questo modo tutta la formattazione difficile viene eseguita per te e non devi hackerare la libreria standard.

Per coloro che lottano, aggiungi quanto segue 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);
}

Connettiti alla tua porta COM tramite putty e dovresti essere bravo.

Se si desidera un approccio diverso e non si desidera sovrascrivere le funzioni o dichiarare le proprie, è possibile utilizzare semplicemente snprintfper archiviare lo stesso obiettivo. Ma non è così elegante.

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