Easy-Connect-Software-PreloadV227

From ArduinoInfo
Jump to: navigation, search

PRELOAD SKETCH V227 TO RELOAD the PreProgrammed EasyConnect board

This page will be updated if another release is done... Questions? terry@yourduino.com

You will need to download and install the 3 libraries shown to your Arduino IDE. In the Arduino IDE Go to SKETCH>INCLUDE LIBRARY> Add ZIP Library and navigate to the Zip. You will use the Arduino Library Manager to find and install the Irremote library. See link below.

LIBRARIES YOU WILL NEED TO DOWNLOAD AND INSTALL:

media:DHTNEW.zip

media:LED_flasher.zip

media:Newliquidcrystal_1.3.5.zip

Installing Arduino Libraries (Link):]

Click on the link above to understand how to install libraries in Arduino. The libraries shown are .ZIP files you need to download.

IRremote library is installed with the Arduino Library Manager. Search for "IRremote" in that manager.

CUT/PASTE to ARDUINO IDE BLANK WINDOW


[code]

/* YourSmartDuino-EM

 - WHAT IT DOES: Provides several preprogrammed lessons options for users
 - Uses the KEYES Easy-Plug Modules
 - V2.26 3/2/2019   TRAFFIC LIGHT SYSTEM WORKING
 NOTES:  IR Remote  TimerFreeTone  NewPing: TIMER_ENABLED set false in newping.h
  Questions: terry@yourduino.com
 - SEE the comments after "//" on each line below
 - CONNECTIONS: KEYES Easy-Plug Control Board V2.0
 D2A6A7  ks0245 keyestudio EASY plug Joystick Module
 D3D4    ks0242 keyestudio EASY plug SR01 Ultrasonic Module
 5       ks0125 keyestudio EASY plug IR Receiver Module
 6       ks0101 keyestudio EASY plug Digital White LED Module
 7       ks0102 keyestudio EASY plug Active Buzzer Module
 8       ks0129 keyestudio EASY plug DHT11 Temperature and Humidity Sensor
 9       ks0122 keyestudio EASY plug PIR Motion Sensor
 10 *    ks0115 keyestudio EASY plug Digital Tilt Sensor Module  [ON SPI CONNECTOR ]
 10 *    ks0112 keyestudio EASY plug Digital Push Button
 10 *    ks0113 keyestudio EASY plug Capacitive Touch Sensor
 11      Unavailable: SPI use only
 12      Unavailable: SPI use only
 7 *     ks0228 keyestudio EASY plug Digital Red LED Module    [OPTIONAL: SHARED]
 8 *     s0229 keyestudio EASY plug Digital Green LED Module
 9 *     ks0230 keyestudio EASY plug Digital Yellow LED Module
 A0      ks0109 keyestudio EASY plug Analog Rotation Sensor
 A1      ks0106 keyestudio EASY plug Photocell Sensor
 A2      SERVO http://www.yourduino.com/sunshop/index.php?l=product_detail&p=238
 A3      Available for General Use
 A4 A5   ks0137 keyestudio EASY plug 1602 LCD I2C Module


 /*-----( Import needed libraries )-----*/
  1. include "IRremote.h" // For handheld remote
  2. include <LedFlasher.h> // From Nick Gammon
  1. include <Wire.h> // Comes with Arduino IDE for I2C support

// Get the LCD I2C Library here: // https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads // Move any other LCD libraries to another folder or delete them // See Library "Docs" folder for possible commands etc.

  1. include <LiquidCrystal_I2C.h>
  1. include <dhtnew.h> // DHT11 Temperature-Humidity Sensor

// [Rob Tillaart's new version: It finds out what module is being used..]

/*----------------( Declare Constants and Pin Numbers )-------------------*/ // NOTE: PWM Pins = 3,5,6,9,10,11

//----- ( 3 pins in socket labelled D2A6A7 can be used for JoyStick )-----

  1. define X_AXIS_PIN A7 /*----(Joystick Pin connections)----*/
  2. define Y_AXIS_PIN A6
  3. define Z_SWITCH_PIN 2

//----- ( 2 pins in socket labelled D3 D4 can be used for Ultrasonic )-----

  1. define ULTRA_TRIG_PIN 3 // Connect to socket labelled "D3D4
  2. define ULTRA_ECHO_PIN 4
  1. define IR_RECEIVER_PIN 5 // Connect always, at beginning to select lessons
  2. define LED_MODULE_PIN 6
  1. define RED_LIGHT 6 // Traffic Lights
  2. define YELLOW_LIGHT 7
  3. define GREEN_LIGHT 8
  4. define WALK_LIGHT 9

