{"id":589,"date":"2015-02-25T18:17:13","date_gmt":"2015-02-25T17:17:13","guid":{"rendered":"http:\/\/www.verelec.nl\/?page_id=589"},"modified":"2015-02-25T18:17:13","modified_gmt":"2015-02-25T17:17:13","slug":"getting-printf-to-work","status":"publish","type":"page","link":"https:\/\/www.verelec.nl\/?page_id=589","title":{"rendered":"Getting printf to work"},"content":{"rendered":"

Being spoiled by the fact that printf is supported on many platforms, it took some time to get this working. But it works. I copied a file called syscalls.c and incorporate it into my projects. this file will give an error from EM::Blocks compiler as _eBSS<\/strong> is not found by the linker. Both errors can be found in _sbrk(). I modified it a bit (borrowed from another source) and now it works. This is the code:<\/p>\n

[code language=”cpp”]
\n\/*
\n * newlib_stubs.c
\n *
\n * Created on: 2 Nov 2010
\n * Author: nanoage.co.uk
\n *\/
\n#include <errno.h>
\n#include <sys\/stat.h>
\n#include <sys\/times.h>
\n#include <sys\/unistd.h>
\n#include "stm32f10x_usart.h"<\/p>\n

#ifndef STDOUT_USART
\n#define STDOUT_USART 1
\n#endif<\/p>\n

#ifndef STDERR_USART
\n#define STDERR_USART 1
\n#endif<\/p>\n

#ifndef STDIN_USART
\n#define STDIN_USART 1
\n#endif<\/p>\n

#undef errno
\nextern int errno;<\/p>\n

\/*
\n environ
\n A pointer to a list of environment variables and their values.
\n For a minimal environment, this empty list is adequate:
\n *\/
\nchar *__env[1] = { 0 };
\nchar **environ = __env;<\/p>\n

int _write(int file, char *ptr, int len);<\/p>\n

void _exit(int status)
\n{
\n _write(1, "exit", 4);
\n while (1) {
\n ;
\n }
\n}<\/p>\n

int _close(int file)
\n{
\n return -1;
\n}
\n\/*
\n execve
\n Transfer control to a new process. Minimal implementation (for a system without processes):
\n *\/
\nint _execve(char *name, char **argv, char **env)
\n{
\n errno = ENOMEM;
\n return -1;
\n}
\n\/*
\n fork
\n Create a new process. Minimal implementation (for a system without processes):
\n *\/<\/p>\n

int _fork()
\n{
\n errno = EAGAIN;
\n return -1;
\n}
\n\/*
\n fstat
\n Status of an open file. For consistency with other minimal implementations in these examples,
\n all files are regarded as character special devices.
\n The `sys\/stat.h’ header file required is distributed in the `include’ subdirectory for this C library.
\n *\/
\nint _fstat(int file, struct stat *st)
\n{
\n st->st_mode = S_IFCHR;
\n return 0;
\n}<\/p>\n

\/*
\n getpid
\n Process-ID; this is sometimes used to generate strings unlikely to conflict with other processes. Minimal implementation, for a system without processes:
\n *\/<\/p>\n

int _getpid()
\n{
\n return 1;
\n}<\/p>\n

\/*
\n isatty
\n Query whether output stream is a terminal. For consistency with the other minimal implementations,
\n *\/
\nint _isatty(int file)
\n{
\n switch (file) {
\n case STDOUT_FILENO:
\n case STDERR_FILENO:
\n case STDIN_FILENO:
\n return 1;
\n default:
\n \/\/errno = ENOTTY;
\n errno = EBADF;
\n return 0;
\n }
\n}<\/p>\n

\/*
\n kill
\n Send a signal. Minimal implementation:
\n *\/
\nint _kill(int pid, int sig)
\n{
\n errno = EINVAL;
\n return (-1);
\n}<\/p>\n

\/*
\n link
\n Establish a new name for an existing file. Minimal implementation:
\n *\/<\/p>\n

int _link(char *old, char *new)
\n{
\n errno = EMLINK;
\n return -1;
\n}<\/p>\n

\/*
\n lseek
\n Set position in a file. Minimal implementation:
\n *\/
\nint _lseek(int file, int ptr, int dir)
\n{
\n return 0;
\n}<\/p>\n

\/*
\n sbrk
\n Increase program data space.
\n Malloc and related functions depend on this
\n *\/
\ncaddr_t _sbrk(int incr)
\n{
\n extern char end asm("end"); \/\/ Defined by the linker
\n static char *heap_end;
\n char *prev_heap_end;<\/p>\n

if (heap_end == 0) {
\n heap_end = &end;
\n }
\n prev_heap_end = heap_end;<\/p>\n

char * stack = (char*) __get_MSP();
\n if (heap_end + incr > stack) {
\n _write (STDERR_FILENO, "Heap and stack collision\\n", 25);
\n errno = ENOMEM;
\n return (caddr_t) -1;
\n \/\/abort ();
\n }<\/p>\n

heap_end += incr;
\n return (caddr_t) prev_heap_end;<\/p>\n

}<\/p>\n

\/*
\n read
\n Read a character to a file. `libc’ subroutines will use this system routine for input from all files, including stdin
\n Returns -1 on error or blocks until the number of characters have been read.
\n *\/<\/p>\n

int _read(int file, char *ptr, int len)
\n{
\n int n;
\n int num = 0;
\n switch (file) {
\n case STDIN_FILENO:
\n for (n = 0; n < len; n++) {
\n#if STDIN_USART == 1
\n while ((USART1->SR & USART_FLAG_RXNE) == (uint16_t)RESET) {}
\n char c = (char)(USART1->DR & (uint16_t)0x01FF);
\n#elif STDIN_USART == 2
\n while ((USART2->SR & USART_FLAG_RXNE) == (uint16_t) RESET) {}
\n char c = (char) (USART2->DR & (uint16_t) 0x01FF);
\n#elif STDIN_USART == 3
\n while ((USART3->SR & USART_FLAG_RXNE) == (uint16_t)RESET) {}
\n char c = (char)(USART3->DR & (uint16_t)0x01FF);
\n#endif
\n *ptr++ = c;
\n num++;
\n }
\n break;
\n default:
\n errno = EBADF;
\n return -1;
\n }
\n return num;
\n}<\/p>\n

\/*
\n stat
\n Status of a file (by name). Minimal implementation:
\n int _EXFUN(stat,( const char *__path, struct stat *__sbuf ));
\n *\/<\/p>\n

int _stat(const char *filepath, struct stat *st)
\n{
\n st->st_mode = S_IFCHR;
\n return 0;
\n}<\/p>\n

\/*
\n times
\n Timing information for current process. Minimal implementation:
\n *\/<\/p>\n

clock_t _times(struct tms *buf)
\n{
\n return -1;
\n}<\/p>\n

\/*
\n unlink
\n Remove a file’s directory entry. Minimal implementation:
\n *\/
\nint _unlink(char *name)
\n{
\n errno = ENOENT;
\n return -1;
\n}<\/p>\n

\/*
\n wait
\n Wait for a child process. Minimal implementation:
\n *\/
\nint _wait(int *status)
\n{
\n errno = ECHILD;
\n return -1;
\n}<\/p>\n

\/*
\n write
\n Write a character to a file. `libc’ subroutines will use this system routine for output to all files, including stdout
\n Returns -1 on error or number of bytes sent
\n *\/
\nint _write(int file, char *ptr, int len)
\n{
\n int n;
\n switch (file) {
\n case STDOUT_FILENO: \/*stdout*\/
\n for (n = 0; n < len; n++) {
\n#if STDOUT_USART == 1
\n while ((USART1->SR & USART_FLAG_TC) == (uint16_t)RESET) {}
\n USART1->DR = (*ptr++ & (uint16_t)0x01FF);
\n#elif STDOUT_USART == 2
\n while ((USART2->SR & USART_FLAG_TC) == (uint16_t) RESET) {
\n }
\n USART2->DR = (*ptr++ & (uint16_t) 0x01FF);
\n#elif STDOUT_USART == 3
\n while ((USART3->SR & USART_FLAG_TC) == (uint16_t)RESET) {}
\n USART3->DR = (*ptr++ & (uint16_t)0x01FF);
\n#endif
\n }
\n break;
\n case STDERR_FILENO: \/* stderr *\/
\n for (n = 0; n < len; n++) {
\n#if STDERR_USART == 1
\n while ((USART1->SR & USART_FLAG_TC) == (uint16_t)RESET) {}
\n USART1->DR = (*ptr++ & (uint16_t)0x01FF);
\n#elif STDERR_USART == 2
\n while ((USART2->SR & USART_FLAG_TC) == (uint16_t) RESET) {
\n }
\n USART2->DR = (*ptr++ & (uint16_t) 0x01FF);
\n#elif STDERR_USART == 3
\n while ((USART3->SR & USART_FLAG_TC) == (uint16_t)RESET) {}
\n USART3->DR = (*ptr++ & (uint16_t)0x01FF);
\n#endif
\n }
\n break;
\n default:
\n errno = EBADF;
\n return -1;
\n }
\n return len;
\n}<\/p>\n

\/**
\n * @brief initialize usart1
\n * @name usart1_init
\n * initializes the UART1 port
\n *\/
\nvoid usart1_init(){
\n GPIO_InitTypeDef \t\tGPIO_InitStructure;\t\t\t\/\/ create a GPIO init structure
\n USART_InitTypeDef \t\tUSART_InitStructure;\t\t\/\/ create a USART init structure
\n USART_ClockInitTypeDef USART_ClockInitStructure;\t\/\/ create a CLOCK init structure
\n \/\/
\n \/\/ since we are connecting an on-chip peripheral (USART) to the IO pin, we must
\n \/\/ configure it to enable alternate IO functions (AFIO). But we must enable the clock first
\n \/\/ thus to enable USART1 we must:
\n \/\/ – enable the peripheral
\n \/\/ – enable GPIOA as our pins are connected to GPIOA
\n \/\/ – enable alternate IO functions to connect USART1 to GPIOA
\n \/\/
\n RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
\n \/\/
\n \/\/Configure USART1 Tx (PA.09) as alternate function push-pull
\n \/\/
\n GPIO_InitStructure.GPIO_Pin \t= GPIO_Pin_9;
\n GPIO_InitStructure.GPIO_Mode \t= GPIO_Mode_AF_PP;
\n GPIO_InitStructure.GPIO_Speed \t= GPIO_Speed_50MHz;
\n GPIO_Init(GPIOA, &GPIO_InitStructure);
\n \/\/
\n \/\/Configure USART1 Rx (PA.10) as input floating
\n \/\/
\n GPIO_InitStructure.GPIO_Pin \t= GPIO_Pin_10;
\n GPIO_InitStructure.GPIO_Mode \t= GPIO_Mode_IN_FLOATING;
\n GPIO_Init(GPIOA, &GPIO_InitStructure);
\n \/\/
\n \/\/ initialize USART Clock
\n \/\/
\n USART_ClockStructInit(&USART_ClockInitStructure);
\n USART_ClockInit(USART1, &USART_ClockInitStructure);
\n \/\/
\n \/\/ set defaults in USART init structure
\n \/\/
\n USART_StructInit(&USART_InitStructure);
\n \/\/
\n \/\/ Configure USART1 basic and asynchronous parameters
\n \/\/
\n USART_InitStructure.USART_BaudRate=921600;\t\t\t\t\/\/ just change the baud rate in this case
\n \/\/
\n \/\/ initialize the USART
\n \/\/
\n USART_Init(USART1, &USART_InitStructure);
\n \/\/
\n \/\/Enable USART1
\n \/\/
\n USART_Cmd(USART1, ENABLE);
\n}
\n\/** @brief Delay function
\n * @name Delay(volatile uint32_t ncCount)
\n * @param nCount delay number of counts. Very unclear what actually
\n * @return none
\n *
\n *\/
\nvoid Delay(volatile uint32_t nCount)
\n{
\n for (; nCount != 0; nCount–);
\n}<\/p>\n

[\/code]<\/p>\n

I added 2 extra functions for my purpose and experimenting. Just put the code in a file and add the file (.c) to the project. Now printf will work outputting stdin, stdout and stderr to the serial monitor or terminal program. Now we are not there yet. floating point is usually omitted from a standard binary. A simple parameter in the linker will solve this:<\/p>\n