Calculating Minimum and Maximum temperature of past 60 sec [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 3 years ago.
Improve this question
This is an algorithm question where I need some idea for my project.
I have one function which is measuring temperature at every 100 ms. My question is, when user asks, I want to calculate the minimum and maximum temperature of last 60 secs.
Note: I don't store measured temperature in any array due to memory restriction.

Answer 1

In most cases temperature does not change very fast, so sampling at 10sps is probably excessive, however if the sampling is noisy, such oversampling is useful to get stable readings at higher resolution.
Given the typical dynamics of temperature change you can instead take the sum of samples over a short period N, and every N seconds, add that sum to a moving-window buffer and reset the N accumulator.
The min/max value over the window period can then be found in the buffer without having to retain all the samples over that period
For example given the following function:
#include <limits.h>
void temperatureWindowedMinMax( int& min, int& max )
{
static const int TEMPERATURE_SENSOR_PIN = A0 ; // Analogue pin for sensor
static const long SAMPLE_PERIOD_MS = 100 ; // 10sps
static const int SAMPLE_SUM_N = 20 ; // Accumulate 2 seconds of samples
static const int MINMAX_BUFFER_LENGTH = 30 ; // 60 second buffer
static int sample_sum = 0 ;
static int sample_sum_count = 0 ;
static int minmax_buffer[MINMAX_BUFFER_LENGTH] = {0} ;
static int minmax_buffer_index = 0 ;
long now = millis() ;
static long last_sample_time = now - SAMPLE_PERIOD_MS ; // force sample on first call
// Get new sample if last sample is SAMPLE_PERIOD_MS old or more
int sample = 0 ;
if( now - last_sample_time > SAMPLE_PERIOD_MS )
{
sample = analogRead( TEMPERATURE_SENSOR_PIN ) ;
// Accumulate samples
sample_sum += sample ;
sample_sum_count++ ;
// When SAMPLE_SUM_N samples have been accumulated...
if( sample_sum_count >= SAMPLE_SUM_N )
{
// Add sample sum to min-max buffer
minmax_buffer[minmax_buffer_index] = sample_sum ;
minmax_buffer_index++ ;
if( minmax_buffer_index >= MINMAX_BUFFER_LENGTH )
{
minmax_buffer_index = 0 ;
}
// Reset mean accumulator
sample_sum_count = 0 ;
sample_sum = 0 ;
}
}
// Find min and max in min-max buffer
min = INT_MAX ;
max = INT_MIN ;
for( int i = 0; i < MINMAX_BUFFER_LENGTH; i++ )
{
if( minmax_buffer[i] > max ) max = minmax_buffer[i] ;
if( minmax_buffer[i] < min ) min = minmax_buffer[i] ;
// NOTE: Convert min/max to temperature here if necessary
// bearing in mind that the sum is 20 x larger
// then the raw analogue sample
}
}
you might have a Sketch loop() like:
void loop()
{
int tmin, tmax ;
temperatureWindowedMinMax( tmin, tmax ) ;
// tmin tmax have min and max temperature over last 60 seconds
}
Note that temperatureWindowedMinMax() handles its own sample timing and need only be called rapidly in the loop. It would be possible to separate the min/max recovery from the sampling by creating two functions and changing the min-max buffer scope:
#include <limits.h>
static const int MINMAX_BUFFER_LENGTH = 30 ;
static int minmax_buffer[MINMAX_BUFFER_LENGTH] = {0} ;
void updateTemperatureMinMax()
{
static const int TEMPERATURE_SENSOR_PIN = A0 ; // Analogue pin for sensor
static const long SAMPLE_PERIOD_MS = 100 ; // 10sps
static const int SAMPLE_SUM_N = 20 ; // Accumulate 2 seconds of samples
static int sample_sum = 0 ;
static int sample_sum_count = 0 ;
static int minmax_buffer_index = 0 ;
long now = millis() ;
static long last_sample_time = now - SAMPLE_PERIOD_MS ; // force sample on first call
// Get new sample if last sample is SAMPLE_PERIOD_MS old or more
int sample = 0 ;
if( now - last_sample_time > SAMPLE_PERIOD_MS )
{
sample = analogRead( TEMPERATURE_SENSOR_PIN ) ;
// Accumulate samples
sample_sum += sample ;
sample_sum_count++ ;
// When SAMPLE_SUM_N samples have been accumulated...
if( sample_sum_count >= SAMPLE_SUM_N )
{
// Add sample sum to min-max buffer
// NOTE: Convert sample_sum to temperature here if necessary
// bearing in mind that the sum is 20 x larger
// then the analogue sample
minmax_buffer[minmax_buffer_index] = sample_sum ;
minmax_buffer_index++ ;
if( minmax_buffer_index >= MINMAX_BUFFER_LENGTH )
{
minmax_buffer_index = 0 ;
}
// Reset mean accumulator
sample_sum_count = 0 ;
sample_sum = 0 ;
}
}
}
void getTemperatureWindowedMinMax( int& min, int& max )
{
// Find min and max in min-max buffer
min = INT_MAX ;
max = INT_MIN ;
for( int i = 0; i < MINMAX_BUFFER_LENGTH; i++ )
{
if( minmax_buffer[i] > max ) max = minmax_buffer[i] ;
if( minmax_buffer[i] < min ) min = minmax_buffer[i] ;
// NOTE: Convert min/max to temperature here if necessary
// bearing in mind that the sum is 20 x larger
// then the raw analogue sample
}
}
Then update and the usage can be independent:
void loop()
{
updateTemperatureMinMax() ;
// Every second, do something with min max
if( millis() % 1000 == 0 )
{
int tmin, tmax ;
getTemperatureWindowedMinMax( min, max ) ;
// tmin tmax have min and max temperature over last 60 seconds
}
}
Either way you get control over the memory usage via the constants:
static const int TEMPERATURE_SENSOR_PIN = A0 ; // Analogue pin for sensor
static const long SAMPLE_PERIOD_MS = 100 ; // 10sps
static const int SAMPLE_SUM_N = 20 ; // Accumulate 2 seconds of samples
static const int MINMAX_BUFFER_LENGTH = 30 ; // 60 second buffer
For example taking a longer average allows a shorter buffer while being less responsive to rapid fluctuations. A shorter average but a longer buffer will capture short temperature spikes at the expense of more memory. In practice, temperature tends to be a low-bandwidth, laggy signal, so the above settings are probably more than adequate in most cases.
Note that in both solutions, the conversion from analogue sample sum to temperature need not be carried out on the stored samples of sample sum, but can be performed only on the final min/max result. Doing do is both efficient and avoids data loss through rounding. Note also that the sum of samples is accumulated, not the average it is both more efficient and avoids data loss.