ATY_LIB/ALGO_Bat_ATY.c

/**
* @file ALGO_Bat_ATY.c
*
* @param Project ALGO_Algorithm_ATY_LIB
*
* @author ATY
*
* @copyright
*       - Copyright 2017 - 2026 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*
* @brief functions of Bat calc
*
* @version
*       - 1_01_230107 > ATY
*           -# Preliminary version, first Release
* @todo not real test
********************************************************************************
*/

#ifndef __ALGO_Bat_ATY_C
#define __ALGO_Bat_ATY_C

#include "ALGO_Bat_ATY.h"
#define ALGO_Bat_ATY_TAG "\r\n[ALGO_Bat_ATY] "

/******************************* For user *************************************/

/******************************************************************************/

/**
 * @brief   calc bat level with adc vol
 *
 * @param   vin           bat vol now
 * @param   lastLevel     last bat level
 * @param   vmax          bat vol when power full
 * @param   vmin          bat vol when power empty or low power limitted
 * @param   levels        whole levels to split, start from 1(1 for empty)
 * @param   vFilter       max vol for adc noise, must lower than ((vmax - vmin) / levels)
 * @return  uint8_t
 */
uint8_t Bat_AD_Levels(float vin, uint8_t lastLevel, float vmax, float vmin, uint8_t levels, float vFilter)
{
    float vUnit = (vmax - vmin) / levels;
    uint8_t resultLevel = lastLevel;

    // input limit judgement
    if(vmax <= vmin)
        return 1;
    if(vin >= vmax)
        return levels;
    else if(vin <= vmin)
        return 1;
    if(vFilter >= vUnit)
        vFilter = vUnit / 2;

    // calc
    if(vin > (vmin + (vUnit * lastLevel) + (vFilter / 2))){
        resultLevel++;
    }
    else if(vin < (vmin + (vUnit * (lastLevel - 1)) - (vFilter / 2))){
        resultLevel--;
    }
    else{}

    // output limit
    if(resultLevel > levels)
        resultLevel = levels;
    else if(resultLevel < 1)
        resultLevel = 1;

    return resultLevel;
}

#endif /* __ALGO_Bat_ATY_C */

// mbP_CVBV = 3.2;//ADC_Get(&hadc1, ADC_CHANNEL_VREFINT) * VOL_PER_AD_ATY;
// mbP_CVPV = Bat_AD_Levels(mbP_CVBV, mbP_CVPV, 4.18, 3.20, 5, 0.096);

#ifdef ALGO_Bat_ATY_Test_ATY
static int __aty_equal_u(uint32_t a, uint32_t b){ return a == b; }
static uint8_t ALGO_Bat_ATY_Test_Pass;
static uint8_t ALGO_Bat_ATY_Test_Fail;
uint32_t ALGO_Bat_ATY_Test(void){
    ALGO_Bat_ATY_Test_Pass = 0;
    ALGO_Bat_ATY_Test_Fail = 0;
    printf_ATY_D("%sSTART\r\n", ALGO_Bat_ATY_TAG);

    {
        float vmax = 3.20f, vmin = 3.20f; uint8_t levels = 5; float vin = 3.21f; uint8_t last = 3; float vf = 0.05f;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        int ok = __aty_equal_u(out, 1u);
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case vmax<=vmin: out = %d, %s\r\n", out, (ok ? "PASS" : "FAIL"));
    }

    {
        float vmax = 4.20f, vmin = 3.20f; uint8_t levels = 5; float vin = 4.20f; uint8_t last = 3; float vf = 0.05f;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        int ok = __aty_equal_u(out, (uint32_t)levels);
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case vin>=vmax: out = %d, %s\r\n", out, (ok ? "PASS" : "FAIL"));
    }

    {
        float vmax = 4.20f, vmin = 3.20f; uint8_t levels = 5; float vin = 3.00f; uint8_t last = 3; float vf = 0.05f;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        int ok = __aty_equal_u(out, 1u);
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case vin<=vmin: out = %d, %s\r\n", out, (ok ? "PASS" : "FAIL"));
    }

    {
        float vmax = 4.20f, vmin = 3.20f; uint8_t levels = 5; float vf = 0.08f; uint8_t last = 3; float vUnit = (vmax - vmin) / levels; float vin = vmin + vUnit * last + vf / 2 + 0.01f;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        int ok = __aty_equal_u(out, (uint32_t)(last + 1));
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case inc: last = %d, out = %d, %s\r\n", last, out, (ok ? "PASS" : "FAIL"));
    }

    {
        float vmax = 4.20f, vmin = 3.20f; uint8_t levels = 5; float vf = 0.08f; uint8_t last = 3; float vUnit = (vmax - vmin) / levels; float vin = vmin + vUnit * (last - 1) - vf / 2 - 0.01f;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        int ok = __aty_equal_u(out, (uint32_t)(last - 1));
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case dec: last = %d, out = %d, %s\r\n", last, out, (ok ? "PASS" : "FAIL"));
    }

    {
        float vmax = 4.20f, vmin = 3.20f; uint8_t levels = 5; float vf = 0.08f; uint8_t last = 3; float vUnit = (vmax - vmin) / levels; float vin = vmin + vUnit * last;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        int ok = __aty_equal_u(out, (uint32_t)last);
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case hold: last = %d, out = %d, %s\r\n", last, out, (ok ? "PASS" : "FAIL"));
    }

    {
        float vmax = 4.20f, vmin = 3.20f; uint8_t levels = 5; float vf = 0.08f; uint8_t last = 5; float vin = 4.25f;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        int ok = __aty_equal_u(out, (uint32_t)levels);
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case clamp upper: last = %d, out = %d, %s\r\n", last, out, (ok ? "PASS" : "FAIL"));
    }

    {
        float vmax = 4.20f, vmin = 3.20f; uint8_t levels = 5; float vf = 0.08f; uint8_t last = 1; float vin = 3.15f;
        uint8_t out = Bat_AD_Levels(vin, last, vmax, vmin, levels, vf);
        if(out < 1) out = 1;
        int ok = __aty_equal_u(out, 1u);
        if(ok) ALGO_Bat_ATY_Test_Pass++; else ALGO_Bat_ATY_Test_Fail++;
        printf_ATY_D("    Case clamp lower: last = %d, out = %d, %s\r\n", last, out, (ok ? "PASS" : "FAIL"));
    }

    printf_ATY_D("%sEND: Pass = %d, Fail = %d\r\n", ALGO_Bat_ATY_TAG, ALGO_Bat_ATY_Test_Pass, ALGO_Bat_ATY_Test_Fail);
    return ALGO_Bat_ATY_Test_Fail;
}
#endif /* ALGO_Bat_ATY_Test_ATY */

/******************************** End Of File *********************************/