/*
 *  $Rev: 1005 $:     Revision of last commit
 *  $Author: tgutwin $:  Author of last commit
 *  $Date: 2015-10-05 12:44:37 -0700 (Mon, 05 Oct 2015) $:    Date of last commit
 *  $URL: svn://svn.webarts.bc.ca/open/trunk/projects/WebARTS/raspberry/ca/bc/webarts/raspberry/GpioCycler.java $
 *
 *  Written by Tom Gutwin
 *  Copyright (C) 2015 Tom B. Gutwin, North Vancouver BC Canada
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; If not, see <http://www.gnu.org/licenses/>.
 */

package ca.bc.webarts.raspberry;

import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.Pin;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.system.SystemInfo;

import ca.bc.webarts.widgets.Util;
/**
 * This code demonstrates cycling Raspberry Pi GPIO pins on and off sequentially as an example of how to
 * perform simple state control of a GPIO pin on the Raspberry Pi.
 *
 * It uses the <a href="http://www.pi4j.com">Pi4J library</a>.
 *
 * @author <a href="http://red.webarts.bc.ca/roller/tom/en_CA/">Tom Gutwin</a>
 */
public class GpioCycler
{
  /** Class constant for a PI board type A. **/
  public static final short BOARD_TYPE_A = 0;
  /** Class constant for a PI board type A+. **/
  public static final short BOARD_TYPE_APLUS = 1;
  /** Class constant for a PI board type B. **/
  public static final short BOARD_TYPE_B = 2;
  /** Class constant for a PI board type B2. **/
  public static final short BOARD_TYPE_B2 = 3;
  /** Class constant for a PI board type B+. **/
  public static final short BOARD_TYPE_BPLUS = 4;
  /** Class constant for a PI board type Pi2. **/
  public static final short BOARD_TYPE_2 = 5;
  /** Class constant for its DEFAULT  PI board type = BOARD_TYPE_2. **/
  public static final short DEFAULT_BOARD_TYPE = BOARD_TYPE_2;

  /** The DEFAULT time in milliSeconds the cycle loop should run. **/
  public static final int DEFAULT_LOOP_TIME_MS = 20000;

  /** The DEFAULT time in milliSeconds the GPIO will go HIGH. **/
  public static final short DEFAULT_CYCLE_TIME_MS = 100;

  /** The DEFAULT time in milliSeconds the <b>next</b> GPIO pin will come on before the previous
    * one goes LOW. Its the overlap time. **/
  public static final short DEFAULT_OVERLAP_TIME_MS = 0;

  /** The default set of pins for a Raspberry Pi Model A or B board that will be controlled. Defaults to all pins. **/
  public static final short [] DEFAULT_PIAB_PINS =    {0,1,2,3,4,5,6,7,8,9,
                                                       10,11,12,13,14,15,16};
  /** The default set of pins for a Raspberry Pi Model B Plus board that will be controlled. Defaults to all pins. **/
  public static final short [] DEFAULT_PIBPLUS_PINS=  {0,1,2,3,4,5,6,7,8,9,
                                                       10,11,12,13,14,15,16,
                                                       21,22,23,24,25,26,27,28,29};
  /** The default set of pins for a Raspberry Pi 2 Model B board that will be controlled. Defaults to all pins. **/
  public static final short [] DEFAULT_PI2_PINS = DEFAULT_PIBPLUS_PINS;
  public static final short [] DEFAULT_PINS = DEFAULT_PI2_PINS;

  /** The default set of pins that will be used / enabled [0-11 are enabled]. **/
  public static final boolean [] DEFAULT_ENABLED_PINS = {true,true,true,true,true,true,true,true,true,true,true,true,
                                                         false,false,false,false,false,false,false,false,
                                                         false,false,false,false,false,false,false,false,false};

  /** The default pin to start the cycle from. **/
  public static final short DEFAULT_START_PIN = DEFAULT_PINS[0];
  /** The default pin to end the cycle from. **/
  public static final short DEFAULT_END_PIN = DEFAULT_PINS[DEFAULT_PINS.length-1];

  /** Default pin state is LOW. **/
  public static final PinState DEFAULT_PINSTATE = PinState.LOW;


