DIY Rocket Datalogger: Arduino + MPU + SD Card in Space : "ROCDAT"

by Aayushman jha in Circuits > Arduino

85 Views, 2 Favorites, 0 Comments

DIY Rocket Datalogger: Arduino + MPU + SD Card in Space : "ROCDAT"

WhatsApp Image 2025-10-01 at 3.10.11 PM (3).jpeg
WhatsApp Image 2025-10-01 at 3.10.11 PM (1).jpeg

🚀 Introduction: ROCDAT – Rocket Datalogger

Every rocket tells a story when it launches — how fast it accelerates, how high it goes, and how stable it flies. To capture that story, I built ROCDAT, a compact rocket datalogger that works like a miniature “black box” for model rockets.

ROCDAT is powered by an Arduino Nano R3, an MPU6050 sensor (for acceleration and rotation), and an SD card module to store the data. During flight, it records motion in real time, saving it to a microSD card. After recovery, the data can be opened on a computer and turned into graphs that reveal the rocket’s path through the sky.

What makes ROCDAT special:

  1. Simple and DIY-friendly — made with affordable, widely available parts.
  2. Compact and lightweight — small enough to fit inside model rockets.
  3. Educational and space-focused — helps anyone learn about rocketry and flight dynamics.

By connecting hands-on electronics with space exploration, ROCDAT shows how even small projects can bring us closer to understanding the physics of flight — a small but meaningful step toward the big dream of space.

Supplies

supplies.jpg

The supplies are :

Arduino Nano

MPU6050 module

MicroSD card module

Prototyping board + jumper wires

female connectors

double sided tape

arduino nano data wire for connecting with laptop to check if working

it can also be powered with 3.3v lipo battery and boost converter (optional)

hot glue gun

3d printed parts (optional)

Gather All Supplies

supplies.jpg

đź›  Step 1: Gathering the Supplies

Before building ROCDAT, the rocket datalogger, let’s collect all the components needed for the project. These are all readily available, low-cost parts, and most of them are common in Arduino-based electronics projects. Having everything ready at the start makes the assembly smoother and avoids interruptions later.

Each part plays an important role:

  1. The Arduino Nano R3 is the “brain” of the logger.
  2. The MPU6050 records motion — acceleration and rotation during flight.
  3. The microSD module (HW125) stores all the data safely, like a black box.
  4. The prototyping board, jumper wires, and header pins make the connections permanent and reliable.

Once you’ve gathered these, you’re ready to bring the datalogger to life.

Coding

ROCDAT.png
The code for this ROCDAT :
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>

// Define the custom Chip Select pin for the SD card module
const int chipSelect = 10;

Adafruit_MPU6050 mpu; // Create MPU-6050 sensor object
File dataFile;

void setup() {
Serial.begin(9600);
while (!Serial); // Wait for serial connection

// Initialize MPU-6050
if (!mpu.begin()) {
Serial.println("Failed to find MPU6050 chip");
while (1) {
delay(10);
}
}
Serial.println("MPU6050 Found!");

// Set MPU-6050 ranges
mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
mpu.setGyroRange(MPU6050_RANGE_500_DEG);
mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);

// Initialize SD card
Serial.print("Initializing SD card...");
// SD.begin() uses the specified chipSelect pin
if (!SD.begin(chipSelect)) {
Serial.println("SD card initialization failed!");
return;
}
Serial.println("SD card initialization done.");

// Create a new file with a header
dataFile = SD.open("datalog.csv", FILE_WRITE);
if (dataFile) {
dataFile.println("Timestamp,AccelX,AccelY,AccelZ,GyroX,GyroY,GyroZ");
dataFile.close();
} else {
Serial.println("Error opening datalog.csv");
}
}

void loop() {
sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp); // Get new sensor events with the readings

// Open the CSV file in append mode
dataFile = SD.open("Datalog.csv", FILE_WRITE);
if (dataFile) {
// Log the data in CSV format
dataFile.print(millis());
dataFile.print(",");
dataFile.print(a.acceleration.x);
dataFile.print(",");
dataFile.print(a.acceleration.y);
dataFile.print(",");
dataFile.print(a.acceleration.z);
dataFile.print(",");
dataFile.print(g.gyro.x);
dataFile.print(",");
dataFile.print(g.gyro.y);
dataFile.print(",");
dataFile.println(g.gyro.z);

// Close the file
dataFile.close();
} else {
Serial.println("error opening datalog.csv");
}

// Print to Serial Monitor for real-time monitoring
Serial.print("Accel (m/s^2): ");
Serial.print(a.acceleration.x); Serial.print(", ");
Serial.print(a.acceleration.y); Serial.print(", ");
Serial.print(a.acceleration.z); Serial.println("");

