C++在单片机（Microcontroller）上的应用：处理中断、寄存器与硬件交互

好的，现在开始讲解C++在单片机上的应用，重点关注中断、寄存器和硬件交互。

C++在单片机上的应用：处理中断、寄存器与硬件交互

大家好，今天我们来探讨如何利用C++在单片机环境下进行开发，尤其是如何处理中断、直接操作寄存器，以及与硬件进行交互。虽然单片机资源有限，C++的抽象特性看似与底层硬件编程格格不入，但通过合理的设计和技巧，我们完全可以利用C++的优势来提高代码的可读性、可维护性和可重用性。

1. C++与单片机的结合：可行性与优势

传统的单片机开发通常使用C语言，因为它贴近硬件，效率高。然而，C++引入了面向对象编程的概念，提供了类、继承、多态等特性，这使得我们可以更好地组织代码，进行模块化设计。在资源受限的单片机上使用C++并非不可行，只要我们避免过度使用动态内存分配、虚函数等开销较大的特性，就可以兼顾代码的效率和可维护性。

C++在单片机编程中的优势主要体现在以下几个方面：

• 代码组织与模块化： 类可以很好地封装硬件驱动，提高代码的可读性和可维护性。
• 代码重用： 通过继承和模板，可以减少代码冗余，提高开发效率。
• 类型安全： C++的类型检查比C语言更严格，可以减少潜在的错误。
• 抽象能力： 可以将底层的硬件操作抽象成易于理解的接口。

2. 中断处理

中断是单片机中一种重要的事件处理机制。当外部事件发生时，单片机会暂停当前执行的任务，跳转到中断服务程序（ISR）进行处理，处理完成后再返回到原来的任务继续执行。

2.1 中断向量表

每个单片机都有一个中断向量表，它存储了每个中断源对应的ISR的地址。当发生中断时，单片机会根据中断向量表找到相应的ISR并执行。

2.2 C++中的中断处理

在C++中处理中断，我们需要将ISR声明为C函数，并将其地址添加到中断向量表中。为了避免C++的名称修饰（name mangling），我们需要使用extern "C"声明ISR。

// 定义中断向量表（示例，具体取决于单片机型号）
#define INTERRUPT_VECTOR_TABLE_ADDRESS  0x0000

// 定义中断服务程序的函数指针类型
typedef void (*InterruptHandler)(void);

// 定义中断向量表结构体
typedef struct {
  InterruptHandler reset;              // 复位中断
  InterruptHandler external_interrupt_0; // 外部中断0
  InterruptHandler timer_0_overflow;    // 定时器0溢出中断
  // ... 其他中断
} InterruptVectorTable;

// 声明一个中断处理函数
extern "C" void externalInterrupt0Handler();

// 创建中断向量表实例，并初始化中断处理函数
const InterruptVectorTable interruptVectorTable __attribute__((section(".vectors"))) = {
  .reset = (InterruptHandler)0x0000,  // 默认复位处理程序的地址（启动代码）
  .external_interrupt_0 = externalInterrupt0Handler, // 外部中断0的处理程序
  .timer_0_overflow = (InterruptHandler)0x0000, // 定时器0处理程序
  // ... 初始化其他中断向量
};

// 外部中断0的中断服务程序
extern "C" void externalInterrupt0Handler() {
  // 中断处理代码
  // 例如，翻转一个LED的状态
  PORTB ^= (1 << PB5); // 假设PB5连接到一个LED

  // 清除中断标志位（重要！否则会一直触发中断）
  // 具体清除方式取决于单片机型号，这里仅为示例
  // 例如：EIFR |= (1 << INTF0); // AVR单片机示例
}

// 初始化IO口（例如，配置PB5为输出）
void initIO() {
  DDRB |= (1 << PB5); // 配置PB5为输出
}

int main() {
  initIO();
  // 初始化中断系统 (使能全局中断 和 外部中断0)
  sei(); // 使能全局中断 ( AVR 单片机)
  EIMSK |= (1 << INT0); // 使能 外部中断 0 ( AVR 单片机)
  EICRA |= (1 << ISC01); // 配置 外部中断 0 为下降沿触发 (AVR 单片机)

  while (1) {
    // 主循环
  }
  return 0;
}

注意：

• 中断服务程序必须尽可能短小精悍，避免执行耗时操作，以免影响其他任务的执行。
• 中断服务程序中不能使用动态内存分配（new、malloc），因为这可能会导致内存碎片。
• 在中断服务程序中访问全局变量时，需要使用volatile关键字声明该变量，以防止编译器优化导致的问题。
• 不同单片机的中断向量表地址和中断控制寄存器不同，需要根据具体的单片机型号进行配置。

2.3 中断的嵌套与优先级

单片机通常支持中断的嵌套，即在一个中断服务程序中可以响应另一个中断。为了避免中断的无限嵌套，需要设置中断的优先级。优先级高的中断可以打断优先级低的中断。

2.4 中断处理类的封装

为了更好地组织中断处理代码，可以将中断处理逻辑封装到类中。

class ExternalInterruptHandler {
public:
  ExternalInterruptHandler(uint8_t port, uint8_t pin) : port_(port), pin_(pin) {}

