ELECTRONICS - [RS-232 Interface] - [page 3/4]

RS-232 Computer Interface

The communication protocol

I have implemented a basic communication protocol to communicate with the PIC. The computer will need to send a request frame to the microcontroller. Such request frame must contain 4 or more bytes:

byte 1: start byte to indicate the start. This is always the hexadecimal number 0xF0.
byte 2: byte containing the number of data bytes that will be transmitted. Each data byte controls 8 outputs, so to control 15 outputs you will need 15 bytes.
byte 3 - byte 18: the actual data bytes.
last byte: the last byte contains the checksum of the data packet. This checksum is calculated by adding the contents of all previous bytes together. Then a modulo 256 operation is executed.

The following image shows a sample request that is transmitted from the PC to the PIC controller. In this example three data bytes are transmitted, to control 24 different outputs. The checksum is 0xF6 (0xF0 + 0x03 + 0x01 + 0x01 + 0x01 = 0xF6. Please notice the modulo 256 operation has no effect here).

The PIC microcontroller will always respond with a single byte. The response can either be 0x0F in case when the command was executed, or 0xF0 when there was a communication problem (wrong packet size, wrong checksum).

The PIC's firmware

As with most of my PIC designs, the software was written in the High-Tech C lite programming environment. You can find the source code at the end of this page.

I used the PIC's built-in USART to receive the serial data. Each time a data byte is received, the interrupt handler will be called. This handler will then add the data to a buffer. I used a pointer to indicate where the next data byte should be stored. By default 20 RAM bytes are reserved to be used for the buffer. Once the buffer is filled completely no more data will be added.

The image below illustrates the buffer that is used to store all received data. After the reception of a byte it is stored in the address that is pointed to by the pointer. Then the pointer is increased to the next address.

byte 1 contains the number of data bytes that are being used (the number of shift registers in the circuit). The program will use this number to calculate the length of the complete request frame: length = data bytes + 3. (1 start byte + 1 data length byte + 1 checksum byte). The processing of the data will begin as soon as the required number of bytes are received. During this processing the checksum is verified. After a positive verification the bytes will be transmitted to the shift registers, bit by bit.

It could happen the transmission of a request packet gets interrupted. In this case the data inside the buffer will become invalid: the pointer will point to an invalid location. I have used the PIC's timer to prevent this: it will reset/clear the buffer when the data remains there for too long.

The firmware

Here you can find the High-Tech source code for my project. Please notice the firmware is not confirmed under all circumstances yet. Some bugs might still exist.

