Program Listing for File hss-shield-bth500xx.cpp

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

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

using namespace hss;

Bth500xxShield::Bth500xxShield(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) {

}

Bth500xxShield::~Bth500xxShield() {

}

Error_t Bth500xxShield::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 Bth500xxShield::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 Bth500xxShield::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 Bth500xxShield::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;
    }

    return err;
}

DiagStatus_t Bth500xxShield::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(2000) / 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.0000160) && (senseCurrent > 0.000001)) || (senseCurrent <= 0.000001))
                {
                    diagStatus = OPEN_LOAD;
                }
                else if((outputVoltage <= supplyVoltage) && (senseCurrent > 0.0000160))
                {
                    diagStatus = NORMAL;
                }
            }
            break;

        case 2:
            switches[1]->enableDiag();
            senseCurrent = switches[1]->readIs(2000) / 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.00000125) && (senseCurrent > 0.000001)) || (senseCurrent <= 0.000001))
                {
                    diagStatus = OPEN_LOAD;
                }
            }
            break;

        default:
            diagStatus = DIAG_READ_ERROR;
    }

    return diagStatus;
}

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

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

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

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

    return isCurrent;
}

Error_t Bth500xxShield::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 Bth500xxShield::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 Bth500xxShield::readVs() {
    float supVol = 0.0;

    supVol = vs->ADCRead() * (5.0/1024.0) * ((5620.0 + 100000.0)/5620.0);
    filterVs->input(supVol);

    return filterVs->output();
}

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

    outVol = vOut->ADCRead() * (5.0/1024.0) * ((5620.0 + 100000.0) / 5620.0);
    filterVOut->input(outVol);

    return filterVOut->output();
}

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

    if(nullptr != temp) {
    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();
    }

    else {
        return -35.43;
    }
}