周日业余时间太无聊，又不喜欢玩游戏，大家的兴趣爱好都是啥？我觉得敲代码也是一种兴趣爱好。正巧手边有一块儿0.96寸的OLED显示屏，一直在吃灰，何不把玩一把？于是说干就干，最后在我的imax6ul的linux开发板上使用spi用户态驱动成功点亮。这里总结下过程，分享给有需要的小伙伴。

前言

本文主要介绍在imax6ul-mini开发板上如何驱动OLED显示屏外设，总结下过程。由于板子默认是spi接口的，这里先玩一把spi接口的驱动，后续计划改为i2c的接口驱动再玩一次。

我的环境资源：

Linux内核：linux-4.1.15

所用开发板：正点原子imax6ul-mini

所用OLED 屏幕：中景园电子0.96 寸OLED 显示屏12864液晶屏模块（支持spi和i2c接口）

所用OLED 驱动芯片：SH1106

完整源码下载地址：

https://download.csdn.net/download/qq8864/88117562

效果截图：

实现方案

想要驱动中景园电子的这款OLED显示屏，方案有很多。这个模块同时支持spi和i2c接口，所以肯定需要使用linux的spi或i2c驱动。

以 spi驱动为例，在嵌入式Linux下，实现SPI驱动的方式有多种。以下是其中几种常见的方式：

1. 使用GPIO控制模拟SPI：使用GPIO接口控制SPI总线的时序和数据传输，需要自行编写驱动程序来实现SPI通信。

2. 使用SPI框架驱动：Linux内核提供了SPI框架驱动，可以通过注册SPI设备和驱动来实现SPI通信。需要编写SPI设备和驱动的代码。

3. 使用spidev驱动：spidev是Linux内核提供的一个通用的SPI设备驱动接口，可以简化SPI设备的使用。它提供了用户空间的API，通过打开/dev/spidev设备文件，使用ioctl函数进行SPI通信。使用spidev驱动可以方便地在用户空间进行SPI通信，而无需编写内核驱动程序。

这里要介绍的实现方式是使用spidev驱动驱动。原因是因为操作OLED屏幕，需要自定义一系列的操作接口如oled_dispString() ，oled_clear()等。虽然使用方式2是较为流行的一种，但是需要注册到字符设备框架下，提供文件系统的操作接口的方式用，用起来稍显麻烦，还需再次封装一下。

spidev驱动是一个通用的SPI设备驱动接口，它允许用户空间通过简单的API与SPI设备进行通信。用户可以通过打开/dev/spidev设备文件，使用ioctl函数进行SPI通信。spidev驱动提供了一些常用的操作函数，如配置SPI模式、设置时钟频率、传输数据等。使用spidev驱动可以方便地在用户空间进行SPI通信，而无需编写内核驱动程序。

与传统的SPI驱动相比，spidev驱动的优点是简单易用，无需编写内核驱动程序，只需在用户空间使用ioctl函数进行SPI通信。但是，spidev驱动也有一些限制，例如无法支持中断和DMA传输等高级功能。如果需要使用这些高级功能，可能需要编写自定义的SPI驱动程序。

实现过程

首先需要确认内核配置开启了spidev驱动。参见博文：嵌入式linux通用spi驱动之spidev使用总结_特立独行的猫a的博客-CSDN博客

修改设备树

修改imx6ull-14x14-evk.dts文件，该设备树文件位于内核源码 linux/arch/arm/boot/dts/目录下。

&ecspi3 {
        fsl,spi-num-chipselects = <2>;/*cs管脚数配置*/
        cs-gpios = <0>,<&gpio1 20 GPIO_ACTIVE_LOW>;/*cs管脚配置*/
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_ecspi3>;
        status = "okay";/* status属性值为"okay" 表示该节点使能*/
 
	spidev: icm20608@0 {
	compatible = "alientek,icm20608";
        spi-max-frequency = <8000000>;
        reg = <0>;/*spi设备是没有设备地址的, 这里是指使用spi控制器的cs-gpios里的第几个片选io　*/
    };
 
	oled: oledsh1106@1 {
	compatible = "yang,oledsh1106";/*重要，会匹配spidev.c中指定的compatible*/
	spi-cpol;/*配置spi信号模式*/
	spi-cpha;
	spi-max-frequency = < 8000000 >;/* 指定spi设备的最大工作时钟 */
    reg = <1>;
    };
};

以上需要注意的是：如果该spi接口下挂载有多个从设备，需要设置fsl,spi-num-chipselects = <2>;默认该值为1。还有需要注意的地方是，cs-gpios 片选信号需要配置对应的个数。以上的为配置了两路片选GPIO管脚，第一个默认的，第二个是指定的。如果仅有一个从设备，可以配置cs-gpio就行了。注意cs-gpio和cs-gpios的区别，带s的标识可以有多个。

