ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

STM32: Put some serial code in common between families

pull/4502/head
Laurent MEUNIER 2017-06-08 17:18:05 +02:00
parent c5c33f1d0f
commit f77ecf4e12
10 changed files with 53 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
targets/TARGET_STM/TARGET_STM32F0/serial_device.c
View File

@ -468,29 +468,6 @@ void serial_putc(serial_t *obj, int c)
huart->Instance->TDR = (uint32_t)(c & (uint16_t)0xFF); huart->Instance->TDR = (uint32_t)(c & (uint16_t)0xFF);
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -500,11 +477,6 @@ void serial_clear(serial_t *obj)
huart->RxXferCount = 0; huart->RxXferCount = 0;
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -513,11 +485,6 @@ void serial_break_set(serial_t *obj)
//HAL_LIN_SendBreak(huart); //HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32F1/serial_device.c
View File

@ -285,29 +285,6 @@ void serial_putc(serial_t *obj, int c)
} }
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -317,11 +294,6 @@ void serial_clear(serial_t *obj)
huart->RxXferCount = 0; huart->RxXferCount = 0;
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -330,11 +302,6 @@ void serial_break_set(serial_t *obj)
HAL_LIN_SendBreak(huart); HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32F2/serial_device.c
View File

@ -434,29 +434,6 @@ void serial_putc(serial_t *obj, int c)
huart->Instance->DR = (uint32_t)(c & (uint16_t)0x1FF); huart->Instance->DR = (uint32_t)(c & (uint16_t)0x1FF);
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -466,11 +443,6 @@ void serial_clear(serial_t *obj)
huart->RxXferCount = 0; huart->RxXferCount = 0;
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -479,11 +451,6 @@ void serial_break_set(serial_t *obj)
HAL_LIN_SendBreak(huart); HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32F3/serial_device.c
View File

@ -369,29 +369,6 @@ void serial_putc(serial_t *obj, int c)
} }
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -401,11 +378,6 @@ void serial_clear(serial_t *obj)
__HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST); __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -414,11 +386,6 @@ void serial_break_set(serial_t *obj)
HAL_LIN_SendBreak(huart); HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32F4/serial_device.c
View File

@ -431,29 +431,6 @@ void serial_putc(serial_t *obj, int c)
huart->Instance->DR = (uint32_t)(c & 0x1FF); huart->Instance->DR = (uint32_t)(c & 0x1FF);
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -463,11 +440,6 @@ void serial_clear(serial_t *obj)
huart->RxXferCount = 0; huart->RxXferCount = 0;
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -476,11 +448,6 @@ void serial_break_set(serial_t *obj)
HAL_LIN_SendBreak(huart); HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32F7/serial_device.c
View File

@ -422,29 +422,6 @@ void serial_putc(serial_t *obj, int c)
huart->Instance->TDR = (uint32_t)(c & 0x1FF); huart->Instance->TDR = (uint32_t)(c & 0x1FF);
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -454,11 +431,6 @@ void serial_clear(serial_t *obj)
__HAL_UART_CLEAR_IT(huart, UART_FLAG_RXNE); __HAL_UART_CLEAR_IT(huart, UART_FLAG_RXNE);
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -467,11 +439,6 @@ void serial_break_set(serial_t *obj)
HAL_LIN_SendBreak(huart); HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32L0/serial_device.c
View File

@ -351,29 +351,6 @@ void serial_putc(serial_t *obj, int c)
huart->Instance->TDR = (uint32_t)(c & (uint16_t)0xFF); huart->Instance->TDR = (uint32_t)(c & (uint16_t)0xFF);
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -383,11 +360,6 @@ void serial_clear(serial_t *obj)
huart->RxXferCount = 0; huart->RxXferCount = 0;
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -396,11 +368,6 @@ void serial_break_set(serial_t *obj)
__HAL_UART_SEND_REQ(huart, UART_SENDBREAK_REQUEST); __HAL_UART_SEND_REQ(huart, UART_SENDBREAK_REQUEST);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32L1/serial_device.c
View File

@ -341,29 +341,6 @@ void serial_putc(serial_t *obj, int c)
} }
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -373,11 +350,6 @@ void serial_clear(serial_t *obj)
huart->RxXferCount = 0; huart->RxXferCount = 0;
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -386,11 +358,6 @@ void serial_break_set(serial_t *obj)
HAL_LIN_SendBreak(huart); HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

33
targets/TARGET_STM/TARGET_STM32L4/serial_device.c
View File

@ -387,29 +387,6 @@ void serial_putc(serial_t *obj, int c)
} }
} }
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -419,11 +396,6 @@ void serial_clear(serial_t *obj)
huart->RxXferCount = 0; huart->RxXferCount = 0;
} }
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
struct serial_s *obj_s = SERIAL_S(obj); struct serial_s *obj_s = SERIAL_S(obj);
@ -432,11 +404,6 @@ void serial_break_set(serial_t *obj)
HAL_LIN_SendBreak(huart); HAL_LIN_SendBreak(huart);
} }
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#if DEVICE_SERIAL_ASYNCH #if DEVICE_SERIAL_ASYNCH
/****************************************************************************** /******************************************************************************

38
targets/TARGET_STM/serial_api.c
View File

@ -31,6 +31,7 @@
#include "mbed_error.h" #include "mbed_error.h"
#include "serial_api.h" #include "serial_api.h"
#include "serial_api_hal.h" #include "serial_api_hal.h"
#include "PeripheralPins.h"
#if DEVICE_SERIAL #if DEVICE_SERIAL
@ -119,4 +120,41 @@ void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_b
init_uart(obj); init_uart(obj);
} }
/******************************************************************************
* READ/WRITE
******************************************************************************/
int serial_readable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
/* To avoid a target blocking case, let's check for
* possible OVERRUN error and discard it
*/
if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_OREFLAG(huart);
}
// Check if data is received
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
}
int serial_writable(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// Check if data is transmitted
return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
}
void serial_pinout_tx(PinName tx)
{
pinmap_pinout(tx, PinMap_UART_TX);
}
void serial_break_clear(serial_t *obj)
{
(void)obj;
}
#endif /* DEVICE_SERIAL */ #endif /* DEVICE_SERIAL */