Y:/FINAL CODE/Main.c

Go to the documentation of this file.

/******************************************************************************                      
 *
 *       Copyright (C) 2006 J Team, Inc.
 *       All Rights Reserved
 *
 * File Name      : Main.c
 * Project Name   : RFIDXpress.mcp
 * Description    : This file contains main() and most functionality of the RFID
 *                  Xpress system.  The main() function begins by initializing 
 *                  the Ethernet.  The infinite while loop consists of a state 
 *                  machine that governs the flow of control.  It also polls
 *                  the Ethernet module to determine if a packet was received.  
 *                  The RFIDInterrupt() function handles an SCI interrupt and 
 *                  extracts the serial number data.
 *                  The HandleTimerInterrupt() function strobes the columns of 
 *                  the keypad and updates the LCD clock.
 *                  The ProcInit() function initializes the peripherals and 
 *                  clock variables.
 *                  The LCDInit() function clears the LCD RAM.
 *                  The HandlePacket() function interprets packets received 
 *                  from the Java server.
 *                  The UpdateLCD() function uses the state determined in the 
 *                  main() function to set the cursor and display new information
 *                  to the LCD.
 *                  The PollKeypad() function checks each row to see if a key 
 *                  press occurred in that row, while the HandleTimerInterrupt()
 *                  function asserts one column at a time.
 *                  The PrintReceipt() function generates a formatted receipt with 
 *                  the user, date, and shopping cart information.
 *                  
 * Authors: Jared Suttles
 *          Jennifer Tietz
 *          Jonathan Chen
 *          Joshua Chapman
 *
 * Version : 1.2
 * Date    : 05/01/06
 *
 *****************************************************************************/

/* Including used modules for compiling procedure */
#include "Cpu.h"
#include "Events.h"
#include "database.h"

/* Include shared modules, which are used for whole project */
#include "PE_Types.h"
#include "PE_Error.h"
#include "PE_Const.h"
#include "IO_Map.h"
#include "LCD_methods.h"
#include "bitmaps.h"
#include "UDP_Client_app.h"
#include "ne64api.h"
#include "ne64config.h"
#include "ne64debug.h"
#include "ne64driver.h"
#include "mBuf.h"
#include "debug.h"
#include "datatypes.h"
#include "timers.h"
#include "system.h"
#include "ethernet.h"
#include "arp.h"
#include "icmp.h"
#include "ip.h"
#include "udp.h"  
#include "address.h"

/**************************/
/*       Constants        */
/**************************/

/* States */
#define IDLE                     1
#define USER_QUERY_DB            2
#define INVALID_USER             3
#define CAPTURE_PIN              4
#define SESSION_START            5
#define SESSION_RUNNING          6
#define INVALID_KEYPRESS         7
#define ITEM_QUERY_DB            8
#define CONFIRM_REMOVAL          9
#define ITEM_NOT_MATCHED        10
#define CANCEL_SESSION          11
#define REMOVE_LAST_ITEM        12
#define SESSION_END             13
#define PRINT                   14
#define EMAIL                   15
#define FINISH_SESSION          16
#define TIME_SYNCH              17

/* Masks and Flags */
#define RFID_FLAG_MASK                0x01
#define KEYPAD_FLAG_MASK              0x02
#define CHK_KEYPAD_FLAG_MASK            0x04
#define VALID_QUERY_FLAG_MASK           0x08
#define CANCEL_ONCE_MASK                0x10
#define ONLY_ONCE_MASK                0x20
#define CHK_RFID_MASK                   0x40
#define MASK_CANCEL_MASK                0x80
#define RFID_FLAG                               0
#define KEYPAD_FLAG                     1
#define CHK_KEYPAD_FLAG                 2 
#define VALID_QUERY_FLAG                3
#define CANCEL_ONCE                     4
#define ONLY_ONCE                               5
#define CHK_RFID_FLAG                   6
#define MASK_CANCEL_FLAG                7

/* RFID serial number type */
#define USER 1
#define ITEM 0

/* Keypad buttons */
#define KEY_ONE     1 
#define KEY_TWO     2
#define KEY_THREE   3
#define KEY_FOUR    4
#define KEY_FIVE    5
#define KEY_SIX     6
#define KEY_SEVEN   7
#define KEY_EIGHT   8
#define KEY_NINE    9
#define KEY_ZERO    0
#define KEY_STAR    11
#define KEY_POUND   12
#define KEY_ENTER   13
#define KEY_CLEAR   14
#define KEY_HELP    15
#define KEY_CANCEL  16

/* Time */
#define AM 1
#define PM 2


/**************************/
/*         Macros         */
/**************************/
#define SetBit(bit_ID, varID)                   (varID |= (byte)(1<<bit_ID))
#define ClearBit(bit_ID, varID)         (varID &= ~(byte)(1<<bit_ID))
#define clrReg8Bits(RegName, ClrMask)   (RegName &= ~(byte)(ClrMask))


/**************************/
/*    Data Structures     */
/**************************/
typedef struct{
  char itemSerial[14];          // Item name, fixed 25 chars
  char itemName[26];            // Item name, fixed 25 chars
  int  nameLength;              // Item name length
  char itemPrice[6];            // Item price, format "XXXXX", fixed 5 chars
} itemStruct;

typedef struct{
  char userName[21];            // Full user name with spaces
  int  nameLength;              // Full user name length
  char userEmail[31];           // Full e-mail address (append "/" if > 30)
  int  emailLength;             // E-mail address length
  int cartSizeI;                        // Number of items in cart
  long cartTotalI;              // Cart total
  int timeHrI;                  // Hours of day
  int timeMinI;                 // Minutes of day
  int timeSecsI;                        // Seconds of day
  int timeHalfI;                        // AM/PM
  int dateMonthI;                       // Current month
  int dateDayI;                 // Current day
  int dateYearI;                        // Current year
  itemStruct items[20];         // Array of purchased items
} sessionStruct;


/**************************/
/*        Globals         */
/**************************/
byte state;
byte returnState;
byte flags;
int keyPressed;
int  pinCounter;
char currentPin[5];
char userPin[5];
char lastSerial[14];
char userSerial[14];
char serialNum[14];
long counter = 0;
int timecounter = 0;
int printcounter = 1;
int testcounter = 0;
int waitcounter = 0;
int pollCounter2 = 0;
sessionStruct currSession;
const int calendar[] = {
  31,31,31,30,31,30,31,31,30,31,30,31
};

