devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

05-SA8155 QNX I2C框架及代码分析_8155跑qnx系统

作者：小小林熬夜学编程 | 2024-02-17 04:50:26

赞

踩

8155跑qnx系统

1. 描述

本文主要描述QNX I2C Drvier的相关内容，并以SA8155处理器为例讲解。
I2C 是经常用到的一种总线协议，它只占用两个IO口资源，分别是SCL时钟信号线与SDA数据线，
两根线就能将连接与总线上的设备实现数据通信，由于它的简便的构造设计，于是成为一种较为
常用的通信方式。在QNX系统里，也提供了I2C驱动框架，整体框架与SPI类似。

I2C总线数据传输和应答 

2. 目录结构

2.1 QUB配置部分

TODO

请查阅 https://blog.csdn.net/liaochaoyun/article/details/127317225

2.2. 驱动部分：

qnx_ap/AMSS/platform/hwdrivers/wired_peripherals/i2c

├── common
│   ├── aarch64
│   │   ├── a-le
│   │   ├── Makefile
│   │   └── so-le
│   ├── arm
│   │   ├── a-le-v7
│   │   ├── Makefile
│   │   └── so-le-v7
│   ├── common.mk
│   ├── Makefile
│   └── src
│       ├── I2cDeviceQup.c
│       └── I2cSys.c
├── inc
│   ├── ddii2c.h
│   ├── I2cDevice.h
│   ├── I2cError.h
│   ├── I2cTransferCfg.h
│   ├── I2cTransfer.h
│   └── I2cTypes.h
├── Makefile
└── platsvc_i2c
    ├── aarch64
    │   ├── a-le
    │   ├── Makefile
    │   └── so-le
    ├── arm
    │   ├── a-le-v7
    │   ├── Makefile
    │   └── so-le-v7
    ├── common.mk
    ├── inc
    │   ├── I2cLog.h
    │   ├── I2cPlatBam.h
    │   ├── I2cPlatBsp.h
    │   ├── I2cPlatSvc.h
    │   └── I2cSys.h
    ├── Makefile
    └── src
        ├── I2cPlatBsp.c
        └── I2cPlatSvc.c

2.3. 资源管理器Res部分

qnx_ap/AMSS/platform/resources/i2c_drv

├── aarch64
│   ├── a-le
│   │   └── Makefile
│   ├── Makefile
│   ├── so-le
│   │   └── Makefile
│   └── so-le-g
│       └── Makefile
├── arm
│   ├── a-le-v7
│   │   └── Makefile
│   ├── Makefile
│   └── so-le-v7
│       └── Makefile
├── common.mk
├── i2c_drv.c
├── Makefile
└── protected
    └── i2c_devctls.h

2.4  I2C Service(Demo 进程)

qnx_ap/AMSS/platform/services/daemons/i2c_service

├── aarch64
│   ├── Makefile
│   └── o-le
│       └── Makefile
├── arm
│   ├── Makefile
│   └── o-le-v7
│       └── Makefile
├── common.mk
├── Makefile
├── src
│   └── i2cservice_main.c
└── usefile

2.5  I2c API(Client)

qnx_ap/AMSS/platform/qal/clients/i2c_client

├── aarch64
│   ├── Makefile
│   ├── so-le
│   │   └── Makefile
│   └── so-le-g
│       └── Makefile
├── arm
│   ├── Makefile
│   └── so-le-v7
│       └── Makefile
├── common.mk
├── i2c_client.c
├── Makefile
└── public
    └── amss
        └── i2c_client.h

3. I2C API 

qnx_ap/AMSS/platform/qal/clients/i2c_client/public/amss/i2c_client.h

安装：qnx_ap/install/usr/include/amss/i2c_client.h

/*
 * gain access to controller/bus driver
 * Returns a handle that is passed to all other functions.
 * Parameters:
 * (in)        devname        Resource Manager connection(ex. "/dev/i2c1")
 *
 * Returns:
 * >0    success
 * -1     failure
 */
int i2c_open(void* devname);

/*
 * releases access to controller/bus driver
 * Frees memory associated with "fd".
 * Parameters:
 * (in)     fd         Handle returned from init()
 *
 */
void i2c_close(int fd);

