Great work on this library! I have created a slightly renamed version of it, called FastWire (from a suggestion somebody else made). The naming is the only difference. Everything else is as you wrote it so far.
I hope to try it out soon.
// Interrupt flag - uncomment and set below to make the specified pin high whenever the
// I2C interrupt occurs. This is useful as a trigger signal when using a logic analyzer.
//
#define I2C0_INTR_FLAG_PIN 8
#define I2C1_INTR_FLAG_PIN 9static const uint8_t SLA = 0x1D;
static const uint16_t timeout = 100000; // this was 100, but I wanted 100 ms (!)
bool LSM303D::begin()
{
// configure
Wire.beginTransmission(SLA); // slave addr
Wire.write(0x20); // memory address (CTRL1)
Wire.write((0b0101 << 4) | (1 << 3) | 0b111) ; // accel normal mode, 50 Hz, block data update, all axes enabled
if (Wire.endTransmission(I2C_STOP, timeout) != 0)
{
return false;
}
Wire.beginTransmission(SLA); // slave addr
Wire.write(0x24); // memory address (CTRL5)
Wire.write((0b11 << 5) | (0b100 << 2) | 0b111) ; // magn high resolution, 50 Hz
if (Wire.endTransmission(I2C_STOP, timeout) != 0)
{
return false;
}
Wire.beginTransmission(SLA); // slave addr
Wire.write(0x25); // memory address (CTRL5)
Wire.write(0b00 << 5); // magn full scale: +-2 gauss
if (Wire.endTransmission(I2C_STOP, timeout) != 0)
{
return false;
}
Wire.beginTransmission(SLA); // slave addr
Wire.write(0x26); // memory address (CTRL5)
Wire.write(0); // magn enable
if (Wire.endTransmission(I2C_STOP, timeout) != 0)
{
return false;
}
return true;
}bool LSM303D::read()
{
// read accel
Wire.beginTransmission(SLA);
Wire.write(0x28 | 0x80); // read accel, continuous
Wire.endTransmission(I2C_NOSTOP, timeout);
Wire.requestFrom(SLA, 6, I2C_STOP, timeout);
uint8_t i = Wire.available();
std::array<uint8_t, 6> buf;
if(i == 6)
{
for(uint8_t i = 0; i < 6; i++)
{
buf[i] = Wire.readByte();
}
... process data in buf ...
}
else
{
for (uint8_t j = 0; j < i; j++)
{
// empty buffer and discard data
Wire.readByte();
}
return false;
}
... more read operations ...
}EDIT: I have downloaded the latest Version and it works slightly better, with occasional lockups lasting until I cycle power.
I have an LSM303DLHC that is part of the 10DOF IMU Breakout Board from Adafruit. It seems to work fine with the standard Wire library for both regular Arduino and TeensyDuino, although I am still testing this to be sure everything is right. Some of my orientation readings seem to be off with the Teensy 3.1. I have not tried using this new I2C library for the Teensy 3.1 yet so don't know if there are any differences.
Try the LSM303 library from Adafruit. That's what I have been using for both Arduino and Teensy 3.1, with the standard Wire libraries for both. However, I am not sure it is returning correct results for the Teensy 3.1. My orientation readings (pitch, roll, and heading) aren't correct for the Teensy 3.1. Maybe you can get better results using this new I2C library. I would definitely like to hear about your results with the Adafruit LSM303 library using the new I2C stuff.
You have over-ranged this. The largest delay you can get with a uint16 will be 65535us. If you really want a timeout that long I can try to rework the routines to maybe support milliseconds. I did not expect people would use timeouts that long.
The code looks ok at first glance. If you can provide more information I'll think about it some more. I am not familiar with a LSM303D, I'll need to pull a datasheet on it. If we can't identify a solution then I can probably acquire one and experiment on it. What specifically are you using?
Slaves can hang if the clocking gets somehow confused between Master and Slave. For instance on a bit-banged Master (not what we are using here, just an example), if the Master drives the SCL line as a CMOS line, not a open-drain, then it will not recognize Slave clock-stretching. So on a Rx command (Slave sending data to Master) the Slave thinks it is stretching the clock and the Master keeps banging away, they become completely out-of-sync and eventually the Slave ends up getting a partial clock and hangs in the middle of transmitting a byte. At that point you are done, the bus is hung. There are other similar ways, basically anything that ends up holding SCL or SDA low indefinitely will hang the bus.
Well the real solution is to not hang the bus in the first place. The less correct (but probably equally workable) solution is for single-Master setups. In the i2c_t3.cpp file look for lines like this (I think there are two spots):
// we are not currently the bus master, so wait for bus ready
while(*(i2c->S) & I2C_S_BUSY);I'm running the bus at 400 kHz, this is my call to begin():
Wire.begin(I2C_MASTER, 0x00, I2C_PINS_16_17, I2C_PULLUP_EXT, I2C_RATE_400);begin() was hanging in the first call to endTransmission(), which I didn't expect at all, because I thought that the timeout would make endTransmission() return after the given time.
Unfortunately, I don't.
I'll try that, thanks for that! It's a single-Master setup and it will stay that way. I might more slaves, though, but that shouldn't make a difference (my experience is that more slaves *will* make a difference).
This is very suspicious. I'm assuming that you start with a power-cycle on the Teensy3. If so, the hardware cannot think that it is a busy bus, so it should never hang on the first Tx call. There is no prior I2C activity to it hanging on the first call to endTransmission() is that right?
Ok, well if we can't get your system stable I'll look into getting one of these. I use this library in my own stuff, so I'm definitely interested in making it reliable.
Ok, more information is better. Another thing to try - if you can isolate the problem to a repeatable case, say the first Tx to occur after a Rx, then just after the Rx (prior to the Tx), you can have the system pause, and then probe SCL/SDA with a voltmeter. They should both be high. In the general case, if either line is low after a STOP has been issued (at the end of any Tx or Rx command, except when I2C_NOSTOP is used), then something is wrong.
bool LSM303D::read()
{
// read accel
Serial.println("LSM303::read() 1"); Serial.flush();
Wire.beginTransmission(SLA);
Wire.write(0x28 | 0x80); // read accel, continuous
Serial.print("LSM303::read() 2"); Serial.flush();
if (Wire.endTransmission(I2C_NOSTOP, timeout) != 0)
{
Serial.println("error"); Serial.flush();
return false;
}
Serial.println("\nLSM303::read() 3"); Serial.flush(); // <========== When it hangs, this is the last message
if (Wire.requestFrom(SLA, 6, I2C_STOP, timeout) == 0) // <========== So this must be the bad one that doesn't return
{
Serial.println("error"); Serial.flush();
return false;
}
uint8_t i = Wire.available();
std::array<uint8_t, 6> buf;
if(i == 6)
{
for(uint8_t i = 0; i < 6; i++)
{
buf[i] = Wire.readByte();
}
... data processing ...
}
else
{
for (uint8_t j = 0; j < i; j++)
{
// empty buffer and discard data
Wire.readByte();
}
return false;
}
// read magn
Serial.println("LSM303::read() 4"); Serial.flush();
Wire.beginTransmission(SLA);
Wire.write(0x08 | 0x80); // read magn, continuous
Serial.println("LSM303::read() 5"); Serial.flush();
if (Wire.endTransmission(I2C_NOSTOP, timeout) != 0)
{
Serial.println("error"); Serial.flush();
return false;
}
Serial.println("LSM303::read() 6"); Serial.flush();
if (Wire.requestFrom(SLA, 6, I2C_STOP, timeout) == 0)
{
Serial.println("error"); Serial.flush();
return false;
}
i = Wire.available();
if(i == 6)
{
for(uint8_t i = 0; i < 6; i++)
{
buf[i] = Wire.readByte();
}
... data processing ...
}
else
{
for (uint8_t j = 0; j < i; j++)
{
// empty buffer and discard data
Wire.readByte();
}
return false;
}
return true;
}void i2c_t3::sendRequest_(struct i2cStruct* i2c, uint8_t addr, size_t len, i2c_stop sendStop)
{
// exit immediately if request for 0 bytes
if(len == 0) return;
i2c->reqCount=len; // store request length
i2c->rxBufferIndex = 0; // reset buffer
i2c->rxBufferLength = 0;
// clear the status flags
*(i2c->S) = I2C_S_IICIF | I2C_S_ARBL;
// now take control of the bus...
if(*(i2c->C1) & I2C_C1_MST)
{
// we are already the bus master, so send a repeated start
I2C_DEBUG_STR("RSTART"); // Repeated START
*(i2c->C1) = I2C_C1_IICEN | I2C_C1_MST | I2C_C1_RSTA | I2C_C1_TX;
}
else
{
// we are not currently the bus master, so wait for bus ready
[COLOR="#FF0000"][B]//while(*(i2c->S) & I2C_S_BUSY);[/B][/COLOR]
// become the bus master in transmit mode (send start)
I2C_DEBUG_STR("START"); // START
i2c->currentMode = I2C_MASTER;
*(i2c->C1) = I2C_C1_IICEN | I2C_C1_MST | I2C_C1_TX;
}
// send 1st data and enable interrupts
i2c->currentStatus = I2C_SEND_ADDR;
i2c->currentStop = sendStop;
*(i2c->C1) = I2C_C1_IICEN | I2C_C1_IICIE | I2C_C1_MST | I2C_C1_TX; // enable intr
uint8_t target = (addr << 1) | 1; // address + READ
I2C_DEBUG_STR("T:"); I2C_DEBUG_HEX(target); I2C_DEBUG_STRB("\n"); // target addr
*(i2c->D) = target;
}static const uint32_t timeout = 100000; // this was 100, but I wanted 100 ms (!)//while(*(i2c->S) & I2C_S_BUSY);uint8_t i2c_t3::finish_(struct i2cStruct* i2c, uint32_t timeout)
{
deltaT = elapsedMicros();
int i =0;
[B] while(!done_(i2c) && (timeout == 0 || deltaT < timeout)) ;[/B]
...
} Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_EXT, I2C_RATE_800); Wire.beginTransmission(devAddr);
Wire.write(regAddr);
Wire.endTransmission();
Wire.beginTransmission(devAddr);
Wire.requestFrom((int) devAddr, (int)minvolatile uint8_t flag=0;
void timerISR() // <-- IntervalTimer ISR
{
flag=1; // set flag based on IntervalTimer timing
}
void loop() // <-- main loop
{
if(flag)
{
// do I2C stuff here
flag=0;
}
}I will double check this, maybe as was just a bit confused because of to less coffee and to much debugging
Timing is rather critical because the code collects samples to run a FFT on it. Allready tried your suggestion before but (without further optimization) results are not very promising.
Good point. The line was not in my original version of code by searching around the web i found this line (or similar) in a lot of code so i tried it out: same result.
// 0 = highest priority
// Cortex-M4: 0,16,32,48,64,80,96,112,128,144,160,176,192,208,224,240
// Cortex-M0: 0,64,128,192
#define NVIC_SET_PRIORITY(irqnum, priority) (*((volatile uint8_t *)0xE000E400 + (irqnum)) = (uint8_t)(priority))
#define NVIC_GET_PRIORITY(irqnum) (*((uint8_t *)0xE000E400 + (irqnum)))void setup()
{
...
// probably do this after Wire and IntervalTimer setup (just so nothing resets to defaults)
NVIC_SET_PRIORITY(IRQ_PIT_CH0,16);
NVIC_SET_PRIORITY(IRQ_PIT_CH1,16);
NVIC_SET_PRIORITY(IRQ_PIT_CH2,16);
NVIC_SET_PRIORITY(IRQ_PIT_CH3,16);
// and just for completeness
NVIC_SET_PRIORITY(IRQ_I2C0,0);
NVIC_SET_PRIORITY(IRQ_I2C1,0);
...
}NVIC_SET_PRIORITY(IRQ_I2C0,0);
void serial3_putchar(uint32_t c)
{
uint32_t head;
if (!(SIM_SCGC4 & SIM_SCGC4_UART2)) return;
head = tx_buffer_head;
if (++head >= TX_BUFFER_SIZE) head = 0;
while (tx_buffer_tail == head) {
int priority = nvic_execution_priority();
if (priority <= IRQ_PRIORITY) {
if ((UART2_S1 & UART_S1_TDRE)) {
uint32_t tail = tx_buffer_tail;
if (++tail >= TX_BUFFER_SIZE) tail = 0;
UART2_D = tx_buffer[tail];
tx_buffer_tail = tail;
}
} else if (priority >= 256) {
yield(); // wait
}
}
tx_buffer[head] = c;
transmitting = 1;
tx_buffer_head = head;
UART2_C2 = C2_TX_ACTIVE;
}