Como uso a função printf no STM32?

Estou tentando descobrir como usar a função printf para imprimir na porta serial.

Minha configuração atual é o código gerado pelo STM32CubeMX e o SystemWorkbench32 com a placa de descoberta STM32F407 .

Vejo em stdio.h que o protótipo printf é definido como:

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

O que isso significa? Onde está o local exato desta definição de função? Qual seria o ponto geral de descobrir como usar esse tipo de função para produzir?

Eu obtive o primeiro método desta página trabalhando no meu STM32F072.

http://www.openstm32.org/forumthread1055

Como afirmado lá,

A maneira como consegui o printf (e todas as outras funções stdio orientadas ao console) para trabalhar foi criando implementações personalizadas das funções de E / S de baixo nível, como _read()e _write().

A biblioteca C do GCC faz chamadas para as seguintes funções para executar E / S de baixo nível:

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)

Essas funções são implementadas na biblioteca C do GCC como rotinas stub com ligação "fraca". Se uma declaração de qualquer uma das funções acima aparecer em seu próprio código, sua rotina substituta substituirá a declaração na biblioteca e será usada no lugar da rotina padrão (não funcional).

Usei o STM32CubeMX para configurar o USART1 ( huart1) como uma porta serial. Como eu só queria printf(), só precisava preencher a _write()função, que fiz da seguinte maneira. Isso é convencionalmente contido em 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 é uma macro, provavelmente contendo algumas diretivas interessantes que informam ao compilador que ele deve verificar se a string de formato é compatível com printf e garantir que os argumentos para printf correspondam à string de formato.

Para aprender a usar o printf, sugiro a página de manual e um pouco mais de pesquisa. Escreva alguns programas C simples que usem printf e execute-os no seu computador antes de tentar fazer a transição para o micro.

A questão interessante será "para onde vai o texto impresso?". Em um sistema unix, ele vai para a "saída padrão", mas um microcontrolador não tem tal coisa. As bibliotecas de depuração do CMSIS podem enviar texto printf para a porta de depuração semi-hospedada do braço, ou seja, na sua sessão gdb ou openocd, mas não tenho idéia do que o SystemWorkbench32 fará.

Se você não estiver trabalhando em um depurador, pode fazer mais sentido usar o sprintf para formatar as sequências que você deseja imprimir e depois enviá-las por uma porta serial ou para qualquer monitor que possa estar conectado.

Cuidado: printf e seu código relacionado são muito grandes. Provavelmente isso não importa muito em um 32F407, mas é um problema real em dispositivos com pouco flash.

A resposta de @ AdamHaun é tudo que você precisa, sprintf()é fácil criar uma string e enviá-la. Mas se você realmente quer uma printf()função própria, então Funções de Argumento Variável (va_list) é o caminho.

Com va_listuma função de impressão personalizada, é semelhante ao seguinte:

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

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

Observe que, embora esta solução ofereça uma função conveniente para uso, mas é mais lenta que o envio de dados brutos ou o uso uniforme sprintf(). Com altos datarates, acho que não será suficiente.

Outra opção, e provavelmente a melhor opção, é usar o depurador SW-ST-Link junto com o utilitário ST-Link. E use Printf via visualizador SWO , aqui está o manual do ST-Link Utility , parte relevante começa na página 31.

O Printf via SWO Viewer exibe os dados de printf enviados do destino através do SWO. Permite exibir algumas informações úteis sobre o firmware em execução.

printf () é (geralmente) parte da biblioteca padrão C. Se sua versão da biblioteca vier com código-fonte, você poderá encontrar uma implementação lá.

Provavelmente seria mais fácil usar sprintf () para gerar uma string e, em seguida, use outra função para enviar a string pela porta serial. Dessa forma, toda a formatação difícil é feita para você e você não precisa invadir a biblioteca padrão.

Para aqueles que lutam, adicione o seguinte 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);
}

Conecte-se à sua porta COM via massa e você deve ser bom.

Se você deseja uma abordagem diferente e não deseja sobrescrever funções ou declarar a sua, pode simplesmente usar snprintfpara arquivar o mesmo objetivo. Mas não é tão elegante.

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