Serial.print("Gyro (rad/s): ");
Serial.print(g.gyro.x); Serial.print(", ");
Serial.print(g.gyro.y); Serial.print(", ");
Serial.print(g.gyro.z); Serial.println("");
Serial.println("--------------------");

delay(1000); // Log data every 100 milliseconds
}

Connection

🔌 ROCDAT Wiring Connections

1. Arduino Nano R3 → MPU6050 (I²C)

  1. VCC → 5V (or 3.3V, depending on your MPU6050 breakout board – most support 5V input).
  2. GND → GND
  3. SDA → A4 (I²C Data)
  4. SCL → A5 (I²C Clock)
  5. AD0 → GND (sets MPU6050 I²C address to 0x68 — default).

2. Arduino Nano R3 → MicroSD Card Module (HW125, SPI)

  1. VCC → 5V (HW125 has a regulator and level shifting, safe for 5V).
  2. GND → GND
  3. MOSI → D11
  4. MISO → D12
  5. SCK → D13
  6. CS (Chip Select) → D10

3. Other Notes

  1. Common Ground: All modules must share a common ground with the Arduino.
  2. Power Supply: Use Arduino Nano’s USB or an external regulated source (if inside rocket, typically a LiPo with a regulator).
  3. Decoupling: Place a 100 µF capacitor across VCC and GND near the SD card module for stability during writes.(optional)

đź–Ľ Wiring Diagram (Not mentioned as i think not that much in use than text)


đź“Ś This is the standard, reliable wiring for your ROCDAT system.

Final Touch and (covering With 3d Printed Case [optional] )

WhatsApp Image 2025-10-01 at 3.10.11 PM (4).jpeg
WhatsApp Image 2025-10-01 at 3.10.11 PM (5).jpeg
WhatsApp Image 2025-10-01 at 3.10.11 PM (6).jpeg

Final touches (what to do before submission)

  1. Secure wiring & strain relief: bundle signal wires with braided sleeving or nylon zip ties; add strain relief at connectors so a tug won’t pull solder joints.
  2. Reliable connectors: use keyed, labeled quick‑disconnects for power and any external plugs (prevents wrong mating).
  3. Insulation & shrouds: heat‑shrink every exposed solder joint; cover high‑current wires with additional sleeving.
  4. Vibration damping: add foam pads, rubber grommets, or silicone bumpers under PCBs and modules to absorb shock.
  5. Mounting option (open): arrange modules on a perforated bulkhead or mounting plate with standoffs, leaving access for inspection and swaps. Keep wires neat and away from edges.
  6. Mounting option (3D‑printed cubes): design small cubes with slots for the module and wire exits, integrated standoffs, and a snap/press fit. Cubes give repeatable placement, reduce movement, and protect pins.
  7. Label everything: print small tags or use a label maker for pins, connectors, power rails, and test points.
  8. Test points & LED indicators: add clearly marked test pads and status LEDs (power, SD activity, IMU OK) for quick bench checks.
  9. Thermal & EMI considerations: avoid tightly packing heat-generating parts; if needed, a thin aluminum shield for EMI-sensitive traces.
  10. Conformal coating (optional): thin conformal coat on PCBs if moisture/residue is a concern — only after final rework.
  11. Access & serviceability: design one removable panel or captive screws so judges can inspect without disassembly.
  12. Weight & balance note: keep heavy items centered; mark the system’s CG on the enclosure.
  13. Final QC checklist: power test, SD read/write test, IMU data sanity, connector tug test, LED/status verification. Photograph each step.
  14. Documentation: include a one‑page wiring map, BOM, and short test log for judges.

Pros / Cons — Open vs 3D cubes

  1. Open mounting
  2. Pros: easy inspection & replacement, simpler to implement.
  3. Cons: less protection vs vibration/impact, wires more exposed.
  4. 3D‑printed cubes
  5. Pros: neat, repeatable, protects modules and wires, better for constrained compartments.
  6. Cons: needs design/print time; may impede quick swaps if overly tight.

Important:

“Final assembly: modules mounted on a standoff plate with labeled quick‑disconnects and strain relief; vibration damping under PCBs; status LEDs and test points for verification. Optional 3D‑printed cube holders secure sensors and SD module for improved shock protection and repeatable placement. All joints heat‑shrunk; enclosure includes an inspection panel and CG mark.” , i have given a plastic model of covering of ROCDAT , it's just for display , anyone can use better materials like alloy of aluminum and titanium casing or use carbon fiber.

Done and Ready to Use or Test!!!!

accGraph.png

This is the output in sd card in the form of csv file in excel , for test I've given the csv output in the form of graph below:

Downloads

DATALOG.CSV