修改spidev驱动

默认的spidev.c驱动文件中，是没有匹配你添加的设备的。因此需要修改spidev.c源码，增加compatible匹配。spidev.c源码文件位于linux/drivers/spi/spidev.c

/* The main reason to have this class is to make mdev/udev create the
 * /dev/spidevB.C character device nodes exposing our userspace API.
 * It also simplifies memory management.
 */
 
static struct class *spidev_class;
 
//#ifdef CONFIG_OF
static const struct of_device_id spidev_dt_ids[] = {
	{ .compatible = "rohm,dh2228fv" },
  { .compatible = "yang,oledsh1106" },
	{},
};
MODULE_DEVICE_TABLE(of, spidev_dt_ids);
//#endif

编译内核和设备树

#加载环境
source /opt/fsl-imx-x11/4.1.15-2.1.0/environment-setup-cortexa7hf-neon-poky-linux-gnueabi
#编译内核
make zImage -j16
#编译指定的设备树
make imx6ull-14x14-nand-4.3-480x272-c.dtb

为了方便调试，更新内核和设备树文件，建议最好使用sd卡启动，这样把sd卡抠出来插入电路上，可以很方便的更新内核和设备树文件。 

设备树查看

内核和设备树更新后，启动开发板。可以看下spidev驱动是否生效了。

查看设备树是否有新添加的节点：

更新设备树到板子上后，能够查看到如下生成spi设备节点(spidev2.1)：

经过以上过程，已经成功了一大半啦。或者可以用工具测试下spi驱动接口。

OELD驱动实现

在以上spidev总线驱动就绪的基础上，OELD驱动实现就简单啦。

先看下oled模块板子的接线：

DO对应SPI接口的CLK, D1(spi)数据线对应SPI接口了MOSI。

注意：由于这个屏幕显示不存在读取的情况，SPI的MISO口并未使用，且莫把线接错了。(比如我一开始就把MISO接到DC上啦，这是错的。)。DC口是啥？这是该模块的数据和命令选择管脚，分为发送指令和发送数据两周类型的操作。当发送指令时，DC口需要输出高电平，当发送数据时，DC口需要发送低电平。

SPI（Serial Peripheral Interface）是一种串行外设接口协议，用于在微控制器或其他设备之间进行通信。SPI使用四根线进行通信：SCLK（时钟线）、MOSI（主设备输出从设备输入线）、MISO（主设备输入从设备输出线）和SS（片选线）。

MOSI（Master Out Slave In）是主设备向从设备发送数据的线路，而MISO（Master In Slave Out）是从设备向主设备发送数据的线路。这两条线的功能是相反的，主设备通过MOSI将数据发送给从设备，从设备通过MISO将数据发送给主设备。

SPI协议中的数据传输是双向的，主设备和从设备可以同时发送和接收数据。因此，如果只需要进行写操作，理论上可以只使用MOSI线，而将MISO线悬空不连接。但在实际应用中，为了保持SPI接口的完整性和稳定性，通常还是会将MISO线连接起来，即使在写操作时不使用。

连接MISO线的好处是可以实现双向通信的灵活性，以备将来可能需要读取从设备的数据。另外，MISO线上的数据也可以用于进行错误检测和校验，以提高数据传输的可靠性。

驱动实现

spidev驱动操作

使用spidev驱动的操作方法，大致过程操作如下：

1. 打开SPI设备：

int spi_fd;
spi_fd = open("/dev/spidev0.0", O_RDWR);
if (spi_fd < 0) {
    perror("Failed to open SPI device");
    return -1;
}

2. 设置SPI模式、速度和位数：

int mode = SPI_MODE_0;
int speed = 1000000;
int bits_per_word = 8;
if (ioctl(spi_fd, SPI_IOC_WR_MODE, &mode) < 0) {
    perror("Failed to set SPI mode");
    return -1;
}
if (ioctl(spi_fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed) < 0) {
    perror("Failed to set SPI speed");
    return -1;
}
if (ioctl(spi_fd, SPI_IOC_WR_BITS_PER_WORD, &bits_per_word) < 0) {
    perror("Failed to set SPI bits per word");
    return -1;
}

3. 创建spi_ioc_message结构体，并设置相关字段：

struct spi_ioc_transfer transfer;
memset(&transfer, 0, sizeof(struct spi_ioc_transfer));
transfer.tx_buf = (unsigned long)tx_buffer;  // 发送缓冲区
transfer.rx_buf = (unsigned long)rx_buffer;  // 接收缓冲区
transfer.len = length;  // 数据长度
transfer.speed_hz = speed;  // 传输速度
transfer.bits_per_word = bits_per_word;  // 每个字的位数
transfer.cs_change = 1;  // 控制片选信号的行为

