菜农QQ群课：<<菜农I2C零耗时全集>>

只看该作者 · 2011-1-13 21:45

本帖最后由 hotpower 于 2011-3-20 02:49 编辑

群课：<<菜农I2C零耗时全集>>

菜农Cortex-M0技术交流群：12047788

只看该作者 · 2011-1-13 21:48

雁塔菜农(1270688699) 20:30:00
现在UART和I2C全部是零耗时，这是俺5年前玩PIC24FJ64GA006实现的。
一直舍不得~~~只发了I2C的~~~
雁塔菜农(1270688699) 20:30:28
俺做的UART太倒塌~~~
单片机玩家(373884636) 20:31:21
我今天发现了一个问题。估计大家都有可能忽略的。就是PIC不能ISP的问题。明天大家分享吧。对了，大家一般用什么东西烧录PIC单片机的？
Mr.Wrong(44500789) 20:31:46
我用QL2006
雁塔菜农(1270688699) 20:32:09
今天想明白了，有些东西是不能带入坟墓里的~~~这就是何立民教授建议俺用录音笔的原因
单片机玩家(373884636) 20:32:19
我本人用PICKIT3或者PICKIT2.
笨孩子(570298585) 20:32:37
支持
单片机玩家(373884636) 20:32:40
有时候PICKIT2比较好用，知道原因吗？
雁塔菜农(1270688699) 20:32:46
领导买的ID3
agllero(859419016) 20:32:48
录音笔做什么用
笨孩子(570298585) 20:32:52
大叔的思想流芳百世
海风(465614759) 20:32:57

雁塔菜农(1270688699) 20:33:08
哈哈，死后他们整理，晕
笨孩子(570298585) 20:33:11
我等后辈要学习一辈子
海风(465614759) 20:33:14
http://ww1.microchip.com/downloads/cn/DeviceDoc/39711B.pdf
单片机玩家(373884636) 20:33:22
ICD3太贵了。没有意思的。有时候烧录PIC单片机是必须要用PICKIT2
单片机玩家(373884636) 20:33:32
要么就用PM3
海风(465614759) 20:33:39
外设配置也有影响
笨孩子(570298585) 20:33:41
等我年龄大了了也用录音笔录音一把
雁塔菜农(1270688699) 20:33:45
ID3挺好看~~~
海风(465614759) 20:33:57
ICD3价格还好,
雁塔菜农(1270688699) 20:34:12
哈哈~~
海风(465614759) 20:34:20
也就跟台湾那些OTP片子仿真器价格差不多
雁塔菜农(1270688699) 20:34:24
#include "main.h"

#ifndef __I2C_H
#define __I2C_H

#define I2CBAUD 800000//800KHz  本程序是读写铁电的，故速度很高

//下面的是I2C的标准状态表,因为PIC的不标准,故凑合着用和补充了加注解的部分~~~
enum enum_I2CState
{
/* Master */
I2C_START =       0x08,//启动
I2C_REP_START= 0x10,//重启动
/* Master Transmitter */
I2C_MT_SLA_ACK= 0x18,//主发模式下得到从机地址应答信号
I2C_MT_SLA_NACK= 0x20,

I2C_MT_DATA_ACK= 0x28,//主发模式下得到从机数据应答信号
I2C_MT_DATA_NACK= 0x30,

I2C_MT_ARB_LOST= 0x38,
/* Master Receiver */
I2C_MR_ARB_LOST= 0x38,
I2C_MR_SLA_ACK= 0x40,//主收模式下得到从机地址应答信号
I2C_MR_SLA_NACK= 0x48,
I2C_MR_DATA_ACK= 0x50,
I2C_MR_DATA_NACK= 0x58,

/* Slave Transmitter */
I2C_ST_SLA_ACK= 0xA8,
I2C_ST_ARB_LOST_SLA_ACK= 0xB0,
I2C_ST_DATA_ACK= 0xB8,
I2C_ST_DATA_NACK= 0xC0,
I2C_ST_LAST_DATA= 0xC8,
/* Slave Receiver */
I2C_SR_SLA_ACK= 0x60,
I2C_SR_ARB_LOST_SLA_ACK= 0x68,
I2C_SR_GCALL_ACK= 0x70,
I2C_SR_ARB_LOST_GCALL_ACK=  0x78,
I2C_SR_DATA_ACK= 0x80,
I2C_SR_DATA_NACK= 0x88,
I2C_SR_GCALL_DATA_ACK= 0x90,
I2C_SR_GCALL_DATA_NACK= 0x98,
I2C_SR_STOP=       0xA0,
/* Misc */
I2C_NO_INFO=       0xF8,

I2C_MT_ADDRH_ACK= 0x3a,//主发模式下得到从机高位EEPROM地址应答信号
I2C_MT_ADDRL_ACK= 0x3b,//主发模式下得到从机高低位EEPROM地址应答信号
I2C_MR_DATA=    0x5a,//主收模式下接收数据
I2C_MR_DATA_EN=    0x5b,//主收模式下使能接收数据功能
I2C_MR_DATA_STOP= 0x5c,//主收模式下接收数据完成

I2C_FAILED=    0xcc,//读写操作失败
I2C_SUCCEEDED=             0x00,//读写操作成功
I2C_RWBIT= 0,//
I2C_READ=       1,//
I2C_WRITE=                0//
};

