/*****************************************************************************************
**
**  EASi Line Assembly Technology Expo 2006 Readerboard Give-away C Source Code
**  Written by David Beecher & Keith Nelson
**  Copyright 2006 CPU Ready Consulting Inc.
**
**  For schematics, instructions and full source, visit:
**  http://www.cpureadyconsulting.com/
**
**  Written for the Atmel ATTiny2313
**
**  License Agreement
**  You are free to copy and use our source code in your non-commercial project as long as 
**  you include this comment block at the top of any source file which contains our code.
**  Commercial use is prohibited without prior authorization from CPU Ready Consulting Inc.
**
******************************************************************************************/


#define ENABLE_BIT_DEFINITIONS 1

#include <iotiny2313.h>
#include <intrinsics.h>
#include "font.h"


#define COL_CLK  (1 << 4)          // Column shifter bit positions
#define COL_DAT  (1 << 5)
#define COL_LOAD (1 << 2)
#define COL_RST  (1 << 3)

#define NUM_ROWS 7                 // Number of LED rows on the readerboard
#define NUM_COLS 12                // Number of LED columns on the readerboard

#define FONT_ROWS 7                // Number of rows in our font
#define FONT_COLS 5                // Number of columns per character in the font
#define SPACE_WIDTH 1              // Width of space, in LED columns, after character
#define MAX_MESSAGE_LENGTH 127     // Maximum message length

#define byte unsigned char         // Byte definition
#define word unsigned int          // Word definition
#define fbyte unsigned char __flash        // Flash stored Byte definition
#define TRUE 1                             
#define FALSE 0


// Message first displayed when the board is initially programmed

__flash static byte firstMessage[] = "Welcome to EASi Line ATExpo 2006\0";  

// Globals Display0 and Display1 are two arrays which represent, bitwise, the rows and columns
// of the readerboard display.   1 is LED on and 0 is LED off.  The first two bytes represent
// the first row of the display, where the bits past 12 columns are ignored.   The next two bytes
// represent the second row and so on.
// We use two displays because we essentially buffer the drawing of the display.  While we are 
// drawing the next shift of the message one display, we are displaying the last drawing.
// This ensures a smooth, clean looking shift.

__no_init static byte display0[14];
__no_init static byte display1[14];

// This global variable holds the length of the current message
__no_init static byte messageLength;   

// This global variable holds the current column data that will be bit banged to the column shifters
__no_init static word colbang;         

// This global variable holds the speed value.  
__no_init static byte speed;

// This global variable counts down the number of characters to display in our message
__no_init static word shutdown;

// These global pointers are set to either display0 or display1 depending on whether we are 
// currently displaying or drawing to the global displays.
__no_init static byte *display;
__no_init static byte *drawdisplay;

// This global variable tells us which display we currently are working with
__no_init static byte curDisplay;



/*********************************
**
** PROCEDURE SetPortD
**
** Purpose:
** 
** This procedure bit bangs the passed in word to PORTD of the Tiny2313
** and then clocks the column shifters.
**
** Parameters:
** 
** WORD w - The 16 bit value that you want to bit bang to PORTD
**
**********************************/

void SetPortD(word w)
{
  byte i;
  word temp;

  for(i=0; i<12; i++)
  {
    temp = w >> i & 1;
    // temp now holds the i-th bit, either a 0 or 1 which we want to bang out to the COL_DAT line
    if(temp == 1)
      PORTD = PORTD | COL_DAT;
    else
      PORTD = PORTD & ~COL_DAT;

    // bits have been sent through the col_dat pin now
    // we need to set the clock pin and clear it
    PORTD = PORTD | COL_CLK;
    PORTD = PORTD & ~COL_CLK;
  }

}

/*********************************
**
** PROCEDURE LoadData
**
** Purpose:
**
** This procedure clears and sets the Load pin
**
**
** Parameters:
**
** None
**
**********************************/

void LoadData()
{
  PORTD = PORTD & ~COL_LOAD;
  PORTD = PORTD | COL_LOAD;
}


/*********************************
**
** PROCEDURE SetRow
**
** Purpose:
**
** This procedure sets the current row of the LED matrix
**
** Parameters:
**
** Byte row - The value of the row that you would like to select in the LED matrix
**
**********************************/

void SetRow(byte row)
{
  byte rtemp = 0;
  rtemp = (1 << row);
  PORTB = rtemp;
}