/*
 * Specify the bus clock frequency
 * If an invalid bus speed is requested, this function should return
 * failure and leave the bus speed unchanged.
 * Parameters:
 * (in)     addr    The slave address
 * (in)     fmt     The slave address format
 * Returns:
 * 0    success
 * -1   failure
 */
int i2c_set_slave_addr(int fd, uint32_t addr, uint32_t fmt);

/*
 * Specify the bus clock frequency
 * If an invalid bus speed is requested, this function should return
 * failure and leave the bus speed unchanged.
 * Parameters:
 * (in)     bus_clock_freq.
 * Returns:
 * 0    success
 * -1   failure
 */
int i2c_set_bus_speed(int fd, uint32_t speed, uint32_t * ospeed);

/*
 * Lock this I2C controller/bus
 * Parameters:
 * (in)     fd         Handle returned from init()
 * Returns:
 * 0    success
 * -1    failure
 */
int i2c_bus_lock(int fd);

/*
 * Unlock this I2C  controller/bus
 * Parameters:
 * (in)     fd         Handle returned from init()
 * Returns:
 * 0    success
 * -1    failure
 */
int i2c_bus_unlock(int fd);

/*
 * Write
 * Parameters:
 * (in)     fd          Handle returned from init()
 * (in)     buf         Buffer of data to write
 * (in)     len         Length in bytes of buf
 * Returns:
 * Number of bytes read
 */
int i2c_write(int fd, void *buf, uint32_t len);

/*
 * Read
 * Parameters:
 * (in)     fd         Handle returned from init()
 * (in)     buf        Buffer for read data
 * (in)     len        Length in bytes of buf
 * Returns:
 * >=0    Number of bytes read
 * <0    Error # from errno.h
 */
int i2c_read(int fd, void *buf, uint32_t len);

/*
 * Combined Write Read
 * Parameters:
 * (in)     fd          Handle returned from init()
 * (in)     wbuf        Buffer of data to send
 * (in)     wlen        Length in bytes of wbuf
 * (in)        rbuff           Buffer for received data
 * (in)        rlen           Length in bytes of wbuf
 * Returns:
 * >=0    Number of bytes read
 * <0    Error # from errno.h
 */
int i2c_combined_writeread(int fd, void * wbuff, uint32_t wlen, void* rbuff, uint32_t rlen );


/*
 * Request info about the driver.
 * Returns:
 * 0    success
 * -1   failure
 */
int i2c_driver_info(int fd, i2c_driver_info_t *info);

文件引用：#include <amss/i2c_client.h>

4.  I2C 资源管理器设计

4.1 优点

资源管理器接口的主要优点是:

  • 它为应用程序开发人员提供了一个清晰、易于理解的思路。
  • 它作为一个中介，在多个应用程序对一个或多个从设备之间进行访问，强制不同I2C接口之间的一致性。
  • 对于专用的i2c总线应用程序，硬件访问库更有效；硬件接口定义了这个库的接口，有助于维护和代码可移植性。

4.2 通用架构

通用架构如下如：

4.3 代码分析

4.3.1 服务进程

