树莓派使用TOF050F传感器（i2c通信）

已于 2022-08-06 20:23:38 修改
阅读量2.4k 收藏 10
点赞数 2
分类专栏： 树莓派使用传感器 文章标签： python linux
于 2022-08-05 04:22:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44712946/article/details/126169616
版权

系统：64位Ubuntu22.04

python版本：miniconda下的3.8

使用iic库：smbus2

使用现成代码：tholecek的VL6180-Python-3.X

其他材料准备：

TOF050F上位机

ttl转串口模块

一台装windows系统的电脑

目录

        一、安装环境

        二、准备代码        

        三、 打开终端更改权限

        四、 使用上位机配置TOF模块

        五、 连线，并运行test.py

一、安装环境

        1. 22.04系统烧录

        2. 安装miniconda

        3. 在虚拟环境中安装smbus2：

pip install smbus2

        4. 创建一个test.py文件

二、准备代码

        1. 将以下代码复制到 test.py中：

import time
import smbus2
from ST_VL6180X import VL6180X

i2c = smbus2.SMBus(1)
i2c.open(1)


class TOF050F:  # 创建一个类
    def __init__(self):
        self.Lidar = VL6180X(i2cBus=i2c)  # 调用VL6180X传感器的处理函数
        # 初始化
        self.Lidar.get_identification()
        if self.Lidar.idModel != 0xB4:
            print("Not Valid Sensor, Id reported as ", hex(self.Lidar.idModel))
        else:
            print("Valid Sensor, ID reported as ", hex(self.Lidar.idModel))
        self.Lidar.default_settings()

    def distance_mm(self):  # 获取传感器距离信息
        return self.Lidar.get_distance()


My_TOF050F = TOF050F()  # 创建一个对象

while True:  # 循环
    print(My_TOF050F.distance_mm())  # 打印距离
    time.sleep(0.01)

        2. 将 ST_VL6180X.py 放于与 test.py 同级目录下

        3. 修改 ST_VL6180X.py 后内容：

#!/usr/bin/python
# Supports Python 3.X and Above

import time
import smbus2


# ===========================================================================
# ST_VL6180x ToF ranger Class
#
# Code updated to Python 3.X by T. Holecek
# References ST_VL6180x Repository of A, Weber
# https://bitbucket.org/310weber/st_vl6180x
#
# Originally written by A. Weber
# References Arduino library by Casey Kuhns of SparkFun:
# https://github.com/sparkfun/ToF_Range_Finder-VL6180_Library\
# ===========================================================================


