uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop){ if(quantity > BUFFER_LENGTH) quantity = BUFFER_LENGTH; uint8_t read = twi_readFrom(address, rxBuffer, quantity, sendStop); rxBufferIndex = 0; rxBufferLength = (read == 0)?quantity:0; return rxBufferLength; }
/** Reset the FIFO. * This bit resets the FIFO buffer when set to 1 while FIFO_EN equals 0. This * bit automatically clears to 0 after the reset has been triggered. * @see MPU6050_RA_USER_CTRL * @see MPU6050_USERCTRL_FIFO_RESET_BIT */ uint8_t MPU6050::resetFIFO() { buffer[0] = MPU6050_RA_USER_CTRL; if (twi_writeTo(devAddr, buffer, 1, true)) return 0xFF; if (twi_readFrom(devAddr, buffer+1, 1) != 1) return 0xFF; buffer[1] |= (1 << MPU6050_USERCTRL_FIFO_RESET_BIT); if (twi_writeTo(devAddr, buffer, 2, true)) return 0xFF; return 0; }
size_t TwoWire::requestFrom(uint8_t address, size_t size, bool sendStop){ if(size > BUFFER_LENGTH){ size = BUFFER_LENGTH; } size_t read = (twi_readFrom(address, rxBuffer, size, sendStop) == 0)?size:0; rxBufferIndex = 0; rxBufferLength = read; return read; }
uint8_t RTC_DS1307::isrunning(void) { twi_buf[0] = 0; twi_writeTo(DS1307_ADDRESS, 1); // perform blocking read into buffer (void)twi_readFrom(DS1307_ADDRESS, 1); uint8_t ss = twi_buf[0]; return !(ss>>7); }
int i2c_rd_byte(uint8_t cli_addr, uint8_t *dat) { uint8_t ret; ret = twi_readFrom(cli_addr, dat, 1, SEND_STOP_BIT); if (ret == 0) return -1; return 0; }
uint8_t ICACHE_FLASH_ATTR wire_requestFrom(uint8_t addr, size_t len) { if(len > WIRE_BUFFER_LEN) { len = WIRE_BUFFER_LEN; } size_t read = (twi_readFrom(addr, wire_rxBuffer, len, true) == 0) ? len : 0; wire_rxBufferIndex = 0; wire_rxBufferLength = read; return read; }
/* * Function Seg8b4a036aReadVersion * Desc Read ZT.SEG8B4A036A Fireware Version * Input addr:ZT.SEG8B4A036A Address *buf:Version Buffer * Output .. number bytes of Version Read out */ int ZtLib::Seg8b4a036aReadVersion(uint8_t addr, uint8_t *buf) { uint8_t state = 0xFF; uint8_t temp; uint8_t regv[1] = {REG_VERSION}; temp = twi_writeTo(addr, regv, 1, 1, 0); // no stop if (temp ==0) { temp = twi_readFrom(addr, &(*buf), 19, 1); } return temp; }
int i2c_rd_blk(uint8_t cli_addr, uint8_t *dat, uint8_t len) { uint8_t ret; if (len > TWI_BUFFER_LENGTH) return -1; ret = twi_readFrom(cli_addr, dat, len, SEND_STOP_BIT); if (ret == 0) return -1; return 0; }
void TwoWire::requestFrom(uint8_t address, uint8_t quantity) { // clamp to buffer length if(quantity > BUFFER_LENGTH){ quantity = BUFFER_LENGTH; } // perform blocking read into buffer twi_readFrom(address, rxBuffer, quantity); // set rx buffer iterator vars rxBufferIndex = 0; rxBufferLength = quantity; }
int i2c_rd_addr_byte(uint8_t cli_addr, uint8_t reg_addr, uint8_t *dat) { uint8_t ret; ret = twi_writeTo(cli_addr, ®_addr, 1, USE_BUSY_WAIT, SEND_STOP_BIT); if (ret != 0) return ret; ret = twi_readFrom(cli_addr, dat, 1, SEND_STOP_BIT); if (ret == 0) return -1; return 0; }
uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop) { // clamp to buffer length if(quantity > BUFFER_LENGTH){ quantity = BUFFER_LENGTH; } // perform blocking read into buffer uint8_t read = twi_readFrom(address, rxBuffer, quantity, sendStop); // set rx buffer iterator vars rxBufferIndex = 0; rxBufferLength = read; return read; }
uint8_t i2c_request_from(uint8_t address, uint8_t quantity, uint8_t stop) { // sanity check if(quantity > BUFFER_LENGTH) { quantity = BUFFER_LENGTH; } // perform blocking read into buffer uint8_t read = twi_readFrom(address, rxBuffer, quantity, stop); // reset buffer vars rxBufferIndex = 0; rxBufferLength = read; return read; }
DateTime RTC_DS1307::now() { twi_buf[0] = 0; twi_writeTo(DS1307_ADDRESS, 1); (void)twi_readFrom(DS1307_ADDRESS, 7); uint8_t ss = bcd2bin(twi_buf[0] & 0x7F); uint8_t mm = bcd2bin(twi_buf[1]); uint8_t hh = bcd2bin(twi_buf[2]); uint8_t d = bcd2bin(twi_buf[4]); // #3 IS SKIPPED uint8_t m = bcd2bin(twi_buf[5]); uint16_t y = bcd2bin(twi_buf[6]) + 2000; return DateTime(y, m, d, hh, mm, ss); }
int i2c_rd_addr16_byte(uint8_t cli_addr, uint16_t reg_addr, uint8_t *dat) { uint8_t buf[2]; uint8_t ret; buf[0] = (uint8_t)((0xFF00 & reg_addr) >> 8); /* reg addr MSB */ buf[1] = (uint8_t)(0x00FF & reg_addr); /* reg addr LSB */ ret = twi_writeTo(cli_addr, buf, sizeof(buf), USE_BUSY_WAIT, SEND_STOP_BIT); if (ret != 0) return ret; ret = twi_readFrom(cli_addr, dat, 1, SEND_STOP_BIT); if (ret == 0) return -1; return 0; }
int i2c_rd_addr_blk(uint8_t cli_addr, uint8_t reg_addr, uint8_t *dat, uint8_t len) { uint8_t ret; if (len > TWI_BUFFER_LENGTH) return -1; ret = twi_writeTo(cli_addr, ®_addr, 1, USE_BUSY_WAIT, SEND_STOP_BIT); if (ret != 0) return ret; ret = twi_readFrom(cli_addr, dat, len, SEND_STOP_BIT); if (ret == 0) return -1; return 0; }
/* * Function Seg8b4a036aReadState * Desc Read ZT.SEG8B4A036A Status * Input addr:ZT.SEG8B4A036A Address * Output !=0xFF ZT.SC-I2CMx Status * 0xFF .. other twi error (lost bus arbitration, bus error, ..) */ int ZtLib::Seg8b4a036aReadState(uint8_t addr) { uint8_t state = 0xFF; uint8_t temp; uint8_t buff[1] = {REG_STATUS}; temp = twi_writeTo(addr, buff, 1, 1, 0); // no stop if (temp ==0) { temp = twi_readFrom(addr, buff, 1, 1); } if (temp==1) { state = buff[0]; } return state; }
uint8_t TwoWireMaster::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop) { // clamp to buffer length if(quantity > BUFFER_LENGTH){ quantity = BUFFER_LENGTH; } #if ORG_FILE // perform blocking read into buffer uint8_t read = twi_readFrom(address, rxBuffer, quantity, sendStop); #else // ORG_FILE bool s = twiMstrTransfer((address << 1) | I2C_READ, rxBuffer, quantity, sendStop ? I2C_STOP : I2C_REP_START); uint8_t read = twiMstrBytesTransfered(); #endif // ORG_FILE // set rx buffer iterator vars rxBufferIndex = 0; rxBufferLength = read; return read; }
/* * name: requestFrom * It attempts to become twi bus master and read a series of bytes from a device * on the bus * @param address: 7bit i2c device address * @param quantity: number of bytes to read into array * @return '0' ok, '1' length too long for buffer * */ uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity) { // Secure I2C power management Wire.secureBegin(); // clamp to buffer length if(quantity > BUFFER_LENGTH) { quantity = BUFFER_LENGTH; } // perform blocking read into buffer uint8_t ret = twi_readFrom(address, rxBuffer, quantity); // set rx buffer iterator vars rxBufferIndex = 0; rxBufferLength = quantity; // Secure I2C power management Wire.secureEnd(); return ret; }
/** Get full set of interrupt status bits. * These bits clear to 0 after the register has been read. Very useful * for getting multiple INT statuses, since each single bit read clears * all of them because it has to read the whole byte. * @return Current interrupt status * @see MPU6050_RA_INT_STATUS */ uint8_t MPU6050::getIntStatus() { buffer[0] = MPU6050_RA_INT_STATUS; if (twi_writeTo(devAddr, buffer, 1, true)) return 0xFF; if (twi_readFrom(devAddr, buffer, 1) != 1) return 0xFF; return buffer[0]; }
void i2c_request_bytes(uint8_t address, uint8_t count, uint8_t *out) { twi_readFrom(address, out, count); }
/** Get current FIFO buffer size. * This value indicates the number of bytes stored in the FIFO buffer. This * number is in turn the number of bytes that can be read from the FIFO buffer * and it is directly proportional to the number of samples available given the * set of sensor data bound to be stored in the FIFO (register 35 and 36). * @return Current FIFO buffer size */ uint16_t MPU6050::getFIFOCount() { buffer[0] = MPU6050_RA_FIFO_COUNTH; if (twi_writeTo(devAddr, buffer, 1, true)) return 0xFFFF; if (twi_readFrom(devAddr, buffer, 2) != 2) return 0xFFFF; return (((uint16_t)buffer[0]) << 8) | buffer[1]; }
/** Get byte from FIFO buffer. * This register is used to read and write data from the FIFO buffer. Data is * written to the FIFO in order of register number (from lowest to highest). If * all the FIFO enable flags (see below) are enabled and all External Sensor * Data registers (Registers 73 to 96) are associated with a Slave device, the * contents of registers 59 through 96 will be written in order at the Sample * Rate. * * The contents of the sensor data registers (Registers 59 to 96) are written * into the FIFO buffer when their corresponding FIFO enable flags are set to 1 * in FIFO_EN (Register 35). An additional flag for the sensor data registers * associated with I2C Slave 3 can be found in I2C_MST_CTRL (Register 36). * * If the FIFO buffer has overflowed, the status bit FIFO_OFLOW_INT is * automatically set to 1. This bit is located in INT_STATUS (Register 58). * When the FIFO buffer has overflowed, the oldest data will be lost and new * data will be written to the FIFO. * * If the FIFO buffer is empty, reading this register will return the last byte * that was previously read from the FIFO until new data is available. The user * should check FIFO_COUNT to ensure that the FIFO buffer is not read when * empty. * * @return Byte from FIFO buffer */ uint8_t MPU6050::getFIFOBytes(uint8_t *data, uint8_t length) { buffer[0] = MPU6050_RA_FIFO_R_W; if (twi_writeTo(devAddr, buffer, 1, true)) return 0xFF; if (twi_readFrom(devAddr, data, length) != length) return 0xFF; return 0; }
/** Get Device ID. * This register is used to verify the identity of the device (0b110100, 0x34). * @return Device ID (6 bits only! should be 0x34) * @see MPU6050_RA_WHO_AM_I * @see MPU6050_WHO_AM_I_BIT * @see MPU6050_WHO_AM_I_LENGTH */ uint8_t MPU6050::getDeviceID() { buffer[0] = MPU6050_RA_WHO_AM_I; if (twi_writeTo(devAddr, buffer, 1, true)) return 0xFF; if (twi_readFrom(devAddr, buffer, 1) != 1) return 0xFE; return (buffer[0] >> 1) & 0b111111; }