i2c驱动APP

最新推荐文章于 2024-07-14 21:53:39 发布
最新推荐文章于 2024-07-14 21:53:39 发布
阅读量288 收藏
点赞数
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68847733/article/details/124427224
版权

一.查看i2c源代码

24cXX.h

/**************************************************************************

 copyright : (C) by 2003-2004 Stefano Barbato

 email : stefano@codesink.org

   $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $

 ***************************************************************************/

 

/***************************************************************************

 * *

 * 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. *

 * *

 ***************************************************************************/

#ifndef _24CXX_H_

#define _24CXX_H_

#include <linux/i2c-dev.h>

#include <linux/i2c.h>

#define EEPROM_TYPE_UNKNOWN 0

#define EEPROM_TYPE_8BIT_ADDR 1

#define EEPROM_TYPE_16BIT_ADDR 2

struct eeprom

{

 char *dev; // device file i.e. /dev/i2c-N

 int addr; // i2c address

 int fd; // file descriptor

 int type; // eeprom type

};

/*

 * opens the eeprom device at [dev_fqn] (i.e. /dev/i2c-N) whose address is

 * [addr] and set the eeprom_24c32 [e]

 */

int eeprom_open(char *dev_fqn, int addr, int type, struct eeprom*);

/*

 * closees the eeprom device [e] 

 */

int eeprom_close(struct eeprom *eeprom_device_struct);

/*

 * read and returns the eeprom byte at memory address [mem_addr] 

 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 

 */

int eeprom_read_byte(struct eeprom* eeprom_device_struct, __u16 mem_addr);

/*

 * read the current byte

 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 

 */

int eeprom_read_current_byte(struct eeprom *eeprom_device_struct);

/*

 * writes [data] at memory address [mem_addr] 

 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 

 */

int eeprom_write_byte(struct eeprom *eeprom_device_struct, __u16 mem_addr, __u8 data);

#endif

24cXX.c

/***************************************************************************

    copyright : (C) by 2003-2004 Stefano Barbato

    email : stefano@codesink.org

 

    $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $

 

 * 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. *

 * *

 ***************************************************************************/

 

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdlib.h>

#include <linux/fs.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <errno.h>

#include <assert.h>

#include <string.h>

#include "24cXX.h"

 

 

static inline __s32 i2c_smbus_access(int file, 

    char read_write, 

    __u8 command,                                  

    int size, 

    union i2c_smbus_data *data)

{

 struct i2c_smbus_ioctl_data args;

 

 args.read_write = read_write;

 args.command = command;

 args.size = size;

 args.data = data;

 return ioctl(file,I2C_SMBUS,&args);

}

 

 

static inline __s32 i2c_smbus_write_quick(int file, __u8 value)

{

 return i2c_smbus_access(file,value,0,I2C_SMBUS_QUICK,NULL);

}

 

static inline __s32 i2c_smbus_read_byte(int file)

{

 union i2c_smbus_data data;

 if (i2c_smbus_access(file,I2C_SMBUS_READ,0,I2C_SMBUS_BYTE,&data))

  return -1;

 else

  return 0x0FF & data.byte;

}

 

static inline __s32 i2c_smbus_write_byte(int file, __u8 value)

{

 return i2c_smbus_access(file,I2C_SMBUS_WRITE,value,

                         I2C_SMBUS_BYTE,NULL);

}

 

static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command)

{

 union i2c_smbus_data data;

 if (i2c_smbus_access(file,I2C_SMBUS_READ,command,

                      I2C_SMBUS_BYTE_DATA,&data))

  return -1;

 else

  return 0x0FF & data.byte;

}

 

static inline __s32 i2c_smbus_write_byte_data(int file, __u8 command, 

                                              __u8 value)

{

 union i2c_smbus_data data;

 data.byte = value;

 return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,

                         I2C_SMBUS_BYTE_DATA, &data);

}

 

static inline __s32 i2c_smbus_read_word_data(int file, __u8 command)

