//Peter Greczner - pag42@cornell.edu
//Matthew Rosoff - msr53@cornell.edu

#include <mega32.h>  
#include "constants_32.h"
#include <stdio.h>               
#include <delay.h>
#include "fingerprintSPI.h"


#define USART_BUFFER_SIZE 1520
#define ADDRH PORTA
#define ADDRL PORTC      



#pragma regalloc-
#pragma warn-
register unsigned int address @4;
register unsigned char address_high @5;
register unsigned char address_low @4;
register unsigned char data @7;
#pragma warn+
#pragma regalloc+     

unsigned char checkSum;
unsigned char id_code[7] = {0,0,0,0,0,0,0};
unsigned char id_index = 0;


     
unsigned char usart_baudrate(float br,float fosc){
        return fosc*125000/br-1;        
}

//Drivc=127 ADCREF=2


void USART_Transmit(unsigned int data)
{                                    
        
        while(!(UCSRA & (1 <<UDRE)));
        UDR = data;    
        
        
}

void USART_Send_Command( unsigned char command[], char length)
{  
        int j = 0;                
   checkSum = 0b00000000;
   
   
   for(j = 0; j<length; j ++)
   {
        checkSum ^= command[j];
        USART_Transmit(command[j]);
   }                           
   USART_Transmit(checkSum);
   
}

