GomX-1 Specifications:

GomSpace GOMX-1

GOMX-1 was launched 21/11-2013 at 07:10 UTC

GOMX-1 is a 2U cubesat mission developed in collaboration between GomSpace, DSE Airport Solutions and Aalborg University to perform research and experimentation in space related to Software Defined Radio (SDR) with emphasis on receiving ADS-B signal from commercial aircraft over oceanic areas. As a secondary payload the satellite flies a NanoCam C1U colour camera for Earth observation experimentation. The projected is financially supported by the Danish National Advanced Technology Foundation.


GOMX-1 is now fully commissioned. The attitude control system has detumbled the spacraft from rather high tip-off rates, and all deployables including the helical antenna are deployed. Both payloads are in full operational state. The primary payload - a software defined ADS-B receiver - has received a large amount of aircraft signals indicating a better than expected link-budget on the helical antenna. The image below shows a preliminary plot of a few of the received aircraft positions.

Radio Amateur Information:

GomX-1 is using a radio amateur frequency, which makes it possible for any radio amateur to receive the satellite telemetry. GomSpace does not use the standard AX.25 or AFSK format used for packet communication. This page will however explain the differences and how to receive the telemetry. The info box to the left contains a summary of the specifications of the transmitted data beacon.


In order to receive the signal you need an antenna gain of around 10 dB. A crossed yagi with options for both left and right hand circular polarisation is good. Otherwise a linear antenna can also be used at the sacrifice of some dB signal.


The radio must be capable of receiving a UHF signal on 437.250 MHz +- 10KHz doppler shift. The NanoCom uses analog FM modulation with a frequency deviation of 2.5 kHz. The 98% power bandwidth of the received signal is within 15 kHz. Receiving the signal require a doppler shift tracing application.


GomX-1 uses 4800 baud MSK modulation at the two tones 2400 and 4800. This mode is not supported by most major TNC providers. So the recommended receiving option is to record the audio from the entire pass, using the line-in port on a PC with correctly adjusted amplitude. These recordings can then be software demodulated by gomspace.

Frame Format

The packet consists of:
    Preamble: 50 ms of 0x55 transmitted only when the radio keys up. There is no gap between packets.
  • Sync word: 4 bytes: 0xC3AA6655 - Unencoded and unscambled
  • Length field: 3 bytes: The first 12 bits are golay encoded parity, and the final 12 bits contain 8 bits length field and a 4 bit optional FEC field
  • Data field: CCSDS scrambled, Viterbi encoded and/or Reed-solomon checksum added - For more information on decoding the FEC format please contact gomspace for source code

Two-line element:

GOMX-1 (2013-066Q)       
1 39430U 13066Q   13328.43735869  .00002588  00000-0  50454-3 0    37
2 39430  97.7845  40.8824 0159058 179.6184 180.5205 14.56012593   413

Last updated: dd-mm-yyyy hh:mm

Transmitted data:

Here is the raw data-format of the data beacon. There are two beacons, a type A and a type B. The type B is only transmitted in certain situations and contains only detailed ADCS information. In order to see that a beacon is type A.

