A bit of history, I put together a complex Arduino project that allowed sampling the receiver voltage input 5000 times per second. This project allowed directly showing the minimum voltage ever hit by the battery voltage input to the receiver and its servos. This unit worked quite well, and I've got several dozen of them built up and installed in a variety of model airplanes.

REF: Arduino Nano Voltsagger
https://www.rcgroups.com/forums/show...t#post40495307

Early on with the above project with its LCD display, I ran into problems with the electrical noise level of the Arduino Nano's internal voltage reference that required the use of an external precision voltage reference.

However, a simpler device was considered. This latest project was built up in a few hours, including the Arduino Sketch program that controls the project. I've rechecked that internal reference on this project on some recently purchased Arduino Nano's, and have found that it is quite stable, and does not require an external voltage reference for this purpose.

This project is designed to allow the user to monitor the receiver/servo voltage input, and it will issue a warning by the flashing red LED's that something is wrong with your receiver power supply setup, and that the power source must be fixed.

Below is the Arduino Sketch for the project. Note that two variables are provided for specific use by the builder. The "const int V_Cal = 915; " variable sets up the voltage calibration of the project. The "const int Min_Volts = 500;" variable sets up the voltage sagging level that will trigger the failure alarm. The "500" number sets the trigger point at less than 5.00 Volts DC. This value should be set to match what you are comfortable with.

Note the command // Serial.println(voltage) ; //This function allows displaying Arduino voltage readout function. It will print out the Arduino Nano voltage read out level through the USB port to the Arduino Interface program. Remove the "//" to activate the serial printout command. Recompile and reprogram. Then Ctrl/Shift/M will activate the Arduino Serial print to the PC, displaying the Arduino voltage. Adjust the constant "915" value to match what your accurate digital multimeter shows on the actual battery voltage.

Be sure to replace the two "//" to remove the serial print command after calibration. And, again recompile and reprogram. This Serial Print command slows down the voltage sampling from 6200 times per second to several times per second.

On power up, the Green LED will light up, showing all is OK. Should the voltage ever sag below the preset voltage (5.0 Volts is currently programmed), the red LED will flash repeatedly until the power is removed.

/*
  Simple Voltsagger
  This Arduino project uses the Arduino Nano internal 1.1 VDC voltage reference for
  reading the receiver battery voltage.  The Arduino Nano reads the receiver voltage
  6200 times per second.  If the receiver voltage never drops below the "Min_Volts"
  value under "const char", the Arduino drives the Green LED to "ON"
  If the receiver voltage EVER drops below the "Min_Volts" set point, even once,
  the Arduino sketch proceeds to flashing the Red LED continuously.
  The Red LED should never flash if the receiver power supply is properly set up
  to power both the receiver and its servos.

  If the "// Serial.println(voltage) ;" is changed to "Serial.println(voltage) ;"
  the Arduino "Tools" "Serial Monitor" feature allows displaying the Arduino Nano
  Voltage readout to the PC.  This is used to calibrate the Arduino Voltage reading
  
  After calibrating, return the "//" to the Serial.print function, as the Serial.print
  function slows down the 6200 A/D readings to several times per second.
*/

