Stop Buying Overpriced Power Stations! Build This 414Wh Arduino Beast

What if I told you that a single developer just exposed how badly we've been ripped off?

You've seen them—the slick marketing, the rugged orange shells, the promise of "off-grid freedom" for the low, low price of $800. Portable power stations from Jackery, EcoFlow, and Anker have colonized every camping trip and emergency prepper's garage. But here's the dirty secret nobody wants you to know: you're paying 3-4x markup for technology that hasn't fundamentally changed in years. Worse? You're locked into their ecosystem, their firmware, their planned obsolescence. When that proprietary battery management system dies, so does your "investment."

But what if you could build something better?

Something with 414 watt-hours of raw capacity. Something with Arduino-programmable intelligence, Wi-Fi OTA updates, and bidirectional USB-C Power Delivery that laughs at your MacBook Pro's power brick. Something where you control the firmware, you choose the cells, and you decide which features matter.

Meet the Omnibus4X8—the open-source power station that's making commercial manufacturers extremely nervous.

What Is Omnibus4X8?

The Omnibus4X8 isn't just another DIY battery pack. It's a custom-designed, highly versatile portable power platform engineered by developer Luq1308 as a complete reimagining of what personal energy storage should be. Born from frustration with locked-down commercial products and overpriced "maker" alternatives, this project represents a radical democratization of power electronics.

At its core, the Omnibus4X8 integrates high-density 18650 lithium-ion energy storage, Arduino-based control via ESP32-C3, and an extensive array of power input/output interfaces—all wrapped in layered protection systems that would make commercial engineers nod in respect. The name itself reveals its architecture: 4S8P—4 cells in series, 8 in parallel—yielding a nominal 14.4V system with massive current capability.

Why it's trending now: The timing is almost poetic. Right as global supply chains wobble and energy prices spike, the maker community has matured enough to tackle serious power electronics safely. The ESP32-C3 brings Wi-Fi and Bluetooth to the table at laughable cost. USB-C Power Delivery has finally standardized high-wattage charging. And 18650 cells—salvaged from laptop packs or bought new—offer unbeatable energy density per dollar.

But here's what separates Omnibus4X8 from random Instructables projects: this is production-grade engineering. We're talking MPPT solar tracking. Constant voltage/constant current regulation. Active thermal management with redundant protection. A 1.3" OLED interface that doesn't require a smartphone app. This is the power station that commercial companies should have built—and now you can build it yourself.

The creator's community engagement is equally impressive. With an active Reddit thread and YouTube guide video, Luq1308 isn't just dropping files and disappearing. They're actively featuring community builds and offering support regardless of donation status—a refreshing ethos in an era of Patreon-locked knowledge.

Key Features That Destroy Commercial Alternatives

Let's dissect what makes the Omnibus4X8 genuinely special, feature by feature:

Massive 414Wh Energy Reservoir

The 4S8P configuration using 3500 mAh 18650 cells delivers 414 watt-hours of usable capacity. That's enough to charge a laptop 5-7 times, run a mini-fridge for hours, or power critical medical devices through extended outages. The parallel arrangement provides exceptional current capability—critical for high-draw applications.

ESP32-C3 Brain: Arduino-Programmable Intelligence

Unlike dumb battery boxes, the Omnibus4X8 runs on the ESP32-C3—a RISC-V based microcontroller with built-in Wi-Fi and Bluetooth. This means custom automation scripts, remote monitoring, and Over-The-Air firmware updates without physical access. Want to auto-shutdown at 20% SOC? Program it. Need SMS alerts on power events? Add a webhook. The Arduino framework makes this accessible to millions of existing developers.

SC8812A Bidirectional DC Port: The Secret Weapon

The programmable 20V 6A bidirectional DC port (120W max) based on the SC8812A chip is where things get interesting. This isn't just output—it's true bidirectional power flow with constant voltage and constant current regulation in output mode. In input mode, it offers adaptive charging current or automatic MPPT tracking for solar panels. You're essentially getting a programmable lab power supply inside your power station.

100W USB-C Power Delivery

The IP2368-based bidirectional USB-C port delivers full 100W USB-PD—charge your power station from a USB-C charger, or power your laptop, phone, or Steam Deck at maximum speed. No proprietary bricks needed.

