C语言GPIO数据读取程序高频率下性能优化建议咨询

我有一个从GPIO引脚读取数据、转换为十六进制并打印的C程序。低频率读取时运行正常，但提升读取频率后，连接的SR锁存器的clear/klaro引脚无法及时复位锁存器，求代码优化提速的建议。

原代码 #

#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define data_ready 17
#define chipselect 27
#define klaro 18
#define D0 6
#define D1 13
#define D2 19
#define D3 26
#define D4 12
#define D5 16
#define D6 20
#define D7 21

int readydata;
int prevdata;
int i;
int chip_select;
int chunk;
int chunk2;
int chunk3;
char storage[3][9];

void chipselectInt (void){
    chunk = strtol(&storage[0][0], 0, 2) ;
    chunk2 = strtol(&storage[1][0], 0, 2) ;
    chunk3 = strtol(&storage[2][0], 0, 2) ;
    printf("%d",i) ;
    printf(",0x%lx", chunk);
    printf(",0x%lx", chunk2);
    printf(",0x%lx", chunk3);
    printf("\n");
    i=0;
}

int main(){
    wiringPiSetupGpio();
    pinMode(data_ready, INPUT);
    pinMode(chipselect, INPUT);
    pinMode(D0, INPUT);
    pinMode(D1, INPUT);
    pinMode(D2, INPUT);
    pinMode(D3, INPUT);
    pinMode(D4, INPUT);
    pinMode(D5, INPUT);
    pinMode(D6, INPUT);
    pinMode(D7, INPUT);
    pinMode(klaro, OUTPUT);
    (wiringPiISR (27, INT_EDGE_RISING , chipselectInt ));
    while(1){
        if(chip_select == LOW){
            readydata = digitalRead(data_ready);
            digitalWrite(klaro, LOW);
            switch(i){
                case 0:
                    storage[0][0] = digitalRead(D0)+ 48;
                    storage[0][1] = digitalRead(D1)+ 48;
                    storage[0][2] = digitalRead(D2)+ 48;
                    storage[0][3] = digitalRead(D3)+ 48;
                    storage[0][4] = digitalRead(D4)+ 48;
                    storage[0][5] = digitalRead(D5)+ 48;
                    storage[0][6] = digitalRead(D6)+ 48;
                    storage[0][7] = digitalRead(D7)+ 48;
                    break;
                case 1:
                    storage[1][0] =  digitalRead(D0)+ 48;
                    storage[1][1] = digitalRead(D1)+ 48;
                    storage[1][2] = digitalRead(D2)+ 48;
                    storage[1][3] = digitalRead(D3)+ 48;
                    storage[1][4] = digitalRead(D4)+ 48;
                    storage[1][5] = digitalRead(D5)+ 48;
                    storage[1][6] = digitalRead(D6)+ 48;
                    storage[1][7] = digitalRead(D7)+ 48;
                    break;
                case 2:
                    storage[2][0] = digitalRead(D0)+48;
                    storage[2][1] = digitalRead(D1)+48;
                    storage[2][2] = digitalRead(D2)+48;
                    storage[2][3] = digitalRead(D3)+48;
                    storage[2][4] = digitalRead(D4)+48;
                    storage[2][5] = digitalRead(D5)+48;
                    storage[2][6] = digitalRead(D6)+48;
                    storage[2][7]= digitalRead(D7)+48;
                    break;
            }
            if(readydata == HIGH && prevdata == LOW){
                i++;
                digitalWrite(klaro, HIGH);
            }
        }
        prevdata == readydata;
    }
    return 0;
}

优化建议 #

1. 修复核心逻辑错误 #

• prevdata == readydata是比较操作而非赋值，应改为prevdata = readydata，否则边沿检测完全失效。
• chip_select变量未赋值，if(chip_select == LOW)条件永远不成立，需改为chip_select = digitalRead(chipselect);，或直接在条件中判断引脚状态。

2. 减少GPIO读取开销 #

• 替换多次digitalRead调用，直接操作GPIO寄存器批量读取引脚状态。以树莓派为例，可访问BCM2835的GPIO_LEVEL寄存器，一次读取获取所有D0-D7的状态，再拆分出每个位的数据：

  // 定义各引脚的位掩码
  #define D0_MASK (1 << 6)
  #define D1_MASK (1 << 13)
  #define D2_MASK (1 << 19)
  #define D3_MASK (1 << 26)
  #define D4_MASK (1 << 12)
  #define D5_MASK (1 << 16)
  #define D6_MASK (1 << 20)
  #define D7_MASK (1 << 21)
  
  // 读取GPIO端口状态（树莓派GPIO基地址为0x20200000，LEVEL寄存器偏移0x30）
  volatile uint32_t *gpio_level = (volatile uint32_t *)0x20200030;
  uint32_t state = *gpio_level;
  
  // 组装8位数据
  uint8_t byte_data = 0;
  byte_data |= (state & D0_MASK) ? 1 : 0;
  byte_data |= ((state & D1_MASK) ? 1 : 0) << 1;
  byte_data |= ((state & D2_MASK) ? 1 : 0) << 2;
  byte_data |= ((state & D3_MASK) ? 1 : 0) << 3;
  byte_data |= ((state & D4_MASK) ? 1 : 0) << 4;
  byte_data |= ((state & D5_MASK) ? 1 : 0) << 5;
  byte_data |= ((state & D6_MASK) ? 1 : 0) << 6;
  byte_data |= ((state & D7_MASK) ? 1 : 0) << 7;
  

3. 移除字符串中转开销 #

• 取消二进制字符串存储，直接用整数数组保存读取到的字节数据，跳过strtol转换步骤：

  uint8_t chunks[3];
  // 读取数据时直接赋值
  chunks[i] = byte_data;
  

  中断函数中可直接打印整数的十六进制格式，无需字符串转换。

4. 优化中断函数执行效率 #

• 中断内的printf是阻塞IO，会导致高频下中断延迟。改用内存缓冲区缓存日志，主循环批量打印：

  #define BUFFER_SIZE 1024
  char log_buffer[BUFFER_SIZE];
  int buffer_pos = 0;
  
  void chipselectInt(void) {
      int len = snprintf(&log_buffer[buffer_pos], BUFFER_SIZE - buffer_pos, 
                        "%d,0x%x,0x%x,0x%x\n", i, chunks[0], chunks[1], chunks[2]);
      buffer_pos += len;
  }
  
  // 主循环中添加批量打印逻辑
  if (buffer_pos >= BUFFER_SIZE - 256) {
      fwrite(log_buffer, 1, buffer_pos, stdout);
      buffer_pos = 0;
  }
  

5. 精准控制klaro引脚时序 #

• 避免无意义的digitalWrite(klaro, LOW)重复调用，仅在需要复位锁存器时触发状态变化。根据锁存器的时序要求，精准控制脉冲宽度，减少GPIO操作开销。

6. 开启编译优化 #

• 编译时添加-O2或-O3优化参数，让编译器自动优化冗余代码：

  gcc -O2 your_program.c -o your_program -lwiringPi
  

内容的提问来源于stack exchange，提问作者red