Building an abstraction for sensors

[jake-g00dwin]

Idea:
Write out object traits/methods that sensor modules have to implement, a set of universal methods such as.

• init_sensor
• config_sensor
• get_sensor_data, returns the sensor's data in a formatted form.
• get_sensor_name, returns string of sensor's name
• get_sensor_types, returns the measurement types for sending to PI for usage.

These would accept embedded_hal i2c/spi types allowing us to have a single sensor_module code base for all available sensors, that could work with all sensor modules that implement the traits.

this could turn our sensor module code into something like this.

use sensor_lib_aht20::Sensor;
/* --SNIP-- */

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let mut sensor_data = Sensor::SharedBuffer::new();
    let mut sensor = Sensor::new(i2c);
    sensor.init();
    sensor.config();

    set_can_measurement_types(sensor.get_types());
    set_can_sensor_name(sensor.get_name());

    /* --SNIP-- */
}

/* --SNIP-- */

//This holds the only mutable reference to the sensor_data buffer.
#[embassy_executor::task]
pub async fn read_sensor_module(s: Sensor) {
    loop {
        if s.is_new_data() {
          sensor_data = s.get_sensor_data();  
        }
        //uses hardware timer+interrupt to wait till next measurement is ready to read.
        s.sampling_delay();
    }
}

[jake-g00dwin]

At the very least we should probably come up with a standard of requests the SBC can make to the sensor modules to figure out what kind of data they will be sending and what the sensors actually are.

[jake-g00dwin]

Okay, So I've started on a repo with an example of what could work.
https://github.com/jake-g00dwin/can_task