\n", prog_name);printf("例如: %s pin3 up # 拉高pin3\n", prog_name);printf("例如: %s pin5 down # 拉低pin5\n", prog_name);printf("例如: %s pin7 get # 读取pin7\n", prog_name);printf("例如: %s all up # 拉高所有pin\n", prog_name);printf("例如: %s all down # 拉低所有pin\n", prog_name);printf("例如: %s all get # 读取所有pin状态\n", prog_name);printf("\n支持的引脚:\n");for (int i = 0; i < PIN_COUNT; i++) {printf("pin%d(GPIO%d) ", pin_mapping[i].pin, pin_mapping[i].gpio_num);if ((i + 1) % 4 == 0) printf("\n");}printf("\n");}/**
* 主函数
*/int main(int argc, char *argv[]) {if (argc < 3) {show_help(argv[0]);return 1;}char *pin_str = argv[1];char *action_str = argv[2];// 解析动作参数int action;if (strcmp(action_str, "up") == 0) {
action = 1;} else if (strcmp(action_str, "down") == 0) {
action = 0;} else if (strcmp(action_str, "get") == 0) {
action = 2;} else {printf("错误: 动作必须是up, down或get\n");return 1;}// 处理all命令if (strcmp(pin_str, "all") == 0) {if (action == 2) {return read_all_pins();} else {return control_all_pins(action);}}// 解析引脚号int pin;if (sscanf(pin_str, "pin%d", &pin) != 1) {printf("错误: 无效的引脚格式，请使用pin3, pin5等\n");return 1;}const pin_map_t *pin_info = get_pin_info(pin);if (pin_info == NULL) {printf("错误: 不支持的引脚 pin%d\n", pin);return 1;}printf("控制 pin%d (GPIO%d)...\n", pin, pin_info->gpio_num);return control_gpio_sysfs(pin_info->gpio_num, action);}
```
将交叉编译后可执行文件推送到开发板并赋权：
```bash
adb push <本地存放路径>/pin_control_sysfs /data/local/tmp/pin_control_sysfs
adb shell "chmod +x /data/local/tmp/pin_control_sysfs"
adb shell "ls -lh /data/local/tmp/pin_control_sysfs"
```
进入设备端shell并运行工具以查看用法：
```bash
adb shell
cd /data/local/tmp
./pin_control_sysfs
```
运行后会打印可用命令和已支持的40‑pin引脚映射，示例输出如下：
```{image} images/image_MaFJbuvqkoRmdfxSIiucg8ocnAe.webp
:width: 575px
:height: 330px
```
3. 常用操作示例：
- 拉高单个引脚：`./pin_control_sysfs pin7 up`
- 拉低单个引脚：`./pin_control_sysfs pin7 down`
- 读取单个引脚：`./pin_control_sysfs pin7 get`
- 操作全部引脚：`./pin_control_sysfs all up | all down | all get`
> 提示：运行时确保目标引脚未被其它功能（如I2C/SPI/UART）占用，建议先通过扩展板指示灯或万用表确认电平变化是否符合预期。
## I2C测试
40‑pin接口的pin3和pin5默认为I2C的数据和时钟引脚。为了测试I2C接口，我们需要外接一个I2C设备。此处我们选用微雪环境传感器扩展板，对应的设备节点为 `/dev/i2c-1`。
### 测试准备
| **
IC
** | **
I2C Addr
** | **
ID Reg
** | **
期望ID返回值
** |
| --- | --- | --- | --- |
|
WSL25911FN
|
0x29
|
0x12
|
0x50
|
|
BME280
|
0x76
|
0xD0
|
0x60
|
|
MPU9250
|
0x68
|
0x75
|
0x71
|
|
LTR390-UV-1
|
0x53
|
0x06
|
0xB2
|
PS:此处的WSL25911FN在读ID寄存器的时候需要带上command bit，也就是0xA0，即寄存器 0x12 实际访问时常写成 0xA0 | 0x12 = 0xB2，其他的不用。
本次测试使用微雪环境传感器扩展板，通过40‑pin接口进行连接。
**硬件连接示意图：**
```{image} images/image_Zhm2bFko3oRYhhxQ6kVcK8ggnMb.webp
:width: 1189px
:height: 639px
```
接入扩展板的Quectel Pi M1
### 测试方法
```plaintext
adb shell #进入ADB shell
ls -al /dev/i2c* #查看I2C-1是否在对应目录下
i2cdetect -y 1 #查看对应的I2C一共挂了多少个设备
```
```{image} images/image_VKP4bz27doI6CAxVVatcyXrLniG.webp
:width: 526px
:height: 339px
:align: center
```
### I2C读取/写入
```plaintext
i2cget -y 1 0x53 0x05 b #读取i2c1下设备地址为0x53的0x05寄存器的值，大小为一个byte
i2cset -y 1 0x53 0x05 0x03 b #设置i2c1下设备地址为0x53的0x05寄存器的值，大小为一个byte
```
```{image} images/image_ROZdb1zFaoG9LrxHhdCcrbuXnlb.webp
:width: 364px
:height: 112px
:align: center
```
## SPI测试
40-pin接口中的SPI功能对应的设备片选节点为 `/dev/spidev0.0` 和 `/dev/spidev0.1`。在adb中输入以下内容可查看这些节点：
```bash
adb shell "ls /dev/spidev*"
```
### 微雪OLED显示器测试（cs0和cs1）
请按照以下表格进行接线：
|
OLED引脚
|
应该连接到
|
SC200U物理引脚
|
备注
|
| --- | --- | --- | --- |
| VCC | 3.3V电源 | Pin1或Pin17 | 必须是3.3V |
| GND | 地线 | Pin6/9/14等任意GND | 共地 |
| DIN/MOSI | SPI数据 | Pin19 | SPI_MOSI |
| CLK/SCK | SPI时钟 | Pin23 | SPI_CLK |
| CS/CE | 片选 | Pin24/Pin26 | SPI_CE0/SPI_CE1 |
| D/C | 数据/命令 | Pin22 | GPIO80 |
| RES/RST | 复位 | Pin18 | GPIO25 |
**硬件连接示意图：**
```{image} images/image_Fwf8bsi5Yofjoax5Ad5cmHr0nPd.webp
:width: 1137px
:height: 645px
```
SPI0.0 (CE0, Pin24) 测试 - OLED显示 "ANDROID SPI0.0"
```{image} images/image_MVUjbjOjyoJRRrxl1ekcdPa7nAc.webp
:width: 1176px
:height: 646px
```
SPI0.1 (CE1, Pin26) 测试 - OLED显示 "ANDROID SPI0.1"
**执行步骤：**
创建源文件
新建 `test_spi.c` 文件，内容如下：
test_spi源码（可自行使用NDK或交叉编译）
```c
/*
* Test both CE0 and CE1 - requires manual wire switching
* This helps verify which CS pin your OLED is connected to
* Enhanced with text display and FPS performance test
*/#include #include #include #include #include #include #include #include #include #define GPIO_BASE 398#define GPIO_RST (GPIO_BASE + 25)#define GPIO_DC (GPIO_BASE + 80)#define SPI_MODE SPI_MODE_3#define SPI_SPEED 8000000#define OLED_WIDTH 128#define OLED_HEIGHT 32#define OLED_PAGES 4// Complete 5x7 fontstatic const uint8_t font_5x7[][5] = {{0x00, 0x00, 0x00, 0x00, 0x00}, // Space{0x3E, 0x51, 0x49, 0x45, 0x3E}, // 0{0x00, 0x42, 0x7F, 0x40, 0x00}, // 1{0x42, 0x61, 0x51, 0x49, 0x46}, // 2{0x21, 0x41, 0x45, 0x4B, 0x31}, // 3{0x18, 0x14, 0x12, 0x7F, 0x10}, // 4{0x27, 0x45, 0x45, 0x45, 0x39}, // 5{0x3C, 0x4A, 0x49, 0x49, 0x30}, // 6{0x01, 0x71, 0x09, 0x05, 0x03}, // 7{0x36, 0x49, 0x49, 0x49, 0x36}, // 8{0x06, 0x49, 0x49, 0x29, 0x1E}, // 9{0x7E, 0x11, 0x11, 0x11, 0x7E}, // A{0x7F, 0x49, 0x49, 0x49, 0x36}, {0x3E, 0x41, 0x41, 0x41, 0x22}, // B C{0x7F, 0x41, 0x41, 0x22, 0x1C}, {0x7F, 0x49, 0x49, 0x49, 0x41}, // D E{0x7F, 0x09, 0x09, 0x09, 0x01}, {0x3E, 0x41, 0x49, 0x49, 0x7A}, // F G{0x7F, 0x08, 0x08, 0x08, 0x7F}, {0x00, 0x41, 0x7F, 0x41, 0x00}, // H I{0x20, 0x40, 0x41, 0x3F, 0x01}, {0x7F, 0x08, 0x14, 0x22, 0x41}, // J K{0x7F, 0x40, 0x40, 0x40, 0x40}, {0x7F, 0x02, 0x0C, 0x02, 0x7F}, // L M{0x7F, 0x04, 0x08, 0x10, 0x7F}, {0x3E, 0x41, 0x41, 0x41, 0x3E}, // N O{0x7F, 0x09, 0x09, 0x09, 0x06}, {0x3E, 0x41, 0x51, 0x21, 0x5E}, // P Q{0x7F, 0x09, 0x19, 0x29, 0x46}, {0x46, 0x49, 0x49, 0x49, 0x31}, // R S{0x01, 0x01, 0x7F, 0x01, 0x01}, {0x3F, 0x40, 0x40, 0x40, 0x3F}, // T U{0x1F, 0x20, 0x40, 0x20, 0x1F}, {0x3F, 0x40, 0x38, 0x40, 0x3F}, // V W{0x63, 0x14, 0x08, 0x14, 0x63}, {0x07, 0x08, 0x70, 0x08, 0x07}, // X Y{0x61, 0x51, 0x49, 0x45, 0x43}, // Z{0x08, 0x08, 0x08, 0x08, 0x08}, // -{0x00, 0x36, 0x36, 0x00, 0x00}, // :{0x00, 0x60, 0x60, 0x00, 0x00}, // .};static int char_to_index(char c) {if (c == ' ') return 0;if (c >= '0' && c <= '9') return 1 + (c - '0');if (c >= 'A' && c <= 'Z') return 11 + (c - 'A');if (c >= 'a' && c <= 'z') return 11 + (c - 'a');if (c == '-') return 37;if (c == ':') return 38;if (c == '.') return 39;return 0;}int gpio_write(int gpio, int value);void oled_quick_test(const char *device, const char *name);int main() {printf("\n╔════════════════════════════════════════════════════════╗\n");printf("║ Chip Select Pin Comparison Tool ║\n");printf("╚════════════════════════════════════════════════════════╝\n");printf("\nThis tool helps identify which CS pin is connected.\n");printf("\nInstruction:\n");printf(" 1. Connect OLED CS to Pin24 first\n");printf(" 2. Run test - should see display\n");printf(" 3. Move OLED CS to Pin26\n");printf(" 4. Run test again - should see display\n");printf("\n");char choice;printf("Which pin is your OLED CS currently connected to?\n");printf(" [0] Pin24 (CE0)\n");printf(" [1] Pin26 (CE1)\n");printf("Choice: ");scanf(" %c", &choice);if (choice == '0') {printf("\nTesting CE0 (Pin24)...\n");oled_quick_test("/dev/spidev0.0", "CE0-PIN24");} else if (choice == '1') {printf("\nTesting CE1 (Pin26)...\n");oled_quick_test("/dev/spidev0.1", "CE1-PIN26");} else {printf("Invalid choice\n");return 1;}return 0;}void oled_quick_test(const char *device, const char *name) {// Display bufferstatic uint8_t buffer[OLED_PAGES][OLED_WIDTH];// Simple GPIO functionsint gpio_export(int gpio) {int fd = open("/sys/class/gpio/export", O_WRONLY);if (fd < 0) return -1;char buf[10];snprintf(buf, sizeof(buf), "%d", gpio);write(fd, buf, strlen(buf));close(fd);usleep(100000);return 0;}int gpio_set_dir(int gpio) {char path[50];snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/direction", gpio);int fd = open(path, O_WRONLY);if (fd < 0) return -1;write(fd, "out", 3);close(fd);return 0;}int gpio_write(int gpio, int value) {char path[50];snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", gpio);int fd = open(path, O_WRONLY);if (fd < 0) return -1;char buf[2] = {value ? '1' : '0', 0};write(fd, buf, 1);close(fd);return 0;}void send_cmd(int fd, uint8_t cmd) {gpio_write(GPIO_DC, 0);write(fd, &cmd, 1);usleep(1000);}void set_pixel(int x, int y, int color) {if (x >= 0 && x < OLED_WIDTH && y >= 0 && y < OLED_HEIGHT) {int page = y / 8;int bit = y % 8;if (color)
buffer[page][x] |= (1 << bit);else
buffer[page][x] &= ~(1 << bit);}}void draw_char(int x, int y, char c) {int idx = char_to_index(c);for (int col = 0; col < 5; col++) {uint8_t data = font_5x7[idx][col];for (int row = 0; row < 8; row++) {if (data & (1 << row)) {set_pixel(x + col, y + row, 1);}}}}void draw_text(int x, int y, const char *text) {int cursor = x;while (*text) {draw_char(cursor, y, *text);
cursor += 6;
text++;}}void clear_buffer() {memset(buffer, 0, OLED_PAGES * OLED_WIDTH);}void display_buffer(int fd) {for (int page = 0; page < OLED_PAGES; page++) {send_cmd(fd, 0xB0 + page);send_cmd(fd, 0x04);send_cmd(fd, 0x10);gpio_write(GPIO_DC, 1);write(fd, buffer[page], OLED_WIDTH);}}// Initialize GPIOgpio_export(GPIO_RST);gpio_export(GPIO_DC);usleep(200000);gpio_set_dir(GPIO_RST);gpio_set_dir(GPIO_DC);// Open SPIprintf(" Opening %s...\n", device);int spi_fd = open(device, O_RDWR);if (spi_fd < 0) {perror(" ERROR: Cannot open device");printf(" → %s is NOT working or OLED not connected\n", name);return;}printf(" ✓ Device opened\n");// Configure SPIuint8_t mode = SPI_MODE;uint32_t speed = SPI_SPEED;ioctl(spi_fd, SPI_IOC_WR_MODE, &mode);ioctl(spi_fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);// Reset OLEDprintf(" Resetting OLED...\n");gpio_write(GPIO_RST, 0);usleep(50000);gpio_write(GPIO_RST, 1);usleep(50000);// Initialize OLEDprintf(" Initializing OLED...\n");send_cmd(spi_fd, 0xAE);send_cmd(spi_fd, 0x04); send_cmd(spi_fd, 0x10); send_cmd(spi_fd, 0x40);send_cmd(spi_fd, 0x81); send_cmd(spi_fd, 0xFF);send_cmd(spi_fd, 0xA1); send_cmd(spi_fd, 0xA6);send_cmd(spi_fd, 0xA8); send_cmd(spi_fd, 0x1F);send_cmd(spi_fd, 0xC8);send_cmd(spi_fd, 0xD3); send_cmd(spi_fd, 0x00);send_cmd(spi_fd, 0xD5); send_cmd(spi_fd, 0xF0);send_cmd(spi_fd, 0xD8); send_cmd(spi_fd, 0x05);send_cmd(spi_fd, 0xD9); send_cmd(spi_fd, 0xC2);send_cmd(spi_fd, 0xDA); send_cmd(spi_fd, 0x12);send_cmd(spi_fd, 0xDB); send_cmd(spi_fd, 0x08);send_cmd(spi_fd, 0xAF);printf(" ✓ OLED initialized\n");// Test 1: Display "USING: CE0" or "USING: CE1"printf("\n [Test 1] Displaying chip select info...\n");clear_buffer();draw_text(10, 4, "USING:");if (strstr(name, "CE0")) {draw_text(25, 16, "CE0");} else {draw_text(25, 16, "CE1");}display_buffer(spi_fd);printf(" ✓ Screen showing: USING %s\n", strstr(name, "CE0") ? "CE0" : "CE1");sleep(3);// Test 2: Fill whiteprintf("\n [Test 2] Filling screen WHITE...\n");memset(buffer, 0xFF, OLED_PAGES * OLED_WIDTH);display_buffer(spi_fd);printf(" ✓ Screen should be WHITE\n");sleep(2);// Test 3: Blink testprintf("\n [Test 3] Blink test (5 times)...\n");for (int i = 0; i < 5; i++) {// Whitememset(buffer, 0xFF, OLED_PAGES * OLED_WIDTH);display_buffer(spi_fd);usleep(200000);// Blackmemset(buffer, 0x00, OLED_PAGES * OLED_WIDTH);display_buffer(spi_fd);usleep(200000);printf(" Blink %d/5\n", i + 1);}printf(" ✓ Blink test complete\n");// Test 4: FPS Performance Testprintf("\n [Test 4] FPS Performance Test...\n");printf(" Running 100 frame updates...\n");struct timespec start, end;clock_gettime(CLOCK_MONOTONIC, &start);for (int frame = 0; frame < 100; frame++) {// Generate test patternfor (int page = 0; page < OLED_PAGES; page++) {for (int x = 0; x < OLED_WIDTH; x++) {
buffer[page][x] = (x + frame) & 0xFF;}}display_buffer(spi_fd);}clock_gettime(CLOCK_MONOTONIC, &end);double elapsed = (end.tv_sec - start.tv_sec) +
(end.tv_nsec - start.tv_nsec) / 1000000000.0;double fps = 100.0 / elapsed;printf(" ✓ Performance: %.1f FPS\n", fps);// Display FPS result on screenclear_buffer();draw_text(10, 4, "FPS TEST");char fps_str[20];snprintf(fps_str, sizeof(fps_str), "%.1f FPS", fps);draw_text(20, 16, fps_str);display_buffer(spi_fd);printf(" ✓ FPS result displayed on screen\n");sleep(3);// Test 5: CS Pin Functionality Testprintf("\n [Test 5] CS Pin Functionality Test...\n");printf(" This test verifies CS pin actually controls the device\n");// Step 1: Display number 1printf(" Step 1: Displaying pattern 1...\n");clear_buffer();draw_text(15, 4, "PATTERN");draw_text(50, 16, "1");display_buffer(spi_fd);sleep(2);// Step 2: Try to update through the OTHER CS (should fail if CS works)printf(" Step 2: Trying to update via OTHER CS...\n");const char *other_device = strstr(name, "CE0") ? "/dev/spidev0.1" : "/dev/spidev0.0";const char *other_name = strstr(name, "CE0") ? "CE1" : "CE0";int other_fd = open(other_device, O_RDWR);if (other_fd >= 0) {uint8_t mode = SPI_MODE;uint32_t speed = SPI_SPEED;ioctl(other_fd, SPI_IOC_WR_MODE, &mode);ioctl(other_fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);// Try to display pattern 2 via other CSclear_buffer();draw_text(15, 4, "PATTERN");draw_text(50, 16, "2");for (int page = 0; page < OLED_PAGES; page++) {send_cmd(other_fd, 0xB0 + page);send_cmd(other_fd, 0x04);send_cmd(other_fd, 0x10);gpio_write(GPIO_DC, 1);write(other_fd, buffer[page], OLED_WIDTH);}close(other_fd);printf(" Sent update via %s (other CS)\n", other_name);sleep(2);printf("\n ╔════════════════════════════════════════════════╗\n");printf(" ║ CHECK SCREEN: Still showing '1' or changed to '2'? ║\n");printf(" ╚════════════════════════════════════════════════╝\n");printf("\n If still showing '1': CS pin is WORKING correctly ✓\n");printf(" If changed to '2': CS pin NOT working (both CS active) ✗\n\n");sleep(2);}// Step 3: Update back via correct CSprintf(" Step 3: Updating via correct CS (%s)...\n", name);clear_buffer();draw_text(15, 4, "BACK TO");draw_text(50, 16, "1");display_buffer(spi_fd);printf(" ✓ Should see pattern 1 again\n");sleep(2);// Test 6: FPS result summaryprintf("\n [Test 6] Final Summary...\n");clear_buffer();draw_text(30, 4, name);char summary_str[20];snprintf(summary_str, sizeof(summary_str), "%.1fFPS", fps);draw_text(20, 16, summary_str);display_buffer(spi_fd);printf(" ✓ Summary displayed\n");sleep(3);// Clear screenclear_buffer();display_buffer(spi_fd);close(spi_fd);printf("\n======================================================================\n");printf(" %s Test Complete!\n", name);printf("======================================================================\n");printf(" CS Pin Test Result:\n");printf(" If screen didn't change to '2' in Step 2:\n");printf(" → CS pin is working correctly ✓\n");printf(" If screen changed to '2':\n");printf(" → CS pin might not be controlling the device ✗\n");printf(" → Both CS pins may be active simultaneously\n");printf("\n Performance: %.1f FPS\n", fps);printf("======================================================================\n");}
```
```bash
adb root
adb push "D:\tools\40pin android\test_android_spi" /data/local/tmp/test_android_spi
adb shell "chmod +x /data/local/tmp/test_android_spi"
adb shell
cd /data/local/tmp/
./test_android_spi
```
程序运行后会提示选择SPI设备：
- **选择0**：使用 `/dev/spidev0.0` (CE0, Pin24)
- **选择1**：使用 `/dev/spidev0.1` (CE1, Pin26)
请根据实际接线情况选择对应的设备（CS/CE引脚连接到pin24则选择0，连接到pin26则选择1）。
**测试结果：**
程序执行后会依次进行以下测试：
```plaintext
╔══════════════════════════════════════════════════════╗
║ Android SPI OLED 测试程序 ║
║ 适配Android设备 ║
╚══════════════════════════════════════════════════════╝
选择SPI设备:
[0] /dev/spidev0.0 (CE0, Pin24)
[1] /dev/spidev0.1 (CE1, Pin26)
[c] 自定义设备路径
选择: 1
使用设备: /dev/spidev0.1
初始化GPIO...
✓ GPIO初始化成功
打开SPI设备: /dev/spidev0.1
✓ SPI设备已打开并配置
- 模式: 3
- 速度: 2000000 Hz
- 位宽: 8 bits
初始化OLED...
复位OLED...
发送初始化命令...
✓ OLED初始化完成
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
开始测试序列: SPI0.1
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[测试1] 显示设备信息...
✓ 屏幕应显示: ANDROID SPI0.1
[测试2] 全白屏测试...
✓ 屏幕应全白
[测试3] 闪烁测试 (5次)...
闪烁 1/5
闪烁 2/5
闪烁 3/5
闪烁 4/5
闪烁 5/5
✓ 闪烁测试完成
[测试4] FPS性能测试...
运行100帧更新...
✓ 性能: 40.3 FPS (耗时: 2.48秒)
✓ FPS结果已显示
[测试5] 图案测试...
图案1: 横条纹
图案2: 竖条纹
图案3: 棋盘格
✓ 图案测试完成
[测试6] 测试总结...
✓ 总结已显示
```
**测试说明：**
- 测试1：验证OLED能够正常显示文本信息
- 测试2：验证OLED全屏显示功能
- 测试3：通过闪烁测试验证OLED刷新功能
- 测试4：测试SPI通信性能（FPS值）
- 测试5：测试不同图案显示功能
- 测试6：显示测试总结信息
若所有测试项均显示 √ 标记，则表明SPI通信与OLED功能一切正常。
---
## UART测试
在 **40-pin** 接口中，**pin8** 和 **pin10** 默认配置为 **UART** 功能，对应的设备节点为 **/dev/ttyHS0**。
**查看串口设备**
可以使用以下命令查看系统中所有的串口设备：
```bash
ls /dev/tty*
```
### UART回环测试
本测试通过将 **pin8** 和 **pin10** 短接，验证串口收发功能是否正常。
**硬件连接：** 将40‑pin的pin8（TX）和pin10（RX）短接。
**执行步骤：** 创建源文件
新建 `uart_loopback.c` 文件，内容如下：
uart_loopback源码（可自行使用NDK或交叉编译）
```c
#include #include #include #include #include #include #include #include // 全局变量用于信号处理static int serial_fd = -1;static volatile int running = 1;// 信号处理函数void signal_handler(int sig) {printf("\n用户中断测试\n");
running = 0;if (serial_fd >= 0) {close(serial_fd);printf("串口已关闭\n");}exit(0);}// 配置串口参数int configure_serial(int fd, int baudrate) {struct termios tty;if (tcgetattr(fd, &tty) != 0) {printf("获取串口属性失败: %s\n", strerror(errno));return -1;}// 设置波特率speed_t speed;switch (baudrate) {case 9600: speed = B9600; break;case 19200: speed = B19200; break;case 38400: speed = B38400; break;case 57600: speed = B57600; break;case 115200: speed = B115200; break;case 230400: speed = B230400; break;default: speed = B115200; break;}cfsetospeed(&tty, speed);cfsetispeed(&tty, speed);// 配置串口参数
tty.c_cflag &= ~PARENB; // 无奇偶校验
tty.c_cflag &= ~CSTOPB; // 1个停止位
tty.c_cflag &= ~CSIZE; // 清除数据位设置
tty.c_cflag |= CS8; // 8个数据位
tty.c_cflag &= ~CRTSCTS; // 禁用硬件流控制
tty.c_cflag |= CREAD | CLOCAL; // 启用接收和本地连接// 配置输入模式
tty.c_iflag &= ~(IXON | IXOFF | IXANY); // 禁用软件流控制
tty.c_iflag &= ~(ICANON | ECHO | ECHOE | ISIG); // 原始模式// 配置输出模式
tty.c_oflag &= ~OPOST; // 原始输出// 配置本地模式
tty.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // 原始模式// 设置超时
tty.c_cc[VTIME] = 10; // 1秒超时
tty.c_cc[VMIN] = 0; // 非阻塞读取if (tcsetattr(fd, TCSANOW, &tty) != 0) {printf("设置串口属性失败: %s\n", strerror(errno));return -1;}return 0;}// UART回环测试函数int serial_loopback_test(const char* port, int baudrate) {char test_data[] = "Hello, Serial Loopback!";char received_data[256];ssize_t bytes_written, bytes_read;// 打开串口设备
serial_fd = open(port, O_RDWR | O_NOCTTY | O_SYNC);if (serial_fd < 0) {printf("无法打开串口 %s: %s\n", port, strerror(errno));return -1;}// 配置串口if (configure_serial(serial_fd, baudrate) != 0) {close(serial_fd);return -1;}printf("串口 %s 已打开，开始回环测试（按Ctrl+C退出）...\n", port);while (running) {// 清空接收缓冲区tcflush(serial_fd, TCIOFLUSH);// 发送数据
bytes_written = write(serial_fd, test_data, strlen(test_data));if (bytes_written < 0) {printf("发送数据失败: %s\n", strerror(errno));break;}printf("发送: %s\n", test_data);// 等待数据接收usleep(100000); // 100ms// 读取回环数据
bytes_read = read(serial_fd, received_data, sizeof(received_data) - 1);if (bytes_read < 0) {printf("读取数据失败: %s\n", strerror(errno));break;}
received_data[bytes_read] = '\0'; // 添加字符串结束符// 验证结果if (bytes_read == strlen(test_data) &&
strncmp(received_data, test_data, strlen(test_data)) == 0) {printf("接收: %s → 测试通过\n\n", received_data);} else {printf("接收异常: 发送[%zu] vs 接收[%zd] → 测试失败\n",
strlen(test_data), bytes_read);if (bytes_read > 0) {printf("接收内容: %s\n\n", received_data);} else {printf("未接收到数据\n\n");}}sleep(1); // 间隔1秒重复测试}close(serial_fd);printf("串口 %s 已关闭\n", port);return 0;}int main(int argc, char* argv[]) {const char* port = "/dev/ttyHS0"; // 默认串口int baudrate = 115200; // 默认波特率// 解析命令行参数if (argc >= 2) {
port = argv[1];}if (argc >= 3) {
baudrate = atoi(argv[2]);}// 设置信号处理signal(SIGINT, signal_handler);signal(SIGTERM, signal_handler);printf("UART回环测试程序\n");printf("使用串口: %s\n", port);printf("波特率: %d\n", baudrate);printf("=====================================\n");// 执行回环测试int result = serial_loopback_test(port, baudrate);return result;}
```
**执行步骤：**
```bash
adb root
adb push <本地路径>/uart_loopback_test /data/local/tmp/uart_loopback
adb shell chmod +x /data/local/tmp/uart_loopback
adb shell ls -la /data/local/tmp/
adb shell
cd /data/local/tmp/
./uart_loopback
```
**测试结果：**
当pin8和pin10正确短接时，程序会持续发送数据并验证接收的数据是否一致：
```plaintext
UART回环测试程序
使用串口: /dev/ttyHS0
波特率: 115200
=====================================
串口 /dev/ttyHS0 已打开，开始回环测试（按Ctrl+C退出）...
发送: Hello, Serial Loopback!
接收: Hello, Serial Loopback! → 测试通过
发送: Hello, Serial Loopback!
接收: Hello, Serial Loopback! → 测试通过
发送: Hello, Serial Loopback!
接收: Hello, Serial Loopback! → 测试通过
```
按 `Ctrl+C` 可退出测试程序。程序会自动关闭串口并退出。
# 散热器控制
## 温控风扇原理
后台进程检测/sys/class/thermal/thermal_zone*
并轮读几个核的温度取最高，并且根据最高温度来配置风扇的PWM占空比。
|
温度
|
占空比/255
|
| --- | --- |
|
<30℃
|
0
|
|
30~40℃
|
64
|
|
40~50℃
|
128
|
|
50~60℃
|
192
|
|
＞60℃
|
255
|
| **风扇引脚** | **M1开发板引脚（40PIN）** |
| --- | --- |
| 红线（电源正极） | PIN2 |
| 黑线（电源负极） | PIN5 |
| 蓝线（PWM） | PIN33 |
```{image} images/image_E7PFbFE7hoYzQWxStjOcFUWnnEI.webp
:width: 2304px
:height: 1728px
:align: center
```
## 测试流程
默认风扇功能是关闭的，开机后输入对应指令查看风扇服务的状态
```plaintext
/system/bin/sh /vendor/bin/40Pin-ctrl fan status #查看当前风扇服务的状态，未启用风扇服务为disabled，启用为enable
/system/bin/sh /vendor/bin/40Pin-ctrl fan enable #使能风扇服务，使能后可以查看下状态是否为enable
/system/bin/sh /vendor/bin/40Pin-ctrl fan disable #关闭风扇服务，停止测试才需要输入该指令
```
在第一个终端里面输入
```plaintext
/system/bin/sh /vendor/bin/40Pin-ctrl fan status
/system/bin/sh /vendor/bin/40Pin-ctrl fan enable
#SC200U
watch -n 1 'PWM=/sys/class/pwm/pwmchip0/pwm0; p=$(cat "$PWM/period"); d=$(cat "$PWM/duty_cycle"); echo $(( (d * 255 + p / 2) / p ))'
#SC200E
watch -n 1 'PWM=/sys/bus/platform/devices/1c40000.qcom,spmi:qcom,pm2250@1:qcom,pwms@be00/pwm/pwmchip2/pwm0; p=$(cat "$PWM/period"); d=$(cat "$PWM/duty_cycle"); echo $(( (d * 255 + p / 2) / p ))'
```
开第二个终端，做升温
```plaintext
for i in 1 2 3 4; do
yes > /dev/null &
done
```
如果第3步里面的升温不够可以把负载调大
```plaintext
for i in $(seq 1 $(nproc)); do
yes > /dev/null &
done
```
看两个终端里面的温度和风扇的PWM占空比是不是和表里面的对齐
```{image} images/image_TfC8bmNR9oCOmCxnS6LckH0cnqd.webp
:width: 1021px
:height: 263px
:align: center
```
测试结束后停止负载
```plaintext
killall yes
```
# 应用场景
- **媒体娱乐终端**: 使用 **Quectel Pi M1** 智能主控板作为媒体娱乐终端，可以播放视频、音乐、查看图片等。
- **工业数据可视化平台**: 使用 **Quectel Pi M1** 智能主控板作为工业数据可视化平台，可以显示工业数据、监控设备运行情况、进行数据处理等。
- **智能交互终端**：使用 **Quectel Pi M1** 智能主控板作为智能交互终端，可以使用于各类的人机交互应用。
# 疑难解答
## 如何查看系统日志
查看系统日志，需要将串口线接至电脑，并使用串口工具查看日志。
## 黑屏问题
在正常连接好设备后，开机后显示 **黑屏**，可能是以下的情况：
**电源连接问题：**
检查显示屏的供电接口是否正确连接，确认4个供电接口中至少有一个已正确连接，确保供电螺丝已拧紧，顶针与40-pin接口接触良好。
**连接线路问题：**
检查MIPI排线是否正确插入并牢固连接，确认排线方向是否正确，避免插反，检查连接器是否有物理损坏。
**系统启动问题：**
确认系统已正常启动并加载显示服务，查看系统日志确认显示驱动是否正常加载。
## 花屏问题
在正常连接好设备后，开机后显示 **花屏**，可能是以下的情况：
**信号干扰：**
检查MIPI排线是否过长或质量不佳，确认排线周围是否有强电磁干扰源，尝试更换高质量的MIPI排线。
**硬件兼容性问题：**
确认使用的显示屏型号与 **Quectel Pi M1** 完全兼容，检查显示屏固件版本是否为最新版本。
## 触摸功能异常
触摸功能异常，可能是以下情况：
**驱动问题：**
确认系统已正确加载触摸屏驱动，检查I2C通信是否正常建立。