//*
 * The following application is a cache program for converting a 9600 baud RFID card reader output
 * to 4800 baud so it can be fed into a RFID transmitter input. The clock is 8Mhz, BRGH is 1, and BRG16 is 0.
 * The PIC used is an 18f1220.
 * The progam is compiled in C using the MC18 compiler on a Windows XP laptop.
 */
#include <p18f1220.h>
#include <usart.h>


#pragma config OSC = HS	 //external crystal clocked at 8Mhz
#pragma config WDT = OFF	
#pragma config LVP = OFF

void main (void)
{
	unsigned char c;            //grab the transmitted char in here
	unsigned char myCache[16];	//we will cache the input in here
	unsigned int counter=0;     //This keeps track of which byte were on
	int j = 0;

	//The next 5 initializations are set according to the PIC datasheet
	//requirements for USART recieve/trans

	TRISBbits.TRISB1 = 1;	//TX set to output
	TRISBbits.TRISB4 = 1;   //RX set to 1, but will be set to 0 by PIC for input(as specified in datasheet)
	ADCON1bits.PCFG6 = 1;	//not sure what these next two are, but setting as specified in datasheet
	ADCON1bits.PCFG5 = 1;
	RCSTAbits.SPEN = 1;		//setting serial port enabled
	
	TXSTAbits.SYNC = 0;			//asynchronous mode
//	PIE1.TXIE = 0;

	BAUDCTLbits.BRG16 = 0;	//8 bit transfer
	TXSTAbits.BRGH = 1;		//BRGH high

	TXSTAbits.TXEN = 1;		//enable transmit

  /*
   * Open the USART configured as
   * 8N1, 96000 baud, in polled mode
   */
  OpenUSART (USART_TX_INT_OFF &
             USART_RX_INT_OFF &
             USART_ASYNCH_MODE &
             USART_EIGHT_BIT &
             USART_CONT_RX &
             USART_BRGH_HIGH, 51);   //[8000000/(9600*16)] - 1 = 51

  /* Loop forever */
  while (1)
  {
		//here, we read the USART and store the char in myCache.
		//Once we have read 16 bytes, we have recieved a full RFID tag ID and need to send it out
		//over the transmit.

		c = ReadUSART();
		myCache[counter] = c;
		counter++;

		if(counter >= 15)		    	        //weve read 16 bytes here
		{
			CloseUSART();					    //so we close the USART
	 		 OpenUSART (USART_TX_INT_OFF &	    //and reopen it at 4800 baud
            	 USART_RX_INT_OFF &
            	 USART_ASYNCH_MODE &
            	 USART_EIGHT_BIT &
           	  	 USART_CONT_RX &
            	 USART_BRGH_HIGH, 103);	    	//[8000000/(4800*16)] - 1 = 103
		
			for(j = 0; j<16;j++)                     //in a for loop, we write each char to the output
			{					         //pin of the USART
				WriteUSART(myCache[j]);
			}
			
			counter = 0;		//we set the counter back to 0
			 
			 CloseUSART();					//we then close the USART again
	 		 OpenUSART (USART_TX_INT_OFF &	   //and reopen it back at 9600 baud to
            	 USART_RX_INT_OFF &			         //wait for the next transmission
            	 USART_ASYNCH_MODE &
            	 USART_EIGHT_BIT &
           	  	 USART_CONT_RX &
            	 USART_BRGH_HIGH, 103);		//[8000000/(9600*16)] - 1 = 51
		}
		
  }
}

            for(j = 0; j<16;j++) //in a for loop, we write each char to the output
            { //pin of the USART
                WriteUSART(myCache[counter]);
            }

            for(j = 0; j<16;j++) //in a for loop, we write each char to the output
            { //pin of the USART
                WriteUSART(myCache[j]);
            }

  while (1)
  {
        //here, we read the USART and store the char in myCache.
        //Once we have read 16 bytes, we have recieved a full RFID tag ID and need to send it out
        //over the transmit.

        OpenUSART (USART_TX_INT_OFF &
                 USART_RX_INT_OFF &
                 USART_ASYNCH_MODE &
                 USART_EIGHT_BIT &
                 USART_CONT_RX &
                 USART_BRGH_HIGH, 51);   //[8000000/(9600*16)] - 1 = 51

        for(j = 0; j<16;j++)                     //in a for loop, we write each char to the output
        {                             //pin of the USART
            myCache[j]=ReadUSART();
        }
        CloseUSART();                        //so we close the USART
        OpenUSART (USART_TX_INT_OFF &        //and reopen it at 4800 baud
            USART_RX_INT_OFF &
            USART_ASYNCH_MODE &
            USART_EIGHT_BIT &
            USART_CONT_RX &
            USART_BRGH_HIGH, 103);            //[8000000/(4800*16)] - 1 = 103        
        for(j = 0; j<16;j++)                     //in a for loop, we write each char to the output
        {                             //pin of the USART
            WriteUSART(myCache[j]);
        }        
        CloseUSART();                        //so we close the USART
    }

for(counter = 0; counter <= 15;)
{
	if (DataRdyUSART())
	{
		myCache[counter] = ReadUSART();
		counter++;
	}
}