Quad 36W USB-C Outputs

Four independent XPM52C-based 36W USB-C ports mean simultaneous fast-charging for multiple devices without power negotiation conflicts. Family camping trip? Everyone's phone tops up at full speed.

150W AC Mains Output

Pure sine wave? Modified sine? The 150W AC output handles essential appliances that refuse DC—CPAP machines, small tools, vintage electronics.

400W+ Direct Battery Access

The XT60 connector provides unfiltered 30A+ direct battery access for high-draw applications: ham radio transmitters, RC chargers, automotive accessories, or custom inverter integration.

Active Thermal Management with Redundancy

Temperature monitoring plus active cooling prevents thermal runaway. Overload and overcurrent protections with redundancy on all outputs means failures fail safe, not spectacular.

Real-World Use Cases Where Omnibus4X8 Dominates

1. Off-Grid Solar Workstation

Pair the Omnibus4X8 with a 100W folding solar panel. The MPPT mode automatically extracts maximum power as light conditions change. Power your laptop, hotspot, and LED workspace lighting indefinitely—no generator noise, no fuel logistics, no $2000 Goal Zero markup.

2. Emergency Medical Preparedness

For CPAP users, insulin pump backups, or home health equipment, reliability isn't optional. The redundant protection systems, precise voltage regulation, and massive capacity provide hospital-grade confidence. The APO (auto power off) prevents dangerous deep-discharge during extended outages.

3. Professional Field Photography/Videography

Drone batteries, camera chargers, lighting panels, monitor power—location shoots devour electrons. The quad USB-C outputs plus 100W PD and 150W AC replace multiple battery systems. Programmable DC output matches specific equipment voltages without bulky step-down converters.

4. Ham Radio & Emergency Communications

The XT60 direct battery access feeds high-draw transmitters that would choke lesser power stations. The ESP32-C3 enables automated band scanning, digital mode operation, or APRS beaconing with power-aware scheduling.

5. Mobile Development & Repair Lab

Power soldering stations, oscilloscopes, programmers, and test equipment anywhere. The bidirectional DC port's CV/CC regulation acts as a programmable power supply for circuit testing—eliminating a separate bench supply.

Step-by-Step Installation & Setup Guide

WARNING: This project involves lithium-ion batteries, high currents, and mains voltages. Proper safety equipment, knowledge, and precautions are mandatory. If you're uncomfortable with any step, seek qualified assistance.

Phase 1: Component Procurement

Core Components:

• 32x 18650 lithium-ion cells (3500 mAh recommended for full 414Wh capacity)
• 4S8P battery holder or custom nickel strip welding setup
• ESP32-C3 development board (Luq1308's design uses specific variant—check repository)
• SC8812A power management module
• IP2368 USB-PD module
• 4x XPM52C USB-C modules
• 150W inverter module
• 1.3" OLED display (SSD1306 or compatible)
• 3-way navigation button
• XT60 connectors (male/female)
• Thermal sensors (NTC thermistors)
• Cooling fan with PWM control
• Enclosure: 290×175×45 mm (custom 3D print or fabricated)

Phase 2: Battery Assembly

# Cell preparation and testing (use proper lithium-ion handling procedures)
# 1. Test all cells for capacity and internal resistance
# 2. Match cells within 5% capacity for balanced pack performance
# 3. Assemble 4S8P configuration with appropriate BMS

# Recommended cell testing tools:
# - Opus BT-C3100 or similar analyzer
# - 4-wire resistance measurement for matching

Critical: The 4S8P arrangement requires individual cell fusing and a proper Battery Management System (BMS) with balancing. The BMS must support:

• 4S configuration (12.6V-16.8V range)
• 30A+ continuous discharge
• Temperature-based protection
• Cell balancing function

Phase 3: Control System Programming

/* Omnibus4X8 Core Control Framework - ESP32-C3
 * Based on Arduino framework with custom power management
 */

#include <WiFi.h>
#include <ArduinoOTA.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>

// Display configuration
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Pin definitions (adjust per hardware revision)
#define NAV_BUTTON_UP     2
#define NAV_BUTTON_DOWN   3
#define NAV_BUTTON_SELECT 4
#define FAN_PWM_PIN       5
#define TEMP_SENSOR_PIN   6

// SC8812A I2C address for bidirectional DC port control
#define SC8812A_ADDR      0x2B

// Global state variables
float batteryVoltage = 0.0;
float batteryCurrent = 0.0;
float temperature = 0.0;
uint8_t fanSpeed = 0;
bool wifiAPMode = false;

void setup() {
  Serial.begin(115200);
  
  // Initialize I2C for power management chips and display
  Wire.begin();
  
  // Initialize OLED display
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Halt on display failure - critical for user feedback
  }
  
  // Configure navigation button pins with internal pullups
  pinMode(NAV_BUTTON_UP, INPUT_PULLUP);
  pinMode(NAV_BUTTON_DOWN, INPUT_PULLUP);
  pinMode(NAV_BUTTON_SELECT, INPUT_PULLUP);
  
  // Configure fan PWM for active cooling control
  pinMode(FAN_PWM_PIN, OUTPUT);
  ledcSetup(0, 25000, 8); // 25kHz PWM, 8-bit resolution
  ledcAttachPin(FAN_PWM_PIN, 0);
  
  // Initialize power management ICs
  initPowerManagement();
  
  // Configure WiFi based on saved settings
  // STA mode for home network, AP mode for field configuration
  initWiFi();
  
  // Enable Over-The-Air firmware updates
  setupOTA();
  
  displaySplashScreen();
  delay(2000);
}

