Code_Pcakages/BHBF_Robot_Washing/BASE/Src/BSP/bsp_UART 尝试使用接口做测试版本 - 副本.txt

/*
 * 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

}