static BOOL Hal_FlipBUff(USER_UART_HandleTypeDef *pHandle)
{
uint8_t tmp;
tmp = WhichLowBuffer(pHandle);
if(tmp==ERR)
return FALSE;
//disable interrupt
__HAL_UART_DISABLE_IT(&(pHandle->UartHandle), UART_IT_RXNE);
//save low buff to upbuff
pHandle->UpBufferPtr = pBuffTable[tmp];
pHandle->UpBufferCount = pHandle->UartHandle.RxXferSize - pHandle->UartHandle.RxXferCount;
//change the uart state
if(pHandle->UartHandle.State==HAL_UART_STATE_BUSY_TX_RX)
pHandle->UartHandle.State = HAL_UART_STATE_BUSY_TX;
else
pHandle->UartHandle.State = HAL_UART_STATE_READY;
//flip buffer
if(tmp==0)
HAL_UART_Receive_IT(&(pHandle->UartHandle), (uint8_t *)pBuffTable[1], HAL_BUFFER_SIZE);
else
HAL_UART_Receive_IT(&(pHandle->UartHandle), (uint8_t *)pBuffTable[0], HAL_BUFFER_SIZE);
__HAL_UART_ENABLE_IT(&(pHandle->UartHandle), UART_IT_RXNE);
return TRUE;
}
void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
{
IRQn_Type irq_n = (IRQn_Type)0;
uint32_t vector = 0;
UartHandle.Instance = (USART_TypeDef *)(obj->uart);
if (obj->uart == UART_1) {
irq_n = USART1_IRQn;
vector = (uint32_t)&uart1_irq;
}
if (obj->uart == UART_2) {
irq_n = USART2_IRQn;
vector = (uint32_t)&uart2_irq;
}
if (obj->uart == UART_3) {
irq_n = USART3_IRQn;
vector = (uint32_t)&uart3_irq;
}
if (enable) {
if (irq == RxIrq) {
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);
} else { // TxIrq
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_TC);
}
NVIC_SetVector(irq_n, vector);
NVIC_EnableIRQ(irq_n);
} else { // disable
int all_disabled = 0;
if (irq == RxIrq) {
__HAL_UART_DISABLE_IT(&UartHandle, UART_IT_RXNE);
// Check if TxIrq is disabled too
if ((UartHandle.Instance->CR1 & USART_CR1_TCIE) == 0) all_disabled = 1;
} else { // TxIrq
__HAL_UART_DISABLE_IT(&UartHandle, UART_IT_TC);
// Check if RxIrq is disabled too
if ((UartHandle.Instance->CR1 & USART_CR1_RXNEIE) == 0) all_disabled = 1;
}
if (all_disabled) NVIC_DisableIRQ(irq_n);
}
}
static void usart_init1(USART_TypeDef *usart, int irqn, cbuf_t *rxbuf, size_t rxsize)
{
cbuf_initialize(rxbuf, rxsize);
/* Enable the UART Parity Error Interrupt */
__HAL_UART_ENABLE_IT(&handle, UART_IT_PE);
/* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
__HAL_UART_ENABLE_IT(&handle, UART_IT_ERR);
/* Enable the UART Data Register not empty Interrupt */
__HAL_UART_ENABLE_IT(&handle, UART_IT_RXNE);
HAL_NVIC_EnableIRQ(USART1_IRQn);
}
void Uart2UARTInit(UART_HandleTypeDef* huart) {
__USART2_CLK_ENABLE()
;
huart->Instance = USART2;
huart->Init.BaudRate = 115200;
huart->Init.WordLength = UART_WORDLENGTH_8B;
huart->Init.StopBits = UART_STOPBITS_1;
huart->Init.Parity = UART_PARITY_NONE;
huart->Init.Mode = UART_MODE_TX_RX;
huart->Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart->Init.OverSampling = UART_OVERSAMPLING_16;
MyHAL_UARTInit(huart);
__HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
__HAL_UART_ENABLE_IT(huart, UART_IT_TC);
}
static void uart_stm32_irq_rx_enable(struct device *dev)
{
struct uart_stm32_data *data = DEV_DATA(dev);
UART_HandleTypeDef *UartHandle = &data->huart;
__HAL_UART_ENABLE_IT(UartHandle, UART_IT_RXNE);
}
static rt_err_t drv_control(struct rt_serial_device *serial,
int cmd, void *arg)
{
struct drv_uart *uart;
RT_ASSERT(serial != RT_NULL);
uart = (struct drv_uart *)serial->parent.user_data;
switch (cmd)
{
case RT_DEVICE_CTRL_CLR_INT:
/* disable rx irq */
NVIC_DisableIRQ(uart->irq);
/* disable interrupt */
__HAL_UART_DISABLE_IT(&uart->UartHandle, UART_IT_RXNE);
break;
case RT_DEVICE_CTRL_SET_INT:
/* enable rx irq */
NVIC_EnableIRQ(uart->irq);
/* enable interrupt */
__HAL_UART_ENABLE_IT(&uart->UartHandle, UART_IT_RXNE);
break;
}
return RT_EOK;
}
int main(void)
{
// Reset of all peripherals, Initializes the Flash interface and the Systick .
HAL_Init();
// Configure the system clock .
SystemClock_Config();
// Initialize all configured peripherals .
MX_GPIO_Init();
MX_UART4_Init();
// Initializes the Global MSP .
HAL_MspInit();
HAL_UART_MspInit( &huart4 );
__HAL_UART_ENABLE_IT( &huart4, UART_IT_RXNE);
HAL_UART_Receive_IT( &huart4 , string , 154 );
while (1)
{
HAL_GPIO_WritePin( GPIOD , GPIO_PIN_15 , GPIO_PIN_SET );
delay(5000000);
HAL_GPIO_WritePin( GPIOD , GPIO_PIN_15 , GPIO_PIN_RESET );
delay(5000000);
}
}
/**
* @brief Initialize GPIO for UART
* @param pxUARTHandle
*/
Status_t vUARTGPIOInit(UART_HandleTypeDef* pxUARTHandle)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(pxUARTHandle->Instance==confUARTx)
{
/* Peripheral clock enable */
confUART_CLK_ENABLE();
/* GPIO clock enable */
confUART_RX_GPIO_CLK_ENABLE();
confUART_TX_GPIO_CLK_ENABLE();
/* UART TX GPIO pin configuration */
GPIO_InitStruct.Pin = confUART_TX_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = confUART_TX_AF;
HAL_GPIO_Init(confUART_TX_GPIO_PORT, &GPIO_InitStruct);
/* UART RX GPIO pin configuration */
GPIO_InitStruct.Pin = confUART_RX_PIN;
GPIO_InitStruct.Alternate = confUART_RX_AF;
HAL_GPIO_Init(confUART_RX_GPIO_PORT, &GPIO_InitStruct);
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(confUART_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(confUART_IRQn);
/* Enable Interrupts here */
__HAL_UART_ENABLE_IT(pxUARTHandle, UART_IT_RXNE);
}
return STATUS_OK;
}
/**
* @brief UART MSP Initialization
* This function configures the hardware resources used in this example:
* - Peripheral's clock enable
* - Peripheral's GPIO Configuration
* @param huart: UART handle pointer
* @retval None
*/
void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
GPIO_InitTypeDef GPIO_InitStruct;
/*##-1- Enable peripherals and GPIO Clocks #################################*/
__HAL_RCC_GPIOA_CLK_ENABLE(); /* Enable GPIO TX/RX clock for USART1 pins */
__HAL_RCC_USART1_CLK_ENABLE(); /* Enable USART1 clock */
/*##-2- Configure peripheral GPIO ##########################################*/
/* UART1 TX GPIO pin configuration */
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* UART RX GPIO pin configuration */
GPIO_InitStruct.Pin = GPIO_PIN_10;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Enable the UART Data Register Not Empty interrupt (?) */
__HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
//SET_BIT(huart->Instance->CR1, USART_CR1_RXNEIE);
}
//相关初始化
void Init_sth(void)
{
Lcd_Init();
__HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_0,GPIO_PIN_SET);
Lcd_Clear(GREEN);
showimage_farsight(gImage_logo);
Gui_DrawFont_GBK16(28,40,BLUE,GREEN,(uint8_t *)"Touch ID");
}
void StartTask_Uart1Reception (void const *argument)
{
extern osMessageQId Q_CmdReceptionHandle;
uint32_t reclen;
osStatus qretval; /*!< The return value which indicates the osMessagePut() implementation result */
uint8_t* ptrdata; /*!< Pointer to any byte in the uart buffer */
uint8_t (*ptr_bufhead)[1], /*!< Pointer to the head of the uart buffer */
(*ptr_buftail)[1]; /*!< Pointer to the tail of the uart buffer */
while (1)
{
osSignalWait (0x01, osWaitForever);
reclen = MAX_DEPTH_UART1_BUF - huart1.hdmarx->Instance->NDTR;
ptrdata = *uart_buf + reclen - 1; // point to the last char received
ptr_bufhead = (uint8_t(*)[1])uart1_buf[0];
ptr_buftail = (uint8_t(*)[1])uart1_buf[MAX_COUNT_UART1_BUF - 2];
if(*ptrdata == '\n')
{
/* Insert a terminal into the string */
*(ptrdata + 1) = 0x0;
if(*(--ptrdata) == '\r') // A command has been received
{
/*
* The current buffer has been used and post to the working thread
* switch to the next uart1 queue buffer to recevie the furture data
*/
qretval = osMessagePut(Q_CmdReceptionHandle, (uint32_t)(uart_buf), 0); // Put the pointer of the data container to the queue
if(qretval != osOK)
{
__breakpoint(0);
//printk(KERN_ERR "It's failed to put the command into the message queue!\r\n");
}
/* Move to the next row of the buffer */
uart_buf++;
if(uart_buf > (uint8_t(*)[50])ptr_buftail)
{
uart_buf = (uint8_t(*)[50])ptr_bufhead;
}
}
/* Reset DMA_EN bit can result in the TCIF interrupt.
The interrupt raises the HAL_UART_RxCpltCallback() event, the DMA_Rx will be restarted in it */
HAL_DMA_Abort(huart1.hdmarx);
USART_Start_Receive_DMA(&huart1);
}
else /* Continue recepition if the last char is not '\n' */
{
__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
}
}
}
/**
* @brief 使能串口接收中断
* @param hcomm : 句柄
* @param en : true 使能
* @retval None
*/
void CommUsart_EnableIT(CommUsartType *hcomm, bool en)
{
if(en)
{
__HAL_UART_ENABLE_IT(hcomm->huart, UART_IT_RXNE);
}
else
{
__HAL_UART_DISABLE_IT(hcomm->huart, UART_IT_RXNE);
}
}
void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
{
UART_HandleTypeDef *handle = &UartHandle[obj->serial.module];
IRQn_Type irq_n = UartIRQs[obj->serial.module];
uint32_t vector = uart_irq_vectors[obj->serial.module];
if (!irq_n || !vector)
return;
if (enable) {
if (irq == RxIrq) {
__HAL_UART_ENABLE_IT(handle, UART_IT_RXNE);
} else { // TxIrq
__HAL_UART_ENABLE_IT(handle, UART_IT_TC);
}
vIRQ_SetVector(irq_n, vector);
vIRQ_EnableIRQ(irq_n);
} else { // disable
int all_disabled = 0;
if (irq == RxIrq) {
__HAL_UART_DISABLE_IT(handle, UART_IT_RXNE);
// Check if TxIrq is disabled too
if ((handle->Instance->CR1 & USART_CR1_TXEIE) == 0) all_disabled = 1;
} else { // TxIrq
__HAL_UART_DISABLE_IT(handle, UART_IT_TXE);
// Check if RxIrq is disabled too
if ((handle->Instance->CR1 & USART_CR1_RXNEIE) == 0) all_disabled = 1;
}
if (all_disabled) vIRQ_DisableIRQ(irq_n);
}
}
//--------------------------------------------------------------
// interne Funktion
// init vom RX-Interrupt
//--------------------------------------------------------------
static void P_ISR_COM_Init(UART_NAME_t uart) {
if (uart == COM1) {
// RX-Interrupt enable
__HAL_UART_ENABLE_IT(&UartHandle1, UART_IT_RXNE);
HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
}
if (uart == COM6) {
// RX-Interrupt enable
__HAL_UART_ENABLE_IT(&UartHandle6, UART_IT_RXNE);
HAL_NVIC_SetPriority(USART6_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(USART6_IRQn);
}
if (uart == COM7) {
// RX-Interrupt enable
__HAL_UART_ENABLE_IT(&UartHandle7, UART_IT_RXNE);
HAL_NVIC_SetPriority(UART7_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(UART7_IRQn);
}
}
/**
* @brief Initializes the UART
* @param None
* @retval None
*/
ErrorStatus UART1_Init()
{
/* Make sure we only initialize it once */
if (!prvInitialized)
{
/* Init GPIO */
UART_GPIO_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.Pin = UART_TX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(UART_PORT, &GPIO_InitStructure);
GPIO_InitStructure.Pin = UART_RX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_INPUT;
HAL_GPIO_Init(UART_PORT, &GPIO_InitStructure);
/* Init the RX Buffer */
prvRxBufferIn = &prvRxBuffer[0];
prvRxBufferOut = &prvRxBuffer[0];
prvRxBufferCount = 0;
/* Enable UART clock */
__HAL_RCC_USART1_CLK_ENABLE();
/* Init the UART */
UART_Handle.Instance = USART1;
UART_Handle.Init.BaudRate = 115200;
UART_Handle.Init.WordLength = UART_WORDLENGTH_8B;
UART_Handle.Init.StopBits = UART_STOPBITS_1;
UART_Handle.Init.Parity = UART_PARITY_NONE;
UART_Handle.Init.Mode = UART_MODE_TX_RX;
UART_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
if (HAL_UART_Init(&UART_Handle) != HAL_OK)
return ERROR;
/* Enable the UART Data Register not empty Interrupt */
__HAL_UART_ENABLE_IT(&UART_Handle, UART_IT_RXNE);
/* NVIC for USART */
HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(USART1_IRQn);
prvInitialized = true;
return SUCCESS;
}
return ERROR;
}
HAL_StatusTypeDef EnableUart2ReceiveData(UART_HandleTypeDef* pUart)
{
if((pUart->gState == HAL_UART_STATE_READY) || (pUart->gState == HAL_UART_STATE_BUSY_TX))
{
__HAL_LOCK(pUart);
UART_MASK_COMPUTATION(pUart);
pUart->ErrorCode = HAL_UART_ERROR_NONE;
pUart->gState = HAL_UART_STATE_BUSY_RX;
__HAL_UART_ENABLE_IT(pUart, UART_IT_PE);
__HAL_UART_ENABLE_IT(pUart, UART_IT_ERR);
__HAL_UNLOCK(pUart);
__HAL_UART_ENABLE_IT(pUart, UART_IT_RXNE);
return HAL_OK;
}
else
{
return HAL_BUSY;
}
}
U32 End_uart_send(UCHAR end_id, UCHAR* txbuf, USHORT txnum )
{
UART_HandleTypeDef *UARTx;
P_UART_CCB p_uc;
UCHAR send_byte=0;
if( txnum < 1 )
{
return FALSE;
}
switch(end_id)
{
case PC_COM_PORT:
UARTx = &PC_UART;
break;
case RS485_COM_PORT:
UARTx= &RS485_UART;
break;
case PLC_COM_PORT:
UARTx = &PLC_UART;
break;
default:
return FALSE;
}
p_uc = &g_uart_ccb[end_id];
p_uc->gpUartTxAddress = txbuf;
p_uc->gUartTxCnt = txnum;
send_byte = *(p_uc->gpUartTxAddress);
p_uc->gpUartTxAddress++;
p_uc->gUartTxCnt--;
while(RESET == __HAL_UART_GET_FLAG(UARTx, UART_FLAG_TXE)); //关键
UARTx->Instance->DR = (send_byte & (uint8_t)0xFF);
while(RESET == __HAL_UART_GET_FLAG(UARTx, UART_FLAG_TC)); //关键
if(p_uc->gUartTxCnt)
__HAL_UART_ENABLE_IT(UARTx, UART_IT_TXE);
return TRUE;
};
/** Begin asynchronous RX transfer (enable interrupt for data collecting)
* The used buffer is specified in the serial object - rx_buff
*
* @param obj The serial object
* @param rx The buffer for sending
* @param rx_length The number of words to transmit
* @param rx_width The bit width of buffer word
* @param handler The serial handler
* @param event The logical OR of events to be registered
* @param handler The serial handler
* @param char_match A character in range 0-254 to be matched
* @param hint A suggestion for how to use DMA with this transfer
*/
void serial_rx_asynch(serial_t *obj, void *rx, size_t rx_length, uint8_t rx_width, uint32_t handler, uint32_t event, uint8_t char_match, DMAUsage hint)
{
// DMA usage is currently ignored
(void) hint;
/* Sanity check arguments */
MBED_ASSERT(obj);
MBED_ASSERT(rx != (void*)0);
MBED_ASSERT(rx_width == 8); // support only 8b width
h_serial_rx_enable_event(obj, SERIAL_EVENT_RX_ALL, 0);
h_serial_rx_enable_event(obj, event, 1);
// set CharMatch
if (char_match != SERIAL_RESERVED_CHAR_MATCH) {
obj->char_match = char_match;
}
h_serial_rx_buffer_set(obj, rx, rx_length, rx_width);
IRQn_Type irqn = h_serial_get_irq_index(obj);
NVIC_ClearPendingIRQ(irqn);
NVIC_DisableIRQ(irqn);
NVIC_SetPriority(irqn, 0);
NVIC_SetVector(irqn, (uint32_t)handler);
NVIC_EnableIRQ(irqn);
UART_HandleTypeDef *handle = &UartHandle[SERIAL_OBJ(index)];
// flush current data + error flags
__HAL_UART_CLEAR_PEFLAG(handle);
#if DEVICE_SERIAL_ASYNCH_DMA
// Enable DMA interrupt
irqn = h_serial_rx_get_irqdma_index(obj);
NVIC_ClearPendingIRQ(irqn);
NVIC_DisableIRQ(irqn);
NVIC_SetPriority(irqn, 1);
NVIC_SetVector(irqn, (uint32_t)handler);
NVIC_EnableIRQ(irqn);
// following HAL function will program and enable the DMA transfer
MBED_UART_Receive_DMA(handle, (uint8_t*)rx, rx_length);
#else
// following HAL function will enable the RXNE interrupt + error interrupts
HAL_UART_Receive_IT(handle, (uint8_t*)rx, rx_length);
#endif
/* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
__HAL_UART_ENABLE_IT(handle, UART_IT_ERR);
DEBUG_PRINTF("UART%u: Rx: 0=(%u, %u, %u) %x\n", obj->serial.module+1, rx_length, rx_width, char_match, HAL_UART_GetState(handle));
return;
}
void uartWrite(serialPort_t *instance, uint8_t ch)
{
uartPort_t *s = (uartPort_t *)instance;
s->port.txBuffer[s->port.txBufferHead] = ch;
if (s->port.txBufferHead + 1 >= s->port.txBufferSize) {
s->port.txBufferHead = 0;
} else {
s->port.txBufferHead++;
}
if (s->txDMAStream) {
if (!(s->txDMAStream->CR & 1))
uartStartTxDMA(s);
} else {
__HAL_UART_ENABLE_IT(&s->Handle, UART_IT_TXE);
}
}
/*====================================================================================================*/
void Serial_Config( void )
{
GPIO_InitTypeDef GPIO_InitStruct;
/* UART Clk ******************************************************************/
UARTx_TX_GPIO_CLK_ENABLE();
UARTx_RX_GPIO_CLK_ENABLE();
UARTx_CLK_ENABLE();
/* UART Pin ******************************************************************/
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Pin = UARTx_TX_PIN;
GPIO_InitStruct.Alternate = UARTx_TX_AF;
HAL_GPIO_Init(UARTx_TX_GPIO_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = UARTx_RX_PIN;
GPIO_InitStruct.Alternate = UARTx_RX_AF;
HAL_GPIO_Init(UARTx_RX_GPIO_PORT, &GPIO_InitStruct);
/* UART IT *******************************************************************/
HAL_NVIC_SetPriority(UARTx_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(UARTx_IRQn);
/* UART Init *****************************************************************/
Serial_HandleStruct.Instance = UARTx;
Serial_HandleStruct.Init.BaudRate = UARTx_BAUDRATE;
Serial_HandleStruct.Init.WordLength = UARTx_BYTESIZE;
Serial_HandleStruct.Init.StopBits = UARTx_STOPBITS;
Serial_HandleStruct.Init.Parity = UARTx_PARITY;
Serial_HandleStruct.Init.HwFlowCtl = UARTx_HARDWARECTRL;
Serial_HandleStruct.Init.Mode = UARTx_MODE;
Serial_HandleStruct.Init.OverSampling = UARTx_OVERSAMPLE;
HAL_UART_Init(&Serial_HandleStruct);
/* UART Enable ***************************************************************/
__HAL_UART_ENABLE_IT(&Serial_HandleStruct, UART_IT_RXNE);
__HAL_UART_ENABLE(&Serial_HandleStruct);
__HAL_UART_CLEAR_FLAG(&Serial_HandleStruct, UART_FLAG_TC);
}
void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(huart->Instance==UART4)
{
/* USER CODE BEGIN UART4_MspInit 0 */
/* USER CODE END UART4_MspInit 0 */
/* Peripheral clock enable */
__UART4_CLK_ENABLE();
/**UART4 GPIO Configuration
PA0-WKUP ------> UART4_TX
PC11 ------> UART4_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(UART4_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(UART4_IRQn);
/* USER CODE BEGIN UART4_MspInit 1 */
__HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
/* USER CODE END UART4_MspInit 1 */
}
}
/**
* @brief It's LOW-LEVEL usart receive initialization function.
* The DMA will be used to receive data.
* @param huart:Which usart port used to receive data
* @retval null
*/
static void USART_Start_Receive_DMA(UART_HandleTypeDef *huart)
{
HAL_UART_Receive_DMA(huart, (uint8_t*)uart_buf, MAX_DEPTH_UART1_BUF);
/*!< Enable the Idle interrupt.
Attention: REMEMBER to add IDLE Interrupt handler to stm324xx_it.c.
[...] The Idle ISR code is following
uint32_t tmp1, tmp2;
tmp1 = __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE);
tmp2 = __HAL_UART_GET_IT_SOURCE(&huart1, UART_IT_IDLE);
if((tmp1 != RESET) && (tmp2 != RESET))
{
__HAL_UART_CLEAR_IDLEFLAG(&huart1);
My_HAL_UART_IdleCallback(&huart1);
}
[...]
*/
__HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
}
void CommInit(void)
{
huart2.Instance = USART2;
huart2.Init.BaudRate = 57600;
huart2.Init.WordLength = UART_WORDLENGTH_8B;
huart2.Init.StopBits = UART_STOPBITS_1;
huart2.Init.Parity = UART_PARITY_NONE;
huart2.Init.Mode = UART_MODE_TX_RX;
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&huart2);
hcrc.Instance = CRC;
HAL_CRC_Init(&hcrc);
chIQInit(&g_iqp, g_comm_iqp_buf, COMM_IQP_BUF_SIZE, NULL);
osSemaphoreDef(COMM_SEMA);
commSema = osSemaphoreEmptyCreate(osSemaphore(COMM_SEMA));
if (NULL == commSema)
{
printf("[%s, L%d] create semaphore failed!\r\n", __FILE__, __LINE__);
return;
}
osThreadDef(CommTask, CommStartTask, osPriorityNormal, 0, 1024);
CommTaskHandle = osThreadCreate(osThread(CommTask), NULL);
if (NULL == CommTaskHandle)
{
printf("[%s, L%d] create thread failed!\r\n", __FILE__, __LINE__);
return;
}
HAL_NVIC_SetPriority(USART2_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY, 0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
__HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE);
return;
}
void PX4FlowPortInit(void)
{
//*******************************************************
//配置USART发送与接受
__USART1_CLK_ENABLE();
PX4_UartHandle.Instance = USART1;
PX4_UartHandle.Init.BaudRate = 115200;
PX4_UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
PX4_UartHandle.Init.StopBits = UART_STOPBITS_1;
PX4_UartHandle.Init.Parity = UART_PARITY_NONE;
PX4_UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
PX4_UartHandle.Init.Mode = UART_MODE_TX_RX;
PX4_UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXOVERRUNDISABLE_INIT;
PX4_UartHandle.AdvancedInit.OverrunDisable=UART_ADVFEATURE_OVERRUN_DISABLE;//关闭OverRun
HAL_UART_DeInit(&PX4_UartHandle);//卸载USART1
HAL_UART_Init(&PX4_UartHandle);//装载USART1
/* NVIC for USART, to catch the RX complete */
/*##-4- Put UART peripheral in reception process ###########################*/
/* Enable the UART Data Register not empty Interrupt */
__HAL_UART_ENABLE_IT(&PX4_UartHandle, UART_IT_RXNE);
}
void End_Init(void)
{
P_END_OBJ pEndObj = NULL;
unsigned char i;
g_EndObject[PC_COM_PORT] = (pvoid)&PC_UART;
g_EndObject[RS485_COM_PORT] = (pvoid)&RS485_UART;
g_EndObject[PLC_COM_PORT] = (pvoid)&PLC_UART;
mem_msg_buffer_init((MSG_INFO *)gShortMsgPool, (P_MSG_INFO *)pShortMsgPool, MAX_MSG_SHORT, sizeof(MSG_SHORT_INFO));
//alan test 需要暂时注释掉, 不知为啥IIC Start 一调用, MCU 就飞啦.
for( i = START_COM_PORT; i < MAX_COM_PORT; i++)
{
// 找到当前End Object
pEndObj = g_EndObjectPool + i;
/* end queue[x] initialize */ /* each end object define '50 block' queue */
g_EndTxQueue[i] = define_new_queue((queue *)pTxEndQueueBuf[i], END_TX_QUEUE_SIZE);
g_EndRxQueue[i] = define_new_queue((queue *)pRxEndQueueBuf[i], END_RX_QUEUE_SIZE);
pEndObj->end_recv_buffer = (unsigned char *)pUartRxBuf[i];
pEndObj->last_receive_len = 0;
pEndObj->receive_len = 0;
pEndObj->recv_timeout = 0;
UART_ReceiveData(i, pEndObj->end_recv_buffer, UART_RECV_BUF_SIZE);
// 所有串口状态转到REVC STATUS
pEndObj->end_send_status = END_STATUS_IDLE;
__HAL_UART_ENABLE_IT((UART_HandleTypeDef *)g_EndObject[i], UART_IT_RXNE);
}
}
// assumes there is a character available
int uart_rx_char(pyb_uart_obj_t *self) {
if (self->read_buf_tail != self->read_buf_head) {
// buffering via IRQ
int data;
if (self->char_width == CHAR_WIDTH_9BIT) {
data = ((uint16_t*)self->read_buf)[self->read_buf_tail];
} else {
data = self->read_buf[self->read_buf_tail];
}
self->read_buf_tail = (self->read_buf_tail + 1) % self->read_buf_len;
if (__HAL_UART_GET_FLAG(&self->uart, UART_FLAG_RXNE) != RESET) {
// UART was stalled by flow ctrl: re-enable IRQ now we have room in buffer
__HAL_UART_ENABLE_IT(&self->uart, UART_IT_RXNE);
}
return data;
} else {
// no buffering
#if defined(MCU_SERIES_F7) || defined(MCU_SERIES_L4)
return self->uart.Instance->RDR & self->char_mask;
#else
return self->uart.Instance->DR & self->char_mask;
#endif
}
}
void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(huart->Instance==USART2)
{
/* USER CODE BEGIN USART2_MspInit 0 */
/* USER CODE END USART2_MspInit 0 */
/* Peripheral clock enable */
__USART2_CLK_ENABLE();
/**USART2 GPIO Configuration
PA2 ------> USART2_TX
PA3 ------> USART2_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Peripheral DMA init*/
hdma_usart2_rx.Instance = DMA1_Stream5;
hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;
hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart2_rx.Init.Mode = DMA_NORMAL;
hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;
hdma_usart2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
HAL_DMA_Init(&hdma_usart2_rx);
__HAL_LINKDMA(huart,hdmarx,hdma_usart2_rx);
hdma_usart2_tx.Instance = DMA1_Stream6;
hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4;
hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart2_tx.Init.Mode = DMA_NORMAL;
hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;
hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
HAL_DMA_Init(&hdma_usart2_tx);
__HAL_LINKDMA(huart,hdmatx,hdma_usart2_tx);
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(USART2_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
/* USER CODE BEGIN USART2_MspInit 1 */
__HAL_UART_ENABLE_IT(huart, UART_IT_RXNE); //|UART_IT_IDLE
/* USER CODE END USART2_MspInit 1 */
}
else if(huart->Instance==USART3)
{
/* USER CODE BEGIN USART3_MspInit 0 */
/* USER CODE END USART3_MspInit 0 */
/* Peripheral clock enable */
__USART3_CLK_ENABLE();
/**USART3 GPIO Configuration
PD8 ------> USART3_TX
PD9 ------> USART3_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/* Peripheral DMA init*/
hdma_usart3_rx.Instance = DMA1_Stream1;
hdma_usart3_rx.Init.Channel = DMA_CHANNEL_4;
hdma_usart3_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_usart3_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart3_rx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart3_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart3_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart3_rx.Init.Mode = DMA_CIRCULAR;
hdma_usart3_rx.Init.Priority = DMA_PRIORITY_LOW;
hdma_usart3_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
HAL_DMA_Init(&hdma_usart3_rx);
__HAL_LINKDMA(huart,hdmarx,hdma_usart3_rx);
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(USART3_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(USART3_IRQn);
/* USER CODE BEGIN USART3_MspInit 1 */
/* USER CODE END USART3_MspInit 1 */
}
else if(huart->Instance==USART6)
{
/* USER CODE BEGIN USART6_MspInit 0 */
/* USER CODE END USART6_MspInit 0 */
/* Peripheral clock enable */
__USART6_CLK_ENABLE();
/**USART6 GPIO Configuration
PC6 ------> USART6_TX
PC7 ------> USART6_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF8_USART6;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/* USER CODE BEGIN USART6_MspInit 1 */
/* USER CODE END USART6_MspInit 1 */
}
}
void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
{
IRQn_Type irq_n = (IRQn_Type)0;
uint32_t vector = 0;
#if DEVICE_SERIAL_ASYNCH_DMA
IRQn_Type irqn_dma = (IRQn_Type)0;
uint32_t vector_dma = 0;
#endif
UartHandle.Instance = (USART_TypeDef *)SERIAL_OBJ(uart);
switch (SERIAL_OBJ(uart)) {
case UART_1:
irq_n = USART1_IRQn;
vector = (uint32_t)&uart1_irq;
break;
case UART_2:
irq_n = USART2_IRQn;
vector = (uint32_t)&uart2_irq;
break;
#if defined(USART3_BASE)
case UART_3:
irq_n = USART3_IRQn;
vector = (uint32_t)&uart3_irq;
break;
#endif
#if defined(UART4_BASE)
case UART_4:
irq_n = UART4_IRQn;
vector = (uint32_t)&uart4_irq;
#if DEVICE_SERIAL_ASYNCH_DMA
if (irq == RxIrq) {
irqn_dma = DMA1_Stream2_IRQn;
vector_dma = (uint32_t)&dma1_stream2_irq;
} else {
irqn_dma = DMA1_Stream4_IRQn;
vector_dma = (uint32_t)&dma1_stream4_irq;
}
#endif
break;
#endif
#if defined(UART5_BASE)
case UART_5:
irq_n = UART5_IRQn;
vector = (uint32_t)&uart5_irq;
break;
#endif
#if defined(USART6_BASE)
case UART_6:
irq_n = USART6_IRQn;
vector = (uint32_t)&uart6_irq;
break;
#endif
#if defined(UART7_BASE)
case UART_7:
irq_n = UART7_IRQn;
vector = (uint32_t)&uart7_irq;
break;
#endif
#if defined(UART8_BASE)
case UART_8:
irq_n = UART8_IRQn;
vector = (uint32_t)&uart8_irq;
break;
#endif
}
if (enable) {
if (irq == RxIrq) {
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);
#if DEVICE_SERIAL_ASYNCH_DMA
NVIC_SetVector(irq_n, vector_dma);
NVIC_EnableIRQ(irq_n);
NVIC_SetVector(irqn_dma, vector_dma);
NVIC_EnableIRQ(irqn_dma);
#else
NVIC_SetVector(irq_n, vector);
NVIC_EnableIRQ(irq_n);
#endif
} else { // TxIrq
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_TC);
NVIC_SetVector(irq_n, vector);
NVIC_EnableIRQ(irq_n);
#if DEVICE_SERIAL_ASYNCH_DMA
NVIC_SetVector(irqn_dma, vector_dma);
NVIC_EnableIRQ(irqn_dma);
#endif
}
} else { // disable
int all_disabled = 0;
if (irq == RxIrq) {
__HAL_UART_DISABLE_IT(&UartHandle, UART_IT_RXNE);
// Check if TxIrq is disabled too
if ((UartHandle.Instance->CR1 & USART_CR1_TXEIE) == 0) all_disabled = 1;
} else { // TxIrq
__HAL_UART_DISABLE_IT(&UartHandle, UART_IT_TXE);
// Check if RxIrq is disabled too
if ((UartHandle.Instance->CR1 & USART_CR1_RXNEIE) == 0) all_disabled = 1;
}
if (all_disabled) {
NVIC_DisableIRQ(irq_n);
#if DEVICE_SERIAL_ASYNCH_DMA
NVIC_DisableIRQ(irqn_dma);
#endif
}
}
}
void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
IRQn_Type irq_n = (IRQn_Type)0;
uint32_t vector = 0;
switch (obj_s->index) {
case 0:
irq_n = USART1_IRQn;
vector = (uint32_t)&uart1_irq;
break;
case 1:
irq_n = USART2_IRQn;
vector = (uint32_t)&uart2_irq;
break;
#if defined(USART3_BASE)
case 2:
irq_n = USART3_IRQn;
vector = (uint32_t)&uart3_irq;
break;
#endif
#if defined(UART4_BASE)
case 3:
irq_n = UART4_IRQn;
vector = (uint32_t)&uart4_irq;
break;
#endif
#if defined(UART5_BASE)
case 4:
irq_n = UART5_IRQn;
vector = (uint32_t)&uart5_irq;
break;
#endif
#if defined(USART6_BASE)
case 5:
irq_n = USART6_IRQn;
vector = (uint32_t)&uart6_irq;
break;
#endif
#if defined(UART7_BASE)
case 6:
irq_n = UART7_IRQn;
vector = (uint32_t)&uart7_irq;
break;
#endif
#if defined(UART8_BASE)
case 7:
irq_n = UART8_IRQn;
vector = (uint32_t)&uart8_irq;
break;
#endif
}
if (enable) {
if (irq == RxIrq) {
__HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
} else { // TxIrq
__HAL_UART_ENABLE_IT(huart, UART_IT_TC);
}
NVIC_SetVector(irq_n, vector);
NVIC_EnableIRQ(irq_n);
} else { // disable
int all_disabled = 0;
if (irq == RxIrq) {
__HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
// Check if TxIrq is disabled too
if ((huart->Instance->CR1 & USART_CR1_TXEIE) == 0) {
all_disabled = 1;
}
} else { // TxIrq
__HAL_UART_DISABLE_IT(huart, UART_IT_TC);
// Check if RxIrq is disabled too
if ((huart->Instance->CR1 & USART_CR1_RXNEIE) == 0) {
all_disabled = 1;
}
}
if (all_disabled) {
NVIC_DisableIRQ(irq_n);
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32L0xx HAL library initialization:
- Configure the Flash prefetch
- Configure the Systick to generate an interrupt each 1 msec
- Low Level Initialization */
HAL_Init();
/* Configure LED3 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 32 MHz */
SystemClock_Config();
/*##-1- Configure the LPUART peripheral ####################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* LPUART configured as follows:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = None
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
HAL_UART_DeInit(&UartHandle);
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
Error_Handler();
}
#ifdef BOARD_IN_STOP_MODE
BSP_LED_On(LED3);
/* wait for two seconds before test start */
HAL_Delay(2000);
/* make sure that no LPUART transfer is on-going */
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET);
/* make sure that UART is ready to receive
* (test carried out again later in HAL_UARTEx_StopModeWakeUpSourceConfig) */
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET);
/* set the wake-up event:
* specify wake-up on RXNE flag */
WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
{
Error_Handler();
}
/* Enable the LPUART Wake UP from stop mode Interrupt */
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);
/* about to enter stop mode: switch off LED */
BSP_LED_Off(LED3);
/* enable MCU wake-up by LPUART */
HAL_UARTEx_EnableStopMode(&UartHandle);
/* enter stop mode */
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
/* ... STOP mode ... */
SystemClock_Config_fromSTOP();
/* at that point, MCU has been awoken: the LED has been turned back on */
/* Wake Up based on RXNE flag successful */
HAL_UARTEx_DisableStopMode(&UartHandle);
/* wait for some delay */
HAL_Delay(100);
/* Inform other board that wake up is successful */
if (HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer1, COUNTOF(aTxBuffer1)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/*##-2- Wake Up second step ###############################################*/
/* make sure that no UART transfer is on-going */
BSP_LED_On(LED3);
/* wait for two seconds before test start */
HAL_Delay(2000);
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET);
/* make sure that LPUART is ready to receive
* (test carried out again later in HAL_UARTEx_StopModeWakeUpSourceConfig) */
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET);
/* set the wake-up event:
* specify wake-up on start-bit detection */
WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
{
Error_Handler();
}
/* Enable the LPUART Wake UP from stop mode Interrupt */
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);
/* about to enter stop mode: switch off LED */
BSP_LED_Off(LED3);
/* enable MCU wake-up by LPUART */
HAL_UARTEx_EnableStopMode(&UartHandle);
/* enter stop mode */
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
/* ... STOP mode ... */
SystemClock_Config_fromSTOP();
/* at that point, MCU has been awoken: the LED has been turned back on */
/* Wake Up on start bit detection successful */
HAL_UARTEx_DisableStopMode(&UartHandle);
/* wait for some delay */
HAL_Delay(100);
/* Inform other board that wake up is successful */
if (HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer2, COUNTOF(aTxBuffer2)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/*##-3- Wake Up third step ################################################*/
/* make sure that no LPUART transfer is on-going */
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET);
/* make sure that UART is ready to receive
* (test carried out again later in HAL_UARTEx_StopModeWakeUpSourceConfig) */
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET);
/* set the wake-up event:
* specify address-to-match type.
* The address is 0x29, meaning the character triggering the
* address match is 0xA9 */
WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_ADDRESS;
WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
WakeUpSelection.Address = 0x29;
if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
{
Error_Handler();
}
/* Enable the LPUART Wake UP from stop mode Interrupt */
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);
/* about to enter stop mode: switch off LED */
BSP_LED_Off(LED3);
/* enable MCU wake-up by LPUART */
HAL_UARTEx_EnableStopMode(&UartHandle);
/* enter stop mode */
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
/* ... STOP mode ... */
SystemClock_Config_fromSTOP();
/* at that point, MCU has been awoken: the LED has been turned back on */
/* Wake Up on 7-bit address detection successful */
HAL_UARTEx_DisableStopMode(&UartHandle);
/* wait for some delay */
HAL_Delay(100);
/* Inform other board that wake up is successful */
if (HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer3, COUNTOF(aTxBuffer3)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/*##-4- Wake Up fourth step ###############################################*/
/* make sure that no LPUART transfer is on-going */
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET);
/* make sure that UART is ready to receive
* (test carried out again later in HAL_UARTEx_StopModeWakeUpSourceConfig) */
while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET);
/* set the wake-up event:
* specify address-to-match type.
* The address is 0x2, meaning the character triggering the
* address match is 0x82 */
WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_ADDRESS;
WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_4B;
WakeUpSelection.Address = 0x2;
if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
{
Error_Handler();
}
/* Enable the LPUART Wake UP from stop mode Interrupt */
__HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);
/* about to enter stop mode: switch off LED */
BSP_LED_Off(LED3);
/* enable MCU wake-up by LPUART */
HAL_UARTEx_EnableStopMode(&UartHandle);
/* enter stop mode */
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
/* ... STOP mode ... */
SystemClock_Config_fromSTOP();
/* at that point, MCU has been awoken: the LED has been turned back on */
/* Wake Up on 4-bit address detection successful */
/* wait for some delay */
HAL_Delay(100);
/* Inform other board that wake up is successful */
if (HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer4, COUNTOF(aTxBuffer4)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
#else
/* initialize the User push-button in Interrupt mode */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);
/* Wait for User push-button press before starting the test.
In the meantime, LED3 is blinking */
while(UserButtonStatus == 0)
{
/* Toggle LED3 */
BSP_LED_Toggle(LED3);
HAL_Delay(100);
}
/*##-2- Send the wake-up from stop mode first trigger ######################*/
/* (RXNE flag setting) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger1, COUNTOF(aWakeUpTrigger1)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put LPUART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer1)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer1,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer1)-1))
{
Error_Handler();
}
/* wait for two seconds before test second step */
HAL_Delay(2000);
/*##-3- Send the wake-up from stop mode second trigger #####################*/
/* (start Bit detection) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger2, COUNTOF(aWakeUpTrigger2)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put LPUART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer2)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer2,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer2)-1))
{
Error_Handler();
}
/* wait for two seconds before test third step */
HAL_Delay(2000);
/*##-4- Send the wake-up from stop mode third trigger ######################*/
/* (7-bit address match) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger3, 1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put LPUART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer3)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer3,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer3)-1))
{
Error_Handler();
}
/* wait for two seconds before test fourth and last step */
HAL_Delay(2000);
/*##-5- Send the wake-up from stop mode fourth trigger #####################*/
/* (4-bit address match) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger4, 1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put LPUART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer4)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer4,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer4)-1))
{
Error_Handler();
}
HAL_Delay(2000);
#endif /* BOARD_IN_STOP_MODE */
/* Turn on LED3 & LED4 if test passes then enter infinite loop */
BSP_LED_On(LED3);
BSP_LED_On(LED4);
while (1)
{
}
}