  void handleInterrupt() {
    // 中断处理代码
    // 例如，翻转一个LED的状态
    PORTB ^= (1 << pin_);
    // 清除中断标志位
    // ...
  }

private:
  uint8_t port_;
  uint8_t pin_;
};

// 创建中断处理类的实例
ExternalInterruptHandler externalInterrupt(PORTB, PB5);

// 中断服务程序
extern "C" void externalInterrupt0Handler() {
  externalInterrupt.handleInterrupt();
}

这种方式将中断处理逻辑封装到类中，使得代码更加清晰和易于维护。

3. 寄存器操作

单片机的所有功能都是通过操作寄存器来实现的。寄存器是单片机内部的一些特殊存储单元，用于控制单片机的各种功能模块，如GPIO、定时器、串口等。

3.1 直接寄存器操作

在C++中，我们可以直接通过地址来访问寄存器。为了方便访问，我们可以使用volatile关键字定义寄存器的地址。

// 定义寄存器的地址（示例，具体取决于单片机型号）
#define PORTB (*(volatile uint8_t *)0x25) // AVR单片机 PORTB 寄存器
#define DDRB  (*(volatile uint8_t *)0x24)  // AVR单片机 DDRB 寄存器

// 初始化IO口（例如，配置PB5为输出）
void initIO() {
  DDRB |= (1 << PB5); // 配置PB5为输出
}

// 翻转PB5的状态
void toggleLED() {
  PORTB ^= (1 << PB5);
}

注意：

• 必须使用volatile关键字声明寄存器，以防止编译器优化导致的问题。
• 需要根据具体的单片机型号确定寄存器的地址。
• 直接操作寄存器需要非常小心，避免误操作导致系统崩溃。

3.2 使用位域结构体

为了更方便地操作寄存器的各个位，可以使用位域结构体。位域结构体可以将寄存器的各个位定义为结构体的成员，从而可以通过结构体成员名来访问寄存器的各个位。

// 定义寄存器的位域结构体（示例，具体取决于单片机型号）
typedef struct {
  uint8_t bit0 : 1;
  uint8_t bit1 : 1;
  uint8_t bit2 : 1;
  uint8_t bit3 : 1;
  uint8_t bit4 : 1;
  uint8_t bit5 : 1;
  uint8_t bit6 : 1;
  uint8_t bit7 : 1;
} PortBRegister;

// 定义寄存器的地址
#define PORTB_ADDRESS  0x25

// 将寄存器地址映射到位域结构体
#define PORTB (*((volatile PortBRegister *)PORTB_ADDRESS))

// 使用位域结构体操作寄存器
void toggleLED() {
  PORTB.bit5 ^= 1; // 翻转PB5的状态
}

使用位域结构体可以提高代码的可读性，更容易理解寄存器的各个位的功能。

3.3 寄存器操作类的封装

为了更好地组织寄存器操作代码，可以将寄存器操作封装到类中。

class GPIOPort {
public:
  GPIOPort(uint8_t portAddress, uint8_t directionAddress)
    : portAddress_(portAddress), directionAddress_(directionAddress) {}

  void setPinMode(uint8_t pin, bool output) {
    if (output) {
      *directionAddress_ |= (1 << pin); // 设置为输出
    } else {
      *directionAddress_ &= ~(1 << pin); // 设置为输入
    }
  }

  void setPin(uint8_t pin, bool high) {
    if (high) {
      *portAddress_ |= (1 << pin); // 设置为高电平
    } else {
      *portAddress_ &= ~(1 << pin); // 设置为低电平
    }
  }

  bool getPin(uint8_t pin) {
    return (*portAddress_ & (1 << pin)) != 0; // 读取引脚状态
  }

  void togglePin(uint8_t pin) {
    *portAddress_ ^= (1 << pin); // 翻转引脚状态
  }

private:
  volatile uint8_t* portAddress_;
  volatile uint8_t* directionAddress_;
};

// 创建GPIO端口类的实例
GPIOPort portB((uint8_t*)0x25, (uint8_t*)0x24); // PORTB 和 DDRB 的地址

// 使用GPIO端口类操作引脚
void initIO() {
  portB.setPinMode(5, true); // 配置PB5为输出
}

void toggleLED() {
  portB.togglePin(5); // 翻转PB5的状态
}

这种方式将寄存器操作封装到类中，使得代码更加模块化和易于重用。

4. 硬件交互

单片机的一个重要应用是与各种硬件设备进行交互，如传感器、显示器、电机等。

4.1 GPIO

GPIO（General Purpose Input/Output）是单片机中最常用的接口之一。通过GPIO，我们可以控制外部设备的开关，读取外部设备的状态。

// 初始化IO口（例如，配置PB5为输出）
void initIO() {
  DDRB |= (1 << PB5); // 配置PB5为输出
}

// 设置PB5为高电平
void setLEDHigh() {
  PORTB |= (1 << PB5);
}

// 设置PB5为低电平
void setLEDLow() {
  PORTB &= ~(1 << PB5);
}

// 读取PB0的状态
bool getButtonState() {
  return (PINB & (1 << PB0)) != 0;
}

