Luận án Phát triển giải pháp điều khiển thích nghi cho bộ lọc tích cực ba pha

Khảo sát và đánh giá các nghiên cứu về điều khiển bộ lọc tích cực ba pha, hướng
điều khiển thích nghi.
Khảo sát và đánh giá tác động của bộ lọc nguồn tích cực lên hệ thống điện ba pha
có các loại tải khác nhau.
Xây dựng mô hình bộ lọc nguồn tích cực ba pha hướng thích nghi với biến động
của tải phi tuyến.
Nghiên cứu các kỹ thuật điều khiển sử dụng trong khâu điều khiển của bộ lọc tích
cực ba pha.
Tối ưu ổn định điện áp tụ trong quá trình hoạt động của bộ lọc tích cực.
Tối ưu kỹ thuật nối lưới cho bộ lọc nhằm giữ ổn định hệ thống khi tải và nguồn có
biến động.
Phát triển giải pháp điều khiển thích nghi ứng dụng trong điều khiển bộ lọc tích
cực ba pha.
Mô phỏng đánh giá giải thuật.
Thực nghiệm để đánh giá hệ thống thực tế sử dụng giải thuật đã nghiên cứu.
Phân tích kết quả, công bố nghiên cứu dưới dạng hội nghị, bài báo khoa học, công
trình nghiên cứu khoa học, giáo trình giảng dạy và luận án. 
pdf 225 trang phubao 26/12/2022 1820
Bạn đang xem 20 trang mẫu của tài liệu "Luận án Phát triển giải pháp điều khiển thích nghi cho bộ lọc tích cực ba pha", để tải tài liệu gốc về máy hãy click vào nút Download ở trên.

File đính kèm:

  • pdfluan_an_phat_trien_giai_phap_dieu_khien_thich_nghi_cho_bo_lo.pdf
  • pdf3.1_Tóm tắt luận án_Tiếng Anh_NCS Huỳnh Lê Minh Thiện.pdf
  • pdf3.2_Tóm tắt luận án_Tiếng Việt_NCS Huỳnh Lê Minh Thiện.pdf
  • pdf4.1_Thông tin tóm tắt luận án_Tiếng Anh_NCS Huỳnh Lê Minh Thiện.pdf
  • pdf4.2_Thông tin tóm tắt luận án_Tiếng Việt_NCS Huỳnh Lê Minh Thiện.pdf
  • docx6.1_ Trang thông tin những đóng góp mới_Tiếng Anh_NCS Huỳnh Lê Minh Thiện.docx
  • docx6.2_ Trang thông tin những đóng góp mới_Tiếng Việt_NCS Huỳnh Lê Minh Thiện.docx