//-------( Multiple uses of these pins )--------------

  1. define BUZZER_PIN 7
  1. define DHT11_PIN 8 // Temperature/Humidity Sensor
  2. define LED_MODULE_INVERT 8 // To show Fix It In Software
  1. define PIR_MOTION_PIN 9
  2. define STROBE_LED_PIN 9
  3. define WALK_LED_PIN 9 // ??

//----- ( 3 pins in socket labelled SPI )-----

  1. define SWITCH1_PIN 10 // in SPI connector
  2. define SPI_Unavailable11 11
  3. define SPI_Unavailable12 12
  1. define ONBOARD_LED_PIN 13 // also in SPI connector
  1. define ROTATION_PIN A0 // Analog inputs from Potentiometer etc.
  2. define REQUEST_WALK_PIN A0 // Digital request traffic walk
  3. define LIGHT_SENSOR_PIN A1 // Photoresistor
  4. define VEHICLE_SENSE_PIN A1
  5. define SERVO_PIN A2
  6. define SWITCH2_PIN A3 // Used for a variety of On-OFF Devices

// NOTE: Pins A4 and A5 in "I2C socket and are used for I2C communication to LCD Display

  1. define I2C_SDA_PIN A4 // I2C Interface OR Joystick ???
  2. define I2C_SCL_PIN A5


  1. define ForEver true // For use in looping
  2. define ON 1
  3. define OFF 0
  4. define DarkValue 500 // Onboard Light Sensor
  1. define ServoMIN 20 // Don't go to very end of servo travel
  2. define ServoMAX 160 // which may not be all the way from 0 to 180.
  1. define MAX_DISTANCE 300 // Maximum distance we want to ping for (in centimeters).
  2. define US_ROUNDTRIP_CM 58.2 // Ultrasonic Sensor constant

//-----( Traffic Control System States )-------

  1. define GREEN_STATE 0
  2. define CAUTION_STATE 1
  3. define RED_STATE 2
  4. define WALKING_STATE 3
  5. define WALK_FAST_STATE 4
  1. define MaxGreenSeconds 20
  2. define MinGreenSeconds 10
  3. define YellowSeconds 5
  4. define MaxRedSeconds 10

/*--------------------( Declare objects )-------------------------*/ IRrecv irrecv(IR_RECEIVER_PIN); // create instance of 'irrecv' decode_results results; // create instance of 'decode_results'

int Led13OnTime = 100; int Led13OffTime = 900; LedFlasher LED13 (ONBOARD_LED_PIN, Led13OffTime, Led13OnTime); // OffTime, OnTime

LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Define the LCD Display

DHTNEW Temp_Humid_Sensor(DHT11_PIN); // Define the DHT11 Temperature / humidity sensor

/*------------------------( Declare Variables )-----------------------------------*/

int OptionNumber = 0; // Option as picked by IR Remote int KnobValue; // Analog values from 0..1023 int PhotosensorValue; // Analog values from 0..1023

int Xvalue; /*----(Values we will read from the Joystick)----*/ int Yvalue; int Zvalue;

unsigned long StrobeLastMs ; unsigned long StrobeLedOnTime = 10L ; // Variables for Strobe LED unsigned long StrobeLedOffTime = 1000L ; boolean InStrobeTime = false; boolean StrobeIsOn = false;

int ServoPosition ;

long duration_uS; // Duration used to calculate distance by Ultrasonic Sensor int DistCM; // Measured distance in CM

boolean ShowedON = false; boolean ShowedOFF = false;

int TrafficControlState = 0; ///---( For Traffic Light Control example )---- int StateDelaySeconds; // Variable set for Traffic Light sequence states boolean TrafficSenseCall = false; boolean WalkerSenseCall = false;


