Class _swuarta: software-emulated UART

Detailed Description

This class implements a software-emulated UART with the following features:

• simplex or half-duplex communication over 1 or 2 wires
• frames of 1 start bit, 8 data bits, 1 stop bit (no parity bit)
• requirements:
  • one 8 or 16-bit counter compare unit
  • one pin able to trigger an interrupt when a falling edge or any change occurs (currently, only pin-change is implemented) for RXD
• optionnal automatic baudrate detection
• optionnal bus-collision detection

Note

Currently, this is only supported by Devices.

Performances

Tested on ATtiny24/44/84 with internal oscillator (rc_8MHz):

• 1200..115200 bps with 16-bit counter, clk_div=1
• 450.. 50000 bps with 16-bit counter, clk_div=8
• 38400..115200 bps with 8-bit counter, clk_div=1
• 10000 bps with 8-bit counter, clk_div=8
• 45..140 kbps with ATtiny85, rc_8MHz, counter1, compare0, clk_div=1 sync=51

Note

The make rule swuarta-perfs defined in hwa/atmel/avr/examples/make/Makefile.cc displays the number of CPU cycles spent in different sections of the _swuarta code and in critical sections according to the configuration. These figures determine the performances that can be achieved.

Pins

If the same pin is used for rxd and txd signals, the UART automatically reverts to RX mode after a transmission is completed and transmissions are delayed one a reception is started, i.e. hw(write,UART,data) blocks until a reception is completed once it has started.

Start detection

By default, the pin-change controller associated to the RXD pin is used as the interrupt provider for detecting the start bit. This implies that the same pin-change controller should not be used by the application.

Counting unit

The counting unit is configured in up-loop mode, counting from 0 to the maximum it can reach. The user application can use the count value and the overflow interrupt, for example to make a RTC counter.

Automatic baudrate detection

If defined, autosync a method to automatically detect the baudrate:

• 51: waits for a sequence of 5 low-level bits followed by 1 low-level bit. The ASCII characters 'A' or 'p' will do that.
• 91: waits for a sequence of 9 low-level bits followed by 1 low-level bit. E.g.: 0x00 / 0xFF bytes.
• 101: waits for a sequence of 10 low-level bits followed by 1 low-level bit. This can be done by sending a break byte of 10 low-level bits or a '0' byte with even parity, followed by a 0xFF byte.

Note

It is advised to disable the sleep instruction and all interrupts except the UART starter for a better accuracy of the baudrate detection. Once the UART is synchronized, interrupts can be re-enabled.

Do not forget that the software UART is interrupt-driven and that too long delays before the UART IRQs are serviced will lead to loss of data.

Currently, baudrate detection is started when the UART receives a character and it is not synced. The processing is blocking. Non blocking alternatives are provided but not yet useable.

Bus collision detection

If check_tx is defined, the status of the bus is compared with the last bit sent before sending a new one. If there is a mismatch (collision), the UART releases the TXD pin and sets the stop status flag to 0. The UART continues virtually to send until the end of the frame when it sets the txc bit as usual. That way, the application remains synchronized with the bus and can decide whether to retry the transmission or to listen to what is happening on the bus.

Note

Currently, check_tx can not be set by the constructor.

Implementation

Header file:

#include <hwa/ext/swuarta.h>

HW_SWUARTA(...) declares an object. You must provide:

• an I/O for the TXD signal;
• an I/O for the RXD signal;
• an IRQ for start bit detection;
• a counter;
• a compare unit of the counter;
• a prescaler value for the counter's clock;
• a synchronization method;
• the address of a fast access register.

HW_SWUARTA(  txd,       ...,         // Pin TXD
           [ rxd,       ...,         // Pin RXD
             startirq,  ..., ]       // IRQ used for RX start bit
             counter,   ...,         // Counter unit used
             compare,   ...,         // Compare unit used
             clkdiv,    ...,         // Counter prescaler value
           [ autosync,  ..., ]       // Autosync method (51,91,101)
           [ fastreg,   ...  ] );    // Address of a fast access register for status

#include <hwa/ext/swuarta.h>
 
#define UART         HW_SWUARTA( txd,      (portb,0),
                                 rxd,      (portb,1),
                                 startirq, ((portb,1),port,pcic,irq),
                                 counter,  counter0,
                                 compare,  compare0,
                                 clkdiv,   2,
                                 autosync, 51,
                                 fastreg,  (shared,gpior0) );

HW_DECLARE( UART ) declares the functions that implement the device. You can put it in your header files:

HW_DECLARE( UART );

Currently, class _swuarta does not support HW_IMPLEMENT(). You must include the assembly file hwa/ext/swuarta.sx in one of your source files after having defined a UART symbol, once per object:

     ;; -*- asm -*-
 
#undef UART
#define UART UART0
#include <hwa/ext/swuarta.sx>        // Implement UART0
 
#undef UART
#define UART UART1
#include <hwa/ext/swuarta.sx>        // Implement UART1

Actions

Both hw( configure, UART, ... ) and hwa( configure, UART, ... ) configure the object but they differ slightly in what they do:

• hwa(configure,UART,...) configures the UART, its pins TXD, RXD, and its counting unit;
• hw(configure,UART,...) can only be used to change the baudrate or to enable/disable the receiver by enabling/disabling start bit interrupts.

Optionnal arguments are used for consistency with the class _uarta.

hwa( configure,     UART,
 
   [ bps,           BPS, ]           //  Baudrate in bits per second
 
   [ cpb,           N, ]             //  Baudrate in CPU clock pulses per bit
 
   [ databits,      8, ]             //  Number of data bits in frame. Must be `8`.
 
   [ parity,        none, ]          //  Parity. Must be `none`.
 
   [ stopbits,      1, ]             //  Number of stop bits in frame. Must be `1`.
 
   [ receiver,      enabled          //  Whether the UART can receive. Default is `enabled`.
                  | disabled, ]
 
   [ transmitter,   enabled ] );     //  Whether the UART can transmit. Must be `enabled`.

hw( configure, UART,
    bps,       100000 );     //  Baudrate in bits per second

hw( read, UART ) clears the rxc flag, and returns the last byte received.

while ( hw(stat,UART).rxc == 0 );
uint8_t byte = hw( read, UART );

hw( write, UART, byte ) places a byte into the shift register, clears the txc flag and starts the transmission.

This instruction returns before the byte is actually transmitted. You need to check the txc flag to know when the transmission is complete.

while ( hw(stat,UART).txc == 0 );
hw( write, UART, '#' );

hw( stat, UART ) returns the status with the following flags:

• stop: the state of the last stop bit received, 0 if the byte failed to transmit (collision)
• rxc: 1 when a reception is completed (stop bit sampled)
• txc: 1 when the transmission is completed (stop bit sent)
• sync: 1 when the UART is synchronized

uint8_t byte ;
hw_stat_t(UART) st ;                 // Structure of UART status
st = hw( stat, UART );               // Read the status
if ( st.rxc==1 && st.stop==1 )       // Reception complete with valid stop bit
  byte = hw( read, UART );

hw( clear, UART ) clears the rxc and txc status flags.

hw( clear, UART );

hw( reset, UART ) aborts any transmission or reception. If the UART has automatic baudrate detection, the UART will first resynchronize.

hw( reset, UART );

hw( wait_idle, UART, n ) wait n idle bits:

hw( wait_idle, UART, 25 );

Registers

• dt0: number of counter clocks between the start condition and the sampling of data bit #0
• dtn: number of counter clocks between samplings
• sr: status byte

Macros
#define	HW_SWUARTA(...)