Oleg
/
DVRLastVersionsCompare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1000Hz
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'cf58cd5b77'
${ noResults }
DVRLastVersionsCompare/SYSCTRL/SystemControlExecute.cpp

1353 lines
79 KiB
C++
Raw Normal View History Unescape Escape

0822 Does not work
5 months ago
/*
* 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);
//<>
0305 Works
5 months ago
IcellMax.execute(m_environment.current_cell_a, m_environment.current_cell_b, m_environment.current_cell_c); // for debug!!!
IinputMax.execute(m_environment.current_input_a, m_environment.current_input_b, m_environment.current_input_c); // for debug!!!
IloadMax.execute(m_environment.current_load_a, m_environment.current_load_b, m_environment.current_load_c); // for debug!!!
0822 Does not work
5 months ago
//
// 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 &
0322 Works
5 months ago
//(bool)m_environment.external_q1_on.signal.is_on);
turnQ1On);
0822 Does not work
5 months ago
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 |
0322 Works
5 months ago
//(bool)m_environment.external_q1_off.signal.is_on);
!turnQ1On);
0822 Does not work
5 months ago
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 &
0322 Works
5 months ago
(bool)m_environment.external_q1_on.signal.is_on);
0822 Does not work
5 months ago
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 |
0322 Works
5 months ago
(bool)m_environment.external_q1_off.signal.is_on);
0822 Does not work
5 months ago
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;
1220 Does not work
5 months ago
m_environment.system_faults_register.equipment.signal.sync_to_grid = !m_pll_abc_input_voltage.get_sync() & m_environment.input_discrete.signal.auxiliary_q1;
0822 Does not work
5 months ago
}
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);
0305 Works
5 months ago
//
0822 Does not work
5 months ago
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);
0305 Works
5 months ago
//
0127 Does not work
5 months ago
0305 Works
5 months ago
/*
0127 Does not work
5 months ago
m_environment.drc_direct_voltage_decomposer.execute(m_environment.voltage_load_a - m_environment.drc_negative_voltage_load_direct * m_environment.main_abc_reverse_orts.phase_a.active + m_environment.drc_negative_voltage_load_quadrature * m_environment.main_abc_reverse_orts.phase_a.reactive,
m_environment.voltage_load_b - m_environment.drc_negative_voltage_load_direct * m_environment.main_abc_reverse_orts.phase_b.active + m_environment.drc_negative_voltage_load_quadrature * m_environment.main_abc_reverse_orts.phase_b.reactive,
m_environment.voltage_load_c - m_environment.drc_negative_voltage_load_direct * m_environment.main_abc_reverse_orts.phase_c.active + m_environment.drc_negative_voltage_load_quadrature * m_environment.main_abc_reverse_orts.phase_c.reactive,
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.drc_positive_voltage_load_direct * m_environment.main_abc_orts.phase_a.active + m_environment.drc_positive_voltage_load_quadrature * m_environment.main_abc_orts.phase_a.reactive,
m_environment.voltage_load_b - m_environment.drc_positive_voltage_load_direct * m_environment.main_abc_orts.phase_b.active + m_environment.drc_positive_voltage_load_quadrature * m_environment.main_abc_orts.phase_b.reactive,
m_environment.voltage_load_c - m_environment.drc_positive_voltage_load_direct * m_environment.main_abc_orts.phase_c.active + m_environment.drc_positive_voltage_load_quadrature * m_environment.main_abc_orts.phase_c.reactive,
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);
0305 Works
5 months ago
*/
0127 Does not work
5 months ago
0822 Does not work
5 months ago
//
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;
0127 Does not work
5 months ago
m_environment.drc_negative_voltage_load_direct = m_environment.drc_back_voltage_decomposer.direct;
0822 Does not work
5 months ago
m_environment.drc_negative_voltage_load_quadrature = m_environment.drc_back_voltage_decomposer.quadrature;
0127 Does not work
5 months ago
#endif
0822 Does not work
5 months ago
/*
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 */