Ground Station Software &
Object-Oriented Programming

Watch this pre-recorded lecture for an overview of the concepts we will cover today.

As you transition into building a satellite ground station, ad hoc scripting files quickly become unmanageable. Ground station software must handle multiple concurrent tasks:

• Concurrency: Reading serial data streams from a radio transceiver while simultaneously updating real-time tracking graphs, logging entries to a local server, and waiting for user command inputs.
• Determinism & Robustness: A ground station cannot afford unexpected crashes, memory leaks, or unhandled exceptions when tracking a satellite overhead.
• State Consistency: Your software needs to track the precise status of the satellite pass, including ground track coordinates, active serial port, radio link quality, and tracking angles.

In professional aerospace and mission software engineering, individual code lines are rarely written from scratch. The true engineering innovation lies in the organization of code and the orchestration of workflows.

🛠️

The Systems Architect: As a systems engineer, you are not just writing scripts; you are building an integrated cyber-physical machine. You must understand how components connect and trace data flows through every layer of the mission.

• Component Orchestration: Linking physical sensors, ESP32 microcontrollers, XBee radio transceivers, local Flask servers, and interactive web dashboards.
• Workflow Design: Composing data telemetry (downlink) and control instructions (uplink) into a secure, predictable loop.
• Systems Level Debugging: Troubleshooting an error by tracing it through hardware buffers, radio signals, serial parses, database saves, and browser rendering.

In JavaScript, you never think about data types. A variable is just var x = 5 or let name = "ISU". In C/C++ and C#, every variable must declare its exact type and size because the compiler needs to know how many bytes to allocate in memory.

var temperature = 25.46;   // number
var sensorName = "BME280"; // string
var isActive = true;       // boolean
var count = 42;            // number

// JS doesn't care if 42 is an
// integer or float. It's all
// just "number" (64-bit float).

float    temperature = 25.46f;  // 4 bytes
char     sensorName[] = "BME280"; // 7 bytes
bool     isActive = true;       // 1 byte
int      count = 42;            // 4 bytes
uint8_t  rawByte = 0xFF;        // 1 byte
double   precise = 3.14159265;  // 8 bytes

// Every byte matters in telemetry.

A C/C++ program has a rigid structure that differs significantly from a JavaScript file. Understanding this structure is essential before reading the ESP32 satellite firmware.

// Just start writing code!
let temp = 25.46;
console.log("Temperature:", temp);

// Functions anywhere
function readSensor() {
  return Math.random() * 40;
}

// No compilation needed
// Browser runs it directly

// 1. INCLUDES (import libraries)
#include <Wire.h>
#include "sensors.h"

// 2. GLOBAL VARIABLES (typed!)
float temperature = 0.0;
int   sensorID   = 0x02;

// 3. SETUP (runs once at boot)
void setup() {
  Serial.begin(115200);
  Wire.begin(13, 15);
}

// 4. LOOP (runs forever)
void loop() {
  temperature = readBME();
  Serial.write((uint8_t*)&temperature,
    sizeof(float));
  delay(1000);
}

Because C++ is compiled and strictly typed, the syntax is highly structured. Code blocks, terminations, and comments have rigid rules that the compiler enforces strictly before any code runs.

// Function signature in sensors.h
bool readBME(float &temp, float &pres);

// Calling the function in loop()
float t, p;
bool success = readBME(t, p); 
// 't' and 'p' are updated directly in memory!

OOP organizes software around data (attributes) and behavior (methods) rather than sequential scripts. We model physical hardware as distinct, logical entities.

// Satellite attributes
string  name         = "ISU-SAT1";
float   batteryLevel = 87.3;
double  frequency    = 437.500;
int     orbitAltKm   = 550;
bool    isTransmitting = true;
uint8_t satelliteID  = 0x13;

// Satellite methods
void  transmitTelemetry();
void  takePicture();
void  setRefreshInterval(int ms);
float getBatteryLevel();
bool  executeCommand(uint8_t cmd);
void  deploySolarPanels();

The most common confusion for beginners: what is the difference between a Class and an Object? Think of it like this:

class Car {
  // Attributes (no values yet)
  string make;
  string color;
  int    horsepower;
  float  fuel_level;

  // Methods (what it can do)
  start_engine();
  accelerate(speed);
  refuel(liters);
}

// Two objects from the same class

myCar = new Car()
  myCar.make       = "Toyota"
  myCar.color      = "Red"
  myCar.horsepower = 150
  myCar.fuel_level = 45.2

yourCar = new Car()
  yourCar.make       = "BMW"
  yourCar.color      = "Black"
  yourCar.horsepower = 300
  yourCar.fuel_level = 60.0

Here is the secret: you have been using OOP the entire time in Google Earth Engine without knowing it. Every line of GEE code is built on classes and methods:

// Class: ee.ImageCollection
// Object: the Sentinel-2 collection
var collection = ee.ImageCollection(
    'COPERNICUS/S2'
)

// Methods called on the object:
  .filterDate('2024-01-01', '2024-12-31')
  .filterBounds(roi)
  .map(maskClouds)
  .median();

Inheritance allows a new class (subclass or child class) to inherit attributes and methods from an existing class (superclass or parent class), preventing redundant code.

Instead of re-writing basic telemetry, command queues, and hardware links for every satellite variation, we create a core base class and extend it.

Polymorphism (Greek for "many forms") is the ability of different classes to respond to the same method call in their own custom way.

Imagine your ground station software needs to talk to two types of transceivers: an XBee radio link (running over standard Serial UART) and a LoRa radio link (running over SPI).

• We define a standardized base interface `Transceiver` with a method signature `sendData(byte[] frame)`.
• XBeeTransceiver overrides this to output bytes using C++ `Serial.write()`.
• LoraTransceiver overrides this to write byte strings to specific SPI registers.
• The core Ground Station software simply calls `transceiver.sendData()`, without needing to know which physical hardware is attached.

A major source of confusion for junior developers is the difference between Visual Studio and Visual Studio Code. Although developed by Microsoft, these tools are built for entirely different workflows. In this course, you will use both.

In the bootcamp, your JavaScript ran directly in the browser with no extra steps. C, C++, and C# work completely differently: the source code must be compiled into machine code before it can run.

Once code is compiled into a binary (.exe), the original source code is no longer visible. This is the foundation of the open source vs closed source distinction.

When you build the ground station desktop application in Visual Studio, you are building on top of Microsoft's .NET Framework. It provides a massive library of pre-built code so you do not have to write everything from scratch.

Here is the step-by-step workflow you will follow to create your ground station desktop application in Visual Studio:

Modern software engineering in 2026 relies heavily on AI-assisted coding tools (like Gemini, GitHub Copilot, or Cursor). These tools are incredibly powerful junior coding partners, but they require a critical mental guardrail.

Setting Up AI Assistants in Your IDEs

Take a quick stretch, grab some coffee, and process the structural concepts of OOP before we deep-dive into binary telemetry frames and serialization!

In your upcoming lab, your satellite is driven by an ESP32 microcontroller. It communicates telemetry and receives commands over an XBee radio module using a Serial UART connection configured at 115200 baud.

• ESP32 Satellite Hub: Coordinates onboard systems, reads sensors (BME280 for temp/humidity, MPU6050 for acceleration/rotation), and drives an OV2640 camera payload.
• XBee Transceiver: Standardizes radio frequency (RF) packets, exposing them to the ESP32 as simple RX/TX serial pins (UART2).
• Baud Rate (115200): The clock speed of the serial interface, representing the transmission of 115,200 raw bits per second.

Let's compare transmitting a single telemetry coordinate (temperature = 25.46) over a radio link:

On the ground station server, your Python/C# backend opens a connection to the serial port. It continuously reads bytes, looking for the header. Here is a simplified visual representation of the byte-unpacking pipeline:

In Python, we unpack raw binary lists into standard variables using the struct library:

import struct
# Unpack 4-byte header, 1-byte sensor ID, and three 4-byte floats
header, sensor_id, val1, val2, val3 = struct.unpack('<I B f f f', raw_bytes[0:17])