#define TRIS_SCL1 _TRISG2 //SCL方向控制
#define TRIS_SDA1 _TRISG3 //SDA方向控制
#define ODC_SCL1 _ODG2 //SCL开漏控制
#define ODC_SDA1 _ODG3 //SDA开漏控制

/*-----------------------------------------
写保护管脚定义,需要硬件的支持
------------------------------------------*/
//#define TRIS_WP _TRISD9 //WP方向控制
//#define WP _LATD9//写保护

typedef struct tagI2CBITS
{
union
{
   unsigned char I2CFlag;
   struct
   {
unsigned char  BusyFlag: 1;//忙标志
unsigned char  ReadFlag: 1;//读回调标志
unsigned char  WriteFlag:  1;//写回调标志
};
};
}I2CBITS;

extern volatile I2CBITS I2CBits;

typedef struct tagI2CREGS
{
unsigned char State;//运行状态编码
unsigned char I2CAddr;//器件地址0xa1,0xa0
unsigned int Command;//命令
unsigned int Count;//运行计数器
unsigned int TxCount;//发送(写)个数
unsigned int RxCount;//接收(读)个数
unsigned int MaxCount;//器件最大容量
unsigned char TxBuffer[128];//发送缓冲区
unsigned char RxBuffer[256];//接收缓冲区
}I2CREGS;

extern volatile I2CREGS I2CRegs;

void I2cInit(void);
void I2CTest(void);
void I2CReadBuffers(unsigned int Command, unsigned char [], unsigned int);
void I2CWriteBuffers(unsigned int Command, unsigned char [], unsigned int);
void I2CReadCallBack(void);
void I2CWriteCallBack(void);
void I2cStart(void);
void I2cReStart(void);
void I2cStop(void);
void I2CExec(void);

#endif//__I2C_H