{

 union i2c_smbus_data data;

 if (i2c_smbus_access(file,I2C_SMBUS_READ,command,

                      I2C_SMBUS_WORD_DATA,&data))

  return -1;

 else

  return 0x0FFFF & data.word;

}

 

static inline __s32 i2c_smbus_write_word_data(int file, __u8 command, 

                                              __u16 value)

{

 union i2c_smbus_data data;

 data.word = value;

 return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,

                         I2C_SMBUS_WORD_DATA, &data);

}

 

static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value)

{

 union i2c_smbus_data data;

 data.word = value;

 if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,

                      I2C_SMBUS_PROC_CALL,&data))

  return -1;

 else

  return 0x0FFFF & data.word;

}

 

 

/* Returns the number of read bytes */

static inline __s32 i2c_smbus_read_block_data(int file, __u8 command, 

                                              __u8 *values)

{

 union i2c_smbus_data data;

 int i;

 if (i2c_smbus_access(file,I2C_SMBUS_READ,command,

                      I2C_SMBUS_BLOCK_DATA,&data))

  return -1;

 else {

  for (i = 1; i <= data.block[0]; i++)

   values[i-1] = data.block[i];

  return data.block[0];

 }

}

 

static inline __s32 i2c_smbus_write_block_data(int file, __u8 command, 

                                               __u8 length, __u8 *values)

{

 union i2c_smbus_data data;

 int order;

 if (length > 32)

  length = 32;

 for (order = 1; order <= length; order++)

  data.block[order] = values[order-1];

 data.block[0] = length;

 return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,

                         I2C_SMBUS_BLOCK_DATA, &data);

}

 

/* Returns the number of read bytes */

static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command,

                                                  __u8 *values)

{

 union i2c_smbus_data data;

 int order;

 if (i2c_smbus_access(file,I2C_SMBUS_READ,command,

                       I2C_SMBUS_I2C_BLOCK_DATA,&data))

  return -1;

 else {

  for (order = 1; order <= data.block[0]; order++)

   values[order-1] = data.block[order];

  return data.block[0];

 }

}

 

static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command,

                                               __u8 length, __u8 *values)

{

 union i2c_smbus_data data;

 int order;

 if (length > 32)

  length = 32;

 for (order = 1; order <= length; order++)

  data.block[order] = values[order-1];

 data.block[0] = length;

 return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,

                         I2C_SMBUS_I2C_BLOCK_DATA, &data);

}

 

/* Returns the number of read bytes */

static inline __s32 i2c_smbus_block_process_call(int file, __u8 command,

                                                 __u8 length, __u8 *values)

{

 union i2c_smbus_data data;

 int order;

 if (length > 32)

  length = 32;

 for (order = 1; order <= length; order++)

  data.block[order] = values[order-1];

 data.block[0] = length;

 if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,

                      I2C_SMBUS_BLOCK_PROC_CALL,&data))

  return -1;

 else {

  for (order = 1; order <= data.block[0]; order++)

   values[order-1] = data.block[order];

  return data.block[0];

 }

}

 

static int i2c_write_1b(struct eeprom *eeprom_device_struct, __u8 buf)

{

 int return_value;

 // we must simulate a plain I2C byte write with SMBus functions

 return_value = i2c_smbus_write_byte(eeprom_device_struct->fd, buf);

 if(return_value < 0)

  fprintf(stderr, "Error i2c_write_1b: %s\n", strerror(errno));

 usleep(10);

 return return_value;

}

 

static int i2c_write_2b(struct eeprom *eeprom_device_struct, __u8 buf[2])

{

 int return_value;

 // we must simulate a plain I2C byte write with SMBus functions

 return_value = i2c_smbus_write_byte_data(eeprom_device_struct->fd, buf[0], buf[1]);

 if(return_value < 0)

  fprintf(stderr, "Error i2c_write_2b: %s\n", strerror(errno));

 usleep(10);

 return return_value;

}

 