INT8 SendData;             //1 if data needs sent. 0 if not.
INT8 RcvData;              //1 if data needs sent. 0 if not.
char toSend[15] = "I:0413AAC34F3A";
char rcvPacket[55];

struct netif localmachine;

extern  tU08    gotlink; 


/**************************/
/*  Function Prototypes   */
/**************************/
void PrintReceipt(void);
void PollKeypad(void);
void ProcInit(void);
void LCDInit(void);
//void EthInit(void);
void UpdateLCD(void);
void SetupSession(void);
void WaitFor(int);
int HandlePacket(void);
extern void RTI_Enable (void);
void mystrcpy(char *, char*, int, int);


/**************************/
/*         main()         */
/**************************/
void main()
{
  INT16 len;
  INT32 i; 
  INT32 j = 0;
  INT32 k = 0;
  
  state = TIME_SYNCH;
  flags = 0x00;
        SendData = 0;

  ProcInit();
  LCDInit();
  SetupSession();

  _INIT_DEBUG();

 /* Set our network information. This is for static configuration.
    if using BOOTP or DHCP this will be a bit different. */
 /* IP address */
      localmachine.localip = *((UINT32 *)ip_address);

        /* Default gateway */
        localmachine.defgw   = *((UINT32 *)ip_gateway);

        /* Subnet mask */
        localmachine.netmask = *((UINT32 *)ip_netmask);

        /* Ethernet (MAC) address */
        localmachine.localHW[0] = hard_addr[0];
        localmachine.localHW[1] = hard_addr[1];
        localmachine.localHW[2] = hard_addr[2];
        localmachine.localHW[3] = hard_addr[3];
        localmachine.localHW[4] = hard_addr[4];
        localmachine.localHW[5] = hard_addr[5];

        /* Init system services */    
        timer_pool_init();
                
      /* Initialize all buffer descriptors */
        mBufInit ();

        /* Interrupts can be enabled AFTER timer pool has been initialized */           
      /* Initialize all network layers  */
      EtherInit();
  
  asm cli;
  
  /* Initialize required network protocols */   
  arp_init();
  (void) udp_init();
  udp_demo_init();
  
  /* Enable RTI */
  RTI_Enable ();

  while (1)
  {
          if (gotlink) {
        /* Try to receive Ethernet Frame        */
                if( NETWORK_CHECK_IF_RECEIVED() == TRUE ) {                             
                        switch( received_frame.protocol)
                  {
                                case PROTOCOL_ARP:
                                  process_arp (&received_frame);
                  break;
                                case PROTOCOL_IP:
                                        len = process_ip_in(&received_frame);
                                        if(len < 0)
                                                break;
                                        switch (received_ip_packet.protocol)
                                          {
                                                case IP_ICMP:
                                                process_icmp_in (&received_ip_packet, len);
                                                          break;
                                                case IP_UDP:
                  process_udp_in (&received_ip_packet,len);                                                     
                  break;
                                                default:
                                                        break;
                                        }
                                break;
                          default:
                                  break;
                  }
                /* discard received frame */                    
                        NETWORK_RECEIVE_END();
                }
      arp_manage();
      udp_demo_run();
          }

    if (state == TIME_SYNCH) {
      if (!(flags & ONLY_ONCE_MASK)) {
        UpdateLCD();
        toSend[0] = 'T';
        SetBit(ONLY_ONCE, flags);       
        SetBit(MASK_CANCEL_FLAG, flags);
      }     
      SendData = 1;
        if(RcvData) {
        if (HandlePacket()) {
          flags = 0x00;
          state = IDLE;
        } else {
          flags = 0x00;
          state = TIME_SYNCH;
        } 
      }
    } 
    
    else if (state == IDLE) {
      if (!(flags & ONLY_ONCE_MASK)) {
        UpdateLCD();
        SetBit(ONLY_ONCE, flags);       
        SetBit(CHK_RFID_FLAG, flags);   
        SetBit(MASK_CANCEL_FLAG, flags);
      }
      if (flags & RFID_FLAG_MASK)        // RFID interrupt occurred
      {
        mystrcpy(userSerial,serialNum,13,13);
        state = USER_QUERY_DB;
        flags = 0x00;
      }
    } 

    else if (state == USER_QUERY_DB) {
      if (!(flags & ONLY_ONCE_MASK)) {
        toSend[0] = 'U';
        mystrcpy(&toSend[1],userSerial,13,13);
        SetBit(ONLY_ONCE, flags);       
      }     
      SendData = 1;
        if(RcvData) {
        if (HandlePacket()) {
          pinCounter = 0;
          flags = 0x00;
          state = CAPTURE_PIN;
        } else {
          flags = 0x00;
          state = INVALID_USER;
        } 
      }
    } 
    
    else if (state == INVALID_USER) {
      UpdateLCD();
      WaitFor(4);
      asm sei;
      SetupSession();
      asm cli;
      state = IDLE;
    } 

    else if (state == CAPTURE_PIN) {
      if (!(flags & ONLY_ONCE_MASK)) {
        UpdateLCD();
        SetBit(CHK_KEYPAD_FLAG, flags);
        SetBit(ONLY_ONCE, flags);       
      }     
      if (flags & KEYPAD_FLAG_MASK) {
        if (pinCounter < 4) {
          if ((keyPressed >= 0) && (keyPressed <= 9)) {
            currentPin[pinCounter] = keyPressed + '0';
            pinCounter++;
            UpdateLCD();
          } else if (keyPressed == KEY_CLEAR) {
            if (pinCounter > 0) {
              pinCounter--;
              UpdateLCD();
            }
          }
        } else {
          if (keyPressed == KEY_CLEAR) {
            pinCounter--;
            UpdateLCD();
          } else if (keyPressed == KEY_ENTER) {
            for (j = 0; j < 4; j++) {
              if (currentPin[j] != userPin[j]) {
                state = INVALID_USER;
                break;
              } 
            } 
            if (j == 4) {
              state = SESSION_START;
            }
            flags = 0x00;
          }
        }
        ClearBit(KEYPAD_FLAG, flags);              
      }
    }
    
    else if (state == SESSION_START) {
      if (!(flags & ONLY_ONCE_MASK)) {
        UpdateLCD();
        SetBit(ONLY_ONCE, flags);
        SetBit(CHK_RFID_FLAG, flags);   
      }
      if (flags & RFID_FLAG_MASK) {
        state = ITEM_QUERY_DB;           // First item RFID was swiped
        flags = 0x00;
      }
    }
            
    else if (state == SESSION_RUNNING) {
      if (!(flags & ONLY_ONCE_MASK)) {
        UpdateLCD();
        SetBit(ONLY_ONCE, flags);
        SetBit(CHK_KEYPAD_FLAG, flags);
        SetBit(CHK_RFID_FLAG, flags);   
      }
      if (flags & RFID_FLAG_MASK) {                      // If next item RFID was swiped
        state = ITEM_QUERY_DB;
        flags = 0x00;
      }if (flags & KEYPAD_FLAG_MASK) {   // If key was pressed
        if (keyPressed == KEY_CLEAR) {
          state = CONFIRM_REMOVAL;
        } else if (keyPressed == KEY_ENTER) {
          state = SESSION_END;
        } else {                                                       // Digit, #, *, or ? key pressed
          state = INVALID_KEYPRESS;
        }
        flags = 0x00;
      }
    } 
    
    else if (state == INVALID_KEYPRESS) {
      UpdateLCD();
      WaitFor(4);
      state = SESSION_RUNNING;
    } 

    else if (state == ITEM_QUERY_DB) {
      if (!(flags & ONLY_ONCE_MASK)) {
        for (i = 0; i < 13; i++) {
          if (lastSerial[i] != serialNum[i]) {
            mystrcpy(lastSerial,serialNum,13,13);
            break;
          } else if (i == 12) {
            flags = 0x00;
                  SetBit(ONLY_ONCE, flags);
            SetBit(CHK_KEYPAD_FLAG, flags);
            SetBit(CHK_RFID_FLAG, flags);               
            state = SESSION_RUNNING;
          }
        }
        if (state != SESSION_RUNNING) {
          toSend[0] = 'I';
          mystrcpy(&toSend[1],serialNum,13,13);
          SetBit(ONLY_ONCE, flags);     
        }
      }
      
      if (state != SESSION_RUNNING) {
        SendData = 1;
      }
        if(RcvData) {
        if (HandlePacket()) {
            state = SESSION_RUNNING;
        } else {
          state = ITEM_NOT_MATCHED;
        }
        flags = 0x00;
        }
    } 

    else if (state == ITEM_NOT_MATCHED) {
      UpdateLCD();
      WaitFor(4);
      state = SESSION_RUNNING;
    } 
    
    else if (state == CANCEL_SESSION) {
      if (!(flags & CANCEL_ONCE_MASK)) {
        UpdateLCD();
        ClearBit(ONLY_ONCE, flags);
        SetBit(CANCEL_ONCE, flags);
        SetBit(CHK_KEYPAD_FLAG, flags);
        SetBit(MASK_CANCEL_FLAG, flags);
      }
      if (flags & KEYPAD_FLAG_MASK) {              // Check for confirmation of cancel
        if (keyPressed == KEY_ENTER) {             // User confirmed cancel
          flags = 0x00;
          state = FINISH_SESSION;
        } else if (keyPressed == KEY_CANCEL) {           // User changed mind - no cancel
          flags = 0x00;
          state = returnState;
        } 
        ClearBit(KEYPAD_FLAG, flags);
      }
    } 
    
    else if (state == CONFIRM_REMOVAL) {
      if (!(flags & ONLY_ONCE_MASK)) {
        UpdateLCD();
        SetBit(ONLY_ONCE, flags);
        SetBit(CHK_KEYPAD_FLAG, flags);
        SetBit(MASK_CANCEL_FLAG, flags);
      }
      if (flags & KEYPAD_FLAG_MASK) {                      // Check for confirmation of item removal from cart
        if (keyPressed == KEY_ENTER) {                         // User confirmed item removal from cart
          flags = 0x00;
          state = REMOVE_LAST_ITEM;
        } else if (keyPressed == KEY_CANCEL) {           // User changed mind - do not remove item, return to cart
          flags = 0x00;
          state = SESSION_RUNNING;
        } 
        ClearBit(KEYPAD_FLAG, flags);
      }
    }

    else if (state == REMOVE_LAST_ITEM) {
      if (!(flags & ONLY_ONCE_MASK)) {
        toSend[0] = 'R';
        mystrcpy(&toSend[1],currSession.items[currSession.cartSizeI-1].itemSerial,13,13);
        UpdateLCD();
        SetBit(ONLY_ONCE, flags);
        SetBit(MASK_CANCEL_FLAG, flags);
      }
      SendData = 1;
        if(RcvData) {
        HandlePacket();
          state = SESSION_RUNNING;
        flags = 0x00;
        }
    } 
    
    else if (state == SESSION_END) {
      if (!(flags & ONLY_ONCE_MASK)) {
        UpdateLCD();
        SetBit(CHK_KEYPAD_FLAG, flags);
        SetBit(MASK_CANCEL_FLAG, flags);
        SetBit(ONLY_ONCE, flags);
      }
      if (flags & KEYPAD_FLAG_MASK) {                      // Ask user for print and/or email receipt
        if (keyPressed == KEY_ENTER) {                         // User selected print receipt
          flags = 0x00;
          state = PRINT;
        } else if (keyPressed == KEY_CANCEL) {           // User refused print receipt - only email
          flags = 0x00;
          state = EMAIL;
        } 
        ClearBit(KEYPAD_FLAG, flags);
      }
    } 
    
    else if (state == PRINT) {
      UpdateLCD();
      asm sei;
      PrintReceipt();
      asm cli;
      WaitFor(3);
      state = EMAIL;     // Email receipt by default
    } 
    
    else if (state == EMAIL) {
      if (!(flags & ONLY_ONCE_MASK)) {
        toSend[0] = 'M';
        mystrcpy(&toSend[1],userSerial,13,13);
        UpdateLCD();
        SetBit(ONLY_ONCE, flags);
      }
      SendData = 1;
        if(RcvData) {
        HandlePacket();
          WaitFor(3);
          state = FINISH_SESSION;
        flags = 0x00;
        }
    } 
    
    else if (state == FINISH_SESSION) {
      UpdateLCD();
      SetupSession();
      WaitFor(8);
      asm cli;
      state = IDLE;
    }
    
    PollKeypad();
  } /* End Infinite Main Loop */
}

