/*
 *  $URL: svn://fred.webarts.bc.ca/open/trunk/projects/WebARTS/ca/bc/webarts/tools/lednet/LedNetProxy.java $
 *  $Author: tgutwin $
 *  $Revision: 1302 $
 *  $Date: 2019-11-03 17:19:03 -0800 (Sun, 03 Nov 2019) $
 */
/*
 *
 *  Written by Tom Gutwin - WebARTS Design.
 *  Copyright (C) 2016-2017 WebARTS Design, North Vancouver Canada
 *  http://www.webarts.bc.ca
 *
 *  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 2 of 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, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package ca.bc.webarts.tools.lednet;

import java.io.*;
import java.net.*;
import java.util.Arrays;
import java.util.concurrent.atomic.DoubleAdder;
import java.util.HashMap;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.Vector;

/**
 *  A class that wraps the comunication to LedNet devices using the
 *  reverse engineered Protocol. Thanks go to the contributors on the Universal Device
 * <a href="http://forum.universal-devices.com/topic/19913-magic-ufo-controller-for-rgbw" > Forum POST</a>.
 * They wireSharked the message format.
 *  <br />
 *  The TCP packets look like:<br />
 *  &nbsp;&nbsp;On: 113;35;15;163;129;138;139;150<br />
 *  &nbsp;&nbsp;Off: 113;36;15;164;129;138;139;150<br />
 *  <br />
 *  &nbsp;&nbsp;Red:   49;255;0;0;0;0;0;15;63;129;138;139;150<br />
 *  &nbsp;&nbsp;Green: 49;0;255;0;0;0;0;15;63;129;138;139;150<br />
 *  &nbsp;&nbsp;Blue:  49;0;0;255;0;0;0;15;63;129;138;139;150<br />
 *  &nbsp;&nbsp;White: 49;0;0;0;255;0;0;15;63;129;138;139;150<br />
 *  &nbsp;&nbsp;Cyan:  49;0;255;255;0;0;0;15;62;129;138;139;150<br />
 *<br />
 * You need to send the TCP packet to the LedNet IP at Port 5577.
 *<br />
 * The bytes after the 15 (63) are stated as being checksum value of the first eight values and have to change for each code you send.<br />
 * Notice how the ON/Off commands use 163, 164? IT would seem the byte after the 15 (packet terminator) is always the sum of the digits from the first until the 15 (inclusive)<br />
 * In a normal protocol if the checksum didn't add up correctly the packet would be ignored as noise.<br />
 *<br />
 * Having said all that, the first single (primary = not cyan) colour packets you sent did add up to the 63 checksum and should have worked.

 *  <br /> See also <a href="http://forum.universal-devices.com/topic/19913-magic-ufo-controller-for-rgbw" > UDI Forum</a> writeup.
 *
 * @author     Tom Gutwin P.Eng
 */
public class LedNetProxy
{
  /**  A holder for this clients System File Separator.  */
  public final static String SYSTEM_FILE_SEPERATOR = File.separator;

  /**  A holder for this clients System line termination separator.  */
  public final static String SYSTEM_LINE_SEPERATOR =
                                           System.getProperty("line.separator");

  /**  The VM classpath (used in some methods)..  */
  public static String CLASSPATH = System.getProperty("class.path");

  /**  The users home ditrectory.  */
  public static String USERHOME = System.getProperty("user.home");

  /**  The users pwd ditrectory.  */
  public static String USERDIR = System.getProperty("user.dir");

  /**  A holder This classes name (used when logging).  */
  private static String CLASSNAME = "ca.bc.webarts.tools.lednet.LedNetProxy";

  /**  Class flag signifying if the initUtil method has been called  */
  private static boolean classInit = false;

  /**  Class flag signifying if debugging_ messages are ptinted */
  private static boolean debugging_ = false;

  /** default receiver IP Address. **/
  public static final String DEFAULT_LEDNET_IP = "10.0.0.40";
  /** Instantiated class IP for the receiver to communicate with. **/
  private String receiverIP_ = DEFAULT_LEDNET_IP;

  /** default LEDNET port. **/
  public static final int DEFAULT_LEDNET_PORT = 5577;
  /** Instantiated class Port for the receiver to communicate with. **/
  private int receiverPort_ = DEFAULT_LEDNET_PORT;

  /** the socket for communication - the protocol spec says to use one socket connection AND HOLD ONTO IT for re-use. **/
  private static Socket lednetSocket_ = null;
  /** the timeout in ms for socket reads. **/
  private static int socketTimeOut_ = 500;
  private static ObjectOutputStream out_ = null;
  private static DataInputStream in_ = null;
  private static boolean connected_ = false;

  private static StringBuffer helpMsg_ = new StringBuffer(SYSTEM_LINE_SEPERATOR);

  private  HashMap<Integer, Integer> levels_ = null;
  private  HashMap<Integer, Integer> reverseLevels_ = null;
  private int levelCount = 0;
  public enum FadeSpeed
  {
      INSTANT (1),  //calls constructor with value 1 step
      VERYFAST (2),  //calls constructor with value 2
      FAST (4),       //calls constructor with value 4
      MEDIUM (8),     //calls constructor with value 8
      SLOW (16),       //calls constructor with value 16
      VERYSLOW (32),    //calls constructor with value 32
      SMOOTH (64),    //calls constructor with value 64
      MOLASSES (128),    //calls constructor with value 128
      BYONES (255)    //calls constructor with value 128
      ; // semicolon needed when fields / methods follow
      private final int levelSteps;
      private FadeSpeed(int levelSteps)
      {
          this.levelSteps = levelSteps;
      }
      public int getLevelSteps()
      {
        return this.levelSteps;
      }
  }


  /** Simple class Constructor (using deafult IP and port) that gets all the class command constants
   * set-up.
   **/
  public LedNetProxy()
  {
    initLevelsMap();
  }


  /** Constructor that takes your receivers ip and default port, gets all the class command
   * constants set-up .
   **/
  public LedNetProxy(String ip)
  {
    initLevelsMap();
    if (ip==null || ip.equals(""))
      receiverIP_=DEFAULT_LEDNET_IP;
    else
      receiverIP_=ip;
    receiverPort_=DEFAULT_LEDNET_PORT;
  }


  /** Constructor that takes your receivers ip and port,  gets all the class command
   * constants set-up .
   **/
  public LedNetProxy(String ip, int ipPort)
  {
    initLevelsMap();
    if (ip==null || ip.equals(""))
      receiverIP_=DEFAULT_LEDNET_IP;
    else
      receiverIP_=ip;
    if (ipPort<1 )
      receiverPort_=DEFAULT_LEDNET_PORT;
    else
      receiverPort_=ipPort;
  }


  /** Makes Chocolate glazed doughnuts. **/
  public void setReceiverIP( String ip) { receiverIP_ = ip;}
  /** Makes Sprinkle doughnuts. **/
  public String getReceiverIP() {return receiverIP_;}
  /** Makes mini doughnuts. **/
  public void setReceiverPort( int port) { receiverPort_ = port;}
  /** Makes glazed doughnuts. **/
  public int getReceiverPort() {return receiverPort_;}

  /**
   * Connects to the receiver by opening a socket connection through the DEFaULT IP and DEFAULT eISCP port.
   **/
   public boolean connectSocket() { return connectSocket(null, -1);}


  /**
   * Connects to the receiver by opening a socket connection through the DEFAULT LedNet Receiver Port.
   **/
   public boolean connectSocket(String ip) { return connectSocket(ip,-1);}


  /**
   * Connects to the receiver by opening a socket connection through the passed in port (or default LedNet Receiver Port).
   **/
  public boolean connectSocket(String ip, int ipPort)
  {
    if (ip==null || ip.equals("")) ip=receiverIP_;
    if (ipPort<1 ) ipPort=receiverPort_;

    if (lednetSocket_==null || !connected_ || !lednetSocket_.isConnected())
    try
    {
      //1. creating a socket to connect to the server
      lednetSocket_ = new Socket(ip, ipPort);
      System.out.println("Connected to LedNetProxy at "+ip+" on port "+ipPort);
      //2. get Input and Output streams
      out_ = new ObjectOutputStream(lednetSocket_.getOutputStream());
      in_ = new DataInputStream(lednetSocket_.getInputStream());

      //System.out.println("out_Init");
      out_.flush();
      // System.out.println("inInit");
      connected_ = true;
    }
    catch(UnknownHostException unknownHost)
    {
      System.err.println("You are trying to connect to an unknown host!");
    }
    catch(IOException ioException)
    {
      System.err.println("Can't Connect: "+ioException.getMessage());
    }
    return connected_;
  }


  /**
   * Tests the Connection to the receiver by opening a socket connection through the DEFaULT IP and DEFAULT eISCP port.
   * @return true if already connected or can connect, and false if can't connect
   **/
   public boolean testConnection() { return testConnection(DEFAULT_LEDNET_IP,DEFAULT_LEDNET_PORT);}


  /**
   * Tests the Connection to the receiver by opening a socket connection through the specified IP and DEFAULT eISCP port.
   * @param ip is the ip address (as a String) of the AV receiver to connect
   * @return true if already connected or can connect, and false if can't connect
   **/
   public boolean testConnection(String ip) { return testConnection(DEFAULT_LEDNET_IP,DEFAULT_LEDNET_PORT);}


  /**
   * test the connection to the receiver by opening a socket connection AND THEN CLOSES it if it was not already open.
   * this method can be used when you need to specificly specify the IP and PORT. If the default port is used then you could also use the
   * {@link #testConnection(String) testConnection} method (that used the default port) or the {@link #testConnection() testConnection}
   * method (that used the default IP and port).
   *
   * @param ip is the ip address (as a String) of the AV receiver to connect
   * @param ipPort is the IP Port of the AV receiver to connect with (Onkyo's default is 60128)
   * @return true if already connected or can connect, and false if can't connect
   **/
  public boolean testConnection(String ip, int ipPort)
  {
    boolean retVal = false;
    if (ip==null || ip.equals("")) ip=DEFAULT_LEDNET_IP;
    if (ipPort==0 ) ipPort=DEFAULT_LEDNET_PORT;

    if (connected_)
    {
      // test existing connection
      if (lednetSocket_.isConnected()) retVal = true;
    }
    else
    {
      // test a new connection
      try
      {
        //1. creating a socket to connect to the server
        lednetSocket_ = new Socket(ip, ipPort);
        if (lednetSocket_!=null) lednetSocket_.close();
        retVal = true;
      }
      catch(UnknownHostException unknownHost)
      {
        System.err.println("You are trying to connect to an unknown host!");
      }
      catch(IOException ioException)
      {
        System.err.println("Can't Connect: "+ioException.getMessage());
      }
    }
    return retVal;
  }