void main(void)
{       

int i = 0;
unsigned int count=0;
unsigned char x=0;
unsigned char row = 0, col = 0;  
unsigned char command[153]; 
unsigned char time1,time2=0;      
unsigned char timeOut;
unsigned char retValue;  
unsigned char reg=0;
unsigned long int mean;
unsigned char retSPDR;
DDRB=0xB0;//MOSI,SCK,SS' are output
PORTB|=0x10;//Set CS'=1

          //serial setop for debugging using printf, etc.     
        UCSRB = 0x18 ;             //transmit and receive enable
        UBRRL = 3 ;//clk = 14.74566MHz and bps = 230.4k
       // putsf("\r\nStarting...\r\n"); 
        TCCR0|=(1<<CS00);
        SPCR|=(1<<SPE)|(1<<MSTR)|(1<<SPR1);
        //SPSR|=(1<<SPI2X);

//#define DATA
//Data low nibble on port B0-B3
//Data high nibble on port D4-D7
//OE' on D2 and WE' D3
PORTD = 0b00001100;//Start out with WE' and OE' high 
DDRA=0xff;
DDRC=0xFF;     


//Code for writing to SRAM which was taken out after the LCD was non-functional, includes SPI functionality that was deprecated
/*
//Set up SPI
while(1){

initSPI();

while(!(SPSR&0x80));
SPDR=rd_sensor;

while(!(SPSR&0x80));
SPDR=dummy_byte_n;




while(!(SPSR&0x80));


while(!(reg&0x01)){//Wait for image to be read
        
        SPDR=rd_spistat;

        while(!(SPSR&0x80));
        SPDR=dummy_byte_n;
  
        while(!(SPSR&0x80));
        SPDR=dummy_byte_n;
              
        while(!(SPSR&0x80));
        reg=SPDR;
        count++;
        //printf("reg: 0x%x\r\n",reg);
        
}


printf("Count: %d",count);
SPDR=rd_spidata;
while(!(SPSR&0x80));
SPDR=dummy_byte_n;
while(!(SPSR&0x80));

//Set up for SRAM write
DDRB|=0x0F;
DDRD|=0xF0;
address=0;

SPDR=dummy_byte_n;
while(!(SPSR&0x80));
SPDR=dummy_byte_n;
while(!(SPSR&0x80));

data=SPDR;


//now we can start the reading
for(row=0;row<200;row++){
        for(col=0;col<152;col++){
                SPDR=dummy_byte_n;
                //SRAM write
                UDR=data;
                ADDRH=address_high;//Are we in big endian or little endian?
                ADDRL=address_low;//Load Address
                PORTB|=data&0x0F;//Load Data
                PORTD|=data&0xF0;
                PORTD&=0b11110111;//Strobe WE' 
                PORTD|=0b00001100;//Back to WE'=1 and OE'=1
                address++;

                while(!(SPSR&0x80));
                
                data=SPDR;
                //data_buffer[row][col]=data;//Read in the byte
                while(!(UCSRA&0x20));//Wait for the byte to be sent over rs-232
         }
}
PORTB.4=1;//Set CS'=1
}//Cut out pete's code


//Write- this is the SRAM write procedure
/*
DDRB|=0x0F;
DDRD|=0xF0;
//TCNT0=0;
ADDRH=address_high;//Are we in big endian or little endian?
ADDRL=address_low;//Load Address
PORTB|=data&0x0F;//Load Data
PORTD|=data&0xF0;
PORTD&=0b11110111;//Strobe WE' 
PORTD|=0b00001100;//Back to WE'=1 and OE'=1
//time1=TCNT0;
*/

/*
//Read
DDRB&=0xF0;
DDRD&=0x0F;
PORTB&=0xF0;
PORTD&=0x0F;
ADDRH=address_high;//Are we in big endian or little endian?
ADDRL=address_low;//Load Address
PORTD&=0b11111011;//Strobe OE'

data=(PINB&0x0F)|(PIND&0xF0);//Read data

time2=TCNT0;
PORTD|=0b00001100;//Back to WE'=1 and OE'=1   
*/



                       
        
        
        
while(1)
        {
        
         
        while( !(UCSRA & (1<<RXC)) ); //Wait for the usart to read in a value from the PC, for the testing scope of this project
                retValue = UDR;
                                     
        //Wait for the PC to allow us to send
                                           
        
        
        while(id_index == 0)
        {
                //Chip Select Keypad
                PORTB.4=0;//Set CS'=0
                PORTA.7=1;
        
                
                SPDR = 'r';       //send to slave a request
                while(!(SPSR&0x80));//Make sure we have transmitted master stuff before we read slave stuff
                retSPDR = SPDR;    //get answer from slave    
                printf("retSPDR: %x\r\n",retSPDR);
               
                
                if(retSPDR == 'y') //if the slave returns a YES we want to send a code 
                {       
                        
                        id_index = 0;
                        while(id_index < 7)
                        {                     
                             
                                SPDR = 'c';//Dummy byte for request
                                while(!(SPSR&0x80));//wait for transmission before reading
                                retSPDR = SPDR;//get the id number at index id_index
                                //store the code
                                id_code[id_index] = retSPDR;
                              
                                id_index ++;
                                
                        }                                
                        
                                                 
                }
                else //the slave does not want to send a code
                {
                        //try again
                        id_index = 0;    
                        
                }
        }        
        
        
                        for(id_index = 0; id_index<7; id_index ++)
                        {
                                     //debugging printing
                                printf("%d,",id_code[id_index]);
                        }                              
                        id_index = 0;
                                   
        
        initSPI();
        
            
                        
        
           
        
        
        printf("starting");     
        printf("----"); //4 characters in a row iniates the image capturing process on the PC client side              
        
        
        while(!(SPSR&0x80));
        SPDR=rd_sensor;

        while(!(SPSR&0x80));
        SPDR=dummy_byte_n;



        
        while(!(SPSR&0x80));

       reg=0;
        while(!(reg&0x01)){//Wait for image to be read
        
                SPDR=rd_spistat;

                while(!(SPSR&0x80));
                SPDR=dummy_byte_n;
  
                while(!(SPSR&0x80));
                SPDR=dummy_byte_n;
              
                while(!(SPSR&0x80));
                reg=SPDR;
                
        
        }

          
        SPDR=rd_spidata;
        while(!(SPSR&0x80));
        SPDR=dummy_byte_n;
        while(!(SPSR&0x80));//dummy paramter

        //Set up for SRAM write
        DDRB|=0x0F;
        DDRD|=0xF0;
        address=0;

        
        
        SPDR=dummy_byte_n;
        while(!(SPSR&0x80));

        data=SPDR;//get first data byte
                //DDRB &=0xEF; 
                        do{      
                                //Comand so that the Client PC recognizes the data is coming and who it is coming from
                                sprintf(command,"SEND%x%x%x%x%x%x%x",id_code[0],id_code[1],id_code[2],id_code[3],id_code[4],id_code[5],id_code[6]);
                                USART_Send_Command(command,152);
                                       
                                //Wait to receive an acknolowdgment
                                while( !(UCSRA & (1<<RXC)) );      
                                retValue = UDR;
                        }while(retValue != 'G');
          
                        for(row = 0; row<200; row += 20)
                        {     
                                
                                
                                        for(i = 0; i<20; i ++)
                                        {                                                
                                               checkSum=0;
                                                for(col = 0; col<152; col ++)
                                                {
                                                        if(row==180&&i==19&&col==151){
                                                           UDR=data;
                                                           mean+=data;             
                                                           checkSum ^= data;
                                                           ADDRH=address_high;//Are we in big endian or little endian?
                                                           ADDRL=address_low;//Load Address
                                                           PORTB=(PINB&0xF0)&(data&0x0F);//Load Data
                                                           PORTD=(PIND&0x0F)&(data&0xF0);
                                                           PORTD&=0b11110111;//Strobe WE' 
                                                           PORTD|=0b00001100;//Back to WE'=1 and OE'=1
                                                           address++;
                                                           while(!(UCSRA&0x20));//Wait for the byte to be sent over rs-232
                                                        }
                                                        else{
                                                                SPDR=dummy_byte_n;
                                                                //SRAM write
                                                                UDR=data;
                                                                mean+=data;
                                                                checkSum ^= data;
                                                                ADDRH=address_high;//Are we in big endian or little endian?
                                                                ADDRL=address_low;//Load Address
                                                                PORTB=(PINB&0xF0)&(data&0x0F);//Load Data
                                                                PORTD=(PIND&0x0F)&(data&0xF0);//high nibble
                                                                PORTD&=0b11110111;//Strobe WE' 
                                                                PORTD|=0b00001100;//Back to WE'=1 and OE'=1
                                                                address++;
                                                                while(!(SPSR&0x80));                
                                                                data=SPDR;                                                        
                                                                while(!(UCSRA&0x20));//Wait for the byte to be sent over rs-232
                                                        }

                                                        
                                                        
                                                        
                                                }
                                                //Insert checksum here
                                                UDR=checkSum;
                                                while(!(UCSRA&0x20));//Wait for the byte to be sent over rs-232                          
                                                
                                        }                  
                                                //Wait for the PC to acknoledge no errors
                                        while( !(UCSRA & (1<<RXC)) );      
                                        retValue = UDR;
                               
                                 
                        }
                        
                        mean=mean/30400;
                        PORTB.4=1;//Set CS'=1           
                        PORTA.7=1;

                   
        }           
           
}