/* *************************************************************************
 * Program ID : TelnetServer_7SEGLED.pde
 * Created by CH, Chen (2011.9.11/Taiwan)
 * 1. Command string sending from telnet client
 *    Leading code(@) + Command code(L/T/N) + Data string + Ending code(%)
 * 2. Command code and Data string : 
 *    Display RGB(L)     : max 8 bytes of tri-color LED display indicator(R/G/B)
 *    Display Text(T)    : max 8 bytes of alpha-numeric characters (A-Z, 0-9, blank, -)
 *    Display Integer(N) : max 8 bytes of numeric characters and negative sign(0-9, -) 
 * ************************************************************************* */
#include <SPI.h>
#include <Ethernet.h>
#include <Wire.h>

#define SEVEN_SEG_LED              0x38
#define THERMOMETER                0x49

#define NUM_OF_DIGITS              4
#define MAX_DATA_LENGTH            8
#define MIN_COMMAND_LENGTH         4
#define END_OF_READ               -1

const char COMMAND_LEADING_CODE    = '@';
const char COMMAND_ENDING_CODE     = '%';

const char COMMAND_DISPLAY_RGB     = 'L';
const char COMMAND_DISPLAY_TEXT    = 'T';
const char COMMAND_DISPLAY_INTEGER = 'N';

const char ledType[] = {'R', 'G', 'B'};
const byte ledPin[]  = {3, 5, 6};

// Seven segment display pattern: 
// Numberals                   0,    1,    2,    3,    4,    5,    6,    7,    8,    9,    blank,-
const byte NumPattern[12]   = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D ,0x07, 0x7F, 0x6F, 0x00, 0x40};
// Alphabet                    A,    b,    C,    d     E     F     G     H     I     J     K     L     M
//                             n     O     P     q     r     s     T     U     v     W     X     y     Z
const byte AlphaPattern[26] = {0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71, 0x3D, 0x76, 0x06, 0x1E, 0x7A, 0x38, 0x15,
                               0x54, 0x3F, 0x73, 0x67, 0x31, 0x6D, 0x07, 0x3E, 0x1C, 0x2A, 0x49, 0x6E, 0x52};
const byte BlankPattern     =  0x00;
const byte DotPattern       =  0x80;

char receiveString[MAX_DATA_LENGTH+1];
boolean isDisplayRGB=false, isDisplayText=false, isDisplayInteger=false;
int numOfDataBytes=0;

// Ethernet Class initialization setting
byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x32, 0x39};
byte ip[]  = {192, 168, 11, 110};

Server server(23);

void setup()
{
  for (int cnt=0; cnt<3; cnt++) pinMode(ledPin[cnt], OUTPUT);
  digitalWrite(ledPin[0], HIGH);  //Red ON
  
  I2C_Init();
  
  Ethernet.begin(mac, ip);
  server.begin();  
  delay(1000);
  
  digitalWrite(ledPin[0], LOW);  //Red OFF
  digitalWrite(ledPin[1], HIGH); //Green ON
}

void loop()
{
  Client client = server.available();
  if (client) {
     int nbytesReady = client.available(); 
     if (nbytesReady >= MIN_COMMAND_LENGTH) {
        char c = client.read();
        if (c == COMMAND_LEADING_CODE) {
           c = client.read();
           if (c == COMMAND_DISPLAY_RGB)          isDisplayRGB     = true;
           else if (c == COMMAND_DISPLAY_TEXT)    isDisplayText    = true;
           else if (c == COMMAND_DISPLAY_INTEGER) isDisplayInteger = true;
           
           if (isDisplayRGB || isDisplayText || isDisplayInteger) {
              numOfDataBytes = 0;
              while (numOfDataBytes < MAX_DATA_LENGTH) {
                    c = client.read();
                    if ((c == COMMAND_ENDING_CODE) || (c == END_OF_READ)) break;
                    receiveString[numOfDataBytes] = c;
                    numOfDataBytes++;                  
             }
             receiveString[numOfDataBytes] = 0;
             
             if (numOfDataBytes > 0) {
                if (isDisplayRGB) {
                   for (int xcnt=0; xcnt<numOfDataBytes; xcnt++) 
                       displayRGB(receiveString[xcnt]);
                   isDisplayRGB = false;
                } 
                else if (isDisplayText) {
                        displayString(receiveString);
                        isDisplayText = false;
                     } 
                else if (isDisplayInteger) {
                       displayInteger(atoi(receiveString));
                       isDisplayInteger = false;
                     }
             } // if (numOfDataBytes > 0) - Must have available data for executing request function
          } // if (isDisplayRGB || isDisplayText || isDisplayInteger) - Command code must be one of the L/T/N
        } // if (c == COMMAND_LEADING_CODE) -  Leading character must be @
     }  // if (nbytesReady >= MIN_COMMAND_LENGTH) - Available reading data must > min number of required bytes
     client.flush();
     delay(1);
  } // if (client) - Get a client connected
}
/* *****************************************************************
 * Subroutines
 * ***************************************************************** */
void displayRGB(char _ledType)
{
  for (int cnt=0; cnt<3; cnt++) {
      if (ledType[cnt] == _ledType) digitalWrite(ledPin[cnt], HIGH);
      else                          digitalWrite(ledPin[cnt], LOW);
  }
  delay(1000);
}