static int i2c_write_3b(struct eeprom *eeprom_device_struct, __u8 buf[3])

{

 int return_value;

 // we must simulate a plain I2C byte write with SMBus functions

 // the __u16 data field will be byte swapped by the SMBus protocol

 return_value = i2c_smbus_write_word_data(eeprom_device_struct->fd, buf[0], buf[2] << 8 | buf[1]);

 if(return_value < 0)

  fprintf(stderr, "Error i2c_write_3b: %s\n", strerror(errno));

 usleep(10);

 return return_value;

}

 

 

#define CHECK_I2C_FUNC( var, label ) \

 do { if(0 == (var & label)) { \

  fprintf(stderr, "\nError: " \

   #label " function is required. Program halted.\n\n"); \

  exit(1); } \

 } while(0);

 

int eeprom_open(char *dev_fqn, int addr, int type, struct eeprom* eeprom_device_struct)

{

 int funcs, fd, return_value;

 eeprom_device_struct->fd = eeprom_device_struct->addr = 0;

 eeprom_device_struct->dev = 0;

 

 fd = open(dev_fqn, O_RDWR);

 if(fd <= 0)

 {

  fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));

  return -1;

 }

 

 // get funcs list

 if((return_value = ioctl(fd, I2C_FUNCS, &funcs) < 0))

 {

  fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));

  return -1;

 }

 

 

 // check for req funcs

 CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_BYTE );

 CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_BYTE );

 CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_BYTE_DATA );

 CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_BYTE_DATA );

 CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_WORD_DATA );

 CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_WORD_DATA );

 

 // set working device

 if( ( return_value = ioctl(fd, I2C_SLAVE, addr)) < 0)

 {

  fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));

  return -1;

 }

 eeprom_device_struct->fd = fd;

 eeprom_device_struct->addr = addr;

 eeprom_device_struct->dev = dev_fqn;

 eeprom_device_struct->type = type;

 return 0;

}

 

int eeprom_close(struct eeprom *eeprom_device_struct)

{

 close(eeprom_device_struct->fd);

 eeprom_device_struct->fd = -1;

 eeprom_device_struct->dev = 0;

 eeprom_device_struct->type = EEPROM_TYPE_UNKNOWN;

 return 0;

}

 

#if 0

int eeprom_24c32_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data)

{

 __u8 buf[3] = { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };

 return i2c_write_3b(e, buf);

}

 

 

int eeprom_24c32_read_current_byte(struct eeprom* e)

{

 ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer

 return i2c_smbus_read_byte(e->fd);

}

 

int eeprom_24c32_read_byte(struct eeprom* e, __u16 mem_addr)

{

 int r;

 ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer

 __u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };

 r = i2c_write_2b(e, buf);

 if (r < 0)

  return r;

 r = i2c_smbus_read_byte(e->fd);

 return r;

}

#endif

 

 

int eeprom_read_current_byte(struct eeprom* eeprom_device_struct)

{

 ioctl(eeprom_device_struct->fd, BLKFLSBUF); // clear kernel read buffer

 return i2c_smbus_read_byte(eeprom_device_struct->fd);

}

 

int eeprom_read_byte(struct eeprom* eeprom_device_struct, __u16 mem_addr)

{

 int return_value;

 ioctl(eeprom_device_struct->fd, BLKFLSBUF); // clear kernel read buffer

 if(eeprom_device_struct->type == EEPROM_TYPE_8BIT_ADDR)

 {

  __u8 buf = mem_addr & 0x0ff;

  return_value = i2c_write_1b(eeprom_device_struct, buf);

 } else if(eeprom_device_struct->type == EEPROM_TYPE_16BIT_ADDR) {

  __u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };

  return_value = i2c_write_2b(eeprom_device_struct, buf);

 } else {

  fprintf(stderr, "ERR: unknown eeprom type\n");

  return -1;

 }

 if (return_value < 0)

  return return_value;

 return_value = i2c_smbus_read_byte(eeprom_device_struct->fd);

 return return_value;

}

 

