battery.cpp

Go to the documentation of this file.

 
#pragma once
 
// INCLUDES ===================================================================
 
// Associated header
#include "../includes/battery.h"
 
// Externals
#include "Arduino.h"
 
// Internal
#include "../includes/alarm_controller.h"
#include "../includes/debug.h"
#include "../includes/parameters.h"
 
// PROGRAM =====================================================================
 
static uint32_t rawBatterySample[BATTERY_MAX_SAMPLES];  // Array to store battery voltage samples
static uint32_t batteryCurrentSample = 0;               // Current battery sample index
static uint32_t batteryTotalSamples = 0;                // Battery total samples
static uint32_t rawBatteryMeanVoltage = RAW_VOLTAGE_MAINS;  // Mean battery voltage in volts
static bool isRunningOnBattery = false;
static bool mainsConnected = false;
static bool mainsConnectedAvailable = false;
 
void initBattery() {
    // hardware v3 expander is connected to AC ON relay. that remains an optionnal wiring.
    pinMode(PIN_IN_MAINS_CONNECTED, INPUT_PULLUP);
    pinMode(PIN_IN_CONNECTION_TO_SUPPLY_OK, INPUT_PULLUP);
    analogReadResolution(ADC_RESOLUTION_MAKAIR);
 
    for (uint8_t i = 0; i < BATTERY_MAX_SAMPLES; i++) {
        rawBatterySample[i] = 0;
    }
 
    // Running this in setup avoids triggering alarms at startup
    for (uint8_t i = 0; i < BATTERY_MAX_SAMPLES; i++) {
        updateBatterySample();
    }
}
 
void updateBatterySample() {
    uint16_t rawVout = analogRead(PIN_BATTERY);
 
    // Assign sample from Vout
    rawBatterySample[batteryCurrentSample] = rawVout;
 
    // Increment sample
    batteryCurrentSample++;
 
    // If we reached max samples
    if (batteryCurrentSample >= BATTERY_MAX_SAMPLES) {
        batteryCurrentSample = 0;
    }
 
    batteryTotalSamples = 0;
    for (uint8_t i = 0; i < BATTERY_MAX_SAMPLES; i++) {
        batteryTotalSamples += rawBatterySample[i];
    }
    // Updates mean voltage
    rawBatteryMeanVoltage = (batteryTotalSamples / BATTERY_MAX_SAMPLES);
}
 
void updateBatteryState(uint32_t p_cycleNumber) {
    // The connector includes a small wire between gnd and PIN_IN_CONNECTION_TO_SUPPLY_OK.
    // If this is not detected, there may be a end of line connection problem,
    // and there is a fallback to Vbat value
    mainsConnectedAvailable = (LOW == digitalRead(PIN_IN_CONNECTION_TO_SUPPLY_OK));
    mainsConnected = (LOW == digitalRead(PIN_IN_MAINS_CONNECTED));
 
    if ((mainsConnectedAvailable && !mainsConnected)
        || (!mainsConnectedAvailable
            && (rawBatteryMeanVoltage < (RAW_VOLTAGE_ON_BATTERY_HIGH - RAW_VOLTAGE_HYSTERESIS)))) {
        alarmController.detectedAlarm(RCM_SW_16, p_cycleNumber,
                                      (RAW_VOLTAGE_ON_BATTERY_HIGH - RAW_VOLTAGE_HYSTERESIS),
                                      rawBatteryMeanVoltage);
        isRunningOnBattery = true;
    } else if ((mainsConnectedAvailable && mainsConnected)
               || (!mainsConnectedAvailable
                   && (rawBatteryMeanVoltage > RAW_VOLTAGE_ON_BATTERY_HIGH))) {
        alarmController.notDetectedAlarm(RCM_SW_16);
        isRunningOnBattery = false;
    } else {
        // This is an hysteresis, so do nothing here
    }
 
    if (!mainsConnected
        && (rawBatteryMeanVoltage < (RAW_VOLTAGE_ON_BATTERY - RAW_VOLTAGE_HYSTERESIS))) {
        alarmController.detectedAlarm(RCM_SW_11, p_cycleNumber,
                                      (RAW_VOLTAGE_ON_BATTERY - RAW_VOLTAGE_HYSTERESIS),
                                      rawBatteryMeanVoltage);
    } else if (mainsConnected || (rawBatteryMeanVoltage > RAW_VOLTAGE_ON_BATTERY)) {
        alarmController.notDetectedAlarm(RCM_SW_11);
    } else {
        // This is an hysteresis, so do nothing here
    }
 
    if (!mainsConnected
        && (rawBatteryMeanVoltage < (RAW_VOLTAGE_ON_BATTERY_LOW - RAW_VOLTAGE_HYSTERESIS))) {
        alarmController.detectedAlarm(RCM_SW_12, p_cycleNumber,
                                      (RAW_VOLTAGE_ON_BATTERY_LOW - RAW_VOLTAGE_HYSTERESIS),
                                      rawBatteryMeanVoltage);
    } else if (mainsConnected || (rawBatteryMeanVoltage > RAW_VOLTAGE_ON_BATTERY_LOW)) {
        alarmController.notDetectedAlarm(RCM_SW_12);
    } else {
        // This is an hysteresis, so do nothing here
    }
}
 
void batteryLoop(uint32_t p_cycleNumber) {
    updateBatterySample();
    updateBatteryState(p_cycleNumber);
}
 
// cppcheck-suppress unusedFunction
uint32_t getBatteryLevel() { return rawBatteryMeanVoltage * RAW_BATTERY_MULTIPLIER; }
 
// cppcheck-suppress unusedFunction
uint32_t getBatteryLevelX10() { return rawBatteryMeanVoltage * (10.0 * RAW_BATTERY_MULTIPLIER); }
 
// cppcheck-suppress unusedFunction
uint32_t getBatteryLevelX100() { return rawBatteryMeanVoltage * (100.0 * RAW_BATTERY_MULTIPLIER); }
 
// cppcheck-suppress unusedFunction
bool isBatteryVeryLow() {
    return rawBatteryMeanVoltage < RAW_VOLTAGE_ON_BATTERY_NOT_STARTING_THRESHOLD;
}
 
bool isBatteryDeepDischarged() {
    return rawBatteryMeanVoltage < RAW_VOLTAGE_ON_BATTERY_STOP_THRESHOLD;
}
 
// cppcheck-suppress unusedFunction
bool isMainsConnected() { return (!isRunningOnBattery); }
 
// cppcheck-suppress unusedFunction
bool isMainsAvailable() { return mainsConnectedAvailable; }