/*********************************
**
** PROCEDURE SetColBit
**
** Purpose:
**
** This procedure adds a particular bit to the global variable colbang, which
** essentially turns on a particular column
**
** Parameters:
**
** Byte col - This is the column that you would like to turn on
**
**
**********************************/

void SetColBit(byte col)
{
  colbang = colbang | (1 << col);
}


/*********************************
**
** Procedure SetColumn
**
** Purpose:
**
** This procedure sends the global colbang variable to enable all of the columns
** that have been turned on by SetColBit.  Once it is complete, colbang is reset to
** zero, which means all columns are turned off.
**
** Parameters:
**
** None
**
**********************************/

void SetColumn()
{
  SetPortD(colbang);
  colbang = 0;
}


/*********************************
**
** PROCEDURE DisplaySwap
**
** Purpose:
**
** Swaps between display0 and display1 as the draw and display memory.  
** For simplicity sake and to help keep track, we do have the curDisplay 
** rather than just an extra temp pointer for the swap.
** Cutting this global variable out would save some compile-time memory
**
** Parameters:
** 
** None
**
**********************************/

void DisplaySwap()
{
  if(curDisplay == 0)
  {
    drawdisplay = display1;
    display = display0;
    curDisplay = 1;
  }
  else
  {
    drawdisplay = display0;
    display = display1;
    curDisplay = 0;
  }
}


/*********************************
**
** PROCEDURE Clear
**
** Purpose:
**
** This clears the drawing memory to enable us to draw the new characters
**
** Parameters:
**
** None
**
**********************************/

void Clear()
{
  char i;
  for(i=0;i<14;i++)
    drawdisplay[i] = 0;
}

/*********************************
**
** PROCEDURE Raster
**
** Purpose:
**
** This function reads the display ram and turns on the appropriate column bits, 
** bangs the the column with SetColumn and sets the row.  Essentially this takes
** what is in the current display ram and actually draws it to the "screen"
**
** Parameters:
**
** None
**
**********************************/

void Raster()
{
  byte i;               // Rows index
  byte j;               // Columns index
  byte first;           // First byte of the display data, representing cols 0-7
  byte second;          // Second byte of display data, representing cols 8-NUM_COLS

  __watchdog_reset();

  SetRow(NUM_ROWS-1);  // this will ensure the last row gets equivalent display time.
                       // Removing this will give extra display time and create a shadow effect on last row.

  for(i=0;i<NUM_ROWS;i++)
  {
    first = display[i*2];
    second = display[i*2+1];
    for(j=0;j<8;j++)
    {
      if(first & (1 << j))
        SetColBit(j);
    }

    for(j=8;j<NUM_COLS;j++)
    {
      if(second & (1 << (j-8)))
        SetColBit(j);
    }

    SetColBit(NUM_COLS);
    SetColumn();
    SetRow(255);
    LoadData();
    SetRow(i);
  }
  SetRow(255);  // this will ensure the last row gets equivalent display time.
                // Removing this will give extra display time and create a shadow effect on last row.
}


/*********************************
**
** PROCEDURE Rc
**
** Purpose:
**
** This function turns on a particular row,column coordinates in the off-screen display ram.
**
** Parameters:
**
** Byte row - The given row that you want to enable
** Byte col - The given column that you want to enable
**
**********************************/

void Rc(byte row, byte col)
{
  byte b;   // Temp byte

  if(col >= NUM_COLS || row >= NUM_ROWS)
    return;

  if(col < 8)
  {
     b = drawdisplay[row*2];
     b = b | (1 << col);
     drawdisplay[row*2] = b;
  }
  else if(col < NUM_COLS)
  {
     b = drawdisplay[row*2+1];
     b = b | (1 << (col-8));
     drawdisplay[row*2+1] = b;
  }
}


/*********************************
**
** PROCEDURE Letter
**
** Purpose:
**
** This draws a particular letter to the drawing ram via the Rc() function.  While it 
** draws the letter it also calls Raster() to update the screen with the current display ram
** as this is a fairly cpu intensive function.
**
** Parameters:
**
** Byte c - The ASCII value of the character ram that is wished to display.
** Byte displayCol - The first column of the font character to start the display
**
**
**********************************/