void mystrcpy(char *dst, char*src, int dstlen, int srclen) {
  int i = 0;
  
  for (i = 0; i < dstlen; i++) {
    if ( i < srclen) {
      dst[i] = src[i];
    } else {
      dst[i] = ' '; 
    }
  }
}

void SetupSession(void) {
  currSession.cartSizeI = 0;
  currSession.cartTotalI = 0;
  currSession.userName[20] = NULL;
  currSession.userEmail[30] = NULL;
  pinCounter = 0;
  lastSerial[0] = '?';
}


/**************************/
/*     RFIDInterrupt()    */
/**************************/

interrupt void RFIDInterrupt(void) {
  int startFlag = 0;
  int mycounter = 0;
  char holder = ' ';
  
  SCI1SR1;                                                                                               
  holder = SCI1DRL;

  if (!(CHK_RFID_MASK & flags)) {
    return;
  }
  
  serialNum[0] = holder;

  if (SCI1DRL == 0x3A) {
    startFlag = 1;
    mycounter++;
  } else {
    return;
  }
    
  while (mycounter < 14) {
    while ((SCI1SR1 & SCI1SR1_RDRF_MASK) == 0);
    if (SCI1DRL == 0x3A) startFlag = 1;            // Received serial start character (:)
    if (startFlag == 1) {
      serialNum[mycounter] = SCI1DRL;
      mycounter++;
    }
  }

  SetBit(RFID_FLAG, flags);     
}


