Recycled Meter Artwork

Battery powered artwork made from recycled ammeter to hang on your wall

Aug 2, 2020

•

1376 views

•

2 respects

energy efficiency

art

recycling

Components and supplies

5 mm LED: Green

Resistor 10k ohm

5 mm LED: Yellow

Arduino UNO

High Brightness LED, White

Capacitor 220 µF

Resistor 330 ohm

Resistor 221 ohm

1N4007 – High Voltage, High Current Rated Diode

Jumper wires (generic)

LDR, 1 Mohm

Analog Panel Meter, Black Spade Type Pointer

Breadboard (generic)

5 mm LED: Red

Project description

Code

Wall_Meter_Display.ino

arduino

Runs a basic light display and is intended to run with very low power consumption for battery operation

1#include <Narcoleptic.h>
2
3/*
4  WallDisplay - Traffic light
5   Creates a basic traffic light display for a wallmount
6*/
7int voltref = 0;     // hold reference voltage level for low voltage calculations
8int demoCount   = 0;   // used to run the demo section when first powered up
9int Direction =   1;   // sets direction either 0 or 1
10int SetDelay = 1; //0=standard delay, 1=NarcoDelay,   low power and no serial port usage
11unsigned long randInit = 20;  // limits of   random number generator, set low for testing
12int LDR;          // voltage measured   on LDR
13int darkLimit = 1000;  // ldr reading for its dark
14int lightLimit =   750;  // ldr reading for its light
15int timeOfDay = 1;  // time of day set to   gloaming so that power on and reset runs full display  0 = night, 1 = gloaming,   2=day
16int lightChange = 0;  // count of contiguous light LDR samples
17int gloamingChange   = 0;   // count of contiguous gloaming LDR samples
18int darkChange = 0;   // count   of contiguous dark LDR samples
19int randLimit = 20;  // limits of random number   generator, set low for testing
20int delayPeriod = 4000; //inital delay period   just in case its needed
21int summer = 14970;  // length of longest day in samples
22int   winter = 7035;  // length of shortest day in samples
23int longDayCount = 0;  //   approximate length of day in displays
24int shortDayCount = 0;  // approximate   length of day in displays
25int maxDay = 0;  // previous length of light in display   cycles
26int delayDayCount = 21; // number of display cycles to defer in the morning   based on previous days estimated length
27int capacitor=2 // pin applying power   to capacitor
28int LDRpower=3 // pin applying power to ldr
29int red1=5;   //   1st red led
30int red2=6;   // 2nd red led
31int amber1=7;   // 1st amber led
32int   amber2=8;   // 2nd amber led
33int green1=9;   // 1st green led
34int green2=10;    // 2nd green led
35int whiteled=11; // white led to illuminate meter
36
37
38
39//   ---------------------------------------------------------------------------------------     
40// the setup function runs once when reset it pressed or power the board
41void   setup() {
42  // initialize digital output pins
43  //   pin A1
44  //   pin   A2
45  //   pin A3
46  pinMode(capacitor, OUTPUT);
47  pinMode(LDRpower, OUTPUT);
48   pinMode(red1, OUTPUT);
49  pinMode(red2, OUTPUT);
50  pinMode(amber1, OUTPUT);
51   pinMode(amber2, OUTPUT);
52  pinMode(green1, OUTPUT);
53  pinMode(green2, OUTPUT);
54   pinMode(whiteled, OUTPUT);
55
56  longDayCount = (summer - winter) / randLimit;
57   shortDayCount = winter / randLimit;
58 
59  
60
61  randInit = LDRvoltage();
62   randomSeed(randInit);          // randomise on light level
63  if (SetDelay ==   0)     // only run serial output if standard not narco delay
64      Serial.begin(9600);
65}
66
67
68
69
70//   ---------------------------------------------------------------------------------------     
71// the loop function runs over and over again forever
72void loop() {
73int   newTimeOfDay;
74// only run routine if random comes up otherwise sleep
75   
76      
77    randInit = random(randLimit);
78    SerialSub(SetDelay, "Random ",   randInit);
79// ---------------------------------------------------------------------------------------     
80    
81    if (delayDayCount < 20)   //  count down non running of display   after dawn when no one will be watching
82         {
83          delayDayCount++;
84           randInit=0;    // extend non running after dawn
85          SerialSub(SetDelay,   "Delay ", demoCount);
86         }
87// ---------------------------------------------------------------------------------------       
88    if (demoCount < 10)   //  demo and test routine runs every time after   power on or reset
89         {
90          demoCount++;
91          randInit=1;     // fudge for test functions
92          SerialSub(SetDelay, "Demo ", demoCount);
93          }
94// ---------------------------------------------------------------------------------------    
95    if (randInit == 1) 
96      {
97        voltref = refVoltage();    //   get the reference voltage
98        LDR = LDRvoltage();   // get light level
99         newTimeOfDay = dayOrNight();
100        if (timeOfDay != newTimeOfDay)
101             timeOfDay = newTimeOfDay;   // swap to new time of day if theres an   update
102        SerialSub(SetDelay, "timeOfDay", timeOfDay);    
103        if   (timeOfDay == 0)    // if night then just wait for 4 or 8 seconds
104            {
105              if (SetDelay == 0)
106                 delayPeriod = 4000;   // if   standard sleep then fixed to 4 seconds
107             else
108                 delayPeriod   = 8000;  // if narco then sleep extra time
109             }
110        else
111             {    
112            Subloop();    // This breakout runs the display
113             delayPeriod = 4000;
114            }
115      }  
116    Ndelay(SetDelay,   delayPeriod); //  Delay for 'delayPeriod' seconds approximately
117}
118
119// ---------------------------------------------------------------------------------------   
120int LDRvoltage() {
121    digitalWrite(LDRpower, HIGH);     // activate LDR   to check light levels
122    int LDRread = analogRead(2);
123    digitalWrite(LDRpower,   LOW);
124    SerialSub(SetDelay, "LDRvoltage", LDRread);
125    return LDRread;
126}
127
128
129//   ---------------------------------------------------------------------------------------   
130// Estimate whether it is day, gloaming or night. The unit has to be in one   state for at least four iterations before a state change is registered
131// the   sequence is light, gloaming, dark, light. 
132int dayOrNight() {
133  int dayLight;
134   dayLight = timeOfDay;
135  if (lightChange > maxDay)
136      maxDay = lightChange;
137   if (LDR > darkLimit)   // calulate continuous state
138      {
139      lightChange   = 0;
140      gloamingChange = 0;
141      darkChange++;
142      }   
143    else   if (LDR < lightLimit) 
144      {
145      lightChange++;
146      gloamingChange   = 0;
147      darkChange = 0;
148      }  
149    else 
150      {
151      lightChange   = 0;
152      gloamingChange++;
153      darkChange = 0;
154      }  
155  if (lightChange   >10)   // after state the same for four iterations return a change
156       dayLight   = 2;
157       else if (gloamingChange > 10)
158                dayLight = 1;
159        else if (darkChange > 10)
160                dayLight = 0;
161  if (timeOfDay   == 0 and dayLight==1) // do not allow change from dark to gloaming
162      dayLight   = 0;        
163  SerialSub(SetDelay, "DayOrNight", dayLight);
164  return dayLight;         
165}
166
167
168// ---------------------------------------------------------------------------------------   
169// get reference voltage for low battery compensation
170int refVoltage()   {
171    digitalWrite(red1, HIGH);
172    int readVoltage = analogRead(3);
173    digitalWrite(red2,   LOW);
174    SerialSub(SetDelay, "voltref", readVoltage);
175    return readVoltage;
176}
177
178
179//   ---------------------------------------------------------------------------------------   
180// Return capacitor voltage
181int capVoltage() {
182    int readVoltage =   analogRead(1);
183 //   SerialSub(SetDelay, "CapVoltage", readVoltage);
184    return   readVoltage;
185}
186
187
188// ---------------------------------------------------------------------------------------   
189// routine to charge capacitor 
190void chargeCap() {
191  if (timeOfDay ==   1)
192      digitalWrite(whiteled, HIGH);     // activate meter illumination
193      Ndelay(SetDelay, 300); // wait for 300 milliseconds to attract attention    
194   do {
195   digitalWrite(capacitor, HIGH);  // start to charge capacitor
196   Ndelay(SetDelay,   100); // wait for 100 milliseconds for capacitor to charge
197  } while (capVoltage()<800);
198   Ndelay(SetDelay, 200); // wait for 200 milliseconds for capacitor to display
199    digitalWrite(capacitor, LOW);  // stop charging  
200}
201
202
203// ---------------------------------------------------------------------------------------   
204// routine to reverse directiion setting
205void reverseDirection() {
206     if (Direction == 1)    // reverse previous light direction
207  {
208    Direction   = 2;
209  }
210  else
211  {
212    Direction = 1;
213  }
214}
215// ---------------------------------------------------------------------------------------   
216// Main display loop
217void Subloop() {
218
219// Start by charging capacitor
220chargeCap();
221
222//   Reverse previous direction to keep variations
223  reverseDirection();
224
225//   run light display until capacitor runs down
226// routine only runs LEDs if gloaming   when viewers are likely to see it
227  do {     
228      if (Direction == 1 and   timeOfDay == 1)
229      {
230        Traffic1();    // run forward light run
231       }
232      if (Direction == 2 and timeOfDay == 1)
233      {
234        Traffic2();     // run reverse light run
235      }
236      if (timeOfDay == 2)
237          Ndelay(SetDelay,   1000); //add time delay omitted due to not running lights
238      if (random(20)   == 1) // Add restart to cap voltage to give random extended displays
239          {   
240          chargeCap();
241          reverseDirection();
242          }
243  }   while (capVoltage() > 50);
244      
245      digitalWritewhiteled, LOW);      //   turn off meter illumination when done
246}
247
248
249// ---------------------------------------------------------------------------------------   
250// One of two LED driver routines which switch on LEDs according to the voltage   on the capacitor
251void Traffic1()
252{
253  int light = capVoltage();
254
255
256   if (light > 60)
257  {
258    digitalWrite(red1, HIGH);   // Turn on red
259    Ndelay(SetDelay,   100); // wait for 100 milliseconds
260  }
261  if (light > 80)
262  {
263    digitalWrite(red2,   HIGH);   // turn on red
264    Ndelay(SetDelay, 100); // wait for 100 milliseconds
265   }
266  if (light > 120)
267  {
268    digitalWrite(amber1, HIGH); // Turn on anber
269     Ndelay(SetDelay, 100); // wait for 100 milliseconds
270  }
271  if (light >   200)
272  {
273    digitalWrite(amber2, HIGH);   // Turn on amber
274    Ndelay(SetDelay,   100); // wait for 100 milliseconds
275  }
276  if (light > 320)
277  {
278    digitalWrite(green1,   HIGH);   // turn on green
279    Ndelay(SetDelay, 100); // wait for 100 milliseconds
280   }
281  if (light > 580)
282  {
283    digitalWrite(green2, HIGH); // Turn on green
284     Ndelay(SetDelay, 100); // wait for 100 milliseconds
285  }
286  digitalWrite(red1,   LOW);
287  Ndelay(SetDelay, 100);
288  digitalWrite(red2, LOW);
289  Ndelay(SetDelay,   100);
290  digitalWrite(amber1, LOW);
291  Ndelay(SetDelay, 100);
292  digitalWrite(amber2,   LOW);
293  Ndelay(SetDelay, 100);;
294  digitalWrite(green1, LOW);
295  Ndelay(SetDelay,   100);
296  digitalWrite(green2, LOW);
297
298}
299
300
301// ---------------------------------------------------------------------------------------   
302// One of two LED driver routines which switch on LEDs according to the voltage   on the capacitor
303// This one works in the opposite direction to the first
304void   Traffic2()
305{
306  int light = capVoltage();
307
308
309  if (light > 60)
310   {
311    digitalWrite(10, HIGH);   // Turn on green
312    Ndelay(SetDelay, 100);   // wait for 100 milliseconds
313  }
314  if (light > 80)
315  {
316    digitalWrite(9,   HIGH);   // turn on green
317    Ndelay(SetDelay, 100); // wait for 100 milliseconds
318   }
319  if (light > 120)
320  {
321    digitalWrite(8, HIGH); // Turn on amber
322     Ndelay(SetDelay, 100);; // wait for 100 milliseconds
323  }
324  if (light >   200)
325  {
326    digitalWrite(7, HIGH);   // Turn on amber
327    Ndelay(SetDelay,   100); // wait for 100 milliseconds
328  }
329  if (light > 320)
330  {
331    digitalWrite(6,   HIGH);   // turn on red
332    Ndelay(SetDelay, 100); // wait for 100 milliseconds
333   }
334  if (light > 580)
335  {
336    digitalWrite(5, HIGH); // Turn on red
337     Ndelay(SetDelay, 100); // wait for 100 milliseconds
338  }
339  digitalWrite(10,   LOW);
340  Ndelay(SetDelay, 100);
341  digitalWrite(9, LOW);
342  Ndelay(SetDelay,   100);
343  digitalWrite(8, LOW);
344  Ndelay(SetDelay, 100);
345  digitalWrite(7,   LOW);
346  Ndelay(SetDelay, 100);
347  digitalWrite(6, LOW);
348  Ndelay(SetDelay,   100);
349  digitalWrite(5, LOW);
350
351}
352
353
354// ---------------------------------------------------------------------------------------   
355// General delay routine which can switch between barco delay and standard   for testing
356void Ndelay(int delaytype, int period)
357{
358  if (delaytype ==   0)
359  {
360    delay(period);
361  }
362  else
363  {
364    Narcoleptic.delay(period);
365   }
366}
367
368
369// ---------------------------------------------------------------------------------------   
370// Serial output routine runs during testing
371void SerialSub(int delaytype,   char stringy[20], int value)
372{
373  if (delaytype == 0)
374  {
375    Serial.print(stringy);
376     Serial.println(value);
377  }
378 
379}
380

