Polito's Martians

Inspiration

We're four engineering students at Politecnico di Torino, and the idea of keeping astronauts alive on Mars with nothing but sunlight and clever control loops was irresistible. Mars receives roughly 43% of Earth's solar irradiance, dust storms can slash that further, and there's no grid to fall back on — every watt matters. We wanted to prove that a small team armed with MATLAB, Simulink, and first-principles thinking could design a power system robust enough to survive 7 Martian sols without a single blackout.

What it does

Our project is a complete, self-sustaining Martian microgrid that chains four subsystems into one closed-loop power architecture:

1. Design Space Exploration — A parameter sweep identifies the minimum viable configuration: 50 kW solar / 90% initial SOC.
2. Impedance Matching — A 1000S × 10P solar array is sized so that $P = V \cdot I = 500\,\text{V} \times 100\,\text{A} = 50\,\text{kW}$ at the optimal load resistance $R_{opt} = 5.05\,\Omega$.
3. MPPT (Perturb & Observe) — A buck-boost converter with $\Delta D = 0.0001$ locks onto the maximum power point in < 0.3 s and holds a rock-steady 50 kW under changing irradiance.
4. Battery Voltage Control — A PI controller ($K = 0.005$, $V_{set} = 510\,\text{V}$) regulates the DC bus within the 500–520 V band for the entire mission.

The end result: 510 V of stable power for 7 sols, with the battery SOC ending just above zero — meaning we sized the system to the tightest viable margin with no wasted capacity.

How we built it

• MATLAB & Simulink were the backbone — every subsystem was modeled, simulated, and validated in Simulink before integration.
• Task 1 used a brute-force parameter sweep (solar power in 10 kW steps, SOC in 10% steps) to map the pass/fail boundary.
• Task 2 modeled a single-diode solar cell, then scaled it with $N_s = 1000$ series cells and $N_p = 10$ parallel strings. A variable resistor sweep ($R_0 = 10\,\Omega$, slope $= -0.9\,\Omega/\text{s}$) located the MPP.
• Task 3 implemented the P&O algorithm with carefully tuned limits ($D_{min} = 0.20$, $D_{max} = 0.80$) to prevent thermal runaway and maintain control authority.
• Task 4 iterated on PI gain — $K = 0.01$ caused oscillations outside spec, so we halved it to $K = 0.005$, which settled with only ~0.004 V undershoot.
• The website was built with Next.js, Tailwind CSS, and Framer Motion, featuring custom WebGL shaders for the Mars-themed visuals and animated task cards that present each solution interactively.
• We used the Simulink Agentic Toolkit with GitHub Copilot to accelerate model exploration and documentation.

Challenges we ran into

• Tuning the PI controller was the trickiest part. Our first gain ($K = 0.01$) drove the bus voltage into large oscillations well outside the 500–520 V band — a classic case of being too aggressive with an integrator on a system with slow battery dynamics.
• MPPT step size trade-off: too large a $\Delta D$ caused visible power ripple on the bus; too small and the algorithm couldn't track irradiance drops fast enough. We converged on $\Delta D = 0.0001$ after several iterations.
• Design space exploration was deceptively simple — but discovering that 50 kW / 80% SOC fails while 50 kW / 90% SOC passes taught us how razor-thin the margin is on Mars, where nighttime loads drain the battery with zero solar input.
• Full system integration required every subsystem's assumptions to be consistent (bus voltage, power rating, sample times), which surfaced subtle mismatches we hadn't anticipated.

Accomplishments that we're proud of

• Voltage regulation within ±0.004 V of setpoint — our PI controller delivers 510 V with near-zero steady-state error across the full 7-sol mission, including dynamic load transients.
• MPPT convergence in 0.3 s with negligible steady-state ripple — the power output is essentially a flat line at 50 kW over 100 seconds of simulation.
• Minimum viable sizing — we didn't over-engineer the array. The 50 kW / 90% SOC configuration is the tightest passing design, finishing the mission with SOC just above zero.
• The interactive website with WebGL shaders, animated architecture diagrams, and per-task breakdowns — we wanted the presentation to match the quality of the engineering.

What we learned

• Control tuning is an art: halving a single gain ($K$: $0.01 \to 0.005$) transformed the system from unstable oscillations to textbook-perfect regulation. Small numbers, big consequences.
• Series vs. parallel array sizing is deeply intuitive once you see it on the I-V curve — $N_s$ stretches horizontally (voltage), $N_p$ stretches vertically (current), and their product gives you the power target.
• The P&O algorithm is elegant in its simplicity — perturb, measure, decide — but the devil is in the step size. We now have real intuition for the speed-vs-ripple trade-off.
• Mars doesn't forgive over-design or under-design: every extra kW of solar panels is mass that must be launched, and every missing kW is a blackout. The engineering sweet spot is narrow.
• AI-assisted model exploration with the Simulink Agentic Toolkit significantly accelerated our workflow, especially for parameter sweeps and documentation.

What's next for Polito's Martians

• Dust storm modeling — inject realistic Martian dust storm profiles (opacity $\tau$ time series) to stress-test MPPT tracking under severe irradiance transients.
• Multi-source generation — add a radioisotope thermoelectric generator (RTG) as a baseload source, with an energy management system that arbitrates between solar, RTG, and battery.
• Thermal modeling — Mars surface temperatures swing from $-80°\text{C}$ to $+20°\text{C}$; modeling temperature effects on solar cell efficiency and battery capacity would bring the simulation closer to flight-ready fidelity.
• Hardware-in-the-loop (HIL) — deploy the control algorithms onto a real-time target (e.g., Speedgoat) and validate against a physical power electronics testbench.
• Code generation — use Simulink Coder to auto-generate embedded C from our controller models, closing the loop from simulation to deployable flight software.

Built With

• matlab
• nextjs
• simulink