MikeFair
commented
7 years ago Moving on to explain how Slave4, the one I like to call the "immediate transaction slave" works. As you've probably guessed, this one doesn't poll every cycle; you enable it, it does its thing just like the other slaves, then disables itself.
There are flags in the I2C_MST_STATUS register for a NACK on each of the Slaves, I2C_SLV4_DONE, I2C_LOST_ARB, and whether or not the FSYNC interrupt has happend (FSYNC and PASS_THROUGH provide a way to pass interrupts from chips on the "hidden" i2c bus through to the host; ignored from here on).
Once SLV4 is enabled, it will begin working its txn. The I2C_SLV4_DONE flag will go high either when the txn completes or times out (SLV4_NACK also goes high). A control flag can enable the txn completion triggering an interrupt. While a slightly more advanced approach, and requiring an extra wire to the device, if you're thinking of doing a lot of Slave4 work, I think it's likely worth the effort. What I'm doing below are spin loops waiting for the done flag to get set.
Slave4 only works with one byte at a time.
While the others can write one byte or read up to 15 bytes; Slave4 has only two registers it works with.
It gets the byte for a write txn from Register 0x33 (51) I2C_SLV4_DO.
It puts the results of a read txn in Register 0x35 (53) I2C_SLV4_DI.
That all said, it configures in much the same way the other slaves do.
Set the device address, set the register, set the write byte if required, set the control flags, which includes enabling the slave and off it goes.
As Slave4 only works with single bytes a txn, there are no byte swapping or read length controls. There is an I2C_SLV4_REG_DIS (disable writing the register address at txn start) and a SLV4_DONE_INT_EN to trigger the interrupt when the txn completes. There is also an I2C_MST_DLY for all the slaves to alter the frequency of slave device polling, but I'm ignoring that for these comments.
Like the other Slaves, it helps to have a few helper functions to make working with the Slave easier:
#define I2C_SLV4_EN_BIT 7
#define SLV4_DONE_INT_EN_BIT 6
#define I2C_SLV4_REG_DIS_BIT 5
#define I2C_SLV4_DONE_BIT 6
#define I2C_SLV4_NACK_BIT 4
bool writeSlave4Byte(uint8_t primary_address, uint8_t dev_addr, uint8_t reg_addr, bool send_reg_addr, uint8_t data) {
return execSlave4Txn(primary_address, dev_addr, reg_addr, send_reg_addr, false, 1, &data);
}
bool writeSlave4Bytes(uint8_t primary_address, uint8_t dev_addr, uint8_t reg_addr, bool send_reg_addr, uint8_t count, uint8_t* data) {
return execSlave4Txn(primary_address, dev_addr, reg_addr, send_reg_addr, false, count, data);
}
bool readSlave4Byte(uint8_t primary_address, uint8_t dev_addr, uint8_t reg_addr, bool send_reg_addr, uint8_t* data) {
return execSlave4Txn(primary_address, dev_addr, reg_addr, send_reg_addr, true, 1, data);
}
bool readSlave4Bytes(uint8_t primary_address, uint8_t dev_addr, uint8_t reg_addr, bool send_reg_addr, uint8_t count, uint8_t* data) {
return execSlave4Txn(primary_address, dev_addr, reg_addr, send_reg_addr, true, count, data);
}
bool execSlave4Txn(uint8_t primary_address, uint8_t dev_addr, uint8_t reg_addr, bool send_reg_addr, bool is_read, uint8_t count, uint8_t *data)
{
// Use Slave4 to read/write from/to a device on the EDA/ECL bus
dev_addr = ((is_read) ? 0x80 : 0x00) | dev_addr); // Write(0x00) or Read(0x80) from device
writeByte(primary_address, I2C_SLV4_ADDR, dev_addr); // set the slave device address
writeByte(primary_address, I2C_SLV4_REG, reg_addr); // set the slave register address
uint8_t slave_ctrl_byte =
(1 << I2C_SLV4_ENABLE_BIT) // The whole point of this function is to execute txns
//| (trg_int << SLV4_DONE_INT_EN_BIT) // Because of spin loop, don't use the interrupt
| (!send_reg_addr << I2C_SLV4_REG_DIS_BIT) // Affects first txn only; does not send reg after that
//| (i2c_mst_delay % 32) // Ignoring this; read it in the docs if you're curious
;
uint8_t i2c_mst_status; // Variable to watch the status on Slave4Done and Slave4NACK
bool txnFailed = false; // Did the txn fail (Save4Nack or timeout)?
uint8_t nByte = 0;
while (nByte < count) {
if (!is_read) writeByte(primary_address, I2C_SLV4_DO, data[nByte]); // Upload the byte to write
writeByte(primary_address, I2C_SLV4_CTRL, slave_ctrl_byte); // Kick off the txn
slave_ctrl_byte = (1 << I2C_SLV4_ENABLE_BIT); // Disable register send for all remaining txns
long tsTimeout = millis() + 3000; // Emergency timeout for txn (hard coded to 3 secs)
bool slave4Done = false;
while (!slave4Done) {
// Poll the I2C Master Status byte; this resets all NACK flags, the SLV4_Done, and LOST_ARB
readByte(primary_addres, I2C_MST_STATUS, &i2c_mst_status);
// Is the Slave4Done bit set or has timeout expired?
slave4Done = ((i2c_mst_status & (1<< I2C_SLV4_DONE_BIT)) > 0) | (millis() > tsTimeout);
//Print some debug status information to track the state while looping
//Serial.print(slave4Done, HEX); Serial.print("\t");
//Serial.print(i2c_mst_status & (1<< I2C_SLV4_NACK_BIT), HEX); Serial.print("\t");
//Serial.println(i2c_mst_status, HEX);
}
// Is the Slave4NACK bit set or did the timeout expire?
txnFailed = (i2c_mst_status & (1 << I2C_SLV4_NACK_BIT)) | (millis() > tsTimeout);
if (txnFailed) break; // If txnFailed then stop looping and quit
if (is_read) readByte(primary_addres, I2C_SLV4_DI, &data[nByte]); // Fetch the byte that was read
nByte++;
}
return !txnFailed;
}
Once we have those functions, we can work through Slave4 similarly to other normal I2C calls.
This is useful for setting up things like the magnetometer or other devices without having to first rely on using the I2C_BYPASS.
Assuming the Bypass is disabled, and the I2C Master has been configured and enabled, to configure the AK8963 on an mpu925X is as simple as replacing the readByte(s)/writeByte(s) calls with the equivalent readSlave4Byte(s)/writeSlave4Byte(s) calls.
Using the current code from MPU9250.h in this repository would look something like this:
void initAK8963(float * destination) {
// First extract the factory calibration for each magnetometer axis
uint8_t rawData[3]; // x/y/z gyro calibration data stored here
writeSlave4Byte(MPU9250_ADDRESS, AK8963_ADDRESS, AK8963_CNTL, 0x00); // Power down magnetometer
wait(0.01);
writeSlave4Byte(MPU9250_ADDRESS, AK8963_ADDRESS, AK8963_CNTL, 0x0F); // Enter Fuse ROM access mode
wait(0.01);
readSlave4Bytes(MPU9250_ADDRESS, AK8963_ADDRESS, AK8963_ASAX, 3, &rawData[0]); // Read the x-, y-, and z-axis calibration values
destination[0] = (float)(rawData[0] - 128)/256.0f + 1.0f; // Return x-axis sensitivity adjustment values, etc.
destination[1] = (float)(rawData[1] - 128)/256.0f + 1.0f;
destination[2] = (float)(rawData[2] - 128)/256.0f + 1.0f;
writeSlave4Byte(MPU9250_ADDRESS, AK8963_ADDRESS, AK8963_CNTL, 0x00); // Power down magnetometer
wait(0.01);
// Configure the magnetometer for continuous read and highest resolution
// set Mscale bit 4 to 1 (0) to enable 16 (14) bit resolution in CNTL register,
// and enable continuous mode data acquisition Mmode (bits [3:0]), 0010 for 8 Hz and 0110 for 100 Hz sample rates
writeSlave4Byte(MPU9250_ADDRESS, AK8963_ADDRESS, AK8963_CNTL, Mscale << 4 | Mmode); // Set magnetometer data resolution and sample ODR
wait(0.01);
}Assuming Slave 0 had been configured during the MPU initialization, once this init routine is finished, the data will begin appearing in the EXT_SENS_DATA registers automatically.
You can dynamically enable/disable and reconfigure the Slaves at any time, and you can issue one-off requests using Slave 4. The only thing you can't really do is have Slaves loopback and request data from its own MPU; they are strictly downstream requests.
Hope that helps!
kriswiner
fereshtemohebbi
PatelKishanJ
utpalban
noega33
AlexOrlo
Hi all,
I thought I'd demo a different way to get the mag data from an MPU 9X5X. The current method uses the INT_BYPASS mode to access the mag data which works great if you only have 1 sensor connected; but as soon as you try using two it all breaks. It also requires two separate reads; one for the acel/gyro and one for the mag device.
Using the slaves you can make one request from the MPU and get all the data as 24 continuous bytes: 14 bytes for the accel/temp/gyro 2 bytes for info/status1 on mag 6 bytes for mag xyz 2 bytes for status2/control1 on mag
You could technically get away with only reading 7 bytes from the mag (xyz + status2), but by reading 10 bytes you also get the status1 register to examine and it keeps the whole buffer aligned on 16bit boundaries. Using the higher slaves to read other data, would place that data after this data. (The slave txns are executed in slave numeric order. So you can rearrange how the data gets laid out.)
An interesting feature of the slaves is they can automatically swap word bytes so that you can control the endianness of any 16bit word data being read.
====
The MPU units, as most of you are likely to be at least vaguely aware, can act as their own I2C master controller, reading/writing data to registers from their own mag as well as devices on the EDA/ECL bus. The read data is placed into EXT_SENS_DATA which are the 24 registers immediately above the Acc/Tmp/Gyr data.
For a complete picture there's two sets of slaves. Slaves 0-3 which effectively run every cycle and fill the data into EXT_SENS_DATA; and Slave 4 which is good for executing one time transactions.
I'm going to break these two things up into two comments. First configuring the I2C Master and Slaves 0-3, then a second comment on using Slave 4.
Configuring the I2C Master is pretty straight forward.
First disable INT_BYPASS, then configure the I2C master, then enable the I2C master:
Configuring the slaves is even less complicated; set the address, set the register, set the controls to tell the slave what to do. The only "tricky" part I found was that to read from a slave device address you need to set the high bit on the address
slave_device_address = (0x80 | slave_device_address);.A helper function makes setting up the slaves so much easier:
To use that function to set up reading the mag into EXT_SENS_DATA using the functions in this library, you would do something like: