【温湿度传感器GXHT3W -- I2C单总线linux设备树驱动】

最新推荐文章于 2024-09-27 12:05:02 发布
最新推荐文章于 2024-09-27 12:05:02 发布
阅读量536 收藏 9
点赞数 5
文章标签： linux c语言 iot 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39964959/article/details/142491348
版权

GXHTC3驱动同上一篇文章，我们再做一款基于北京中科银河芯单总线通讯的高精度温湿度传感器GXHT3W驱动；
做驱动先看规格书：
在这里插入图片描述
可以看到GXHT3W温湿度传感器仅需两根线即可进行通讯（VCC采用寄生供电,从通讯数据线上窃取电流，从而节省VCC端口）,并且拥有全球唯一的ID可 用作加密保护，数字标签等功能；
官方推荐的传感器原理图也非常简单

注意：由于供电采用的“窃电”原理，上拉电阻的阻值不能太大，最好是4.7K以内的阻值
我们将数据线接在鲁班猫2开发板物理引脚第40脚GPIOB2上面，如下图所示

在这里插入图片描述
修改设备树代码，将GPIOB2设置为普通GPIO：
在这里插入图片描述
在这里插入图片描述
鲁班猫2的设备树文件位于/kernel/arch/arm64/boot/dts/rockchip/rk3568-lubancat-2-v2.dts ，编译后替换掉原设备树文件：
cp arch/arm64/boot/dts/rockchip/rk3568-lubancat-2-v2.dtb /boot/dtb/

开始着手GXHT3W的单总线驱动软件配置；
首先，GXHT3W的总线读写时序如下：
在这里插入图片描述

static void gxht3w_write_bit(uint8_t bit)
{
    GXHT3W_IO_OUT();     /* 设置为输出 */

    bit = bit > 1 ? 1 : bit;
    GXHT3W_WRITE(0);
    udelay(2);
    GXHT3W_WRITE(bit);
    /* 写0和写1的时间至少要大于60us */
    udelay(60);           /*  us */

    GXHT3W_WRITE(1);   /* 释放总线 */
    udelay(16);
}

/* 整个读周期最少需要60us，启动读开始信号后必须15us内读取IO电平，否则就会被上拉拉高 */
static uint8_t gxht3w_read_bit(void)
{
    uint8_t bit;

    GXHT3W_IO_OUT();     /* 设置为输出 */
    /* 读时间的起始：必须由主机产生 >1us <15us 的低电平信号 */
    GXHT3W_WRITE(0);
    udelay(5);
    GXHT3W_IO_IN();    /* 设置为输入 */
    udelay(5);
    bit = GXHT3W_READ();    /* 读取结果 */
    /* 这个延时参数请参考时序图 */
    udelay(45);

    return bit;
}

复位时序：
在这里插入图片描述

static int gxht3w_reset(void)
{
    int ret = 1;

    GXHT3W_IO_OUT();     /* 设置为输出 */
    GXHT3W_WRITE(0);
    /* 主机至少产生480us的低电平复位信号 */
    udelay(750);
    /* 主机在产生复位信号后，需将总线拉高 */
    GXHT3W_WRITE(1);
    /*从机接收到主机的复位信号后，会在15~60us后给主机发一个存在脉冲*/
    udelay(75);
    GXHT3W_IO_IN();    /* 设置为输入 */
    ret = GXHT3W_READ();
    udelay(10);
    GXHT3W_IO_OUT();
    GXHT3W_WRITE(1);       /* 释放总线 */
//    udelay(10);
//    GXHT3W_WRITE(0);
//    udelay(60);
//    GXHT3W_WRITE(1);
//    udelay(16);
    return ret;
}