其中，transfer.cs_change为1表示每次传输前会拉低片选信号，传输完成后会拉高片选信号。

4. 发送命令和数据：

if (ioctl(spi_fd, SPI_IOC_MESSAGE(1), &transfer) < 0) {
    perror("Failed to send SPI message");
    return -1;
}

其中，SPI_IOC_MESSAGE(1)表示发送1个spi_ioc_transfer结构体。

OELD驱动接口封装

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>
#include "oledfont.h"
#include "bmp.h"
#include "oled.h"


#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))


static void pabort(const char *s)
{
	perror(s);
	abort();
}

static const char *device = "/dev/spidev2.1";

static int32_t  spi_fd;
static uint32_t spi_mode;
static uint8_t  spi_bits = 8;
static uint32_t spi_speed = 800000;
static uint16_t spi_delay;
static int verbose;

static void hex_dump(const void *src, size_t length, size_t line_size, char *prefix)
{
	int i = 0;
	const unsigned char *address = src;
	const unsigned char *line = address;
	unsigned char c;

	printf("%s | ", prefix);
	while (length-- > 0) {
		printf("%02X ", *address++);
		if (!(++i % line_size) || (length == 0 && i % line_size)) {
			if (length == 0) {
				while (i++ % line_size)
					printf("__ ");
			}
			printf(" | ");  /* right close */
			while (line < address) {
				c = *line++;
				printf("%c", (c < 33 || c == 255) ? 0x2E : c);
			}
			printf("\n");
			if (length > 0)
				printf("%s | ", prefix);
		}
	}
}

/*
 *  Unescape - process hexadecimal escape character
 *      converts shell input "\x23" -> 0x23
 */
static int unescape(char *_dst, char *_src, size_t len)
{
	int ret = 0;
	char *src = _src;
	char *dst = _dst;
	unsigned int ch;

	while (*src) {
		if (*src == '\\' && *(src+1) == 'x') {
			sscanf(src + 2, "%2x", &ch);
			src += 4;
			*dst++ = (unsigned char)ch;
		} else {
			*dst++ = *src++;
		}
		ret++;
	}
	return ret;
}

static int transfer(int fd, uint8_t const *tx, uint8_t const *rx, size_t len)
{
	int ret;

	struct spi_ioc_transfer tr = {
		.tx_buf = (unsigned long)tx,
		.rx_buf = (unsigned long)rx,
		.len = len,
		.delay_usecs = spi_delay,
		.speed_hz = spi_speed,
		.bits_per_word = spi_bits,
        .cs_change = 0,
	};

	if (spi_mode & SPI_TX_QUAD)
		tr.tx_nbits = 4;
	else if (spi_mode & SPI_TX_DUAL)
		tr.tx_nbits = 2;
	if (spi_mode & SPI_RX_QUAD)
		tr.rx_nbits = 4;
	else if (spi_mode & SPI_RX_DUAL)
		tr.rx_nbits = 2;
	if (!(spi_mode & SPI_LOOP)) {
		if (spi_mode & (SPI_TX_QUAD | SPI_TX_DUAL))
			tr.rx_buf = 0;
		else if (spi_mode & (SPI_RX_QUAD | SPI_RX_DUAL))
			tr.tx_buf = 0;
	}

	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
	if (ret < 1)
		pabort("can't send spi message");

	if (verbose){
		hex_dump(tx, len, 32, "TX");
        hex_dump(rx, len, 32, "RX");
    }
    
    return ret;
}

//向SSD1106写入一个字节。
//dat:要写入的数据/命令
//cmd:数据/命令标志 0,表示命令;1,表示数据;
void OLED_WR_Byte(u8 dat,u8 cmd)
{			  
    u8 tx[2];
    u8 rx[2];
    tx[0] = dat;
    if(cmd)
    {
        system("echo 1 > /sys/class/gpio/gpio1/value");
        transfer(spi_fd,tx,rx,1);
    }
    else
    {
       system("echo 0 > /sys/class/gpio/gpio1/value");
       transfer(spi_fd,tx,rx,1);
    }  
} 

