mbed official
mbed library sources. Supersedes mbed-src.
Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more
Diff: targets/TARGET_STM/TARGET_STM32F0/serial_device.c
- Revision:
- 187:0387e8f68319
- Parent:
- 186:707f6e361f3e
- Child:
- 189:f392fc9709a3
--- a/targets/TARGET_STM/TARGET_STM32F0/serial_device.c Fri Jun 22 16:45:37 2018 +0100
+++ b/targets/TARGET_STM/TARGET_STM32F0/serial_device.c Thu Sep 06 13:40:20 2018 +0100
@@ -33,13 +33,13 @@
#include "serial_api_hal.h"
#if defined (TARGET_STM32F031K6)
- #define UART_NUM (1)
+#define UART_NUM (1)
#elif defined (TARGET_STM32F030R8) || defined (TARGET_STM32F051R8) || defined (TARGET_STM32F042K6)
- #define UART_NUM (2)
+#define UART_NUM (2)
#elif defined (TARGET_STM32F070RB) || defined (TARGET_STM32F072RB)
- #define UART_NUM (4)
+#define UART_NUM (4)
#else
- #define UART_NUM (8) // max value (TARGET_STM32F091RC)
+#define UART_NUM (8) // max value (TARGET_STM32F091RC)
#endif
uint32_t serial_irq_ids[UART_NUM] = {0};
@@ -59,7 +59,7 @@
int8_t id = get_uart_index(uart_name);
if (id >= 0) {
- UART_HandleTypeDef * huart = &uart_handlers[id];
+ UART_HandleTypeDef *huart = &uart_handlers[id];
if (serial_irq_ids[id] != 0) {
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_TXE) != RESET) {
@@ -100,45 +100,45 @@
{
#if defined(TARGET_STM32F091RC)
#if defined(USART3_BASE)
- if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART3) != RESET) {
- uart_irq(UART_3);
- }
+ if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART3) != RESET) {
+ uart_irq(UART_3);
+ }
#endif
#if defined(USART4_BASE)
- if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART4) != RESET) {
- uart_irq(UART_4);
- }
+ if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART4) != RESET) {
+ uart_irq(UART_4);
+ }
#endif
#if defined(USART5_BASE)
- if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART5) != RESET) {
- uart_irq(UART_5);
- }
+ if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART5) != RESET) {
+ uart_irq(UART_5);
+ }
#endif
#if defined(USART6_BASE)
- if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART6) != RESET) {
- uart_irq(UART_6);
- }
+ if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART6) != RESET) {
+ uart_irq(UART_6);
+ }
#endif
#if defined(USART7_BASE)
- if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART7) != RESET) {
- uart_irq(UART_7);
- }
+ if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART7) != RESET) {
+ uart_irq(UART_7);
+ }
#endif
#if defined(USART8_BASE)
- if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART8) != RESET) {
- uart_irq(UART_8);
- }
+ if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART8) != RESET) {
+ uart_irq(UART_8);
+ }
#endif
#else // TARGET_STM32F070RB, TARGET_STM32F072RB
#if defined(USART3_BASE)
- if (USART3->ISR & (UART_FLAG_TXE | UART_FLAG_RXNE | UART_FLAG_ORE)) {
- uart_irq(UART_3);
- }
+ if (USART3->ISR & (UART_FLAG_TXE | UART_FLAG_RXNE | UART_FLAG_ORE)) {
+ uart_irq(UART_3);
+ }
#endif
#if defined(USART4_BASE)
- if (USART4->ISR & (UART_FLAG_TXE | UART_FLAG_RXNE | UART_FLAG_ORE)) {
- uart_irq(UART_4);
- }
+ if (USART4->ISR & (UART_FLAG_TXE | UART_FLAG_RXNE | UART_FLAG_ORE)) {
+ uart_irq(UART_4);
+ }
#endif
#endif
}
@@ -146,7 +146,7 @@
void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id)
{
struct serial_s *obj_s = SERIAL_S(obj);
-
+
irq_handler = handler;
serial_irq_ids[obj_s->index] = id;
}
@@ -297,7 +297,7 @@
* LOCAL HELPER FUNCTIONS
******************************************************************************/
-/**
+/**
* Configure the TX buffer for an asynchronous write serial transaction
*
* @param obj The serial object.
@@ -317,7 +317,7 @@
obj->tx_buff.length = tx_length;
obj->tx_buff.pos = 0;
}
-
+
/**
* Configure the RX buffer for an asynchronous write serial transaction
*
@@ -339,7 +339,7 @@
obj->rx_buff.pos = 0;
}
-/**
+/**
* Configure events
*
* @param obj The serial object
@@ -347,9 +347,9 @@
* @param enable Set to non-zero to enable events, or zero to disable them
*/
static void serial_enable_event(serial_t *obj, int event, uint8_t enable)
-{
+{
struct serial_s *obj_s = SERIAL_S(obj);
-
+
// Shouldn't have to enable interrupt here, just need to keep track of the requested events.
if (enable) {
obj_s->events |= event;
@@ -439,7 +439,7 @@
* MBED API FUNCTIONS
******************************************************************************/
-/**
+/**
* Begin asynchronous TX transfer. The used buffer is specified in the serial
* object, tx_buff
*
@@ -453,28 +453,28 @@
* @return Returns number of data transfered, or 0 otherwise
*/
int serial_tx_asynch(serial_t *obj, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
-{
+{
// TODO: DMA usage is currently ignored
(void) hint;
-
+
// Check buffer is ok
- MBED_ASSERT(tx != (void*)0);
+ MBED_ASSERT(tx != (void *)0);
MBED_ASSERT(tx_width == 8); // support only 8b width
-
+
struct serial_s *obj_s = SERIAL_S(obj);
- UART_HandleTypeDef * huart = &uart_handlers[obj_s->index];
+ UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
if (tx_length == 0) {
return 0;
}
-
+
// Set up buffer
serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
-
+
// Set up events
serial_enable_event(obj, SERIAL_EVENT_TX_ALL, 0); // Clear all events
serial_enable_event(obj, event, 1); // Set only the wanted events
-
+
// Enable interrupt
IRQn_Type irq_n = serial_get_irq_n(obj_s->uart);
NVIC_ClearPendingIRQ(irq_n);
@@ -484,14 +484,14 @@
NVIC_EnableIRQ(irq_n);
// the following function will enable UART_IT_TXE and error interrupts
- if (HAL_UART_Transmit_IT(huart, (uint8_t*)tx, tx_length) != HAL_OK) {
+ if (HAL_UART_Transmit_IT(huart, (uint8_t *)tx, tx_length) != HAL_OK) {
return 0;
}
-
+
return tx_length;
}
-/**
+/**
* Begin asynchronous RX transfer (enable interrupt for data collecting)
* The used buffer is specified in the serial object, rx_buff
*
@@ -512,18 +512,18 @@
/* Sanity check arguments */
MBED_ASSERT(obj);
- MBED_ASSERT(rx != (void*)0);
+ MBED_ASSERT(rx != (void *)0);
MBED_ASSERT(rx_width == 8); // support only 8b width
-
+
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
serial_enable_event(obj, SERIAL_EVENT_RX_ALL, 0);
serial_enable_event(obj, event, 1);
-
+
// set CharMatch
obj->char_match = char_match;
-
+
serial_rx_buffer_set(obj, rx, rx_length, rx_width);
IRQn_Type irq_n = serial_get_irq_n(obj_s->uart);
@@ -533,8 +533,8 @@
NVIC_SetVector(irq_n, (uint32_t)handler);
NVIC_EnableIRQ(irq_n);
- // following HAL function will enable the RXNE interrupt + error interrupts
- HAL_UART_Receive_IT(huart, (uint8_t*)rx, rx_length);
+ // following HAL function will enable the RXNE interrupt + error interrupts
+ HAL_UART_Receive_IT(huart, (uint8_t *)rx, rx_length);
}
/**
@@ -546,11 +546,11 @@
uint8_t serial_tx_active(serial_t *obj)
{
MBED_ASSERT(obj);
-
+
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
-
- return ((HAL_UART_GetState(huart) == HAL_UART_STATE_BUSY_TX) ? 1 : 0);
+
+ return (((HAL_UART_GetState(huart) & HAL_UART_STATE_BUSY_TX) == HAL_UART_STATE_BUSY_TX) ? 1 : 0);
}
/**
@@ -562,20 +562,22 @@
uint8_t serial_rx_active(serial_t *obj)
{
MBED_ASSERT(obj);
-
+
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
-
- return ((HAL_UART_GetState(huart) == HAL_UART_STATE_BUSY_RX) ? 1 : 0);
+
+ return (((HAL_UART_GetState(huart) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) ? 1 : 0);
}
-void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
+{
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
}
}
-void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
+void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
+{
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF);
}
@@ -600,49 +602,49 @@
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
-
+
volatile int return_event = 0;
- uint8_t *buf = (uint8_t*)(obj->rx_buff.buffer);
+ uint8_t *buf = (uint8_t *)(obj->rx_buff.buffer);
uint8_t i = 0;
-
+
// TX PART:
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
// Return event SERIAL_EVENT_TX_COMPLETE if requested
- if ((obj_s->events & SERIAL_EVENT_TX_COMPLETE ) != 0) {
+ if ((obj_s->events & SERIAL_EVENT_TX_COMPLETE) != 0) {
return_event |= (SERIAL_EVENT_TX_COMPLETE & obj_s->events);
}
}
}
-
+
// Handle error events
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) {
return_event |= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);
}
}
-
+
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {
return_event |= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);
}
}
-
+
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
}
}
-
+
HAL_UART_IRQHandler(huart);
-
+
// Abort if an error occurs
if ((return_event & SERIAL_EVENT_RX_PARITY_ERROR) ||
- (return_event & SERIAL_EVENT_RX_FRAMING_ERROR) ||
- (return_event & SERIAL_EVENT_RX_OVERRUN_ERROR)) {
+ (return_event & SERIAL_EVENT_RX_FRAMING_ERROR) ||
+ (return_event & SERIAL_EVENT_RX_OVERRUN_ERROR)) {
return return_event;
}
-
+
//RX PART
if (huart->RxXferSize != 0) {
obj->rx_buff.pos = huart->RxXferSize - huart->RxXferCount;
@@ -650,7 +652,7 @@
if ((huart->RxXferCount == 0) && (obj->rx_buff.pos >= (obj->rx_buff.length - 1))) {
return_event |= (SERIAL_EVENT_RX_COMPLETE & obj_s->events);
}
-
+
// Check if char_match is present
if (obj_s->events & SERIAL_EVENT_RX_CHARACTER_MATCH) {
if (buf != NULL) {
@@ -664,11 +666,11 @@
}
}
}
-
- return return_event;
+
+ return return_event;
}
-/**
+/**
* Abort the ongoing TX transaction. It disables the enabled interupt for TX and
* flush TX hardware buffer if TX FIFO is used
*
@@ -678,17 +680,17 @@
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
-
+
__HAL_UART_DISABLE_IT(huart, UART_IT_TC);
__HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
-
+
// clear flags
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
// reset states
huart->TxXferCount = 0;
// update handle state
- if(huart->gState == HAL_UART_STATE_BUSY_TX_RX) {
+ if (huart->gState == HAL_UART_STATE_BUSY_TX_RX) {
huart->gState = HAL_UART_STATE_BUSY_RX;
} else {
huart->gState = HAL_UART_STATE_READY;
@@ -705,20 +707,20 @@
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
-
+
// disable interrupts
__HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
__HAL_UART_DISABLE_IT(huart, UART_IT_PE);
__HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
-
+
// clear flags
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF | UART_CLEAR_FEF | UART_CLEAR_OREF);
volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->RDR; // Clear RXNE flag
-
+
// reset states
huart->RxXferCount = 0;
// update handle state
- if(huart->RxState == HAL_UART_STATE_BUSY_TX_RX) {
+ if (huart->RxState == HAL_UART_STATE_BUSY_TX_RX) {
huart->RxState = HAL_UART_STATE_BUSY_TX;
} else {
huart->RxState = HAL_UART_STATE_READY;
@@ -748,9 +750,9 @@
obj_s->uart = (UARTName)pinmap_merge(uart_cts, uart_rts);
MBED_ASSERT(obj_s->uart != (UARTName)NC);
- if(type == FlowControlNone) {
+ if (type == FlowControlNone) {
// Disable hardware flow control
- obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
+ obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
}
if (type == FlowControlRTS) {
// Enable RTS
@@ -780,7 +782,7 @@
// Enable the pin for RTS function
pinmap_pinout(rxflow, PinMap_UART_RTS);
}
-
+
init_uart(obj);
}