int eeprom_write_byte(struct eeprom *eeprom_device_struct, __u16 mem_addr, __u8 data)

{

 if(eeprom_device_struct->type == EEPROM_TYPE_8BIT_ADDR) {

  __u8 buf[2] = { mem_addr & 0x00ff, data };

  return i2c_write_2b(eeprom_device_struct, buf);

 } else if(eeprom_device_struct->type == EEPROM_TYPE_16BIT_ADDR) {

  __u8 buf[3] = 

   { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };

  return i2c_write_3b(eeprom_device_struct, buf);

 } 

 fprintf(stderr, "ERR: unknown eeprom type\n");

 return -1;

}

eeprog.c

/***************************************************************************

    copyright : (C) by 2009 Guangzhou FriendlyaRM, in China

    email : capbily@163.com

    website : arm9.net

 ***************************************************************************/

 

#include <stdio.h>

#include <fcntl.h>

#include <getopt.h>

#include <unistd.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "24cXX.h"

 

#define DEVICE_FILE_STRING "/dev/i2c-0"

#define DEVICE_ADDRESS 0x50

 

#define usage_if(a) do { do_usage_if( a , __LINE__); } while(0);

void do_usage_if(int b, int line) {

 const static char *eeprog_usage = 

  "I2C-24C08(256 bytes) Read/Write Program, ONLY FOR TEST!\n"

  "FriendlyARM Computer Tech. 2009\n";

 if(!b)

  return;

 fprintf(stderr, "%s\n[line %d]\n", eeprog_usage, line);

 exit(1);

}

 

 

#define die_if(a, msg) do { do_die_if( a , msg, __LINE__); } while(0);

void do_die_if(int b, char* msg, int line) {

 if(!b)

  return;

 fprintf(stderr, "Error at line %d: %s\n", line, msg);

 fprintf(stderr, " sysmsg: %s\n", strerror(errno));

 exit(1);

}

 

 

static int read_from_eeprom(struct eeprom *eeprom_device_struct, int addr, int size) {

 int ch, index;

 for(index = 0; index < size; ++index, ++addr) {

  die_if((ch = eeprom_read_byte(eeprom_device_struct, addr)) < 0, "read error");

  if( (index % 16) == 0 ) 

   printf("\n %.4x| ", addr);

  else if( (index % 8) == 0 ) 

   printf(" ");

  printf("%.2x ", ch);

  fflush(stdout);

 }

 fprintf(stderr, "\n\n");

 return 0;

}

 

static int write_to_eeprom(struct eeprom *eeprom_device_struct, int addr) {

 int index;

 for(index=0, addr=0; index<256; index++, addr++) {

  if( (index % 16) == 0 ) 

   printf("\n %.4x| ", addr);

  else if( (index % 8) == 0 ) 

   printf(" ");

  printf("%.2x ", index);

  fflush(stdout);

  die_if(eeprom_write_byte(eeprom_device_struct, addr, index), "write error");

 }

 fprintf(stderr, "\n\n");

 return 0;

}

 

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

 struct eeprom eeprom_device_struct;

 int op;

 

 op = 0;

 

 usage_if(argc != 2 || argv[1][0] != '-' || argv[1][2] != '\0');

 op = argv[1][1];

 

 //TODO: 将数字改为自己的学号。

 write(STDOUT_FILENO, "APP for 201930310056 ...\n", strlen("APP for 201930310056 ...\n"));

 fprintf(stderr, "Open %s with 8bit mode\n", DEVICE_FILE_STRING);

 die_if(eeprom_open(DEVICE_FILE_STRING, DEVICE_ADDRESS, EEPROM_TYPE_8BIT_ADDR, &eeprom_device_struct) < 0,

   "unable to open eeprom device file "

   "(check that the file exists and that it's readable)");

 switch(op) {

 case 'r':

  fprintf(stderr, " Reading 256 bytes from 0x0\n");

  read_from_eeprom(&eeprom_device_struct, 0, 256);

  break;

 case 'w':

  fprintf(stderr, " Writing 0x00-0xff into 24C08 \n");

  write_to_eeprom(&eeprom_device_struct, 0);

  break;

 default:

  usage_if(1);

  exit(1);

 }

 eeprom_close(&eeprom_device_struct);

 

 return 0;

}

