The Complete Guide to SD Card Module with Arduino

1 Hardware Requirements

To follow this tutorial, you'll need these essential components:

• Arduino Board: Uno, Mega, Nano, or similar with SPI pins
• SD Card Module: Standard SPI-based module with microSD slot
• microSD Card: Formatted as FAT16 or FAT32 (2GB-32GB recommended)
• Jumper Wires: Male-to-female or male-to-male for connections
• Breadboard: Optional but recommended for prototyping
• USB Cable: For Arduino programming and power

2 SD Card Preparation

Before using an SD card with Arduino, proper preparation is essential:

1. Backup Data: Formatting erases everything - backup existing files first
2. Format as FAT32: Most compatible file system for Arduino SD library
3. Windows Formatting: Right-click drive → Format → Choose FAT32 → Quick Format
4. Mac Formatting: Use Disk Utility → Erase → MS-DOS (FAT)
5. Linux Formatting: Use GParted or mkfs.fat -F 32 /dev/sdX1
6. Test on Computer: Create a test file to verify card works properly

3 Connection Guide

For Arduino Uno, Nano, and similar boards:

• SD Module VCC → Arduino 5V
• SD Module GND → Arduino GND
• SD Module MOSI → Arduino Pin 11
• SD Module MISO → Arduino Pin 12
• SD Module SCK → Arduino Pin 13
• SD Module CS → Arduino Pin 4 (or any digital pin)

For Arduino Mega:

• SD Module VCC → Arduino 5V
• SD Module GND → Arduino GND
• SD Module MOSI → Arduino Pin 51
• SD Module MISO → Arduino Pin 50
• SD Module SCK → Arduino Pin 52
• SD Module CS → Arduino Pin 53 (or any digital pin)

4 Initial Testing Code

Upload this code to verify your SD card module is working correctly:

#include 
#include 

File myFile;
const int chipSelect = 4;

void setup() {
  Serial.begin(9600);
  
  Serial.print("Initializing SD card...");
  
  if (!SD.begin(chipSelect)) {
    Serial.println("Initialization failed!");
    return;
  }
  Serial.println("Initialization done.");
  
  // Open file for writing
  myFile = SD.open("test.txt", FILE_WRITE);
  
  if (myFile) {
    Serial.print("Writing to test.txt...");
    myFile.println("SD card test successful!");
    myFile.close();
    Serial.println("done.");
  } else {
    Serial.println("Error opening test.txt");
  }
  
  // Re-open file for reading
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("test.txt content:");
    
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    myFile.close();
  } else {
    Serial.println("Error opening test.txt for reading");
  }
}

void loop() {
  // Nothing happens here
}

5 Complete Data Logger Code

Here's a complete data logger that records temperature readings with timestamps:

#include 
#include 

const int chipSelect = 4;
const int temperaturePin = A0;
File dataFile;

void setup() {
  Serial.begin(9600);
  
  // Initialize SD card
  if (!SD.begin(chipSelect)) {
    Serial.println("SD card initialization failed!");
    while (1); // Halt if SD card fails
  }
  Serial.println("SD card initialized.");
  
  // Check if file exists, create header if not
  if (!SD.exists("datalog.csv")) {
    dataFile = SD.open("datalog.csv", FILE_WRITE);
    if (dataFile) {
      dataFile.println("Timestamp,Temperature (C)");
      dataFile.close();
    }
  }
}

void loop() {
  // Read temperature (simulated with potentiometer for this example)
  int sensorValue = analogRead(temperaturePin);
  float voltage = sensorValue * (5.0 / 1023.0);
  float temperatureC = voltage * 100; // Simple conversion for demonstration
  
  // Open file for appending
  dataFile = SD.open("datalog.csv", FILE_WRITE);
  
  if (dataFile) {
    // Create timestamp (simplified - consider RTC module for accurate time)
    unsigned long timestamp = millis();
    
    // Write data to file
    dataFile.print(timestamp);
    dataFile.print(",");
    dataFile.println(temperatureC);
    
    dataFile.close();
    
    // Also print to Serial for monitoring
    Serial.print("Logged: ");
    Serial.print(timestamp);
    Serial.print(" ms, ");
    Serial.print(temperatureC);
    Serial.println(" C");
  } else {
    Serial.println("Error opening datalog.csv");
  }
  
  delay(5000); // Log every 5 seconds
}

Code Explanation: This creates a CSV file that can be easily opened in spreadsheet software. The code initializes the SD card, creates a header row if the file doesn't exist, then periodically logs timestamped temperature readings.

6 Directory Management

Organize your data with proper directory structure:

// Create a directory
if (SD.mkdir("/sensor_data")) {
  Serial.println("Directory created");
}

// Check if directory exists
if (SD.exists("/sensor_data")) {
  Serial.println("Directory exists");
}

// List files in directory
void listFiles(const char* dirname) {
  Serial.print("Listing files in: ");
  Serial.println(dirname);
  
  File root = SD.open(dirname);
  if (!root) {
    Serial.println("Failed to open directory");
    return;
  }
  
  File file = root.openNextFile();
  while (file) {
    if (!file.isDirectory()) {
      Serial.print("  FILE: ");
      Serial.print(file.name());
      Serial.print("  SIZE: ");
      Serial.println(file.size());
    }
    file = root.openNextFile();
  }
}

7 Efficient Data Writing Techniques

For frequent data logging, optimize write operations to extend SD card lifespan:

• Buffer Data: Collect data in memory and write larger chunks less frequently
• Minimize Open/Close: Keep files open during logging sessions instead of opening for each write
• Check File Size: Create new files when current file reaches size limit
• Implement Error Handling: Add recovery mechanisms for write failures

8 Battery-Powered Projects

For battery-powered projects, SD card power consumption matters:

• Active Writing: 15-100mA (depending on card class and size)
• Idle Current: 0.1-2mA
• Sleep Mode: 50-200μA

Power-Saving Tips:

1. Power the SD module through a digital pin to turn it off when not needed
2. Minimize write operations by buffering data
3. Use lower-capacity cards (they often consume less power)
4. Consider disabling SPI bus when not in use