Boris Leonov, Sam Kristoff, Arthur Brown

Published July 16, 2018 © MIT

Servo Brightness Gauge

An R/C servo can be used to make a gauge to measure the intensity of light.

BeginnerProtip2 hours2,404

Things used in this project

Hardware components

Digilent OpenScope MZ

Arduino UNO

Photo resistor

Servos (Tower Pro MG996R)

This project uses a 180° servo, but beyond that choose whatever model you want.

Capacitor 1000 µF

Software apps and online services

Digilent WaveForms Live

Arduino IDE

Story

Note: In order to use the photoresistor, you'll first need to characterize its response to light intensity, which is covered in this article. For the following article, it's assumed you have established arelationship between the photoresistor's value and the intensity of light falling on it. If you're interested in a more in-depth exploration of how servos work and how to characterize their response to signals from an Arduino, please read this article.

Introduction

The goal of this project was to create a servomotor-based gauge to display the intensity of light striking a photoresistor, measured in units of lux. The photoresistor (whose resistance changes in relation to the amount of light falling on it) is in a voltage divider configuration with a 220Ω resistor. An analog pin on the Arduino is used to measure the voltage in the divider, which varies as the brightness detected by the photoresistor changes. The Arduino then changes the servo position in response to the change in voltage. The following schematic and breadboard diagrams show how to arrange all the electronic components necessary for this system.

1 / 2 • This schematic and breadboard will work with the code attached at the end of the page.

Equations for Code

I previously characterized the photoresistor's behavior by using my cell phone's ambient light sensor, an OpenScope, and WaveForms Live. By using an Android app called Sensors Multitool (Lirum Device Info Lite for iPhone also works), I was able to get lux measurements for various light sources and correlate those values to the voltage measurements I saw in WaveForms Live. Since many of the light sources I chose used PWM to modulate their brightness, it was useful that WaveForms Live has a built-in function to calculate the mean value for voltage.

Once I had the characterization done, I used Excel to graph the data and generate lines of best fit. I ended up using four different equations to cover the photoresistor's full range while maximizing the R² values: 0-0.534V, 0.534-2.9V, 2.9-4.1V, and 4.1-5V. This covers 0 to 1, 000, 000 lux, or complete dark to a very bright bike light held directly to the phone's sensor.

Graph and lines of best fit used to characterize the photoresistor

I used Arduino's Servo library to control the R/C servo. The library uses degree values to set the position of the servo, so I had to map the lux scale, which is best viewed in log base 10, to a 0-180° scale. I selected the seven lux values seen on the y-axis on the chart above, spaced them 30° apart, and used Excel to generate a line of best fit for those points. The graph below generated the equation that was used in the Arduino's servo positioning command.

Arduino Code

With all the equations generated, they had to be implemented into the Arduino code. The program initially included only two functions: one to measure the brightness, and one to position the servo. I later added a third function, discussed at the end of this write-up.

In the measurement function I used four if-else statements to tell the Arduino how to interpret the voltage divider measurement on the analog input pin. These commands use the four equations from the "Photocell Characterization" graph.

The servo position-setting function simply implemented the equation from the "Lux-Degree Correlation" graph. The x-value found in the line of best fit equation was replaced by the lux value supplied by the function above.

Jerky Behavior

Overall, the code worked for visualizing the amount of light falling on the photoresistor. However, there were some areas where the servo would start to swing wildly before settling into a reading. It would also experience subsequent oscillations at random times. By using WaveForms Live to look at the servo control signal and the voltage divider measurement, I was able to gain some insight into why this behavior happens.

Primarily, the "jerky" behavior was observed in low-light situations, such as when I held my finger on the sensor to block all light. At this point, the voltage at the divider is nearly zero. However, because the servo is powered by the Arduino, and because the servo draws a significant amount of current when the motor is active, the voltage divider sees noise during the periods the servo is re-positioning itself. At the low voltage levels associated with near-dark, the noise manifests itself in the form of voltage spikes. These spikes cause the Arduino to re-position the servo, which causes subsequent spikes. Optimally, the servo should run off of a separate power supply that can source the necessary current without dropping the voltage.

The images below demonstrate the issues caused by the servo. In the first image, the Arduino was programmed to bring the yellow signal low whenever it was reading the photoresistor voltage (the blue signal). Notice that there are some instances where the photoresistor voltage is spiking or dipping right as the Arduino is taking a measurement. The second image shows the dip in photoresistor voltage immediately following a servo command signal.

1 / 2 • The drops to 0V in the yellow indicate points where the Arduino is measuring the voltage divider.

A second factor contributing to the servo's oscillations lies in the decision to map a logarithmic scale to a 0-180° scale. This means is that a change from 0 to 10 lux results in the same degree shift as from 100, 000 to 1, 000, 000. Thus, small fluctuations in voltage on the "dark" side of the scale cause relatively large movements compared to small fluctuations on the "bright" side. A change of 10mV near 0V would cause the servo to move 4°, whereas a change of 10mV near 5V wouldn't even move the servo a single degree. This is a design decision that may be flawed, but, in my opinion, is appropriate to how my eyes perceive brightness: I can easily detect the difference between 0 and 10 lux, whereas from 100, 000 to 1, 000, 000, the light goes from blinding to slightly more blinding.

Solution: Software Filter

Together, the hardware and software factors combine to make the servo unstable at low voltage levels. My initial design included a 1000µF capacitor to filter the servo-caused noise, but this was clearly insufficient. The solution was to implement a software-based filter in the form of a running average.