  /**
   * Closes the socket connection.
   * @return true if the closed succesfully
   **/
  public boolean closeSocket()
  {
    //4: Closing connection
    try
    {
      boolean acted = false;
      if (in_!=null) {in_.close();in_=null;acted = true;}
      if (out_!=null) {out_.close();out_=null;acted = true;}
      if (lednetSocket_!=null) {lednetSocket_.close();lednetSocket_=null;acted = true;}
      if (acted) System.out.println("closed connections");
      connected_ = false;
    }
    catch(IOException ioException)
    {
      ioException.printStackTrace();
    }
    return connected_;
  }


  public static String convertAsciiToBase10(String str)  {return convertAsciiToBase10( str, false);}
  public static String convertAsciiToBase10(String str,  boolean dumpOut)
  {
    char[] chars = str.toCharArray();
    StringBuffer base10 = new StringBuffer();
    if (dumpOut) System.out.print(" Base10: ");
    for(int i = 0; i < chars.length; i++)
    {
      base10.append( (int)chars[i]);
      if(i+1<chars.length) base10.append( ";" );
      if (dumpOut) System.out.print("  "+((""+(int)chars[i]).length()==1?"0":"")+(int)chars[i] + " ");
    }
   if (dumpOut) System.out.println("");
    return base10.toString();
  }


  /** Converts an ascii decimal String to a hex  String.
   * @param str holding the string to convert to HEX
   * @return a string holding the HEX representation of the passed in decimal str.
   **/
  public static String convertStringToHex(String str)
  {
     return convertStringToHex( str, false);
  }


  /** Converts an ascii decimal String to a hex  String.
   * @param str holding the string to convert to HEX
   * @param dumpOut flag to turn some debug output on/off
   * @return a string holding the HEX representation of the passed in str.
   **/
  public static String convertStringToHex(String str,  boolean dumpOut)
  {
    char[] chars = str.toCharArray();
    String out_put = "";

    if (dumpOut) System.out.println("    Ascii: "+str);
    if (dumpOut) System.out.print("    Hex: ");
    StringBuffer hex = new StringBuffer();
    for(int i = 0; i < chars.length; i++)
    {
      out_put = Integer.toHexString((int)chars[i]);
      if (out_put.length()==1) hex.append("0");
      hex.append(out_put);
      if (dumpOut) System.out.print("0x"+(out_put.length()==1?"0":"")+ out_put+" ");
    }
    if (dumpOut) System.out.println("");
    if (dumpOut) convertAsciiToBase10(str,dumpOut);
    /*
    if (dumpOut) System.out.print(" Base10: ");
    for(int i = 0; i < chars.length; i++)
    {
      System.out.print("   "+convertHexNumberStringToDecimal(chars[i]));
    }
    if (dumpOut) System.out.println("");
    */

    return hex.toString();
  }


  public static final byte[] intToByteArray(int value)
  {
    return new byte[] {
            (byte)(value >>> 24),
            (byte)(value >>> 16),
            (byte)(value >>> 8),
            (byte)value};
  }

  /** Converts an HEX number String to its decimal equivalent.
   * @param str holding the Hex Number string to convert to decimal
   * @return an int holding the decimal equivalent of the passed in HEX numberStr.
   **/
  public static int convertHexNumberStringToDecimal(String str)
  {
    return convertHexNumberStringToDecimal(str, false);
  }


  /** Converts an HEX number String to its decimal equivalent.
   * @param str holding the Hex Number string to convert to decimal
   * @param dumpOut boolean flag to turn some debug output on/off
   * @return an int holding the decimal equivalent of the passed in HEX numberStr.
   **/
  public static int convertHexNumberStringToDecimal(String str,  boolean dumpOut)
  {
    char[] chars = str.toCharArray();
    String out_put = "";

    if (dumpOut) System.out.println("\n      AsciiHex: 0x"+str);
    if (dumpOut) System.out.print(  "       Decimal: ");

    StringBuffer hex = new StringBuffer();
    String hexInt = new String();
    for(int i = 0; i < chars.length; i++)
    {
      out_put = Integer.toHexString((int)chars[i]);
      if (out_put.length()==1) hex.append("0");
      hex.append(out_put);
      if (dumpOut) System.out.print((out_put.length()==1?"0":"")+ out_put);
    }
    hexInt = ""+(Integer.parseInt( hex.toString(), 16));
    if (dumpOut) System.out.println("");
    if (dumpOut) System.out.println( "      Decimal: "+hexInt.toString());

    return Integer.parseInt(hexInt.toString());

    //return Integer.decode("0x"+str);
  }


  /** Converts a hex byte to an ascii String.
   * @param hex byte holding the HEX string to convert back to decimal
   * @return a string holding the HEX representation of the passed in str.
   **/
  public static String convertHexToString(byte hex)
  {
    byte [] bytes = {hex};
    return convertHexToString( new String(bytes), false);
  }


  /** Converts a hex String to an ascii String.
   * @param hex the HEX string to convert back to decimal
   * @return a string holding the HEX representation of the passed in str.
   **/
  public static String convertHexToString(String hex)
  {
    return convertHexToString( hex, false);
  }


  /** Converts a hex String to an ascii String.
   * @param hex the HEX string to convert backk to decimal
   * @param dumpOut boolean flag to turn some debug output on/off
   * @return a string holding the HEX representation of the passed in str.
   **/
  public static String convertHexToString(String hex,  boolean dumpOut)
  {

    StringBuilder sb = new StringBuilder();
    StringBuilder temp = new StringBuilder();
    String out_put = "";

    if (dumpOut) System.out.print("    Hex: ");
    //49204c6f7665204a617661 split into two characters 49, 20, 4c...
    for( int i=0; i<hex.length()-1; i+=2 ){

        //grab the hex in pairs
        out_put = hex.substring(i, (i + 2));
        if (dumpOut) System.out.print("0x"+out_put+" ");
        //convert hex to decimal
        int decimal = Integer.parseInt(out_put, 16);
        //convert the decimal to character
        sb.append((char)decimal);

        temp.append(decimal);
    }
    if (dumpOut) System.out.println("    Decimal : " + temp.toString());

    return temp.toString();
  }


  /**
    * Wraps a command in a colour data message (data characters).
    *  <br />
    *           49, r, g, b, ww, cw, 0, 15<br />
    *  &nbsp;&nbsp;<span style="color: #FF0000">Red</span>:   49;255;0;0;0;0;0;15;63<br />
    *  &nbsp;&nbsp;<span style="color: #00FF00">Green</span>: 49;0;255;0;0;0;0;15;63<br />
    *  &nbsp;&nbsp;<span style="color: #0000FF">Blue</span>:  49;0;0;255;0;0;0;15;63<br />
    *  &nbsp;&nbsp;<span style="color: #FFFFFF; background: #333333">ColdWhite</span>: 49;0;0;0;0;255;0;15;63 (isy networkResource command = 49;0;0;0;0;255;255;15;62;129;138;139;150)<br />
    *  &nbsp;&nbsp;<span style="color: #00FFFF">Cyan</span>:  49;0;255;255;0;0;0;15;62;129;138;139;150<br />
    *<br />
    * The bytes after the 15 (63) are stated as being checksum value of the first eight values and have to change for each code you send.<br />
    * Notice how the ON/Off commands use 163, 164? IT would seem the byte after the 15 (packet terminator) is always the sum of the digits from the first until the 15 (inclusive)<br />
    * In a normal protocol if the checksum didn't add up correctly the packet would be ignored as noise.<br />
    *  <br /> Thanks go to the contributors at the <a href="http://forum.universal-devices.com/topic/19913-magic-ufo-controller-for-rgbw" > UDI Forum POST</a> writeup.
    *
    * @param rgbw must be one of the 0-255 representing a decimal val for the colour
    * @return StringBuffer holing the full message packet
    **/
  public StringBuilder getLedNetColourMessage(int r, int g, int b, int w)
  {
    String cmdStr = "";
    if(r<0)r=0;if(r>255)r=255;
    if(g<0)g=0;if(g>255)g=255;
    if(b<0)b=0;if(b>255)b=255;
    if(w<0)w=0;if(w>255)w=255;

    int chkSum = 0;  //49+r+g+b+w+15;   //+240;

    StringBuilder sb = new StringBuilder();

    /* This is where I construct the entire message character by character. */
     /*
       0x31     command of setting color and color temperature
       Send      [0X31] + [8bit red data ] + [8bit green data] + [8bit blue data] + [8bit warm white data] + [8bit cold white data]
             + [8bit status sign] + [0xF0 remote,0x0F local] + [check digit] (length of command:9)

       Return   Local(0x0F):no return
       Remote(0xF0): [0xF0 remote] +  [0X31] + [0x00] + [check digit]
       Status sign: [0XF0]  means changing RGB, [0X0F] means W
       Note:phone send commands which control static color.Range of static color value is 00-0xff.When value is 0,PWM is 0%;when value is 0XFF,PWM is 100%;

       The ISY msg for 25% BLU = 49; 0;0;64; 0;0; 0; 15; 128;129;138;139;150
              dido for 100% CW = 49; 0;0;0;0;255;255;15;  62;129;138;139;150
      */
    sb.append((char)Integer.parseInt("31", 16));  //0x31  = 49
    chkSum += 49;

    // char for R G B wW cW
    sb.append((char)Integer.parseInt(""+r, 10));
    chkSum += Integer.parseInt(""+r, 10);
    sb.append((char)Integer.parseInt(""+g, 10));
    chkSum += Integer.parseInt(""+g, 10);
    sb.append((char)Integer.parseInt(""+b, 10));
    chkSum += Integer.parseInt(""+b, 10);
    sb.append((char)Integer.parseInt("00", 16));// 1 char for Warm White (mine is not connected)
    chkSum += Integer.parseInt(""+0, 10);
    sb.append((char)Integer.parseInt(""+w, 10));// 1 char for Cold White
    chkSum += Integer.parseInt(""+w, 10);

    //8bit status sign: [0XF0] means RGB, [0X0F] means W, [0xff] means both
    /*
    if( (r+g+b)>0 && w==0)
      sb.append((char)Integer.parseInt("F0", 16));
    else if( (r+g+b)==0 && w>0)
      sb.append((char)Integer.parseInt("0F", 16));
    else if( (r+g+b)>0 && w>0)
      sb.append((char)Integer.parseInt("FF", 16));
    else if( (r+g+b)==0 && w==0)
      sb.append((char)Integer.parseInt("FF", 16));
    */

    if( (r+g+b)>0 && w==0)  // [0X00] means RGB
    {
      sb.append((char)Integer.parseInt("00", 16));
      chkSum += Integer.parseInt("00", 16);
    }
    else if( (r+g+b)==0 && w>0)  // [0XFF] means W
    {
      sb.append((char)Integer.parseInt("FF", 16));
      chkSum += Integer.parseInt("FF", 16);
    }
    else if( (r+g+b)>0 && w>0)
    {
      sb.append((char)Integer.parseInt("00", 16));
      chkSum += Integer.parseInt("00", 16);
    }
    else if( (r+g+b)==0 && w==0)
    {
      sb.append((char)Integer.parseInt("00", 16));
      chkSum += Integer.parseInt("00", 16);
    }

    sb.append((char)Integer.parseInt("0F", 16));  //0xF0 remote WIFI, 0x0F local / direct WIFI (0x0f=15)
    chkSum += Integer.parseInt("0F", 16);

    // keep the ckecksum below 256
    if(chkSum>(5*256))
      chkSum-=(5*256);
    else if(chkSum>(4*256))
      chkSum-=(4*256);
    else if(chkSum>(3*256))
      chkSum-=(3*256);
    else if(chkSum>(2*256))
      chkSum-=(2*256);
    else if(chkSum>(256))
      chkSum-=(256);

    // 1 char for checkSum
    sb.append((char)Integer.parseInt(""+chkSum, 10));

    // msg end
    sb.append((char)Integer.parseInt(""+129, 10));
    sb.append((char)Integer.parseInt(""+138, 10));
    sb.append((char)Integer.parseInt(""+139, 10));
    sb.append((char)Integer.parseInt(""+150, 10));

    return sb;
  }  //getLedNetColourMessage