  /** Class var specifying the active board type - it starts as the   DEFAULT_BOARD_TYPE. **/
  private short boardType = DEFAULT_BOARD_TYPE;
  /** The time that the whole thing should run/looping back and forth - use -1 to go forever **/
  private int loopTime = DEFAULT_LOOP_TIME_MS;
  /** The duty cycle time in ms that the GPIO will cycle ON. **/
  private short cycleTime = DEFAULT_CYCLE_TIME_MS;
  /** The time in ms that the next GPIO will come ON before the previous one is OFF -
    * it can be a negative number to specify a delAY. **/
  private short overlapTime = DEFAULT_OVERLAP_TIME_MS;
  /** pins represents the GPIO pin numbers on the board. **/
  private short[] pins = DEFAULT_PINS;

  /** The pins that are enabled.**/
  private boolean[] enabledPins = DEFAULT_ENABLED_PINS;

  /** The gpioPin number associated with the first enabled GPIO pin that is 1st used in the cycle - zero based. **/
  private short startPin = DEFAULT_START_PIN;
  /** The gpioPin number associated with the last enabled GPIO pin that is LAST used in the cycle - zero based. **/
  private short endPin =   DEFAULT_END_PIN;
  /** The usable GPIO pins that will be used by this class - it does NOT get init until provisionPins is called. **/
  private GpioPinDigitalOutput[] gpioPins = new GpioPinDigitalOutput[pins.length];

  /** supervisor class flag to save re-provisioning. **/
  private boolean allPinsProvisioned = false;

  /** gpio controller used by all methods in this class. **/
  private final GpioController gpio = GpioFactory.getInstance();


  /** constructor **/
  public GpioCycler()
  {
    try
    {
      SystemInfo.BoardType bt = SystemInfo.getBoardType();
      if(bt.equals(SystemInfo.BoardType.Model2B_Rev1)) boardType = BOARD_TYPE_2;
      else if(bt.equals(SystemInfo.BoardType.ModelB_Plus_Rev1)) boardType = BOARD_TYPE_BPLUS;
      else if(bt.equals(SystemInfo.BoardType.ModelB_Rev2)) boardType = BOARD_TYPE_B;
      else if(bt.equals(SystemInfo.BoardType.ModelB_Rev1)) boardType = BOARD_TYPE_B2;
      else if(bt.equals(SystemInfo.BoardType.ModelA_Plus_Rev1)) boardType = BOARD_TYPE_APLUS;
      else if(bt.equals(SystemInfo.BoardType.ModelA_Rev1)) boardType = BOARD_TYPE_A;
      else boardType = DEFAULT_BOARD_TYPE;
    }
    catch (java.io.IOException ioEx)
    {
      boardType = DEFAULT_BOARD_TYPE;
    }
    catch (java.lang.InterruptedException iEx)
    {
      boardType = DEFAULT_BOARD_TYPE;
    }
  }


  /** Stop all GPIO activity/threads by shutting down the GPIO controller.
    * This method will forcefully shutdown all GPIO monitoring threads and scheduled tasks.
    **/
  public void shutdown()
  {
        // stop all GPIO activity/threads by shutting down the GPIO controller
        // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
        gpio.shutdown();

  }


  /**
    * Sets the 3 timing paramets based on optional commandline parameters - passed to this method in args[].
    *
    * @param args is the commandline args array
    **/
  protected void parseCommandlineParms(String [] args)
  {
      if (args!=null && args.length >0)
      {
        System.out.println("  > Override loopTime="+args[0]);
        loopTime = Short.parseShort(args[0]);
      }
      if (args!=null && args.length >1)
      {
        System.out.println("  > Override duty cycleTime="+args[1]);
        cycleTime = Short.parseShort(args[1]);
      }
      if (args!=null && args.length >2)
      {
        System.out.println("  > Override overlapTime="+args[2]);
        overlapTime = Short.parseShort(args[2]);
      }
  }


  /** Cycles ALL gpio pins on / off 2 times for 500ms each. **/
  public void flashAllPins()  {  flashAllPins((short)2, (short)500); }


