mcuApi.h

Go to the documentation of this file.

#pragma once

#include <boost/function.hpp>
#include <boost/system/error_code.hpp>
#include <boost/shared_ptr.hpp>
#include <list>

#include "mcuTypes.h"
#include "firmware.h"

class McuClient;

namespace dpyMcu {

enum LedsColor
{
    RED = 1, 
    BLUE = 2, 
    GREEN = 3, 
    MAGENTA = 4, 
    YELLOW = 5, 
    CYAN = 6, 
    UNDEFINED = 7 
};

enum PowerStates
{
    N_A = 1, 
    POWER_ON = 2, 
    REBOOT = 3, 
    STANDBY = 4, 
    HALT = 5, 
    ABORT = 6, 
    CRITICAL_BATTERY = 7 
};

enum GpiosAvailable {
    GPI1 = 1, 
    GPI2 = 2, 
    GPI3 = 3, 
    GPI4 = 4, 
    GPI5 = 5, 
    GPI6 = 6, 
    GPI7 = 7, 
    GPI8 = 8, 
    BUTTON1 = 9, 
    BUTTON2 = 10, 
    BUTTON3 = 11, 
    BUTTON4 = 12, 
    BUTTON5 = 13, 
    BUTTON6 = 14, 
    BUTTON7 = 15, 
    BUTTON8 = 16, 
    POWER_BUTTON = 17, 
    ODO = 18, 
    ODO_REDU = 19, 
    IGN  = 20, 
    GPO1 = 21, 
    GPO2 = 22, 
    GPO3 = 23, 
    GPO4 = 24, 
    GPO5 = 25, 
    GPO6 = 26, 
    GPO7 = 27, 
    GPO8 = 28  
};

enum Result {
    OK = 0, 
    ERROR = 1 
};

struct LedsConfig
{
    std::string timestamp; 
    LedsColor color; 
    std::uint32_t period; 
    std::uint32_t duty_cycle; 
};

struct GpioConfig
{
    std::string timestamp; 
    std::uint32_t gpio; 
    bool value; 
};

struct I2CValue
{
    int bus; 
    int device; 
    std::list<int> address; 
    std::list<int> values; 
};

struct UpdateConfig
{
    std::string timestamp; 
    std::string partition_written; 
};

struct PowerInformationConfig
{
    std::string timestamp; 
    bool ignition; 
    float battery_extern_voltage; 
    float battery_inner_percent; 
    bool battery_type; 
    std::int32_t temperature; 
    bool fault; 
    bool battery_protection_mode; 
};

struct PowerStateConfig
{
    std::string timestamp; 
    PowerStates power_state; 
    std::uint32_t event_flags; 
    Result result; 
};

struct TimersConfig
{
    std::string timestamp; 
    std::uint32_t timer_standby_minutes; 
    std::uint32_t timer_halt_minutes; 
};

struct GUIDConfig
{
    std::string timestamp; 
    std::string part_number; 
    std::string serial_number; 
    std::string cidl_number; 
};

struct GUIDConfigList
{
    std::list<struct GUIDConfig> guids; 
};

struct WorkingTimeConfig
{
    std::string timestamp; 
    std::uint32_t power_on_hours_working; 
    std::uint32_t standby_hours_working; 
    std::uint32_t halt_hours_working; 
};

struct MCUStatus
{
    std::string timestamp; 
    std::uint32_t hardware_exceptions; 
    std::uint32_t software_exceptions; 
};

struct BatteryProtectionConfig
{
    std::string timestamp; 
    float idle_voltage; 
    float voltage_percentage_over_idle_voltage_threshold; 
    float hysteresis_percentage_over_idle_voltage; 
    std::uint32_t grace_period_minutes; 
};

struct DateConfig
{
    std::string timestamp;  
    std::uint32_t seconds;  
    std::uint32_t minutes;  
    std::uint32_t hours;    
    std::uint32_t day;      
    std::uint32_t month;    
    std::uint32_t year;     
};

typedef boost::function<void(const bool &available)> service_availability_handler;

typedef boost::function<void(boost::system::error_code error_code, dpyMcu::PowerInformationConfig &)> power_mng_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::LedsConfig &)> leds_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::PowerStateConfig &)> power_states_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::TimersConfig &)> timers_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::UpdateConfig &)> update_firmware_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::GUIDConfigList &)> guid_handler_function;
typedef boost::function<void(boost::system::error_code error_code, char &, char &)> eqvar_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::WorkingTimeConfig &)> working_time_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::MCUStatus &)> mcu_status_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::BatteryProtectionConfig &)> battery_protection_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::DateConfig &)> rtc_date_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::GpioConfig &)> gpio_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::GpiosAvailable &)> gpios_events_handler_function;
typedef boost::function<void(boost::system::error_code error_code,  dpyMcu::I2CValue &)> i2c_handler_function;
typedef boost::function<void(boost::system::error_code error_code, const dpyFirmware::FirmwareVersionInfo& fw_version)> version_handler_function;
typedef boost::function<void(boost::system::error_code error_code, dpyMcu::CanStatusEvent &)> can_status_handler_function;

typedef boost::function<void(boost::system::error_code error_code)> test_misc_handler_function;

typedef boost::function<void(boost::system::error_code error_code)> set_power_button_state_handler_function;

typedef boost::function<void(boost::system::error_code error_code, bool enabled)> get_power_button_state_handler_function;

typedef boost::function<void(boost::system::error_code error_code)> result_handler_function;

}

class Mcu
{
protected:
    boost::shared_ptr<McuClient> mClient;
public:
    explicit Mcu(std::string ip = "127.0.0.1");

    virtual ~Mcu();

#ifndef TESTING

