riot-ci/RIOT
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cpu/nrf51822: added interrupt mode to UART driver

Browse Source
This commit is contained in:
Hauke Petersen 2014-08-11 13:19:15 +02:00 committed by Hauke Petersen
parent 4a5e794f32
commit 2bab8aed2e
1 changed files with 115 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
cpu/nrf51822/periph/uart.c
View File

@ -23,13 +23,12 @@
#include <stdint.h> #include <stdint.h>
#include "cpu.h" #include "cpu.h"
#include "thread.h"
#include "sched.h"
#include "periph_conf.h" #include "periph_conf.h"
#include "periph/uart.h" #include "periph/uart.h"
#include "board.h" #include "board.h"
#define ENABLE_DEBUG (0)
#include "debug.h"
/* guard file in case no UART device was specified */ /* guard file in case no UART device was specified */
#if UART_NUMOF #if UART_NUMOF
@ -42,10 +41,13 @@ typedef struct {
void *arg; void *arg;
} uart_conf_t; } uart_conf_t;
/**
* @brief Data structure holding the callbacks and argument for each UART device
*/
static uart_conf_t uart_config;
/** /**
* @brief Allocate memory to store the callback functions. * @brief Allocate memory to store the callback functions.
*
* TODO: this function needs to be implemented
*/ */
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, uart_tx_cb_t tx_cb, void *arg) int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, uart_tx_cb_t tx_cb, void *arg)
{ {
@ -58,189 +60,184 @@ int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, uart_tx_cb_t t
return res; return res;
} }
return -1; /* remember callback addresses and argument */
uart_config.rx_cb = rx_cb;
uart_config.tx_cb = tx_cb;
uart_config.arg = arg;
/* enable global and receiving interrupt */
NVIC_SetPriority(UART0_IRQn, UART_IRQ_PRIO);
NVIC_EnableIRQ(UART0_IRQn);
NRF_UART0->INTENSET = UART_INTENSET_RXDRDY_Msk;
return 0;
} }
int uart_init_blocking(uart_t uart, uint32_t baudrate) int uart_init_blocking(uart_t uart, uint32_t baudrate)
{ {
uint32_t baudrate_real; /* the NRF only supports 1 UART device, so we don't need a switch statement here */
if (uart != UART_0) {
return -1;
}
/* power on the UART device */
NRF_UART0->POWER = 1;
/* reset configuration registers */
NRF_UART0->CONFIG = 0;
/* configure RX/TX pin modes */
NRF_GPIO->DIRSET = (1 << UART_PIN_TX);
NRF_GPIO->DIRCLR = (1 << UART_PIN_RX);
/* configure UART pins to use */
NRF_UART0->PSELTXD = UART_PIN_TX;
NRF_UART0->PSELRXD = UART_PIN_RX;
/* enable HW-flow control if defined */
#if UART_HWFLOWCTRL
/* set pin mode for RTS and CTS pins */
NRF_GPIO->DIRSET = (1 << UART_PIN_RTS);
NRF_GPIO->DIRSET = (1 << UART_PIN_CTS);
/* configure RTS and CTS pins to use */
NRF_UART0->PSELRTS = UART_PIN_RTS;
NRF_UART0->PSELCTS = UART_PIN_CTS;
NRF_UART0->CONFIG |= UART_CONFIG_HWFC_Msk; /* enable HW flow control */
#else
NRF_UART0->PSELRTS = 0xffffffff; /* pin disconnected */
NRF_UART0->PSELCTS = 0xffffffff; /* pin disconnected */
#endif
/* select baudrate */
switch (baudrate) { switch (baudrate) {
case 1200: case 1200:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud1200; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud1200;
break; break;
case 2400: case 2400:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud2400; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud2400;
break; break;
case 4800: case 4800:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud4800; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud4800;
break; break;
case 9600: case 9600:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud9600; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud9600;
break; break;
case 14400: case 14400:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud14400; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud14400;
break; break;
case 19200: case 19200:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud19200; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud19200;
break; break;
case 28800: case 28800:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud28800; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud28800;
break; break;
case 38400: case 38400:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud38400; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud38400;
break; break;
case 57600: case 57600:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud57600; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud57600;
break; break;
case 76800: case 76800:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud76800; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud76800;
break; break;
case 115200: case 115200:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud115200; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud115200;
break; break;
case 230400: case 230400:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud230400; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud230400;
break; break;
case 250000: case 250000:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud250000; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud250000;
break; break;
case 460800: case 460800:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud460800; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud460800;
break; break;
case 921600: case 921600:
baudrate_real = UART_BAUDRATE_BAUDRATE_Baud921600; NRF_UART0->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud921600;
break; break;
default: default:
return -1; return -1;
} }
switch (uart) { /* enable the UART device */
#if UART_0_EN NRF_UART0->ENABLE = UART_ENABLE_ENABLE_Enabled;
case UART_0: /* enable TX and RX */
/* power on UART device */ NRF_UART0->TASKS_STARTTX = 1;
UART_0_DEV->POWER = 1; NRF_UART0->TASKS_STARTRX = 1;
/* reset configuration registers */
UART_0_DEV->CONFIG = 0;
/* select baudrate */
UART_0_DEV->BAUDRATE = baudrate_real;
/* configure RX/TX pin modes */
NRF_GPIO->DIRSET = (1 << UART_0_PIN_TX);
NRF_GPIO->DIRCLR = (1 << UART_0_PIN_RX);
/* configure UART pins to use */
UART_0_DEV->PSELTXD = UART_0_PIN_TX;
UART_0_DEV->PSELRXD = UART_0_PIN_RX;
/* enable hw-flow control if defined */
#if UART_0_HWFLOWCTRL
/* set pin mode for RTS and CTS pins */
NRF_GPIO->DIRSET = (1 << UART_0_PIN_RTS);
NRF_GPIO->DIRSET = (1 << UART_0_PIN_CTS);
/* configure RTS and CTS pins to use */
UART_0_DEV->PSELRTS = UART_0_PIN_RTS;
UART_0_DEV->PSELCTS = UART_0_PIN_CTS;
UART_0_DEV->CONFIG |= 1; /* enable HW flow control */
#else
UART_0_DEV->PSELRTS = 0xffffffff; /* pin disconnected */
UART_0_DEV->PSELCTS = 0xffffffff; /* pin disconnected */
#endif
/* enable the UART device */
UART_0_DEV->ENABLE = UART_ENABLE_ENABLE_Enabled;
/* enable TX and RX */
UART_0_DEV->TASKS_STARTTX = 1;
UART_0_DEV->TASKS_STARTRX = 1;
break;
#endif
}
return 0; return 0;
} }
void uart_tx_begin(uart_t uart) void uart_tx_begin(uart_t uart)
{ {
/* TODO: to be implemented */ if (uart == UART_0) {
} if (uart_config.tx_cb(uart_config.arg) != 0) {
NRF_UART0->INTENSET = UART_INTENSET_TXDRDY_Msk;
void uart_tx_end(uart_t uart) }
{ }
/* TODO: to be implemented */
} }
int uart_write(uart_t uart, char data) int uart_write(uart_t uart, char data)
{ {
switch (uart) { if (uart == UART_0) {
case UART_0: NRF_UART0->TXD = (uint8_t)data;
UART_0_DEV->TXD = (uint8_t)data; NRF_UART0->EVENTS_TXDRDY = 0;
break; return 1;
} }
return 0;
return 1;
} }
int uart_read_blocking(uart_t uart, char *data) int uart_read_blocking(uart_t uart, char *data)
{ {
switch (uart) { if (uart == UART_0) {
case UART_0: /* wait for until data was received (RXDRDY == 1) */
DEBUG("READING CHAR\n"); while (NRF_UART0->EVENTS_RXDRDY != 1);
/* wait for until data was received (RXDRDY == 1) */ /* reset RXDRDY flag */
while (UART_0_DEV->EVENTS_RXDRDY != 1); NRF_UART0->EVENTS_RXDRDY = 0;
DEBUG("RXDRDY was set\n"); /* read new byte from receive data register */
/* reset RXDRDY flag */ *data = (char)(NRF_UART0->RXD & 0xff);
UART_0_DEV->EVENTS_RXDRDY = 0; return 1;
/* read new byte from receive data register */
DEBUG("Reading data\n");
*data = (char)(UART_0_DEV->RXD & 0xff);
break;
} }
return 0;
return 1;
} }
int uart_write_blocking(uart_t uart, char data) int uart_write_blocking(uart_t uart, char data)
{ {
switch (uart) { if (uart == UART_0) {
case UART_0: /* write data into transmit register */
/* write data into transmit register */ NRF_UART0->TXD = (uint8_t)data;
UART_0_DEV->TXD = (uint8_t)data; /* wait for any transmission to be done */
/* wait for any transmission to be done */ while (NRF_UART0->EVENTS_TXDRDY == 0);
while (UART_0_DEV->EVENTS_TXDRDY == 0); /* reset ready flag */
/* reset ready flag */ NRF_UART0->EVENTS_TXDRDY = 0;
UART_0_DEV->EVENTS_TXDRDY = 0; return 1;
break;
} }
return 0;
return 1;
} }
void uart_poweron(uart_t uart) void uart_poweron(uart_t uart)
{ {
switch (uart) { if (uart == UART_0) {
#if UART_0_EN NRF_UART0->POWER = 1;
case UART_0:
UART_0_DEV->POWER = 1;
break;
#endif
default:
return;
} }
} }
void uart_poweroff(uart_t uart) void uart_poweroff(uart_t uart)
{ {
switch (uart) { if (uart == UART_0) {
#if UART_0_EN NRF_UART0->POWER = 0;
case UART_0: }
UART_0_DEV->POWER = 0; }
break;
#endif void isr_uart0(void)
default: {
return; if (NRF_UART0->EVENTS_RXDRDY == 1) {
NRF_UART0->EVENTS_RXDRDY = 0;
char byte = (char)(NRF_UART0->RXD & 0xff);
uart_config.rx_cb(uart_config.arg, byte);
}
if (NRF_UART0->EVENTS_TXDRDY == 1) {
NRF_UART0->EVENTS_TXDRDY = 0;
if (uart_config.tx_cb(uart_config.arg) == 0) {
NRF_UART0->INTENCLR = UART_INTENSET_TXDRDY_Msk;
}
}
if (sched_context_switch_request) {
thread_yield();
} }
} }