Hey, I'm fairly new to Rust and been trying to play around with the avr-hal library in combination with other public driver crates.
I wanted to use the available Sh1106 driver by jamwaffles over SPI with the avr lib.
But I have some problems getting the respective GraphicsMode struct constructed via the provided Builder, because I just own a ChipSelectPin object (wrapper object for the real OutputPin) provided by the avr-hal crate.
But the Builder requires a OutputPin.
AVR-Hal Documentation about ChipSelectPin object
/// Wrapper for the CS pin
///
/// Used to contain the chip-select pin during operation to prevent its mode from being
/// changed from Output. This is necessary because the SPI state machine would otherwise
/// reset itself to SPI slave mode immediately. This wrapper can be used just like an
/// output pin, because it implements all the same traits from embedded-hal.
pub struct ChipSelectPin<CSPIN>(port::Pin<port::mode::Output, CSPIN>);
Sh1106 code regarding the Builder
/// Finish the builder and use SPI to communicate with the display
///
/// If the Chip Select (CS) pin is not required, [`NoOutputPin`] can be used as a dummy argument
///
/// [`NoOutputPin`]: ./struct.NoOutputPin.html
pub fn connect_spi<SPI, DC, CS, CommE, PinE>(
self,
spi: SPI,
dc: DC,
cs: CS,
) -> DisplayMode<RawMode<SpiInterface<SPI, DC, CS>>>
where
SPI: hal::blocking::spi::Transfer<u8, Error = CommE>
+ hal::blocking::spi::Write<u8, Error = CommE>,
DC: OutputPin<Error = PinE>,
CS: OutputPin<Error = PinE>,
{
let properties = DisplayProperties::new(
SpiInterface::new(spi, dc, cs),
self.display_size,
self.rotation,
);
DisplayMode::<RawMode<SpiInterface<SPI, DC, CS>>>::new(properties)
}
Comming from the Rust Book, the normal way on how to solve this would be to use some sort of Box casting, but as I use the no_std macro, I dont have access to Box.
Also, if I try to .into() method, which is quite prominent in Code examples, I just get a exception regarding missing type annotations.
let mut display: GraphicsMode<_> = Builder::new()
| ----------- consider giving `display` the explicit type `GraphicsMode<SpiInterface<avr_hal_generic::spi::Spi<Atmega, SPI, PB5, PB3, PB4, PB2>, avr_hal_generic::port::Pin<Output, PB0>, CS>>`, where the type parameter `CS` is specified
46 | .connect_spi(spi, dc, cs.into() )
| ^^^^^^^^^^^ cannot infer type for type parameter `CS` declared on the associated function `connect_spi`
What would be the typical solution to solve this kind of issues in Embedded Rust? I will also append my current not working source code, but its basically just copy-pasted from the different examples.
Sincerely, Fatalon
Full SourceCode
#![no_std]
#![no_main]
use embedded_hal::digital::v2::OutputPin;
use sh1106::{prelude::*, Builder, mode::GraphicsMode};
use arduino_hal::prelude::*;
use arduino_hal::spi;
use embedded_hal::spi::FullDuplex;
use embedded_graphics::{
image::{Image, ImageRawLE},
pixelcolor::BinaryColor,
prelude::*,
};
use panic_halt as _;
const UART_BAUDRATE: u32 = 57600;
#[arduino_hal::entry]
fn main() -> ! {
let dp = arduino_hal::Peripherals::take().unwrap();
let pins = arduino_hal::pins!(dp);
// Create SPI interface.
let (mut spi, mut cs) = arduino_hal::Spi::new(
dp.SPI,
pins.d13.into_output(),
pins.d11.into_output(),
pins.d12.into_pull_up_input(),
pins.d10.into_output(),
spi::Settings::default(),
);
let dc = pins.d8.into_output();
// Alternative: Use lib without a Chip Select pin
//let cs_no_output = sh1106::builder::NoOutputPin::new();
let mut display: GraphicsMode<_> = Builder::new()
.connect_spi(spi, dc, cs.into())
.into();
display.init().unwrap();
display.flush().unwrap();
let im: ImageRawLE<BinaryColor> = ImageRawLE::new(include_bytes!("rust.raw"), 64);
Image::new(&im, Point::new(32, 0))
.draw(&mut display)
.unwrap();
display.flush().unwrap();
loop {
}
}