数据读取流程ROM匹配模式：
在这里插入图片描述
数据读取流程跳过ROM匹配模式：
在这里插入图片描述
因为我们的总线上面只挂载一颗GXHT3W，我们采用比较简单的跳过ROM匹配的模式来采集数据，采集数据过程如下：

    int ret = -1, i;
    unsigned char  tpmsb, tplsb, Th, Tl, con, res, humil, humim, crc, data[9];
    unsigned short tem, hum;
    short gxht3w_result[2];

    if (gxht3w_reset() != 0)
    {
        printk("%d gxht3w reset failed\n", __LINE__);
        return -EFAULT;
    }
    gxht3w_wrte_byte(CMD_SKIP_ROM_ID);
    gxht3w_wrte_byte(CMD_CONVERT_TEMP);

    msleep(60);

    if (gxht3w_reset() != 0)
    {
        printk("%d gxht3w reset failed", __LINE__);
        return -EFAULT;
    }
    gxht3w_wrte_byte(CMD_SKIP_ROM_ID);
    gxht3w_wrte_byte(CMD_READ_DATA);      /* 发送读数据命令 */
    for (i = 0; i < 9; i++)
    {
        data[i] = gxht3w_read_byte();
    }
    crc = data[8];
    if (CRC_Check(data, 8) == crc)
    {
        tplsb = data[0];
        tpmsb = data[1];
        Th = data[2];
        Tl = data[3];
        con = data[4];
        res = data[5];
        humil = data[6];
        humim = data[7];

        tpmsb = 0x0f & tpmsb;
        tem = ((tpmsb << 8) | tplsb);//温度拼接
        hum = ((humil << 8) | humim);//湿度拼接i
        //内核不能进行浮点运算，把值放大100倍
        gxht3w_result[0] = 17500 * tem / 4095 - 4500;
        gxht3w_result[1] = (100 * hum / 655);

        if (gxht3w_result[0] < 17501 && gxht3w_result[1] < 10001)
        {

            ret = copy_to_user(buf, gxht3w_result, size);

            if (ret != 0)
            {
                printk("copy_to_user error!");
            }
        }
    }
    return ret;

测试app:

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>

int main(int argc, char *argv[])
{

    unsigned short data[2];
    float T,RH;
    int ret = -1 ;
         /*打开文件*/
        int fd = open("/dev/gxht3w", O_RDWR);
        if(fd < 0)
         {
                printf("open file : %s failed !\n", argv[0]);
                return -1;
        }

    /*读取数据*/
        while(1)
        {
                ret = read(fd,data,sizeof(data));//linux内核不支持浮点运算，返回的数据是放大100倍的整型数需要/100
                //ret = fread(data, sizeof(unsigned short), 2, (FILE*)fdopen(fd, "r"));
                printf("reading gxht3W:%d\r\n",ret);
                printf("sizeof data:%d\r\n",sizeof(data));
                if(ret >= 0){
                T = (float)data[0]/100 ;
                RH = (float)data[1]/100;
                printf("T:%.2f RH:%.2f \r\n",T,RH);
                }
                usleep(1000000);
        }
        int error = close(fd);
        if(error<0)
        {
                printf("close file error!\n");
        }

    return 0;
}

运行结果：
在这里插入图片描述
以下是整体的测试源码方便码友们一次性复制

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/platform_device.h>
#include <linux/of_irq.h>
#include <linux/wait.h>
#include <linux/sched/signal.h>
#include <linux/atomic.h>


#define DEV_PIN_DTS_NAME     "gxht3wdat"           /* GPIO引脚的属性名 */
#define DEV_NAME             "gxht3w"                 /* 设备名  /dev/gxht3w */
#define DEV_DTS_COMPATIBLE   "gxht,gxht3w"             /* 设备匹配属性 compatible */
struct semaphore sem; //互斥锁，只能有一个打开

struct gxht3w {
    int gpio;                       /* gpio */
    dev_t dev_no;                   /* 设备号 */
    struct cdev chrdev;
    struct class* class;
};

static struct gxht3w  gxht3w_dev;

#define CMD_CONVERT_TEMP         0x44
#define CMD_READ_DATA            0xBE
#define CMD_SKIP_ROM_ID          0xCC
#define CMD_MATCH_ROM_ID         0x55
#define CMD_READ_ROM_ID          0x33
#define CMD_SEARCH_ROM_ID        0xF0

#define GXHT3W_IO_OUT()    gpio_direction_output(gxht3w_dev.gpio, 1)
#define GXHT3W_IO_IN()     gpio_direction_input(gxht3w_dev.gpio)
#define GXHT3W_WRITE(bit)  gpio_set_value(gxht3w_dev.gpio, bit)
#define GXHT3W_READ()      gpio_get_value(gxht3w_dev.gpio)


