# For loop to get average value of analog input

I'm measuring the voltage and current of a battery. I'm getting inconsistent values. That's why I want to take multiple measures over a longer period. I think I should use a for loop but I'm not sure how.

``````float measureCurrent() {

// Measure
float shuntvoltage = ina219.getShuntVoltage_mV();
float busvoltage = ina219.getBusVoltage_V();
float current_mA = ina219.getCurrent_mA();
float loadvoltage = busvoltage + (shuntvoltage / 1000);

Serial.print("Bus Voltage:   "); Serial.print(busvoltage); Serial.println(" V");
Serial.print("Shunt Voltage: "); Serial.print(shuntvoltage); Serial.println(" mV");
Serial.print("Current:       "); Serial.print(current_mA); Serial.println(" mA");
Serial.println("");

return current_mA;

}
``````

Thanks for any help

Where is your attempt to calculate an average?

I haven't because I don't know how to start

You could start by adding 5 measurements each with 100ms between them and then divide with 5 to get the average of those readings? If your sketch does other work than these measurements you should use millis() for timing instead of a blocking delay Hi David,
Welcome to the forum.

Don’t use a for loop for this kind of thing, it stops anything else happening in your code elsewhere. Use loop to do the looping.

I put this together quickly to illustrate how I would get an average if I were doing what you are doing. Note this is incomplete and untested, but I hope it is enough to illustrate the approach. I hope I’ve not made any silly mistakes ``````uint16_t A2Dcumulative;
float result;
bool result_ready = false;

void setup() {
//As required
}

void loop() {
voltage_average();
process_result();
}

void voltage_average() {
#define no_of_measurements 10
static uint8_t count = 0;
if (count < no_of_measurements) {
A2Dcumulative += your_measurement_function();    //Function to read the analogue input. Add this to the value already in A2Dcumulative
}
else {
result = (float) A2Dcumulative / count;
A2Dcumulative = 0;
count = 0;
}
}

void process_result() {
//Do stuff with the result
}
}
``````

Note:
I used a 16 bit unsigned int for the cumulative result. If you have a 10 bit A2D then the maximum number of results you can add is as follows:
Assume all results return 0x3f, the maximum possible, which is 10 bits all at 1.
There are 6 unused bits
6 bits gives 2^6, which is 64
You can therefore add 64 measurements to the 16 bit unsigned int A2Dcumulative without risking overflow.

Here is how I do it. Note that in my application I didn't need to account for the sample array filling up. You can read with the following call:

``````int smoothAnalog(int reading)
{
const int numSamples = 10;
static int samples[numSamples];
static int sampleIndex = 0;
static int sampleSum = 0;

//
// Analogs are a 10-bit value (0-1023), therefore we could
// average up to 32 values with a signed int.
// NOTE: It will take 10 measurements to fill the sample
// array and return a true smoothed value.  This is not a
// problem for our application and not worth compensating for.
//

// Update sum
sampleSum -= samples[sampleIndex];