Notes

So to summarize, I am trying to understand how to structure embedded code, which uses a HAL crate. For example https://github.com/rp-rs/rp-hal/blob/main/rp2040-hal/examples/spi.rs shows initialization of spi, and writing to it. Usually minimum initialization is sth like:

- singleton `pac::Peripherals::take()`
- `hal::clocks::init_clocks_and_plls(pac.clock1, pac.clock2, ...)`
- setup of `hal::gpio::Pins`
- setting correct mode for pins for spi function
- creating spi "object" `hal::Spi::<_, _, 8>::new(pac.SPI0)`
- and finally initializing `spi.init(pac.clock1, mode)`

Then one could write to it with `let x = spi.send(0xff)`;

However, if one wanted to have a couple of different items, i guess one would need to split this into rust modules.

I would then want to have something resembling:

`src/main.rs`

```
#![no_std]
use rp2040_hal;
mod disp;
mod flash;
fn main() -> ! {
let p = rp2040_hal::pac::Peripherals::take();
(...) // all the other init from above, clocks ect

// idea A
let d = MyDisp_or_Flash::new(spi<generic_specialized_paramA, generic_specialized_paramB>); // but this is a bit difficult
let e = MyDisp_or_Flash::new(different_spi)
e.write(0x55);
d.write(0x55);
// idea B?
}
```

and

`src/disp/mod.rs`

```
pub struct MyDisp_or_Flash {
// either spi: Spi<?, ?, ?> // or sth else
// or display:
}
impl MyDisp_or_Flash {
pub fn new(

/* spi: Spi<?, ?, ?> or passing &pins/&clocks/&peripherals stucts*/

) -> Self {
// initialize spi, then "keep it" inside the class
// so it wouldn't be destroyed after new() returns

// in a second module this spi is used to initialize mpidsi object
// let di = display_interface_spi::SPIInterface::new(spi, 1, 2);
// where 1, 2 are pins - so not important in this example
let mut delay = embedded_hal::blocking::delay::new(10);
let mut display = Builder::ili9486(di).init(&mut delay, Some(reset));

// what should i return to be able to use display and/or spi
// for example calling from parent modulename.write([1,2,3]),
// how could I contain them within this module/struct?

}

pub fn write(&self, data: u8)
{
self.spi.write(data);

// or in case of display we could want to clear it

self.display.clear(Rgb666::BLACK)?;
}

}
```