###

********************Header File********************  
#include "avr/io.h"
#include "avr/pgmspace.h"
#include "avr/boot.h"
#include "avr/wdt.h"
#include "avr/interrupt.h"
#include "avr/eeprom.h"
#include "avr/sleep.h"
#include "stdio.h"
#include "stdarg.h"
#include "util/delay.h"
 
#define LOBYTE(_W_)    (_W_ & 0x0F)
#define HIBYTE(_W_)    ((_W_ >> 4) & 0x0F)
 
#define OUTPUT_PORT 0xFF
#define OUTPUT_PIN 1
#define INPUT_PORT 0x00
#define INPUT_PIN 0
 
enum {OFF, ON, HIGH_Z};
enum {FALSE, TRUE};
 
typedef struct{
unsigned char b0:1; unsigned char b1:1; unsigned char b2:1; unsigned char b3:1;
unsigned char b4:1; unsigned char b5:1; unsigned char b6:1; unsigned char b7:1;
} bits;
 
#define PORT_B (*(volatile bits *) & PORTB)
#define PIN_B (*(volatile bits *) & PINB)
#define DDR_B (*(volatile bits *) & DDRB)
 
#define PORT_C (*(volatile bits *) & PORTC)
#define PIN_C (*(volatile bits *) & PINC)
#define DDR_C (*(volatile bits *) & DDRC)
 
#define PORT_D (*(volatile bits *) & PORTD)
#define PIN_D (*(volatile bits *) & PIND)
#define DDR_D (*(volatile bits *) & DDRD)
 
#if defined (_AVR_IOM16_H_) || (_AVR_IOM32_H_)
#define __UCSRB UCSRB
#define __TXEN  TXEN
#define __RXEN  RXEN
#define __UCSRC  UCSRC
#define __UCSZ0  UCSZ0
#define __UCSZ1  UCSZ1
#define __URSEL  URSEL
#define __UBRRL  UBRRL
#define __UBRRH  UBRRH
#define __SPMEN  SPMEN
#define __BLBSET  BLBSET
#define __UCSRA  UCSRA
#define __UDRE  UDRE
#define __RXCIE RXCIE
#define __RXC  RXC
#define __UDR  UDR
#elif defined (_AVR_IOM168P_H_) || (_AVR_IOM168_H_) || (_AVR_IOM328P_H_) || (_AVR_IOM88_H_)
#define __UCSRB UCSR0B
#define __TXEN  TXEN0
#define __RXEN  RXEN0
#define __UCSRC  UCSR0C
#define __UCSZ0  UCSZ00
#define __UCSZ1  UCSZ01
#define __URSEL  UMSEL01
#define __UBRRL  UBRR0L
#define __UBRRH  UBRR0H
#define __SPMEN  SELFPRGEN
#define __BLBSET  BLBSET
#define __UCSRA  UCSR0A
#define __UDRE  UDRE0
#define __RXC  RXC0
#define __RXCIE RXCIE0
#define __UDR  UDR0
#endif
 
#if defined (LCD_PORT)
#define _LCD_DATA_ LCD_PORT(PORT)
#define _LCD_DDR_ LCD_PORT(DDR)
#define LCD_BK LCD_PORT(PORT_).b7
#define RS LCD_PORT(PORT_).b5
#define EN LCD_PORT(PORT_).b4
#define LCD_D4 LCD_PORT(PORT_).b3
#define LCD_D5 LCD_PORT(PORT_).b2
#define LCD_D6 LCD_PORT(PORT_).b1
#define LCD_D7 LCD_PORT(PORT_).b0
#define LCD_Row1 0x80
#define LCD_Row2 0xC0
#define LCD_Row3 0x94
#define LCD_Row4 0xD4
#define LCD_EN() {EN = 1; _delay_ms(5); EN = 0;}
#define Write_Cmd(Byte) _nWrite(0, Byte)
#define Write_Char(Byte) _nWrite(1, Byte)
#define Clear_LCD()  Write_Cmd(0x01)
#define Next_Line()  Write_Cmd(0xC0)
#define LCD_Backlight(x) LCD_BK = x
 
