[Rust] Error Opening SD Card Volume: "Invalid MBR Signature"

astennumero · July 7, 2025, 1:32pm

Hello.

I’m writing simple programs for the PicoCalc using Rust. I’m trying to read the SD card with the following code [1], but it keeps failing with the following error [2]. I’m using the embedded-sdmmc crate.

Additionally, the card size is incorrect. The SD card that came with the kit reads as 32GB when connected to my laptop, but it’s only recognized as 8GB when I try to access it through the Rust program. I have already tried formatting the card (FAT32, MBR) and partitioning it with the official script from the ClockworkPi repo [3].

Any help would be appreciated. Thanks.

[1] Failing Code : clockworkpi-picocalc-rust/p2_spi_sdcard/src/main.rs at main · A-I-nstein/clockworkpi-picocalc-rust · GitHub

[2] Error:

Card Size: 8169455616
Could not open volume: FormatError("Invalid MBR signature")

[3] ClockworkPi SD Card Script: PicoCalc/wiki/How-to-Create-an-Official-PicoCalc-SD-Card.md at master · clockworkpi/PicoCalc · GitHub

BlairLeduc · July 7, 2025, 2:39pm

Take a look at the “sdcard” branch at my repo. It only supports reading right now; I am still actively developing this. The initialisation code seems solid so far.

The interesting part about SD Cards is that you are inserting different hardware with each card and they are all not created equally even if they are following the same specifications.

PicoCalc Text Starter (on GitHub)

BlairLeduc · July 7, 2025, 3:20pm

I have been using that SD card image during development of my FAT32 driver and I know the structure of that image at byte level. Please let me know how I can help.

Where in the embedded-sdmmc crate is it throwing that error?

astennumero · July 7, 2025, 3:49pm

Thanks. It’s on line 142. when I try to open the volume.

volume_mgr.open_volume(VolumeIdx(0))

github.com/A-I-nstein/clockworkpi-picocalc-rust

p2_spi_sdcard/src/main.rs

main

#![no_std]
#![no_main]

use embedded_hal::{delay::DelayNs, spi::MODE_0};
use embedded_hal_bus::spi::ExclusiveDevice;
use embedded_sdmmc::{SdCard, TimeSource, Timestamp, VolumeIdx, VolumeManager};
use panic_halt as _;
use rp235x_hal::{
    Clock, Sio, Spi, Timer, Watchdog,
    block::ImageDef,
    clocks, entry,
    fugit::RateExtU32,
    gpio::{FunctionSpi, Pins},
    pac::Peripherals,
    usb::UsbBus,
};
use usb_device::{class_prelude::*, prelude::*};
use usbd_serial::{SerialPort, embedded_io::Write};

#[unsafe(link_section = ".start_block")]

This file has been truncated. show original

astennumero · July 7, 2025, 3:56pm

I’m new to embedded development and I’ve been trying to get this to work for a few days now. Still having the same issues.

I’ve checked your repo and ensured that the pins are right. The only difference is the speed. I believe you’re using 25MHz. I’m initialising the card with 200kHz and then increasing it to 16MHz. I’ve also tried directly initialising with higher speed instead of starting slower. That doesn’t work as well.

Please let me know if you need any other details.

BlairLeduc · July 7, 2025, 5:45pm

I am not sure why it is having a problem.

In the crate that you are using, you get this error if the signature for the MBR is not correct:

github.com/rust-embedded-community/embedded-sdmmc-rs

src/volume_mgr.rs

614da3eef


      
          }
          
          let (part_type, lba_start, num_blocks) = {
              trace!("Reading partition table");
              let block = data
                  .block_cache
                  .read(BlockIdx(0))
                  .map_err(Error::DeviceError)?;
              // We only support Master Boot Record (MBR) partitioned cards, not
              // GUID Partition Table (GPT)
              if LittleEndian::read_u16(&block[FOOTER_START..FOOTER_START + 2]) != FOOTER_VALUE {
                  return Err(Error::FormatError("Invalid MBR signature"));
              }
              let partition = match volume_idx {
                  VolumeIdx(0) => {
                      &block[PARTITION1_START..(PARTITION1_START + PARTITION_INFO_LENGTH)]
                  }
                  VolumeIdx(1) => {
                      &block[PARTITION2_START..(PARTITION2_START + PARTITION_INFO_LENGTH)]
                  }
                  VolumeIdx(2) => {

Which is the same check I do:

github.com/BlairLeduc/picocalc-text-starter

drivers/sdcard.c

bfba7770f


      
              return sd_write_block(volume_start_block + sector, buffer);
          }
          
          //
          // FAT32 file system functions
          //
          
          static bool sd_is_mbr(const uint8_t *sector)
          {
              // Check for 0x55AA signature
              if (sector[510] != 0x55 || sector[511] != 0xAA)
              {
                  return false;
              }
          
              // Check for valid partition type in partition table
              for (int i = 0; i < 4; i++)
              {
                  uint8_t part_type = sector[446 + i * 16 + 4];
                  if (part_type != 0x00)
                  {

I stumbled upon someone else using this crate on a RP2040, perhaps how they initialize the SPI port might help:

github.com/michaelkamprath/rp2040-rust-robot

src/robot/file_storage.rs

eff6aa3ac


      
                  error!("Error reading volume size: {:?}", e);
                  return Self {
                      volume_mgr: None,
                      volume: None,
                      root_dir: None,
                  };
              }
          }
          
          trace!("Getting Volume 0...");
          let volume = match volume_mgr.open_volume(VolumeIdx(0)) {
              Ok(v) => v,
              Err(e) => {
                  error!("Error getting volume 0: {}", defmt::Debug2Format(&e));
                  return Self {
                      volume_mgr: None,
                      volume: None,
                      root_dir: None,
                  };
              }
          };

astennumero · July 8, 2025, 2:21am

Thanks. Looks like they are using a mutex wrap on the Spi and a critical section to increase to speed. Let me try that.

astennumero · July 8, 2025, 2:53am

Okay. Unfortunately even the mutex and the critical section did not help. I think there could still be something wrong with how the SD Card is formatted and partitioned.

What do you think is the best way to format it? I’ve tried the windows formatter, the official tool from the SD Association and also the clockworkpi official linux script.

tabemann · July 8, 2025, 3:52am

I reformatted the SD card that came with my PicoCalc with mkfs.fat on Debian (because I never bothered to implement support for long file names in zeptoforth), and haven’t had any problems with it. Note that I did not regenerate the partition table, so I am still using the stock partition table that came with the SD card from ClockworkPi.

My guess is that there is data corruption in the communication between the SD card and your board. In the case of zeptoforth, I send/receive dummy bytes in many places when communicating with the SD card, and previously had communication problems without the right number of dummy bytes.

astennumero · July 8, 2025, 10:12am

Could be. And a few people I spoke to said that they’ve only used this crate with microSD cards and not full sized once. I should probably test that as well.

Topic		Replies	Views
[Rust] Starter Code for PicoCalc Development PicoCalc community , development , software	2	71	July 8, 2025
Error: SD Card not found PicoCalc	8	154	May 24, 2025
Error reading micro sd card on Mac OS X Q&A	8	908	January 8, 2020
I made an App that dynamically load firmware from SD Card PicoCalc feedback , community , app , software , firmware	29	1549	May 8, 2025
Im trying to install things on the sd card but the format is wrong GameShell	3	404	October 31, 2023

[Rust] Error Opening SD Card Volume: "Invalid MBR Signature"

Related topics