发 帖  
原厂入驻New
[资料]

RT-Thread DS18B20温度传感器驱动程序

2021-3-25 11:19:51  4283 温度传感器 ds18b20
分享
本帖最后由 a77582508 于 2017-4-10 17:11 编辑







复制代码

//首先查到到相关的DS18b20驱动
//然后打开驱动  打开方式为RT_NULL
//打开成功就可以调用rt_device_read函数读取温度
//

#include <rtdevice.h>
#include <rthw.h>
#include <board.h>

//还没有添加调试信息
//应该添加一个.h文件


#IF 0 /* 库函数方式 */
        #define DQ_0(PORT_DQ,PIN_DQ)                GPIO_ResetBits(PORT_DQ, PIN_DQ)
        #define DQ_1(PORT_DQ,PIN_DQ)                GPIO_SetBits(PORT_DQ, PIN_DQ)

        /* 判断DQ输入是否为低 */
        #define DQ_IS_HIGH()                    GPIO_ReadInputDataBit(PORT_DQ, PIN_DQ)
#else        /* 直接操作寄存器,提高速度 */
        #define DQ_0(PORT_DQ,PIN_DQ)                PORT_DQ->BSRR |= (PIN_DQ<<16)
        #define DQ_1(PORT_DQ,PIN_DQ)                PORT_DQ->BSRR |= (PIN_DQ)

        /* 判断DQ输入是否为低 */
        #define DQ_IS_HIGH(PORT_DQ,PIN_DQ)        (PORT_DQ->IDR & PIN_DQ)
#endif


//设置IO口方向
#define _IO_IN(CR,BIT_AND,BIT_OR)  {*CR&=BIT_AND;*CR|=BIT_OR;}
#define _IO_OUT(CR,BIT_AND,BIT_OR) {*CR&=BIT_AND;*CR|=BIT_OR;}

//驱动名字
#define HARD_DEVICE_NAME_FORMAT     "18b20_%d"
#define HARD_DEVICE_NAME_SIZE       (sizeof(HARD_DEVICE_NAME_FORMAT) + 2)

//获得数组元素个数
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(arr)     (sizeof(arr)/sizeof(arr[0]))
#endif

//IO口相关信息
struct ds18b20_gpio_desc
{
    uint32_t rcc;
    GPIO_TypeDef *gpio;
    uint32_t pin;
};

//在这里添加DS18B20相关引脚信息
//如果有多个DS18B20,依次添加即可
//目前只支持一个引脚上挂一个DS18B20
const static struct ds18b20_gpio_desc _hard_desc[] =
{
    {RCC_APB2Periph_GPIOA, GPIOA, GPIO_Pin_3},
};
//其他地方不需要修改





//设置IO方向
struct _IO_
{
    uint32_t _IO_IN_and;
    uint32_t _IO_IN_or;
    uint32_t _IO_OUT_and;
    uint32_t _IO_OUT_or;
    volatile uint32_t * _CRx;
};

//DS18B20驱动
struct _ds18b20_drv
{
    struct rt_device device;
    struct _IO_ io;
    const struct ds18b20_gpio_desc * hard_desc;
    rt_mutex_t mutex;
};

//内部使用,左移四位
static uint32_t _crol_(uint32_t c)
{
    uint32_t temp;

    temp = c<<4;
    c = c>>(sizeof(uint32_t)*8-4);
    return c |= temp;
}

//DS18B20复位
static rt_err_t _ds18b20_reset(struct _ds18b20_drv * _drv)
{
    uint8_t retry = 0;

    _IO_OUT(_drv->io._CRx,_drv->io._IO_OUT_and,_drv->io._IO_OUT_or);
    DQ_0(_drv->hard_desc->gpio,_drv->hard_desc->pin);
    rt_delay_us(750);//拉低750us
    DQ_1(_drv->hard_desc->gpio,_drv->hard_desc->pin);
    rt_delay_us(10);
        _IO_IN(_drv->io._CRx,_drv->io._IO_IN_and,_drv->io._IO_IN_or);
    while(DQ_IS_HIGH(_drv->hard_desc->gpio,_drv->hard_desc->pin)&&retry<200)
        {
                retry++;
                rt_delay_us(1);
        }

        if(retry>=200)
        return RT_ERROR;

    while((!DQ_IS_HIGH(_drv->hard_desc->gpio,_drv->hard_desc->pin))&&retry<240)
        {
                retry++;
                rt_delay_us(1);
        }

        if(retry>=240)
        return RT_ERROR;

        return RT_EOK;
}