核心文件： qnx_ap/AMSS/platform/services/daemons/i2c_service/src/i2cservice_main.c

  1. int i2c_service_base_init(void)
  2. {
  3.     //调用i2c_drv 资源管理接口实现i2c资源管理器初始化
  4.     if (-1 == i2c_drv_init()) {
  5.         logger_log(QCLOG_AMSS_QNP_SERVICES_I2C_SERVICE, QCLOG_AMSS_I2C_SERVICE_MINOR, 
  6.                    QCLOG_ERROR, "i2c_drv_init Failed");
  7.     }
  8.  
  9.     drop_abilities_i2c();
  10.     /* init sysctrl */
  11.     if(DAL_SUCCESS != sysctrl_init()) {
  12.         logger_log(QCLOG_AMSS_QNP_SERVICES_I2C_SERVICE, QCLOG_AMSS_I2C_SERVICE_MINOR, 
  13.                    QCLOG_ERROR, "sysctrl_init failed, errno: %s", strerror(errno));
  14.         return DAL_ERROR;
  15.     }
  16.  
  17.     return DAL_SUCCESS;
  18. }
  19.  
  20. int main(int argc, char *argv[]) {
  21.  
  22.     int c;
  23.     ...
  24.  
  25.     /* QNX IO operation privilege */
  26.     if (ThreadCtl(_NTO_TCTL_IO, 0) == -1)
  27.     {
  28.         PROCESS_ERROR_CRITICAL("i2c_service: ThreadCtl Error");
  29.         return EXIT_FAILURE;
  30.     }
  31.     
  32.     //信号SIGTERM处理
  33.     signal(SIGTERM,handle_sigterm);
  34.  
  35.     // Check if process is running /dev/i2c_service
  36.     if( 0 < open(DEVICE_NAME, O_RDONLY))
  37.     {
  38.         PROCESS_ERROR_CRITICAL("Process [%s] already running.. exiting.", DEVICE_NAME);
  39.         return EXIT_FAILURE;
  40.     }
  41.  
  42.     // Run process in background，进程后台运行
  43.     Resource_Daemonize();
  44.  
  45.     //资源管理器实现接口
  46.     if(i2c_service_base_init() != DAL_SUCCESS)
  47.     {
  48.         PROCESS_ERROR_CRITICAL("i2c_service: i2c_service_core_init failed");
  49.         return EXIT_FAILURE;
  50.     }
  51.     //启动I2C资源管理器服务
  52.     /* the i2c resource manager main loop is going to run after here */
  53.     if(DAL_SUCCESS != sysctrl_start(DEVICE_NAME)) {
  54.         PROCESS_ERROR_CRITICAL("i2c_service: service_init failed");
  55.         return EXIT_FAILURE;
  56.     }
  57.  
  58.     // Code should never reach here
  59.     PROCESS_ERROR_CRITICAL("Exiting i2c_service..");
  60.     return EXIT_SUCCESS;
  61. }

 查看系统进程：

# pidin | grep i2c
   40982   1 bin/i2c_service     10r RECEIVE     8
   40982   2 bin/i2c_service     15r RECEIVE     2
   40982   3 bin/i2c_service     21r SEM         fff808a056320f94
   40982   4 bin/i2c_service     41r INTR
   40982   5 bin/i2c_service     10r RECEIVE     3
   40982   6 bin/i2c_service     41r INTR
   40982   7 bin/i2c_service     10r RECEIVE     6
   40982   8 bin/i2c_service     41r INTR
   40982   9 bin/i2c_service     10r RECEIVE     11