void Letter(byte c, byte displayCol)
{
  fbyte *ptr = 0;                      // Pointer into flash for reading the font 
  byte index, row, col, curbit, temp;  

  // Calculate the location of the character.  First subtract the 32 from the ASCII value
  index = c-32;

  // Next, setup ptr to point to the flash memory location of the font array
  ptr = (fbyte *)font;

  // Finally, calculate the actual memory location of the character
  ptr = ptr + (index * 5);
  curbit = 1;

  for(col=0;col<FONT_COLS;col++)
  {
    if(col%speed==0) Raster();   // Raster occasionally  depending on speed

    for(row=0;row<FONT_ROWS;row++)
    {
      // temp will hold the current byte (of 5 bytes per character) that we are looking at.
      temp = *(ptr+(curbit/8));

      // we want to check one particular bit
      if((1 << curbit % 8) & temp)
        Rc(FONT_ROWS-row-1,displayCol-col);  // FONT_ROWS-row-1 because font is inverted

      curbit++;

      // least significant bit of the font is worthless, so we skip it
      if(curbit % 8 == 0)
        curbit++;
    }
  }
}

/*********************************
**
** FUNCTION ReadEE
**
** Purpose:
**
** Reads a byte value from EEprom
**
** Parameters:
**
** Byte index - The index of the EEProm value to read
**
** Return Value:
**
** Returns a byte which is the value read from the EEProm
**
**********************************/

byte ReadEE(byte index)
{
  while(EECR & (1 << EEPE));
  EEAR = index;
  EECR |= (1<<EERE);
  return EEDR;
}

/*********************************
**
** PROCEDURE StoreEE
**
** Purpose:
**
** Writes the given byte to a particular index in the EEprom
**
** Parameters:
**
** Byte b - The value to store in EE
** Byte index - The index to store b in EE
**
**********************************/

void StoreEE(byte b, byte index)
{
  while(EECR & (1<<EEPE));
  EEAR = index;
  EEDR = b;
  EECR |= (1<<EEMPE);
  EECR |= (1<<EEPE);
}

/*********************************
**
** PROCEDURE ProgressBar
**
** Purpose:
**
** This function draws the progress bar border, calculates the progress
** depending on the given length, and draws the progress
**
** Parameters:
** 
** Byte length - This value represents the number of the current character written to EE
**
**********************************/

void ProgressBar(byte length)
{
  byte i;

  // Draw Border
  for(i=0;i<6;i++)
  {
    Rc(2,i);
    Rc(4,i);
  }
  Rc(3,0);
  Rc(3,5);

  // calculate progress & display.  32 would be the adjustment value
  // depending on number of characters in EEProm

  i = (length+1)/32;
  while(i)
  {
    Rc(3,5-i);
    i--;
    __watchdog_reset();
  }
}


/*********************************
**
** PROCEDURE RxDisplay
**
** Purpose:
** 
** This draws the current letter read in from the USART and displays it allong with the
** progress bar
**
** Parameters:
**
** Byte b - Read character
** Byte i - Current index
**
**********************************/

// This displays the current text from RS232 programming
void RxDisplay(byte b, byte i)
{
  if(b == '\r')
    return;

  byte j;

  Clear();
  Letter(b,11);
  ProgressBar(i);
  for(j=0;j<16;j++)
    Raster();
}

/*********************************
**
** FUNCTION RxInterrupt
**
** Purpose:
** 
** Not really an interrupt, but called periodically to check to see if any characters are waiting
** in the USART buffer.  If so, it controls the sequence of steps to reprogramming the message
** and scroll speed of this device.
**
** Parameters:
**
** None
**
** Return Value:
**
** If the value of the read character from the USART is an M, it will return a 1 when finished
** processing all the message generation routine.   If it is not an M it will return a 0, indicating
** that Message setup cannot proceed.   This is to save the unit from accidently receiving garbage
** characters to the USART which would overwrite EE.
**
**********************************/

byte RxInterrupt(void)
{
  byte b;              // Current byte read from USART
  byte i;              // Index value, current character
  byte *saveDisplay;   // Save the current display/drawdisplay state
  b = UDR;             // Read the character from the USART buffer
  i = 0;               // Index value at 0

  // return with 0 if we are not setting the message
  if(b != 'M')
    return 0;

  // Write directly to display, but save the current display first.
  saveDisplay = display;
  display = drawdisplay;

  // Show nothing with an empty progress bar
  RxDisplay(' ',i);

  // Display characters as they come in with the progress bar updated
  while(b != '\r' && i < MAX_MESSAGE_LENGTH-1)
  {
    while(!(UCSRA & (1<<RXC)))
      Raster();
    b = UDR;
    StoreEE(b,i);
    RxDisplay(b,i);
    i++;
  }

  // Set message length
  messageLength = i-1;

  // Store message
  if(i<MAX_MESSAGE_LENGTH-1)
  {
    b = '\0';
    StoreEE(b,i-1);
  }
  else
  {
    StoreEE(b,i-1);
    messageLength++;
  }

  // Reset shutdown sequence
  shutdown = (messageLength * 5) + 1; // Set number of characters to display

  // Notify the user that it is full or we are done.
  Clear();
  Letter('D',11);
  ProgressBar(128);
  for(i=0;i<100;i++)
  {
    b = UDR;
    Raster();
  }

  Clear();

  // read the speed
  Letter('S',11);
  Letter('?',5);
  while(!(UCSRA & (1<<RXC)))
      Raster();
  b = UDR;
  speed = b - 16 - 32;
  StoreEE(speed,MAX_MESSAGE_LENGTH);
  if(speed == 0) speed = 1;
  if(speed > 9) speed = 9;
  Clear();
  Letter('S',11);
  Letter(b,5);
  for(i=0;i<100;i++)
  {
    b = UDR;
    Raster();
  }

  // Return display
  display = saveDisplay;
  return 1;

}

