• 自制Linux功能板

    Cloud

    一、前言

    由于上次的小熊板制作过程犯了很多错误，造成一些影响颜值的结果。对此想要重新设计制作相关的linux功能板，此版本依然采用imx6ull核心板，同时加入了mpu6050、光敏输入等功能模块。

    坦白：大部分电路都是借鉴了原子开源电路。

    • 1

    总结主要功能：
    一、核心功能

    • 电源管理：锂电池、充放电路、稳压电路。
    • boot的emmc/sd卡启动方式。
    • USB_HUB（WIFI、键盘等）。
    • 复位电路reset、开关机电路on_off。

    二、扩展功能

    • ipslcd屏幕：显示窗口。
    • mpu6050：获取姿态。
    • LED炫彩灯：花里胡哨。
    • 光敏电阻：获取光强。
    • 摄像头ov5640：获取图像信息。
    • 扩展接口：留存I2C、PWM、UART等接口。

    二、电源管理

    2.1 锂电池

    • 型号：102040(10mmx20mmx40mm)
    • 电压：3.7V
    • 容量：1200毫安
      在这里插入图片描述

    2.2 充放电路

    使用英集芯ip5306电源芯片。是一款集成升压转换器、 锂电池充电管理、电池电量指示的多功能电源管理 SOC，为移动电源提供完整的电源解决方案。

    • 输入电压：5V
    • 输出电压：5V 2.4A(max)
    • 充电目标电压/电流：4.2V 2.1A

    电路图：
    在这里插入图片描述

    实物图：第一次想自己画，把功能电路和电源电路画在一起，但是忽略了电源线的宽度(<10mil)。后来意识到电源电路和功能电路还是要分开绘制，这样如果电源冒烟了，不会影响功能电路。如下图为某宝获得，真香！！，几块大洋，小巧方便。
    （电源电路对于外行人还真不是一下就掌握的，器件布局和布线不规范可能导致发热或烧掉）。
    新版功能板的电源线宽度给到了20mil。
    在这里插入图片描述

    2.3 稳压电路（5V->3.3V）

    使用XC6206P系列芯片XC6206P332MR，只能说该芯片YYDS，高精度、低功耗、低压差，3端CMOS降压型电压稳定器。 应用于电池供电的数码家电设备。

    • 封装：SOT-23
    • 最大输入电压：7V
    • 最大输出电流：200mA
    • 低功耗：1.0uA

    电路图：
    在这里插入图片描述

    三 、启动方式boot

    3.1 概述

    在这里插入图片描述

    3.2 电路图

    启动方式： 根据概述，只需要EMMC/SD卡启动之间切换。
    在这里插入图片描述
    外接SD卡： 注意，SD卡还有一个外壳，外壳需要接地。这是因为在插入SD卡后，电路中CD/SW引脚会连接到外壳上，通过读取该引脚电平为低电平判断是否插卡。
    在这里插入图片描述

    四、USB_HUB电路

    4.1 概述

    I.MX6ULL 有2个 USB 主控制器，每个主控制器可以外接USB_HUB扩展坞。
    一个 USB 主控制器支持 128 个地址，地址 0 是默认地址（主机），所以一个 USB 主控制器最多可以
    分配 127 个地址的设备（从机）。

    USB 分为 HOST(主机)和从机(或 DEVICE)， OTG是 On-The-Go 的缩写，支持USB OTG 功能的 USB 接口既可以做 HOST，也可以做 DEVICE。通过ID线切换主从状态。

    USB OTG功能相关的引脚有5个：

    • 引脚1 - VBUS，电压为5V
    • 引脚2 - D-
    • 引脚3 - D+
    • 引脚4 - ID 0：主机模式；1：从机模式
    • 引脚5 - GND

    4.2 硬件电路

    原理图： 这里的OTG1_ID为0，表示也做主设备，可应用于无线WIFI、键盘、扩展坞等。
    在这里插入图片描述
    实物图：
    在这里插入图片描述

    五、mpu6050设计及应用

    5.1 概述

    5.1.1 mpu6050概述

    参考博文：MPU6050模块
    MPU6050内部整合了三轴MEMS陀螺仪、三轴MEMS加速度计、可扩展的数字运动处理器DMP(Digital Motion Processor)和一个数字温度传感器。通过IIC接口输出一个6轴信号。
    陀螺仪就是测角速度的，加速度传感器就是测角加速度的，二者数据通过算法就可以得到PITCH、YAW、ROLL角。

    • 具有 131 LSBs/° /sec 敏感度与全格感测范围为±250、±500、±1000 与±2000° /sec的 3 轴角速度感测器(陀螺仪)
    • 集成可程序控制，范围为±2g、±4g、±8g 和±16g 的 3 轴加速度传感器
    • 陀螺仪工作电流： 5mA，陀螺仪待机电流： 5uA； 加速器工作电流：500uA，加速器省电模式电流： 40uA@10Hz
    • 高达 400Khz 的 IIC 通信接口
    • ADC都是16位

    姿态角示意图：绕向即为正方向，可根据右手螺旋定则确定方向。
    在这里插入图片描述
    内部结构示意图：内置了三轴加速度传感器、三轴陀螺仪和一个温度传感器。

    • INT为中断输出脚
    • TCS为片选脚
    • AD0为设置地址脚
    • SCL和SDA为主IIC接口
    • AUX_CL和AUX_DA为从IIC接口

    在这里插入图片描述

    5.1.2 i2c概述

    I2C 是很常见的一种总线协议， I2C 是 NXP 公司设计的， I2C 使用两条线在主控制器和从机之间进行数据通信。一条是 SCL(串行时钟线)，另外一条是 SDA(串行数据线)，这两条数据线需要接上拉电阻，一般是 4.7K，总线空闲的时候 SCL 和 SDA 处于高电平。 I2C 总线标准模式下速度可以达到 100Kb/S，快速模式下可以达到 400Kb/S。 一个 I2C 控制器下可以挂多个 I2C 从设备。

    I2C 总线工作是按照一定的协议来运行的。
    协议相关术语：
    1、起始位
    在 SCL 为高电平的时候， SDA 出现下降沿就表示为起始位。
    在这里插入图片描述
    2、停止位
    在 SCL 位高电平的时候， SDA出现上升沿就表示为停止位。
    在这里插入图片描述
    3、数据传输
    I2C 总线在数据传输的时候要保证在 SCL 高电平期间， SDA 上的数据稳定，因此 SDA 上的数据变化只能在 SCL 低电平期间发生。
    在这里插入图片描述
    4、应答信号ACK
    应答信号是由从机发出的，主机需要提供应答信号所需的时钟，主机发送完 8 位数据以后紧跟着的一个时钟信号就是给应答信号使用的。从机通过将 SDA 拉低来表示发出应答信号，表示通信成功，否则表示通信失败。

    5、 I2C 写时序（三步）

    • 写信号：0

    在这里插入图片描述
    设备地址（写）->寄存器地址->写数据

    6、 I2C 读时序（四步）

    • 读信号：1

    在这里插入图片描述
    设备地址（写）->寄存器地址->设备地址（读）->读数据

    规律：每次写设备地址/寄存器地址之前有起始位，每8bit数据从机有应答/非应答。

    • 1

    5.2 硬件电路

    芯片引脚复用：
    在这里插入图片描述

    原理图： 注意，I2C要上拉电阻。
    在这里插入图片描述
    实物图：
    在这里插入图片描述

    5.3 软件编写

    I2C设备驱动程序结构模型为：I2C设备（设备树描述）–I2C总线驱动（厂商提供）–>I2C设备驱动（自己编写）。

    5.3.1 I2C总线驱动

    这里就是 SOC 的 I2C 控制器驱动，一旦编写完成就不需要再做修改，其他的I2C设备直接调用提供的API函数完成读写操作即可，正好符合 Linux 的驱动分离与分层的思想。这部分相关驱动NXP厂商已经帮我们写好了，可直接调用，但还是大概了解一下吧。

    I2C 控制器描述
    描述为 i2c_adapter，定义在 include/linux/i2c.h 。

    //厂商已写好
struct i2c_adapter {
	struct module *owner;
	unsigned int class; /* classes to allow probing for */
	const struct i2c_algorithm *algo; /* 总线访问算法 */
	void *algo_data;
	...
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    i2c_algorithm 就是 I2C 控制器与 IIC 设备进行通信的方法，对外提供读写 API 函数。

