模拟IIC

最新推荐文章于 2024-03-10 21:23:05 发布
最新推荐文章于 2024-03-10 21:23:05 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： demo 文章标签： demo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pig10086/article/details/70318668
版权


IIC相对而言硬件设计较为简单，两线总线可以直接挂载很多芯片，但通信受干扰，容易进入“死锁”状态，需要软件处理。SPI相对而言需要的硬线更多，但不存在出现“死锁”的问题，另外通信速率也更高。

死锁: 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

那么为什么会产生死锁呢？
1.因为系统资源不足。
2.进程运行推进的顺序不合适。    
3.资源分配不当。

产生死锁的四个必要条件：

互斥条件(Mutual exclusion)：资源不能被共享，只能由一个进程使用。
请求与保持条件(Hold and wait)：已经得到资源的进程可以再次申请新的资源。
非剥夺条件(No pre-emption)：已经分配的资源不能从相应的进程中被强制地剥夺。
循环等待条件(Circular wait)：系统中若干进程组成环路，该环路中每个进程都在等待相邻进程正占用的资源。


#ifndef __USER_IIC_
#define __USER_IIC_

#include "pca10040.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"

//ERROR
#define ERROR_CODE_TRUE 0
#define ERROR_CODE_FALSE 1
#define ERROR_CODE_WRITE_ADDR 10
#define ERROR_CODE_WRITE_DATA        20
#define ERROR_CODE_READ_ADDR        30
#define ERROR_CODE_READ_DATA        40
#define ERROR_CODE_START_BIT        50
#define ERROR_CODE_APROCESS 60
#define ERROR_CODE_DENY 70

#define I2C_DELAY nrf_delay_us(13) // 5uS delay setting
#define I2C_DELAY_LONG nrf_delay_us(130)  // 10uS delay setting

#define SCL1 6
#define SDA1 7
//设置IO方向
#define SDA_OUT1()  nrf_gpio_cfg_output(SDA1)
#define SDA_IN1()   nrf_gpio_cfg_input(SDA1,NRF_GPIO_PIN_PULLUP)
//设置IO电平
#define I2C_SCL_HIGH1   nrf_gpio_pin_set(SCL1)   //SCL = 1
#define I2C_SCL_LOW1    nrf_gpio_pin_clear(SCL1) //SCL = 0
#define I2C_SDA1        1    //SDA  
#define READ_SDA1          nrf_gpio_pin_read(SDA1)  //read SDA
#define I2C_SDA_HIGH1   nrf_gpio_pin_set(SDA1)   //SDA
#define I2C_SDA_LOW1    nrf_gpio_pin_clear(SDA1) //SDA

void IIC_IO_Init1(void);
void _i2c_start1(void);
void _i2c_stop1(void);
unsigned char _i2c_write_byte1(unsigned char data);
unsigned char _i2c_read_byte1(unsigned char ack);
void _i2c_ack_send1(void);
void _i2c_nack_send1(void);
unsigned char _i2c_ack_detect1(void);

#endif


