1

#include "serial.h"

     2

     3

#include "stdlib.h"

     4

     5

#include <avr/io.h>

     6

#include <avr/interrupt.h>

     7

     8

/** Serial state */

     9

static enum serial_mode serial_mode = SERIAL_MODE_ASYNC;

    10

static enum serial_chars serial_chars = SERIAL_CHARS_8;

    11

    12

struct serial {

    13

    char buf[SERIAL_BUF];

    14

    byte in, out;

    15

} serial_rx;

    16

    17

char serial_tx = 0;

    18

    19

static void serial_enable (char rx, char tx);

    20

    21

/*

    22

 * Setup the UART for serial mode.

    23

 */

    24

void serial_init (

    25

    enum serial_baud baud,

    26

    enum serial_parity parity,

    27

    enum serial_stopbits stopbits

    28

)

    29

{

    30

    UCSR0A = (

    31

            // Double the USART Transmission Speed

    32

            (0b0 << U2X0)   // single speed

    33

    34

            // Multi-processor Communication Mode

    35

        |   (0b0 << MPCM0)  // off

    36

    );

    37

    UCSR0B = (

    38

            // Character Size

    39

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

    40

    );

    41

    UCSR0C = (

    42

            // USART Mode Select

    43

            (serial_mode << UMSEL00) // async

    44

    45

            // Parity Mode

    46

        |   (parity << UPM00)

    47

    48

            // Stop Bit Select

    49

        |   (stopbits << USBS0)

    50

    51

            // Character Size

    52

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

    53

    54

            // Clock Polarity

    55

        |   (0b0 << UCPOL0)

    56

    );

    57

    UBRR0 = baud;

    58

    59

    // active RX, idle TX

    60

    serial_enable(1, 0);

    61

}

    62

    63

static void serial_enable (char rx, char tx)

    64

{

    65

    UCSR0B = (

    66

            // RX Complete Interrupt Enable

    67

            (!!rx << RXCIE0)

    68

    69

            // USART Data Register Empty Interrupt Enable

    70

        |   (!!tx << UDRIE0)

    71

    72

            // Receiver Enable

    73

        |   (0b1 << RXEN0)  // enabled

    74

    75

            // Transmitter Enable

    76

        |   (0b1 << TXEN0)  // enabled

    77

    78

            // Character Size

    79

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

    80

    );

    81

}

    82

    83

/*

    84

 * Read incoming into buffer.

    85

 */

    86

ISR(USART_RX_vect)

    87

{

    88

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

    89

    90

    if (serial_rx.in >= SERIAL_BUF)

    91

        serial_rx.in = 0;

    92

}

    93

    94

/*

    95

 * Write outgoing buffer.

    96

 */

    97

ISR(USART_UDRE_vect)

    98

{

    99

    UDR0 = serial_tx;

   100

   101

    // tx buffer consumed

   102

    serial_tx = 0;

   103

   104

    // idle tx

   105

    serial_enable(1, 0);

   106

}

   107

   108

char serial_read ()

   109

{

   110

    if (serial_rx.out == serial_rx.in)

   111

        return 0;

   112

   113

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

   114

   115

    if (serial_rx.out >= SERIAL_BUF)

   116

        serial_rx.out = 0;

   117

   118

    return rx;

   119

}

   120

   121

void serial_write (char c)

   122

{

   123

    // XXX: atomic?

   124

    if (tbi(&UCSR0A, UDRE0)) {

   125

        // direct

   126

        UDR0 = c;

   127

    } else {

   128

        // buffered

   129

        serial_tx = c;

   130

        serial_enable(1, 1);

   131

    }

   132

}