  /** Cycles ALL gpio pins on / off numFlashes times with a duty time of flashTimeMS . **/
  public void flashAllPins(short numFlashes, short flashTimeMS)
  {
    if (!allPinsProvisioned) provisionPins(true);
    //enableAllPin();
    for (short flashNum = 0;flashNum<numFlashes;flashNum++)
    {
      for (short i=0; i< pins.length; i++) gpioPins[i].low();
      sleep(flashTimeMS);
      System.out.print("ON...");
      for (short i=0; i< pins.length; i++) gpioPins[i].high();
      sleep(flashTimeMS);
      System.out.println("OFF");
      for (short i=0; i< pins.length; i++) gpioPins[i].low();
      sleep(flashTimeMS);
    }
  }


  /** figures out, sets the class Var endPin, and returns the array ref for the last ENABLED GPIO pin. **/
  private int lastEnabledPinRef()
  {
    int lastEnabledPinRef = 0;
    int i=0;
    for (i=0; i< pins.length; i++)
    {
      if(enabledPins[i] && gpioPins[i]!=null)
      {
        lastEnabledPinRef = i;
      }
    }
    setEndPin(pins[lastEnabledPinRef]);
    return lastEnabledPinRef;
  }


  /** figures out, sets the class Var startPin, and returns the array ref for the FIRST ENABLED GPIO pin. **/
  private int firstEnabledPinRef()
  {
    int firstEnabledPinRef = 0;
    int i=0;
    for (i=0; i< pins.length; i++)
    {
      if(enabledPins[i] && gpioPins[i]!=null)
      {
        firstEnabledPinRef = i;
        break;
      }
    }
    setStartPin(pins[firstEnabledPinRef]);
    return firstEnabledPinRef;
  }


  /** Run the Cycling of te GPIO pins that have been defined, for the Class set loopTime (which defaults to DEFAULT_LOOP_TIME_MS if not set).    **/
  public void cycle(){ cycle(loopTime);}


  /** Run the Cycling of te GPIO pins that have been defined.
    * @param loopTime is the length of time in ms to run the loop.
    **/
  public void cycle(int loopTime)
  {
    System.out.print("[");
    for (short i=0; i< pins.length; i++) if(enabledPins[i]) System.out.print(pins[i]+((i<pins.length-1)?",":""));
    System.out.println("]");
    System.out.print(" ... ");
    if(overlapTime<0) delayCycle(loopTime);
    else overlapCycle(loopTime);
    System.out.println("...done!");
  }


  /** This is the method that actually cyles the GPIO states - when overlapTime is positive - the LEDs overlap their ON,
    * for the Class set loopTime (which defaults to DEFAULT_LOOP_TIME_MS if not set).    **/
  public void overlapCycle(){ overlapCycle(loopTime);}


  /** This is the method that actually cyles the GPIO states - when overlapTime is positive - the LEDs overlap their ON.
    * @param loopTime is the length of time in ms to run the loop.
    **/
  public void overlapCycle(int loopTime)
  {
    int runTime = 0;
    short currDelay = 0;
    int lastEnabledPinRef = lastEnabledPinRef();
    int firstEnabledPinRef = firstEnabledPinRef();
    System.out.println(" overlapping: dutyCycleTime="+(cycleTime)+"ms   overlapTime="+(overlapTime)+"ms");

    if(enabledPins[firstEnabledPinRef] && gpioPins[firstEnabledPinRef]!=null)
    {
      gpioPins[firstEnabledPinRef].high();
          currDelay = (short)(overlapTime);
          sleep(currDelay);
          runTime+=currDelay;
    }
    while(loopTime==-1 || runTime<loopTime)
    {
      // loop through the GPIO cycling
      for (short i=(short)firstEnabledPinRef; i< (short)lastEnabledPinRef; i++)
      {
        if(enabledPins[i] && gpioPins[i]!=null)
        {
          currDelay = (short)(cycleTime-(2*overlapTime));
          sleep(currDelay);
          runTime+=currDelay;
          if(enabledPins[i+1] && gpioPins[i+1]!=null) gpioPins[i+1].high();

          currDelay = (short)(overlapTime);
          sleep(currDelay);
          runTime+=currDelay;
          gpioPins[i].low();
        }
      }

      // Bounce at the end of the loop and go back
      for (short i=(short)lastEnabledPinRef; i>(short)firstEnabledPinRef; i--)
      {
        if(enabledPins[i] && gpioPins[i]!=null)
        {
          currDelay = (short)(cycleTime-(2*overlapTime));
          sleep(currDelay);
          runTime+=currDelay;
          if(enabledPins[i-1] && gpioPins[i-1]!=null) gpioPins[i-1].high();

          currDelay = (short)(overlapTime);
          sleep(currDelay);
          runTime+=currDelay;
          gpioPins[i].low();
        }
      }

    } // while loop
    gpioPins[firstEnabledPinRef].low();
    System.out.println(" Completed in:"+ runTime +"ms");

  }


