登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›龙芯2k0300 - 走马观碑组vl53l0x驱动移植

龙芯2k0300 - 走马观碑组vl53l0x驱动移植

赏勿 7 天前
程序园永久vip申请，无限下载程序园所有程序/软件/数据/等
在《龙芯2k0300 - 久久派开发环境搭建及内核升级》中我们介绍了如何将久久派默认带有的PMON固件以及内核linux 4.19升级为uboot及linux 6.12版本。当我们的板子执行了升级操作后，我们的系统环境已经搭建完成了，接下来的任务就是移植驱动程序和编写应用程序。其中涉及的模块有：

  • VL53测距模块；
  • 1.8寸SPI TFT屏幕；
  • MPU6050陀螺仪。
这里我们参考的资料主要来源以下两个仓库：

  • 《龙芯2K300_301软件开源库》;
  • 《WwuSama 21届智能车走马观碑开源仓库》。
一、开源驱动

1.1 创建项目目录

在/opt/2k0300目录下创建子目录loongson_2k300_lib；
  1. zhengyang@ubuntu:/opt/2k0300$ mkdir loongson_2k300_lib
  2. zhengyang@ubuntu:/opt/2k0300$ cd loongson_2k300_lib
复制代码
创建驱动子目录：
  1. zhengyang@ubuntu:/opt/2k0300/loongson_2k300_lib$ mkdir driver
复制代码
创建测试用例子目录：
  1. zhengyang@ubuntu:/opt/2k0300/loongson_2k300_lib$ mkdir example
复制代码
创建走马观碑项目子目录：
  1. zhengyang@ubuntu:/opt/2k0300/loongson_2k300_lib$ mkdir car_project
复制代码
1.2 拷贝驱动

这里我们将《WwuSama/21届智能车走马观碑开源仓库》开源的linux 6.9源码下载下来，需要注意的是仓库中已经将linux内核源码移除了，但是其QQ交流群依然提供了内核源码，这里我下载了linux-6.9-WuwuSama-99pi.tar.gz，其驱动位于drivers/wuwu_drivers/：
  1. zhengyang@ubuntu:/opt/2k0300/build-2k0300/workspace/linux-6.9-WuwuSama-99pi$ ll drivers/wuwu_drivers/
  2. -rw-rw-r--   1 zhengyang zhengyang  7109 12月 17 16:42 imc20602.h
  3. -rw-rw-r--   1 zhengyang zhengyang  4144 12月 17 16:42 wuwu_brushless.c
  4. -rw-rw-r--   1 zhengyang zhengyang  3601 12月 17 16:42 wuwu_buzzer.c
  5. -rw-rw-r--   1 zhengyang zhengyang  4134 12月 17 16:42 wuwu_fans.c
  6. -rw-rw-r--   1 zhengyang zhengyang  9198 12月 17 16:42 wuwu_icm42688.c
  7. -rw-rw-r--   1 zhengyang zhengyang  5306 12月 17 16:42 wuwu_icm42688.h
  8. -rw-rw-r--   1 zhengyang zhengyang 11666 12月 17 16:42 wuwu_imc20602.c
  9. -rw-rw-r--   1 zhengyang zhengyang 13770 12月 17 16:42 wuwu_motor.c
  10. -rw-rw-r--   1 zhengyang zhengyang  1488 12月 17 16:42 wuwu_motor.h
  11. -rw-rw-r--   1 zhengyang zhengyang  4416 12月 17 16:42 wuwu_servo.c
  12. -rw-rw-r--   1 zhengyang zhengyang 30204 12月 17 16:42 wuwu_vl53l0x.c
  13. -rw-rw-r--   1 zhengyang zhengyang   877 12月 17 16:42 wuwu_vl53l0x.h
