kingkevin
/
spark_abacus
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

use macros to derivate USART addresses based on ID

This commit is contained in:
King Kévin 2016-09-04 18:56:49 +02:00
parent 63f07be7b5
commit 868283a8e7
3 changed files with 61 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
global.h
View File

@ -36,11 +36,11 @@
#define RCC_GPIO(x) CAT2(RCC_GPIO,x)
/** get TIM based on TIM identifier */
#define TIM(x) CAT2(TIM,x)
/** get RCC for timer based on TIM */
/** get RCC for timer based on TIM identifier */
#define RCC_TIM(x) CAT2(RCC_TIM,x)
/** get NVIC IRQ for timer base on TIM */
/** get NVIC IRQ for timer base on TIM identifier */
#define NVIC_TIM_IRQ(x) CAT3(NVIC_TIM,x,_IRQ)
/** get interrupt service routine for timer base on TIM */
/** get interrupt service routine for timer base on TIM identifier */
#define TIM_ISR(x) CAT3(tim,x,_isr)
/** get external interrupt based on pin identifier */
#define EXTI(x) CAT2(EXTI,x)
@ -70,6 +70,28 @@
#define exti13_isr exti15_10_isr /**< isr for line 15 to 10 for pin 13 */
#define exti14_isr exti15_10_isr /**< isr for line 15 to 10 for pin 14 */
#define exti15_isr exti15_10_isr /**< isr for line 15 to 10 for pin 15 */
/** get USART based on USART identifier */
#define USART(x) CAT2(USART,x)
/** get RCC for USART based on USART identifier */
#define USART_RCC(x) CAT2(RCC_USART,x)
/** get NVIC IRQ for USART based on USART identifier */
#define USART_IRQ(x) CAT3(NVIC_USART,x,_IRQ)
/** get interrupt service routine for USART based on USART identifier */
#define USART_ISR(x) CAT3(usart,x,_isr)
/** get port for USART based on USART identifier */
#define USART_PORT(x) CAT2(USART_PORT,x)
#define USART_PORT1 GPIOA
#define USART_PORT2 GPIOA
#define USART_PORT3 GPIOB
/** get RCC for USART port based on USART identifier */
#define USART_PORT_RCC(x) CAT2(RCC_USART_PORT,x)
#define RCC_USART_PORT1 RCC_GPIOA
#define RCC_USART_PORT2 RCC_GPIOA
#define RCC_USART_PORT3 RCC_GPIOB
/** get transmit pin for USART based on USART identifier */
#define USART_PIN_TX(x) CAT3(GPIO_USART,x,_TX)
/** get receive pin for USART based on USART identifier */
#define USART_PIN_RX(x) CAT3(GPIO_USART,x,_RX)
/** @} */
/** @defgroup board_led board LED GPIO

76
lib/usart.c
View File

@ -32,18 +32,12 @@
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
#include "usart.h" // USART header and definitions
#include "global.h" // common methods
/** @defgroup usart USART peripheral used for UART communication
* @{
*/
#define USART USART1 /**< USART peripheral */
#define USART_RCC RCC_USART1 /**< USART peripheral clock */
#define USART_IRQ NVIC_USART1_IRQ /**< USART peripheral interrupt signal */
#define USART_ISR usart1_isr /**< USART interrupt service routine */
#define USART_PORT GPIOA /**< USART port */
#define USART_PORT_RCC RCC_GPIOA /**< USART port peripheral clock */
#define USART_PIN_TX GPIO_USART1_TX /**< USART transmit pin (PA9) */
#define USART_PIN_RX GPIO_USART1_RX /**< USART receive pin (PA10) */
#define USART_ID 1 /**< USART peripheral */
/** @} */
#define USART_BAUDRATE 115200 /**< serial baudrate, in bits per second (with 8N1 8 bits, no parity bit, 1 stop bit settings) */
@ -55,41 +49,41 @@ static volatile uint8_t rx_used = 0; /**< how much data has been received and no
static uint8_t tx_buffer[USART_BUFFER] = {0}; /**< ring buffer for data to transmit */
static volatile uint8_t tx_i = 0; /**< current position if transmitted data */
static volatile uint8_t tx_used = 0; /**< how much data needs to be transmitted */
volatile uint8_t usart_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
volatile bool usart_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
void usart_setup(void)
{
/* enable USART I/O peripheral */
rcc_periph_clock_enable(USART_PORT_RCC); // enable clock for USART port peripheral
rcc_periph_clock_enable(USART_RCC); // enable clock for USART peripheral
gpio_set_mode(USART_PORT, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, USART_PIN_TX); // setup GPIO pin USART transmit
gpio_set_mode(USART_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, USART_PIN_RX); // setup GPIO pin USART receive
gpio_set(USART_PORT, USART_PIN_RX); // pull up to avoid noise when not connected
rcc_periph_clock_enable(USART_PORT_RCC(USART_ID)); // enable clock for USART port peripheral
rcc_periph_clock_enable(USART_RCC(USART_ID)); // enable clock for USART peripheral
gpio_set_mode(USART_PORT(USART_ID), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, USART_PIN_TX(USART_ID)); // setup GPIO pin USART transmit
gpio_set_mode(USART_PORT(USART_ID), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, USART_PIN_RX(USART_ID)); // setup GPIO pin USART receive
gpio_set(USART_PORT(USART_ID), USART_PIN_RX(USART_ID)); // pull up to avoid noise when not connected
/* setup USART parameters */
usart_set_baudrate(USART, USART_BAUDRATE);
usart_set_databits(USART, 8);
usart_set_stopbits(USART, USART_STOPBITS_1);
usart_set_mode(USART, USART_MODE_TX_RX);
usart_set_parity(USART, USART_PARITY_NONE);
usart_set_flow_control(USART, USART_FLOWCONTROL_NONE);
usart_set_baudrate(USART(USART_ID), USART_BAUDRATE);
usart_set_databits(USART(USART_ID), 8);
usart_set_stopbits(USART(USART_ID), USART_STOPBITS_1);
usart_set_mode(USART(USART_ID), USART_MODE_TX_RX);
usart_set_parity(USART(USART_ID), USART_PARITY_NONE);
usart_set_flow_control(USART(USART_ID), USART_FLOWCONTROL_NONE);
nvic_enable_irq(USART_IRQ); // enable the USART interrupt
usart_enable_rx_interrupt(USART); // enable receive interrupt
usart_enable(USART); // enable USART
nvic_enable_irq(USART_IRQ(USART_ID)); // enable the USART interrupt
usart_enable_rx_interrupt(USART(USART_ID)); // enable receive interrupt
usart_enable(USART(USART_ID)); // enable USART
/* reset buffer states */
tx_i = 0;
tx_used = 0;
rx_i = 0;
rx_used = 0;
usart_received = 0;
usart_received = false;
}
void usart_putchar_blocking(char c)
{
usart_flush(); // empty buffer first
usart_send_blocking(USART, c); // send character
usart_send_blocking(USART(USART_ID), c); // send character
}
void usart_flush(void)
@ -97,55 +91,55 @@ void usart_flush(void)
while (tx_used) { // idle until buffer is empty
__WFI(); // sleep until interrupt
}
usart_wait_send_ready(USART); // wait until transmit register is empty (transmission might not be complete)
usart_wait_send_ready(USART(USART_ID)); // wait until transmit register is empty (transmission might not be complete)
}
char usart_getchar(void)
{
while (!rx_used) { // idle until data is available
__WFI(); // sleep until interrupt;
__WFI(); // sleep until interrupt
}
char to_return = rx_buffer[rx_i]; // get the next available character
usart_disable_rx_interrupt(USART); // disable receive interrupt to prevent index corruption
usart_disable_rx_interrupt(USART(USART_ID)); // disable receive interrupt to prevent index corruption
rx_i = (rx_i+1)%sizeof(rx_buffer); // update used buffer
rx_used--; // update used buffer
usart_received = rx_used; // update available data
usart_enable_rx_interrupt(USART); // enable receive interrupt
usart_received = (rx_used!=0); // update available data
usart_enable_rx_interrupt(USART(USART_ID)); // enable receive interrupt
return to_return;
}
void usart_putchar_nonblocking(char c)
{
while (tx_used>=sizeof(tx_buffer)) { // idle until buffer has some space
usart_enable_tx_interrupt(USART); // enable transmit interrupt
usart_enable_tx_interrupt(USART(USART_ID)); // enable transmit interrupt
__WFI(); // sleep until something happened
}
usart_disable_tx_interrupt(USART); // disable transmit interrupt to prevent index corruption
usart_disable_tx_interrupt(USART(USART_ID)); // disable transmit interrupt to prevent index corruption
tx_buffer[(tx_i+tx_used)%sizeof(tx_buffer)] = c; // put character in buffer
tx_used++; // update used buffer
usart_enable_tx_interrupt(USART); // enable transmit interrupt
usart_enable_tx_interrupt(USART(USART_ID)); // enable transmit interrupt
}
/** USART interrupt service routine called when data has been transmitted or received */
void USART_ISR(void)
void USART_ISR(USART_ID)(void)
{
if (usart_get_interrupt_source(USART, USART_SR_TXE)) { // data has been transmitted
if (usart_get_interrupt_source(USART(USART_ID), USART_SR_TXE)) { // data has been transmitted
if (!tx_used) { // no data in the buffer to transmit
usart_disable_tx_interrupt(USART); // disable transmit interrupt
usart_disable_tx_interrupt(USART(USART_ID)); // disable transmit interrupt
} else {
usart_send(USART,tx_buffer[tx_i]); // put data in transmit register
usart_send(USART(USART_ID),tx_buffer[tx_i]); // put data in transmit register
tx_i = (tx_i+1)%sizeof(rx_buffer); // update location on buffer
tx_used--; // update used size
}
}
if (usart_get_interrupt_source(USART, USART_SR_RXNE)) { // data has been received
if (usart_get_interrupt_source(USART(USART_ID), USART_SR_RXNE)) { // data has been received
// only save data if there is space in the buffer
if (rx_used>=sizeof(rx_buffer)) {
usart_recv(USART); // read to clear interrupt
usart_recv(USART(USART_ID)); // read to clear interrupt
} else {
rx_buffer[(rx_i+rx_used)%sizeof(rx_buffer)] = usart_recv(USART); // put character in buffer
rx_buffer[(rx_i+rx_used)%sizeof(rx_buffer)] = usart_recv(USART(USART_ID)); // put character in buffer
rx_used++; // update used buffer
usart_received = rx_used; // update available data
usart_received = (rx_used!=0); // update available data
}
}
}

2
lib/usart.h
View File

@ -23,7 +23,7 @@
/** transmit and receive buffer sizes */
#define USART_BUFFER 128
/** how many bytes available in the received buffer since last read */
extern volatile uint8_t usart_received;
extern volatile bool usart_received;
/** setup USART peripheral */
void usart_setup(void);