/*********************************
**
** PROCEDURE WriteFirstMessage
**
** Purpose:
**
** This function will write the global firstMessage variable to EE Prom.  Called when the
** unit is first powered up after programming.
**
** Parameters:
**
** None
**
**********************************/

void WriteFirstMessage()
{
  int i;
  byte b;
  i = 0;
  b = firstMessage[0];  // Set our temp variable to first char

  // Until we've hit the null char, keep reading and storing
  while(b != '\0')
  {
    StoreEE(b,i);
    i++;
    b = firstMessage[i];
  }
  if(i < MAX_MESSAGE_LENGTH)
    StoreEE('\0',i);

}

/*********************************
**
** PROCEDURE LightAllLEDS 
**
** Purpose:
**
** This turns all the LED's on for a short period of time (around 4 seconds)
** just after the unit is programmed, so that we can see all LED's were installed
** on the board correctly.
**
** Parameters:
**
** None
**
**********************************/

void LightAllLEDS()
{
  char i;
  for(i=0;i<14;i++)
    display[i] = 0xFF;

  for(i=0;i<255;i++)
    Raster();
}




/*********************************
**
** FUNCTION main
**
** Purpose:
**
** Main controls the entire process, including setup of the timers, USART, shifters, first messages,
** etc.  Once running, it will display the message for a given period of time, shifting the
** message across the screen and then finally going into shutdown mode.
**
** Parameters:
**
** None
**
** Return Value:
**
** N/A
**
**
**********************************/