4.2 定时器

定时器可以用于产生定时中断，或者用于测量外部事件的持续时间。

// 初始化定时器0（示例，具体取决于单片机型号）
void initTimer0() {
  // 设置定时器0的工作模式
  TCCR0A = (1 << WGM01); // CTC模式
  // 设置定时器的预分频系数
  TCCR0B = (1 << CS02) | (1 << CS00); // 1024分频
  // 设置比较匹配值
  OCR0A = 156; // 1ms中断
  // 使能定时器0的比较匹配中断
  TIMSK0 |= (1 << OCIE0A);
}

// 定时器0的比较匹配中断服务程序
extern "C" void timer0CompareMatchISR() {
  // 中断处理代码
  // 例如，翻转一个LED的状态
  PORTB ^= (1 << PB5);

  // 清除中断标志位
  // ...
}

4.3 串口

串口可以用于与其他设备进行通信，如PC、其他单片机等。

// 初始化串口（示例，具体取决于单片机型号）
void initSerial() {
  // 设置波特率
  UBRR0H = (uint8_t)(BAUD_PRESCALER >> 8);
  UBRR0L = (uint8_t)BAUD_PRESCALER;
  // 使能接收和发送
  UCSR0B = (1 << RXEN0) | (1 << TXEN0);
  // 设置帧格式：8位数据，1位停止位，无校验
  UCSR0C = (3 << UCSZ00);
}

// 发送一个字节
void serialWrite(uint8_t data) {
  // 等待上一个字节发送完成
  while (!(UCSR0A & (1 << UDRE0)));
  // 发送数据
  UDR0 = data;
}

// 接收一个字节
uint8_t serialRead() {
  // 等待数据接收完成
  while (!(UCSR0A & (1 << RXC0)));
  // 返回接收到的数据
  return UDR0;
}

4.4 其他接口

除了GPIO、定时器和串口之外，单片机还提供了许多其他的接口，如SPI、I2C、ADC、DAC等。这些接口可以用于与各种不同的硬件设备进行交互。

5. C++标准库的使用

在单片机上使用C++标准库需要特别小心，因为标准库中的一些函数可能会占用大量的内存。一般来说，我们可以使用标准库中的一些基本功能，如字符串处理、数学运算等，但是要避免使用动态内存分配等开销较大的功能。

5.1 iostream 的替代方案

iostream库通常过于庞大，不适合在资源受限的单片机环境中使用。可以使用轻量级的格式化输出函数，例如 printf (需要包含 <cstdio> 头文件) 或者自定义的格式化输出函数。

6. 注意事项

• 内存管理： 尽量避免使用动态内存分配，可以使用静态数组或预分配的缓冲区。
• 代码优化： 使用编译器优化选项（如-Os）来减小代码体积和提高执行效率。
• 硬件抽象层（HAL）： 创建一个硬件抽象层，将底层的硬件操作封装起来，方便代码移植。
• 测试： 在实际硬件上进行充分的测试，确保代码的正确性和稳定性。
• 避免虚函数： 虚函数会引入额外的开销，尽量避免在对时间要求很高的代码中使用。可以使用模板或静态多态来实现类似的功能。
• 避免异常： 异常处理会增加代码体积和运行时开销，很多单片机环境不支持异常处理。

代码示例：基于类的LED控制

// LED.h
#ifndef LED_H
#define LED_H

#include <stdint.h>

class LED {
public:
  LED(volatile uint8_t *port, uint8_t pin);
  void on();
  void off();
  void toggle();

private:
  volatile uint8_t *port_;
  uint8_t pin_;
};

#endif

// LED.cpp
#include "LED.h"

LED::LED(volatile uint8_t *port, uint8_t pin) : port_(port), pin_(pin) {}

void LED::on() {
  *port_ |= (1 << pin_);
}

void LED::off() {
  *port_ &= ~(1 << pin_);
}

void LED::toggle() {
  *port_ ^= (1 << pin_);
}

// main.cpp
#include "LED.h"

// 定义寄存器的地址（示例，具体取决于单片机型号）
#define PORTB (*(volatile uint8_t *)0x25) // AVR单片机 PORTB 寄存器
#define DDRB  (*(volatile uint8_t *)0x24)  // AVR单片机 DDRB 寄存器

int main() {
  // 初始化IO口，配置PB5为输出
  DDRB |= (1 << 5);

  LED led(&PORTB, 5);

  while (1) {
    led.toggle();
    _delay_ms(500); // 延时500ms，需要包含 <util/delay.h> 或者类似的头文件
  }

  return 0;
}

总结

合理使用C++的特性，可以提高单片机代码的可读性、可维护性和可重用性。通过封装中断处理、寄存器操作和硬件交互，我们可以构建更加模块化和易于理解的代码。同时，需要注意内存管理和代码优化，以确保代码的效率和稳定性。

最后想说的话

C++在单片机上的应用关键在于扬长避短。利用C++的抽象能力组织代码，但要避免过度使用动态特性和复杂的运行时机制。深入了解单片机的硬件特性，才能编写出高效、可靠的嵌入式程序。

更多IT精英技术系列讲座，到智猿学院