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;
}