int main( void )
{

  word i;     // Number of column shifts
  word col;   // Used to calculate the current column to draw
  byte b;     // Temporary variable

  // Setup timeout feature
  PORTD = PORTD & ~(1 << 6);  // Turn on transistor in circuit

  // Set Clock  Uses internal clock, 1mhz
  TIMSK = TIMSK | (1 << 2);
  TCCR0B = 1;   // Set the timer divide by to full
  // full speed is 1
  // 1/8 speed is 2
  // 1/64 is 3
  // 1/256 is 4
  // 1/1024 is 5

  // turn off interruptes
  __disable_interrupt();

  // setup the watchdog timer
  __watchdog_reset();
  WDTCR &= ~((1<<WDIE) & (1<<WDP3));
  WDTCR |= (1<<WDE);
  WDTCR |= (1<<WDP2) | (1<<WDP1) | (1<<WDP0);   // We are setting the watchdog to two seconds

  // Set Port Directions
  DDRB = 0xFF;   // set b & d ports to be output ports
  DDRD = 0xFE;   // 11111110   (PD0 is RX pin, so the direction is in)

  // clear screen
  PORTD &= ~((1<<3) | (1<<2));    // Clear Reset & Load Bit
  PORTD |= (1<<3) | (1<<2);       // Set Reset & Load Bit

  // Set Shifters
  PORTD = PORTD & ~COL_CLK;
  PORTD = PORTD | COL_RST;

  // Setup display rams
  display = display1;
  drawdisplay = display0;
  curDisplay = 0;
  colbang = 0;


  // Setup USART
  UBRRL = 12;                       // Set Baud to 4800
  UCSRB = UCSRB |  (1 << RXEN);     // Enable USART Receive
  UCSRB = UCSRB & ~(1 << UCSZ2);    // Character size 8 bits
  UCSRC = UCSRC |  (1 << UCSZ0);
  UCSRC = UCSRC |  (1 << UCSZ1);
  UCSRC = UCSRC & ~(1 << UMSEL);    // Asynchronous
  UCSRC = UCSRC & ~(1 << UPM1);     // No parity
  UCSRC = UCSRC & ~(1 << USBS);     // 1 Stop Bit




  // Read Speed
  speed = ReadEE(MAX_MESSAGE_LENGTH);
  if(speed == 0) speed = 1;
  if(speed == 0xFF)
  {
     // If the speed hasn't been set before (0xff case), set it
     speed = 4;
     StoreEE(speed,MAX_MESSAGE_LENGTH);
     WriteFirstMessage();
     LightAllLEDS();
  }

  // i represents the number of column shifts that have taken place.  Starts at 0.  Also
  // used as a temp variable here (reset to 0 again later)
  i=0;

  // Clear the screen again just to be sure
  Clear();
  DisplaySwap();
  Raster();
  DisplaySwap();

  // Set Message Length
  messageLength = 0;
  b = ReadEE(i);
  while(b != '\0')
  {
    i++;
    messageLength = i;
    if(i < MAX_MESSAGE_LENGTH)
      b = ReadEE(i);
    else
    {
      b = '\0';
      messageLength--;
    }
  }

  // here's the reset we talked about earlier
  i = 0;

  byte curLetter = 0;      // represents the current letter of the message that we're looking at
  byte offset;      // an offset value to help in drawing letters past the current letter we look at
  byte drawing = 1;   // drawing is a boolean whether or not we are currently drawing anything

  shutdown = (messageLength * 5) + 1; // Set number of characters to display 
                                      // (display the message just beyond 5 times)

  // Run main loop
  while(shutdown > 0)
  {

   offset=0;
   drawing = 1;

   // Keep drawing characters until we're done or until we're at the end of the message

   while(drawing && curLetter < messageLength)
   {

     // Figure out the column of the current letter we are on
     col = i-(curLetter*(FONT_COLS+SPACE_WIDTH));

     // If it is still in scope, we draw it and the next 3 letters
     if(col < NUM_COLS+FONT_COLS+1)
     {
       DisplaySwap();

       // Must clear the display buffer before we can start re-writing to it
       Clear();

       byte count = 2;

       
       // Draw the current letter on the screen space since it is still in view
       Letter(ReadEE(curLetter+offset),col);

       // This loop will draw the next three letters and stops if
       // it reaches the end of the message
       while(count)
       {
         offset++; 
         
         if(curLetter+offset >= messageLength)
         {
           // If we're past the end of the message, fake some clock cycles
           // to slow down the message scroll.  Taking this out speeds up the
           // last couple of characters 

           for(byte k=0;k<FONT_COLS*3;k++)
             if(k%speed==0) Raster();
           drawing = 0;
           count=0;
         }
         else
         {
           // draw characters 2 and 3 on the screen space

           col = col - FONT_COLS - SPACE_WIDTH;
           Letter(ReadEE(curLetter+offset),col);
           count--;
         }
       }
       drawing = 0;  // We're done drawing so we can stop
     }

     // if it is out of scope, we go to the next letter
     else
     {
       Raster();
       curLetter++;
       shutdown--;     // we've fully drawn one character across the display so we can
                       // decrement shutdown

       // if we're at the last letter, we're done drawing the message one time
       if(curLetter == messageLength)
         drawing = 0;
     }
   }


   // Multiple Rasters() slows the text down further, not used in our source
   //for(k=0;k<speed*16;k++) if not using divide by 8
   //for(k=0;k<speed*2;k++)


   // Scroll to the next column
   i++;

   // Restart the message a little while after it is done
   if(i > (messageLength * (FONT_COLS+1)) + (3 * FONT_COLS))
   {
     i = 0;
     curLetter = 0;
   }

   // If a character is waiting in the UART, we begin to start a new message
   if(UCSRA & (1<<RXC))
   {
     if(RxInterrupt())
     {
       i = 0;                // We reset everything and shutdown was reset inside RxInterrupt
       curLetter = 0;
     }
   }

  }  // end main while loop


  // Now we've show the message a few times, so we begin powering down the device

  // Disable the power
  PORTD = PORTD | (1 << 6);  // Turn off transistor in circuit to shutdown
  DDRB = 0;

  while(1)
  {
    PORTD = PORTD | (1 << 6);  // Turn off transistor in circuit to shutdown
    // Clock Cycle to load nothing
    PORTD &= ~((1<<3) | (1<<2));   // Clear Reset & Load Bit
    PORTD |= (1<<3) | (1<<2);       // Set Reset & Load Bit
    //__watchdog_reset();       
  }

}