  /**
    * This implements the custom message format - NOT DONE YET.
    **/
  public StringBuilder getCustomMessage(int r, int g, int b, int w, int r2, int g2, int b2, int w2, int speed)
  {
    String cmdStr = "";
    w=0; w2=0;  // ignore for now
    if(r<0)r=0;if(r>255)r=255;
    if(g<0)g=0;if(g>255)g=255;
    if(b<0)b=0;if(b>255)b=255;
    if(w<0)w=0;if(w>255)w=255;

    int chkSum = Integer.parseInt("51", 16)+
                 r+g+b+w+r2+g2+b2+w2+
                 speed+
                 Integer.parseInt("60", 16)+Integer.parseInt("FF", 16)+Integer.parseInt("0F", 16);

    if(chkSum>(13*256))
      chkSum-=(13*256);
    else if(chkSum>(12*256))
      chkSum-=(12*256);
    else if(chkSum>(11*256))
      chkSum-=(11*256);
    else if(chkSum>(10*256))
      chkSum-=(10*256);
    else if(chkSum>(9*256))
      chkSum-=(9*256);
    else if(chkSum>(8*256))
      chkSum-=(8*256);
    else if(chkSum>(7*256))
      chkSum-=(7*256);
    else if(chkSum>(6*256))
      chkSum-=(6*256);
    else if(chkSum>(5*256))
      chkSum-=(5*256);
    else if(chkSum>(4*256))
      chkSum-=(4*256);
    else if(chkSum>(3*256))
      chkSum-=(3*256);
    else if(chkSum>(2*256))
      chkSum-=(2*256);
    else if(chkSum>(256))
      chkSum-=(256);

    StringBuilder sb = new StringBuilder();
    String zeroColour5ByteStr = ""+(char)Integer.parseInt("00", 16)+(char)Integer.parseInt("00", 16)+(char)Integer.parseInt("00", 16);
    int numColours = 0;
    //int speed = 50;  // 0 - 100

    /* This is where I construct the entire message character by character. */
    /*
      0x51      command of setting command of custom mode
      Send       [0X51] + [First point 32bit color value] + [Second point 32bit color value] + [Third point 32bit color value] +
                 [Fourth point 32bit color value] + [Fifth point 32bit color value] + [Sixth point 32bit color value] +
                 [Seventh point 32bit color value] + [Eighth point 32bit color value] + [Ninth point 32bit color value] +
                 [Tenth point 32bit color value] + [Eleventh point 32bit color value] + [Twelfth point 32bit color value] +
                 [Thirteenth point 32bit color value] + [Fourteenth point 32bit color value] + [Fifteenth point 32bit color value] +
                 [Sixteenth point 32bit color value] + [8bit speed value] + [8bit mode value] +
                 [0XFF] + [0xF0 remote,0x0F local] + [check digit] (length of command:55)"

      Return     If command is local(0x0F):no return
             If command is remote (0xF0): [0xF0 remote] +  [0X51] + [0x00] + [check digit]

        Note:In command of custom mode,value of RGB cannot be 0x01,0x02,0x03.Otherwise,RGB is over.
             mode: Custome mode is 0x60

       32bit colour: ARGB values are typically expressed using 8 hexadecimal digits, with each pair of the hexadecimal digits
                     representing the values of the Alpha, Red, Green and Blue channel, respectively.
                     For example, 80FFFF00 represents 50.2% opaque (non-premultiplied) yellow.
                     SEE: https://en.wikipedia.org/wiki/RGBA_color_space#RGBA_hexadecimal_.28word-order.29
    */
    sb.append((char)Integer.parseInt("51", 16));  //0x51
    // char for R G B wW cW
    //int first32BitColour = Integer.parseInt(""+r, 10)+Integer.parseInt(""+g, 10)+Integer.parseInt(""+b, 10)+Integer.parseInt(""+w, 10);
    String first32BitColourHexStr = convertStringToHex(""+r,true)+convertStringToHex(""+g,true)+convertStringToHex(""+b,true)+convertStringToHex(""+w,true);
    byte [] bytes1 = intToByteArray(Integer.parseInt(first32BitColourHexStr, 16));
    if (debugging_) System.out.println("32bit Colour1: "+Arrays.toString(bytes1));
    String second32BitColourHexStr = convertStringToHex(""+r2,true)+convertStringToHex(""+g2,true)+convertStringToHex(""+b2,true)+convertStringToHex(""+w2,true);
    byte [] bytes2 = intToByteArray(Integer.parseInt(second32BitColourHexStr, 16));
    if (debugging_) System.out.println("32bit Colour2: "+Arrays.toString(bytes2));

    for (int i=0;i<bytes1.length;i++) sb.append((char)bytes1[i]);
    numColours++;

    for (int i=0;i<bytes2.length;i++) sb.append((char)bytes2[i]);
    numColours++;

    for (int i=0; i< 16-numColours;i++) sb.append(zeroColour5ByteStr);

    sb.append((char)Integer.parseInt(""+speed, 10));
    sb.append((char)Integer.parseInt("60", 16)); // mode: custom mode is 0x60

    sb.append((char)Integer.parseInt("FF", 16));
    sb.append((char)Integer.parseInt("0F", 16)); //0xF0 remote WIFI, 0x0F local / direct WIFI

    // 1 char for checkSum
    sb.append((char)Integer.parseInt(""+chkSum, 10));

    // msg end
    sb.append((char)Integer.parseInt(""+129, 10));
    sb.append((char)Integer.parseInt(""+138, 10));
    sb.append((char)Integer.parseInt(""+139, 10));
    sb.append((char)Integer.parseInt(""+150, 10));

    return sb;
  }  //getLedNetColourMessage


  /** Override helper method to redirect to getLedNetOnOffMessage true. **/
  public StringBuilder getLedNetOnMessage(){ return getLedNetOnOffMessage(true);}
  /** Override helper method to redirect to getLedNetOnOffMessage false. **/
  public StringBuilder getLedNetOffMessage(){ return getLedNetOnOffMessage(false);}


  /**
    * Wraps an On or Off command in a  data message (data characters).
    *  <br />
    *  On: 113;35;15;163;129;138;139;150<br />
    *  Off: 113;36;15;164;129;138;139;150<br />
    *<br />
    * The bytes after the 15 (163) are stated as being checksum value of the first eight values and have to change for each code you send.<br />
    * Notice how the ON/Off commands use 163, 164? IT would seem the byte after the 15 (packet terminator) is always the sum of the digits from the first until the 15 (inclusive)<br />
    * In a normal protocol if the checksum didn't add up correctly the packet would be ignored as noise.<br />    *
    * @param on must be true to send on command, or false to send OFF command
    * @return StringBuffer holing the full message packet
   **/
  public StringBuilder getLedNetOnOffMessage(boolean on)
  {
    String cmdStr = "";
    int chkSum = (on?35:36)+113+15;
    StringBuilder sb = new StringBuilder();

    /* This is where I construct the entire message
        character by character. */
    sb.append((char)Integer.parseInt("113", 10));

    // 1 char for On/Off
    sb.append((char)Integer.parseInt(""+(on?35:36), 10));
    sb.append((char)Integer.parseInt(""+15, 10));

    // 1 char for checkSum
    sb.append((char)Integer.parseInt(""+chkSum, 10));

    // msg end
    sb.append((char)Integer.parseInt(""+129, 10));
    sb.append((char)Integer.parseInt(""+138, 10));
    sb.append((char)Integer.parseInt(""+139, 10));
    sb.append((char)Integer.parseInt(""+150, 10));

    return sb;
  }  //getLedNetOnOffMessage