static int gxht3w_reset(void)
{
    int ret = 1;

    GXHT3W_IO_OUT();     /* 设置为输出 */
    GXHT3W_WRITE(0);
    /* 主机至少产生480us的低电平复位信号 */
    udelay(750);
    /* 主机在产生复位信号后，需将总线拉高 */
    GXHT3W_WRITE(1);
    /*从机接收到主机的复位信号后，会在15~60us后给主机发一个存在脉冲*/
    udelay(75);
    GXHT3W_IO_IN();    /* 设置为输入 */
    ret = GXHT3W_READ();
    udelay(10);
    GXHT3W_IO_OUT();
    GXHT3W_WRITE(1);       /* 释放总线 */
    udelay(10);
    GXHT3W_WRITE(0);
    udelay(60);
    GXHT3W_WRITE(1);
    udelay(16);
    return ret;
}

static void gxht3w_write_bit(uint8_t bit)
{
    GXHT3W_IO_OUT();     /* 设置为输出 */

    bit = bit > 1 ? 1 : bit;
    GXHT3W_WRITE(0);
    udelay(2);
    GXHT3W_WRITE(bit);
    /* 写0和写1的时间至少要大于60us */
    udelay(60);           /*  us */

    GXHT3W_WRITE(1);   /* 释放总线 */
    udelay(16);
}

/* 整个读周期最少需要60us，启动读开始信号后必须15us内读取IO电平，否则就会被上拉拉高 */
static uint8_t gxht3w_read_bit(void)
{
    uint8_t bit;

    GXHT3W_IO_OUT();     /* 设置为输出 */
    /* 读时间的起始：必须由主机产生 >1us <15us 的低电平信号 */
    GXHT3W_WRITE(0);
    udelay(5);
    GXHT3W_IO_IN();    /* 设置为输入 */
    udelay(5);
    bit = GXHT3W_READ();    /* 读取结果 */
    /* 这个延时参数请参考时序图 */
    udelay(45);

    return bit;
}

static void gxht3w_wrte_byte(uint8_t byte)
{
    int i;

    for (i = 0; i < 8; i++)
    {
        gxht3w_write_bit((byte >> i) & 0x01);
    }
}

static uint8_t gxht3w_read_byte(void)
{
    int i;
    uint8_t bit;
    uint8_t byte = 0;

    for (i = 0; i < 8; i++)
    {
        bit = gxht3w_read_bit();
        if (bit) byte |= (0x01 << i);
    }

    return byte;
}





/* 使设备只能被一个进程打开 */
static int _drv_open(struct inode* node, struct file* file)
{
     /*上锁*/
//    down(&sem);

    gxht3w_reset();

    printk("gxht3w open ,gpio=%d\n", gxht3w_dev.gpio);
    return 0;
}



//CRC校验
static u8 CRC_Check(unsigned char *check_data, unsigned char num)
{
        uint8_t ret = 0,pBuf,i;

        while(num--)
        {
                pBuf = *check_data ++;

                for ( i = 0; i < 8; i ++ )
                {
                        if ((ret ^ (pBuf)) & 0x01)
                        {
                                ret ^= 0x18;
                                ret >>= 1;
                                ret |= 0x80;
                        }
                        else
                        {
                                ret >>= 1;
                        }

                        pBuf >>= 1;
                }
        }

        return ret;
}



static ssize_t _drv_read(struct file* filp, char __user* buf, size_t size, loff_t* offset)
{
    int ret=-1,i;
    unsigned char  tpmsb, tplsb, Th, Tl, con, res, humil, humim, crc,data[9];
    unsigned short tem, hum;
    short gxht3w_result[2];

    if(gxht3w_reset() != 0)
    {
            printk("%d gxht3w reset failed\n",__LINE__);
            return -EFAULT;
    }
    gxht3w_wrte_byte(CMD_SKIP_ROM_ID);
    gxht3w_wrte_byte(CMD_CONVERT_TEMP);

    msleep(60);

    if (gxht3w_reset() != 0)
    {
        printk("%d gxht3w reset failed", __LINE__);
        return -EFAULT;
    }
    gxht3w_wrte_byte(CMD_SKIP_ROM_ID);
    gxht3w_wrte_byte(CMD_READ_DATA);      /* 发送读数据命令 */
    for(i=0;i<9;i++)
    {
        data[i] = gxht3w_read_byte();
    }
    crc = data[8];
    if(CRC_Check(data,8) == crc)
    {
        tplsb = data[0];
        tpmsb = data[1];
        Th = data[2];
        Tl = data[3];
        con = data[4];
        res = data[5];
        humil = data[6];
        humim = data[7];

        tpmsb = 0x0f & tpmsb;
        tem = ((tpmsb << 8) | tplsb);//温度拼接
        hum = ((humil << 8) | humim);//湿度拼接i
        //内核不能进行浮点运算，把值放大100倍
        gxht3w_result[0] = 17500 * tem / 4095 - 4500;
        gxht3w_result[1] = (100 * hum / 655);

        if(gxht3w_result[0]<17501 && gxht3w_result[1]<10001)
        {

                ret = copy_to_user(buf, gxht3w_result, size);

                if (ret != 0)
                {
                        printk("copy_to_user error!");
                }
        }
    }
    return ret;

}


