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
|
|
Description
|
Configures and initializes the
software UART module.
Parameters :
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 :
|
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 :
|
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');
Comments
Post a Comment