void setup() /******************* SETUP: RUNS ONCE *************************/ {

 Serial.begin(115200);        // Start up the Serial Monitor
 lcd.begin(16, 2);  // initialize the lcd for 16 chars 2 lines, turn on backlight
 lcd.noBacklight();
 delay(500);
 lcd.backlight(); // finish with backlight on
 lcd.setCursor(0, 0); //Start at character 0 on line 0
 lcd.print(F("YourSmart!Duino"));
 lcd.setCursor(0, 1); //Start at character 0 on line 0
 lcd.print(F("YourDuino.com"));
 irrecv.enableIRIn(); // Start the IR Remote receiver
 pinMode(LED_MODULE_PIN, OUTPUT);
 pinMode(LED_MODULE_INVERT, OUTPUT);
 pinMode(ONBOARD_LED_PIN, OUTPUT);
 pinMode(SERVO_PIN, OUTPUT);
 pinMode(BUZZER_PIN, OUTPUT);
 pinMode(SWITCH2_PIN, INPUT_PULLUP);
 pinMode(SWITCH1_PIN, INPUT_PULLUP);
 pinMode(ULTRA_TRIG_PIN, OUTPUT);
 pinMode(ULTRA_ECHO_PIN, INPUT);
 pinMode(Z_SWITCH_PIN, INPUT_PULLUP); // Use built-in pullup resistor


 LED13.begin ();
 Serial.println("YourDuino.com EasyConnect system preload V2.26 3/2/2019");
 delay(200);

}//--(end setup )---