Initially, an array of floats was used to calculate the average, but the Arduino Uno's limited memory was causing inconsistent performance, so a slightly different solution had to be found. Normally, a running average is calculated from a sum of the measurements, and as a new measurement is added, the oldest is discarded by subtraction, thereby updating the value. However, this requires that the values comprising the sum are all kept in memory, which results in a large memory load when dealing with float data types. Another, slightly less accurate, method is to subtract the average value from the sum, instead of the oldest value, thereby removing the need to keep old measurements in memory. This works well when the measured values are approximately the same in the sampling period, which is true with the light sensor. If all the values in an average are the same, then subtracting the average would be no different than subtracting the oldest value. (If this makes no sense, try adding the same number together a couple of times and taking the average. Now, is there any difference between the oldest value and the average?)

I found that the best balance between responsiveness and noise damping required 50 samples in the running average. The size of the running average window needs to be long enough that any spikes in voltage are outweighed by the correct voltage readings, but short enough so that the system is able to respond quickly to changes. Additionally, the rate at which samples are taken is important, especially with the servo. Too short a window will cause the Arduino to take a measurement while the servo is still moving, which generates noise, and too long of a window will also cause it to see noise, since the next period of the command signal starts after 20ms. For this reason, a 15 millisecond pause between moving the servo and taking the next sample seemed to be the sweet spot.

1 / 2 • Final product.

Conclusion

With the software filter implemented, my gauge was no longer unstable in the low voltage range, and was able to quickly respond to changes in lighting. An interesting result of the modified running average was that the gauge was quicker to respond to an increase in brightness than it was to a decrease. Also, the fact that the low-light end of the scale results in large degree changes for small signal variations still caused the gauge to twitch in the 0-10 lux range, but this is an artifact of mapping a logarithmic scale to a linear one.

You can find the both the final version of the Arduino code and image I used to make the lux gauge attached at the bottom.

Code

Servo Brightness Gauge

#include <Servo.h>
#include <math.h>

//variables to keep a running average of the samples
float total;
float avg;

//number of samples to have in the running average
const int numSmpl = 10;

// create a servo object
Servo servo; 

//analog input from the photoresistor
int photoVal = A0;

/*
equations to convert voltage to lux values:
0-.534V:
lux = 1286.47506604*pow(voltage,2) + 178.51342186*voltage - 1.70982528

>0.534-2.9V: 
lux = 197.90983722e^(1.62826391*voltage)

>2.9 - 4.1V:
lux = -3785.88415527*voltage^6 + 85678.15521655*voltage^5 - 604387.00259741*voltagets^4 + 1410432.63046882*voltage^3 + 1529553.55029751*voltage^2 - 11122170.790418*voltage + 12440209.3288285

>4.1V:
lux = 23.9858393e^(2.28356737*voltage)

equation to convert lux value to degrees on servo:
y = 13.0288344570976*ln(voltage) - 0.0000000000000560135

*/

void setup() {
  // link the servo to pin 9, setting the pulse width limits
  servo.attach(9, 544, 2660);  
  
  //set the pins as inputs and outputs
  pinMode(photoVal, INPUT);
  analogWrite(LED,1);
  Serial.begin(9600);
  //take an initial sampling of measurements
  total = 0;
  for(int i = 0; i < numSmpl; i++){
    total += readBrightness();
    delay(1);
  }
  //average the samples out
  avg = total/numSmpl;
}

void loop() {
  //position the servo based on the running average
  setServo(sampleBuffer());
  
  //give the servo time to move
  delay(15);
}

//performs a reading of the photoresistor and converts the voltage to lux
float readBrightness(){
  //store the potentiometer position as a float
  float level = analogRead(photoVal);

  //calculate analog voltage
  float voltage = 5*level/1024;

  //make sure the voltage isn't outside the acceptable range
  if(voltage < 0){
    voltage = 0;
  }
  if(voltage > 5){
    voltage = 5;
  }
  //initialize a lux value
  float lux = 0;

  //based on the voltage reading, select the equation that will best convert it to a lux value
  if(voltage <= 0.534){
    lux = 1286.47506604*pow(voltage,2) + 178.51342186*voltage - 1.70982528;   
  }
  
  else if(voltage <= 2.9){
    lux = 197.90983722*exp(1.62826391*voltage);
  }

  else if(voltage <= 4.1){
    lux = -3785.88415527*pow(voltage,6) + 85678.15521655*pow(voltage,5) - 604387.00259741*pow(voltage,4) + 1410432.63046882*pow(voltage,3) + 1529553.55029751*pow(voltage,2) - 11122170.790418*voltage + 12440209.3288285;
  }

  else{
    lux = 23.9858393*exp(2.28356737*voltage);
  }
  if(lux < 0 ){
    lux = 0;
  }
  return lux;
}

//performs a modified running average on the lux measurements
float sampleBuffer(){
  //add new value to total
  total += readBrightness();

  //subtract previous average
  total -= avg;

  //calculate new average
  avg = total/numSmpl;
  return avg;
}


//moves the servo to a new position
void setServo(float lux){
  //map lux values to 180-degree scale
  int pos = round(13.0288344570976*log(lux) - 0.0000000000000560135);
  if(pos < 0){
    pos = 0;
  }
  //position value is reversed to make gauge indicate from left to right
  servo.write(180 - pos);
}