static int _drv_release(struct inode* node, struct file* file)
{
     /*释放锁*/
  //  up(&sem);
    printk("gxht3w  release\n");
    return 0;
}

static struct file_operations drv_file_ops = {
        .owner = THIS_MODULE,
        .open = _drv_open,
    .read = _drv_read,
    .release = _drv_release,
};

/* 设备树的匹配列表 */
static struct of_device_id dts_match_table[] = {
    {.compatible = DEV_DTS_COMPATIBLE, },                     /* 通过设备树来匹配 */
};


static int _driver_probe(struct platform_device* pdev)
{
    int err;
    struct device* ds_dev;
    struct device_node  *gxhtc3_device_node; //设备树节点
    gxhtc3_device_node = of_find_node_by_path("/gxht3w");

    gxht3w_dev.gpio = of_get_named_gpio(gxhtc3_device_node, "gpios", 0);

    err = gpio_request(gxht3w_dev.gpio, DEV_PIN_DTS_NAME);
    if (err)
    {
        printk("gpio_request gpio is failed!\n");
        return -EINVAL;
    }
    printk("gxht3w gpio = %d \n",gxht3w_dev.gpio);

    /* 内核自动分配设备号 */
    err = alloc_chrdev_region(&gxht3w_dev.dev_no, 0, 1, DEV_NAME);
    if (err < 0) {
        pr_err("Error: failed to register mbochs_dev, err: %d\n", err);
        return err;
    }

    cdev_init(&gxht3w_dev.chrdev, &drv_file_ops);
    cdev_add(&gxht3w_dev.chrdev, gxht3w_dev.dev_no, 1);
    gxht3w_dev.class = class_create(THIS_MODULE, DEV_NAME);
    if (IS_ERR(gxht3w_dev.class)) {
        err = PTR_ERR(gxht3w_dev.class);
        goto failed1;
    }

    /* 创建设备节点 */
    ds_dev = device_create(gxht3w_dev.class, NULL, gxht3w_dev.dev_no, NULL, DEV_NAME);
    if (IS_ERR(ds_dev)) {       /* 判断指针是否合法 */
        err = PTR_ERR(ds_dev);
        goto failed2;
    }

    printk("gxht3w  probe success\r\n");
    return 0;
failed2:
    device_destroy(gxht3w_dev.class, gxht3w_dev.dev_no);
    class_destroy(gxht3w_dev.class);
failed1:
    unregister_chrdev_region(gxht3w_dev.dev_no, 1);
    cdev_del(&gxht3w_dev.chrdev);
    gpio_free(gxht3w_dev.gpio);
    return err;
}

static int _driver_remove(struct platform_device* pdev)
{
    device_destroy(gxht3w_dev.class, gxht3w_dev.dev_no);
    class_destroy(gxht3w_dev.class);
    unregister_chrdev_region(gxht3w_dev.dev_no, 1);
    cdev_del(&gxht3w_dev.chrdev);
    gpio_free(gxht3w_dev.gpio);

    printk(KERN_INFO"GXHT3W  remove success\n");

    return 0;
}

static struct platform_driver _platform_driver = {
      .probe = _driver_probe,
      .remove = _driver_remove,
      .driver = {
        .name = DEV_DTS_COMPATIBLE,
        .owner = THIS_MODULE,
        .of_match_table = dts_match_table,         /* 通过设备树匹配 */
      },
};

