Merge pull request #4707 from LMESTM/stm32_serial_it_source

0xc0170 · web-flow · commit 59dd8592102c · 2017-07-13T16:40:16.000+02:00
STM32: serial: use proper macro to check  interrupt
diff --git a/targets/TARGET_STM/TARGET_STM32F0/serial_device.c b/targets/TARGET_STM/TARGET_STM32F0/serial_device.c
@@ -265,20 +265,20 @@ static void uart_irq(int id)
     
     if (serial_irq_ids[id] != 0) {
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {
                 irq_handler(serial_irq_ids[id], TxIrq);
                 __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {
                 irq_handler(serial_irq_ids[id], RxIrq);
                 volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE flag
                 UNUSED(tmpval);
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
                 __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);
             }
         }
@@ -780,19 +780,19 @@ int serial_irq_handler_asynch(serial_t *obj)
     
     // Handle error events
     if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
-        if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != RESET) {
+        if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
             return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
         }
     }
diff --git a/targets/TARGET_STM/TARGET_STM32F3/serial_device.c b/targets/TARGET_STM/TARGET_STM32F3/serial_device.c
@@ -211,20 +211,20 @@ static void uart_irq(int id)
     
     if (serial_irq_ids[id] != 0) {
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {
             irq_handler(serial_irq_ids[id], TxIrq);
                 __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
         }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {
             irq_handler(serial_irq_ids[id], RxIrq);
                 volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE flag
                 UNUSED(tmpval);
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
                 __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);
             }
         }
@@ -679,19 +679,19 @@ int serial_irq_handler_asynch(serial_t *obj)
     
     // Handle error events
     if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
-        if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != RESET) {
+        if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
             return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
         }
     }
diff --git a/targets/TARGET_STM/TARGET_STM32F7/serial_device.c b/targets/TARGET_STM/TARGET_STM32F7/serial_device.c
@@ -239,19 +239,19 @@ static void uart_irq(int id)
     
     if (serial_irq_ids[id] != 0) {
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {
                 irq_handler(serial_irq_ids[id], TxIrq);
                 __HAL_UART_CLEAR_IT(huart, UART_CLEAR_TCF);
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {
                 irq_handler(serial_irq_ids[id], RxIrq);
                 volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
                 __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
             }
         }
@@ -744,19 +744,19 @@ int serial_irq_handler_asynch(serial_t *obj)
     
     // Handle error events
     if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
-        if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != RESET) {
+        if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
             return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
         }
     }
diff --git a/targets/TARGET_STM/TARGET_STM32L0/serial_device.c b/targets/TARGET_STM/TARGET_STM32L0/serial_device.c
@@ -202,19 +202,19 @@ static void uart_irq(int id)
     
     if (serial_irq_ids[id] != 0) {
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {
                 irq_handler(serial_irq_ids[id], TxIrq);
                 __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {
                 irq_handler(serial_irq_ids[id], RxIrq);
                 volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE flag
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
                 __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);
             }
         }
@@ -645,27 +645,27 @@ int serial_irq_handler_asynch(serial_t *obj)
     
     // Handle error events
     if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
-        if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
             __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF);
+        if (__HAL_UART_GET_IT(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != RESET) {
+        if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {
             __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_FEF);
             return_event |= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);
         }
     }
     
     if (__HAL_UART_GET_FLAG(huart, UART_FLAG_NE) != RESET) {
-        if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
+        if (__HAL_UART_GET_IT(huart, UART_IT_NE) != RESET) {
             __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_NEF);
         }
     }
     
     if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
-        if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
+        if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
             __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);
             return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
         }
diff --git a/targets/TARGET_STM/TARGET_STM32L4/serial_device.c b/targets/TARGET_STM/TARGET_STM32L4/serial_device.c
@@ -218,19 +218,19 @@ static void uart_irq(int id)
     
     if (serial_irq_ids[id] != 0) {
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {
             irq_handler(serial_irq_ids[id], TxIrq);
                 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {
             irq_handler(serial_irq_ids[id], RxIrq);
                 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
             }
         }
         if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
-            if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET) {
+            if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
                 volatile uint32_t tmpval = huart->Instance->RDR; // Clear ORE flag
             }
         }