void IIC_IO_Init1(void)
{
nrf_gpio_cfg_output(SDA1);
nrf_gpio_cfg_output(SCL1);

I2C_SDA_HIGH1;
I2C_SCL_HIGH1;
}
void _i2c_start1(void)
{
    SDA_OUT1();
    I2C_SDA_HIGH1;
    I2C_SCL_HIGH1;
    I2C_DELAY;
    I2C_SDA_LOW1;
    I2C_DELAY;
    I2C_SCL_LOW1;
    I2C_DELAY;
}
void _i2c_stop1(void)
{
    SDA_OUT1();
    I2C_SCL_LOW1;
    I2C_SDA_LOW1;
    I2C_DELAY;
    I2C_SCL_HIGH1;
    I2C_DELAY;
    I2C_SDA_HIGH1;
    I2C_DELAY_LONG;
}
void _i2c_ack_send1(void)//??ACK??
{
    SDA_OUT1();
    I2C_SCL_LOW1;
    I2C_SDA_LOW1;
    I2C_DELAY;
    I2C_SCL_HIGH1;
    I2C_DELAY;
    I2C_SCL_LOW1;
    I2C_DELAY;
}
void _i2c_nack_send1(void)
{
    SDA_OUT1();
    I2C_SCL_LOW1;
    I2C_SDA_HIGH1;
    I2C_DELAY;
    I2C_SCL_HIGH1;
    I2C_SCL_LOW1;
    I2C_DELAY;
}
unsigned char _i2c_ack_detect1(void)
{
    unsigned char ucErrTime=0;
    SDA_IN1(); // SDA Input Mode
    I2C_SDA_HIGH1;
    I2C_SCL_HIGH1;
    I2C_DELAY;
    while(READ_SDA1==I2C_SDA1)
    {
        ucErrTime++;
        if(ucErrTime>250)
        {
            SDA_OUT1();        
            return ERROR_CODE_FALSE; // false
        }        
    }
    I2C_SCL_LOW1;
    I2C_DELAY;
    return ERROR_CODE_TRUE;
} 
unsigned char _i2c_write_byte1(unsigned char data)
{
    unsigned char i ;  
    SDA_OUT1(); 
    I2C_SCL_LOW1;    
    for(i = 0; i< 8; i++)
    {
        if( (data & 0x80) == 0x80) I2C_SDA_HIGH1;
        else I2C_SDA_LOW1;
        data <<=1;
        I2C_DELAY;
        I2C_SCL_HIGH1;
        I2C_DELAY;
        I2C_SCL_LOW1;
        I2C_DELAY;
    }
    if(_i2c_ack_detect1()) 
    {
        return ERROR_CODE_FALSE;
    }
    return ERROR_CODE_TRUE;
}
unsigned char _i2c_read_byte1(unsigned char ack)//ack=1 send ACK,ack=0 send NACK
{
    unsigned char i=0, data=0;
    SDA_IN1();
    I2C_SDA_HIGH1;
    for(i = 0; i< 8; i++)
    {
        data <<= 1;  
        I2C_SCL_LOW1;
        I2C_DELAY;
        I2C_SCL_HIGH1;
        I2C_DELAY;      
        if (READ_SDA1==I2C_SDA1) data |= 0x01;  
        I2C_DELAY;     
    } 
    if (!ack) _i2c_nack_send1();
    else _i2c_ack_send1();
    return data;
}



//MPU6050

struct MPU6050_ACCEL1 MPU6050_ACCEL_OUT1;

unsigned char MPU_X050_Write_Byte1(unsigned char SlaveAddress,unsigned char REG_Address,unsigned char REG_data)
{
    _i2c_start1();
    if(_i2c_write_byte1(SlaveAddress))  
    {
        _i2c_stop1();
        return ERROR_CODE_WRITE_ADDR;    
    }   
    if(_i2c_write_byte1(REG_Address))
    {
        _i2c_stop1();
        return ERROR_CODE_WRITE_ADDR;      
    }
    if(_i2c_write_byte1(REG_data))
    {
        _i2c_stop1();
        return ERROR_CODE_WRITE_ADDR;     
    }   
    _i2c_stop1(); 
    I2C_DELAY_LONG;
    return ERROR_CODE_TRUE;      
}


unsigned char MPU_X050_Read_Byte1(unsigned char SlaveAddress,unsigned char REG_Address)
{
    unsigned char REG_data; 
    _i2c_start1();   
    if(_i2c_write_byte1(SlaveAddress))
    {
        _i2c_stop1();
        return 0;     
    }
    if(_i2c_write_byte1(REG_Address))
    {
        _i2c_stop1();
        return 0;      
    }   
    _i2c_start1();
    if(_i2c_write_byte1(SlaveAddress+1))
    {
        _i2c_stop1();
        return 0;     
    }
    REG_data = _i2c_read_byte1(0);
    _i2c_stop1();
    I2C_DELAY_LONG;
    return REG_data;    
}



unsigned char MPU_Write_Len1(unsigned char SlaveAddress,unsigned char REG_Address,unsigned char len,unsigned char *buf)
{
    unsigned char i; 
    _i2c_start1(); 
    if(_i2c_write_byte1(SlaveAddress))
    {
        _i2c_stop1();
        return ERROR_CODE_WRITE_ADDR;     
    }
    if(_i2c_write_byte1(REG_Address))
    {
        _i2c_stop1();
        return ERROR_CODE_WRITE_ADDR;      
    }
    for(i=0;i<len;i++)
    {
        if(_i2c_write_byte1(buf[i]))
        {
            _i2c_stop1();
            return ERROR_CODE_WRITE_ADDR;      
        }
    }    
    _i2c_stop1();
    return 0;
}