In your satellite firmware lab, you will see code split into .h (headers) and .cpp (sources). This separation of concerns represents the physical boundaries of your software components.

// Header guards prevent multiple inclusions
#ifndef SENSORS_H
#define SENSORS_H

#include <Arduino.h>

// Declare public functions (The Interface Contract)
bool init_sensors();
void transmit_data(float &temperature, float &pressure,
                   float &humidity, float &gx,
                   float &gy, float &gz,
                   float &ax, float &ay,
                   float &az);

#endif

#include "sensors.h"
#include <Adafruit_BME280.h>

Adafruit_BME280 bme; // Private hardware object

bool init_sensors() {
  // Configure pins SDA=13, SCL=15 and start I2C sensor
  Wire.begin(13, 15);
  return bme.begin(0x76, &Wire);
}

Let's review the critical code that packages sensor data into a raw binary frame and streams it over the XBee radio interface.

// 1. Pack telemetry into an aligned memory structure
struct TelemetryFrame {
  uint32_t header = 0xA1B2C3D4; // 4 bytes
  uint32_t sensor_id;           // 4 bytes
  float    data[3];             // 12 bytes
  uint32_t footer = 0x1E2D3C4B; // 4 bytes
};

void transmit_data(float &temperature, ...) {
  TelemetryFrame frame;
  frame.sensor_id = 0x00000002; // BME280 ID
  frame.data[0]   = temperature;
  frame.data[1]   = pressure;
  frame.data[2]   = humidity;

  // 2. Cast struct to a byte array and stream it over Serial2
  Serial2.write((uint8_t *)&frame, sizeof(frame));
}

Communication with satellites is bidirectional. While the satellite downlinks telemetry frames, the ground station must uplink commands. In your lab, you will construct and transmit strict 4-byte command packets.

// Reading the serial link in loop()
if (Serial2.available() >= 4) {
  uint8_t packet[4];
  Serial2.readBytes(packet, 4);

  // Verify headers
  if (packet[0] == 0x13 && packet[1] == 0xAA) {
    uint8_t cmd = packet[2];
    if (cmd == 0xB0) capture_jpeg();
    else if (cmd == 0x15) set_rate(15);
  }
}

Fixed-size telemetry frames (like our 56-byte sensor struct) are predictable because variable positions in memory never change. However, when the satellite transmits an **image capture**, the payload size changes with every picture. We must use a variable-length framing protocol.

// Read image size from stream (4 bytes)
byte[] sizeBuffer = readBytes(4);
int imgSize = convertToInt(sizeBuffer);

// Read the exact JPEG data
byte[] jpegData = readBytes(imgSize);

How does a physical physical phenomenon (like temperature) on a satellite in space travel all the way to a text character on your ground station browser dashboard? Let's trace the physical and logical lifecycle:

A comprehensive ground station architecture is a multi-layered system, bridging raw hardware streams up to web-based dashboards.

• Physical/Hardware Layer: The satellite orbital transceivers and antennas communicating RF signals.
• Middleware/TNC Layer: A Terminal Node Controller (TNC) like the Kantronics 9612XE, running in KISS mode to package raw radio packets into clean serial structures.
• Backend/Server Layer: Opens the serial ports, validates frames, archives telemetry to database, and schedules commands.
• Frontend Dashboard Layer: Updates real-time dials, track map, and visualizes status changes.

Hardware You Will Work With

ESP32 Microcontroller
Runs the satellite firmware (C++). Reads sensors, captures images, transmits binary telemetry via UART.

XBee S2C Transceiver
Radio link between satellite and ground station. Communicates via serial UART at 115200 baud.

This is what your ground station software does every second. Click Parse Next Field to step through a real telemetry frame byte by byte.

To construct, test, and debug this full stack ground system, you will use several key utility tools throughout your laboratory weeks:

Here are the core concepts and vocabulary from today's lecture. Review these as you launch into your laboratory experiments:

Congratulations! You have completed the foundational lecture on Object-Oriented Programming and Space Full-Stack middleware. You are ready to start building!