单片机玩家(373884636) 20:34:42
ICD3毕竟只是一个仿真器，它的主要功能不是烧芯片用的。批量生产时最好用PICKIT2,或者PICKIT3
雁塔菜农(1270688699) 20:34:55
倒塌了，太长
雁塔菜农(1270688699) 20:35:03
i2c.c
雁塔菜农(1270688699) 20:35:39
void I2CExec(void)
{
if (I2C1STATbits.S)//收到Start过信号
{
switch (I2CRegs.State)
{
case I2C_START://收到Start信号
I2C1TRN = I2CRegs.I2CAddr & 0xfe;//发送器件写地址(通知从机只能听)
I2CRegs.State = I2C_MT_SLA_ACK;//下次应该接收器件写地址应答信号
break;
case I2C_MT_SLA_ACK://收到器件写地址应答信号
if (!I2C1STATbits.ACKSTAT)//收到Ack信号
{
if (I2CRegs.MaxCount > 0x100)//EEPROM容量超过256个字节,EEPROM地址需要两次发送
{
I2C1TRN = I2CRegs.Command >> 8;//发送EEPROM写高8位地址
I2CRegs.State = I2C_MT_ADDRH_ACK;//下次应该接收EEPROM写高8位地址应答信号
}
else//小容量只需一次发送!!!
{
I2C1TRN = I2CRegs.Command;//发送EEPROM写低8位地址
I2CRegs.State = I2C_MT_ADDRL_ACK;//下次应该接收EEPROM写低8位地址应答信号
I2CRegs.Count = 0;//清空发送缓冲计数器
}
}
else//收到NAck信号
{
I2cExit();//错误的ACK信号
}
break;
case I2C_MT_ADDRH_ACK://收到EEPROM写高8位地址应答信号
if (!I2C1STATbits.ACKSTAT)//收到Ack信号
{
I2C1TRN = I2CRegs.Command & 0xff;//发送EEPROM写低8位地址
I2CRegs.State = I2C_MT_ADDRL_ACK;//下次应该接收EEPROM写低8位地址应答信号
I2CRegs.Count = 0;//清空发送缓冲计数器
}
else//收到NAck信号
{
I2cExit();//错误的ACK信号
}
break;
case I2C_MT_ADDRL_ACK://收到EEPROM写高低8位地址应答信号
if (I2CRegs.TxCount)//写保护只在写入期间不保护，增加了对误写入的安全防护能力!!!
{
// WP = 0;//不写保护
}
case I2C_MT_DATA_ACK://收到应答信号
if (!I2C1STATbits.ACKSTAT)//收到Ack信号
{
if (I2CRegs.Count < I2CRegs.TxCount)//缓冲区未空
{
I2C1TRN = I2CRegs.TxBuffer[I2CRegs.Count ++];//继续发送数据
}
else if (I2CRegs.Count == I2CRegs.TxCount)//缓冲区已空
{
if (I2CRegs.I2CAddr & 1)//应该开始接收数据
{
I2cReStart();//发送重复位命令
}
else//只写退出
{
I2cStop();//正常发送结束
}
}
else//干扰出错
{
I2cExit();//错误
}
}
else//收到NAck信号(可能被写保护)
{
I2cExit();//错误的ACK信号
}
break;
case I2C_REP_START://收到ReStart信号
I2C1TRN = I2CRegs.I2CAddr | I2C_READ;//发送器件读地址(通知从机可以说话)
I2CRegs.State = I2C_MR_SLA_ACK;//下次应该接收器件写读地址应答信号
break;
case I2C_MR_SLA_ACK://收到器件读地址应答信号
if (!I2C1STATbits.ACKSTAT)//收到Ack信号
{
I2C1CONbits.RCEN = 1;//开始接收数据
I2CRegs.State = I2C_MR_DATA;//下次应该收接收数据
}
else//收到NAck信号
{
I2cExit();//错误的ACK信号
}
break;
case I2C_MR_DATA://收到接收数据
if (I2CRegs.Count < I2CRegs.RxCount)
{
// I2C1STATbits.I2COV = 0;
I2CRegs.RxBuffer[I2CRegs.Count ++] = I2C1RCV;
if (I2CRegs.Count < I2CRegs.RxCount)
{
  I2C1CONbits.ACKDT = 0;//应答子机
I2CRegs.State = I2C_MR_DATA_EN;//下次应该收到器件允许继续读信号
}
else
{
I2C1CONbits.ACKDT = 1;//非应答子机
I2CRegs.State = I2C_MR_DATA_STOP;//下次应该收到退出信号
}
  I2C1CONbits.ACKEN = 1;//向从机发送(非)应答信号
}
else//正确的状态已分支到I2C_MR_DATA_STOP
{
I2cExit();//错误
}
break;
case I2C_MR_DATA_EN://收到器件允许继续读信号
I2C1CONbits.RCEN = 1;//开始接收数据
I2CRegs.State = I2C_MR_DATA;//下次应该继续接收数据
break;
case I2C_MR_DATA_STOP://收到器件退出信号
I2cStop();//正常接收结束
break;
default://其他不可预料的错误
I2cExit();//错误
}
}
else if (I2C1STATbits.P)//收到Stop信号
{
if (I2CRegs.State == I2C_SUCCEEDED)//成功,回调
{
if (I2CRegs.I2CAddr & 1)//读
{
I2CBits.ReadFlag = 1;//激活用户读回调函数I2CReadCallBack()
I2CReadCallBack();
}
else//写
{
I2CBits.WriteFlag = 1;//激活用户写回调函数I2CWriteCallBack()
I2CWriteCallBack();
}
}
}
else//无法确认的复杂错误
{
I2cExit();//错误出错退出
}
}

雁塔菜农(1270688699) 20:35:56
注意这个回调
雁塔菜农(1270688699) 20:36:12
比5年前好
雁塔菜农(1270688699) 20:37:10
void __attribute__ ((interrupt, no_auto_psv)) _MI2C1Interrupt( void )
{
_MI2C1IF = 0;//清除I2c1中断标志
I2CExec();
}

雁塔菜农(1270688699) 20:37:20
次序很关键
雁塔菜农(1270688699) 20:37:44
这样就可以实现真正的零耗时
雁塔菜农(1270688699) 20:37:47
哈哈
雁塔菜农(1270688699) 20:38:50
#include "i2c.h"

_PERSISTENT volatile I2CREGS I2CRegs;
_PERSISTENT volatile I2CBITS I2CBits;