/**************************/
/* HandleTimerInterrupt() */
/**************************/

interrupt void HandleTimerInterrupt(void) {
  if (pollCounter2 == 0) {
    PTJ_PTJ6 = 1;                        // Set C1 to high
    PTJ_PTJ7 = 0;                                  
    PTT_PTT4 = 0;                                  
    PTT_PTT5 = 0;                                 
  } else if (pollCounter2 == 1) {
    PTJ_PTJ6 = 0;                                 
    PTJ_PTJ7 = 1;                        // Set C2 to high
    PTT_PTT4 = 0;                              
    PTT_PTT5 = 0;                                
  } else if (pollCounter2 == 2) {
    PTJ_PTJ6 = 0;                             
    PTJ_PTJ7 = 0;                               
    PTT_PTT4 = 1;                         // Set C3 to high
    PTT_PTT5 = 0;                                  
  } else if (pollCounter2 == 3) {
    PTJ_PTJ6 = 0;                              
    PTJ_PTJ7 = 0;                              
    PTT_PTT4 = 0;                                
    PTT_PTT5 = 1;                         // Set C4 to high
  }
  pollCounter2 = (pollCounter2 + 1) % 4;
          
  TFLG1_C6F = 1;
  timecounter++;
  if (timecounter == 25) {
    currSession.timeSecsI++;
    if (currSession.timeSecsI > 59) {
      currSession.timeSecsI = 0;
      currSession.timeMinI++;
      if (currSession.timeMinI > 59) {
        currSession.timeMinI = 0;
        currSession.timeHrI++;
        if (currSession.timeHrI == 12) {
          if (currSession.timeHalfI == AM) {
            currSession.timeHalfI = PM;
          } else {
            currSession.timeHalfI = AM;
            currSession.dateDayI++;
            if (currSession.dateDayI > calendar[currSession.dateMonthI]) {
              currSession.dateDayI = 1;
              currSession.dateMonthI++;
              if (currSession.dateMonthI > 12) {
                currSession.dateMonthI = 1;
                currSession.dateYearI++;
                if (currSession.dateYearI > 99) {
                  currSession.dateYearI = 0;
                }
              }
            }
          }
        } else if (currSession.timeHrI > 12) {
          currSession.timeHrI = 1;
        }
      }
      if ((state == SESSION_RUNNING)) {
        UpdateLCD(); 
      }    
    }
    waitcounter++;
    timecounter = 0;
  }
}


/*************************/
/*       ProcInit()       */
/**************************/

void ProcInit(void) {
  SCI0BD = 163;                // Printer port - 9600 baud
  SCI0CR2 = 0x08;              // Printer port - transmit only
  SCI1BD = 163;                // RFID reader port - 9600 baud
  SCI1CR2 = 0x24;              // RFID reader port - receive interrupt mode
  DDRG = 0xFF;
  DDRH = 0x07;
  PERH = 0x78;
  PPSH = 0x78;
  DDRJ_DDRJ0 = 1;
  DDRJ_DDRJ6 = 1;
  DDRJ_DDRJ7 = 1;
  DDRT_DDRT4 = 1;
  DDRT_DDRT5 = 1;
  
  TSCR1 = 0x80;
  TCTL1 = 0x00;
  TIOS = 0xF0;
  TIE = 0x40;
  TSCR2 = 0x0E;
  TC7 = 0x3D0A;  
  TC6 = 0x3D09;  

  CLKSEL=0;
  CLKSEL_PLLSEL = 0;           // Select clock source from XTAL
  PLLCTL_PLLON = 0;            // Disable the PLL
  SYNR = 0;                    // Set the multiplier register
  REFDV = 0;                   // Set the divider register
  PLLCTL = 192;
  PLLCTL_PLLON = 1;            // Enable the PLL
  while(!CRGFLG_LOCK);         // Wait
  CLKSEL_PLLSEL = 1;           // Select clock source from PLL

  INTCR_IRQEN = 0;             // Disable the IRQ interrupts, enable after CPU reset by default
}


/**************************/
/*       LCDInit()       */
/**************************/

void LCDInit(void) {
  LCD_reset();                                           
}


/**************************/
/*     HandlePacket()     */
/**************************/