//初始化SSD1306					    
void OLED_Init(void)
{ 	
    //OLED_RST_Set();
	usleep(100000);
	//OLED_RST_Clr();
	usleep(100000);
	//OLED_RST_Set(); 
					  
	OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
	OLED_WR_Byte(0x02,OLED_CMD);//---set low column address
	OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
	OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
	OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
	OLED_WR_Byte(0xCF,OLED_CMD); // Set SEG Output Current Brightness
	OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
	OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
	OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
	OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
	OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
	OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset	Shift Mapping RAM Counter (0x00~0x3F)
	OLED_WR_Byte(0x00,OLED_CMD);//-not offset
	OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
	OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
	OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
	OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
	OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
	OLED_WR_Byte(0x12,OLED_CMD);
	OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
	OLED_WR_Byte(0x40,OLED_CMD);//Set VCOM Deselect Level
	OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
	OLED_WR_Byte(0x02,OLED_CMD);//
	OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
	OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
	OLED_WR_Byte(0xA4,OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
	OLED_WR_Byte(0xA6,OLED_CMD);// Disable Inverse Display On (0xa6/a7) 
	OLED_WR_Byte(0xAF,OLED_CMD);//--turn on oled panel
	
	OLED_WR_Byte(0xAF,OLED_CMD); /*display ON*/ 
	OLED_Clear();
	OLED_Set_Pos(0,0); 	
}

void OLED_Set_Pos(unsigned char x, unsigned char y) 
{ 
	OLED_WR_Byte(0xb0+y,OLED_CMD);
	OLED_WR_Byte(((x&0xf0)>>4)|0x10,OLED_CMD);
	OLED_WR_Byte((x&0x0f)|0x01,OLED_CMD); 
}   	  
//开启OLED显示    
void OLED_Display_On(void)
{
	OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
	OLED_WR_Byte(0X14,OLED_CMD);  //DCDC ON
	OLED_WR_Byte(0XAF,OLED_CMD);  //DISPLAY ON
}
//关闭OLED显示     
void OLED_Display_Off(void)
{
	OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
	OLED_WR_Byte(0X10,OLED_CMD);  //DCDC OFF
	OLED_WR_Byte(0XAE,OLED_CMD);  //DISPLAY OFF
}		   			 
//清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!	  
void OLED_Clear(void)  
{  
	u8 i,n;		    
	for(i=0;i<8;i++)  
	{  
		OLED_WR_Byte (0xb0+i,OLED_CMD);    //设置页地址（0~7）
		OLED_WR_Byte (0x02,OLED_CMD);      //设置显示位置—列低地址
		OLED_WR_Byte (0x10,OLED_CMD);      //设置显示位置—列高地址   
		for(n=0;n<128;n++)OLED_WR_Byte(0,OLED_DATA); 
	} //更新显示
}


//在指定位置显示一个字符,包括部分字符
//x:0~127
//y:0~63
//mode:0,反白显示;1,正常显示				 
//size:选择字体 16/12 
void OLED_ShowChar(u8 x,u8 y,u8 chr)
{      	
	unsigned char c=0,i=0;	
		c=chr-' ';//得到偏移后的值			
		if(x>Max_Column-1){x=0;y=y+2;}
		if(SIZE ==16)
			{
			OLED_Set_Pos(x,y);	
			for(i=0;i<8;i++)
			OLED_WR_Byte(F8X16[c*16+i],OLED_DATA);
			OLED_Set_Pos(x,y+1);
			for(i=0;i<8;i++)
			OLED_WR_Byte(F8X16[c*16+i+8],OLED_DATA);
			}
			else {	
				OLED_Set_Pos(x,y+1);
				for(i=0;i<6;i++)
				OLED_WR_Byte(F6x8[c][i],OLED_DATA);
				
			}
}
//m^n函数
u32 oled_pow(u8 m,u8 n)
{
	u32 result=1;	 
	while(n--)result*=m;    
	return result;
}				  
//显示2个数字
//x,y :起点坐标	 
//len :数字的位数
//size:字体大小
//mode:模式	0,填充模式;1,叠加模式
//num:数值(0~4294967295);	 		  
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size)
{         	
	u8 t,temp;
	u8 enshow=0;						   
	for(t=0;t<len;t++)
	{
		temp=(num/oled_pow(10,len-t-1))%10;
		if(enshow==0&&t<(len-1))
		{
			if(temp==0)
			{
				OLED_ShowChar(x+(size/2)*t,y,' ');
				continue;
			}else enshow=1; 
		 	 
		}
	 	OLED_ShowChar(x+(size/2)*t,y,temp+'0'); 
	}
} 
//显示一个字符号串
void OLED_ShowString(u8 x,u8 y,u8 *chr)
{
	unsigned char j=0;
	while (chr[j]!='\0')
	{		OLED_ShowChar(x,y,chr[j]);
			x+=8;
		if(x>120){x=0;y+=2;}
			j++;
	}
}
//显示汉字
void OLED_ShowCHinese(u8 x,u8 y,u8 no)
{      			    
	u8 t,adder=0;
	OLED_Set_Pos(x,y);	
    for(t=0;t<16;t++)
		{
				OLED_WR_Byte(Hzk[2*no][t],OLED_DATA);
				adder+=1;
     }	
		OLED_Set_Pos(x,y+1);	
    for(t=0;t<16;t++)
			{	
				OLED_WR_Byte(Hzk[2*no+1][t],OLED_DATA);
				adder+=1;
      }					
}
/***********功能描述：显示显示BMP图片128×64起始点坐标(x,y),x的范围0～127，y为页的范围0～7*****************/
void OLED_DrawBMP(unsigned char x0, unsigned char y0,unsigned char x1, unsigned char y1,unsigned char BMP[])
{ 	
 unsigned int j=0;
 unsigned char x,y;
  
  if(y1%8==0) y=y1/8;      
  else y=y1/8+1;
	for(y=y0;y<y1;y++)
	{
		OLED_Set_Pos(x0,y);
    for(x=x0;x<x1;x++)
	    {      
	    	OLED_WR_Byte(BMP[j++],OLED_DATA);	    	
	    }
	}
} 