void loop() /********************** LOOP: RUNS CONSTANTLY ************************/ {

 switch (OptionNumber)
 {
   case 0:
     /*-------------( Option 0: DIGITAL OUTPUT )---------------
        Blinks Morse Code "HI" on pins 7 and 13.
        User sees blink on onboard LED pin 13.
        User uses a cable to connect bright LED brick to pin 7
        User connects buzzer brick to LED_MODULE_PIN (7) so Morse is audible.
        Morse is discussed. Digital is discussed. Look at cables and colors.
     */
     {
       Serial.println("Option 0");
       do
       {
         BlinkHiSimple();
         //--------( Check if user has sent a IR Remote Command )------------------------------
         if (irrecv.decode(&results)) // have we received an IR signal?
         {
           translateIR();   // Translate the IR data, and change the Option Number
           irrecv.resume(); // receive the next value
         }
       } while (OptionNumber == 0);  // Loop here "ForEver" or until a different option requested
       break;
     } // END case 0


   case 1:   /*-------------( Option 1: DIGITAL INPUTS )---------------
       User connects different switches to A3
        User pushes button brick, ON-OFF, TRUE-FALSE, 1-0, HIGH-LOW discussed.
        Other bricks are connected to pin A3: Tilt, Vibration, Motion Detect
        Bare wires connected to pin A3; conductors/insulators discussed.
        Bright LED reconnected to pin 6: lights when switch is ON.
  • /
     {
       Serial.println("Option 1");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       lcd.print(F("1: SWITCH ON/OFF"));
       pinMode(A3, INPUT_PULLUP);


       do
       {
         if    ((digitalRead(SWITCH1_PIN)   == LOW)
                or     (digitalRead(SWITCH2_PIN)   == LOW))
         {
           digitalWrite(LED_MODULE_PIN, HIGH);
           digitalWrite(BUZZER_PIN,     HIGH);
           digitalWrite(LED_MODULE_INVERT, LOW); // Fix It In Software
           if (!ShowedON)
           {
             lcd.setCursor(0, 1); //Start at character 0 on line 0
             lcd.print(F("IT'S ON! 1 HIGH "));
             LED13.on ();
           }
           ShowedON = true;
           ShowedOFF = false;
         }
         else
         {
           digitalWrite(LED_MODULE_PIN, LOW);
           digitalWrite(BUZZER_PIN,     LOW);
           digitalWrite(LED_MODULE_INVERT, HIGH);
           if (! ShowedOFF)
           {
             lcd.setCursor(0, 1); //Start at character 0 on line 0
             lcd.print(F("IT'S OFF! 0 LOW  "));
             LED13.off ();
           }
           ShowedOFF = true;
           ShowedON = false;
         }
         LED13.update ();
       } while (ForEver);  // Loop here "ForEver" or RESET
     }// END case 1


   //-----------------------------------------------------------------------------------------
   case 2: //------------( ANALOG MEASUREMENTS - LCD )-----------------------
     {
       Serial.println("Option 2");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       lcd.print(F("2:Analog to LCD"));
       delay(4000);
       do
       {
         KnobValue = analogRead(ROTATION_PIN);   // Read the position of the Potentiometer
         lcd.setCursor(0, 0); //Start at character 0 on line 0
         lcd.print(F("ANALOG VALUES: "));
         lcd.setCursor(0, 1); //Start at character 0 on line 1
         lcd.print(F("          "));
         lcd.setCursor(0, 1); //Start at character 0 on line 1
         lcd.print(F("KNOB"));
         lcd.print(KnobValue);
         PhotosensorValue = analogRead(LIGHT_SENSOR_PIN);   // Read the light sensor
         lcd.setCursor(9, 1); //Start at character 8 on line 1
         lcd.print(F("          "));
         lcd.setCursor(9, 1); //Start at character 0 on line 0
         lcd.print(F("LITE"));
         lcd.print(PhotosensorValue);
         LED13.update ();
         delay(1000);
       } while (ForEver);  // Loop here "ForEver" or RESET
     } // END case 2
   //------------------------------------------------------------------------------------------


   case 3: // ANALOG IN OUT STROBE
     /*-------------------( Option 3: ANALOG IN / OUT / STROBE )-------------------------------
        Analog variable from user's Potentiometer on A3
        Dimming of Bright LED on LED_MODULE Pin 6
        Strobe blink speed on STROBE LED on Pin 9
        Servo Position on pin A2
     */
     {
       Serial.println("Option  3");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       //-------------------1234567890123456----------
       lcd.print(F("3:KNOB sets LEDS"));
       do
       {
         KnobValue = analogRead(ROTATION_PIN);   // Read the position of the Potentiometer
         if (KnobValue < 15) {
           KnobValue = 0;
         }
         analogWrite(LED_MODULE_PIN, ((KnobValue / 4) ) );
         /*-----------( Set up and control strobe frequency and duration )-----------------------------*/
         StrobeLedOffTime = (1023 - KnobValue) / 2L;  // Set Strobe parameters from Analog Input
         StrobeLedOnTime  = StrobeLedOffTime / 10L;
         if (InStrobeTime)
         {
           if
           (
             ((StrobeLastMs + StrobeLedOnTime) < millis())
             &&
             StrobeIsOn
           )
           {
             StrobeIsOn = false;
             digitalWrite(STROBE_LED_PIN, LOW);
           }
           if
           (
             ((StrobeLastMs + StrobeLedOnTime + StrobeLedOffTime) < millis())
             &&
             ! StrobeIsOn
           )
           {
             InStrobeTime = false;
           }


         } // END InStrobeTime
         else // Begin another Strobe cycle
         {
           StrobeLastMs = millis();
           InStrobeTime = true;
           digitalWrite(STROBE_LED_PIN, HIGH);
           StrobeIsOn   = true;
         }
         /*----Set Servo position from Potentiometer value and Send Servo Position to Servo )-----*/
         ServoPosition  = map((1023 - KnobValue), 0, 1023, 900 , 2000);
         PointServo(ServoPosition);
         LED13.update ();
       } while (ForEver);  // Loop here "ForEver" or RESET
     } // END case 3
   //-------------------------------------------------------------------


   case 4: // TEMPERATURE / HUMIDITY
     {
       Serial.println("Option 4");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       //-------------------1234567890123456----------
       lcd.print(F("4: Temp-Humidity"));
       lcd.setCursor(0, 1); //Start at character 0 on line 0
       lcd.print(F("DHT11 Sensor "));
       delay(4000);
       do
       {
         Temp_Humid_Sensor.read();
         delay(1000);
         lcd.setCursor(0, 0); //Start at character 0 on line 0
         lcd.print("Humidity   = ");
         lcd.print((float)Temp_Humid_Sensor.humidity, 0);
         lcd.print("%");
         lcd.setCursor(0, 1); //Start at character 0 on line 1
         lcd.print("Temperature= ");
         lcd.print((float)Temp_Humid_Sensor.temperature, 0);
         lcd.print("C");
       } while (ForEver);  // Loop here "ForEver" or RESET
     } // END case 4
   case 5:  // IR REMOTE
     {
       Serial.println("Option 5");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       //-------------------1234567890123456----------
       lcd.print(F("5: SHOW REMOTE  "));
       lcd.setCursor(0, 1); //Start at character 0 on line 1
       lcd.print(F("Press a button"));
       do
       {
         delay(100);
         //--------( Check if user has sent a IR Remote Command )------------------------------
         if (irrecv.decode(&results)) // have we received an IR signal?
         {
           lcd.setCursor(0, 1); //Start at character 0 on line 0
           lcd.print(F("                 "));   // Blank out previous line
           lcd.setCursor(0, 1); //Start at character 0 on line 0 for following print
           switch (results.value)
           {
             case 0xFF629D: lcd.print(F(" FORWARD")); break;
             case 0xFF22DD: lcd.print(F(" LEFT"));    break;
             case 0xFF02FD: lcd.print(F(" -OK-"));    break;
             case 0xFFC23D: lcd.print(F(" RIGHT"));   break;
             case 0xFFA857: lcd.print(F(" REVERSE")); break;
             case 0xFF6897: lcd.print(F(" 1")); break;
             case 0xFF9867: lcd.print(F(" 2")); break;
             case 0xFFB04F: lcd.print(F(" 3")); break;
             case 0xFF30CF: lcd.print(F(" 4")); break;
             case 0xFF18E7: lcd.print(F(" 5")); break;
             case 0xFF7A85: lcd.print(F(" 6")); break;
             case 0xFF10EF: lcd.print(F(" 7")); break;
             case 0xFF38C7: lcd.print(F(" 8")); break;
             case 0xFF5AA5: lcd.print(F(" 9")); break;
             case 0xFF42BD: lcd.print(F(" *")); break;
             case 0xFF4AB5: lcd.print(F(" 0")); break;
             case 0xFF52AD: lcd.print(F(" #")); break;
             case 0xFFFFFFFF: lcd.print(F(" REPEAT")); break;
             default:
               lcd.print(F(" Bad Signal"));
           }// End Case
           irrecv.resume(); // receive the next value
         }//END If IR Received
       } while (ForEver);  // Loop here "ForEver" or RESET
     } // END case 5
   case 6: // ULTRASONIC
     {
       Serial.println("Option 6");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       lcd.print(F("6: UltraSonic  "));
       lcd.setCursor(0, 1); //Start at character 0 on line 1
       lcd.print(F("DISTANCE= "));
       do
       {
         /* The following trigPin/echoPin cycle is used to determine the
           distance of the nearest object by bouncing soundwaves off of it. */
         digitalWrite(ULTRA_TRIG_PIN, LOW);  // Pulse the Trigger  pin High and then Low
         delayMicroseconds(2);
         digitalWrite(ULTRA_TRIG_PIN, HIGH);
         delayMicroseconds(10);
         digitalWrite(ULTRA_TRIG_PIN, LOW);
         duration_uS = pulseIn(ULTRA_ECHO_PIN, HIGH);
         //Calculate the distance (in cm) based on the speed of sound.
         DistCM = duration_uS / US_ROUNDTRIP_CM; // Calculate distance in CM
         Serial.print("DistCM = ");
         Serial.println(DistCM);


         lcd.setCursor(10, 1); //Start at character 0 on line 1
         lcd.print(F("      "));
         lcd.setCursor(10, 1); //Start at character 0 on line 1
         if (DistCM > 200)
         {
           lcd.print("XXX");
         }
         else
         {
           lcd.print(DistCM);
         }
         lcd.print(" CM");


         if (DistCM <= 200)
         {
           //-----( Calculate buzzer action depending on distance )--------
           digitalWrite(BUZZER_PIN, HIGH);
           delay(DistCM * 2);
           digitalWrite(BUZZER_PIN, LOW);
           delay(DistCM * 12);
         }
         delay(10);
       } while (ForEver);  // Loop here "ForEver" or RESET
     } // END case
   case 7:  // JOYSTICK
     {
       Serial.println("Option 7");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       //-----------1234567890123456----------
       lcd.print(F("7: JoyStick     "));
       delay(500);
       do
       {
         lcd.print(F("      "));
         lcd.setCursor(0, 1); //Start at character 0 on line 1
         Xvalue = analogRead (X_AXIS_PIN); /*----(Read the X value and display it)----*/
         Xvalue = map(Xvalue, 1023, 0, 0, 1023); // Correct the right-left on Joystick
         Serial.print ( "X " );
         Serial.print (Xvalue, DEC );
         lcd.print(F("X="));
         lcd.print(Xvalue, DEC);
         Yvalue = analogRead (Y_AXIS_PIN);/*----(Read the Y value and display it)----*/
         Yvalue = 1023 - Yvalue;   // Reverse the numbers so it "looks right"
         Serial.print ( " | Y " );
         Serial.print (Yvalue, DEC );
         lcd.print(F(" Y="));
         lcd.print(Yvalue, DEC);
         Zvalue = digitalRead (Z_SWITCH_PIN);/*----(Read the Z value and display it)----*/
         Serial.print ( " | Z " );
         Serial.print (Zvalue, DEC );
         lcd.print(F(" Z="));
         lcd.print(Zvalue, DEC);
         Serial.println ();  /*----(End of Line)----*/
         if (Zvalue == 1) //The knob is pushed down
         {
           digitalWrite(ONBOARD_LED_PIN, HIGH);
         }
         else
         {
           digitalWrite(ONBOARD_LED_PIN, LOW);
         }
         delay(200);  /*----(Wait to read the print)----*/
       } while (ForEver);  // Loop here "ForEver" or RESET


     } // END case
   case 8:  // -----( TRAFFIC LIGHT CONTROL SYSTEM )------
     /* States:
         GREEN_STATE  - Green One, testing Sensor, Red (Don't Walk)  [MAX 30][Extend Green (red) 10]
         CAUTION_STATE  - Flashing Yellow  White (Don't Walk)[5 sec]
         RED_STATE  - Red ,  White (Don't Walk)[10]
         WALKING_STATE  - Red plus flashing white, beeping
         WALK_FAST_STATE   - Red plus White, fast beeping
     */
     {
       Serial.println("Option 8");
       pinMode(GREEN_LIGHT, OUTPUT);
       pinMode(YELLOW_LIGHT, OUTPUT);
       pinMode(RED_LIGHT, OUTPUT);
       pinMode(WALK_LIGHT, OUTPUT);
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       //-----------1234567890123456----------
       lcd.print(F("8:TRAFFIC LIGHT "));
       StateDelaySeconds = MaxGreenSeconds;
       TrafficSenseCall  = false;
       do
       {
         lcd.setCursor(0, 1); //Start at character 0 on line
         //-------------------1234567890123456----------
         lcd.print(F("                "));
         lcd.setCursor(0, 1); //Start at character 0 on line
         lcd.print(F("STATE= "));
         lcd.print(TrafficControlState);
         delay(100);


         if (digitalRead(VEHICLE_SENSE_PIN) == 0)
         {
           TrafficSenseCall = true;
         }
         if (digitalRead(REQUEST_WALK_PIN) == 0)
         {
           WalkerSenseCall = true;
         }


         switch (TrafficControlState)
         {
           case GREEN_STATE:
             {
               Serial.println("GREEN");
               lcd.setCursor(9, 1); //Start at character 9 on line
               lcd.print(F("GREEN"));
               digitalWrite(GREEN_LIGHT, ON);
               digitalWrite(RED_LIGHT, OFF);
               if (StateDelaySeconds >= 0)
               {
                 delay(1000);
                 Serial.println(StateDelaySeconds);
                 StateDelaySeconds -= 1;
               }
               else
               {
                 StateDelaySeconds = YellowSeconds;
                 TrafficControlState = CAUTION_STATE;
               }
               if (  (TrafficSenseCall | WalkerSenseCall)
                     & (StateDelaySeconds < MinGreenSeconds) )
               {
                 Serial.println("Vehicle/Walker Sensed");
                 TrafficSenseCall = false;
                 StateDelaySeconds = YellowSeconds;
                 TrafficControlState = CAUTION_STATE;
               }
             }//End GREEN_STATE
             break;
           case CAUTION_STATE:
             {
               Serial.println("YELLOW");
               lcd.setCursor(9, 1); //Start at character 9 on line
               lcd.print(F("YELLOW"));
               digitalWrite(GREEN_LIGHT, OFF);
               digitalWrite(YELLOW_LIGHT, ON);
               if (StateDelaySeconds >= 0)
               {
                 delay(1000);
                 Serial.println(StateDelaySeconds);
                 StateDelaySeconds -= 1;
               }
               else
               {
                 StateDelaySeconds = MaxRedSeconds;
                 TrafficControlState = RED_STATE;
               }
             }//End CAUTION_STATE
             break;
           case RED_STATE:
             {
               Serial.println("RED");
               lcd.setCursor(9, 1); //Start at character 9 on line
               lcd.print(F("RED"));
               digitalWrite(RED_LIGHT, ON);
               digitalWrite(YELLOW_LIGHT, OFF);
               if (StateDelaySeconds >= 0)
               {
                 delay(1000);
                 Serial.println(StateDelaySeconds);
                 StateDelaySeconds -= 1;
               }
               else
               {
                 StateDelaySeconds = MaxGreenSeconds;
                 TrafficControlState = GREEN_STATE;
               }
               if (WalkerSenseCall)
               {
                 Serial.println("Walker Sensed");
                 WalkerSenseCall = false;
                 TrafficControlState = WALKING_STATE;
               }
             }
             break;


           case WALKING_STATE:
             {
               Serial.println("WALKING");
               lcd.setCursor(9, 1); //Start at character 9 on line
               lcd.print(F("WALKING"));
               delay(1000);
               digitalWrite(WALK_LED_PIN, ON);
               delay(5000);
               digitalWrite(WALK_LED_PIN, OFF);
               StateDelaySeconds = 5;
               TrafficControlState = WALK_FAST_STATE;
             }
             break;
           case WALK_FAST_STATE:
             {
               Serial.println("WALK FAST");
               lcd.setCursor(9, 1); //Start at character 9 on line
               lcd.print(F("RUN ! !"));
               if (StateDelaySeconds >= 0)
               {
                 delay(500);
                 digitalWrite(WALK_LED_PIN, ON);
                 delay(500);
                 digitalWrite(WALK_LED_PIN, OFF);
                 Serial.println(StateDelaySeconds);
                 StateDelaySeconds -= 1;
               }
               else
               {
                 delay(1000);
                 StateDelaySeconds = MaxGreenSeconds;
                 TrafficControlState = GREEN_STATE;
               }
             }
             break;


             delay(500);
         } //End Switch on TrafficControlState
       } while (ForEver);  // Loop here "ForEver" or RESET


     } // END case
   case 9:
     {
       Serial.println("Option 9");
       lcd.setCursor(0, 0); //Start at character 0 on line 0
       //-------------------1234567890123456----------
       lcd.print(F("9:  NOPE        "));
       do
       {
         BlinkHi();
         delay(2000);
       } while (ForEver);  // Loop here "ForEver" or RESET


     } // END case
 } // End switch on OptionNumber

}//--(end main loop )---