int HandlePacket(void) {
  char mynum[3] = "00";
  int startpos = 0;
  int i = 0;
  
  SendData = 0;
  RcvData = 0;
  if (rcvPacket[0] == '~') {
    return 0; 
  } else if (state == TIME_SYNCH) {

    /* Grab Month */
    if (rcvPacket[startpos+1] == '/') {
      currSession.dateMonthI = rcvPacket[startpos] - '0';
      startpos += 2;
    } else {
      currSession.dateMonthI = 10 + (rcvPacket[startpos+1] - '0');
      startpos += 3;
    }
        
    /* Grab Day */
    if (rcvPacket[startpos+1] == '/') {
      currSession.dateDayI = rcvPacket[startpos] - '0';
      startpos += 2;
    } else {
      currSession.dateDayI = (10 * (rcvPacket[startpos] - '0')) + (rcvPacket[startpos+1] - '0');
      startpos += 3;
    }

    /* Grab Year */
    currSession.dateYearI = (10 * (rcvPacket[startpos] - '0')) + (rcvPacket[startpos+1] - '0');
    startpos += 3;
    
    /* Grab Hours */
    if (rcvPacket[startpos+1] == ':') {
      currSession.timeHrI = rcvPacket[startpos] - '0';
      startpos += 2;
    } else {
      currSession.timeHrI = 10 + (rcvPacket[startpos+1] - '0');
      startpos += 3;
    }

    /* Grab Minutes */
    currSession.timeMinI = (10 * (rcvPacket[startpos] - '0')) + (rcvPacket[startpos+1] - '0');
    startpos += 3;

    /* Grab Seconds */
    currSession.timeSecsI = (10 * (rcvPacket[startpos] - '0')) + (rcvPacket[startpos+1] - '0');
    startpos += 3;

    if (rcvPacket[startpos] == 'A') {
      currSession.timeHalfI = AM;
    } else {
      currSession.timeHalfI = PM;      
    }
    
  } else if (state == USER_QUERY_DB) {
    mystrcpy(currSession.userName, rcvPacket, 20, 20);
    i = 19;
    while(rcvPacket[i] == ' ') {
      i--;
    }
    currSession.nameLength = i + 1;
    mystrcpy(currSession.userEmail, &rcvPacket[20], 30, 30);
    i = 49;
    while(rcvPacket[i] == ' ') {
      i--;
    }
    currSession.emailLength = i + 1 - 20;
    mystrcpy(userPin, &rcvPacket[50], 4, 4);
  } else if (state == REMOVE_LAST_ITEM) {
 
    /* Recalculate cart total by subtracting last item's price */
    if (currSession.items[currSession.cartSizeI-1].itemPrice[0] != ' ') {
      currSession.cartTotalI -= 10000 * (currSession.items[currSession.cartSizeI-1].itemPrice[0] - '0');
    }
    if (currSession.items[currSession.cartSizeI-1].itemPrice[1] != ' ') {
      currSession.cartTotalI -= 1000 * (currSession.items[currSession.cartSizeI-1].itemPrice[1] - '0');
    }
    if (currSession.items[currSession.cartSizeI-1].itemPrice[2] != ' ') {
      currSession.cartTotalI -= 100 * (currSession.items[currSession.cartSizeI-1].itemPrice[2] - '0');
    }
    if (currSession.items[currSession.cartSizeI-1].itemPrice[3] != ' ') {
      currSession.cartTotalI -= 10 * (currSession.items[currSession.cartSizeI-1].itemPrice[3] - '0');
    }
    if (currSession.items[currSession.cartSizeI-1].itemPrice[4] != ' ') {
      currSession.cartTotalI -= 1 * (currSession.items[currSession.cartSizeI-1].itemPrice[4] - '0');
    }
    currSession.cartSizeI--;
    mystrcpy(lastSerial,currSession.items[currSession.cartSizeI-1].itemSerial,13,13);
  } else if (state == ITEM_QUERY_DB) {
    mystrcpy(currSession.items[currSession.cartSizeI].itemSerial, serialNum, 13, 13);
    mystrcpy(currSession.items[currSession.cartSizeI].itemName, rcvPacket, 25, 25);
    i = 24;
    while(rcvPacket[i] == ' ') {
      i--;
    }
    currSession.items[currSession.cartSizeI].nameLength = i + 1;
    mystrcpy(currSession.items[currSession.cartSizeI].itemPrice, &rcvPacket[25], 5, 5);

    /* Calculate new cart total by adding new item price */
    if (currSession.items[currSession.cartSizeI].itemPrice[0] != ' ') {
      currSession.cartTotalI += 10000 * (currSession.items[currSession.cartSizeI].itemPrice[0] - '0');
    }
    if (currSession.items[currSession.cartSizeI].itemPrice[1] != ' ') {
      currSession.cartTotalI += 1000 * (currSession.items[currSession.cartSizeI].itemPrice[1] - '0');
    }
    if (currSession.items[currSession.cartSizeI].itemPrice[2] != ' ') {
      currSession.cartTotalI += 100 * (currSession.items[currSession.cartSizeI].itemPrice[2] - '0');
    }
    if (currSession.items[currSession.cartSizeI].itemPrice[3] != ' ') {
      currSession.cartTotalI += 10 * (currSession.items[currSession.cartSizeI].itemPrice[3] - '0');
    }
    if (currSession.items[currSession.cartSizeI].itemPrice[4] != ' ') {
      currSession.cartTotalI += 1 * (currSession.items[currSession.cartSizeI].itemPrice[4] - '0');
    }
    currSession.cartSizeI++;
  } 
  
  return 1;
}


/**************************/
/*      UpdateLCD()       */
/**************************/