  /** Sends the passed in on or off command to LedNet and leaves the socket open.
    *
    * @param on true or falso to send On or Off.
  **/
  public String sendOnOffCommand(boolean on){return sendOnOffCommand(on, false);}


  /**
    * Sends to command to the receiver and does not wait for a reply.
    *
    * @param on true or falso to send On or Off.
    * @param closeSocket flag to close the connection when done or leave it open.
    **/
  public String sendOnOffCommand(boolean on, boolean closeSocket)
  {
    String retVal = "";

    StringBuilder sb = getLedNetOnOffMessage(on);
    if(connectSocket())
    {
      try
      {
        if (debugging_) System.out.print("  sending "+sb.length() +" chars: ");
        //out_.writeObject(sb.toString());
        //out_.writeChars(sb.toString());
        out_.writeBytes(sb.toString());  // <--- This is the one that works
        //out_.writeBytes(convertStringToHex(sb.toString(), false));
        //out_.writeChars(convertStringToHex(sb.toString(), false));
        out_.flush();
        if (debugging_)  System.out.println((on?" ON ":" OFF ")+"sent!" );
      }
      catch(IOException ioException)
      {
        ioException.printStackTrace();
      }
    }
    if (closeSocket) closeSocket();

    return retVal;
  }


  /**
    * Sends to command to the receiver and does not wait for a reply AND leaves the socket open.
    *
    * @param rgbw are the colour levels (0-255)
    **/
  public String sendColourCommand(int r, int g, int b, int w){return sendColourCommand(r, g, b, w, false, false);}


  /**
    * Sends to command to the receiver and does not wait for a reply.
    *
    * @param rgbw are the colour levels (0-255)
    * @param closeSocket flag to close the connection when done or leave it open.
    **/
  public String sendColourCommand(int r, int g, int b, int w, boolean waitForResponse, boolean closeSocket)
  {
    String retVal = "";
    StringBuilder sb = getLedNetColourMessage(r,g,b,w);
    //StringBuilder sb2 = getLedNetColourMessage(0,128,0,0);
    if(connectSocket())
    {
      try
      {
        if(debugging_)System.out.print("  sending "+sb.toString().getBytes("UNICODE").length +" chars (bytes): ");

        //convertStringToHex(sb.toString(), true);
        //out_.writeObject(sb.toString());
        //out_.writeChars(sb.toString());

        if(debugging_)System.out.println(sb.toString().getBytes("UNICODE"));
        out_.writeBytes(sb.toString());  // <--- This is the one that works

        //if(debugging_)System.out.println(convertStringToHex(sb.toString(),false));
        //out_.writeBytes(convertStringToHex(sb.toString(), false));
        //out_.writeChars(convertStringToHex(sb.toString(), false));
        out_.flush();

        //out_.writeBytes(sb2.toString());
        //out_.flush();

        if(debugging_)System.out.println("sent!" );
        if(waitForResponse)
        {
          /* now listen for the response. */
          Vector <String> rv = null;
          rv = readQueryResponses();
        }
      }
      catch(IOException ioException)
      {
        ioException.printStackTrace();
      }
    }
    if (closeSocket) closeSocket();

    return retVal;
  }


  /**
    * Sends to command to the receiver and does not wait for a reply AND leaves the socket open.
    *
    * @param rgbw are the colour levels (0-255)
    **/
  public void sendCustomCommand(int r, int g, int b, int w, int r2, int g2, int b2, int w2, int speed){sendCustomCommand(r, g, b, w, r2, g2, b2, w2, speed, false);}


  /**
    * Sends to command to the receiver and does not wait for a reply.
    *
    * @param rgbw are the colour levels (0-255)
    * @param closeSocket flag to close the connection when done or leave it open.
    **/
  public void sendCustomCommand(int r, int g, int b, int w, int r2, int g2, int b2, int w2, int speed, boolean closeSocket)
  {
    boolean waitForResponse = false;
    StringBuilder sb = getCustomMessage(r,g,b,w,r2,g2,b2,w2,speed);
    StringBuilder sb2 = getLedNetColourMessage(0,128,0,0);
    if(connectSocket())
    {
      try
      {
        if(debugging_)System.out.println("  sending "+sb.length() +" chars: ");
        if(debugging_)System.out.println(convertStringToHex(sb.toString(),true));
        //convertStringToHex(sb.toString(), true);
        //out_.writeObject(sb.toString());
        //out_.writeChars(sb.toString());
        out_.writeBytes(sb.toString());  // <--- This is the one that works
        //out_.writeBytes(convertStringToHex(sb.toString(), false));
        //out_.writeChars(convertStringToHex(sb.toString(), false));
        out_.flush();

        //out_.writeBytes(sb2.toString());
        //out_.flush();

        if(debugging_)System.out.println("sent!" );
        if(waitForResponse)
        {
          /* now listen for the response. */
          Vector <String> rv = null;
          rv = readQueryResponses();
        }

      }
      catch(IOException ioException)
      {
        ioException.printStackTrace();
      }
    }
    if (closeSocket) closeSocket();
  }


  /** A method to wrap a number of colour change calls (just for fun).
  *
  * @param loopTime is how long to loop the fun OR -1 to run forever.
  **/
  public void fun(int loopTime){ fun(loopTime,0);}
  /** A method to wrap a number of colour change calls (just for fun).
  *
  * @param loopTime is how long to loop the fun OR -1 to run forever.
  * @param pause is the delay between colour change calls in the loop
  **/
  public void fun(int loopTime, long pause)
  {
    int r = 10; int g = 0; int b = 0; int w = 0;
    long looping = 0;
    long msgTime = 505;
    int count = 0;
    System.out.println("Fun "+(loopTime!=-1?" for "+loopTime +"ms.":" Indefinately."));
    String t1 = ca.bc.webarts.widgets.Util.createCurrentTimeStamp();
    int []reds = {15,15, 0, 0, 0, 5};
    int []grns = { 0,15,15,15, 0, 0};
    int []blus = { 0, 0, 0, 5,15,15};
    int []whts = { 0, 0, 0, 0, 0, 0};
    while(loopTime==-1||looping<loopTime)
    {
      for(int i=0; i< reds.length;i++)
      {
        r = reds[i]; g = grns[i]; b = blus[i]; w = whts[i];
        sendColourCommand(r,g,b,w); sleep(pause);
      }

      if(loopTime!=-1) {looping+=6*(pause+msgTime);count++;}
    }
    String t2 = ca.bc.webarts.widgets.Util.createCurrentTimeStamp();
    double duration = secondsBetween(t1,t2); // in ms
    System.out.println("duration="+duration);
    System.out.println("count="+count);
    System.out.println("msgDuration="+(duration*1000/count/6 - pause) );
  }