unsigned char MPU_Read_Len1(unsigned char SlaveAddress,unsigned char REG_Address,unsigned char len,unsigned char *buf)
{
    _i2c_start1(); 
    if(_i2c_write_byte1(SlaveAddress))
    {
        _i2c_stop1();
        return ERROR_CODE_READ_ADDR;     
    }    
    if(_i2c_write_byte1(REG_Address))
    {
        _i2c_stop1();
        return ERROR_CODE_READ_ADDR;      
    }    
    _i2c_start1();
    if(_i2c_write_byte1(SlaveAddress+1))
    {
        _i2c_stop1();
        return ERROR_CODE_READ_ADDR;     
    } 
    while(len)
    {
        if(len==1)*buf=_i2c_read_byte1(0);
        else *buf=_i2c_read_byte1(1);
        len--;
        buf++; 
    }   
    _i2c_stop1();
    return 0;
}
unsigned char MPU0605_Init1(void)
{
    unsigned char res;
    nrf_delay_ms(100);
    IIC_IO_Init1();
    nrf_delay_ms(100);
    MPU_X050_Write_Byte1(MPU6050_Addr,PWR_MGMT_1,0X80);
    nrf_delay_ms(100);
    MPU_X050_Write_Byte1(MPU6050_Addr,PWR_MGMT_1, 0x00);
    MPU_X050_Write_Byte1(MPU6050_Addr,SMPLRT_DIV, 7);
    MPU_X050_Write_Byte1(MPU6050_Addr,CONFIG, 0x06);
    MPU_X050_Write_Byte1(MPU6050_Addr,GYRO_CONFIG, 0x18);
    MPU_X050_Write_Byte1(MPU6050_Addr,ACCEL_CONFIG, 0x00);


    MPU_X050_Write_Byte1(MPU6050_Addr,MPU_INT_EN_REG,0X00);
    MPU_X050_Write_Byte1(MPU6050_Addr,MPU_USER_CTRL_REG,0X00);
    MPU_X050_Write_Byte1(MPU6050_Addr,MPU_FIFO_EN_REG,0X00);
    nrf_delay_ms(50);
    res=MPU_X050_Read_Byte1(MPU6050_Addr,WHO_AM_I);
    printf("\r\nWHO = %x", res);
    if(res==0x68)
    {
        MPU_X050_Write_Byte1(MPU6050_Addr,PWR_MGMT_1, 0x03);
        MPU_X050_Write_Byte1(MPU6050_Addr,PWR_MGMT_2, 0x00);
    }
    else
            return 1;
    return 0;
}
unsigned char MPU_Get_Accelerometer1(void)
{
    unsigned char buf[6],res;  
    res=MPU_Read_Len1(MPU6050_Addr,ACCEL_XOUT_H,6,buf);
    if(res==0)
    {
        MPU6050_ACCEL_OUT1.ACCEL_xOUT=((int)buf[0]<<8)|buf[1];  
        MPU6050_ACCEL_OUT1.ACCEL_yOUT=((int)buf[2]<<8)|buf[3];  
        MPU6050_ACCEL_OUT1.ACCEL_zOUT=((int)buf[4]<<8)|buf[5];
    }
    return res;    
}


void test_MPU60501(void)
{
#if(user_printf==jiaodu)
float Accel_x;
float Accel_y;
float Accel_z;
MPU_Get_Accelerometer1();
  Accel_x = MPU6050_ACCEL_OUT1.ACCEL_xOUT;
  Accel_y = MPU6050_ACCEL_OUT1.ACCEL_yOUT;
  Accel_z = MPU6050_ACCEL_OUT1.ACCEL_zOUT;
  if(Accel_x>=0x8000)
  {
     Accel_x = -(65536-Accel_x);
  }
  if(Accel_y>=0x8000)
  {
     Accel_y = -(65536-Accel_y);
  }
  if(Accel_z>=0x8000)
  {
     Accel_z = -(65536 - Accel_z);
  } 
  Accel_x=(int)((Accel_x/16384.0f)*1000);
  Accel_y=(int)((Accel_y/16384.0f)*1000);
  Accel_z=(int)((Accel_z/16384.0f)*1000);


  printf("X1 %d ",(int)Accel_x);
  printf("Y1 %d ",(int)Accel_y);
  printf("Z1 %d ",(int)Accel_z);
#else
MPU_Get_Accelerometer1();
//  printf("X1 %d ",MPU6050_ACCEL_OUT1.ACCEL_xOUT);
//  printf("Y1 %d ",MPU6050_ACCEL_OUT1.ACCEL_yOUT);
//  printf("Z1 %d ",MPU6050_ACCEL_OUT1.ACCEL_zOUT);
#endif
}