void I2C_Init()
{    
  // Join I2C bus as Master
  Wire.begin();  
  // Initialize SAA1064 7-Segment LED driver (0x38)
  Wire.beginTransmission(SEVEN_SEG_LED);
  Wire.send(B00000000);    // Instruction byte, the next byte is the control byte
  Wire.send(B01000111);    // Control byte, dynamic mode on, digits 1+3 on, digits 2+4 on, 12mA segment current
  Wire.endTransmission();
  
  // Initialize digital Thermometer (0x49)
  Wire.beginTransmission(THERMOMETER);    
  Wire.send(1);           // Set TMP75 pointer register to configuration register
  Wire.send(B01100000);   // Set TMP75 12 bits resolution(R1,R0)=(1,1), b6,b5 of configuration register
  Wire.endTransmission();
  
  Wire.beginTransmission(THERMOMETER);    
  Wire.send(0);           // Set TMP75 pointer register to temperature register
  Wire.endTransmission(); 
}

void clearDisplay()
{
  Wire.beginTransmission(SEVEN_SEG_LED);
  Wire.send(1); // Write sub-address, point to register of the 1st digit(Right Hand Side)
  Wire.send(BlankPattern); // blank digit 1
  Wire.send(BlankPattern); // blank digit 2
  Wire.send(BlankPattern); // blank digit 3
  Wire.send(BlankPattern); // blank digit 4
  Wire.endTransmission();
}

// Display at most 4 digits number on LED
// Enable display negative sign
void displayInteger(int intNumber)
{
  int digitSign, digit, digitTen, digitHundred, digitThousand;
  clearDisplay();
 
  digitSign = (intNumber<0 ? 11: 10);
  digitThousand = abs(intNumber)/1000;
  digitHundred  = (abs(intNumber) - digitThousand*1000) / 100;
  digitTen      = (abs(intNumber) - digitThousand*1000 - digitHundred*100) / 10;
  digit         = abs(intNumber) - digitThousand*1000 - digitHundred*100 - digitTen*10;
  if (digitThousand == 0) {
      digitThousand = 10;
      if (digitHundred == 0) {
          digitHundred = 10;
          if (digitTen == 0)  
              digitTen = 10;      
      }
  }
  // Set sign symbol
  if (intNumber < 0) {
      if (digit != 10) {
          if (digitTen != 10) {
              if (digitHundred != 10) 
                  digitThousand = 11;
              else
                  digitHundred  = 11;
          }
          else 
              digitTen = 11;
      }
  }
  Wire.beginTransmission(SEVEN_SEG_LED);
  Wire.send(0x01);  // Write sub-address, point to register of the 1st digit(Right Hand Side)
  Wire.send(NumPattern[digit]);
  Wire.send(NumPattern[digitTen]);
  Wire.send(NumPattern[digitHundred]);
  Wire.send(NumPattern[digitThousand]);  
  Wire.endTransmission();
  delay(1000);   
}

// Display character array/string on LED 
// This function will convert ascii value to pattern then use displayFlyFromRightSide() function
// to display.
void displayString(char displayStr[])
{
  byte displayPattern [strlen(displayStr)];
  int numOfBytes = 0;
  for (int xii=0; xii<strlen(displayStr); xii++)
  { 
    if (displayStr[xii] >= 'A' && displayStr[xii] <= 'Z') {
        displayPattern[numOfBytes] = AlphaPattern[displayStr[xii] - 'A'];
        numOfBytes++;
    }
    else if (displayStr[xii] >= 'a' && displayStr[xii] <= 'z') {            
             displayPattern[numOfBytes] = AlphaPattern[displayStr[xii] - 'a'];
             numOfBytes++;
         }
         else if (displayStr[xii] >= '0' && displayStr[xii] <= '9') {            
                  displayPattern[numOfBytes] = NumPattern[displayStr[xii] - '0'];
                  numOfBytes++;
              }
              else if (displayStr[xii] == ' ') {
                       displayPattern[numOfBytes] = NumPattern[10];
                       numOfBytes++;
                   }
                   else if (displayStr[xii] == '-') {
                            displayPattern[numOfBytes] = NumPattern[11];
                            numOfBytes++;
                        }
                        else if (displayStr[xii] == '.') {
                                 displayPattern[numOfBytes] = DotPattern;
                                 numOfBytes++;
                             }
  }
  if (numOfBytes > 0) displayFlyFromRightSide(displayPattern, numOfBytes);
}

// Display pattern array with fly-in effect
void displayFlyFromRightSide(const byte displayArray[], int numberOfBytes)
{
  int xindex = 0;
  clearDisplay();
  while (xindex < numberOfBytes+NUM_OF_DIGITS)
  {
    Wire.beginTransmission(SEVEN_SEG_LED);
    Wire.send(0x01);  // Write sub-address, point to register of the 1st digit(Right Hand Side)
    for (int xdigit=0, xdisplayIdx=xindex; xdigit<NUM_OF_DIGITS && xdisplayIdx>=0; xdigit++, xdisplayIdx--)
    {    
      if (xdisplayIdx < numberOfBytes) Wire.send(displayArray[xdisplayIdx]);                  
      else                             Wire.send(BlankPattern);         
    }
    Wire.endTransmission();
    delay(600);
    xindex++;
  }  
}