//Main program follows:
//**************************************************************************************
int voltage = 0;                      //Variable for voltage ie 620 equals 6.20 Volts DC
const int V_Cal = 915;                        //915 number is used to calibrate voltage
const int Min_Volts = 500;                              //500 equals minimum 5.00 Volts
int Ad_In=0;                //Ad_In is raw A/D Arduino Nano reading of the input voltage
void setup() 
{
  pinMode(7, OUTPUT);                       //Configure digital pins for input or output
  pinMode(4, OUTPUT);
  pinMode(3, INPUT);
  pinMode(6, INPUT);
  pinMode (13,OUTPUT);
  analogReference(INTERNAL);                 //set voltage reference to internal 1.1 VDC
  Serial.begin(9600);     //Allows dumping Arduino voltage readout to USB for test setup
  digitalWrite(7, HIGH);             //turn the Green LED on (HIGH is the voltage level)
  digitalWrite(4, LOW);                //turn the Red LED Off (LOW is the voltage level)
}
void loop()
{
 Ad_In = analogRead(A7);
 voltage = map(Ad_In, 0, 1023, 0, V_Cal);           //map is program to convert readings 
//  Serial.println(voltage) ;   //This function allows displaying Arduino voltage readout
 if (voltage>Min_Volts)                //5.00 Volts is the trip voltage for undervoltage
 {}                       //If voltage is above Min_Volts, loop above routine repeatedly
 else
 for(;;)   //If voltage drops below Min_Volts, routine halts, flashes RED LED repeatedly
 {
  digitalWrite(7, LOW);              //turn the Green LED off (LOW is the voltage level)
  digitalWrite(4, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(80);                            //time delay in milliseconds for RED LED on time

  digitalWrite(7, LOW);                   // turn the LEDS on (OFF is the voltage level)
  digitalWrite(4, LOW);    
  delay(150);                          //time delay in milliseconds for RED LED off time
 }
}
//**************************************************************************************

The original version of this project used an LCD display to show the actual minimum voltage in digital format reached during a flight. They worked very well, but pretty much needed a small circuit board for the construction of the project.

I also did a few where the minimum voltage reached was displayed with a single LED that flashed a code for the minimum voltage.

That also worked quite well. The process was flashing five times for 5.X volts, and flashing 4 times for X.4 Volts to represent 5.4 VDC. In fact, that feature could be added to this project with a bit of new Sketch software. It would flash the green LED for 5.X and the red LED for X.4 volts.

And, it would use the same exact Arduino Nano as per the schematic in this thread. The sample rate would be lowered to 5000 times per second on an interrupt basis to allow the Arduino microcontroller time to drive the LED flashing process.

Anyone interested???

I could be interested. I have built one of the previous versions with the, very small, external voltage regulator and led indicator. I think that an actual indication of the lowest voltage would be more useful than the red/green traffic lights system as that does not indicate how low the voltage actually got.

I've just completed an alternate sketch, where the Arduino Nano shows a green LED if the receiver input voltage never drops below a user defined minimum voltage.

If the receiver voltage drops below that preset minimum voltage, even for one millisecond, the Arduino Nano will flash its two LED's in a code where, for example, a sag to 5.2 Volts DC shows up as 5 Green LED flashes, then 2 Red LED flashes. (A zero value shows up as a rapid double flash) Here is the code for this feature.

/*
  Simple Voltsagger with voltage readouts
  This Arduino project uses the Arduino Nano internal 1.1 VDC voltage reference for
  reading the receiver battery voltage.  The Arduino Nano reads the receiver voltage
  5000  times per second.  If the receiver voltage never drops below the "Min_Volts"
  value under "const char", the Arduino drives the Green LED to "ON"
  NEW CODE 04/04/2020
  If the receiver voltage EVER drops below the "Min_Volts" set point, even once,
  the Arduino sketch proceeds to flashing the green and red LED's continuously
  setting up a code for the actual voltage dropped to level.
  The LED flash is as follows, ie 5.4 Volt sag is 5 Grn Flashes, 4 Red Flashes
  The Red/green LEDs should never flash if the receiver power supply is properly set up
  to power both the receiver and its servos.

  If the "// Serial.println(voltage) ;" is changed to "Serial.println(voltage) ;"
  the Arduino "Tools" "Serial Monitor" feature allows displaying the Arduino Nano
  Voltage readout to the PC.  This is used to calibrate the Arduino Voltage reading
  
  After calibrating, return the "//" to the Serial.print function, as the Serial.print
  function slows down the 6200 A/D readings to several times per second.
  Note that capacitor C1 is currently 0.47 uF, a value selected to slow down the
  Arduino response time to a voltage sag to about one millisecond to allow
  ignoring very short transients that might show up.
*/

//Main program follows:

//**************************************************************************************
#include <TimerOne.h>                                   //set up for interrupt functions
int Low_Volts = 1110;             //Variable for low voltage ie 620 equals 6.20 Volts DC
const int V_Cal = 928;                         //915 number is used to calibrate voltage
const int Min_Volts = 580; //580 this is the users preset minimum sagging voltage setting
int Ad_In=1110;                //Ad_In is raw A/D Arduino Nano reading of the input voltage
int long Ad_Cnv = 1100;             //default level for initializing low voltage reading
char counter = 0;
char x=0;

void setup() 
{
  Timer1.initialize(200);                       // set a timer of length 200 uS or 5Khz
  Timer1.attachInterrupt( timerIsr );                // attach the service routine here
  analogReference(INTERNAL);                //set up for external VDC voltage reference
  pinMode(7, OUTPUT);                      //Configure digital pins for input or output
  pinMode(4, OUTPUT);
  pinMode(3, INPUT);
  pinMode(6, INPUT);
  pinMode (13,OUTPUT);
  Serial.begin(9600);    //Allows dumping Arduino voltage readout to USB for test setup
 delay(2000);
  Low_Volts = 1100; //initiate the low voltage reading after the interrupt settles down
  }
  //this is the interrupt server for the A/D converter. 
   void timerIsr()
 {
   Ad_In= analogRead(7);
   Ad_Cnv = map(Ad_In, 0, 1023, 0, V_Cal);          //convert to actual voltage reading
 if(Ad_Cnv<Low_Volts) 
 {                
    Low_Volts = Ad_Cnv ;
  }  
 }
void Grn_Flash()           //this is the routine to flash the green LED for 6.X readout
{
  for (x=0;x<counter;x++)
  {
  digitalWrite(7, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(200);                           //time delay in milliseconds for RED LED on time
  digitalWrite(7, LOW);    
  delay(500);                          //time delay in milliseconds for RED LED off time
  }
  delay(1500);                        //time delay between Green flashes and Red flashes
 }
void Red_Flash()
{
   if(counter==0)           //if X.0 where the digit = 0, double flash the LED very fast
{
  digitalWrite(4, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(100);                            //time delay in milliseconds for RED LED on time
  digitalWrite(4, LOW);    
  delay(150); 
  digitalWrite(4, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(100);                            //time delay in milliseconds for RED LED on time
  digitalWrite(4, LOW);    
  delay(3500); 
}
else
 {
  for (x=0;x<counter;x++)
  {
  digitalWrite(4, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(200);                           //time delay in milliseconds for RED LED on time
  digitalWrite(4, LOW);    
  delay(500);                          //time delay in milliseconds for RED LED off time
  }
  delay(3500);                            //time delay between Red and Green flash cycle
 }  
}
//**************************************************************************************
//This is the main program of the Arduino Sketch Software
void loop()
{
// Serial.println(Ad_Cnv) ;  //This function allows displaying Arduino voltage readout
 if (Low_Volts>Min_Volts)  //if the load voltage  exceeds preset "Min_Volts" Green is lit
  {
   digitalWrite(7, HIGH);             //turn the Green LED on (HIGH is the voltage level)
  }
 else   //voltage sagged below "Min_Volts" setting, got to endless flash of lowest Volts
  {
 for(;;)                                     //Run the voltage level routine indefinitely
  {
//    Serial.println(Low_Volts) ; //This function allows displaying Arduino voltage readout
   counter = (Low_Volts/100);                                //get most significant digit
   Grn_Flash();          //flash the green LED for the msd.  ie 6.X = 6 green LED flashes
   counter = (Low_Volts/10)%10;                                    //get the middle digit
   Red_Flash();     //flash the red LED for the middle digit.  ie X.4 = 4 red LED flashes
  }
 }
}  
//**************************************************************************************

Originally Posted by Bearded Flyer

I could be interested. I have built one of the previous versions with the, very small, external voltage regulator and led indicator. I think that an actual indication of the lowest voltage would be more useful than the red/green traffic lights system as that does not indicate how low the voltage actually got.

It's done, take a look at the previous posting. FYI, the same exact circuit is used. Nice thing about microcontrollers, a change in software can create an entirely new product, using the same circuit diagram.

Denny, just confirming. I presume from the comments in the sketch (6.2V as Low value) this is set up for 2x A123 packs?
I know you are a fan of them as receiver packs.

However why is the first line in these three set to 1110?

===========

int Low_Volts = 1110; //Variable for low voltage ie 620 equals 6.20 Volts DC
const int V_Cal = 928; //915 number is used to calibrate voltage
const int Min_Volts = 580; //580 this is the users preset minimum sagging voltage setting

============

Thanks

John

Originally Posted by jj604

Denny, just confirming. I presume from the comments in the sketch (6.2V as Low value) this is set up for 2x A123 packs?
I know you are a fan of them as receiver packs.

However why is the first line in these three set to 1110?

===========

int Low_Volts = 1110; //Variable for low voltage ie 620 equals 6.20 Volts DC
const int V_Cal = 928; //915 number is used to calibrate voltage
const int Min_Volts = 580; //580 this is the users preset minimum sagging voltage setting


============

Thanks

John

This unit will work on any receiver pack, including A123, LiFe, NiMH, or LiPo. The maximum Iput voltage is 7500/1000*1.1Volts or 8.25 Volts DC. For different voltage range, change the 7500 ohm resistor value, and adjust the voltage calibration. Example, changing the two 7500/1000 Ohm resistors to 10,000/1000 Ohms will change the full scale reading to 10,000/1000 Times 1.1 Volt voltage reference, or 11 Volts full scale. Don't go over 15 Volts DC input, that is the maximum input voltage rating of the Arduino voltage regulator chip.

As for the "int Low_Volts = 1110", ignore that. I'll recompile to show that.

The proper setting for minimum volts is the command

"const int Min_Volts = 580; //580 this is the users preset minimum sagging voltage setting"

/*
  Simple Voltsagger with voltage readouts
  This Arduino project uses the Arduino Nano internal 1.1 VDC voltage reference for
  reading the receiver battery voltage.  The Arduino Nano reads the receiver voltage
  6200 times per second.  If the receiver voltage never drops below the "Min_Volts"
  value under "const char", the Arduino drives the Green LED to "ON"
  NEW CODE 04/05/2020
  If the receiver voltage EVER drops below the "Min_Volts" set point, even once,
  the Arduino sketch proceeds to flashing the green and red LED's continuously
  setting up a code for the actual voltage dropped to level.
  The LED flash is as follows, ie 5.4 Volt sag is 5 Grn Flashes, 4 Red Flashes
  The Red/green LEDs should never flash if the receiver power supply is properly set up
  to power both the receiver and its servos.

  If the "// Serial.println(voltage) ;" is changed to "Serial.println(voltage) ;"
  the Arduino "Tools" "Serial Monitor" feature allows displaying the Arduino Nano
  Voltage readout to the PC.  This is used to calibrate the Arduino Voltage reading
  
  After calibrating, return the "//" to the Serial.print function, as the Serial.print
  function slows down the 6200 A/D readings to several times per second.
*/

//Main program follows:

//******** These two constants are used to set up the Simple Volt Sagger project   *****
const int V_Cal = 928;                         //928 number is used to calibrate voltage
const int Min_Volts = 580;//580 this is the users preset minimum sagging voltage setting
//        Note: To set the unit to always display minimum voltage, set Min_Volts to 1200
//**************************************************************************************
#include <TimerOne.h>                                   //set up for interrupt functions
int Low_Volts =  1100;             //initiate the minimum voltage measurement
int Ad_In=1110;              //Ad_In is raw A/D Arduino Nano reading of the input voltage
int long Ad_Cnv = 1100;             //default level for initializing low voltage reading
char counter = 0;
char x=0;

void setup()                //the usual setup routines as used by the Arduino Sketches
{
  Timer1.initialize(200);                       // set a timer of length 200 uS or 5Khz
  Timer1.attachInterrupt( timerIsr );                // attach the service routine here
  analogReference(INTERNAL);                //set up for external VDC voltage reference
  pinMode(7, OUTPUT);                      //Configure digital pins for input or output
  pinMode(4, OUTPUT);
  pinMode(3, INPUT);
  pinMode(6, INPUT);
  pinMode (13,OUTPUT);
 // pinMode (9,OUTPUT);
  Serial.begin(9600);    //Allows dumping Arduino voltage readout to USB for test setup
 delay(2000);

// Serial.println("VoltSagger " __DATE__); // compilation date
  Low_Volts = 1100; //initiate the low voltage reading after the interrupt settles down
  }
  //this is the interrupt server for the A/D converter. 
   void timerIsr()
 {
   Ad_In= analogRead(7);
   Ad_Cnv = map(Ad_In, 0, 1023, 0, V_Cal);          //convert to actual voltage reading
 if(Ad_Cnv<Low_Volts) 
 {                
   Low_Volts = Ad_Cnv ;
  }
 }
void Grn_Flash()           //this is the routine to flash the green LED for 6.X readout
{
  for (x=0;x<counter;x++)
  {
  digitalWrite(7, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(200);                           //time delay in milliseconds for RED LED on time
  digitalWrite(7, LOW);    
  delay(500);                          //time delay in milliseconds for RED LED off time
  }
  delay(1500);                        //time delay between Green flashes and Red flashes
 }
void Red_Flash()
{
   if(counter==0)           //if X.0 where the digit = 0, double flash the LED very fast
{
  digitalWrite(4, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(100);                            //time delay in milliseconds for RED LED on time
  digitalWrite(4, LOW);    
  delay(150); 
  digitalWrite(4, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(100);                            //time delay in milliseconds for RED LED on time
  digitalWrite(4, LOW);    
  delay(3500); 
}
else
 {
  for (x=0;x<counter;x++)
  {
  digitalWrite(4, HIGH);               //turn the Red LED on (HIGH is the voltage level)
  delay(200);                           //time delay in milliseconds for RED LED on time
  digitalWrite(4, LOW);    
  delay(500);                          //time delay in milliseconds for RED LED off time
  }
  delay(3500);                            //time delay between Red and Green flash cycle
 }  
}
//**************************************************************************************
//This is the main program of the Arduino Sketch Software
void loop()
{
  if (Low_Volts>Min_Volts)  //if the load voltage  exceeds preset "Min_Volts" Green is lit
  {
   digitalWrite(7, HIGH);             //turn the Green LED on (HIGH is the voltage level)
  }
 else   //voltage sagged below "Min_Volts" setting, got to endless flash of lowest Volts
  {
 for(;;)                                     //Run the voltage level routine indefinitely
  {
//   Serial.println(Low_Volts) ;  //This function allows displaying Arduino voltage readout
   counter = (Low_Volts/100);                                //get most significant digit
   Grn_Flash();          //flash the green LED for the msd.  ie 6.X = 6 green LED flashes
   counter = (Low_Volts/10)%10;                                    //get the middle digit
   Red_Flash();     //flash the red LED for the middle digit.  ie X.4 = 4 red LED flashes
  }
 }
}  
//**************************************************************************************

Thanks

FYI, I've created a new posting of this thread per the following link.

https://www.rcgroups.com/forums/show...es-again%21%29

I am interested Dennis.
I will go over to your new thread.

I still have one of these original Voltsagers.
I pulled it out to fit into a current model to monitor the power system.
When I compare the voltage reading indicated to 2 volt meters, the flashing LED indicated a voltage 1 volt lower than the two meters.
As I see it, I have two options:

1. Flash the arduino nano board again with the original sketch
Or:
2. Abandon this version and upgrade the board to the version with the flashing green LED (obviously superior!).

Comments please, if any of your regulars are still reading.

Jim.

Originally Posted by vollrathd

It's done, take a look at the previous posting. FYI, the same exact circuit is used. Nice thing about microcontrollers, a change in software can create an entirely new product, using the same circuit diagram.

I will do just that.
Please ignore my previous post.
I will report in again after changing the software.

Edit:
For clarification purposed, how many versions of this device have been developed?
I am aware or two. Is there another? Sorry for this old man's confusion!.................
I am trying to decide which one to make up.

Jim.

Originally Posted by Jim.Thompson

I will do just that.
Please ignore my previous post.
I will report in again after changing the software.

Edit:
For clarification purposed, how many versions of this device have been developed?
I am aware or two. Is there another? Sorry for this old man's confusion!.................
I am trying to decide which one to make up.

Jim.

Hi Jim

There are two main versions of this project using the Arduino Nano microcontrollers. First is the LCD version, second is the much simpler and much less costg LED version. I put the LED versions in most of my models.

As for calibration, their is a calibration line of code in the Arduino sketch. That calibration can be changed to match the real voltage as measured with an external voltmeter. Something like this:

volts = AD_result*0.0098; //retrieve live voltage, correct ratio

Originally Posted by Jim.Thompson

I will do just that.
Please ignore my previous post.
I will report in again after changing the software.

Edit:
For clarification purposed, how many versions of this device have been developed?
I am aware or two. Is there another? Sorry for this old man's confusion!.................
I am trying to decide which one to make up.

Jim.

Hi Jim

There are two main versions of this project using the Arduino Nano microcontrollers. First is the LCD version, second is the much simpler and much less costg LED version. I put the LED versions in most of my models.

The latest version uses three LED's that shows minimum voltage and so on.

https://www.rcgroups.com/forums/show...9#post44227477

As for calibration, there is a calibration variable line of code in the Arduino sketch above. That calibration can be changed to match the real voltage as measured with an external voltmeter.

const int V_Cal = 928; //915 number is used to calibrate voltage

(PS, as for old man, I just turned over 80 years old last fall. And after losing my first wife of 55 years, got remarried one year and 3 months ago!)

Originally Posted by vollrathd

Hi Jim

There are two main versions of this project using the Arduino Nano microcontrollers. First is the LCD version, second is the much simpler and much less costg LED version. I put the LED versions in most of my models.

The latest version uses three LED's that shows minimum voltage and so on.

.........................

Many thanks for responding to me with what must be beginners questions.
I plan to make up one of the three LED versions next.
I will move over to that thread and ask one or two questions about that version.

Married again? Wow! You are a better man than me!

More later,

Jim.