//DS18B20读一个字节
static rt_err_t _ds18b20_read_byte(struct _ds18b20_drv * _drv, uint8_t * data)
{
    uint8_t bit = 0,result = 0;
    uint8_t i = 0;

    for(i = 0;i<8;i++)
    {
        _IO_OUT(_drv->io._CRx,_drv->io._IO_OUT_and,_drv->io._IO_OUT_or);
        DQ_0(_drv->hard_desc->gpio,_drv->hard_desc->pin);
        rt_delay_us(1);
        DQ_1(_drv->hard_desc->gpio,_drv->hard_desc->pin);
        _IO_IN(_drv->io._CRx,_drv->io._IO_IN_and,_drv->io._IO_IN_or);
        rt_delay_us(12);
        if(DQ_IS_HIGH(_drv->hard_desc->gpio,_drv->hard_desc->pin)) bit=1;
        else bit=0;               
        result=(bit<<7)|(result>>1);

        rt_delay_us(50);
    }
    *data = result;

    return RT_EOK;
}

//DS18B20写一个字节
static uint8_t _ds18b20_write_byte(struct _ds18b20_drv * _drv, uint8_t data)
{
    uint8_t i, testb;

        _IO_OUT(_drv->io._CRx,_drv->io._IO_OUT_and,_drv->io._IO_OUT_or);
    for (i=0;i<8;i++)
        {
        testb=data&0x01;
        data=data>>1;
        if (testb)
        {
            DQ_0(_drv->hard_desc->gpio,_drv->hard_desc->pin);
            rt_delay_us(2);                           
            DQ_1(_drv->hard_desc->gpio,_drv->hard_desc->pin);
            rt_delay_us(60);
        }
        else
        {
            DQ_0(_drv->hard_desc->gpio,_drv->hard_desc->pin);
            rt_delay_us(60);                           
            DQ_1(_drv->hard_desc->gpio,_drv->hard_desc->pin);
            rt_delay_us(2);                          
        }
    }

    return RT_EOK;
}

//DS18B20转换一次
static rt_err_t _ds18b20_start(struct _ds18b20_drv * _drv)
{
    rt_base_t level;

    if(_ds18b20_reset(_drv) == RT_EOK)
    {
        level = rt_hw_interrupt_disable();
        _ds18b20_write_byte(_drv,0xcc);        // skip rom
        _ds18b20_write_byte(_drv,0x44);        // convert
        rt_hw_interrupt_enable(level);

        return RT_EOK;
    }

    return RT_ERROR;
}

//ds18b20读取温度
static rt_err_t _ds18b20_read_data(struct _ds18b20_drv * _drv, float * result)
{
    rt_base_t level;
    uint8_t  data_H, data_L;
    short data;

    _ds18b20_reset(_drv);
    level = rt_hw_interrupt_disable();
    _ds18b20_write_byte(_drv,0xcc);        // skip rom
    _ds18b20_write_byte(_drv,0xbe);        // convert            
    _ds18b20_read_byte(_drv, &data_L);         // LSB   
    _ds18b20_read_byte(_drv, &data_H);         // MSB
    rt_hw_interrupt_enable(level);
    data = data_H;
    data <<= 8;
    data |=  data_L;
    if(data&0xF800)
        *result=(~data+1)*0.0625*10;
    else
        *result=data*0.0625;

    if(*result>-55 && *result<125)
        return RT_EOK;
    else
        return RT_ERROR;

}