复制代码
我们将这些驱动拷贝到loongson_2k300_lib/driver目录，供我们参考使用；
  1. zhengyang@ubuntu:/opt/2k0300/loongson_2k300_lib/driver$ cp /opt/2k0300/build-2k0300/workspace/linux-6.9-WuwuSama-99pi/drivers/wuwu_drivers/* ./
复制代码
1.3 准备工作

在下文，我们将会进行各个模块的驱动编译，在编译之前，先在内核源码目录执行如下命令，生成 Module.symvers：
  1. zhengyang@ubuntu:/opt/2k0300/build-2k0300/workspace/linux-6.12$ source ../set_env.sh && make loongson_2k300_defconfig V=1
  2. # 生成Module.symvers的命令
  3. zhengyang@ubuntu:/opt/2k0300/build-2k0300/workspace/linux-6.12$ source ../set_env.sh && make  modules_prepare -j$(nproc)
  4. # 如果没有Module.symvers才需要执行下面这条指令
  5. zhengyang@ubuntu:/opt/2k0300/build-2k0300/workspace/linux-6.12$ cp vmlinux.symvers Module.symvers
复制代码
这一步会生成完整的 Module.symvers，其中记录了内核导出的所有符号信息。
二、vl53l0x设备驱动

如果对I2C驱动源码移植感兴趣，可参考：

  • 《通信协议-I2C》；
  • 《linux驱动移植-I2C总线设备驱动》；
  • 《linux驱动移植-I2C适配器驱动移植》；
  • 《linux驱动移植-I2C驱动移植（OLED SSD1306）》。
2.1 项目目录

接下来我们创建子目录i2c_vl53l0x_driver ：
  1. zhengyang@ubuntu:/opt/2k0300/loongson_2k300_lib/driver$ mkdir i2c_vl53l0x_driver
复制代码
拷贝源码：
  1. zhengyang@ubuntu:/opt/2k0300/loongson_2k300_lib/driver/i2c_vl53l0x_driver$ cp ../wuwu_vl53l0x.* ./
  2. zhengyang@ubuntu:/opt/2k0300/loongson_2k300_lib/driver/i2c_vl53l0x_driver$ ll
  4. -rw-rw-r-- 1 zhengyang zhengyang 30204  3月 23 21:25 wuwu_vl53l0x.c
  5. -rw-rw-r-- 1 zhengyang zhengyang   877  3月 23 21:25 wuwu_vl53l0x.h
复制代码
wuwu_vl53l0x.c代码内容较多，这里我们对其进行拆分，并进行适当调整，最终目录结构如下：
  1. i2c_vl53l0x_driver/
  2. ├── inc/
  3. │   └── vl53l0x.h         # 公共头文件（宏、结构体定义、ioctl 命令等）
  4. ├── src/
  5. │   ├── vl53l0x_core.c    # 核心层：传感器初始化、测距算法
  6. │   ├── vl53l0x_dev.c     # 设备层：字符设备接口
  7. │   └── vl53l0x_hw.c      # 硬件层：I2C 读写操作
  8. ├── vl53l0x_driver.c      # 驱动层：I2C 驱动注册、probe/remove
  9. └── Makefile
复制代码
2.2 vl53l0x.h

inc为头文件目录，在inc创建vl53l0x.h文件；
  1. /*
  2. * VL53L0X Linux I2C Driver
  3. * Copyright (C) 2026 zhengyang
  4. *
  5. * Based on Seekfree TC264 Library: https://gitee.com/seekfree/TC264_Library
  6. * SPDX-License-Identifier: GPL-2.0-only
  7. */
  9. #ifndef _VL53L0X_H_
  10. #define _VL53L0X_H_
  12. #include <linux/module.h>
  13. #include <linux/kernel.h>
  14. #include <linux/init.h>
  15. #include <linux/fs.h>
  16. #include <linux/uaccess.h>
  17. #include <linux/io.h>
  18. #include <linux/cdev.h>
  19. #include <linux/device.h>
  20. #include <linux/i2c.h>
  21. #include <linux/delay.h>
  22. #include <linux/ioctl.h>
  24. /* ========================= 设备信息 ========================= */
  25. #define VL53L0X_COUNT           1
  26. #define VL53L0X_NAME            "vl53l0x_tof"
  28. /* ========================= ioctl 命令 ========================= */
  29. #define VL53L0X_IOCTL_MAGIC     't'
  30. #define VL53L0X_GET_DATA        _IOR(VL53L0X_IOCTL_MAGIC, 1, uint16_t)
  32. /* ========================= 硬件常量 ========================= */
  33. #define VL53L0X_TIMEOUT_COUNT   10
  35. /* ========================= 辅助宏 ========================= */
  36. #define decode_vcsel_period(reg_val)            (((reg_val) + 1) << 1)
  37. #define calc_macro_period(vcsel_period_pclks)   ((((uint32_t)2304 * (vcsel_period_pclks) * 1655) + 500) / 1000)
  39. /* ========================= 枚举定义 ========================= */
  40. typedef enum {
  41.     VL53L0X_VCSEL_PERIOD_PER_RANGE,
  42.     VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
  43. } vl53l0x_vcsel_period_type_enum;
  45. /* ========================= 结构体定义 ========================= */
  46. typedef struct {
  47.     uint8_t tcc;
  48.     uint8_t msrc;
  49.     uint8_t dss;
  50.     uint8_t pre_range;
  51.     uint8_t final_range;
  52. } vl53l0x_sequence_enables_step_struct;
  54. typedef struct {
  55.     uint16_t pre_range_vcsel_period_pclks;
  56.     uint16_t final_range_vcsel_period_pclks;
  58.     uint16_t msrc_dss_tcc_mclks;
  59.     uint16_t pre_range_mclks;
  60.     uint16_t final_range_mclks;
  61.     uint32_t msrc_dss_tcc_us;
  62.     uint32_t pre_range_us;
  63.     uint32_t final_range_us;
  64. } vl53l0x_sequence_timeout_step_struct;
  66. /* 内部设备结构（所有模块共用） */
  67. struct vl53l0x_dev {
  68.     dev_t devid;
  69.     struct cdev cdev;
  70.     struct class *class;
  71.     struct device *device;
  73.     void *private_data;          /* 指向 i2c_client */
  74.     struct mutex lock;
  75.     uint16_t vl53l0x_distance_mm;
  76. };
  78. /* ========================= 全局变量声明 ========================= */
  79. extern struct vl53l0x_dev vl53l0x;
  81. /* ========================= 硬件层函数声明 ========================= */
  82. int vl53l0x_read_regs(struct vl53l0x_dev *dev, u8 reg, void *val, int len);
  83. int vl53l0x_write_regs(struct vl53l0x_dev *dev, u8 reg, u8 *buf, u8 len);
  84. void vl53l0x_writeByte(u8 reg, u8 Byte);
  85. void vl53l0x_writeBuf(u8 reg, u8 *buf, u8 len);
  86. void vl53l0x_readByte(u8 reg, u8 *byte);
  87. void vl53l0x_readBuf(u8 reg, u8 *buf, u8 len);
  89. /* ========================= 核心层函数声明 ========================= */
  90. void vl53l0x_set_signal_rate_limit(uint16_t limit_mcps);
  91. uint8_t vl53l0x_get_spad_info(uint8_t *index, uint8_t *type_is_aperture);
  92. void vl53l0x_get_sequence_step_enables(vl53l0x_sequence_enables_step_struct *enables);
  93. uint8_t vl53l0x_get_vcsel_pulse_period(vl53l0x_vcsel_period_type_enum type);
  94. uint32_t vl53l0x_timeout_mclks_to_microseconds(uint16_t timeout_period_mclks, uint8_t vcsel_period_pclks);
  95. uint16_t vl53l0x_decode_timeout(uint16_t reg_val);
  96. void vl53l0x_get_sequence_step_timeouts(const vl53l0x_sequence_enables_step_struct *enables,
  97.                                         vl53l0x_sequence_timeout_step_struct *timeouts);
  98. uint32_t vl53l0x_get_measurement_timing_budget(void);
  99. uint16_t vl53l0x_encode_timeout(uint16_t timeout_mclks);
  100. uint32_t vl53l0x_timeout_microseconds_to_mclks(uint32_t timeout_period_us, uint8_t vcsel_period_pclks);
  101. uint8_t vl53l0x_set_measurement_timing_budget(uint32_t budget_us);
  102. uint8_t vl53l0x_perform_single_ref_calibration(uint8_t vhv_init_byte);
  103. int vl53l0x_init(void);
  104. void vl53l0x_get_distance(void);
  106. /* ========================= 设备层函数声明 ========================= */
  107. int vl53l0x_cdev_init(struct i2c_client *client);
  108. void vl53l0x_cdev_destroy(void);
  110. #endif /* _VL53L0X_H_ */