class VL6180X:
    #i2c = None

    __VL6180X_IDENTIFICATION_MODEL_ID = 0x0000
    __VL6180X_IDENTIFICATION_MODEL_REV_MAJOR = 0x0001
    __VL6180X_IDENTIFICATION_MODEL_REV_MINOR = 0x0002
    __VL6180X_IDENTIFICATION_MODULE_REV_MAJOR = 0x0003
    __VL6180X_IDENTIFICATION_MODULE_REV_MINOR = 0x0004
    __VL6180X_IDENTIFICATION_DATE = 0x0006  # 16bit value
    __VL6180X_IDENTIFICATION_TIME = 0x0008  # 16bit value

    __VL6180X_SYSTEM_MODE_GPIO0 = 0x0010
    __VL6180X_SYSTEM_MODE_GPIO1 = 0x0011
    __VL6180X_SYSTEM_HISTORY_CTRL = 0x0012
    __VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO = 0x0014
    __VL6180X_SYSTEM_INTERRUPT_CLEAR = 0x0015
    __VL6180X_SYSTEM_FRESH_OUT_OF_RESET = 0x0016
    __VL6180X_SYSTEM_GROUPED_PARAMETER_HOLD = 0x0017

    __VL6180X_SYSRANGE_START = 0x0018
    __VL6180X_SYSRANGE_THRESH_HIGH = 0x0019
    __VL6180X_SYSRANGE_THRESH_LOW = 0x001A
    __VL6180X_SYSRANGE_INTERMEASUREMENT_PERIOD = 0x001B
    __VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME = 0x001C
    __VL6180X_SYSRANGE_CROSSTALK_COMPENSATION_RATE = 0x001E
    __VL6180X_SYSRANGE_CROSSTALK_VALID_HEIGHT = 0x0021
    __VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE = 0x0022
    __VL6180X_SYSRANGE_PART_TO_PART_RANGE_OFFSET = 0x0024
    __VL6180X_SYSRANGE_RANGE_IGNORE_VALID_HEIGHT = 0x0025
    __VL6180X_SYSRANGE_RANGE_IGNORE_THRESHOLD = 0x0026
    __VL6180X_SYSRANGE_MAX_AMBIENT_LEVEL_MULT = 0x002C
    __VL6180X_SYSRANGE_RANGE_CHECK_ENABLES = 0x002D
    __VL6180X_SYSRANGE_VHV_RECALIBRATE = 0x002E
    __VL6180X_SYSRANGE_VHV_REPEAT_RATE = 0x0031

    __VL6180X_SYSALS_START = 0x0038
    __VL6180X_SYSALS_THRESH_HIGH = 0x003A
    __VL6180X_SYSALS_THRESH_LOW = 0x003C
    __VL6180X_SYSALS_INTERMEASUREMENT_PERIOD = 0x003E
    __VL6180X_SYSALS_ANALOGUE_GAIN = 0x003F
    __VL6180X_SYSALS_INTEGRATION_PERIOD = 0x0040

    __VL6180X_RESULT_RANGE_STATUS = 0x004D
    __VL6180X_RESULT_ALS_STATUS = 0x004E
    __VL6180X_RESULT_INTERRUPT_STATUS_GPIO = 0x004F
    __VL6180X_RESULT_ALS_VAL = 0x0050
    __VL6180X_RESULT_HISTORY_BUFFER = 0x0052
    __VL6180X_RESULT_RANGE_VAL = 0x0062
    __VL6180X_RESULT_RANGE_RAW = 0x0064
    __VL6180X_RESULT_RANGE_RETURN_RATE = 0x0066
    __VL6180X_RESULT_RANGE_REFERENCE_RATE = 0x0068
    __VL6180X_RESULT_RANGE_RETURN_SIGNAL_COUNT = 0x006C
    __VL6180X_RESULT_RANGE_REFERENCE_SIGNAL_COUNT = 0x0070
    __VL6180X_RESULT_RANGE_RETURN_AMB_COUNT = 0x0074
    __VL6180X_RESULT_RANGE_REFERENCE_AMB_COUNT = 0x0078
    __VL6180X_RESULT_RANGE_RETURN_CONV_TIME = 0x007C
    __VL6180X_RESULT_RANGE_REFERENCE_CONV_TIME = 0x0080

    __VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD = 0x010A
    __VL6180X_FIRMWARE_BOOTUP = 0x0119
    __VL6180X_FIRMWARE_RESULT_SCALER = 0x0120
    __VL6180X_I2C_SLAVE_DEVICE_ADDRESS = 0x0212
    __VL6180X_INTERLEAVED_MODE_ENABLE = 0x02A3

    __ALS_GAIN_1 = 0x06
    __ALS_GAIN_1_25 = 0x05
    __ALS_GAIN_1_67 = 0x04
    __ALS_GAIN_2_5 = 0x03
    __ALS_GAIN_5 = 0x02
    __ALS_GAIN_10 = 0x01
    __ALS_GAIN_20 = 0x00
    __ALS_GAIN_40 = 0x07

    # Dictionaries with the valid ALS gain values
    # These simplify and clean the code (avoid abuse of if/elif/else clauses)
    ALS_GAIN_REG = {
        1: __ALS_GAIN_1,
        1.25: __ALS_GAIN_1_25,
        1.67: __ALS_GAIN_1_67,
        2.5: __ALS_GAIN_2_5,
        5: __ALS_GAIN_5,
        10: __ALS_GAIN_10,
        20: __ALS_GAIN_20,
        40: __ALS_GAIN_40
    }

    ALS_GAIN_ACTUAL = {  # Data sheet shows gain values as binary list
        1: 1.01,  # Nominal gain 1;    actual gain 1.01
        1.25: 1.28,  # Nominal gain 1.25; actual gain 1.28
        1.67: 1.72,  # Nominal gain 1.67; actual gain 1.72
        2.5: 2.60,  # Nominal gain 2.5;  actual gain 2.60
        5: 5.21,  # Nominal gain 5;    actual gain 5.21
        10: 10.32,  # Nominal gain 10;   actual gain 10.32
        20: 20.00,  # Nominal gain 20;   actual gain 20
        40: 40.00,  # Nominal gain 40;   actual gain 40
    }

    def __init__(self, i2cBus, address=0x29, debug=False):
        # Depending on if you have an old or a new Raspberry Pi, you
        # may need to change the I2C bus.  Older Pis use SMBus 0,
        # whereas new Pis use SMBus 1.  If you see an error like:
        # 'Error accessing 0x29: Check your I2C address '
        # change the SMBus number in the initializer below!

        # setup i2c bus and SFR address
        self.i2c = i2cBus
        self.address = address
        self.debug = debug

        # Module identification
        self.idModel = 0x00
        self.idModelRevMajor = 0x00
        self.idModelRevMinor = 0x00
        self.idModuleRevMajor = 0x00
        self.idModuleRevMinor = 0x00
        self.idDate = 0x00
        self.idTime = 0x00

        if self.get_register(self.__VL6180X_SYSTEM_FRESH_OUT_OF_RESET) == 1:
            print("ToF sensor is ready.")
            self.ready = True
        else:
            print("ToF sensor reset failure.")
            self.ready = False

        # Required by datasheet
        # http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
        self.set_register(0x0207, 0x01)
        self.set_register(0x0208, 0x01)
        self.set_register(0x0096, 0x00)
        self.set_register(0x0097, 0xfd)
        self.set_register(0x00e3, 0x00)
        self.set_register(0x00e4, 0x04)
        self.set_register(0x00e5, 0x02)
        self.set_register(0x00e6, 0x01)
        self.set_register(0x00e7, 0x03)
        self.set_register(0x00f5, 0x02)
        self.set_register(0x00d9, 0x05)
        self.set_register(0x00db, 0xce)
        self.set_register(0x00dc, 0x03)
        self.set_register(0x00dd, 0xf8)
        self.set_register(0x009f, 0x00)
        self.set_register(0x00a3, 0x3c)
        self.set_register(0x00b7, 0x00)
        self.set_register(0x00bb, 0x3c)
        self.set_register(0x00b2, 0x09)
        self.set_register(0x00ca, 0x09)
        self.set_register(0x0198, 0x01)
        self.set_register(0x01b0, 0x17)
        self.set_register(0x01ad, 0x00)
        self.set_register(0x00ff, 0x05)
        self.set_register(0x0100, 0x05)
        self.set_register(0x0199, 0x05)
        self.set_register(0x01a6, 0x1b)
        self.set_register(0x01ac, 0x3e)
        self.set_register(0x01a7, 0x1f)
        self.set_register(0x0030, 0x00)

        if self.debug:
            print("Register settings:")
            print("0x0207 - ", hex(self.get_register(0x0207)))
            print("0x0208 - ", hex(self.get_register(0x0208)))
            print("0x0096 - ", hex(self.get_register(0x0096)))
            print("0x0097 - ", hex(self.get_register(0x0097)))
            print("0x00e3 - ", hex(self.get_register(0x00e3)))
            print("0x00e4 - ", hex(self.get_register(0x00e4)))
            print("0x00e5 - ", hex(self.get_register(0x00e5)))
            print("0x00e6 - ", hex(self.get_register(0x00e6)))
            print("0x00e7 - ", hex(self.get_register(0x00e7)))
            print("0x00f5 - ", hex(self.get_register(0x00f5)))
            print("0x00d9 - ", hex(self.get_register(0x00d9)))
            print("0x00db - ", hex(self.get_register(0x00db)))
            print("0x00dc - ", hex(self.get_register(0x00dc)))
            print("0x00dd - ", hex(self.get_register(0x00dd)))
            print("0x009f - ", hex(self.get_register(0x009f)))
            print("0x00a3 - ", hex(self.get_register(0x00a3)))
            print("0x00b7 - ", hex(self.get_register(0x00b7)))
            print("0x00bb - ", hex(self.get_register(0x00bb)))
            print("0x00b2 - ", hex(self.get_register(0x00b2)))
            print("0x00ca - ", hex(self.get_register(0x00ca)))
            print("0x0198 - ", hex(self.get_register(0x0198)))
            print("0x01b0 - ", hex(self.get_register(0x01b0)))
            print("0x01ad - ", hex(self.get_register(0x01ad)))
            print("0x00ff - ", hex(self.get_register(0x00ff)))
            print("0x0100 - ", hex(self.get_register(0x0100)))
            print("0x0199 - ", hex(self.get_register(0x0199)))
            print("0x01a6 - ", hex(self.get_register(0x01a6)))
            print("0x01ac - ", hex(self.get_register(0x01ac)))
            print("0x01a7 - ", hex(self.get_register(0x01a7)))
            print("0x0030 - ", hex(self.get_register(0x0030)))

    def default_settings(self):
        # Recommended settings from datasheet
        # http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
        # Set GPIO1 high when sample complete
        self.set_register(self.__VL6180X_SYSTEM_MODE_GPIO1, 0x10)
        # Set Avg sample period
        self.set_register(self.__VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD, 0x30)
        # Set the ALS gain
        self.set_register(self.__VL6180X_SYSALS_ANALOGUE_GAIN, 0x46)
        # Set auto calibration period (Max = 255)/(OFF = 0)
        self.set_register(self.__VL6180X_SYSRANGE_VHV_REPEAT_RATE, 0xFF)
        # Set ALS integration time to 100ms
        self.set_register(self.__VL6180X_SYSALS_INTEGRATION_PERIOD, 0x63)
        # perform a single temperature calibration
        self.set_register(self.__VL6180X_SYSRANGE_VHV_RECALIBRATE, 0x01)

        # Optional settings from datasheet
        # http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
        # Set default ranging inter-measurement period to 100ms
        self.set_register(self.__VL6180X_SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09)
        # Set default ALS inter-measurement period to 100ms
        self.set_register(self.__VL6180X_SYSALS_INTERMEASUREMENT_PERIOD, 0x31)
        # Configures interrupt on 'New Sample Ready threshold event' 
        self.set_register(self.__VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO, 0x24)

        # Additional settings defaults from community
        self.set_register(self.__VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME, 0x32)
        self.set_register(
            self.__VL6180X_SYSRANGE_RANGE_CHECK_ENABLES, 0x10 | 0x01)
        self.set_register_16bit(
            self.__VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, 0x7B)
        self.set_register_16bit(self.__VL6180X_SYSALS_INTEGRATION_PERIOD, 0x64)
        self.set_register(self.__VL6180X_SYSALS_ANALOGUE_GAIN, 0x40)
        self.set_register(self.__VL6180X_FIRMWARE_RESULT_SCALER, 0x01)

        if self.debug:
            print("Default settings:")
            print("SYSTEM_MODE_GPIO1 - ",
                  hex(self.get_register(self.__VL6180X_SYSTEM_MODE_GPIO1)))
            print("READOUT_AVERAGING_SAMPLE_PERIOD - ",
                  hex(self.get_register(
                      self.__VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD)))
            print("SYSALS_ANALOGUE_GAIN - ",
                  hex(self.get_register(self.__VL6180X_SYSALS_ANALOGUE_GAIN)))
            print("SYSRANGE_VHV_REPEAT_RATE - ",
                  hex(self.get_register(self.__VL6180X_SYSRANGE_VHV_REPEAT_RATE)))
            print("SYSALS_INTEGRATION_PERIOD - ",
                  hex(self.get_register(self.__VL6180X_SYSALS_INTEGRATION_PERIOD)))
            print("SYSRANGE_VHV_RECALIBRATE - ",
                  hex(self.get_register(self.__VL6180X_SYSRANGE_VHV_RECALIBRATE)))
            print("SYSRANGE_INTERMEASUREMENT_PERIOD - ",
                  hex(self.get_register(
                      self.__VL6180X_SYSRANGE_INTERMEASUREMENT_PERIOD)))
            print("SYSALS_INTERMEASUREMENT_PERIOD - ",
                  hex(self.get_register(
                      self.__VL6180X_SYSALS_INTERMEASUREMENT_PERIOD)))
            print("SYSTEM_INTERRUPT_CONFIG_GPIO - ",
                  hex(self.get_register(
                      self.__VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO)))
            print("SYSRANGE_MAX_CONVERGENCE_TIME - ",
                  hex(self.get_register(
                      self.__VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME)))
            print("SYSRANGE_RANGE_CHECK_ENABLES - ",
                  hex(self.get_register(self.__VL6180X_SYSRANGE_RANGE_CHECK_ENABLES)))
            print("SYSRANGE_EARLY_CONVERGENCE_ESTIMATE - ",
                  hex(self.get_register_16bit(
                      self.__VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE)))
            print("SYSALS_INTEGRATION_PERIOD - ",
                  hex(self.get_register_16bit(
                      self.__VL6180X_SYSALS_INTEGRATION_PERIOD)))
            print("SYSALS_ANALOGUE_GAIN - ",
                  hex(self.get_register(self.__VL6180X_SYSALS_ANALOGUE_GAIN)))
            print("FIRMWARE_RESULT_SCALER - ",
                  hex(self.get_register(self.__VL6180X_FIRMWARE_RESULT_SCALER)))

    def get_identification(self):

        self.idModel = self.get_register(
            self.__VL6180X_IDENTIFICATION_MODEL_ID)
        self.idModelRevMajor = self.get_register(
            self.__VL6180X_IDENTIFICATION_MODEL_REV_MAJOR)
        self.idModelRevMinor = self.get_register(
            self.__VL6180X_IDENTIFICATION_MODEL_REV_MINOR)
        self.idModuleRevMajor = self.get_register(
            self.__VL6180X_IDENTIFICATION_MODULE_REV_MAJOR)
        self.idModuleRevMinor = self.get_register(
            self.__VL6180X_IDENTIFICATION_MODULE_REV_MINOR)

        self.idDate = self.get_register_16bit(
            self.__VL6180X_IDENTIFICATION_DATE)
        self.idTime = self.get_register_16bit(
            self.__VL6180X_IDENTIFICATION_TIME)

    def change_address(self, old_address, new_address):
        # NOTICE:  IT APPEARS THAT CHANGING THE ADDRESS IS NOT STORED IN NON-
        # VOLATILE MEMORY POWER CYCLING THE DEVICE REVERTS ADDRESS BACK TO 0X29

        if old_address == new_address:
            return old_address
        if new_address > 127:
            return old_address

        self.set_register(self.__VL6180X_I2C_SLAVE_DEVICE_ADDRESS, new_address)
        self.address = new_address
        return self.get_register(self.__VL6180X_I2C_SLAVE_DEVICE_ADDRESS)

    # Print statement updated to Python 3.X
    def get_distance(self):
        # Start Single shot mode
        self.set_register(self.__VL6180X_SYSRANGE_START, 0x01)
        time.sleep(0.010)
        if self.debug:
            print("Range status: ",
                  hex(self.get_register(self.__VL6180X_RESULT_RANGE_STATUS) & 0xF1))
        distance = self.get_register(self.__VL6180X_RESULT_RANGE_VAL)
        self.set_register(self.__VL6180X_SYSTEM_INTERRUPT_CLEAR, 0x07)
        return distance

    def get_ambient_light(self, als_gain):
        # First load in Gain we are using, do it every time in case someone
        # changes it on us.
        # Note: Upper nibble should be set to 0x4 i.e. for ALS gain
        # of 1.0 write 0x46

        # Set the ALS gain, defaults to 20.
        # If gain is in the dictionary (defined in init()) it returns the value
        # of the constant otherwise it returns the value for gain 20.
        # This saves a lot of if/elif/else code!
        # Print statement updated to Python 3.X
        if als_gain not in self.ALS_GAIN_ACTUAL:
            print("Invalid gain setting: ", float(als_gain), ".  Setting to 20.")

        als_gain_actual = self.ALS_GAIN_ACTUAL.setdefault(als_gain, 20)
        self.set_register(
            self.__VL6180X_SYSALS_ANALOGUE_GAIN,
            (0x40 | self.ALS_GAIN_REG.setdefault(als_gain, self.__ALS_GAIN_20)))

        # Start ALS Measurement
        self.set_register(self.__VL6180X_SYSALS_START, 0x01)

        time.sleep(0.100)  # give it time...

        # Retrieve the Raw ALS value from the sensor
        # Print statement updated to Python 3.X
        if self.debug:
            print("ALS status: ",
                  hex(self.get_register(self.__VL6180X_RESULT_ALS_STATUS)) & 0xF1)

        als_raw = self.get_register_16bit(self.__VL6180X_RESULT_ALS_VAL)
        self.set_register(self.__VL6180X_SYSTEM_INTERRUPT_CLEAR, 0x07)

        # Get Integration Period for calculation, we do this every time in case
        # someone changes it on us.
        als_integration_period_raw = self.get_register_16bit(
            self.__VL6180X_SYSALS_INTEGRATION_PERIOD)

        als_integration_period = 100.0 / als_integration_period_raw

        # Calculate actual LUX from application note
        als_calculated = \
            0.32 * (als_raw / als_gain_actual) * als_integration_period

        return als_calculated

    def get_register(self, register_address):
        a1 = (register_address >> 8) & 0xFF
        a0 = register_address & 0xFF
        self.i2c.write_i2c_block_data(self.address, a1, [a0])
        data = self.i2c.read_byte(self.address)
        return data

    def get_register_16bit(self, register_address):
        a1 = (register_address >> 8) & 0xFF
        a0 = register_address & 0xFF
        self.i2c.write_i2c_block_data(self.address, a1, [a0])
        data0 = self.i2c.read_byte(self.address)
        data1 = self.i2c.read_byte(self.address)
        return (data0 << 8) | (data1 & 0xFF)

    def set_register(self, register_address, data):
        a1 = (register_address >> 8) & 0xFF
        a0 = register_address & 0xFF
        self.i2c.write_i2c_block_data(self.address, a1, [a0, (data & 0xFF)])

    def set_register_16bit(self, register_address, data):
        a1 = (register_address >> 8) & 0xFF
        a0 = register_address & 0xFF
        d1 = (data >> 8) & 0xFF
        d0 = data & 0xFF
        self.i2c.write_i2c_block_data(self.address, a1, [a0, d1, d0])

