All items ship from our office in Colorado USA - $5.95 Flat-Rate US shipping & free shipping on orders over $75!

Micro SD Memory Card Storage Board Module with SPI Interface User Guide

Microcontroller shields Type hookup guide Type tutorial Type user manual
Micro SD Memory Card Storage Board Module with SPI Interface

This Micro SD TF (TransFlash) card reader and writer module lets you add removable data storage to your Arduino or other microcontroller projects. It includes an onboard 3.3V voltage regulator and level shifters, making it safe to interface directly with both 5V and 3.3V microcontrollers. The module communicates over the standard SPI bus and is fully compatible with the built-in Arduino SD card library — no extra libraries needed.

Whether you're logging sensor data, storing configuration files, or saving large datasets that won't fit in your microcontroller's onboard memory, this module makes it easy. Just insert a formatted Micro SD or Micro SDHC card, wire up four SPI lines plus power, and you're ready to read and write files.

💡 Tip: This module works best with the Arduino IDE and its built-in SD library. It can also be used with other microcontrollers that support SPI, but the Arduino ecosystem offers the easiest setup experience.

💡 How It Works

The Micro SD card module acts as a bridge between your microcontroller and a Micro SD card. Here's what's happening under the hood:

  1. SPI Communication: Your microcontroller sends commands and data to the SD card over the SPI (Serial Peripheral Interface) bus using four signal lines: MOSI (data out), MISO (data in), SCK (clock), and CS (chip select).
  2. Voltage Regulation: The onboard AMS1117-3.3V (or equivalent) low-dropout regulator converts the 5V input down to the 3.3V that the SD card requires. This protects the card from overvoltage damage.
  3. Level Shifting: The module includes a 74LVC125A (or equivalent) level-shifting IC that translates the 5V logic signals from your microcontroller down to 3.3V levels that are safe for the SD card's data lines.
  4. File System: The Arduino SD library handles the FAT16 or FAT32 file system on the card, allowing you to create, read, write, and delete files and directories just like you would on a computer.

⭐ Features

  • Supports Micro SD cards (up to 2 GB) and Micro SDHC cards (up to 32 GB)
  • Onboard 3.3V voltage regulator — no external regulator needed
  • Built-in level shifters for safe 5V or 3.3V logic interfacing
  • Standard SPI interface (MOSI, MISO, SCK, CS)
  • Compatible with the built-in Arduino SD library — no extra libraries required
  • 6-pin male right-angle header on 2.54mm centers — breadboard and jumper-wire friendly
  • 4 × M2 mounting holes (2.2mm diameter) for secure installation
  • LED power indicator

📋 Specifications

Parameter Value
Operating Voltage (VCC) 4.5V – 5.5V DC
Logic Level 3.3V and 5V compatible (onboard level shifters)
Communication Interface SPI (Serial Peripheral Interface)
Supported Card Types Micro SD (up to 2 GB), Micro SDHC (up to 32 GB)
Supported File Systems FAT16, FAT32
Onboard Regulator AMS1117-3.3V or equivalent LDO
Level Shifter 74LVC125A or equivalent
Header Pins 6-pin male right-angle, 2.54mm pitch
Mounting Holes 4 × M2 (2.2mm diameter)
Board Dimensions Approx. 42 × 24 mm (1.65 × 0.94 inches) L × W
Operating Current ~80 mA (during read/write), ~100 µA (idle)

📌 Pin Description

The module has a 6-pin male right-angle header on 2.54mm centers. It can be inserted directly into a breadboard, or female Dupont-style jumper wires can be used for connections.

Pin Label Description
1 GND Ground — must share a common ground with your microcontroller
2 VCC Power input: 4.5V – 5.5V DC
3 MISO SPI Master In, Slave Out — data from SD card to microcontroller
4 MOSI SPI Master Out, Slave In — data from microcontroller to SD card
5 SCK SPI Clock — clock signal from microcontroller
6 CS SPI Chip Select — active LOW to select this device on the SPI bus

📝 Note: Some versions of this module have a silkscreen error where MISO is labeled as "MOSO." The pin still functions as MISO — connect it to the MISO pin on your microcontroller.

🔌 Wiring the Micro SD Card Module to Arduino