/*--------------------( Declare User-written Functions )------------------------*/

void BeepNum(int numBeeps) {

 int i;
 delay(1000);
 for (i = 0 ; i < numBeeps; i++)
 {
   digitalWrite(BUZZER_PIN, HIGH);
   delay(100);
   digitalWrite(BUZZER_PIN, LOW);
   delay(100);
 }

}

//-----------------( BlinkHi with switches )---------------- void BlinkHi() {

 int i;
 for (i = 0; i < 4; i++)
 {
   digitalWrite(ONBOARD_LED_PIN, HIGH);   // turn the ONBOARD_LED_PIN on (HIGH is the voltage level)
   // Check if the user has pressed buttons
   if (digitalRead(SWITCH2_PIN) == LOW) {
     digitalWrite(LED_MODULE_PIN, HIGH);  // turn the LED_MODULE_PIN on (HIGH is the voltage level)
   }
   if (digitalRead(SWITCH1_PIN) == LOW) {
     digitalWrite(BUZZER_PIN, HIGH);
   }
   delay(100);               // wait for 1/10 second
   digitalWrite(ONBOARD_LED_PIN, LOW);    // turn the LED off by making the voltage LOW
   digitalWrite(LED_MODULE_PIN, LOW);     // turn the LED off by making the voltage LOW
   digitalWrite(BUZZER_PIN, LOW);
   delay(200);               // wait for a second, watch the Dark
 }
 delay(200);
 for (i = 0; i < 2; i++)
 {
   digitalWrite(ONBOARD_LED_PIN, HIGH);   // turn the LED on (HIGH is the voltage level)
   // Check if the user has pressed buttons
   if (digitalRead(SWITCH2_PIN) == LOW) {
     digitalWrite(LED_MODULE_PIN, HIGH);  // turn the LED_MODULE_PIN on (HIGH is the voltage level)
   }
   if (digitalRead(SWITCH1_PIN) == LOW) {
     digitalWrite(BUZZER_PIN, HIGH);
   }
   delay(100);               // wait for 1/10 second
   digitalWrite(ONBOARD_LED_PIN, LOW);    // turn the LED off by making the voltage LOW
   digitalWrite(LED_MODULE_PIN, LOW);     // turn the LED off by making the voltage LOW
   digitalWrite(BUZZER_PIN, LOW);
   delay(200);               // wait for a second, watch the Dark
 }
 delay(1000);

}//END BlinkHI