void UpdateLCD(void) {
  int item_counter, e, f, flag = 0;
  char indexStr[3] = " 0";
  char datetime[18] = "11:11AM  11/11/11";
  char datetime2[21] = "11:11:11AM  11/11/11";
  char mynumber[3] = "00";
  char myprice[8] = "$000.00";
  char temp = ' ';

  LCD_clr_scr_char(0);
  if (state == IDLE) {
    LCD_graphic_ini();
    
    /* Write 4 blank rows */
    for (e = 0; e < 4; e++) {
      for (f = 0; f < 30; f++) {
         LCD_write_data(0x00);
      }
    }
    
    /* Write RFID Xpress 109 row logo */
    for (e = 0; e < LOGO_SIZE; e++) {
      LCD_write_data(logo_bitmap[e]); 
    }
    
    /* Write 'please scan your keyfob' 12 row logo */
    for (e = 0; e < FOOTER_SIZE; e++) {
      LCD_write_data(please_scan_bitmap[e]); 
    }
    
    /* Write 3 blank rows */
    for (e = 0; e < 3; e++) {
      for (f = 0; f < 30; f++) {
         LCD_write_data(0x00);
      }
    }
  } else if (state == TIME_SYNCH) {
    LCD_graphic_ini();
  
    /* Write 4 blank rows */
    for (e = 0; e < 4; e++) {
      for (f = 0; f < 30; f++) {
         LCD_write_data(0x00);
      }
    }
    
    /* Write RFID Xpress 109 row logo */
    for (e = 0; e < LOGO_SIZE; e++) {
      LCD_write_data(logo_bitmap[e]); 
    }
    
    /* Write 3 rows blank */
    for (e = 0; e < 15; e++) {
      for (f = 0; f < 30; f++) {
         LCD_write_data(0x00);
      }
    }
  } else if (state == INVALID_USER) {           // Invalid keyfob scanned
    LCD_char_ini();
    LCD_set_char_add(5,4);
    LCD_print_string("Sorry, customer not recognized.");
  } else if (state == CAPTURE_PIN) {
    LCD_char_ini();                                                                                                                                                                      // Prompt user for PIN
    LCD_set_char_add(5,9);
    LCD_print_string("Welcome, ");
    LCD_print_string(currSession.userName);
    LCD_set_char_add(6,5);
    LCD_print_string("Please enter your 4-digit PIN:");
    LCD_set_char_add(8,17);
    if (pinCounter == 0)
      LCD_print_string(" ");
    else if (pinCounter == 1)
      LCD_print_string("*");
    else if (pinCounter == 2)
      LCD_print_string("* *");
    else if (pinCounter == 3)
      LCD_print_string("* * *");
    else if (pinCounter == 4)
      LCD_print_string("* * * *");
    else
      LCD_print_string("FATAL ERROR");
  } else if (state == SESSION_START) {                  // Instruct user to scan first item
    LCD_char_ini();
    LCD_set_char_add(5,6);
    LCD_print_string("Please scan your first item");
  } else if (state == SESSION_RUNNING) {                        // Shopping cart display
    LCD_char_ini();
    LCD_set_char_add(0,0);
    LCD_print_string("RFID Xpr3ss");
    LCD_set_char_add(0,21);
    mynumber[0] = (currSession.timeHrI / 10) + '0';
    mynumber[1] = (currSession.timeHrI % 10) + '0';
    mystrcpy(&datetime[0],mynumber,2,2);
    mynumber[0] = (currSession.timeMinI / 10) + '0';
    mynumber[1] = (currSession.timeMinI % 10) + '0';
    mystrcpy(&datetime[3],mynumber,2,2);
    mynumber[0] = (currSession.dateMonthI / 10) + '0';
    mynumber[1] = (currSession.dateMonthI % 10) + '0';
    mystrcpy(&datetime[9],mynumber,2,2);
    mynumber[0] = (currSession.dateDayI / 10) + '0';
    mynumber[1] = (currSession.dateDayI % 10) + '0';
    mystrcpy(&datetime[12],mynumber,2,2);
    mynumber[0] = (currSession.dateYearI / 10) + '0';
    mynumber[1] = (currSession.dateYearI % 10) + '0';
    mystrcpy(&datetime[15],mynumber,2,2);
    mynumber[1] = 'M';
    if (currSession.timeHalfI == AM) {
      mynumber[0] = 'A';
    } else {
      mynumber[0] = 'P';
    }
    mystrcpy(&datetime[5],mynumber,2,2);
    LCD_print_string(datetime);
    LCD_set_char_add(1,0);
    LCD_print_string("ITEM                              PRICE ");

    /* Print last 7 scanned items in shopping cart to allow for automatic scrolling */
    for (item_counter=currSession.cartSizeI-7; item_counter<currSession.cartSizeI; item_counter++){
      if (currSession.cartSizeI == 0){break;}
      if (item_counter<0){item_counter=0;}
      if (item_counter < 9) {
        indexStr[0] = ' '; 
      } else {
        indexStr[0] = (char)(((item_counter+1) / 10)+'0');
      }
      indexStr[1] = (char)(((item_counter+1) % 10) + '0');
      LCD_print_string(indexStr);
      LCD_print_string(" ");
      LCD_print_string(currSession.items[item_counter].itemName);
      LCD_print_string("     ");
      mystrcpy(&myprice[1], currSession.items[item_counter].itemPrice,3,3);
      mystrcpy(&myprice[5], &currSession.items[item_counter].itemPrice[3],2,2);
      LCD_print_string(myprice);
    }
    
    LCD_set_char_add(9,33);
    LCD_print_string("-------");

    temp = (currSession.cartSizeI / 10) + '0';
    if (temp == '0') {
      mynumber[0] = ' ';
    } else {  
      mynumber[0] = temp;
    }

    mynumber[1] = (currSession.cartSizeI % 10) + '0';
    
    LCD_set_char_add(10,0);
    LCD_print_string(mynumber);
    LCD_print_string(" items in your cart");
    LCD_set_char_add(10,3);
    LCD_print_string("items in your cart           TOTAL: $");

    /* Decode integer cart total into its character representation */    
    temp = (currSession.cartTotalI / 100000) + '0';
    if ((temp == '0') && (flag == 0)) {
      myprice[0] = ' ';
    } else {
      myprice[0] = temp;
      flag = 1;
    }

    temp = ((currSession.cartTotalI % 100000) / 10000) + '0';
    if ((temp == '0') && (flag == 0)) {
      myprice[1] = ' ';
    } else {
      myprice[1] = temp;
      flag = 1;
    }

    temp = ((currSession.cartTotalI % 10000) / 1000) + '0';
    if ((temp == '0') && (flag == 0)) {
      myprice[2] = ' ';
    } else {
      myprice[2] = temp;
      flag = 1;
    }

    temp = ((currSession.cartTotalI % 1000) / 100) + '0';
    if ((temp == '0') && (flag == 0)) {
      myprice[3] = ' ';
    } else {
      myprice[3] = temp;
      flag = 1;
    }

    temp = ((currSession.cartTotalI % 100) / 10) + '0';
    if ((temp == '0') && (flag == 0)) {
      myprice[5] = ' ';
    } else {  
      myprice[5] = temp;
      flag = 1;
    }

    temp = ((currSession.cartTotalI % 10) / 1) + '0';
    if ((temp == '0') && (flag == 0)) {
      myprice[6] = ' ';
    } else {
      myprice[6] = temp;
      flag = 1;
    }
    LCD_print_string(myprice);
    LCD_set_char_add(11,1);
    LCD_print_string("[ PRESS ENTER TO FINISH ]");
  } else if (state == INVALID_KEYPRESS) {                                                                                       // Keypress not recognized
    LCD_char_ini();
    LCD_set_char_add(5,10);
    LCD_print_string("Key not recognized");
  } else if (state == ITEM_NOT_MATCHED) {                                                                                       // Item RFID not found
    LCD_char_ini();
    LCD_set_char_add(5,10);
    LCD_print_string("Item not recognized");
  } else if (state == CANCEL_SESSION) {                                                                                         // Confirm user wants to cancel shopping session
    LCD_char_ini();
    LCD_set_char_add(4,0);
    LCD_print_string(" Are you sure you want to quit shopping?");
                LCD_set_char_add(6,0);
    if (returnState == CAPTURE_PIN) {
                LCD_print_string("   Press ENTER  to confirm,             ");
      LCD_print_string("         CANCEL to return to pin entry  ");
    } else {
                LCD_print_string("     Press ENTER  to confirm,           ");
      LCD_print_string("           CANCEL to return to cart");       
    }
  } else if ((state == REMOVE_LAST_ITEM) || (state == CONFIRM_REMOVAL)) {        // Confirm user wants to remove last item
    LCD_char_ini();
    LCD_set_char_add(2,5);
    LCD_print_string("Are you sure you want to remove         ");
    LCD_set_char_add(4,(20 - currSession.items[currSession.cartSizeI-1].nameLength / 2));     
    LCD_print_string(currSession.items[currSession.cartSizeI-1].itemName);
    LCD_set_char_add(6,13);
    LCD_print_string("from your cart?");
    LCD_set_char_add(8,0);
    LCD_print_string("      Press ENTER  to remove item,      ");
                LCD_print_string("            CANCEL to return to cart");
  } else if (state == SESSION_END) {                         // Prompt user for printed receipt 
    LCD_char_ini();
    LCD_set_char_add(5,5);
    LCD_print_string("Do you want a printed receipt?");
    LCD_set_char_add(7,0);
    LCD_print_string("         Press ENTER  for yes,          ");
                LCD_print_string("               CANCEL to skip");
  } else if (state == PRINT) {                                                                                                                   // Print receipt
    LCD_char_ini();
    LCD_set_char_add(4,15);
    LCD_print_string("Printing...");
    LCD_set_char_add(6,7);
    LCD_print_string("Please take your receipt...");
  } else if (state == EMAIL) {                                                                                                                   // Email receipt
    LCD_char_ini();
    LCD_set_char_add(4,11);
    LCD_print_string("Emailing receipt to");
    LCD_set_char_add(6,(20 - currSession.emailLength / 2));                                                        
    LCD_print_string(currSession.userEmail);
  } else if (state == FINISH_SESSION) {                                                                                 // Thank user for shopping
    LCD_graphic_ini(); 
  
    /* Write 4 blank rows */
    for (e = 0; e < 4; e++) {
      for (f = 0; f < 30; f++) {
         LCD_write_data(0x00);
      }
    }
    
    /* Write RFID Xpress 109 row logo */
    for (e = 0; e < LOGO_SIZE; e++) {
      LCD_write_data(logo_bitmap[e]); 
    }
    
    /* Write 'thank you for shopping' 12 row logo */
    for (e = 0; e < FOOTER_SIZE; e++) {
      LCD_write_data(thank_you_bitmap[e]); 
    }
    
    /* Write 3 blank rows */
    for (e = 0; e < 3; e++) {
      for (f = 0; f < 30; f++) {
         LCD_write_data(0x00);
      }
    }
  } else {
    LCD_set_char_add(5,10);
    LCD_print_string("UNKNOWN ERROR");
  }
}


