|
|
|
/*
|
|
|
|
* SystemControlExecute.cpp
|
|
|
|
*
|
|
|
|
* Author: Aleksey Gerasimenko
|
|
|
|
* gerasimenko.aleksey.n@gmail.com
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include "SYSCTRL/SystemControl.h"
|
|
|
|
|
|
|
|
namespace SYSCTRL
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::execute_additional()
|
|
|
|
{
|
|
|
|
(this->*_execute_additional)();
|
|
|
|
}//
|
|
|
|
//
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::_additional_undef()
|
|
|
|
{}//
|
|
|
|
//
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::_additional_operational()
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// RMS Filter
|
|
|
|
//
|
|
|
|
m_environment.rms_current_input_a = m_rms_filter_current_input_a.execute(m_environment.current_input_a);
|
|
|
|
m_environment.rms_current_input_b = m_rms_filter_current_input_b.execute(m_environment.current_input_b);
|
|
|
|
m_environment.rms_current_input_c = m_rms_filter_current_input_c.execute(m_environment.current_input_c);
|
|
|
|
//
|
|
|
|
m_environment.rms_current_cell_a = m_rms_filter_current_cell_a.execute(m_environment.current_cell_a);
|
|
|
|
m_environment.rms_current_cell_b = m_rms_filter_current_cell_b.execute(m_environment.current_cell_b);
|
|
|
|
m_environment.rms_current_cell_c = m_rms_filter_current_cell_c.execute(m_environment.current_cell_c);
|
|
|
|
//
|
|
|
|
m_environment.rms_current_load_a = m_rms_filter_current_load_a.execute(m_environment.current_load_a);
|
|
|
|
m_environment.rms_current_load_b = m_rms_filter_current_load_b.execute(m_environment.current_load_b);
|
|
|
|
m_environment.rms_current_load_c = m_rms_filter_current_load_c.execute(m_environment.current_load_c);
|
|
|
|
//
|
|
|
|
m_environment.rms_voltage_input_ab = m_rms_filter_voltage_input_a.execute(m_environment.voltage_grid_a - m_environment.voltage_grid_b);
|
|
|
|
m_environment.rms_voltage_input_bc = m_rms_filter_voltage_input_b.execute(m_environment.voltage_grid_b - m_environment.voltage_grid_c);
|
|
|
|
m_environment.rms_voltage_input_ca = m_rms_filter_voltage_input_c.execute(m_environment.voltage_grid_c - m_environment.voltage_grid_a);
|
|
|
|
//
|
|
|
|
m_environment.rms_current_bypass_a = m_rms_filter_current_bypass_a.execute(m_environment.current_bypass_a);
|
|
|
|
m_environment.rms_current_bypass_b = m_rms_filter_current_bypass_b.execute(m_environment.current_bypass_b);
|
|
|
|
m_environment.rms_current_bypass_c = m_rms_filter_current_bypass_c.execute(m_environment.current_bypass_c);
|
|
|
|
//
|
|
|
|
m_environment.rms_voltage_load_ab = m_rms_filter_voltage_load_a.execute(m_environment.voltage_load_a - m_environment.voltage_load_b);
|
|
|
|
m_environment.rms_voltage_load_bc = m_rms_filter_voltage_load_b.execute(m_environment.voltage_load_b - m_environment.voltage_load_c);
|
|
|
|
m_environment.rms_voltage_load_ca = m_rms_filter_voltage_load_c.execute(m_environment.voltage_load_c - m_environment.voltage_load_a);
|
|
|
|
//<>
|
|
|
|
|
|
|
|
//
|
|
|
|
// RMS Module
|
|
|
|
//
|
|
|
|
// xrms = sqrt((xa*xa + xb*xb + xc*xc)/3)
|
|
|
|
SYSCTRL::SystemControl::_rms_module_calculator(m_environment.voltage_grid_a, m_environment.voltage_grid_b, m_environment.voltage_grid_c, m_environment.rms_voltage_input_module);
|
|
|
|
SYSCTRL::SystemControl::_rms_module_calculator(m_environment.voltage_load_a, m_environment.voltage_load_b, m_environment.voltage_load_c, m_environment.rms_voltage_load_module);
|
|
|
|
SYSCTRL::SystemControl::_rms_module_calculator(m_environment.current_input_a, m_environment.current_input_b, m_environment.current_input_c, m_environment.rms_current_input_module);
|
|
|
|
SYSCTRL::SystemControl::_rms_module_calculator(m_environment.current_load_a, m_environment.current_load_b, m_environment.current_load_c, m_environment.rms_current_load_module);
|
|
|
|
SYSCTRL::SystemControl::_rms_module_calculator(m_environment.current_bypass_a, m_environment.current_bypass_b, m_environment.current_bypass_c, m_environment.rms_current_bypass_module);
|
|
|
|
//<>
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// FRAM Operation Control Bits
|
|
|
|
//
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.fram_operation.signal.burn, m_environment.fram_burn);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.fram_operation.signal.erase, m_environment.fram_erase);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.fram_operation.signal.verify, m_environment.fram_verify);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.fram_operation.signal.read, m_environment.fram_read);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.fram_operation.signal.restore, m_environment.fram_restore);
|
|
|
|
//<>
|
|
|
|
|
|
|
|
//
|
|
|
|
// FRAM Control
|
|
|
|
//
|
|
|
|
if(m_fram_db.is_free())
|
|
|
|
{
|
|
|
|
// FRAM is free
|
|
|
|
//
|
|
|
|
if(m_environment.fram_erase.signal.is_switched_on)
|
|
|
|
{
|
|
|
|
m_fram_db.set_erase();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(m_environment.fram_verify.signal.is_switched_on)
|
|
|
|
{
|
|
|
|
m_fram_db.set_verify();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(m_environment.fram_burn.signal.is_switched_on)
|
|
|
|
{
|
|
|
|
m_system_configuration.selfupdata();
|
|
|
|
m_fram_db.update_buffer(&m_system_configuration);
|
|
|
|
m_fram_db.set_burn();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(m_environment.fram_restore.signal.is_switched_on)
|
|
|
|
{
|
|
|
|
m_fram_db.implement_dafault_configuration();
|
|
|
|
m_fram_db.update_buffer(&m_system_configuration);
|
|
|
|
m_fram_db.set_restore();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
}//if else
|
|
|
|
//
|
|
|
|
}//if else
|
|
|
|
//
|
|
|
|
}//if else
|
|
|
|
//
|
|
|
|
}//if else
|
|
|
|
//
|
|
|
|
}//if
|
|
|
|
//<>
|
|
|
|
//
|
|
|
|
if(m_fram_db.is_busy())
|
|
|
|
{
|
|
|
|
// FRAM is busy
|
|
|
|
//WAIT, READ, WRITE, ERASE, VERIFY, RESTORE
|
|
|
|
switch(m_fram_db.get_mode())
|
|
|
|
{
|
|
|
|
case FRAM::FRAMDATABASE::READ:
|
|
|
|
{
|
|
|
|
m_fram_db.read_fram_index();
|
|
|
|
break;
|
|
|
|
}//
|
|
|
|
case FRAM::FRAMDATABASE::BURN:
|
|
|
|
{
|
|
|
|
m_fram_db.write_fram_index();
|
|
|
|
reload();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case FRAM::FRAMDATABASE::ERASE:
|
|
|
|
{
|
|
|
|
m_fram_db.erase_fram_index();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case FRAM::FRAMDATABASE::VERIFY:
|
|
|
|
{
|
|
|
|
m_fram_db.verify_fram_index();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case FRAM::FRAMDATABASE::RESTORE:
|
|
|
|
{
|
|
|
|
m_fram_db.restore_fram_index();
|
|
|
|
reload();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}//switch
|
|
|
|
//
|
|
|
|
}//if
|
|
|
|
//<>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Response To Monitor
|
|
|
|
//
|
|
|
|
m_test_read_word.bit32.b00 = m_fram_db.is_free() ? 1 : 0;
|
|
|
|
//<>
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Algorithm Control
|
|
|
|
//
|
|
|
|
m_environment.algorithm_control.all = m_system_configuration.algorithm_control.all;
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.algorithm_control.signal.enable_current_limit, m_environment.enable_current_limit);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.algorithm_control.signal.enable_pfc, m_environment.enable_pfc);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.algorithm_control.signal.enable_harmonica, m_environment.enable_harmonica);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.algorithm_control.signal.enable_auto_offset, m_environment.enable_auto_offset);
|
|
|
|
//
|
|
|
|
#if TYPECONTROL == SCALARCONTROL
|
|
|
|
m_environment.phase_control.common_control_bit.signal.enable_current_limit = m_environment.enable_current_limit.signal.is_on;
|
|
|
|
m_environment.phase_control.common_control_bit.signal.enable_pfc = m_environment.enable_pfc.signal.is_on;
|
|
|
|
m_environment.phase_control.common_control_bit.signal.enable_harmonica = m_environment.enable_harmonica.signal.is_on;
|
|
|
|
//
|
|
|
|
m_environment.phase_control.phase_a.control_bit.all = m_environment.phase_control.common_control_bit.all;
|
|
|
|
m_environment.phase_control.phase_b.control_bit.all = m_environment.phase_control.common_control_bit.all;
|
|
|
|
m_environment.phase_control.phase_c.control_bit.all = m_environment.phase_control.common_control_bit.all;
|
|
|
|
#endif
|
|
|
|
//<>
|
|
|
|
|
|
|
|
}//
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::slow_loop_execute()
|
|
|
|
{
|
|
|
|
(this->*_slow_loop_execute)();
|
|
|
|
//
|
|
|
|
}//
|
|
|
|
//
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::_slow_loop_undef()
|
|
|
|
{}//
|
|
|
|
//
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::_slow_loop_operational()
|
|
|
|
{
|
|
|
|
|
|
|
|
if(m_environment.allow_auto_offset)
|
|
|
|
{
|
|
|
|
m_environment.offset_voltage_grid_a = m_zero_filter_voltage_input_a.execute(m_environment.adc_voltage_grid_a);
|
|
|
|
m_environment.offset_voltage_grid_b = m_zero_filter_voltage_input_b.execute(m_environment.adc_voltage_grid_b);
|
|
|
|
m_environment.offset_voltage_grid_c = m_zero_filter_voltage_input_c.execute(m_environment.adc_voltage_grid_c);
|
|
|
|
//
|
|
|
|
m_environment.offset_current_input_a = m_zero_filter_current_input_a.execute(m_environment.adc_current_input_a);
|
|
|
|
m_environment.offset_current_input_b = m_zero_filter_current_input_b.execute(m_environment.adc_current_input_b);
|
|
|
|
m_environment.offset_current_input_c = m_zero_filter_current_input_c.execute(m_environment.adc_current_input_c);
|
|
|
|
//
|
|
|
|
m_environment.offset_current_bypass_a = m_zero_filter_current_bypass_a.execute(m_environment.adc_current_bypass_a);
|
|
|
|
m_environment.offset_current_bypass_b = m_zero_filter_current_bypass_b.execute(m_environment.adc_current_bypass_b);
|
|
|
|
m_environment.offset_current_bypass_c = m_zero_filter_current_bypass_c.execute(m_environment.adc_current_bypass_c);
|
|
|
|
//
|
|
|
|
m_environment.offset_current_cell_a = m_zero_filter_current_cell_a.execute(m_environment.adc_current_cell_a);
|
|
|
|
m_environment.offset_current_cell_b = m_zero_filter_current_cell_b.execute(m_environment.adc_current_cell_b);
|
|
|
|
m_environment.offset_current_cell_c = m_zero_filter_current_cell_c.execute(m_environment.adc_current_cell_c);
|
|
|
|
//
|
|
|
|
m_environment.offset_voltage_load_a = m_zero_filter_voltage_load_a.execute(m_environment.adc_voltage_load_a);
|
|
|
|
m_environment.offset_voltage_load_b = m_zero_filter_voltage_load_b.execute(m_environment.adc_voltage_load_b);
|
|
|
|
m_environment.offset_voltage_load_c = m_zero_filter_voltage_load_c.execute(m_environment.adc_voltage_load_c);
|
|
|
|
//
|
|
|
|
m_environment.offset_current_load_a = m_zero_filter_current_load_a.execute(m_environment.adc_current_load_a);
|
|
|
|
m_environment.offset_current_load_b = m_zero_filter_current_load_b.execute(m_environment.adc_current_load_b);
|
|
|
|
m_environment.offset_current_load_c = m_zero_filter_current_load_c.execute(m_environment.adc_current_load_c);
|
|
|
|
//
|
|
|
|
}//if
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Phase Alert monitor
|
|
|
|
//
|
|
|
|
m_phase_alert_monitor.execute(m_environment.rms_voltage_input_ab,
|
|
|
|
m_environment.rms_voltage_input_bc,
|
|
|
|
m_environment.rms_voltage_input_ca,
|
|
|
|
m_environment.rms_current_load_a,
|
|
|
|
m_environment.rms_current_load_b,
|
|
|
|
m_environment.rms_current_load_c,
|
|
|
|
m_environment.rms_current_cell_a,
|
|
|
|
m_environment.rms_current_cell_b,
|
|
|
|
m_environment.rms_current_cell_c,
|
|
|
|
m_environment.rms_current_input_a,
|
|
|
|
m_environment.rms_current_input_b,
|
|
|
|
m_environment.rms_current_input_c);
|
|
|
|
|
|
|
|
if(m_system_fault_trigger.signal.quit)
|
|
|
|
{
|
|
|
|
m_environment.phase_alert_monitor_register.phase_a.fault.all = m_environment.system_faults_register.phase_a.all;
|
|
|
|
m_environment.phase_alert_monitor_register.phase_b.fault.all = m_environment.system_faults_register.phase_b.all;
|
|
|
|
m_environment.phase_alert_monitor_register.phase_c.fault.all = m_environment.system_faults_register.phase_c.all;
|
|
|
|
m_environment.phase_alert_monitor_register.phase_a.warning.all = m_phase_alert_monitor.status.phase_a.warning.all;
|
|
|
|
m_environment.phase_alert_monitor_register.phase_b.warning.all = m_phase_alert_monitor.status.phase_b.warning.all;
|
|
|
|
m_environment.phase_alert_monitor_register.phase_c.warning.all = m_phase_alert_monitor.status.phase_c.warning.all;
|
|
|
|
//
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_environment.phase_alert_monitor_register = m_phase_alert_monitor.status;
|
|
|
|
//
|
|
|
|
}//
|
|
|
|
//<>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if (TYPECONTROL == VECTORCONTROL) || (TYPECONTROL == DIRECTREVERSECONTROL)
|
|
|
|
//
|
|
|
|
// Decompose Input Voltage
|
|
|
|
m_decompose_voltage_input_a.execute(m_environment.voltage_grid_a, m_environment.pll_abc_orts.phase_a.active, m_environment.pll_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_voltage_input_a.get_outputs(m_environment.projection_voltage_input_a.active, m_environment.projection_voltage_input_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_input_b.execute(m_environment.voltage_grid_b, m_environment.pll_abc_orts.phase_b.active, m_environment.pll_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_voltage_input_b.get_outputs(m_environment.projection_voltage_input_b.active, m_environment.projection_voltage_input_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_input_c.execute(m_environment.voltage_grid_c, m_environment.pll_abc_orts.phase_c.active, m_environment.pll_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_voltage_input_c.get_outputs(m_environment.projection_voltage_input_c.active, m_environment.projection_voltage_input_c.reactive);
|
|
|
|
// m_environment.projection_voltage_input_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_voltage_input_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_voltage_input_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
// Ort Corrector
|
|
|
|
if(m_pll_abc_input_voltage.get_sync() && m_environment.auxiliary_q1.state.signal.is_on)
|
|
|
|
{
|
|
|
|
// Spinner
|
|
|
|
SYSCTRL::VectorSpinner::spin_calculator(m_environment.projection_voltage_input_a, m_environment.module_voltage_phase_a, m_environment.spinner_phase_a);
|
|
|
|
SYSCTRL::VectorSpinner::spin_calculator(m_environment.projection_voltage_input_b, m_environment.module_voltage_phase_b, m_environment.spinner_phase_b);
|
|
|
|
SYSCTRL::VectorSpinner::spin_calculator(m_environment.projection_voltage_input_c, m_environment.module_voltage_phase_c, m_environment.spinner_phase_c);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Reset Spinner
|
|
|
|
m_environment.spinner_phase_a.active = 1.0;
|
|
|
|
m_environment.spinner_phase_a.reactive = FP_ZERO;
|
|
|
|
|
|
|
|
m_environment.spinner_phase_b.active = 1.0;
|
|
|
|
m_environment.spinner_phase_b.reactive = FP_ZERO;
|
|
|
|
|
|
|
|
m_environment.spinner_phase_c.active = 1.0;
|
|
|
|
m_environment.spinner_phase_c.reactive = FP_ZERO;
|
|
|
|
//
|
|
|
|
}//if else
|
|
|
|
//
|
|
|
|
SYSCTRL::VectorSpinner::ort_corrector(m_environment.spinner_phase_a, m_environment.pll_abc_orts.phase_a, m_environment.twisted_abc_orts.phase_a);
|
|
|
|
SYSCTRL::VectorSpinner::ort_corrector(m_environment.spinner_phase_b, m_environment.pll_abc_orts.phase_b, m_environment.twisted_abc_orts.phase_b);
|
|
|
|
SYSCTRL::VectorSpinner::ort_corrector(m_environment.spinner_phase_c, m_environment.pll_abc_orts.phase_c, m_environment.twisted_abc_orts.phase_c);
|
|
|
|
//<>
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::ort_abc_jm_from_real(m_environment.twisted_abc_orts.phase_a.active,
|
|
|
|
m_environment.twisted_abc_orts.phase_b.active,
|
|
|
|
m_environment.twisted_abc_orts.phase_c.active,
|
|
|
|
m_environment.twisted_abc_orts.phase_a.reactive,
|
|
|
|
m_environment.twisted_abc_orts.phase_b.reactive,
|
|
|
|
m_environment.twisted_abc_orts.phase_c.reactive);
|
|
|
|
//
|
|
|
|
//m_environment.main_abc_orts = m_environment.pll_abc_orts;
|
|
|
|
//m_environment.main_abc_orts = m_environment.twisted_abc_orts;
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.main_abc_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_orts.phase_c.active,
|
|
|
|
m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
//Decompose Load Voltage
|
|
|
|
m_decompose_voltage_load_a.execute(m_environment.voltage_load_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_voltage_load_a.get_outputs(m_environment.projection_voltage_load_a.active, m_environment.projection_voltage_load_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_load_b.execute(m_environment.voltage_load_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_voltage_load_b.get_outputs(m_environment.projection_voltage_load_b.active, m_environment.projection_voltage_load_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_load_c.execute(m_environment.voltage_load_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_voltage_load_c.get_outputs(m_environment.projection_voltage_load_c.active, m_environment.projection_voltage_load_c.reactive);
|
|
|
|
|
|
|
|
// m_environment.projection_voltage_load_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_voltage_load_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_voltage_load_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
//Decompose Load Current
|
|
|
|
m_decompose_current_load_a.execute(m_environment.current_load_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_current_load_a.get_outputs(m_environment.projection_current_load_a.active, m_environment.projection_current_load_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_load_b.execute(m_environment.current_load_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_current_load_b.get_outputs(m_environment.projection_current_load_b.active, m_environment.projection_current_load_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_load_c.execute(m_environment.current_load_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_current_load_c.get_outputs(m_environment.projection_current_load_c.active, m_environment.projection_current_load_c.reactive);
|
|
|
|
|
|
|
|
// m_environment.projection_current_load_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_current_load_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_current_load_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
//Decompose Bypass Current
|
|
|
|
m_decompose_current_bypass_a.execute(m_environment.current_bypass_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_current_bypass_a.get_outputs(m_environment.projection_current_bypass_a.active, m_environment.projection_current_bypass_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_bypass_b.execute(m_environment.current_bypass_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_current_bypass_b.get_outputs(m_environment.projection_current_bypass_b.active, m_environment.projection_current_bypass_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_bypass_c.execute(m_environment.current_bypass_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_current_bypass_c.get_outputs(m_environment.projection_current_bypass_c.active, m_environment.projection_current_bypass_c.reactive);
|
|
|
|
|
|
|
|
// m_environment.projection_current_bypass_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_current_bypass_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_current_bypass_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
//Decompose Cell Current
|
|
|
|
m_decompose_current_cell_a.execute(m_environment.current_cell_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_current_cell_a.get_outputs(m_environment.projection_current_cell_a.active, m_environment.projection_current_cell_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_cell_b.execute(m_environment.current_cell_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_current_cell_b.get_outputs(m_environment.projection_current_cell_b.active, m_environment.projection_current_cell_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_cell_c.execute(m_environment.current_cell_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_current_cell_c.get_outputs(m_environment.projection_current_cell_c.active, m_environment.projection_current_cell_c.reactive);
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
}//
|
|
|
|
//
|
|
|
|
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::execute_symmetrical_calculator()
|
|
|
|
{
|
|
|
|
//
|
|
|
|
// Symmetrical Components
|
|
|
|
//
|
|
|
|
//define symmetrical components of input voltage
|
|
|
|
SYSCTRL::SymmetricalComponents::compute_symmetrical_components_axis_own(m_environment.projection_voltage_input_a,
|
|
|
|
m_environment.projection_voltage_input_b,
|
|
|
|
m_environment.projection_voltage_input_c,
|
|
|
|
m_environment.symmetrical_components_voltage_input);
|
|
|
|
// SYSCTRL::SymmetricalComponents::compute_symmetrical_components_axis_own(m_environment.test_projection_a,
|
|
|
|
// m_environment.test_projection_b,
|
|
|
|
// m_environment.test_projection_c,
|
|
|
|
// m_environment.symmetrical_components_voltage_input);
|
|
|
|
|
|
|
|
//define symmetrical components of load voltage
|
|
|
|
SYSCTRL::SymmetricalComponents::compute_symmetrical_components_axis_own(m_environment.projection_voltage_load_a,
|
|
|
|
m_environment.projection_voltage_load_b,
|
|
|
|
m_environment.projection_voltage_load_c,
|
|
|
|
m_environment.symmetrical_components_voltage_load);
|
|
|
|
|
|
|
|
//define symmetrical components of load current
|
|
|
|
SYSCTRL::SymmetricalComponents::compute_symmetrical_components_axis_own(m_environment.projection_current_load_a,
|
|
|
|
m_environment.projection_current_load_b,
|
|
|
|
m_environment.projection_current_load_c,
|
|
|
|
m_environment.symmetrical_components_current_load);
|
|
|
|
|
|
|
|
//define symmetrical components of bypass current
|
|
|
|
SYSCTRL::SymmetricalComponents::compute_symmetrical_components_axis_own(m_environment.projection_current_bypass_a,
|
|
|
|
m_environment.projection_current_bypass_b,
|
|
|
|
m_environment.projection_current_bypass_c,
|
|
|
|
m_environment.symmetrical_components_current_bypass);
|
|
|
|
//<>
|
|
|
|
}//
|
|
|
|
//
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::execute()
|
|
|
|
{
|
|
|
|
(this->*_execute)();
|
|
|
|
//
|
|
|
|
}//execute()
|
|
|
|
//
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::_execute_ubdef()
|
|
|
|
{
|
|
|
|
//
|
|
|
|
}//_execute_ubdef()
|
|
|
|
//
|
|
|
|
#pragma CODE_SECTION("ramfuncs");
|
|
|
|
void SystemControl::_execute_operational()
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// External Command
|
|
|
|
//
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.start, m_environment.external_start);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.stop, m_environment.external_stop);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.reset, m_environment.external_reset);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.e_stop, m_environment.external_e_stop);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.km1_on, m_environment.external_km1_on);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.km1_off, m_environment.external_km1_off);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.km3_on, m_environment.external_km3_on);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.km3_off, m_environment.external_km3_off);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.q1_on, m_environment.external_q1_on);
|
|
|
|
SYSCTRL::MonitorDigitalInputSignal::implement(m_environment.external_command_word.signal.q1_off, m_environment.external_q1_off);
|
|
|
|
//
|
|
|
|
//
|
|
|
|
if (m_environment.external_q1_on.signal.is_switched_on)
|
|
|
|
{
|
|
|
|
turnQ1On = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_environment.external_q1_off.signal.is_switched_on)
|
|
|
|
{
|
|
|
|
turnQ1On = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(m_environment.system_fault.boolbit.b0)
|
|
|
|
{
|
|
|
|
turnQ1On = false;
|
|
|
|
}
|
|
|
|
// Command KM1 - on/off
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_km1_external_command_trigger,
|
|
|
|
!m_environment.system_fault.boolbit.b0 &
|
|
|
|
m_environment.input_discrete.signal.hw_dvr_ready &
|
|
|
|
m_environment.input_discrete.signal.bypass_ready &
|
|
|
|
(bool)m_environment.external_km1_on.signal.is_on);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_km1_external_command_trigger,
|
|
|
|
(m_environment.system_fault.boolbit.b0 & m_environment.auxiliary_km2.state.signal.is_on) |
|
|
|
|
!m_environment.input_discrete.signal.hw_dvr_ready |
|
|
|
|
!m_environment.input_discrete.signal.bypass_ready |
|
|
|
|
(bool)m_environment.external_km1_off.signal.is_on);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_km1_external_command_trigger);
|
|
|
|
//<>
|
|
|
|
//
|
|
|
|
// Command KM3 - on/off
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_km3_external_command_trigger,
|
|
|
|
!m_environment.system_fault.boolbit.b0 &
|
|
|
|
m_environment.input_discrete.signal.hw_dvr_ready &
|
|
|
|
m_environment.input_discrete.signal.bypass_ready &
|
|
|
|
(bool)m_environment.external_km3_on.signal.is_on);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_km3_external_command_trigger,
|
|
|
|
(m_environment.system_fault.boolbit.b0 & m_environment.auxiliary_km2.state.signal.is_on) |
|
|
|
|
!m_environment.input_discrete.signal.hw_dvr_ready |
|
|
|
|
!m_environment.input_discrete.signal.bypass_ready |
|
|
|
|
(bool)m_environment.external_km3_off.signal.is_on);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_km3_external_command_trigger);
|
|
|
|
//<>
|
|
|
|
//
|
|
|
|
// Command Q1 - on/off
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_q1_external_command_trigger,
|
|
|
|
!m_environment.system_fault.boolbit.b0 &
|
|
|
|
m_environment.input_discrete.signal.hw_dvr_ready &
|
|
|
|
m_environment.input_discrete.signal.bypass_ready &
|
|
|
|
//(bool)m_environment.external_q1_on.signal.is_on);
|
|
|
|
turnQ1On);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_q1_external_command_trigger,
|
|
|
|
(m_environment.system_fault.boolbit.b0 & m_environment.auxiliary_km2.state.signal.is_on) |
|
|
|
|
!m_environment.input_discrete.signal.hw_dvr_ready |
|
|
|
|
!m_environment.input_discrete.signal.bypass_ready |
|
|
|
|
//(bool)m_environment.external_q1_off.signal.is_on);
|
|
|
|
!turnQ1On);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_q1_external_command_trigger);
|
|
|
|
//<>
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// System Reset
|
|
|
|
//
|
|
|
|
static bool _reset_local = false;
|
|
|
|
_reset_local = m_environment.remote_reset.state.signal.is_on;
|
|
|
|
_reset_local |= m_environment.external_reset.signal.is_on;
|
|
|
|
_reset_local &= m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::OFF) | m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::FAULT);
|
|
|
|
//_reset &= (m_environment.remote_start.is_off() & m_environment.local_remote.is_on());
|
|
|
|
//_reset &= (m_environment.remote_stop.is_off() & m_environment.local_remote.is_on());
|
|
|
|
m_environment.system_reset.boolbit.b0 = _reset_local;
|
|
|
|
|
|
|
|
if(m_environment.system_fault.boolbit.b0 & m_environment.system_reset.boolbit.b0)
|
|
|
|
{
|
|
|
|
m_phase_alert_monitor.reset();
|
|
|
|
m_environment.hardware.reset();
|
|
|
|
hardware_analog_current_fault.all = 0;
|
|
|
|
m_environment.system_faults_register.equipment.all = 0;
|
|
|
|
m_environment.system_faults_register.phase_a.all = 0;
|
|
|
|
m_environment.system_faults_register.phase_b.all = 0;
|
|
|
|
m_environment.system_faults_register.phase_c.all = 0;
|
|
|
|
//
|
|
|
|
}//
|
|
|
|
m_q1_control_fault.reset(m_environment.system_fault.boolbit.b0 & m_environment.system_reset.boolbit.b0);
|
|
|
|
m_km1_control_fault.reset(m_environment.system_fault.boolbit.b0 & m_environment.system_reset.boolbit.b0);
|
|
|
|
m_km2_control_fault.reset(m_environment.system_fault.boolbit.b0 & m_environment.system_reset.boolbit.b0);
|
|
|
|
m_km3_control_fault.reset(m_environment.system_fault.boolbit.b0 & m_environment.system_reset.boolbit.b0);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// System Faults
|
|
|
|
//
|
|
|
|
if(m_system_fault_trigger.signal.negquit)
|
|
|
|
{
|
|
|
|
if(m_enable_work_trigger.signal.is_on)
|
|
|
|
{
|
|
|
|
m_environment.system_faults_register.phase_a.all = m_phase_alert_monitor.status.phase_a.fault.all;
|
|
|
|
m_environment.system_faults_register.phase_b.all = m_phase_alert_monitor.status.phase_b.fault.all;
|
|
|
|
m_environment.system_faults_register.phase_c.all = m_phase_alert_monitor.status.phase_c.fault.all;
|
|
|
|
//
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_environment.system_faults_register.phase_a.all = 0;
|
|
|
|
m_environment.system_faults_register.phase_b.all = 0;
|
|
|
|
m_environment.system_faults_register.phase_c.all = 0;
|
|
|
|
//
|
|
|
|
}
|
|
|
|
//
|
|
|
|
m_environment.system_faults_register.equipment.signal.remote_e_stop = m_environment.remote_e_stop.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.local_e_stop = (m_environment.local_e_stop.state.signal.is_on | m_environment.external_e_stop.signal.is_on);
|
|
|
|
m_environment.system_faults_register.equipment.signal.fan = m_environment.fan_fault.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.cells = m_environment.hardware.fault;
|
|
|
|
// m_environment.system_faults_register.equipment.signal.cabinet_door_open = m_environment.cabinet_door_interlocked.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_multi_winding = m_environment.transformer_inv_over_temperature_fault.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_phase_a = m_environment.transformer_t_over_temperature_fault.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_phase_b = m_environment.transformer_t_over_temperature_fault.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_phase_c = m_environment.transformer_t_over_temperature_fault.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.arc_and_fire = m_environment.arc_and_fire.state.signal.is_on;
|
|
|
|
m_environment.system_faults_register.equipment.signal.q1 = m_q1_control_fault.status.signal.fault;
|
|
|
|
m_environment.system_faults_register.equipment.signal.km1 = m_km1_control_fault.status.signal.fault;
|
|
|
|
m_environment.system_faults_register.equipment.signal.km2 = m_km2_control_fault.status.signal.fault;
|
|
|
|
m_environment.system_faults_register.equipment.signal.km3 = m_km3_control_fault.status.signal.fault;
|
|
|
|
m_environment.system_faults_register.equipment.signal.sync_to_grid = !m_pll_abc_input_voltage.get_sync() & m_environment.input_discrete.signal.auxiliary_q1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_system_fault_trigger,
|
|
|
|
m_environment.system_faults_register.equipment.signal.remote_e_stop |
|
|
|
|
m_environment.system_faults_register.equipment.signal.local_e_stop |
|
|
|
|
(m_phase_alert_monitor.fault & m_enable_work_trigger.signal.is_on) |
|
|
|
|
m_environment.system_faults_register.equipment.signal.fan |
|
|
|
|
m_environment.system_faults_register.equipment.signal.cells | // DON'T FORGET BACK!!!!!
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_multi_winding |
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_phase_a |
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_phase_b |
|
|
|
|
m_environment.system_faults_register.equipment.signal.temperature_transformer_phase_c |
|
|
|
|
m_environment.system_faults_register.equipment.signal.cabinet_door_open |
|
|
|
|
m_environment.system_faults_register.equipment.signal.arc_and_fire |
|
|
|
|
m_environment.system_faults_register.equipment.signal.q1 |
|
|
|
|
m_environment.system_faults_register.equipment.signal.km1 |
|
|
|
|
m_environment.system_faults_register.equipment.signal.km2 |
|
|
|
|
m_environment.system_faults_register.equipment.signal.km3 |
|
|
|
|
m_vs_protection_control_trigger.signal.quit);
|
|
|
|
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_system_fault_trigger, m_environment.system_reset.boolbit.b0);
|
|
|
|
SYSCTRL::TriggerRegister::execute_set_priority(m_system_fault_trigger);
|
|
|
|
m_environment.system_fault.boolbit.b0 = (bool)m_system_fault_trigger.signal.is_on;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// System Alarm (Warning)
|
|
|
|
//
|
|
|
|
static bool _alarm_local;
|
|
|
|
_alarm_local = false;
|
|
|
|
_alarm_local |= m_phase_alert_monitor.warning;
|
|
|
|
_alarm_local |= m_environment.transformer_inv_over_temperature_alarm.state.signal.is_on;
|
|
|
|
m_environment.system_alarm.boolbit.b0 = _alarm_local;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// System Ready
|
|
|
|
//
|
|
|
|
static bool _ready_local = true;
|
|
|
|
_ready_local = !m_environment.system_fault.boolbit.b0;
|
|
|
|
_ready_local &= m_environment.input_discrete.signal.control_power_supply_status;
|
|
|
|
_ready_local &= m_environment.auxiliary_q1.state.signal.is_on;
|
|
|
|
_ready_local &= m_environment.bypass_ready.state.signal.is_on;
|
|
|
|
_ready_local &= (m_environment.auxiliary_km2.state.signal.is_on | m_environment.enable_work.boolbit.b0);
|
|
|
|
_ready_local &= m_environment.auxiliary_km11.state.signal.is_on;
|
|
|
|
_ready_local &= m_pll_abc_input_voltage.get_sync(); // DON'T FORGET BACK!!!!!
|
|
|
|
_ready_local &= m_environment.auxiliary_km1.state.signal.is_on;
|
|
|
|
_ready_local &= m_environment.auxiliary_km3.state.signal.is_on;
|
|
|
|
_ready_local &= m_environment.hardware.enable;
|
|
|
|
m_environment.system_ready.boolbit.b0 = _ready_local;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Enable Work
|
|
|
|
//
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_enable_work_trigger,
|
|
|
|
m_environment.system_ready.boolbit.b0 &
|
|
|
|
(
|
|
|
|
(m_environment.local_remote.state.signal.is_off & m_environment.remote_start.state.signal.is_switched_on) |
|
|
|
|
(m_environment.local_remote.state.signal.is_on & m_environment.external_start.signal.is_on)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_enable_work_trigger,
|
|
|
|
!m_environment.system_ready.boolbit.b0 |
|
|
|
|
m_environment.enable_work_reset.boolbit.b0);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_enable_work_trigger);
|
|
|
|
m_environment.enable_work.boolbit.b0 = (bool)m_enable_work_trigger.signal.is_on;
|
|
|
|
m_environment.enable_work_is_on.boolbit.b0 = (bool)m_enable_work_trigger.signal.is_switched_on;
|
|
|
|
m_environment.enable_work_is_off.boolbit.b0 = (bool)m_enable_work_trigger.signal.is_off;
|
|
|
|
m_environment.enable_work_reset.boolbit.b0 = false;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Auto offset scan
|
|
|
|
//
|
|
|
|
m_environment.allow_auto_offset = !m_environment.enable_work.boolbit.b0 & m_environment.enable_auto_offset.signal.is_on;
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Execute Control Loop
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
// Generator ABC
|
|
|
|
// FOR DEBUG ONLY
|
|
|
|
#if 3 == 2
|
|
|
|
//m_environment.generator_abc.execute();
|
|
|
|
//m_environment.generator_abc.get_out(m_environment.gen_ort_a, m_environment.gen_ort_b, m_environment.gen_ort_c);
|
|
|
|
//FLTSYSLIB::Transformation::clarke_forward(m_environment.gen_ort_a, m_environment.gen_ort_b, m_environment.gen_ort_c, m_environment.gen_ort_alpha, m_environment.gen_ort_beta);
|
|
|
|
//
|
|
|
|
//m_environment.gen_symm_comp_inp_volt.execute(m_environment.gen_ort_alpha, m_environment.gen_ort_beta);
|
|
|
|
//m_environment.gen_symm_comp_inp_volt.get_output(m_environment.voltage_input_a, m_environment.voltage_input_b, m_environment.voltage_input_c);
|
|
|
|
//
|
|
|
|
//m_environment.gen_symm_comp_out_volt.execute(m_environment.gen_ort_alpha, m_environment.gen_ort_beta);
|
|
|
|
//m_environment.gen_symm_comp_out_volt.get_output(m_environment.voltage_load_a, m_environment.voltage_load_b, m_environment.voltage_load_c);
|
|
|
|
//
|
|
|
|
//m_environment.gen_symm_comp_out_current.execute(m_environment.gen_ort_alpha, m_environment.gen_ort_beta);
|
|
|
|
//m_environment.gen_symm_comp_out_current.get_output(m_environment.current_load_a, m_environment.current_load_b, m_environment.current_load_c);
|
|
|
|
//
|
|
|
|
//m_environment.gen_symm_comp_input_current.execute(m_environment.gen_ort_alpha, m_environment.gen_ort_beta);
|
|
|
|
//m_environment.gen_symm_comp_input_current.get_output(m_environment.current_input_a, m_environment.current_input_b, m_environment.current_input_c);
|
|
|
|
//
|
|
|
|
//m_environment.gen_symm_comp_bypass_current.execute(m_environment.gen_ort_alpha, m_environment.gen_ort_beta);
|
|
|
|
//m_environment.gen_symm_comp_bypass_current.get_output(m_environment.current_bypass_a, m_environment.current_bypass_b, m_environment.current_bypass_c);
|
|
|
|
//
|
|
|
|
//m_environment.gen_symm_comp_cell_current.execute(m_environment.gen_ort_alpha, m_environment.gen_ort_beta);
|
|
|
|
//m_environment.gen_symm_comp_cell_current.get_output(m_environment.current_cell_a, m_environment.current_cell_b, m_environment.current_cell_c);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Relative Input Voltage
|
|
|
|
//
|
|
|
|
if(m_environment.auxiliary_q1.state.signal.is_on)
|
|
|
|
{
|
|
|
|
// Q1 is on
|
|
|
|
m_environment.reference_phase_a = m_environment.voltage_grid_a;
|
|
|
|
m_environment.reference_phase_b = m_environment.voltage_grid_b;
|
|
|
|
m_environment.reference_phase_c = m_environment.voltage_grid_c;
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Q1 is off
|
|
|
|
m_environment.reference_phase_a = m_environment.voltage_load_a;
|
|
|
|
m_environment.reference_phase_b = m_environment.voltage_load_b;
|
|
|
|
m_environment.reference_phase_c = m_environment.voltage_load_c;
|
|
|
|
//
|
|
|
|
}//if else
|
|
|
|
//
|
|
|
|
|
|
|
|
m_relative_filter_voltage_input_a.execute(m_environment.reference_phase_a);
|
|
|
|
m_relative_filter_voltage_input_b.execute(m_environment.reference_phase_b);
|
|
|
|
m_relative_filter_voltage_input_c.execute(m_environment.reference_phase_c);
|
|
|
|
|
|
|
|
m_relative_filter_voltage_input_a.get_outputs(m_environment.relative_voltage_input_a.amplitude, m_environment.relative_voltage_input_a.relative);
|
|
|
|
m_relative_filter_voltage_input_b.get_outputs(m_environment.relative_voltage_input_b.amplitude, m_environment.relative_voltage_input_b.relative);
|
|
|
|
m_relative_filter_voltage_input_c.get_outputs(m_environment.relative_voltage_input_c.amplitude, m_environment.relative_voltage_input_c.relative);
|
|
|
|
//<>
|
|
|
|
|
|
|
|
m_environment.generator_abc.execute();
|
|
|
|
m_environment.generator_abc.get_out(m_environment.gen_ort_a, m_environment.gen_ort_b, m_environment.gen_ort_c);
|
|
|
|
|
|
|
|
if (m_environment.auxiliary_q1.state.signal.is_on)
|
|
|
|
{
|
|
|
|
m_environment.relative_voltage_input_a.relative = m_environment.gen_ort_a;
|
|
|
|
m_environment.relative_voltage_input_b.relative = m_environment.gen_ort_b;
|
|
|
|
m_environment.relative_voltage_input_c.relative = m_environment.gen_ort_c;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_environment.relative_voltage_input_a.relative = 0;
|
|
|
|
m_environment.relative_voltage_input_b.relative = 0;
|
|
|
|
m_environment.relative_voltage_input_c.relative = 0;
|
|
|
|
}
|
|
|
|
//
|
|
|
|
// PLL-ABC Input Voltage
|
|
|
|
//
|
|
|
|
m_pll_abc_input_voltage.execute(m_environment.relative_voltage_input_a.relative,
|
|
|
|
m_environment.relative_voltage_input_b.relative,
|
|
|
|
m_environment.relative_voltage_input_c.relative);
|
|
|
|
|
|
|
|
m_pll_abc_input_voltage.get_output(m_environment.pll_abc_orts.phase_a.active,
|
|
|
|
m_environment.pll_abc_orts.phase_b.active,
|
|
|
|
m_environment.pll_abc_orts.phase_c.active);
|
|
|
|
|
|
|
|
FLTSYSLIB::Transformation::ort_abc_jm_from_real(m_environment.pll_abc_orts.phase_a.active,
|
|
|
|
m_environment.pll_abc_orts.phase_b.active,
|
|
|
|
m_environment.pll_abc_orts.phase_c.active,
|
|
|
|
m_environment.pll_abc_orts.phase_a.reactive,
|
|
|
|
m_environment.pll_abc_orts.phase_b.reactive,
|
|
|
|
m_environment.pll_abc_orts.phase_c.reactive);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//if(m_environment.auxiliary_q1.state.signal.is_on)
|
|
|
|
if(m_pll_abc_input_voltage.get_sync())
|
|
|
|
{
|
|
|
|
m_environment.grid_frequency = m_pll_abc_input_voltage.get_frequency();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_environment.grid_frequency = FP_ZERO;
|
|
|
|
//
|
|
|
|
}//
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if TYPECONTROL == VECTORCONTROL
|
|
|
|
//
|
|
|
|
m_environment.main_abc_orts = m_environment.pll_abc_orts;
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.main_abc_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_orts.phase_c.active,
|
|
|
|
m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.voltage_grid_a,
|
|
|
|
m_environment.voltage_grid_b,
|
|
|
|
m_environment.voltage_grid_c,
|
|
|
|
m_environment.voltage_grid_alpha,
|
|
|
|
m_environment.voltage_grid_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.voltage_load_a,
|
|
|
|
m_environment.voltage_load_b,
|
|
|
|
m_environment.voltage_load_c,
|
|
|
|
m_environment.voltage_load_alpha,
|
|
|
|
m_environment.voltage_load_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.current_load_a,
|
|
|
|
m_environment.current_load_b,
|
|
|
|
m_environment.current_load_c,
|
|
|
|
m_environment.current_load_alpha,
|
|
|
|
m_environment.current_load_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.current_bypass_a,
|
|
|
|
m_environment.current_bypass_b,
|
|
|
|
m_environment.current_bypass_c,
|
|
|
|
m_environment.current_bypass_alpha,
|
|
|
|
m_environment.current_bypass_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.current_cell_a,
|
|
|
|
m_environment.current_cell_b,
|
|
|
|
m_environment.current_cell_c,
|
|
|
|
m_environment.current_cell_alpha,
|
|
|
|
m_environment.current_cell_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.voltage_grid_alpha,
|
|
|
|
m_environment.voltage_grid_beta,
|
|
|
|
m_environment.voltage_grid_direct,
|
|
|
|
m_environment.voltage_grid_quadrature);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.voltage_load_alpha,
|
|
|
|
m_environment.voltage_load_beta,
|
|
|
|
m_environment.voltage_load_direct,
|
|
|
|
m_environment.voltage_load_quadrature);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.current_load_alpha,
|
|
|
|
m_environment.current_load_beta,
|
|
|
|
m_environment.current_load_direct,
|
|
|
|
m_environment.current_load_quadrature);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.current_bypass_alpha,
|
|
|
|
m_environment.current_bypass_beta,
|
|
|
|
m_environment.current_bypass_direct,
|
|
|
|
m_environment.current_bypass_quadrature);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.current_cell_alpha,
|
|
|
|
m_environment.current_cell_beta,
|
|
|
|
m_environment.current_cell_direct,
|
|
|
|
m_environment.current_cell_quadrature);
|
|
|
|
//
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if TYPECONTROL == SCALARCONTROL
|
|
|
|
|
|
|
|
// Decompose Input Voltage
|
|
|
|
m_decompose_voltage_input_a.execute(m_environment.voltage_grid_a, m_environment.pll_abc_orts.phase_a.active, m_environment.pll_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_voltage_input_a.get_outputs(m_environment.projection_voltage_input_a.active, m_environment.projection_voltage_input_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_input_b.execute(m_environment.voltage_grid_b, m_environment.pll_abc_orts.phase_b.active, m_environment.pll_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_voltage_input_b.get_outputs(m_environment.projection_voltage_input_b.active, m_environment.projection_voltage_input_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_input_c.execute(m_environment.voltage_grid_c, m_environment.pll_abc_orts.phase_c.active, m_environment.pll_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_voltage_input_c.get_outputs(m_environment.projection_voltage_input_c.active, m_environment.projection_voltage_input_c.reactive);
|
|
|
|
// m_environment.projection_voltage_input_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_voltage_input_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_voltage_input_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
// Main Ort Corrector
|
|
|
|
if(m_pll_abc_input_voltage.get_sync() && m_environment.auxiliary_q1.state.signal.is_on)
|
|
|
|
{
|
|
|
|
|
|
|
|
// Spinner
|
|
|
|
SYSCTRL::VectorSpinner::spin_calculator(m_environment.projection_voltage_input_a, m_environment.module_voltage_phase_a, m_environment.spinner_phase_a);
|
|
|
|
SYSCTRL::VectorSpinner::spin_calculator(m_environment.projection_voltage_input_b, m_environment.module_voltage_phase_b, m_environment.spinner_phase_b);
|
|
|
|
SYSCTRL::VectorSpinner::spin_calculator(m_environment.projection_voltage_input_c, m_environment.module_voltage_phase_c, m_environment.spinner_phase_c);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Reset Spinner
|
|
|
|
m_environment.spinner_phase_a.active = 1.0;
|
|
|
|
m_environment.spinner_phase_a.reactive = FP_ZERO;
|
|
|
|
|
|
|
|
m_environment.spinner_phase_b.active = 1.0;
|
|
|
|
m_environment.spinner_phase_b.reactive = FP_ZERO;
|
|
|
|
|
|
|
|
m_environment.spinner_phase_c.active = 1.0;
|
|
|
|
m_environment.spinner_phase_c.reactive = FP_ZERO;
|
|
|
|
//
|
|
|
|
}//if else
|
|
|
|
//
|
|
|
|
SYSCTRL::VectorSpinner::ort_corrector(m_environment.spinner_phase_a, m_environment.pll_abc_orts.phase_a, m_environment.twisted_abc_orts.phase_a);
|
|
|
|
SYSCTRL::VectorSpinner::ort_corrector(m_environment.spinner_phase_b, m_environment.pll_abc_orts.phase_b, m_environment.twisted_abc_orts.phase_b);
|
|
|
|
SYSCTRL::VectorSpinner::ort_corrector(m_environment.spinner_phase_c, m_environment.pll_abc_orts.phase_c, m_environment.twisted_abc_orts.phase_c);
|
|
|
|
//<>
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::ort_abc_jm_from_real(m_environment.twisted_abc_orts.phase_a.active,
|
|
|
|
m_environment.twisted_abc_orts.phase_b.active,
|
|
|
|
m_environment.twisted_abc_orts.phase_c.active,
|
|
|
|
m_environment.twisted_abc_orts.phase_a.reactive,
|
|
|
|
m_environment.twisted_abc_orts.phase_b.reactive,
|
|
|
|
m_environment.twisted_abc_orts.phase_c.reactive);
|
|
|
|
//
|
|
|
|
//m_environment.main_abc_orts = m_environment.pll_abc_orts;
|
|
|
|
m_environment.main_abc_orts = m_environment.twisted_abc_orts;
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.main_abc_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_orts.phase_c.active,
|
|
|
|
m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive);
|
|
|
|
//
|
|
|
|
//Decompose Load Voltage
|
|
|
|
m_decompose_voltage_load_a.execute(m_environment.voltage_load_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_voltage_load_a.get_outputs(m_environment.projection_voltage_load_a.active, m_environment.projection_voltage_load_a.reactive);
|
|
|
|
m_decompose_voltage_load_a.get_outputs(m_environment.phase_control.phase_a.feedback.voltage_ampl_real, m_environment.phase_control.phase_a.feedback.voltage_ampl_jm);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_load_b.execute(m_environment.voltage_load_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_voltage_load_b.get_outputs(m_environment.projection_voltage_load_b.active, m_environment.projection_voltage_load_b.reactive);
|
|
|
|
m_decompose_voltage_load_b.get_outputs(m_environment.phase_control.phase_b.feedback.voltage_ampl_real, m_environment.phase_control.phase_b.feedback.voltage_ampl_jm);
|
|
|
|
//
|
|
|
|
m_decompose_voltage_load_c.execute(m_environment.voltage_load_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_voltage_load_c.get_outputs(m_environment.projection_voltage_load_c.active, m_environment.projection_voltage_load_c.reactive);
|
|
|
|
m_decompose_voltage_load_c.get_outputs(m_environment.phase_control.phase_c.feedback.voltage_ampl_real, m_environment.phase_control.phase_c.feedback.voltage_ampl_jm);
|
|
|
|
|
|
|
|
// m_environment.projection_voltage_load_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_voltage_load_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_voltage_load_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
//Decompose Load Current
|
|
|
|
m_decompose_current_load_a.execute(m_environment.current_load_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_current_load_a.get_outputs(m_environment.projection_current_load_a.active, m_environment.projection_current_load_a.reactive);
|
|
|
|
m_decompose_current_load_a.get_outputs(m_environment.phase_control.phase_a.feedback.current_ampl_real, m_environment.phase_control.phase_a.feedback.current_ampl_jm);
|
|
|
|
//
|
|
|
|
m_decompose_current_load_b.execute(m_environment.current_load_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_current_load_b.get_outputs(m_environment.projection_current_load_b.active, m_environment.projection_current_load_b.reactive);
|
|
|
|
m_decompose_current_load_b.get_outputs(m_environment.phase_control.phase_b.feedback.current_ampl_real, m_environment.phase_control.phase_b.feedback.current_ampl_jm);
|
|
|
|
//
|
|
|
|
m_decompose_current_load_c.execute(m_environment.current_load_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_current_load_c.get_outputs(m_environment.projection_current_load_c.active, m_environment.projection_current_load_c.reactive);
|
|
|
|
m_decompose_current_load_c.get_outputs(m_environment.phase_control.phase_c.feedback.current_ampl_real, m_environment.phase_control.phase_c.feedback.current_ampl_jm);
|
|
|
|
|
|
|
|
// m_environment.projection_current_load_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_current_load_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_current_load_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
//Decompose Bypass Current
|
|
|
|
m_decompose_current_bypass_a.execute(m_environment.current_bypass_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_current_bypass_a.get_outputs(m_environment.projection_current_bypass_a.active, m_environment.projection_current_bypass_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_bypass_b.execute(m_environment.current_bypass_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_current_bypass_b.get_outputs(m_environment.projection_current_bypass_b.active, m_environment.projection_current_bypass_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_bypass_c.execute(m_environment.current_bypass_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_current_bypass_c.get_outputs(m_environment.projection_current_bypass_c.active, m_environment.projection_current_bypass_c.reactive);
|
|
|
|
|
|
|
|
// m_environment.projection_current_bypass_a = m_environment.test_projection_a;
|
|
|
|
// m_environment.projection_current_bypass_b = m_environment.test_projection_b;
|
|
|
|
// m_environment.projection_current_bypass_c = m_environment.test_projection_c;
|
|
|
|
|
|
|
|
|
|
|
|
//Decompose Cell Current
|
|
|
|
m_decompose_current_cell_a.execute(m_environment.current_cell_a, m_environment.main_abc_orts.phase_a.active, m_environment.main_abc_orts.phase_a.reactive);
|
|
|
|
m_decompose_current_cell_a.get_outputs(m_environment.projection_current_cell_a.active, m_environment.projection_current_cell_a.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_cell_b.execute(m_environment.current_cell_b, m_environment.main_abc_orts.phase_b.active, m_environment.main_abc_orts.phase_b.reactive);
|
|
|
|
m_decompose_current_cell_b.get_outputs(m_environment.projection_current_cell_b.active, m_environment.projection_current_cell_b.reactive);
|
|
|
|
//
|
|
|
|
m_decompose_current_cell_c.execute(m_environment.current_cell_c, m_environment.main_abc_orts.phase_c.active, m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
m_decompose_current_cell_c.get_outputs(m_environment.projection_current_cell_c.active, m_environment.projection_current_cell_c.reactive);
|
|
|
|
//
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if TYPECONTROL == DIRECTREVERSECONTROL
|
|
|
|
//
|
|
|
|
m_environment.main_abc_orts = m_environment.pll_abc_orts;
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::ort_direct_to_back(m_environment.main_abc_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_orts.phase_c.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_c.active);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::ort_back_to_orthogonal(m_environment.main_abc_reverse_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_c.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_a.reactive,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_b.reactive,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_c.reactive);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.main_abc_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_orts.phase_c.active,
|
|
|
|
m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.voltage_grid_a,
|
|
|
|
m_environment.voltage_grid_b,
|
|
|
|
m_environment.voltage_grid_c,
|
|
|
|
m_environment.drc_voltage_grid_alpha,
|
|
|
|
m_environment.drc_voltage_grid_beta);
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.voltage_load_a,
|
|
|
|
m_environment.voltage_load_b,
|
|
|
|
m_environment.voltage_load_c,
|
|
|
|
m_environment.drc_voltage_load_alpha,
|
|
|
|
m_environment.drc_voltage_load_beta);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.current_load_a,
|
|
|
|
m_environment.current_load_b,
|
|
|
|
m_environment.current_load_c,
|
|
|
|
m_environment.drc_current_load_alpha,
|
|
|
|
m_environment.drc_current_load_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.current_bypass_a,
|
|
|
|
m_environment.current_bypass_b,
|
|
|
|
m_environment.current_bypass_c,
|
|
|
|
m_environment.drc_current_bypass_alpha,
|
|
|
|
m_environment.drc_current_bypass_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::clarke_forward(m_environment.current_cell_a,
|
|
|
|
m_environment.current_cell_b,
|
|
|
|
m_environment.current_cell_c,
|
|
|
|
m_environment.drc_current_cell_alpha,
|
|
|
|
m_environment.drc_current_cell_beta);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.drc_voltage_grid_alpha,
|
|
|
|
m_environment.drc_voltage_grid_beta,
|
|
|
|
m_environment.drc_voltage_grid_direct,
|
|
|
|
m_environment.drc_voltage_grid_quadrature);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.drc_current_load_alpha,
|
|
|
|
m_environment.drc_current_load_beta,
|
|
|
|
m_environment.drc_current_load_direct,
|
|
|
|
m_environment.drc_current_load_quadrature);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.drc_current_bypass_alpha,
|
|
|
|
m_environment.drc_current_bypass_beta,
|
|
|
|
m_environment.drc_current_bypass_direct,
|
|
|
|
m_environment.drc_current_bypass_quadrature);
|
|
|
|
//
|
|
|
|
FLTSYSLIB::Transformation::park_forward(m_environment.main_ab_orts.active,
|
|
|
|
m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.drc_current_cell_alpha,
|
|
|
|
m_environment.drc_current_cell_beta,
|
|
|
|
m_environment.drc_current_cell_direct,
|
|
|
|
m_environment.drc_current_cell_quadrature);
|
|
|
|
//
|
|
|
|
m_environment.drc_direct_voltage_decomposer.execute(m_environment.voltage_load_a,
|
|
|
|
m_environment.voltage_load_b,
|
|
|
|
m_environment.voltage_load_c,
|
|
|
|
m_environment.main_abc_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_orts.phase_c.active,
|
|
|
|
m_environment.main_abc_orts.phase_a.reactive,
|
|
|
|
m_environment.main_abc_orts.phase_b.reactive,
|
|
|
|
m_environment.main_abc_orts.phase_c.reactive);
|
|
|
|
//
|
|
|
|
m_environment.drc_back_voltage_decomposer.execute(m_environment.voltage_load_a,
|
|
|
|
m_environment.voltage_load_b,
|
|
|
|
m_environment.voltage_load_c,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_a.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_b.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_c.active,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_a.reactive,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_b.reactive,
|
|
|
|
m_environment.main_abc_reverse_orts.phase_c.reactive);
|
|
|
|
//
|
|
|
|
m_environment.drc_positive_voltage_load_direct = m_environment.drc_direct_voltage_decomposer.direct;
|
|
|
|
m_environment.drc_positive_voltage_load_quadrature = m_environment.drc_direct_voltage_decomposer.quadrature;
|
|
|
|
m_environment.drc_negaative_voltage_load_direct = m_environment.drc_back_voltage_decomposer.direct;
|
|
|
|
m_environment.drc_negative_voltage_load_quadrature = m_environment.drc_back_voltage_decomposer.quadrature;
|
|
|
|
//
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
harmonica_multiplyer(m_environment.main_ab_orts.active, m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.main_ab_orts.active, m_environment.main_ab_orts.reactive,
|
|
|
|
m_environment.harmonica_2.active, m_environment.harmonica_2.reactive);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
harmonica_multiplyer(m_environment.harmonica_2.active, m_environment.harmonica_2.reactive,
|
|
|
|
m_environment.main_ab_orts.active, m_environment.main_ab_orts.active,
|
|
|
|
m_environment.harmonica_3.active, m_environment.harmonica_3.reactive);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
harmonica_multiplyer(m_environment.harmonica_2.active, m_environment.harmonica_2.reactive,
|
|
|
|
m_environment.harmonica_3.active, m_environment.harmonica_3.reactive,
|
|
|
|
m_environment.harmonica_5.active, m_environment.harmonica_5.reactive);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
harmonica_multiplyer(m_environment.harmonica_2.active, m_environment.harmonica_2.reactive,
|
|
|
|
m_environment.harmonica_5.active, m_environment.harmonica_5.reactive,
|
|
|
|
m_environment.harmonica_7.active, m_environment.harmonica_7.reactive);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
harmonica_multiplyer(m_environment.harmonica_2.active, m_environment.harmonica_2.reactive,
|
|
|
|
m_environment.harmonica_7.active, m_environment.harmonica_7.reactive,
|
|
|
|
m_environment.harmonica_9.active, m_environment.harmonica_9.reactive);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
harmonica_multiplyer(m_environment.harmonica_2.active, m_environment.harmonica_2.reactive,
|
|
|
|
m_environment.harmonica_9.active, m_environment.harmonica_9.reactive,
|
|
|
|
m_environment.harmonica_11.active, m_environment.harmonica_11.reactive);
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
|
|
|
|
//m_environment.voltage_input_a_harmonica_5 = m_voltage_input_a_harmonica_filter_5.execute(m_environment.voltage_input_a, m_environment.sys_ort_cos_h5, m_environment.sys_ort_sin_h5);
|
|
|
|
//m_environment.voltage_input_b_harmonica_5 = m_voltage_input_b_harmonica_filter_5.execute(m_environment.voltage_input_b, m_environment.sys_ort_cos_h5, m_environment.sys_ort_sin_h5);
|
|
|
|
//m_environment.voltage_input_c_harmonica_5 = m_voltage_input_c_harmonica_filter_5.execute(m_environment.voltage_input_c, m_environment.sys_ort_cos_h5, m_environment.sys_ort_sin_h5);
|
|
|
|
|
|
|
|
//
|
|
|
|
// Define algorithm
|
|
|
|
//
|
|
|
|
m_algorithm.strategy();
|
|
|
|
m_algorithm_executed = m_algorithm.get_algorithm();
|
|
|
|
m_algorithm.execute();
|
|
|
|
m_algorithm.get_ref_invertor_voltage(m_environment.hardware.hvcell.data_u, m_environment.hardware.hvcell.data_v, m_environment.hardware.hvcell.data_w);
|
|
|
|
|
|
|
|
|
|
|
|
// Q1 Control
|
|
|
|
// on - 4006; off - 4007
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_q1_control_trigger,
|
|
|
|
(!m_environment.system_fault.boolbit.b0) & m_q1_external_command_trigger.signal.quit);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_q1_control_trigger,
|
|
|
|
m_q1_external_command_trigger.signal.negquit);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_q1_control_trigger);
|
|
|
|
|
|
|
|
// KM1 Control
|
|
|
|
// on - 4011; off - 4012
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_km1_control_trigger,
|
|
|
|
(!m_environment.system_fault.boolbit.b0) & m_km1_external_command_trigger.signal.quit);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_km1_control_trigger,
|
|
|
|
m_km1_external_command_trigger.signal.negquit);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_km1_control_trigger);
|
|
|
|
|
|
|
|
// KM3 Control
|
|
|
|
// on - 4018; off - 4020
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_km3_control_trigger,
|
|
|
|
(!m_environment.system_fault.boolbit.b0) & m_km3_external_command_trigger.signal.quit);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_km3_control_trigger,
|
|
|
|
m_km3_external_command_trigger.signal.negquit);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_km3_control_trigger);
|
|
|
|
|
|
|
|
// KM11 Control
|
|
|
|
// on/off - 4008
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_km11_control_on_off_trigger, m_environment.arc_and_fire.state.signal.is_off);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_km11_control_on_off_trigger, m_environment.arc_and_fire.state.signal.is_on);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_km11_control_on_off_trigger);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// KM2 Control
|
|
|
|
// on - 4013; off - 4014
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_km2_control_trigger,
|
|
|
|
m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::UNKNOWN) |
|
|
|
|
(m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::START) & m_environment.timer_start.is_running()) |
|
|
|
|
(m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::STOP) & m_environment.timer_stop.is_finished()) |
|
|
|
|
m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::FAULT) |
|
|
|
|
m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::OFF)
|
|
|
|
);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_km2_control_trigger,
|
|
|
|
(m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::START) & m_environment.timer_start.is_finished()) |
|
|
|
|
(m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::STOP) & m_environment.timer_stop.is_running()) |
|
|
|
|
m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::SOURCE) |
|
|
|
|
m_algorithm.compare_algorithm(SYSCTRL::AlgorithmContext::WORK)
|
|
|
|
);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_km2_control_trigger);
|
|
|
|
|
|
|
|
|
|
|
|
// Short Circuit VS Control
|
|
|
|
SYSCTRL::TriggerRegister::setSet(m_vs_protection_control_trigger,
|
|
|
|
m_environment.auxiliary_km2.state.signal.is_off & m_vs_protection_control_trigger.signal.quit);
|
|
|
|
SYSCTRL::TriggerRegister::setReset(m_vs_protection_control_trigger,
|
|
|
|
m_environment.auxiliary_km2.state.signal.is_on);
|
|
|
|
SYSCTRL::TriggerRegister::execute_reset_priority(m_vs_protection_control_trigger);
|
|
|
|
hardware_analog_current_fault.signal.vs = m_vs_protection_control_trigger.signal.quit;
|
|
|
|
|
|
|
|
//
|
|
|
|
// Digital Output Register filling
|
|
|
|
//
|
|
|
|
|
|
|
|
m_environment.digital_output.signal.work = m_environment.enable_work.boolbit.b0; // 4001 Running
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.fault = m_environment.system_fault.boolbit.b0; // 4002 Fault
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.ready = m_environment.system_ready.boolbit.b0; // 4003 Ready;
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.alarm = m_environment.system_alarm.boolbit.b0; // 4004 Alarm;
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.off_high_voltage_q1 = m_environment.system_fault.boolbit.b0; // 4005 off Q1
|
|
|
|
//
|
|
|
|
// m_environment.digital_output.signal.on_q1 = m_q1_control_trigger.signal.quit & !m_environment.input_discrete.signal.auxiliary_q1; // 4006 on Q1
|
|
|
|
m_environment.digital_output.signal.on_q1 = m_q1_control_trigger.signal.quit; // 4006 on Q1
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.off_q1 = m_q1_control_trigger.signal.negquit & m_environment.input_discrete.signal.auxiliary_q1; // 4007 off Q1
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.on_km11 = m_km11_control_on_off_trigger.signal.quit; // 4008 on KM11
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.vs_control = m_vs_protection_control_trigger.signal.quit; // 4009 Short Circuit VS
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.allow_on_high_voltage = !m_environment.system_fault.boolbit.b0; // 4010 enable on Q1
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.on_km1 = m_km1_control_trigger.signal.quit & !m_environment.input_discrete.signal.auxiliary_km1; // 4011 on KM1
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.off_km1 = m_km1_control_trigger.signal.negquit & m_environment.input_discrete.signal.auxiliary_km1; // 4012 off KM1
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.on_km2 = m_km2_control_trigger.signal.quit & m_environment.auxiliary_km2.state.signal.is_off; // 4013 on KM2
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.off_km2 = m_km2_control_trigger.signal.negquit & m_environment.auxiliary_km2.state.signal.is_on; // 4014 off KM2
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.high_voltage_indicator = m_environment.auxiliary_q1.state.signal.is_on; // 4015 high voltage!!
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.reserved_b15 = m_km1_control_trigger.signal.quit; // 4016
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.mode_local_remote = m_environment.local_remote.state.signal.is_on; // 4017 Local/Remote indication
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.on_km3 = m_km3_control_trigger.signal.quit & !m_environment.input_discrete.signal.auxiliary_km3; // 4018 on KM3
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.on_km11t = m_environment.fan_control.is_on(); // 4019 on KM11T
|
|
|
|
//
|
|
|
|
m_environment.digital_output.signal.off_km3 = m_km3_control_trigger.signal.negquit & m_environment.input_discrete.signal.auxiliary_km3; // 4020 off KM3
|
|
|
|
|
|
|
|
// FOR DEBUG ONLY
|
|
|
|
//m_environment.digital_output.all = m_environment.digital_output_temp.all;
|
|
|
|
|
|
|
|
|
|
|
|
m_environment.digital_output_inverse.all = m_environment.digital_output.all ^ 0xFFFFFFFF ;
|
|
|
|
|
|
|
|
|
|
|
|
// FOR DEBUG ONLY !!!!
|
|
|
|
//m_environment.digital_output_inverse.all = m_environment.digital_output_temp.all ^ 0xFFFFFFFF ;
|
|
|
|
//m_environment.digital_output_inverse.all = m_environment.digital_output_temp.all;
|
|
|
|
|
|
|
|
|
|
|
|
m_environment.counter_slow--;
|
|
|
|
m_environment.counter_additional--;
|
|
|
|
m_environment.counter_symmetrical--;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Generator PWM
|
|
|
|
#if 2 == 3
|
|
|
|
static float _gen_pwm_a, _gen_pwm_b, _gen_pwm_c;
|
|
|
|
m_environment.generator_pwm.implement();
|
|
|
|
m_environment.generator_pwm.get_out(_gen_pwm_a, _gen_pwm_b, _gen_pwm_c);
|
|
|
|
|
|
|
|
m_environment.hardware.hvcell.data_u = m_environment.amplitude_generator_pwm * _gen_pwm_a;
|
|
|
|
m_environment.hardware.hvcell.data_v = m_environment.amplitude_generator_pwm * _gen_pwm_b;
|
|
|
|
m_environment.hardware.hvcell.data_w = m_environment.amplitude_generator_pwm * _gen_pwm_c;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Scale Compute
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
if(m_environment.scale_compute_voltage_command.bit.start == 1)
|
|
|
|
{
|
|
|
|
m_environment.scale_compute_voltage_command.bit.start = 0;
|
|
|
|
m_environment.scale_compute_voltage_input.fix();
|
|
|
|
m_environment.scale_compute_voltage_load.fix();
|
|
|
|
//
|
|
|
|
}//if
|
|
|
|
*/
|
|
|
|
//
|
|
|
|
/*
|
|
|
|
if(m_environment.scale_compute_current_command.bit.start == 1)
|
|
|
|
{
|
|
|
|
m_environment.scale_compute_current_command.bit.start = 0;
|
|
|
|
//m_environment.scale_compute_current_cell.fix();
|
|
|
|
//m_environment.scale_compute_current_load.fix();
|
|
|
|
//m_environment.scale_compute_current_bypass.fix();
|
|
|
|
//m_environment.scale_compute_current_input.fix();
|
|
|
|
//
|
|
|
|
}//if
|
|
|
|
*/
|
|
|
|
|
|
|
|
//
|
|
|
|
}//_execute_operational()
|
|
|
|
//
|
|
|
|
} /* namespace SYSCTRL */
|