//------------( BlinkHiSimple - NO switches )----------------- void BlinkHiSimple() {

 int i;
 for (i = 0; i < 4; i++)
 {
   digitalWrite(ONBOARD_LED_PIN, HIGH);   // turn the ONBOARD_LED_PIN on (HIGH is the voltage level)
   digitalWrite(BUZZER_PIN, HIGH);
   digitalWrite(LED_MODULE_PIN, HIGH);
   digitalWrite(LED_MODULE_INVERT, LOW);


   delay(100);               // wait for 1/10 second
   digitalWrite(ONBOARD_LED_PIN, LOW);    // turn the LED off by making the voltage LOW
   digitalWrite(BUZZER_PIN, LOW);
   digitalWrite(LED_MODULE_PIN, LOW);     // turn the LED off by making the voltage LOW
   digitalWrite(LED_MODULE_INVERT, HIGH);
   delay(200);               // wait for a second, watch the Dark
 }


 delay(200);
 for (i = 0; i < 2; i++)
 {
   digitalWrite(ONBOARD_LED_PIN, HIGH);   // turn the ONBOARD_LED_PIN on (HIGH is the voltage level)
   digitalWrite(BUZZER_PIN, HIGH);
   digitalWrite(LED_MODULE_PIN, HIGH);
   digitalWrite(LED_MODULE_INVERT, LOW);


   delay(100);               // wait for 1/10 second
   digitalWrite(ONBOARD_LED_PIN, LOW);    // turn the LED off by making the voltage LOW
   digitalWrite(BUZZER_PIN, LOW);
   digitalWrite(LED_MODULE_PIN, LOW);     // turn the LED off by making the voltage LOW
   digitalWrite(LED_MODULE_INVERT, HIGH);
   delay(200);               // wait for a second, watch the Dark
 }
 delay(1000);

}//END BlinkHISimple


