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 ) ;
}