二、编译

在 i2c 目录

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_16,color_FFFFFF,t_70,g_se,x_16

 三.思考题

1.i2c总线的优点？

（1）I2C总线最主要的优点是其简单性和有效性。由于接口直接在组件之上，因此I2C总线占用的空间非常小，减少了电路板的空间和芯片管脚的数量，降低了互联成本。

（2）它只需数据（SDA）和时钟（SCL）两根总线就可以支持主设备与多个从设备之间进行通信。

（3）I2C总线具有极低的电流消耗，抗噪声干扰能力强，可兼容不同电压等级的器件，工作温度范围宽。

2. I2C总线的启动信号和结束信号有什么特点。

• 启动：在时钟线SCL保持高电平期间，数据线SDA上的电平被拉低（即负跳变），定义为I2C总线总线的启动信号，它标志着一次数据传输的开始。启动信号是一种电平跳变时序信号，而不是一个电平信号。启动信号是由主控器主动建立的，在建立该信号之前I2C总线必须处于空闲状态。

• 结束：在时钟线SCL保持高电平期间，数据线SDA被释放，使得SDA返回高电平（即正跳变），称为I2C总线的停止信号，它标志着一次数据传输的终止。停止信号也是一种电平跳变时序信号，而不是一个电平信号，停止信号也是由主控器主动建立的，建立该信号之后，I2C总线将返回空闲状态。

四、提高项

使用 ${CROSS_COMPILE}gcc 编译各个程序

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_9,color_FFFFFF,t_70,g_se,x_16

 

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_20,color_FFFFFF,t_70,g_se,x_16

在开发板内 mount nfs,并运行各个程序

1)在主机根目录建立 /nfs 并更改权限

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_20,color_FFFFFF,t_70,g_se,x_162)添加目录到共享 

sudo vim /etc/export

添加代码

/nfs * (rw,async,wde

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_20,color_FFFFFF,t_70,g_se,x_16

 3)启动 nfs 服务

/usr/sbin/exportfs -a

service nfs-kernel-server restart

service nfs-kernel-server status

2.登陆开发板

~/ubuntu-18.04_imx6ul_qemu_system/qemu-imx6ull-nogui.sh ##不调用gui的启动，资源占用少

3. mount nfs

将主机已经设定好的共享目录 /nfs 挂载(mount)到开发板的 /root/mnt 目录下

mount -t nfs -o nolock 10.0.2.2:/nfs /root/mnt ##10.0.2.2是开发板默认给主机分配的 ip

4.如果之前已经编译好的话直接运行 i2c 程序

./i2c -w

./i2c -r

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_19,color_FFFFFF,t_70,g_se,x_16

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQXVnZW5zdGVybsK3S1VO,size_10,color_FFFFFF,t_70,g_se,x_16 

 

 

 

