#include "cmsis_os.h" #include "ddc112.h" #include "GPIO_HAL/gpioHal.h" #include "main.h" #include "Param/param.h" #include "IAP/iap.h" #define EXTERN_CAP_VALUE 270 ///< pF #define REF_VOLTAGE 4.096 ///< V extern TIM_HandleTypeDef htim3; extern TIM_HandleTypeDef htim2; extern TIM_HandleTypeDef htim4; typedef enum { IO_ID_RANGE0 = 0, IO_ID_RANGE1, IO_ID_RANGE2, IO_ID_DXMIT, IO_ID_DCLK, IO_ID_DOUT, IO_ID_DVALID, IO_ID_CONV, IO_ID_TEST, } IO_INDEX_DEF; typedef struct __moduleIoTypeDef { gpioHalDef tPort; ///< 端口 gpioHalModeDef eMode; ///< 端口配置模式 uint8_t ucInitLevel; ///< 初始电平 } moduleIoTypeDef; static const moduleIoTypeDef _gatIoArray[] = { {{GPIOD, GPIO_PIN_4}, GPIO_Mode_Out_PP, 0}, ///< RANGE0 {{GPIOD, GPIO_PIN_3}, GPIO_Mode_Out_PP, 0}, ///< RANGE1 {{GPIOD, GPIO_PIN_2}, GPIO_Mode_Out_PP, 0}, ///< RANGE2 {{GPIOB, GPIO_PIN_7}, GPIO_Mode_Out_PP, 1}, ///< DXMIT,active low {{GPIOC, GPIO_PIN_10}, GPIO_Mode_Out_PP, 0}, ///< DCLK,normaly low {{GPIOC, GPIO_PIN_11}, GPIO_Mode_IPU, 0}, ///< DOUT {{GPIOC, GPIO_PIN_12}, GPIO_Mode_IPU, 0}, ///< DVALID,active low {{GPIOB, GPIO_PIN_5}, GPIO_Mode_IPU, 0}, ///< CONV,output for mastrt,input for slave {{GPIOD, GPIO_PIN_5}, GPIO_Mode_Out_PP, 0}, ///< High for master to output sync,Low for slave to input sync {NULL, 0}, }; struct { uint32_t ulAdcClk; uint32_t ulConvPeriod; ///< us DDC_RANG_DEF eRange; float fCapValue; ///< pF } _gtModuleInfo; #pragma pack(1) typedef struct __transferPacketDef { uint16_t usHeaderA; uint16_t usHeaderB; uint16_t usQueueRemainDataLen; uint16_t usLen; adcDataUnitDef atData[PACKET_DATA_UNIT_NUM]; } transferPacketDef; #pragma pack() static transferPacketDef _gtTmpPkt; typedef enum { WORK_MODE_IDLE = 0, WORK_MODE_CMD_SAMPLE, WORK_MODE_PIN_SAMPLE, WORK_MODE_SEND_DATA, WORK_MODE_WAIT, } DDC112_WORK_MODE_DEF; volatile adcDataQueueDef gtAdcDataQueue; volatile uint32_t gulAdcSampleIndex; volatile uint32_t ulSampleStartTime = 0; volatile uint32_t ulSampleDuration = 0; volatile int _iWorkMode = WORK_MODE_IDLE; typedef struct { uint32_t ulTick; uint32_t ulCnt; } tickTimeDef; tickTimeDef _gtLastTrigTime; int _giEncoderTrigFlag = 0; uint32_t gulEncoderSpeed = 0; /// 0.1mm/s static void resetAdcDataQueue(void); static void _delay() { __asm("nop"); __asm("nop"); __asm("nop"); __asm("nop"); __asm("nop"); __asm("nop"); } static void _ioInit(void) { } static void _dvalidInterruptInit(void) { } static void _readChannel(void) { uint8_t ucVal; uint8_t i; uint32_t ulData1 = 0, ulData2 = 0; static uint32_t ulData1_old = 0, ulData2_old = 0; // printf("readChannel start\n"); GPIO_HAL_LOW(&_gatIoArray[IO_ID_DCLK].tPort); GPIO_HAL_LOW(&_gatIoArray[IO_ID_DXMIT].tPort); _delay(); for (i = 0; i < 20; i++) { ulData1 <<= 1; _delay(); GPIO_HAL_HIGH(&_gatIoArray[IO_ID_DCLK].tPort); _delay(); ucVal = GPIO_HAL_READ(&_gatIoArray[IO_ID_DOUT].tPort); GPIO_HAL_LOW(&_gatIoArray[IO_ID_DCLK].tPort); if (ucVal) { ++ulData1; } } for (i = 0; i < 20; i++) { ulData2 <<= 1; _delay(); GPIO_HAL_HIGH(&_gatIoArray[IO_ID_DCLK].tPort); _delay(); ucVal = GPIO_HAL_READ(&_gatIoArray[IO_ID_DOUT].tPort); GPIO_HAL_LOW(&_gatIoArray[IO_ID_DCLK].tPort); if (ucVal) { ++ulData2; } } _delay(); GPIO_HAL_HIGH(&_gatIoArray[IO_ID_DXMIT].tPort); if (gulAdcSampleIndex >= 10) { volatile adcDataUnitDef *ptData = >AdcDataQueue.atQueue[gtAdcDataQueue.ulWritePos]; if (gptSysParam->ucFilterMode == 0) { ptData->aulData[0] = (uint16_t)(ulData1 / 16); ptData->aulData[1] = (uint16_t)(ulData2 / 16); } else { ptData->aulData[0] = (uint16_t)((ulData1 + ulData1_old) / 2 / 16); ptData->aulData[1] = (uint16_t)((ulData2 + ulData2_old) / 2 / 16); } gtAdcDataQueue.ulWritePos++; if (gtAdcDataQueue.ulWritePos >= ADC_QUEUE_LEN) { gtAdcDataQueue.ulWritePos = 0; } } ulData1_old = ulData1; ulData2_old = ulData2; } void ddc112SetRange(DDC_RANG_DEF eRange) { if (eRange & 0x01) { GPIO_HAL_HIGH(&_gatIoArray[IO_ID_RANGE0].tPort); } else { GPIO_HAL_LOW(&_gatIoArray[IO_ID_RANGE0].tPort); } if (eRange & 0x02) { GPIO_HAL_HIGH(&_gatIoArray[IO_ID_RANGE1].tPort); } else { GPIO_HAL_LOW(&_gatIoArray[IO_ID_RANGE1].tPort); } if (eRange & 0x04) { GPIO_HAL_HIGH(&_gatIoArray[IO_ID_RANGE2].tPort); } else { GPIO_HAL_LOW(&_gatIoArray[IO_ID_RANGE2].tPort); } } /** * @brief ddc112ValueToCurrent * @param ulValue * @return 电流,单位uA */ float ddc112ValueToCurrent(uint32_t ulValue) { double lfVol; double lfTmp; #define ZERO_VALUE 0x1000 #define FULL_VALUE 0xFFFFF #define FS_FACTOR 0.96 if (ulValue == 0x1000) { return 0; } lfVol = REF_VOLTAGE * FS_FACTOR; if (ulValue > ZERO_VALUE) { ulValue -= ZERO_VALUE; lfVol = lfVol * ulValue / FULL_VALUE; lfTmp = lfVol * _gtModuleInfo.fCapValue / _gtModuleInfo.ulConvPeriod; ///< uA return (float)lfTmp; } else { ulValue = ZERO_VALUE - ulValue; lfVol = lfVol * ulValue / FULL_VALUE; lfTmp = lfVol * _gtModuleInfo.fCapValue / _gtModuleInfo.ulConvPeriod; ///< uA lfTmp = -lfTmp; return (float)lfTmp; } } void tim3PeriodInit(uint32_t ulPeriod) { htim3.Init.Period = ulPeriod - 1; if (HAL_TIM_PWM_Init(&htim3) != HAL_OK) { Error_Handler(); } } void pwmConvInit(uint32_t ulPeriod) { TIM_MasterConfigTypeDef sMasterConfig = {0}; TIM_OC_InitTypeDef sConfigOC = {0}; tim3PeriodInit(ulPeriod * 2 - 1); sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK) { Error_Handler(); } sConfigOC.OCMode = TIM_OCMODE_PWM1; sConfigOC.Pulse = ulPeriod - 1; sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN TIM3_Init 2 */ /* USER CODE END TIM3_Init 2 */ HAL_TIM_MspPostInit(&htim3); } void ddc112SetTestMode(uint8_t ucMode) { if (ucMode) { GPIO_HAL_HIGH(&_gatIoArray[IO_ID_TEST].tPort); debug("enable ddc112 test mode"); } else { GPIO_HAL_LOW(&_gatIoArray[IO_ID_TEST].tPort); debug("disable ddc112 test mode"); } } /* * DDC112数据采集就绪 */ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) { if (GPIO_Pin == MCU_ADC_DVAILD_Pin) { gulAdcSampleIndex++; _readChannel(); } } static void resetAdcDataQueue(void) { gtAdcDataQueue.ulReadPos = 0; gtAdcDataQueue.ulWritePos = 0; } static uint16_t getBufferedDataLength(void) { uint16_t ulLength = 0; if (gtAdcDataQueue.ulWritePos == gtAdcDataQueue.ulReadPos) { return 0; } if (gtAdcDataQueue.ulWritePos > gtAdcDataQueue.ulReadPos) { ulLength = gtAdcDataQueue.ulWritePos - gtAdcDataQueue.ulReadPos; } else { ulLength = ADC_QUEUE_LEN - gtAdcDataQueue.ulReadPos + gtAdcDataQueue.ulWritePos; } return ulLength; } static void base64_encode(const unsigned char *input, size_t input_len, char *output) { static const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; int i = 0, j = 0; unsigned char char_array_3[3], char_array_4[4]; while (input_len--) { char_array_3[i++] = *(input++); if (i == 3) { char_array_4[0] = (char_array_3[0] >> 2) & 0x3F; char_array_4[1] = ((char_array_3[0] & 0x03) << 4) | (char_array_3[1] >> 4); char_array_4[2] = ((char_array_3[1] & 0x0F) << 2) | (char_array_3[2] >> 6); char_array_4[3] = char_array_3[2] & 0x3F; for (i = 0; i < 4; i++) { output[j++] = base64_table[char_array_4[i]]; } i = 0; } } if (i) { for (int k = i; k < 3; k++) { char_array_3[k] = '\0'; } char_array_4[0] = (char_array_3[0] >> 2) & 0x3F; char_array_4[1] = ((char_array_3[0] & 0x03) << 4) | (char_array_3[1] >> 4); char_array_4[2] = ((char_array_3[1] & 0x0F) << 2) | (char_array_3[2] >> 6); char_array_4[3] = char_array_3[2] & 0x3F; for (int k = 0; k < i + 1; k++) { output[j++] = base64_table[char_array_4[k]]; } while (i++ < 3) { output[j++] = '='; } } output[j] = '\0'; // Null-terminate the output string } static int sendDataPacket(uint8_t *pucData, uint16_t usLen) { static char aucBase64Buf[45 * 1024]; static char aucUdpBuf[64 * 1024]; if (usLen <= 0) { return -1; } if (usLen > 41 * 1024) { printf("data too long\n"); return -1; } base64_encode(pucData, usLen, aucBase64Buf); sprintf(aucUdpBuf, "{\"type\":\"data_points\",\"name\":\"daq\",\"data\":\"%s\"}", aucBase64Buf); #if 0 if (udpSendBroadcast(aucUdpBuf, strlen(aucUdpBuf)) < 0) { printf("udp send failed \r\n"); return -1; } #else // udpSendTo(aucUdpBuf, strlen(aucUdpBuf), // "192.168.8.12", // 50009); udpSendTo(aucUdpBuf, strlen(aucUdpBuf), "192.168.100.100", 50009); osDelay(100); udpSendTo(aucUdpBuf, strlen(aucUdpBuf), "192.168.100.10", 50009); #endif printf("send ok \r\n"); return usLen; } static int makeDataPacket(void) { uint16_t ulPos = 0; uint16_t i = 0; uint16_t ulLen = getBufferedDataLength(); uint16_t send_size = 0; if (ulLen < 5) { return 0; } ulLen -= 5; for (i = 0; i < ulLen; ++i) { ulPos = gtAdcDataQueue.ulReadPos + i; if (ulPos >= ADC_QUEUE_LEN) { ulPos -= ADC_QUEUE_LEN; } volatile adcDataUnitDef *ptData = >AdcDataQueue.atQueue[ulPos]; memcpy(&_gtTmpPkt.atData[i], (uint8_t *)ptData, sizeof(adcDataUnitDef)); } _gtTmpPkt.usHeaderA = 0xAA55; _gtTmpPkt.usHeaderB = 0x55CC; _gtTmpPkt.usLen = ulLen; printf("_gtTmpPkt.usLen : %d , _gtTmpPkt.usQueueRemainDataLen : %d \r\n", _gtTmpPkt.usLen, _gtTmpPkt.usQueueRemainDataLen); send_size = 8 + sizeof(adcDataUnitDef) * ulLen; return send_size; } void encoderModeInit() { GPIO_InitTypeDef GPIO_InitStruct = {0}; /**TIM3 GPIO Configuration PB5 ------> TIM3_CH2 */ GPIO_InitStruct.Pin = GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } void encoderModeDeinit() { GPIO_InitTypeDef GPIO_InitStruct = {0}; /**TIM3 GPIO Configuration PB5 ------> TIM3_CH2 */ GPIO_InitStruct.Pin = GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF2_TIM3; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } void _sampleStart(void) { if (gptSysParam->usDdc112Period > 300) { encoderModeDeinit(); _readChannel(); resetAdcDataQueue(); gulAdcSampleIndex = 0; ulSampleStartTime = osKernelGetTickCount(); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2); } else { _readChannel(); __disable_irq(); encoderModeInit(); resetAdcDataQueue(); gulAdcSampleIndex = 0; ulSampleStartTime = osKernelGetTickCount(); __enable_irq(); } } void _sampleStop(void) { HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_2); _giEncoderTrigFlag = 0; HAL_GPIO_WritePin(RELAY_GPIO_Port, RELAY_Pin, GPIO_PIN_RESET); } /** * @brief ddc112Start * @return 1:成功,0:失败 */ int ddc112Start(uint16_t delay, uint32_t ulDuration) { if (_iWorkMode == WORK_MODE_IDLE) { osDelay(delay); _sampleStart(); _iWorkMode = WORK_MODE_CMD_SAMPLE; // printf("ddc112Start\r\n"); ulSampleDuration = ulDuration; return 1; } return 0; } /** * @brief ddc112Stop * @return 1:成功,0:失败 */ int ddc112Stop(void) { if (_iWorkMode == 1) { _iWorkMode = 0; _sampleStop(); printf("ddc112Stop\r\n"); return 1; } return 0; } static void test_correct() { ddc112SetTestMode(1); osDelay(100); _sampleStart(); osDelay(100); uint16_t ulPos = 0; uint16_t i = 0; uint16_t ulLen = getBufferedDataLength(); uint16_t send_size = 0; if (ulLen == 0) { return 0; } for (i = 0; i < ulLen; ++i) { ulPos = gtAdcDataQueue.ulReadPos + i; if (ulPos >= ADC_QUEUE_LEN) { ulPos -= ADC_QUEUE_LEN; } volatile adcDataUnitDef *ptData = >AdcDataQueue.atQueue[ulPos]; memcpy(&_gtTmpPkt.atData[i], (uint8_t *)ptData, sizeof(adcDataUnitDef)); } } static void ddc112_task(void *arg) { _iWorkMode = WORK_MODE_IDLE; while (1) { switch (_iWorkMode) { case WORK_MODE_IDLE: // 空闲状态 if (gptSysParam->usPinSampleTime > 0) { if (HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_8) == GPIO_PIN_RESET) { if (gptSysParam->usPinSampleDelay > 0) { osDelay(gptSysParam->usPinSampleDelay); } ulSampleDuration = gptSysParam->usPinSampleTime; if (ulSampleDuration > 16000) { ulSampleDuration = 16000; } _sampleStart(); _iWorkMode = WORK_MODE_PIN_SAMPLE; } } break; case WORK_MODE_CMD_SAMPLE: // 命令采样状态 case WORK_MODE_PIN_SAMPLE: // 引脚采样状态 if (osKernelGetTickCount() > ulSampleStartTime + ulSampleDuration) { _sampleStop(); _iWorkMode = WORK_MODE_SEND_DATA; printf("sample timeout \r\n"); printf("sample data length: %d\r\n", getBufferedDataLength()); } else if (getBufferedDataLength() > PACKET_DATA_UNIT_NUM) { _sampleStop(); _iWorkMode = WORK_MODE_SEND_DATA; printf("sample data length: %d\r\n", getBufferedDataLength()); } break; case WORK_MODE_SEND_DATA: // 发送数据状态 { int ret = makeDataPacket(); if (ret > 0) { sendDataPacket((uint8_t *)&_gtTmpPkt, ret); } resetAdcDataQueue(); _iWorkMode = WORK_MODE_WAIT; } break; case WORK_MODE_WAIT: // 发送数据状态 { if (gptSysParam->usPinSampleTime == 0) { _iWorkMode = WORK_MODE_IDLE; } else if (HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_8) == GPIO_PIN_SET) { _iWorkMode = WORK_MODE_IDLE; } } break; default: break; } osDelay(1); } } void aimSpeedSet(uint16_t usPeriod) { TIM_OC_InitTypeDef sConfigOC = {0}; sConfigOC.OCMode = TIM_OCMODE_TIMING; sConfigOC.Pulse = 10000 - usPeriod; sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; if (HAL_TIM_OC_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) != HAL_OK) { Error_Handler(); } sConfigOC.Pulse = 10000 + usPeriod; if (HAL_TIM_OC_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4) != HAL_OK) { Error_Handler(); } TIM2->CNT = 10000; } void ddc112UpdateParam(void) { ddc112SetRange(gptSysParam->ucDdc112Range); if (gptSysParam->usDdc112Period < 300) { aimSpeedSet(gptSysParam->usDdc112Period); } else { pwmConvInit(gptSysParam->usDdc112Period); } if (gptSysParam->ucTestMode) { ddc112SetTestMode(1); } else { ddc112SetTestMode(0); } } void ddc112Init(void) { static const float afRangeCaps[] = { EXTERN_CAP_VALUE, 12.5, 25, 37.5, 50, 62.5, 75, 87.5}; _gtModuleInfo.eRange = (DDC_RANG_DEF)(gptSysParam->ucDdc112Range); _gtModuleInfo.ulConvPeriod = gptSysParam->usDdc112Period; _gtModuleInfo.ulAdcClk = 15000000; _gtModuleInfo.fCapValue = afRangeCaps[_gtModuleInfo.eRange]; _ioInit(); ddc112UpdateParam(); printf("ddc112 pwm conv period: %d\r\n", _gtModuleInfo.ulConvPeriod); _dvalidInterruptInit(); HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1); ///< 启动定时器4通道1 HAL_TIM_Encoder_Start(&htim2, TIM_CHANNEL_ALL); HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_3); HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_4); TIM2->CNT = 10000; // 创建任务 const osThreadAttr_t ddc112_task_attributes = { .name = "ddc112_task", .stack_size = 4096 * 4, .priority = (osPriority_t)osPriorityNormal, }; if (osThreadNew(ddc112_task, NULL, &ddc112_task_attributes) == NULL) { printf("failed to create ddc112_task\n"); } else { printf("create ddc112_task success\n"); } } void TIM3_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { } uint32_t getDeltaTime(tickTimeDef *last, tickTimeDef *now) { if (last->ulTick == 0) { return 0; } if (now->ulTick < last->ulTick) { return 0; } else if (now->ulTick == last->ulTick) { if (now->ulCnt < last->ulCnt) { return 0; } } return (now->ulTick - last->ulTick) * 1000 + (now->ulCnt - last->ulCnt); } void channelHandler(uint32_t ulVal) { tickTimeDef tim; if (_giEncoderTrigFlag > 10) { HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_5); } tim.ulCnt = TIM13->CNT; tim.ulTick = uwTick; uint32_t ulTim = getDeltaTime(&_gtLastTrigTime, &tim); if (ulTim > 0) { gulEncoderSpeed = gptSysParam->usDdc112Period * 10000 / ulTim; } if (gulEncoderSpeed >= gptSysParam->usDdc112Period * 10 * 8 / 10) { if (_giEncoderTrigFlag < 100) { _giEncoderTrigFlag++; } } // printf("pulse 40, %u, flag %d\n", gulEncoderSpeed, _giEncoderTrigFlag); _gtLastTrigTime = tim; } void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim) { if (htim->Instance == TIM2) { uint32_t ulVal = TIM2->CNT; TIM2->CNT = 10000; channelHandler(ulVal); } else if (htim == &htim3) { // gulAdcSampleIndex++; } } void TIM2_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { tickTimeDef tim; if (_giEncoderTrigFlag > 10) { HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_5); } tim.ulCnt = TIM13->CNT; tim.ulTick = uwTick; uint32_t ulVal = getDeltaTime(&_gtLastTrigTime, &tim); gulEncoderSpeed = gptSysParam->usDdc112Period * 10000 / ulVal; if (gulEncoderSpeed >= gptSysParam->usDdc112Period * 10 * 8 / 10) { if (_giEncoderTrigFlag < 100) { _giEncoderTrigFlag++; } } else { _giEncoderTrigFlag = 0; } // printf("pulse 40, %u, flag %d\n", gulEncoderSpeed, _giEncoderTrigFlag); _gtLastTrigTime = tim; } // void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) //{ // if(htim->Instance == TIM2) // { // if((ulEnc_sta & 0x80) == 0) // { // if(ulEnc_sta & 0x40) // { // ulEnc_sta |= 0x80; // ulEnc =HAL_TIM_ReadCapturedValue(&htim2,TIM_CHANNEL_1); // TIM_RESET_CAPTUREPOLARITY(&htim2,TIM_CHANNEL_1); // } // else { // ulEnc_sta = 0; // ulEnc = 0; // ulEnc_sta = 0x40; // __HAL_TIM_DISABLE(&htim2); // __HAL_TIM_SET_COUNTER(&htim2,0); // TIM_RESET_CAPTUREPOLARITY(&htim2,TIM_CHANNEL_1); // __HAL_TIM_ENABLE(&htim2); // } // } // } // }