Rick & Morty Steampunk Multifunction gadget

//
// Rick Box time/Temp display baseline - Mark M. Lambert - December 6, 2021
//
// This is an attempt to fully load an Arduino Mega 2560 controller.
// We're real close to 100% utilization with everything but the kitchen 
// sink installed (it's on back order ...)
//
// This is a steampunk, over the top, 3d printed, lexan and wood remote control
// gadget that does lots of things with blinkey lights, remote control and it
// even plays music.
//
// It also acts as biker magic 8-ball and an insulin computer. It reads analogs for
// the blood sugar number & joystick, turns lights off at dark, knows what time it is,
// can communicate remotely, switch meter feeds, control blinkey lights, measure
// distance, and move steppers and servos - all at once!
//
// We're down to the last 5 D's, but we still have 8 AI's
//
const float Version = 5.09;
//
// V5.09 - 11Feb22 - MML - Add insulin estimator & PO Box sim using pot as input device
// V5.08 - 08Feb22 - MML - Clean up LCD layout
// V5.07 - 07Feb22 - MML - Make 9-ball biker & get VU meter wired
// V5.06 - 06Feb22 - MML - Add Magic 8-ball
// V5.05 - 05Feb22 - MML - Get 2nd servo running - All remote buttons working, codes verified
// V5.04 - 31Jan22 - MML - Stepper fixed - odd phase ordering and setting RPM fixed it
// V5.03 - 30Jan22 - MML - Servo working, still wirinjg, diddle with stepper
// V5.02 - 27Jan22 - MML - (Cont.) - Lots working - Echo & clock up, 
// V5.01 - 26Jan22 - MML - (Cont.)
// V5.00 - 24Jan22 - MML - Upgrade IO's (again)
// V4.03 - 12Jan22 - MML - Test IR remote
// V4.02 - 11Jan22 - MML - Work on Touch sw & knock
// V4.01 - 10Jan22 - MML - Try to get hardware to run - everything lights up
// V4.00 - 08Jan22 - MML - Align I/O's with "as built" hardware
// V3.01 - 16Dec21 - MML - Get RTC and rangerfinder working
// V3.00 - 14Dec21 - MML - Get 2nd lcd working
// V2.00 - 13Dec21 - MML - Strip down to get clean compile
// V1.01 - 10Dec21 - MML - Continue baseline
// V1.00 - 06Dec21 - MML - Baseline with LCD - Mega 2650 has built in pullups
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// Device Master List
//
// Mega 2560          Processor
// +12 to +5 Vreg & Buss Bars
// I2C devices
// 1602 LCD           Command display
// 2004 LCD #1        Indoor Display
// 2004 LCD #2        Outdoor Display
// BHT280 Baro        Barometric sensor
//
// Echo Rangefinder
// Traffic Light
// FM Radio (Button)  <<====== OUT - Real Radio in
//    Analog VU meter Subsystem
// IR remote command in
// LDR light sensor
// Analog Joystick with push sw
//
// K1-4, 5, & 6 relays
// RTC
// DHT11 Temp/Humidity (Indoor)
// ESP-01 WiFi - From Outdoor DHT-11
// Touch Sensor
// Servo output - Haven't added IO's yet or quite figured out what this will do. 
//    I'm leaning to a secret compartment with a hidden release and maybe the knock sensor
// Knock sensor
//
// ==================================
// Start of Pin Constants
// ==================================
//
// Analogs first
//
int xx      = 0;            //Placeholder value
//
const int Vnoise  = A2;     // Random number seed is open AI
const int Vin     = A3;     //Power supply direct output monitor - NOT USED
//
const int I2C_A4  = A4;    // RESERVED
const int I2C_A5  = A5;    // RESERVED
//
// Float constant
//
const float VoltsPerBit = (5.0 / 1024.0);   //Compute bit weight based on +5 Vin max
//
// Int constant implied
//
const int VinAux5 = A12;    //+5v input monitor via card
//
// Joystick - A13 & 14 not on Uno
// See Also Zaxis DI
//
const int Yaxis   = A13;    //Joystick y
const int Xaxis   = A14;    //Joystick X
//
const int Wiper   = A15;    //Wiper from 5k pot
//
// Analogs end
// -----------
// Now digitals 
//
// D0 and D1 are rx/tx for serial programming
//
const int RPM                 = 15;   // Top end is ~15 from what I've read, works at 15
const int StepsPerRevolution  = 2048;  // 28BYJ-48 Stepper - this # may not be exact, docs differ
//
// Stepper motor pins - Powered by Aux +5 - Works!
//
const int StepA     = 2;     //Stepper Motor Phase A
const int StepB     = 3;     //Stepper Motor Phase B
const int StepC     = 4;     //Stepper Motor Phase C
const int StepD     = 5;     //Stepper Motor Phase D
//
// 6/7 L & R PWM
//
const int VULeft    = 6;    // Signal to VU meter Left
const int VURight   = 7;    // Ditto right
//
const int MotorSpeed = 8;   // PWM for motor speed control 
//
// Servo needs a PWM output. Powered by Aux +5
//
const int PWM1      =  9;   // Big servo
const int PWM2      = 10;   // Small servo - needs test
//
// 11 & 12 RFU
//
const int LEDPin    = 13;  // Built in LED
//
// Comm channel I/O's are given
//
const int S3_TX     = 14;     //ESP-01 WiFi - needs test
const int S3_RX     = 15;
//
const int S2_TX     = 16;     //Button radio <<=== Not used
const int S2_RX     = 17;
//
const int S1_TX     = 18;     //Knob radio BACK IN! *****
const int S1_RX     = 19;
//
// I2C is brought out to buss bars for mass connections
// We have at least five I2C devices on the buss. three LCD's, the RTC, and the BM-280 baro chip
// Device addresses have been jumper preset on LCD's
//
// Actually the buss bars are connected thru the SDA/SCL pins by D13, not these
//
const int I2C_SDA   = 20;     // These are attached to the matching buss bars for bussing to all I2C devices
const int I2C_SCL   = 21;     // Pullups are internal to Mega 2560
//
// 22-25 reserved for MOSI/MISO SP1 devices
//
// 11Feb22
// Got dot matrix and 4 digit readouts on order.
// The matrix needs MOSI and I think the readouts
// are I2C, but I won't be sure until they arrive
//
// Alternative Pins Function:
// SPI Pins:
// 
// Pin 22 - SS
// Pin 23 - SCK 
// Pin 24 - MOSI 
// Pin 25 – MISO
//
// See also pins 51-53
//
const int SSX        = 22;
const int SCKX       = 23;
const int MOSIX      = 24;
const int MISOX      = 25;
//
// RTC I/O pins - Working fine - Use SET_CLOCK project to preset time
//
// Set the appropriate digital I/O pin connections. These are the pin
// assignments for the Arduino as well for as the DS1302 chip. See the DS1302
// datasheet:
//
//   http://datasheets.maximintegrated.com/en/ds/DS1302.pdf
//
const int kCePin    = 26;  // Chip Enable
const int kIoPin    = 27;  // Input/Output
const int kSclkPin  = 28;  // Serial Clock
//
// H drive Circuit still under development
//
const int MotorOn   = 29;   //DC motor on/off - plan is two outputs, direction and enable
const int MotorDir  = 30;   //DC motor Direction - plan is to add H drive circuit
//
// Need a PWM for MotorSpeed - D8
//
const int TL2_R     = 31;
const int TL2_Y     = 32;
const int TL2_G     = 33;
//
// Singleton relay Modules
//
const int K5        = 34;    // Left Audio - Powered by Aux +5
const int K6        = 35;    // Right Audio - Powered by Aux +5
//
// Humidity/temp sensors
//
const int DHTPIN    = 36;     // Digital pin connected to the DHT sensor
//
// IR remote control input
//
const int RECV_PIN  = 37;     //IR Receiver input pin
//
// There are seven rows of three buttons each. Each has (presumably)
// a unique code. We're going to define the button codes here instead
// of scattering them in a massive SWITCH.
//
// ----------------------
// _00 = _RC, 0 indexed
//
// All the little IR remotes appear to use the same set of codes
// Determined empirically:
//
const int Btn_00  = 23971;  // Top Row, left button - Row 0, Col 0
const int Btn_01  = 25245;  // Row 0, Col 1 - 
const int Btn_02  = 7651;   // Top Row, right button - Row 0, Col 2
//
const int Btn_10  = 8925;   // Row 1, col 0 - (red)
const int Btn_11  = 765;
const int Btn_12  = 15811;
//
const int Btn_20  = 8161;
const int Btn_21  = 22441;
const int Btn_22  = 28561;
//
const int Btn_30  = 26775;
const int Btn_31  = 26521;
const int Btn_32  = 20401;
//
const int Btn_40  = 12495;
const int Btn_41  = 6375;
const int Btn_42  = 31365;
//
const int Btn_50  = 4335;
const int Btn_51  = 14535;
const int Btn_52  = 23205;
//
const int Btn_60  = 17085;
const int Btn_61  = 19125;
const int Btn_62  = 21165;     // Bottom Row, right button
// ----------------------
//
const int TouchSw   = 38;     //Touch switch - Needs debounce
//
// Quad Relay board pins - Powered By Aux +5 Via Jumper
//
const int K1        = 39;    // VU Meter power          - Not yet wired
const int K2        = 40;    // VU Mode Button Select   - Not yet wired
const int K3        = 41;    // Decoration lighting control
const int K4        = 42;    // Sundown Relay - Follows LDR input
//
const int KnockSw   = 43;    // Knock switch - This and TouchSw activate together to rotate servo 90 deg
//
// Joystick switch
//
const int Zaxis     = 44;    // Joystick Z (push sw)
//
// LDR
//
const int LDR_IN    = 45;    // LDR w/ comparator input
//
// Sonar pins HC-SRO4 - Wired backwards it faulted the +5 but didn't burn out.
// Just lucky I guess
//
const int echoPin   = 46;
const int trigPin   = 47;
//
// Traffic light shows distance - range is limited
//
const float DistFar   = 18.0;   // Green
const float DistMed   = 12.0;   // Yellow
const float DistNear  =  6.0;   // Red
//
// Needs to move for MOSI/MISO support
//
// Traffic lights are at top end of DOs
//
const int TL_R      = 48;    //As of V5
const int TL_Y      = 49;
const int TL_G      = 50;   // <<== Overlap with MISO **********
//
// See also pins 21-25
// 51-53 not used - reserved for MOSI/MISO
// SPI:
//  50/25 (MISO) <<== not needed for output only
//  51/24 (MOSI)
//  52/23 (SCK)
//  53/22 (SS)   <<== Device Select
//
// ==================================
// End of Pin Constants
// ==================================
//
// Device Constants
//
const unsigned interval = 500;  // Half second pulse
//
// LCD geometry
// Smaller display
//
const int LCD_COLS = 16;
const int LCD_ROWS = 2;
//
// Bigger display
//
const int LCD_COLS2 = 20;
const int LCD_ROWS2 = 4;
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// Includes - DO NOT REORDER
//
#include <stdio.h>
#include <DHT.h>          //Digital Humidity/Temp sensor library
#include <DS1302.h>       //RTC library
#include <IRremote.h>     //IR Remote Library
//
// These three includes MUST be in this order or wierd "Error compiling for board Arduino Mega or Mega 2560." error
// Wire.h must load first
//
#include <Wire.h>               //I2C Driver
#include <LiquidCrystal_I2C.h>  //I2C LCD display driver for all LCD's
#include <Servo.h>              //PWM Servo motor
#include <Stepper.h>            //Four Phase stepper motor
//
//
// BMP280 stuff
//
#include <SPI.h>                // ???
#include <Adafruit_BMP280.h>    //Baro I2C sensor
//
#define BMP_SCK  (13)           // Not using MISO/MOSI, am I?
#define BMP_MISO (12)
#define BMP_MOSI (11)
#define BMP_CS   (10)
//
Adafruit_BMP280 bmp; // I2C
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
Servo DoorServo;  // create servo object to control large servo
Servo AuxServo;   // create servo object to control small servo
//
// Invoke LCD objects
// Currently only #2 and #3 are used
//
LiquidCrystal_I2C lcd1(0x3E, LCD_COLS,  LCD_ROWS );  // set the LCD1 object address to 0x3E for a 16 chars and 2 line display
LiquidCrystal_I2C lcd2(0x25, LCD_COLS2, LCD_ROWS2);  // set the LCD2 object address to 0x25 for a 20 chars and 4 line display
LiquidCrystal_I2C lcd3(0x26, LCD_COLS2, LCD_ROWS2);  // set the LCD3 object address to 0x27 for a 20 chars and 4 line display
// LiquidCrystal_I2C lcd4(0x27, LCD_COLS2, LCD_ROWS2);  // set the LCD4 object address to 0x25 for a 20 chars and 4 line display (Not installed)
//
// Create a DS1302 RTC object.
//
DS1302 rtc(kCePin, kIoPin, kSclkPin);
// Turn clock on after power up
//
// Temp/Humidity
//
// Uncomment whatever type you're using!
#define DHTTYPE DHT11   // DHT 11
//#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)
//
int valx = 0;  // variable to store the value read
//
DHT dht(DHTPIN, DHTTYPE);     // Create Object
//
// Stepper motor object. Note odd order: A/C/B/D
//
Stepper MotorStepper(StepsPerRevolution, StepA, StepC, StepB, StepD);
//
// IR Remote control object
//
IRrecv irrecv(RECV_PIN);      // Build IR receiver object
decode_results results;     // Not sure about this, but it works
//
// -------------------------
// Objects built
// -------------------------
//
// Fancy footwork needed to run instead of using Delay
//
// Global state flags
//
int EchoFlag = true;    // Enables rangefinder
//
const int VURadio = false;
const int VUPWM = true;
//
// K5/6 state tracks this
int VUMode = VURadio;
//
// LCD states
//
int lcd1light = true;
int lcd2light = true;
int lcd3light = true;
//
unsigned long previousMillis = 0;        // will store last time LED was updated
//
// Define strings for PO Box Combo Lock simulator
// 20 lock postitions
const int LockAngle = 15;
const int UnLockAngle = LockAngle + 79;   //Desired rotation angle to open door
const int MidAngle = (LockAngle + UnLockAngle) /2;
int LockSteps = 20;   //Number of LockTable entries
char *LockTable[] = {
      "A", 
      "A-B", 
      "B", 
      "B-C", 
      "C", 
      "C-D", 
      "D", 
      "D-E", 
      "E", 
      "E-F", 
      "F", 
      "F-G", 
      "G", 
      "G-H", 
      "H", 
      "H-I", 
      "I", 
      "I-J", 
      "J", 
      "J-A"
    };