//-------------------( IsTime )---------------------------- boolean IsTime(unsigned long * timeMark, unsigned long timeInterval) {

 if (millis() - *timeMark >= timeInterval)
 {
   *timeMark = millis();
   return true;
 }
 return false;

}

//-------------( PointServo )-------------- void PointServo(int ServoAngle) {

 for (int i = 0; i < 3; i++) // Send the pulse 10 times
 {
   digitalWrite(SERVO_PIN, HIGH);
   delayMicroseconds(ServoAngle);
   digitalWrite(SERVO_PIN, LOW);
   delay(1);
 }

}//END PointServo /*---------------------------*/

//------------------( Translate IR - Read the IR Remote; change optionNumber )-------- void translateIR() // takes action based on IR code received

// describing KEYES Remote IR codes

{

 switch (results.value)
 {
   case 0xFF629D: Serial.println(" FORWARD"); break;
   case 0xFF22DD: Serial.println(" LEFT");    break;
   case 0xFF02FD: Serial.println(" -OK-");    break;
   case 0xFFC23D: Serial.println(" RIGHT");   break;
   case 0xFFA857: Serial.println(" REVERSE"); break;
   case 0xFF6897: {
       Serial.println(" 1");
       OptionNumber = 1;
     }    break;
   case 0xFF9867: {
       Serial.println(" 2");
       OptionNumber = 2;
     }    break;
   case 0xFFB04F: {
       Serial.println(" 3");
       OptionNumber = 3;
     }    break;
   case 0xFF30CF: {
       Serial.println(" 4");
       OptionNumber = 4;
     }    break;
   case 0xFF18E7: {
       Serial.println(" 5");
       OptionNumber = 5;
     }    break;
   case 0xFF7A85: {
       Serial.println(" 6");
       OptionNumber = 6;
     }    break;
   case 0xFF10EF: {
       Serial.println(" 7");
       OptionNumber = 7;
     }    break;
   case 0xFF38C7: {
       Serial.println(" 8");
       OptionNumber = 8;
     }    break;
   case 0xFF5AA5: {
       Serial.println(" 9");
       OptionNumber = 9;
     }    break;
   case 0xFF42BD: {
       Serial.println(" *");
       OptionNumber = 10;
     }    break;
   case 0xFF4AB5: {
       Serial.println(" 0");
       OptionNumber = 0;
     }    break;
   case 0xFF52AD: {
       Serial.println(" #");
       OptionNumber = 11;
     }    break;
   //   case 0xFFFFFFFF: Serial.println(" REPEAT"); break;
   default:
     Serial.println(" Bad Signal   ");
 }// End Case
 BeepNum(OptionNumber);

} //END translateIR

//*********( THE END )*********** [/code]