#include <Narcoleptic.h>

/*
  WallDisplay - Traffic light
   Creates a basic traffic light display for a wallmount
*/
int voltref = 0;     // hold reference voltage level for low voltage calculations
int demoCount   = 0;   // used to run the demo section when first powered up
int Direction =   1;   // sets direction either 0 or 1
int SetDelay = 1; //0=standard delay, 1=NarcoDelay,   low power and no serial port usage
unsigned long randInit = 20;  // limits of   random number generator, set low for testing
int LDR;          // voltage measured   on LDR
int darkLimit = 1000;  // ldr reading for its dark
int lightLimit =   750;  // ldr reading for its light
int timeOfDay = 1;  // time of day set to   gloaming so that power on and reset runs full display  0 = night, 1 = gloaming,   2=day
int lightChange = 0;  // count of contiguous light LDR samples
int gloamingChange   = 0;   // count of contiguous gloaming LDR samples
int darkChange = 0;   // count   of contiguous dark LDR samples
int randLimit = 20;  // limits of random number   generator, set low for testing
int delayPeriod = 4000; //inital delay period   just in case its needed
int summer = 14970;  // length of longest day in samples
int   winter = 7035;  // length of shortest day in samples
int longDayCount = 0;  //   approximate length of day in displays
int shortDayCount = 0;  // approximate   length of day in displays
int maxDay = 0;  // previous length of light in display   cycles
int delayDayCount = 21; // number of display cycles to defer in the morning   based on previous days estimated length
int capacitor=2 // pin applying power   to capacitor
int LDRpower=3 // pin applying power to ldr
int red1=5;   //   1st red led
int red2=6;   // 2nd red led
int amber1=7;   // 1st amber led
int   amber2=8;   // 2nd amber led
int green1=9;   // 1st green led
int green2=10;    // 2nd green led
int whiteled=11; // white led to illuminate meter