void loop() {
  // Read all sensor values
  readBatteryStatus();
  readTemperature();
  
  // Adaptive thermal management
  updateFanControl();
  
  // Check for navigation input
  handleUserInput();
  
  // Update display with current status
  updateDisplay();
  
  // Handle OTA update requests
  ArduinoOTA.handle();
  
  // Power management state machine
  updatePowerState();
  
  delay(50); // 20Hz main loop
}

void initPowerManagement() {
  // Initialize SC8812A bidirectional DC-DC converter
  Wire.beginTransmission(SC8812A_ADDR);
  // Configuration registers for 20V output, 6A limit
  // Detailed register settings in repository documentation
  Wire.write(0x00); // Select configuration register
  Wire.write(0x1A); // Enable bidirectional mode, set switching frequency
  Wire.endTransmission();
  
  // Initialize IP2368 for 100W USB-PD
  // Initialize XPM52C modules for quad 36W outputs
  // ... (see full implementation in repository)
}

void updateFanControl() {
  // Map temperature to fan speed with hysteresis
  // Below 35°C: fan off
  // 35-50°C: proportional speed
  // Above 50°C: full speed, trigger warnings
  
  if(temperature < 35.0) {
    fanSpeed = 0;
  } else if(temperature > 55.0) {
    fanSpeed = 255; // Full speed
    // Trigger thermal warning on display
    setSystemWarning(WARNING_THERMAL);
  } else {
    // Linear interpolation between 35-55°C
    fanSpeed = map((int)(temperature * 10), 350, 550, 0, 255);
  }
  
  ledcWrite(0, fanSpeed);
}

void setupOTA() {
  ArduinoOTA.setHostname("omnibus4x8");
  
  ArduinoOTA.onStart([]() {
    String type;
    if (ArduinoOTA.getCommand() == U_FLASH)
      type = "sketch";
    else // U_SPIFFS
      type = "filesystem";
    
    // Save power state before update
    enterSafeMode();
  });
  
  ArduinoOTA.begin();
}

Phase 4: Wi-Fi Configuration & OTA Setup

// WiFi configuration with dual-mode support
void initWiFi() {
  // Attempt to connect to saved STA credentials
  WiFi.mode(WIFI_STA);
  WiFi.begin("YOUR_SSID", "YOUR_PASSWORD");
  
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 20) {
    delay(500);
    attempts++;
  }
  
  if(WiFi.status() != WL_CONNECTED) {
    // Fallback to AP mode for configuration
    WiFi.mode(WIFI_AP);
    WiFi.softAP("Omnibus4X8_Setup", "configure_me");
    wifiAPMode = true;
  }
}

// OTA update endpoint - accessible when connected to AP
// Navigate to http://192.168.4.1/update for firmware upload