//
// ============================================
// SETUP
// ============================================
//
void setup()
  {
    //
    // seed random number generator with noise
    //
    randomSeed(analogRead(Vnoise));    // floating input is seed
  //
  // Set stepper speed - not in all examples but required
  //
  MotorStepper.setSpeed(RPM);   // RPM slew rate
  //
  // Fire up servos
  //
  DoorServo.attach(PWM1);  // attaches the Large servo pin to the servo object
  AuxServo.attach(PWM2);  // attaches the Small servo pin to the servo object
  DoorServo.write(LockAngle);     // Default to locked position
  AuxServo.write(LockAngle);
  //
  // Fire up RTC
  //
  rtc.writeProtect(false);  //Gotta unlock before letting it run
  rtc.halt(false);          //Let clock run
  rtc.writeProtect(true);   //Only protect AFTER letting it run
  //
  Serial.begin(9600);       //Warm up comm port
  //
  // INPUT is default but we need to make sure they don't float with INPUT_PULLUP
  // Declare all inputs as pullups
  //
  pinMode(KnockSw, INPUT_PULLUP);      //Knick Switch
  pinMode(TouchSw, INPUT_PULLUP);      //Touch Switch
  pinMode(LDR_IN, INPUT_PULLUP);      //Light dark
  pinMode(Zaxis, INPUT_PULLUP);      //Push sw on joystick
  //
  // Relays
  //
  pinMode(K1, OUTPUT);
  pinMode(K2, OUTPUT);
  pinMode(K3, OUTPUT);
  pinMode(K4, OUTPUT);
  pinMode(K5, OUTPUT);
  pinMode(K6, OUTPUT);
  //
  digitalWrite(K1, HIGH);   //Turn off - Negative logic
  digitalWrite(K2, HIGH);   //Turn off
  digitalWrite(K3, HIGH);   //Turn off
  digitalWrite(K4, HIGH);   //Turn off
  digitalWrite(K5, LOW);    //Turn off - positive logic
  digitalWrite(K6, LOW);    //Turn off
  //
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);   //Turn off
  //
  // Traffic lights
  //
  pinMode(TL_G, OUTPUT);
  pinMode(TL_Y, OUTPUT);
  pinMode(TL_R, OUTPUT);
  //
  pinMode(TL2_G, OUTPUT);
  pinMode(TL2_Y, OUTPUT);
  pinMode(TL2_R, OUTPUT);
  //
  digitalWrite(TL_G, LOW);   //Turn off  
  digitalWrite(TL_Y, LOW);   //Turn off  
  digitalWrite(TL_R, LOW);   //Turn off  
  //
  digitalWrite(TL2_G, LOW);   //Turn off  
  digitalWrite(TL2_Y, LOW);   //Turn off  
  digitalWrite(TL2_R, LOW);   //Turn off  
  //
  // Sonar I/O
  //
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT_PULLUP);
  //
  // Pins all set, anything not listed is a hi-Z input
  //
  // ============
  //
  // Turn on IR remote
  //
  irrecv.enableIRIn();
  //
  dht.begin();      //Fire up temp/humidity sensor
  //Serial.print("DHT pin: ");
  //Serial.println(DHTPIN);
  //
  //  Serial.println("Init 1602 LCD");
  //  Serial.println("LCD 1 test");
  // Print a message to the 1602 LCD
  lcd1.clear();
  lcd1.print("Hello, Mark!");
  delay(1500); // wait a bit to see it
  lcd1.setCursor(0, 1);
  lcd1.print("Hello, Again!");
  //
  //  Serial.println("LCD 2 test");
  //
  // Three LCD's - show something on 2004's
  //
  lcd2.init();  //initialize the lcd
  lcd2.backlight();  //open the backlight 
  lcd2.setCursor ( 0, 0 );            // go to the top left corner
  lcd2.print("Hello, Mark!");
  lcd2.setCursor ( 0, 1 );            // go to the 2nd row
  lcd2.print("Mark's Next Idea!");
  lcd2.setCursor ( 0, 2 );
  lcd2.print("Rick & Morty Box!");
  lcd2.setCursor ( 3, 3 );            // go to the 4th row
  lcd2.print("Version: ");
  lcd2.print(Version);
  //
  Serial.println("LCD 3 test");
  lcd3.init();  //initialize the lcd
  lcd3.backlight();  //open the backlight 
  lcd3.setCursor ( 0, 0 );            // go to the top left corner
  lcd3.print("Hello, Mark!"); // write this string on the top row
  lcd3.setCursor ( 0, 1 );            // go to the top left corner
  lcd3.print("LCD #3"); // write this string on the top row
  lcd3.setCursor ( 3, 3 );            // go to the 4th row
  lcd3.print("Version: ");
  lcd3.print(Version);
  //
  delay(2000); // wait a bit to see it
  //
  // RTC init
  // Initialize a new chip by turning off write protection and clearing the
  // clock halt flag. These methods needn't always be called. See the DS1302
  // datasheet for details.
  //
  // Turn clock on after power up
  //
  rtc.writeProtect(false);
  rtc.halt(false);
  rtc.writeProtect(true);
  //
  // BMP-180 or -280 init
  //
    /* Default settings from datasheet. */
  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,     /* Operating Mode. */
                  Adafruit_BMP280::SAMPLING_X2,     /* Temp. oversampling */
                  Adafruit_BMP280::SAMPLING_X16,    /* Pressure oversampling */
                  Adafruit_BMP280::FILTER_X16,      /* Filtering. */
                  Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */
  //
  lcd2.clear();
  lcd3.clear();
  Serial.println("Setup Complete");
  }
