# Manpads System Launcher And Rocket > ```markdown - Skill: `aradotso-trending-skills/manpads-system-launcher-and-rocket` (Agent Skill) - Install (CLI): `npx skillmds@latest add aradotso-trending-skills/manpads-system-launcher-and-rocket` - Raw SKILL.md: https://api.skillmd.com/api/skills/aradotso-trending-skills/manpads-system-launcher-and-rocket/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Docs & Writing - Author: aradotso (https://skillmd.com/u/aradotso-trending-skills) - Updated: 2026-09-21 - Page: https://skillmd.com/skills/aradotso-trending-skills/manpads-system-launcher-and-rocket --- ```markdown --- name: manpads-system-launcher-and-rocket description: Low-cost proof-of-concept MANPADS-style guided rocket and launcher prototype using ESP32, MPU6050, folding fins, canard stabilization, and consumer electronics triggers: - manpads rocket launcher - esp32 flight controller - guided rocket prototype - canard stabilization firmware - mpu6050 rocket imu - openrocket simulation - 3d printed rocket launcher - folding fin rocket design --- # MANPADS System Launcher and Rocket Skill > Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection A proof-of-concept guided rocket and launcher system built with consumer electronics and 3D-printed components. The rocket features folding fins, canard stabilization, an ESP32 flight computer, and an MPU6050 IMU. The launcher integrates GPS, compass, and barometric sensors for orientation and telemetry. Total hardware cost: ~$96. --- ## What It Does - **Rocket flight computer**: ESP32-based controller reads IMU data, drives canard servos for stabilization, manages ignition sequencing - **Launcher system**: GPS + compass + barometer integration for target orientation and telemetry - **Mechanical design**: Fusion 360 CAD for rocket body, folding fins, canard assembly, and launcher tube - **Simulation**: OpenRocket files for aerodynamic stability analysis and motor selection - **Firmware**: Arduino/ESP-IDF firmware for both rocket and launcher subsystems --- ## Repository Structure ``` / ├── CAD/ # Fusion 360 .f3d files for rocket and launcher ├── Firmware/ │ ├── Rocket/ # ESP32 flight controller firmware │ └── Launcher/ # Launcher sensor and telemetry firmware ├── Simulation/ # OpenRocket .ork simulation files └── Documentation/ # System flow diagrams, BOM, specs ``` --- ## Hardware Stack ### Rocket | Component | Purpose | |---|---| | ESP32 | Flight computer / main MCU | | MPU6050 | 6-DOF IMU (accel + gyro) | | Micro servos (x2) | Canard fin actuation | | E-match / igniter | Motor ignition | | LiPo cell | Power supply | ### Launcher | Component | Purpose | |---|---| | ESP32 | Main controller | | GPS module (NEO-6M or similar) | Position fix | | HMC5883L / QMC5883 | Compass / heading | | BMP280 / MS5611 | Barometric altitude | | Relay module | Fire control circuit | --- ## Firmware: Rocket Flight Controller ### Core IMU Read + Canard Control Loop (ESP32 / Arduino framework) ```cpp #include #include #include MPU6050 imu; Servo canardPitch; Servo canardYaw; // PID state float pitchIntegral = 0, yawIntegral = 0; float prevPitchErr = 0, prevYawErr = 0; const float Kp = 1.2f, Ki = 0.01f, Kd = 0.4f; const int SERVO_CENTER = 90; const int SERVO_RANGE = 30; // ±30 degrees max deflection void setup() { Wire.begin(); imu.initialize(); if (!imu.testConnection()) { Serial.println("MPU6050 connection failed"); while (1); } canardPitch.attach(18); // GPIO18 canardYaw.attach(19); // GPIO19 canardPitch.write(SERVO_CENTER); canardYaw.write(SERVO_CENTER); Serial.begin(115200); } float pidUpdate(float error, float &integral, float &prevError, float dt) { integral += error * dt; float derivative = (error - prevError) / dt; prevError = error; return Kp * error + Ki * integral + Kd * derivative; } void loop() { static unsigned long lastTime = micros(); unsigned long now = micros(); float dt = (now - lastTime) / 1e6f; lastTime = now; int16_t ax, ay, az, gx, gy, gz; imu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz); // Convert raw gyro to deg/s (MPU6050 default ±250°/s scale) float pitchRate = gy / 131.0f; float yawRate = gz / 131.0f; // Target: zero rotation rate (stabilization mode) float pitchCmd = pidUpdate(pitchRate, pitchIntegral, prevPitchErr, dt); float yawCmd = pidUpdate(yawRate, yawIntegral, prevYawErr, dt); // Clamp and apply pitchCmd = constrain(pitchCmd, -SERVO_RANGE, SERVO_RANGE); yawCmd = constrain(yawCmd, -SERVO_RANGE, SERVO_RANGE); canardPitch.write(SERVO_CENTER + (int)pitchCmd); canardYaw.write(SERVO_CENTER + (int)yawCmd); delayMicroseconds(2000); // ~500 Hz loop } ``` ### Complementary Filter for Attitude Estimation ```cpp // Fuse accelerometer angle with gyro integration float compFilter(float accelAngle, float gyroRate, float prevAngle, float dt, float alpha = 0.98f) { return alpha * (prevAngle + gyroRate * dt) + (1.0f - alpha) * accelAngle; } float accelPitch(int16_t ax, int16_t ay, int16_t az) { return atan2f((float)ay, sqrtf((float)ax * ax + (float)az * az)) * RAD_TO_DEG; } ``` --- ## Firmware: Launcher System ### GPS + Compass + Barometer Initialization ```cpp #include #include #include #include #include TinyGPSPlus gps; QMC5883LCompass compass; Adafruit_BMP280 baro; HardwareSerial gpsSerial(1); // UART1 void launcherSetup() { Wire.begin(); gpsSerial.begin(9600, SERIAL_8N1, 16, 17); // RX=GPIO16, TX=GPIO17 compass.init(); compass.setCalibration(-500, 500, -500, 500, -500, 500); // calibrate per unit if (!baro.begin(0x76)) { Serial.println("BMP280 not found"); } baro.setSampling(Adafruit_BMP280::MODE_NORMAL, Adafruit_BMP280::SAMPLING_X2, Adafruit_BMP280::SAMPLING_X16, Adafruit_BMP280::FILTER_X4, Adafruit_BMP280::STANDBY_MS_500); } struct LauncherTelemetry { double lat, lng; float altitudeMSL; float heading; bool gpsFix; }; LauncherTelemetry readTelemetry() { LauncherTelemetry t = {}; // Feed GPS while (gpsSerial.available()) gps.encode(gpsSerial.read()); t.gpsFix = gps.location.isValid(); if (t.gpsFix) { t.lat = gps.location.lat(); t.lng = gps.location.lng(); } t.altitudeMSL = baro.readAltitude(1013.25f); // standard sea-level pressure compass.read(); t.heading = compass.getAzimuth(); // 0–360 degrees return t; } ``` ### Fire Control Relay ```cpp const int RELAY_PIN = 25; const int ARM_PIN = 26; // physical arm switch const int LAUNCH_DELAY = 3000; // ms countdown void fireControlSetup() { pinMode(RELAY_PIN, OUTPUT); pinMode(ARM_PIN, INPUT_PULLUP); digitalWrite(RELAY_PIN, LOW); } bool fireLaunch() { if (digitalRead(ARM_PIN) != LOW) { Serial.println("System not armed"); return false; } Serial.println("FIRE in 3..."); delay(LAUNCH_DELAY); digitalWrite(RELAY_PIN, HIGH); delay(500); // e-match pulse duration digitalWrite(RELAY_PIN, LOW); Serial.println("Launch complete"); return true; } ``` --- ## OpenRocket Simulation Workflow 1. Open `.ork` file in [OpenRocket](https://openrocket.info/) (free, Java-based) 2. Verify stability margin (target: 1.0–2.0 calibers at launch) 3. Select motor from database matching the prototype's 24mm or 29mm mount 4. Run simulation → check apogee, max velocity, max acceleration 5. Export CSV for post-processing thrust curves ```python # Parse OpenRocket CSV export import pandas as pd import matplotlib.pyplot as plt df = pd.read_csv("simulation_export.csv", skiprows=5) df.columns = df.columns.str.strip() plt.figure(figsize=(10, 4)) plt.plot(df["Time (s)"], df["Altitude (m)"], label="Altitude") plt.plot(df["Time (s)"], df["Vertical velocity (m/s)"], label="Velocity") plt.xlabel("Time (s)") plt.legend() plt.title("OpenRocket Simulation") plt.tight_layout() plt.savefig("sim_plot.png") ``` --- ## Configuration ### PID Tuning Constants (Rocket firmware) ```cpp // Tune these for your specific airframe and motor const float Kp = 1.2f; // Proportional — increase for faster response const float Ki = 0.01f; // Integral — increase to correct steady drift const float Kd = 0.4f; // Derivative — increase to reduce overshoot ``` ### MPU6050 Full-Scale Range ```cpp // In setup(), optionally set higher range for high-G flight imu.setFullScaleAccelRange(MPU6050_ACCEL_FS_16); // ±16g imu.setFullScaleGyroRange(MPU6050_GYRO_FS_2000); // ±2000°/s // Update scale factor: gyro = raw / 16.4f at 2000°/s range ``` ### platformio.ini ```ini [env:esp32dev] platform = espressif32 board = esp32dev framework = arduino lib_deps = electroniccats/MPU6050 @ ^1.3.0 madhephaestus/ESP32Servo @ ^0.13.0 mikalhart/TinyGPSPlus @ ^1.0.3 mprograms/QMC5883LCompass @ ^1.2.0 adafruit/Adafruit BMP280 Library @ ^2.6.8 monitor_speed = 115200 ``` --- ## Integration Patterns ### Rocket State Machine ```cpp enum FlightState { IDLE, ARMED, BOOST, COAST, APOGEE, DESCENT }; FlightState state = IDLE; void updateStateMachine(float accelMag, float altitudeDelta) { switch (state) { case IDLE: if (/* arm signal received */ false) state = ARMED; break; case ARMED: if (accelMag > 3.0f) state = BOOST; // 3g threshold for launch detect break; case BOOST: if (accelMag < 1.1f) state = COAST; // motor burnout break; case COAST: if (altitudeDelta < -0.5f) state = APOGEE; // descending break; case APOGEE: // deploy recovery, cut power to servos state = DESCENT; break; default: break; } } ``` ### Launcher–Rocket Communication (optional UART link) ```cpp // Launcher sends launch command over serial before ignition void sendLaunchPacket(HardwareSerial &link) { uint8_t packet[] = { 0xAA, 0x01, 0xFF }; // header, cmd, checksum link.write(packet, sizeof(packet)); } // Rocket receives and validates bool receiveLaunchCommand(HardwareSerial &link) { if (link.available() >= 3) { uint8_t buf[3]; link.readBytes(buf, 3); return (buf[0] == 0xAA && buf[1] == 0x01 && buf[2] == 0xFF); } return false; } ``` --- ## Troubleshooting | Symptom | Likely Cause | Fix | |---|---|---| | MPU6050 not detected | I2C address mismatch | Check AD0 pin; address is 0x68 (low) or 0x69 (high) | | Servos jittering at rest | PID gains too high / noise | Lower Kp, add low-pass filter on gyro | | GPS no fix indoors | Weak signal | Test outdoors with clear sky view; cold start takes 1–3 min | | Compass heading drifts | Hard/soft iron interference | Run compass calibration routine, keep away from motors | | Relay fires immediately | ARM_PIN floating | Ensure INPUT_PULLUP and arm switch wired correctly | | Rocket unstable in sim | CG behind CP | Add nose weight or lengthen nose cone in CAD | | High current draw on 3.3V | All peripherals active | Stagger initialization; use separate 3.3V LDO for sensors | ### MPU6050 I2C Scan ```cpp void i2cScan() { for (uint8_t addr = 1; addr < 127; addr++) { Wire.beginTransmission(addr); if (Wire.endTransmission() == 0) { Serial.printf("Device at 0x%02X\n", addr); } } } ``` --- ## Resources - [Full development archive (Google Drive)](https://drive.google.com/drive/folders/17zpks6_R59H0iXJaGkTrtp1SzIFFAQtY?usp=drive_link) — BOM, assembly media, test footage, flow diagrams - [OpenRocket](https://openrocket.info/) — free rocket simulation - [ESP32 Arduino core](https://github.com/espressif/arduino-esp32) - [MPU6050 datasheet](https://invensense.tdk.com/products/motion-tracking/6-axis/mpu-6050/) - [30-second overview video](https://www.youtube.com/shorts/zFn__6_LdTc) - [Full 5-minute system overview](https://www.youtube.com/watch?v=DDO2EvXyncE&t=59s) ```