Phase 5: Enclosure Assembly

The 290×175×45 mm form factor demands careful thermal design:

• Position cells for even heat distribution
• Route airflow from intake → cells → power electronics → exhaust fan
• Isolate high-voltage AC section with physical barriers
• Ensure all connectors are strain-relieved

Final weight: 2.4 kg with cells installed.

REAL Code Examples from the Repository

The Omnibus4X8 repository contains the complete hardware designs and firmware. Here are critical implementation patterns extracted and explained:

Example 1: Auto Power Off (APO) Implementation

The customizable APO function prevents dangerous deep-discharge:

/* Auto Power Off Configuration
 * Prevents battery damage from extended low-load operation
 * Critical for unattended operation and battery longevity
 */

#define APO_DEFAULT_TIMEOUT_MS  3600000  // 1 hour default
#define APO_MIN_VOLTAGE_MV      12000    // 12.0V cutoff (3.0V per cell)
#define APO_WAKEUP_CURRENT_MA   100      // Threshold to reset timer

struct APOConfig {
  uint32_t timeoutMs;        // Duration before auto-shutdown
  bool enabled;              // APO active state
  uint16_t minVoltage;       // Emergency cutoff voltage
  uint16_t wakeCurrent;      // Current threshold to keep alive
} apoConfig;

unsigned long lastActivityTime = 0;

void initAPO() {
  // Load configuration from EEPROM/flash
  // Default: enabled, 1 hour timeout
  apoConfig = {
    .timeoutMs = APO_DEFAULT_TIMEOUT_MS,
    .enabled = true,
    .minVoltage = APO_MIN_VOLTAGE_MV,
    .wakeCurrent = APO_WAKEUP_CURRENT_MA
  };
}

void updateAPO() {
  if(!apoConfig.enabled) return;
  
  // Check if load current exceeds wake threshold
  uint16_t totalCurrent = getTotalOutputCurrent();
  
  if(totalCurrent > apoConfig.wakeCurrent) {
    lastActivityTime = millis(); // Reset timer on activity
  }
  
  // Check timeout condition
  if(millis() - lastActivityTime > apoConfig.timeoutMs) {
    initiateShutdownSequence();
  }
  
  // Emergency voltage-based cutoff (overrides timeout)
  if(batteryVoltage < apoConfig.minVoltage / 1000.0) {
    emergencyShutdown("Undervoltage protection");
  }
}

void initiateShutdownSequence() {
  // Graceful shutdown: notify user, save state, disable outputs
  displayMessage("Auto power off...");
  delay(2000);
  
  // Disable all output stages in sequence
  disableUSBOutputs();
  disableDCOutput();
  disableACOutput();
  
  // Enter deep sleep with periodic wake for button check
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_4, 0); // Wake on button press
  esp_deep_sleep_start();
}

Why this matters: The APO isn't just a timer—it's a multi-layered protection system combining timeout, current sensing, and voltage monitoring. The ESP32's deep sleep capability achieves microamp consumption while maintaining wake-on-interrupt for instant revival.

Example 2: MPPT Solar Charging Algorithm

/* Maximum Power Point Tracking for Solar Input
 * Perturb and Observe algorithm with adaptive step size
 * SC8812A in input mode with automatic current tracking
 */

#define MPPT_VOLTAGE_MIN    15000   // 15V minimum panel voltage
#define MPPT_VOLTAGE_MAX    24000   // 24V maximum panel voltage
#define MPPT_CURRENT_MAX    6000    // 6A maximum charging current

float previousPower = 0.0;
float previousVoltage = 0.0;
int perturbationDirection = 1;      // 1 = increase, -1 = decrease
float perturbationStep = 0.5;       // Volts per iteration