// ============================================
//
// SETUP ends
//
// ============================================
// ============================================
//
// LOOP BEGINS
//
// ============================================
/*
 * The idea here is to trigger different functions with the remote
 * The Temp/Humidity, time, distance, etc are selectively displayed on command
 * Everything but the RTC is curretly connected.
 */
 // Globals
int LastTouch = LOW;   // Hope this scope is universal
int LastLDR   = LOW;
int Coin      = LOW;
String IRval;
String LastIRCmd;
//
// Declaring vars inside SWITCH blows up
//
const int MaxUnitsN   = 60;    // Hard code for now
int minsTo12          =  0;   //12 * 60 = 720 max
int UnitsN            =  0;
int UnitsR            =  0;
// int valx              =  0;
int xxx               =     random(27);
int Rdg               = analogRead(Wiper) / 3;
Time t                =   rtc.time();    // Device data type
//
// Fall into runtime
//
void loop() 
  {
  //
  // Fast execution items lead
  //
  digitalWrite(TL_G, digitalRead(KnockSw));   // Works!
//  digitalWrite(TL_G, digitalRead(TouchSw));   // Works - sorta
  //
  // Servo needs to be responsive Move on both sides of clock tick
  //
//  MoveServo();            //Move servo to follow pot - for test
//  MotorStepper.step(205);   // Spin stepper for test
  //
  // Watch LDR and toggle accordingly
  // Actually we should only act on changes
  //
  int CurrentState = digitalRead(LDR_IN);
  //
  if (CurrentState != LastLDR)
    {
    LastLDR = CurrentState;
    if (CurrentState == HIGH)
      {
//      lcd2.clear();             // Clear before update
//      lcd3.clear();
      digitalWrite(TL_Y, HIGH);   // turn the LED on (HIGH is the voltage level)
      digitalWrite(K4, LOW);      // turn the relay off during the day
      lcd3.setCursor(0, 1);
      lcd3.print("Dark ");        // Trailing blank needed to cover the T in lighT
      }
    else
      {
      digitalWrite(TL_Y, LOW);   // turn the LED on (HIGH is the voltage level)
      digitalWrite(K4, HIGH);   // turn the relay on at night (HIGH is the active voltage level)
      lcd3.setCursor(0, 1);
      lcd3.print("Light");       //
      }
    //
    }
  //
  // This is tic-toc timer - items here are polled once a second
  // Tic is first half of second, toc is last half.
  //
  unsigned long currentMillis = millis();
  //
  if (currentMillis - previousMillis >= interval) 
    {
    //
    // Here every 500 ms
    //
    // save the last time you blinked the LED
    //
    previousMillis = currentMillis;
    //
    // if the LED is off turn it on and vice-versa:
    //
    if (Coin != HIGH) 
      {
      //
      // Tic 1/2 sec
      //
      Coin = HIGH;
      digitalWrite(LED_BUILTIN, HIGH);   // turn the heartbeat led on
      digitalWrite(TL_R, HIGH);   //Turn on
      lcd2.setCursor(19, 3);
      lcd2.print("|");        //Tick Symbol
      }
    else 
      {
      //
      // toc 1/2 sec
      //
      Coin = LOW;
      //
      digitalWrite(LED_BUILTIN, LOW);   // turn the heartbeat LED off
      digitalWrite(TL_R, LOW);   //Turn off  
      lcd2.setCursor(19, 3);
      lcd2.print("-");        //Tock Symbol
      //
      // Touch SW
      // Actually we should only act on changes
      // Still not working right
      //
        /*
      int NewState = digitalRead(TouchSw);
      //
      // Act on rising edge only
      //
      if ( (NewState != LastTouch) && (NewState == HIGH) )
        {
        LastTouch = NewState;
        Serial.print(NewState);

        if (digitalRead(K4) != HIGH)
          {
          digitalWrite(K4, HIGH);   // Touchy if running fast. only poll once a second to debounce
          digitalWrite(TL_G, LOW);   // Touchy if running fast. only poll once a second to debounce
          Serial.println("Touch Off");
          }
        else
          {
          digitalWrite(K4, LOW);   // Touchy if running fast. only poll once a second to debounce
          digitalWrite(TL_G, HIGH);   // Touchy if running fast. only poll once a second to debounce
          Serial.println("Touch On");
          }
        
        //
        }
        */
      //
      // Here every second ... We should load balance but for diags we run
      // all subs at once
      //
      // All of these work with correct IO assignments
      //
      ShowTime();       // Works!
      Read_DHT();       // Read/display temp/humidity
      RangeFinder();    // Compute range to target - I think I blew the sensor
      FindJoy();        // read joystick
      ShowAnalog();     // Display input voltages
      //
      // ****************************************
      // Bottom of Tic-Toc before IR remote added
      // ****************************************
      //
      // Both fast and slow I/O's have been polled
      // IR remote code is big switch. There are 21 different buttons with unique responses
      //
      // IR Remote needs to be shielded from other light sources
      // Umm dunno how fast we should poll this. Its fast polling now. 
      // but we might need to slow it down
      //
      CheckIR();
      //
      }     // End of tic/tock
    //
    }     // End of currentmills
  //
  }     // End of LOOP
