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

Comments

Post a Comment

Popular posts from this blog

PIC 16F877A Microcontroller Based Electronic Lock 16x2LCD 4x3 Keypad

 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...
134 comments
More

Electronic Voting Machine Using 8051 Microcontroller (AT89C51)

  Circuit Electronic voting machine has now replaced the traditional mechanism of voting due to several advantages like security, automatic counting etc. This project presents a way to develop an electronic voting machine which displays the count of votes on a 16x2 LCD interface. A user can get his/her vote register through a set of switches (one for each candidate). After every cast of vote, the subsequent count can be seen on LCD. The circuit uses AT89C51 microcontroller and the code for the project has been written in C. This LCD based electronic voting machine is designed for four candidates. The input part consists of a set of six tactile switches. The switches and 16x2 LCD are interfaced to microcontroller AT89C51 for various operations and displays. The provision of casting votes for the candidates has been provided through four of these switches. These switches are made active high and connected to pins 2-5 (P1^1 – P1^4) of the controller. The remaining ...
50 comments
More

PC Based Digital Voltmeter Using PIC 16F877A

Voltmeter C# .Net PIC, Arduino, AVR This is a simple voltmeter which measures 0-5V at a precision of 4.8 mV. This is a simple design using inbuilt ADC of PIC 16F877A. PIC 16F877A have 8 channel 10bit ADC.   This is a computer interfaced project. Measured voltage is output in serial interface software in computer. There is a serial interface circuit (MAX232) is necessary for interfacing with computer, which is not included in the circuit. Please check       PIC Serial Communication Tutorial (UART)   for the circuit and more details. Using one of the most popular 8 bit PIC 16f877A, for instance, reading the datasheet , we'll find that the ADC modules (10 bit) are controlled by four different registers. The first two, ADCON0 and ADCON1 , are used to set and start the ADC module. When high level language is used, the programmer doesn't need to care a lot of the register connected to the results because they are normally stored in...
1 comment
More