First, a quick history of RS232. What is RS232? It's just a name for a standard that has propagated from generation to generation of computers. The first computers had serial ports that used RS232, and even current computers have serial ports (or at least USB ports that act like RS232 ports). Back in the day, serial information needed to be passed from devices like printers, joysticks, scanners, etc to the computer. The simplest way to do this was to pass a series of 1s and 0s to the computer. Both the computer and the device agreed on a speed of information - 'bits per second'. A computer would pass image data to a printer at 9600 bits per second and the printer would listen for this stream of 1s and 0s expecting a new bit every 1/9600 = 104us (104 micro-seconds, 0.000104 seconds). As long as the computer output bits at the pre-determined speed, the printer could listen.
Zoom forward to today. Electronics have changed a bit. Before they were relatively high power, high voltage devices. The standard that is 'RS232' dictates that a bit ranges from -12V to +12V. Modern electronics do not operate at such high positive and negative voltages. In fact, our PIC runs 0V to 5V. So how do we get our 5V micro to talk the RS232 +/-12V voltages? This problem has been solved by the IC manufacturers of the world. They have made an IC that is generically known as the MAX232 (very close to RS232, no?).
The MAX232 is an IC originally designed by a company called Maxim IC that converts the +/-12V signals of RS232 down to the 0/5V signals that our PIC can understand. It also boosts the voltage of our PIC to the needed +/-12V of the RS232 protocol so that a computer can understand our PIC and vice versa. To get our PIC IC sending serial characters to a computer, we have to send these serial signals through a MAX232 circuit so that the computer receives +/-12V RS232 signals. Don't worry if you're working with a chip labeled 'ICL232' or 'ST232' - these are just generics of the MAX232. Everyone says 'MAX232'. The ICs all function the same and nearly all have the same pinout.
Circuit
UART Library
The UART hardware module is available with a number of PIC compliant MCUs. The mikroC PRO for PIC UART Library provides comfortable work with the Asynchronous (full duplex) mode.
You can easily communicate with other devices via RS-232 protocol (for example with PC, see the figure at the end of the topic – RS-232 HW connection). You need a PIC MCU with hardware integrated UART, for example 16F887. Then, simply use the functions listed below.
Important :
- UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 1 to 2.
- Switching between the UART modules in the UART library is done by the UART_Set_Active function (UART modules have to be previously initialized).
- Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Library Routines
Generic Routines
UARTx_Init
Prototype
|
void UARTx_Init(const unsigned long baud_rate);
|
Returns
|
Nothing.
|
Description
|
Initializes desired hardware UART module with the desired baud rate. Refer to the device data sheet for baud rates allowed for specific Fosc. If you specify the unsupported baud rate, compiler will report an error.
|
Requires
|
You need PIC MCU with hardware UART.
UARTx_Init needs to be called before using other functions from UART Library.
Parameters :
- baud_rate: requested baud rate
Refer to the device data sheet for baud rates allowed for specific Fosc.
Note : Calculation of the UART baud rate value is carried out by the compiler, as it would produce a relatively large code if performed on the library level.
Therefore, compiler needs to know the value of the parameter in the compile time. That is why this parameter needs to be a constant, and not a variable.
|
Example
|
// Initialize hardware UART1 and establish communication at 9600 bps
UART1_Init(9600);
|
UARTx_Data_Ready
Prototype
|
char UARTx_Data_Ready();
|
Returns
|
- 1 if data is ready for reading
- 0 if there is no data in the receive register
|
Description
|
Use the function to test if data in receive buffer is ready for reading.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
// If data is ready, read it:
if (UART1_Data_Ready() == 1) {
receive = UART1_Read();
}
|
UARTx_Tx_Idle
Prototype
|
char UARTx_Tx_Idle();
|
Returns
|
- 1 if the data has been transmitted
- 0 otherwise
|
Description
|
Use the function to test if the transmit shift register is empty or not.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
// If the previous data has been shifted out, send next data:
if (UART1_Tx_Idle() == 1) {
UART1_Write(_data);
}
|
UARTx_Read
Prototype
|
char UARTx_Read();
|
Returns
|
Returns the received byte.
|
Description
|
Function receives a byte via UART. Use the function UARTx_Data_Ready to test if data is ready first.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
// If data is ready, read it:
if (UART1_Data_Ready() == 1) {
receive = UART1_Read();
}
|
UARTx_Read_Text
Prototype
|
void UARTx_Read_Text(char *Output, char *Delimiter, char Attempts);
|
Returns
|
Nothing.
|
Description
|
Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter output; delimiter sequence is stored in the parameter delimiter.
This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found).
Parameters :
- Output: received text
- Delimiter: sequence of characters that identifies the end of a received string
- Attempts: defines number of received characters in which Delimiter sequence is expected. If Attempts is set to 255, this routine will continuously try to detect the Delimiter sequence.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
Read text until the sequence “OK” is received, and send back what’s been received:
UART1_Init(4800); // initialize UART1 module
Delay_ms(100);
while (1) {
if (UART1_Data_Ready() == 1) { // if data is received
UART1_Read_Text(output, "OK", 10); // reads text until 'OK' is found
UART1_Write_Text(output); // sends back text
}
}
|
UARTx_Write
Prototype
|
void UARTx_Write(char data_);
|
Returns
|
Nothing.
|
Description
|
The function transmits a byte via the UART module.
Parameters :
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
unsigned char _data = 0x1E;
...
UART1_Write(_data);
|
UARTx_Write_Text
Prototype
|
void UARTx_Write_Text(char * UART_text);
|
Returns
|
Nothing.
|
Description
|
Sends text via UART. Text should be zero terminated.
Parameters :
- UART_text: text to be sent
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
Read text until the sequence “OK” is received, and send back what’s been received:
UART1_Init(4800); // initialize UART1 module
Delay_ms(100);
while (1) {
if (UART1_Data_Ready() == 1) { // if data is received
UART1_Read_Text(output, "OK", 10); // reads text until 'OK' is found
UART1_Write_Text(output); // sends back text
}
}
|
UART_Set_Active
Prototype
|
void UART_Set_Active(char (*read_ptr)(), void (*write_ptr)(unsigned char data_), char (*ready_ptr)(), char (*tx_idle_ptr)())
|
Returns
|
Nothing.
|
Description
|
Sets active UART module which will be used by the UART library routines.
Parameters :
|
Requires
|
Routine is available only for MCUs with two UART modules.
Used UART module must be initialized before using this routine. See UARTx_Init routine
|
Example
|
UART1_Init(9600); // initialize UART1 module
UART2_Init(9600); // initialize UART2 module
RS485Master_Init(); // initialize MCU as Master
UART_Set_Active(&UART1_Read, &UART1_Write, &UART1_Data_Ready, &UART1_Tx_Idle); // set UART1 active
RS485Master_Send(dat,1,160); // send message through UART1
UART_Set_Active(&UART2_Read, &UART2_Write, &UART2_Data_Ready, &UART2_Tx_Idle); // set UART2 active
RS485Master_Send(dat,1,160); // send through UART2
|
UART_Data_Ready
Prototype
|
char UART_Data_Ready();
|
Returns
|
- 1 if data is ready for reading
- 0 if there is no data in the receive register
|
Description
|
Use the function to test if data in receive buffer is ready for reading.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
// If data is ready, read it:
if (UART_Data_Ready() == 1) {
receive = UART_Read();
}
|
UART_Tx_Idle
Prototype
|
char UART_Tx_Idle();
|
Returns
|
- 1 if the data has been transmitted
- 0 otherwise
|
Description
|
Use the function to test if the transmit shift register is empty or not.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
// If the previous data has been shifted out, send next data:
if (UART_Tx_Idle() == 1) {
UART_Write(_data);
}
|
UART_Read
Prototype
|
char UART_Read();
|
Returns
|
Returns the received byte.
|
Description
|
Function receives a byte via UART. Use the function UART_Data_Ready to test if data is ready first.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
// If data is ready, read it:
if (UART_Data_Ready() == 1) {
receive = UART_Read();
}
|
UART_Read_Text
Prototype
|
void UART_Read_Text(char *Output, char *Delimiter, char Attempts);
|
Returns
|
Nothing.
|
Description
|
Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter output; delimiter sequence is stored in the parameter delimiter.
This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found).
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters :
- Output: received text
- Delimiter: sequence of characters that identifies the end of a received string
- Attempts: defines number of received characters in which Delimiter sequence is expected. If Attempts is set to 255, this routine will continuously try to detect the Delimiter sequence.
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
Read text until the sequence “OK” is received, and send back what’s been received:
UART1_Init(4800); // initialize UART1 module
Delay_ms(100);
while (1) {
if (UART_Data_Ready() == 1) { // if data is received
UART_Read_Text(output, "OK", 10); // reads text until 'OK' is found
UART_Write_Text(output); // sends back text
}
}
|
UART_Write
Prototype
|
void UART_Write(char data_);
|
Returns
|
Nothing.
|
Description
|
The function transmits a byte via the UART module.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters :
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
unsigned char _data = 0x1E;
...
UART_Write(_data);
|
UART_Write_Text
Prototype
|
void UART_Write_Text(char * UART_text);
|
Returns
|
Nothing.
|
Description
|
Sends text via UART. Text should be zero terminated.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Parameters :
- UART_text: text to be sent
|
Requires
|
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
|
Example
|
Read text until the sequence “OK” is received, and send back what’s been received:
UART1_Init(4800); // initialize UART1 module
Delay_ms(100);
while (1) {
if (UART_Data_Ready() == 1) { // if data is received
UART_Read_Text(output, "OK", 10); // reads text until 'OK' is found
UART_Write_Text(output); // sends back text
}
}
|
This program demonstrates a simple data exchange via UART. When PIC MCU receives data, it immediately sends it back. If PIC is connected to the PC (see the figure below), you can test the example from the mikroC PRO for PIC terminal for RS-232 communication, menu choice Tools › Terminal.
Code
char uart_rd;
void main() {
ANSEL = 0; // Configure AN pins as digital
ANSELH = 0;
UART1_Init(9600); // Initialize UART module at 9600 bps
Delay_ms(100); // Wait for UART module to stabilize
UART1_Write_Text("Start");
UART1_Write(10);
UART1_Write(13);
while (1) { // Endless loop
if (UART1_Data_Ready()) { // If data is received,
uart_rd = UART1_Read(); // read the received data,
UART1_Write(uart_rd); // and send data via UART
}
}
}
Check Our New Blog: Embedded Projects-Tutorials-Arduino-Android-Raspberry PI- Gadgets News - Embedded Hackes - New Embedded Products Intro etc
(click the Image Below to Visit the Blog)
See Also
