how do I write a code to take samples and calculate the rms vlaue from analog signal?

Question

first I want to say that I'm a beginner in Arduino programming, so please explain the code if possible. I want to design a system which can monitor the 3 phase supply currents and voltages and take action e.g. activate a relay to isolate the system from load if there is a phase loss.

I'm using ACS712 current sensors and AC voltage measurement circuit to measure the voltages.

I wrote a code to monitor the phases and trigger the relay to isolate the load if the voltage drop below 100V for instance. but one issue I'm facing is the relay is getting activated randomly on and off, even though the phase voltage is 220V well above the threshold value which is 100V.

My real question is how do I write a code which can take samples and divide it with a number of samples and calculate the RMS value?

I found this code below online but failed to understand it.so if you explain it will be very appreciated.

float current=0;
const int currentPin = A0;
const unsigned long sampleTime = 100000UL; // sample over 100ms, it is an exact number of cycles for both 50Hz and 60Hz mains
const unsigned long numSamples = 250UL;  // choose the number of samples to divide sampleTime exactly, but low enough for the ADC to keep up
const unsigned long sampleInterval = sampleTime/numSamples;  // the sampling interval, must be longer than then ADC conversion time
const int adc_zero = 510;                                                     // relative digital zero of the arudino input from ACS712 (could make this a variable and auto-adjust it)

void setup()
{
 Serial.begin(9600);
}

void loop()
{

CurrentSense();
Serial.println(current);
delay(1000);

}

void CurrentSense()
{
 unsigned long currentAcc = 0;
 unsigned int count = 0;
 unsigned long prevMicros = micros() - sampleInterval ;
 while (count < numSamples)
 {
   if (micros() - prevMicros >= sampleInterval)
   {
     int adc_raw = analogRead(currentPin) - adc_zero;
     currentAcc += (unsigned long)(adc_raw * adc_raw);
     ++count;
     prevMicros += sampleInterval;
   }
 }

 float rms = sqrt((float)currentAcc/(float)numSamples) * (50 / 1024.0);
rms=rms-0.10;
if (rms<0.20)
{
rms=0;
}

current=rms;
}

I didn't understand the following line of codes:

const unsigned long sampleTime = 100000UL; what is unsigned long & what is UL?
const unsigned long numSamples = 250UL;
const unsigned long sampleInterval = sampleTime/numSamples;

unsigned long prevMicros = micros() - sampleInterval ; what is Micro() function?
while (count < numSamples)
 {
   if (micros() - prevMicros >= sampleInterval)
   {
     int adc_raw = analogRead(currentPin) - adc_zero;
     currentAcc += (unsigned long)(adc_raw * adc_raw);
     ++count;
     prevMicros += sampleInterval;
   }
 }

 float rms = sqrt((float)currentAcc/(float)numSamples) * (50 / 1024.0);

Answer 1

To answer your first question about the unsigned long, with numerical data types the most-significant bit is usually used to determine if a number is positive or negative. However, this is at the cost of halving the positive capacity of the data type. If a negative value is not an expected outcome, then you can declare a data type as unsigned to use the most significant bit for a greater positive capacity.

So for example:

• An unsigned long using 4 bytes has a value range from 0 to 4,294,967,295
• A (signed) long using 4 bytes has a value range from -2,147,483,648 to 2,147,483,647

The use of UL at the end of a number explicitly tells the compiler that this value is an unsigned long. Note that the size of a long (or any other numerical types) may not be consistent across compilers.

See also - What's the difference between unsigned long/long/int in c/c++?

As for your other question, the Arduino docs describe the micros() function:

Returns the number of microseconds since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 70 minutes. On 16 MHz Arduino boards (e.g. Duemilanove and Nano), this function has a resolution of four microseconds (i.e. the value returned is always a multiple of four). On 8 MHz Arduino boards (e.g. the LilyPad), this function has a resolution of eight microseconds.

Note: there are 1,000 microseconds in a millisecond and 1,000,000 microseconds in a second.