Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Update to use the overhauled GPIO API #1

Merged
merged 5 commits into from
Nov 10, 2023
Merged

Update to use the overhauled GPIO API #1

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
995a40d
Bump dependencies versions & update accordingly
ithinuel May 31, 2023
480249f
Clone delay in example in the one place we need to avoid moving it
9names Oct 15, 2023
168129c
Remove `_old_pins_states`
ithinuel Oct 15, 2023
215795c
Rename DS to DATA_SIZE
ithinuel Oct 15, 2023
01a7e71
remove unused info! placeholder
ithinuel Nov 5, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
39 changes: 18 additions & 21 deletions Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,30 +10,27 @@ repository = "https://github.com/rp-rs/spi-pio-rs"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
cortex-m = "0.7.3"
eh1_0_alpha = { version = "=1.0.0-alpha.9", package = "embedded-hal", optional = true }
embedded-hal = "0.2.6"
nb = "1.0.0"
pio = "0.2.0"
pio-proc = "0.2.0"
rp2040-hal = "0.8.0"
fugit = "0.3.5"
defmt = { version = "0.3.0", optional = true }
cortex-m = "0.7.7"
eh1_0_alpha = { version = "1.0.0-rc.1", package = "embedded-hal", optional = true }
embedded-hal = "0.2.7"
nb = "1.1.0"
pio = "0.2.1"
pio-proc = "0.2.2"
rp2040-hal = "0.9.0"
fugit = "0.3.7"
defmt = { version = "0.3.5", optional = true }

[dev-dependencies]
rp2040-hal = { version = "0.8.0", features = ["defmt"] }
rp-pico = "*"
rp2040-hal = { version = "0.9.0", features = ["defmt"] }
rp-pico = "0.8.0"
panic-halt = "0.2.0"
embedded-hal = "0.2.5"
embedded-hal = "0.2.7"
cortex-m-rt = "0.7"
nb = "1.0"
embedded-sdmmc = "0.4.0"
pio = "0.2.0"
pio-proc = "0.2.1"
critical-section = "1.0.0"
nb = "1.1"
embedded-sdmmc = "0.6.0"
pio = "0.2.1"
pio-proc = "0.2.2"
critical-section = "1.1.2"

defmt = "0.3.0"
defmt = "0.3.5"
defmt-rtt = "0.4.0"

[patch.crates-io]
rp2040-hal = { git = "https://github.com/rp-rs/rp-hal" }
156 changes: 55 additions & 101 deletions examples/pico_spi_pio_sd_card.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -39,37 +39,6 @@
//!
//! $ mkfs.fat /dev/sdj1
//!
//! In the following ASCII art the SD card is also connected to 5 strong pull up
//! resistors. I've found varying values for these, from 50kOhm, 10kOhm
//! down to 5kOhm.
//! Stronger pull up resistors will eat more amperes, but also allow faster
//! data rates.
//!
//! ```text
//! +3.3V
//! Pull Ups ->||||
//! 4x[5kOhm]
//! ||| \
//! _______________ ||| \
//! | DAT2/NC 9\---o|| \ _|USB|_
//! | S DAT3/CS 1|---o+----+------SS--\ |1 R 40|
//! | D CMD/DI 2|----o----+-----MOSI-+-\ |2 P 39|
//! | VSS1 3|-- GND | | | GND-|3 38|- GND
//! | C VDD 4|-- +3.3V | /--SCK--+-+----SPI0 SCK-|4 P 37|
//! | A CLK/SCK 5|---------+-/ | \----SPI0 TX--|5 I 36|- +3.3V
//! | R VSS2 6|-- GND | /--MISO-+------SPI0 RX--|6 C |
//! | D DAT0/DO 7|---------o-/ \------SPI0 CSn-|7 O |
//! | DAT1/IRQ 8|-[5k]- +3.3V | |
//! """""""""""""""" | |
//! | |
//! .........
//! |20 21|
//! """""""
//! Symbols:
//! - (+) crossing lines, not connected
//! - (o) connected lines
//! ```
//!
//! The example can either be used with a probe to receive debug output
//! and also the LED is used as status output. There are different blinking
//! patterns.
Expand Down Expand Up @@ -104,7 +73,7 @@ use defmt_rtt as _;
use panic_halt as _;

// Pull in any important traits
use rp_pico::hal::prelude::*;
use rp_pico::hal::{gpio::PullUp, prelude::*};

// Embed the `Hz` function/trait:
use fugit::RateExtU32;
Expand All @@ -117,18 +86,22 @@ use rp_pico::hal::pac;
// higher-level drivers.
use rp_pico::hal;

// Provides `.delay_ms(…)`.
use embedded_hal::blocking::delay::DelayMs;
// Provides gpio generic operations.
use embedded_hal::digital::v2::OutputPin;