4.3.2 资源管理器实现

 核心文件：qnx_ap/AMSS/platform/resources/i2c_drv/i2c_drv.c

 入口：

  1. /******************************************************************************/
  2. /***************************** startup and config  ****************************/
  3. /******************************************************************************/
  4.  
  5. int i2c_drv_init(void)
  6. {
  7.     int i;
  8.     int idx = 0;
  9.     int ret = EOK;
  10.     uint64_t chip_id = 0;
  11.     const void *fdt_paddr = 0;
  12.     pthread_t threadID;
  13.     DALSYSPropertyVar PropVar;
  14.  
  15.     DALSYS_PROPERTY_HANDLE_DECLARE(hDALProps);
  16.     DALSYS_InitMod(NULL);
  17.     DALSYS_RegisterMod(&gDALModDriverInfoList);
  18.  
  19.     int policy;
  20.     struct sched_param param;
  21.     pthread_attr_t attr;
  22.  
  23.     if (waitfor_attach(QCORE_SERVICE, 5000))
  24.     {
  25.         I2C_SLOGE("Timed out waiting for %s to be ready", QCORE_SERVICE);
  26.         return -1;
  27.     }
  28.  
  29.     fdt_paddr = fdt_get_root();
  30.     if (!fdt_paddr) {
  31.         I2C_SLOGE("Failed to load device tree");
  32.         return -1;
  33.     }
  34.     ret = fdt_foreach_subnode_byname((void*) fdt_paddr , "/chip_info",
  35.             &get_chip_info, &chip_id);
  36.     if (ret) {
  37.         I2C_SLOGE("Failed to find dt chip_info");
  38.         return -1;
  39.     }
  40.  
  41.     I2C_SLOGI("Found chip id=%d", (int)chip_id);
  42.  
  43.     //线程配置
  44.     pthread_attr_init(&attr);
  45.     pthread_getschedparam(pthread_self(), &policy, &param);
  46.     param.sched_priority = 100;
  47.     pthread_attr_setschedparam(&attr, &param);
  48.  
  49.     devs = calloc(MAX_NUM_I2C_DEVS, sizeof(i2c_dev_t));
  50.     if(devs == NULL)
  51.         return -1;
  52.  
  53.     //创建设备
  54.     // create devices , if specified via command line
  55.     for(i = 0; i < MAX_NUM_I2C_DEVS; i++)
  56.     {
  57.         if(DALSYS_GetDALPropertyHandle(DeviceID[i], hDALProps) == DAL_SUCCESS)
  58.         {
  59.             //解析I2C配置，详情看QUP-I2C配置项
  60.             if (DAL_SUCCESS != DALSYS_GetPropertyValue(hDALProps, "I2C_ENABLED", 0, &PropVar)
  61.                     || PropVar.Val.dwVal == 0)
  62.             {
  63.                 continue;
  64.             }
  65.  
  66.             if (DAL_SUCCESS != DALSYS_GetPropertyValue(hDALProps, "CLOCK_SE_NAME", 0, &PropVar)
  67.                     || PropVar.Val.pszVal == 0)
  68.             {
  69.                 I2C_SLOGE("Failed to get property CLOCK_SE_NAME");
  70.                 return -1;
  71.             }
  72.  
  73.             if (!strncmp(PropVar.Val.pszVal, "scc", 3)) {
  74.                 devs[idx].is_ssc = true;
  75.             }
  76.             
  77.             //设备编号，名称等
  78.             snprintf(devs[idx].devname, MAX_NUM_DEVNAME, "/dev/i2c%d", i+1);
  79.             devs[idx].DALDeviceID = DeviceID[i];
  80.             devs[idx].index = idx;
  81.             devs[idx].bus_active = 0;
  82.             devs[idx].timer_created = 0;
  83.  
  84.             //QUP I2C设备初始化
  85.             if (DAL_SUCCESS != I2CDEV_Init(DeviceID[i], &devs[idx].ahI2cDev)) {
  86.                I2C_SLOGE("Failed to initialize I2C %s", devs[idx].devname);
  87.                continue;
  88.             }
  89.             devs[idx].initialized = 1;
  90.  
  91.             //通过线程创建设备，资源管理器及接口。
  92.             ret = pthread_create(&threadID, NULL, (void *)&device_main,
  93.                     (void *)&devs[idx]);
  94.             if (EOK == ret) {
  95.                 pthread_setname_np(threadID, devs[idx].devname);
  96.                 idx++;
  97.             } else {
  98.                 I2C_SLOGE("Couldn't create RM thread for device-%d:"
  99.                           "name-%s:ret-%d",
  100.                           DeviceID[i], devs[idx].devname, ret);
  101.             }
  102.         }
  103.     }
  104.  
  105.     if (ID_6155 == chip_id) {
  106.         if ((ret = i2c_register_ssr())) {
  107.             I2C_SLOGE("Failed to register for SSR ret=%x", ret);
  108.             return -1;
  109.         }
  110.     }
  111.  
  112.     return 0;
  113. }

 资源管理器创建通用步骤：

  1. 建立一个上下文切换句柄dpp = dispatch_create();这个东东主要用在mainloop中产生一个block特性，可以让我们等待接受消息；
  2. iofunc初始化。这一步是将自己实现的函数与POSIX层函数进行接口，解析从read、write、devctl等函数传来的消息进行解析，以实现底层与应用层函数之间的交互，通过io_funcs.read = io_read，io_funcs.write = io_write，进行函数重载；
  3. 注册设备名，使设备在命名空间中产生相应的名称，这一点是整个过程的关键了，形如 pathID = resmgr_attach (dpp, &rattr, "/dev/Null",_FTYPE_ANY, 0, &connect_funcs,&io_funcs, &ioattr)，这样不仅注册了一个设备名，还让系统知道了我们实习的IO函数对应关系；
  4. 为之前创建的上下文句柄分配空间，例如ctp = dispatch_context_alloc (dpp);为了第六步使用；
  5. 通过不断循环等待dispatch_block()来调用MsgReceive()使Resource manger处于receive block状态，以接收上层发送来的消息，通过dispatch_handler (ctp)去调用我们自己定义的IO函数

 资源管理器创建实现：

 

  1.  
  2. int device_main(i2c_dev_t *dev)
  3. {
  4.     resmgr_connect_funcs_t  connect_funcs;
  5.     resmgr_io_funcs_t   io_funcs;
  6.     resmgr_attr_t       rattr;
  7.     iofunc_funcs_t      ocb_funcs = { _IOFUNC_NFUNCS, _ocb_calloc, _ocb_free,
  8.                                        NULL, NULL, NULL };
  9.     iofunc_mount_t      mount = { 0, IOFUNC_PC_ACL, 0, 0, &ocb_funcs };
  10.     I2CDEV_PowerStates  power_state = 0;
  11.     pthread_condattr_t cond_attr = { 0 };
  12.  
  13.     /* Set up contiguous buffers */
  14.     dev->fd_mmap = posix_typed_mem_open("/ram/dma",
  15.                                         O_RDWR,
  16.                                         POSIX_TYPED_MEM_ALLOCATE_CONTIG);
  17.     if (dev->fd_mmap == -1) {
  18.         I2C_SLOGE("%s: posix_typed_mem_open(/ram/dma) failed(%d-%s)",
  19.                   __FUNCTION__, errno, strerror(errno));
  20.         exit(1);
  21.     }
  22.  
  23.     /* Configure clocks, gpios at init-time*/
  24.     I2CDEV_GetPowerState(dev->ahI2cDev, &power_state);
  25.     if (POWER_STATE_2 != power_state) {
  26.         I2CDEV_SetPowerState(dev->ahI2cDev , POWER_STATE_2);
  27.         dev->bus_active = 1;
  28.     }
  29.  
  30.     pthread_mutex_init(&dev->mutex, NULL);
  31.  
  32.     pthread_condattr_init(&cond_attr);
  33.     pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC);
  34.     pthread_cond_init(&dev->cond, &cond_attr);
  35.  
  36.     //创建channel
  37.     dev->chid = ChannelCreate(_NTO_CHF_DISCONNECT | _NTO_CHF_UNBLOCK);
  38.     if(dev->chid == -1) {
  39.         I2C_SLOGE("ChannelCreate failed (%s)", strerror(errno));
  40.         exit (1);
  41.     }
  42.  
  43.     //第一步
  44.     /*
  45.      * allocate and initialize a dispatch structure for use by our
  46.      * main loop
  47.      */
  48.     I2C_SLOGI("initializing %s\n",dev->devname);
  49.     dev->dpp = dispatch_create_channel ( dev->chid, 0);
  50.     if (dev->dpp == NULL)
  51.     {
  52.         I2C_SLOGE("couldn't dispatch_create: %s\n",strerror(errno));
  53.         exit (1);
  54.     }
  55.  
  56.  
  57.     /*
  58.      * set up the resource manager attributes structure, we'll
  59.      * use this as a way of passing information to resmgr_attach().
  60.      * For now, we just use defaults.
  61.      */
  62.  
  63.     memset (&rattr, 0, sizeof (rattr)); /* using the defaults for rattr */
  64.     rattr.nparts_max = 2; /* Max iov used by client is 2 */
  65.     rattr.msg_max_size = MAX_NUM_I2C_WRITE;
  66.  
  67.     //第二步 iofunc初始化
  68.     /*
  69.      * intialize the connect functions and I/O functions tables to
  70.      * their defaults by calling iofunc_func_init().
  71.      *
  72.      * connect_funcs, and io_funcs variables are already declared.
  73.      *
  74.      */
  75.     iofunc_func_init (_RESMGR_CONNECT_NFUNCS, &connect_funcs,
  76.             _RESMGR_IO_NFUNCS, &io_funcs);
  77.  
  78.     /* over-ride the connect_funcs handler for open with our io_open,
  79.      * and over-ride the io_funcs handlers for read and write with our
  80.      * io_read and io_write handlers
  81.      */
  82.     connect_funcs.open = io_open;
  83.     io_funcs.devctl = io_devctl;
  84.     io_funcs.acl = io_acl;
  85.     io_funcs.close_ocb = io_close;
  86.  
  87.     /* initialize our device description structure
  88.     */
  89.  
  90.     iofunc_attr_init (&dev->hdr, S_IFCHR | 0666, NULL, NULL);
  91.  
  92.     dev->hdr.mount = &mount;   // so we can alloc an OCB per open
  93.  
  94.     iofunc_acl_init(&dev->hdr, iofunc_acl_posix_ctrl, 0);
  95.  
  96.     //第三步 注册设备
  97.     /*
  98.      *  call resmgr_attach to register our prefix with the
  99.      *  process manager, and also to let it know about our connect
  100.      *  and I/O functions.
  101.      *
  102.      *  On error, returns -1 and errno is set.
  103.      */
  104.     dev->pathID = resmgr_attach(dev->dpp,
  105.                                 &rattr,
  106.                                 dev->devname,
  107.                                 _FTYPE_ANY,
  108.                                 0,
  109.                                 &connect_funcs,
  110.                                 &io_funcs,
  111.                                 (RESMGR_HANDLE_T *)dev);
  112.     if (dev->pathID == -1)
  113.     {
  114.         I2C_SLOGE(" couldn't attach pathname: %s\n", strerror (errno));
  115.         exit (1);
  116.     }
  117.  
  118.     //第四步 为dpp分配句柄空间
  119.     dispatch_context_t *ctp;
  120.     dev->ctp = dispatch_context_alloc(dev->dpp);
  121.     if (dev->ctp == NULL)
  122.     {
  123.         dispatch_destroy(dev->dpp);
  124.         return EXIT_FAILURE;
  125.     }
  126.  
  127.     /* Notify bmetrics I2C device is ready */
  128.     int fd = open("/dev/bmetrics", O_WRONLY);
  129.     if (fd == -1) {
  130.         I2C_SLOGE("Failed to open /dev/bmetrics with error:%d\n", errno);
  131.     } else {
  132.         char buf[BM_KPI_BUF_SIZE];
  133.         snprintf(buf, BM_KPI_BUF_SIZE, "bootmarker DRIVER I2C Ready:%s\n",
  134.                 dev->devname);
  135.         if (-1 == write(fd, buf, strlen(buf))) {
  136.             I2C_SLOGE("Failed to write /dev/bmetrics with error:%d\n", errno);
  137.         }
  138.         close(fd);
  139.     }
  140.  
  141.     /* register LPM pulses */
  142.     if (EOK != i2c_register_pulse(dev)) {
  143.         I2C_SLOGE("pulse registration for %s failed", dev->devname);
  144.         exit(1);
  145.     }
  146.  
  147.     /* register SSR pulses */
  148.     dev->ssr_coid = ConnectAttach(ND_LOCAL_NODE, 0 /* pid */,
  149.                                   dev->chid, _NTO_SIDE_CHANNEL, 0);
  150.     if (-1 == dev->ssr_coid) {
  151.         I2C_SLOGE("I2C_RM SSR ConnectAttach failed (%s)", strerror(errno));
  152.         exit(1);
  153.     }
  154.  
  155.     I2C_SLOGE("Initialized %s", dev->devname);
  156.  
  157.     //第五步 通过不断循环等待dispatch_block()来调用MsgReceive()使Resource manger处于receive block状态，以接收上层发送来的消息，通过dispatch_handler (ctp)去调用我们自己定义的IO函数
  158.     while(1) {
  159.         if ((ctp = dispatch_block(dev->ctp)) == NULL) {
  160.             I2C_SLOGE("dispatch_block failed");
  161.             exit(1);
  162.         }
  163.         dispatch_handler(dev->ctp);
  164.     }
  165.  
  166.     return 0;
  167. }

4.4 API与资源管理器之间的关联 

4.4.1 标准框架如下：

4.4.2 具体实现

 TODO

拿devctl为例： 

 

5. 梳理

6. 案例

TODO

//伪代码如下

  1. #include <amss/i2c_client.h>
  2.  
  3. #define DEV_NAME "/dev/i2c_1"
  4.  
  5. int fd = -1;
  6. int slaveAddr = 0xAA;
  7.  
  8. main()
  9. {
  10.     unsigned char writedata[3];
  11. 	writedata[0] = 0x11;
  12. 	writedata[1] = 0x22;
  13. 	writedata[2] = 0x22;
  14.  
  15.     fd = i2c_open(DEV_NAME );
  16.     i2c_bus_lock ( fd );
  17.     i2c_set_slave_addr(fd, slaveAddr, 0))
  18.     i2c_write(fd, writedata, sizeof(writedata));
  19. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/100186
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号