clangtidy corrections part 1
This commit is contained in:
+118
-78
@@ -4,30 +4,32 @@
|
||||
* @brief Contains the implementation of the class Battery
|
||||
* @version 0.1
|
||||
* @date 2022-02-05
|
||||
*
|
||||
*
|
||||
* @copyright Copyright (c) 2022
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include "battery.h"
|
||||
|
||||
Battery::Battery(uint8_t pin, uint32_t r1, uint32_t r2) {
|
||||
this->pin = pin;
|
||||
this->r1 = r1;
|
||||
this->r2 = r2;
|
||||
this->batteryVoltageFactor = (double) (this->r1 + this->r2) / (double) this->r2;
|
||||
Battery::Battery(uint8_t pin, uint32_t firstResistor, uint32_t secondResistor)
|
||||
: pin{pin}, firstResistor{firstResistor}, secondResistor{secondResistor},
|
||||
batteryVoltageFactor{firstResistor + secondResistor / static_cast<double>(secondResistor)}
|
||||
{
|
||||
this->initBuffer();
|
||||
this->loopDelay = 100;
|
||||
Component::loopDelay = Battery::loopDelay;
|
||||
}
|
||||
|
||||
Battery::Battery(uint8_t pin) {
|
||||
this->pin = pin;
|
||||
Battery::Battery(uint8_t pin)
|
||||
: pin{pin}
|
||||
{
|
||||
this->initBuffer();
|
||||
this->loopDelay = 100;
|
||||
Component::loopDelay = Battery::loopDelay;
|
||||
}
|
||||
|
||||
void Battery::run() {
|
||||
if (this->calibrationState != CalibrationState::None) {
|
||||
void Battery::run()
|
||||
{
|
||||
if (this->calibrationState != CalibrationState::None)
|
||||
{
|
||||
this->runCalibration();
|
||||
return;
|
||||
}
|
||||
@@ -35,164 +37,202 @@ void Battery::run() {
|
||||
this->readAdcToBuf();
|
||||
this->loopCounter++;
|
||||
|
||||
if (this->loopCounter >= this->calulationDelayMultiplier) {
|
||||
if (this->loopCounter >= this->calulationDelayMultiplier)
|
||||
{
|
||||
this->calculateBatteryVoltage();
|
||||
this->calculateBatteryPercent();
|
||||
this->loopCounter = 0;
|
||||
this->calculatetNewValues = true;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void Battery::runCalibration() {
|
||||
void Battery::runCalibration()
|
||||
{
|
||||
if (this->calibrationState != CalibrationState::Reading)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
this->readAdcToBuf();
|
||||
if (this->bufferPos == 0) {
|
||||
uint16_t res = this->getBufAvg();
|
||||
this->readAdcToBuf();
|
||||
if (this->bufferPos == 0)
|
||||
{
|
||||
const uint16_t res = this->getBufAvg();
|
||||
this->newRawAdcVoltages[this->currentCalibrationVoltage] = res;
|
||||
std::cout << "Index: "
|
||||
<< (int) this->currentCalibrationVoltage
|
||||
std::cout << "Index: "
|
||||
<< (int)this->currentCalibrationVoltage
|
||||
<< " Value: "
|
||||
<< (int) res
|
||||
<< (int)res
|
||||
<< std::endl;
|
||||
this->currentCalibrationVoltage++;
|
||||
this->calibrationState = CalibrationState::Waiting;
|
||||
|
||||
if (this->currentCalibrationVoltage == 60) {
|
||||
if (this->currentCalibrationVoltage == Battery::rawAdcVoltagesCount)
|
||||
{
|
||||
this->calibrationState = CalibrationState::Finished;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
double Battery::getBatteryVoltage() const {
|
||||
double res = this->batteryVoltage;
|
||||
return (int)(res*100+0.5)/100.0;
|
||||
double Battery::getBatteryVoltage() const
|
||||
{
|
||||
return static_cast<int>((this->batteryVoltage * 100 + 0.5)) / 100.0;
|
||||
}
|
||||
|
||||
bool Battery::isBatteryLow(double voltage) const {
|
||||
bool Battery::isBatteryLow(double voltage) const
|
||||
{
|
||||
if (this->getBatteryVoltage() <= voltage && this->batteryVoltage > this->absurdLowVoltage)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Battery::isNewValue() {
|
||||
bool Battery::isNewValue()
|
||||
{
|
||||
if (!this->calculatetNewValues)
|
||||
{
|
||||
return false;
|
||||
|
||||
}
|
||||
|
||||
this->calculatetNewValues = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
void Battery::nextVoltageIsReady() {
|
||||
if (this->calibrationState == CalibrationState::Waiting) {
|
||||
void Battery::nextVoltageIsReady()
|
||||
{
|
||||
if (this->calibrationState == CalibrationState::Waiting)
|
||||
{
|
||||
this->calibrationState = CalibrationState::Reading;
|
||||
}
|
||||
}
|
||||
|
||||
void Battery::startCalibration() {
|
||||
void Battery::startCalibration()
|
||||
{
|
||||
this->calibrationState = CalibrationState::Waiting;
|
||||
this->currentCalibrationVoltage = 0;
|
||||
this->bufferPos = 0;
|
||||
this->loopDelay = 50;
|
||||
this->newRawAdcVoltages = new uint16_t[60];
|
||||
Component::loopDelay = Battery::loopDelay / 2;
|
||||
this->newRawAdcVoltages = new uint16_t[Battery::rawAdcVoltagesCount];
|
||||
}
|
||||
|
||||
void Battery::finishCalibration() {
|
||||
void Battery::finishCalibration()
|
||||
{
|
||||
if (this->calibrationState != CalibrationState::None)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
delete[] this->newRawAdcVoltages;
|
||||
this->calibrationState = CalibrationState::None;
|
||||
this->loopDelay = 100;
|
||||
Component::loopDelay = Battery::loopDelay;
|
||||
}
|
||||
|
||||
double Battery::calculateInputVoltage() {
|
||||
double Battery::calculateInputVoltage()
|
||||
{
|
||||
// Reference voltage is 3v3 so maximum reading is 3v3 = 4095 in range 0 to 4095
|
||||
double reading = this->getBufAvg();
|
||||
if(reading < 1 || reading > 4095) return 0;
|
||||
return - 0.000000000000016 * pow(reading,4)
|
||||
+ 0.000000000118171 * pow(reading,3)
|
||||
- 0.000000301211691 * pow(reading,2)
|
||||
+ 0.001109019271794 * reading
|
||||
+ 0.034143524634089;
|
||||
if (reading < 1 || reading > Battery::adcMaxValue)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
return -this->adcCurveCoeficient[0] * pow(reading, 4) + this->adcCurveCoeficient[1] * pow(reading, 3) - this->adcCurveCoeficient[2] * pow(reading, 2) + this->adcCurveCoeficient[3] * reading + this->adcCurveCoeficient[4];
|
||||
}
|
||||
|
||||
void Battery::calculateBatteryVoltage() {
|
||||
if (this->r1 && this->r2) {
|
||||
void Battery::calculateBatteryVoltage()
|
||||
{
|
||||
if (this->firstResistor && this->secondResistor)
|
||||
{
|
||||
this->batteryVoltage = this->calculateInputVoltage() * this->batteryVoltageFactor;
|
||||
return;
|
||||
}
|
||||
|
||||
uint16_t adcValue = this->getBufAvg();
|
||||
if (adcValue < this->rawAdcVoltages[0]) {
|
||||
const uint16_t adcValue = this->getBufAvg();
|
||||
if (adcValue < this->rawAdcVoltages[0])
|
||||
{
|
||||
this->batteryVoltage = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
if (adcValue > this->rawAdcVoltages[this->rawAdcVoltagesCount] + 50) {
|
||||
this->batteryVoltage = -2;
|
||||
return;
|
||||
}
|
||||
|
||||
uint8_t index;
|
||||
for (index = 1; index < this->rawAdcVoltagesCount; index++) {
|
||||
uint8_t index = 1;
|
||||
for (; index < this->rawAdcVoltagesCount; index++)
|
||||
{
|
||||
if (adcValue < this->rawAdcVoltages[index])
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
double indexDelta = this->rawAdcVoltages[index] - this->rawAdcVoltages[index - 1];
|
||||
double valueDelta = this->rawAdcVoltages[index] - adcValue;
|
||||
const double indexDelta = this->rawAdcVoltages[index] - this->rawAdcVoltages[index - 1];
|
||||
const double valueDelta = this->rawAdcVoltages[index] - adcValue;
|
||||
double voltage = this->startVoltage + (index - 1) * this->stepVoltage;
|
||||
voltage += valueDelta / indexDelta * this->stepVoltage;
|
||||
this->batteryVoltage = voltage;
|
||||
|
||||
// std::cout << "Battery::calculateBatteryVoltage() - Voltage: " << voltage << " Index: " <<(int) index << " adcValue: " << (int) adcValue <<" iD: " << indexDelta << " vD: " << valueDelta << std::endl;
|
||||
}
|
||||
|
||||
void Battery::calculateBatteryPercent() {
|
||||
void Battery::calculateBatteryPercent()
|
||||
{
|
||||
int8_t size = sizeof(this->capacityVoltages) / sizeof(*this->capacityVoltages);
|
||||
uint8_t i;
|
||||
for (i = 0; i < size; i++) {
|
||||
if (this->batteryVoltage <= this->capacityVoltages[i])
|
||||
uint8_t index = 0;
|
||||
for (; index < size; index++)
|
||||
{
|
||||
if (this->batteryVoltage <= this->capacityVoltages[index])
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i == 0) {
|
||||
if (this->batteryVoltage > 6)
|
||||
std::cout << "Critical low battery!" << std::endl;
|
||||
} else if (i == size - 1) {
|
||||
|
||||
} else {
|
||||
double diffToLowerVal = this->batteryVoltage - this->capacityVoltages[i - 1];
|
||||
double diffToHigherVal = this->capacityVoltages[i] - this->batteryVoltage;
|
||||
if (diffToLowerVal > diffToHigherVal)
|
||||
i--;
|
||||
if (index == 0)
|
||||
{
|
||||
if (this->batteryVoltage > this->absurdLowVoltage)
|
||||
{
|
||||
std::cout << "Critical low battery!" << std::endl;
|
||||
}
|
||||
}
|
||||
this->batteryPercent = i * (100 / (size - 1));
|
||||
else if (index == size - 1)
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
const double diffToLowerVal = this->batteryVoltage - this->capacityVoltages[index - 1];
|
||||
const double diffToHigherVal = this->capacityVoltages[index] - this->batteryVoltage;
|
||||
if (diffToLowerVal > diffToHigherVal)
|
||||
{
|
||||
index--;
|
||||
}
|
||||
}
|
||||
this->batteryPercent = index * (100 / (size - 1));
|
||||
}
|
||||
|
||||
void Battery::readAdcToBuf() {
|
||||
void Battery::readAdcToBuf()
|
||||
{
|
||||
this->adcBuffer[this->bufferPos] = analogRead(this->pin);
|
||||
this->bufferPos++;
|
||||
if (this->bufferPos == Battery::bufferSize)
|
||||
{
|
||||
this->bufferPos = 0;
|
||||
}
|
||||
|
||||
// std::cout << "Battery::readAdcToBuf added Value: " << this->adcBuffer[this->bufferPos] << std::endl;
|
||||
}
|
||||
|
||||
void Battery::initBuffer() {
|
||||
void Battery::initBuffer()
|
||||
{
|
||||
for (uint8_t i = 0; i < Battery::bufferSize; i++)
|
||||
{
|
||||
this->adcBuffer[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t Battery::getBufAvg() const {
|
||||
uint16_t Battery::getBufAvg() const
|
||||
{
|
||||
uint32_t res = 0;
|
||||
uint8_t emptyPos = 0;
|
||||
for (uint8_t i = 0; i < Battery::bufferSize; i++) {
|
||||
for (uint8_t i = 0; i < Battery::bufferSize; i++)
|
||||
{
|
||||
if (this->adcBuffer[i] == 0)
|
||||
{
|
||||
emptyPos++;
|
||||
}
|
||||
res += this->adcBuffer[i];
|
||||
}
|
||||
return res / (Battery::bufferSize - emptyPos);
|
||||
|
||||
Reference in New Issue
Block a user