// =============================================================================
// =============================================================================
// Functions
// =============================================================================
// =============================================================================
// ======================================================
//
// Function to read and display Temp Humidity from sensor
//
void Read_DHT()
  {
  float h, f;
  //
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  //
  h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  //    t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  f = dht.readTemperature(true);
  //
  // Display on LCD'S
  //
  // LCD2 is outdoor data - eventually - gotta build the remote first LOL
  //
  lcd2.setCursor ( 0, 2 );            // go to the 3rd row
  lcd2.print(String(h, 1) + "%");
  lcd2.setCursor ( 0, 3 );            // go to the fourth row
  lcd2.print(String(f, 1) + "F");
  //
  // LCD3 is indoor data
  //
  lcd3.setCursor ( 0, 2 );            // go to the 3rd row
  lcd3.print(String(h, 1) + "%");
  lcd3.setCursor ( 0, 3 );            // go to the fourth row
  lcd3.print(String(f, 1) + "F");
  //
  }
//
// End of Read_DHT()
//
// =======================================
// 
// MoveServo to where pot tells it to go
//
void MoveServo()
  {
  int valx = analogRead(Wiper);            // reads the value of the potentiometer (value between 0 and 1023)
  valx = map(valx, 0, 1023, 0, 180);     // scale it for use with the servo (value between 0 and 180)
  DoorServo.write(valx);                  // sets the servo position according to the scaled value
  AuxServo.write(valx);                // Both servos track for test
  lcd2.setCursor ( 10, 1 );            // go to the 3rd row
  lcd2.print(valx);
  lcd2.print(" Deg  ");
  }