  /** This is the method that actually cyles the GPIO states - used when overlapTime is negative - there is a gap between the LEDs,
    * for the Class set loopTime (which defaults to DEFAULT_LOOP_TIME_MS if not set).    **/
  public void delayCycle(){ delayCycle(loopTime);}


  /** This is the method that actually cyles the GPIO states - used when overlapTime is negative - there is a gap between the LEDs.
    * @param loopTime is the length of time in ms to run the loop.
    **/
  public void delayCycle(int loopTime)
  {
    int runTime = 0;
    short currDelay = 0;
    int lastEnabledPinRef = lastEnabledPinRef();
    int firstEnabledPinRef = firstEnabledPinRef();
    System.out.println(" delay "+(-1*overlapTime));
    while(loopTime==-1 || runTime<loopTime)
    {
      // fill in GPIO cycling
      for (short i=(short)firstEnabledPinRef; i<= (short)lastEnabledPinRef; i++)
      {
        if(enabledPins[i] && gpioPins[i]!=null)
        {
          gpioPins[i].high();
          currDelay = (short)cycleTime;
          this.sleep(currDelay);
          runTime+=currDelay;

          gpioPins[i].low();
          currDelay = (short)(-1*overlapTime);
          this.sleep(currDelay);
          runTime+=currDelay;
        }
      }
      // Bounce at the end of the loop
      currDelay = (short)(overlapTime);
      this.sleep(currDelay);
      runTime+=currDelay;
      if(enabledPins[lastEnabledPinRef] && gpioPins[lastEnabledPinRef]!=null)gpioPins[lastEnabledPinRef].low();

      for (short i=(short)(lastEnabledPinRef-1); i>=firstEnabledPinRef; i--)
      {
        if(enabledPins[i] && gpioPins[i]!=null)
        {
          gpioPins[i].high();
          currDelay = cycleTime;
          this.sleep(currDelay);
          runTime+=currDelay;

          gpioPins[i].low();
          currDelay = (short)(-1*overlapTime);
          this.sleep(currDelay);
          runTime+=currDelay;
        }
      }
      currDelay = (short)(-1*overlapTime);
      this.sleep(currDelay);
      runTime+=currDelay;
    } // while loop

  }

  /** Mark a pin as DISABLED - it sets the class var that keeps track of which GPIO pins are enabled; 'enabledPins' to false.
    * If the passed var 'pin' is NOT one of the available pins for the connected board, this method simply/silently does nothing.
    * @param pin is the GPIO pin number to disable
    **/
  public void disablePin(short pin)
  {
    for (short i=0; i< pins.length; i++)
    {
      if(pins[i]==pin)
      {
        enabledPins[i] = false;
        break;
      }
    }
  }


  /** Mark a pin as ENABLED - it sets the class var that keeps track of which GPIO pins are enabled; 'enabledPins' to true.
    * If the passed var 'pin' is NOT one of the available pins for the connected board, this method simply/silently does nothing.
    * @param pin is the GPIO pin number to enable
    **/
  public void enablePin(short pin)
  {
    for (short i=0; i< pins.length; i++)
    {
      if(pins[i]==pin)
      {
        enabledPins[i] = true;
        break;
      }
    }
  }


  /** Mark all available pins for the active boardType as ENABLED - it sets the class var that keeps track of
    * which GPIO pins are enabled; 'enabledPins' to true. **/
  public void enableAllPin()
  {
    for (short i=0; i< pins.length; i++)
    {
        enabledPins[i] = true;
    }
  }


  /**
    * Set the boardType to use, must be one of the Class constants  BOARD_TYPE_*.
    *
    * @param boardType is the value to set this class field to.
    *
    * @return short - The value boardType if successful ELSE -1.
    **/
  public  short setBoardType(short boardType)
  {
    short retVal = -1;

    if( boardType>=0 && boardType<=BOARD_TYPE_2)
    {
      this.boardType = boardType;
      retVal = boardType;
    }
    return retVal;
  }  // setBoardType Method