//   ---------------------------------------------------------------------------------------     
// the setup function runs once when reset it pressed or power the board
void   setup() {
  // initialize digital output pins
  //   pin A1
  //   pin   A2
  //   pin A3
  pinMode(capacitor, OUTPUT);
  pinMode(LDRpower, OUTPUT);
   pinMode(red1, OUTPUT);
  pinMode(red2, OUTPUT);
  pinMode(amber1, OUTPUT);
   pinMode(amber2, OUTPUT);
  pinMode(green1, OUTPUT);
  pinMode(green2, OUTPUT);
   pinMode(whiteled, OUTPUT);

  longDayCount = (summer - winter) / randLimit;
   shortDayCount = winter / randLimit;
 
  

  randInit = LDRvoltage();
   randomSeed(randInit);          // randomise on light level
  if (SetDelay ==   0)     // only run serial output if standard not narco delay
      Serial.begin(9600);
}




//   ---------------------------------------------------------------------------------------     
// the loop function runs over and over again forever
void loop() {
int   newTimeOfDay;
// only run routine if random comes up otherwise sleep
   
      
    randInit = random(randLimit);
    SerialSub(SetDelay, "Random ",   randInit);
// ---------------------------------------------------------------------------------------     
    
    if (delayDayCount < 20)   //  count down non running of display   after dawn when no one will be watching
         {
          delayDayCount++;
           randInit=0;    // extend non running after dawn
          SerialSub(SetDelay,   "Delay ", demoCount);
         }
// ---------------------------------------------------------------------------------------       
    if (demoCount < 10)   //  demo and test routine runs every time after   power on or reset
         {
          demoCount++;
          randInit=1;     // fudge for test functions
          SerialSub(SetDelay, "Demo ", demoCount);
          }
// ---------------------------------------------------------------------------------------    
    if (randInit == 1) 
      {
        voltref = refVoltage();    //   get the reference voltage
        LDR = LDRvoltage();   // get light level
         newTimeOfDay = dayOrNight();
        if (timeOfDay != newTimeOfDay)
             timeOfDay = newTimeOfDay;   // swap to new time of day if theres an   update
        SerialSub(SetDelay, "timeOfDay", timeOfDay);    
        if   (timeOfDay == 0)    // if night then just wait for 4 or 8 seconds
            {
              if (SetDelay == 0)
                 delayPeriod = 4000;   // if   standard sleep then fixed to 4 seconds
             else
                 delayPeriod   = 8000;  // if narco then sleep extra time
             }
        else
             {    
            Subloop();    // This breakout runs the display
             delayPeriod = 4000;
            }
      }  
    Ndelay(SetDelay,   delayPeriod); //  Delay for 'delayPeriod' seconds approximately
}

// ---------------------------------------------------------------------------------------   
int LDRvoltage() {
    digitalWrite(LDRpower, HIGH);     // activate LDR   to check light levels
    int LDRread = analogRead(2);
    digitalWrite(LDRpower,   LOW);
    SerialSub(SetDelay, "LDRvoltage", LDRread);
    return LDRread;
}