复制代码
2.3.2 vl53l0x_core.c

vl53l0x_core.c: 核心层，实现传感器初始化、距离读取等算法，调用硬件层；
点击查看详情
  1. #include "vl53l0x.h"
  3. /* I2C 读写函数（硬件层） */
  4. int vl53l0x_read_regs(struct vl53l0x_dev *dev, u8 reg, void *val, int len)
  5. {
  6.     struct i2c_client *client = (struct i2c_client *)dev->private_data;
  8.     struct i2c_msg msg[] = {
  9.         {
  10.             .addr = client->addr,
  11.             .flags = 0,
  12.             .len = 1,
  13.             .buf = &reg,
  14.         },
  15.         {
  16.             .addr = client->addr,
  17.             .flags = I2C_M_RD,
  18.             .len = len,
  19.             .buf = val,
  20.         },
  21.     };
  23.     return i2c_transfer(client->adapter, msg, 2);
  24. }
  26. int vl53l0x_write_regs(struct vl53l0x_dev *dev, u8 reg, u8 *buf, u8 len)
  27. {
  28.     u8 b[256];
  29.     struct i2c_msg msg;
  30.     struct i2c_client *client = (struct i2c_client *)dev->private_data;
  32.     b[0] = reg;
  33.     memcpy(&b[1], buf, len);
  35.     msg.addr = client->addr;
  36.     msg.flags = 0;
  37.     msg.len = len + 1;
  38.     msg.buf = b;
  40.     return i2c_transfer(client->adapter, &msg, 1);
  41. }
  43. /* 单字节/多字节封装 */
  44. void vl53l0x_writeByte(u8 reg, u8 Byte)
  45. {
  46.     vl53l0x_write_regs(&vl53l0x, reg, &Byte, 1);
  47. }
  49. void vl53l0x_writeBuf(u8 reg, u8 *buf, u8 len)
  50. {
  51.     vl53l0x_write_regs(&vl53l0x, reg, buf, len);
  52. }
  54. void vl53l0x_readByte(u8 reg, u8 *byte)
  55. {
  56.     vl53l0x_read_regs(&vl53l0x, reg, byte, 1);
  57. }
  59. void vl53l0x_readBuf(u8 reg, u8 *buf, u8 len)
  60. {
  61.     vl53l0x_read_regs(&vl53l0x, reg, buf, len);
  62. }
复制代码
2.4 vl53l0x_driver.c