/**************************/
/*       WaitFor()        */
/**************************/

void WaitFor(int time) {
  waitcounter = 0;
  while (waitcounter < time); 
}


/**************************/
/*     PollKeypad()       */
/**************************/

void PollKeypad(void)
{
  asm sei;
  if (PTH_PTH6 == 1) {                   // If row 1 is pressed                         
    if (pollCounter2 == 1) {                                             // If col 1 is pressed
      keyPressed = KEY_ONE;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 2) {                      // If col 2 is pressed
      keyPressed = KEY_TWO;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 3) {                      // If col 3 is pressed
      keyPressed = KEY_THREE;
      SetBit(KEYPAD_FLAG, flags);
    } else {                                                                                                             // If col 4 is pressed
      keyPressed = KEY_ENTER;
      SetBit(KEYPAD_FLAG, flags);
    }
  } else if (PTH_PTH5 == 1) {            // If row 2 is pressed            
    if (pollCounter2 == 1) {                                             // If col 1 is pressed
      keyPressed = KEY_FOUR;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 2) {                      // If col 2 is pressed
      keyPressed = KEY_FIVE;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 3) {                      // If col 3 is pressed
      keyPressed = KEY_SIX;
      SetBit(KEYPAD_FLAG, flags);
    } else {                                                                                                             // If col 4 is pressed
      keyPressed = KEY_CLEAR;
      SetBit(KEYPAD_FLAG, flags);
    }
  } else if (PTH_PTH4 == 1) {            // If row 3 is pressed            
    if (pollCounter2 == 1) {                                             // If col 1 is pressed
      keyPressed = KEY_SEVEN;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 2) {                      // If col 2 is pressed
      keyPressed = KEY_EIGHT;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 3) {                      // If col 3 is pressed
      keyPressed = KEY_NINE;
      SetBit(KEYPAD_FLAG, flags);
    } else {                                                                                                             // If col 4 is pressed
      keyPressed = KEY_HELP;
      SetBit(KEYPAD_FLAG, flags);
    }
  } else if (PTH_PTH3 == 1) {            // If row 4 is pressed            
    if (pollCounter2 == 1) {                                             // If col 1 is pressed
      keyPressed = KEY_STAR;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 2) {                      // If col 2 is pressed
      keyPressed = KEY_ZERO;
      SetBit(KEYPAD_FLAG, flags);
    } else if (pollCounter2 == 3) {                      // If col 3 is pressed
      keyPressed = KEY_POUND;
      SetBit(KEYPAD_FLAG, flags);
    } else {                                                                                                             // If col 4 is pressed
      keyPressed = KEY_CANCEL;
      SetBit(KEYPAD_FLAG, flags);
    }
  }
  
  /* Wait until key is released */
  while (PTH_PTH6 || PTH_PTH5 || PTH_PTH4 || PTH_PTH3);
  
  asm cli;

  if (flags & KEYPAD_FLAG_MASK) {        // Cancel button pressed
    if ((keyPressed == KEY_CANCEL) && (!(flags & MASK_CANCEL_MASK))) {
      returnState = state;
      state = CANCEL_SESSION;
      ClearBit(KEYPAD_FLAG, flags);
    } else if (!(flags & CHK_KEYPAD_FLAG_MASK)) {
      ClearBit(KEYPAD_FLAG, flags);
    }
  } 
}