// Link in the embedded_sdmmc crate.
// The `SdMmcSpi` is used for block level access to the card.
// And the `Controller` gives access to the FAT filesystem functions.
use embedded_sdmmc::{Controller, SdMmcSpi, TimeSource, Timestamp, VolumeIdx};
use embedded_sdmmc::{SdCard, TimeSource, Timestamp, VolumeIdx};

// Get the file open mode enum:
use embedded_sdmmc::filesystem::Mode;

/// A dummy timesource, which is mostly important for creating files.
#[derive(Default)]
pub struct DummyTimesource();

pub struct DummyTimesource;
impl TimeSource for DummyTimesource {
// In theory you could use the RTC of the rp2040 here, if you had
// any external time synchronizing device.
Expand All @@ -152,11 +125,10 @@ const BLINK_ERR_2_SHORT: [u8; 4] = [1u8, 0u8, 1u8, 0u8];
const BLINK_ERR_3_SHORT: [u8; 6] = [1u8, 0u8, 1u8, 0u8, 1u8, 0u8];
const BLINK_ERR_4_SHORT: [u8; 8] = [1u8, 0u8, 1u8, 0u8, 1u8, 0u8, 1u8, 0u8];
const BLINK_ERR_5_SHORT: [u8; 10] = [1u8, 0u8, 1u8, 0u8, 1u8, 0u8, 1u8, 0u8, 1u8, 0u8];
const BLINK_ERR_6_SHORT: [u8; 12] = [1u8, 0u8, 1u8, 0u8, 1u8, 0u8, 1u8, 0u8, 1u8, 0u8, 1u8, 0u8];

fn blink_signals(
pin: &mut dyn embedded_hal::digital::v2::OutputPin<Error = core::convert::Infallible>,
delay: &mut cortex_m::delay::Delay,
pin: &mut impl OutputPin<Error = core::convert::Infallible>,
mut delay: impl DelayMs<u32>,
sig: &[u8],
) {
for bit in sig {
Expand All @@ -179,23 +151,21 @@ fn blink_signals(
}

fn blink_signals_loop(
pin: &mut dyn embedded_hal::digital::v2::OutputPin<Error = core::convert::Infallible>,
delay: &mut cortex_m::delay::Delay,
pin: &mut impl OutputPin<Error = core::convert::Infallible>,
mut delay: impl DelayMs<u32> + Clone,
sig: &[u8],
) -> ! {
loop {
blink_signals(pin, delay, sig);
blink_signals(pin, delay.clone(), sig);
delay.delay_ms(1000);
}
}

#[entry]
fn main() -> ! {
info!("Program start");

// Grab our singleton objects
let mut pac = pac::Peripherals::take().unwrap();
let core = pac::CorePeripherals::take().unwrap();
let _core = pac::CorePeripherals::take().unwrap();

// Set up the watchdog driver - needed by the clock setup code
let mut watchdog = hal::Watchdog::new(pac.WATCHDOG);
Expand Down Expand Up @@ -230,13 +200,16 @@ fn main() -> ! {
let mut led_pin = pins.led.into_push_pull_output();

// Setup a delay for the LED blink signals:
let mut delay = cortex_m::delay::Delay::new(core.SYST, clocks.system_clock.freq().to_Hz());
let mut timer = rp_pico::hal::timer::Timer::new(pac.TIMER, &mut pac.RESETS, &clocks);

// Enable internal pull up on MISO
let gpio4 = pins.gpio4.into_pull_type::<PullUp>();

// These are implicitly used by the spi driver if they are in the correct mode
let (mut pio, sm0, _, _, _) = pac.PIO0.split(&mut pac.RESETS);
let spi: spi_pio::Spi<'_, _, _, _, _, _, 8> = spi_pio::Spi::new(
(&mut pio, sm0),
(pins.gpio4, pins.gpio3, pins.gpio2),
(gpio4, pins.gpio3, pins.gpio2),
embedded_hal::spi::MODE_0,
16u32.MHz(),
clocks.peripheral_clock.freq(),
Expand All @@ -247,83 +220,64 @@ fn main() -> ! {

// Exchange the uninitialised SPI driver for an initialised one

info!("Aquire SPI SD/MMC BlockDevice...");
let mut sdspi = SdMmcSpi::new(spi, spi_cs);

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);

// Next we need to aquire the block device and initialize the
// communication with the SD card.
let block = match sdspi.acquire() {
Ok(block) => block,
Err(e) => {
error!("Error retrieving card size: {}", defmt::Debug2Format(&e));
blink_signals_loop(&mut led_pin, &mut delay, &BLINK_ERR_2_SHORT);
}
};

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);

info!("Init SD card controller...");
let mut cont = Controller::new(block, DummyTimesource::default());

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);
let sdcard = SdCard::new(spi, spi_cs, timer);

info!("OK!\nCard size...");
match cont.device().card_size_bytes() {
match sdcard.num_bytes() {
Ok(size) => info!("card size is {} bytes", size),
Err(e) => {
error!("Error retrieving card size: {}", defmt::Debug2Format(&e));
blink_signals_loop(&mut led_pin, &mut delay, &BLINK_ERR_3_SHORT);
blink_signals_loop(&mut led_pin, timer, &BLINK_ERR_2_SHORT);
}
}

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);
blink_signals(&mut led_pin, timer, &BLINK_OK_LONG);

info!("Getting Volume 0...");
let mut volume = match cont.get_volume(VolumeIdx(0)) {
let mut volume_mgr = embedded_sdmmc::VolumeManager::new(sdcard, DummyTimesource);
let volume = match volume_mgr.open_volume(VolumeIdx(0)) {
Ok(v) => v,
Err(e) => {
error!("Error getting volume 0: {}", defmt::Debug2Format(&e));
blink_signals_loop(&mut led_pin, &mut delay, &BLINK_ERR_4_SHORT);
blink_signals_loop(&mut led_pin, timer, &BLINK_ERR_3_SHORT);
}
};

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);
blink_signals(&mut led_pin, timer, &BLINK_OK_LONG);

// After we have the volume (partition) of the drive we got to open the
// root directory:
let dir = match cont.open_root_dir(&volume) {
let dir = match volume_mgr.open_root_dir(volume) {
Ok(dir) => dir,
Err(e) => {
error!("Error opening root dir: {}", defmt::Debug2Format(&e));
blink_signals_loop(&mut led_pin, &mut delay, &BLINK_ERR_5_SHORT);
blink_signals_loop(&mut led_pin, timer, &BLINK_ERR_4_SHORT);
}
};

info!("Root directory opened!");
blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);
blink_signals(&mut led_pin, timer, &BLINK_OK_LONG);

// This shows how to iterate through the directory and how
// to get the file names (and print them in hope they are UTF-8 compatible):
cont.iterate_dir(&volume, &dir, |ent| {
info!(
"/{}.{}",
core::str::from_utf8(ent.name.base_name()).unwrap(),
core::str::from_utf8(ent.name.extension()).unwrap()
);
})
.unwrap();

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);
volume_mgr
.iterate_dir(dir, |ent| {
info!(
"/{}.{}",
core::str::from_utf8(ent.name.base_name()).unwrap(),
core::str::from_utf8(ent.name.extension()).unwrap()
);
})
.unwrap();

blink_signals(&mut led_pin, timer, &BLINK_OK_LONG);

let mut successful_read = false;

// Next we going to read a file from the SD card:
if let Ok(mut file) = cont.open_file_in_dir(&mut volume, &dir, "O.TST", Mode::ReadOnly) {
if let Ok(file) = volume_mgr.open_file_in_dir(dir, "O.TST", Mode::ReadOnly) {
let mut buf = [0u8; 32];
let read_count = cont.read(&volume, &mut file, &mut buf).unwrap();
cont.close_file(&volume, file).unwrap();
let read_count = volume_mgr.read(file, &mut buf).unwrap();
volume_mgr.close_file(file).unwrap();

if read_count >= 2 {
info!("READ {} bytes: {}", read_count, buf);
Expand All @@ -337,22 +291,22 @@ fn main() -> ! {
}
}

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);
blink_signals(&mut led_pin, timer, &BLINK_OK_LONG);

match cont.open_file_in_dir(&mut volume, &dir, "O.TST", Mode::ReadWriteCreateOrTruncate) {
Ok(mut file) => {
cont.write(&mut volume, &mut file, b"\x42\x1E").unwrap();
cont.close_file(&volume, file).unwrap();
match volume_mgr.open_file_in_dir(dir, "O.TST", Mode::ReadWriteCreateOrTruncate) {
Ok(file) => {
volume_mgr.write(file, b"\x42\x1E").unwrap();
volume_mgr.close_file(file).unwrap();
}
Err(e) => {
error!("Error opening file 'O.TST': {}", defmt::Debug2Format(&e));
blink_signals_loop(&mut led_pin, &mut delay, &BLINK_ERR_6_SHORT);
blink_signals_loop(&mut led_pin, timer, &BLINK_ERR_5_SHORT);
}
}

cont.free();
volume_mgr.free();

blink_signals(&mut led_pin, &mut delay, &BLINK_OK_LONG);
blink_signals(&mut led_pin, timer, &BLINK_OK_LONG);

if successful_read {
info!("Successfully read previously written file 'O.TST'");
Expand All @@ -363,11 +317,11 @@ fn main() -> ! {

loop {
if successful_read {
blink_signals(&mut led_pin, &mut delay, &BLINK_OK_SHORT_SHORT_LONG);
blink_signals(&mut led_pin, timer, &BLINK_OK_SHORT_SHORT_LONG);
} else {
blink_signals(&mut led_pin, &mut delay, &BLINK_OK_SHORT_LONG);
blink_signals(&mut led_pin, timer, &BLINK_OK_SHORT_LONG);
}

delay.delay_ms(1000);
timer.delay_ms(1000);
}
}
Loading
Loading