UL/TX
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Lots of refactoring

Browse Source
This commit is contained in:
Brent Perteet
2025-06-11 10:55:00 -05:00
parent a437bcf8b5
commit aaa7f0dc29
35 changed files with 1165 additions and 809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
source/adc.c
View File

@@ -1,5 +1,5 @@
/*
* adc.c
* _adc->c
*
* Created on: Mar 31, 2023
* Author: Keith.Lloyd
@@ -22,11 +22,9 @@
#include "adc.h"
#include "frq.h"
#include "ports.h"
#include "measure.h"
#include "utils.h"
#include "hwFixes.h"
#include "adc.h"
#include "System/system.h"
/*******************************************************************************
* Definitions
@@ -51,11 +49,13 @@ extern float32_t Watts_Filt;
extern HARDWARE_FIX_t hwf;
extern SYSTEM_DATA_t sys;
/*******************************************************************************
* Variables
******************************************************************************/
ADC_t adc;
static ADC_t *_adc;
adc_result_info_t adcResultInfoStruct;
/*
@@ -383,8 +383,8 @@ static float32_t ScaleLowGainCurrent(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -439,8 +439,8 @@ static float32_t ScaleHighGainCurrent(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -495,8 +495,8 @@ static float32_t ScaleLowGainVoltage(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.votageClipping
adc.voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
//Update _adc->votageClipping
_adc->voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
return (input * scale);
}
@@ -552,8 +552,8 @@ static float32_t ScaleLowGainCurrent208023(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -608,8 +608,8 @@ static float32_t ScaleHighGainCurrent208023(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -664,8 +664,8 @@ static float32_t ScaleLowGainVoltage208023(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.votageClipping
adc.voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
//Update _adc->votageClipping
_adc->voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
return (input * scale);
}
@@ -731,8 +731,8 @@ static float32_t ScaleLowGainCurrent208025(float32_t input)
offset = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
return ((input * scale) + offset);
}
@@ -798,8 +798,8 @@ static float32_t ScaleHighGainCurrent208025(float32_t input)
offset = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
return ((input * scale) + offset);
}
@@ -811,8 +811,10 @@ static float32_t ScaleHighGainCurrent208025(float32_t input)
/*!
* @brief Main function
*/
void ADC_Init2(void)
void ADC_SysInit(void)
{
_adc = &sys.adc;
/* Enable the power and clock for ADC. */
ADC_ClockPower_Configuration();
@@ -839,7 +841,7 @@ void ADC_Init2(void)
ADC_MeasureCurrentOffset();
//Start automatic ADC measurements (ctimer callback)
adc.measure = true;
_adc->measure = true;
}
//Measure offset for current measurement channel
@@ -847,8 +849,8 @@ void ADC_Init2(void)
void ADC_MeasureCurrentOffset(void)
{
//Measure current 8x and average
//Store as adc.I_Offset
//Store as _adc->I_Offset
Delay_Ticks(7); //70mS for current signal to stabilize
@@ -863,39 +865,39 @@ void ADC_MeasureCurrentOffset(void)
Delay_Ticks(2); //20mS
currentOffsetSum += adc.rawCurrent;
voltageOffsetSum += adc.rawVoltage;
currentOffsetSum += _adc->rawCurrent;
voltageOffsetSum += _adc->rawVoltage;
test[i] = adc.rawVoltage; //collect samples for testing
test[i] = _adc->rawVoltage; //collect samples for testing
}
adc.I_OffsetAdc = currentOffsetSum >> 3; //average of 8 samples
_adc->I_OffsetAdc = currentOffsetSum >> 3; //average of 8 samples
#if ADC_USE_NOISE_OFFSET
adc.I_OffsetAdc -= ADC_NOISE_OFFSET_COUNTS;
_adc->I_OffsetAdc -= ADC_NOISE_OFFSET_COUNTS;
#endif
#if 0 //TESTING: Allow larger offset
if(abs((int32_t)(adc.I_OffsetAdc) - ADC_HALF_COUNTS) <= 50)
if(abs((int32_t)(_adc->I_OffsetAdc) - ADC_HALF_COUNTS) <= 50)
#else
if(abs((int32_t)(adc.I_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
if(abs((int32_t)(_adc->I_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
#endif
{
adc.iosOK = true;
_adc->iosOK = true;
}
else
{
adc.iosOK = false; //This will NOT be needed after keith removes the restart when USB is disconnected
_adc->iosOK = false; //This will NOT be needed after keith removes the restart when USB is disconnected
}
adc.V_OffsetAdc = voltageOffsetSum >> 3; //average of 8 samples
if(abs((int32_t)(adc.V_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
_adc->V_OffsetAdc = voltageOffsetSum >> 3; //average of 8 samples
if(abs((int32_t)(_adc->V_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
{
adc.vosOK = true;
_adc->vosOK = true;
}
else
{
adc.vosOK = false;
_adc->vosOK = false;
}
}
@@ -915,39 +917,39 @@ void ADC_Update(void)
while(!ADC_GetChannelConversionResult(DEMO_ADC_BASE, 10, &adcResultInfoStruct));
//Add measurement to adc struct
adc.V_BID_RAW += adcResultInfoStruct.result; //ch10
_adc->V_BID_RAW += adcResultInfoStruct.result; //ch10
//CURRENT
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 0, &adcResultInfoStruct);
adc.rawCurrent = adcResultInfoStruct.result;
adc.I_OUT_RAW = adc.rawCurrent;
adc.I_OUT = adc.rawCurrent; //route raw current measurement to testIout
_adc->rawCurrent = adcResultInfoStruct.result;
_adc->I_OUT_RAW = _adc->rawCurrent;
_adc->I_OUT = _adc->rawCurrent; //route raw current measurement to testIout
#if 0 //TESTING: Don't use offset
adc.I_OUT -= ADC_HALF_COUNTS;
_adc->I_OUT -= ADC_HALF_COUNTS;
#else
if(adc.iosOK) {adc.I_OUT -= adc.I_OffsetAdc; }
else {adc.I_OUT -= ADC_HALF_COUNTS; }
if(_adc->iosOK) {_adc->I_OUT -= _adc->I_OffsetAdc; }
else {_adc->I_OUT -= ADC_HALF_COUNTS; }
#endif
#if 1 //Testing filtered raw value
adc.IRaw = adc.I_OUT; //ADC value with offset applied
adc.IRawFilt = adc.I_OUT; //filtered ADC counts w/ offset
adc.IRawFilt = FILT_ExpAvgF32(adc.IRawFilt,&adc.IRawDelay,0.02);
_adc->IRaw = _adc->I_OUT; //ADC value with offset applied
_adc->IRawFilt = _adc->I_OUT; //filtered ADC counts w/ offset
_adc->IRawFilt = FILT_ExpAvgF32(_adc->IRawFilt,&_adc->IRawDelay,0.02);
#endif
#if ADC_CORRECT_FOR_CURRENT_NOISE
//signal = SQRT( measurement^2 - noise^2)
if(adc.I_OUT > ADC_NOISE_OFFSET_COUNTS) //avoid sqrt(negative number)
if(_adc->I_OUT > ADC_NOISE_OFFSET_COUNTS) //avoid sqrt(negative number)
{
adc.I_OUT = sqrtf(adc.I_OUT * adc.I_OUT - ADC_NOISE_OFFSET_COUNTS * ADC_NOISE_OFFSET_COUNTS);
_adc->I_OUT = sqrtf(_adc->I_OUT * _adc->I_OUT - ADC_NOISE_OFFSET_COUNTS * ADC_NOISE_OFFSET_COUNTS);
}
else
{
adc.I_OUT = 0;
_adc->I_OUT = 0;
}
#endif
@@ -957,50 +959,50 @@ void ADC_Update(void)
{
if(hwf.mainPcbaPN >= 208025)
{
adc.I_OUT = ScaleHighGainCurrent208025(adc.I_OUT);
_adc->I_OUT = ScaleHighGainCurrent208025(_adc->I_OUT);
}
else if(hwf.mainPcbaPN == 208023)
{
adc.I_OUT = ScaleHighGainCurrent208023(adc.I_OUT);
_adc->I_OUT = ScaleHighGainCurrent208023(_adc->I_OUT);
}
else
{
adc.I_OUT = ScaleHighGainCurrent(adc.I_OUT);
_adc->I_OUT = ScaleHighGainCurrent(_adc->I_OUT);
}
}
else //Low Current Gain
{
if(hwf.mainPcbaPN >= 208025)
{
adc.I_OUT = ScaleLowGainCurrent208025(adc.I_OUT);
_adc->I_OUT = ScaleLowGainCurrent208025(_adc->I_OUT);
}
else if(hwf.mainPcbaPN == 208023)
{
adc.I_OUT = ScaleLowGainCurrent208025(adc.I_OUT);
_adc->I_OUT = ScaleLowGainCurrent208025(_adc->I_OUT);
}
else
{
adc.I_OUT = ScaleLowGainCurrent(adc.I_OUT);
_adc->I_OUT = ScaleLowGainCurrent(_adc->I_OUT);
}
}
//VOLTAGE
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 1, &adcResultInfoStruct);
adc.rawVoltage = adcResultInfoStruct.result;
adc.V_OUT_RAW = adc.rawVoltage;
adc.V_OUT = adc.rawVoltage;
_adc->rawVoltage = adcResultInfoStruct.result;
_adc->V_OUT_RAW = _adc->rawVoltage;
_adc->V_OUT = _adc->rawVoltage;
#if 0 //TESTING: Don't use offset
adc.V_OUT -= ADC_HALF_COUNTS;
_adc->V_OUT -= ADC_HALF_COUNTS;
#else
if(adc.vosOK) {adc.V_OUT -= adc.V_OffsetAdc; } //use offset if in range
else {adc.V_OUT -= ADC_HALF_COUNTS; } //otherwise, use ADC_HALF_COUNTS
if(_adc->vosOK) {_adc->V_OUT -= _adc->V_OffsetAdc; } //use offset if in range
else {_adc->V_OUT -= ADC_HALF_COUNTS; } //otherwise, use ADC_HALF_COUNTS
#endif
#if 1 //Testing filtered raw value
adc.VRaw = adc.V_OUT; //ADC value with offset applied. Snapshot since V_OUT gets modified later
adc.VRawFilt = FILT_ExpAvgF32(adc.VRaw,&adc.VRawDelay,0.02); //filtered ADC counts w/ offset
_adc->VRaw = _adc->V_OUT; //ADC value with offset applied. Snapshot since V_OUT gets modified later
_adc->VRawFilt = FILT_ExpAvgF32(_adc->VRaw,&_adc->VRawDelay,0.02); //filtered ADC counts w/ offset
#endif
#if 1
@@ -1008,25 +1010,25 @@ void ADC_Update(void)
if((Port_State[BOTTOM_SR] & 0x80) > 0) //High Voltage Gain
{
//Not implemented
//adc.V_OUT = MeasureHighGainVoltage(adc.V_OUT);
//_adc->V_OUT = MeasureHighGainVoltage(_adc->V_OUT);
}
else //Low Current Gain
{
if(hwf.mainPcbaPN >= 208023) //208023 and 208025 use the same table
{
adc.V_OUT = ScaleLowGainVoltage208023(adc.V_OUT);
_adc->V_OUT = ScaleLowGainVoltage208023(_adc->V_OUT);
}
else
{
adc.V_OUT = ScaleLowGainVoltage(adc.V_OUT);
_adc->V_OUT = ScaleLowGainVoltage(_adc->V_OUT);
}
}
#else
adc.V_OUT = adc.V_OUT / 4096.0 * ADC_VREF; //scale to input voltage
//adc.V_OUT = adc.V_OUT * (804.0 + 10.0) / 10.0; //Scale for external voltage divider
_adc->V_OUT = _adc->V_OUT / 4096.0 * ADC_VREF; //scale to input voltage
//_adc->V_OUT = _adc->V_OUT * (804.0 + 10.0) / 10.0; //Scale for external voltage divider
adc.V_OUT = CompensateVout(adc.V_OUT); //divider scaling sucked because AC...
_adc->V_OUT = CompensateVout(_adc->V_OUT); //divider scaling sucked because AC...
Measure_Volts();
#endif
@@ -1034,24 +1036,24 @@ void ADC_Update(void)
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 3, &adcResultInfoStruct);
adc.V_PSU_RAW += adcResultInfoStruct.result;
_adc->V_PSU_RAW += adcResultInfoStruct.result;
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 4, &adcResultInfoStruct);
adc.V_BAT_RAW += adcResultInfoStruct.result;
_adc->V_BAT_RAW += adcResultInfoStruct.result;
while(!ADC_GetChannelConversionResult(DEMO_ADC_BASE, 5, &adcResultInfoStruct));
adc.V_ID2_RAW += adcResultInfoStruct.result;
_adc->V_ID2_RAW += adcResultInfoStruct.result;
what_val2 = adcResultInfoStruct.result;
while(!ADC_GetChannelConversionResult(DEMO_ADC_BASE, 6, &adcResultInfoStruct));
adc.V_ID1_RAW += adcResultInfoStruct.result;
_adc->V_ID1_RAW += adcResultInfoStruct.result;
what_val1 = adcResultInfoStruct.result;
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 7, &adcResultInfoStruct);
adc.V_CHK_RAW += adcResultInfoStruct.result;
_adc->V_CHK_RAW += adcResultInfoStruct.result;
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 8, &adcResultInfoStruct);
adc.V_TMP_RAW += adcResultInfoStruct.result;
_adc->V_TMP_RAW += adcResultInfoStruct.result;
static uint32_t index = 0;
@@ -1062,70 +1064,70 @@ void ADC_Update(void)
index = 0;
//CHANNEL 5
adc.V_ID1 = adc.V_ID1_RAW / ADC_NUM_AVERAGES; //average
adc.V_ID1 = adc.V_ID1 / 4096.0 * ADC_VREF; //scaling
_adc->V_ID1 = _adc->V_ID1_RAW / ADC_NUM_AVERAGES; //average
_adc->V_ID1 = _adc->V_ID1 / 4096.0 * ADC_VREF; //scaling
//CHANNEL 6
adc.V_ID2 = adc.V_ID2_RAW / ADC_NUM_AVERAGES; //average
adc.V_ID2 = adc.V_ID2 / 4096.0 * ADC_VREF; //scaling
_adc->V_ID2 = _adc->V_ID2_RAW / ADC_NUM_AVERAGES; //average
_adc->V_ID2 = _adc->V_ID2 / 4096.0 * ADC_VREF; //scaling
//CHANNEL 4
adc.V_BAT = adc.V_BAT_RAW / ADC_NUM_AVERAGES; //average
adc.diag_bat = (adc.V_BAT);
_adc->V_BAT = _adc->V_BAT_RAW / ADC_NUM_AVERAGES; //average
_adc->diag_bat = (_adc->V_BAT);
adc.V_BAT = adc.V_BAT / 4096.0 * 3.3;//ADC_VREF; //scaling
_adc->V_BAT = _adc->V_BAT / 4096.0 * 3.3;//ADC_VREF; //scaling
float temp;
temp = 10000.0/59900.0;
adc.V_BAT = adc.V_BAT / temp;
_adc->V_BAT = _adc->V_BAT / temp;
//CHANNEL 3
adc.V_PSU = adc.V_PSU_RAW / ADC_NUM_AVERAGES; //average
adc.V_PSU = adc.V_PSU / 4096.0 * ADC_VREF; //scaling
_adc->V_PSU = _adc->V_PSU_RAW / ADC_NUM_AVERAGES; //average
_adc->V_PSU = _adc->V_PSU / 4096.0 * ADC_VREF; //scaling
//CHANNEL 8
adc.V_TMP = adc.V_TMP_RAW / ADC_NUM_AVERAGES; //average
adc.V_TMP = adc.V_TMP / 4096.0 * ADC_VREF; //scaling
_adc->V_TMP = _adc->V_TMP_RAW / ADC_NUM_AVERAGES; //average
_adc->V_TMP = _adc->V_TMP / 4096.0 * ADC_VREF; //scaling
//CHANNEL 10 - Battery ID
adc.V_BID = adc.V_BID_RAW / ADC_NUM_AVERAGES; //average
adc.V_BID = adc.V_BID / 4096.0 * 3.3;//ADC_VREF; //scaling
_adc->V_BID = _adc->V_BID_RAW / ADC_NUM_AVERAGES; //average
_adc->V_BID = _adc->V_BID / 4096.0 * 3.3;//ADC_VREF; //scaling
//############# Added 2/5/24
// adc.V_BID = adc.V_BID * 1.09; // additional scaling factor
// _adc->V_BID = _adc->V_BID * 1.09; // additional scaling factor
temp = 10000.0/59900.0;
adc.V_BID = adc.V_BID / temp;
_adc->V_BID = _adc->V_BID / temp;
//##############
//CHANNEL 7
adc.V_CHK = adc.V_CHK_RAW / ADC_NUM_AVERAGES; //average
volts_check = adc.V_CHK;
_adc->V_CHK = _adc->V_CHK_RAW / ADC_NUM_AVERAGES; //average
volts_check = _adc->V_CHK;
//scaling
adc.V_PSU = adc.V_PSU * (1000+47.5)/47.5; // vratio;
_adc->V_PSU = _adc->V_PSU * (1000+47.5)/47.5; // vratio;
adc.V_CHK = adc.V_CHK / 4096.0 * ADC_VREF; //ADC bits & ref voltage
_adc->V_CHK = _adc->V_CHK / 4096.0 * ADC_VREF; //ADC bits & ref voltage
#if 1 //HV scaling
adc.V_CHK *= 2.0; //Divider in the LPF
adc.V_CHK += 0.7; //diode drop from rectifier
adc.V_CHK = adc.V_CHK * (402.0 + 3.92) / 3.92; //voltage divider
_adc->V_CHK *= 2.0; //Divider in the LPF
_adc->V_CHK += 0.7; //diode drop from rectifier
_adc->V_CHK = _adc->V_CHK * (402.0 + 3.92) / 3.92; //voltage divider
#else
adc.V_CHK *= 599.0 / 100.0; // Vin = Vadc* (R1+R2) / R2
_adc->V_CHK *= 599.0 / 100.0; // Vin = Vadc* (R1+R2) / R2
adc.V_CHK *= 100; //rough scale factor needs to be re done later
_adc->V_CHK *= 100; //rough scale factor needs to be re done later
#endif
//clear raw sums
adc.V_ID1_RAW = 0;
adc.V_ID2_RAW = 0;
adc.V_CHK_RAW = 0;
adc.V_PSU_RAW = 0;
adc.V_BAT_RAW = 0;
adc.V_TMP_RAW = 0;
adc.V_BID_RAW = 0;
_adc->V_ID1_RAW = 0;
_adc->V_ID2_RAW = 0;
_adc->V_CHK_RAW = 0;
_adc->V_PSU_RAW = 0;
_adc->V_BAT_RAW = 0;
_adc->V_TMP_RAW = 0;
_adc->V_BID_RAW = 0;
}
@@ -1138,48 +1140,48 @@ float temp;
float32_t fast_k=0.0951;
adc.V_OUT_SlowFilt = FILT_ExpAvgF32(adc.V_OUT,&adc.V_OUT_Delay,k);
adc.I_OUT_SlowFilt = FILT_ExpAvgF32(adc.I_OUT,&adc.I_OUT_Delay,k);
_adc->V_OUT_SlowFilt = FILT_ExpAvgF32(_adc->V_OUT,&_adc->V_OUT_Delay,k);
_adc->I_OUT_SlowFilt = FILT_ExpAvgF32(_adc->I_OUT,&_adc->I_OUT_Delay,k);
adc.V_OUT_FastFilt = FILT_ExpAvgF32(adc.V_OUT,&adc.V_OUT_FastDelay,fast_k);
adc.I_OUT_FastFilt = FILT_ExpAvgF32(adc.I_OUT,&adc.I_OUT_FastDelay,fast_k);
_adc->V_OUT_FastFilt = FILT_ExpAvgF32(_adc->V_OUT,&_adc->V_OUT_FastDelay,fast_k);
_adc->I_OUT_FastFilt = FILT_ExpAvgF32(_adc->I_OUT,&_adc->I_OUT_FastDelay,fast_k);
if(adc.I_OUT_FastFilt > 0)
if(_adc->I_OUT_FastFilt > 0)
{
adc.Ohms_slowfilt = FILT_ExpAvgF32(adc.V_OUT_FastFilt/adc.I_OUT_FastFilt,&adc.Ohms_SlowDelay,k);
_adc->Ohms_slowfilt = FILT_ExpAvgF32(_adc->V_OUT_FastFilt/_adc->I_OUT_FastFilt,&_adc->Ohms_SlowDelay,k);
if(isnanf(adc.Ohms_SlowDelay)) //Fix nan delay line
if(isnanf(_adc->Ohms_SlowDelay)) //Fix nan delay line
{
adc.Ohms_SlowDelay = 0.00001;
_adc->Ohms_SlowDelay = 0.00001;
}
}
//##########################################################################
Watts_Filt = adc.V_OUT_FastFilt * (adc.I_OUT_FastFilt);
// Ohms_filt = adc.V_OUT_Filt/adc.I_OUT_Filt;
Watts_Filt = _adc->V_OUT_FastFilt * (_adc->I_OUT_FastFilt);
// Ohms_filt = _adc->V_OUT_Filt/_adc->I_OUT_Filt;
#if ADC_MEASUREMENT_TEST
//USAGE: Set adc.testCollectData = 1; to start data collection
//USAGE: Set _adc->testCollectData = 1; to start data collection
//adc.testIout = FILT_ExpAvgF32(adc.testIout,&adc.testIoutDelay,fast_k);
//adc.testVout = FILT_ExpAvgF32(adc.testVout,&adc.testVoutDelay,fast_k);
//_adc->testIout = FILT_ExpAvgF32(_adc->testIout,&_adc->testIoutDelay,fast_k);
//_adc->testVout = FILT_ExpAvgF32(_adc->testVout,&_adc->testVoutDelay,fast_k);
//Test data collection for measuring filter responses
static uint32_t idx = 0;
static bool measure = 1;
if(adc.testCollectData && measure)
if(_adc->testCollectData && measure)
{
adc.testData1[idx] = adc.V_OUT_FastFilt;
adc.testData2[idx] = adc.I_OUT_FastFilt * 1000.0; //convert to mA
_adc->testData1[idx] = _adc->V_OUT_FastFilt;
_adc->testData2[idx] = _adc->I_OUT_FastFilt * 1000.0; //convert to mA
idx++;
if(idx >= ADC_NUM_TEST)
{
adc.testCollectData = 0; //stop data collection
_adc->testCollectData = 0; //stop data collection
idx = 0; //reset idx
measure = 0; //DO NOT take another measurement (Don't clear and it'll measure again)
}