int spidev_init()
{
    int ret = 0;
    spi_mode = SPI_MODE_0;
    verbose = 0;

	spi_fd = open(device, O_RDWR);
	if (spi_fd < 0)
		pabort("can't open device");

	/*
	 * spi mode
	 */
	ret = ioctl(spi_fd, SPI_IOC_WR_MODE32, &spi_mode);
	if (ret == -1)
		pabort("can't set spi mode");

	ret = ioctl(spi_fd, SPI_IOC_RD_MODE32, &spi_mode);
	if (ret == -1)
		pabort("can't get spi mode");

	/*
	 * bits per word
	 */
	ret = ioctl(spi_fd, SPI_IOC_WR_BITS_PER_WORD, &spi_bits);
	if (ret == -1)
		pabort("can't set bits per word");

	ret = ioctl(spi_fd, SPI_IOC_RD_BITS_PER_WORD, &spi_bits);
	if (ret == -1)
		pabort("can't get bits per word");

	/*
	 * max speed hz
	 */
	ret = ioctl(spi_fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi_speed);
	if (ret == -1)
		pabort("can't set max speed hz");

	ret = ioctl(spi_fd, SPI_IOC_RD_MAX_SPEED_HZ, &spi_speed);
	if (ret == -1)
		pabort("can't get max speed hz");

	printf("spi mode: 0x%x\n", spi_mode);
	printf("bits per word: %d\n", spi_bits);
	printf("max speed: %d Hz (%d KHz)\n", spi_speed, spi_speed/1000);

	return ret;
}

 测试使用

int main(int argc, char *argv[])
{
    //导出DC口，这里使用的是GPIO1管脚，作为DC口使用(命令数据选择管脚)
    system("echo 1 > /sys/class/gpio/export");
    system("echo out >/sys/class/gpio/gpio1/direction");
    
    spidev_init();
    OLED_Init();
    
    OLED_ShowString(0,0,"hello world");

    return 0;
}

 注意，这里使用了一种偷懒的做法，直接导出了一个GPIO1管脚使用，通过system调用的方式先导出IO口。在OLED的发送接口里，也通过了system命令调用的方式（相当低效且费资源，正式用的话肯定不这么做，这里仅是为了测试）。

gpiochipxx：当前SoC 所包含的GPIO 控制器，I.MX6UL/I.MX6ULL 一共包含了5 个GPIO控制器，分别为GPIO1、GPIO2、GPIO3、GPIO4、GPIO5，在这里分别对应gpiochip0、gpiochip32、gpiochip64、gpiochip96、gpiochip128 这5 个文件夹，每一个gpiochipxx 文件夹用来管理一组GPIO。

 例如要导出GPIO1_1，可以通过这种方式：

echo 1 > /sys/class/gpio/export

对于给定的一个GPIO 引脚，如何计算它在sysfs 中对应的编号呢？其实非常简单，譬如给定一个GPIO引脚为GPIO4_IO16，那它对应的编号是多少呢？首先我们要确定GPIO4 对应于gpiochip96，该组GPIO 引脚的最小编号是96（对应于GPIO4_IO0），所以GPIO4_IO16 对应的编号自然是96 + 16 = 112；同理GPIO3_IO20 对应的编号是64 + 20 = 84。

//向SSD1106写入一个字节。
//dat:要写入的数据/命令
//cmd:数据/命令标志 0,表示命令;1,表示数据;
void OLED_WR_Byte(u8 dat,u8 cmd)
{			  
    u8 tx[2];
    u8 rx[2];
    tx[0] = dat;
    if(cmd)
    {
        system("echo 1 > /sys/class/gpio/gpio1/value");
        transfer(spi_fd,tx,rx,1);
    }
    else
    {
       system("echo 0 > /sys/class/gpio/gpio1/value");
       transfer(spi_fd,tx,rx,1);
    }  
}

使用 echo 命令通过文件系统导出和控制 GPIO 口是一种简单易用的方式，但在性能要求较高的场景下可能不够高效。可以考虑使用 GPIO 库、设备驱动程序或用户空间库和工具来提高效率，如可以使用libgpiod库的方式。 

libgpiod库简介