void I2cInit(void)
{
unsigned int i;
// TRIS_WP = PORTOUTMODE;//定义WP为输出IO
TRIS_SCL1 = PORTOUTMODE;//定义SCL为输出IO
TRIS_SDA1 = PORTINPUTMODE;//定义SDA为输出入IO
ODC_SCL1 = 1;//OC输出
ODC_SDA1 = 1;//OC输出
// WP = 1;//写保护
// I2CRegs.MaxCount = 0x200;//8KByte
I2CRegs.MaxCount = 256;//256Byte
I2CRegs.I2CAddr = 0xb2;//器件地址
I2CRegs.Command = 0;//EEPROM读写地址命令
I2CRegs.TxCount = 0;//发送数据字节个数
I2CRegs.RxCount = 0;//接收数据字节个数
for (i = 0; i < sizeof(I2CRegs.TxBuffer); i ++)
{
I2CRegs.TxBuffer = 0;//发送缓冲区清零
}
for (i = 0; i < sizeof(I2CRegs.RxBuffer); i ++)
{
I2CRegs.RxBuffer = 0;//接收缓冲区清零
}

I2C1CON = 0;
// I2C1CONbits.A10M = 0;//7位地址模式
I2C1CONbits.SCLREL = 1;
I2C1MSK = 0;
I2C1STAT = 0;
_MI2C1IF = 0;
_SI2C1IF = 0;
I2C1BRG = (FCY / (2 * I2CBAUD)) - 1;//波特率计算
/*------------------------------------------------------------------------
定义I2C串口2中断优先级位1111)
-------------------------------------------------------------------------*/
IPC4bits.MI2C1P0 = 1;
IPC4bits.MI2C1P1 = 1;
IPC4bits.MI2C1P2 = 1;

I2C1CONbits.I2CEN = 1;//允许I2C功能
_MI2C1IE = 1;//允许主设备中断

// I2cStop();
}

/*------------------------------------------------------------------
EEPROM读块函数(只能在回调函数I2CReadCallBack中得到读出的数据)
-------------------------------------------------------------------*/

void I2CTest(void)
{
I2CRegs.TxCount = 19;
I2CRegs.RxCount = 20;
I2CRegs.Command = '$';
I2CRegs.I2CAddr |= 1;//0xa3
I2cStart();
}

void I2CReadBuffers(unsigned int Command, unsigned char ReadBuffer[], unsigned int ReadSize)
{
if (ReadSize && (ReadSize <= 256))
{
I2CRegs.TxCount = 0;
I2CRegs.RxCount = ReadSize;
I2CRegs.Command = Command;
I2CRegs.I2CAddr |= 1;//0xa3
I2cStart();
}
}

/*------------------------------------------------------------------
EEPROM写块函数
-------------------------------------------------------------------*/
void I2CWriteBuffers(unsigned int Command, unsigned char WriteBuffer[], unsigned int WriteSize)
{
if (WriteSize && (WriteSize <= 16))
{
I2CRegs.TxCount = WriteSize;
I2CRegs.RxCount = 0;
I2CRegs.Command = Command;
I2CRegs.I2CAddr &= 0xfe;//0xa0
I2cStart();
}
}

/*------------------------------------------------------------------
用户读回调函数
-------------------------------------------------------------------*/
void I2CReadCallBack(void)
{
I2CBits.ReadFlag = 0;
I2CRegs.I2CAddr ^= 0x10;
I2CTest();
}

/*------------------------------------------------------------------
用户写回调函数
-------------------------------------------------------------------*/
void I2CWriteCallBack(void)
{
I2CBits.WriteFlag = 0;
}

/*------------------------------------------------------------------
EEPROM读写启动函数
-------------------------------------------------------------------*/
void I2cStart(void)
{
/*------------------------------------------------------------------------
//本程序在状态I2C_MT_ADDRL_ACK下进行瞬间打开,也可在此打开，不过安全不好
if (I2CRegs.TxCount)//需要写入字节
{
WP = 0;//不写保护
}
else
{
WP = 1;//写保护
}
--------------------------------------------------------------------------*/
I2C1STATbits.IWCOL = 0;
I2CBits.BusyFlag = 1;
I2CRegs.State = I2C_START;//主机准备发送启始位
I2CRegs.Count = 0;//发送数据个数
I2CBits.I2CFlag = 0;
I2C1CONbits.SEN = 1;//发送Start信号
}