// =======================================
//
// RTC Print time
//
void ShowTime()
  {
  // Get the current time and date from the chip.
  t = rtc.time();
  // Name the day of the week.
  //  const String day = dayAsString(t.day);
  // Format the time and date and insert into the temporary buffer.
  char buf[50];
  snprintf(buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d",
           t.yr, t.mon, t.date,
           t.hr, t.min, t.sec);
  //
  // Print the formatted string to serial so we can see the time.
  // Update both displays so time is always visible
  //
  lcd1.setCursor(0, 0);
  lcd1.print(buf);
  //
  lcd2.setCursor(0, 0);
  lcd2.print(buf);
  //
  lcd3.setCursor(0, 0);
  lcd3.print(buf);
  }
// ==================================================
//
// Range finder
//
void RangeFinder()
{
//
// Check to see if we should run at all
//
const int Tol = 1;  // Overlap between limits
if (EchoFlag != false)
  {
  // Serial.println("Ping!");
  float duration, distance, distinch;
  //
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  //
  duration = pulseIn(echoPin, HIGH);
  distance = (duration * .0343) / 2;
  distinch = (distance / 2.54); //Cm to inches
  //
  // Filter noise
  //
  if ((distance > 1.0 ) && (distance< 100.0))   // Inside Range gate?
    {
    //
    lcd2.setCursor(0, 1);
    lcd2.print("                    ");
    lcd2.setCursor(0, 1);
    lcd2.print(String(distinch, 1));
    lcd2.print(" in.");
    //
    if ( (distinch <= DistFar) && (distinch > DistMed) )
      {
        digitalWrite(TL2_G, HIGH);
      }
    else
      {
        digitalWrite(TL2_G, LOW);
      }
      //
    if ( (distinch <= DistMed) && (distinch > DistNear) )
      {
        digitalWrite(TL2_Y, HIGH);
      }
    else
      {
        digitalWrite(TL2_Y, LOW);
      }
      //
    if (distinch <= DistNear)
      {
        digitalWrite(TL2_R, HIGH);
      }
    else
      {
        digitalWrite(TL2_R, LOW);
      }
    //
    }
  else
    {
      // We're Out Of Range - say so
      lcd2.setCursor(0, 1);
      lcd2.print("OOR                 ");
      //
      // All off ? 
      // This may cause flicker
      //
        digitalWrite(TL2_R, LOW);
        digitalWrite(TL2_Y, LOW);
        digitalWrite(TL2_G, LOW);
    }   // Range gate closes
    //
  }   // Enable gate closes
else
  {
    // We're Off - update screen
    lcd2.setCursor(0, 1);
    lcd2.print("Off            ");
    //
    digitalWrite(TL2_R, LOW);
    digitalWrite(TL2_Y, LOW);
    digitalWrite(TL2_G, LOW);
  //
  }
  //
}
// ==================================================
//
// FindJoy - Read joystick analogs - Tested - Works
//
void FindJoy()
  {
  //  char tmp[80];
  int x, y;
  x = analogRead(Xaxis);
  y = analogRead(Yaxis);
  //
  String tmp = String(x);
  tmp = tmp + "X/";
  tmp = tmp + String(y);
  tmp = tmp + "Y";
  // Serial.println(tmp);
  lcd2.setCursor(6, 2);
  // "----X/----Y UP" <= 14 chars
  lcd2.print("              "); // <= 14 chars
  lcd2.setCursor(6, 2);
  lcd2.print(tmp);      // Col 7, row 3 + 14 chars just fits on 20 char line
  //
  // Print cursor is where tmo ended, tack on tail
  //
  if (digitalRead(Zaxis) != 0)
    {
    lcd2.print(" UP");
    }
  else
    {
    lcd2.print(" DN");      
    }
  //
  }   // End of FindJoy
