ATtiny88初体验（三）：串口

ATtiny88初体验（三）：串口

ATtiny88单片机不包含串口模块，因此只能使用软件方式模拟串口时序。

串口通信时序通常由起始位、数据位、校验位和停止位四个部分组成，常见的配置为1位起始位、8位数据位、无校验位和1位停止位。

模拟串口发送时序

1. 设置TX引脚为输出模式，初始电平状态为高电平。
2. 设置定时器周期，以9600波特率为例，将定时器周期设为 \(\frac{1s}{9600} \approx 104us\) 。
3. TX引脚输出低电平（起始位），同时开启定时器。
4. 之后的8次定时器中断，每次输出1位数据，从低位开始。
5. 第9次定时器中断，TX引脚输出高电平（停止位）。
6. 第10次定时器中断，关闭定时器。

模拟串口接收时序

1. 设置RX引脚为输入模式，使能上拉电阻，开启下降沿中断。
2. 当接收到起始位时，触发下降沿中断，设置定时器周期为 \(\frac{1s}{9600} \times \frac{1}{6} \approx 17us\) ，开启定时器。
3. 之后的30次定时器中断，对RX引脚的电平状态进行计数（起始位）。
4. 第1次定时器中断，将定时器周期重设为 \(\frac{1s}{9600} \times \frac{1}{3} \approx 35us\) 。
5. 第3次定时器中断，如果高电平数量大于低电平数量，则表示起始位接收失败，直接关闭定时器，并开启下降沿中断。
6. 第6/9/.../24/27次定时器中断，判断高电平和低电平的数量，选取数量多的那个电平作为数据位，从低位开始填充。
7. 第30次定时器中断，关闭定时器中断，开启下降沿中断，如果高电平数量大于低电平数量，则表示成功接收到停止位，数据有效。

外部中断

ATtiny88有8个外部中断源：INT0、INT1、PCI0、PCI1、PCI2、PCI3。其中INT0/1支持低电平/下降沿/上升沿触发，PCI0/1/2/3在引脚状态改变时触发。

ATtiny88外部中断和引脚的对应关系如下：

中断源	引脚
INT0	PD2
INT1	PD3
PCI0	PB[0:7] -> PCINT[0:7]
PCI1	PC[0:7] -> PCINT[8:15]
PCI2	PD[0:7] -> PCINT[16:23]
PCI3	PA[0:3] -> PCINT[24:27]

注意：即使引脚配置为输出模式，也能触发相应的中断。

寄存器

• ISC1[1:0] ：设置INT1中断触发方式。
  
• ISC0[1:0] ：设置INT0中断触发方式，取值同 ISC1[1:0] 。

• INT1 ：设为1使能INT1中断。
• INT0 ：设为1使能INT0中断。

• INTF1 ：INT1中断标志位，执行中断函数时自动清零，也可以写1清零。
• INTF0 ：INT0中断标志位，执行中断函数时自动清零，也可以写1清零。

• PCIE3 ：设为1使能PCI3（PCINT[27:24]）中断。
• PCIE2 ：设为1使能PCI2（PCINT[23:16]）中断。
• PCIE1 ：设为1使能PCI1（PCINT[15:8]）中断。
• PCIE0 ：设为1使能PCI0（PCINT[7:0]）中断。

• PCIF3 ：PCI3（PCINT[27:24]）中断标志位，执行中断函数时自动清零，也可以写1清零。
• PCIF2 ：PCI2（PCINT[23:16]）中断标志位，执行中断函数时自动清零，也可以写1清零。
• PCIF1 ：PCI1（PCINT[15:8]）中断标志位，执行中断函数时自动清零，也可以写1清零。
• PCIF0 ：PCI0（PCINT[7:0]）中断标志位，执行中断函数时自动清零，也可以写1清零。

• PCINTx ：设为1使能PCINTx中断。

代码实现

代码文件的整体结构如下：

.
├── Makefile
├── inc
│   └── serial.h
└── src
    ├── main.c
    └── serial.c

inc/serial.h 头文件的代码内容如下：

#pragma once

#include <stdint.h>

#define UART    (&serial)

typedef struct {
    const uint8_t *cfg;
    uint8_t flag;
    uint8_t tx_idx;
    uint8_t tx_temp;
    uint8_t tx_data;
    uint8_t rx_idx;
    uint8_t rx_temp;
    uint8_t rx_data;
    uint8_t rx_cnt;
} serial_t;