pig10086
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
STM32F103模拟IIC程序（亲测可用）
07-31
STM32F103模拟IIC程序（亲测可用）
主机模拟i2c检测设备时出现错误死循环_详谈：I2C设备导致死锁怎么办？
weixin_39740737的博客
11-22 642
一般情况下， i2c 设备焊接没什么问题，按照设备手册一步步来，基本上就顺风顺水能够用起来。如果这么一个简单的东西，有时候想要的结果死活不出来，反复的检查问题的原因，查询解决办法，核查设备的数据手册，甚至发送和接收的每一条命令与数据都知道是什么意思，仍然无法解决问题，那该怎么办呢?本文主要针对 i2c 设备，讲解如何解决 i2c 设备主机与从机直接无法正常数据交互的问题，侧重点是针对硬...
STM32_HAL---GPIO模拟IIC协议
最新发布
aa1asd的博客
03-10 273
【代码】STM32_HAL---GPIO模拟IIC协议。
【InterFace】STM32 I2C 死锁问题
吴秀华Cherry的有趣博客
06-08 1万+
最近在项目中设计了一个 IIC 模拟从机的程序。为了图方便，我随便拿了个 STM32F207 的开发板做 IIC Master，用 STM32CUBE 做了个程序，Master 的 数据发送和接收，都是直接调用 HAL 库的函数。 通过逻辑分析仪测试发现，每次主机出现错误后，IIC SDA 会被拉低，导致整个 IIC 总线被锁死了。后续的数据传输异常。现象如下图所示： 后来我查看了 H...
STM32单片机初学4-IIC通信（软件模拟）
qq_55203246的博客
04-10 1万+
IIC（Inter-Integrated Circuit）是IICBus简称，中文名为集成电路总线，它是一种串行通信总线，使用多主从架构，由飞利浦公司在1980年代为了让主板、嵌入式系统或手机用以连接低速周边设备而发展。 ...
IO口软件模拟IIC
热门推荐
zhejfl的博客
09-28 2万+
  一、IIC时序 IIC(Inter-Integrated Circuit, 内部集成电路)总线是飞利浦公司开发的两线式串行总线，用于短距离传输，常用语微控制器及其外围设备。它是由数据线SDA和时钟线SCL构成的串行总线，可发送和接收数据。 I2C总线通过上拉电阻接正电源。即当总线空闲时，两根线均为高电平。如此，连在总线上的任一器件输出的低电平，都可以使得总线的信号变低，也就是说各器件...
通过GPIO的方式模拟实现IIC
08-16
通过GPIO的方式模拟实现IIC master的访问时序，希望能够帮助到大家，谢谢
GPIO模拟IIC代码模板
fyyy4030的专栏
03-05 1769
GPIO模拟IIC代码模板           [嵌入式]发布时间：2009-09-07 23:49:31        GPIO模拟IIC接口的公开的代码应该有很多了，最近正好要做一个GPIO模拟IIC主机的代码，驱动一个芯片。但是发现网上的代码基本没有让偶满意的，所以自己从新写了一个代码模板。在AVR和MTK(ARM)上测试通过，效果还8错。 1. 模板化的代码，使用还算比
00025-----GPIO模拟IIC总线程序
bingqingsuimeng的专栏
03-04 2267
因2440自带的IIC控制器本人用它作为从机使用，所以用GPIO模拟了IIC总线的主机模式。以下列出驱动代码和应用试验程序 总线模拟读写EEPROM   1.底层驱动   /********************************* ** EEPROM模拟IIC总线 驱动程序   ** **        日期：2012.8.30       ** **
[单片机] GPIO模拟IIC
wabil的专栏
02-03 481
【代码】[单片机] GPIO模拟IIC。
GPIO口模拟IIC
qq_37612662的博客
06-02 1153
IIC
gpio模拟iic drivers
03-17
gpio模拟iic驱动，基于stm8寄存器版，移植方便，只需要修改io即可
EFM32 GPIO模拟IIC
07-29
在EFM32上用GPIO模拟IIC进行通讯。
stm32 IO口模拟IIC程序例程
12-03
功能：本程序为单功能实现stm32IIC模拟的测试程序，本程序可用，可以一直到需要模拟IIC口的程序中。
使用STM32 GPIO口模拟IIC
06-12
STM32GPIO口模拟IIC，可设置使用任意IO口，已调试验证ok。
IIC通信Demo.7z
09-16
1、使用STM32F103Ze芯片实现 2、板间通过I2C进行通信的Demo程序
stm32f103模拟IIC
09-21
这是stm32f103的模拟IIC源码程序，当引脚IIC的引脚不够用时使用，已测试好用。
模拟IIC源码
08-01
封装好的模拟IIC，支持自定义多个IIC，使用简单方便
IO口模拟IIC
07-05
利用单片机的IO口模拟IIC通信，通信速率高，亲测能用。
模拟iic等待ack
01-22
模拟IIC（Inter-Integrated Circuit）等待ACK（Acknowledgement）是指在IIC通讯中，主设备发送数据后需要等待从设备的确认信号。如果主设备发送的数据未收到从设备的确认信号，就会出现通讯错误。要模拟IIC等待ACK，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值