/* BEACON A */
struct __attribute__((__packed__)) cdh_beacon_a {
    struct __attribute__((packed)) {
        uint16_t bootcount;                // Total boot count
        int16_t temp1;                     // Board temp1 * 4 in [C]
        int16_t temp2;                     // Board temp2 * 4 in [C]
        int16_t  panel_temp[6];            // Panel temperatures * 4 in [C]
    } obc;
    struct __attribute__((packed)) {
        uint16_t byte_corr_tot;            // Total bytes corrected by reed-solomon
        uint16_t rx;                       // Total packets detected
        uint16_t rx_err;                   // Total packets with error
        uint16_t tx;                       // Total packets transmitted
        int16_t  last_temp_a;              // Last temperature A in [C]
        int16_t  last_temp_b;              // Last temperature B in [C]
        int16_t  last_rssi;                // Last detected RSSI [dBm]
        int16_t  last_rferr;               // Last detected RF-error [Hz]
        uint16_t last_batt_volt;           // Last sampled battery voltage [mV/10]
        uint16_t last_txcurrent;           // Last TX current [mA]
        uint16_t bootcount;                // Total bootcount
    } com;
    struct __attribute__ ((__packed__)) {
        uint16_t vboost[3];                // Voltage of boost converters [mV] [PV1, PV2, PV3]
        uint16_t vbatt;                    // Voltage of battery [mV]
        uint16_t curout[6];                // Current out [mA]
        uint16_t curin[3];                 // Current in [mA]
        uint16_t cursun;                   // Current from boost converters
        uint16_t cursys;                   // Current out of battery
        int16_t temp[6];                   // Temperature sensors [0 = TEMP1, TEMP2, TEMP3, TEMP4, BATT0, BATT1]
        uint8_t output;                    // Status of outputs
        uint16_t counter_boot;             // Number of EPS reboots
        uint16_t counter_wdt_i2c;          // Number of WDT I2C reboots
        uint16_t counter_wdt_gnd;          // Number of WDT GND reboots
        uint8_t    bootcause;              // Cause of last EPS reset
        uint16_t latchup[6];               // Number of latch-ups
        uint8_t battmode;                  // Mode for battery [0 = normal, 1 = undervoltage, 2 = overvoltage]
    } eps;
    struct __attribute__((__packed__)) {
        uint16_t average_fps_5min;
        uint16_t average_fps_1min;
        uint16_t average_fps_10sec;
        uint16_t plane_count;
        uint32_t frame_count;
        uint32_t last_icao;
        uint32_t last_timestamp;
        float last_lat;
        float last_lon;
        uint32_t last_altitude;
        uint32_t crc_corrected;
        uint16_t bootcount;
        uint16_t bootcause;
    } gatoss;
    struct __attribute__((packed)) {
        int8_t  temp;                      // Temperature of nanohub in [C]
        uint16_t bootcount;                // Total bootcount
        uint8_t  reset;                    // Reset cause:
        uint8_t  sense_status;             // Status on feedback switches and arm switch [ARM1 ARM0 K1S3 K1S2 K1S1 K1S0 K0S1 K0S0]
        uint16_t burns[2];                 // Number of burn tries [K1B1 K1B0]
    } hub;
    struct __attribute__((packed)) {
        float tumblerate[3];
        float tumblenorm[2];
        float mag[3];
        uint8_t status;                    // [xxxxxxab] a = magvalid, b = detumbled
        float torquerduty[3];
        uint8_t ads;                       // State [xxxxyyyy] x = state, y = dstate
        uint8_t acs;                       // State [xxxxyyyy] x = state, y = dstate
        uint8_t sunsensor_packed[8];
    } adcs;

struct __attribute__((__packed__)) cdh_beacon_b {
        uint16_t sun[5];                   // sun sensor +x +y -x -y -z
        uint8_t ineclipse;                 // 0=in sun, 1=ineclipse
        float xest[16];                    // State vector [_i^cq ^c\omega b_mag b_gyro \tau] in total 16 states
        float zfilt[9];                    // Filt meas vector [v_sun v_mag omega_gyro]
        uint16_t enable;                   // Enable vector (bit mask) for meas vector [xsunsensor,3xmag,3xgyro]
        float ref_q[4];                    // Control ref
        float err_q[4];                    // control err
        float ierr_q[3];                   // Control ierr
        float err_rate[3];                 // Control err rate
        float  sc_reci[3];                 // Ephem satellite pos
        float  sun_eci[3];                 // Ephem sun pos
        float  mag_eci[3];                 // Ephem mag

/* BEACON */
typedef struct __attribute__((packed)) {
    uint32_t     beacon_time;              // Time the beacon was formed
    uint8_t     beacon_flags;              // Which type of beacon is this
    union {
        struct cdh_beacon_a a;             // A is common housekeeping
        struct cdh_beacon_b b;             // B is extended ADCS
} cdh_beacon;