Program Listing for File hss-shield-bts500xx.cpp

↰ Return to documentation for file (src/corelib/hss-shield-bts500xx.cpp)

#include "hss-shield-bts500xx.hpp"
#include <math.h>

using namespace hss;

Bts500xxShield::Bts500xxShield(Hss *sw1, Hss *sw2, ADCPAL *vs, ADCPAL *vOut, ADCPAL *temp, BtxVariants_t *btxVariant1, BtxVariants_t *btxVariant2)
:
switches{sw1, sw2},
vs(vs),
vOut(vOut),
temp(temp),
btxVariant1(btxVariant1),
btxVariant2(btxVariant2)
{

}

Bts500xxShield::~Bts500xxShield()
{

}

Error_t Bts500xxShield::init()
{
    Error_t err = OK;

    HSS_ASSERT_NULLPTR(btxVariant1);
    HSS_ASSERT_NULLPTR(btxVariant2);

    for(uint8_t i = 0; i < hssNum; i++)
    {
        HSS_ASSERT_NULLPTR(switches[i]);
        err = switches[i]->init();
        HSS_ASSERT_RET(err)
    }

    if(nullptr != vs)
    {
        err = vs->init();
        HSS_ASSERT_RET(err);
    }

    if(nullptr != vOut)
    {
        err = vOut->init();
        HSS_ASSERT_RET(err);
    }

    if(nullptr != temp)
    {
        err = temp->init();
        HSS_ASSERT_RET(err);
    }

    filterVs = new ExponentialFilter(0.0, 0.4);
    filterVOut = new ExponentialFilter(0.0, 0.4);
    filterTemp = new ExponentialFilter(0.0, 0.4);

    return(err);
}

Error_t Bts500xxShield::deinit()
{
    Error_t err = OK;

    for(uint8_t i = 0; i < hssNum; i++)
    {
        HSS_ASSERT_NULLPTR(switches[i]);
        err = switches[i]->deinit();
        HSS_ASSERT_RET(err);
    }

    if(nullptr != vs)
    {
        err = vs->deinit();
        HSS_ASSERT_RET(err);
    }

    if(nullptr != vOut)
    {
        err = vOut->deinit();
        HSS_ASSERT_RET(err);
    }

    if(nullptr != temp)
    {
        err = temp->deinit();
        HSS_ASSERT_RET(err);
    }

    return(err);
}

Error_t Bts500xxShield::switchHxOn(uint8_t x)
{
    Error_t err = OK;

    switch (x)
    {
        case 1:
            err = switches[0]->enable();
            HSS_ASSERT_RET(err);
            break;

        case 2:
            err = switches[1]->enable();
            HSS_ASSERT_RET(err);
            break;

        default:
            err = INVALID_CH_ERROR;
    }

    return err;
}

Error_t Bts500xxShield::switchHxOff(uint8_t x)
{
    Error_t err = OK;

    switch (x)
    {
        case 1:
            err = switches[0]->disable();
            HSS_ASSERT_RET(err);
            break;

        case 2:
            err = switches[1]->disable();
            HSS_ASSERT_RET(err);
            break;

        default:
            err = INVALID_CH_ERROR; // Desired number of the switch is not available.
    }

    return err;
}


DiagStatus_t Bts500xxShield::readDiagx(uint8_t x)
{
    DiagStatus_t diagStatus = NORMAL;
    float senseCurrent = 0.0;
    float supplyVoltage = 0.0;
    float outputVoltage = 0.0;

    switch (x)
    {
        case 1:
            switches[0]->enableDiag();
            senseCurrent = switches[0]->readIs(806) / btxVariant1->kilis;
            supplyVoltage = readVs();
            outputVoltage = readVOut();
            if(POWER_OFF == switches[0]->getSwitchStatus())
            {
                if(senseCurrent >= btxVariant1->iisFault)
                {
                    if(supplyVoltage == outputVoltage)
                    {
                        diagStatus = SHORT_TO_VSS;
                    }
                    else
                    {
                        diagStatus = OPEN_LOAD;
                    }
                }
            }
            else
            {
                if(senseCurrent >= btxVariant1->iisFault)
                {
                        diagStatus = SHORT_TO_GND_OR_OT;
                }
                else if(((senseCurrent <= 0.0000143) && (senseCurrent > 0.000001)) || (senseCurrent <= 0.000001))
                {
                    diagStatus = OPEN_LOAD;
                }
                else if((outputVoltage <= supplyVoltage) && (senseCurrent > 0.0000143))
                {
                    diagStatus = NORMAL;
                }
            }
            break;

        case 2:
            switches[1]->enableDiag();
            senseCurrent = switches[1]->readIs(806) / btxVariant2->kilis;
            if(POWER_OFF == switches[1]->getSwitchStatus())
            {
                if(senseCurrent >= btxVariant2->iisFault)
                {
                   diagStatus = FAULT;
                }
            }
            else
            {
                if(senseCurrent >= btxVariant2->iisFault)
                {
                        diagStatus = SHORT_TO_GND_OR_OT;
                }
                else if(((senseCurrent <= 0.00000431) && (senseCurrent > 0.000001)) || (senseCurrent <= 0.000001))
                {
                    diagStatus = OPEN_LOAD;
                }
            }
            break;

        default:
            diagStatus = DIAG_READ_ERROR;
    }

    return diagStatus;
}

float Bts500xxShield::readIsx(uint8_t x)
{
    float isCurrent = 0.0;

    switch (x)
    {
        case 1:
            switches[0]->enableDiag();
            isCurrent = switches[0]->readIs(806);
            switches[0]->disableDiag();
            break;

        case 2:
            switches[1]->enableDiag();
            isCurrent = switches[1]->readIs(806);
            switches[1]->disableDiag();
            break;

        default:
            isCurrent = -1.2345;    // Invalid channel indicator
    }

    return isCurrent;
}

Error_t Bts500xxShield::switchesHxOn(bool h1, bool h2)
{
    Error_t err = OK;

    if(true == h1)
    {
        err = switches[0]->enable();
        HSS_ASSERT_RET(err);
    }

    if(true == h2)
    {
        err = switches[1]->enable();
        HSS_ASSERT_RET(err);
    }

    return err;
}

Error_t Bts500xxShield::switchesHxOff(bool h1, bool h2)
{
    Error_t err = OK;

    if(true == h1)
    {
        err = switches[0]->disable();
        HSS_ASSERT_RET(err);
    }

    if(true == h2)
    {
        err = switches[1]->disable();
        HSS_ASSERT_RET(err);
    }

    return err;
}

float Bts500xxShield::readVs()
{
    float supVol = 0.0;

    supVol = vs->ADCRead() * (5.0/1024.0) * (10562.0/562.0);
    filterVs->input(supVol);

    return filterVs->output();
}

float Bts500xxShield::readVOut()
{
    float outVol = 0.0;

    outVol = vOut->ADCRead() * (5.0/1024.0) * (10562.0/562.0);
    filterVOut->input(outVol);

    return filterVOut->output();
}

float Bts500xxShield::readTemperature()
{
    float temperature = 0.0;
    float adcMeas = 0.0;
    float resisNTC = 0.0;

    adcMeas = temp->ADCRead() * (5.0/1024.0);
    resisNTC = (75.0 * (readVs()/adcMeas)) - 75.0;
    temperature = (1.0/298.15) + ((1.0/3380.0) * log(resisNTC/10000.0));
    temperature = (1.0/temperature) - 273.15;

    filterTemp->input(temperature);

    return filterTemp->output();
}