    //厂商已写好
struct i2c_algorithm {
	......
	int (*master_xfer)(struct i2c_adapter *adap,
	struct i2c_msg *msgs, int num);
	int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
	......
};
//master_xfer 就是 I2C 适配器的传输函数，可以通过此函数来完成与 IIC 设备之间的通信
//smbus_xfer 就是 SMBUS 总线的传输函数。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    I2C 控制器注册/注销

    //注册
int i2c_add_adapter(struct i2c_adapter *adapter)
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
//注销
void i2c_del_adapter(struct i2c_adapter * adap)

    • 1
    • 2
    • 3
    • 4
    • 5

    综上所述
    I2C 总线驱动（I2C控制器驱动）的主要工作就是

    • 初始化 i2c_adapter 结构体变量，然后设置 i2c_algorithm 中的master_xfer 函数。
    • 通过 i2c_add_numbered_adapter/i2c_add_adapter函数向系统注册设置好的 i2c_adapter。

    更深一层
    其实 I2C 总线驱动（I2C控制器驱动）内部也是是通过设备-总线-驱动这一结构模型完成的。示意图如下：

    对I2C控制器：（控制器描述-platform总线驱动-控制器驱动）==>I2C总线驱动
    对I2C设备：I2C设备–I2C总线驱动–>I2C设备驱动

    也就是说我们写驱动程序时只针对I2C设备那一层，更深一层的驱动在i2c-imx.c文件写好，内部有关于I2C控制器相关寄存器操作以及对I2C协议相关术语描述，如i2c_imx_start、 i2c_imx_read、 i2c_imx_write 和 i2c_imx_stop 这些函数就是 I2C 寄存器的具体操作函数。

    总线部分就是这些，就是对控制器驱动后又充当了外层设备的总线。

    5.3.2 I2C设备

    就是针对具体的 I2C 设备而编写的驱动，如本章的mpu6050驱动。

    I2C总线驱动对设备的描述
    I2C总线驱动提供i2c_client 结构体，在 include/linux/i2c.h 文件中。
    一个设备对应一个 i2c_client，每检测到一个 I2C 设备就会给这个 I2C 设备分配一个i2c_client。

    //厂商已写好
struct i2c_client {
	unsigned short flags; /* 标志 */
	unsigned short addr; /* 芯片地址， 7 位，存在低 7 位*/
	......
	char name[I2C_NAME_SIZE]; /* 名字 */
	struct i2c_adapter *adapter; /* 对应的 I2C 适配器 */
	struct device dev; /* 设备结构体 */
	int irq; /* 中断 */
	struct list_head detected;
	......
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在I2C设备树上添加mpu6050设备的描述
    个人理解：I2C总线驱动将设备树中的描述（i2c1、设备厂商、设备名称、设备地址）存到i2c_client结构体对象中，方便在设备驱动中调用。

    //IO复用
pinctrl_i2c1: i2c1grp {
	fsl,pins = <
		MX6UL_PAD_UART4_TX_DATA__I2C1_SCL 0x4001b8b0
		MX6UL_PAD_UART4_RX_DATA__I2C1_SDA 0x4001b8b0
	>;
};
...
//在I2C设备树上添加mpu6050设备的描述
&i2c1 {
	clock-frequency = <100000>;		/*100k 400k可选*/
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_i2c1>;	/*pinctrl子系统*/
	status = "okay";

	mpu6050:mpu6050@68{
		compatible = "InvenSense,mpu6050";/*描述*/
		reg = <0x68>;				/*mpu6050作为从机地址为：0x68*/
		status = "okay";			/*需要方便开关就写*/
	};
	
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    启动系统可以在/sys/bus/i2c/devices 目录下看到mpu6050的设备地址。

    5.3.3 I2C设备驱动

    I2C总线驱动对设备驱动的API函数
    1、I2C总线驱动提供i2c_driver 结构体，在 include/linux/i2c.h 文件中。

    //厂商已写好
struct i2c_driver {
	...
	//当 I2C 设备和驱动匹配成功以后 probe 函数就会执行
	int (*probe)(struct i2c_client *, const struct i2c_device_id *);
	int (*remove)(struct i2c_client *);
	...
	//如果使用设备树的话，需要设置 device_driver 的of_match_table 成员变量，也就是驱动的兼容(compatible)属性。
	struct device_driver driver;
	const struct i2c_device_id *id_table;
	...
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    i2c_driver 注册/注销

    //注册
int i2c_register_driver(struct module *owner,struct i2c_driver *driver)
//注销
void i2c_del_driver(struct i2c_driver *driver)

    • 1
    • 2
    • 3
    • 4

    2、I2C总线驱动提供 i2c_transfer 函数，i2c_transfer 函数最终会调用 I2C 适配器中 i2c_algorithm 里面的 master_xfer 函数，对于 I.MX6U 而言就是
    i2c_imx_xfer 这个函数。

    int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
//adap： 所使用的 I2C 适配器， i2c_client 会保存其对应的 i2c_adapter。
//msgs： I2C 要发送的一个或多个消息。
//num： 消息数量，也就是 msgs 的数量。
//返回值： 负值，失败，其他非负值，发送的 msgs 数量。

    • 1
    • 2
    • 3
    • 4
    • 5

    重点在于msgs 这个参数，内部主要存I2C读写操作中的设备地址、寄存器地址、读写标志、缓存数据等内容。

    mpu6050设备驱动程序

    #include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "mpu6050reg.h"
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名		: mpu6050.c
作者	  	: zxy
版本	   	: V1.0
描述	   	: mpu6050驱动程序
日志	   	: 初版V1.0 2022/2/16 zxy修改
***************************************************************/
#define MPU6050_CNT	1
#define MPU6050_NAME	"mpu6050"

struct mpu6050_dev {
	dev_t devid;				/* 设备号 	 */
	struct cdev cdev;			/* cdev 	*/
	struct class *class;		/* 类 		*/
	struct device *device;		/* 设备 	 */
	struct device_node	*nd; 	/* 设备节点 */
	int major;					/* 主设备号 */
	void *private_data;			/* 私有数据 */
	//接收的数据为2字节 但i2c的基本单位都是1字节
	signed short gyro_x_adc;		/* 陀螺仪X轴原始值 	 */
	signed short gyro_y_adc;		/* 陀螺仪Y轴原始值		*/
	signed short gyro_z_adc;		/* 陀螺仪Z轴原始值 		*/
	signed short accel_x_adc;		/* 加速度计X轴原始值 	*/
	signed short accel_y_adc;		/* 加速度计Y轴原始值	*/
	signed short accel_z_adc;		/* 加速度计Z轴原始值 	*/
	signed short temp_adc;		/* 温度原始值 			*/
};

static struct mpu6050_dev mpu6050dev;

//-----------------------------------------------------------------------------------------------------------------------//
//mpu6050初始化等操作函数

/*
 * @description	: 从mpu6050读取多个寄存器数据
 * @param - dev:  mpu6050设备
 * @param - reg:  要读取的寄存器首地址 8bit
 * @param - val:  读取到的数据
 * @param - len:  要读取的数据长度
 * @return 		: 操作结果
 */
static int mpu6050_read_regs(struct mpu6050_dev *dev, u8 reg, void *val, int len)
{
	int ret;
	struct i2c_msg msg[2];												//一个msg发送时序中的>=2Byte 用于存从机地址+数据
	struct i2c_client *client = (struct i2c_client *)dev->private_data;	//结构体中存放从机地址，用到的i2c控制器信息

	/* msg[0] 2 Byte：从机地址+写+寄存机地址 */
	msg[0].addr = client->addr;			/* mpu6050地址 7bit */
	msg[0].flags = 0;					/* 0为写 1bit */
	msg[0].buf = &reg;					/* 读取的首地址 8bit */
	msg[0].len = 1;						/* reg长度*/

	/* msg[1] 1+n_data Byte：从机地址+读+本地接收地址 */
	msg[1].addr = client->addr;			/* mpu6050地址 */
	msg[1].flags = I2C_M_RD;			/* 1为读 */
	msg[1].buf = val;					/* 读取数据缓冲区 */
	msg[1].len = len;					/* 要读取的数据长度*/

	ret = i2c_transfer(client->adapter, msg, 2);//拜托i2c控制器发送相关信息 i2c1或i2c2
	if(ret == 2) {
		ret = 0;
	} else {
		printk("i2c rd failed=%d reg=%06x len=%d\n",ret, reg, len);
		ret = -EREMOTEIO;
	}
	return ret;
}

/*
 * @description	: 读取mpu6050指定寄存器值，读取一个寄存器
 * @param - dev:  mpu6050设备
 * @param - reg:  要读取的寄存器
 * @return 	  :   读取到的寄存器值
 */
static unsigned char mpu6050_read_reg(struct mpu6050_dev *dev, u8 reg)
{
	u8 data = 0;

	mpu6050_read_regs(dev, reg, &data, 1);
	return data;

#if 0
	struct i2c_client *client = (struct i2c_client *)dev->private_data;
	return i2c_smbus_read_byte_data(client, reg);
#endif
}

/*
 * @description	: 向mpu6050多个寄存器写入数据
 * @param - dev:  mpu6050设备
 * @param - reg:  要写入的寄存器首地址
 * @param - buf:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
static s32 mpu6050_write_regs(struct mpu6050_dev *dev, u8 reg, u8 *buf, u8 len)
{
	u8 b[256];
	struct i2c_msg msg;
	struct i2c_client *client = (struct i2c_client *)dev->private_data;
	
	b[0] = reg;					/* 寄存器首地址 */
	memcpy(&b[1],buf,len);		/* 将要写入的数据拷贝到数组b里面 */

	/* msg：1+n_data Byte：从机地址+读+本地接收地址 */
	msg.addr = client->addr;	/* mpu6050地址 7bit */
	msg.flags = 0;				/* 0为写 1bit */
	msg.buf = b;				/* 要写入的数据缓冲区 */
	msg.len = len + 1;			/* 要写入的数据长度 */

	return i2c_transfer(client->adapter, &msg, 1);
}

/*
 * @description	: 向mpu6050指定寄存器写入指定的值，写一个寄存器
 * @param - dev:  mpu6050设备
 * @param - reg:  要写的寄存器
 * @param - data: 要写入的值
 * @return   :    无
 */
static void mpu6050_write_reg(struct mpu6050_dev *dev, u8 reg, u8 data)
{
	u8 buf = 0;//新建一个变量，可能更安全吧
	buf = data;
	mpu6050_write_regs(dev, reg, &buf, 1);
}

/*
 * @description	: mpu6050相关寄存器的初始化
 * @return 		: 无。
 */
void mpu6050_reginit(void)
{
	u8 value = 0;
	
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_PWR_MGMT_1, 0x80);
	mdelay(50);
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_PWR_MGMT_1, 0x01);
	mdelay(50);

