/******************************************************************************            
************                 LABCENTER ELECTRONICS                  ************            
************           Proteus VSM Sample Design Code               ************            
************                   IAR 'C' Calculator                   ************            
*******************************************************************************/       

#include "calc.h"
#include "stdio.h"
#include "math.h"
#include "stdlib.h"
          
//Variables
static FLOAT lvalue;
static FLOAT rvalue;
static CHAR lastop;

VOID main (VOID)
// Initialise our variables and call the 
// Assembly routine to initialise the LCD display. 
 { lcd_init();
   calc_evaluate();
 }   

VOID calc_evaluate()
 { CHAR number[MAX_DISPLAY_CHAR+1], key;
   INT8 pos;
   FLOAT tmp;
   
   // Initialize static values:
   lvalue = 0;
   rvalue = 0;
   lastop = 0;
   
   // Display a Zero to start:
   calc_format(0);
   
   // Clear the buffer before we start.
   pos = 0;

   for (;;)
    { key = calc_getkey();
      if (calc_testkey(key))
       { // Key test positive for digit so we read it into the
         // buffer and then write the buffer to the screen/LCD.
         // Size limit the number of digits - allow for termination
         // and possible negative results.
         if (pos != MAX_DISPLAY_CHAR - 2)
          { number[pos++] = key;
            number[pos] = 0;
            calc_display(number);
          }
       }
      else       
       { // If a number has been entered, then evaulate it.
         // The number is stored to lvalue if we have no current operator,
         // or else rvalue if we do.
         if (pos != 0)
          { tmp = atof(number);
            if (lastop == 0)
               lvalue = tmp;
            else
               rvalue = tmp;
          }

         // Reset the input buffer.
         pos = 0;
       
         // Process the Command - LastOp holds the last actual operator;          
         if (lastop != 0)
            calc_opfunctions(lastop);
         if (key != '=')
            lastop = key;
         else 
            lastop = 0;  
       }
    }
 }

VOID calc_opfunctions (CHAR token)
// Handle the operations. Lvalue holds the result and we test for
// consecutive operator presses.
 { INT8 result = OK;
   switch (token)
    { case '+' : lvalue += rvalue; break;
      case '-' : lvalue -= rvalue; break;
      case '*' : lvalue *= rvalue; break;
      case '/' : 
         if (rvalue != 0) 
            lvalue /= rvalue;
         else
            result = ERROR;
         break;      
     }

   if (result == OK)
      calc_format(lvalue);
   else if (result == ERROR)
      calc_display("*ERROR*"); 
 }

 
/************************************************************************
***** Utility Routines *****
***************************/

VOID calc_format (FLOAT f)
 { CHAR buf [MAX_DISPLAY_CHAR+1];
   FLOAT divisor = 100000000;
   FLOAT digit;
   INT8 pad=0, p=0;

   // Sort out minus sign:   
   if (f >= 0)
      buf[p++] = ' ';
   else
    { buf[p++] = '-';
      f = -f;
    }

   if (f >= divisor)
      buf[p++] = 'E';
   else
      while (p < MAX_DISPLAY_CHAR && (divisor > 1 || f >= 0.0000001))
       { divisor /= 10;
         digit = floor(f/divisor);
         if (divisor < 1 && divisor > 0.01)
            buf[p++] = '.';
         if (digit != 0 || divisor < 10)
          { buf[p++] = digit + '0';
            pad = TRUE;        
          }
         else if (pad)
            buf[p++] = '0';
         f -= digit*divisor;
       }
   buf[p] = 0;           
   calc_display(buf);
 }

BOOL calc_testkey (CHAR key)
// Test whether the key is a digit, a decimal point or an operator. 
// Return 1 for digit or decimal point, 0 for op.
 { if ((key == '.')|| ((key >= '0') && (key <= '9')))
      return TRUE;
   else
      return FALSE;
 }

/************************************************************************
***** I/O Routines *****
************************/

CHAR calc_getkey (VOID)
// Use the input routine from the *Keypad_Read* assembly file to 
// Scan for a key and return ASCII value of the Key pressed.
{ CHAR mykey;
  while ((mykey = keypadread()) == 0x00)
     /* Poll again */;
  return mykey;
 }

VOID calc_display (CHAR *buf)
// Use the Output and Clearscreen routines from the 
// *LCD_Write* assembly file to output ASCII values to the LCD.
 { INT8 i;
   clearscreen();
   for (i=0 ; buf[i] != 0; i++)
//    { if (buf[calc_testkey(buf[i]) || buf[i] == 0x2D)
       { wrdata(buf[i]); }
//    }   
 }

/******************************************************************************            
************             LABCENTER ELECTRONICS                      ***********            
************	       Proteus VSM Sample Design Code               ***********		 	     
************	           IAR 'C' Calculator                 	    ***********            
******************************************************************************/           
                                                                                            
typedef void VOID;                                                                          
typedef int  INT;                                                                           
typedef signed char INT8;
typedef signed int  INT16;
typedef signed long INT32;
typedef unsigned short WORD;                                                                
typedef char CHAR;                                                                          
typedef unsigned char BYTE;                                                                 
typedef float FLOAT;                                                                        
typedef double DOUBLE;                                                                      
typedef long LONG;                                                                          
typedef INT8 BOOL;
                                                                                            
//Display Config.
#define MAX_DISPLAY_CHAR 10    

// Keypad Config.
#define KEYP_NUM_ROWS 4
#define KEYP_NUM_COLS 4

