mirror of
https://github.com/esp-rs/esp-idf-hal.git
synced 2025-10-02 14:44:51 +00:00
b739c46b12
* embedded-hal::delay no longer returns Error * embedded_hal::digital add generic GpioError * spi: init work: from closure to Operation pattern * first full implementation * i2c: remove iter fn droped by e-hal master * make ci work by temp. refere to e-hal master * more ci fix * make clippy happy * more ci fighting * gpio: cursed repair of ulp_processor * fmt * spi: repair example + get rid of generic's * dep: change to new e-hal release * fix e-hal 0.2 comp & fix bus * fmt * clippy * remove debug artifacts * test ci with e-hal-nb-alpha.1 * e-hal-nb to alpha.2 * modified comments * impl e-hal delay to general purpose provider * use embedded_hal_error macro for riscv-ulp-hal * typo * impl pwm alpha10 * fixed wrong return error on async gpio * duplicated impl error macro for ulp
66 lines
2.2 KiB
Rust
66 lines
2.2 KiB
Rust
//! SPI loopback test
|
|
//!
|
|
//! Folowing pins are used:
|
|
//! SCLK GPIO6
|
|
//! SDI GPIO2
|
|
//! SDO GPIO7
|
|
//! CS_1 GPIO10
|
|
//! CS_2 GPIO3
|
|
//!
|
|
//! Depending on your target and the board you are using you have to change the pins.
|
|
//!
|
|
//! This example transfers data via SPI.
|
|
//! Connect SDI and SDO pins to see the outgoing data is read as incoming data.
|
|
|
|
use embedded_hal::spi::Operation;
|
|
use esp_idf_hal::delay::FreeRtos;
|
|
use esp_idf_hal::peripherals::Peripherals;
|
|
use esp_idf_hal::prelude::*;
|
|
use esp_idf_hal::spi::*;
|
|
|
|
fn main() -> anyhow::Result<()> {
|
|
esp_idf_sys::link_patches();
|
|
|
|
let peripherals = Peripherals::take().unwrap();
|
|
let spi = peripherals.spi2;
|
|
|
|
let sclk = peripherals.pins.gpio6;
|
|
let serial_in = peripherals.pins.gpio2; // SDI
|
|
let serial_out = peripherals.pins.gpio7; // SDO
|
|
let cs_1 = peripherals.pins.gpio10;
|
|
let cs_2 = peripherals.pins.gpio3;
|
|
|
|
println!("Starting SPI loopback test");
|
|
|
|
let driver = SpiDriver::new::<SPI2>(spi, sclk, serial_out, Some(serial_in), Dma::Disabled)?;
|
|
|
|
let config_1 = config::Config::new().baudrate(26.MHz().into());
|
|
let mut device_1 = SpiDeviceDriver::new(&driver, Some(cs_1), &config_1)?;
|
|
|
|
let config_2 = config::Config::new().baudrate(13.MHz().into());
|
|
let mut device_2 = SpiDeviceDriver::new(&driver, Some(cs_2), &config_2)?;
|
|
|
|
let mut read = [0u8; 4];
|
|
let write = [0xde, 0xad, 0xbe, 0xef];
|
|
|
|
loop {
|
|
// we are using thread::sleep here to make sure the watchdog isn't triggered
|
|
FreeRtos::delay_ms(500);
|
|
device_1.transfer(&mut read, &write)?;
|
|
println!("Device 1: Wrote {write:x?}, read {read:x?}");
|
|
|
|
let write_buf = [0xde, 0xad, 0xbe, 0xef];
|
|
let mut write_in_place_buf = [0xde, 0xad, 0xbe, 0xef];
|
|
let mut read_buf = [0; 8];
|
|
|
|
println!("Device 2: To write {write_in_place_buf:x?} ... ");
|
|
// cascade multiple operations with different buffer length into one transaction
|
|
device_2.transaction(&mut [
|
|
Operation::Write(&write_buf),
|
|
Operation::TransferInPlace(&mut write_in_place_buf),
|
|
Operation::Read(&mut read_buf),
|
|
])?;
|
|
println!("... read {write_in_place_buf:x?}");
|
|
}
|
|
}
|