	value = mpu6050_read_reg(&mpu6050dev, MPU6050_RA_WHO_AM_I);
	printk("mpu6050 ID = %#X\r\n", value);	

	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_SMPLRT_DIV, 0x00); 	/* 输出速率是内部采样率					*/
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_GYRO_CONFIG, 0x18); 	/* 陀螺仪±2000dps量程 				*/
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_ACCEL_CONFIG, 0x18); 	/* 加速度计±16G量程 					*/
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_CONFIG, 0x04); 		/* 陀螺仪低通滤波BW=20Hz 				*/
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_FF_THR, 0x04); 		/* 加速度计低通滤波BW=21.2Hz 			*/
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_PWR_MGMT_2, 0x00); 	/* 打开加速度计和陀螺仪所有轴 				*/
	// mpu6050_write_reg(&mpu6050dev, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CYCLE_BIT); 	/* 关闭低功耗 						*/
	mpu6050_write_reg(&mpu6050dev, MPU6050_RA_FIFO_EN, 0x00);		/* 关闭FIFO						*/
}

/*
 * @description	: 读取mpu6050的数据，读取原始数据
 * @return 		: 无。
 */
void mpu6050_readdata(struct mpu6050_dev *dev)
{
	unsigned char data[14];	
	mpu6050_read_regs(dev, MPU6050_RA_ACCEL_XOUT_H, data, 14);	//0x3B位置，连续14个寄存器，包括加速度、温度、角速度等数据
	//设备结构体收到了数据
	dev->accel_x_adc = (signed short)((data[0] << 8) | data[1]); 
	dev->accel_y_adc = (signed short)((data[2] << 8) | data[3]); 
	dev->accel_z_adc = (signed short)((data[4] << 8) | data[5]); 
	dev->temp_adc    = (signed short)((data[6] << 8) | data[7]); 
	dev->gyro_x_adc  = (signed short)((data[8] << 8) | data[9]); 
	dev->gyro_y_adc  = (signed short)((data[10] << 8) | data[11]);
	dev->gyro_z_adc  = (signed short)((data[12] << 8) | data[13]);
}

//-----------------------------------------------------------------------------------------------------------------------//
//文件操作结构体部分

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int mpu6050_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &mpu6050dev;//在所有文件操作函数中使用设备文件保存该设备结构体

	/* 每次打开设备文件，mpu6050时就初始化一次 */
	mpu6050_reginit();

	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t mpu6050_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
{
	signed short data[7];
	long err = 0;

	struct mpu6050_dev *dev = (struct mpu6050_dev *)filp->private_data;//从文件操作函数领域使用自己保存的设备结构体
	
	mpu6050_readdata(dev);//读到的数据存入了本设备结构体变量中
	//将数据从内核空间发送到用户空间
	data[0] = dev->gyro_x_adc;
	data[1] = dev->gyro_y_adc;
	data[2] = dev->gyro_z_adc;
	data[3] = dev->accel_x_adc;
	data[4] = dev->accel_y_adc;
	data[5] = dev->accel_z_adc;
	data[6] = dev->temp_adc;
	err = copy_to_user(buf, data, sizeof(data));
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int mpu6050_release(struct inode *inode, struct file *filp)
{
	return 0;
}

/* mpu6050文件操作函数 */
static const struct file_operations mpu6050_ops = {
	.owner = THIS_MODULE,
	.open = mpu6050_open,
	.read = mpu6050_read,
	.release = mpu6050_release,
};

//-----------------------------------------------------------------------------------------------------------------------//
//设备驱动结构体部分

 /*
  * @description     : i2c驱动的probe函数，当驱动与设备匹配以后此函数就会执行，就是初始化开头的mpu6050结构体中的各个变量      
  * @param - client  : i2c设备
  * @param - id      : i2c设备ID
  * @return          : 0，成功;其他负值,失败
  */
static int mpu6050_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	/* 1、构建设备号 */
	if (mpu6050dev.major) {
		mpu6050dev.devid = MKDEV(mpu6050dev.major, 0);
		register_chrdev_region(mpu6050dev.devid, MPU6050_CNT, MPU6050_NAME);
	} else {
		alloc_chrdev_region(&mpu6050dev.devid, 0, MPU6050_CNT, MPU6050_NAME);
		mpu6050dev.major = MAJOR(mpu6050dev.devid);
	}

	/* 2、注册字符设备 */
	cdev_init(&mpu6050dev.cdev, &mpu6050_ops);		//有了设备号就能注册字符设备，提供文件操作函数并得到了相关字符设备资格
	cdev_add(&mpu6050dev.cdev, mpu6050dev.devid, MPU6050_CNT);

	/* 3、创建类 */
	mpu6050dev.class = class_create(THIS_MODULE, MPU6050_NAME);
	if (IS_ERR(mpu6050dev.class)) {
		return PTR_ERR(mpu6050dev.class);
	}

	/* 4、创建设备 */
	mpu6050dev.device = device_create(mpu6050dev.class, NULL, mpu6050dev.devid, NULL, MPU6050_NAME); //终于可以创建设备了
	if (IS_ERR(mpu6050dev.device)) {
		return PTR_ERR(mpu6050dev.device);
	}

	mpu6050dev.private_data = client;//i2c的设备和驱动匹配成功后，client就得到了设备树相关信息，这里设备结构体变量赶紧保存起来

	return 0;
}

/*
 * @description     : i2c驱动的remove函数，移除i2c驱动的时候此函数会执行
 * @param - client 	: i2c设备
 * @return          : 0，成功;其他负值,失败
 */
static int mpu6050_remove(struct i2c_client *client)
{
	/* 删除设备 */
	cdev_del(&mpu6050dev.cdev);
	unregister_chrdev_region(mpu6050dev.devid, MPU6050_CNT);

	/* 注销掉类和设备 */
	device_destroy(mpu6050dev.class, mpu6050dev.devid);
	class_destroy(mpu6050dev.class);
	return 0;
}

/* 传统匹配方式ID列表 */
static const struct i2c_device_id mpu6050_id[] = {
	{"alientek,ap3216c", 0},  
	{}
};

/* 设备树匹配列表 */
static const struct of_device_id mpu6050_of_match[] = {
	{ .compatible = "InvenSense,mpu6050" },
	{ /* Sentinel */ }
};

