RSeries astromech firmware
ChargeBayIndicator.h
Go to the documentation of this file.
1 #ifndef ChargeBayIndicator_h
2 #define ChargeBayIndicator_h
3 
4 #include "ReelTwo.h"
5 #include "core/LedControlMAX7221.h"
6 #include "core/SetupEvent.h"
7 #include "core/AnimatedEvent.h"
8 #include "core/CommandEvent.h"
9 
36 class ChargeBayIndicator : public AnimatedEvent, SetupEvent, CommandEvent
37 {
38 public:
44  ChargeBayIndicator(LedControl& ledControl, int analogInput = -1) :
45  fLC(ledControl),
46  fID(ledControl.addDevice()),
47  fDisplayEffectVal(kNormalVal),
48  fPreviousEffectVal(~kNormalVal),
49  fAnalogInput(analogInput)
50  {
51  }
52 
53  enum EffectValue
54  {
55  kNormalVal = 0
56  };
57  enum Sequence
58  {
59  kNormal = 0,
60  kDisabled = 1,
61  kFlicker = 2,
62  kNaboo = 3,
63  kCharging = 4,
64  kBlink = 5,
65  kHeart = 6,
66  kVCCOnly = 7
67  };
68 
76  void selectEffect(long inputNum)
77  {
78  fDisplayEffectVal = inputNum;
79  fPreviousEffectVal = ~fDisplayEffectVal;
80  }
81 
85  inline void setSequence(Sequence seq = kNormal, uint8_t speedScale = 0, uint8_t numSeconds = 0)
86  {
87  selectEffect((long int)seq * 10000L + (long int)speedScale * 100 + numSeconds);
88  }
89 
93  virtual void setup() override
94  {
95  fLC.clearDisplay(fID);
96  fLC.setIntensity(fID, 15);
97  fLC.setPower(fID, true);
98  setVCCAnalogInputPin(fAnalogInput);
99  }
100 
104  virtual void animate() override
105  {
106  unsigned long now = millis();
107  if (fDisplayEffectVal != fPreviousEffectVal)
108  {
109  fLC.setIntensity(fID, 15);
110  fLC.clearDisplay(fID);
111  fSeqStep = -1;
112  fDelayTime = 50;
113  fNextStepTimeMS = 0;
114  fEffectStartMillis = millis();
115  fPreviousEffectVal = fDisplayEffectVal;
116  }
117  else if (now < fNextStepTimeMS)
118  {
119  return;
120  }
121 
122  int selectSequence = (fDisplayEffectVal % 1000000) / 10000;
123  int selectSpeed = (fDisplayEffectVal % 1000) / 100;
124  int selectLength = (fDisplayEffectVal % 100);
125  UNUSED(selectSpeed);
126 
127  getVCC();
128  switch (selectSequence)
129  {
130  case kFlicker:
131  fLC.setIntensity(fID, random(15));
132  randomSEQ();
133  break;
134  case kNormal:
135  randomSEQ();
136  // displayVCC();
137  // ESBoperatingSEQ();
138  break;
139  case kDisabled:
140  fDelayTime = 300;
141  break;
142  case kNaboo:
143  displayVCC();
144  operatingSEQ();
145  break;
146  case kCharging:
147  chargingSEQ();
148  break;
149  case kBlink:
150  blinkSEQ();
151  break;
152  case kHeart:
153  displayVCC();
154  heartSEQ();
155  break;
156  case kVCCOnly:
157  displayVCC();
158  break;
159  default:
160  selectEffect(kNormalVal); //unknown effecct go back to normal
161  break;
162  }
163  fNextStepTimeMS = now + fDelayTime;
164  if (selectLength > 0 && millis() - fEffectStartMillis >= unsigned(selectLength) * 1000L)
165  {
166  selectEffect(kNormalVal); //go back to normal operation if its time
167  }
168  }
169 
173  virtual void handleCommand(const char* cmd) override
174  {
175  if (*cmd++ == 'C' && *cmd++ == 'B')
176  {
177  long int cmdvalue = 0;
178  const char* c = cmd;
179  while (*c >= '0' && *c <= '9')
180  {
181  cmdvalue = cmdvalue * 10 + (*c++ - '0');
182  }
183  selectEffect(cmdvalue);
184  }
185  }
186 
192  inline void setRow(byte row, byte data)
193  {
194  fLC.setRow(fID, row, data << 3);
195  }
196 
200  inline void setGreenLight(bool on)
201  {
202  fLC.setLed(fID, 6, 5, on);
203  }
204 
208  inline void setYellowLight(bool on)
209  {
210  fLC.setLed(fID, 5, 5, on);
211  }
212 
216  inline void setRedLight(bool on)
217  {
218  fLC.setLed(fID, 4, 5, on);
219  }
220 
224  void displayVCC()
225  {
226  setGreenLight((fVCC >= GREEN_VCC));
227  setYellowLight((fVCC >= YELLOW_VCC));
228  setRedLight(true);
229  }
230 
234  void randomSEQ()
235  {
236  setRow(random(4), fLC.randomRow(random(4)));
237  if (random(100) < 30)
238  setGreenLight(random(2));
239  if (random(100) < 20)
240  setYellowLight(random(2));
241  if (random(100) < 10)
242  setRedLight(random(2));
243  fDelayTime = 300;
244  }
245 
249  void blinkSEQ()
250  {
251  // Check if we are still on the same step
252  switch (fSeqStep)
253  {
254  case 0:
255  setRow(0, B00000);
256  setRow(1, B00000);
257  setRow(2, B00000);
258  setRow(3, B00000);
259  setGreenLight(false);
260  setYellowLight(false);
261  setRedLight(false);
262  break;
263  case 1:
264  setRow(0, B11111);
265  setRow(1, B11111);
266  setRow(2, B11111);
267  setRow(3, B11111);
268  setGreenLight(true);
269  setYellowLight(true);
270  setRedLight(true);
271  break;
272  }
273  fSeqStep = (++fSeqStep <= 1) ? fSeqStep : 0;
274  fDelayTime = 2000;
275  }
276 
280  void heartSEQ()
281  {
282  // used when monitorVCC == false
283  switch (fSeqStep)
284  {
285  case 0:
286  setRow(0, B01110);
287  setRow(1, B00100);
288  setRow(2, B00100);
289  setRow(3, B01110);
290  break;
291  case 1:
292  setRow(0, B01010);
293  setRow(1, B11111);
294  setRow(2, B01110);
295  setRow(3, B00100);
296  break;
297  case 2:
298  setRow(0, B01010);
299  setRow(1, B01010);
300  setRow(2, B01010);
301  setRow(3, B01110);
302  break;
303  }
304  fSeqStep = (++fSeqStep <= 2) ? fSeqStep : 0;
305  fDelayTime = 1000;
306  }
307 
311  void chargingSEQ()
312  {
313  // used when monitorVCC == false
314  switch (fSeqStep)
315  {
316  case 0:
317  setRow(0, B11100);
318  setRow(1, B11100);
319  setRow(2, B11100);
320  setRow(3, B00010);
321  setGreenLight(true);
322  break;
323  case 1:
324  setRow(1, B00000110);
325  break;
326  case 2:
327  setRow(1, B11100);
328  setRow(2, B00010);
329  setRow(3, B11100);
330  setYellowLight(true);
331  break;
332  case 3:
333  setRow(0, B00010);
334  setRow(1, B11100);
335  setRow(2, B11100);
336  setRow(3, B00010);
337  setRedLight(true);
338  break;
339  case 4:
340  setRow(0, B11100);
341  setRow(1, B11100);
342  setRow(2, B11100);
343  setRow(3, B11100);
344  break;
345  case 5:
346  setRow(0, B11100);
347  setRow(1, B00010);
348  setRow(1, B00010);
349  setRow(3, B00010);
350  break;
351  case 6:
352  setRow(0, B00010);
353  setRow(1, B11100);
354  setRow(2, B00010);
355  setRow(3, B00010);
356  setRedLight(false);
357  break;
358  case 7:
359  setRow(0, B11100);
360  setRow(1, B11100);
361  setRow(2, B00010);
362  setRow(3, B00010);
363  setYellowLight(false);
364  break;
365  case 8:
366  setRow(0, B00011);
367  setRow(1, B11100);
368  setRow(2, B00010);
369  setRow(3, B11100);
370  setGreenLight(false);
371  break;
372  case 9:
373  setRow(0, B00010);
374  setRow(1, B11100);
375  setRow(2, B11100);
376  setRow(3, B11100);
377  break;
378  }
379  fSeqStep = (++fSeqStep <= 9) ? fSeqStep : 0;
380  fDelayTime = 300;
381  }
382 
386  void operatingSEQ()
387  {
388  switch (fSeqStep)
389  {
390  case 0:
391  setRow(0, B11100);
392  setRow(1, B11100);
393  setRow(2, B11110);
394  setRow(3, B00011);
395  break;
396  case 1:
397  setRow(1, B00011);
398  break;
399  case 2:
400  setRow(1, B11100);
401  setRow(2, B00011);
402  setRow(3, B11100);
403  break;
404  case 3:
405  setRow(0, B00011);
406  setRow(1, B11100);
407  setRow(2, B11100);
408  setRow(3, B00011);
409  break;
410  case 4:
411  setRow(0, B11100);
412  setRow(1, B11100);
413  setRow(2, B11100);
414  setRow(3, B11100);
415  break;
416  case 5:
417  setRow(0, B11100);
418  setRow(1, B00011);
419  setRow(1, B00011);
420  setRow(3, B00011);
421  break;
422  case 6:
423  setRow(0, B00011);
424  setRow(1, B11100);
425  setRow(2, B00011);
426  setRow(3, B00011);
427  break;
428  case 7:
429  setRow(0, B11100);
430  setRow(1, B11100);
431  setRow(2, B00011);
432  setRow(3, B00011);
433  break;
434  case 8:
435  setRow(0, B00011);
436  setRow(1, B11100);
437  setRow(2, B00011);
438  setRow(3, B11100);
439  break;
440  case 9:
441  setRow(0, B00011);
442  setRow(1, B11100);
443  setRow(2, B11100);
444  setRow(3, B11100);
445  break;
446  case 10:
447  fLC.clearDisplay(fID);
448  break;
449  }
450  fSeqStep = (++fSeqStep <= 10) ? fSeqStep : 0;
451  fDelayTime = 300;
452  }
453 
457  void setVCCAnalogInputPin(int analogInput)
458  {
459  fAnalogInput = analogInput;
460  if (fAnalogInput != -1)
461  pinMode(fAnalogInput, INPUT);
462  }
463 
467  float getVCC()
468  {
469  fVCC = (fAnalogInput != -1) ? ((analogRead(fAnalogInput) * 5.0) / 1024.0) / (R2/(R1+R2)) : 0;
470  return fVCC;
471  }
472 
473 private:
474  LedControl& fLC;
475  byte fID;
476  int fSeqStep;
477  unsigned long fNextStepTimeMS;
478  unsigned long fEffectStartMillis;
479 
480  long fDisplayEffectVal;
481  long fPreviousEffectVal;
482  int fAnalogInput; // Analog Pin for the voltage reading. -1 for disabled.
483 
484  static constexpr float GREEN_VCC = 12.5; // Green LED l21 on if above this voltage
485  static constexpr float YELLOW_VCC = 12.0; // Yellow LED l22 on if above this voltage & below greenVCC... below turn on only RED l23
486 
487  // For 15volts: R1=47k, R2=24k
488  // For 30volts: R1=47k, R2=9.4k
489  static constexpr float R1 = 47000.0; // >> resistance of R1 in ohms << the more accurate these values are
490  static constexpr float R2 = 24000.0; // >> resistance of R2 in ohms << the more accurate the measurement will be
491 
492  float fVCC; // voltage measured by voltage divider circuit
493 
494  /* we always wait a bit between updates of the display */
495  unsigned long fDelayTime = 300;
496 };
497 
498 #if 0
499  void ESBoperatingSEQ()
500  {
501  switch (fSeqStep)
502  {
503  case 0:
504  setRow(0,0,B01101101);
505  setRow(0,1,B00000110);
506  setRow(0,2,B11011011);
507  setRow(0,3,B00010011);
508  setRow(0,4,B11000011);
509  setRow(0,5,B01000011);
510  setRow(0,6,B00110011);
511  break;
512 
513  case 1:
514  setRow(0,0,B01100101);
515  setRow(0,1,B00000110);
516  setRow(0,2,B10010111);
517  setRow(0,3,B00001011);
518  setRow(0,4,B00100001);
519  setRow(0,5,B11000001);
520  setRow(0,6,B10101011);
521  break;
522  case 2:
523  setRow(0,0,B00000110);
524  setRow(0,1,B00010011);
525  setRow(0,2,B10110001);
526  setRow(0,3,B00001011);
527  setRow(0,4,B11101001);
528  setRow(0,5,B10100000);
529  setRow(0,6,B11101001);
530  break;
531  case 3:
532  setRow(0,0,B10000111);
533  setRow(0,1,B00010011);
534  setRow(0,2,B10110111);
535  setRow(0,3,B11000010);
536  setRow(0,4,B00000011);
537  setRow(0,5,B10010000);
538  setRow(0,6,B10001000);
539  break;
540  case 4:
541  setRow(0,0,B01010001);
542  setRow(0,1,B00010011);
543  setRow(0,2,B10010111);
544  setRow(0,3,B11001000);
545  setRow(0,4,B11001000);
546  setRow(0,5,B10101001);
547  setRow(0,6,B00000001);
548  break;
549  case 5:
550  setRow(0,0,B01010101);
551  setRow(0,1,B01010011);
552  setRow(0,2,B00010011);
553  setRow(0,3,B01001100);
554  setRow(0,4,B00000001);
555  setRow(0,5,B00010000);
556  setRow(0,6,B11000001);
557  break;
558  case 6:
559  setRow(0,0,B00010011);
560  setRow(0,1,B00010011);
561  setRow(0,2,B00010011);
562  setRow(0,3,B10100110);
563  setRow(0,4,B10000001);
564  setRow(0,5,B00010000);
565  setRow(0,6,B11000001);
566  break;
567  case 7:
568  setRow(0,0,B00010011);
569  setRow(0,1,B00000110);
570  setRow(0,2,B10011011);
571  setRow(0,3,B00010011);
572  setRow(0,4,B11001010);
573  setRow(0,5,B11001000);
574  setRow(0,6,B10100000);
575  break;
576  case 8:
577  setRow(0,0,B00010011);
578  setRow(0,1,B10100101);
579  setRow(0,2,B10000010);
580  setRow(0,3,B00110101);
581  setRow(0,4,B10110000);
582  setRow(0,5,B00000011);
583  setRow(0,6,B11001000);
584  break;
585  case 9:
586  setRow(0,0,B00001110);
587  setRow(0,1,B00010011);
588  setRow(0,2,B01000010);
589  setRow(0,3,B00000110);
590  setRow(0,4,B10101011);
591  setRow(0,5,B00000001);
592  setRow(0,6,B10101011);
593  break;
594  case 10:
595  setRow(0,0,B01000011);
596  setRow(0,1,B00000110);
597  setRow(0,2,B00010011);
598  setRow(0,3,B00000110);
599  setRow(0,4,B10101011);
600  setRow(0,5,B11101001);
601  setRow(0,6,B00000011);
602  break;
603  case 11:
604  setRow(0,0,B01100101);
605  setRow(0,1,B00110011);
606  setRow(0,2,B00010111);
607  setRow(0,3,B00000110);
608  setRow(0,4,B10100000);
609  setRow(0,5,B11101001);
610  setRow(0,6,B10101011);
611  break;
612  case 12:
613  setRow(0,0,B00100000);
614  setRow(0,1,B00010011);
615  setRow(0,2,B10001000);
616  setRow(0,3,B00011000);
617  setRow(0,4,B00000001);
618  setRow(0,5,B00000011);
619  setRow(0,6,B11001000);
620  break;
621  case 13:
622  setRow(0,0,B10000000);
623  setRow(0,1,B00010011);
624  setRow(0,2,B10110101);
625  setRow(0,3,B10010110);
626  setRow(0,4,B00000001);
627  setRow(0,5,B11101001);
628  setRow(0,6,B11101001);
629  break;
630  case 14:
631  setRow(0,0,B10100110);
632  setRow(0,1,B01010001);
633  setRow(0,2,B01010011);
634  setRow(0,3,B10100000);
635  setRow(0,4,B11001000);
636  setRow(0,5,B10110000);
637  setRow(0,6,B00000011);
638  break;
639  case 15:
640  setRow(0,0,B10101000);
641  setRow(0,1,B01010001);
642  setRow(0,2,B00010001);
643  setRow(0,3,B10000000);
644  setRow(0,4,B11101001);
645  setRow(0,5,B11101001);
646  setRow(0,6,B10101011);
647  break;
648  case 16:
649  setRow(0,0,B10000011);
650  setRow(0,1,B00100000);
651  setRow(0,2,B10010011);
652  setRow(0,3,B11000010);
653  setRow(0,4,B10101011);
654  setRow(0,5,B00000001);
655  setRow(0,6,B00000011);
656  break;
657  case 17:
658  setRow(0,0,B10000010);
659  setRow(0,1,B00010011);
660  setRow(0,2,B00010010);
661  setRow(0,3,B11000010);
662  setRow(0,4,B00110000);
663  setRow(0,5,B11101001);
664  setRow(0,6,B00110000);
665  break;
666  case 18:
667  setRow(0,0,B01100101);
668  setRow(0,1,B00010011);
669  setRow(0,2,B00100000);
670  setRow(0,3,B00000110);
671  setRow(0,4,B11001000);
672  setRow(0,5,B00011001);
673  setRow(0,6,B01000001);
674  break;
675  case 19:
676  setRow(0,0,B10100011);
677  setRow(0,1,B00010011);
678  setRow(0,2,B01010101);
679  setRow(0,3,B01100101);
680  setRow(0,4,B00110000);
681  setRow(0,5,B01010000);
682  setRow(0,6,B01100001);
683  break;
684  case 20:
685  setRow(0,0,B10000000);
686  setRow(0,1,B10000000);
687  setRow(0,2,B01010001);
688  setRow(0,3,B00001011);
689  setRow(0,4,B11101001);
690  setRow(0,5,B11001000);
691  setRow(0,6,B11001000);
692  break;
693  case 21:
694  setRow(0,0,B00000110);
695  setRow(0,1,B00100000);
696  setRow(0,2,B11011000);
697  setRow(0,3,B01001100);
698  setRow(0,4,B10101011);
699  setRow(0,5,B01010000);
700  setRow(0,6,B00000010);
701  break;
702  case 22:
703  setRow(0,0,B01000011);
704  setRow(0,1,B00011000);
705  setRow(0,2,B10011000);
706  setRow(0,3,B01000011);
707  setRow(0,5,B00000010);
708  setRow(0,6,B11001010);
709  break;
710  case 23:
711  setRow(0,0,B00101100);
712  setRow(0,1,B00010011);
713  setRow(0,2,B01011010);
714  setRow(0,3,B01000011);
715  setRow(0,4,B01010000);
716  setRow(0,5,B10101011);
717  setRow(0,6,B11001010);
718  break;
719  case 24:
720  setRow(0,0,B10101010);
721  setRow(0,1,B00100000);
722  setRow(0,2,B01001100);
723  setRow(0,3,B01000010);
724  setRow(0,4,B00000011);
725  setRow(0,5,B11001010);
726  setRow(0,6,B01010000);
727  break;
728  case 25:
729  setRow(0,0,B00000110);
730  setRow(0,1,B00000110);
731  setRow(0,2,B10001100);
732  setRow(0,3,B00000110);
733  setRow(0,4,B01001000);
734  setRow(0,5,B01010000);
735  setRow(0,6,B00000010);
736  break;
737  case 26:
738  setRow(0,0,B00000110);
739  setRow(0,1,B00010011);
740  setRow(0,2,B00111000);
741  setRow(0,3,B01001100);
742  setRow(0,4,B11001010);
743  setRow(0,5,B00000001);
744  setRow(0,6,B10101011);
745  break;
746  case 27:
747  setRow(0,0,B00000110);
748  setRow(0,1,B00010011);
749  setRow(0,2,B01001100);
750  setRow(0,3,B01000011);
751  setRow(0,4,B00000011);
752  setRow(0,5,B11001000);
753  setRow(0,6,B11001000);
754  break;
755  }
756  fSeqStep = (++fSeqStep <= 10) ? fSeqStep : 0;
757  fDelayTime = 300;
758  }
759 #endif
760 
761 #endif
ChargeBayIndicator::setGreenLight
void setGreenLight(bool on)
Turn the green LED on or off.
Definition: ChargeBayIndicator.h:200
ChargeBayIndicator::kBlink
@ kBlink
Definition: ChargeBayIndicator.h:64
ChargeBayIndicator::EffectValue
EffectValue
Definition: ChargeBayIndicator.h:53
ChargeBayIndicator::Sequence
Sequence
Definition: ChargeBayIndicator.h:57
CommandEvent
Base class for all command enabled devices. CommandEvent::handleCommand() is called for each device e...
Definition: CommandEvent.h:17
ChargeBayIndicator::kVCCOnly
@ kVCCOnly
Definition: ChargeBayIndicator.h:66
ReelTwo.h
ChargeBayIndicator::ChargeBayIndicator
ChargeBayIndicator(LedControl &ledControl, int analogInput=-1)
Constructor.
Definition: ChargeBayIndicator.h:44
SetupEvent.h
ChargeBayIndicator::kFlicker
@ kFlicker
Definition: ChargeBayIndicator.h:61
AnimatedEvent
Base class for all animated devices. AnimatedEvent::animate() is called for each device once through ...
Definition: AnimatedEvent.h:18
SetupEvent
Base class for all devices that require setup that cannot happen in the constructor....
Definition: SetupEvent.h:15
ChargeBayIndicator::blinkSEQ
void blinkSEQ()
Test utility routine for blinking all LEDs every two seconds.
Definition: ChargeBayIndicator.h:249
LedControlMAX7221.h
UNUSED
#define UNUSED(x)
Definition: ReelTwo.h:172
AnimatedEvent.h
ChargeBayIndicator::handleCommand
virtual void handleCommand(const char *cmd) override
ChargeBayIndicator Commands start with 'CB'.
Definition: ChargeBayIndicator.h:173
ChargeBayIndicator::setRow
void setRow(byte row, byte data)
This function is only for the grid pattern not the VCC LEDs.
Definition: ChargeBayIndicator.h:192
ChargeBayIndicator::randomSEQ
void randomSEQ()
Update LEDs randomly for one frame.
Definition: ChargeBayIndicator.h:234
ChargeBayIndicator::chargingSEQ
void chargingSEQ()
Animate the LEDs like ESB charging sequence.
Definition: ChargeBayIndicator.h:311
ChargeBayIndicator::animate
virtual void animate() override
Perform a single frame of LED animation based on the selected sequence.
Definition: ChargeBayIndicator.h:104
ChargeBayIndicator::operatingSEQ
void operatingSEQ()
Operating sequence.
Definition: ChargeBayIndicator.h:386
ChargeBayIndicator
ChargeBayIndicator (CBI) controller.
Definition: ChargeBayIndicator.h:36
ChargeBayIndicator::heartSEQ
void heartSEQ()
Pulse.
Definition: ChargeBayIndicator.h:280
ChargeBayIndicator::kCharging
@ kCharging
Definition: ChargeBayIndicator.h:63
ChargeBayIndicator::setup
virtual void setup() override
Perform any initialzation not possible in the constructor.
Definition: ChargeBayIndicator.h:93
ChargeBayIndicator::setYellowLight
void setYellowLight(bool on)
Turn the yellow LED on or off.
Definition: ChargeBayIndicator.h:208
ChargeBayIndicator::setRedLight
void setRedLight(bool on)
Turn the red LED on or off.
Definition: ChargeBayIndicator.h:216
ChargeBayIndicator::kNormal
@ kNormal
Definition: ChargeBayIndicator.h:59
ChargeBayIndicator::setVCCAnalogInputPin
void setVCCAnalogInputPin(int analogInput)
Specify the analog pint used by the voltage divider.
Definition: ChargeBayIndicator.h:457
ChargeBayIndicator::setSequence
void setSequence(Sequence seq=kNormal, uint8_t speedScale=0, uint8_t numSeconds=0)
Select the specified effect sequence.
Definition: ChargeBayIndicator.h:85
ChargeBayIndicator::selectEffect
void selectEffect(long inputNum)
Select the specified effect using a 32-bit integer.
Definition: ChargeBayIndicator.h:76
ChargeBayIndicator::getVCC
float getVCC()
Read the voltage level from the voltage divider.
Definition: ChargeBayIndicator.h:467
ChargeBayIndicator::kNormalVal
@ kNormalVal
Definition: ChargeBayIndicator.h:55
ChargeBayIndicator::kHeart
@ kHeart
Definition: ChargeBayIndicator.h:65
ChargeBayIndicator::displayVCC
void displayVCC()
Set the green/yellow/red LEDs based on the voltage levels read from the voltage divider.
Definition: ChargeBayIndicator.h:224
CommandEvent.h
ChargeBayIndicator::kDisabled
@ kDisabled
Definition: ChargeBayIndicator.h:60
ChargeBayIndicator::kNaboo
@ kNaboo
Definition: ChargeBayIndicator.h:62