typedef enum {
    SERIAL_BR_1200 = 0,
    SERIAL_BR_2400,
    SERIAL_BR_4800,
    SERIAL_BR_9600,
    SERIAL_BR_19200,
    SERIAL_BR_38400,
    SERIAL_BR_57600,
    SERIAL_BR_115200
} serial_baudrate_t;

typedef enum {
    SERIAL_FLAG_TXE = 0x01,
    SERIAL_FLAG_RXNE = 0x02
} serial_flag_t;

extern serial_t serial;

void serial_setup(serial_t *serial, serial_baudrate_t br);
uint8_t serial_get_flag(serial_t *serial, serial_flag_t flag);
void serial_send_data(serial_t *serial, uint8_t data);
uint8_t serial_receive_data(serial_t *serial);

src/serial.c 源文件的代码内容如下，其中将PD1引脚定义为TX，将PD2引脚定义为RX：

#include <serial.h>
#include <avr/io.h>
#include <avr/interrupt.h>

serial_t serial;

static const uint8_t serial_cfg[] = {
    0x03, 208, 35, 69,  // 1200
    0x03, 104, 17, 35,  // 2400
    0x03, 52, 9, 17,    // 4800
    0x02, 208, 35, 69,  // 9600
    0x02, 104, 17, 35,  // 19200
    0x02, 52, 9, 17,    // 38400
    0x02, 35, 6, 12,    // 57600
    0x01, 139, 23, 46,  // 115200
};

void serial_setup(serial_t *serial, serial_baudrate_t br)
{
    serial->cfg = &serial_cfg[br * 4];
    serial->flag = SERIAL_FLAG_TXE;         // initial value for serial->flag

    // setup tx pin
    PORTD |= _BV(PORTD1);                   // PD1 outputs high level
    DDRD |= _BV(DDD1);                      // set PD1 as output

    // setup rx pin
    PORTD |= _BV(PORTD2);                   // enable PD2 pull-up resistance
    DDRD &= ~_BV(DDD2);                     // set PD2 as input

    // setup INT0
    EICRA &= ~(_BV(ISC01) | _BV(ISC00));
    EICRA |= _BV(ISC01);                    // the falling edge of INT0 generates an interrupt request
    EIFR = _BV(INTF0);                      // clear INT0 interrupt flag
    EIMSK |= _BV(INT0);                     // enable INT0 interrupt

    // setup TIMER0
    TCNT0 = 0;                              // clear counter
    TIMSK0 = 0;                             // disable all interrupts of TIMER0
    TIFR0 = _BV(OCF0B) | _BV(OCF0A);        // clear TIMER0_COMPA & TIMER0_COMPB interrupt flags
    TCCR0A = serial->cfg[0];                // set mode & prescaler of TIMER0
}

uint8_t serial_get_flag(serial_t *serial, serial_flag_t flag)
{
    return serial->flag & flag;
}

void serial_send_data(serial_t *serial, uint8_t data)
{
    serial->flag &= ~SERIAL_FLAG_TXE;       // clear TXE flag
    serial->tx_data = data;                 // store the data to transmit
    serial->tx_temp = data;
    serial->tx_idx = 0;                     // reset index of transmission

    OCR0A = TCNT0 + serial->cfg[1] - 1;     // set period of TIMER0_COMPA
    PORTD &= ~_BV(PORTD1);                  // PD1 outputs low level
    TIFR0 = _BV(OCF0A);                     // clear TIMER0_COMPA interrupt flag
    TIMSK0 |= _BV(OCIE0A);                  // enable TIMER0_COMPA interrupt
}

uint8_t serial_receive_data(serial_t *serial)
{
    uint8_t data = serial->rx_data;         // read the data received
    serial->flag &= ~SERIAL_FLAG_RXNE;      // clear RXNE flag
    return data;
}

static inline void serial_tx_timer_isr(serial_t *serial)
{
    if (serial->tx_idx < 8) {               // send databits
        if (serial->tx_temp & 0x01) {       // output the lowest bit
            PORTD |= _BV(PORTD1);
        } else {
            PORTD &= ~_BV(PORTD1);
        }
        serial->tx_temp >>= 1;
    } else if (serial->tx_idx == 8) {       // send stopbit
        PORTD |= _BV(PORTD1);
    } else {                                // end of transmission
        serial->flag |= SERIAL_FLAG_TXE;    // set TXE flag
        TIMSK0 &= ~_BV(OCIE0A);             // disable TIMER0_COMPA interrupt
    }

    OCR0A += serial->cfg[1];                // set time of the next interrupt
    serial->tx_idx++;                       // update index of transmission
}