vl53l0x_driver.c: I2C驱动层，实现probe/remove，创建设备节点；
  1. #include "vl53l0x.h"
  3. /* 全局设备结构实例（所有模块共享） */
  4. struct vl53l0x_dev vl53l0x;
  6. //-------------------------------------------------------------------------------------------------------------------
  7. // 函数简介     设置返回信号速率限制 该值单位为 MCPS (百万次每秒)
  8. // 参数说明     limit_mcps      设置的最小速率
  9. // 返回参数     void
  10. // 使用示例     vl53l0x_set_signal_rate_limit(32);
  11. // 备注信息     这个速率表示从目标反射并被设备检测到的信号的振幅
  12. //              设置此限制可以确定传感器报告有效读数所需的最小测量值
  13. //              设置一个较低的限制可以增加传感器的测量范围
  14. //              但似乎也增加了 <由于来自目标以外的物体的不需要的反射导致> 得到不准确读数的可能性
  15. //              默认为 32 MCPS 可预设范围为 0 - 65534
  16. //-------------------------------------------------------------------------------------------------------------------
  17. void vl53l0x_set_signal_rate_limit(uint16_t limit_mcps_fixed)
  18. {
  19.     uint8_t data_buffer[2];
  21.     data_buffer[0] = (limit_mcps_fixed >> 8) & 0xFF;
  22.     data_buffer[1] = limit_mcps_fixed & 0xFF;
  24.     vl53l0x_write_regs(&vl53l0x, 0x44, data_buffer, 2);
  25. }
  28. //-------------------------------------------------------------------------------------------------------------------
  29. // 函数简介     获取设备 SPAD 信息
  30. // 参数说明     index           索引
  31. // 参数说明     type            类型值
  32. // 返回参数     uint8_t           是否成功 0-成功 1-失败
  33. // 使用示例     vl53l0x_get_spad_info(index, type_is_aperture);
  34. // 备注信息
  35. //-------------------------------------------------------------------------------------------------------------------
  36. uint8_t vl53l0x_get_spad_info(uint8_t *index, uint8_t *type_is_aperture)
  37. {
  38.     uint8_t tmp = 0;
  39.     uint8_t return_state = 0;
  40.     volatile uint16_t loop_count = 0;
  42.     do {
  43.         vl53l0x_writeByte(0x80, 0x01);
  44.         vl53l0x_writeByte(0xFF, 0x01);
  45.         vl53l0x_writeByte(0x00, 0x00);
  47.         vl53l0x_writeByte(0xFF, 0x06);
  48.         vl53l0x_readByte(0x83, &tmp);
  49.         vl53l0x_writeByte(0x83, tmp | 0x04);
  50.         vl53l0x_writeByte(0xFF, 0x07);
  51.         vl53l0x_writeByte(0x81, 0x01);
  53.         vl53l0x_writeByte(0x80, 0x01);
  55.         vl53l0x_writeByte(0x94, 0x6b);
  56.         vl53l0x_writeByte(0x83, 0x00);
  58.         tmp = 0x00;
  59.         while (0x00 == tmp || 0xFF == tmp) {
  60.             msleep(1);
  61.             vl53l0x_readByte(0x83, &tmp);
  62.             if (VL53L0X_TIMEOUT_COUNT < loop_count++) {
  63.                 return_state = 1;
  64.                 break;
  65.             }
  66.         }
  67.         if (return_state)
  68.             break;
  70.         vl53l0x_writeByte(0x83, 0x01);
  71.         vl53l0x_readByte(0x92, &tmp);
  73.         *index = tmp & 0x7f;
  74.         *type_is_aperture = (tmp >> 7) & 0x01;
  76.         vl53l0x_writeByte(0x81, 0x00);
  77.         vl53l0x_writeByte(0xFF, 0x06);
  78.         vl53l0x_readByte(0x83, &tmp);
  79.         vl53l0x_writeByte(0x83, tmp);
  80.         vl53l0x_writeByte(0xFF, 0x01);
  81.         vl53l0x_writeByte(0x00, 0x01);
  83.         vl53l0x_writeByte(0xFF, 0x00);
  84.         vl53l0x_writeByte(0x80, 0x00);
  85.     } while (0);
  87.     return return_state;
  88. }
  90. //-------------------------------------------------------------------------------------------------------------------
  91. // 函数简介     获取序列步骤使能设置
  92. // 参数说明     enables         序列使能步骤结构体
  93. // 返回参数     void
  94. // 使用示例     vl53l0x_get_sequence_step_enables(enables);
  95. // 备注信息
  96. //-------------------------------------------------------------------------------------------------------------------
  97. void vl53l0x_get_sequence_step_enables(vl53l0x_sequence_enables_step_struct *enables)
  98. {
  99.     uint8_t sequence_config = 0;
  100.     vl53l0x_readByte(0x01, &sequence_config);
  102.     enables->tcc          = (sequence_config >> 4) & 0x1;
  103.     enables->dss          = (sequence_config >> 3) & 0x1;
  104.     enables->msrc         = (sequence_config >> 2) & 0x1;
  105.     enables->pre_range    = (sequence_config >> 6) & 0x1;
  106.     enables->final_range  = (sequence_config >> 7) & 0x1;
  107. }
  109. //-------------------------------------------------------------------------------------------------------------------
  110. // 函数简介     获取脉冲周期
  111. // 参数说明     type            预量程类型
  112. // 返回参数     uint8_t           返回的周期值
  113. // 使用示例     vl53l0x_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PER_RANGE);
  114. // 备注信息     在 PCLKs 中获取给定周期类型的 VCSEL 脉冲周期
  115. //-------------------------------------------------------------------------------------------------------------------
  116. uint8_t vl53l0x_get_vcsel_pulse_period(vl53l0x_vcsel_period_type_enum type)
  117. {
  118.     uint8_t data_buffer = 0;
  119.     if (VL53L0X_VCSEL_PERIOD_PER_RANGE == type) {
  120.         vl53l0x_readByte(0x50, &data_buffer);
  121.         data_buffer = decode_vcsel_period(data_buffer);
  122.     } else if (VL53L0X_VCSEL_PERIOD_FINAL_RANGE == type) {
  123.         vl53l0x_readByte(0x70, &data_buffer);
  124.         data_buffer = decode_vcsel_period(data_buffer);
  125.     } else {
  126.         data_buffer = 255;
  127.     }
  128.     return data_buffer;
  129. }
  131. //-------------------------------------------------------------------------------------------------------------------
  132. // 函数简介     将超时数值从 MCLKs 转换到对应的 ms
  133. // 参数说明     timeout_period_mclks    超时周期 MCLKs
  134. // 参数说明     vcsel_period_pclks      PCLK 值
  135. // 返回参数     uint32_t                  返回超时数值
  136. // 使用示例     vl53l0x_timeout_mclks_to_microseconds(timeout_period_mclks, vcsel_period_pclks);
  137. // 备注信息     将序列步骤超时从具有给定 VCSEL 周期的 MCLK (以 PCLK 为单位)转换为微秒
  138. //-------------------------------------------------------------------------------------------------------------------
  139. uint32_t vl53l0x_timeout_mclks_to_microseconds(uint16_t timeout_period_mclks, uint8_t vcsel_period_pclks)
  140. {
  141.     uint32_t macro_period_ns = calc_macro_period(vcsel_period_pclks);
  142.     return ((timeout_period_mclks * macro_period_ns) + (macro_period_ns / 2)) / 1000;
  143. }
  145. //-------------------------------------------------------------------------------------------------------------------
  146. // 函数简介     对超时数值进行解码
  147. // 参数说明     reg_val         超时时长 寄存器值
  148. // 返回参数     uint16_t          返回超时数值
  149. // 使用示例     vl53l0x_decode_timeout(reg_val);
  150. // 备注信息     从寄存器值解码 MCLK 中的序列步骤超时
  151. //-------------------------------------------------------------------------------------------------------------------
  152. uint16_t vl53l0x_decode_timeout(uint16_t reg_val)
  153. {
  154.     return (uint16_t)((reg_val & 0x00FF) << ((reg_val & 0xFF00) >> 8)) + 1;
  155. }
  157. //-------------------------------------------------------------------------------------------------------------------
  158. // 函数简介     获取序列步骤超时设置
  159. // 参数说明     enables         序列使能步骤结构体
  160. // 参数说明     timeouts        序列超时步骤结构体
  161. // 返回参数     void
  162. // 使用示例     vl53l0x_get_sequence_step_timeouts(enables, timeouts);
  163. // 备注信息     获取所有超时而不仅仅是请求的超时 并且还存储中间值
  164. //-------------------------------------------------------------------------------------------------------------------
  165. void vl53l0x_get_sequence_step_timeouts(const vl53l0x_sequence_enables_step_struct *enables,
  166.                                         vl53l0x_sequence_timeout_step_struct *timeouts)
  167. {
  168.     uint8_t reg_buffer[2];
  169.     uint16_t reg16_buffer = 0;
  171.     timeouts->pre_range_vcsel_period_pclks = vl53l0x_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PER_RANGE);
  173.     vl53l0x_readByte(0x46, reg_buffer);
  174.     timeouts->msrc_dss_tcc_mclks = reg_buffer[0] + 1;
  175.     timeouts->msrc_dss_tcc_us = vl53l0x_timeout_mclks_to_microseconds(timeouts->msrc_dss_tcc_mclks,
  176.                                                                        (uint8_t)timeouts->pre_range_vcsel_period_pclks);
  178.     vl53l0x_readBuf(0x51, reg_buffer, 2);
  179.     reg16_buffer = ((uint16_t)reg_buffer[0] << 8) | reg_buffer[1];
  180.     timeouts->pre_range_mclks = vl53l0x_decode_timeout(reg16_buffer);
  181.     timeouts->pre_range_us = vl53l0x_timeout_mclks_to_microseconds(timeouts->pre_range_mclks,
  182.                                                                    (uint8_t)timeouts->pre_range_vcsel_period_pclks);
  184.     timeouts->final_range_vcsel_period_pclks = vl53l0x_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE);
  186.     vl53l0x_readBuf(0x71, reg_buffer, 2);
  187.     reg16_buffer = ((uint16_t)reg_buffer[0] << 8) | reg_buffer[1];
  188.     timeouts->final_range_mclks = vl53l0x_decode_timeout(reg16_buffer);
  190.     if (enables->pre_range) {
  191.         timeouts->final_range_mclks -= timeouts->pre_range_mclks;
  192.     }
  194.     timeouts->final_range_us = vl53l0x_timeout_mclks_to_microseconds(timeouts->final_range_mclks,
  195.                                                                      (uint8_t)timeouts->final_range_vcsel_period_pclks);
  196. }
  198. //-------------------------------------------------------------------------------------------------------------------
  199. // 函数简介     获取测量定时预算 (以微秒为单位)
  200. // 参数说明     void
  201. // 返回参数     uint32_t          已设定的测量允许的时间
  202. // 使用示例     vl53l0x_get_measurement_timing_budget();
  203. // 备注信息
  204. //-------------------------------------------------------------------------------------------------------------------
  205. uint32_t vl53l0x_get_measurement_timing_budget(void)
  206. {
  207.     vl53l0x_sequence_enables_step_struct enables;
  208.     vl53l0x_sequence_timeout_step_struct timeouts;
  210.     uint32_t budget_us = 1910 + 960;
  212.     vl53l0x_get_sequence_step_enables(&enables);
  213.     vl53l0x_get_sequence_step_timeouts(&enables, &timeouts);
  215.     if (enables.tcc)
  216.         budget_us += (timeouts.msrc_dss_tcc_us + 590);
  217.     if (enables.dss)
  218.         budget_us += 2 * (timeouts.msrc_dss_tcc_us + 690);
  219.     else if (enables.msrc)
  220.         budget_us += (timeouts.msrc_dss_tcc_us + 660);
  221.     if (enables.pre_range)
  222.         budget_us += (timeouts.pre_range_us + 660);
  223.     if (enables.final_range)
  224.         budget_us += (timeouts.final_range_us + 550);
  226.     return budget_us;
  227. }
  229. //-------------------------------------------------------------------------------------------------------------------
  230. // 函数简介     对超时数值进行编码
  231. // 参数说明     timeout_mclks   超时时长 -MCLKs 值
  232. // 返回参数     uint16_t          返回编码值
  233. // 使用示例     vl53l0x_encode_timeout(timeout_mclks);
  234. // 备注信息     在 MCLK 中对超时的序列步骤超时寄存器值进行编码
  235. //-------------------------------------------------------------------------------------------------------------------
  236. uint16_t vl53l0x_encode_timeout (uint16_t timeout_mclks)
  237. {
  238.     uint32_t ls_byte = 0;
  239.     uint16_t ms_byte = 0;
  240.     uint16_t return_data = 0;
  242.     if(0 < timeout_mclks)
  243.     {
  244.         // 格式: (LSByte * 2 ^ MSByte) + 1
  245.         ls_byte = timeout_mclks - 1;
  246.         while(0 < (ls_byte & 0xFFFFFF00))
  247.         {
  248.             ls_byte >>= 1;
  249.             ms_byte++;
  250.         }
  251.         return_data = (ms_byte << 8) | ((uint16_t)ls_byte & 0xFF);
  252.     }
  253.     return return_data;
  254. }
  256. //-------------------------------------------------------------------------------------------------------------------
  257. // 函数简介     将超时数值从 ms 转换到对应的 MCLKs
  258. // 参数说明     timeout_period_us   超时周期 微秒单位
  259. // 参数说明     vcsel_period_pclks  PCLK 值
  260. // 返回参数     uint32_t              返回超时数值
  261. // 使用示例     vl53l0x_timeout_microseconds_to_mclks(timeout_period_us, vcsel_period_pclks);
  262. // 备注信息     将序列步骤超时从微秒转换为具有给定 VCSEL 周期的 MCLK (以 PCLK 为单位)
  263. //-------------------------------------------------------------------------------------------------------------------
  264. uint32_t vl53l0x_timeout_microseconds_to_mclks (uint32_t timeout_period_us, uint8_t vcsel_period_pclks)
  265. {
  266.     uint32_t macro_period_ns = calc_macro_period(vcsel_period_pclks);
  268.     return (((timeout_period_us * 1000) + (macro_period_ns / 2)) / macro_period_ns);
  269. }
  271. //-------------------------------------------------------------------------------------------------------------------
  272. // 函数简介     设置测量定时预算 (以微秒为单位)
  273. // 参数说明     budget_us       设定的测量允许的时间
  274. // 返回参数     uint8_t           操作结果 0-成功 1-失败
  275. // 使用示例     vl53l0x_set_measurement_timing_budget(measurement_timing_budget_us);
  276. // 备注信息     这是一次测量允许的时间
  277. //              即在测距序列的子步骤之间分配时间预算
  278. //              更长的时间预算允许更精确的测量
  279. //              增加一个N倍的预算可以减少一个sqrt(N)倍的范围测量标准偏差
  280. //              默认为33毫秒 最小值为20 ms
  281. //-------------------------------------------------------------------------------------------------------------------
  282. uint8_t vl53l0x_set_measurement_timing_budget (uint32_t budget_us)
  283. {
  284.     uint8_t return_state = 0;
  285.     uint8_t data_buffer[3];
  286.     uint16_t data = 0;
  288.     vl53l0x_sequence_enables_step_struct enables;
  289.     vl53l0x_sequence_timeout_step_struct timeouts;
  291.     do
  292.     {
  293.         if(20000 > budget_us)
  294.         {
  295.             return_state = 1;
  296.             break;
  297.         }
  299.         uint32_t used_budget_us = 1320 + 960;
  300.         vl53l0x_get_sequence_step_enables(&enables);
  301.         vl53l0x_get_sequence_step_timeouts(&enables, &timeouts);
  303.         if (enables.tcc)
  304.         {
  305.             used_budget_us += (timeouts.msrc_dss_tcc_us + 590);
  306.         }
  308.         if (enables.dss)
  309.         {
  310.             used_budget_us += 2 * (timeouts.msrc_dss_tcc_us + 690);
  311.         }
  312.         else if (enables.msrc)
  313.         {
  314.             used_budget_us += (timeouts.msrc_dss_tcc_us + 660);
  315.         }
  317.         if (enables.pre_range)
  318.         {
  319.             used_budget_us += (timeouts.pre_range_us + 660);
  320.         }
  322.         if (enables.final_range)
  323.         {
  324.             // 请注意 最终范围超时由计时预算和序列中所有其他超时的总和决定
  325.             // 如果没有空间用于最终范围超时 则将设置错误
  326.             // 否则 剩余时间将应用于最终范围
  327.             used_budget_us += 550;
  328.             if (used_budget_us > budget_us)
  329.             {
  330.                 // 请求的超时太大
  331.                 return_state = 1;
  332.                 break;
  333.             }
  335.             // 对于最终超时范围 必须添加预量程范围超时
  336.             // 为此 最终超时和预量程超时必须以宏周期 MClks 表示
  337.             // 因为它们具有不同的 VCSEL 周期
  338.             uint32_t final_range_timeout_us = budget_us - used_budget_us;
  339.             uint16_t final_range_timeout_mclks =
  340.             (uint16_t)vl53l0x_timeout_microseconds_to_mclks(final_range_timeout_us,
  341.                      (uint8_t)timeouts.final_range_vcsel_period_pclks);
  343.             if (enables.pre_range)
  344.             {
  345.                 final_range_timeout_mclks += timeouts.pre_range_mclks;
  346.             }
  348.             data = vl53l0x_encode_timeout(final_range_timeout_mclks);
  349.             data_buffer[0] = 0x71;
  350.             data_buffer[1] = ((data >> 8) & 0xFF);
  351.             data_buffer[2] = (data & 0xFF);
  352.             vl53l0x_writeBuf(data_buffer[0], &data_buffer[1], 2);
  353.         }
  354.     }while(0);
  355.     return return_state;
  356. }
  358. //-------------------------------------------------------------------------------------------------------------------
  359. // 函数简介     执行单次参考校准
  360. // 参数说明     vhv_init_byte   预设校准值
  361. // 返回参数     uint8_t           操作是否成功 0-成功 1-失败
  362. // 使用示例     vl53l0x_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PER_RANGE);
  363. // 备注信息     在 PCLKs 中获取给定周期类型的 VCSEL 脉冲周期
  364. //-------------------------------------------------------------------------------------------------------------------
  365. uint8_t vl53l0x_perform_single_ref_calibration (uint8_t vhv_init_byte)
  366. {
  367.     uint8_t return_state = 0;
  368.     uint8_t data_buffer = 0;
  369.     volatile uint16_t loop_count = 0;
  370.     do
  371.     {
  372.         vl53l0x_writeByte(0x00, 0x01 | vhv_init_byte);
  373.         vl53l0x_readByte(0x46, &data_buffer);
  374.         while(0 == (data_buffer & 0x07))
  375.         {
  376.             msleep(1);
  377.             vl53l0x_readByte(0x46, &data_buffer);
  378.             if(VL53L0X_TIMEOUT_COUNT < loop_count ++)
  379.             {
  380.                 return_state = 1;
  381.                 break;
  382.             }
  383.         }
  384.         if(return_state)
  385.         {
  386.             break;
  387.         }
  388.         vl53l0x_writeByte(0x0B, 0x01);
  389.         vl53l0x_writeByte(0x00, 0x00);
  390.     }while(0);
  392.     return return_state;
  393. }
  395. int vl53l0x_init(void)
  396. {
  397.     uint8_t stop_variable = 0;
  398.     uint8_t reg_data_buffer = 0;
  399.     uint8_t return_state = 0;
  400.     uint32_t measurement_timing_budget_us;
  402.     uint8_t data_buffer[7] = {0};
  403.     uint8_t ref_spad_map[6];
  404.     int i = 0;
  406.     do
  407.     {
  408.         vl53l0x_readByte(0x89, &reg_data_buffer);
  409.         vl53l0x_writeByte(0x89, reg_data_buffer | 0x01);
  411.         vl53l0x_writeByte(0x88, 0x00);
  413.         vl53l0x_writeByte(0x80, 0x01);
  414.         vl53l0x_writeByte(0xFF, 0x01);
  415.         vl53l0x_writeByte(0x00, 0x00);
  417.         vl53l0x_readByte(0x91, &stop_variable);
  419.         vl53l0x_writeByte(0x00, 0x01);
  420.         vl53l0x_writeByte(0xFF, 0x00);
  421.         vl53l0x_writeByte(0x80, 0x00);
  423.         vl53l0x_readByte(0x60, &reg_data_buffer);
  424.         vl53l0x_writeByte(0x60, reg_data_buffer | 0x12);
  426.         vl53l0x_set_signal_rate_limit(32);
  427.         vl53l0x_writeByte(0x01, 0xFF);
  430.         if(vl53l0x_get_spad_info(&data_buffer[0], &data_buffer[1]))
  431.         {
  432.             return_state = 1;
  433.             printk("init error\r\n");
  434.             break;
  435.         }
  437.         vl53l0x_read_regs(&vl53l0x, 0xB0, ref_spad_map, 6);
  439.         vl53l0x_writeByte(0xFF, 0x01);
  440.         vl53l0x_writeByte(0x4F, 0x00);
  441.         vl53l0x_writeByte(0x4E, 0x2C);
  442.         vl53l0x_writeByte(0xFF, 0x00);
  443.         vl53l0x_writeByte(0x86, 0xB4);
  445.         data_buffer[2] = data_buffer[1] ? 12 : 0;
  447.         for(i = 0; 48 > i; i ++)
  448.         {
  449.             if(i < data_buffer[2] || data_buffer[3] == data_buffer[0])
  450.             {
  451.                 // 此位低于应启用的第一个位
  452.                 // 或者 (eference_spad_count) 位已启用
  453.                 // 因此此位为零
  454.                 ref_spad_map[i / 8] &= ~(1 << (i % 8));
  455.             }
  456.             else if((ref_spad_map[i / 8] >> (i % 8)) & 0x1)
  457.             {
  458.                 data_buffer[3] ++;
  459.             }
  460.         }
  462.         data_buffer[0] = 0xB0;
  463.         for(i = 1; 7 > i; i ++)
  464.         {
  465.             data_buffer[1] = ref_spad_map[i - 1];
  466.         }
  467.         vl53l0x_write_regs(&vl53l0x, 0xB0, &data_buffer[1], 6);
  469.         vl53l0x_writeByte(0xFF, 0x01);
  470.         vl53l0x_writeByte(0x00, 0x00);
  471.         vl53l0x_writeByte(0xFF, 0x00);
  472.         vl53l0x_writeByte(0x09, 0x00);
  473.         vl53l0x_writeByte(0x10, 0x00);
  474.         vl53l0x_writeByte(0x11, 0x00);
  475.         vl53l0x_writeByte(0x24, 0x01);
  476.         vl53l0x_writeByte(0x25, 0xFF);
  477.         vl53l0x_writeByte(0x75, 0x00);
  478.         vl53l0x_writeByte(0xFF, 0x01);
  479.         vl53l0x_writeByte(0x4E, 0x2C);
  480.         vl53l0x_writeByte(0x48, 0x00);
  481.         vl53l0x_writeByte(0x30, 0x20);
  482.         vl53l0x_writeByte(0xFF, 0x00);
  483.         vl53l0x_writeByte(0x30, 0x09);
  484.         vl53l0x_writeByte(0x54, 0x00);
  485.         vl53l0x_writeByte(0x31, 0x04);
  486.         vl53l0x_writeByte(0x32, 0x03);
  487.         vl53l0x_writeByte(0x40, 0x83);
  488.         vl53l0x_writeByte(0x46, 0x25);
  489.         vl53l0x_writeByte(0x60, 0x00);
  490.         vl53l0x_writeByte(0x27, 0x00);
  491.         vl53l0x_writeByte(0x50, 0x06);
  492.         vl53l0x_writeByte(0x51, 0x00);
  493.         vl53l0x_writeByte(0x52, 0x96);
  494.         vl53l0x_writeByte(0x56, 0x08);
  495.         vl53l0x_writeByte(0x57, 0x30);
  496.         vl53l0x_writeByte(0x61, 0x00);
  497.         vl53l0x_writeByte(0x62, 0x00);
  498.         vl53l0x_writeByte(0x64, 0x00);
  499.         vl53l0x_writeByte(0x65, 0x00);
  500.         vl53l0x_writeByte(0x66, 0xA0);
  501.         vl53l0x_writeByte(0xFF, 0x01);
  502.         vl53l0x_writeByte(0x22, 0x32);
  503.         vl53l0x_writeByte(0x47, 0x14);
  504.         vl53l0x_writeByte(0x49, 0xFF);
  505.         vl53l0x_writeByte(0x4A, 0x00);
  506.         vl53l0x_writeByte(0xFF, 0x00);
  507.         vl53l0x_writeByte(0x7A, 0x0A);
  508.         vl53l0x_writeByte(0x7B, 0x00);
  509.         vl53l0x_writeByte(0x78, 0x21);
  510.         vl53l0x_writeByte(0xFF, 0x01);
  511.         vl53l0x_writeByte(0x23, 0x34);
  512.         vl53l0x_writeByte(0x42, 0x00);
  513.         vl53l0x_writeByte(0x44, 0xFF);
  514.         vl53l0x_writeByte(0x45, 0x26);
  515.         vl53l0x_writeByte(0x46, 0x05);
  516.         vl53l0x_writeByte(0x40, 0x40);
  517.         vl53l0x_writeByte(0x0E, 0x06);
  518.         vl53l0x_writeByte(0x20, 0x1A);
  519.         vl53l0x_writeByte(0x43, 0x40);
  520.         vl53l0x_writeByte(0xFF, 0x00);
  521.         vl53l0x_writeByte(0x34, 0x03);
  522.         vl53l0x_writeByte(0x35, 0x44);
  523.         vl53l0x_writeByte(0xFF, 0x01);
  524.         vl53l0x_writeByte(0x31, 0x04);
  525.         vl53l0x_writeByte(0x4B, 0x09);
  526.         vl53l0x_writeByte(0x4C, 0x05);
  527.         vl53l0x_writeByte(0x4D, 0x04);
  528.         vl53l0x_writeByte(0xFF, 0x00);
  529.         vl53l0x_writeByte(0x44, 0x00);
  530.         vl53l0x_writeByte(0x45, 0x20);
  531.         vl53l0x_writeByte(0x47, 0x08);
  532.         vl53l0x_writeByte(0x48, 0x28);
  533.         vl53l0x_writeByte(0x67, 0x00);
  534.         vl53l0x_writeByte(0x70, 0x04);
  535.         vl53l0x_writeByte(0x71, 0x01);
  536.         vl53l0x_writeByte(0x72, 0xFE);
  537.         vl53l0x_writeByte(0x76, 0x00);
  538.         vl53l0x_writeByte(0x77, 0x00);
  539.         vl53l0x_writeByte(0xFF, 0x01);
  540.         vl53l0x_writeByte(0x0D, 0x01);
  541.         vl53l0x_writeByte(0xFF, 0x00);
  542.         vl53l0x_writeByte(0x80, 0x01);
  543.         vl53l0x_writeByte(0x01, 0xF8);
  544.         vl53l0x_writeByte(0xFF, 0x01);
  545.         vl53l0x_writeByte(0x8E, 0x01);
  546.         vl53l0x_writeByte(0x00, 0x01);
  547.         vl53l0x_writeByte(0xFF, 0x00);
  548.         vl53l0x_writeByte(0x80, 0x00);
  550.         vl53l0x_writeByte(0x0A, 0x04);
  551.         vl53l0x_readByte(0x84, &reg_data_buffer);
  552.         vl53l0x_writeByte(0x84, reg_data_buffer & ~0x10);
  553.         vl53l0x_writeByte(0x0B, 0x01);
  555.         measurement_timing_budget_us  = vl53l0x_get_measurement_timing_budget();
  557.         vl53l0x_writeByte(0x01, 0xE8);
  558.         vl53l0x_set_measurement_timing_budget(measurement_timing_budget_us);    // 重新计算时序预算
  560.         vl53l0x_writeByte(0x01, 0x01);
  561.         if(vl53l0x_perform_single_ref_calibration(0x40))
  562.         {
  563.             return_state = 1;
  564.             break;
  565.         }
  566.         vl53l0x_writeByte(0x01, 0x02);
  567.         if(vl53l0x_perform_single_ref_calibration(0x00))
  568.         {
  569.             return_state = 1;
  570.             break;
  571.         }
  573.         vl53l0x_writeByte(0x01, 0xE8);
  575.         msleep(100);
  577.         vl53l0x_writeByte(0x80, 0x01);
  578.         vl53l0x_writeByte(0xFF, 0x01);
  579.         vl53l0x_writeByte(0x00, 0x00);
  580.         vl53l0x_writeByte(0x91, stop_variable);
  581.         vl53l0x_writeByte(0x00, 0x01);
  582.         vl53l0x_writeByte(0xFF, 0x00);
  583.         vl53l0x_writeByte(0x80, 0x00);
  585.         vl53l0x_writeByte(0x00, 0x02);
  587.     }while(0);
  589.     return return_state;
  590. }
  592. //-------------------------------------------------------------------------------------------------------------------
  593. // 函数简介     返回以毫米为单位的范围读数
  594. // 参数说明     void
  595. // 返回参数     void
  596. // 使用示例     vl53l0x_get_distance();
  597. // 备注信息     在开始单次射程测量后也调用此函数
  598. //-------------------------------------------------------------------------------------------------------------------
  599. void vl53l0x_get_distance (void)
  600. {
  601.     uint8_t reg_databuffer[3];
  603.     vl53l0x_readByte(0x13, reg_databuffer);
  604.     if((reg_databuffer[0] & 0x07) != 0)
  605.     {
  606.         // 假设线性度校正增益为默认值 1000 且未启用分数范围
  607.         vl53l0x_readBuf(0x14 + 10, reg_databuffer, 2);
  608.         vl53l0x.vl53l0x_distance_mm = ((uint16_t)reg_databuffer[0] << 8);
  609.         vl53l0x.vl53l0x_distance_mm |= reg_databuffer[1];
  611.         vl53l0x_writeByte(0x0B, 0x01);
  612.     }
  613.     if(reg_databuffer[0] & 0x10)
  614.     {
  615.         vl53l0x_readBuf(0x14 + 10, reg_databuffer, 2);
  616.         vl53l0x_writeByte(0x0B, 0x01);
  617.     }
  618. }
复制代码
通过 of_match_table 与设备树中 compatible = "icar,vl53l0x" 的节点匹配，实现驱动与硬件自动绑定。
2.5 Makefile

创建Makefile文件：
[code]# 内核源码路径KERNELDIR ?= /opt/2k0300/build-2k0300/workspace/linux-6.12# 当前驱动目录PWD := $(shell pwd)# 交叉编译工具链CROSS_COMPILE := loongarch64-linux-gnu-# 架构ARCH := loongarch# 所需文件夹BUILD_DIR := buildINCLUDE:=incKO_DIR:=koSRC_DIR:=srcEXTRA_CFLAGS +=  -I$(src)/$(INCLUDE)# 编译目标obj-m := vl53l0x.ovl53l0x-y := vl53l0x_driver.o \             src/vl53l0x_hw.o \             src/vl53l0x_core.o \             src/vl53l0x_dev.o# 编译规则ll: prepare compile move_files# 提前创建目录prepare:        @mkdir -p $(BUILD_DIR) $(KO_DIR)        @echo "
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
龙芯2k0300走马观碑组vl53l0x

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
赏勿
7 天前

0

粉丝关注

18

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