精华内容
下载资源
问答
  • 判断红外对管传感器资料 如何判断红外对管 以及 如何焊接电路
  • 2.当红外接收管的分压电阻恒定时,测量光照强度变化时,红外接收管管压降的变化范围,分析管压降的变化范围与分压电阻阻值的关系。 3.根据传感器有效距离的不同,设计几组不同的电阻阻值组合。 2.实验设备 1.光电...

    本文格式有缺陷,较为完美的格式见压缩文件中的word文档

    1.实验目的

    1.测量3mm红外发射管与5mm红外发射管的正向压降。

    2.当红外接收管的分压电阻恒定时,测量光照强度变化时,红外接收管管压降的变化范围,分析管压降的变化范围与分压电阻阻值的关系。

    3.根据传感器有效距离的不同,设计几组不同的电阻阻值组合。

    2.实验设备

    1.光电传感器实验PCB验证板V0.1

    2.KOMAX DT-9205A增强版万用表

    3.MESTEK DP155直流电源

    3.实验原理

    3.1红外发射管原理

     

     
     


    红外发射管是一个发射红外光的发光二极管,本质上与普通发光二极管没有区别,只是红外发射管发射红外光,普通发光二极管发射可见光而已。

     

    图3.1.1  数据手册片段1

    和普通二极管一样,红外发射管最重要的参数是正向压降与最大整流电流,其中最大整流电流在5mm红外发射管数据手册[1]中的名称为“连续正向电流”,值为100mA。25摄氏度时的功耗为150mW,假设这个功耗是指最大整流电流时的功耗,那么压降应该约为1.5V。

     

     
     


    根据数据手册[1]光电特性参数中的数据,5mm红外发射管的正向压降在1.2到1.8之间,约为1.5V。

     

    图3.1.2  数据手册片段2

    按照二极管的等效模型,将二极管等效为一个大小等于二极管正向压降的电压源,因二极管内阻很小何以忽略不计,将二极管两端电压减去二极管正向压降再除以二极管串联的限流电阻就可以得到流过二极管的电流,直流情况下就是二极管的整流电流。

     

     
     


    另外,作为与红外接收管配套的设备,其正向电流与光照强度的关系也是比较重要的,根据数据手册[1]中的数据,其关系如下图所示,是正比关系。

     

    图3.1.3  数据手册片段3

    3.2红外接收管原理

     

     
     


    红外接收管伏安特性曲线如下图所示,是一个伏安特性曲线会根据光照强度上下平移的二极管,一般工作于第三象限。

     

    图3.2.1  红外接收管伏安特性曲线

     

     
     


    红外接收管又名光电二极管,当它工作于第三象限的时候相当于一个光控的电流源——给红外接收管施加反压,则流过红外接收管的电流只与光照强度成正比,根据数据手册中的图表[2],其关系如下图所示,其横坐标是衡量光强度的一种单位——兆瓦/平方米,针对的是一个平面中的功率。

     

    图3.2.2  数据手册片段

     

     
     


    红外接收管限流电阻的选择方面。红外接收管的限流电阻实际上是一个分压电阻,目的是将不同光照强度下红外接收管的电流变化转变成电压变化。假设红外发射管满功率输出,红外接收管获得最大光照强度,电流达到最大值,则位于红外接收管上方的分压电阻达到最大压降。之后,随着红外发射管光照强度的降低,分压电阻下方的电位会逐渐升高,最终接近于电源电压。因此,如果想要使分压电阻下方的电压有较大的可调范围,例如希望光照强度从最大变为最小时,分压电阻下端电位从0变到电源电压,那么分压电阻的阻止应该要很大,数量级一般在几十到几百千欧,可以根据上图最大电流值进行计算,结果再适当增大一点。

     

    图3.2.3  电路图

    3.3光电传感器原理

    光电传感器分为两种,一种是红外发射管与红外接收管面对面,当有物体从两管的缝隙中穿过时可以被精准捕捉到。另一种是红外发射管与红外接收管并排而立,当物体挡住红外对管,红外发射管的光线被反射回来后被捕捉到。

    光电传感器的原理图如下图所示:

    一般希望红外发射管工作在接近最大工作电流的状态,即正向电流接近最大整流电流,限流电阻阻值应该根据红外发射管的管压降和最大整流电流计算得到。红外接收管在最大光照条件下其端电压应该为0,即分压电阻应该足够大,通过


    调节电位器RV3来进行灵敏度的调节。

    图3.3.1  光电传感器总电路图

    对于并排式的光电传感器,当物体接近,即光线被反射回来的时候,红外接收管的管压降会根据反射光的强度不同而不同,物体近则管压降小,物体远则管压降大,也就是上图K点处的电位。因此通过电压比较器反向输入端的电位器可以指定希望的电位,当物体够近,K点的电位就够小,反向输入端的电位大因而输出低电平。

    虽说理想情况下,即红外发射管发射的光被红外接收管完全接受时,在限流电阻与分压电阻选择合适的情况下K点电位接近于0,但是考虑到驱动能力的问题,以及反射式的光电传感器往往达不到理想条件,因此还是加一个电压比较器比较稳妥,可以获得标准的数字信号,而且可以让光电传感器具有调节灵敏度的功能,否则,调节灵敏度只可以通过调节限流电阻R1来进行。

     

    文件:https://download.csdn.net/download/weixin_43718316/15482623

    展开全文
  • 光电反射传感器 红外对管模块

    万次阅读 多人点赞 2018-12-07 16:49:28
    传感器的探测距离可以通过电位器调节、具有干扰小、便于装配、使用方便等特点, 可以广泛应用于机器人避障、避障小车、流水线计数及黑白线循迹等众多场合。 部件 两个灯管:白色灯管为发射管,发射红外光;黑色...

     

    模块描述

    可通过电位器旋钮调节检测距离,有效距离范围 2~30mm,检测角度35度,工作电压为 3.3V-5V。

    该传感器的探测距离可以通过电位器调节、具有干扰小、便于装配、使用方便等特点,

    可以广泛应用于机器人避障、避障小车、流水线计数及黑白线循迹等众多场合。

    部件

    两个灯管:白色灯管为发射管,发射红外光;黑色灯管为接收管,接受反射回来的红外光

    两个指示灯:电源指示灯、输出指示灯

    模块接口说明

    • VCC 外接 3.3V-5V 电压(建议3.3V
    • GND 外接 GND
    • OUT 接开发板或单片机的GPIO口(输出0 或 1)

    使用时

    • 发射管(白色灯管)发射出一定频率的红外线,当检测方向遇到障碍物(反射面)时,红外线反射回来被接收管(黑色灯管)接受,经过比较器电路处理后,输出指示灯会亮起,同时输出数字信号(低电平信号)。

    两个指示灯,三种状态

    通电时,电源指示灯常亮,

    • 距离较远、未感应到障碍物时,输出指示灯灭,OUT引脚输出高电平
    • 距离近,感应到障碍物时,输出指示灯亮,OUT端口输出低电平
    • 距离近,遇到黑色障碍物时,黑色灯管接收不到,输出指示灯灭,OUT引脚输出高电平

    检测距离调节

    检测距离2~30mm,可以通过电位器进行调节,顺时针调节电位器,检测距离增加;逆时针调节电位器,检测距离减少。

    STM32驱动代码参考

    #include "infrared.h"
    
    void INFRARED_Init(void)
    {
    	RCC->APB2ENR|=1<<3;           // 使能GPIOB时钟
    
    	GPIOB->CRH &= 0XFFF00FFF;     //PB11、PB12 浮空输入
    	GPIOB->CRH |= 0X00004400;
    }

    寻迹/循迹

    循迹是指自制的小车能够沿黑线(黑色电胶布)构成的直线或曲线行驶(行驶在指定区域内)。

    安装好红外对管的小车正常放在地板上(无黑线)时,输出指示灯应

    • 一只红外对管

    将红外对管安装在小车右前方(左前方),使小车可以沿着右(左)侧黑线行驶。

    思路:让小车一直右转,碰到黑线时左转。

    //沿右侧黑线循迹伪代码
    while(1)
    {
        if(输出指示灯灭)  //碰到黑线
            小车左转;
        小车右转;
    }
    //沿左侧黑线循迹同理
    • 两只红外对管
      • 一条黑线

    两个红外对管均放置在小车前方,两个黑管的间距理论上应略大于黑线宽度的根号2倍(直角)。(跨于黑线两侧)

    while(1)
    {
        if(左对管输出指示灯灭 && 右对管输出指示灯亮)    //左对管碰到黑线
            小车左转;
        if(左对管输出指示灯亮 && 右对管输出指示灯灭)
            小车右转;
    }

     

    展开全文
  • 一线制数字温度传感器 ·铂金属温度传感器 ·红外对管 ·黑白线检测传感器 ·光电避障传感器 ·金属探测传感器 ·霍尔传感器+磁钢 ·超声波探头 ·附录1:传感器接线图
  • 头文件: /* * filename: rohm_scm_proximity.h */ #ifndef __ROHM_SCM_PROXIMTIY__ #define __ROHM_SCM_PROXIMTIY__ #define ROHM_PROXIMITY "rohm_proximity...#define PROXIMITY_DEVICE "rohm_proximity

     

    头文件:

    /*
    * filename: rohm_scm_proximity.h
    */
    #ifndef __ROHM_SCM_PROXIMTIY__
    #define __ROHM_SCM_PROXIMTIY__
    
    
    #define ROHM_PROXIMITY "rohm_proximity"
    #define PROXIMITY_DEVICE "rohm_proximity"
    
    #include <linux/types.h>
    #include <linux/ioctl.h>
    
    #define ROHM_PROXIMITY_IOCTL_MAGIC 				'r'
    #define ROHM_PROXIMITY_IOCTL_GET_ENABLED  		_IOR(ROHM_PROXIMITY_IOCTL_MAGIC, 1, int *)
    #define ROHM_PROXIMITY_IOCTL_ENABLE   			_IOW(ROHM_PROXIMITY_IOCTL_MAGIC, 2, int *)
    
    #endif
    
    


     

    /*
     * File:         rohm_scm_proximity.c
     * Based on:
     * Author:       Yunlong Wang <Yunlong.Wang@spreadtrum.com>
     *
     * Created:   2011-04-08
     * Description:  Rohm Proximity Sensor Driver
     *
     * 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.
     *
     */

    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/gpio.h>
    #include <linux/input.h>
    #include <linux/platform_device.h>
    #include <linux/fs.h>
    #include <linux/uaccess.h>
    #include <linux/miscdevice.h>
    #include <linux/delay.h>
    #include <linux/wakelock.h>
    #include <mach/mfp.h>
    #include <mach/adc_drvapi.h>

    #include "rohm_scm_proximity.h"

    #define PS_DEBUG 1
    #define RHOM_PROXIMITY_DATA_POLL_TIMER      100
    #define RHOM_PROXIMITY_THRESHOLD            500
    #define RHOM_PROXIMITY_ADC_CHANNEL          1

    //static int debug_level=0;
    static int debug_level=1;

    #if PS_DEBUG
    #define PS_DBG(format, ...) \
        if(debug_level == 1) \
            printk(KERN_INFO "PROXIMITY: " format , ## __VA_ARGS__)
    #else
    #define PS_DBG(format, ...)
    #endif

    extern int sprd_3rdparty_gpio_proximity_trans;
    extern int sprd_3rdparty_gpio_proximity_recv;


    struct rohm_proximity_platform_data {
            int gpio_trans; /*control transmit light*/
            int gpio_recv;  /*control recevie light*/
    };

    static struct rohm_proximity_platform_data proximity_platform_data;
    static struct wake_lock prox_delayed_work_wake_lock;


    static struct rohm_proximity_data {
        struct input_dev *input_dev;
        struct rohm_proximity_platform_data *pdata;
        struct delayed_work work;
        struct workqueue_struct *work_queue;
        int enabled;
    } proximity_data;

    static int misc_opened;
    static int proximity_start=0;


    static struct platform_device rohm_proximity_device = {
            .name           = ROHM_PROXIMITY,
            .id             = -1,
            .dev    = {
            .platform_data  = &proximity_platform_data,
        },
    };

     

    static int rohm_proximity_enable(struct rohm_proximity_data *data);
    static int rohm_proximity_disable(struct rohm_proximity_data *data);

    static ssize_t rohm_proximity_show_control(struct device* cd, struct device_attribute *attr, char* buf)
    {
        ssize_t ret = 0;

        if(proximity_start==1)
            sprintf(buf, "Proximity Start\n");
        else
            sprintf(buf, "Proximity Stop\n");
       
        ret = strlen(buf) + 1;
        return ret;
    }

    static ssize_t rohm_proximity_store_control(struct device* cd, struct device_attribute *attr, const char* buf, size_t len)
    {
        unsigned long on_off = simple_strtoul(buf, NULL, 10);
        proximity_start = on_off;
       
        if(on_off==1)
        {
            printk("Proximity Start\n");
            rohm_proximity_enable(&proximity_data);
        }
        else
        {
            printk("Proximity Stop\n");
            rohm_proximity_disable(&proximity_data);
        }
       
        return len;
    }

    static ssize_t rohm_proximity_show_debug(struct device* cd,struct device_attribute *attr, char* buf)
    {
        ssize_t ret = 0;
       
        sprintf(buf, "ROHM Debug %d\n",debug_level);
       
        ret = strlen(buf) + 1;

        return ret;
    }

    static ssize_t rohm_proximity_store_debug(struct device* cd, struct device_attribute *attr,
                   const char* buf, size_t len)
    {
        unsigned long on_off = simple_strtoul(buf, NULL, 10);
        debug_level = on_off;

        printk("%s: debug_level=%d\n",__func__, debug_level);
       
        return len;
    }


    static DEVICE_ATTR(control, S_IRUGO | S_IWUSR, rohm_proximity_show_control, rohm_proximity_store_control);
    static DEVICE_ATTR(debug, S_IRUGO | S_IWUSR, rohm_proximity_show_debug, rohm_proximity_store_debug);


    static int rohm_proximity_create_sysfs(struct platform_device *client)
    {
        struct device *dev = &(client->dev);
        int err = 0;

        PS_DBG("%s\n", __func__);
       
        if ((err = device_create_file(dev, &dev_attr_control)))
            goto err_out;

        if ((err = device_create_file(dev, &dev_attr_debug)))
            goto err_out;

        return 0;
       
    err_out:
        return err;
    }

     

    static int rohm_proximity_get_adc(void)
    {
        int val;
       
        val = ADC_GetValue(RHOM_PROXIMITY_ADC_CHANNEL, ADC_SCALE_3V);  
        return val;
    }

    static int rohm_proximity_report(struct rohm_proximity_data *data)
    {
        int data1, data2;
        int val;
       
        //get environment adc
        gpio_set_value(data->pdata->gpio_recv, 1);
        msleep(30); //for stable
        data1 = rohm_proximity_get_adc();

        //get infrared adc
        gpio_set_value(data->pdata->gpio_trans, 1);
        msleep(30);
        data2 = rohm_proximity_get_adc();

        val = (data2-data1)>RHOM_PROXIMITY_THRESHOLD? 0:1;

        PS_DBG("data1=%d; data2=%d; proximity=%d\n", data1, data2, val);
     
        /* 0 is close, 1 is far */
        input_report_abs(data->input_dev, ABS_DISTANCE, val);
        input_sync(data->input_dev);

        gpio_set_value(data->pdata->gpio_recv, 0);
        gpio_set_value(data->pdata->gpio_trans, 0);
       
        return val;
    }

    static void rohm_proximity_start_work(int ms, struct rohm_proximity_data *data)
    {
        queue_delayed_work(data->work_queue, &data->work,msecs_to_jiffies(ms));
    }

    static void rohm_proximity_stop_work(struct rohm_proximity_data *data)
    {
        PS_DBG("%s\n", __func__);
        cancel_rearming_delayed_workqueue(data->work_queue,&data->work);
        flush_workqueue(data->work_queue);
    }

    static void rohm_proximity_work(struct work_struct *work)
    {
        struct rohm_proximity_data *data = container_of(work, struct rohm_proximity_data, work.work);
        rohm_proximity_report(data);
        rohm_proximity_start_work(RHOM_PROXIMITY_DATA_POLL_TIMER, data);
    }

    static int rohm_proximity_enable(struct rohm_proximity_data *data)
    {
        PS_DBG("%s\n", __func__);
        data->enabled = 1;
        wake_lock(&prox_delayed_work_wake_lock);
        rohm_proximity_start_work(RHOM_PROXIMITY_DATA_POLL_TIMER, data);
        return 0;
    }

    static int rohm_proximity_disable(struct rohm_proximity_data *data)
    {
        PS_DBG("%s\n", __func__);
        data->enabled = 0;
        wake_unlock(&prox_delayed_work_wake_lock);
        rohm_proximity_stop_work(data);
        return 0;
    }

    static int rohm_proximity_setup(struct rohm_proximity_data *ip)
    {
        struct rohm_proximity_platform_data *pdata = ip->pdata;

        //config gpio
        pdata->gpio_trans = sprd_3rdparty_gpio_proximity_trans;
        pdata->gpio_recv = sprd_3rdparty_gpio_proximity_recv;

        PS_DBG("%s, gpio_recv=%d; gpio_trans=%d\n", __func__, pdata->gpio_recv, pdata->gpio_trans);

        gpio_direction_output(pdata->gpio_trans, 0);
        gpio_direction_output(pdata->gpio_recv, 0);

        //set control gpio low
        gpio_set_value(pdata->gpio_trans, 0);
        gpio_set_value(pdata->gpio_recv, 0);

        //init adc
        ADC_Init();

        return 0;
    }

    static int rohm_proximity_open(struct inode *inode, struct file *file)
    {
        PS_DBG("%s\n", __func__);
        if (misc_opened)
            return -EBUSY;
        misc_opened = 1;
        return 0;
    }

    static int rohm_proximity_release(struct inode *inode, struct file *file)
    {
        PS_DBG("%s\n", __func__);
        misc_opened = 0;
        return rohm_proximity_disable(&proximity_data);
    }

    static long rohm_proximity_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    {
        int val;
        PS_DBG("%s cmd %d\n", __func__, _IOC_NR(cmd));
        switch (cmd) {
        case ROHM_PROXIMITY_IOCTL_ENABLE:
            if (get_user(val, (unsigned long __user *)arg))
                return -EFAULT;
            if (val)
                return rohm_proximity_enable(&proximity_data);
            else
                return rohm_proximity_disable(&proximity_data);
            break;
        case ROHM_PROXIMITY_IOCTL_GET_ENABLED:
            return put_user(proximity_data.enabled, (unsigned long __user *)arg);
            break;
        default:
            pr_err("%s: invalid cmd %d\n", __func__, _IOC_NR(cmd));
            return -EINVAL;
        }
    }

    static struct file_operations rohm_proximity_fops = {
        .owner = THIS_MODULE,
        .open = rohm_proximity_open,
        .release = rohm_proximity_release,
        .unlocked_ioctl = rohm_proximity_ioctl
    };

    struct miscdevice rohm_proximity_misc = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = PROXIMITY_DEVICE,
        .fops = &rohm_proximity_fops
    };

     

    static int rohm_proximity_probe(struct platform_device *pdev)
    {
        int rc = -EIO;
        struct input_dev *input_dev;
        struct rohm_proximity_data *ip;
        struct rohm_proximity_platform_data *pdata;

        PS_DBG("%s\n", __func__);

        wake_lock_init(&prox_delayed_work_wake_lock, WAKE_LOCK_SUSPEND, "prox_delayed_work");

        pdata = pdev->dev.platform_data;
       
        if (!pdata) {
            pr_err("%s: missing pdata!\n", __func__);
            goto done;
        }


        ip = &proximity_data;
        platform_set_drvdata(pdev, ip);

        PS_DBG("%s: allocating input device\n", __func__);
        input_dev = input_allocate_device();
        if (!input_dev) {
            pr_err("%s: could not allocate input device\n", __func__);
            rc = -ENOMEM;
            goto done;
        }
        ip->input_dev = input_dev;
        ip->pdata = pdata;
        input_set_drvdata(input_dev, ip);

        input_dev->name = "proximity";
        input_dev->phys = "proximity";
        input_dev->id.bustype = BUS_HOST;
        input_dev->id.vendor = 0x0001;
        input_dev->id.product = 0x0001;
        input_dev->id.version = 0x0100;

        set_bit(EV_ABS, input_dev->evbit);
        input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0);

        PS_DBG("%s: registering input device\n", __func__);
        rc = input_register_device(input_dev);
        if (rc < 0) {
            pr_err("%s: could not register input device\n", __func__);
            goto err_free_input_device;
        }

        PS_DBG("%s: registering misc device\n", __func__);
        rc = misc_register(&rohm_proximity_misc);
        if (rc < 0) {
            pr_err("%s: could not register misc device\n", __func__);
            goto err_unregister_input_device;
        }

        //create work queue
        INIT_DELAYED_WORK(&ip->work, rohm_proximity_work);
        ip->work_queue = create_singlethread_workqueue("proximity");       

        rohm_proximity_create_sysfs(pdev);
        //rohm_proximity_enable(&proximity_data);//add by DO驱动自动启动,不用上层调用
        rc = rohm_proximity_setup(ip);
        if (!rc)
            goto done;

        misc_deregister(&rohm_proximity_misc);

    err_unregister_input_device:
        input_unregister_device(input_dev);
    err_free_input_device:
        input_free_device(input_dev);
        wake_lock_destroy(&prox_delayed_work_wake_lock);
    done:
        PS_DBG("%s, Done\n", __func__);
        return rc;
    }

    static int rohm_proximity_remove(struct platform_device *pdev)
    {
        struct rohm_proximity_platform_data *pdata=pdev->dev.platform_data;

        cancel_rearming_delayed_workqueue(proximity_data.work_queue, &proximity_data.work); 
        flush_workqueue(proximity_data.work_queue);
        destroy_workqueue(proximity_data.work_queue);

        misc_deregister(&rohm_proximity_misc);
        input_unregister_device(proximity_data.input_dev);
        input_free_device(proximity_data.input_dev);

        //unregister gpio
        gpio_free(pdata->gpio_trans);
        gpio_free(pdata->gpio_recv);

        wake_lock_destroy(&prox_delayed_work_wake_lock);

        return 0;
    }


    static struct platform_driver rohm_proximity_driver = {
        .probe = rohm_proximity_probe,
        .remove = rohm_proximity_remove,
        .driver = {
            .name = ROHM_PROXIMITY,
            .owner = THIS_MODULE
        },
    };


    static int __devinit rohm_proximity_init(void)
    {
        PS_DBG("%s\n",__func__);
        platform_device_register(&rohm_proximity_device);
        return platform_driver_register(&rohm_proximity_driver);
    }

    static void rohm_proximity_exit(void)
    {
        PS_DBG("%s\n",__func__);
       
        platform_device_unregister(&rohm_proximity_device);
        platform_driver_unregister(&rohm_proximity_driver);
    }

    module_init(rohm_proximity_init);
    module_exit(rohm_proximity_exit);

    MODULE_DESCRIPTION("Rohm Proximity driver");
    MODULE_LICENSE("GPL");
    MODULE_ALIAS("platform:proximity sensor");


     


     

     

     

     

     

    展开全文
  • 红外对管测试

    2015-08-10 11:17:03
    描 述: 挡住红外对管,对管上的灯亮,拿开就灭。发生一次D1也会改变 * P0.4口为传感器的输入端 串口配置也115200 8N1 ****************************************************************************/ #include #...
  • 红外测距模块–红外对管(TCRT5000)原理 一、基本概述 TCRT5000光电传感器模块是基于TCRT5000红外光电传感器设计的一款红外反射式开关器件,传感器采用发射功率红外光电二极管和光电接收管组成,输出的信号经过...

    红外测距模块–红外对管(TCRT5000)原理

    一、基本概述

    TCRT5000光电传感器模块是基于TCRT5000红外光电传感器设计的一款红外反射式开关器件,传感器采用发射功率红外光电二极管和光电接收管组成,输出的信号经过施密特电路整形、稳定可靠。
    适用场景:
    1、碎纸机纸张检测
    2、障碍检测
    3、黑白线检测

    二、模块原理和应用

    1、电路图如图所示
    在这里插入图片描述
    此模块使用的是LM393比较器搭建而成,当正输入电压>负输入电压 时,DO输出H,LED灯熄灭。
    当正输入电压 < 负输入电压时, DO输出为L,LED灯亮起。
    原理阐述:
    1、TCRT5000(1、2脚)通过限流电阻进行红外线发射,3、4脚为反射接收管,最大承受的电流为15mA,
    2、电源采用3.3V电压,(可以为其他电压如5V),LM393的2脚电压经过分压电阻R1\R6得到约等于1.65V左右的电压,3脚的经过电流电阻与接收管连接,当接收管接收到反射线后,导通,此时的3脚电压为0V左右,此时3脚电压 < 2脚电压,输出为低L。此管脚连接到单片机上可以作为中断进行逻辑功能使用,反之亦然。

    记录点滴,每天进步一点点。

    展开全文
  • 51红外传感器资料及例程
  • 寻迹小车笔记——红外对管(TCRT5000)原理

    万次阅读 多人点赞 2019-11-17 21:18:54
    TCRT5000光电传感器模块是基于TCRT5000红外光电传感器设计的一款红外反射式光电开关。传感器采用高发射功率红外光电二极管和高灵敏度光电晶体管组成,输出信号经施密特电路整形,稳定可靠。    &...
  • 基于stm32f103的红外对管(TCRT5000)接收发送 广西●河池学院 广西高校重点实验室培训基地 系统控制与信息处理重点实验室 本篇博客来自河池学院: 智控无人机小组 写作时间: 2020年8月8日 一、模块简介 在此模块中...
  • 根据红外对管作为传感器,测量脉冲间隔。使用PWM方式对直流舵机进行控制。通过STC89C52单片机实现一个闭环控制系统。静态LED数码管显示。
  • 小车循迹程序

    2013-08-11 10:56:07
    智能小车基于红外对管传感器的51单片机循迹避障程序
  • 本系统由STC89C52单片机、红外对管传感器、LCD1602液晶显示、 LED指示灯及电源组成。 1、通过红外对管模块实时检测车位是否占用,车位分为1车位,2车位,3车位。 2、液晶实时显示车位是否被占用、车位被占用数、空车...
  • ( TCRT5000_红外反射式光电传感器_反射型光电开关_光电对管_寻迹小车专用.doc
  • 本设计由STC89C52单片机电路+红外对管传感器+LCD1602液晶显示电路+LED指示灯电路+电源电路组成。 1、通过红外对管模块实时检测车位是否占用,车位分为1车位,2车位,3车位。 2、液晶实时显示车位是否被占用、车位被...
  • 基于51单片机的智能垃圾桶

    万次阅读 多人点赞 2019-03-20 21:41:04
    (1)红外对管传感器检测是否有人扔垃圾 (2)垃圾桶满报警 (3)步进电机驱动电路的设计 2.硬件设计 (1)总体硬件设计 硬件主要以单片机为核心,通过软件和硬件的结合实现检测到人自动打开垃圾桶盖的效果,并且...
  • 常用的传感器: ·一线制数字温度传感器 ·铂金属温度传感器 ·红外对管 ·黑白线检测传感器 ·光电避障传感器 ·金属探测传感器 ·霍尔传感器+磁钢 ·超声波探头 ·附录1:传感器接线图
  • 循迹小车

    万次阅读 2017-01-12 17:26:05
    记得09年时候,还不会单片机,专业课也还没开单片机的课,想做个循迹和避障小车。于是网上搜资料,发现ardunio非常不错,简单好入门,x宝买了一个Arduino Uno和一个USBtinyISP开启了我...3.红外对管传感器x6; 4.CP2
  • 本文介绍了基于stm32的转速仪的设计,可以用光电门传感器和红外对管传感器测量,可以设置选择传感器、计数方式,可以显示测量结果。描述总体设计方案、器件选型,各模块原理分析、软件设计思路与过程。制作测试仪并...
  • 如果需要关门,需要触摸红外对管传感器,模拟门关了可以上锁。 2、可对指纹进行增删查改家庭成员指纹信息,增删查改是否成功的相关信息显示在OLED屏幕上 3.也可以对密码进行修改。 4.可对RFID进行录入,或者注销操作...
  • 传感器和距离传感器TMD22713源代码执行过程分析 距离传感器vcnl4010驱动总结 http://blog.csdn.net/feng85016578/article/details/52836298linux红外对管(距离传感器)驱动 分析 http://blog.cs
  • 电机测速(霍尔传感器+磁钢或者红外反射对管+黑白码盘实验)
  • 上图为H2光雨量传感器,内部采用4路红外对管。大IC芯片型号为:R5F2120. 对外引脚有4个,分别为VBAT,LIN IN,LIN OUT,GND。 采用的解码器为这种:(LIN转串口解码器) 最后形成协议矩阵,matrix格式的矩阵文件: ...
  • 设计简介: 本设计是基于单片机的GSM...可实现通过红外对管检测是否有人闯入 可实现通过继电器控制异常处理模块 可实现通过SIM900A模块传输异常信息 可实现通过LCD1602显示当前检测数值信息 */ void main() {
  • 51红外寻迹小车(一)

    千次阅读 多人点赞 2020-11-29 09:23:42
    系统原理∶在汽车行红外光在具有不同颜色的物体表面的不同...寻迹模块:红外对管避障传感器 通过电位器调节红外发射管的功率,将红外线发射出去,接收管接收经过地面反射回来的红外线,由于黑色会吸收较多的红外线,
  • 红外避障的使用

    2017-11-23 10:14:00
    红外对管(注意:传感器还有 Grove IR Distance Interrupter可选,sensor型号RPR-359F 红外发射管SE303A) 这里有购买,其中F3,F5的资料在这里http://pan.baidu.com/s/1mgslQbQ F3,F5只是尺寸不一样,主要参数...
  • 2火焰传感器对应开发板上的红外对管传感器,用手遮挡时红外对管时,明火报警; 3换气扇操作对应开发板上的马达,打开换气扇按钮,马达开始正转; 4插座开关对应开发板的RGB LED中的红灯,打开插座开关按钮,红灯亮。...
  • 本项目采用主要芯片:AT89S52、LCD1602、GSM模块、红外对管; 本资料是我今年做的项目,已经完美交货,现在把全部设计资料共享给大家 压缩包里包含该项目的完整原理图、PCB图、程序、实物图等。 硬件设计部分使用...
  • 采用槽型对射光电传感器测量智能车车速,使用红外对管进行障碍物检测, TFT LCD 彩屏模拟汽车的仪表盘,并显示智能车的各项数据,如驾驶模式、 行驶距离、 车速等。使用红外遥控器对智能车进行操控,并且控制多种...
  • 设计简介: ...可实现通过红外对管自动循迹 可实现通过温度传感器测得车内温度 可实现自动避障、自动循迹等功能 可实现通过LCD1602显示当前检测到的障碍物距离、车内温度数值以及左右偏差值 ...

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

红外对管传感器