@@ -697,19 +697,19 @@ int serial_irq_handler_asynch(serial_t *obj)
     
     // Handle error events
     if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
-        if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != 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_SOURCE(huart, USART_IT_ERR) != RESET) {
+        if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
             return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -265,20 +265,20 @@ static void uart_irq(int id)`
`265`	`265`
`266`	`266`	`if (serial_irq_ids[id] != 0) {`
`267`	`267`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {`
`268`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {`
	`268`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {`
`269`	`269`	`irq_handler(serial_irq_ids[id], TxIrq);`
`270`	`270`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {`
`274`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {`
	`274`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {`
`275`	`275`	`irq_handler(serial_irq_ids[id], RxIrq);`
`276`	`276`	`volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE flag`
`277`	`277`	`UNUSED(tmpval);`
`278`	`278`	`}`
`279`	`279`	`}`
`280`	`280`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`281`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {`
	`281`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`282`	`282`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);`
`283`	`283`	`}`
`284`	`284`	`}`
`@@ -780,19 +780,19 @@ int serial_irq_handler_asynch(serial_t *obj)`
`780`	`780`
`781`	`781`	`// Handle error events`
`782`	`782`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {`
`783`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`783`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) {`
`784`	`784`	`return_event \|= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);`
`785`	`785`	`}`
`786`	`786`	`}`
`787`	`787`
`788`	`788`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {`
`789`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`789`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {`
`790`	`790`	`return_event \|= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);`
`791`	`791`	`}`
`792`	`792`	`}`
`793`	`793`
`794`	`794`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`795`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`795`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`796`	`796`	`return_event \|= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);`
`797`	`797`	`}`
`798`	`798`	`}`
Original file line number	Diff line number	Diff line change
`@@ -211,20 +211,20 @@ static void uart_irq(int id)`
`211`	`211`
`212`	`212`	`if (serial_irq_ids[id] != 0) {`
`213`	`213`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {`
`214`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {`
	`214`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {`
`215`	`215`	`irq_handler(serial_irq_ids[id], TxIrq);`
`216`	`216`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {`
`220`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {`
	`220`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {`
`221`	`221`	`irq_handler(serial_irq_ids[id], RxIrq);`
`222`	`222`	`volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE flag`
`223`	`223`	`UNUSED(tmpval);`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`227`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {`
	`227`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`228`	`228`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);`
`229`	`229`	`}`
`230`	`230`	`}`
`@@ -679,19 +679,19 @@ int serial_irq_handler_asynch(serial_t *obj)`
`679`	`679`
`680`	`680`	`// Handle error events`
`681`	`681`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {`
`682`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`682`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) {`
`683`	`683`	`return_event \|= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);`
`684`	`684`	`}`
`685`	`685`	`}`
`686`	`686`
`687`	`687`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {`
`688`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`688`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {`
`689`	`689`	`return_event \|= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);`
`690`	`690`	`}`
`691`	`691`	`}`
`692`	`692`
`693`	`693`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`694`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`694`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`695`	`695`	`return_event \|= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);`
`696`	`696`	`}`
`697`	`697`	`}`
Original file line number	Diff line number	Diff line change
`@@ -239,19 +239,19 @@ static void uart_irq(int id)`
`239`	`239`
`240`	`240`	`if (serial_irq_ids[id] != 0) {`
`241`	`241`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {`
`242`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {`
	`242`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {`
`243`	`243`	`irq_handler(serial_irq_ids[id], TxIrq);`
`244`	`244`	`__HAL_UART_CLEAR_IT(huart, UART_CLEAR_TCF);`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {`
`248`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {`
	`248`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {`
`249`	`249`	`irq_handler(serial_irq_ids[id], RxIrq);`
`250`	`250`	`volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`254`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {`
	`254`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`255`	`255`	`__HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);`
`256`	`256`	`}`
`257`	`257`	`}`
`@@ -744,19 +744,19 @@ int serial_irq_handler_asynch(serial_t *obj)`
`744`	`744`
`745`	`745`	`// Handle error events`
`746`	`746`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {`
`747`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`747`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) {`
`748`	`748`	`return_event \|= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);`
`749`	`749`	`}`
`750`	`750`	`}`
`751`	`751`
`752`	`752`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {`
`753`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`753`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {`
`754`	`754`	`return_event \|= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);`
`755`	`755`	`}`
`756`	`756`	`}`
`757`	`757`
`758`	`758`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`759`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`759`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`760`	`760`	`return_event \|= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);`
`761`	`761`	`}`
`762`	`762`	`}`
Original file line number	Diff line number	Diff line change
`@@ -202,19 +202,19 @@ static void uart_irq(int id)`
`202`	`202`
`203`	`203`	`if (serial_irq_ids[id] != 0) {`
`204`	`204`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {`
`205`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {`
	`205`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {`
`206`	`206`	`irq_handler(serial_irq_ids[id], TxIrq);`
`207`	`207`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {`
`211`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {`
	`211`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {`
`212`	`212`	`irq_handler(serial_irq_ids[id], RxIrq);`
`213`	`213`	`volatile uint32_t tmpval = huart->Instance->RDR; // Clear RXNE flag`
`214`	`214`	`}`
`215`	`215`	`}`
`216`	`216`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`217`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ORE) != RESET) {`
	`217`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`218`	`218`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);`
`219`	`219`	`}`
`220`	`220`	`}`
`@@ -645,27 +645,27 @@ int serial_irq_handler_asynch(serial_t *obj)`
`645`	`645`
`646`	`646`	`// Handle error events`
`647`	`647`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {`
`648`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
`649`	`648`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF);`
	`649`	`+ if (__HAL_UART_GET_IT(huart, USART_IT_ERR) != RESET) {`
`650`	`650`	`return_event \|= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);`
`651`	`651`	`}`
`652`	`652`	`}`
`653`	`653`
`654`	`654`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {`
`655`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`655`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {`
`656`	`656`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_FEF);`
`657`	`657`	`return_event \|= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);`
`658`	`658`	`}`
`659`	`659`	`}`
`660`	`660`
`661`	`661`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_NE) != RESET) {`
`662`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`662`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_NE) != RESET) {`
`663`	`663`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_NEF);`
`664`	`664`	`}`
`665`	`665`	`}`
`666`	`666`
`667`	`667`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`668`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`668`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`669`	`669`	`__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);`
`670`	`670`	`return_event \|= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);`
`671`	`671`	`}`
Original file line number	Diff line number	Diff line change
`@@ -218,19 +218,19 @@ static void uart_irq(int id)`
`218`	`218`
`219`	`219`	`if (serial_irq_ids[id] != 0) {`
`220`	`220`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {`
`221`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {`
	`221`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) {`
`222`	`222`	`irq_handler(serial_irq_ids[id], TxIrq);`
`223`	`223`	`__HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {`
`227`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {`
	`227`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {`
`228`	`228`	`irq_handler(serial_irq_ids[id], RxIrq);`
`229`	`229`	`__HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`233`		`- if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET) {`
	`233`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`234`	`234`	`volatile uint32_t tmpval = huart->Instance->RDR; // Clear ORE flag`
`235`	`235`	`}`
`236`	`236`	`}`
`@@ -697,19 +697,19 @@ int serial_irq_handler_asynch(serial_t *obj)`
`697`	`697`
`698`	`698`	`// Handle error events`
`699`	`699`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {`
`700`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`700`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) {`
`701`	`701`	`return_event \|= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);`
`702`	`702`	`}`
`703`	`703`	`}`
`704`	`704`
`705`	`705`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {`
`706`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`706`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {`
`707`	`707`	`return_event \|= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);`
`708`	`708`	`}`
`709`	`709`	`}`
`710`	`710`
`711`	`711`	`if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {`
`712`		`- if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {`
	`712`	`+ if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {`
`713`	`713`	`return_event \|= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);`
`714`	`714`	`}`
`715`	`715`	`}`