PIC 18f1220 EUSART Baud Rate Cache Problem

Thread Starter


Joined Apr 14, 2008
I'm in the middle of a project I've been working on for about 3 weeks.
What I have is an ID-12 RFID reader(http://www.sparkfun.com/commerce/product_info.php?products_id=8419) to read passive RFID tags. The reader outputs at 9600 baud. However, I need to send the data output from the ID-12 reader through a wireless RF transmitter(http://www.sparkfun.com/commerce/product_info.php?products_id=7816) which takes in data at a max of 4800 baud. I am using the built in USART Rx/Tx pins on a PIC 18F1220 to accomplish this cache job. What I am having trouble programming in MPLAB using C language is a routine for setting the baud rate to 9600, receiving all the bits, then changing the baud to 4800, and sending the bits.

I thought we had the send/receive part down in the code and were just using improper SPBRG values, however it turns out we were using the correct SPBRG values but our code was faulty. I know our SPBRG values work properly and our clock source is alright because we wrote tests for the pic which worked both at 9600 baud and 4800 baud. Our old cache code was faulty mainly due to the interrupts that were being used. So we have given up on the interrupt driven USART and have decided to just do a polled while loop. Since all we need the PIC18f1220 for is caching this ID-12 output we decided interrupts are not essential. We spent hours combing through the datasheet and setting values manually but decided to use the usart.h library functions instead. Below is the
code we are trying to get working, however for some reason it is not. If someone would take a look at it and suggest what we are doing wrong I would be very appreciative.

Thanks much, -WK

Specs on project:
PIC: 18f1220
Compiler: C18 C-language compiler used in MPLAB
Computer OS: Windows XP


Rich (BB code):
 * 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
             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;

        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
            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