static inline void serial_rx_int_isr(serial_t *serial)
{
    OCR0B = TCNT0 + serial->cfg[2] - 1;     // set time of the first TIMER0_COMPB interrupt
    EIMSK &= ~_BV(INT0);                    // disable INT0 interrupt
    TIFR0 = _BV(OCF0B);                     // clear TIMER0_COMPB interrupt flag
    TIMSK0 |= _BV(OCIE0B);                  // enable TIMER0_COMPB interrupt
    serial->rx_idx = 0;                     // reset index of reception
    serial->rx_cnt = 0;                     // clear counter of 0/1
}

static inline void serial_rx_timer_isr(serial_t *serial)
{
    serial->rx_cnt += PIND & _BV(PIND2) ? 0x10 : 0x01;  // count 0/1

    if (serial->rx_idx == 2) {              // receive startbit
        if (serial->rx_cnt > 0x20) {        // if startbit is '1'
            TIMSK0 &= ~_BV(OCIE0B);         // disable TIMER0_COMPB interrupt
            EIFR = _BV(INTF0);              // clear INT0 interrupt flag
            EIMSK |= _BV(INT0);             // enable INT0 interrupt flag
        }
        serial->rx_cnt = 0;                 // reset counter of 0/1
    } else if (serial->rx_idx == 29) {      // receive stopbit
        if (serial->rx_cnt > 0x20) {        // if stopbit is '1'
            serial->rx_data = serial->rx_temp;  // the data received is valid, store it to serial->rx_data
            serial->flag |= SERIAL_FLAG_RXNE;   // set RXNE flag
        }
        TIMSK0 &= ~_BV(OCIE0B);             // disable TIMER0_COMPB interrupt
        EIFR = _BV(INTF0);                  // clear INT0 interrupt flag
        EIMSK |= _BV(INT0);                 // clear INT0 interrupt flag
    } else if (serial->rx_idx % 3 == 2) {   // receive databits
        serial->rx_temp >>= 1;
        if (serial->rx_cnt > 0x20) {
            serial->rx_temp |= 0x80;
        }
        serial->rx_cnt = 0;                 // reset counter of 0/1
    }

    OCR0B += serial->cfg[3];                // set time of the next interrupt
    serial->rx_idx++;                       // update index of reception
}

ISR(TIMER0_COMPA_vect)
{
    uint8_t sreg = SREG;
    serial_tx_timer_isr(UART);
    SREG = sreg;
}

ISR(INT0_vect)
{
    uint8_t sreg = SREG;
    serial_rx_int_isr(UART);
    SREG = sreg;
}

ISR(TIMER0_COMPB_vect)
{
    uint8_t sreg = SREG;
    serial_rx_timer_isr(UART);
    SREG = sreg;
}

注意：实测115200以下（含）的波特率发送都正常，但是9600以上（不含）的波特率接收不正常，建议日常使用9600波特率。

重定向stdio到串口

为了更方便的使用串口，可以将标准输入输出重定向到串口，在AVR GCC中的做法如下：

1. 定义输入和输出的接口函数，原型如下：

   int putc(char c, FILE *stream);
   int getc(FILE *stream);
   

2. 使用 FDEV_SETUP_STREAM 创建一个stream。

   FILE s = FDEV_SETUP_STREAM(putc, getc, flag)
   

3. 将上面创建的stream替换掉 stdout / stdin 。

   stdout = stdin = &s;
   

代码实现

src/main.c 源文件的代码内容如下：

#include <stdint.h>
#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <serial.h>

static void stdio_setup(void);

int main(void)
{
    cli();
    stdio_setup();
    sei();

    printf("Hello, ATtiny88!\r\n");
    for (;;) {
        putchar(getchar());
    }
}

static int serial_putchar(char c, FILE *stream)
{
    while (!serial_get_flag(UART, SERIAL_FLAG_TXE));
    serial_send_data(UART, c);
    return 0;
}

static int serial_getchar(FILE *stream)
{
    while (!serial_get_flag(UART, SERIAL_FLAG_RXNE));
    return serial_receive_data(UART);
}

static void stdio_setup(void)
{
    static FILE f = FDEV_SETUP_STREAM(serial_putchar, serial_getchar, _FDEV_SETUP_RW);
    serial_setup(UART, SERIAL_BR_9600);
    stdout = &f;
    stdin = &f;
}

参考资料

1. avr-libc: Standard IO facilities
2. ATtiny88 Datasheet