/* * bsp_UART.c * * Created on: Oct 26, 2023 * Author: shiya */ #include "BSP/bsp_UART.h" #include "DLT/DLTuc.h" void UARTHandlerAddTxList(struct UARTHandler *uartHandler, uint8_t *data, uint16_t length, void (*UART_Decode)(uint8_t*, uint16_t)); //Store all the data in these buffer uint8_t RS485_1_RxMA_buf[UART_Receive_MAX_NUM]; uint8_t RS485_2_RxDMA_buf[UART_Receive_MAX_NUM]; uint8_t RS485_3_RxDMA_buf[UART_Receive_MAX_NUM]; uint8_t RS485_4_RxDMA_buf[UART_Receive_MAX_NUM]; uint8_t Debug_RxDMA_buf[UART_Receive_MAX_NUM]; uint8_t ExternSerial_RxDMA_buf[UART_Receive_MAX_NUM]; uint8_t RS485_1_TxDMA_buf[UART_Transmit_MAX_NUM]; uint8_t RS485_2_TxDMA_buf[UART_Transmit_MAX_NUM]; uint8_t RS485_3_TxDMA_buf[UART_Transmit_MAX_NUM]; uint8_t RS485_4_TxDMA_buf[UART_Transmit_MAX_NUM]; uint8_t Debug_TxDMA_buf[UART_Transmit_MAX_NUM]; uint8_t ExternSerial_TxDMA_buf[UART_Transmit_MAX_NUM]; #define InterCall_DEBUG_UART huart4 #define E28_SBUS_UART huart5 #define RS485_4_UART huart7 #define RS485_1_UART huart1 #define E22_Serial_UART huart2 #define RS485_2_UART huart3 #define RS485_3_UART huart6 struct UARTHandler RS_485_1_UART_Handler; struct UARTHandler RS_485_2_UART_Handler; struct UARTHandler RS_485_3_UART_Handler; struct UARTHandler RS_485_4_UART_Handler; struct UARTHandler InterCall_DEBUG_UART_Handler; struct UARTHandler E28_SBUS_UART_Handler; struct UARTHandler E22_Serial_UART_Handler; void GF_BSP_UARTHandlers_Intialize() { IntializeUARTHandler(&RS_485_1_UART_Handler, &RS485_1_UART, 100, 2); //10ms 剩余2ms IntializeUARTHandler(&RS_485_2_UART_Handler, &RS485_2_UART, 100, 2); //10ms 剩余2ms IntializeUARTHandler(&RS_485_3_UART_Handler, &RS485_3_UART, 100, 2); //10ms 剩余2ms IntializeUARTHandler(&RS_485_4_UART_Handler, &RS485_4_UART, 100, 2); //10ms 剩余2ms IntializeUARTHandler(&E22_Serial_UART_Handler, &E22_Serial_UART, 100, 2); //10ms 剩余2ms IntializeUARTHandler(&InterCall_DEBUG_UART_Handler, &InterCall_DEBUG_UART, 100, 2); //10ms 剩余2ms IntializeUARTHandler(&E28_SBUS_UART_Handler, &E28_SBUS_UART, 100, 2); //10ms 剩余2ms HAL_UART_Receive_IT((RS_485_1_UART_Handler.uart), (uint8_t*) &RS_485_1_UART_Handler.tmp_Rx_Buf, 1); HAL_UART_Receive_IT((RS_485_2_UART_Handler.uart), (uint8_t*) &RS_485_2_UART_Handler.tmp_Rx_Buf, 1); HAL_UART_Receive_IT((RS_485_3_UART_Handler.uart), (uint8_t*) &RS_485_3_UART_Handler.tmp_Rx_Buf, 1); HAL_UART_Receive_IT((RS_485_4_UART_Handler.uart), (uint8_t*) &RS_485_4_UART_Handler.tmp_Rx_Buf, 1); HAL_UART_Receive_IT((E22_Serial_UART_Handler.uart), (uint8_t*) &E22_Serial_UART_Handler.tmp_Rx_Buf, 1); HAL_UART_Receive_IT((InterCall_DEBUG_UART_Handler.uart), (uint8_t*) &InterCall_DEBUG_UART_Handler.tmp_Rx_Buf, 1); GF_BSP_Interrupt_Add_CallBack( DF_BSP_InterCall_TIM8_2ms_PeriodElapsedCallback, GF_BSP_UART_Timer); //RS_485_2_UART_Handler.send_finished=1; } static DispacherController *_dispacherController; static HardWareController *_uartHardWareController; //Count Every 2 ms void GF_BSP_UART_Timer() { //Counting(&E28_SBUS_UART_Handler); Counting(&RS_485_4_UART_Handler); //Counting(&RS_485_3_UART_Handler); Counting(&RS_485_1_UART_Handler); Counting(&RS_485_2_UART_Handler); Counting(&E22_Serial_UART_Handler); Counting(&InterCall_DEBUG_UART_Handler); } void UARTHandlerAddTxList(struct UARTHandler *uartHandler, uint8_t *data, uint16_t length, void (*UART_Decode)(uint8_t*, uint16_t)) { UARTSendHandler *pTmp = NULL; //临时指针 //临时指针2用于逐个申请内存 pTmp = (UARTSendHandler*) malloc(sizeof(UARTSendHandler)); memcpy(pTmp->Tx_Buf, data, length); pTmp->pNext = NULL; pTmp->TxCount = length; pTmp->UART_Decode = UART_Decode; //if NULL, call intialize one if (uartHandler->pCurrentUARTSendHadler == NULL) { uartHandler->pCurrentUARTSendHadler = pTmp; //空链表 }else { char i = 0; //插到尾部 UARTSendHandler *phead = NULL; phead = uartHandler->pCurrentUARTSendHadler; while (phead->pNext != NULL) { i++; phead = phead->pNext; } phead->pNext = pTmp; } uartHandler-> UARTSendHadlerListNum++; } void UARTHandlerTx(struct UARTHandler *uartHandler) { if (uartHandler->uart == NULL) { LOGFF(DL_ERROR, "the UART Hardware did not intialize,check the setting"); return; } uartHandler->RxCount = 0; if (uartHandler->uart->Instance == UART4) //**DEBUG { } else if (uartHandler->uart->Instance == USART1) //**RS485_1 { HAL_GPIO_WritePin(RS485_1_DIR_GPIO_Port, RS485_1_DIR_Pin, GPIO_PIN_SET); } else if (uartHandler->uart->Instance == USART3) //**RS485_2 { HAL_GPIO_WritePin(RS485_2_DIR_GPIO_Port, RS485_2_DIR_Pin, GPIO_PIN_SET); } else if (uartHandler->uart->Instance == USART6) //**RS485_3 { HAL_GPIO_WritePin(RS485_3_DIR_GPIO_Port, RS485_3_DIR_Pin, GPIO_PIN_SET); } else if (uartHandler->uart->Instance == UART7) //**RS485_4 { HAL_GPIO_WritePin(RS485_4_DIR_GPIO_Port, RS485_4_DIR_Pin, GPIO_PIN_SET); } else if (uartHandler->uart->Instance == USART2)//**E22 // External serial port { } else if (uartHandler->uart->Instance == UART5) //**E28 // SBUS { } SCB_CleanInvalidateDCache_by_Addr((uint32_t*) uartHandler->Tx_Buf, uartHandler->TxCount); HAL_UART_Transmit_DMA(uartHandler->uart, uartHandler->Tx_Buf, uartHandler->TxCount); // while(HAL_DMA_GetState(&hdma_usart1_tx) == HAL_DMA_STATE_BUZY) // // while (uartHandler->uart->gState != HAL_UART_STATE_READY)//等待数据发送完毕 // { // } } void UARTHandlerRX(struct UARTHandler *uartHandler) { if (uartHandler->startCountFlag == 0) { uartHandler->startCountFlag = 1; uartHandler->RxCount = 0; } uartHandler->Rx_Buf[uartHandler->RxCount] = uartHandler->tmp_Rx_Buf[0]; uartHandler->RxCount++; uartHandler->Wait_Time_Count = 0; HAL_UART_Receive_IT(uartHandler->uart, uartHandler->tmp_Rx_Buf, 1); //HAL_UART_Receive_IT(uartHandler->uart, RS_485_2_UART_Handler.tmp_Rx_Buf, 1); } void IntializeUARTHandler(struct UARTHandler *uartHandler, UART_HandleTypeDef *uart, int32_t WaitTime, unsigned char timeSpan) { uartHandler->Wait_Time_Count = 0; uartHandler->Wait_time = WaitTime; uartHandler->timeSpan = timeSpan; uartHandler->Send_time = 0; //0 代表不等待，默认是不进行等大发送 uartHandler->uart = uart; uartHandler->UART_Rx = UARTHandlerRX; uartHandler->UART_Tx = UARTHandlerTx; uartHandler->AddSendList = UARTHandlerAddTxList; uartHandler->pCurrentUARTSendHadler = NULL; uartHandler->dispacherController = (DispacherController*) malloc( sizeof(DispacherController)); uartHandler->dispacherController->pHead = NULL; uartHandler->dispacherController->pTail = NULL; uartHandler->dispacherController->Dispatcher_Run = Dispatch_t; uartHandler->dispacherController->DispacherNumber = 0; uartHandler->dispacherController->Add_Dispatcher_List = Dispatcher_List_Add_t; uartHandler->dispacherController->DispacherCallTime = 50; //2ms 一次， uartHandler->dispacherController->Dispacher_Enable = 1; //enable this function uartHandler->dispacherController->Dispacher_Counter = 0; uartHandler->uartHardWareController = (HardWareController*) malloc( sizeof(HardWareController)); uartHandler->uartHardWareController->pComHWHead = NULL; uartHandler->uartHardWareController->pComHWTail = NULL; //uartHandler->Add_PCOMHardWare = ComHardWare_List_Add; uartHandler->uartHardWareController->PCOMHardWare_Check = PCOMHardWare_Check_t; uartHandler->uartHardWareController->Set_PCOMHardWare = Set_PCOMHardWare_t; uartHandler->uartHardWareController->Add_PCOMHardWare = ComHardWare_List_Add_t; uartHandler->uartHardWareController->HardWare_Check_Counter = 0; uartHandler->uartHardWareController->DispacherCallTime = 50; uartHandler->pCurrentUARTSendHadler = (UARTSendHandler*) malloc( sizeof(UARTSendHandler)); uartHandler->pCurrentUARTSendHadler = NULL; uartHandler-> UARTSendHadlerListNum=0; } void Counting(struct UARTHandler *uartHandler) { //读取数据 if (uartHandler->UART_Decode == NULL) //不解析，直接返回true { uartHandler->decode_finished = 1; } else { if (uartHandler->startCountFlag == 1) { uartHandler->Wait_Time_Count++; if (uartHandler->timeSpan * uartHandler->Wait_Time_Count >= uartHandler->Wait_time) { uartHandler->Wait_Time_Count = 0; uartHandler->startCountFlag = 0; //启动解析函数 if (uartHandler->RxCount >= 1) { uartHandler->UART_Decode(uartHandler->Rx_Buf, uartHandler->RxCount); } //uartHandler->RxCount=0; } } } if (uartHandler-> UARTSendHadlerListNum>0) { uartHandler->Send_Time_Count++; if (uartHandler->timeSpan * uartHandler->Send_Time_Count >= uartHandler->Send_time) { uartHandler->Send_Time_Count = 0; //拷贝数据到相关的代码中，然后发送 uartHandler->UART_Decode=NULL; // uartHandler->UART_Decode = // uartHandler->pCurrentUARTSendHadler->UART_Decode; // memcpy(uartHandler->Tx_Buf, uartHandler->pCurrentUARTSendHadler->Tx_Buf, uartHandler->pCurrentUARTSendHadler->TxCount); uartHandler->TxCount = uartHandler->pCurrentUARTSendHadler->TxCount; uartHandler->UART_Tx(uartHandler); if (uartHandler->pCurrentUARTSendHadler->pNext != NULL) { UARTSendHandler *temp = uartHandler->pCurrentUARTSendHadler->pNext; if(uartHandler->pCurrentUARTSendHadler!=NULL) { free(uartHandler->pCurrentUARTSendHadler); //清除内存 uartHandler->pCurrentUARTSendHadler=NULL; } uartHandler->pCurrentUARTSendHadler = temp; } else { free(uartHandler->pCurrentUARTSendHadler); //清除内存 uartHandler->pCurrentUARTSendHadler = NULL; } uartHandler-> UARTSendHadlerListNum--; } } else { //dispacher and hardware check _dispacherController = uartHandler->dispacherController; if(_dispacherController!=NULL) { _dispacherController->Dispatcher_Run(_dispacherController); } _uartHardWareController =uartHandler->uartHardWareController; if(_uartHardWareController!=NULL) { _uartHardWareController->PCOMHardWare_Check(_uartHardWareController); } } //发送数据 } void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if (huart->Instance == UART4) //**DEBUG { UARTHandlerRX(&InterCall_DEBUG_UART_Handler); GF_BSP_Interrupt_Run_CallBack(DF_BSP_InterCall_DEBUG_RxCpltCallback); } else if (huart->Instance == USART1) //**RS485_1 { GF_BSP_Interrupt_Run_CallBack(DF_BSP_InterCall_RS485_1_RxCpltCallback); UARTHandlerRX(&RS_485_1_UART_Handler); } else if (huart->Instance == USART3) //**RS485_2 { GF_BSP_Interrupt_Run_CallBack(DF_BSP_InterCall_RS485_2_RxCpltCallback); UARTHandlerRX(&RS_485_2_UART_Handler); } else if (huart->Instance == USART6) //**RS485_3 { GF_BSP_Interrupt_Run_CallBack(DF_BSP_InterCall_RS485_3_RxCpltCallback); UARTHandlerRX(&RS_485_3_UART_Handler); } else if (huart->Instance == UART7) //**RS485_4 { GF_BSP_Interrupt_Run_CallBack(DF_BSP_InterCall_RS485_4_RxCpltCallback); UARTHandlerRX(&RS_485_4_UART_Handler); } else if (huart->Instance == USART2) //**E22 // External serial port { GF_BSP_Interrupt_Run_CallBack( DF_BSP_InterCall_E22_Serial_RxCpltCallback); UARTHandlerRX(&E22_Serial_UART_Handler); } else if (huart->Instance == UART5) //**E28 // SBUS { GF_BSP_Interrupt_Run_CallBack( DF_BSP_InterCall_E28_SBUS_RxFifo0Callback); } } void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) { if (huart->Instance == UART4) //**DEBUG { } else if (huart->Instance == USART1) //**RS485_1 { HAL_GPIO_WritePin(RS485_1_DIR_GPIO_Port, RS485_1_DIR_Pin, GPIO_PIN_RESET); } else if (huart->Instance == USART3) //**RS485_2 { HAL_GPIO_WritePin(RS485_2_DIR_GPIO_Port, RS485_2_DIR_Pin, GPIO_PIN_RESET); } else if (huart->Instance == USART6) //**RS485_3 { HAL_GPIO_WritePin(RS485_3_DIR_GPIO_Port, RS485_3_DIR_Pin, GPIO_PIN_RESET); } else if (huart->Instance == UART7) //**RS485_4 { HAL_GPIO_WritePin(RS485_4_DIR_GPIO_Port, RS485_4_DIR_Pin, GPIO_PIN_RESET); } else if (huart->Instance == USART2) //**E22 // External serial port { } else if (huart->Instance == UART5) //**E28 // SBUS { } } //RS485_Index:1-4 RS485; 5 ExternSerial; 6 Debug; void GF_BSP_UART_Transmit(const uint8_t RS485_Index, const uint8_t *pData, uint16_t Size) { UART_HandleTypeDef *huart; if (Size > UART_Transmit_MAX_NUM) Size = UART_Transmit_MAX_NUM; switch (RS485_Index) { case 1: huart = &huart1; HAL_GPIO_WritePin(RS485_1_DIR_GPIO_Port, RS485_1_DIR_Pin, GPIO_PIN_SET); memcpy(RS485_1_TxDMA_buf, pData, Size); SCB_CleanInvalidateDCache_by_Addr((uint32_t*) RS485_1_TxDMA_buf, Size); HAL_UART_Transmit_DMA(huart, RS485_1_TxDMA_buf, Size); break; case 2: huart = &huart3; HAL_GPIO_WritePin(RS485_2_DIR_GPIO_Port, RS485_2_DIR_Pin, GPIO_PIN_SET); memcpy(RS485_2_TxDMA_buf, pData, Size); SCB_CleanInvalidateDCache_by_Addr((uint32_t*) RS485_2_TxDMA_buf, Size); HAL_UART_Transmit_DMA(huart, RS485_2_TxDMA_buf, Size); break; case 3: huart = &huart6; HAL_GPIO_WritePin(RS485_3_DIR_GPIO_Port, RS485_3_DIR_Pin, GPIO_PIN_SET); memcpy(RS485_3_TxDMA_buf, pData, Size); SCB_CleanInvalidateDCache_by_Addr((uint32_t*) RS485_3_TxDMA_buf, Size); HAL_UART_Transmit_DMA(huart, RS485_3_TxDMA_buf, Size); break; case 4: huart = &huart7; HAL_GPIO_WritePin(RS485_4_DIR_GPIO_Port, RS485_4_DIR_Pin, GPIO_PIN_SET); memcpy(RS485_4_TxDMA_buf, pData, Size); SCB_CleanInvalidateDCache_by_Addr((uint32_t*) RS485_4_TxDMA_buf, Size); HAL_UART_Transmit_DMA(huart, RS485_4_TxDMA_buf, Size); break; case 5: huart = &huart2; memcpy(ExternSerial_TxDMA_buf, pData, Size); SCB_CleanInvalidateDCache_by_Addr( (uint32_t*) ExternSerial_TxDMA_buf, Size); HAL_UART_Transmit_DMA(huart, ExternSerial_TxDMA_buf, Size); break; default: huart = &huart4; memcpy(Debug_TxDMA_buf, pData, Size); SCB_CleanInvalidateDCache_by_Addr((uint32_t*) Debug_TxDMA_buf, Size); HAL_UART_Transmit_DMA(huart, Debug_TxDMA_buf, Size); break; } } //void USART_Dispatch(struct UARTHandler *uartHandler) //{ ////2ms // // if(uartHandler->Dispacher_Enable==1) // { // uartHandler->counter++; // if (uartHandler->DispacherNumber > 0) //列表中有数据 // { // if (uartHandler->counter // > uartHandler->DispacherCallTimeCount // / uartHandler->DispacherNumber) //多长时间运行一次 // { // uartHandler->counter = 0; // if (uartHandler->pHead != NULL && uartHandler->pHead->pNext != NULL) // { // uartHandler->pHead->dispache(); // uartHandler->pHead = uartHandler->pHead->pNext; // } else // { // // } // } // } // // } // // // // //} //void Dispatcher_List_Add(struct UARTHandler *uartHandler, // void (*dispache)(void)) //{ // Dispatcher *pTmp = NULL; //临时指针2 // // if (uartHandler->pHead == NULL && uartHandler->pTail == NULL) //头尾部都为空 // { // uartHandler->pHead = uartHandler->pTail = (Dispatcher*) malloc( // sizeof(Dispatcher)); // uartHandler->pTail->dispache = dispache; // uartHandler->pTail->pNext = uartHandler->pHead; // uartHandler->DispacherNumber++; // } else // { // //临时指针2用于逐个申请内存 // pTmp = (Dispatcher*) malloc(sizeof(Dispatcher)); // pTmp->dispache = dispache; // pTmp->pNext = uartHandler->pHead; //set the new dispatcher .next to the header, thus make it a circle // // //临时指针1的next指向刚分配内存的临时指针2 // uartHandler->pTail->pNext = pTmp; // // uartHandler->pTail = pTmp; //set pTail the last node of this ring // uartHandler->DispacherNumber++; // } //} //void ComHardWare_List_Add(struct UARTHandler *uartHandler, char *name, // char value) //{ // // ComHardWare *pTmp = NULL; //临时指针2 // if (uartHandler->pComHWHead == NULL && uartHandler->pComHWTail == NULL) //头尾部都为空 // { // uartHandler->pComHWHead = uartHandler->pTail = (ComHardWare*) malloc( // sizeof(ComHardWare)); // // memcpy(uartHandler->pComHWHead->Name, name, strlen(name)); // uartHandler->pComHWHead->IsOnline = value; // uartHandler->pComHWHead->pNext = NULL; // } else // { // // pTmp = (ComHardWare*) malloc(sizeof(ComHardWare)); // pTmp->IsOnline = value; // pTmp->pNext = NULL; //set the new dispatcher .next to the header, thus make it a circle // uartHandler->pComHWTail->pNext = pTmp; // uartHandler->pComHWTail = pTmp; // // } // //} //void PCOMHardWare_Check(struct UARTHandler *uartHandler) //{ // uartHandler->HardWare_Check_Counter++; // if (uartHandler->HardWare_Check_Counter // >= uartHandler->DispacherCallTimeCount * 5) //make sure every // { // uartHandler->HardWare_Check_Counter = 0;//perform the check of connection // ComHardWare *ptr = uartHandler->pComHWHead; // // if (ptr == NULL) // { // //printf("链表为空\n"); // return; // } // char IsAbnornalStatus = 0; // int index = 0; // //check invalid state // while (ptr != NULL) // { // if (ptr->IsOnline != 1) // { // LOGFF(DL_ERROR, "%s connecting Error", ptr->Name); // IsAbnornalStatus = 1; // } // ptr = ptr->pNext; // } // // //set invalid state // ptr = uartHandler->pComHWHead; // while (ptr != NULL) // { // ptr->IsOnline = 0; // ptr = ptr->pNext; // } // // } //} // //int Set_PCOMHardWare(struct UARTHandler *uartHandler, char *name, char value) //{ // // ComHardWare *ptr = uartHandler->pComHWHead; // char finddata = 0; // // if (ptr == NULL) // { // // return NULL; // } // // while (ptr != NULL) // { // if (strcmp(ptr->Name, name) == 0) // { // ptr->IsOnline = value; // finddata = 1; // return finddata; // } else // { // ptr = ptr->pNext; // } // // } // return finddata; // //} void uartHandler_intialize(UARTHandlerHelper *helper, struct UARTHandler *Handler, int WaitTime) { // helper->disp=NULL; // helper->hardWares=NULL; helper->UART_Handler = Handler; helper->UART_Handler->Wait_time = WaitTime; //等待10ms 最低不要低于4； helper->disp = helper->UART_Handler->dispacherController; helper->hardWares = helper->UART_Handler->uartHardWareController; // helper->disp->Add_Dispatcher_List(helper->disp,read_angle); // // helper->hardwareController->Add_PCOMHardWare(helper->hardwareController,"angle_encoder",0); //uartHandler->Insert_HardWare_Entry_UART }