void updateMPPT() {
  // Read current panel voltage and charging current
  float panelVoltage = readPanelVoltage();
  float chargeCurrent = readChargeCurrent();
  float currentPower = panelVoltage * chargeCurrent;
  
  // Perturb and Observe algorithm
  if(currentPower > previousPower) {
    // Power increased: continue same direction
    perturbationDirection = perturbationDirection;
  } else {
    // Power decreased: reverse direction
    perturbationDirection *= -1;
    // Reduce step size for finer convergence
    perturbationStep *= 0.8;
    if(perturbationStep < 0.1) perturbationStep = 0.1;
  }
  
  // Apply perturbation to SC8812A voltage setpoint
  float newSetpoint = panelVoltage + (perturbationDirection * perturbationStep);
  
  // Clamp to valid operating range
  newSetpoint = constrain(newSetpoint, MPPT_VOLTAGE_MIN/1000.0, MPPT_VOLTAGE_MAX/1000.0);
  
  // Update SC8812A via I2C
  setSC8812AInputVoltage(newSetpoint);
  
  // Store for next iteration
  previousPower = currentPower;
  previousVoltage = panelVoltage;
}

void setSC8812AInputVoltage(float voltage) {
  // Convert voltage to SC8812A register value
  // Reference voltage is 1.2V with resistor divider
  // Register value = (V_target / V_ref - 1) * 1024 / divider_ratio
  uint16_t regValue = (uint16_t)((voltage / 1.2 - 1) * 1024 / 10);
  
  Wire.beginTransmission(SC8812A_ADDR);
  Wire.write(0x02); // VBUS voltage setpoint register
  Wire.write(regValue >> 8);    // High byte
  Wire.write(regValue & 0xFF);  // Low byte
  Wire.endTransmission();
}

Why this matters: This isn't naive constant-voltage charging. The adaptive perturbation step converges faster under stable conditions while remaining responsive to cloud transients. The SC8812A's programmability lets you extract 20-30% more energy from marginal solar conditions compared to simple PWM controllers.

Example 3: Display Navigation & User Interface

/* 3-Way Button Navigation with OLED Menu System
 * Intuitive control without smartphone dependency
 */

enum MenuState {
  MENU_MAIN,           // Voltage, current, power summary
  MENU_OUTPUT_CONTROL, // Enable/disable individual outputs
  MENU_APO_SETTINGS,   // Configure auto power off
  MENU_WIFI_SETTINGS,  // STA/AP mode configuration
  MENU_MPPT_STATUS,    // Solar charging telemetry
  MENU_SYSTEM_INFO     // Firmware version, temperatures
};

MenuState currentMenu = MENU_MAIN;
int menuSelection = 0;
const char* menuNames[] = {"Main", "Outputs", "APO", "WiFi", "Solar", "System"};

void handleUserInput() {
  static unsigned long lastButtonTime = 0;
  const unsigned long DEBOUNCE_MS = 200;
  
  if(millis() - lastButtonTime < DEBOUNCE_MS) return;
  
  if(digitalRead(NAV_BUTTON_UP) == LOW) {
    menuSelection--;
    if(menuSelection < 0) menuSelection = 5;
    lastButtonTime = millis();
  }
  else if(digitalRead(NAV_BUTTON_DOWN) == LOW) {
    menuSelection++;
    if(menuSelection > 5) menuSelection = 0;
    lastButtonTime = millis();
  }
  else if(digitalRead(NAV_BUTTON_SELECT) == LOW) {
    currentMenu = (MenuState)menuSelection;
    lastButtonTime = millis();
  }
}

void updateDisplay() {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  
  switch(currentMenu) {
    case MENU_MAIN:
      drawMainScreen();
      break;
    case MENU_OUTPUT_CONTROL:
      drawOutputControlScreen();
      break;
    // ... additional screens
  }
  
  display.display();
}

void drawMainScreen() {
  // Battery voltage with precision
  display.setCursor(0, 0);
  display.print("Bat: ");
  display.print(batteryVoltage, 2);
  display.print("V ");
  
  // Calculate state of charge from voltage (simplified)
  int soc = map((int)(batteryVoltage * 100), 1200, 1680, 0, 100);
  soc = constrain(soc, 0, 100);
  display.print(soc);
  display.print("%");
  
  // Power output
  display.setCursor(0, 16);
  display.print("Out: ");
  display.print(getTotalOutputPower(), 1);
  display.print("W");
  
  // Temperature with warning indicator
  display.setCursor(0, 32);
  if(temperature > 50.0) {
    display.print("TEMP HIGH! ");
  }
  display.print(temperature, 1);
  display.print("C");
  
  // WiFi status
  display.setCursor(0, 48);
  display.print(wifiAPMode ? "AP: Omnibus4X8" : WiFi.localIP().toString());
}