  /** A method to wrap a number of colour change calls (just for fun).
  *
  * @param loopTime is how long to loop the fun OR -1 to run forever.
  **/
  public void christmasFun(int loopTime){ fun(loopTime,0);}
  /** A method to wrap a number of colour change calls (just for fun).
  *
  * @param loopTime is how long to loop the fun OR -1 to run forever.
  * @param pause is the delay between colour change calls in the loop
  **/
  public void christmasFun(int loopTime, long pause)
  {
    boolean dim = true;
    int r = 10; int g = 0; int b = 0; int w = 0;
    long looping = 0;
    long msgTime = 505;
    int count = 0;
    System.out.println("Xmas Fun "+(loopTime!=-1?" for "+loopTime +"ms.":" Indefinately."));
    String t1 = ca.bc.webarts.widgets.Util.createCurrentTimeStamp();
    int []reds1 = {60,45,60,30,30,20,15, 8, 8, 8, 8, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    int []grns1 = { 0, 0, 0, 0, 0, 0, 1, 2, 4, 8,15,15,15,15,15,20,20,30,30,60,45,60};
    int []blus1 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    int []whts1 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    int []reds2 = { 8, 8, 7, 6, 5, 4, 4, 3, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    int []grns2 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 8};
    int []blus2 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    int []whts2 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    int []reds = reds1;
    int []grns = grns1;
    int []blus = blus1;
    int []whts = whts1;

    if (dim)
    {
      reds = reds2;
      grns = grns2;
      blus = blus2;
      whts = whts2;
    }

    while(loopTime==-1||looping<loopTime)
    {
      for(int i=0; i< reds.length;i++)
      {
        r = reds[i]; g = grns[i]; b = 0; w = 0;
        sendColourCommand(r,g,b,w); sleep(pause);
      }
      for(int i=reds.length-1; i>=0 ;i--)
      {
        r = reds[i]; g = grns[i]; b = 0; w = 0;
        sendColourCommand(r,g,b,w); sleep(pause);
      }

      if(loopTime!=-1) {looping+=6*(pause+msgTime);count++;}
    }
    String t2 = ca.bc.webarts.widgets.Util.createCurrentTimeStamp();
    double duration = secondsBetween(t1,t2); // in ms
    System.out.println("duration="+duration);
    System.out.println("count="+count);
    System.out.println("msgDuration="+(duration*1000/count/6 - pause) );
  }


  /** A method to wrap a number of colour change calls (just for fun).
  *
  * @param loopTime is how long to loop the fun OR -1 to run forever.
  **/
  public void christmasFade(){ christmasFade(64,-1,0);}
  /** A method to wrap a number of colour change calls (just for fun).
  *
  * @param loopTime is how long to loop the fun OR -1 to run forever.
  **/
  public void christmasFade(int loopTime){ christmasFade(64, loopTime,0);}
  /** A method to wrap a number of colour change calls (just for fun).
  *
  * @param loopTime is how long to loop the fun OR -1 to run forever.
  * @param pause is the delay between colour change calls in the loop
  **/
  public void christmasFade(int toLevel, int loopTime, long pause)
  {
    long looping = 0;
    //int loopTime = -1;
    //long pause = 250;
    long msgTime = 505;
    int count = 0;

    // Turn On
    sendColourCommand(0,0,0,0);
    String queryResponse =  sendQueryOnOffCommand(true, false);

    // Fade
    while(loopTime==-1||looping<loopTime)
    {

      fadeBetweenCommand( 0,1,0,0, 0,toLevel,0,0 ,  FadeSpeed.SLOW); // green
      fadeBetweenCommand( 0,toLevel,0,0, 0,2,0,0,   FadeSpeed.SLOW);  // dim the green
      fadeBetweenCommand( 0,2,0,0, 2,2,0,0,   FadeSpeed.SLOW);  // red
      fadeBetweenCommand( 2,2,0,0, toLevel,0,0,0,   FadeSpeed.SLOW);  // red
      sleep(1000);
      sendColourCommand(4,0,0,0);
      sleep(250);
      sendColourCommand(toLevel,0,0,0);
      sleep(250);
      sendColourCommand(4,0,0,0);
      sleep(250);
      //sendColourCommand(toLevel,0,0,0);
      fadeBetweenCommand( toLevel,0,0,0 ,2,2,0,0,   FadeSpeed.SLOW);  // dim the red
      fadeBetweenCommand( 2,2,0,0, 0,2,0,0,    FadeSpeed.SLOW);  // green
      sleep(1000);
      sendColourCommand(0,4,0,0);
      sleep(250);
      sendColourCommand(0,toLevel,0,0);
      sleep(250);
      sendColourCommand(0,4,0,0);
      sleep(250);
      if(loopTime!=-1) {looping+=6*(pause+msgTime);count++;}
    }

    //Turn OFF
    sendQueryOnOffCommand(false, true);
  }


  public void slowBurn(int toLevel, int loopTime, long pause)
  {
    long looping = 0;
    //int loopTime = -1;
    //long pause = 250;
    long msgTime = 505;
    int count = 0;

    // Turn On
    sendColourCommand(0,0,0,0);
    String queryResponse =  sendQueryOnOffCommand(true, false);

    // Fade
    boolean waitDelay = true;
    int waitDelayMs = 750;
    while(loopTime==-1||looping<loopTime)
    {
      //fadeBetweenCommand(int r, int g, int b, int w, int r2, int g2, int b2, int w2, FadeSpeed speed, boolean nonLinear)
      sendColourCommand( 6,0,0,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 6,0,0,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 5,0,1,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 5,0,1,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,2,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 3,0,3,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 2,0,4,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 2,0,5,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 2,0,5,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 2,0,6,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 1,0,6,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 1,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 1,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 0,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 0,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 0,0,7,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,10,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,10,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,11,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,11,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,12,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,12,0, waitDelay, false);sleep(waitDelayMs);
      sleep(1500);
      //sendColourCommand( 0,0,11,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,11,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,10,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,10,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,9,0, waitDelay, false);sleep(waitDelayMs);
      //sendColourCommand( 0,0,9,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 0,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 0,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 0,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 1,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 1,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 2,0,7,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 2,0,6,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 3,0,6,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 3,0,5,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,5,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,4,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,3,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,2,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,1,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,1,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,0,0, waitDelay, false);sleep(waitDelayMs);
      sendColourCommand( 4,0,0,0, waitDelay, false);sleep(waitDelayMs);
      sleep(1500);
      if(loopTime!=-1) {looping+=6*(pause+msgTime);count++;}
    }

    //Turn OFF
    sendQueryOnOffCommand(false, true);
  }


  /**
    * linear Steps the rgbw  between the passed values to provide a fade. It will NOT turn the LedNet ON if not already on.
    *
    * @param r starting red value
    * @param r2 ending red value
    **/
  public void stepBetween(int r, int g, int b, int w, int r2, int g2, int b2, int w2)
  {
    int maxD = 0;
    int rD = r2-r;
    if(java.lang.Math.abs(rD)>maxD) maxD=java.lang.Math.abs(rD);
    int gD = g2-g;
    if(java.lang.Math.abs(gD)>maxD) maxD=java.lang.Math.abs(gD);
    int bD = b2-b;
    if(java.lang.Math.abs(bD)>maxD) maxD=java.lang.Math.abs(bD);
    int wD = w2-w;
    if(java.lang.Math.abs(wD)>maxD) maxD=java.lang.Math.abs(wD);
    if(debugging_)System.out.println("\nStepping\n      rD="+rD+"   gD="+gD+"   bD="+bD+"   wD="+wD+"   maxD="+maxD);
    int steps = maxD;
    double stepsd = steps;
    if(debugging_)System.out.println("Stepping "+maxD+" times: r "+r+"-->"+r2+"    g "+g+"-->"+g2+"    b "+b+"-->"+b2+"    w "+w+"-->"+w2);

    int nextR = r;
    int nextG = g;
    int nextB = b;
    int nextW = w;
    int rStepSize = (rD>0?1:(rD<0?-1:0));
    int gStepSize = (gD>0?1:(gD<0?-1:0));
    int bStepSize = (bD>0?1:(bD<0?-1:0));
    int wStepSize = (wD>0?1:(wD<0?-1:0));
    int rSteps = 0;
    int gSteps = 0;
    int bSteps = 0;
    int wSteps = 0;
    int rStepCount = 0;
    int gStepCount = 0;
    int bStepCount = 0;
    int wStepCount = 0;

    if(rD!=0) rSteps = dToi(maxD / rD);
    if(gD!=0) gSteps = dToi(maxD / gD);
    if(bD!=0) bSteps = dToi(maxD / bD);
    if(wD!=0) wSteps = dToi(maxD / wD);
    if(debugging_)System.out.println("Stepping "+maxD+" times: red "+rSteps+"    green "+gSteps+"    blue "+bSteps+"    w "+wSteps);


    int i=0;
    for (i=0; i< steps; i++)
    {
      if(rStepCount == java.lang.Math.abs(rSteps))
      {
        nextR += rStepSize;
        rStepCount = 1;
      }
      else
      {
        rStepCount++;
      }
      if(gStepCount == java.lang.Math.abs(gSteps))
      {
        nextG += gStepSize;
        gStepCount = 1;
      }
      else
      {
        gStepCount++;
      }
      if(bStepCount == java.lang.Math.abs(bSteps))
      {
        nextB += bStepSize;
        bStepCount = 1;
      }
      else
      {
        bStepCount++;
      }
      if(wStepCount == java.lang.Math.abs(wSteps))
      {
        nextW += wStepSize;
        wStepCount = 1;
      }
      else
      {
        wStepCount++;
      }

      if(debugging_) System.out.println(""+i+"/"+steps+" ]  nextR="+nextR+"  nextG="+nextG+"  nextB="+nextB+"  nextW="+nextW);
      sendColourCommand(nextR, nextG, nextB, nextW);
    }
    // One Last Step
    nextR += rStepSize;
    nextG += gStepSize;
    nextB += bStepSize;
    nextW += wStepSize;
    if(debugging_) System.out.println(""+i+"/"+steps+" ]  nextR="+nextR+"  nextG="+nextG+"  nextB="+nextB+"  nextW="+nextW);
    sendColourCommand(nextR, nextG, nextB, nextW);
  }


    /**
    * Steps the non-linear LedLevel rgbw between the passed values to provide a fade. It will also turn the LedNet ON if not already on.
    *
    * @param nonLinear boolean flag to choose between linear or default non-linear level lookup.
    **/
  public void fadeBetweenCommand(int r, int g, int b, int w, int r2, int g2, int b2, int w2, FadeSpeed speed)
  {
    fadeBetweenCommand(r, g, b, w, r2, g2, b2, w2, speed, true);
  }


  /**
    * Steps the rgbw (linear or non-linear LedLevel ) between the passed values to provide a fade. It will also turn the LedNet ON if not already on.
    *
    * @param nonLinear boolean flag to choose between linear or default non-linear level lookup.
    **/
  public void fadeBetweenCommand(int r, int g, int b, int w, int r2, int g2, int b2, int w2, FadeSpeed speed, boolean nonLinear)
  {
    boolean dryRun = false;
    int stepMultiple = 1;
    int fadeSteps = speed.getLevelSteps();
    double fadeStepsd = fadeSteps;
    double stepMultipled = stepMultiple;

    if(debugging_)System.out.println((nonLinear?"NON-linear ":"")+"Fading "+fadeSteps+": r "+r+"-->"+r2+"    g "+g+"-->"+g2+"    b "+b+"-->"+b2+"    w "+w+"-->"+w2);
    int rD = r2-r;
    int gD = g2-g;
    int bD = b2-b;
    int wD = w2-w;
    if(debugging_)System.out.println("      rD="+rD+"   gD="+gD+"   bD="+bD+"   wD="+wD);

    int rlD = levelsDiff(r,r2, nonLinear); // returns the abs diff between the ledLevels for r and r2
    int glD = levelsDiff(g,g2, nonLinear);
    int blD = levelsDiff(b,b2, nonLinear);
    int wlD = levelsDiff(w,w2, nonLinear);
    double rlDd = rlD;
    double glDd = glD;
    double blDd = blD;
    double wlDd = wlD;

    int maxLevelDiff = Math.max(Math.max(Math.max(rlD,glD),blD),wlD);

    int maxLevelStep = (int) Math.round((double)(maxLevelDiff/fadeSteps));

    if(debugging_)
    {
      System.out.println("FadingLevelSteps "+fadeSteps+": r "+r+"/"+ledLevel(r, nonLinear)+"-->"+ledLevel(r2, nonLinear)+
                         "    g "+g+"/"+ledLevel(g, nonLinear)+"-->"+ledLevel(g2, nonLinear)+"    b "+b+"/"+ledLevel(b, nonLinear)+"-->"+ledLevel(b2, nonLinear)+"    w "+w+"/"+ledLevel(w, nonLinear)+"-->"+ledLevel(w2, nonLinear));
      System.out.println("    LevelDIFFs rlD="+rlD+"   glD="+glD+"   blD="+blD+"   wlD="+wlD);
      System.out.println("   maxLevelDiff="+maxLevelDiff);
    }

    if(fadeSteps>maxLevelDiff) fadeSteps=maxLevelDiff;
    int levelStepSize = fadeSteps;

    //if(stepTime < fastestStep) stepTime = fastestStep;

    int rlStep = (rD<0?-1:1)*(rlD==0?0:rlD/fadeSteps)*stepMultiple; // these are in ledLevels
    int glStep = (gD<0?-1:1)*(glD==0?0:glD/fadeSteps)*stepMultiple;
    int blStep = (bD<0?-1:1)*(blD==0?0:blD/fadeSteps)*stepMultiple;
    int wlStep = (wD<0?-1:1)*(wlD==0?0:wlD/fadeSteps)*stepMultiple;
    double rlStepd = (rD<0?-1:1)*(rlD==0?0:rlDd/fadeStepsd)*stepMultipled; // these are in ledLevels
    double glStepd = (gD<0?-1:1)*(glD==0?0:glDd/fadeStepsd)*stepMultipled;
    double blStepd = (bD<0?-1:1)*(blD==0?0:blDd/fadeStepsd)*stepMultipled;
    double wlStepd = (wD<0?-1:1)*(wlD==0?0:wlDd/fadeStepsd)*stepMultipled;

    DoubleAdder currRleveld = new DoubleAdder();
    DoubleAdder currGleveld = new DoubleAdder();
    DoubleAdder currBleveld = new DoubleAdder();
    DoubleAdder currWleveld = new DoubleAdder();

    int currRlevel=ledLevel(r, nonLinear);
    currRleveld.add(Double.parseDouble(""+currRlevel));
    int currGlevel=ledLevel(g, nonLinear);
    currGleveld.add(Double.parseDouble(""+currGlevel));
    int currBlevel=ledLevel(b, nonLinear);
    currBleveld.add(Double.parseDouble(""+currBlevel));
    int currWlevel=ledLevel(w, nonLinear);
    currWleveld.add(Double.parseDouble(""+currWlevel));
    int prevRlevel=currRlevel;
    int prevGlevel=currGlevel;
    int prevBlevel=currBlevel;
    int prevWlevel=currWlevel;
    if(debugging_)
    {
      System.out.println("testFading :    rlStep="+rlStep+"   glStep="+glStep+"   blStep="+blStep+"   wlStep="+wlStep);
      System.out.println("testFading :    rlStepd="+rlStepd+"   glStepd="+glStepd+"   blStepd="+blStepd+"   wlStepd="+wlStepd);
      System.out.println("num steps : fadeSteps="+fadeSteps);
    }
    String t1 = ca.bc.webarts.widgets.Util.createCurrentTimeStamp();
    if(!dryRun)
    {
      //sendColourCommand(r,g,b,w);
      //sleep(100);
    }
    String t2 = ca.bc.webarts.widgets.Util.createCurrentTimeStamp();
    for(int i=0; i<= fadeSteps; i++)
    {
      /*System.out.println("i:"+i+"     rLevel="+currRlevel+
                                "     gLevel="+currGlevel+
                                "     bLevel="+currBlevel+
                                "     wLevel="+currWlevel
                         );*/
      if(debugging_)
      {
        System.out.println("i:"+i+"   rLevelda="+daToi(currRleveld)+
                                  "   gLevelda="+daToi(currGleveld)+
                                  "   bLevelda="+daToi(currBleveld)+
                                  "   wLevelda="+daToi(currWleveld)
                           );
      }

      if(!dryRun)
      {
        boolean oldDebug = debugging_;
        debugging_=false;
          //sendOnOffCommand(true,false);
          //sendColourCommand(currRlevel,currGlevel,currBlevel,currWlevel);  // these are already ledLevel'd
          sendColourCommand(daToi(currRleveld),daToi(currGleveld),daToi(currBleveld),daToi(currWleveld));  // these are already ledLevel'd
        debugging_=oldDebug;
        //sleep(100);
      }
      prevRlevel=currRlevel;
      prevGlevel=currGlevel;
      prevBlevel=currBlevel;
      prevWlevel=currWlevel;
      currRlevel+=rlStep;currGlevel+=glStep;currBlevel+=blStep;currWlevel+=wlStep;
      currRleveld.add(rlStepd);currGleveld.add(glStepd);currBleveld.add(blStepd);currWleveld.add(wlStepd);
    }
    String t3 = ca.bc.webarts.widgets.Util.createCurrentTimeStamp();
    if(!debugging_)
    {
      System.out.println("t1= "+t1);
      System.out.println("t2= "+t2);
      System.out.println("t3= "+t3);
    }
  }


  /**
    * Function to accepts a double and returns an int primitive.  Could also get implemented as a java 8 java.util.function.DoubleToIntFunction
  **/
  private int dToi(double d) { return (new Double(d)).intValue();}


  /**
    * Function to accepts a java 8 doubleAdder and returns an int primitive.
  **/
  private int daToi(DoubleAdder d) { return (new Double(d.sum())).intValue();}


  public  String right(String value, int length)
  {
    // To get right characters from a string, change the begin index.
    return value.substring(value.length() - length);
  }


  /**
    * Calculates the seconds between the 2 passed timeStamps.
  **/
  public  double secondsBetween(String t1,String t2)
  {
    /*
    System.out.println("t1= "+t1);
    System.out.println("t2= "+t2);
    System.out.println("tm1= "+t1.substring((t1.length() - (t1.startsWith("0")?8:9)), 5));
    System.out.println("tm2= "+t2.substring((t2.length() - (t2.startsWith("0")?8:9)), 5));
    System.out.println("add60= "+!t2.substring((t2.length() - (t2.startsWith("0")?8:9)), 5).equals(t1.substring((t1.length() - (t1.startsWith("0")?8:9)), 5)));
    */
    double add60 = 0d;
    double mins = Double.parseDouble(t2.substring((t2.length() - (t2.startsWith("0")?8:9)), 5)) - Double.parseDouble(t1.substring((t1.length() - (t1.startsWith("0")?8:9)), 5));
    if(!t2.substring((t2.length() - (t2.startsWith("0")?8:9)), 5).equals(t1.substring((t1.length() - (t1.startsWith("0")?8:9)), 5))) add60 = 60d;
    //System.out.println("t2.length()= "+t2.length());
    //System.out.println("seconds= "+t2.substring((t2.length() - (t2.startsWith("0")?5:6)), 8)+"."+right(t2,3));
    return Double.parseDouble(t2.substring((t2.length() - (t2.startsWith("0")?5:6)), 8)+"."+right(t2,3))+ mins*add60 -
           Double.parseDouble(t1.substring((t1.length() - (t1.startsWith("0")?5:6)), 8)+"."+right(t1,3));
  }


  /**
  * LED Level lookup from the <b>non-linear</b> hashmap setup in {@link #initLevelsMap() initLevelsMap}.
  *
  * @param v is the (0-255) level to lookup the non-linear level lookup.
  **/
  private int ledLevel(int v)  { return ledLevel(v, true);}


  /**
  * LED Level lookup from the linear or non-linear hashmap setup in {@link #initLevelsMap() initLevelsMap}.
  *
  * @param v is the (0-255) level to lookup the non-linear level lookup.
  * @param nonLinear boolean flag to choose between linear or default non-linear level lookup from {@link #HashMap levels_} map.
  **/
  private int ledLevel(int v, boolean nonLinear)
  {
    int retVal = levels_.get(Integer.valueOf(v)).intValue(); // start with the default map lookup
    if(v<0)v=0;if(v>255)v=255;

    boolean direct = false;
    boolean lookup = false;
    boolean useExponential = true;
    //(1+EXP(((A2/21)-6)*-1))*255
    //int form = Math.round( (int)(1/((1+Math.exp(((v/21)-6)*-1))*255)));

    //System.out.println("v="+v+"  "+levels_.get(Integer.valueOf(v)).intValue());
    //System.out.println("v="+v+"  ExpLevel="+1/((1+Math.exp(((v/21)-6)*-1))*255));
    if (direct) retVal = v;
    else if (useExponential) retVal = expLedLevel(v);

    //System.out.println("v="+v+" "+(useExponential?" ExponLevel=":"")+retVal);
    return retVal;
  }


  /**
  * LED Level lookup from an exponential formula.
  *
  * @param v is the (0-255) level to lookup the non-linear level lookup.
  **/
  private int expLedLevel(int v)
  {
    double vd = (double) v;
    if(vd<0.0)vd=0.0;if(vd>255.0)vd=255.0;
    //double retVal = (1/(1+Math.exp(vd*-1))*255);
    int retVal = (int) Math.round( 1/(1+Math.exp((((vd)/21)-6)*-1))*255+0.5);
    if(v==0) retVal = 0;
    return retVal;
  }


  /**
  * The difference between the LED Level lookup from the non-linear hashmap setup in {@link #initLevelsMap() initLevelsMap}.
  *
  * @param l1 is the (0-255) level to lookup the non-linear level lookup.
  * @param l2 is the (0-255) level to lookup the non-linear level lookup.
  **/
  private int levelsDiff(int l1, int l2) {return levelsDiff(l1,l2,true);}
  /**
  * The difference between the LED Level lookup from the linear or non-linear hashmap setup in {@link #initLevelsMap() initLevelsMap}.
  *
  * @param l1 is the (0-255) level to lookup the non-linear level lookup.
  * @param l2 is the (0-255) level to lookup the non-linear level lookup.
  * @param nonLinear boolean flag to choose between linear or default non-linear level lookup.
  **/
  private int levelsDiff(int l1, int l2, boolean nonLinear)
  {
    int levelDiff = l1-l2;
    //System.err.println("Diffing: l1="+l1+"  l2="+l2);
    //System.err.println("Diffing: ledLevel(l1)="+ledLevel(l1)+"  ledLevel(l2)="+ledLevel(l2));
    try
    {
      if (nonLinear)
        levelDiff = Math.abs(ledLevel(l1)-ledLevel(l2));
      else
        levelDiff = Math.abs(levelDiff);
    }
    catch (java.lang.NullPointerException npe)
    {
      System.err.println("ERROR: levelsDiff l1="+l1+"  l2="+l2);
      npe.printStackTrace();
    }
    return levelDiff;
  }


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


  /**
    * Get Method for class field 'levelCount'.
    *
    * @return int - The value the class field 'levelCount'.
    *
    **/
  public int getLevelCount()
  {
    return levelCount;
  }  // getLevelCount Method


  /**
  * Lookup the linear value from the non-linear hashmap setup in {@link #initLevelsMap() initLevelsMap}.
  *
  * @param v is the non-level value to lookup the linear level .
  **/
  private int reverseLedLevel(int v)
  {
   if(v<0){v=0;}
   else if(v>255){v=255;}
   Integer ii = Integer.valueOf(v);
   if(debugging_) System.out.println("ii="+ii);
   Integer iii = reverseLevels_.get(ii);
   if(debugging_) System.out.println("iii="+iii);
   return (iii!=null?iii.intValue():-1);
  }


  /**
    * Sends to command to the receiver and then waits for the response(s). The responses often have nothing to do with the command sent
    * so this method can filter them to return only the responses related to the command sent.
    *
    * @param command must be one of the Command Class Constants from the eiscp.Eiscp.Command class.
    * @param closeSocket flag to close the connection when done or leave it open.
    * @param returnAll flags if all response packetMessages are returned, if no then ONLY the ones related to the command requested
    * @return the response to the command
    **/
  public String sendQueryOnOffCommand(boolean on,  boolean closeSocket)
  {
    String retVal = "";

    /* Send The Command and then... */
    sendOnOffCommand(on,false);
    //sleep(50); // docs say so

    /* now listen for the response. */
    Vector <String> rv = null;
    rv = readQueryResponses();
    String currResponse = "";
    for (int i=0; i < rv.size(); i++)
    {
      currResponse = (String) rv.elementAt(i);
      retVal+= currResponse+"\n";
    }

    if (closeSocket) closeSocket();

    return retVal ;
  }


  /**
   * This method reads responses (possibly more than one) after a command.
   * @return an array of the data portion of the response messages only - There might be more than one response message received.
   **/
  public Vector <String> readQueryResponses()
  {
    //boolean debugging = debugging_;
    boolean foundCommand = false;
    Vector <String> retVal = new Vector <String> ();
    byte [] responseBytes = new byte[32] ;
    String currResponse = "";
    int numBytesReceived = 0;
    int totBytesReceived = 0;
    int i=0;
    int packetCounter=0;
    int headerSizeDecimal = 0;
    int dataSizeDecimal = 0;
    char endChar1 ='!';// NR-5008 response sends 3 chars to terminate the packet - 0x1a 0x0d 0x0a
    char endChar2 ='!';
    char endChar3 ='!';

    if(connected_)
    {
      try
      {
        if (debugging_) System.out.println("\nReading Response Packet");
        lednetSocket_.setSoTimeout(socketTimeOut_); // this must be set or the following read will BLOCK / hang the method when the messages are done

        while(!foundCommand && ((numBytesReceived = in_.read(responseBytes))>0) )
        {
          totBytesReceived = 0;
          StringBuilder msgBuffer = new StringBuilder("");
          if (debugging_) System.out.println("\n*\n*\n*\n*Buffering bytes: "+numBytesReceived);
          if (debugging_) System.out.print( " Packet"+"["+packetCounter+"]:");

          /* Read ALL the incoming Bytes and buffer them */
          // *******************************************
          while(numBytesReceived>0 )
          {
            totBytesReceived+=numBytesReceived;
            msgBuffer.append(new String(responseBytes));
            responseBytes = new byte[32];
            numBytesReceived = 0;
            if (in_.available()>0)
              numBytesReceived = in_.read(responseBytes);
            if (debugging_) System.out.print(" "+numBytesReceived);
          }
          if (debugging_) System.out.println();
          convertStringToHex(msgBuffer.toString(), debugging_);

          /* Response is done... process it into dataMessages */
          // *******************************************
          char [] responseChars = msgBuffer.toString().toCharArray(); // use the charArray to step through
          msgBuffer = null;// clear for garbageCollection

          if (debugging_) System.out.println("responseChars.length="+responseChars.length);
          int responseByteCnt = 0;
          char [] headerSizeBytes = new char[4];
          char [] dataSizeBytes  = new char[4];
          char [] dataMessage = null ; //init dynamically
          int dataByteCnt = 0;
          String dataMsgStr = "";

          if(debugging_ && msgBuffer!=null) System.out.println("Message Received: "+msgBuffer.toString());
          // loop through all the chars and split out the dataMessages
          //while (!foundCommand && (responseByteCnt< totBytesReceived))
          //{
            // read Header
            // 1st 4 chars are the leadIn
           // responseByteCnt+=4;

            // read headerSize
            //headerSizeBytes[0]=responseChars[responseByteCnt++];
           // headerSizeBytes[1]=responseChars[responseByteCnt++];
           // headerSizeBytes[2]=responseChars[responseByteCnt++];
           // headerSizeBytes[3]=responseChars[responseByteCnt++];

            //packetCounter++;
          //}// done packet

        } // check for more data

      }
      catch( java.net.SocketTimeoutException  noMoreDataException)
      {
        if (debugging_) System.out.println("Response Done: " );
      }
      catch(EOFException  eofException)
      {
        System.out.println("received: \""+retVal+"\"" );
      }
      catch(IOException ioException)
      {
        ioException.printStackTrace();
      }
    }
    else
      System.out.println("!!Not Connected to Receive ");
    return retVal;
  }


  /**
   *  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 boolean sleep(long waitTime)
  {
    boolean retVal = true;
    /*
     *  BLOCK for the spec'd time
     */
    if(waitTime>0)
    try
    {
      Thread.sleep(waitTime);
    }
    catch (InterruptedException iex)
    {
      retVal = false;
    }
    return retVal;
  }