/*------------------------------------------------------------------
EEPROM读再启动函数
-------------------------------------------------------------------*/
void I2cReStart(void)
{
I2C1STATbits.IWCOL = 0;
I2CBits.BusyFlag = 1;
I2CRegs.State = I2C_REP_START;//主机准备发送重新启始位
I2CRegs.Count = 0;//发送数据个数
I2C1CONbits.RSEN = 1;//发送ReStart信号
I2C1CONbits.ACKEN = 0;
}

/*------------------------------------------------------------------
EEPROM读写正确停止函数
-------------------------------------------------------------------*/
void I2cStop(void)
{
I2C1STATbits.IWCOL = 0;
I2CBits.BusyFlag = 0;
I2CRegs.State = I2C_SUCCEEDED;//通讯成功
I2C1CONbits.PEN = 1;//发送Stop信号
// WP = 1;//写保护
}

/*------------------------------------------------------------------
EEPROM读写错误退出函数
-------------------------------------------------------------------*/
void I2cExit(void)
{
I2C1STATbits.IWCOL = 0;
I2CBits.BusyFlag = 0;
I2CRegs.State = I2C_FAILED;
I2C1CONbits.PEN = 1;//发送Stop信号
// WP = 1;//写保护
}

雁塔菜农(1270688699) 20:39:55
这是个通用的 I2C主机模式，可以访问任何格式的I2C,SMBUS,TWI,USI
雁塔菜农(1270688699) 20:40:57
PIC的I2C根本就是门外汉，俺将其绑架为“标准的I2C”
雁塔菜农(1270688699) 20:41:55
单片机玩家：见过此类的I2C吗？？？
雁塔菜农(1270688699) 20:42:10
在PIC上
雁塔菜农(1270688699) 20:42:47
俺这个套路在AVR,ARM7,M0上全部是同一套路
Mr.Wrong(44500789) 20:42:58
有点长，说说为什么是零耗时吧。
雁塔菜农(1270688699) 20:43:23
只要不等待就是零耗时
Mr.Wrong(44500789) 20:43:39
用户回调函数为什么放在中断里？
雁塔菜农(1270688699) 20:43:39
必须做的不算
雁塔菜农(1270688699) 20:44:04
哈哈，你可以在主循环里轮询
雁塔菜农(1270688699) 20:44:34
5年前在在主循环里
雁塔菜农(1270688699) 20:45:23
现在绝对没必要，因为你可以在回调了不清除标志
雁塔菜农(1270688699) 20:45:39
else if (I2C1STATbits.P)//收到Stop信号
{
if (I2CRegs.State == I2C_SUCCEEDED)//成功,回调
{
if (I2CRegs.I2CAddr & 1)//读
{
I2CBits.ReadFlag = 1;//激活用户读回调函数I2CReadCallBack()
I2CReadCallBack();
}
else//写
{
I2CBits.WriteFlag = 1;//激活用户写回调函数I2CWriteCallBack()
I2CWriteCallBack();
}
}
}
else//无法确认的复杂错误
{
I2cExit();//错误出错退出
}
}

雁塔菜农(1270688699) 20:46:11
/*------------------------------------------------------------------
EEPROM读块函数(只能在回调函数I2CReadCallBack中得到读出的数据)
-------------------------------------------------------------------*/

void I2CTest(void)
{
I2CRegs.TxCount = 19;
I2CRegs.RxCount = 20;
I2CRegs.Command = '$';
I2CRegs.I2CAddr |= 1;//0xa3
I2cStart();
}

void I2CReadBuffers(unsigned int Command, unsigned char ReadBuffer[], unsigned int ReadSize)
{
if (ReadSize && (ReadSize <= 256))
{
I2CRegs.TxCount = 0;
I2CRegs.RxCount = ReadSize;
I2CRegs.Command = Command;
I2CRegs.I2CAddr |= 1;//0xa3
I2cStart();
}
}

只看该作者 · 2011-1-13 21:53

雁塔菜农(1270688699) 20:51:24
哈哈，等俺把PIC24FJ256GA106最低级的问题搞定，将此程序裁剪在群内发布
agllero(859419016) 20:51:54

捏乒乓球(513837087) 20:52:49
期待，看看是怎么零耗时的
雁塔菜农(1270688699) 20:52:56
哈哈，别人是死了钱没花完，俺是死了程序没发完~~~
雁塔菜农(1270688699) 20:53:28
nt main(void)
{
disable_interrupts();//关中断
SystemInit();
enable_interrupts();//开中断
UartSendCommand0();

I2CTest();
while(1)
{
ClrWdt();
Nop();
}
return 0;
}

