/**
* Initialize particular pins to output mode,
* enable GPIO interrupts on ZX_RD and ZX_WRITE,
* keep ZX Spectrum stopped (via ZX_RESET)
*/
void zx_init_pins(void) {
// make sure we do not handle any ZX control operations
clear_zx_control_lines_handlers();
ASSERT_ZX_RESET();
init_output_od(ZX_RESET_GPIO_Port, ZX_RESET_Pin);
DEASSERT_ZX_WAIT();
init_output_pp(ZX_WAIT_GPIO_Port, ZX_WAIT_Pin);
// disable internal ZX ROM permanently
DEASSERT_ZX_ROMCS();
init_output_pp(ZX_ROMCS_GPIO_Port, ZX_ROMCS_Pin);
// make sure ZX Spectrum is stopped
ASSERT_ZX_RESET();
/* EXTI interrupt init*/
HAL_NVIC_ClearPendingIRQ(EXTI9_5_IRQn);
HAL_NVIC_SetPriority(EXTI9_5_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
HAL_NVIC_ClearPendingIRQ(EXTI4_IRQn);
HAL_NVIC_SetPriority(EXTI4_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI4_IRQn);
}
extern "C" void SPI3_IRQHandler()
{
HAL_NVIC_ClearPendingIRQ(SPI3_IRQn);
if (spiMap[2]) {
spiMap[2]->handleIrq();
}
}
/**
* @brief This function handles EXTI Line[9:5] interrupts.
*/
void EXTI9_5_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(EXTI9_5_IRQn);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9);
}
/**
* @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 */
}
/**
* @brief This function handles EXTI Line[9:5] interrupts.
*/
void EXTI9_5_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(EXTI9_5_IRQn);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8); /* MPU9250 on navX-MXP, navX-PI */
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9); /* CAL BTN on navX-MXP */
}
//DMA2 Stream6 - USART6 TX
void DMA2_Stream6_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(DMA2_Stream6_IRQn);
HAL_DMA_IRQHandler(&hdma2_str6_ch5);
}
void EXTI0_IRQHandler()
{
if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0)) {
ExpLedToggle(RED_LED);
while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0));
HAL_NVIC_ClearPendingIRQ(EXTI0_IRQn);
}
}
/**
* @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 callback_MPU6050(void){
static uint32_t last = 0;
uint32_t current = HAL_GetTick10u();
timeDiffMPU = current - last;
last = current;
MPU6050_GetRawAccelGyro(acceltempgyroVals); // GET ACCLEx3 TEMP GYROx3
filterMain(); // FILTER MPU DATA
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_3);
HAL_NVIC_ClearPendingIRQ(EXTI3_IRQn);
}
/**
* @brief Enable SPI IRQ.
* @param None
* @retval None
*/
static void Enable_SPI_Receiving_Path(void)
{
__HAL_GPIO_EXTI_CLEAR_IT(BNRG_SPI_EXTI_PIN);
HAL_NVIC_ClearPendingIRQ(BNRG_SPI_EXTI_IRQn);
HAL_NVIC_EnableIRQ(BNRG_SPI_EXTI_IRQn);
if (HAL_GPIO_ReadPin(BNRG_SPI_IRQ_PORT, BNRG_SPI_IRQ_PIN) == GPIO_PIN_SET)
{
__HAL_GPIO_EXTI_GENERATE_SWIT(BNRG_SPI_IRQ_PIN);
}
}
/**
* @brief This function handles USB On-The-Go FS Wakeup through EXTI Line18 interrupt.
*/
void OTG_FS_WKUP_IRQHandler(void)
{
/* USER CODE BEGIN OTG_FS_WKUP_IRQn 0 */
/* USER CODE END OTG_FS_WKUP_IRQn 0 */
HAL_NVIC_ClearPendingIRQ(OTG_FS_WKUP_IRQn);
HAL_PCD_IRQHandler(&hpcd_USB_OTG_FS);
/* USER CODE BEGIN OTG_FS_WKUP_IRQn 1 */
/* USER CODE END OTG_FS_WKUP_IRQn 1 */
}
/**
* @brief This function handles I2C3 error interrupt.
*/
void I2C3_ER_IRQHandler(void)
{
/* USER CODE BEGIN I2C3_ER_IRQn 0 */
/* USER CODE END I2C3_ER_IRQn 0 */
HAL_NVIC_ClearPendingIRQ(I2C3_ER_IRQn);
HAL_I2C_ER_IRQHandler(&hi2c3);
/* USER CODE BEGIN I2C3_ER_IRQn 1 */
/* USER CODE END I2C3_ER_IRQn 1 */
}
/**
* @brief This function handles SPI1 global interrupt.
*/
void SPI1_IRQHandler(void)
{
/* USER CODE BEGIN SPI1_IRQn 0 */
/* USER CODE END SPI1_IRQn 0 */
HAL_NVIC_ClearPendingIRQ(SPI1_IRQn);
HAL_SPI_IRQHandler(&hspi1);
/* USER CODE BEGIN SPI1_IRQn 1 */
/* USER CODE END SPI1_IRQn 1 */
}
/**
* @brief This function handles USART6 global interrupt.
*/
void USART6_IRQHandler(void)
{
/* USER CODE BEGIN USART6_IRQn 0 */
/* USER CODE END USART6_IRQn 0 */
HAL_NVIC_ClearPendingIRQ(USART6_IRQn);
HAL_UART_IRQHandler(&huart6);
/* USER CODE BEGIN USART6_IRQn 1 */
/* USER CODE END USART6_IRQn 1 */
}
/**
* @brief This function handles DMA2 Stream6 global interrupt.
*/
void DMA2_Stream6_IRQHandler(void)
{
/* USER CODE BEGIN DMA2_Stream6_IRQn 0 */
/* USER CODE END DMA2_Stream6_IRQn 0 */
HAL_NVIC_ClearPendingIRQ(DMA2_Stream6_IRQn);
HAL_DMA_IRQHandler(&hdma_usart6_tx);
/* USER CODE BEGIN DMA2_Stream6_IRQn 1 */
/* USER CODE END DMA2_Stream6_IRQn 1 */
}
/**
* @brief This function handles DMA1 Stream4 global interrupt.
*/
void DMA1_Stream4_IRQHandler(void)
{
/* USER CODE BEGIN DMA1_Stream4_IRQn 0 */
/* USER CODE END DMA1_Stream4_IRQn 0 */
HAL_NVIC_ClearPendingIRQ(DMA1_Stream4_IRQn);
HAL_DMA_IRQHandler(&hdma_i2c3_tx);
/* USER CODE BEGIN DMA1_Stream4_IRQn 1 */
/* USER CODE END DMA1_Stream4_IRQn 1 */
}
/**
* @brief This function handles EXTI Line 4 to 15 interrupts.
*/
void EXTI4_15_IRQHandler(void)
{
/* USER CODE BEGIN EXTI4_15_IRQn 0 */
/* USER CODE END EXTI4_15_IRQn 0 */
HAL_NVIC_ClearPendingIRQ(EXTI4_15_IRQn);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5);
/* USER CODE BEGIN EXTI4_15_IRQn 1 */
iqs_count++;
if(iqs_count > 8){
iqs_count=0 ;
Interrupt_call();
}
/* USER CODE END EXTI4_15_IRQn 1 */
}
/* ----------------------- Start implementation -----------------------------*/
BOOL
xMBPortTimersInit( USHORT usTim1Timerout50us )
{
HAL_UART_Transmit(&huart1, "_TI_" , 4, 0xFFFF);
#if MB_TIMER_DEBUG == 1
PIO_Configure( xTimerDebugPins, PIO_LISTSIZE( xTimerDebugPins ) );
#endif
__HAL_TIM_DISABLE_IT(&htim1, TIM_IT_UPDATE);
htim1.Init.Period = ( 50 * usTim1Timerout50us );
//htim1.Init.Period = ( 50 * 1000 );
HAL_TIM_Base_Init(&htim1);
HAL_NVIC_ClearPendingIRQ(TIM1_UP_IRQn);
__HAL_TIM_CLEAR_IT(&htim1, TIM_IT_UPDATE);
return TRUE;
}
/**
* @brief Manage the SPI transmit
* @param TransmitRequest: the transmit request
* @retval None
*/
static void SPI_Transmit_Manager(SPI_TRANSMIT_REQUEST_t TransmitRequest)
{
/*
* Disable both DMA
*/
__HAL_DMA_DISABLE(SPI_Context.hspi->hdmatx);
__HAL_DMA_DISABLE(SPI_Context.hspi->hdmarx);
__HAL_DMA_DISABLE_IT(SPI_Context.hspi->hdmarx, DMA_IT_TC); /**< Disable Receive packet notification */
__HAL_DMA_CLEAR_FLAG(SPI_Context.hspi->hdmatx, BNRG_SPI_TX_DMA_TC_FLAG); /**< Clear flag in DMA */
HAL_NVIC_ClearPendingIRQ(BNRG_SPI_DMA_TX_IRQn); /**< Clear DMA pending bit in NVIC */
__HAL_DMA_ENABLE_IT(SPI_Context.hspi->hdmatx, DMA_IT_TC); /**< Enable Transmit packet notification */
__HAL_BLUENRG_DMA_SET_MINC(SPI_Context.hspi->hdmatx); /**< Configure DMA to send Tx packet */
switch (TransmitRequest)
{
case SPI_HEADER_TRANSMIT:
SPI_Context.SPI_Transmit_Context.Spi_Transmit_Event = SPI_HEADER_TRANSMITTED;
#ifdef ENABLE_SPI_FIX
set_irq_as_input();
#endif
__HAL_BLUENRG_DMA_SET_COUNTER(SPI_Context.hspi->hdmatx, SPI_Context.SPI_Transmit_Context.header_size); /**< Set counter in DMA TX */
__HAL_BLUENRG_DMA_SET_MEMORY_ADDRESS(SPI_Context.hspi->hdmatx, (uint32_t)SPI_Context.SPI_Transmit_Context.header_data); /**< Set memory address in DMA TX */
break;
case SPI_PAYLOAD_TRANSMIT:
SPI_Context.SPI_Transmit_Context.Spi_Transmit_Event = SPI_PAYLOAD_TRANSMITTED;
__HAL_BLUENRG_DMA_SET_COUNTER(SPI_Context.hspi->hdmatx, SPI_Context.SPI_Transmit_Context.payload_size_to_transmit); /**< Set counter in DMA TX */
__HAL_BLUENRG_DMA_SET_MEMORY_ADDRESS(SPI_Context.hspi->hdmatx, (uint32_t)SPI_Context.SPI_Transmit_Context.payload_data); /**< Set memory address in DMA TX */
break;
default:
break;
}
__HAL_DMA_ENABLE(SPI_Context.hspi->hdmatx); /**< Enable DMA TX */
}
void Uart::ActiveInteruption(FunctionalState NewState )
{
if(NonMaskableInt_IRQn != m_NVIC_IRQChannel)
{
if(ENABLE == NewState)
{
HAL_NVIC_EnableIRQ(m_NVIC_IRQChannel);
HAL_NVIC_ClearPendingIRQ(m_NVIC_IRQChannel);
m_ITSuperviseur->ActiveIT(m_NVIC_IRQChannel);
}
else
{
m_ITSuperviseur->DesactiveIT(m_NVIC_IRQChannel);
}
}
}
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);
}
static void TM_USART_INT_Init(
USART_TypeDef* USARTx,
TM_USART_PinsPack_t pinspack,
uint32_t baudrate,
TM_USART_HardwareFlowControl_t FlowControl,
uint32_t Mode,
uint32_t Parity,
uint32_t StopBits,
uint32_t WordLength
) {
UART_HandleTypeDef UARTHandle;
IRQn_Type irq;
/*
* Initialize USARTx pins
* Set channel for USARTx NVIC
*/
#ifdef USART1
if (USARTx == USART1) {
/* Enable USART clock */
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_USART1_FORCE_RESET();
__HAL_RCC_USART1_RELEASE_RESET();
/* Init pins */
TM_USART1_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART1;
}
#endif
#ifdef USART2
if (USARTx == USART2) {
/* Enable USART clock */
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_USART2_FORCE_RESET();
__HAL_RCC_USART2_RELEASE_RESET();
/* Init pins */
TM_USART2_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART2;
}
#endif
#ifdef USART3
if (USARTx == USART3) {
/* Enable USART clock */
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_USART3_FORCE_RESET();
__HAL_RCC_USART3_RELEASE_RESET();
/* Init pins */
TM_USART3_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART3;
}
#endif
#ifdef UART4
if (USARTx == UART4) {
/* Enable UART clock */
__HAL_RCC_UART4_CLK_ENABLE();
__HAL_RCC_UART4_FORCE_RESET();
__HAL_RCC_UART4_RELEASE_RESET();
/* Init pins */
TM_UART4_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART4;
}
#endif
#ifdef UART5
if (USARTx == UART5) {
/* Enable UART clock */
__HAL_RCC_UART5_CLK_ENABLE();
__HAL_RCC_UART5_FORCE_RESET();
__HAL_RCC_UART5_RELEASE_RESET();
/* Init pins */
TM_UART5_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART5;
}
#endif
#ifdef USART6
if (USARTx == USART6) {
/* Enable UART clock */
__HAL_RCC_USART6_CLK_ENABLE();
__HAL_RCC_USART6_FORCE_RESET();
__HAL_RCC_USART6_RELEASE_RESET();
/* Init pins */
TM_USART6_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART6;
}
#endif
#ifdef UART7
if (USARTx == UART7) {
/* Enable UART clock */
__HAL_RCC_UART7_CLK_ENABLE();
__HAL_RCC_UART7_FORCE_RESET();
__HAL_RCC_UART7_RELEASE_RESET();
/* Init pins */
TM_UART7_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART7;
}
#endif
#ifdef UART8
if (USARTx == UART8) {
/* Enable UART clock */
__HAL_RCC_UART8_CLK_ENABLE();
__HAL_RCC_UART8_FORCE_RESET();
__HAL_RCC_UART8_RELEASE_RESET();
/* Init pins */
TM_UART8_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART8;
}
#endif
/* STM32F0xx related */
#ifdef USART4
if (USARTx == USART4) {
/* Enable UART clock */
__HAL_RCC_USART4_CLK_ENABLE();
__HAL_RCC_USART4_FORCE_RESET();
__HAL_RCC_USART4_RELEASE_RESET();
/* Init pins */
TM_USART4_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART4;
}
#endif
#ifdef USART5
if (USARTx == USART5) {
/* Enable UART clock */
__HAL_RCC_USART5_CLK_ENABLE();
__HAL_RCC_USART5_FORCE_RESET();
__HAL_RCC_USART5_RELEASE_RESET();
/* Init pins */
TM_USART5_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART5;
}
#endif
#ifdef USART7
if (USARTx == USART7) {
/* Enable UART clock */
__HAL_RCC_USART7_CLK_ENABLE();
__HAL_RCC_USART7_FORCE_RESET();
__HAL_RCC_USART7_RELEASE_RESET();
/* Init pins */
TM_USART7_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART7;
}
#endif
#ifdef USART8
if (USARTx == USART8) {
/* Enable UART clock */
__HAL_RCC_USART8_CLK_ENABLE();
__HAL_RCC_USART8_FORCE_RESET();
__HAL_RCC_USART8_RELEASE_RESET();
/* Init pins */
TM_USART8_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART8;
}
#endif
/* Fill default settings */
UARTHandle.Instance = USARTx;
UARTHandle.Init.BaudRate = baudrate;
UARTHandle.Init.HwFlowCtl = FlowControl;
UARTHandle.Init.Mode = Mode;
UARTHandle.Init.Parity = Parity;
UARTHandle.Init.StopBits = StopBits;
UARTHandle.Init.WordLength = WordLength;
UARTHandle.Init.OverSampling = UART_OVERSAMPLING_16;
#if defined(STM32F0xx)
UARTHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
#endif
/* Disable IRQ */
HAL_NVIC_DisableIRQ(irq);
/* Set priority */
HAL_NVIC_SetPriority(irq, USART_NVIC_PRIORITY, TM_USART_INT_GetSubPriority(USARTx));
/* Enable interrupt */
HAL_NVIC_EnableIRQ(irq);
/* Clear interrupt */
HAL_NVIC_ClearPendingIRQ(irq);
/* Init USART */
HAL_UART_Init(&UARTHandle);
/* Enable RX interrupt */
USARTx->CR1 |= USART_CR1_RXNEIE;
}
/**
* @brief This function handles DMA1 Stream6 global interrupt.
*/
void DMA1_Stream6_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(DMA1_Stream6_IRQn);
HAL_DMA_IRQHandler(&hdma_i2c1_tx);
}
void TIM1_TRG_COM_TIM11_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(TIM1_TRG_COM_TIM11_IRQn);
HAL_TIM_IRQHandler(&TimHandle);
}
/**
* @brief This function handles EXTI Line[15:10] interrupts.
*/
void EXTI15_10_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(EXTI15_10_IRQn);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_11); /* CAL BTN on navX-PI */
}
/**
* @brief This function handles TIM6 global interrupt, DAC1 and DAC2 underrun error interrupts.
*/
void TIM6_DAC_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(TIM6_DAC_IRQn);
HAL_TIM_IRQHandler(&htim6);
}
/**
* @brief This function handles TIM7 global interrupt.
*/
void TIM7_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(TIM7_IRQn);
HAL_TIM_IRQHandler(&htim7);
}
/**
* @brief This function handles I2C1 error interrupt.
*/
void I2C1_ER_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(I2C1_ER_IRQn);
HAL_I2C_ER_IRQHandler(&hi2c1);
}
/**
* @brief Clear Pending SPI IRQ.
* @param None
* @retval None
*/
void Clear_SPI_IRQ(void)
{
HAL_NVIC_ClearPendingIRQ(BNRG_SPI_EXTI_IRQn);
}
/**
* @brief This function handles TIM1 Update interrupt and TIM10 global interrupt.
*/
void TIM1_UP_TIM10_IRQHandler(void)
{
HAL_NVIC_ClearPendingIRQ(TIM1_UP_TIM10_IRQn);
HAL_TIM_IRQHandler(&htim1);
HAL_TIM_IRQHandler(&htim10);
}
