Skip to main content

An Extra UART For Your PIC


 

Software UART Library


The mikroC PRO for PIC provides routines for implementing Software UART communication. These routines are hardware independent and can be used with any MCU.
The Software UART Library provides easy communication with other devices via the RS232 protocol.
Important : The Software UART library implements time-based activities, so interrupts need to be disabled when using it.

Library Routines






Soft_UART_Init
Prototype
char Soft_UART_Init(char *port, char rx_pin, char tx_pin, unsigned long baud_rate, char inverted);
Returns
  • 2 - error, requested baud rate is too low
  • 1 - error, requested baud rate is too high
  • 0 - successful initialization
Description
Configures and initializes the software UART module.
Parameters :
  • port: port to be used.
  • rx_pin: sets rx_pin to be used.
  • tx_pin: sets tx_pin to be used.
  • baud_rate: baud rate to be set. Maximum baud rate depends on the MCU’s clock and working conditions.
  • inverted: inverted output flag. When set to a non-zero value, inverted logic on output is used.
Software UART routines use Delay_Cyc routine. If requested baud rate is too low then calculated parameter for calling Delay_Cyc exceeds Delay_Cyc argument range.
If requested baud rate is too high then rounding error of Delay_Cyc argument corrupts Software UART timings.
Requires
Nothing.
Example
This will initialize software UART and establish the communication at 14400 bps:
char error;
...
error = Soft_UART_Init(&PORTC, 7, 6, 14400, 0);   // Initialize Soft UART at 14400 bps
Soft_UART_Read
Prototype
char Soft_UART_Read(char * error);
Returns
Byte received via UART.
Description
The function receives a byte via software UART.
This is a blocking function call (waits for start bit). Programmer can unblock it by calling Soft_UART_Break routine.
Parameters :
  • error: Error flag. Error code is returned through this variable.
Requires
Software UART must be initialized before using this function. See the Soft_UART_Init routine.
Example
char data_, error;
...
// wait until data is received
do
  data = Soft_UART_Read(&error);
while (error);

// Now we can work with data:
if (data_) {...}
Soft_UART_Write
Prototype
void Soft_UART_Write(char udata);
Returns
Nothing.
Description
This routine sends one byte via the Software UART bus.
Parameters :
  • udata: data to be sent.
Requires
Software UART must be initialized before using this function. See the Soft_UART_Init routine.
Be aware that during transmission, software UART is incapable of receiving data – data transfer protocol must be set in such a way to prevent loss of information.
Example
char some_byte = 0x0A;
...
// Write a byte via Soft UART
Soft_UART_Write(some_byte);
Soft_UART_Break
Prototype
void Soft_UART_Break();
Returns
Nothing.
Description
Soft_UART_Read is blocking routine and it can block the program flow. Calling this routine from the interrupt will unblock the program execution. This mechanism is similar to WDT.
  Note : Interrupts should be disabled before using Software UART routines again (see note at the top of this page).
Requires
Nothing.
Example
char data1, error, counter = 0;

void interrupt() {

  if (INTCON.T0IF) {
    if (counter >= 20) {
      Soft_UART_Break();
      counter = 0;              // reset counter
    }
    else
      counter++;                // increment counter

    INTCON.T0IF = 0;            // Clear Timer0 overflow interrupt flag

    }
}

void main() {

  OPTION_REG = 0x04;            // TMR0 prescaler set to 1:32

  ...

  if (Soft_UART_Init(&PORTC, 7, 6, 9600, 0) == 0)
    Soft_UART_Write(0x55);

  ...

  // try Soft_UART_Read with blocking prevention mechanism
  INTCON.GIE = 1;               // Global interrupt enable
  INTCON.T0IE = 1;              // Enable Timer0 overflow interrupt
  data1 = Soft_UART_Read(&error);
  INTCON.GIE = 0;               // Global interrupt disable

}



Example Program use two UART

/* This program inputs from on chip UART and output to Soft UART*/



char i, error, byte_read='1',uart_rd='1';                 // Auxiliary variables

void main(){



  TRISB = 0x00;                           // Set PORTB as output (error signalization)
  PORTB = 0; 
  UART1_Init(9600);                             // No error

  error = Soft_UART_Init(&PORTC,1 , 0, 9600, 0); // Initialize Soft UART at 14400 bps
  if (error > 0) {
    PORTB = error;                        // Signalize Init error
    while(1) ;                            // Stop program
  }
  Delay_ms(100);
    UART1_Write_Text("Enter Text Here (0 to exit)");
  do {
 
  if (UART1_Data_Ready()) {

    UART1_Write(10);
    UART1_Write(13);
    uart_rd = UART1_Read();
    Soft_UART_Write(uart_rd);
    Delay_ms(100);
  }
 }while(uart_rd!='0');
  }



 Circuit Of above Example


Soft UART


 Visit PIC UART Tutorial For Basic Connections

Popular posts from this blog

PIC Microcontroller Based Electronic Lock

Circuit Diagram

Security is a prime concern in our day-today life. Everyone wants to be as much secure as possible. An access control for doors forms a vital link in a security chain. The microcontroller based digital lock for Doors is an access control system that allows only authorized persons to access a restricted area. An electronic lock or digital lock is a device which has an electronic control assembly attached to it. They are provided with an access control system. This system allows the user to unlock the device with a password. The password is entered by making use of a keypad. The user can also set his password to ensure better protection. The major components include a Keypad, LCD and the controller PIC16F877A. This article describes the making of an electronic code lock using the 16F877A microcontroller.
The system is fully controlled by the 8 bit microcontroller 16F877A which has a 8Kbytes of ROM for the program memory. The password is stored in the EPROM so that we …

PIC Serial Communication Tutorial (UART)

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 …