Han·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
(二十)linux中i2c的ioctl,write,read函数的使用
weixin_30460489的博客
01-20 1058
一、ioctl函数的使用:原型：structioctl(struct file *file,unsigned int cmd,unsigned long arg);cmd有I2C_SLAVE,I2C_SLAVE_FORCE,I2C_TENBIT,I2C_S3C2410_SET_SPEED几个选项；I2C_SLAVE：对应的arg取值为I2C从机地址，用来设定I2C从机地址； I2C_SLA...
Linux驱动之i2c用户态函数调用
晨海的博客
03-24 2704
原文链接：https://blog.csdn.net/wnn_0919/article/details/80526509?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task ...
1. I2C 协议
10-09 1806
r = ioctl(fd, I2C_FUNCS, &funcs)是查看其功能，它最终调用algo通信方式中的functionality（）函数 r = ioctl(fd, I2C_SLAVE, addr)这个函数设置要通信的从设备地址，如下： case I2C_SLAVE:
嵌入式linux应用读写i2c示例
锅锅的博客
09-19 1414
这里分享一个嵌入式linux读写24c02的i2c程序 ioctl函数的使用: 原型：struct ioctl(struct file *file,unsigned int cmd,unsigned long arg); cmd有I2C_SLAVE,I2C_SLAVE_FORCE,I2C_TENBIT,I2C_SET_SPEED几个选项； I2C_SLAVE：对应的arg取值为I2C从机地址，用来设定I2C从机地址； I2C_SLAVE_FORCE：对应的arg取值为I2C从机地址，用来修改I2C从机地址；
Linux设备驱动之——I2C总线
热门推荐
博学而笃志，切问而近思
04-23 2万+
2  I2C子系统 2.1 LinuxI2C子系统架构 在内核中已经提供I2C子系统，所以在做I2C驱动之前，就必须要熟悉该子系统。 2.2 三大组成部分 1、I2C核心(i2c-core) I2C核心提供了I2C总线驱动和设备驱动的注册、注销方法，I2C通信方法(algorithm)上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。   2、I2C总线驱
i2c驱动app
cerry_world的博客
04-24 250
I2C介绍 I2C即Inter IC，由Philips公司开发，是当今电子设计中应用非常广泛的串行总线之一，主要用于电压、温度监控，EEPROM(电可擦可编程只读存储器)数据的读写，光模块的管理等。I2C总线只有两根线，SCL和SDA，SCL即Serial Clock，串行时钟，SDA即Serial Data，串行数据。 查看i2c代码 code 24cXX.c eeprog.c 24cXX.h /******************************************************
基于嵌入式系统的I2C驱动编写及测试
08-10
基于嵌入式系统的I2C驱动编写及测试 在嵌入式系统中，I2C（Inter-Integrated Circuit）是一种常用的总线协议，用于连接微控制器、感知器、显示器等外围设备。今天，我们将通过一个基于I2C总线的温度传感器驱动的...
安卓 I2C JNI及测试 DEMO AS 源码
03-28
- DTS配置：Device Tree Source（DTS）文件用于描述硬件结构，应确保DTS中没有预定义的I2C从设备地址，以免与内核中的I2C驱动冲突。 6. **调试与优化** - 在Android设备上运行测试程序，检查日志输出，定位可能...
1848-I2C测试程序
05-09
接着，我们需要编写一个I2C驱动程序，这个程序通常在主机控制器（如Arduino、Raspberry Pi或嵌入式微处理器）上运行，用于初始化I2C接口，设置合适的时钟速度，并找到1848芯片的地址。 测试程序的核心是读写1848...
firefly-rk3288j开发板--linux I2C实验之eeprom驱动，包含驱动源码、测试app
06-10
适用用于linux内核驱动学习，参考
pcf8563_i2c1_r8_ruoge_ov2640通过给RTC驱动增加设备节点读取秒钟成功+直接读取I2C1获取秒钟值20160626_2201.7z
06-26
pcf8563_i2c1_r8_ruoge_ov2640通过给RTC驱动增加设备节点读取秒钟成功+直接读取I2C1获取秒钟值20160626_2201.7z http://blog.csdn.net/21cnbao/article/details/7919055 在Android源码树中添加userspace I2C读写...
linux内核__force,Linux内核学习：I2C_SLAVE_FORCE
weixin_39737317的博客
04-30 209
在Linux内核源代码include/linux/i2c-dev.h文件内，有如下定义：#define I2C_SLAVE0x0703/* Use this slave address */#define I2C_SLAVE_FORCE0x0706/* Use this slave address, even if itis already in use by a driver! */看注释，意思...
im6x板Linux应用层I2C通信
↓
08-01 554
驱动给应用层提供了open、read、write、ioctl等函数来实现对底层硬件的控制，前三个参数相比其他设备比如uart、spi等使用方法都一样，主要的不同在ioctl里。 /* i2c_dev.h */ /* ioctl函数参数 */ #define I2C_SLAVE 0x0703 /* Use this slave address */ #define I2C_SLAVE_FOR...
I2C知识大全系列六 —— I2C应用之Linux下的I2C
phmatthaus的专栏
10-24 4078
本文是I2C知识大全系列文章的第六篇，介绍了Linux下的I2C应用。
海思平台通过write/read调用直接读写I2C设备节点
jzwjzw19900922的博客
05-11 1904
1. 打开I2C总线对应的设备文件，获取文件描述符 fd = open("/dev/i2c-0",O_RDWR); 2. 通过ioctl设置外围设备地址、外围设备寄存器位宽和数据位宽 ret = ioctl(fd, I2C_SLAVE_FORCE, device_addr); ioctl(fd, I2C_16BIT_REG, 0); ioctl(fd, I2C_16BIT_DATA, 0); 注：ioctl的第三个参数为0表示8bit位宽，为1表示16bit位宽； ...
i o 设备在linux中被当作啥文件,【SoC FPGA学习】十四、基于 Linux 标准文件 I/O 的设备读写...
weixin_39541044的博客
04-30 94
ssize_t write(int fd, const void *buf, size_t count);操作成功，返回实际写入的字节数，出错则返回-1， 同时设置全局变量 errno 报告具体错误的原因，比如 errno=ENOSPC 表示磁盘满了。参数 fd 是打开文件的描述符， buf 是数据缓冲区， 存放着准备写入文件的数据， count 是请求写入的字节数。实际写入的字节数可以小于请求写...
Zynq-Linux移植学习笔记之43-linux下应用读写I2C设备
无知的我
10-23 1708
在读写I2C设备时，由于I2C地址分为7bit和10bit，读写时序存在区别，因此应用程序也存在区别。 首先来看读写时序对比，这里以写为例： 可以看出从设备地址分成了两次进行传输。 于是应用程序可以这样修改。 首先是7位模式下对某设备寄存器的读写： #include <sys/types.h> #include <sys/stat.h> #inclu...
接着探索Linux的世界 -- 基本指令（文件查看、时间相关、打包压缩等等）
最新发布
weixin_73359101的博客
07-14 1679
命令输出到某个指定文件中，而不是输出到终端屏幕或终端窗口。我们从键盘输入什么，cat命令就打印什么。命令 + >> + 目标文件名。： 将命令的结果写入目标文件中；这两条指令的作用等价。
esp32 I2S 驱动
07-29
对于ESP32的I2S驱动，你可以使用ESP-IDF（Espressif IoT Development Framework）中提供的I2S API来进行配置和控制。以下是一个简单的示例代码，用于初始化I2S并设置其参数： ```c #include <stdio.h> #include "driver/i2s.h" void i2s_init() { i2s_config_t i2s_config = { .mode = I2S_MODE_MASTER | I2S_MODE_TX, // 设置为主模式和发送模式 .sample_rate = 44100, // 设置采样率为44100Hz .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT, .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // 只使用左声道 .communication_format = I2S_COMM_FORMAT_I2S_MSB, .dma_buf_count = 8, .dma_buf_len = 64, .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1 // 设置中断优先级为1 }; i2s_pin_config_t pin_config = { .bck_io_num = 26, // BCLK引脚 .ws_io_num = 25, // LRCK引脚 .data_out_num = 22, // DATA引脚 .data_in_num = -1 // 如果不需要接收数据，可以设置为-1 }; i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL); // 安装I2S驱动程序 i2s_set_pin(I2S_NUM_0, &pin_config); // 设置I2S引脚 } void app_main() { i2s_init(); // 在这里可以添加其他代码来发送音频数据 } ``` 请注意，上述示例代码仅用于初始化I2S并设置其参数。你可以根据自己的需求进行更改和扩展。如果你想发送音频数据，可以使用`i2s_write`函数来发送数据。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值