  /**
    * Get Method for class field 'boardType'.
    *
    * @return short - The boardType being used; will be one of the Class constants  BOARD_TYPE_*.
    *
    **/
  public short getBoardType()
  {
    return boardType;
  }  // getBoardType Method



  /**
    * Set Method for class field 'startPin'.
    *
    * @param pin is the value to set this class field to.
    *
    **/
  public  void setStartPin(short pin)
  {
    this.startPin = pin;
  }  // setStartPin Method


  /**
    * Get Method for class field 'startPin'.
    *
    * @return short - The value the class field 'startPin'.
    *
    **/
  public short getStartPin()
  {
    return startPin;
  }  // getStartPin Method


  /**
    * Set Method for class field 'endPin'.
    *
    * @param pin is the value to set this class field to.
    *
    **/
  public  void setEndPin(short pin)
  {
    this.endPin = pin;
  }  // setEndPin Method


  /**
    * Get Method for class field 'endPin'.
    *
    * @return short - The value the class field 'endPin'.
    *
    **/
  public short getEndPin()
  {
    return endPin;
  }  // getEndPin Method


  /**
    * Set Method for class field 'cycleTime'.
    *
    * @param cycleTime is the value to set this class field to.
    *
    **/
  public  void setCycleTime(short cycleTime)
  {
    this.cycleTime = cycleTime;
  }  // setCycleTime Method


  /**
    * Get Method for class field 'cycleTime'.
    *
    * @return short - The value the class field 'cycleTime'.
    *
    **/
  public short getCycleTime()
  {
    return cycleTime;
  }  // getCycleTime Method


  /**
    * Set Method for class field 'overlapTime'.
    *
    * @param overlapTime is the value to set this class field to.
    *
    **/
  public  void setOverlapTime(short overlapTime)
  {
    this.overlapTime = overlapTime;
  }  // setOverlapTime Method


  /**
    * Get Method for class field 'overlapTime'.
    *
    * @return short - The value the class field 'overlapTime'.
    *
    **/
  public short getOverlapTime()
  {
    return overlapTime;
  }  // getOverlapTime Method


  /**
    * Set Method for class field 'pins' that represents the GPIO pin numbers on the board.
    *
    * @param short[] is the value to set this class field pinsto.
    *
    **/
  public  void setPins(short[] pins)
  {
    this.pins = pins;
  }  // setPins Method


  /**
    * Get Method for class field '[]'.
    *
    * @return short - The value the class field '[]'.
    *
    **/
  public short[] getPins()
  {
    return pins;
  }  // getPins[] Method


  private short getEnabledPinCount()
  {
    short pinCount = 0;
    for (short i=0; i< pins.length; i++) if(enabledPins[i]) pinCount++;
    return pinCount;
  }


  /** RaspiPINS have names of the form 'GPIO 4' or 'GPIO 12'.
    * @param pin is the Pi4j (wiringPI) pin number.
    **/
  private Pin getRaspiPin(short pin)
  {
    Pin retVal = null;
    String pinName = "GPIO ";
    /*
    if(pin>0 && pin<10)
    {
      pinName += "0"+pin;
      retVal = RaspiPin.getPinByName(pinName);
    }
    else if(pin>9)
    */
   // {
      pinName += ""+pin;
      retVal = RaspiPin.getPinByName(pinName);
   // }
    return retVal;
  }


  /** provisions and returns a Gpio Outpout Pin with the DEFAULT state. **/
  private GpioPinDigitalOutput provisionOutputPin(short pin)
  {
    return provisionOutputPin(pin, DEFAULT_PINSTATE);
  }


  /** provisions and returns a Gpio Outpout Pin. **/
  private GpioPinDigitalOutput provisionOutputPin(short pin, PinState pinState)
  {
    GpioPinDigitalOutput gpioPin = null;
    if( pin>=pins[0] && pin<=pins[pins.length-1])
    {
      gpioPin = gpio.provisionDigitalOutputPin(getRaspiPin(pin), DEFAULT_PINSTATE);
    }
    return gpioPin;
  }


  /** provisions ALL enabled pins and puts them in the class var gpioPins. **/
  private GpioPinDigitalOutput[] provisionPins(){return provisionPins(false);}