三、 打开终端更改权限

sudo chmod -R 777 /dev/i2c-1

四、 使用上位机配置TOF模块

        1. ttl转串口模块连接TOF050F，连接方式如图：（确认已安装ch340驱动）

（图1）

         2. 打开上位机，将参数配置中的“禁止IIC”数值设为1；待刷新后退出。

（图2）

五、 连线，并运行test.py

        1. 参考图1和图3（下图），

树莓派4B                3.3v -> VIN                TOF050F

GND -> GND

SCL -> SCL

SDA -> SDA

（图3）

        2. 运行代码，即看到一串距离数据不停地打印：

python test.py

NowLoadY
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
STM32 + VL53L0激光测距 TOF 软件I2C协议代码
04-26
VL53L0x 是ST公司生成的 TOF激光测距传感器，得益于非常小巧的尺寸，很容易放入手机、无人机中，提供更加精准、稳定的测距方式。 STM32 + VL53L0激光测距 I2C协议代码 软件IIC通讯，只用到了四根线，VCC、GND、SCL、SDA。 VL53L0X的设备地址是0x52（初始状态的，这个地址是可以修改的） 单片机源程序如下: #include #include "intrins.h" #define uchar unsigned char #define uint unsigned int #define VL53L0X_REG_IDENTIFICATION_MODEL_ID 0xc0 #define VL53L0X_REG_IDENTIFICATION_REVISION_ID 0xc2 #define VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD 0x50 #define VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD 0x70 #
ToF 激光测距传感器模块 TOF050F 200F 400F 串口IICMODBUS模式
07-20
激光TOF(飞行时间)测距传感器技术手册，开放文档，传感器模块类型包括：TOF050F、TOF200F、TOF400F。 文档包括规格参数，以及IIC模式的规格书。 上位机程序中文 基于rasberry树莓派、esp8266、stm32f103c8t6、UNO的demo TOFxxx激光测距多连例程stm32f103模拟MODBUS通讯搭配485模块实现
用树莓派获取传感器数据通过Onenet云平台（物模型）传输至微信小程序（上）
最新发布
Rrrrr040803的博客
03-17 2820
为了传输传感器数据，在网上找了很多方法，但都因为各种各样的问题最终没能成功实现。最终找到这个既简单，又方便实现的方法。步骤有点多，希望大家可以跟着教程，一步步耐心的做下去，愿大家都能成功实现数据传输。代码放在最后啦，下面开始我的教程。
STM32 HAL库硬I2C的TOF050C模块
星羽空间
03-02 2095
STM32 基于硬I2C开发TOF050C模块
ToF（飞行时间）原理详解.zip
07-23
可以使用不同类型的传感器和测量技术来记录被测对象或场景的3D信息。 非接触式测量技术可以估算目标距离，利用微波，超声波或光波[1,2]。 然而，只有后一种技术才能实现良好的角分辨率性能，在紧凑的测量设置中，如3D成像系统所需[3]。 在通常的实践中，获取物体几何的两种方法是：（i）被动，通过使用多视图图像数据或（ii）主动，利用光学距离测量技术
激光测距模块TOF50
07-21
STM32F103 野火板子写的代码，通过串口向模块写指令，再接受模块发出的距离数据
TOF050F激光测距模块.zip
05-11
基于arduino的激光测距模块
树莓派处理温湿度监控，红外蔽障传感器，超声波测距传感器，激光传感器，有害气体检测，人体感应器，倾斜开关，雨滴传感器，土壤监测
wailaizhu的博客
02-23 3627
1.性能指标和特性： 工作电压范围：3.5V-5.5V 工作电流：平均0.5mA 湿度测量范围：20－90％RH 温度测量范围：0－50℃ 湿度分辨率：1％RH8位 温度分辨率：1℃8位 采样周期：1S 2.DHT11数据结构 DHT11数字湿温度传感器采用单总线数据格式。即，单个数据引脚端口完成输 入输出双向传输。其数据包由5Byte（40B...
树莓派基础实验19：光敏传感器实验
chinacqzgp的博客
08-04 7308
一、介绍    该传感器实际上是一个光敏电阻，它随着光强的变化而改变其电阻，它可以用来制作光控开关。 二、组件 ★Raspberry Pi主板*1 ★树莓派电源*1 ★40P软排线*1 ★PCF8591模数转换器模块*1 ★光敏传感器模块*1 ★面包板*1 ★跳线若干 三、实验原理   随着光强度的增加，光敏电阻的电阻将降低，因此输出电压降低。由光敏电阻收集的模拟信号通过PCF8591转换为数字信号。然后将这些数字信号传输到树莓派并打印在屏幕上。   光敏电阻传感器有两个LED指示灯。PWR-LED是
树莓派光照传感器java_树莓派上使用光照强度检测（BH1750）传感器
weixin_28928039的博客
02-25 1494
BH1750FVI 是一款 IIC 接口的数字型光强度传感器集成电路。下面介绍一下其在树莓派下的用法。一、前期准备1、环境要求GY30模块(BH1750FVI传感器)树莓派 Raspbian 系统python-smbusIIC 开启启动 IIC 驱动的方法：运行 sudo raspi-config 进入 Interfacing Options 高级设置，将 SPI 与 I2C 设置为 Enable...
ToF 测距模块相关资料
09-18
TOF050F TOF200F TOF400F规格书资料以及调试上位机、demo文件等，包含串口、iic格式
TOF原理 - Melexis TOF产品应用开发说明书
12-09
阐述TOF相机软硬件构成，对理解TOF深度相机硬件原理及深度解析算法有帮助。 文档主要包括概述，软件算法原理，硬件原理，TOF sensor pixel，TOF性能及光学参数等介绍
java 数据库连接 sql access oracle mysql
12-29
java 数据库连接 sql access oracle mysql java 数据库连接 sql access oracle mysql java 数据库连接 sql access oracle mysql
android aidl简单实例
10-18
anroid3.0 sdk 平台运行正常。 aidl 简单实现代码。
tof introduction.pdf
07-05
tof相机相关的知识，我也是刚刚进行tof相关东西的学习，与大家分享，tof——introduction
基于ToF的微型近距离测距雷达解决方案.doc
07-23
微型近距离测距雷达是一款用于短距离探测的激光雷达。激光测距技术是现代探测最重要的一门技术，对军事和人们的生活领域影响较大。继世界上第一台激光测距机发明以后，经过试验，这种测距机性能可靠、稳定，可以后被运用到实际生活中，各种激光测距机为人类带来福利的同时，充分利用激光的优点，完成光学测距机不能完成的任务。 微型近距离测距雷达基于ToF（飞行时间）原理，采用850nm激光光源，配合独特的光学、电学设计，实现稳定、精准、高灵敏和高速的距离测量的功能。主要应用于智能交通、自动化控制、智能道闸、周界探测等短距离警戒等场所。   技术优势 高度集成 产品配以独特的光学、结构和电子设计，外观更迷你，使得产品具有低成本、小体积和低功耗三大优点。   精度高 产品采用850nm激光光源，激光本身具有非常精确的测距能力，输出帧率可达100Hz，其测距精度可达厘米级的可信数据。   抗杂散光及强光干扰 采用先进的窄带滤光片，配合独创光学系统设计，可有效隔离室外其他杂散光及强光干扰，使产品更稳定工作。   ToF技术 采用ToF飞行时间算法，通过相位差间接测量激光脉冲的来回飞行时间，由于光速一定，从而可测算出距离值。基于相位的ToF测距抗环境干扰能力非常强，误差也相对更小。   探测距离可设定 报警探测范围可通过RS485通讯设置，物体智能识别。   IP67防护等级 外壳采用IP67防水防尘设计，极大拓宽其使用领域及场景。   测距精度高 品基于ToF（飞行时间）原理，配合独创光学系统设计和融合算法，激光测距系统的精度不受被测距离的影响，精度可达厘米级别，测量数据可靠。   抗电磁和地波干扰能力 激光测距的分辨率取决于窄的光束和短的脉冲宽度，而且电磁和地波无法干扰其分辨率。仰角较低时，激光测距雷达的工作可以不受地面信号的干扰，从而测量结果不被影响，这样激光测距雷达可以正常反馈监测信息。微波雷达相比之下受到干扰就会比较严重，使监测数据不准确。有了激光测距雷达就不会再纠结地面信号的干扰。   一、应用领域 微型近距离测距雷达是一种工作在从红外到紫外光谱段的测距雷达系统，其作用是能精确测量目标位置（距离和角度）、运动状态（速度、振动和姿态）和形状，探测、识别、分辨和跟踪目标。主要可应用到以下领域。   智能交通应用 汽车防撞探测器 现有汽车碰撞预防系统将激光测距传感器用于识别汽车在前或者在后形势的目标汽车之间的距离，当汽车间距小于预定安全距离时，汽车防碰撞系统对汽车进行紧急刹车，或者对司机发出报警，或者综合目标汽车速度、车距、汽车制动距离、响应时间等对汽车行驶进行即时的判断和响应，可以大量的减少行车事故。
Arduino TOF10120_i2c_0401_tof_I2Carduino_TOF测距_
10-01
ST 的TOF激光测距程序，基于I2C总线
使用 ToF 传感器进行距离测量和手势识别的基本原理
01-19
这种接近感应需求催生了众多竞争性解决方案，包括光学飞行时间 (ToF) 传感器。虽然这些传感器非常，但其成本一直非常昂贵，并且实施复杂；不过近的解决方案已经显著简化了此类技术的使用。  使用接近感应的产品...
TFmini（TOF）在stm32上的应用
Xiaomo
01-06 3237
使用TFmini是采用串口通信，与STM32F103ZET6通信，同时在LCD上显示。 通信协议使用出厂预设 TFmini数据输出使用标准数据输出格式 设置TFmini串口发送速率为20Hz（注意可使用串口工具修改TFmini参数，具体请参见对应操作手册） 在LCD上显示距离、强度、接收到的9bit数据以及接收速率。 注意：在本程序中使用标准库以及正点原子的LCD驱动程序 ma...
arduino调用tof050f
04-30
TOF050F是一款时间飞行(Time-of-Flight)传感器，可以用于测量距离、速度、方向等。要在Arduino上使用TOF050F，需要连接器件并编写相应的代码。 以下是连接步骤： 1. 连接电源和地线：将TOF050F的VCC引脚连接到Arduino的5V引脚，GND引脚连接到Arduino的GND引脚。 2. 连接I2C总线：将TOF050F的SCL引脚连接到Arduino的SCL引脚，SDA引脚连接到Arduino的SDA引脚。 连接完成后，您需要编写相应的代码。以下是示例代码： ``` #include <Wire.h> #define TOF050F_ADDRESS 0x29 //TOF050F的I2C地址 void setup() { Wire.begin(); //初始化I2C总线 Serial.begin(9600); //初始化串口 } void loop() { Wire.beginTransmission(TOF050F_ADDRESS); //开始传输数据 Wire.write(0x00); //设置TOF050F的寄存器地址 Wire.endTransmission(false); //结束传输数据，false表示不释放总线 Wire.requestFrom(TOF050F_ADDRESS, 2); //请求2个字节的数据 byte msb = Wire.read(); //读取高位数据 byte lsb = Wire.read(); //读取低位数据 int distance = (msb << 8) | lsb; //计算距离（单位：毫米） Serial.print("Distance: "); Serial.print(distance); Serial.println(" mm"); delay(1000); //等待1秒钟 } ``` 上述代码首先初始化I2C总线和串口，然后在循环中读取TOF050F传感器的距离数据，并通过串口输出。在读取数据时，需要向TOF050F传感器发送寄存器地址，并从中读取2个字节的数据，然后将它们合并计算得到距离值。最后等待1秒钟后再进行下一轮循环。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NowLoadY

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值