📦 Parts Needed

  • 1× Micro SD Card Module (this product)
  • 1× Arduino Uno, Nano, or compatible board
  • 1× Micro SD or Micro SDHC card (formatted as FAT16 or FAT32)
  • Jumper wires

Connection Table — Arduino Uno

Module Pin Arduino Uno Pin
VCC 5V
GND GND
MISO Pin 12 (MISO)
MOSI Pin 11 (MOSI)
SCK Pin 13 (SCK)
CS Pin 10 (SS)

Connection Table — Arduino Nano

Module Pin Arduino Nano Pin
VCC 5V
GND GND
MISO D12 (MISO)
MOSI D11 (MOSI)
SCK D13 (SCK)
CS D10 (SS)

📝 Note: The CS (Chip Select) pin can be connected to any available digital pin, but you must update the pin number in your code to match. Pin 10 is the default used by the Arduino SD library. The MOSI, MISO, and SCK pins are fixed hardware SPI pins and cannot be changed on the Uno/Nano.

🔧 Preparing Your SD Card

Before using your Micro SD card with this module, it must be formatted with a compatible file system. The Arduino SD library supports FAT16 and FAT32 formats.

Formatting Instructions

  1. Insert your Micro SD card into your computer using an SD card adapter or built-in card reader.
  2. Windows: Right-click the drive in File Explorer → Format → select FAT32 → click Start.
  3. Mac: Open Disk Utility → select the card → click Erase → choose MS-DOS (FAT) format.
  4. Linux: Use the command sudo mkfs.vfat -F 32 /dev/sdX1 (replace sdX1 with your card's device name).

⚠️ Important: Cards larger than 32 GB (SDXC) are typically formatted as exFAT, which is not supported by the Arduino SD library. Stick with cards 32 GB or smaller, and make sure they are formatted as FAT32. For best compatibility, use cards from well-known brands (SanDisk, Samsung, Kingston).

💻 Installing the Arduino SD Library

The SD library comes pre-installed with the Arduino IDE, so in most cases you don't need to install anything extra. To verify it's available:

  1. Open the Arduino IDE.
  2. Go to Sketch → Include Library and look for "SD" in the list.
  3. If it's listed, you're ready to go. If not, go to Sketch → Include Library → Manage Libraries, search for "SD," and install it.

The SD library also depends on the SPI library, which is always included with the Arduino IDE.

🚀 Step 1: Test Your SD Card Connection (CardInfo)

This sketch tests whether your Arduino can communicate with the SD card. It reads and displays the card type, size, and file listing over the Serial Monitor. This is the best first sketch to run to verify your wiring is correct.

/*
 * SD Card Info Test
 * Envistia Mall - Product Support
 *
 * Tests communication with the SD card module and
 * displays card type, size, and file listing.
 *
 * Connections:
 *   CS   -> Arduino Pin 10
 *   MOSI -> Arduino Pin 11
 *   MISO -> Arduino Pin 12
 *   SCK  -> Arduino Pin 13
 *   VCC  -> Arduino 5V
 *   GND  -> Arduino GND
 */

#include <SPI.h>
#include <SD.h>

const int chipSelect = 10;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // Wait for Serial Monitor to open (needed for some boards)
  }

  Serial.print("Initializing SD card...");

  if (!SD.begin(chipSelect)) {
    Serial.println("initialization failed!");
    Serial.println("Check: Is a card inserted? Is the wiring correct?");
    while (1);
  }
  Serial.println("initialization done.");

  // Print card type
  Sd2Card card;
  SdVolume volume;
  SdFile root;

  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("Card init failed.");
    return;
  }

  Serial.print("Card type: ");
  switch (card.type()) {
    case SD_CARD_TYPE_SD1:  Serial.println("SD1");  break;
    case SD_CARD_TYPE_SD2:  Serial.println("SD2");  break;
    case SD_CARD_TYPE_SDHC: Serial.println("SDHC"); break;
    default:                Serial.println("Unknown");
  }

  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.");
    return;
  }

  Serial.print("Volume type is FAT");
  Serial.println(volume.fatType(), DEC);

  uint32_t volumesize;
  volumesize = volume.blocksPerCluster() * volume.clusterCount();
  volumesize /= 2; // Convert blocks to KB
  Serial.print("Volume size (KB): ");
  Serial.println(volumesize);
  Serial.print("Volume size (MB): ");
  Serial.println(volumesize / 1024);
  Serial.print("Volume size (GB): ");
  Serial.println((float)volumesize / 1024.0 / 1024.0);

  Serial.println("\nFiles on card:");
  root.openRoot(volume);
  root.ls(LS_R | LS_DATE | LS_SIZE);
}

