Comment utiliser la fonction printf sur STM32?

J'essaie de comprendre comment utiliser la fonction printf pour imprimer sur le port série.

Ma configuration actuelle est le code généré par STM32CubeMX et SystemWorkbench32 avec la carte de découverte STM32F407 .

Je vois dans stdio.h que le prototype printf est défini comme:

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

Qu'est-ce que ça veut dire? Où est l'emplacement exact de cette définition de fonction? Quel serait l'intérêt général de savoir comment utiliser ce type de fonction pour sortir?

J'ai obtenu la première méthode de cette page sur mon STM32F072.

http://www.openstm32.org/forumthread1055

Comme indiqué ici,

La façon dont j'ai fait fonctionner printf (et toutes les autres fonctions stdio orientées console) était de créer des implémentations personnalisées des fonctions d'E / S de bas niveau comme _read()et _write().

La bibliothèque GCC C appelle les fonctions suivantes pour effectuer des E / S de bas niveau:

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)

Ces fonctions sont implémentées dans la bibliothèque GCC C en tant que routines tronquées avec une liaison "faible". Si une déclaration de l'une des fonctions ci-dessus apparaît dans votre propre code, votre routine de remplacement remplacera la déclaration dans la bibliothèque et sera utilisée à la place de la routine par défaut (non fonctionnelle).

J'ai utilisé STM32CubeMX pour configurer USART1 ( huart1) comme port série. Comme je voulais seulement printf(), je n'avais qu'à remplir la _write()fonction, ce que j'ai fait comme suit. Ceci est classiquement contenu dans 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 est une macro, contenant probablement des directives intéressantes qui indiquent au compilateur qu'il doit vérifier que la chaîne de format est compatible avec printf et s'assurer que les arguments de printf correspondent à la chaîne de format.

Pour apprendre à utiliser printf, je suggère la page de manuel et un peu plus de recherche sur Google. Écrivez quelques programmes C simples qui utilisent printf et exécutez-les sur votre ordinateur avant d'essayer de passer à l'utilisation sur le micro.

La question intéressante sera "où va le texte imprimé?". Sur un système de type Unix, il passe en "sortie standard", mais un microcontrôleur n'a rien de tel. Les bibliothèques de débogage CMSIS peuvent envoyer du texte printf au port de débogage de semihosting arm, c'est-à-dire dans votre session gdb ou openocd mais je n'ai aucune idée de ce que SystemWorkbench32 fera.

Si vous ne travaillez pas dans un débogueur, il peut être plus judicieux d'utiliser sprintf pour formater les chaînes que vous souhaitez imprimer, puis envoyer ces chaînes sur un port série ou sur tout affichage que vous pourriez avoir connecté.

Attention: printf et son code associé sont très volumineux. Cela n'a probablement pas beaucoup d'importance sur un 32F407, mais c'est un vrai problème sur les appareils avec peu de flash.

@ La réponse d'AdamHaun est tout ce dont vous avez besoin, sprintf()il est facile de créer une chaîne puis de l'envoyer. Mais si vous voulez vraiment une printf()fonction de votre choix, alors les fonctions d'argument variable (va_list) sont la solution.

Avec va_listune fonction d'impression personnalisée ressemble à ceci:

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

Exemple d'utilisation:

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

Notez que bien que cette solution vous offre une fonction pratique à utiliser, elle est plus lente que l'envoi de données brutes ou l'utilisation de even sprintf(). Avec des taux de données élevés, je pense que ce ne sera pas suffisant.

Une autre option, et probablement meilleure, consiste à utiliser ST-Link, le débogueur SWD avec l'utilitaire ST-Link. Et utilisez Printf via la visionneuse SWO , voici le manuel de l' utilitaire ST-Link , la partie pertinente commence à la page 31.

Printf via SWO Viewer affiche les données printf envoyées depuis la cible via SWO. Il permet d'afficher des informations utiles sur le firmware en cours d'exécution.

printf () fait (généralement) partie de la bibliothèque standard C. Si votre version de la bibliothèque est livrée avec du code source, vous pouvez y trouver une implémentation.

Il serait probablement plus facile d'utiliser sprintf () pour générer une chaîne, puis d'utiliser une autre fonction pour envoyer la chaîne via le port série. De cette façon, tout le formatage difficile est fait pour vous et vous n'avez pas à pirater la bibliothèque standard.

Pour ceux qui éprouvent des difficultés, ajoutez ce qui suit à 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);
}

Connectez-vous à votre port COM via du mastic et vous devriez être bon.

Si vous voulez une approche différente et ne voulez pas écraser les fonctions ou déclarer la vôtre, vous pouvez simplement utiliser snprintfpour archiver le même objectif. Mais ce n'est pas aussi élégant.

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