跳转至

ATtiny88初体验（三）：串口

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

image.png

串口通信时序通常由起始位、数据位、校验位和停止位四个部分组成，常见的配置为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]

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

寄存器

image.png

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

image.png

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

image.png

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

image.png

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

image.png

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

image.png

image.png

image.png

image.png

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

代码实现

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

1
2
3
4
5
6
7
.
├── Makefile
├── inc
│   └── serial.h
└── src
    ├── main.c
    └── serial.c

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

inc/serial.h
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#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：

src/serial.c
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#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. 定义输入和输出的接口函数，原型如下： 
    1
2
    int putc(char c, FILE *stream);
int getc(FILE *stream);
  2. 使用 FDEV_SETUP_STREAM 创建一个stream。 
    1
    FILE s = FDEV_SETUP_STREAM(putc, getc, flag)
  3. 将上面创建的stream替换掉 stdout / stdin 。 
    1
    stdout = stdin = &s;

代码实现

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

src/main.c
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#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