Software UART Library

The mikroC PRO for dsPIC30/33 and PIC24 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.

Soft_UART_Init

Prototype	char Soft_UART_Init(unsigned int port, unsigned int* rx, unsigned int tx, unsigned long baud_rate, unsigned int inverted);
Description	Configures and initializes the software UART module. 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.
Parameters	`port:` software UART port address `rx:` receiver pin `tx:` transmiter pin `baud_rate:` requested baudrate. Maximum baud rate depends on the MCU’s clock and working conditions `inverted:` if set to non-zero value, indicates inverted logic on output
Returns	`2` - error, requested baud rate is too low `1` - error, requested baud rate is too high `0` - successful initialization
Requires	Nothing.
Example	This will initialize software UART and establish the communication at 9600 bps: char error; ... error = Soft_UART_Init(&PORTF, 4, 5, 14400, 0); // Initialize Soft UART at 14400 bps
Notes	The Software UART library implements time-based activities, so interrupts need to be disabled when using it.

Soft_UART_Read

Prototype	char Soft_UART_Read(char *error);
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. Values : `0` - no error `1` - stop bit error `255` - user abort, Soft_UART_Break called
Returns	Byte received via UART.
Requires	Software UART must be initialized before using this function. See the Soft_UART_Init routine.
Example	char data_; char error; ... // wait until data is received do data = Soft_UART_Read(&error); while (error); // Now we can work with data: if (data_) {...}
Notes	The Software UART library implements time-based activities, so interrupts need to be disabled when using it.

Soft_UART_Write

Prototype	void Soft_UART_Write(char udata);
Description	This routine sends one byte via the Software UART bus.
Parameters	`udata:` data to be sent.
Returns	Nothing.
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);
Notes	The Software UART library implements time-based activities, so interrupts need to be disabled when using it.

Soft_UART_Break

Prototype	void Soft_UART_Break();
Description	Soft_UART_Read is blocking routine and it can block the program flow. Calling `Soft_UART_Break` routine from the interrupt will unblock the program execution. This mechanism is similar to WDT.
Parameters	None.
Returns	Nothing.
Requires	Nothing.
Example	char data1, error, counter = 0; void Timer1Int() org IVT_ADDR_T1INTERRUPT { if (counter >= 20) { Soft_UART_Break(); counter = 0; // reset counter } else counter++; // increment counter T1IF_bit = 0; // Clear Timer1 overflow interrupt flag } void main() { ... if (Soft_UART_Init(&PORTF, 4, 5, 14400, 0) = 0) Soft_UART_Write(0x55); ... // try Soft_UART_Read with blocking prevention mechanism IPC0 = IPC0 \| 0x1000; // Interrupt priority level = 1 T1IE_bit= 1; // Enable Timer1 interrupts T1CON = 0x8030; // Timer1 ON, internal clock FCY, prescaler 1:256 data1 = Soft_UART_Read(&error); T1IE_bit= 0; // Disable Timer1 interrupts }
Notes	The Software UART library implements time-based activities, so interrupts need to be disabled when using it.

Library Example

This example demonstrates simple data exchange via software UART. If MCU is connected to the PC, you can test the example from the mikroC PRO for dsPIC30/33 and PIC24 USART communication terminal, launch it from the drop-down menu Tools › USART Terminal or simply click the USART Terminal Icon .

Copy Code To Clipboard

char i, error, byte_read;  // Auxiliary variables

void main(){

  ADPCFG = 0xFFFF;

  TRISB = 0;              // Set PORTB as output (error signalization)
  LATB = 0;

  error = Soft_UART_Init(&PORTF, 4, 5, 14400, 0); // Initialize Soft UART at 14400 bps
  if (error > 0) {
    LATB = error;                                 // Signalize Init error
    while(1);                                    // Stop program
  }
  Delay_ms(100);

  for (i = 'z'; i >= 'A'; i--) {                  // Send bytes from 'z' downto 'A'
    Soft_UART_Write(i);
    Delay_ms(100);
  }
   
  while(1) {                                      // Endless loop
    byte_read = Soft_UART_Read(&error);           // Read byte, then test error flag
    if (error)                                    // If error was detected
      LATB = error;                               //   signal it on PORTB
    else
      Soft_UART_Write(byte_read);                 // If error was not detected, return byte read
    }      
}

Want more examples and libraries?
Find them on