ATtiny88初体验(三):串口

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

ATtiny88初体验(三):串口-LMLPHP

串口通信时序通常由起始位、数据位、校验位和停止位四个部分组成,常见的配置为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外部中断和引脚的对应关系如下:

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

寄存器

ATtiny88初体验(三):串口-LMLPHP

  • ISC1[1:0] :设置INT1中断触发方式。
    ATtiny88初体验(三):串口-LMLPHP
  • ISC0[1:0] :设置INT0中断触发方式,取值同 ISC1[1:0]

ATtiny88初体验(三):串口-LMLPHP

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

ATtiny88初体验(三):串口-LMLPHP

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

ATtiny88初体验(三):串口-LMLPHP

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

ATtiny88初体验(三):串口-LMLPHP

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

ATtiny88初体验(三):串口-LMLPHP

ATtiny88初体验(三):串口-LMLPHP

ATtiny88初体验(三):串口-LMLPHP

ATtiny88初体验(三):串口-LMLPHP

  • 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
08-23 00:25