// ==================================================
//
// ShowAnalog - Read voltage analog
//
void ShowAnalog()
  {
  int VoltageRaw = analogRead(VinAux5);   // Not yet wired
  String tmp = String(VoltageRaw * VoltsPerBit, 1) + "V";
  lcd3.setCursor(15, 1);
  lcd3.print("     ");
  lcd3.setCursor(15, 1);
  lcd3.print(tmp);
  //
  // Read & Display pot wiper - Currently driving servo position
  //
  VoltageRaw = analogRead(Wiper);
  tmp = String(VoltageRaw * VoltsPerBit, 1) + "V";
  lcd3.setCursor(15, 2);
  lcd3.print("     ");
  lcd3.setCursor(15, 2);
  lcd3.print(tmp);
  //
  // This input is scaled down by a factor of 5 due to input card.
  // This input monitors the internal Aux +5 power buss that powers the relays, motors, servos, etc.
  //
  VoltageRaw = analogRead(VinAux5);   // Aux +5 powers motors
  //
  float Work = VoltageRaw * VoltsPerBit * 5;
  //
  float Nominal   = 5.0;
  float Tolerance = 0.2;    //In Spec band
  //
  // Keep tmp strings equal lemngth
  //
  tmp = "Aux";
  if ((Work >= (Nominal - Tolerance)) && (Work <= (Nominal + Tolerance)))
    {
      // Aux Power Good
      tmp = tmp + " Ok";      
    }
  else
    {
      // Motors down
      tmp = "No " + tmp;
    }
  //
  lcd3.setCursor(14, 3);
  lcd3.print(tmp);
  //
  }   // End of ShowAnalog
// =====================================
//
// Pulses relay output for passed time
//
void Pulse(int x)  //Fire Relay for specified MS - no return value
  {
  SetTo(HIGH);
  // Serial.print("Pulse: ");
  // Serial.print(x);
  // Serial.print(" Ms");
  delay(x);                       // wait for three seconds for door to open a bit
  SetTo(LOW);
  //
  }
// ======================================
//
// Function to read and display random analog
//
int Read_Analog(int AnalogPin)
  {
  //
  // Analog testbed
  valx = analogRead(AnalogPin);  // read the input pin
  Serial.print("AI #");
  Serial.print(AnalogPin, HEX);
  Serial.print(": ");
  Serial.println(valx);          // debug value
  return valx;
  }
// ============================================
//
// Sets/clears Relay and LED, Pass HIGH/LOW
//
int SetTo(int x)
  {
  digitalWrite(K2, x);            // turn the LED on (HIGH is the voltage level)
  digitalWrite(LED_BUILTIN, x);   // turn the LED on (HIGH is the voltage level)
  }
