DVRLastVersionsCompare/SYSCTRL/AlgorithmContext.cpp

/*
 * AlgorithmContext.cpp
 *
 *      Author: Aleksey Gerasimenko
 *      gerasimenko.aleksey.n@gmail.com
 */

#include "SYSCTRL/AlgorithmContext.h"

namespace SYSCTRL
{
//CONSTRUCTOR
AlgorithmContext::AlgorithmContext(SYSCTRL::SystemEnvironment&  env):
        m_mode(SYSCTRL::AlgorithmContext::UNDEFINED),
        m_algorithm(SYSCTRL::AlgorithmContext::UNKNOWN),
        m_algorithm_previous(SYSCTRL::AlgorithmContext::UNKNOWN),
        m_env(env),
        m_algorithm_pointer(&m_off),
        m_fault(env),
        m_work(env),
        m_stop(env),
        m_start(env),
        m_off(env),
        m_source(env),
        _strategy(&SYSCTRL::AlgorithmContext::_strategy_undef),
        _set_fault(&SYSCTRL::AlgorithmContext::_set_empty_exe),
        _set_work(&SYSCTRL::AlgorithmContext::_set_empty_exe),
        _set_stop(&SYSCTRL::AlgorithmContext::_set_empty_exe),
        _set_start(&SYSCTRL::AlgorithmContext::_set_empty_exe),
        _set_off(&SYSCTRL::AlgorithmContext::_set_empty_exe),
        _set_source(&SYSCTRL::AlgorithmContext::_set_empty_exe)
//
{}//CONSTRUCTOR


void AlgorithmContext::setup()
{
    static bool status = true;
    if(m_mode == SYSCTRL::AlgorithmContext::UNDEFINED)
    {

        m_algorithm = SYSCTRL::AlgorithmContext::UNKNOWN;
        m_algorithm_previous = SYSCTRL::AlgorithmContext::UNKNOWN;

        m_fault.setup();
        m_work.setup();
        m_stop.setup();
        m_start.setup();
        m_off.setup();
        m_source.setup();

        _strategy = &SYSCTRL::AlgorithmContext::_strategy_undef;
        _set_fault = &SYSCTRL::AlgorithmContext::_set_empty_exe;
        _set_work = &SYSCTRL::AlgorithmContext::_set_empty_exe;
        _set_stop = &SYSCTRL::AlgorithmContext::_set_empty_exe;
        _set_start = &SYSCTRL::AlgorithmContext::_set_empty_exe;
        _set_off = &SYSCTRL::AlgorithmContext::_set_empty_exe;
        _set_source = &SYSCTRL::AlgorithmContext::_set_empty_exe;

        if(status)
        {
            m_mode = SYSCTRL::AlgorithmContext::CONFIGURATE;
            //
        }//if
        //
    }//if
    //
}//
//
void AlgorithmContext::configure()
{
    static bool status = true;
    if(m_mode == SYSCTRL::AlgorithmContext::CONFIGURATE)
    {

        _strategy = &SYSCTRL::AlgorithmContext::_strategy_off;
        _set_fault = &SYSCTRL::AlgorithmContext::_set_fault_exe;
        _set_work = &SYSCTRL::AlgorithmContext::_set_work_exe;
        _set_stop = &SYSCTRL::AlgorithmContext::_set_stop_exe;
        _set_start = &SYSCTRL::AlgorithmContext::_set_start_exe;
        _set_off = &SYSCTRL::AlgorithmContext::_set_off_exe;
        _set_source = &SYSCTRL::AlgorithmContext::_set_source_exe;

        if(status)
        {
            m_algorithm = SYSCTRL::AlgorithmContext::OFF;
            m_algorithm_previous = SYSCTRL::AlgorithmContext::OFF;

            m_mode = SYSCTRL::AlgorithmContext::OPERATIONAL;
            set_strategy_off();
            set_off();
            //
        }//if
        //
    }//if
    //
}//
//
SYSCTRL::AlgorithmContext::mode_t AlgorithmContext::get_mode()
{
    return m_mode;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
SYSCTRL::AlgorithmContext::algorithm_t AlgorithmContext::get_algorithm()
{
    return m_algorithm;
}//
//
bool AlgorithmContext::compare(const SYSCTRL::AlgorithmContext::mode_t mode)
{
    return mode == m_mode;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
bool AlgorithmContext::compare_algorithm(const SYSCTRL::AlgorithmContext::algorithm_t algorithm)
{
    return algorithm == m_algorithm;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::get_ref_invertor_voltage(float& volt_a, float& volt_b, float& volt_c)
{
    m_algorithm_pointer->get_ref_invertor_voltage(volt_a, volt_b, volt_c);
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::strategy()
{
    (this->*_strategy)();
    //
}//
//
void AlgorithmContext::_strategy_undef()
{}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_strategy_fault()
{
    if((!m_env.system_fault.boolbit.b0)&&(m_env.system_reset.boolbit.b0))
    {
        set_strategy_off();
        set_off();
        //
    }//if
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_strategy_work()
{
    if(m_env.system_fault.boolbit.b0)
    {
        m_env.enable_work_reset.boolbit.b0 = true;
        set_strategy_fault();
        set_fault();
    }
    else
    {
        //
        if(!m_env.enable_work.boolbit.b0)
        {
            m_env.enable_work_reset.boolbit.b0 = true;
            set_strategy_off();
            set_off();
            //
        }else{

            if((m_env.local_remote.state.signal.is_off & m_env.remote_stop.state.signal.is_switched_on) |
               ((m_env.local_remote.state.signal.is_on & m_env.external_stop.signal.is_on)))
                {
                    //m_env.reference_intensity_voltage_load_direct.set_output(m_env.voltage_load_active);
                    //m_env.reference_intensity_voltage_load_quadrature.set_output(m_env.voltage_load_reactive);

                    set_strategy_stop();
                    set_stop();
                    //
                  }//if
        }
        //
    }//if else
    //
}//
//

#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_strategy_stop()
{
    if(m_env.system_fault.boolbit.b0)
    {
        m_env.enable_work_reset.boolbit.b0 = true;
        set_strategy_fault();
        set_fault();
    }
    else
    {
        if(!m_env.enable_work.boolbit.b0 |
           //(m_env.local_remote.state.signal.is_off & m_env.remote_stop.state.signal.is_switched_on) |
           //(m_env.local_remote.state.signal.is_on & m_env.external_stop.signal.is_on)
           m_env.auxiliary_km2.state.signal.is_on
           )
        {
            m_env.enable_work_reset.boolbit.b0 = true;
            set_strategy_off();
            set_off();
            //
        }
        //
    }//if else
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_strategy_start()
{
    if(m_env.system_fault.boolbit.b0)
    {
        m_env.enable_work_reset.boolbit.b0 = true;
        set_strategy_fault();
        set_fault();
    }
    else
    {
        if(!m_env.enable_work.boolbit.b0)
        {
            m_env.enable_work_reset.boolbit.b0 = true;
            set_strategy_off();
            set_off();
            //
        }
        else
        {

            if((m_env.local_remote.state.signal.is_off & m_env.remote_stop.state.signal.is_switched_on) |
               ((m_env.local_remote.state.signal.is_on & m_env.external_stop.signal.is_on))
               )
            {
                m_env.enable_work_reset.boolbit.b0 = true;
                set_strategy_off();
                set_off();
                //
            }//if



            if(m_env.auxiliary_km2.state.signal.is_off)
            {
                //m_env.regulator_voltage_load_a.set_output(m_env.reference.start.voltage_a);
                //m_env.regulator_voltage_load_b.set_output(m_env.reference.start.voltage_b);
                //m_env.regulator_voltage_load_c.set_output(m_env.reference.start.voltage_c);
                //
                //m_env.current_regulator_active.reset();
                //m_env.current_regulator_reactive.reset();
                //
                set_strategy_work();
                set_work();
                //
                //set_strategy_stop();
                //set_stop();
                //
            }//if

            //
        }//if else
        //
    }//if else
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_strategy_off()
{
    if(m_env.system_fault.boolbit.b0)
    {
        set_strategy_fault();
        set_fault();
    }
    else
    {
        if(m_env.enable_work_is_on.boolbit.b0)
        {
            set_strategy_start();
            set_start();
            //
            //set_strategy_source();
            //set_source();
            //
            //set_strategy_stop();
            //set_stop();
            //
        }//if
        //
    }//if else
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_strategy_source()
{
    if(m_env.system_fault.boolbit.b0)
    {
        m_env.enable_work_reset.boolbit.b0 = true;
        set_strategy_fault();
        set_fault();
    }
    else
    {
        //
        if((!m_env.enable_work.boolbit.b0) |
           (m_env.local_remote.state.signal.is_off & m_env.remote_stop.state.signal.is_switched_on) |
           ((m_env.local_remote.state.signal.is_on & m_env.external_stop.signal.is_on))
          )
        {
            m_env.enable_work_reset.boolbit.b0 = true;
            set_strategy_off();
            set_off();
            //
        }//if
        //
    }//if else
    //
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_strategy_fault()
{
    _strategy = &SYSCTRL::AlgorithmContext::_strategy_fault;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_strategy_work()
{
    _strategy = &SYSCTRL::AlgorithmContext::_strategy_work;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_strategy_stop()
{
    _strategy = &SYSCTRL::AlgorithmContext::_strategy_stop;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_strategy_start()
{
    _strategy = &SYSCTRL::AlgorithmContext::_strategy_start;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_strategy_off()
{
    _strategy = &SYSCTRL::AlgorithmContext::_strategy_off;
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_strategy_source()
{
    _strategy = &SYSCTRL::AlgorithmContext::_strategy_source;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_fault()
{
    (this->*_set_fault)();
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_work()
{
    (this->*_set_work)();
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_stop()
{
    (this->*_set_stop)();
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_start()
{
    (this->*_set_start)();
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_off()
{
    (this->*_set_off)();
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::set_source()
{
    (this->*_set_source)();
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::execute()
{
    m_algorithm_pointer->execute();
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_set_fault_exe()
{
    //
    m_algorithm_previous = m_algorithm;
    m_algorithm = SYSCTRL::AlgorithmContext::FAULT;
    //
    _set_fault = &SYSCTRL::AlgorithmContext::_set_empty_exe;
    _set_work = &SYSCTRL::AlgorithmContext::_set_work_exe;
    _set_stop = &SYSCTRL::AlgorithmContext::_set_stop_exe;
    _set_start = &SYSCTRL::AlgorithmContext::_set_start_exe;
    _set_off = &SYSCTRL::AlgorithmContext::_set_off_exe;
    _set_source = &SYSCTRL::AlgorithmContext::_set_source_exe;
    //
    m_env.timer_start.reset();
    m_env.timer_stop.reset();
    //
    m_algorithm_pointer = &m_fault;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_set_work_exe()
{
    //
    m_algorithm_previous = m_algorithm;
    m_algorithm = SYSCTRL::AlgorithmContext::WORK;
    //
    _set_fault = &SYSCTRL::AlgorithmContext::_set_fault_exe;
    _set_work = &SYSCTRL::AlgorithmContext::_set_empty_exe;
    _set_stop = &SYSCTRL::AlgorithmContext::_set_stop_exe;
    _set_start = &SYSCTRL::AlgorithmContext::_set_start_exe;
    _set_off = &SYSCTRL::AlgorithmContext::_set_off_exe;
    _set_source = &SYSCTRL::AlgorithmContext::_set_source_exe;
    //
    //
#if TYPECONTROL == VECTORCONTROL
    //
    m_env.regulator_voltage_load_direct.reset();
    m_env.regulator_voltage_load_quadrature.reset();
    //
    m_env.integrator_direct.reset();
    m_env.integrator_quadrature.reset();
    //
    m_env.regulator_current_limit.set_to_low_saturation();
    m_env.regulator_current_pfc.reset();
    //
#endif

#if TYPECONTROL == SCALARCONTROL
    //
    //m_env.regulator_dc_a.reset();
    //m_env.regulator_dc_b.reset();
    //m_env.regulator_dc_c.reset();
    //
    m_env.regulator_current_limit_a.set_to_high_saturation();
    m_env.regulator_current_pfc_a.reset();

    m_env.regulator_current_limit_b.set_to_high_saturation();
    m_env.regulator_current_pfc_b.reset();

    m_env.regulator_current_limit_c.set_to_high_saturation();
    m_env.regulator_current_pfc_c.reset();


#if SCALARCONTROL_VOLTAGEREGULATOR  == SCALARCONTROL_VOLTAGEREGULATOR_ABC
    m_env.regulator_voltage_load_a_active.reset();
    m_env.regulator_voltage_load_a_reactive.reset();

    m_env.regulator_voltage_load_b_active.reset();
    m_env.regulator_voltage_load_b_reactive.reset();

    m_env.regulator_voltage_load_c_active.reset();
    m_env.regulator_voltage_load_c_reactive.reset();
#endif
#if SCALARCONTROL_VOLTAGEREGULATOR  == SCALARCONTROL_VOLTAGEREGULATOR_RMS
    m_env.reference_voltage_load_rms_intensity.set_output(m_env.rms_voltage_load_module);
    m_env.regulator_voltage_load_rms.reset();
#endif
    //
#endif


#if TYPECONTROL == DIRECTREVERSECONTROL

    m_env.drc_positive_voltage_controller_direct.reset();
    m_env.drc_positive_voltage_controller_quadrature.reset();
    m_env.drc_negative_voltage_controller_direct.reset();
    m_env.drc_negative_voltage_controller_quadrature.reset();
    //
    m_env.drc_regulator_current_limit.set_to_low_saturation();
    m_env.drc_regulator_current_pfc.reset();

    m_env.drc_reference_voltage_direct_intensity.set_output(m_env.drc_voltage_grid_direct);
    m_work.reset_switcher();
    //
#endif

    //
    m_env.timer_start.reset();
    m_env.timer_stop.reset();
    //
    m_algorithm_pointer = &m_work;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_set_stop_exe()
{
    //
    m_algorithm_previous = m_algorithm;
    m_algorithm = SYSCTRL::AlgorithmContext::STOP;
    //
    _set_fault = &SYSCTRL::AlgorithmContext::_set_fault_exe;
    _set_work = &SYSCTRL::AlgorithmContext::_set_work_exe;
    _set_stop = &SYSCTRL::AlgorithmContext::_set_empty_exe;
    _set_start = &SYSCTRL::AlgorithmContext::_set_start_exe;
    _set_off = &SYSCTRL::AlgorithmContext::_set_off_exe;
    _set_source = &SYSCTRL::AlgorithmContext::_set_source_exe;
    //
#if TYPECONTROL == VECTORCONTROL
    m_env.reference_voltage_direct_intensity.set_output(m_env.regulator_current_limit.get_output());
#endif

#if TYPECONTROL == DIRECTREVERSECONTROL
    //m_env.drc_reference_voltage_direct_intensity.set_output(m_env.drc_voltage_grid_direct);
    m_env.drc_reference_voltage_direct_intensity.set_output(m_env.drc_regulator_current_limit.get_output());
#endif

    //
    //
    /* FOR DEBUG ONLY!!!! */
    /*
    m_env.regulator_voltage_load_a_active.reset();
    m_env.regulator_voltage_load_a_reactive.reset();

    m_env.regulator_voltage_load_b_active.reset();
    m_env.regulator_voltage_load_b_reactive.reset();

    m_env.regulator_voltage_load_c_active.reset();
    m_env.regulator_voltage_load_c_reactive.reset();
    */

    /* FOR DEBUG ONLY!!!! */
    /* VECTOR CONTROL */
    /*
    m_env.regulator_voltage_load_direct.reset();
    m_env.regulator_voltage_load_quadrature.reset();
    //
    m_env.integrator_direct.reset();
    m_env.integrator_quadrature.reset();
    */
    //
    m_env.timer_start.reset();
    m_env.timer_stop.start();
    //
    m_algorithm_pointer = &m_stop;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_set_start_exe()
{
    //
    m_algorithm_previous = m_algorithm;
    m_algorithm = SYSCTRL::AlgorithmContext::START;
    //
    _set_fault = &SYSCTRL::AlgorithmContext::_set_fault_exe;
    _set_work = &SYSCTRL::AlgorithmContext::_set_work_exe;
    _set_stop = &SYSCTRL::AlgorithmContext::_set_stop_exe;
    _set_start = &SYSCTRL::AlgorithmContext::_set_empty_exe;
    _set_off = &SYSCTRL::AlgorithmContext::_set_off_exe;
    _set_source = &SYSCTRL::AlgorithmContext::_set_source_exe;
    //
#if TYPECONTROL == VECTORCONTROL
    //
    m_env.regulator_current_load_direct.reset();
    m_env.regulator_current_load_quadrature.reset();
    //
    m_env.referencer_current_bypass_direct.reset();
    m_env.referencer_current_bypass_quadrature.reset();
    //
#endif
    //
#if TYPECONTROL == SCALARCONTROL
    //
    m_env.current_referencer_a_active.reset();
    m_env.current_referencer_a_reactive.reset();
    m_env.current_referencer_b_active.reset();
    m_env.current_referencer_b_reactive.reset();
    m_env.current_referencer_c_active.reset();
    m_env.current_referencer_c_reactive.reset();
    //
    m_env.current_regulator_a_active.reset();
    m_env.current_regulator_a_reactive.reset();
    m_env.current_regulator_b_active.reset();
    m_env.current_regulator_b_reactive.reset();
    m_env.current_regulator_c_active.reset();
    m_env.current_regulator_c_reactive.reset();
    //
#endif


#if TYPECONTROL == DIRECTREVERSECONTROL
    //
    m_env.drc_regulator_current_load_direct.reset();
    m_env.drc_regulator_current_load_quadrature.reset();
    //
    m_env.drc_referencer_current_bypass_direct.reset();
    m_env.drc_referencer_current_bypass_quadrature.reset();
    //
    m_env.drc_positive_voltage_cell_direct = FP_ZERO;
    m_env.drc_positive_voltage_cell_quadrature = FP_ZERO;
    m_env.drc_negative_voltage_cell_direct = FP_ZERO;
    m_env.drc_negative_voltage_cell_quadrature = FP_ZERO;
    //
    m_env.drc_positive_voltage_cell_alpha = FP_ZERO;
    m_env.drc_positive_voltage_cell_beta = FP_ZERO;
    m_env.drc_negative_voltage_cell_alpha = FP_ZERO;
    m_env.drc_negative_voltage_cell_beta = FP_ZERO;
    //
    m_env.drc_positive_voltage_cell_a = FP_ZERO;
    m_env.drc_positive_voltage_cell_b = FP_ZERO;
    m_env.drc_positive_voltage_cell_c = FP_ZERO;
    //
    m_env.drc_negative_voltage_cell_a = FP_ZERO;
    m_env.drc_negative_voltage_cell_b = FP_ZERO;
    m_env.drc_negative_voltage_cell_c = FP_ZERO;
    //
#endif


    //
    m_env.timer_start.start();
    m_env.timer_stop.reset();
    //
    m_algorithm_pointer = &m_start;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_set_off_exe()
{
    //
    m_algorithm_previous = m_algorithm;
    m_algorithm = SYSCTRL::AlgorithmContext::OFF;
    //
    _set_fault = &SYSCTRL::AlgorithmContext::_set_fault_exe;
    _set_work = &SYSCTRL::AlgorithmContext::_set_work_exe;
    _set_stop = &SYSCTRL::AlgorithmContext::_set_stop_exe;
    _set_start = &SYSCTRL::AlgorithmContext::_set_start_exe;
    _set_off = &SYSCTRL::AlgorithmContext::_set_empty_exe;
    _set_source = &SYSCTRL::AlgorithmContext::_set_source_exe;
    //
    m_env.timer_start.reset();
    m_env.timer_stop.reset();
    //
    m_algorithm_pointer = &m_off;
    //
}//
//
#pragma CODE_SECTION("ramfuncs");
void AlgorithmContext::_set_source_exe()
{
    //
    m_algorithm_previous = m_algorithm;
    m_algorithm = SYSCTRL::AlgorithmContext::SOURCE;
    //
    _set_fault = &SYSCTRL::AlgorithmContext::_set_fault_exe;
    _set_work = &SYSCTRL::AlgorithmContext::_set_work_exe;
    _set_stop = &SYSCTRL::AlgorithmContext::_set_stop_exe;
    _set_start = &SYSCTRL::AlgorithmContext::_set_start_exe;
    _set_off = &SYSCTRL::AlgorithmContext::_set_off_exe;
    _set_source = &SYSCTRL::AlgorithmContext::_set_empty_exe;
    //
    m_env.timer_start.reset();
    m_env.timer_stop.reset();
    //
    m_algorithm_pointer = &m_source;
    //
}//
//
void AlgorithmContext::_set_empty_exe()
{
    //
}//
//
//
} /* namespace SYSCTRL */