1

/** Serial modes */

     2

static enum {

     3

    SERIAL_MODE_ASYNC   = 0b00,

     4

} serial_mode = SERIAL_MODE_ASYNC;

     5

     6

static enum {

     7

    SERIAL_BAUD_9600    = 103,

     8

} serial_baud = SERIAL_BAUD_9600;

     9

    10

static enum {

    11

    SERIAL_PARITY_N     = 0b00,

    12

} serial_parity = SERIAL_PARITY_N;

    13

    14

static enum {

    15

    SERIAL_STOPBITS_1   = 0b0,

    16

} serial_stopbits = SERIAL_STOPBITS_1;

    17

    18

static enum {

    19

    SERIAL_CHARS_8      = 0b011,

    20

} serial_chars = SERIAL_CHARS_8;

    21

    22

/** Serial state */

    23

#define SERIAL_BUF 64

    24

    25

struct serial {

    26

    char buf[SERIAL_BUF];

    27

    byte in, out;

    28

} serial_rx;

    29

    30

char serial_tx = 0;

    31

    32

void serial_enable (char rx, char tx);

    33

    34

/*

    35

 * Setup the UART for serial mode.

    36

 */

    37

void serial_init ()

    38

{

    39

    UCSR0A = (

    40

            // Double the USART Transmission Speed

    41

            (0b0 << U2X0)   // single speed

    42

    43

            // Multi-processor Communication Mode

    44

        |   (0b0 << MPCM0)  // off

    45

    );

    46

    UCSR0B = (

    47

            // Character Size

    48

            ((serial_chars >> 2) << UCSZ02) // standard character sizes

    49

    );

    50

    UCSR0C = (

    51

            // USART Mode Select

    52

            (serial_mode << UMSEL00) // async

    53

    54

            // Parity Mode

    55

        |   (serial_parity << UPM00)

    56

    57

            // Stop Bit Select

    58

        |   (serial_stopbits << USBS0)

    59

    60

            // Character Size

    61

        |   ((serial_chars & 0b11) << UCSZ00)

    62

    63

            // Clock Polarity

    64

        |   (0b0 << UCPOL0)

    65

    );

    66

    UBRR0 = serial_baud;

    67

    68

    // active RX, idle TX

    69

    serial_enable(1, 0);

    70

}

    71

    72

void serial_enable (char rx, char tx)

    73

{

    74

    UCSR0B = (

    75

            // RX Complete Interrupt Enable

    76

            (!!rx << RXCIE0)

    77

    78

            // USART Data Register Empty Interrupt Enable

    79

        |   (!!tx << UDRIE0)

    80

    81

            // Receiver Enable

    82

        |   (0b1 << RXEN0)  // enabled

    83

    84

            // Transmitter Enable

    85

        |   (0b1 << TXEN0)  // enabled

    86

    87

            // Character Size

    88

        |   ((serial_chars >> 2) << UCSZ02) // standard character sizes

    89

    );

    90

}

    91

    92

/*

    93

 * Read incoming into buffer.

    94

 */

    95

ISR(USART_RX_vect)

    96

{

    97

    serial_rx.buf[serial_rx.in++] = UDR0;

    98

    99

    if (serial_rx.in >= SERIAL_BUF)

   100

        serial_rx.in = 0;

   101

}

   102

   103

/*

   104

 * Write outgoing buffer.

   105

 */

   106

ISR(USART_UDRE_vect)

   107

{

   108

    UDR0 = serial_tx;

   109

   110

    // tx buffer consumed

   111

    serial_tx = 0;

   112

   113

    // idle tx

   114

    serial_enable(1, 0);

   115

}

   116

   117

char serial_read ()

   118

{

   119

    if (serial_rx.out == serial_rx.in)

   120

        return 0;

   121

   122

    char rx = serial_rx.buf[serial_rx.out++];

   123

   124

    if (serial_rx.out >= SERIAL_BUF)

   125

        serial_rx.out = 0;

   126

   127

    return rx;

   128

}

   129

   130

void serial_write (char c)

   131

{

   132

    // XXX: atomic?

   133

    if (tbi(&UCSR0A, UDRE0)) {

   134

        // direct

   135

        UDR0 = c;

   136

    } else {

   137

        // buffered

   138

        serial_tx = c;

   139

        serial_enable(1, 1);

   140

    }

   141

}