Nội dung text: Luận án Phát triển giải pháp điều khiển thích nghi cho bộ lọc tích cực ba pha

  1. 174 } / Configure Injected Channel */ / Configure Injected Channel */ sConfigInjected.InjectedRank = sConfigInjected.InjectedChannel = ADC_INJECTED_RANK_3; ADC_CHANNEL_2; if (HAL_ADCEx_InjectedConfigChannel(&hadc2, sConfigInjected.InjectedRank = &sConfigInjected) != HAL_OK) ADC_INJECTED_RANK_1; { sConfigInjected.InjectedSamplingTime = Error_Handler(); ADC_SAMPLETIME_1CYCLE_5; } sConfigInjected.InjectedSingleDiff = /* USER CODE BEGIN ADC2_Init 2 */ ADC_SINGLE_ENDED; sConfigInjected.InjectedOffsetNumber = /* USER CODE END ADC2_Init 2 */ ADC_OFFSET_NONE; } sConfigInjected.InjectedOffset = 0; static void MX_ADC3_Init(void) sConfigInjected.InjectedLeftBitShift = { ADC_LEFTBITSHIFT_NONE; /* USER CODE BEGIN ADC3_Init 0 */ sConfigInjected.InjectedNbrOfConversion = 3; /* USER CODE END ADC3_Init 0 */ sConfigInjected.InjectedDiscontinuousConvMode = ADC_InjectionConfTypeDef sConfigInjected = DISABLE; {0}; sConfigInjected.AutoInjectedConv = ENABLE; /* USER CODE BEGIN ADC3_Init 1 */ sConfigInjected.QueueInjectedContext = /* USER CODE END ADC3_Init 1 */ DISABLE; / Common config */ sConfigInjected.ExternalTrigInjecConv = hadc3.Instance = ADC3; ADC_INJECTED_SOFTWARE_START; hadc3.Init.ClockPrescaler = sConfigInjected.ExternalTrigInjecConvEdge = ADC_CLOCK_ASYNC_DIV8; ADC_EXTERNALTRIGINJECCONV_EDGE_NO hadc3.Init.Resolution = NE; ADC_RESOLUTION_16B; sConfigInjected.InjecOversamplingMode = hadc3.Init.ScanConvMode = ENABLE; ADC_SCAN_ENABLE; sConfigInjected.InjecOversampling.Ratio = 0; hadc3.Init.EOCSelection = sConfigInjected.InjecOversampling.RightBitShift = ADC_EOC_SINGLE_CONV; ADC_RIGHTBITSHIFT_NONE; hadc3.Init.LowPowerAutoWait = DISABLE; if (HAL_ADCEx_InjectedConfigChannel(&hadc2, hadc3.Init.ContinuousConvMode = ENABLE; &sConfigInjected) != HAL_OK) hadc3.Init.NbrOfConversion = 1; { hadc3.Init.DiscontinuousConvMode = DISABLE; Error_Handler(); hadc3.Init.ConversionDataManagement = } ADC_CONVERSIONDATA_DR; / Configure Injected Channel */ hadc3.Init.Overrun = sConfigInjected.InjectedRank = ADC_OVR_DATA_PRESERVED; ADC_INJECTED_RANK_2; hadc3.Init.BoostMode = DISABLE; if (HAL_ADCEx_InjectedConfigChannel(&hadc2, hadc3.Init.OversamplingMode = DISABLE; &sConfigInjected) != HAL_OK) if (HAL_ADC_Init(&hadc3) != HAL_OK) { { Error_Handler(); Error_Handler(); } }
  2. 176 sConfig.DAC_OutputBuffer = htim1.Init.Period = 5000; DAC_OUTPUTBUFFER_ENABLE; htim1.Init.ClockDivision = sConfig.DAC_ConnectOnChipPeripheral = TIM_CLOCKDIVISION_DIV1; DAC_CHIPCONNECT_DISABLE; htim1.Init.RepetitionCounter = 0; sConfig.DAC_UserTrimming = htim1.Init.AutoReloadPreload = DAC_TRIMMING_FACTORY; TIM_AUTORELOAD_PRELOAD_DISABLE; sConfig.DAC_SampleAndHoldConfig.DAC_Sampl if (HAL_TIM_Base_Init(&htim1) != HAL_OK) eTime = 1; { sConfig.DAC_SampleAndHoldConfig.DAC_HoldTi Error_Handler(); me = 1; } sConfig.DAC_SampleAndHoldConfig.DAC_Refres sClockSourceConfig.ClockSource = hTime = 1; TIM_CLOCKSOURCE_INTERNAL; if (HAL_DAC_ConfigChannel(&hdac1, &sConfig, if (HAL_TIM_ConfigClockSource(&htim1, DAC_CHANNEL_1) != HAL_OK) &sClockSourceConfig) != HAL_OK) { { Error_Handler(); Error_Handler(); } } / DAC channel OUT2 config */ if (HAL_TIM_PWM_Init(&htim1) != HAL_OK) sConfig.DAC_ConnectOnChipPeripheral = { DAC_CHIPCONNECT_DISABLE; Error_Handler(); if (HAL_DAC_ConfigChannel(&hdac1, &sConfig, } DAC_CHANNEL_2) != HAL_OK) sSlaveConfig.SlaveMode = { TIM_SLAVEMODE_RESET; Error_Handler(); sSlaveConfig.InputTrigger = TIM_TS_ITR1; } if /* USER CODE BEGIN DAC1_Init 2 */ (HAL_TIM_SlaveConfigSynchronization(&htim1, /* USER CODE END DAC1_Init 2 */ &sSlaveConfig) != HAL_OK) } { /* KHỞI TẠO CHỨC NĂNG TIMER */ Error_Handler(); static void MX_TIM1_Init(void) } { sMasterConfig.MasterOutputTrigger = TIM_ClockConfigTypeDef sClockSourceConfig = TIM_TRGO_RESET; {0}; sMasterConfig.MasterOutputTrigger2 = TIM_SlaveConfigTypeDef sSlaveConfig = {0}; TIM_TRGO2_RESET; TIM_MasterConfigTypeDef sMasterConfig = {0}; sMasterConfig.MasterSlaveMode = TIM_OC_InitTypeDef sConfigOC = {0}; TIM_MASTERSLAVEMODE_DISABLE; TIM_BreakDeadTimeConfigTypeDef if sBreakDeadTimeConfig = {0}; (HAL_TIMEx_MasterConfigSynchronization(&hti /* USER CODE BEGIN TIM1_Init 1 */ m1, &sMasterConfig) != HAL_OK) /* USER CODE END TIM1_Init 1 */ { htim1.Instance = TIM1; Error_Handler(); htim1.Init.Prescaler = 0; } htim1.Init.CounterMode = sConfigOC.OCMode = TIM_OCMODE_PWM1; TIM_COUNTERMODE_CENTERALIGNED1; sConfigOC.Pulse = 0;
  3. 178 { /* @brief TIM3 Initialization Function Error_Handler(); * @param None } * @retval None */ sSlaveConfig.SlaveMode = static void MX_TIM3_Init(void) TIM_SLAVEMODE_DISABLE; { sSlaveConfig.InputTrigger = TIM_TS_ITR1; /* USER CODE BEGIN TIM3_Init 0 */ if /* USER CODE END TIM3_Init 0 */ (HAL_TIM_SlaveConfigSynchronization(&htim2, TIM_ClockConfigTypeDef sClockSourceConfig = &sSlaveConfig) != HAL_OK) {0}; { TIM_MasterConfigTypeDef sMasterConfig = {0}; Error_Handler(); /* USER CODE BEGIN TIM3_Init 1 */ } /* USER CODE END TIM3_Init 1 */ sMasterConfig.MasterOutputTrigger = htim3.Instance = TIM3; TIM_TRGO_RESET; htim3.Init.Prescaler = 0; sMasterConfig.MasterSlaveMode = htim3.Init.CounterMode = TIM_MASTERSLAVEMODE_DISABLE; TIM_COUNTERMODE_CENTERALIGNED1; if htim3.Init.Period = 3999; (HAL_TIMEx_MasterConfigSynchronization(&hti htim3.Init.ClockDivision = m2, &sMasterConfig) != HAL_OK) TIM_CLOCKDIVISION_DIV1; { htim3.Init.AutoReloadPreload = Error_Handler(); TIM_AUTORELOAD_PRELOAD_ENABLE; } if (HAL_TIM_Base_Init(&htim3) != HAL_OK) sConfigOC.OCMode = TIM_OCMODE_PWM1; { sConfigOC.Pulse = 0; Error_Handler(); sConfigOC.OCPolarity = } TIM_OCPOLARITY_HIGH; sClockSourceConfig.ClockSource = sConfigOC.OCFastMode = TIM_CLOCKSOURCE_INTERNAL; TIM_OCFAST_DISABLE; if (HAL_TIM_ConfigClockSource(&htim3, if (HAL_TIM_PWM_ConfigChannel(&htim2, &sClockSourceConfig) != HAL_OK) &sConfigOC, TIM_CHANNEL_1) != HAL_OK) { { Error_Handler(); Error_Handler(); } } sMasterConfig.MasterOutputTrigger = sConfigOC.OCPolarity = TIM_TRGO_RESET; TIM_OCPOLARITY_LOW; sMasterConfig.MasterSlaveMode = if (HAL_TIM_PWM_ConfigChannel(&htim2, TIM_MASTERSLAVEMODE_DISABLE; &sConfigOC, TIM_CHANNEL_2) != HAL_OK) if { (HAL_TIMEx_MasterConfigSynchronization(&hti Error_Handler(); m3, &sMasterConfig) != HAL_OK) } { /* USER CODE BEGIN TIM2_Init 2 */ Error_Handler(); /* USER CODE END TIM2_Init 2 */ } HAL_TIM_MspPostInit(&htim2); /* USER CODE BEGIN TIM3_Init 2 */ } /* USER CODE END TIM3_Init 2 */
  4. 180 } htim15.Instance = TIM15; sBreakDeadTimeConfig.OffStateRunMode = htim15.Init.Prescaler = 0; TIM_OSSR_DISABLE; htim15.Init.CounterMode = sBreakDeadTimeConfig.OffStateIDLEMode = TIM_COUNTERMODE_UP; TIM_OSSI_DISABLE; htim15.Init.Period = 833; sBreakDeadTimeConfig.LockLevel = htim15.Init.ClockDivision = TIM_LOCKLEVEL_OFF; TIM_CLOCKDIVISION_DIV1; sBreakDeadTimeConfig.DeadTime = 0; htim15.Init.RepetitionCounter = 0; sBreakDeadTimeConfig.BreakState = htim15.Init.AutoReloadPreload = TIM_BREAK_DISABLE; TIM_AUTORELOAD_PRELOAD_DISABLE; sBreakDeadTimeConfig.BreakPolarity = if (HAL_TIM_Base_Init(&htim15) != HAL_OK) TIM_BREAKPOLARITY_HIGH; { sBreakDeadTimeConfig.BreakFilter = 0; Error_Handler(); sBreakDeadTimeConfig.Break2State = } TIM_BREAK2_DISABLE; sClockSourceConfig.ClockSource = sBreakDeadTimeConfig.Break2Polarity = TIM_CLOCKSOURCE_INTERNAL; TIM_BREAK2POLARITY_HIGH; if (HAL_TIM_ConfigClockSource(&htim15, sBreakDeadTimeConfig.Break2Filter = 0; &sClockSourceConfig) != HAL_OK) sBreakDeadTimeConfig.AutomaticOutput = { TIM_AUTOMATICOUTPUT_DISABLE; Error_Handler(); if (HAL_TIMEx_ConfigBreakDeadTime(&htim8, } &sBreakDeadTimeConfig) != HAL_OK) if (HAL_TIM_PWM_Init(&htim15) != HAL_OK) { { Error_Handler(); Error_Handler(); } } /* USER CODE BEGIN TIM8_Init 2 */ sMasterConfig.MasterOutputTrigger = /* USER CODE END TIM8_Init 2 */ TIM_TRGO_RESET; HAL_TIM_MspPostInit(&htim8); sMasterConfig.MasterSlaveMode = } TIM_MASTERSLAVEMODE_DISABLE; /* @brief TIM15 Initialization Function if * @param None (HAL_TIMEx_MasterConfigSynchronization(&hti * @retval None */ m15, &sMasterConfig) != HAL_OK) static void MX_TIM15_Init(void) { { Error_Handler(); /* USER CODE BEGIN TIM15_Init 0 */ } /* USER CODE END TIM15_Init 0 */ sConfigOC.OCMode = TIM_OCMODE_PWM1; TIM_ClockConfigTypeDef sClockSourceConfig = sConfigOC.Pulse = 0; {0}; sConfigOC.OCPolarity = TIM_MasterConfigTypeDef sMasterConfig = {0}; TIM_OCPOLARITY_HIGH; TIM_OC_InitTypeDef sConfigOC = {0}; sConfigOC.OCNPolarity = TIM_BreakDeadTimeConfigTypeDef TIM_OCNPOLARITY_HIGH; sBreakDeadTimeConfig = {0}; sConfigOC.OCFastMode = /* USER CODE BEGIN TIM15_Init 1 */ TIM_OCFAST_DISABLE; /* USER CODE END TIM15_Init 1 */
  5. 182 HAL_GPIO_WritePin(GPIOG, HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); ENA_UART_Pin|DISABLE5_Pin|DISABLE6_Pin| /* CẤU HÌNH PORT I/O: PF0 PF3 PF4 PF6 DISABLE7_Pin PF8 PF10 PF12 PF14PF15 */ |DISABLE8_Pin, GPIO_InitStruct.Pin = GPIO_PIN_RESET); GPIO_PIN_0|GPIO_PIN_3|GPIO_PIN_4|GPIO_PI /*Configure GPIO pin Output Level */ N_6 HAL_GPIO_WritePin(GPIOD, |GPIO_PIN_8|GPIO_PIN_10|GPIO_PIN_12|GPIO_ DISABLE1_Pin|DISABLE2_Pin|DISABLE3_Pin|DI PIN_14|GPIO_PIN_15; SABLE4_Pin, GPIO_PIN_RESET); GPIO_InitStruct.Mode = /*Configure GPIO pins : PE2 PE3 PE6 PE7 GPIO_MODE_ANALOG; PE8 PE10 PE14 PE15 GPIO_InitStruct.Pull = GPIO_NOPULL; PE0 PE1 */ HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); GPIO_InitStruct.Pin = /*Configure GPIO pins : INPUT_Pin PF2 */ GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_6|GPIO_PI GPIO_InitStruct.Pin = INPUT_Pin|GPIO_PIN_2; N_7 GPIO_InitStruct.Mode = |GPIO_PIN_8|GPIO_PIN_10|GPIO_PIN_14|GPIO_ GPIO_MODE_OUTPUT_PP; PIN_15 GPIO_InitStruct.Pull = GPIO_NOPULL; |GPIO_PIN_0|GPIO_PIN_1; GPIO_InitStruct.Speed = GPIO_InitStruct.Mode = GPIO_SPEED_FREQ_LOW; GPIO_MODE_ANALOG; HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); GPIO_InitStruct.Pull = GPIO_NOPULL; /* CẤU HÌNH PORT I/O: PH0PH1PH2PH3PH4 HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); PH5PH6PH7PH8 PH9 PH10 PH11PH12 */ /* CẤU HÌNH PORT I/O: PI8 PI10 PI11 PI2 GPIO_InitStruct.Pin = PI3 PI4 PI5 PI6 */ GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PI GPIO_InitStruct.Pin = GPIO_PIN_8| N_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6| GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_2 GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PI |GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PI N_10| GPIO_PIN_11|GPIO_PIN_12; N_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOH, &GPIO_InitStruct); HAL_GPIO_Init(GPIOI, &GPIO_InitStruct); /*Configure GPIO pins : PA2 PA3 PA8 PA9 /*CẤU HÌNH PORT I/O: PC13 PC14 PC15 PC0 PA10 PA11 PA15 */ PC1 PC2 PC5 PC9 GPIO_InitStruct.Pin = PC10 PC11 PC12 */ GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_8|GPIO_PI GPIO_InitStruct.Pin = N_9 GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_ |GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_15; PIN_0 GPIO_InitStruct.Mode = |GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_5|GPIO_PI GPIO_MODE_ANALOG; N_9 GPIO_InitStruct.Pull = GPIO_NOPULL; |GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Mode = /*Configure GPIO pins : PB2 PB10 PB11 PB12 GPIO_MODE_ANALOG; PB13 PB3 PB4 PB5 GPIO_InitStruct.Pull = GPIO_NOPULL; PB6 PB7 PB8 PB9 */
  6. 184 Vc2=0.0152992*(adc1-Vc2_offset); cos_theta=cos(theta_gc); adc2=HAL_ADCEx_InjectedGetValue(&hadc1,2); // reference signals //Vc1 Mag=5000*ma; Vc1=0.0156176*(adc2-Vc1_offset); if (regbank[0][23]==0)// islanding mode adc3=HAL_ADCEx_InjectedGetValue(&hadc2,1); { // I_load err_Ia=Ia-I_ref_a; IL=0.000354296*(adc3-IL_offset); err_Ib=-Ia-Ic-I_ref_b; adc4= HAL_ADCEx_InjectedGetValue(&hadc2,2); err_Ic=Ic-I_ref_c; adc5=HAL_ADCEx_InjectedGetValue(&hadc2,3); Va_ref=5000*(sin_theta); adc6=HAL_ADCEx_InjectedGetValue(&hadc3,1); Vb_ref=5000*(- //Vca 0.5*sin_theta+0.866025404*cos_theta); Vca=0.0320598*(adc6-Vca_offset); Vc_ref=5000*(-0.5*sin_theta- adc7=HAL_ADCEx_InjectedGetValue(&hadc3,2); 0.866025404*cos_theta); // Ic // *ĐIỀU KHIỂN ĐIỆN ÁP TỤ */ Ic=0.000354296*(adc7-Ic_offset); //Vdc_ref=40; adc8=HAL_ADCEx_InjectedGetValue(&hadc3,3); err_Vdc=Vdc_ref-(Vc1+Vc2); //Vab Duty=Duty_old+(Kp_Vdc+Ki_Vdc)*err_Vdc- Vab=0.0301928*(adc8-Vab_offset); Kp_Vdc*err_Vdc_old; adc9=HAL_ADCEx_InjectedGetValue(&hadc3,4); if (Duty>1) Duty=1; //Ia if (Duty f_max) up=0; err_Vdc_old=err_Vdc; else if (count1 delta_f2) up2=0; D2=(int)(Duty*5000); else if (del_t2 1) Iac_c=1; theta_g+=delta_theta; if (Iac_c two_pi) theta=theta-two_pi; //ma=err_Iac*Kp_Iac; if(theta_g>two_pi) theta_g=theta_g-two_pi; if (ma>1) ma=1; if(theta_gc>two_pi) if (ma<-1) ma=-1; theta_gc=theta_gc-two_pi; ma=0; if(theta_g<0) theta_g=two_pi-theta_g; Va_ref=5000*ma*(sin_theta)- sin_theta=sin(theta); err_Ia*Kp_Iac; cos_theta=cos(theta); sin_theta=sin(theta_gc);
  7. 186 { IL_f=IL*0.001+IL_old*0.999;IL_old=IL_f; __HAL_TIM_SET_COMPARE(&htim1,TIM_CHA max_scale=two_pi; NNEL_1,(int)(5000+Vc_ref));//Cs2s4 theta=two_pi; __HAL_TIM_SET_COMPARE(&htim1,TIM_CHA DAC=(uint16_t)(err_Ia*2047.0/max_scale+2047); NNEL_2,(int)0);//Cs1s3 DAC2=(uint16_t)(I_ref*2047.0/max_scale+2047); __HAL_TIM_SET_COMPARE(&htim1,TIM_CHA DAC2=(uint16_t)(Ia*2047.0/max_scale+2047); NNEL_1,(int)(c24));//Cs2s4 //err_Iac } HAL_DAC_SetValue(&hdac1, ////////////////////////////////////////// DAC_CHANNEL_1, DAC_ALIGN_12B_R, DAC); if (Vab>0) { if (Vab>Vab_max) //max 4096 Vab_max=Vab; Vab_status=1;countvab=0;} HAL_DAC_Start(&hdac1, DAC_CHANNEL_1); if (Vab 0) { if (Vca>Vca_max) HAL_DAC_Start(&hdac1, DAC_CHANNEL_2); Vca_max=Vca; Vca_status=1;countvca=0;} //DAC_get=HAL_DAC_GetValue(&hdac1, if (Vca 0) { if (Ia>Ia_max) Ia_max=Ia; uint16_t crc_cal(uint8_t* data, int num) Ia_status=1;countia=0;} { if (Ia 9)) uint16_t crc; {Ia_m=Ia_max;Ia_max=0;Ia_status=0;}} crc = 0xffff; if (Ic>0) for (j=0; j Ic_max) Ic_max=Ic; { Ic_status=1;countic=0;} crc = (uint16_t)(crc ^ data[j]); if (Ic 9)) { {Ic_m=Ic_max;Ic_max=0;Ic_status=0;}} if ((crc & 0x0001) == 1) ////////////////////////////////////////////////////////// { Vab_f=Vab*0.2+Vab_old*0.8;Vab_old=Vab_f;// crc = crc >> 1; filter AB crc = crc ^ 0xa001; if (Vab_f > 1); Im=k*IL_f; } I_ref_a=-Im*sin_theta; } I_ref_b=-Im*(- crc = (uint16_t)(((crc > 8)) & 0.5*sin_theta+0.866025404*cos_theta); 0xffff); I_ref_c=-Im*(-0.5*sin_theta- return crc; 0.866025404*cos_theta); }
  8. 188 else { { for(temp1=0;temp1 9) break; { default: for(temp1=0;temp1 > 8) & 0xff); /* Infinite loop */ data_send[length_data_send - 1] = (my_crc & 0xff); for(;;) HAL_GPIO_WritePin(ENA_UART_GPIO_Port, { ENA_UART_Pin, 1); uint8_t clear = 0; HAL_UART_Transmit(&huart4, if (enable_tx == 1) &data_send[0],length_data_send,0xff); { HAL_GPIO_WritePin(ENA_UART_GPIO if ((cmd == 1) || (cmd == 2)) _Port, ENA_UART_Pin, 0); { } uint8_t else if (cmd == 3) temp=0,temp1=0; { start_address =valid_data[3]; start_address = (valid_data[2] >8)&0xff; if(num_reg<9)
  9. 190 { Ic_offset = sum/10000.0;sum=0; data_send[clear]=0; for(i=0;i<10000;i++) } { clear=0; adc3=HAL_ADCEx_InjectedGetValue(&hadc2,1);// enable_tx = 0; IL /*CODE END Header_chuongtrinh1 */ for(j=1;j<10000;j++); void chuongtrinh1(void const * argument) sum+=adc3; { } /* USER CODE BEGIN chuongtrinh1 */ IL_offset = sum/10000.0;sum=0; /* Infinite loop */ for(i=0;i<10000;i++) uint32_t sum=0; { uint16_t j; adc8=HAL_ADCEx_InjectedGetValue(&hadc3,3);// for(i=0;i<10000;i++) Vab { for(j=1;j<10000;j++); adc1=HAL_ADCEx_InjectedGetValue(&ha sum+=adc8; dc1,1); } for(j=1;j<10000;j++); Vab_offset = sum/10000.0;sum=0; sum+=adc1; for(i=0;i<10000;i++) } { Vc2_offset = sum/10000.0;sum=0; adc9=HAL_ADCEx_InjectedGetValue(&hadc3,4);// for(i=0;i<10000;i++) Ia { for(j=1;j<10000;j++); adc2=HAL_ADCEx_InjectedGetValue(&ha sum+=adc9; dc1,2); } for(j=1;j<10000;j++); Ia_offset = sum/10000.0;sum=0; sum+=adc2; HAL_TIM_Base_Start_IT(&htim3); } htim2.Init.Period = 1000; Vc1_offset = sum/10000.0;sum=0; HAL_DAC_Start(&hdac1,DAC_CHANNEL_1); HAL_DAC_SetValue(&hdac1, for(i=0;i<10000;i++) DAC_CHANNEL_1, DAC_ALIGN_12B_R, 2048); { HAL_DAC_Start(&hdac1,DAC_CHANNEL_2); adc6=HAL_ADCEx_InjectedGetValue(&ha HAL_DAC_SetValue(&hdac1, dc3,1); DAC_CHANNEL_2, DAC_ALIGN_12B_R, 1024); for(j=1;j<10000;j++); for(;;) sum+=adc6; { } if (regbank[0][2]==1) Vca_offset = sum/10000.0;sum=0; { for(i=0;i<10000;i++) DISABLE1_OFF; { DISABLE2_OFF; adc7=HAL_ADCEx_InjectedGetValue(&hadc3,2); DISABLE3_OFF; //Ic DISABLE4_OFF; for(j=1;j<10000;j++); DISABLE5_OFF; sum+=adc7; DISABLE6_OFF; } DISABLE7_OFF;
  10. 192 HAL_TIMEx_PWMN_Stop(&htim8, //////////////////////////////////////////////////// TIM_CHANNEL_2); __HAL_TIM_SET_COMPARE(&htim15,TIM_CH HAL_TIM_PWM_Stop(&htim8, ANNEL_1,(int)(dem*power));__HAL_TIM_SET_C TIM_CHANNEL_3); OMPARE(&htim1,TIM_CHANNEL_1,(int)(dem*p HAL_TIMEx_PWMN_Stop(&htim8, ower));__HAL_TIM_SET_COMPARE(&htim1,TI TIM_CHANNEL_3); M_CHANNEL_2,(int)((200-power)*dem)); ////////////////////////////////////////// f_min=90e6/(f+delta_f/2); HAL_TIM_PWM_Stop(&htim15, f_max=90e6/(f-delta_f/2); TIM_CHANNEL_1); f_min2=regbank[2][123]; HAL_TIMEx_PWMN_Stop(&htim15, f_max2=regbank[2][124]; TIM_CHANNEL_1); f1=f_min2; __HAL_TIM_SET_COUNTER(&htim1, 0); delta_t=Ts*f1*delta_f; __HAL_TIM_SET_COUNTER(&htim8, 0); delta_f2=(float)(f_max2)/(float)f_min2; regbank[0][11]=0; delta_t2=Ts*f2*delta_f2; } delta_theta=two_pi*f_ref*Ts; } Mag=8660.254*ma/Vab_m;//5000*sqrt(3)=8660.25 f2=regbank[2][127]; 4, 5000 period of PWM __HAL_TIM_SET_AUTORELOAD(&htim1,(int)f_ //////////////////////// dien ap, dong dien// max); adc1=HAL_ADCEx_InjectedGetValue(&hadc1,1); __HAL_TIM_SET_AUTORELOAD(&htim2,(int)f_ adc2=HAL_ADCEx_InjectedGetValue(&hadc1,2); max); adc3=HAL_ADCEx_InjectedGetValue(&hadc2,1); __HAL_TIM_SET_AUTORELOAD(&htim8,(int)f_ adc4=HAL_ADCEx_InjectedGetValue(&hadc2,2); max); adc5=HAL_ADCEx_InjectedGetValue(&hadc2,3); __HAL_TIM_SET_AUTORELOAD(&htim15,(int)f adc6=HAL_ADCEx_InjectedGetValue(&hadc3,1); _max); adc7=HAL_ADCEx_InjectedGetValue(&hadc3,2); //////////////////////////////////////////// adc8=HAL_ADCEx_InjectedGetValue(&hadc3,3); __HAL_TIM_SET_COMPARE(&htim1,TIM_CHA adc9=HAL_ADCEx_InjectedGetValue(&hadc3,4);// NNEL_1,(int)(dem*power)*2); HAL_GPIO_WritePin(GPIOF,GPIO_PIN_1,1); __HAL_TIM_SET_COMPARE(&htim1,TIM_CHA Vab_m_f=Vab_m*0.01+Vab_m_old*0.99; NNEL_2,(int)(dem*power)*2); Vab_m_old=Vab_m_f;// filter AC __HAL_TIM_SET_COMPARE(&htim1,TIM_CHA Vca_m_f=Vca_m*0.01+Vca_m_old*0.99; NNEL_3,(int)(dem*power)*2); Vca_m_old=Vca_m_f;// filter AC /////////////////////////////////////////////////////// Ia_m_f=Ia_m*0.01+Ia_m_old*0.99;Ia_m_old=Ia_m __HAL_TIM_SET_COMPARE(&htim2,TIM_CHA _f; NNEL_1,(int)(dem*power)*2); // filter AC __HAL_TIM_SET_COMPARE(&htim2,TIM_CHA NNEL_2,(int)(dem*power)*2); Ic_m_f=Ic_m*0.01+Ic_m_old*0.99;Ic_m_old=Ic_m /////////////////////////////////////////////// _f; __HAL_TIM_SET_COMPARE(&htim8,TIM_CHA // filter AC NNEL_1,(int)(dem*power)*2); Vc1_f=Vc1*0.01+Vc1_old*0.99; Vc1_old=Vc1_f; __HAL_TIM_SET_COMPARE(&htim8,TIM_CHA // filter DC NNEL_2,(int)(dem*power)*2); Vc2_f=Vc2*0.01+Vc2_old*0.99; Vc2_old=Vc2_f; __HAL_TIM_SET_COMPARE(&htim8,TIM_CHA regbank[2][56]=(int)(100*Vab_m_f/sqrt(2)) NNEL_3,(int)(dem*power)*2); ;
  11. 194 /* USER CODE BEGIN Error_Handler_Debug */ /* User can add his own implementation to report the HAL error return state */ while(1) { /* USER CODE BEGIN 6 */ /* User can add his own implementation to report the file name and line number, tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ /* USER CODE END 6 */ } #endif /* USE_FULL_ASSERT */ //*(C) COPYRIGHT STMicroelectronics // END OF FILE