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); }
/** Abort the ongoing RX transaction It disables the enabled interrupt for RX and * flush RX hardware buffer if RX FIFO is used * * @param obj The serial object */ void serial_rx_abort_asynch(serial_t *obj) { UART_HandleTypeDef *handle = &UartHandle[SERIAL_OBJ(index)]; __HAL_UART_DISABLE_IT(handle, UART_IT_RXNE); // clear flags __HAL_UART_CLEAR_PEFLAG(handle); // reset states handle->RxXferCount = 0; // update handle state handle->gState = HAL_UART_STATE_READY; }
/** 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 serial_tx_abort_asynch(serial_t *obj) { UART_HandleTypeDef *handle = &UartHandle[obj->serial.module]; // stop interrupts handle->Instance->CR1 &= ~(USART_CR1_TCIE | USART_CR1_TXEIE); // clear flags __HAL_UART_CLEAR_PEFLAG(handle); // reset states handle->TxXferCount = 0; // update handle state if(handle->State == HAL_UART_STATE_BUSY_TX_RX) { handle->State = HAL_UART_STATE_BUSY_RX; } else { handle->State = HAL_UART_STATE_READY; } }
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) { // TODO: DMA usage is currently ignored (void) hint; bool use_rx = (rx != NULL && rx_length > 0); IRQn_Type irq_n = UartIRQs[obj->serial.module]; if (!use_rx || !irq_n) return; obj->rx_buff.buffer = rx; obj->rx_buff.length = rx_length; obj->rx_buff.pos = 0; obj->rx_buff.width = rx_width; obj->serial.event = (obj->serial.event & ~SERIAL_EVENT_RX_MASK) | (event & SERIAL_EVENT_RX_MASK); obj->serial.char_match = char_match; UART_HandleTypeDef *handle = &UartHandle[obj->serial.module]; // register the thunking handler vIRQ_SetVector(irq_n, handler); vIRQ_EnableIRQ(irq_n); // HAL_StatusTypeDef rc = HAL_UART_Receive_IT(handle, rx, rx_length); handle->pRxBuffPtr = rx; handle->RxXferSize = rx_length; handle->RxXferCount = rx_length; if(handle->State == HAL_UART_STATE_BUSY_TX) { handle->State = HAL_UART_STATE_BUSY_TX_RX; } else { handle->State = HAL_UART_STATE_BUSY_RX; } __HAL_UART_CLEAR_PEFLAG(handle); handle->Instance->CR1 |= USART_CR1_RXNEIE | USART_CR1_PEIE; handle->Instance->CR3 |= USART_CR3_EIE; 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)); }
static void TM_USART_INT_ClearAllFlags(USART_TypeDef* USARTx, IRQn_Type irq) { UART_Handle.Instance = USARTx; #ifdef __HAL_UART_CLEAR_PEFLAG __HAL_UART_CLEAR_PEFLAG(&UART_Handle); #endif #ifdef __HAL_UART_CLEAR_FEFLAG __HAL_UART_CLEAR_FEFLAG(&UART_Handle); #endif #ifdef __HAL_UART_CLEAR_NEFLAG __HAL_UART_CLEAR_NEFLAG(&UART_Handle); #endif #ifdef __HAL_UART_CLEAR_OREFLAG __HAL_UART_CLEAR_OREFLAG(&UART_Handle); #endif #ifdef __HAL_UART_CLEAR_IDLEFLAG __HAL_UART_CLEAR_IDLEFLAG(&UART_Handle); #endif /* Clear IRQ bit */ HAL_NVIC_ClearPendingIRQ(irq); }
void CommUartIrqHandler(UART_HandleTypeDef *huart) { uint32_t tmp_flag = 0, tmp_it_source = 0; tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_PE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE); /* UART parity error interrupt occurred ------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_PEFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_PE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_FE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR); /* UART frame error interrupt occurred -------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_FEFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_FE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_NE); /* UART noise error interrupt occurred -------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_NEFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_NE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_ORE); /* UART Over-Run interrupt occurred ----------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_OREFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_ORE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE); /* UART in mode Receiver ---------------------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { CommUartRxIrqProcess(huart); } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_TXE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_TXE); /* UART in mode Transmitter ------------------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { CommUartTxIrqProcess(huart); } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_TC); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC); /* UART in mode Transmitter end --------------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { } if (huart->ErrorCode != HAL_UART_ERROR_NONE) { /* Set the UART state ready to be able to start again the process */ huart->State = HAL_UART_STATE_READY; HAL_UART_ErrorCallback(huart); } }
T_Boolean WifiCom_Gestion ( void ) { static uint32_t time_out_wifi = 2000 ; static uint32_t time_out_transport = 0 ; static uint32_t Date_Envoi = 500 ; static T_Boolean Demande_Initialisation = FAUX ; T_Boolean etat_com_wifi = VRAI ; if ( Demande_Initialisation == VRAI ) { if ( time_out_wifi <= HAL_GetTick () ) { Demande_Initialisation = FAUX ; #ifdef DEBUG_WIFI ++CPT_Demande_Initialisation ; #endif WifiCom_Communication_Start () ; time_out_wifi = HAL_GetTick () + 1000 ; } } else { if ( Si_Recu_De_Wifi() ) { T_Ack_Nack qualite = WifiCom_Lire_Data ( &Wifi_Buf_Rec [Idc_Buf_Rec_Lec] ) ; Mise_A_Jour_Idc_Buf_Lec_Ecr() ; switch ( qualite ) { case ACK_MSG : #ifdef DEBUG_WIFI ++Msg_Requete_TxAck ; #endif // on a reçu un message transport alors envoyer un message de service avec ack ou nack, ou un message normal en erreur envoyer NACK WifiCom_Transmit_Service ( REQUETE_ACK_NACK, qualite, 0 ) ; break ; case NACK_MSG : #ifdef DEBUG_WIFI ++Msg_Requete_TxNack ; #endif // on a reçu un message transport alors envoyer un message de service avec ack ou nack, ou un message normal en erreur envoyer NACK WifiCom_Transmit_Service ( REQUETE_ACK_NACK, qualite, 0 ) ; break ; case ERREUR_SYNCHRO : Demande_Initialisation = VRAI ; HAL_UART_DMAStop ( &Wifi_Com_Uart) ; /* Lance une petite tempo pour permettre à l'it Rx générée par AbortDMA de passer avant la réinitialisation */ time_out_wifi = HAL_GetTick () + 5 ; return ( VRAI ) ; default : break ; } time_out_wifi = HAL_GetTick () + (10 * PERIODE_ENVOI_WIFI) ; // ms } else { if ( time_out_wifi <= HAL_GetTick () ) { #ifdef DEBUG_WIFI ++CPT_time_out_wifi ; #endif __HAL_UART_CLEAR_PEFLAG(&Wifi_Com_Uart); // Demande_Initialisation = VRAI ; // HAL_UART_DMAStop ( &Wifi_Com_Uart) ; /* Lance une petite tempo pour permettre à l'it Rx générée par AbortDMA de passer avant la réinitialisation */ // time_out_wifi = HAL_GetTick () + 5 ; time_out_wifi = HAL_GetTick () + (10 * PERIODE_ENVOI_WIFI) ; return ( FAUX ) ; } } int8_t status = HAL_ERROR ; switch ( Transport_Emis.Etat_Transport ) { case DISPO : /* Selon la position de l'automate demandé par le distant , envoi du message */ if ( Presence_Host == HOST_DEFAUT ) { WifiCom_Transmit_Service ( REQUETE_RESET_WIFI, 0, 0 ) ; Presence_Host = HOST_ABSENT ; } else { switch ( Requete_Exterieure ) { case REQUETE_MSG_REGLAGE : if ( Date_Envoi <= HAL_GetTick () ) { if ( (status = WifiCom_Transmit_Reglage()) == HAL_OK ) { #ifdef DEBUG_WIFI ++Mesg_reglage_Tx ; #endif } } break ; default : break ; } } break ; case DEMANDE : if ( Date_Envoi <= HAL_GetTick () ) { if ( (status = WifiCom_Transmit_NextPacket ()) == HAL_OK ) { Transport_Emis.Etat_Transport = EN_COUR ; Transport_Emis.Buf->Etat_Transport = EN_COUR ; /* arme time-out réception */ time_out_transport = HAL_GetTick () + 10 ; // < à 6,5 ms max pour transfert d'un message de 2000 octets } } break ; case DONE : #ifdef DEBUG_WIFI ++ Mesg_transport_Tx ; #endif Transport_Emis.Etat_Transport_Precedent = DONE ; Transport_Emis.Etat_Transport = DISPO ; Transport_Emis.Buf->Etat_Transport = DISPO ; break ; case ABORT : #ifdef DEBUG_WIFI ++ Mesg_transport_Abort ; #endif Transport_Emis.Etat_Transport_Precedent = ABORT ; Transport_Emis.Etat_Transport = DISPO ; Transport_Emis.Buf->Etat_Transport = DISPO ; break ; case EN_COUR : if ( time_out_transport <= HAL_GetTick () ) Transport_Emis.Etat_Transport = ABORT ; // abort transport car pas de réponse de la carte WIFI break ; default : break ; } if ( status == HAL_OK ) { /* un envoi a eu lieu calcule prochaine date d'envoi */ Date_Envoi = HAL_GetTick () + PERIODE_ENVOI_WIFI ; } } return ( etat_com_wifi ) ; }