//! # I2C Driver
//tests
use anyhow;
use esp_idf_hal::{
    i2c::{config::MasterConfig, Master, MasterPins, I2C0},
    peripherals::Peripherals,
    prelude::*,
};
use esp_idf_sys::*;
use hardware_check::imc42670p::{IMC42670P, SlaveAddr};

// Dont change this file. Work in the lib.rs and modify it so main.rs runs.

fn main() -> anyhow::Result<()> {
    link_patches();

    let peripherals = Peripherals::take().unwrap();

    let sda = peripherals.pins.gpio10;
    let scl = peripherals.pins.gpio8;
    // If you are using an ESP32-C3-DevKitC-02, change to:
    // let sda = peripherals.pins.gpio4;
    // let scl = peripherals.pins.gpio5;

    let i2c = Master::<I2C0, _, _>::new(
        peripherals.i2c0,
        MasterPins { sda, scl },
        <MasterConfig as Default>::default().baudrate(400.kHz().into()),
    )?;

    let mut sensor = IMC42670P::new(i2c, SlaveAddr::AD0)?;
    // If you are using an ESP32-C3-DevKitC-02, change to:
    // let mut sensor = IMC42670P::new(i2c, SlaveAddr::AD1)?;

    println!("Sensor init");
    let device_id = sensor.read_device_id_register()?;

    // assert_eq!(device_id, 103_u16);
    println!("Hello, world, I am sensor {}", device_id);

   loop {};


}




main.rs

diagram.json

// Wokwi Custom Chip - For information and examples see:
// https://link.wokwi.com/custom-chips-alpha
//
// SPDX-License-Identifier: MIT
// Copyright (C) 2022 Uri Shaked / wokwi.com


// https://3cfeqx1hf82y3xcoull08ihx-wpengine.netdna-ssl.com/wp-content/uploads/2021/07/DS-000451-ICM-42670-P-v1.0.pdf
#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

const int ADDRESS = 0x68;

typedef enum
{
  REG_WHO_AM_I = 0x75
} Registers;

typedef enum
{
  ST_EXPECTING_CONNECT,
  ST_EXPECTING_READ_BYTE_1,
  ST_EXPECTING_READ_BYTE_2,
  ST_EXPECTING_WRITE_BYTE_1,
  ST_EXPECTING_WRITE_BYTE_2,
} States;

typedef struct
{
  States state;
  uint8_t internal_address;
  uint8_t product_id_hi;
  uint8_t product_id_lo;
} chip_state_t;

static bool on_i2c_connect(void *user_ctx, uint32_t address, bool connect);
static uint8_t on_i2c_read(void *user_ctx);
static bool on_i2c_write(void *user_ctx, uint8_t data);

void chip_init()
{
  printf("IMC42670P Stub starting\n");
  chip_state_t *chip = calloc(1, sizeof(chip_state_t));

  chip->product_id_hi = 0x67;
  chip->product_id_lo = 0x0;

  //
  // Initialise I2C
  //
  const i2c_config_t i2c_config =
  {
    .user_data = chip,
    .address = ADDRESS,
    .scl = pin_init("SCL", INPUT), 
    .sda = pin_init("SDA", INPUT),
    .connect = on_i2c_connect,
    .read = on_i2c_read,
    .write = on_i2c_write
  };
  i2c_init(&i2c_config);
  
}

bool on_i2c_connect(void *user_ctx, uint32_t address, bool read)
{
  chip_state_t *chip = user_ctx;

  if (read)
  {
    chip->state = ST_EXPECTING_READ_BYTE_1;
  }
  else
  {
    chip->state = ST_EXPECTING_WRITE_BYTE_1;
  }
  return true; /* Ack */
}

uint8_t on_i2c_read(void *user_ctx)
{
  chip_state_t *chip = user_ctx;
  uint8_t result;

  switch (chip->state)
  {
    case ST_EXPECTING_READ_BYTE_1:
      switch (chip->internal_address)
      {
        case REG_WHO_AM_I:
          result = chip->product_id_hi;
          chip->state = ST_EXPECTING_READ_BYTE_2;
          break;
        default:
          chip->state = ST_EXPECTING_CONNECT;
          result = 0;
          break;
      }
      break;
    case ST_EXPECTING_READ_BYTE_2:
      switch (chip->internal_address)
      {
        case REG_WHO_AM_I:
          result = chip->product_id_lo;
          chip->state = ST_EXPECTING_CONNECT;
          break;
        default:
          result = 0;
          chip->state = ST_EXPECTING_CONNECT;
          break;
      }
      break;
    default:
      result = 0;
      chip->state = ST_EXPECTING_CONNECT;
      break;
  }
  return result;
}

bool on_i2c_write(void *user_ctx, uint8_t data)
{
  chip_state_t *chip = user_ctx;

  switch (chip->state)
  {
    case ST_EXPECTING_WRITE_BYTE_1:
      chip->internal_address = data;
      chip->state = ST_EXPECTING_WRITE_BYTE_2;
      break;
    case ST_EXPECTING_WRITE_BYTE_2:
      chip->state = ST_EXPECTING_CONNECT;
      break;
    default:
      chip->state = ST_EXPECTING_CONNECT;
      break;
  }
  return true; // Ack
}


void on_i2c_disconnect(void *user_data) {
  // Do nothing
}


stub-imc42670p.chip.c

IMC42670P

stub-imc42670p.chip.json

#![deny(unsafe_code)]
#![no_std]

pub mod imc42670p;

lib.rs

#![deny(unsafe_code)]

use embedded_hal::blocking::i2c;

/// IMC42670P device driver.
/// Datasheet: https://3cfeqx1hf82y3xcoull08ihx-wpengine.netdna-ssl.com/wp-content/uploads/2021/07/DS-000451-ICM-42670-P-v1.0.pdf
#[derive(Debug)]
pub struct IMC42670P<I2C> {
    /// The concrete I²C device implementation.
    i2c: I2C,

    /// Device address
    address: SlaveAddr,
}

// see Table 3.3.2
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum SlaveAddr {

    AD0 = 0b110_1000,
    AD1 = 0b110_1001,
}

impl<I2C, E>IMC42670P<I2C>
where
    I2C: i2c::WriteRead<Error = E> + i2c::Write<Error = E>,
{
    /// Creates a new instance of the sensor, taking ownership of the i2c peripheral
    pub fn new(i2c: I2C, address: SlaveAddr) -> Result<Self, E> {

        let imc42670p = IMC42670P { i2c, address };

        Ok(imc42670p)
    }

    /// Should return `0x67 (if it doesn't, something is amiss)
    /// Public method that can be accessed from outside this file
    pub fn read_device_id_register(&mut self) -> Result<u16, E> {
        self.read_register(Register::WhoAmI)
    }

    /// Writes into a register
    /// This method is not public as it is only needed inside this file
    #[allow(unused)]
    fn write_register(&mut self, register: Register, value: u8) -> Result<(), E> {
        let byte = value as u8;
        self.i2c
            .write(self.address as u8, &[register.address(), byte])
    }

    /// Reads a register using a `write_read` method.
    /// this method is not public as it is only needed inside this file
    fn read_register(&mut self, register: Register) -> Result<u16, E> {
        let mut data = [0; 2];
        self.i2c
            .write_read(self.address as u8, &[register.address()], &mut data)?;
        Ok(u16::from_le_bytes(data))
    }
}

// Table 14.1
#[derive(Clone, Copy)]
pub enum Register {
    WhoAmI = 0x75,
}

impl Register {
    fn address(&self) -> u8 {
        *self as u8
    }
}