libgpiod是用于与linux GPIO交互的C库和工具，从 linux 4.8 后，官方不推荐使用 GPIO sysfs 接口，libgpiod库封装了 ioctl 调用和简单的API接口。Libgpiod是一种字符设备接口，GPIO访问控制是通过操作字符设备文件（比如/dev/gpiodchip0）实现的。
与sysfs方式相比，libgpiod可以保证所有分配的资源，在关闭文件描述符后得到完全释放，并且拥有sysfs方式接口中不存在的功能(如时间轮询，一次设置/读取多个gpio值)。此外libgpiod还包含一组命令行工具，允许用户使用脚本对gpio进行个性化操作。

详细介绍：libgpiod/libgpiod.git - C library and tools for interacting with the linux GPIO character device

libgpiod库的简单使用：

#include <gpiod.h>
#include <stdio.h>
 int main() {
    struct gpiod_chip *chip;
    struct gpiod_line *line;
    int value;
     // 打开 GPIO 控制器
    chip = gpiod_chip_open("/dev/gpiochip0");
    if (!chip) {
        perror("Failed to open GPIO chip");
        return -1;
    }
     // 获取 GPIO 口
    line = gpiod_chip_get_line(chip, 17);
    if (!line) {
        perror("Failed to get GPIO line");
        gpiod_chip_close(chip);
        return -1;
    }
     // 设置 GPIO 口为输出模式
    int ret = gpiod_line_request_output(line, "example", 0);
    if (ret < 0) {
        perror("Failed to set GPIO line as output");
        gpiod_line_release(line);
        gpiod_chip_close(chip);
        return -1;
    }
     // 控制 GPIO 输出高低电平
    ret = gpiod_line_set_value(line, 1);
    if (ret < 0) {
        perror("Failed to set GPIO line value");
        gpiod_line_release(line);
        gpiod_chip_close(chip);
        return -1;
    }
     // 读取 GPIO 输入值
    value = gpiod_line_get_value(line);
    printf("GPIO value: %d\n", value);
     // 释放资源
    gpiod_line_release(line);
    gpiod_chip_close(chip);
     return 0;
}

上述示例中，首先通过 gpiod_chip_open 打开指定的 GPIO 控制器（例如 /dev/gpiochip0 ），然后使用 gpiod_chip_get_line 获取指定的 GPIO 口（例如 17 号口）。接下来，我们使用 gpiod_line_request_output 将 GPIO 口设置为输出模式，并使用 gpiod_line_set_value 控制输出高低电平。最后，我们使用 gpiod_line_get_value 读取 GPIO 输入值，并使用 gpiod_line_release 和 gpiod_chip_close 释放资源。 需要注意的是，使用 libgpiod 需要安装相应的库文件和头文件，并在编译时链接 libgpiod 库。

需要注意的是，libgpiod 要求 Linux 内核版本至少为 4.8，因为它依赖于内核的 GPIO 字符设备接口（gpiochip）。在 4.8 版本之前的内核中，该接口可能不存在或不完整，因此无法使用 libgpiod 库。可以使用如下的方式：

int main(int argc, char *argv[])
{
    //导出DC口，这里使用的是GPIO1管脚，作为DC口使用(命令数据选择管脚)
    //system("echo 1 > /sys/class/gpio/export");
    //system("echo out >/sys/class/gpio/gpio1/direction");
    dc_p = fopen("/sys/class/gpio/export","w");
    fprintf(dc_p,"%d",1);
    fclose(dc_p);
    dc_p = fopen("/sys/class/gpio/gpio1/direction","w");
    fprintf(dc_p,"out");
    fclose(dc_p);
    dc_p = fopen("/sys/class/gpio/gpio1/value","w");
    fprintf(dc_p,"1");
    fflush(dc_p);
    
    spidev_init();
    OLED_Init();
    
    OLED_ShowString(0,0,"hello world");

    return 0;
}

//向SSD1106写入一个字节。
//dat:要写入的数据/命令
//cmd:数据/命令标志 0,表示命令;1,表示数据;
void OLED_WR_Byte(u8 dat,u8 cmd)
{			  
    u8 tx[2];
    u8 rx[2];
    tx[0] = dat;
    if(cmd)
    {
        //system("echo 1 > /sys/class/gpio/gpio1/value");
        fprintf(dc_p,"1");
        fflush(dc_p);
        transfer(spi_fd,tx,rx,1);
    }
    else
    {
       //system("echo 0 > /sys/class/gpio/gpio1/value");
       fprintf(dc_p,"0");
       fflush(dc_p);
       transfer(spi_fd,tx,rx,1);
    }  
} 

也可以使用open系统调用函数。究竟哪个更高效？需要考虑到多个因素，包括数据量、缓冲区大小、系统调用次数等。以上推荐使用fopen和fwrite.

