/******************************************************************************
* FunctionName : user_mvh3004_burst_read
* Description : burst read mvh3004's internal data
* Parameters : uint8 addr - mvh3004's address
* uint8 *pData - data point to put read data
* uint16 len - read length
* Returns : bool - true or false
*******************************************************************************/
LOCAL bool ICACHE_FLASH_ATTR
peri_iaq_single_burst_read(uint8 addr, uint8 *pData, uint16 len)
{
uint8 ack;
uint16 i;
i2c_start();
i2c_writeByte(addr);
ack = i2c_check_ack();
PRINTF("the first ack is:%d\n",ack);
if (ack==0) {
os_printf("addr1 not ack when tx write cmd \n");
i2c_stop();
return false;
}
i2c_writeByte(0x52);
ack = i2c_check_ack();
PRINTF("the second ack is:%d\n",ack);
if (ack==0) {
os_printf("not ack when write 0x52 \n");
i2c_stop();
return false;
}
i2c_start();
i2c_writeByte(addr + 1);
ack = i2c_check_ack();
PRINTF("the third ack is:%d\n",ack);
if (ack==0) {
os_printf("addr2 not ack when tx write cmd \n");
i2c_stop();
return false;
}
os_delay_us(1);
for (i = 0; i < len; i++) {
pData[i] = i2c_readByte();
if(i==3)
i2c_send_ack(0);
else
i2c_send_ack(1);
os_delay_us(1);
PRINTF("bytes_readed:%d\n", pData[i]);
}
i2c_stop();
return true;
}
/**
* Read bytes addressed by internal EEPROM internally incremented counter.
*
* @param buffer for successful operation contains bytes read from EEPROM.
* @param len buffer size.
* @return 0 - success, error code otherwise.
*/
unsigned char eeprom_readCurrentAddress(unsigned char* buffer, unsigned char len)
{
i2c_start();
// Control byte for reading, should be followed by ACK from EEPROM.
i2c_transmitByte(CONTROL_BYTE_READ);
// Now EEPROM sends bytes addressed by the internal counter.
for (unsigned char i = 0; i < len; i++)
{
// EEPROM should acknowledge each time
if (!i2c_check_ack())
{
i2c_stop();
return EEPROM_NO_ACK;
}
buffer[i] = i2c_receiveByte();
}
// Finally master won't acknowledge and then generate a Stop condition.
i2c_send_ack(NACK);
i2c_stop();
return EEPROM_OK;
}
uint8 TwoWire::requestFrom(uint8 address, int num_bytes) {
if (num_bytes > WIRE_BUFSIZ) num_bytes = WIRE_BUFSIZ;
rx_buf_idx = 0;
rx_buf_len = 0;
i2c_start(port);
i2c_shift_out(port, (address << 1) | I2C_READ);
if (!i2c_get_ack(port)) {
return 0;
}
while (rx_buf_len < num_bytes) {
rx_buf[rx_buf_len++] = i2c_shift_in(port);
if(rx_buf_len < num_bytes) {
i2c_send_ack(port);
}
}
i2c_send_nack(port);
i2c_stop(port);
return rx_buf_len;
}
uint8 TwoWire::requestFrom(uint8 address, int num_bytes) {
if (num_bytes > WIRE_BUFSIZ) num_bytes = WIRE_BUFSIZ;
rx_buf_idx = 0;
rx_buf_len = 0;
i2c_start(port);
i2c_shift_out(port, (address << 1) | I2C_READ);
if (!i2c_get_ack(port)) {
//Serial1.print("requestFrom failed at byte ");
//Serial1.print(rx_buf_len,10);
//Serial1.println();
return ENACKADDR;
}
while (rx_buf_len < num_bytes) {
rx_buf[rx_buf_len++] = i2c_shift_in(port);
if(rx_buf_len < num_bytes) {
i2c_send_ack(port);
}
}
i2c_send_nack(port);
i2c_stop(port);
return rx_buf_len;
}
// not debugged
uns8 i2c_rx_multi( uns8 addr, uns8 *data_ptr, uns8 length )
{
uns8 dt;
i2c_start(); // send START
if( i2c_put_byte( addr ) ) // slave did not acknowledge
{
i2c_stop();
return( I2C_NO_ACK_ADDR );
}
while( length )
{
length--;
dt = i2c_get_byte(); // get a data byte
*data_ptr++ = dt;
if( length )
i2c_send_ack(); // this is not the last byte
}
i2c_send_noack(); // this was the last byte
i2c_stop(); // send STOP
return( I2C_NORMAL );
}
static void ICACHE_FLASH_ATTR tcn75_read_all(void *arg)
{
int i;
uint8 dtmp1, dtmp2;
// set in one shot mode
i2c_init();
for (i=0; i < 8; i++) {
uint8_t addr = TCN_BASE_ADDR | i;
if (!(present&(1<<i))) {
continue;
}
i2c_start();
i2c_writeByte(addr << 1);
if (!i2c_check_ack()) {
i2c_stop();
data[i] |= INVALID_READING;
continue;
}
i2c_writeByte(TCN_TA);
if (!i2c_check_ack()) {
i2c_stop();
data[i] |= INVALID_READING;
continue;
}
i2c_stop();
i2c_start();
// now read
i2c_writeByte((addr<<1)|1); // i2c read
if (!i2c_check_ack()) {
i2c_stop();
data[i] |= INVALID_READING;
continue;
}
dtmp1=i2c_readByte(); //read MSB
i2c_send_ack(1);
dtmp2 = i2c_readByte(); //read LSB
i2c_send_ack(0); //NACK READY FOR STOP
data[i]= ((dtmp1<<8)|dtmp2);
i2c_stop();
}
}
static int i2c_do_read(i2c_t *obj, char * data, int last) {
if (last)
i2c_send_nack(obj);
else
i2c_send_ack(obj);
*data = (obj->i2c->D & 0xFF);
// start rx transfer and wait the end of the transfer
return i2c_wait_end_rx_transfer(obj);
}
/* Function sht21_read_raw_value
*
* */
uint16_t ICACHE_FLASH_ATTR sht21_read_raw(uint8_t reg) {
if(!sht21_writeCommand(SHT21_ADDR_W, reg))
return 999;
os_delay_us(20);
sht21_readCommand(SHT21_ADDR_R);
uint8_t msb = i2c_readByte();
i2c_send_ack(1);
uint8_t lsb = i2c_readByte();
i2c_send_ack(0);
i2c_stop();
uint16_t rawH = msb << 8 | lsb;
rawH = rawH & 0xFFFC;
return rawH;
}
unsigned char i2c_read(unsigned char dev,
unsigned char reg,
unsigned char length,
unsigned char * data)
{
unsigned char i ;
i2c_start() ;
i2c_send_byte(dev) ;
i2c_send_byte(reg) ;
i2c_start() ;
i2c_send_byte(dev + 1) ;
for(i = 0; i < length; i ++)
{
data[i] = i2c_recv_byte() ;
if(i == length-1)
i2c_send_ack(_NACK) ;
else
i2c_send_ack(_ACK) ;
}
i2c_stop() ;
return 0 ;
}
void SequentialRead24c512(unsigned char faddr,
unsigned char saddr,
unsigned char *dat,
unsigned char num)
{
unsigned char i;
i2c_start();
i2c_send_byte(0xA0);
i2c_send_byte(faddr);
i2c_send_byte(saddr);
i2c_start() ;
i2c_send_byte(0xA1);
for(i=0;i<num;i++)
{
dat[i] = i2c_recv_byte();
if(i == num-1)
i2c_send_ack(_NACK) ;
else
i2c_send_ack(_ACK) ;
}
i2c_stop();
}
uint8 TwoWire::process() {
itc_msg.xferred = 0;
uint8 sla_addr = (itc_msg.addr << 1);
if (itc_msg.flags == I2C_MSG_READ) {
sla_addr |= I2C_READ;
}
i2c_start();
// shift out the address we're transmitting to
i2c_shift_out(sla_addr);
if (!i2c_get_ack())
{
i2c_stop();// Roger Clark. 20141110 added to set clock high again, as it will be left in a low state otherwise
return ENACKADDR;
}
// Recieving
if (itc_msg.flags == I2C_MSG_READ) {
while (itc_msg.xferred < itc_msg.length) {
itc_msg.data[itc_msg.xferred++] = i2c_shift_in();
if (itc_msg.xferred < itc_msg.length)
{
i2c_send_ack();
}
else
{
i2c_send_nack();
}
}
}
// Sending
else {
for (uint8 i = 0; i < itc_msg.length; i++) {
i2c_shift_out(itc_msg.data[i]);
if (!i2c_get_ack())
{
i2c_stop();// Roger Clark. 20141110 added to set clock high again, as it will be left in a low state otherwise
return ENACKTRNS;
}
itc_msg.xferred++;
}
}
i2c_stop();
return SUCCESS;
}
/**********************************************************************
functionName:void pcf8563_get(uint8_t start,uint8_t num,uint8_t *buf)
description:获取数据
**********************************************************************/
void pcf8563_get(uint8_t start,uint8_t num,uint8_t *buf)
{
uint8_t i;
i2_start();
i2c_sendbyte(0xA2);
i2c_wait_ack();
i2c_sendbyte(start);
i2c_wait_ack();
i2_start();
i2c_sendbyte(0xA3);
i2c_wait_ack();
for (i=0;i<num;i++)
{
buf[i]=i2c_recv_byte();
if (i!=(num-1)) i2c_send_ack();
}
i2c_send_notack();
i2_stop();
}
static unsigned char i2c_read_byte( void )
{
int i;
unsigned char temp, data = 0;
GPIOPIN_Set_Fast( GPIO_SCL, GPIO_I2C_SCL_LOW );
GPIOPIN_Set_Fast( GPIO_SDA, GPIO_I2C_SDA_HIGH );
for (i=7; i>=0; i--) {
GPIOPIN_Set_Fast( GPIO_SCL, GPIO_I2C_SCL_LOW );
delay();
GPIOPIN_Set_Fast( GPIO_SCL, GPIO_I2C_SCL_HIGH );
GPIOPIN_Get_Fast(GPIO_SDA, &temp);
data = (data <<1) | temp; //从高位到低位依次准备数据进行读取
delay();
}
i2c_send_ack(); //向目标设备发送ACK信号
return data;
}
static unsigned char i2c_readbyte(int ack_required)
{
int i;
unsigned char data=0;
/*read data*/
i2c_set_lines(0,1);
for (i=7; i>=0; i--)
{
i2c_set_lines(1,1);
if (i2c_get_data()==1)
data |= (1<<i);
i2c_set_lines(0,1);
}
/*send acknowledge*/
if (ack_required) i2c_send_ack();
return data;
}
int gpio_i2c_rd_arr(int Grp, unsigned char dev,
unsigned char rarr[], int rsize,
unsigned char darr[], int dsize)
{
int i;
I2C_LOCK(Grp);
i2c_start_bit(Grp);
i2c_send_byte(Grp, dev);
i2c_receive_ack(Grp);
for(i = 0; i < rsize; i ++) {
i2c_send_byte(Grp, rarr[i]);
i2c_receive_ack(Grp);
}
if(dsize > 0) {
i2c_start_bit(Grp);
i2c_send_byte(Grp, (unsigned char)(dev) | 1);
i2c_receive_ack(Grp);
for(i = 0; i < dsize-1; i ++) {
darr[i] = i2c_receive_byte(Grp);
i2c_send_ack(Grp);
}
darr[i] = i2c_receive_byte(Grp);
}
i2c_stop_bit(Grp);
I2C_UNLOCK(Grp);
return 0;
}
uint8 TwoWire::process() {
itc_msg.xferred = 0;
uint8 sla_addr = (itc_msg.addr << 1);
if (itc_msg.flags == I2C_MSG_READ) {
sla_addr |= I2C_READ;
}
i2c_start();
// shift out the address we're transmitting to
i2c_shift_out(sla_addr);
if (!i2c_get_ack()) {
return ENACKADDR;
}
// Recieving
if (itc_msg.flags == I2C_MSG_READ) {
while (itc_msg.xferred < itc_msg.length) {
itc_msg.data[itc_msg.xferred++] = i2c_shift_in();
if (itc_msg.xferred < itc_msg.length) {
i2c_send_ack();
} else {
i2c_send_nack();
}
}
}
// Sending
else {
for (uint8 i = 0; i < itc_msg.length; i++) {
i2c_shift_out(itc_msg.data[i]);
if (!i2c_get_ack()) {
return ENACKTRNS;
}
itc_msg.xferred++;
}
}
i2c_stop();
return SUCCESS;
}
int16_t ICACHE_FLASH_ATTR
SHT21_GetVal(uint8 mode)
{
i2c_start(); //Start i2c
i2c_writeByte(SHT21_ADDRESS);
if (!i2c_check_ack()) {
//os_printf("-%s-%s slave not ack... return \r\n", __FILE__, __func__);
i2c_stop();
return(0);
}
if (mode==GET_SHT_TEMPERATURE)
i2c_writeByte(TRIGGER_TEMP_MEASURE_NOHOLD);
else if (mode==GET_SHT_HUMIDITY)
i2c_writeByte(TRIGGER_HUMD_MEASURE_NOHOLD);
else
return 0;
if (!i2c_check_ack()) {
//os_printf("-%s-%s slave not ack... return \r\n", __FILE__, __func__);
i2c_stop();
return(0);
}
os_delay_us(20);
i2c_stop();
os_delay_us(70000);
uint8 ack = 0;
while (!ack) {
i2c_start();
i2c_writeByte(SHT21_ADDRESS+1);
ack = i2c_check_ack();
if (!ack) i2c_stop();
}
//os_printf("-%s-%s get ack \r\n", __FILE__, __func__);
uint8 msb = i2c_readByte();
i2c_send_ack(1);
uint8 lsb = i2c_readByte();
i2c_send_ack(0);
i2c_stop();
uint16_t _rv = msb << 8;
_rv += lsb;
_rv &= ~0x0003;
//os_printf("-%s-%s RAW:%d \r\n", __FILE__, __func__,_rv);
float rv = _rv;
if (mode==GET_SHT_TEMPERATURE) {
rv *= 175.72;
rv /= 65536;
rv -= 46.85;
} else if (mode==GET_SHT_HUMIDITY) {
rv *= 125.0;
rv /= 65536;
rv -= 6.0;
}
return (int16_t)(rv*10);
}
int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{
unsigned int loop, rxdata;
int sadr, ack, bytes_read;
rxdata = 0;
switch ((int)obj->i2c) {
case I2C_0:
sadr = TSC_I2C_ADDR;
break;
case I2C_1:
sadr = AAIC_I2C_ADDR;
break;
case I2C_2:
case I2C_3:
sadr = address; //LM75_I2C_ADDR; or MMA7660_I2C_ADDR;
break;
}
bytes_read = 0;
// Start bit
i2c_start(obj);
switch ((int)obj->i2c) {
case I2C_0:
// Set serial and register address
i2c_send_byte(obj, sadr);
ack += i2c_receive_ack(obj);
i2c_send_byte(obj, address);
ack += i2c_receive_ack(obj);
// Stop bit
i2c_stop(obj);
// Start bit
i2c_start_tsc(obj);
// Read from I2C address
i2c_send_byte(obj, sadr | 1);
ack += i2c_receive_ack(obj);
rxdata = (i2c_receive_byte(obj) & 0xFF);
data[((length - 1) - bytes_read)] = (char)rxdata;
bytes_read++;
// Read multiple bytes
if ((length > 1) && (length < 5)) {
for (loop = 1; loop <= (length - 1); loop++) {
// Send ACK
i2c_send_ack(obj);
// Next byte
//rxdata = ((rxdata << 8) & 0xFFFFFF00);
//rxdata |= (i2c_receive_byte(obj) & 0xFF);
rxdata = i2c_receive_byte(obj);
data[(length - 1) - bytes_read] = (char)rxdata;
bytes_read++;
}
}
break;
case I2C_1:
// Set serial and register address
i2c_send_byte(obj, sadr);
ack += i2c_receive_ack(obj);
i2c_send_byte(obj, address);
ack += i2c_receive_ack(obj);
// Stop bit
i2c_stop(obj);
// Start bit
i2c_start_tsc(obj);
// Fall through to read data
case I2C_2:
case I2C_3:
// Read from preset register address pointer
i2c_send_byte(obj, sadr | 1);
ack += i2c_receive_ack(obj);
rxdata = i2c_receive_byte(obj);
data[bytes_read] = (char)rxdata;
bytes_read++;
// Read multiple bytes
if ((length > 1) && (length < 5)) {
for (loop = 1; loop <= (length - 1); loop++) {
// Send ACK
i2c_send_ack(obj);
// Next byte
rxdata = i2c_receive_byte(obj);
data[loop] = (char)rxdata;
bytes_read++;
}
}
break;
}
i2c_send_nack(obj);
i2c_stop(obj); // Actual stop bit
return bytes_read;
}