static rt_err_t STM32_ds18b20_init(rt_device_t dev)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    uint32_t TempInAnd,TempInOr,TempOutAnd,TempOutOr;
    uint16_t GPIO_Pin_x = 0;

    struct _ds18b20_drv * ds18b20 = (struct _ds18b20_drv *)dev;

    RCC_APB2PeriphclockCmd(ds18b20->hard_desc->rcc, ENABLE);         //使能时钟
    GPIO_InitStructure.GPIO_Pin = ds18b20->hard_desc->pin;             // 推挽输出
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(ds18b20->hard_desc->gpio, &GPIO_InitStructure);
    GPIO_SetBits(ds18b20->hard_desc->gpio,ds18b20->hard_desc->pin);//输出1

    TempInAnd  = 0xFFFFFFF0;
    TempOutAnd = 0xFFFFFFF0;
    TempInOr   = 0x00000008;
    TempOutOr  = 0x00000003;

    if (((uint32_t)GPIO_InitStructure.GPIO_Pin & ((uint32_t)0x00FF)) != 0x00)
    {
        ds18b20->io._CRx = &(ds18b20->hard_desc->gpio->CRL);
        GPIO_Pin_x = ds18b20->hard_desc->pin>>1;
    }
    if((GPIO_InitStructure.GPIO_Pin > 0x00FF))
    {
        ds18b20->io._CRx = &(ds18b20->hard_desc->gpio->CRH);
        GPIO_Pin_x = ds18b20->hard_desc->pin>>9;
    }

    while(GPIO_Pin_x)
    {
        TempInAnd  = _crol_(TempInAnd);
        TempOutAnd = _crol_(TempOutAnd);
        TempInOr   = _crol_(TempInOr);
        TempOutOr  = _crol_(TempOutOr);
        GPIO_Pin_x >>= 1;
    }

    ds18b20->io._IO_IN_and  = TempInAnd;
    ds18b20->io._IO_IN_or   = TempInOr;
    ds18b20->io._IO_OUT_and = TempOutAnd;
    ds18b20->io._IO_OUT_or  = TempOutOr;

    return RT_EOK;
}
static rt_err_t stm32_ds18b20_open(rt_device_t dev, rt_uint16_t oflag)
{   
    struct _ds18b20_drv * ds18b20 = (struct _ds18b20_drv *)dev;

    return _ds18b20_reset(ds18b20);
}

static rt_err_t stm32_ds18b20_close(rt_device_t dev)
{

    return RT_EOK;
}

static rt_size_t stm32_ds18b20_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
    float temp;
    int count = 0,i = 0;
    float * data = (float *)buffer;
    struct _ds18b20_drv * ds18b20 = (struct _ds18b20_drv *)dev;

    while(i<(size/sizeof(float)))
    {
        rt_mutex_take(ds18b20->mutex,RT_WAITING_FOREVER);
        if(_ds18b20_start(ds18b20) == RT_EOK)
        {
            rt_thread_delay(800);
            if(_ds18b20_read_data(ds18b20, &temp) == RT_EOK)
            {
                data = temp;
                count++;
            }
            else
            {
                data = 85;
            }

        }
        rt_mutex_release(ds18b20->mutex);
        i++;
    }

    return count;
}

static rt_err_t stm32_ds18b20_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{

    return RT_EOK;
}

int ds18b20_drv_init(void)
{
    int i = 0, count = 0;
    char dev_name[HARD_DEVICE_NAME_SIZE] = "";
    struct _ds18b20_drv *_dev = RT_NULL;

    for(i=0; i<ARRAY_SIZE(_hard_desc);i++)
    {
        _dev = (struct _ds18b20_drv *)rt_malloc(sizeof(struct _ds18b20_drv));
        if (RT_NULL == _dev)
        {
            continue;
        }
        rt_sprintf(dev_name, HARD_DEVICE_NAME_FORMAT, i);
        if(RT_NULL ==rt_device_find(dev_name))
        {
            _dev->hard_desc = &(_hard_desc);
            _dev->device.init      = stm32_ds18b20_init;
            _dev->device.open      = stm32_ds18b20_open;
            _dev->device.close     = stm32_ds18b20_close;
            _dev->device.read      = stm32_ds18b20_read;
            _dev->device.write     = RT_NULL;
            _dev->device.control   = stm32_ds18b20_control;
            _dev->device.user_data = RT_NULL;
            rt_device_register(&(_dev->device),dev_name,RT_DEVICE_FLAG_RDONLY);

            _dev->mutex =  rt_mutex_create(dev_name,RT_IPC_FLAG_FIFO); //创建信号量没有判断是否成功

            count++;
        }
    }

    return count;
}


INIT_DEVICE_EXPORT(ds18b20_drv_init);

0
分享淘帖 显示全部楼层

评论

高级模式
您需要登录后才可以回帖 登录 | 注册

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容图片侵权或者其他问题,请联系本站作侵删。 侵权投诉
发资料
关闭

站长推荐 上一条 /8 下一条

快速回复 返回顶部 返回列表