fopen 和 open 是 Linux 中用于打开文件的两个函数，它们之间有一些区别。

1. fopen 是 C 标准库中的函数，用于以流的形式打开文件。它返回一个 FILE* 类型的指针，可以使用标准库函数（如 fread 、 fwrite 、 fprintf 等）对文件进行读写操作。 fopen 函数提供了一些方便的功能，如自动缓冲、格式化输入输出等。但是，由于它是标准库函数，因此在处理大量数据时可能会有性能上的损失。

2. open 是系统调用函数，用于以文件描述符的形式打开文件。它返回一个整数类型的文件描述符，可以使用系统调用函数（如 read 、 write 、 ioctl 等）对文件进行读写操作。 open 函数是操作系统提供的原始接口，直接与内核交互，因此在处理大量数据时通常比 fopen 更高效。 总的来说，如果你只是进行简单的文件读写操作，并且希望使用标准库函数进行处理，那么可以选择使用 fopen 。但是，如果你需要更高效的文件操作，并且需要使用系统调用函数进行底层控制，那么可以选择使用 open 。 

fwrite 是 C 标准库中的函数，用于将数据写入文件。它会先将数据写入缓冲区，然后再将缓冲区的数据写入文件。相比之下， write 是一个系统调用，直接将数据写入文件，不经过缓冲区。 对于小数据量的写入操作， fwrite 的效率可能会更高，因为它可以将多个小数据一次性写入缓冲区，然后一次性写入文件，减少了系统调用的次数。 而对于大数据量的写入操作， write 的效率可能更高。因为 fwrite 需要将数据先写入缓冲区，然后再写入文件，这个过程可能会涉及到多次的缓冲区刷新操作。而 write 直接将数据写入文件，减少了缓冲区刷新的开销。 此外，还需要考虑到缓冲区大小的影响。如果缓冲区大小适合数据量， fwrite 可能会有更好的性能。但是如果数据量超过了缓冲区大小， fwrite 需要多次刷新缓冲区，可能导致性能下降。 总的来说，对于小数据量的写入操作， fwrite 可能更高效。而对于大数据量的写入操作， write 可能更高效。但是具体的效率还需要根据具体的场景和需求进行测试和评估。

使用系统调用的方式如下：

int main(int argc, char *argv[])
{
    //导出DC口，这里使用的是GPIO1管脚，作为DC口使用(命令数据选择管脚)
    //system("echo 1 > /sys/class/gpio/export");
    //system("echo out >/sys/class/gpio/gpio1/direction");
    system("echo 1 > /sys/class/gpio/unexport");
    ssize_t bytes_written;
    const char* value = "1";

    // 打开 /sys/class/gpio/export 文件
    fd_dc = open("/sys/class/gpio/export", O_WRONLY,0644);
    if (fd_dc == -1) {
        // 处理打开文件失败的情况
        printf("open error\n");
        return -1;
    }
    bytes_written = write(fd_dc, "1", 1);
    close(fd_dc);
    if (bytes_written == -1) {
        // 处理写入文件失败的情况
        printf("write failed: %s\n", strerror(errno));
        return -1;
    }

    // 打开 /sys/class/gpio/gpio1/direction 文件
    fd_dc = open("/sys/class/gpio/gpio1/direction", O_WRONLY,0644);
    if (fd_dc == -1) {
        // 处理打开文件失败的情况
        printf("open error1\n");
        return -1;
    }
    bytes_written = write(fd_dc, "out", 3);
    close(fd_dc);
    if (bytes_written == -1) {
        // 处理写入文件失败的情况
        printf("write failed1: %s\n", strerror(errno));
        return -1;
    }

    // 打开 /sys/class/gpio/gpio1/value 文件
    fd_dc = open("/sys/class/gpio/gpio1/value", O_WRONLY,0644);
    if (fd_dc == -1) {
        // 处理打开文件失败的情况
        printf("open error2\n");
        return -1;
    }
    bytes_written = write(fd_dc, value, strlen(value));
    fsync(fd_dc);
    
    spidev_init();
    OLED_Init();
    
    OLED_ShowString(0,0,"hello world");

    return 0;
}

在调用 open 函数时，可以通过第二个参数指定文件的访问权限。权限参数是一个八进制数，表示文件的读、写和执行权限。 以下是一些常用的权限参数值：

- O_RDONLY ：只读模式，表示打开文件以供读取。

- O_WRONLY ：只写模式，表示打开文件以供写入。

- O_RDWR ：读写模式，表示打开文件以供读取和写入。

- O_CREAT ：如果文件不存在，则创建文件。

- O_EXCL ：与 O_CREAT 一起使用，如果文件已经存在，则返回错误。

- O_TRUNC ：如果文件存在，并且以写入模式打开，则将文件截断为零长度。