void loop() {
  // Nothing to do here
}

How to Use:

  1. Wire the module to your Arduino as shown in the connection table above.
  2. Insert a FAT32-formatted Micro SD card into the module.
  3. Upload this sketch to your Arduino.
  4. Open the Serial Monitor at 9600 baud.
  5. You should see the card type, volume size, and a file listing. If you see "initialization failed," double-check your wiring and card formatting.

🚀 Step 2: Read and Write Files

This sketch demonstrates how to create a file on the SD card, write data to it, and then read the data back. This is the foundation for data logging and file storage projects.

/*
 * SD Card Read/Write Example
 * Envistia Mall - Product Support
 *
 * Creates a file, writes sample data, then reads it back.
 *
 * Connections:
 *   CS   -> Arduino Pin 10
 *   MOSI -> Arduino Pin 11
 *   MISO -> Arduino Pin 12
 *   SCK  -> Arduino Pin 13
 *   VCC  -> Arduino 5V
 *   GND  -> Arduino GND
 */

#include <SPI.h>
#include <SD.h>

const int chipSelect = 10;
File myFile;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ;
  }

  Serial.print("Initializing SD card...");
  if (!SD.begin(chipSelect)) {
    Serial.println("initialization failed!");
    while (1);
  }
  Serial.println("initialization done.");

  // --- WRITE to file ---
  myFile = SD.open("test.txt", FILE_WRITE);
  if (myFile) {
    Serial.print("Writing to test.txt...");
    myFile.println("Hello from Envistia Mall!");
    myFile.println("SD card module is working.");
    myFile.println("Line 3: You can log sensor data here.");
    myFile.close();
    Serial.println("done.");
  } else {
    Serial.println("Error opening test.txt for writing.");
  }

  // --- READ from file ---
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("\nContents of test.txt:");
    Serial.println("---------------------");
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    myFile.close();
    Serial.println("---------------------");
  } else {
    Serial.println("Error opening test.txt for reading.");
  }
}

void loop() {
  // Nothing to do here
}

How to Use:

  1. Upload this sketch to your Arduino.
  2. Open the Serial Monitor at 9600 baud.
  3. The sketch will create a file called test.txt, write three lines to it, then read and display the contents.
  4. You can remove the SD card and read the file on your computer to verify.

🚀 Step 3: Simple Data Logger

This sketch reads the value from an analog pin every 2 seconds and logs it to a CSV file on the SD card with a timestamp. This is a practical starting point for sensor data logging projects.

/*
 * Simple Data Logger
 * Envistia Mall - Product Support
 *
 * Reads analog pin A0 every 2 seconds and logs the
 * value to a CSV file on the SD card.
 *
 * Connections:
 *   CS   -> Arduino Pin 10
 *   MOSI -> Arduino Pin 11
 *   MISO -> Arduino Pin 12
 *   SCK  -> Arduino Pin 13
 *   VCC  -> Arduino 5V
 *   GND  -> Arduino GND
 *   Sensor output -> Arduino A0 (or leave unconnected for test)
 */

#include <SPI.h>
#include <SD.h>

const int chipSelect = 10;
const int sensorPin = A0;
unsigned long sampleNumber = 0;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ;
  }

  Serial.print("Initializing SD card...");
  if (!SD.begin(chipSelect)) {
    Serial.println("initialization failed!");
    while (1);
  }
  Serial.println("initialization done.");

  // Write CSV header
  File dataFile = SD.open("datalog.csv", FILE_WRITE);
  if (dataFile) {
    // Only write header if file is new (size == 0 after open)
    if (dataFile.size() == 0) {
      dataFile.println("Sample,Millis,AnalogValue,Voltage");
    }
    dataFile.close();
    Serial.println("Logging to datalog.csv...");
    Serial.println("Sample, Millis, Value, Voltage");
  } else {
    Serial.println("Error opening datalog.csv");
  }
}

