I2C locks up/stuck forever

[borissmidt]

Dear Rahix,

I've implemented some code to read the temperature sensor MLX90614
I already tested the sensor itself using the sample from adaFruit and that works fine.

But it always start to hang after several reads but sadly i don't really know on how i can debug this in rust (i'm new to rust).
I verified that there is no panic by enabling the logging panic from the examples. (sadly i don't have a JTAG debugger to know where the code is stuck).

I suspect that it is stuck in one of the loops but i'm not sure on how to verify this:
while self.twcr.read().twint().bit_is_clear() {}

avr-hal versions tried:

• 533159f6c6a508abe4ecec34bf5013d7a1eb0cf5 // latest branch
• 3b8f39fa2ec5e3359c7bedc33d982e75e8cc3700 //default cargo init

pub struct MLX90614 {
    pub i2c: I2c,
    pub address: u8,
}
const DEFAULT_ADDRESS: u8 = 0x5a;
const OBJECT_TEMPERATURE: u8 = 0x07;
pub type Temperature = i16;
impl MLX90614 {
    pub fn new(i2c: I2c) -> Self {
        MLX90614 {
            i2c: i2c,
            address: DEFAULT_ADDRESS,
        }
    }

    pub fn read_temperature_c(&mut self) -> Result<Temperature, Error> {
        let mut buffer: [u8; 2] = [0; 2];
        let _ = self.i2c.write(self.address, &[OBJECT_TEMPERATURE]);
        let _ = self.i2c.read(self.address, &mut buffer)?;
        return Ok((u16::from_le_bytes(buffer)/ 50) as Temperature - 273);
    }
}

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);
    //
    let mut i2c = arduino_hal::i2c::I2c::new(
        dp.TWI,
        pins.a4.into_pull_up_input(),
        pins.a5.into_pull_up_input(),
        50000,
    );

    let mut serial = arduino_hal::default_serial!(dp, pins, 57600);

    let mut s = MLX90614::new(i2c);
    loop {

        delay_ms(1500);
        ufmt::uwriteln!(&mut serial, "Reading temperature!\r").void_unwrap();

        match s.read_temperature_c() {
            Ok(temp) => {
                ufmt::uwriteln!(&mut serial, "Got {}!\r", temp).void_unwrap();
                // if temp > 10 {
                //     led.toggle();
                // }
            }
            Err(BusError) => {
                ufmt::uwriteln!(&mut serial, "Got BUS error \r").void_unwrap();
            }
            Err(ArbitrationLost) =>
                {
                    ufmt::uwriteln!(&mut serial, "Got ArbitrationLost error \r").void_unwrap();
                }
            Err(AddressNack) =>
                {
                    ufmt::uwriteln!(&mut serial, "Got AddressNack error \r").void_unwrap();
                }
            Err(DataNack) =>
                {
                    ufmt::uwriteln!(&mut serial, "Got DataNack error \r").void_unwrap();
                }
            Err(Unknown) =>
                {
                    ufmt::uwriteln!(&mut serial, "Got Unknown error \r").void_unwrap();
                }
        }
    }
}

result:

Reading temperature!
Got 20!
Reading temperature!
Got 20!
Reading temperature! <-hangs forever

#include <Wire.h>
#include <Adafruit_MLX90614.h>
Adafruit_MLX90614 mlx = Adafruit_MLX90614();

void setup() {
  Serial.begin(9600);
  Serial.println("Adafruit MLX90614 test");  
  mlx.begin();  
}

void loop() {
  Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempC()); 
  Serial.print("*C\tObject = "); Serial.print(mlx.readObjectTempC()); Serial.println("*C");
  Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempF()); 
  Serial.print("*F\tObject = "); Serial.print(mlx.readObjectTempF()); Serial.println("*F");
  Serial.println();
  delay(500);
}

[Rahix]

Hi!

First thing I'd try is whether combining the write and read into a write_read() helps... So changing

        let _ = self.i2c.write(self.address, &[OBJECT_TEMPERATURE]);
        let _ = self.i2c.read(self.address, &mut buffer)?;

to

        let _ = self.i2c.write_read(self.address, &[OBJECT_TEMPERATURE], &mut buffer)?;

---

If this doesn't help, I'd give each of the read-loops an upper bound and return an individual error code when it is hit (just add new ones to the error enum). You can then print out the errors in your main() to find out where it got stuck...

BTW, our error type implements uDebug so you should be able to drop the individual match arms and just write:

            Err(e) => {
                ufmt::uwriteln!(&mut serial, "Got {:?} error!\r", e).void_unwrap();
            }

Let me know how this goes... I guess it would be nice to include some easier way to debug such issues in avr-hal...

[borissmidt]

I used read write initially and i found the bug.
I'll open a pr for it.

A different proposal i think an improved the project template would be like :
To allow unit tests on the host you can split up the project in a top lib projec which builds against embedded-hal and use embedded-hal-mock for tests. Then a sub project implements the code to connect the embedded hal to traits to the embedded-avr code.
(i'm new to rust by the way so there might be much better ways of doing this)

This makes it easier to debug and verify the code that you write yourself. (up to a point).
project structure:

├── arduino <-builds the bin
│   ├── Cargo.lock
│   ├── Cargo.toml
│   └── src
│       └── bin
│           └── toasti-avr.rs
├── avr-specs
│   ├── avr-atmega1280.json
│   ├── avr-atmega168.json
│   ├── avr-atmega2560.json
│   ├── avr-atmega328p.json
│   ├── avr-atmega32u4.json
│   ├── avr-atmega48p.json
│   ├── avr-attiny85.json
│   └── avr-attiny88.json
├── Cargo.lock
├── Cargo.toml
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── rust-toolchain.toml
└── src <- builds the code that i can test on the host system and use embedded-hal-mock instead of the actual hal
    └── lib.rs

[dependencies]
embedded-hal = "0.2.3"

[dev-dependencies]
embedded-hal-mock = "0.8.0"