#if defined (E1004)
inline void Write_Nibble(unsigned char Nibble)
{
LCD_D4 = (Nibble >> 0) & 1;
LCD_D5 = (Nibble >> 1) & 1;
LCD_D6 = (Nibble >> 2) & 1;
LCD_D7 = (Nibble >> 3) & 1;
 
LCD_EN();
}
#endif
 
void _nWrite(unsigned char Type, unsigned char xByte)
{
RS = Type;
Write_Nibble(HIBYTE(xByte));
 
RS = Type;
Write_Nibble(LOBYTE(xByte));
 
_delay_us(50);
}
 
void Init_LCD()
{
_LCD_DDR_ = OUTPUT_PORT;
_delay_ms(25);
 
Write_Cmd(0x33);
_delay_us(200);
 
Write_Cmd(0x32);
_delay_us(200);
 
Write_Cmd(0x28);
_delay_us(50);
 
Write_Cmd(0x28);
_delay_us(50);
 
Write_Cmd(0x0C);
Write_Cmd(0x06);
_delay_us(50);
 
Clear_LCD();
_delay_us(50);
}
 
void _LCD_gotoxy(unsigned char Row, unsigned char Col)
{
switch(Row)
{
case 1: Row = LCD_Row1; break;
case 2: Row = LCD_Row2; break;
case 3: Row = LCD_Row3; break;
case 4: Row = LCD_Row4; break;
}
 
Row += --Col;
 
Write_Cmd(Row);
}
 
void _LCD_Write(unsigned char *strText)
{
while(*strText)
{
switch(*strText)
{
   case'n':
case'r':
strText++;
Next_Line();
continue;
   default :
Write_Char(*strText);
}
strText++;
}
}
 
void Write_LCD(unsigned char Row, unsigned char Col, char *Str, ...)
{
    char String[90];
 
va_list arg_ptr;
va_start(arg_ptr, Str);
    vsprintf(String, Str, arg_ptr);
va_end(arg_ptr);
 
if(!Str) return;
 
_LCD_gotoxy(Row, Col);
    _LCD_Write((unsigned char *)String);
}
#endif
 
#if defined (USART)
#if !defined (USART_BAUDRATE)
#define USART_BAUDRATE 9600
#endif
#define BAUD_PRESCALE  (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)
void Init_USART()
{
  __UCSRB |= _BV(__RXEN) | _BV(__TXEN);
__UCSRC |= _BV(__URSEL) | _BV(__UCSZ0) | _BV(__UCSZ1);
 
__UBRRL = BAUD_PRESCALE;
__UBRRH = BAUD_PRESCALE >> 8;
}
 
inline void TxChar(unsigned char Chr)
{
while((__UCSRA & _BV(__UDRE)) == 0);
__UDR = Chr;
}
 
inline unsigned char RxChar()
{
while((__UCSRA & _BV(__RXC)) == 0);
return(__UDR);
}
 
void RxNchar(unsigned char *Str, unsigned char Size, unsigned char StopChar)
{
do
{
*Str = RxChar();
 
if(StopChar != 0x00)
if(*Str == StopChar)
return;
 
Str++;
Size--;
}
while(Size);
}
 
void TxNchar(unsigned char *strText)
{
while(*strText)
{
switch(*strText)
{
   case'n':
case'r':
strText++;
TxChar(0x0D);
TxChar(0x0A);
continue;
   default :
TxChar(*strText);
}
strText++;
}
}
 
void Write_USART(char *Str, ...)
{
    unsigned char String[128];
 
va_list arg_ptr;
va_start(arg_ptr, Str);
    vsprintf((char *)String, Str, arg_ptr);
va_end(arg_ptr);
 
TxNchar((unsigned char *)&String);
}
#endif

********************Calculator File********************
#define E1004// Using E1004 type development stick
#define F_CPU8000000UL// Internal 8 MHz oscillator
#define LCD_PORT(_)_ ## B// LCD connected to PORT B
#define USARTON// USART communication over USB is being used
#define USART_BAUDRATE19200// At 19200 bps speed
 
#include "Header.h"
 
#define DIV'/'
#define MUL'*'
#define ADD'+'
#define SUB'-'
 
// Structure for equation string stack
typedef struct Char_Stack
{
unsigned charValue;
struct Char_Stack*Next;
};
 
// Structure for equation numbers' stack
typedef struct Float_Stack
{
floatValue;
struct Float_Stack*Next;
};
 