//LCD Registers addresses (PORT B)
#define LCD_CMD_WR	   0x00
#define LCD_DATA_WR	   0x01
#define LCD_BUSY_RD	   0x02
#define LCD_DATA_RD	   0x03
                     
//LCD Commands        
#define LCD_CLS		   0x01
#define LCD_HOME	   0x02
#define LCD_SETMODE	   0x04
#define LCD_SETVISIBLE	   0x08
#define LCD_SHIFT	   0x10
#define LCD_SETFUNCTION	   0x20
#define LCD_SETCGADDR	   0x40
#define LCD_SETDDADDR	   0x80

#define E_PIN_MASK         0x04
#define NOP                asm("NOP")

#define FALSE 0
#define TRUE  1                                                       
                                                                                            
//Error handling status.                                                                    
enum ERROR { OK = 0, SLEEP = 1, ERROR = 2};                                                 
                                                                                               
/************************************************************************                   
***** FUNCTION PROTOTYPES *****                                                             
******************************/                                                             
VOID calc_evaluate();                                                                       
CHAR calc_getkey (VOID);                                                                    
VOID calc_format (FLOAT f);
VOID calc_display (CHAR *buf);                                             
                                                                                            
//Operator Indirect function.                                                               
VOID calc_opfunctions (CHAR token);                                                         
                                                                                            
//Utility functions.                                                                        
BOOL  calc_testkey  (CHAR ch);                                                              
VOID  calc_output   (INT status);                                                           

// Keypad Functions.
CHAR keypadread(); 
CHAR scankeypad();

VOID lcd_init();
VOID lcd_wait();
VOID wrcmd (CHAR data);
VOID wrdata(CHAR data);
VOID clearscreen();

/*********************************************************************
**********************************************************************
*****                                                             ****
*****         L A B C E N T E R    E L E C T R O N I C S          ****
*****                                                             ****
*****                  PIC 16F87X Keypad Scanner                  ****
*****                                                             ****
**********************************************************************
*********************************************************************/

// Rows are connected to Port C 
// Columns are connected to Port A with external pull-up resistors.

#include "calc.h"
#include "io16F876.h"

CHAR keycodes[16] = {'7','8','9','/','4','5','6','*','1','2','3','-','.','0','=','+'};

CHAR keypadread()
// Find a key, wait for
// it to be released and return.
 { CHAR key = scankeypad();
   if (key)
      while (scankeypad() != 0)
         /* Nothing */  ;  
   return key;
 } 

CHAR scankeypad()
// Scan the keypad for a keypress.
// Return 0 for no press or the char pressed.
 { INT8 row,col,tmp;
   CHAR key=0;

   // Disable ADC functionality on Port A
   ADCON1 = 6; 

   // Initialise Port for input, and PORTC for output
   TRISA = PORTC = 0xFF;
   TRISC = 0;

   for (row=0; row < KEYP_NUM_ROWS; row++)
    { // Drive appropriate row low and read columns:
      PORTC = ~(1 << row);
      asm ( "NOP");     
      tmp = PORTA;
    
      // See if any column is active (low):
      for (col=0; col<KEYP_NUM_COLS; ++col)
         if ((tmp & (1<<col)) == 0)
          { INT8 idx = (row*KEYP_NUM_COLS) + col;
            key = keycodes[idx]; 
            goto DONE;
          }
    }
   DONE:

   // Disable Port Drive and return.
   TRISC = 0xFF;
   return key;
 }

/*********************************************************************
**********************************************************************
*****                                                             ****
*****         L A B C E N T E R    E L E C T R O N I C S          ****
*****                                                             ****
*****                    PIC 16F87X LCD Driver                     ****
*****                                                             ****
**********************************************************************
*********************************************************************/

#include "calc.h"
#include "io16F876.h"

VOID lcd_init ()
// Initialise the LCD Display. 
 { PORTB = TRISB = 0; 
   TRISC = PORTC = 0xFF;
   wrcmd(0x30);                  // 8-bit mode - 1 line.
   wrcmd(LCD_SETVISIBLE+0x04);   // Display only - no cursors.
   wrcmd(LCD_SETMODE+0x03);      // Automatic Increment - Display shift left.
   wrcmd(LCD_SETDDADDR+0x0F);    // Initial Position far right.
 }

VOID clearscreen ()
// Clear the LCD Screen and reset
// initial position.
 { wrcmd(LCD_CLS);
   wrcmd(LCD_SETDDADDR+0x0F);
 }

/***** Utility Functions *****/

VOID wrcmd (CHAR cmdcode)
// Write a command to the LCD display.
 { TRISC = 0;
   PORTC = cmdcode;

   // Write to PORTB to latch data into the display.
   // Toggle Pin 'E' to send the command.
   PORTB  = LCD_CMD_WR;
   PORTB |= E_PIN_MASK;
   asm("NOP");
   PORTB &= ~E_PIN_MASK;
   
   lcd_wait();
 }
     
VOID wrdata (CHAR data)
// Write a Character to the LCD Display. 
 { TRISC = 0;
   PORTC = data;
   
   PORTB = LCD_DATA_WR;
   PORTB |= E_PIN_MASK;
   asm("NOP");
   PORTB &= ~E_PIN_MASK;
   
   lcd_wait();
 }

VOID lcd_wait ()
// Wait for the LCD busy flag to clear. 
 { BYTE status;
   TRISC = 0xFF;
   
   PORTB = LCD_BUSY_RD;
   do
    { PORTB |= E_PIN_MASK;
      asm("NOP");
      status = PORTC;
      PORTB &= ~E_PIN_MASK;
    } while (status & 0x80);
 }