Why this matters: The physical button interface with instant visual feedback eliminates the "where's my phone?" frustration of app-dependent power stations. The menu structure prioritizes information density—everything critical at a glance, details one click away.

Advanced Usage & Best Practices

Cell Selection Strategy

For maximum capacity: Samsung 35E or Panasonic NCR18650GA (3500mAh). For maximum cycle life: Molicel P28A (2800mAh, 35A discharge) with reduced total capacity but 2x cycle count. Never mix cell ages or chemistries.

Thermal Optimization

Add thermal interface material between power ICs and enclosure. Consider copper heat spreaders for the SC8812A and IP2368. The stock fan profile is conservative—experienced builders can implement predictive thermal modeling based on load forecasting.

Firmware Customization

The Arduino framework enables rapid experimentation. Popular mods include:

• CAN bus integration for automotive applications
• LoRa telemetry for remote monitoring beyond WiFi range
• Scheduled charging to exploit time-of-use electricity rates
• Battery health logging with predictive replacement alerts

Safety Redundancy

The design includes redundant protection, but test your BMS independently before first power-up. Use a current-limited lab supply for initial bring-up. Verify all protection thresholds with deliberate fault injection.

Comparison with Alternatives

The verdict: Commercial units offer convenience and warranty. The Omnibus4X8 offers capability, control, and cost efficiency that no commercial product matches. For technically capable builders, it's not even close.

Frequently Asked Questions

Is the Omnibus4X8 safe for beginners to build?

Not without preparation. Lithium-ion battery assembly requires understanding of cell matching, welding techniques, and BMS configuration. The firmware side is accessible to anyone with Arduino experience. Consider building the control electronics first, then progress to battery assembly with experienced guidance.

What's the actual build cost?

$200-300 depending on cell source and component choices. Using salvaged laptop cells (tested and matched) reduces cost significantly but requires more effort. New high-quality cells add $100-150 but deliver better longevity.

Can I modify the firmware for my specific needs?

Absolutely. The ESP32-C3 with Arduino framework is one of the most documented platforms in existence. The repository includes the complete source, and the creator actively supports modifications.

How does the MPPT compare to dedicated solar charge controllers?

The SC8812A implementation achieves 95%+ efficiency with proper inductor selection. For most portable panels (50-150W), performance matches $100+ dedicated MPPT units. For large stationary arrays, dedicated controllers still win.

Is the 150W AC output pure sine wave?

Check the specific inverter module used—the repository may specify. Modified sine wave is typical at this power level. For sensitive medical equipment, verify or upgrade to pure sine.

Can I parallel multiple Omnibus4X8 units?

Not directly—the design is standalone. However, the XT60 direct access allows creative configurations with external balancing equipment. Future firmware could enable synchronized charging over WiFi.

What happens if the ESP32 crashes?

Hardware protection remains active. The BMS, overcurrent protection, and thermal management operate independently of the microcontroller. The ESP32 enhances functionality but isn't required for safe operation.

Conclusion: The Power Station You Actually Own

The Omnibus4X8 isn't just a cheaper alternative to commercial power stations. It's a fundamentally different category of device—one where you are the manufacturer, the service technician, and the product manager. When Anker discontinues your model's firmware support, your Omnibus4X8 gets a community update. When Jackery's proprietary BMS dies, you replace a standard component. When EcoFlow's app demands a subscription, you laugh and write your own interface.

At 414Wh, 2.4 kg, and under $300, the value proposition is almost embarrassing to commercial competitors. Add Arduino programmability, Wi-Fi connectivity, MPPT solar, and bidirectional programmable DC, and the comparison becomes almost unfair.

But the real value? Competence. Building the Omnibus4X8 teaches power electronics, battery management, embedded systems, and thermal design in one integrated project. That knowledge compounds across every future build.

Ready to stop renting your power and start owning it?

⭐ Star the repository • 📺 Watch the build guide • 💬 Join the Reddit community

Built one? The creator wants to feature your build—share it! Need help? Reach out regardless of support status. This is what open source hardware should be.