/**************************/
/*     PrintReceipt()     */
/**************************/

void PrintReceipt(void)
{
  int printcounter = 0;
  const char Logo[] = "*********************************             \\\\//             **         RFID // PRESS        **             //\\\\             *********************************";
  char DashDash[32] =  "                         -------";
  char Total[32] =     "                 Total: $1111.11";
  char ThankYou[32] =  " Thank you for shopping with us.";
  char ComeAgain[32] = "       Please come again!       ";
  char datetime[18] = "11:11AM  11/11/11";
  int i, j, itemLen, priceLen, flag = 0;
  char datetime2[21] = "11:11:11AM  11/11/11";
  char mynumber[3] = "00";
  char myprice[9] = "$0000.00";
  char temp = ' ';

  /* Transmit CR and LF */
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0D;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;

  /* Print RFID Xpress Logo */
  while (printcounter < 160) {
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = Logo[printcounter];
    printcounter++;
  }

  /* Transmit CR and LF */
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0D;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;

  mynumber[0] = (currSession.timeHrI / 10) + '0';
  mynumber[1] = (currSession.timeHrI % 10) + '0';
  mystrcpy(&datetime2[0],mynumber,2,2);
  mynumber[0] = (currSession.timeMinI / 10) + '0';
  mynumber[1] = (currSession.timeMinI % 10) + '0';
  mystrcpy(&datetime2[3],mynumber,2,2);
  mynumber[0] = (currSession.timeSecsI / 10) + '0';
  mynumber[1] = (currSession.timeSecsI % 10) + '0';
  mystrcpy(&datetime2[6],mynumber,2,2);
  mynumber[0] = (currSession.dateMonthI / 10) + '0';
  mynumber[1] = (currSession.dateMonthI % 10) + '0';
  mystrcpy(&datetime2[12],mynumber,2,2);
  mynumber[0] = (currSession.dateDayI / 10) + '0';
  mynumber[1] = (currSession.dateDayI % 10) + '0';
  mystrcpy(&datetime2[15],mynumber,2,2);
  mynumber[0] = (currSession.dateYearI / 10) + '0';
  mynumber[1] = (currSession.dateYearI % 10) + '0';
  mystrcpy(&datetime2[18],mynumber,2,2);
  mynumber[1] = 'M';
  if (currSession.timeHalfI == AM) {
    mynumber[0] = 'A';
  } else {
    mynumber[0] = 'P';
  }
  mystrcpy(&datetime2[8],mynumber,2,2);
    
  for (j = 0; j < 12; j++) {
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = ' ';
  }    
  
  printcounter = 0;

  while (printcounter < 20) {
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = datetime2[printcounter];
    printcounter++;     
  }

  /* Transmit CR and LF */
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0D;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;

  /* Print items with price in shopping cart */
  for (i = 0; i < currSession.cartSizeI; i++)
  {
    itemLen = 0;
    priceLen = 0;

    /* Print item */
    while (itemLen < 20){
      while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
      SCI0DRH = 0;
      SCI0DRL = currSession.items[i].itemName[itemLen];
      itemLen++;
    }

    /* Print whitespace between item and price */
    for (j = 0; j < 5; j++) {
      while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
      SCI0DRH = 0;
      SCI0DRL = ' ';
    }    

    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = '$';

    /* Print price */
    while (priceLen < 3) {
      while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
      SCI0DRH = 0;
      SCI0DRL = currSession.items[i].itemPrice[priceLen];
      priceLen++;
    }

    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = '.';

    while (priceLen < 5) {
      while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
      SCI0DRH = 0;
      SCI0DRL = currSession.items[i].itemPrice[priceLen];
      priceLen++;
    }

    /* Print CR and LF */
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = 0x0D;
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = 0x0A;
  }

  printcounter = 0;

  while (printcounter < 32) {
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = DashDash[printcounter];
    printcounter++;
  }

  /* Print CR and LF */
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0D;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;

  /* Convert integer cart total to character representation */
  temp = (currSession.cartTotalI / 100000) + '0';
  if ((temp == '0') && (flag == 0)) {
    myprice[1] = ' ';
  } else {
    myprice[1] = temp;
    flag = 1;
  }

  temp = ((currSession.cartTotalI % 100000) / 10000) + '0';
  if ((temp == '0') && (flag == 0)) {
    myprice[2] = ' ';
  } else {
    myprice[2] = temp;
    flag = 1;
  }

  temp = ((currSession.cartTotalI % 10000) / 1000) + '0';
  if ((temp == '0') && (flag == 0)) {
    myprice[3] = ' ';
  } else {
    myprice[3] = temp;
    flag = 1;
  }

  temp = ((currSession.cartTotalI % 1000) / 100) + '0';
  if ((temp == '0') && (flag == 0)) {
    myprice[4] = ' ';
  } else {
    myprice[4] = temp;
    flag = 1;
  }

  temp = ((currSession.cartTotalI % 100) / 10) + '0';
  if ((temp == '0') && (flag == 0)) {
    myprice[6] = ' ';
  } else {  
    myprice[6] = temp;
    flag = 1;
  }

  temp = ((currSession.cartTotalI % 10) / 1) + '0';
  if ((temp == '0') && (flag == 0)) {
    myprice[7] = ' ';
  } else {
    myprice[7] = temp;
    flag = 1;
  }

  /* Print Total */
  mystrcpy(&Total[24],myprice,8,8);
  printcounter = 0;

  while (printcounter < 32) {
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = Total[printcounter];
    printcounter++;
  }

  /* Print CR and LF */
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0D;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;

  /* Print last line of receipt */
  printcounter = 0;
  while (printcounter < 32) {
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = ThankYou[printcounter];
    printcounter++;
  }

  /* Print CR and LF */
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0D;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;

  printcounter = 0;
  while (printcounter < 32) {
    while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
    SCI0DRH = 0;
    SCI0DRL = ComeAgain[printcounter];
    printcounter++;
  }

  /* Print CR and LF */
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0D;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
  while ((SCI0SR1 & SCI0SR1_TDRE_MASK) == 0);
  SCI0DRH = 0;
  SCI0DRL = 0x0A;
}

---