// ============================================
//
void CheckIR()
{

const String LockCombo = "ECB";   // Min combo is three chars
String LockEntryA;  // Remember Entry, not code
String LockEntryB;  // 11 chars max "A-B B-C C-D"
String LockEntryC;  // 11 chars max "A-B B-C C-D"
String LockEntry;  // 11 chars max "A-B B-C C-D"
//
 char *myStrings[] = {
      "Soitenly!", 
      "It is decidedly so", 
      "Absolutely", 
      "Yes, definitely",
      "Bet on it!", 
      "As I see it, Yeah", 
      "Maybe, maybe not", 
      "Si! Si!",
      "YES!", 
      "I wouldn't", 
      "NEVER!", 
      "Why not?", 
      "Unclear", 
      "Have a bowl ...", 
      "Can't lie, no", 
      "No telling", 
      "Think & ask again", 
      "Fuggedaboutit!", 
      "My guess is no", 
      "Don't ask ME!", 
      "Could be worse", 
      "STFU!", 
      "Pbbbbttt!", 
      "Nonya bidness", 
      "MYOB", 
      "Fuck off!", 
      "Wubba lubba dub dub", 
      "No way, Jose!" 
      };
  //
  //
  if (irrecv.decode(&results))
  {
    // Display what we got
    //
    valx     = abs(results.value);   // no negatives
    IRval   = String( abs(valx) );   // no negatives
    IRval.trim();   //Strange Syntax
    LastIRCmd.trim();
    //
    // Catch value
    //
    if ( (valx > 0) && (LastIRCmd != IRval))
    {
      if (IRval != "")
      {
        LastIRCmd = IRval;
        LastIRCmd.trim();
      }
    //
    }
    //
    // Live command when received
    //
    Serial.print("RXD:  = ");
    valx = abs(valx);
    Serial.println(valx);
    //
    // Ok, No silly negatives, Each button sends a code, both remotes send
    // the same code for the same physical button
    //
    // =============================
    // =============================
    // Main control switch on remote command
    // =============================
    // =============================
    //   
    if (valx >= 1)      // Triple filter out negs
        {
        Serial.println(valx);
        switch (valx)    //Needs integer for switch
          {
          //
          // Button codes in table up front - all tested & work
          //
          case Btn_00:
            Serial.println("btn 00");
          break;
          // =================
          case Btn_01:
            Serial.println("btn 01");
            //
//              irrecv.resume();    // fix? 
            //
            // Magic 8-ball
            // Blank for 3 seconds
            // Throw random number & display message
            // wait 3 seconds
            // clear and release lock
            //
            lcd2.noBacklight();
            lcd3.noBacklight();
            lcd2.clear();             // Clear before update
            delay(3000);
            lcd2.backlight();
            //
            // Get random number
            //
            xxx       = random(27);
            //
            // Magic 8-ball responses
            //
            lcd3.noBacklight();   // Blank aux display
            lcd2.backlight();     // Fire up primary
            lcd2.setCursor(0, 0);
            lcd2.print(myStrings[xxx]);
            delay(1000);
            //
            lcd2.setCursor(1, 1);
            lcd2.print(myStrings[xxx]);
            delay(1000);
            //
            lcd2.setCursor(2, 2);
            lcd2.print(myStrings[xxx]);
            delay(1000);
            //
            lcd2.setCursor(3, 3);
            lcd2.print(myStrings[xxx]);
            delay(1000);
            //
            lcd2.clear();             // Clear before update
            lcd3.backlight();         //  Turn aud LCD back on
            //           
          break;
          // =================
          case Btn_02:
            Serial.println("btn 02");
            //
            // Make this insulin calculator
            //
            // Assuming shots at noon & midnight
            // this will pro-rate the shot based
            // on hours remaining until next shot.
            // the closer to the time the less N
            // that is needed. R is computed as
            // 10% of the last reading rounded to the nearest 5
            // We'll use the pot analog as an input device
            // for inputting the current blood sugar reading for
            // the R computation.
            // The shots are based on my personal needs of 
            // 65 AM and 55 PM but I might make it read from the
            // the pot too
            // 
            lcd2.noBacklight();   // Kill LCD2
            lcd3.clear();
            lcd3.backlight();
            //
            // Start clean
            //
            lcd3.print("Insulin Pro-Rater");
            lcd3.setCursor(0, 1);
            lcd3.print("Dial in Current BS &");
            lcd3.setCursor(0, 2);
            lcd3.print("Press Joystick Btn:");
            lcd3.setCursor(0, 3);
            lcd3.print("Reading: ");
            //
            while (digitalRead(Zaxis) != 0)
              {
                //
                // show live reading
                //
                lcd3.setCursor(9, 3);
                lcd3.print("     ");
                lcd3.setCursor(9, 3);
                lcd3.print(analogRead(Wiper)/3);
                delay(20);  //Reduce display flicker
              }
            loop;
            // 
            // Wait fast for button release
            //
            while (digitalRead(Zaxis) == 0)
              {
              }
            loop;
            //
            // Button released, use last reading
            //
            lcd3.clear();
            //
            // Lets see if this blows up switch
            //
            Rdg = analogRead(Wiper) / 3;
            lcd3.setCursor(0, 0);
            lcd3.print("Reading: ");
            lcd3.print(Rdg);
            lcd3.print(" mg/dL");
            //
            t = rtc.time();
          //
            if (t.hr < 12)
              {
                // 12 - hour, midnight to noon is 55 units
              UnitsN = MaxUnitsN - 5;     // Default to nominal units -5
              minsTo12 = (11 - t.hr) * 60 + (60 - t.min);
              }
            //
            if (t.hr >= 12)
              {
                // 24 - hour
              UnitsN = MaxUnitsN + 5;     // Default to nominal units +5
              minsTo12 = (23 - t.hr) * 60 + (60 - t.min);
              }
            //
            lcd3.setCursor(2, 1);
            lcd3.print("Take ");
            UnitsN = MaxUnitsN * minsTo12 / 720;
            lcd3.print( UnitsN );
            lcd3.print(" units N");
            //
            UnitsR = Rdg / 10;
            lcd3.setCursor(2, 2);
            lcd3.print("Take ");
            lcd3.print(UnitsR);
            lcd3.print(" units R");
            //
            lcd3.setCursor(0, 3);
            lcd3.print("Total: ");
            lcd3.print(UnitsN + UnitsR);
            lcd3.print(" units");
            //
            // Wait fast
            //
            while (digitalRead(Zaxis) != 0)
              {
              }
            loop;
            //
            // Clean up on exit
            //
            lcd3.clear();
            lcd2.backlight();   // Turn #2 back on
            //            
          break;
          // =================
          // 2nd Row
          //
          case Btn_10:
            Serial.println("btn 10");
            //
            // Toggle VU display mode
            //
            if (VUMode != VURadio)
            {
              VUMode = VURadio;
              digitalWrite(K5, LOW);
              digitalWrite(K6, LOW);
              Serial.println("VU Radio");
              lcd2.setCursor(6, 3);
              lcd2.print("VU Radio");
            }
            else
            {
              VUMode = VUPWM;
              digitalWrite(K5, HIGH);
              digitalWrite(K6, HIGH);              
              Serial.println("VU PWM");
              lcd2.setCursor(6, 3);
              lcd2.print("VU PWM  ");
            }
          break;
          // =================
          case Btn_11:
            Serial.println("btn 11");
            //
            // enable/disable rangefinder
            //
            if (EchoFlag != true)
              {
              EchoFlag = true;
              }
            else
              {
              EchoFlag = false;
              }
          break;
          // =================
          case Btn_12:
            Serial.println("btn 12");
            //
            // Simulate a PO box lock.
            // Turn pot to dial setting
            // Click Joystick to enter #
            //
            lcd2.noBacklight();   // Kill LCD2
            lcd3.clear();
            lcd3.backlight();
            //
            // Start clean
            //
            lcd3.clear();
            lcd3.print("PO Box Sim");
            lcd3.setCursor(0, 1);
            lcd3.print("First Code &");
            lcd3.setCursor(0, 2);
            lcd3.print("Press Joystick Btn:");
            lcd3.setCursor(0, 3);
            lcd3.print("Code: ");
            //
            while (digitalRead(Zaxis) != 0)
              {
                //
                // show live reading - 3 chars
                //
                lcd3.setCursor(6, 3);
                lcd3.print("   ");
                lcd3.setCursor(6, 3);
                //
                // We wanna map 0-1023 to 0-19 & display
                // letters
                //              
                lcd3.print(LockTable[ map( analogRead(Wiper), 0, 1023, 0, 19) ] );
                //
                delay(20);  //Reduce display flicker
              }
            loop;
            // 
            // Wait fast for button release
            //
            while (digitalRead(Zaxis) == 0)
              {
              }
            loop;
            //
            // Button released, use last reading
            //
            LockEntryA = LockTable[map( analogRead(Wiper), 0, 1023, 0, 19)];
            //
            lcd3.clear();
            lcd3.print("PO Box Sim");
            lcd3.setCursor(0, 1);
            lcd3.print("Second Code &");
            lcd3.setCursor(0, 2);
            lcd3.print("Press Joystick Btn:");
            lcd3.setCursor(0, 3);
            lcd3.print("Code: ");
            //
            while (digitalRead(Zaxis) != 0)
              {
                //
                // show live reading - 3 chars
                //
                lcd3.setCursor(6, 3);
                lcd3.print("   ");
                lcd3.setCursor(6, 3);
                //
                // We wanna map 0-1023 to 0-19 & display
                // letters
                //              
                lcd3.print(LockTable[ map( analogRead(Wiper), 0, 1023, 0, 19) ] );
                //
                delay(20);  //Reduce display flicker
              }
            loop;
            // 
            // Wait fast for button release
            //
            while (digitalRead(Zaxis) == 0)
              {
              }
            loop;
            //
            // Button released, use last reading
            //
            LockEntryB = LockTable[ map( analogRead(Wiper), 0, 1023, 0, 19)] ;
            //
            lcd3.clear();
            lcd3.print("PO Box Sim");
            lcd3.setCursor(0, 1);
            lcd3.print("Final Code &");
            lcd3.setCursor(0, 2);
            lcd3.print("Press Joystick Btn:");
            lcd3.setCursor(0, 3);
            lcd3.print("Code: ");
            //
            while (digitalRead(Zaxis) != 0)
              {
                //
                // show live reading - 3 chars
                //
                lcd3.setCursor(6, 3);
                lcd3.print("   ");
                lcd3.setCursor(6, 3);
                //
                // We wanna map 0-1023 to 0-19 & display
                // letters
                //              
                lcd3.print(LockTable[ map( analogRead(Wiper), 0, 1023, 0, 19) ] );
                //
                delay(20);  //Reduce display flicker
              }
            loop;
            // 
            // Wait fast for button release
            //
            while (digitalRead(Zaxis) == 0)
              {
              }
            loop;
            //
            // Button released, use last reading
            //
            LockEntryC = LockTable[map( analogRead(Wiper), 0, 1023, 0, 19) ];
            //
            lcd3.clear();
            lcd3.print("PO Box Sim");
            lcd3.setCursor(0, 1);
            lcd3.print("Code: ");
            lcd3.print(LockEntryA);
            lcd3.print(" ");
            lcd3.print(LockEntryB);
            lcd3.print(" ");
            lcd3.print(LockEntryC);
            lcd3.setCursor(1, 2);
            // 
            LockEntry = LockEntryA;
            LockEntry += LockEntryB;
            LockEntry += LockEntryC;
            Serial.print(" Entered: ");
            Serial.println(LockEntry);
            Serial.print("Required: ");
            Serial.println(LockCombo);
            //
            if (LockEntry == LockCombo)
              {
              lcd3.print("Access GRANTED.");
              DoorServo.write(UnLockAngle);
              delay(3000);
              DoorServo.write(LockAngle);
              }
            else
              {
              lcd3.print("ACCESS DENIED!");              
              delay(3000);
              }
          //
          lcd3.clear();
          lcd2.backlight();
          //
          break;
          // =================
          // 3rd Row
          //
          case Btn_20:
            Serial.println("btn 20");
//            tone(VURight, 1000);
            Serial.println("Tone on");
          break;
          // =================
          case Btn_21:
            Serial.println("btn 21");
//            noTone(VURight);
            Serial.println("Tone off");
          break;
          // =================
          case Btn_22:
            Serial.println("btn 22");
          break;
          // =================
          // 4th Row
          //
          case Btn_30:
            Serial.println("btn 30");
            //
            // Toggle LCD2 backlight
            //
            if (lcd2light != true)
              {
              lcd2light = true;
              lcd2.backlight();
              Serial.println("LCD2 On");
              }
            else
              {
              lcd2light = false;
              lcd2.noBacklight();
              Serial.println("LCD2 Off");
              }
          break;
          // =================
          case Btn_31:
            Serial.println("btn 31");
          break;
          // =================
          case Btn_32:
            Serial.println("btn 32");
          break;
          // =================
          // 5th Row
          //
          case Btn_40:
            Serial.println("btn 40");
            //
            // Toggle LCD3 backlight
            //
            if (lcd3light != true)
              {
              lcd3light = true;
              lcd3.backlight();
              Serial.println("LCD3 On");
              }
            else
              {
              lcd3light = false;
              lcd3.noBacklight();
              Serial.println("LCD3 Off");
              }
          break;
          // =================
          case Btn_41:
            Serial.println("btn 41");
          break;
          // =================
          case Btn_42:
            Serial.println("btn 42");
            //
            // Toggle LCD1 backlight
            //
            if (lcd1light != true)
              {
              lcd1light = true;
              lcd1.backlight();
              Serial.println("LCD1 On");
              }
            else
              {
              lcd1light = false;
              lcd1.noBacklight();
              Serial.println("LCD1 Off");
              }
          break;
          // =================
          // 6th Row
          //
          case Btn_50:
            Serial.println("btn 50");
            //
            // Rotate stepper 1/4 turn CCW
            // Next command stops system until motion is complete
            //
            MotorStepper.step(StepsPerRevolution/4);   // Spin stepper         
            break;
          // =================
          case Btn_51:
            Serial.println("btn 51");
          break;
          // =================
          case Btn_52:
            Serial.println("btn 52");
            //
            // Rotate stepper 1/4 turn CW
            //
            MotorStepper.step(-StepsPerRevolution/4);   // Spin stepper
          break;
          // =================
          // 7th and last Row
          //
          // Servo test
          //
          case Btn_60:
            Serial.println("btn 60");
            lcd3.setCursor(6, 2);
            lcd3.print("Locked.");
            DoorServo.write(LockAngle);                  // sets the servo position according to the scaled value
            AuxServo.write(LockAngle);                // Both servos track for test
          break;
          // =================
          case Btn_61:
            Serial.println("btn 61");
            lcd3.setCursor(6, 2);
            lcd3.print("- - - -");
            DoorServo.write(MidAngle);                  // sets the servo position according to the scaled value
            AuxServo.write(MidAngle);                // Both servos track for test
          break;
          // =================
          case Btn_62:
            Serial.println("btn 62");
            lcd3.setCursor(6, 2);
            lcd3.print("OPEN!  ");
            DoorServo.write(UnLockAngle);                  // sets the servo position according to the scaled value
            AuxServo.write(UnLockAngle);                // Both servos track for test
            delay(3000);
            lcd3.setCursor(6, 2);
            lcd3.print("Locked.");
            DoorServo.write(LockAngle);                  // sets the servo position according to the scaled value
            AuxServo.write(LockAngle);                // Both servos track for test
          break;
          // =================
          //
          // SWITCH VAL ENDS
          //
          }
      //
      }   // If Val ends
      //
    }   // Decode ends
  //
  // Resume IR control - not really sure what this does.
  //
  irrecv.resume();    
  //
}
// ==================================================
// ==================================================
// FIN
// ==================================================
// ==================================================