  /** provisions (according to passed flag) pins and puts them in the class var gpioPins.
    *
    * @param boolean controls if all pins are provisioned for only those that are enabled in enabledPins class var.
    *
    **/
  private GpioPinDigitalOutput[] provisionPins(boolean doAll)
  {
    if(!allPinsProvisioned)
    {
      System.out.print("[");
      for (short i=0; i< pins.length; i++)
      {
        if(doAll || enabledPins[i])
        {
          System.out.print(pins[i]+((i<pins.length-1)?",":""));
          gpioPins[i] = provisionOutputPin(pins[i]);
        }
      }
    }
    System.out.println("]");
    allPinsProvisioned = (allPinsProvisioned || doAll);
    return gpioPins;
  }


  /** The main entrance to this class.
    *<pre>
    *--------------------------------------------------------------------------------
    * Java Raspberry PI  - GpioCycler
    * Copyright (C) 2015 - Tom B. Gutwin
    *--------------------------------------------------------------------------------
    *Syntax:
    *java ca.bc.webarts.raspberry.GpioCycler [loopTime [dutyCycleTime [overlapTime]]]
    *     where the 3 OPTIONAL parameters are:
    *           loopTime      time in milliSeconds to run the looping (default=DEFAULT_LOOP_TIME_MS ms)
    *                         (default=DEFAULT_LOOP_TIME_MS ms)
    *           dutyCycleTime time in milliSeconds the GPIOs stays in the 'ON' state
    *                         (default=DEFAULT_CYCLE_TIME_MS ms)
    *           overlapTime   time in milliSeconds the next/following GPIO will turn
    *                         'ON' before the previous GPIO turns 'OFF'
    *                         (default=DEFAULT_OVERLAP_TIME_MS ms)
    * </pre>
    **/
  public static void main(String [] args) throws InterruptedException
  {
    GpioCycler instance = new GpioCycler();
    if (args==null || args.length == 0)
    {
      System.out.println("--------------------------------------------------------------------------------");
      System.out.println(" Java Raspberry PI  - GpioCycler  ");
      System.out.println(" Copyright (C) 2015 - Tom B. Gutwin  ");
      System.out.println("--------------------------------------------------------------------------------");
      System.out.println("Syntax:");
      System.out.println("java ca.bc.webarts.raspberry.GpioCycler [loopTime [dutyCycleTime [overlapTime]]]");
      System.out.println("     where the 3 OPTIONAL parameters are:");
      System.out.println("           loopTime      time in milliSeconds to run the looping (default="+DEFAULT_LOOP_TIME_MS+"ms)");
      System.out.println("                         (default="+DEFAULT_LOOP_TIME_MS+"ms)");
      System.out.println("           dutyCycleTime time in milliSeconds the GPIOs stays in the 'ON' state ");
      System.out.println("                         (default="+DEFAULT_CYCLE_TIME_MS+"ms)");
      System.out.println("           overlapTime   time in milliSeconds the next/following GPIO will turn");
      System.out.println("                         'ON' before the previous GPIO turns 'OFF' ");
      System.out.println("                         (default="+DEFAULT_OVERLAP_TIME_MS+"ms)");
      System.out.println("--------------------------------------------------------------------------------");
    }
    //else
    {
      instance.parseCommandlineParms(args);
      System.out.println("<Provisioning All GPIO pins>");
      instance.provisionPins(true);

      System.out.println("<TESTING All GPIO pins>");
      instance.flashAllPins();
      System.out.println("<Cycling GPIO pins>");
      instance.cycle();
    }

    instance.shutdown();

  }

  /**
   *  A method to simply abstract the Try/Catch required to put the current
   *  thread to sleep for the specified time in ms.
   *
   * @param  waitTime  the sleep time in milli seconds (ms).
   * @return boolean value specifying if the sleep completed (true) or was interupted (false).
   */
  public static boolean sleep(long waitTime)
  {
    boolean retVal = true;
    if (waitTime<0)
      retVal=false;
    else
    {
      /*
       *  BLOCK for the spec'd time
       */
      try
      {
        Thread.sleep(waitTime);
      }
      catch (InterruptedException iex)
      {
        retVal = false;
      }
    }
    return retVal;
  }



}