static void uart_irq(UARTName uart_name)
{
int8_t id = get_uart_index(uart_name);
if (id >= 0) {
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) {
irq_handler(serial_irq_ids[id], TxIrq);
}
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {
irq_handler(serial_irq_ids[id], RxIrq);
/* Flag has been cleared when reading the content */
}
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
}
}
}
}
}
/**
* @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
*/
void USART1_IRQHandler(void)
{
/* USER CODE BEGIN USART1_IRQn 0 */
uint8_t Res;
uint16_t len=0;
/* USER CODE END USART1_IRQn 0 */
HAL_UART_IRQHandler(&huart1);
/* USER CODE BEGIN USART1_IRQn 1 */
if(update==0)
{
if(__HAL_UART_GET_IT(&huart1, UART_IT_RXNE) != RESET)//接收到中断（接收到的数据必须是0x0d 0x0a结尾）
{
USART1->RQR |= 0x08;//?? RXNE
Res =USART1->RDR;//USARTx_RX_Data(&UartHandle);
if((USART_RX_STA&0x8000)==0)//接收未完成
{
if(USART_RX_STA&0x4000)//接收到了0x0d
{
if(Res!=0x0a)USART_RX_STA=0;//接收错误，重新开始
else USART_RX_STA|=0x8000; //接收完成
}
else //还没有接受到0X0D
{
if(Res==0x0d)USART_RX_STA|=0x4000;
else
{
if(Res != 0x00)
{
USART_RX_BUF1[USART_RX_STA&0X3FFF]=Res ;
USART_RX_STA++;
if(USART_RX_STA>49)USART_RX_STA=0;// 接收数据错误，重新开始接收
}
}
}
}
}
}
else
{
if(__HAL_UART_GET_IT(&huart1, UART_IT_RXNE) != RESET)//接收到中断（接收到的数据必须是0x0d 0x0a结尾）
{
USART1->RQR |= 0x08;//?? RXNE
Res =USART1->RDR;//USARTx_RX_Data(&UartHandle);
if(USART_RX_CNT<USART_REC_LEN)
{
if(Res != 0x00)
{
USART_RX_BUF[USART_RX_CNT]=Res;
USART_RX_CNT++;
}
}
}
}
HAL_NVIC_ClearPendingIRQ(USART1_IRQn);
/* USER CODE END USART1_IRQn 1 */
}
void USART6_IRQHandler(void) {
volatile int8_t value;
if (__HAL_UART_GET_IT(&UartHandle6, UART_IT_RXNE) != RESET) {
// wenn ein Byte im Empfangspuffer steht
value = (int8_t)((USART6->RDR) & 0xFF);
// if(dataokold==dataok) return;
if (rxrdy == 0)
return;
if (count1 == 0) {
dataok = 0;
if (value != 85)
return; // wait for startpattern 0x55
else
rx_oldptr6 = rx_wr_ptr6;
}
rx_buf6[rx_wr_ptr6] = value; // byte speichern
count1++;
++rx_wr_ptr6;
if (rx_wr_ptr6 >= RX_BUF_SIZE - 6) { // ring buffer
rx_wr_ptr6 = 0;
}
if (count1 == 6) {
count1 = 0;
if (value != 160)
return; // no end- pattern 0xAA
else {
dataok = 1;
return;
}
}
}
}
/**
* @brief This function handles USART2 global interrupt / USART2 wake-up interrupt through EXTI line 26.
*/
void USART2_IRQHandler(void)
{
/* USER CODE BEGIN USART2_IRQn 0 */
uint8_t Res;
/* USER CODE END USART2_IRQn 0 */
HAL_UART_IRQHandler(&huart2);
/* USER CODE BEGIN USART2_IRQn 1 */
if(__HAL_UART_GET_IT(&huart2, UART_IT_RXNE) != RESET)//接收到中断（接收到的数据必须是0x0d 0x0a结尾）
{
USART2->RQR |= 0x08;//?? RXNE
Res =USART2->RDR;//USARTx_RX_Data(&UartHandle);
if((USART_RX_STA2&0x8000)==0)//接收未完成
{
if(USART_RX_STA2&0x4000)//接收到了0x0d
{
if(Res!=0x0a)USART_RX_STA2=0;//接收错误，重新开始
else USART_RX_STA2|=0x8000; //接收完成
}
else //还没有接受到0X0D
{
if(Res==0x0d)USART_RX_STA2|=0x4000;
else
{
USART_RX_BUF2[USART_RX_STA2&0X3FFF]=Res ;
USART_RX_STA2++;
if(USART_RX_STA2>(USART_REC_LEN-1))USART_RX_STA2=0;// 接收数据错误，重新开始接收
}
}
}
}
HAL_NVIC_ClearPendingIRQ(USART2_IRQn);
/* USER CODE END USART2_IRQn 1 */
}
int uart_pgetc(int port)
{
if ((__HAL_UART_GET_IT(&handle, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_RXNE) != RESET)) {
uint8_t c = (uint8_t)(handle.Instance->RDR & 0xff);
return c;
}
return -1;
}
void stm32_USART1_IRQ(void)
{
bool resched = false;
arm_cm_irq_entry();
/* UART parity error interrupt occurred -------------------------------------*/
if ((__HAL_UART_GET_IT(&handle, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_PE) != RESET)) {
__HAL_UART_CLEAR_PEFLAG(&handle);
printf("UART PARITY ERROR\n");
}
/* UART frame error interrupt occurred --------------------------------------*/
if ((__HAL_UART_GET_IT(&handle, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_ERR) != RESET)) {
__HAL_UART_CLEAR_FEFLAG(&handle);
printf("UART FRAME ERROR\n");
}
/* UART noise error interrupt occurred --------------------------------------*/
if ((__HAL_UART_GET_IT(&handle, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_ERR) != RESET)) {
__HAL_UART_CLEAR_NEFLAG(&handle);
printf("UART NOISE ERROR\n");
}
/* UART Over-Run interrupt occurred -----------------------------------------*/
if ((__HAL_UART_GET_IT(&handle, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_ERR) != RESET)) {
__HAL_UART_CLEAR_OREFLAG(&handle);
printf("UART OVERRUN ERROR\n");
}
/* UART in mode Receiver ---------------------------------------------------*/
if ((__HAL_UART_GET_IT(&handle, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_RXNE) != RESET)) {
/* we got a character */
uint8_t c = (uint8_t)(handle.Instance->RDR & 0xff);
if (cbuf_write_char(&uart1_rx_buf, c, false) != 1) {
printf("WARNING: uart cbuf overrun!\n");
}
resched = true;
/* Clear RXNE interrupt flag */
__HAL_UART_SEND_REQ(&handle, UART_RXDATA_FLUSH_REQUEST);
}
/* UART in mode Transmitter ------------------------------------------------*/
if ((__HAL_UART_GET_IT(&handle, UART_IT_TXE) != RESET) &&(__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_TXE) != RESET)) {
;
}
/* UART in mode Transmitter (transmission end) -----------------------------*/
if ((__HAL_UART_GET_IT(&handle, UART_IT_TC) != RESET) &&(__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_TC) != RESET)) {
;
}
arm_cm_irq_exit(resched);
}
void UART_ProcessStatus(UART_HandleTypeDef* pUart) {
/* UART parity error interrupt occurred ------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_PE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_PE) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_PEF);
pUart->ErrorCode |= HAL_UART_ERROR_PE;
}
/* UART frame error interrupt occurred --------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_FE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_FEF);
pUart->ErrorCode |= HAL_UART_ERROR_FE;
}
/* UART noise error interrupt occurred --------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_NE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_NEF);
pUart->ErrorCode |= HAL_UART_ERROR_NE;
}
/* UART Over-Run interrupt occurred -----------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_ORE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_OREF);
pUart->ErrorCode |= HAL_UART_ERROR_ORE;
}
/* Call UART Error Call back function if need be --------------------------*/
if (pUart->ErrorCode != HAL_UART_ERROR_NONE)
{
HAL_UART_ErrorCallback(pUart);
}
/* UART Wake Up interrupt occurred ------------------------------------------*/
if ((__HAL_UART_GET_IT(pUart, UART_IT_WUF) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_WUF) != RESET))
{
__HAL_UART_CLEAR_IT(pUart, UART_CLEAR_WUF);
HAL_UARTEx_WakeupCallback(pUart);
}
}
void UART7_IRQHandler(void) {
volatile uint8_t value;
if (__HAL_UART_GET_IT(&UartHandle7, UART_IT_RXNE) != RESET) {
// wenn ein Byte im Empfangspuffer steht
value = (uint8_t)(UART7->RDR & 0xFF);
// byte speichern
rx_buf7[rx_wr_ptr7] = value;
rx_wr_ptr7++;
if (rx_wr_ptr7 >= RX_BUF_SIZE)
rx_wr_ptr7 = 0;
}
}
void USART3_IRQHandler(void)
{
struct stm32_uart *uart;
uart = &uart3;
/* enter interrupt */
rt_interrupt_enter();
/* UART in mode Receiver ---------------------------------------------------*/
if ((__HAL_UART_GET_IT(&uart->UartHandle, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&uart->UartHandle, UART_IT_RXNE) != RESET))
{
rt_hw_serial_isr(&serial3, RT_SERIAL_EVENT_RX_IND);
/* Clear RXNE interrupt flag */
__HAL_UART_SEND_REQ(&uart->UartHandle, UART_RXDATA_FLUSH_REQUEST);
}
/* leave interrupt */
rt_interrupt_leave();
}
void USART1_IRQHandler(void) {
volatile uint8_t value;
if (__HAL_UART_GET_IT(&UartHandle1, UART_IT_RXNE) != RESET) {
// wenn ein Byte im Empfangspuffer steht
value = (uint8_t)(USART1->RDR & 0xFF);
// byte speichern
if (rx_select == 0) // ** WK
rx_buf1[rx_wr_ptr1] = value;
else // **
rx_buf2[rx_wr_ptr1] = value; // **
rx_wr_ptr1++;
if (rx_wr_ptr1 >= RX_BUF_SIZE) {
rx_rdy = 1;
rx_wr_ptr1 = 0;
if (rx_select == 0)
rx_select = 1; // **
else
rx_select = 0; // **
}
}
}
bool UART_GetCharacter(UART_HandleTypeDef* pUart, uint8_t* pChar) {
UART_ProcessStatus(pUart);
/* UART in mode Receiver ---------------------------------------------------*/
if((__HAL_UART_GET_IT(pUart, UART_IT_RXNE) != RESET) &&
(__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_RXNE) != RESET))
{
if((pUart->gState == HAL_UART_STATE_BUSY_RX) || (pUart->gState == HAL_UART_STATE_BUSY_TX_RX))
{
*pChar = (uint8_t) (pUart->Instance->RDR & (uint8_t) pUart->Mask);
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
/**
* @brief This function handles UART interrupt request.
* @param huart: uart handle
* @retval None
*/
void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
{
/* UART parity error interrupt occurred -------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);
huart->ErrorCode |= HAL_UART_ERROR_PE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* UART frame error interrupt occured --------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
huart->ErrorCode |= HAL_UART_ERROR_FE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* UART noise error interrupt occured --------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
huart->ErrorCode |= HAL_UART_ERROR_NE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* UART Over-Run interrupt occured -----------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
huart->ErrorCode |= HAL_UART_ERROR_ORE;
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
}
/* Call UART Error Call back function if need be --------------------------*/
if(huart->ErrorCode != HAL_UART_ERROR_NONE)
{
HAL_UART_ErrorCallback(huart);
}
#if !defined(STM32F030x6) && !defined(STM32F030x8)
/* UART wakeup from Stop mode interrupt occurred -------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_WUF) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_WUF) != RESET))
{
__HAL_UART_CLEAR_IT(huart, UART_CLEAR_WUF);
/* Set the UART state ready to be able to start again the process */
huart->State = HAL_UART_STATE_READY;
HAL_UART_WakeupCallback(huart);
}
#endif /* !defined(STM32F030x6) && !defined(STM32F030x8) */
/* UART in mode Receiver ---------------------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET))
{
UART_Receive_IT(huart);
/* Clear RXNE interrupt flag */
__HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
}
/* UART in mode Transmitter ------------------------------------------------*/
if((__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) &&(__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET))
{
UART_Transmit_IT(huart);
}
}
/**
* The asynchronous TX and RX handler.
*
* @param obj The serial object
* @return Returns event flags if a TX/RX transfer termination condition was met or 0 otherwise
*/
int serial_irq_handler_asynch(serial_t *obj)
{
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 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) {
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 return_event;
}
//RX PART
if (huart->RxXferSize != 0) {
obj->rx_buff.pos = huart->RxXferSize - huart->RxXferCount;
}
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) {
for (i = 0; i < obj->rx_buff.pos; i++) {
if (buf[i] == obj->char_match) {
obj->rx_buff.pos = i;
return_event |= (SERIAL_EVENT_RX_CHARACTER_MATCH & obj_s->events);
serial_rx_abort_asynch(obj);
break;
}
}
}
}
return return_event;
}