//   ---------------------------------------------------------------------------------------   
// Estimate whether it is day, gloaming or night. The unit has to be in one   state for at least four iterations before a state change is registered
// the   sequence is light, gloaming, dark, light. 
int dayOrNight() {
  int dayLight;
   dayLight = timeOfDay;
  if (lightChange > maxDay)
      maxDay = lightChange;
   if (LDR > darkLimit)   // calulate continuous state
      {
      lightChange   = 0;
      gloamingChange = 0;
      darkChange++;
      }   
    else   if (LDR < lightLimit) 
      {
      lightChange++;
      gloamingChange   = 0;
      darkChange = 0;
      }  
    else 
      {
      lightChange   = 0;
      gloamingChange++;
      darkChange = 0;
      }  
  if (lightChange   >10)   // after state the same for four iterations return a change
       dayLight   = 2;
       else if (gloamingChange > 10)
                dayLight = 1;
        else if (darkChange > 10)
                dayLight = 0;
  if (timeOfDay   == 0 and dayLight==1) // do not allow change from dark to gloaming
      dayLight   = 0;        
  SerialSub(SetDelay, "DayOrNight", dayLight);
  return dayLight;         
}


// ---------------------------------------------------------------------------------------   
// get reference voltage for low battery compensation
int refVoltage()   {
    digitalWrite(red1, HIGH);
    int readVoltage = analogRead(3);
    digitalWrite(red2,   LOW);
    SerialSub(SetDelay, "voltref", readVoltage);
    return readVoltage;
}


//   ---------------------------------------------------------------------------------------   
// Return capacitor voltage
int capVoltage() {
    int readVoltage =   analogRead(1);
 //   SerialSub(SetDelay, "CapVoltage", readVoltage);
    return   readVoltage;
}


// ---------------------------------------------------------------------------------------   
// routine to charge capacitor 
void chargeCap() {
  if (timeOfDay ==   1)
      digitalWrite(whiteled, HIGH);     // activate meter illumination
      Ndelay(SetDelay, 300); // wait for 300 milliseconds to attract attention    
   do {
   digitalWrite(capacitor, HIGH);  // start to charge capacitor
   Ndelay(SetDelay,   100); // wait for 100 milliseconds for capacitor to charge
  } while (capVoltage()<800);
   Ndelay(SetDelay, 200); // wait for 200 milliseconds for capacitor to display
    digitalWrite(capacitor, LOW);  // stop charging  
}


// ---------------------------------------------------------------------------------------   
// routine to reverse directiion setting
void reverseDirection() {
     if (Direction == 1)    // reverse previous light direction
  {
    Direction   = 2;
  }
  else
  {
    Direction = 1;
  }
}
// ---------------------------------------------------------------------------------------   
// Main display loop
void Subloop() {

// Start by charging capacitor
chargeCap();

//   Reverse previous direction to keep variations
  reverseDirection();

//   run light display until capacitor runs down
// routine only runs LEDs if gloaming   when viewers are likely to see it
  do {     
      if (Direction == 1 and   timeOfDay == 1)
      {
        Traffic1();    // run forward light run
       }
      if (Direction == 2 and timeOfDay == 1)
      {
        Traffic2();     // run reverse light run
      }
      if (timeOfDay == 2)
          Ndelay(SetDelay,   1000); //add time delay omitted due to not running lights
      if (random(20)   == 1) // Add restart to cap voltage to give random extended displays
          {   
          chargeCap();
          reverseDirection();
          }
  }   while (capVoltage() > 50);
      
      digitalWritewhiteled, LOW);      //   turn off meter illumination when done
}