雁塔菜农(1270688699) 20:54:06
这个程序早跑到主循环了， uart和I2C还早着呢
雁塔菜农(1270688699) 20:54:34
Uart有自己的回调
雁塔菜农(1270688699) 20:54:43
I2C有自己的回调
雁塔菜农(1270688699) 20:55:28
这种系统架构对于低功耗是最完美的
雁塔菜农(1270688699) 20:55:45
就等同于OS
雁塔菜农(1270688699) 20:56:20
它的思想是基于PC程序的事件处理机制
雁塔菜农(1270688699) 20:56:34
delphi的最为经典
雁塔菜农(1270688699) 20:57:16
哈哈，不知不觉M0的群里谈起了PIC,晕！！！
雁塔菜农(1270688699) 20:57:41
记录官最近不知跑哪去了
agllero(859419016) 20:58:22

HotCortex(106821270) 20:58:29
DELPHI没用过
Mr.Wrong(44500789) 20:58:33
回家过年去了吧
HotCortex(106821270) 20:59:00
比VC6好用吗
Mr.Wrong(44500789) 20:59:37
好用，但后继有点脱力。
HotCortex(106821270) 21:00:04
是啊
HotCortex(106821270) 21:00:26
DELPHI之父据说搞C#了
HotCortex(106821270) 21:00:40
C#之父
雁塔菜农(1270688699) 21:01:05
这是俺的芯唐M0的程序，看看套路一样吗？
//I2C回调函数(静态成员函数)
void I2cObj::Exec(void)
{
  switch(I2Cs.STATUS.Regs & 0xf8) {
case I2C_START://主机收到自己发送的开始信号
   if (I2c.State == I2C_START) {//本次中断应该接收TW_START信号
      I2Cs.DATA.Regs = I2c.SubAddr & 0xfe;//发送子机地址(写)
      I2Cs.CON.Bits.STA = 0;//此位必须清除，否则死机
I2Cs.CON.Bits.SI = 1;//清除中断标志
I2c.State = I2C_MT_SLA_ACK;//Status下次I2C_MT_SLA_ACK
}
else I2c.Exit();//通讯失败
   break;
case I2C_REP_START://主机收到自己发送的重新开始信号
   if (I2c.State == I2C_REP_START) {//本次中断应该接收TW_RESTART信号
      I2Cs.DATA.Regs = I2c.SubAddr | 0x01;//发送子机地址(读)
   I2c.State = I2C_MR_SLA_ACK;//Status下次I2C_MR_SLA_ACK
I2Cs.CON.Bits.STA = 0;//此位必须清除，否则读不出数据
I2Cs.CON.Regs |= (1 << I2C_CON_SI) | (1 << I2C_CON_AA);
}
else I2c.Exit();//通讯失败
   break;
case I2C_MT_SLA_ACK://主发机接收到从机的地址应答信号后发送命令
   if (I2c.State == I2C_MT_SLA_ACK) {//本次中断应该接收TW_MT_SLA_ACK信号
   I2c.State = I2C_MT_DATA_ACK;//Status下次应该收TW_MT_DATA_ACK
         I2Cs.DATA.Regs = I2c.SubComm;//发送子机命令
I2Cs.CON.Regs |= (1 << I2C_CON_SI) | (1 << I2C_CON_AA);
}
else I2c.Exit();//通讯失败
   break;
case I2C_MR_SLA_ACK://主收机接收到从机的地址应答信号
   if ((I2c.State == I2C_MR_SLA_ACK) && I2c.SubCount) {//本次中断应该接收TW_MR_SLA_ACK信号
   I2c.State = I2C_MR_DATA_ACK;//Status下次应该收TW_MR_DATA_ACK
//  I2Cs.DATA.Regs = 0XFF;//
I2Cs.CON.Bits.SI = 1;//清除中断标志
}
else I2c.Exit();//通讯失败
break;
case I2C_MT_DATA_ACK://主收机接收到从机的数据应答信号
   if ((I2c.State == I2C_MT_DATA_ACK) && (I2c.Count < I2c.MainCount)) {//本次中断应该接收TW_MT_DATA_ACK信号
      I2Cs.DATA.Regs = I2c.TxBuffer[I2c.Count ++];//发送子机数据
   I2Cs.CON.Regs |= (1 << I2C_CON_SI) | (1 << I2C_CON_AA);
}
else {
      if ((I2c.State == I2C_MT_DATA_ACK) && (I2c.Count == I2c.MainCount) && (I2c.SubAddr & 1)) {//本次中断应该接收TW_MT_DATA_ACK信号
      I2c.REStart();//
}
         else I2c.Stop();//通讯成功
}
break;
case I2C_MR_DATA_ACK:
   if ((I2c.State == I2C_MR_DATA_ACK) && (I2c.Count < I2c.SubCount)) {
      I2c.RxBuffer[I2c.Count ++] = I2Cs.DATA.Regs;//接收子机数据
if (I2c.Count < I2c.SubCount) {
   I2Cs.CON.Regs |= (1 << I2C_CON_SI) | (1 << I2C_CON_AA);//主机转入接收状态
}
else {
I2Cs.CON.Bits.AA = 0;//清除ACK标志
I2Cs.CON.Bits.SI = 1;//清除中断标志
I2c.State = I2C_MR_DATA_NACK;//下次进入I2C_MR_DATA_NACK，接收数据准备完成
}
}
else I2c.Exit();//通讯失败
break;
case I2C_MR_DATA_NACK://数据接收结束
   if ((I2c.State == I2C_MR_DATA_NACK) && (I2c.Count == I2c.SubCount)) {
   I2c.Stop();//通讯成功
}
else I2c.Exit();//通讯失败
break;
// case I2C_MT_DATA_NACK:
// Exit();//通讯失败
// break;
default:
I2c.Exit();//通讯失败
  }
}

