Wireless Printf using BLE UART

RE: Wireless Printf using BLE UART

flodis — Mon, 04 Sep 2017 18:01:59 GMT

You can inhibit the already existing nRF redirection module retarget.c by setting "RETARGET_ENABLED 0" in the sdk_config.h file.

If you then make a copy of retarget.c named my_retarget.c in your project source and enable that module using som other module name like "MY_RETARGET_ENABLED 1" you can redirect as you like.

In my case I included a 'my_retarget.h' header file in the "my_retarget.c" and "main.c" with an added reference to the "ble_nus.h" library and a redirection flag and a pointer to the ble_nus_t structure to use.

Header file "my_retarget.h":

#include "ble_nus.h"
extern bool use_ble_prn;       //* Enable to use printf over ble set 'use_ble_prn' true prior to a call to printf() */
extern ble_nus_t * p_nus;      //* Pointer to a static 'ble_nus_t' structure*/

In the "my_retarget.c" I added som more code to the _write() function:

int _write(int file, const char * p_char, int len)
{
    int i;

    UNUSED_PARAMETER(file);

	if (!use_ble_prn)
	{
		//Print to hardware UART
		for (i = 0; i < len; i++)
		{
			UNUSED_VARIABLE(app_uart_put(*p_char++));
		}	

	}
	else
	{
		//Print to Bluetooth UART
		if (p_nus != NULL)
		{
			ble_nus_string_send(p_nus, (uint8_t *) p_char, len);			
		}

		//Disable redirection after each print
		use_ble_prn = false;
	}

    return len;
}

The pointer p_nus was initialized in the main.c on the line next after the ble_nus_t structure

static ble_nus_t                        m_nus;                                      /**< Structure to identify the Nordic UART Service. */
ble_nus_t *								p_nus = &m_nus;                             /**< Ponter to UART structure used by external retarget> */

More generic approach - implementing a callback function:

A more generic aproach would be a writeCallback() function in the my_retarget.c file. In that case you avoid references to UART devices and can do whatever you like in the callback residing in your main module.

Declared in the my_retarget.h as

extern volatile int (*_writeCallback)(int, const char *, int);

In the my_retarget.c:

volatile int(*_writeCallback)(int, const char *, int) = NULL;

..and callback declared in main.c as:

//Printf callback function
volatile int printfCallback(int file, const char * p_char, int len)
{
	//Send printf data to ble UART
	ble_nus_string_send(&m_nus, (uint8_t *) p_char, len);
	return len;	
}

..and to init the callback from main:

void printf_redirect_init()
{
	_writeCallback = printfCallback;
}

The my_redirect.c may contain a _write() function like this:

int _write(int file, const char * p_char, int len)
{
    int i;

    UNUSED_PARAMETER(file);


	if (use_ble_prn)
	{
		//Disable redirection after each print
		use_ble_prn = false;	

		if (_writeCallback != NULL)
		{
			//Invoke callback function
			return _writeCallback(file, p_char, len);		
		}
	
	}	
	else
	{
		//Print to hardware UART
		for (i = 0; i < len; i++)
		{
			UNUSED_VARIABLE(app_uart_put(*p_char++));
		}	

	}


    return len;
}

At least some ideas to irritate or inspire.

RE: Wireless Printf using BLE UART

Nick — Thu, 24 Jul 2014 23:03:06 GMT

The solution Nick outlined works. I tested by replacing

void nus_data_handler(ble_nus_t * p_nus, uint8_t * p_data, uint16_t length)

with

void nus_data_handler(ble_nus_t * p_nus, uint8_t * p_data, uint16_t length)
{
	if(p_data[0] == 'a')
	{
		ble_nus_send_string(&m_nus, "Using BLE NUS", 13);
	}
	else if(p_data[0] == 'b')
	{
		printf("Using Printf %d",1234);
	}
}

When i send 'a' from my Android App it returns "Using BLE NUS"

When i send 'b' from my Android App it returns "Using Printf 1234"

Unfortunately floats dont work even with

CFLAGS = -O0 -g
LDFLAGS = -u _printf_float

in my Makefile.

RE: Wireless Printf using BLE UART

cocoa — Thu, 24 Jul 2014 13:14:50 GMT

Hi Nick, this is very usefull code. I think Nordic should ask to you about how adopt it in its SDK.

-c

RE: Wireless Printf using BLE UART

Nick — Thu, 24 Jul 2014 01:09:07 GMT

You need to route the _write system call to use the ble_nus_send_string() function. I've done this before with GCC for a Cortex-M4 device (STM32F4).

You need to add new source file to your project called "syscalls.c" (code below is untested, but it should give you a pretty good idea on how it's done).

EDIT: As in the printf-gcc example you linked, you probably only have to supply the _write() function. However, I've provided the entire syscalls.c file below for completeness.

#include <sys/stat.h>
#include <stdint.h>
#include "app_error.h"
#include "ble_nus.h"

extern ble_nus_t m_nus;

int __errno;

int _close(int file) {
	return 0;
}

int _fstat(int file, struct stat *st) {
	return 0;
}

int _isatty(int file) {
	return 1;
}

int _lseek(int file, int ptr, int dir) {
	return 0;
}

int _open(const char *name, int flags, int mode) {
	return -1;
}

int _read(int file, char *ptr, int len) {
	if (file != 0) {
		return 0;
	}

    // Add read implementation here if required

	return 1;
}

// Register name faking - works in collusion with the linker. 
register char * stack_ptr asm ("sp");

caddr_t _sbrk_r (struct _reent *r, int incr) {
	extern char   end asm ("end"); // Defined by the linker.
	static char * heap_end;
	char *        prev_heap_end;

	if (heap_end == NULL)
		heap_end = & end;

	prev_heap_end = heap_end;

	if (heap_end + incr > stack_ptr) {
		return (caddr_t) -1;
	}

	heap_end += incr;

	return (caddr_t) prev_heap_end;
}

int _write(int file, char *ptr, int len) {
    uint32_t err_code = ble_nus_send_string(&m_nus, ptr, len);
	APP_ERROR_CHECK(err_code);
    return len;
}

RE: Wireless Printf using BLE UART

Nick — Wed, 23 Jul 2014 17:23:28 GMT

Hi Cocoa, currently I am using a modified ble_app_uart which can communicate over ble uart both ways however it has the limitation of having to manually convert floating point numbers to strings. My goal is to use printf so i can access all the automatic text formatting.

I have edited the main post in case this was not clear.

RE: Wireless Printf using BLE UART

cocoa — Wed, 23 Jul 2014 08:03:30 GMT

Hi,

see ble_app_uart , is an uart over ble , probably it fits your needs.

Path : /sdk/nrf51_sdk_v6_0_0_43681/nrf51822/Board/pca10001/s110/experimental/ble_app_uart

-c