// Structure for FIFO Queue
typedef struct Float_Q
{
floatValue;
struct Float_Q*Next;
};
 
struct Float_Q *Front = NULL, *Rear = NULL;
 
// Adds given no. to the Queue
unsigned char AddQ(float Num)
{
struct Float_Q *Temp;
Temp = (struct Float_Q*)malloc(sizeof(struct Float_Q));
 
if(Temp == NULL)
return 0;
else
{
Temp->Value = Num;
Temp->Next  = NULL;
 
if(Front == NULL)
Rear = Front = Temp;
else
{
Rear->Next = Temp;
Rear = Rear->Next;
}
 
return 1;
}
}
 
// Removes first no. from the Queue and returns the value to calling function
float DeleteQ()
{
float Value;
struct Float_Q *Temp;
 
if(Front == NULL)
return 0;
else
{
Value = Front->Value;
Temp  = Front;
Front = Front->Next;
free(Temp);
 
return Value;
}
}
 
// Pushes a character to character equation stack
unsigned char Push_Char(struct Char_Stack **Top, unsigned char ch)
{
struct Char_Stack *Temp;
Temp = (struct Char_Stack*)malloc(sizeof(struct Char_Stack));
 
if(Temp == NULL)
return 0;
else
{
Temp->Value = ch;
Temp->Next  = *Top;
*Top = Temp;
 
return 1;
}
}
 
// Pops a character from character equation stack and returns value to calling function
unsigned char Pop_Chr(struct Char_Stack **Top)
{
unsigned char Value;
struct Char_Stack *Temp;
 
if(*Top != NULL)
{
Temp  = *Top;
Value = Temp->Value;
*Top  = Temp->Next;
free(Temp);
}
else
Value = 0;
 
return Value;
}
 
// Checks if the stack is empty and returns TRUE / FALSE accordingly
inline unsigned char IsEmpty(struct Char_Stack **Top)
{
return(*Top == NULL);
}
 
// Pushes a number to equation stack
unsigned char Push_Dbl(struct Float_Stack **Top, float Num)
{
struct Float_Stack *Temp;
Temp = (struct Float_Stack*)malloc(sizeof(struct Float_Stack));
 
if(Temp == NULL)
return 0;
else
{
Temp->Value = Num;
Temp->Next  = *Top;
*Top = Temp;
 
return 1;
}
}
 
// Pops a number from equation stack and returns value to calling function
float Pop_Dbl(struct Float_Stack **Top)
{
float Value;
struct Float_Stack *Temp;
 
if(*Top != NULL)
{
Temp = *Top;
Value = Temp->Value;
*Top  = Temp->Next;
free(Temp);
}
else
Value = 0;
 
return Value;
}
 
// Performs requested operation between two supplied numbers and returns answer to calling function
float Binary_Operate(float Operand1, float Operand2, unsigned char Operation)
{
switch(Operation)
{
case DIV: return(Operand1 / Operand2);
case MUL: return(Operand1 * Operand2);
case ADD: return(Operand1 + Operand2);
case SUB: return(Operand1 - Operand2);
}
 
return 0;
}
 
// Checks if the character supplied is operator or not, returns TRUE / FALSE
inline unsigned char IsOperator(unsigned char chr)
{
return(chr == ADD || chr == SUB || chr == MUL || chr == DIV);
}
 
// Defines and returns precedence of each operator, higher the precedence higher the number (follows BoDMAS rule)
unsigned char Value(unsigned char Opt)
{
switch(Opt)
{
case DIV: return 4;
case MUL: return 3;
case ADD: return 1;
case SUB: return 1;
}
 
return 0;
}
 