/******************************************************************** * RS-232 Computer Interface Board * Copyright (c) 2012 - Vanderhaegen Bart, bvsystems.be * * * This firmware allows the PIC to receive RS-232 signals from a * computer. The PIC will decode the received data packets and * transmit the data to one or more 74x595 output shift registers. * * Any data is validated by a checksum. ********************************************************************/ #include <htc.h>; // definition of program behavior #define MAX_DATA_PACKETS 20 #define _XTAL_FREQ 19668000 // other definitions #define true 1 #define false 0 #define MSG_OK 0x0F #define MSG_ERR 0xF0 // definition of hardware I/O ports #define LED_ERR RB0 #define LED_DATA RB4 #define DATA RB3 #define CLOCK1 RB5 #define CLOCK2 RB6 // definitions of the data packets char packets[MAX_DATA_PACKETS+1]; // packet char *packetPntr; // pointer to current index char cycleKeeper=0; // time-out aider variable // Function prototypes void interrupt irq(void); void sendToBuffers(char *ptrDataByte,char numberOfDataBytes); void clearAllOutputs(); void initData(void); void initUART(void); void flashyLED(void); bit isDataValid(char *data,char numberOfDataBytesToReceive); void main(void); void transmitResponse(char returnCode); /******************************************************************** * Interrupt Handler * Puts the received data into the packets buffer, and handles * the time-out event. ********************************************************************/ void interrupt irq(void) { if (TMR1IF) { // timer overflow: data time-out detected static char cycleKeeper=0; if (cycleKeeper++>10) { cycleKeeper=0; initData(); } TMR1IF=0; } if (RCIF) { // data received. First we need to analyze if the if (FERR) { // A framing error occured. LED_ERR=1; FERR=0; } else if (OERR) { // An overrun error occured LED_ERR=1; CREN=0; CREN=1; } else { // The received byte was OK cycleKeeper=0; // reset time-out while(RCIF) { // read the RCREG as long as the RCIF is "1". *packetPntr=RCREG; // Set output LEDs LED_DATA=!LED_DATA; if ((packetPntr-packets)<MAX_DATA_PACKETS-1) { packetPntr++; } // end if ((packetPntr-packets)<MAX_DATA_PACKETS-1) } // end while(RCIF) } // end if (FERR==1) } // end if (RCIF) } /******************************************************************** * Shift Register Controllers * These functions will control the outputs of the shift registers. ********************************************************************/ // send a certain number of databytes to the shift registers void sendToBuffers(char *ptrDataByte,char numberOfDataBytes) { for (char byteCnt=0;byteCnt<numberOfDataBytes;byteCnt++) { for (char bitCnt=0;bitCnt<8;bitCnt++) { // Set data and increase pointer DATA=((*ptrDataByte)&0x01==0x01); *ptrDataByte=(*ptrDataByte)>>1; // Generate shift clock pulse CLOCK1=1; __delay_us(10); CLOCK1=0; __delay_us(10); } ptrDataByte++; } // Send data to output registers CLOCK2=1; __delay_us(10); CLOCK2=0; __delay_us(10); } // clear all the ouptuts void clearAllOutputs() { DATA=0; for (char byteCounter=0;byteCounter<MAX_DATA_PACKETS;byteCounter++) { CLOCK1=1; CLOCK1=0; } CLOCK2=1; CLOCK2=0; } /******************************************************************** * Data Handling * This code is written for a 9600 baud communication ********************************************************************/ // Reset the incoming databuffer void initData(void) { // clearing the data is not necessary packetPntr=packets; } // This function will validate our data bit isDataValid(char *data,char numberOfDataBytesToReceive) { if (*data==0xF0) { // valid start byte int checksum=*data; for (char i=0;i<numberOfDataBytesToReceive+1;i++) { data++; checksum+=*data; } data++; return ((char)(checksum%256)==*data); } else { // incorrect startbyte return false; } } /******************************************************************** * Communication Initialisation * This code is written for a 9600 baud communication ********************************************************************/ void initUART(void) { SPBRG=31; // baud rate generator register BRGH=0; // Enable high baud-rate // Enable asynchronous communication SYNC=0; // Asynchronous mode SPEN=1; // Enable serial port TRISB1=1; // Required by UART (datasheet) TRISB2=1; // Required by UART (datasheet) // Enable 8-bit data words TX9=0; RX9=0; // Enable Interrupts RCIE=1; // USART interrupt CREN=1; // Continuous recieve enable bit } // this code will transmit a confirmation code void transmitResponse(char returnCode) { TXREG=returnCode; // set byte TXEN=1; // enable transmission while(TXIF==0); // //TXEN=0; // } /******************************************************************** * LED output controllers * These functions will control the output LEDs ********************************************************************/ // flash the DATA LED 25 times void flashyLED(void) { for (char i=0;i<50;i++) { __delay_ms(50); LED_DATA=!LED_DATA; } LED_DATA=0; } /******************************************** * The main sub of the program * * *******************************************/ void main(void) { // define the PIC's ports TRISA=0x00; TRISB=0b00000110; // clear the output of the shift register(s) clearAllOutputs(); // set timeout timer properties T1CKPS1=1; // prescaler 1:8 T1CKPS0=1; // prescaler 1:8 T1OSCEN=1; // enable oscillator TMR1CS=0; // use internal clock TMR1ON=1; // enable timer TMR1IE=1; // enable timer interrupt // clear the ports PORTA=0x00; PORTB=0x00; // initialize the data initData(); // setup the RS-232 system initUART(); // test our system flashyLED(); // enable the interrupts PEIE=1; // Unmasked periheral interrupts (timer/USART) ei(); // here our actual programloop will begin while (true) { char *receiveBuffer=packets; // pointer to buffer if ((packetPntr-receiveBuffer)>1) { // number of bytes is received receiveBuffer++; char numberOfDataBytesToReceive=*receiveBuffer; if ((packetPntr-receiveBuffer)==numberOfDataBytesToReceive+2) { // we have what we needed receiveBuffer++; if(isDataValid(packets,numberOfDataBytesToReceive)) { // the data is valid sendToBuffers(receiveBuffer,numberOfDataBytesToReceive); LED_ERR=0; transmitResponse(MSG_OK); } else { // the data is invalid LED_ERR=1; transmitResponse(MSG_ERR); } // reinitialize the data initData(); } } // end if ((packetPntr-receiveBuffer)>1) } // while (true) }