// ---------------------------------------------------------------------------------------   
// One of two LED driver routines which switch on LEDs according to the voltage   on the capacitor
void Traffic1()
{
  int light = capVoltage();


   if (light > 60)
  {
    digitalWrite(red1, HIGH);   // Turn on red
    Ndelay(SetDelay,   100); // wait for 100 milliseconds
  }
  if (light > 80)
  {
    digitalWrite(red2,   HIGH);   // turn on red
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
   }
  if (light > 120)
  {
    digitalWrite(amber1, HIGH); // Turn on anber
     Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  if (light >   200)
  {
    digitalWrite(amber2, HIGH);   // Turn on amber
    Ndelay(SetDelay,   100); // wait for 100 milliseconds
  }
  if (light > 320)
  {
    digitalWrite(green1,   HIGH);   // turn on green
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
   }
  if (light > 580)
  {
    digitalWrite(green2, HIGH); // Turn on green
     Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  digitalWrite(red1,   LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(red2, LOW);
  Ndelay(SetDelay,   100);
  digitalWrite(amber1, LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(amber2,   LOW);
  Ndelay(SetDelay, 100);;
  digitalWrite(green1, LOW);
  Ndelay(SetDelay,   100);
  digitalWrite(green2, LOW);

}


// ---------------------------------------------------------------------------------------   
// One of two LED driver routines which switch on LEDs according to the voltage   on the capacitor
// This one works in the opposite direction to the first
void   Traffic2()
{
  int light = capVoltage();


  if (light > 60)
   {
    digitalWrite(10, HIGH);   // Turn on green
    Ndelay(SetDelay, 100);   // wait for 100 milliseconds
  }
  if (light > 80)
  {
    digitalWrite(9,   HIGH);   // turn on green
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
   }
  if (light > 120)
  {
    digitalWrite(8, HIGH); // Turn on amber
     Ndelay(SetDelay, 100);; // wait for 100 milliseconds
  }
  if (light >   200)
  {
    digitalWrite(7, HIGH);   // Turn on amber
    Ndelay(SetDelay,   100); // wait for 100 milliseconds
  }
  if (light > 320)
  {
    digitalWrite(6,   HIGH);   // turn on red
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
   }
  if (light > 580)
  {
    digitalWrite(5, HIGH); // Turn on red
     Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  digitalWrite(10,   LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(9, LOW);
  Ndelay(SetDelay,   100);
  digitalWrite(8, LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(7,   LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(6, LOW);
  Ndelay(SetDelay,   100);
  digitalWrite(5, LOW);

}


// ---------------------------------------------------------------------------------------   
// General delay routine which can switch between barco delay and standard   for testing
void Ndelay(int delaytype, int period)
{
  if (delaytype ==   0)
  {
    delay(period);
  }
  else
  {
    Narcoleptic.delay(period);
   }
}


// ---------------------------------------------------------------------------------------   
// Serial output routine runs during testing
void SerialSub(int delaytype,   char stringy[20], int value)
{
  if (delaytype == 0)
  {
    Serial.print(stringy);
     Serial.println(value);
  }
 
}

Wall_Meter_Display.ino

arduino

Runs a basic light display and is intended to run with very low power consumption for battery operation

1#include <Narcoleptic.h>
2
3/*
4  WallDisplay - Traffic light
5  Creates a basic traffic light display for a wallmount
6*/
7int voltref = 0;    // hold reference voltage level for low voltage calculations
8int demoCount  = 0;   // used to run the demo section when first powered up
9int Direction =  1;   // sets direction either 0 or 1
10int SetDelay = 1; //0=standard delay, 1=NarcoDelay,  low power and no serial port usage
11unsigned long randInit = 20;  // limits of  random number generator, set low for testing
12int LDR;          // voltage measured  on LDR
13int darkLimit = 1000;  // ldr reading for its dark
14int lightLimit =  750;  // ldr reading for its light
15int timeOfDay = 1;  // time of day set to  gloaming so that power on and reset runs full display  0 = night, 1 = gloaming,  2=day
16int lightChange = 0;  // count of contiguous light LDR samples
17int gloamingChange  = 0;   // count of contiguous gloaming LDR samples
18int darkChange = 0;   // count  of contiguous dark LDR samples
19int randLimit = 20;  // limits of random number  generator, set low for testing
20int delayPeriod = 4000; //inital delay period  just in case its needed
21int summer = 14970;  // length of longest day in samples
22int  winter = 7035;  // length of shortest day in samples
23int longDayCount = 0;  //  approximate length of day in displays
24int shortDayCount = 0;  // approximate  length of day in displays
25int maxDay = 0;  // previous length of light in display  cycles
26int delayDayCount = 21; // number of display cycles to defer in the morning  based on previous days estimated length
27int capacitor=2 // pin applying power  to capacitor
28int LDRpower=3 // pin applying power to ldr
29int red1=5;   //  1st red led
30int red2=6;   // 2nd red led
31int amber1=7;   // 1st amber led
32int  amber2=8;   // 2nd amber led
33int green1=9;   // 1st green led
34int green2=10;   // 2nd green led
35int whiteled=11; // white led to illuminate meter
36
37
38
39//  ---------------------------------------------------------------------------------------    
40// the setup function runs once when reset it pressed or power the board
41void  setup() {
42  // initialize digital output pins
43  //   pin A1
44  //   pin  A2
45  //   pin A3
46  pinMode(capacitor, OUTPUT);
47  pinMode(LDRpower, OUTPUT);
48  pinMode(red1, OUTPUT);
49  pinMode(red2, OUTPUT);
50  pinMode(amber1, OUTPUT);
51  pinMode(amber2, OUTPUT);
52  pinMode(green1, OUTPUT);
53  pinMode(green2, OUTPUT);
54  pinMode(whiteled, OUTPUT);
55
56  longDayCount = (summer - winter) / randLimit;
57  shortDayCount = winter / randLimit;
58 
59  
60
61  randInit = LDRvoltage();
62  randomSeed(randInit);          // randomise on light level
63  if (SetDelay ==  0)     // only run serial output if standard not narco delay
64      Serial.begin(9600);
65}
66
67
68
69
70//  ---------------------------------------------------------------------------------------    
71// the loop function runs over and over again forever
72void loop() {
73int  newTimeOfDay;
74// only run routine if random comes up otherwise sleep
75   
76     
77    randInit = random(randLimit);
78    SerialSub(SetDelay, "Random ",  randInit);
79// ---------------------------------------------------------------------------------------    
80    
81    if (delayDayCount < 20)   //  count down non running of display  after dawn when no one will be watching
82         {
83          delayDayCount++;
84          randInit=0;    // extend non running after dawn
85          SerialSub(SetDelay,  "Delay ", demoCount);
86         }
87// ---------------------------------------------------------------------------------------      
88    if (demoCount < 10)   //  demo and test routine runs every time after  power on or reset
89         {
90          demoCount++;
91          randInit=1;    // fudge for test functions
92          SerialSub(SetDelay, "Demo ", demoCount);
93         }
94// ---------------------------------------------------------------------------------------   
95    if (randInit == 1) 
96      {
97        voltref = refVoltage();    //  get the reference voltage
98        LDR = LDRvoltage();   // get light level
99        newTimeOfDay = dayOrNight();
100        if (timeOfDay != newTimeOfDay)
101            timeOfDay = newTimeOfDay;   // swap to new time of day if theres an  update
102        SerialSub(SetDelay, "timeOfDay", timeOfDay);    
103        if  (timeOfDay == 0)    // if night then just wait for 4 or 8 seconds
104            {
105             if (SetDelay == 0)
106                 delayPeriod = 4000;   // if  standard sleep then fixed to 4 seconds
107             else
108                 delayPeriod  = 8000;  // if narco then sleep extra time
109             }
110        else
111            {    
112            Subloop();    // This breakout runs the display
113            delayPeriod = 4000;
114            }
115      }  
116    Ndelay(SetDelay,  delayPeriod); //  Delay for 'delayPeriod' seconds approximately
117}
118
119// ---------------------------------------------------------------------------------------  
120int LDRvoltage() {
121    digitalWrite(LDRpower, HIGH);     // activate LDR  to check light levels
122    int LDRread = analogRead(2);
123    digitalWrite(LDRpower,  LOW);
124    SerialSub(SetDelay, "LDRvoltage", LDRread);
125    return LDRread;
126}
127
128
129//  ---------------------------------------------------------------------------------------  
130// Estimate whether it is day, gloaming or night. The unit has to be in one  state for at least four iterations before a state change is registered
131// the  sequence is light, gloaming, dark, light. 
132int dayOrNight() {
133  int dayLight;
134  dayLight = timeOfDay;
135  if (lightChange > maxDay)
136      maxDay = lightChange;
137  if (LDR > darkLimit)   // calulate continuous state
138      {
139      lightChange  = 0;
140      gloamingChange = 0;
141      darkChange++;
142      }   
143    else  if (LDR < lightLimit) 
144      {
145      lightChange++;
146      gloamingChange  = 0;
147      darkChange = 0;
148      }  
149    else 
150      {
151      lightChange  = 0;
152      gloamingChange++;
153      darkChange = 0;
154      }  
155  if (lightChange  >10)   // after state the same for four iterations return a change
156       dayLight  = 2;
157       else if (gloamingChange > 10)
158                dayLight = 1;
159       else if (darkChange > 10)
160                dayLight = 0;
161  if (timeOfDay  == 0 and dayLight==1) // do not allow change from dark to gloaming
162      dayLight  = 0;        
163  SerialSub(SetDelay, "DayOrNight", dayLight);
164  return dayLight;        
165}
166
167
168// ---------------------------------------------------------------------------------------  
169// get reference voltage for low battery compensation
170int refVoltage()  {
171    digitalWrite(red1, HIGH);
172    int readVoltage = analogRead(3);
173    digitalWrite(red2,  LOW);
174    SerialSub(SetDelay, "voltref", readVoltage);
175    return readVoltage;
176}
177
178
179//  ---------------------------------------------------------------------------------------  
180// Return capacitor voltage
181int capVoltage() {
182    int readVoltage =  analogRead(1);
183 //   SerialSub(SetDelay, "CapVoltage", readVoltage);
184    return  readVoltage;
185}
186
187
188// ---------------------------------------------------------------------------------------  
189// routine to charge capacitor 
190void chargeCap() {
191  if (timeOfDay ==  1)
192      digitalWrite(whiteled, HIGH);     // activate meter illumination
193     Ndelay(SetDelay, 300); // wait for 300 milliseconds to attract attention    
194  do {
195   digitalWrite(capacitor, HIGH);  // start to charge capacitor
196   Ndelay(SetDelay,  100); // wait for 100 milliseconds for capacitor to charge
197  } while (capVoltage()<800);
198  Ndelay(SetDelay, 200); // wait for 200 milliseconds for capacitor to display
199   digitalWrite(capacitor, LOW);  // stop charging  
200}
201
202
203// ---------------------------------------------------------------------------------------  
204// routine to reverse directiion setting
205void reverseDirection() {
206    if (Direction == 1)    // reverse previous light direction
207  {
208    Direction  = 2;
209  }
210  else
211  {
212    Direction = 1;
213  }
214}
215// ---------------------------------------------------------------------------------------  
216// Main display loop
217void Subloop() {
218
219// Start by charging capacitor
220chargeCap();
221
222//  Reverse previous direction to keep variations
223  reverseDirection();
224
225//  run light display until capacitor runs down
226// routine only runs LEDs if gloaming  when viewers are likely to see it
227  do {     
228      if (Direction == 1 and  timeOfDay == 1)
229      {
230        Traffic1();    // run forward light run
231      }
232      if (Direction == 2 and timeOfDay == 1)
233      {
234        Traffic2();    // run reverse light run
235      }
236      if (timeOfDay == 2)
237          Ndelay(SetDelay,  1000); //add time delay omitted due to not running lights
238      if (random(20)  == 1) // Add restart to cap voltage to give random extended displays
239          {  
240          chargeCap();
241          reverseDirection();
242          }
243  }  while (capVoltage() > 50);
244      
245      digitalWritewhiteled, LOW);      //  turn off meter illumination when done
246}
247
248
249// ---------------------------------------------------------------------------------------  
250// One of two LED driver routines which switch on LEDs according to the voltage  on the capacitor
251void Traffic1()
252{
253  int light = capVoltage();
254
255
256  if (light > 60)
257  {
258    digitalWrite(red1, HIGH);   // Turn on red
259    Ndelay(SetDelay,  100); // wait for 100 milliseconds
260  }
261  if (light > 80)
262  {
263    digitalWrite(red2,  HIGH);   // turn on red
264    Ndelay(SetDelay, 100); // wait for 100 milliseconds
265  }
266  if (light > 120)
267  {
268    digitalWrite(amber1, HIGH); // Turn on anber
269    Ndelay(SetDelay, 100); // wait for 100 milliseconds
270  }
271  if (light >  200)
272  {
273    digitalWrite(amber2, HIGH);   // Turn on amber
274    Ndelay(SetDelay,  100); // wait for 100 milliseconds
275  }
276  if (light > 320)
277  {
278    digitalWrite(green1,  HIGH);   // turn on green
279    Ndelay(SetDelay, 100); // wait for 100 milliseconds
280  }
281  if (light > 580)
282  {
283    digitalWrite(green2, HIGH); // Turn on green
284    Ndelay(SetDelay, 100); // wait for 100 milliseconds
285  }
286  digitalWrite(red1,  LOW);
287  Ndelay(SetDelay, 100);
288  digitalWrite(red2, LOW);
289  Ndelay(SetDelay,  100);
290  digitalWrite(amber1, LOW);
291  Ndelay(SetDelay, 100);
292  digitalWrite(amber2,  LOW);
293  Ndelay(SetDelay, 100);;
294  digitalWrite(green1, LOW);
295  Ndelay(SetDelay,  100);
296  digitalWrite(green2, LOW);
297
298}
299
300
301// ---------------------------------------------------------------------------------------  
302// One of two LED driver routines which switch on LEDs according to the voltage  on the capacitor
303// This one works in the opposite direction to the first
304void  Traffic2()
305{
306  int light = capVoltage();
307
308
309  if (light > 60)
310  {
311    digitalWrite(10, HIGH);   // Turn on green
312    Ndelay(SetDelay, 100);  // wait for 100 milliseconds
313  }
314  if (light > 80)
315  {
316    digitalWrite(9,  HIGH);   // turn on green
317    Ndelay(SetDelay, 100); // wait for 100 milliseconds
318  }
319  if (light > 120)
320  {
321    digitalWrite(8, HIGH); // Turn on amber
322    Ndelay(SetDelay, 100);; // wait for 100 milliseconds
323  }
324  if (light >  200)
325  {
326    digitalWrite(7, HIGH);   // Turn on amber
327    Ndelay(SetDelay,  100); // wait for 100 milliseconds
328  }
329  if (light > 320)
330  {
331    digitalWrite(6,  HIGH);   // turn on red
332    Ndelay(SetDelay, 100); // wait for 100 milliseconds
333  }
334  if (light > 580)
335  {
336    digitalWrite(5, HIGH); // Turn on red
337    Ndelay(SetDelay, 100); // wait for 100 milliseconds
338  }
339  digitalWrite(10,  LOW);
340  Ndelay(SetDelay, 100);
341  digitalWrite(9, LOW);
342  Ndelay(SetDelay,  100);
343  digitalWrite(8, LOW);
344  Ndelay(SetDelay, 100);
345  digitalWrite(7,  LOW);
346  Ndelay(SetDelay, 100);
347  digitalWrite(6, LOW);
348  Ndelay(SetDelay,  100);
349  digitalWrite(5, LOW);
350
351}
352
353
354// ---------------------------------------------------------------------------------------  
355// General delay routine which can switch between barco delay and standard  for testing
356void Ndelay(int delaytype, int period)
357{
358  if (delaytype ==  0)
359  {
360    delay(period);
361  }
362  else
363  {
364    Narcoleptic.delay(period);
365  }
366}
367
368
369// ---------------------------------------------------------------------------------------  
370// Serial output routine runs during testing
371void SerialSub(int delaytype,  char stringy[20], int value)
372{
373  if (delaytype == 0)
374  {
375    Serial.print(stringy);
376    Serial.println(value);
377  }
378 
379}
380

#include <Narcoleptic.h>

/*
  WallDisplay - Traffic light
  Creates a basic traffic light display for a wallmount
*/
int voltref = 0;    // hold reference voltage level for low voltage calculations
int demoCount  = 0;   // used to run the demo section when first powered up
int Direction =  1;   // sets direction either 0 or 1
int SetDelay = 1; //0=standard delay, 1=NarcoDelay,  low power and no serial port usage
unsigned long randInit = 20;  // limits of  random number generator, set low for testing
int LDR;          // voltage measured  on LDR
int darkLimit = 1000;  // ldr reading for its dark
int lightLimit =  750;  // ldr reading for its light
int timeOfDay = 1;  // time of day set to  gloaming so that power on and reset runs full display  0 = night, 1 = gloaming,  2=day
int lightChange = 0;  // count of contiguous light LDR samples
int gloamingChange  = 0;   // count of contiguous gloaming LDR samples
int darkChange = 0;   // count  of contiguous dark LDR samples
int randLimit = 20;  // limits of random number  generator, set low for testing
int delayPeriod = 4000; //inital delay period  just in case its needed
int summer = 14970;  // length of longest day in samples
int  winter = 7035;  // length of shortest day in samples
int longDayCount = 0;  //  approximate length of day in displays
int shortDayCount = 0;  // approximate  length of day in displays
int maxDay = 0;  // previous length of light in display  cycles
int delayDayCount = 21; // number of display cycles to defer in the morning  based on previous days estimated length
int capacitor=2 // pin applying power  to capacitor
int LDRpower=3 // pin applying power to ldr
int red1=5;   //  1st red led
int red2=6;   // 2nd red led
int amber1=7;   // 1st amber led
int  amber2=8;   // 2nd amber led
int green1=9;   // 1st green led
int green2=10;   // 2nd green led
int whiteled=11; // white led to illuminate meter



//  ---------------------------------------------------------------------------------------    
// the setup function runs once when reset it pressed or power the board
void  setup() {
  // initialize digital output pins
  //   pin A1
  //   pin  A2
  //   pin A3
  pinMode(capacitor, OUTPUT);
  pinMode(LDRpower, OUTPUT);
  pinMode(red1, OUTPUT);
  pinMode(red2, OUTPUT);
  pinMode(amber1, OUTPUT);
  pinMode(amber2, OUTPUT);
  pinMode(green1, OUTPUT);
  pinMode(green2, OUTPUT);
  pinMode(whiteled, OUTPUT);

  longDayCount = (summer - winter) / randLimit;
  shortDayCount = winter / randLimit;
 
  

  randInit = LDRvoltage();
  randomSeed(randInit);          // randomise on light level
  if (SetDelay ==  0)     // only run serial output if standard not narco delay
      Serial.begin(9600);
}




//  ---------------------------------------------------------------------------------------    
// the loop function runs over and over again forever
void loop() {
int  newTimeOfDay;
// only run routine if random comes up otherwise sleep
   
     
    randInit = random(randLimit);
    SerialSub(SetDelay, "Random ",  randInit);
// ---------------------------------------------------------------------------------------    
    
    if (delayDayCount < 20)   //  count down non running of display  after dawn when no one will be watching
         {
          delayDayCount++;
          randInit=0;    // extend non running after dawn
          SerialSub(SetDelay,  "Delay ", demoCount);
         }
// ---------------------------------------------------------------------------------------      
    if (demoCount < 10)   //  demo and test routine runs every time after  power on or reset
         {
          demoCount++;
          randInit=1;    // fudge for test functions
          SerialSub(SetDelay, "Demo ", demoCount);
         }
// ---------------------------------------------------------------------------------------   
    if (randInit == 1) 
      {
        voltref = refVoltage();    //  get the reference voltage
        LDR = LDRvoltage();   // get light level
        newTimeOfDay = dayOrNight();
        if (timeOfDay != newTimeOfDay)
            timeOfDay = newTimeOfDay;   // swap to new time of day if theres an  update
        SerialSub(SetDelay, "timeOfDay", timeOfDay);    
        if  (timeOfDay == 0)    // if night then just wait for 4 or 8 seconds
            {
             if (SetDelay == 0)
                 delayPeriod = 4000;   // if  standard sleep then fixed to 4 seconds
             else
                 delayPeriod  = 8000;  // if narco then sleep extra time
             }
        else
            {    
            Subloop();    // This breakout runs the display
            delayPeriod = 4000;
            }
      }  
    Ndelay(SetDelay,  delayPeriod); //  Delay for 'delayPeriod' seconds approximately
}

// ---------------------------------------------------------------------------------------  
int LDRvoltage() {
    digitalWrite(LDRpower, HIGH);     // activate LDR  to check light levels
    int LDRread = analogRead(2);
    digitalWrite(LDRpower,  LOW);
    SerialSub(SetDelay, "LDRvoltage", LDRread);
    return LDRread;
}


//  ---------------------------------------------------------------------------------------  
// Estimate whether it is day, gloaming or night. The unit has to be in one  state for at least four iterations before a state change is registered
// the  sequence is light, gloaming, dark, light. 
int dayOrNight() {
  int dayLight;
  dayLight = timeOfDay;
  if (lightChange > maxDay)
      maxDay = lightChange;
  if (LDR > darkLimit)   // calulate continuous state
      {
      lightChange  = 0;
      gloamingChange = 0;
      darkChange++;
      }   
    else  if (LDR < lightLimit) 
      {
      lightChange++;
      gloamingChange  = 0;
      darkChange = 0;
      }  
    else 
      {
      lightChange  = 0;
      gloamingChange++;
      darkChange = 0;
      }  
  if (lightChange  >10)   // after state the same for four iterations return a change
       dayLight  = 2;
       else if (gloamingChange > 10)
                dayLight = 1;
       else if (darkChange > 10)
                dayLight = 0;
  if (timeOfDay  == 0 and dayLight==1) // do not allow change from dark to gloaming
      dayLight  = 0;        
  SerialSub(SetDelay, "DayOrNight", dayLight);
  return dayLight;        
}


// ---------------------------------------------------------------------------------------  
// get reference voltage for low battery compensation
int refVoltage()  {
    digitalWrite(red1, HIGH);
    int readVoltage = analogRead(3);
    digitalWrite(red2,  LOW);
    SerialSub(SetDelay, "voltref", readVoltage);
    return readVoltage;
}


//  ---------------------------------------------------------------------------------------  
// Return capacitor voltage
int capVoltage() {
    int readVoltage =  analogRead(1);
 //   SerialSub(SetDelay, "CapVoltage", readVoltage);
    return  readVoltage;
}


// ---------------------------------------------------------------------------------------  
// routine to charge capacitor 
void chargeCap() {
  if (timeOfDay ==  1)
      digitalWrite(whiteled, HIGH);     // activate meter illumination
     Ndelay(SetDelay, 300); // wait for 300 milliseconds to attract attention    
  do {
   digitalWrite(capacitor, HIGH);  // start to charge capacitor
   Ndelay(SetDelay,  100); // wait for 100 milliseconds for capacitor to charge
  } while (capVoltage()<800);
  Ndelay(SetDelay, 200); // wait for 200 milliseconds for capacitor to display
   digitalWrite(capacitor, LOW);  // stop charging  
}


// ---------------------------------------------------------------------------------------  
// routine to reverse directiion setting
void reverseDirection() {
    if (Direction == 1)    // reverse previous light direction
  {
    Direction  = 2;
  }
  else
  {
    Direction = 1;
  }
}
// ---------------------------------------------------------------------------------------  
// Main display loop
void Subloop() {

// Start by charging capacitor
chargeCap();

//  Reverse previous direction to keep variations
  reverseDirection();

//  run light display until capacitor runs down
// routine only runs LEDs if gloaming  when viewers are likely to see it
  do {     
      if (Direction == 1 and  timeOfDay == 1)
      {
        Traffic1();    // run forward light run
      }
      if (Direction == 2 and timeOfDay == 1)
      {
        Traffic2();    // run reverse light run
      }
      if (timeOfDay == 2)
          Ndelay(SetDelay,  1000); //add time delay omitted due to not running lights
      if (random(20)  == 1) // Add restart to cap voltage to give random extended displays
          {  
          chargeCap();
          reverseDirection();
          }
  }  while (capVoltage() > 50);
      
      digitalWritewhiteled, LOW);      //  turn off meter illumination when done
}


// ---------------------------------------------------------------------------------------  
// One of two LED driver routines which switch on LEDs according to the voltage  on the capacitor
void Traffic1()
{
  int light = capVoltage();


  if (light > 60)
  {
    digitalWrite(red1, HIGH);   // Turn on red
    Ndelay(SetDelay,  100); // wait for 100 milliseconds
  }
  if (light > 80)
  {
    digitalWrite(red2,  HIGH);   // turn on red
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  if (light > 120)
  {
    digitalWrite(amber1, HIGH); // Turn on anber
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  if (light >  200)
  {
    digitalWrite(amber2, HIGH);   // Turn on amber
    Ndelay(SetDelay,  100); // wait for 100 milliseconds
  }
  if (light > 320)
  {
    digitalWrite(green1,  HIGH);   // turn on green
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  if (light > 580)
  {
    digitalWrite(green2, HIGH); // Turn on green
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  digitalWrite(red1,  LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(red2, LOW);
  Ndelay(SetDelay,  100);
  digitalWrite(amber1, LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(amber2,  LOW);
  Ndelay(SetDelay, 100);;
  digitalWrite(green1, LOW);
  Ndelay(SetDelay,  100);
  digitalWrite(green2, LOW);

}


// ---------------------------------------------------------------------------------------  
// One of two LED driver routines which switch on LEDs according to the voltage  on the capacitor
// This one works in the opposite direction to the first
void  Traffic2()
{
  int light = capVoltage();


  if (light > 60)
  {
    digitalWrite(10, HIGH);   // Turn on green
    Ndelay(SetDelay, 100);  // wait for 100 milliseconds
  }
  if (light > 80)
  {
    digitalWrite(9,  HIGH);   // turn on green
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  if (light > 120)
  {
    digitalWrite(8, HIGH); // Turn on amber
    Ndelay(SetDelay, 100);; // wait for 100 milliseconds
  }
  if (light >  200)
  {
    digitalWrite(7, HIGH);   // Turn on amber
    Ndelay(SetDelay,  100); // wait for 100 milliseconds
  }
  if (light > 320)
  {
    digitalWrite(6,  HIGH);   // turn on red
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  if (light > 580)
  {
    digitalWrite(5, HIGH); // Turn on red
    Ndelay(SetDelay, 100); // wait for 100 milliseconds
  }
  digitalWrite(10,  LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(9, LOW);
  Ndelay(SetDelay,  100);
  digitalWrite(8, LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(7,  LOW);
  Ndelay(SetDelay, 100);
  digitalWrite(6, LOW);
  Ndelay(SetDelay,  100);
  digitalWrite(5, LOW);

}


// ---------------------------------------------------------------------------------------  
// General delay routine which can switch between barco delay and standard  for testing
void Ndelay(int delaytype, int period)
{
  if (delaytype ==  0)
  {
    delay(period);
  }
  else
  {
    Narcoleptic.delay(period);
  }
}


// ---------------------------------------------------------------------------------------  
// Serial output routine runs during testing
void SerialSub(int delaytype,  char stringy[20], int value)
{
  if (delaytype == 0)
  {
    Serial.print(stringy);
    Serial.println(value);
  }
 
}

Downloadable files

Schematic

Diagram of breadboarded project

Runs the basic animation of the meter and the light display

Diagram of breadboarded project

Schematic

Comments

Only logged in users can leave comments

tekyinblack2

0 Followers

•

0 Projects

Intro