/* i2c驱动结构体 */	
static struct i2c_driver mpu6050_driver = {
	.probe = mpu6050_probe,
	.remove = mpu6050_remove,
	.driver = {
			.owner = THIS_MODULE,
		   	.name = "mpu6050",
		   	.of_match_table = mpu6050_of_match, 
		   },
	.id_table = mpu6050_id,
};
		   
/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init mpu6050_init(void)
{
	int ret = 0;

	ret = i2c_add_driver(&mpu6050_driver);
	return ret;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit mpu6050_exit(void)
{
	i2c_del_driver(&mpu6050_driver);
}

/* module_i2c_driver(mpu6050_driver) */

module_init(mpu6050_init);
module_exit(mpu6050_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zxy");

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368

    5.3.4 App程序编写
    就是一个简单的测试。

    #include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "sys/ioctl.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include 
#include 
#include 
#include 
#include 
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名		: mpu6050App.c
作者	  	: 左忠凯
版本	   	: V1.0
描述	   	: mpu6050设备测试APP。
其他	   	: 无
使用方法	 ：./mpu6050App /dev/mpu6050
日志	   	: 
***************************************************************/

/*
 * @description		: main主程序
 * @param - argc 	: argv数组元素个数
 * @param - argv 	: 具体参数
 * @return 			: 0 成功;其他 失败
 */
int main(int argc, char *argv[])
{
	int fd;
	char *filename;
	signed short databuf[7];//都是2字节的ADC数据
	signed short gyro_x_adc, gyro_y_adc, gyro_z_adc;
	signed short accel_x_adc, accel_y_adc, accel_z_adc;
	signed short temp_adc;
	float gyro_x_act, gyro_y_act, gyro_z_act;
	float accel_x_act, accel_y_act, accel_z_act;
	float temp_act;

	//检查参数
	int ret = 0;
	if (argc != 2) {
		printf("Error Usage!\r\n");
		return -1;
	}
	/* 1、打开设备文件 */
	filename = argv[1];
	fd = open(filename, O_RDWR);
	if(fd < 0) {
		printf("can't open file %s\r\n", filename);
		return -1;
	}
	/* 2、读取设备文件 */
	while (1) {
		ret = read(fd, databuf, sizeof(databuf));
		if(ret == 0) { 			/* 数据读取成功 */
			/*adc值*/
			gyro_x_adc = databuf[0];//角速度
			gyro_y_adc = databuf[1];
			gyro_z_adc = databuf[2];
			accel_x_adc = databuf[3];//加速度
			accel_y_adc = databuf[4];
			accel_z_adc = databuf[5];
			temp_adc = databuf[6];//温度
			/*adc值->实际值*/
			gyro_x_act = (float)(gyro_x_adc)  / 16.4;
			gyro_y_act = (float)(gyro_y_adc)  / 16.4;
			gyro_z_act = (float)(gyro_z_adc)  / 16.4;
			accel_x_act = (float)(accel_x_adc) / 2048;
			accel_y_act = (float)(accel_y_adc) / 2048;
			accel_z_act = (float)(accel_z_adc) / 2048;
			temp_act = ((float)(temp_adc) - 25 ) / 326.8 + 25;
			/*打印出来*/
			printf("\r\nADC value:\r\n");
			printf("gx = %d, gy = %d, gz = %d\r\n", gyro_x_adc, gyro_y_adc, gyro_z_adc);
			printf("ax = %d, ay = %d, az = %d\r\n", accel_x_adc, accel_y_adc, accel_z_adc);
			printf("temp = %d\r\n", temp_adc);
			printf("TRUE value:");
			printf("act gx = %.2f°/S, act gy = %.2f°/S, act gz = %.2f°/S\r\n", gyro_x_act, gyro_y_act, gyro_z_act);
			printf("act ax = %.2fg, act ay = %.2fg, act az = %.2fg\r\n", accel_x_act, accel_y_act, accel_z_act);
			printf("act temp = %.2f°C\r\n", temp_act);
		}
		usleep(1000000); /*100ms */
	}
	/* 3、关闭文件 */	
	close(fd);	
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91

    六、ipslcd设计及应用

    6.1 概述

    6.3.1 ipslcd概述

    ipslcd用于屏幕显示：

    • 材料：高清IPS彩色屏
    • 控制芯片：ST7789
    • 接口类型：4线SPI接口
    • 工作电压：3.3V

    8个引脚的描述：

    • GND：电源地
    • VCC：3.3V
    • SCL：SPI时钟线(SCK)
    • SDA：SPI数据线(MOSI)
    • RES：显示屏复位管脚
    • DC：SPI数据/命令选择角
    • CS：SPI数据片选，低电平有效
    • BLK：LED背光控制，默认可以悬空，低电平关闭背光(LED)

    6.3.2 spi概述

    SPI 全称是 SerialPerripheral Interface，也就是串行外围设备接口。 SPI 是 Motorola 公司推出的一种同步串行接口技术，是一种高速、全双工的同步通信总线， SPI 时钟频率相比 I2C 要高很多，最高可以工作在上百 MHz。

    一般 SPI 需要4 根线：

    • CS/SS， Slave Select/Chip Select，这个是片选信号线，用于选择需要进行通信的从设备。I2C 主机是通过发送从机设备地址来选择需要进行通信的从机设备的， SPI 主机不需要发送从机设备，直接将相应的从机设备片选信号拉低即可。低电平使能。
    • SCK， Serial Clock，串行时钟，和 I2C 的 SCL 一样，为 SPI 通信提供时钟。脉冲跳变时数据有效。
    • MOSI/SDO， Master Out Slave In/Serial Data Output，简称主出从入信号线，这根数据线只能用于主机向从机发送数据，也就是主机输出，从机输入。
    • MISO/SDI， Master In Slave Out/Serial Data Input，简称主入从出信号线，这根数据线只能用户从机向主机发送数据，也就是主机输入，从机输出。

    SPI 有四种工作模式，通过串行时钟极性(CPOL)和相位(CPHA)的搭配来得到四种工作模式：

    • CPOL=0，串行时钟空闲状态为低电平。
    • CPOL=1，串行时钟空闲状态为高电平。
    • CPHA=0，串行时钟的第一个跳变沿(上升沿或下降沿)采集数据。
    • CPHA=1，串行时钟的第二个跳变沿(上升沿或下降沿)采集数据。
      在这里插入图片描述

    6.3.3 FrameBuffer概述

    帧缓冲（framebuffer） 是Linux 系统为显示设备提供的一个接口，将内存中的一块儿显存抽象为一种设备，用户可直接通过fb操作函数控制这一块显存，进而反映到屏幕上。

    framebuffer是个字符设备，主设备号为29，对应于/dev/fb%d 设备文件。

    据说这事成了之后可以直接控制/dev/fbx，挺方便的。

    在这里插入图片描述

    6.2 硬件电路

    芯片引脚复用：
    在这里插入图片描述

    原理图：
    在这里插入图片描述
    实物图：
    在这里插入图片描述

    6.3 软件编写

    同样地，SPI设备驱动程序结构模型为：SPI设备（设备树描述）–SPI总线驱动（厂商提供）–>SPI设备驱动（自己编写）。

    6.3.1 SPI总线驱动

    这里就是 SOC 的 SPI控制器驱动，一旦编写完成就不需要再做修改，其他的SPI设备直接调用提供的API函数完成读写操作即可，正好符合 Linux 的驱动分离与分层的思想。这部分相关驱动NXP厂商已经帮我们写好了，可直接调用，但还是大概了解一下吧。

    SPI控制器描述
    描述为 spi_master，定义在 include/linux/spi/spi.h 。

    //厂商已写好
struct spi_master {
	struct device dev;
	struct list_head list;
	...
	int (*transfer)(struct spi_device *spi, struct spi_message *mesg);
	...
	int (*transfer_one_message)(struct spi_master *master, struct spi_message *mesg);
	...
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    transfer 函数，和 i2c_algorithm 中的 master_xfer 函数一样，控制器数据传输函数。重点也是维护mesg。

    spi_master 注册与注销

    //注册
int spi_register_master(struct spi_master *master)
//注销
void spi_unregister_master(struct spi_master *master)

    • 1
    • 2
    • 3
    • 4

    综上所述
    SPI总线驱动（SPI控制器驱动）的主要工作就是

    • 初始化spi_master结构体变量
    • 向系统注册设置好的spi_master。

    更深一层
    其实SPI总线驱动（SPI控制器驱动）内部也是是通过设备-总线-驱动这一结构模型完成的。示意图如下：

    对SPI控制器：（控制器描述-platform总线驱动-控制器驱动）==>SPI总线驱动
    对SPI设备：SPI设备–SPI总线驱动–>SPI设备驱动

    也就是说我们写驱动程序时只针对SPI设备那一层，更深一层的驱动在spi-imx.c文件写好，内部有关于SPI控制器相关寄存器操作。

    总线部分就是这些，就是对控制器驱动后又充当了外层设备的总线。

    6.3.2 结合了framebuffer的SPI设备驱动

    详细描述参考本文另一篇博文。

    驱动目录/driver/staging/fbtft下已经将spi和framebuffer结合。

    主要有以下几个角色文件：

    • fbtft.h：连接源文件的头文件，主要的结构体、基本驱动框架、spi/platform框架。
    • fbtft_device.c：补充设备树未描述的硬件信息。
    • st7789v.c：屏幕IC的驱动部分。
    • fbtft-core.c：核心层，匹配成功之后的probe函数，实现了一个 frambuffer 设备驱动。
    • fbtft-bus.c：提供读写寄存器 / 显存的功能。
    • fbtft-io.c：提供最底层的 spi 读写功能。
    • fbtft-sysfs.c，导出一些调试接口。

    在SPI总线驱动的设备树下添加ipslcd
    这次设备树只负责引脚的说明，仅仅pinctrl、gpio子系统发挥了作用。

    /* zxy	ips_tftlcd 1.14 research imx6ul-pinfunc.h*/
		pinctrl_ecspi3: ipslcd {
			fsl,pins = < 
				MX6UL_PAD_UART3_TX_DATA__GPIO1_IO24		0x10b0	/* RES */
				MX6UL_PAD_UART3_RX_DATA__GPIO1_IO25		0x10b0	/* DC */

				MX6UL_PAD_UART2_TX_DATA__GPIO1_IO20		0x10b0	/* CS */
				MX6UL_PAD_UART2_RX_DATA__ECSPI3_SCLK	0x10b1	/* SCLK high slew rate*/
				MX6UL_PAD_UART2_RTS_B__ECSPI3_MISO		0x10b1	/* MISO high slew rate*/
				MX6UL_PAD_UART2_CTS_B__ECSPI3_MOSI		0x10b1	/* MOSI high slew rate*/
			>;
		};
...


/* zxy ips_tftlcd */
&ecspi3 {
	fsl,spi-num-chipselects = <1>;
	res-gpios = <&gpio1 24 GPIO_ACTIVE_HIGH>;//用于自己的驱动reset
	dc-gpios = <&gpio1 25 GPIO_ACTIVE_HIGH>;//用于自己的驱动dc
	cs-gpios = <&gpio1 20 GPIO_ACTIVE_LOW>;	//spi-imx.c中的probe函数识别并使用该片选
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_ecspi3>;//pinctrl子系统加载刚才配置的引脚，使其具有复用、电器属性
	status = "okay";

	/* ipslcd sub-node */
	/*
	spidev0: ipslcd@0 {	//0表示片选 
		compatible = "zhongjing,ipslcd_st7789v";
		spi-max-frequency = <25000000>;	//刷新频率有待商榷 
		reg = <0>;
	};	
	*/
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    fbtft_device.c
    描述设备树未描述完的设备信息，由于/driver/spi中的驱动自己在设备树中找到了cs片选，这里就不用描述了。

    传给struct fbtft_device_display displays[]这个结构体用于匹配，之后在驱动初始化函数中申请硬件资源。

    //name必须赋值,赋值为你要使用的驱动，这样才能和displays[].name匹配上，否则这里会使用默认的空，然后你就很难找到问题所在
static char *name = "zxy_ipslcd_st7789v";
//分析代码得知，这个必须设置 (即使设置了下面配置列表的busnum也无效，这里应该是原来代码的bug)
static unsigned busnum = 2;

......

//struct fbtft_device_display displays[]中添加自己的设备信息
{	//zxy ipslcd st7789v 设备硬件描述，替代设备树
		.name = "zxy_ipslcd_st7789v",
		.spi = &(struct spi_board_info) {
			.modalias = "fb_st7789v",	//用于匹配driver
			.max_speed_hz = 25000000,	//25MHz
			.bus_num = 2,	//spi总线编号 ecspi3==spi2.0
			//.chip_select = 0,	//片选初始化电平
			.mode = SPI_MODE_0,	//spi模式
			.platform_data = &(struct fbtft_platform_data) {
				.display = {
					.buswidth = 8,	//总线宽度
					//.backlight = 1,	//背光
				},
				.bgr = false,	//背景 一般为false
				.gpios = (const struct fbtft_gpio []) {	//gpio设置，前提是IO复用和电气属性已经配置
					{ "reset", 24 },	//指定reset gpio号
					{ "dc", 25 },		//指定dc gpio号
					//{ "cs", 20 },		//指定cs gpio号
					//{ "led", 3 },
					//{},
				},
			}
		}
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    st7789v.c
    在这就可以参考之前写的那个测试驱动初始化函数。

    里边儿写的这些主要有初始化函数、设置窗口函数。
    最后传给struct fbtft_display display这个结构体变量。

    本来也写了个测试刷屏的函数，写完之后启动内核的时候可就炸了，直接failed，吓得咱赶紧去掉，或许是内核的启动内存控制比较严格吧，不小心给弄的栈溢出了。

    /*
 * FB driver for the st7789s LCD display controller
 *
 * This display uses 9-bit SPI: Data/Command bit + 8 data bits
 * For platforms that doesn't support 9-bit, the driver is capable
 * of emulating this using 8-bit transfer.
 * This is done by transferring eight 9-bit words in 9 bytes.
 *
 * Copyright (C) 2013 Christian Vogelgsang
 * Based on adafruit22fb.c by Noralf Tronnes
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include "fbtft.h"

/*
author : zxy
describe: 搞了好几天也没搞好，正愁着，看了一眼zhihui大佬的驱动，原来这个驱动是叫st7789vw，
		  调试时候，单独写的驱动模块，屏幕初始化，按照中景源码写的，调试OK
		  使用fbtft这一部分接近内核，就有点儿陌生了，调了好几天，确定了以下代码，和其他屏幕不同，
		  如此的小屏幕，还是发命令，发字节啥的都自己写一遍吧，都交给通用源码恐难以消受。
		  不管怎样，这也算搞好了。
日志：		2022.2.17 更新为240*280 ipslcd 屏幕
*/


#define DRVNAME		"fb_st7789v"
#define WIDTH		280//如果旋转了角度，这里的宽高需要对调
#define HEIGHT		240
#define DEFAULT_GAMMA \
    "D0 04 0D 11 13 2B 3F 54 4C 18 0D 0B 1F 23\n" \
    "D0 04 0C 11 13 2C 3F 44 51 2F 1F 1F 20 23"	//颜色细调，非专业人士请勿靠近，默认

/* 写命令 */
static int ipslcd_write_command(struct fbtft_par *par, u8 cmd)
{
	int ret;

	gpio_set_value(par->gpio.dc, 0);
	ret = par->fbtftops.write(par, &cmd, 1);
	if (ret < 0)
		dev_err(par->info->device,
			"write() failed and returned %d\n", ret);
	gpio_set_value(par->gpio.dc, 1);
	
	return ret;
}

/* 写数据 8bit */
static int ipslcd_write_data8(struct fbtft_par *par, u8 data)
{
	int ret;

	ret = par->fbtftops.write(par, &data, 1);
	if (ret < 0)
		dev_err(par->info->device,
			"write() failed and returned %d\n", ret);

	return ret;
}

/* 硬件复位 */
static void reset(struct fbtft_par *par)
{
	if(par->gpio.reset == -1)
		return;

	gpio_set_value(par->gpio.reset, 0);
	mdelay(200);
	gpio_set_value(par->gpio.reset, 1);
	mdelay(200);

	printk("Reset screen done.\n");
}


/* st7789初始化函数 */
static int init_display(struct fbtft_par *par)
{
	par->fbtftops.reset(par);//硬件复位，防止之前的设置干扰当前配置

	printk("**********************************zxy:screen init_display...*************************************************\r\n");

	//************* Start Initial Sequence **********//
	ipslcd_write_command(par, 0x11);
	mdelay(120);
	ipslcd_write_command(par, 0x36);//控制屏幕旋转的寄存器
	ipslcd_write_data8(par, 0xA0);
	/*
	竖屏：0x00或0xC0
	横屏：0x70或0xA0
	修改之后对应的设置窗口函数边框也要微调。
	*/

	ipslcd_write_command(par, 0x3A);
	ipslcd_write_data8(par, 0x05);

	ipslcd_write_command(par, 0xB2);
	ipslcd_write_data8(par, 0x0C);
	ipslcd_write_data8(par, 0x0C);
	ipslcd_write_data8(par, 0x00);
	ipslcd_write_data8(par, 0x33);
	ipslcd_write_data8(par, 0x33); 

	ipslcd_write_command(par, 0xB7); 
	ipslcd_write_data8(par, 0x35);  

	ipslcd_write_command(par, 0xBB);
	ipslcd_write_data8(par, 0x32);		//Vcom=1.35V

	//ipslcd_write_command(par, 0xC0);
	//ipslcd_write_data8(par, 0x2C);

	ipslcd_write_command(par, 0xC2);
	ipslcd_write_data8(par, 0x01);

	ipslcd_write_command(par, 0xC3);
	ipslcd_write_data8(par, 0x15); 		//GVDD=4.8V  颜色深度

	ipslcd_write_command(par, 0xC4);
	ipslcd_write_data8(par, 0x20);  

	ipslcd_write_command(par, 0xC6); 
	ipslcd_write_data8(par, 0x0F);    	//0x0F:60Hz

	ipslcd_write_command(par, 0xD0); 
	ipslcd_write_data8(par, 0xA4);
	ipslcd_write_data8(par, 0xA1);

	ipslcd_write_command(par, 0xE0);
	ipslcd_write_data8(par, 0xD0);
	ipslcd_write_data8(par, 0x08);
	ipslcd_write_data8(par, 0x0E);
	ipslcd_write_data8(par, 0x09);
	ipslcd_write_data8(par, 0x09);
	ipslcd_write_data8(par, 0x05);
	ipslcd_write_data8(par, 0x31);
	ipslcd_write_data8(par, 0x33);
	ipslcd_write_data8(par, 0x48);
	ipslcd_write_data8(par, 0x17);
	ipslcd_write_data8(par, 0x14);
	ipslcd_write_data8(par, 0x15);
	ipslcd_write_data8(par, 0x31);
	ipslcd_write_data8(par, 0x34);

	ipslcd_write_command(par, 0xE1);
	ipslcd_write_data8(par, 0xD0);
	ipslcd_write_data8(par, 0x08);
	ipslcd_write_data8(par, 0x0E);
	ipslcd_write_data8(par, 0x09);
	ipslcd_write_data8(par, 0x09);
	ipslcd_write_data8(par, 0x15);
	ipslcd_write_data8(par, 0x31);
	ipslcd_write_data8(par, 0x33);
	ipslcd_write_data8(par, 0x48);
	ipslcd_write_data8(par, 0x17);
	ipslcd_write_data8(par, 0x14);
	ipslcd_write_data8(par, 0x15);
	ipslcd_write_data8(par, 0x31);
	ipslcd_write_data8(par, 0x34);

	ipslcd_write_command(par, 0x21); 

	ipslcd_write_command(par, 0x29);

	//ipslcd_test_fill(par, 0x001F);

	printk("**********************************zxy:screen init_display...finish*************************************************\r\n");

	return 0;
}

/* st7789设置窗口函数 */
static void set_addr_win(struct fbtft_par *par, int xs, int ys, int xe, int ye)
{
	/* adjustment 去除屏幕黑边儿*/	
	xs += 20; xe += 20;

	/* Column address set */
	write_reg(par, 0x2A,
		(xs >> 8) & 0xFF, xs & 0xFF, (xe >> 8) & 0xFF, xe & 0xFF);

	/* Row address set */
	write_reg(par, 0x2B,
		(ys >> 8) & 0xFF, ys & 0xFF, (ye >> 8) & 0xFF, ye & 0xFF);

	/* Memory write */
	write_reg(par, 0x2C);
}




/* 一些硬件参数 初始化、窗口 */
static struct fbtft_display display = {
	.regwidth = 8,	//IC 8bit
	.width = WIDTH,
	.height = HEIGHT,
	.gamma_num = 2,	//gamma的暂时默认
	.gamma_len = 14,
	.gamma = DEFAULT_GAMMA,
	.fbtftops = {
		.reset = reset,
		.init_display = init_display,
		.set_addr_win = set_addr_win,
	},
};
FBTFT_REGISTER_DRIVER(DRVNAME, "zj,st7789v", &display);	//兼容性compatible fbtft.h

MODULE_ALIAS("spi:" DRVNAME);
MODULE_ALIAS("platform:" DRVNAME);
MODULE_ALIAS("spi:st7789v");
MODULE_ALIAS("platform:st7789v");

MODULE_DESCRIPTION("FB driver for the st7789v LCD display controller");
MODULE_AUTHOR("zxy");
MODULE_LICENSE("GPL");
*/



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261

    图形界面配置
    打开自己添加的驱动加入编译队列，/driver/staging/fbtft：

    • Kconfig
    config FB_TFT_ST7789V
	tristate "FB driver for the ST7789V LCD Controller"
	depends on FB_TFT
	help
	  Generic Framebuffer support for ST7789V

    • 1
    • 2
    • 3
    • 4
    • 5
    • Makefile
    obj-$(CONFIG_FB_TFT_ST7789V)     += fb_st7789v.o	# 根据Kconfig 告诉编译器，我是否要得到这个文件

    • 1

    • 设置自己的驱动编译进内核
      在这里插入图片描述
      按“Y”，编译进内核。
      在这里插入图片描述

    • 禁止掉原子那个大LCD驱动编译
      在这里插入图片描述
      按“N”，禁止编译。
      在这里插入图片描述

    最后启动内核，会在板子上出现/dev/fb0节点，且显示终端。

    遇到的问题：
    1、就是那个fbtft_device.c中的开头的内部链接静态变量name没有说明，导致怎么改，都匹配不上，都逼得我在这些代码中加printk了，一次次启动内核，看看到底程序运行到哪，有没有进入probe函数。这个文件应该可以编译为模块，在终端输入参数启动，所以才有这种静态变量的。
    2、解决了匹配问题，能进probe函数了，可是没有产生/dev/fbx节点，通过本人设置printk，耐心的观察内核启动信息，找到了错误地方，原来是设备描述中gpio请求失败。应该是fbtft_device.c有其他的驱动使用了这两个引脚，可是不是有匹配的吗，至今也有点儿迷，索性就把其他的引脚都注释了。
    /sys/kernel/debug/gpio可以查看板子上gpio使用情况。
    3、结果还是不行，一“hai”解千愁，发现没有给驱动中的display结构体配置reset文件函数，而我的小屏幕这么脆弱，默认的延时肯定很短，承受不起。
    看了默认的果然是，默认的中间20us，这咱的小屏幕哪反应的过来呀。
    自己写一个吧，反应时间也得200ms，只要你写了的函数，他就不会使用默认值，还是很人性化的。
    make V=1 all 2>info.log可以将编译到终端中有error、warning等信息存到文件中便于查看。

    七、摄像头设计及应用

    7.1 概述

    OV5640 是 OV（OmniVision）公司生产的一颗 1/4 寸的 CMOS QSXGA（2592*1944）图像传感器，提供了一个完整的 500W 像素摄像头解决方案，并且集成了自动对焦（AF）功能，具有非常高的性价比。

    该传感器体积小、工作电压低，提供单片 QSXGA 摄像头和影像处理器的所有功能。通过 SCCB 总线控制，可以输出整帧、子采样、缩放和取窗口等方式的各种分辨率 8/10 位影像数据。该产品 QSXGA 图像最高达到 15 帧/秒（1080P 图像可达 30 帧， 720P 图像可达 60帧， QVGA 分辨率时可达 120 帧）。用户可以完全控制图像质量、数据格式和传输方式。所有图像处理功能过程包括伽玛曲线、白平衡、对比度、色度等都可以通过 SCCB 接口编程。

    OV5640 的特点有：

    • 支持图像缩放、平移和窗口设置
    • 支持图像压缩，即可输出 JPEG 图像数据
    • 支持数字视频接口（DVP）和 MIPI 接口
    • 支持自动对焦
    • 自带嵌入式微处理器
    • 标准的 SCCB 接口，兼容 IIC 接口

    功能框图
    在这里插入图片描述
    在这里插入图片描述

    7.2 硬件电路

    原理图：
    在这里插入图片描述
    在这里插入图片描述

    实物图：
    在这里插入图片描述

    7.3 软件编写

    这部分详见本文博文。

    7.3.1 设备树配置

    /* iomxc复用 注意这里使用的引脚，其他设备就不能使用了，找到并注释掉*/
//pinctrl_csi1 pinctrl子系统
pinctrl_csi1: csi1grp {
	fsl,pins = <
		MX6UL_PAD_CSI_MCLK__CSI_MCLK		0x1b088
		MX6UL_PAD_CSI_PIXCLK__CSI_PIXCLK	0x1b088
		MX6UL_PAD_CSI_VSYNC__CSI_VSYNC		0x1b088
		MX6UL_PAD_CSI_HSYNC__CSI_HSYNC		0x1b088
		MX6UL_PAD_CSI_DATA00__CSI_DATA02	0x1b088
		MX6UL_PAD_CSI_DATA01__CSI_DATA03	0x1b088
		MX6UL_PAD_CSI_DATA02__CSI_DATA04	0x1b088
		MX6UL_PAD_CSI_DATA03__CSI_DATA05	0x1b088
		MX6UL_PAD_CSI_DATA04__CSI_DATA06	0x1b088
		MX6UL_PAD_CSI_DATA05__CSI_DATA07	0x1b088
		MX6UL_PAD_CSI_DATA06__CSI_DATA08	0x1b088
		MX6UL_PAD_CSI_DATA07__CSI_DATA09	0x1b088
	>;
};
//csi_pwn_rst pinctrl子系统
csi_pwn_rst: csi_pwn_rstgrp {
	fsl,pins = <
		MX6UL_PAD_GPIO1_IO02__GPIO1_IO02	0x10b0
		MX6UL_PAD_GPIO1_IO04__GPIO1_IO04	0x10b0
	>;
};

/* ov5640设备树 */
ov5640: ov5640@3c {
	compatible = "ovti,ov5640";
	reg = <0x3c>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_csi1
		     &csi_pwn_rst>;
	clocks = <&clks IMX6UL_CLK_CSI>;
	clock-names = "csi_mclk";
	pwn-gpios = <&gpio1 4 1>;
	rst-gpios = <&gpio1 2 0>;
	csi_id = <0>;
	mclk = <24000000>;
	mclk_source = <0>;
	status = "okay";
	port {
		ov5640_ep: endpoint {
			remote-endpoint = <&csi1_ep>;
		};
	};
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    7.3.2 源码拷贝
    出厂源码路径：linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek/drivers/media/platform/mxc，复制当前文件夹到自己开发版本的对应路径下。
    在这里插入图片描述
    配置文件

    事情是这样的，原子linux提供了两套linux源码：
1、专用于文档教程的源码，内部包括无线wifi驱动源码。
2、开发板出厂展示的源码，内部包括ov5640的源码，相关配置文件选项很全面。
我们基于文档教程的源码开发所有功能，因此需要将ov5640源码移植过去，并使用全面的那个配置文件编译ov5640驱动。

    • 1
    • 2
    • 3
    • 4

    配置过程：

    • 出厂源码/arch/arm/configs/imx_alientek_emmc_defconfig复制到教程源码/arch/arm/configs/。
    • linux内核编译是依赖于教程源码/.config，其实imx_alientek_emmc_defconfig和.config都是一个意思。
      将名字改为.config即可进入图形界面配置，每次配置完一项功能就保存.config，配置其他功能再接着用。
      （使用make xxx_defconfig用于将imx_alientek_emmc_defconfig重新保存在教程源码/.config，不过这里不用）
    Location:                                                             │  
  │     -> Device Drivers                                                   │  
  │       -> Multimedia support (MEDIA_SUPPORT [=y])                        │  
  │         -> V4L platform devices (V4L_PLATFORM_DRIVERS [=y]) 

    • 1
    • 2
    • 3
    • 4

    具体配置不用改，出厂源码配置已经设置好了。

    这里遇到的问题，虽然摄像头可以驱动了，但出厂配置文件太全面。到了屏幕开发阶段，想使用ipslcd必须关闭原配4.3寸LCD，关掉原配LCD的配置如下：

    • 配置路径（直接使用新配置的.config）
    Location:                                                             │  
  │     -> Device Drivers                                                   │  
  │       -> Graphics support                                               │  
  │         -> Frame buffer Devices

    • 1
    • 2
    • 3
    • 4
    • 具体设置：尤其注意箭头位置
      在这里插入图片描述

    7.3.3 编译生成驱动模块
    在.config的指导下，经过linux源码编译，在mxc/subdev下找到两个驱动模块，放到板子/lib/modules/4.1.15xxx/路径下（其他路径也可），板子上电，modprobe注册这两个驱动。
    /dev下出现video1说明驱动成功啦！！

    • ov5640_camera：用于摄像头的驱动。
    • mx6s_capture：用于板子捕获相关驱动。
      在这里插入图片描述

    7.3.4 APP程序编写
    只需操作ov5640提供的video1设备接口和ipslcd提供的fb0设备接口，复制原子应用开发教程中的源码。

    /***************************************************************
 Copyright © ALIENTEK Co., Ltd. 1998-2021. All rights reserved.
 文件名 : v4l2_camera.c
 作者 : 邓涛
 版本 : V1.0
 描述 : V4L2摄像头应用编程实战
 其他 : 无
 论坛 : www.openedv.com
 日志 : 初版 V1.0 2021/7/09 邓涛创建
 ***************************************************************/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define FB_DEV              "/dev/fb0"      //LCD设备节点
#define FRAMEBUFFER_COUNT   3               //帧缓冲数量

/*** 摄像头像素格式及其描述信息 ***/
typedef struct camera_format {
    unsigned char description[32];  //字符串描述信息
    unsigned int pixelformat;       //像素格式
} cam_fmt;

/*** 描述一个帧缓冲的信息 ***/
typedef struct cam_buf_info {
    unsigned short *start;      //帧缓冲起始地址
    unsigned long length;       //帧缓冲长度
} cam_buf_info;

static int width;                       //LCD宽度
static int height;                      //LCD高度
static unsigned short *screen_base = NULL;//LCD显存基地址
static int fb_fd = -1;                  //LCD设备文件描述符
static int v4l2_fd = -1;                //摄像头设备文件描述符
static cam_buf_info buf_infos[FRAMEBUFFER_COUNT];
static cam_fmt cam_fmts[10];
static int frm_width, frm_height;   //视频帧宽度和高度

static int fb_dev_init(void)
{
    struct fb_var_screeninfo fb_var = {0};
    struct fb_fix_screeninfo fb_fix = {0};
    unsigned long screen_size;

    /* 打开framebuffer设备 */
    fb_fd = open(FB_DEV, O_RDWR);
    if (0 > fb_fd) {
        fprintf(stderr, "open error: %s: %s\n", FB_DEV, strerror(errno));
        return -1;
    }

    /* 获取framebuffer设备信息 */
    ioctl(fb_fd, FBIOGET_VSCREENINFO, &fb_var);
    ioctl(fb_fd, FBIOGET_FSCREENINFO, &fb_fix);

    screen_size = fb_fix.line_length * fb_var.yres;
    width = fb_var.xres;
    height = fb_var.yres;

    /* 内存映射 */
    screen_base = mmap(NULL, screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
    if (MAP_FAILED == (void *)screen_base) {
        perror("mmap error");
        close(fb_fd);
        return -1;
    }

    /* LCD背景刷白 */
    memset(screen_base, 0xFF, screen_size);
    return 0;
}

static int v4l2_dev_init(const char *device)
{
    struct v4l2_capability cap = {0};

    /* 打开摄像头 */
    v4l2_fd = open(device, O_RDWR);
    if (0 > v4l2_fd) {
        fprintf(stderr, "open error: %s: %s\n", device, strerror(errno));
        return -1;
    }

    /* 查询设备功能 */
    ioctl(v4l2_fd, VIDIOC_QUERYCAP, &cap);

    /* 判断是否是视频采集设备 */
    if (!(V4L2_CAP_VIDEO_CAPTURE & cap.capabilities)) {
        fprintf(stderr, "Error: %s: No capture video device!\n", device);
        close(v4l2_fd);
        return -1;
    }

    return 0;
}

static void v4l2_enum_formats(void)
{
    struct v4l2_fmtdesc fmtdesc = {0};

    /* 枚举摄像头所支持的所有像素格式以及描述信息 */
    fmtdesc.index = 0;
    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FMT, &fmtdesc)) {

        // 将枚举出来的格式以及描述信息存放在数组中
        cam_fmts[fmtdesc.index].pixelformat = fmtdesc.pixelformat;
        strcpy(cam_fmts[fmtdesc.index].description, fmtdesc.description);
        fmtdesc.index++;
    }
}

static void v4l2_print_formats(void)
{
    struct v4l2_frmsizeenum frmsize = {0};
    struct v4l2_frmivalenum frmival = {0};
    int i;

    frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    for (i = 0; cam_fmts[i].pixelformat; i++) {

        printf("format<0x%x>, description<%s>\n", cam_fmts[i].pixelformat,
                    cam_fmts[i].description);

        /* 枚举出摄像头所支持的所有视频采集分辨率 */
        frmsize.index = 0;
        frmsize.pixel_format = cam_fmts[i].pixelformat;
        frmival.pixel_format = cam_fmts[i].pixelformat;
        while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {

            printf("size<%d*%d> ",
                    frmsize.discrete.width,
                    frmsize.discrete.height);
            frmsize.index++;

            /* 获取摄像头视频采集帧率 */
            frmival.index = 0;
            frmival.width = frmsize.discrete.width;
            frmival.height = frmsize.discrete.height;
            while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {

                printf("<%dfps>", frmival.discrete.denominator /
                        frmival.discrete.numerator);
                frmival.index++;
            }
            printf("\n");
        }
        printf("\n");
    }
}

static int v4l2_set_format(void)
{
    struct v4l2_format fmt = {0};
    struct v4l2_streamparm streamparm = {0};

    /* 设置帧格式 */
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type类型
    fmt.fmt.pix.width = width;  //视频帧宽度
    fmt.fmt.pix.height = height;//视频帧高度
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;  //像素格式
    if (0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt)) {
        fprintf(stderr, "ioctl error: VIDIOC_S_FMT: %s\n", strerror(errno));
        return -1;
    }

    /*** 判断是否已经设置为我们要求的RGB565像素格式
    如果没有设置成功表示该设备不支持RGB565像素格式 */
    if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {
        fprintf(stderr, "Error: the device does not support RGB565 format!\n");
        return -1;
    }

    frm_width = fmt.fmt.pix.width;  //获取实际的帧宽度
    frm_height = fmt.fmt.pix.height;//获取实际的帧高度
    printf("视频帧大小<%d * %d>\n", frm_width, frm_height);

    /* 获取streamparm */
    streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ioctl(v4l2_fd, VIDIOC_G_PARM, &streamparm);

    /** 判断是否支持帧率设置 **/
    if (V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability) {
        streamparm.parm.capture.timeperframe.numerator = 1;
        streamparm.parm.capture.timeperframe.denominator = 30;//30fps
        if (0 > ioctl(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {
            fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
            return -1;
        }
    }

    return 0;
}

static int v4l2_init_buffer(void)
{
    struct v4l2_requestbuffers reqbuf = {0};
    struct v4l2_buffer buf = {0};

    /* 申请帧缓冲 */
    reqbuf.count = FRAMEBUFFER_COUNT;       //帧缓冲的数量
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    reqbuf.memory = V4L2_MEMORY_MMAP;
    if (0 > ioctl(v4l2_fd, VIDIOC_REQBUFS, &reqbuf)) {
        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
        return -1;
    }

    /* 建立内存映射 */
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

        ioctl(v4l2_fd, VIDIOC_QUERYBUF, &buf);
        buf_infos[buf.index].length = buf.length;
        buf_infos[buf.index].start = mmap(NULL, buf.length,
                PROT_READ | PROT_WRITE, MAP_SHARED,
                v4l2_fd, buf.m.offset);
        if (MAP_FAILED == buf_infos[buf.index].start) {
            perror("mmap error");
            return -1;
        }
    }

    /* 入队 */
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

        if (0 > ioctl(v4l2_fd, VIDIOC_QBUF, &buf)) {
            fprintf(stderr, "ioctl error: VIDIOC_QBUF: %s\n", strerror(errno));
            return -1;
        }
    }

    return 0;
}

static int v4l2_stream_on(void)
{
    /* 打开摄像头、摄像头开始采集数据 */
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if (0 > ioctl(v4l2_fd, VIDIOC_STREAMON, &type)) {
        fprintf(stderr, "ioctl error: VIDIOC_STREAMON: %s\n", strerror(errno));
        return -1;
    }

    return 0;
}

static void v4l2_read_data(void)
{
    struct v4l2_buffer buf = {0};
    unsigned short *base;
    unsigned short *start;
    int min_w, min_h;
    int j;

    if (width > frm_width)
        min_w = frm_width;
    else
        min_w = width;
    if (height > frm_height)
        min_h = frm_height;
    else
        min_h = height;

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for ( ; ; ) {

        for(buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

            ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);     //出队
            for (j = 0, base=screen_base, start=buf_infos[buf.index].start;
                        j < min_h; j++) {

                memcpy(base, start, min_w * 2); //RGB565 一个像素占2个字节
                base += width;  //LCD显示指向下一行
                start += frm_width;//指向下一行数据
            }

            // 数据处理完之后、再入队、往复
            ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
        }
    }
}

int main(int argc, char *argv[])
{
    if (2 != argc) {
        fprintf(stderr, "Usage: %s \n", argv[0]);
        exit(EXIT_FAILURE);
    }

    /* 初始化LCD */
    if (fb_dev_init())
        exit(EXIT_FAILURE);

    /* 初始化摄像头 */
    if (v4l2_dev_init(argv[1]))
        exit(EXIT_FAILURE);

    /* 枚举所有格式并打印摄像头支持的分辨率及帧率 */
    v4l2_enum_formats();
    v4l2_print_formats();

    /* 设置格式 */
    if (v4l2_set_format())
        exit(EXIT_FAILURE);

    /* 初始化帧缓冲：申请、内存映射、入队 */
    if (v4l2_init_buffer())
        exit(EXIT_FAILURE);

    /* 开启视频采集 */
    if (v4l2_stream_on())
        exit(EXIT_FAILURE);

    /* 读取数据：出队 */
    v4l2_read_data();       //在函数内循环采集数据、将其显示到LCD屏

    exit(EXIT_SUCCESS);
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335

    编译生成App文件放到板子里。

    ./App名字 /dev/video1

    • 1

    八、其他功能

    8.1 无线WiFi应用

    该部分见本人博文
    实物图
    在这里插入图片描述

    驱动成功后，启动系统重要的操作就是：
    接口配置

    /etc/network/interfaces.d/wlan0
auto wlan0
iface wlan0 inet static	//设置为静态ip，不适用dhcp，以免相互冲突
address 192.168.18.34
netmask 255.255.255.0
gateway 192.168.18.1

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    连接无线

     ifconfig -a	//查看所有可驱动网口
 ifconfig wlan0 up//打开wlan0网口，即wifi部分
 iwlist wlan0 scanning//扫描所有热点
 //配置连接热点的文件，格式要求严格，2个空格缩进
 /etc/wpa_supplicant.conf
文件中：ctrl_interface=/var/run/wpa_supplicant
		ap_scan=1
		network={
			ssid="热点名"
			psk="密码"
		}
//新建缓存文件
mkdir /var/run/wpa_supplicant -p	
//最后一步连接热点
wpa_supplicant -Dwext -iwlan0 -c/etc/wpa_supplicant.conf  &
// /etc/network/interfaces.d/wlan0下改一下ip地址和网关地址
// /etc/resolv.conf下改一下网关地址
//最后重启网络配置
/etc/init.d/networking restart

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    8.2 扩展接口

    设置扩展接口，用于后期外接其他有趣的设备。

    复用接口
    在这里插入图片描述

    电路图
    在这里插入图片描述

    8.3 未安排的

    。。。（略）

    九、结果展示

    PCB绘制结果
    在这里插入图片描述
    PCB打板结果
    过了几天，板子来了。
    在这里插入图片描述
    焊接结果
    经过一天的焊接，完成。
    在这里插入图片描述
    开机显示
    有了小熊板的制作经验，一次成功，！！！
    在这里插入图片描述
    B站稿件
    制作过程留下了一些痕迹，都整理为小视频了。前往观看
    上传到了gitee仓库

  • 相关阅读:
    罗胖关于学习的观点
    那里可以自学C语言？
    【云原生之Docker实战】使用Docker部署siyuan个人笔记系统
    SQL注入漏洞 | bool型
    PMP每日一练 | 考试不迷路-8.10（包含敏捷+多选）
    大数据概述、前世今生、处理流程、学习路线、开发工具详解
    Lilishop 开源商城系统代码审计
    微信小程序开发系列（三十五）·自定义组件的属性properties
    Springboot整合Mybatis
    地铁听书系列之“看破不说破，81个为人处事潜规则”8月圆满收尾20220831
  • 原文地址：https://blog.csdn.net/qq_41753052/article/details/125433234