UART Communication using PIC Code




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.UART Communication using PIC Code

Library Routines

  • UARTx_Init
  • UARTx_Data_Ready
  • UARTx_Tx_Idle
  • UARTx_Read
  • UARTx_Read_Text
  • UARTx_Write
  • UARTx_Write_Text
  • UART_Set_Active

Generic Routines

  • UART_Data_Ready
  • UART_Tx_Idle
  • UART_Read
  • UART_Read_Text
  • UART_Write
  • UART_Write_Text

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

  • _data: data to be sent
Requires UART HW module must be initialized and communication established before using this function.
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.
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 :

  • read_ptr: UARTx_Read handler
  • write_ptr: UARTx_Write handler
  • ready_ptr: UARTx_Data_Ready handler
  • tx_idle_ptr: UARTx_Tx_Idle handler
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.
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.
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.
Example
// If data is ready, read it:
if (UART_Data_Ready() == 1) { 
 receive = UART_Read();
 }

UART Communication using PIC Code schematichUART_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.
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 
 }
}

 

 

For more detail: UART Communication using PIC Code




Leave a Comment

*
= 5 + 3

Read previous post:
Find the right solder for you

The solder matters, it is an undisputable fact confirmed daily in a development and production of electronics. Hand soldering of...

Close
Scroll to top