  /** gets the help as a String.
   * @return the helpMsg in String form
   **/
  private static String getHelpMsgStr() {return getHelpMsg().toString();}


  /** initializes and gets the helpMsg_
  class var.
   * @return the class var helpMsg_
   **/
  private static StringBuffer getHelpMsg()
  {
    helpMsg_ = new StringBuffer(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("---  WebARTS LedNetProxy Class  -----------------------------------------------------");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("---  $Revision: 1302 $ $Date: 2019-11-03 17:19:03 -0800 (Sun, 03 Nov 2019) $ ---");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("-------------------------------------------------------------------------------");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("WebARTS LedNetProxy Class");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("SYNTAX:");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("   java ");
    helpMsg_.append(CLASSNAME);
    helpMsg_.append(" [hostIP:port] command [commandArgs]");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("      - hostIP:port is optional and defaults to 10.0.0.247:5577");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("      - command is NOT optional");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("Available Commands:");
    /* now add all the commands available */
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"test");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"on");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"off");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"colour r g b w");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"r");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"g");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"b");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"w");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"cw");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"p");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"cyan");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"fade r g b w r2 g2 b2 w2");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"the from and to rgbw levels");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"fun [loopTime-ms [pausetime-ms]]");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"loopTime-ms  can be -1 to loop indefinitely");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"pausetime-ms  is the pause between the colour changes");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"christmasFun [loopTime-ms [pausetime-ms]]");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"loopTime-ms  can be -1 to loop indefinitely");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"pausetime-ms  is the pause between the colour changes");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"christmasFade [loopTime-ms [pausetime-ms]]");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"loopTime-ms  can be -1 to loop indefinitely");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"pausetime-ms  is the pause between the colour changes");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"slowBurn [loopTime-ms [pausetime-ms]]");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"loopTime-ms  can be -1 to loop indefinitely");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("         -->   "+"pausetime-ms  is the pause between the colour changes");
      helpMsg_.append(SYSTEM_LINE_SEPERATOR);
      helpMsg_.append("-->   "+"dumpLevels");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);
    helpMsg_.append("---------------------------------------------------------");
    helpMsg_.append("----------------------");
    helpMsg_.append(SYSTEM_LINE_SEPERATOR);

    return helpMsg_;
  }


  /**
   * Class main commandLine entry method.
   **/
  public static void main(String [] args)
  {
    final String methodName = CLASSNAME + ": main()";
    LedNetProxy instance = new LedNetProxy(DEFAULT_LEDNET_IP, DEFAULT_LEDNET_PORT);
    int commandArg = 0;

    // if there are more than 1 args, then the 1st is assumed to be a non-default port number
    if (args.length>1 && args[commandArg].contains(":"))
    {
      System.out.println("Overriding DEFAULT IP & port with: "+args[commandArg]);
      String [] ipPort = args[commandArg].split("\\:");
      instance.setReceiverIP(ipPort[0]);
      instance.setReceiverPort(Integer.parseInt(ipPort[1]));
      commandArg++;
    }

    /* Simple way af parsing the args */
    if (args ==null || args.length<1)
      System.out.println(getHelpMsgStr());
    else
    {
      /* *********************************************** */
      if (args[commandArg].equalsIgnoreCase("test"))
      {
        System.out.println("Testing LedNetProxy");
        String queryResponse =  instance.sendQueryOnOffCommand(true, false);
        System.out.println(queryResponse);
        System.out.println();

        int delay = 250;
        instance.sendColourCommand(128,0,0,0);
        instance.fadeBetweenCommand(255,0,0,0,  0,255,0,0, FadeSpeed.MEDIUM);
        instance.fadeBetweenCommand(0,255,0,0,  0,0,255,0, FadeSpeed.MEDIUM);

        instance.sendColourCommand(0,0,0,0);
        instance.sendColourCommand(180,180,180,0);
        instance.sendColourCommand(0,0,0,180);
        instance.sendColourCommand(0,0,0,0);
        instance.sendColourCommand(0,0,0,180);
        instance.sendColourCommand(0,0,0,0);
        instance.sendColourCommand(0,0,0,180);
        instance.sendColourCommand(0,0,0,0);
        instance.sendColourCommand(0,0,0,180);

        instance.fadeBetweenCommand(255,0,0,0,  0,255,0,0 , FadeSpeed.MEDIUM);

        instance.sendQueryOnOffCommand(false, true);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("test2"))
      {
        int toLevel = 255;
        instance.debugging_=true;
        instance.sendQueryOnOffCommand(true, false);
        // Test Fade
        instance.fadeBetweenCommand( toLevel,0,toLevel,0, (toLevel/20),0,(toLevel/20),0 ,  FadeSpeed.MOLASSES, true);
        instance.fadeBetweenCommand( (toLevel/20),0,(toLevel/20),0 , toLevel,0,toLevel,0,  FadeSpeed.MOLASSES, true);

        //Turn OFF
        instance.sendQueryOnOffCommand(false, true);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("testFade"))
      {
        int toLevel = 128;
        if(args.length>1) toLevel = Integer.parseInt(args[commandArg+1]);
        System.out.println("Testing LedNetProxy Fading to level:"+toLevel);
        // Turn On
        instance.sendColourCommand(0,0,0,0);
        String queryResponse =  instance.sendQueryOnOffCommand(true, false);

        // Test Fade
        instance.fadeBetweenCommand( toLevel,0,toLevel,0, (toLevel/20),0,(toLevel/20),0 ,  FadeSpeed.VERYSLOW);
        instance.fadeBetweenCommand( (toLevel/20),0,(toLevel/20),0 , toLevel,0,toLevel,0,  FadeSpeed.VERYSLOW);

        //Turn OFF
        instance.sendQueryOnOffCommand(false, true);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("testCustom"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendCustomCommand(255,0,0,0,0,0,255,0,60);
      }


      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("on"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        String queryResponse =  instance.sendQueryOnOffCommand(true, true);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("off"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        String queryResponse =  instance.sendQueryOnOffCommand(false, true);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("r"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(255,0,0,0);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("g"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(0,255,0,0);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("b"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(0,0,255,0);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("p"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(5,0,15,0);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("y"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(255,255,0,0);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("w"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(200,200,200,255);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("ww"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(0,0,0,255);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("cw"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(240,240,255,80);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("cyan"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(0,20,10,0);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("fade"))
      {
        if(args.length>8)
        {
          instance.sendQueryOnOffCommand(true, false);
          instance.fadeBetweenCommand(Integer.parseInt(args[commandArg+1]),
                                      Integer.parseInt(args[commandArg+2]),
                                      Integer.parseInt(args[commandArg+3]),
                                      Integer.parseInt(args[commandArg+4]),
                                      Integer.parseInt(args[commandArg+5]),
                                      Integer.parseInt(args[commandArg+6]),
                                      Integer.parseInt(args[commandArg+7]),
                                      Integer.parseInt(args[commandArg+8]),
                                      FadeSpeed.VERYSLOW,
                                      false);
        }
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("colour"))
      {
        //System.out.println("args.length="+args.length+"\ncommandArg="+commandArg);
        int r = (args.length>commandArg+1 ? Integer.parseInt(args[commandArg+1]):0);
        int g = (args.length>commandArg+2?Integer.parseInt(args[commandArg+2]):0);
        int b = (args.length>commandArg+3?Integer.parseInt(args[commandArg+3]):0);
        int w = (args.length>commandArg+4?Integer.parseInt(args[commandArg+4]):0);
        //instance.sendQueryOnOffCommand(true, true);
        instance.sendColourCommand(r,g,b,w);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("dumplevels"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.dumpLevels();
        instance.dumpReverseLevels();
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("dumpExpLevels"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.dumpExpLevels();
      }


      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("fun"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.fun((args.length>1?Integer.parseInt(args[commandArg+1]):-1),
                     (args.length>2?Integer.parseInt(args[commandArg+2]):200));  // loopTime, pause
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("christmasFun"))
      {
        //instance.sendQueryOnOffCommand(true, true);
        instance.christmasFun((args.length>1?Integer.parseInt(args[commandArg+1]):-1),
                              (args.length>2?Integer.parseInt(args[commandArg+2]):200));  // loopTime, pause
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("christmasFade"))
      {
        int loopTime = -1;
        long pause = 250;
        int toLevel = 64;
        if(args.length>1) toLevel = Integer.parseInt(args[commandArg+1]);
        instance.christmasFade(toLevel, loopTime, pause);

        //Turn OFF
        instance.sendQueryOnOffCommand(false, true);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("slowBurn"))
      {
        int loopTime = -1;
        long pause = 250;
        int toLevel = 10;
        if(args.length>1) toLevel = Integer.parseInt(args[commandArg+1]);
        instance.slowBurn(toLevel, loopTime, pause);

        //Turn OFF
        instance.sendQueryOnOffCommand(false, true);
      }
      /* *********************************************** */
      else if (args[commandArg].equalsIgnoreCase("nightFade"))
      {
        instance.sendQueryOnOffCommand(true, false);

        while(true)
        {
          instance.stepBetween(1,0,1,0,   8,0,16,0);
          instance.stepBetween(8,0,16,0,  1,0,1,0);
        }
      }
      instance.closeSocket();
    }
  } // main


  /** Prints out the non-linear levels from the class var Exponential formula. **/
  public void dumpExpLevels()
  {
    for (int i=0; i<256; i++)
      System.out.println("v="+i+"  "+expLedLevel(i));
  }


  /** Prints out the non-linear levels from the class var levels_. **/
  public void dumpLevels()
  {
    for (int i=0; i<256; i++)
      //System.out.println("v="+i+"  "+levels_.get(Integer.valueOf(i)).intValue());
      System.out.println("v="+i+"  "+ledLevel(i));
    //System.out.println("\nLevelCount="+levelCount);

  }


  /** Prints out the reverse non-linear lookup levels from the class var reverseLevels_. **/
  public void dumpReverseLevels()
  {
    System.out.println("\rreverseLevels_ size="+reverseLevels_.size());
    for (int i=0; i<256; i++)
      if (reverseLevels_.get(Integer.valueOf(i))!=null)
        System.out.println("v="+i+"  "+reverseLevels_.get(Integer.valueOf(i)).intValue());
    System.out.println("\nLevelCount="+levelCount);

  }


  /**
    * Initializes the class var 'levels_' HashMap of non-linear lookup values for the LED brightness levels.
    **/
  private void initLevelsMap()
  {
    int inc = 1;
    int currVal = 0;
    levelCount = 0;
    int [] levelMarks = {0,16,32,64,128,256};
    int currMark = 0;
    int maxVal = 255;

    levels_ = new HashMap<Integer, Integer>(256);

    for (int loop=0; loop<levelMarks.length-1; loop++)
    {
      currMark = levelMarks[loop];
      //System.out.println("\n   initLevelsMap currMark="+currMark);
      // count through all numbers 0-255 and assign its lookupLevel
      for (int i=currMark; i<levelMarks[loop+1]; i++)
      {
        levels_.put(Integer.valueOf(i), Integer.valueOf(currVal));
        //System.out.println("       i="+i+"  mapped to "+currVal);
        currVal+=inc;
        if(currVal>maxVal) currVal=maxVal;
      }
      inc*=2;  // double the incrementer after every levelMark
      /*for (int i=currMark; i<levelMarks[loop+1]; i+=inc)
      {
        for(int j=0; j<inc; j++)  {levels_.put(Integer.valueOf(i+j), Integer.valueOf(currVal));}
        currVal+=inc; levelCount++;
      }
      currVal+=inc; inc*=2;  // double the incrementer after every levelMark*/
    }

    // manually set the levels
    /*
    for (int i=0; i<8; i++)
    {
      levels_.put(Integer.valueOf(i), Integer.valueOf(currVal));
      currVal+=inc;
      levelCount++;
    }

    currVal+=inc;
    inc=2;
    for (int i=8; i<16; i+=inc)
    {
      for(int j=0; j<inc; j++)  {levels_.put(Integer.valueOf(i+j), Integer.valueOf(currVal));}
      currVal+=inc; levelCount++;
    }

    currVal+=inc;
    inc=4;
    for (int i=16; i<32; i+=inc)
    {
      for(int j=0; j<inc; j++)  {levels_.put(Integer.valueOf(i+j), Integer.valueOf(currVal));}
      currVal+=inc; levelCount++;
    }

    currVal+=inc;
    inc=8;
    for (int i=32; i<64; i+=inc)
    {
      for(int j=0; j<inc; j++)  {levels_.put(Integer.valueOf(i+j), Integer.valueOf(currVal));}
      currVal+=inc; levelCount++;
    }

    currVal+=inc;
    inc=16;
    for (int i=64; i<128; i+=inc)
    {
      for(int j=0; j<inc; j++)  {levels_.put(Integer.valueOf(i+j), Integer.valueOf(currVal));}
      currVal+=inc; levelCount++;
    }

    currVal+=inc;
    inc=32;
    for (int i=128; i<256; i+=inc)
    {
      for(int j=0; j<inc; j++)  {levels_.put(Integer.valueOf(i+j), Integer.valueOf(currVal));}
      currVal+=inc; levelCount++;
    }
    */


    //System.out.println("Creating  reverseLevels_  levelsCount="+levelCount);
    reverseLevels_ = new HashMap<Integer, Integer>(levelCount);
    for (int i=levelMarks[0]; i<levelMarks[levelMarks.length-1]; i++)
    {
      for(int j=levelMarks[0];j<levelMarks[levelMarks.length-1];j++)
      {
        if(levels_.get(Integer.valueOf(j))!=null)
        {
          //System.out.println(" Checking "+i+" for level "+levels_.get(Integer.valueOf(j)));
          if(levels_.get(Integer.valueOf(j)).intValue()==i)
          {
            //System.out.println("       ..... adding "+Integer.valueOf(j) + "  "+ Integer.valueOf(i));
            reverseLevels_.put(Integer.valueOf(j), Integer.valueOf(i));
            j=levelMarks[levelMarks.length-1];
          }
        }
      }
    }
    //System.out.println("reverseLevels_  size="+reverseLevels_.size());

  }

} // class