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

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.

pelrun · July 8, 2025, 11:12am

This is the point where I would hook up my logic analyzer to the SD card pins and dump the entire transaction out. Trying to debug subtle communication errors without actually seeing what is on the wire is only going to drive you insane.

tabemann · July 8, 2025, 12:49pm

microSD versus SD should make no difference when using SPI.

BlairLeduc · July 8, 2025, 3:00pm

This is either a software problem or a hardware one.

I do remember someone here, and for the life of me I cannot find the post, had a hardware problem with the SD card socket not soldered correctly and he repaired it with his soldering iron.

astennumero · July 8, 2025, 3:53pm

I don’t think it’s hardware. I just tried the “print mm.info(free space)” in picomite and it returns 31663472640. I’m also able to access the files in the sd card. This makes it clear that there’s nothing wrong with the both the SD card and the SD Card Socket.

So it’s probably the code or the crate. I still want to check the code with a micro sd card. But I haven’t been able to source an adapter in nearby stores. If it works then it’s the SD Card + embedded-sdmmc crate combo that’s the issue. If it doesn’t then it’s probably the code.

astennumero · July 8, 2025, 3:53pm

That’s true. It’s probably time that I invested in one.

astennumero · July 8, 2025, 3:55pm

I’m inclined to agree, but like I said, most people that I checked with haven’t really had an opportunity to use this particular library with a full size SD Card. I just want to rule that out.

BlairLeduc · July 8, 2025, 6:08pm

I can definitely confirm this. You are adding slightly different hardware to you PicoCalc with each SD card you connect. I had to play around with short delays in magic places and sending dummy bytes here and there to get different cards to work. The older the card, the more eccentric it seemed to be.

BlairLeduc · July 8, 2025, 6:09pm

I was hoping you would try that.

Budlight_247 · July 10, 2025, 5:52am

Did you already try a different SD card? Cheaper cards might not have wear leveling and its easier than you might expect to get errors in the allocation table

astennumero · July 10, 2025, 8:31am

Unfortunately not. Got busy with work. I’m planning try out a few things this weekend. I’ll let you all know what happens.

Topic		Replies	Views
GameShell won't recognize my 64gb card Customer Services sd-card , filesystem	44	7858	November 20, 2019
Larger SD card Problem Q&A hardware	13	1293	December 10, 2019
Just got a new 64 gb as card for the 0.4 os, but when I flash it, only 43 mb show GameShell hardware	14	1517	July 20, 2019
Expand File System GameShell tinkering , sd-card , filesystem	47	7441	July 3, 2019
Error reading micro sd card on Mac OS X Q&A	8	923	January 8, 2020

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

Related topics