火凤凰(76679150) 21:01:06
我听说是java的团队搞的
火凤凰(76679150) 21:01:12
版本很多
雁塔菜农(1270688699) 21:02:30
这是俺的NXP的M0的I2C
void I2cObj::Exec(void)
{
  switch(I2C0.STAT.Regs & 0xf8) {
case I2C_START://主机收到自己发送的开始信号
   if (State == I2C_START) {//本次中断应该接收TW_START信号
      I2C0.DAT.Regs = SubAddr & 0xfe;//发送子机地址(写)
State = I2C_MT_SLA_ACK;//Status下次I2C_MT_SLA_ACK
         I2C0.CONCLR.Regs = (1 << STA) | (1 << SI) | (1 << AA);//清除中断标志
}
else Exit();//通讯失败
   break;
case I2C_REP_START://主机收到自己发送的重新开始信号
   if (State == I2C_REP_START) {//本次中断应该接收TW_RESTART信号
      I2C0.DAT.Regs = SubAddr | 0x01;//发送子机地址(读)
   State = I2C_MR_SLA_ACK;//Status下次I2C_MR_SLA_ACK
         I2C0.CONCLR.Regs = (1 << STA) | (1 << SI) | (1 << AA);//清除中断标志
}
else Exit();//通讯失败
   break;
case I2C_MT_SLA_ACK://主发机接收到从机的地址应答信号后发送命令
   if (State == I2C_MT_SLA_ACK) {//本次中断应该接收TW_MT_SLA_ACK信号
   State = I2C_MT_DATA_ACK;//Status下次应该收TW_MT_DATA_ACK
         I2C0.DAT.Regs = SubComm;//发送子机命令
         I2C0.CONCLR.Regs = (1 << STA) | (1 << SI) | (1 << AA);//清除中断标志
}
else Exit();//通讯失败
   break;
case I2C_MR_SLA_ACK://主收机接收到从机的地址应答信号
   if ((State == I2C_MR_SLA_ACK) && SubCount) {//本次中断应该接收TW_MR_SLA_ACK信号
   State = I2C_MR_DATA_ACK;//Status下次应该收TW_MR_DATA_ACK
         I2C0.CONCLR.Regs = (1 << STA) | (1 << SI);//清除中断标志,主机转入接收状态
I2C0.CONSET.Bits.AA = 1;
}
else Exit();//通讯失败
break;
case I2C_MT_DATA_ACK://主收机接收到从机的数据应答信号
   if ((State == I2C_MT_DATA_ACK) && (Count < MainCount)) {//本次中断应该接收TW_MT_DATA_ACK信号
      I2C0.DAT.Regs = TxBuffer[Count ++];//发送子机数据
         I2C0.CONCLR.Regs = (1 << STA) | (1 << SI) | (1 << AA);//清除中断标志
}
else {
      if ((State == I2C_MT_DATA_ACK) && (Count == MainCount) && (SubAddr & 1)) {//本次中断应该接收TW_MT_DATA_ACK信号
      REStart();//
}
         else Stop();//通讯成功
}
break;
case I2C_MR_DATA_ACK:
   if ((State == I2C_MR_DATA_ACK) && (Count < SubCount)) {
      RxBuffer[Count ++] = I2C0.DAT.Regs;//接收子机数据
if (Count < SubCount) {
            I2C0.CONCLR.Regs = (1 << STA) | (1 << SI);//主机转入接收状态
I2C0.CONSET.Bits.AA = 1;
}
else {
            I2C0.CONCLR.Regs = (1 << STA) | (1 << SI) | (1 << AA);//清除中断标志,主机转入接收状态
State = I2C_MR_DATA_NACK;//下次进入I2C_MR_DATA_NACK，接收数据准备完成
}
}
else Exit();//通讯失败
break;
case I2C_MR_DATA_NACK://数据接收结束
   if ((State == I2C_MR_DATA_NACK) && (Count == SubCount)) {
   Stop();//通讯成功
}
else Exit();//通讯失败
break;
// case I2C_MT_DATA_NACK:
// Exit();//通讯失败
// break;
default:
Exit();//通讯失败
  }
}
雁塔菜农(1270688699) 21:04:21
https://bbs.21ic.com/frame.php?fr ... hp%3Fitem%3Dthreads
这是俺的AVR的TWI