void loop() {
  int sensorValue = analogRead(sensorPin);
  float voltage = sensorValue * (5.0 / 1023.0);
  unsigned long timestamp = millis();
  sampleNumber++;

  // Build the data string
  String dataString = "";
  dataString += String(sampleNumber);
  dataString += ",";
  dataString += String(timestamp);
  dataString += ",";
  dataString += String(sensorValue);
  dataString += ",";
  dataString += String(voltage, 2);

  // Write to SD card
  File dataFile = SD.open("datalog.csv", FILE_WRITE);
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    Serial.println(dataString);
  } else {
    Serial.println("Error opening datalog.csv");
  }

  delay(2000); // Log every 2 seconds
}

How to Use:

  1. Connect a sensor to analog pin A0, or leave it unconnected to log floating values as a test.
  2. Upload the sketch and open the Serial Monitor at 9600 baud.
  3. The Arduino will log a reading every 2 seconds to datalog.csv on the SD card.
  4. Remove the SD card and open datalog.csv in a spreadsheet application to view your logged data.

💡 Tip: For long-term data logging, consider adding a Real-Time Clock (RTC) module like the DS3231 to get accurate date and time stamps instead of using millis().

🏗️ Schematic

The schematic below shows the onboard circuitry of the Micro SD card module, including the voltage regulator and level-shifting components.

Micro SD Memory Card Storage Board Module with SPI Interface Schematic

🎯 Typical Applications

  • Sensor data logging (temperature, humidity, pressure, GPS, etc.)
  • Storing configuration files for microcontroller projects
  • Audio playback projects (WAV file playback)
  • Image storage for TFT display projects
  • GPS track logging
  • Flight data recorders for drones and RC aircraft
  • Portable measurement and test instruments
  • Storing web pages for Arduino-based web servers

🛠️ Troubleshooting

Problem Possible Cause Solution
"Initialization failed" in Serial Monitor Wiring error, no card inserted, or card not formatted correctly Double-check all SPI wiring. Ensure the card is fully seated. Format the card as FAT32.
Card is detected but files can't be created Card is write-protected or full Check the lock switch on your SD adapter. Try a different card with free space.
Garbled or no data in Serial Monitor Baud rate mismatch Make sure the Serial Monitor baud rate matches the value in Serial.begin() (typically 9600).
Module works intermittently Loose connections or insufficient power Secure all jumper wire connections. Ensure VCC is getting a stable 5V supply. Try shorter jumper wires.
Card works on computer but not with Arduino Card formatted as exFAT or NTFS Reformat the card as FAT32. Cards over 32 GB may default to exFAT.
Only some cards work Card compatibility issue Try a different brand or smaller capacity card (4 GB or 8 GB cards tend to be most reliable).
Data logging stops after a while File not being closed properly, or card is full Always call myFile.close() after writing. Check available space on the card.

💡 Tip: If you're having persistent initialization failures, try reducing the SPI speed by using SPI_HALF_SPEED in the card initialization. Some cards and longer wiring runs work better at lower clock speeds.

⚠️ Important Notes

  • Always format your SD card as FAT16 or FAT32 before use. exFAT and NTFS are not supported by the Arduino SD library.
  • The Arduino SD library supports filenames in the 8.3 format only (e.g., DATALOG.CSV, not my_long_filename.csv). Filenames must be 8 characters or fewer with a 3-character extension.
  • Always close files after writing with myFile.close() to ensure data is saved properly. Data may be lost if the file is not closed before power is removed.
  • Do not remove the SD card while the Arduino is actively reading or writing — this can corrupt the file system.
  • The module draws approximately 80 mA during active read/write operations. If powering multiple modules from your Arduino, ensure your power supply can handle the total current draw.
  • SDXC cards (64 GB and larger) are not supported.
  • For best reliability, use name-brand SD cards (SanDisk, Samsung, Kingston) in the 4 GB – 16 GB range.

🏪 Where to Buy the Micro SD Memory Card Module

This module is available at Envistia Mall.

📚 Additional Resources

This guide is provided by Envistia Mall for educational and technical reference purposes. The manufacturer and Envistia LLC (dba Envistia Mall) are not responsible for any damages or losses resulting from the use of this product. Always follow proper electrical safety practices when working with electronic components. Specifications are based on manufacturer data and are subject to change without notice.

Share this guide:
in

🛒 Related Products

Find the components mentioned in this guide in our store.

Browse Products →