/* 入口函数 */
static int __init _driver_init(void)
{
    int ret;
    printk("GXHT3W init %s\n", __FUNCTION__);

    ret = platform_driver_register(&_platform_driver);   //注册platform驱动
    return ret;
}

/*  出口函数 */
static void __exit _driver_exit(void)
{
    printk("GXHT3W exit  %s\n", __FUNCTION__);
    platform_driver_unregister(&_platform_driver);
}

module_init(_driver_init);
module_exit(_driver_exit);

MODULE_AUTHOR("GXHT");
MODULE_LICENSE("GPL");
qq_451526010
关注
单总线温湿度传感器GXHT3W，通信时序命令兼容18b20,数据处理部分有差别
03-22
单总线温湿度传感器GXHT3W是一款专为嵌入式系统设计的设备，它集成了温度和湿度的测量功能，并且在通信时序上与经典的18B20传感器保持兼容，使得开发者能够轻松地将它整合到现有的18B20系统中。然而，虽然时序兼容，...
中科银河芯GXHT30温湿度传感器模块STM32 I2C demo GXHT3x-STM32.rar
12-24
【标题】"中科银河芯GXHT30温湿度传感器模块STM32 I2C demo GXHT3x-STM32.rar"所涉及的核心知识点主要集中在以下几个方面： 1. **GXHT30温湿度传感器**：GXHT30是中科银河芯推出的一款高精度温湿度传感器，它能够...
驱动兼容18b20系列的单总线温湿度传感器GXHT3W
qq_44668817的博客
03-22 1254
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言单总线一、GXHT3W简介二、参数简介1.工作参数三、驱动程序1.读写时序2.读写数据3.数据处理总结 前言 单总线 提示：以下是本篇文章正文内容，下面案例可供参考 一、GXHT3W简介 GXHT3W是北京中科银河芯设计生产的一款使用单总线协议通信的温湿度传感器，区别于IIC
温湿度传感器 GXHT3L
chilian12321的博客
02-08 4319
特征：https://atta.szlcsc.com/upload/public/pdf/source/20211115/18AAECAE46F4BEFF1630C9054BE08F03.pdf ★ 全温湿度范围校准和温度补偿数字输出 ★ 宽电源电压范围，从 2.2 V 到 5.5 V ★ I2C 接口，通信速度高达 1MHz ★ 两个用户可选择的地址 ★ 典型精度为±5%RH 和±0.5°C ★ 单芯片集成温湿传感器 ★ 高可靠性和长期稳定性 ★ 测量 0-100%相对湿度的温度 ★ 集
藏经阁（五）温湿度传感器 SHT3x-DIS 手册 解析
weixin_43564241的博客
03-10 1601
湿度和温度传感器完全校准，线性化 温度补偿数字输出供电电压范围宽，从2.4 V到5.5 VI2C接口 通讯速度可达1MHz和两个用户可选地址 典型精度+ 2% RH和+ 0.3°C非常快的启动和测量时间微型8针DFN包
2元4mm2高精度温度湿度传感器GXHTC3
易板
04-22 1590
GXHTC3 是一款为消费电子应用领域设计的温湿度传感器芯片。它在封装体积、功耗、供电电压范围和性价比方面完全消费电子领域需求。GXHTC3在单颗芯片上实现了完整的温湿度传感器系统，包括电容式湿敏传感单元，PN 结测温单元，16 位 ADC，数字信号处理电路，校准数据存储单元和 I2C 数字通信接口电路。GXHTC3 采用小型化 DFN6 封装，尺寸为2 × 2 ×0.75mm3，可以应用在对空间要求苛刻的场景中。
3.14 haas506 2.0开发教程-example-温湿度传感器（SHT30/GXHT30）
haas506开发板
03-30 858
3.14 haas506 2.0开发教程-example-温湿度传感器（SHT30/GXHT30）1.GXHT30介绍2.测试代码3.测试结果 1.GXHT30介绍 （1）器件实物图 （2）参数 （3）硬件接线 2.测试代码 案例说明 获取GXHT30传感器湿度、温度数值。 寄存器地址0x00，存有6个相关字节数据 cTemp MSB cTemp LSB cTemp CRC Humididty MSB Humidity LSB Humidity CRC 温度高位 温度低位 校验码
外设驱动库开发笔记11：SHT3x系列温湿度传感器驱动
木南创智
08-02 3363
在我们的产品中经常会遇到温湿度检测的需求。可以用于检测温湿度的传感器元件也有很多。我们经常使用的SHT各系列数字温湿度传感器来实现应用需求。在这里我们将设计并实现SHT3x系列温湿度传感器的驱动。 1、功能概述 SHT3x系列温湿度传感器是适用于各种应用的高品质湿度传感器。SHT3x温湿度传感器系列结合了多种功能和各种接口适合各类应用。 1.1、硬件描述 SHT3x建立在全新和优化的CMOSens®芯片之上，进一步提高了产品可靠性和精度规格。SHT3x提供了一系列新功能，如增强信号处理、两个独特和用
3.14 haas506开发教程-example-温湿度传感器（SHT30/GXHT30）
haas506开发板
02-24 869
3.14 haas506开发教程-example-温湿度传感器（SHT30/GXHT30）
GXHT30温湿度传感器——与SHT30 pin to pin 兼容的温湿度传感器
qq_44668817的博客
10-23 8307
GXHT30温湿度传感器——与SHT30 pin to pin 兼容的温湿度传感器 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 GXHT30温湿度传感器是一款国产温湿度I2C传感器芯片，由北京中科银河芯研发并量产，其性能与通信方式与SHT30完全兼容，可pin to pin..
STM32读取GXHT30A模拟温湿度传感器
qq_44668817的博客
09-02 738
数字传感器现在应用越来越广泛，但在许多领域，模拟输出的传感器因为其简单，易用的特点还是广泛应用在很多行业中，例如家电等行业，中科银河芯的GXHT30A就是一款电压输出的模拟温湿度传感器。提示：以下是本篇文章正文内容，下面案例可供参考芯片支持的工作电压范围为2.2V到5.5V，温湿度的输出电压会根据工作电压不同而变化，只需将读取的电压值带入公式进行计算即可得出最终温湿度值。而传感器的管脚顺序和另外一款数字输出的温湿度传感器GXHT30匹配，在某些情况下两颗芯片的PCB能通用。
GXHT3W温湿度传感器中文版用户手册
09-13
GXHT3W温湿度传感器是一款由北京银河-卡斯科技有限公司推出的高性能传感器，主要应用于产品研发，特别是在温湿度监控的领域。这款传感器的特点包括支持单总线协议，这意味着它只需要一根信号线和一根地线就能与...
温度和湿度传感器 GXHT30驱动
10-12
温度和湿度传感器 GXHT30驱动 适用于linux android系统
GXHT3x-STM32.zip
02-22
通过将GXHT3X连接到STM32的I2C或SPI总线，并正确配置相应的GPIO引脚，就可以实现对温湿度数据的实时监控和记录。同时，为了确保系统稳定运行，还需要考虑电源管理、抗干扰措施以及数据处理算法的优化。
Linux 安装redis主从模式+哨兵模式3台节点
最新发布
一千个读者就有一千个哈姆雷特
09-27 320
Linux 安装redis主从模式+哨兵模式3台节点
【linux】gcc makefile
Quietcoder的博客
09-24 1078
在静态链接中，链接器（如GNU的。
linux 源代码编译
Lxn2zh的博客
09-27 1208
有时候会在linux上下载源码包，然后进行编译成可执行的文件，这个过程需要经过configure、make、make install、make clean四个步骤。configure 为这个程序在当前的操作系统环境下选择合适的编译器和环境参数来编译该代码。make install 将已编译好的可执行文件安装到操作系统指定或默认的安装目录下。make 对程序代码进行编译操作，会将源码编译成可执行的目标文件。make clean 删除编译时临时产生的目录或文件。
9.4 Linux_I/O_访问目录、文件属性
Fresh_man111的博客
09-25 348
返回值：成功返回指向打开的目录文件的结构体指针（流指针），失败返回NULLname：目录的路径fd：文件描述符返回值：成功返回0，失败返回EOFdirp：指向目录的流指针。
GXHT3W温湿度传感器：详尽中文手册，研发人员的理想选择
GXHT3W温湿度传感器凭借其小巧的体积、高效的数据传输能力和卓越的测量精度，为物联网(IoT)设备和工业自动化系统提供了可靠的温湿度监控解决方案。用户手册作为开发工具，为研发人员提供了全面的技术支持，确保了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值