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

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