Jak korzystać z funkcji printf na STM32?

Próbuję wymyślić, jak używać funkcji printf do drukowania na porcie szeregowym.

Moja obecna konfiguracja to kod wygenerowany przez STM32CubeMX i SystemWorkbench32 z płytą wykrywającą STM32F407 .

Widzę w stdio.h, że prototyp printf jest zdefiniowany jako:

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

Co to znaczy? Gdzie jest dokładna lokalizacja tej definicji funkcji? Jaki byłby ogólny sens odkrywania, jak używać tego rodzaju funkcji do generowania wyników?

Pierwsza metoda z tej strony działa na moim STM32F072.

http://www.openstm32.org/forumthread1055

Jak tam powiedziano

Sposób, w jaki działałem printf (i wszystkie inne zorientowane na konsolę funkcje stdio), polegał na tworzeniu niestandardowych implementacji funkcji We / Wy niskiego poziomu, takich jak _read()i _write().

Biblioteka GCC C wywołuje następujące funkcje w celu wykonywania operacji we / wy niskiego poziomu:

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)

Funkcje te są implementowane w bibliotece GCC C jako procedury pośredniczące z „słabym” łączeniem. Jeśli deklaracja którejkolwiek z powyższych funkcji pojawi się w twoim kodzie, twoja procedura zastępcza zastąpi deklarację w bibliotece i zostanie użyta zamiast domyślnej (niefunkcjonalnej) procedury.

Użyłem STM32CubeMX do skonfigurowania USART1 ( huart1) jako portu szeregowego. Ponieważ chciałem tylko printf(), potrzebowałem tylko wypełnić _write()funkcję, co zrobiłem w następujący sposób. Jest to konwencjonalnie zawarte w 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 jest makrem, prawdopodobnie zawierającym kilka interesujących dyrektyw, które mówią kompilatorowi, że powinien sprawdzić ciąg formatu pod kątem zgodności z printf i upewnić się, że argumenty printf są zgodne z ciągiem formatu.

Aby dowiedzieć się, jak korzystać z printf, sugeruję stronę podręcznika i trochę więcej googlowania. Napisz kilka prostych programów C korzystających z printf i uruchom je na komputerze, zanim spróbujesz przejść na korzystanie z niego na mikro.

Interesującym pytaniem będzie „gdzie idzie wydrukowany tekst?”. W systemie uniksowym idzie na „standardowe wyjście”, ale mikrokontroler nie ma czegoś takiego. Biblioteki debugowania CMSIS mogą wysyłać tekst printf do portu debugowania semihosting ramienia, tj. Do sesji gdb lub openocd, ale nie mam pojęcia, co zrobi SystemWorkbench32.

Jeśli nie pracujesz w debuggerze, bardziej sensowne może być użycie sprintf do sformatowania ciągów, które chcesz wydrukować, a następnie wysłanie tych ciągów przez port szeregowy lub na inny ekran, który mógł zostać podłączony.

Uwaga: printf i powiązany z nim kod są bardzo duże. To prawdopodobnie nie ma większego znaczenia na 32F407, ale jest to prawdziwy problem na urządzeniach z małą ilością flasha.

@ AdamHaun to wszystko, czego potrzebujesz, dzięki sprintf()czemu łatwo jest utworzyć ciąg, a następnie wysłać go. Ale jeśli naprawdę chcesz mieć własną printf()funkcję, to Variable Argument Functions (va_list) jest właściwą drogą.

Z va_listniestandardową funkcją drukowania wygląda następująco:

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

Przykład użycia:

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

Zwróć uwagę, że chociaż to rozwiązanie zapewnia wygodną funkcję, ale jest wolniejsze niż wysyłanie surowych danych lub używanie parzystości sprintf(). Myślę, że w przypadku dużych danych nie będzie to wystarczające.

Inną opcją i prawdopodobnie lepszą opcją jest użycie ST-Link, debuggera SWD wraz z narzędziem ST-Link. I użyj Printf za pośrednictwem przeglądarki SWO , oto instrukcja ST-Link Utility , odpowiednia część zaczyna się na stronie 31.

Printf przez SWO Viewer wyświetla dane printf wysłane z celu przez SWO. Pozwala wyświetlić przydatne informacje o działającym oprogramowaniu układowym.

printf () jest (zwykle) częścią standardowej biblioteki C. Jeśli twoja wersja biblioteki zawiera kod źródłowy, możesz tam znaleźć implementację.

Prawdopodobnie łatwiej byłoby użyć sprintf () do wygenerowania ciągu, a następnie użyć innej funkcji do wysłania ciągu przez port szeregowy. W ten sposób całe trudne formatowanie jest zrobione dla Ciebie i nie musisz hakować standardowej biblioteki.

Dla tych, którzy mają trudności, dodaj następujące informacje do 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);
}

Podłącz do portu COM za pomocą szpachli i powinieneś być dobry.

Jeśli chcesz mieć inne podejście i nie chcesz nadpisywać funkcji ani zadeklarować własnych, możesz po prostu użyć snprintfdo osiągnięcia tego samego celu. Ale to nie jest tak eleganckie.

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