// Applies postfix algorithm to equation string and returns postfixed string to calling function
unsigned char *PostFix(unsigned char *Expr)
{
static struct Char_Stack *opStk = NULL;
unsigned char *Post = NULL;
unsigned char index = 0;
unsigned char Temp;
 
Post = (unsigned char *)malloc(strlen((char *)Expr) + 2);
 
while(*Expr)
{
if(isalpha(*Expr))
Post[index++] = *Expr;
 
if(*Expr == '(')
Push_Char(&opStk, *Expr);
 
if(*Expr == ')')
{
if(!IsEmpty(&opStk))
{
while(!IsEmpty(&opStk))
{
Temp = Pop_Chr(&opStk);
if(Temp == '(')
break;
Post[index++] = Temp;
}
}
}
 
if(IsOperator(*Expr))
{
if(!IsEmpty(&opStk))
{
Temp = Pop_Chr(&opStk);
 
if(IsOperator(Temp))
{
if(Value(Temp) < Value(*Expr))
{
Push_Char(&opStk, Temp);
Push_Char(&opStk, *Expr);
}
else
{
Post[index++] = Temp;
Push_Char(&opStk, *Expr);
}
}
else
{
Push_Char(&opStk, Temp);
Push_Char(&opStk, *Expr);
}
}
else
Push_Char(&opStk, *Expr);
}
 
Expr++;
}
 
while(!IsEmpty(&opStk))
Post[index++] = Pop_Chr(&opStk);
 
Post[index] = NULL;
 
return Post;
}
 
// Converts user supplied character string into token based alphabetical string for easement of calculations
unsigned char *Convert(unsigned char *Expr)
{
unsigned char *nExpr = NULL;
unsigned char Alpha  = 'A';
 unsigned char *Temp = (unsigned char *)calloc(25, 1);
 
unsigned char index  = 0;
unsigned char tindex = 0;
unsigned char hasPoint = FALSE;
 
nExpr = (unsigned char *)malloc(strlen((char *)Expr) + 2);
 
while(*Expr)
{
if(isdigit(*Expr) || *Expr == '.')
{
if(tindex == 0)
nExpr[index++] = Alpha++;
 
if(*Expr == '.')
hasPoint = TRUE;
 
Temp[tindex++] = *Expr;
}
else
if(*Expr == ')' || *Expr == '(')
nExpr[index++] = *Expr;
else
if(IsOperator(*Expr))
{
nExpr[index++] = *Expr;
 
if(hasPoint == FALSE)
{
Temp[tindex++] = '.';
Temp[tindex] = '0';
}
 
AddQ(strtod((char *)Temp, (char **)NULL));
 
memset(Temp, 0, sizeof(Temp));
tindex = 0;
hasPoint = FALSE;
}
 
Expr++;
}
 
if(hasPoint == FALSE)
{
Temp[tindex++] = '.';
Temp[tindex] = '0';
}
 
AddQ(strtod((char*)Temp, (char**)NULL));
nExpr[index] = NULL;
 
free(Temp);
 
return nExpr;
}
 
// Calculates answer to any given expression and returns the final answer
float Calculate(unsigned char *Expr)
{
static struct Float_Stack *opStk = NULL;
 
float Answer = 0;
float Operator1, Operator2;
 
// Convert the expression into alphabetical string for easement in evaluation
Expr = Convert(Expr);
 
// Convert the expression string into postfix notation
Expr = PostFix(Expr);
 
// Perform calculations
while(*Expr)
{
if(isalpha(*Expr))
Push_Dbl(&opStk, DeleteQ());
else
if(IsOperator(*Expr))
{
Operator2 = Pop_Dbl(&opStk);
Operator1 = Pop_Dbl(&opStk);
 
Answer = Binary_Operate(Operator1, Operator2, *Expr);
 
Push_Dbl(&opStk, Answer);
}
 
Expr++;
}
 
// Final answer
Answer = Pop_Dbl(&opStk);
 
return Answer;
}
 
int main()
{
static unsigned char Expr[255];
float Ans;
 
Init_LCD();
LCD_Backlight(ON);
 
while(1)
{
// Read user input from serial terminal until '=' sign does not appear
RxNchar(Expr, sizeof(Expr) - 1, '=');
 
// Switch OFF the LCD backlight and evaluate expression for final answer
LCD_Backlight(OFF);
Ans = Calculate((unsigned char *)Expr);
 
// Write final answer to the serial terminal as well as on LCD screen
Clear_LCD();
Write_USART("%s%.4fn", Expr, Ans);
Write_LCD(1, 1, "%16sn%16.4f", Expr, Ans);
 
// Clear the input string for next operation and turn ON the LCD backlight
memset(Expr, 0, sizeof(Expr));
LCD_Backlight(ON);
}
}
 
 
###