- O_APPEND ：以追加模式打开文件，即写入时将数据追加到文件末尾。 权限参数可以与上述标志位进行位运算，以指定文件的访问权限。例如，若要以读写模式打开文件并在文件不存在时创建它，可以使用以下权限参数：

int fd = open("filename.txt", O_RDWR | O_CREAT, 0644);

在上述示例中， 0644 是一个八进制数，表示文件的权限。其中， 0 表示八进制数， 6 表示用户（文件所有者）具有读写权限， 4 表示组用户具有只读权限， 4 表示其他用户具有只读权限。 需要注意的是，权限参数只在创建文件时起作用，对于已经存在的文件，权限参数不会改变文件的权限。文件的实际权限由文件系统的权限控制决定。

最后，为了测试OLED，写一段简单的makefile，方便编译。

# test spidev-oled
#
# Copyright (C) 2023 yangyongzhen <5234117529@qq.com>
#

CC	?= arm-linux-gnueabihf-gcc
AR	?= arm-linux-gnueabihf-ar
STRIP	?= strip

CFLAGS		?= -O2
# When debugging, use the following instead
#CFLAGS		:= -O -g
CFLAGS		+= -Wall
SOCFLAGS	:= -fpic -D_REENTRANT $(CFLAGS)

#KERNELVERSION	:= $(shell uname -r)

.PHONY: all strip clean 

all:
	$(CC) spidev_oled.c -o spidev_oled
  
clean:
	rm -rf *.o 

测试demo：

int main(int argc, char *argv[])
{
    //导出DC口，这里使用的是GPIO1管脚，作为DC口使用(命令数据选择管脚)
    //system("echo 1 > /sys/class/gpio/export");
    //system("echo out >/sys/class/gpio/gpio1/direction");
    u8 t;
    dc_p = fopen("/sys/class/gpio/export","w");
    fprintf(dc_p,"%d",1);
    fclose(dc_p);
    dc_p = fopen("/sys/class/gpio/gpio1/direction","w");
    fprintf(dc_p,"out");
    fclose(dc_p);
    dc_p = fopen("/sys/class/gpio/gpio1/value","w");
    fprintf(dc_p,"1");
    fflush(dc_p);
    
    spidev_init();
    OLED_Init();
    
    while(1) 
	{		
		OLED_Clear();
		OLED_ShowCHinese(0,0,0);//中
		OLED_ShowCHinese(18,0,1);//景
		OLED_ShowCHinese(36,0,2);//园
		OLED_ShowCHinese(54,0,3);//电
		OLED_ShowCHinese(72,0,4);//子
		OLED_ShowCHinese(90,0,5);//科
		OLED_ShowCHinese(108,0,6);//技
		OLED_ShowString(0,3,"1.3' OLED TEST");
		//OLED_ShowString(8,2,"ZHONGJINGYUAN");  
	 //	OLED_ShowString(20,4,"2014/05/01");  
		OLED_ShowString(0,6,"ASCII:");  
		OLED_ShowString(63,6,"CODE:");  
		OLED_ShowChar(48,6,t);//显示ASCII字符	   
		t++;
		if(t>'~')t=' ';
		OLED_ShowNum(103,6,t,3,16);//显示ASCII字符的码值 	
			
		
		delay_ms(8000);
		OLED_Clear();
		delay_ms(8000);
		OLED_DrawBMP(0,0,128,8,BMP1);  //图片显示(图片显示慎用，生成的字表较大，会占用较多空间，FLASH空间8K以下慎用)
		delay_ms(8000);
		OLED_DrawBMP(0,0,128,8,BMP2);
		delay_ms(8000);
	}	  

}

   

 工程完整源码下载地址：

https://download.csdn.net/download/qq8864/88117562

其他资源

嵌入式Linux——IIC总线驱动（3）：IIC驱动OLED外设_iic怎么唤醒外设_moxue10的博客-CSDN博客

Linux系统GPIO应用编程_linux控制gpio程序_行稳方能走远的博客-CSDN博客

linux系统基于syfs控制gpio_gpio linux sys_嵌入式Linux开发的博客-CSDN博客

交叉编译开源代码(以libgpiod为例)_libgpiod交叉编译_仰望&南极光的博客-CSDN博客

[imx6ull应用开发]GPIO编程之LED灯设备控制---sysfs方式和libgpiod方式_gpiod_line_request_output_WH^2的博客-CSDN博客

飞凌嵌入式技术帖——i.MX9352的GPIO怎么用？_dts_设备_操作

[imx6ull应用开发]GPIO编程之LED灯设备控制---sysfs方式和libgpiod方式_gpiod_line_request_output_WH^2的博客-CSDN博客

C语言方式(libgpiod) - Sipeed Wiki

Libgpiod库的使用，点亮LED_猪突猛进进进的博客-CSDN博客