    bool isAlive();

    void monitorServiceAvailability_S(dpyMcu::service_availability_handler handler);
    void monitorServiceAvailability_U();

    void asyncGetLedsConfig(dpyMcu::leds_handler_function handler);

    void asyncSetLedsConfig(dpyMcu::leds_handler_function handler, dpyMcu::LedsColor color, std::uint32_t period, std::uint32_t duty_cycle);

    void asyncSetBatteryProtectionConfig(dpyMcu::battery_protection_handler_function handler, float idle_voltage, float voltage_percentage_threshold,
            float hysteresis_percentage, std::uint32_t grace_period_minutes);

    void asyncGetBatteryProtectionConfig(dpyMcu::battery_protection_handler_function handler);

    void asyncGetRtcDateConfig(dpyMcu::rtc_date_handler_function handler);

    boost::system::error_code getRtcDateConfig(dpyMcu::DateConfig & config);

    void asyncGetTimersConfig(dpyMcu::timers_handler_function handler);

    void asyncUpdateMCU(dpyMcu::update_firmware_handler_function handler);

    void asyncGetGUIDValues(dpyMcu::guid_handler_function handler);

    virtual boost::system::error_code getGUIDValues( dpyMcu::GUIDConfigList &guid_list);


    void asyncGetEQVar(dpyMcu::eqvar_handler_function handler);

    virtual boost::system::error_code getEQVar(char &eq_id, char &var_id);

    void asyncGetWorkingTimeValues(dpyMcu::working_time_handler_function handler);

    void asyncGetMCUStatus(dpyMcu::mcu_status_handler_function handler);

    void getPowerInformation_S(dpyMcu::power_mng_handler_function handler);

    void asyncGetPowerInformation(dpyMcu::power_mng_handler_function handler);

    void asyncGetGpioValue(dpyMcu::gpio_handler_function handler, std::uint32_t gpio_number);

    void asyncSetGpioValue(dpyMcu::gpio_handler_function handler, std::uint32_t gpio_number, bool gpio_value);

    void asyncGetGpiosEvents(dpyMcu::gpios_events_handler_function handler);

    void asyncGetI2CValue(dpyMcu::i2c_handler_function handler, unsigned char busid, unsigned char deviceid, std::list<unsigned char> address, int lenght);

    void asyncSetI2CValue(dpyMcu::i2c_handler_function handler, unsigned char busid, unsigned char deviceid, std::list<unsigned char> address, std::list<unsigned char> values);

    void asyncGetVersion(dpyMcu::version_handler_function handler, dpyFirmware::Rfs rfs);

    void getPowerInformation_U();


    boost::system::error_code setI2CValue(unsigned char busid, unsigned char deviceid, std::list<unsigned char> address, std::list<unsigned char> values,dpyMcu::I2CValue& result);

    boost::system::error_code getI2CValue(unsigned char busid, unsigned char deviceid, std::list<unsigned char> address, int length,dpyMcu::I2CValue& result);

    void asyncGetCanStatus(dpyMcu::can_status_handler_function handler);


#else
    virtual bool isAlive();
    virtual void asyncGetLedsConfig(dpyMcu::leds_handler_function handler);
    virtual void asyncSetLedsConfig(dpyMcu::leds_handler_function handler, dpyMcu::LedsColor color, std::uint32_t period, std::uint32_t duty_cycle);
    virtual void asyncSetBatteryProtectionConfig(dpyMcu::battery_protection_handler_function handler, float idle_voltage, float voltage_percentage_threshold, float hysteresis_percentage, std::uint32_t grace_period_minutes);
    virtual void asyncGetBatteryProtectionConfig(dpyMcu::battery_protection_handler_function handler);
    virtual void asyncGetRtcDateConfig(dpyMcu::rtc_date_handler_function handler);
    virtual boost::system::error_code getRtcDateConfig(dpyMcu::DateConfig & config);
    virtual void asyncGetTimersConfig(dpyMcu::timers_handler_function handler);
    virtual void asyncUpdateMCU(dpyMcu::update_firmware_handler_function handler);
    virtual void asyncGetGUIDValues(dpyMcu::guid_handler_function handler);
    virtual boost::system::error_code getGUIDValues( dpyMcu::GUIDConfigList &guid_list);
    virtual void asyncGetEQVar(dpyMcu::eqvar_handler_function handler);
    virtual boost::system::error_code getEQVar(char &eq_id, char &var_id);
    virtual void asyncGetWorkingTimeValues(dpyMcu::working_time_handler_function handler);
    virtual void asyncGetMCUStatus(dpyMcu::mcu_status_handler_function handler);
    virtual void getPowerInformation_S(dpyMcu::power_mng_handler_function handler);
    virtual void asyncGetPowerInformation(dpyMcu::power_mng_handler_function handler);
    virtual void asyncGetGpioValue(dpyMcu::gpio_handler_function handler, std::uint32_t gpio_number);
    virtual void asyncSetGpioValue(dpyMcu::gpio_handler_function handler, std::uint32_t gpio_number, bool gpio_value);
    virtual void asyncGetGpiosEvents(dpyMcu::gpios_events_handler_function handler);
    virtual void asyncGetVersion(dpyMcu::version_handler_function handler, dpyFirmware::Rfs rfs);
    virtual void getPowerInformation_U();
    virtual boost::system::error_code setI2CValue(unsigned char busid, unsigned char deviceid, std::list<unsigned char> address, std::list<unsigned char> values,dpyMcu::I2CValue& value);
    virtual boost::system::error_code getI2CValue(unsigned char busid, unsigned char deviceid, std::list<unsigned char> address, int lenght,dpyMcu::I2CValue& value);

#endif
};