void TwiObj::Exec(void)
{
switch(TW_STATUS)
{
      case TW_START://主机收到自己发送的开始信号
      if (Status == 0)//本次中断应该接收TW_START信号
         {
         TWDR = SubAddr & 0xfe;//发送子机地址(写)
      Status = 1;//Status下次主发为1，主收为2
      TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWIE);//发送出去
      }
         else//通讯失败
         {
            Exit();
         }
      break;
case TW_REP_START://主机收到自己发送的重新开始信号
      if (Status == 0x55)//本次中断应该接收TW_REPSTART信号
         {
         TWDR = SubAddr | 1;//发送子机地址(读)
      Status = 2;//Status下次主发为1，主收为2
      TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWIE);//发送出去
      }
      else//通讯失败
         {
            Exit();
         }
      break;
case TW_MT_SLA_ACK://主发机接收到从机的地址应答信号后发送命令
      if (Status == 1)//本次中断应该接收TW_MT_SLA_ACK信号
         {
         Status = 3;//Status下次应该收TW_MT_DATA_ACK
            TWDR = SubComm ^ (SubAddr & 0xfe);//发送子机命令
/*-----------------------------------------------------------------------------
         以后可以复杂些
-----------------------------------------------------------------------------*/
      TxBuffer[0] = SubComm;//简单命令校验
      TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWIE);//发送出去
      }
      else//通讯失败
         {
            Exit();
         }
      break;
case TW_MR_SLA_ACK://主收机接收到从机的地址应答信号
      if (SubCount && (Status == 2))//本次中断应该接收TW_MR_SLA_ACK信号
         {
         Status = 4;//Status下次应该收TW_MR_DATA_ACK
            TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWIE) | (1 << TWEA);//主机转入接收状态
      }
      else//通讯失败
         {
            Exit();
         }
      break;
case TW_MT_DATA_ACK:
      if ((Count < MainCount) && (Status == 3))//本次中断应该接收TW_MT_DATA_ACK信号
         {
         TWDR = TxBuffer[Count ++] ^ (SubAddr & 0xfe);//发送子机数据
      TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWIE);//发送出去
      }
      else if ((Count == MainCount) && (Status == 3) && (SubAddr & 1))//本次中断应该接收TW_MT_DATA_ACK信号
         {
         RepStart();//
      }
      else//通讯失败
         {
            Exit();
         }
      break;
case TW_MT_DATA_NACK://数据发送结束
      break;
case TW_MR_DATA_ACK:
      if ((Count < SubCount) && (Status == 4))
         {
         RxBuffer[Count ++] = TWDR ^ (SubAddr | 0x01);//接收子机数据
      if (Count < SubCount)
            {
                  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWIE) | (1 << TWEA);//主机转入接收状态
            }
      else
            {
                  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWIE);//主机转入接收状态
         Status = 6;//下次进入I2C_MR_DATA_NACK，接收数据准备完成
            }
      }
      else//通讯失败
         {
            Exit();
         }
      break;
case TW_MR_DATA_NACK://数据接收结束
      if ((Count == SubCount) && (Status == 6))
         {
            if (((RxBuffer[0] ^ RxBuffer[2]) == 0xff) && ((RxBuffer[1] ^ RxBuffer[3]) == 0xff))
            {
            if ((RxBuffer[0] & 0xf0) == (SubComm & 0xf0))
                  {
                     Succeed = true;//数据通讯成功
         SetDataBuff();//取出接收字节
            }
                  Stop();//通讯成功
         }
      }
      else//通讯失败
         {
            Exit();
         }
         break;
default:
      Exit();
      break;
}
}