The Missionary Satellite Project.

This project has been designed to enable friends of all religions to spread their beliefs beyond our planet. The target audience is the intelligent life on planets in other solar systems in our galaxy and beyond. This article describes a small autonomous and self-powered satellite (53 x 30 x 30mm) which is capable of continuously transmitting the content of the bible (or any other religious text) in morse code using a light emitting diode (LED) and an optional 433MHz radio transmitter. To be successful several assumptions must be made. The area of space in which the device is intercepted must have enough light to power the photocell and charge the battery. Also, the aliens will require some kind of photo receptors to sense visible light and have enough wit to understand that the flashes represent a coded message. Given all that they should have no more difficulty in decoding the text than scientists here had in deciphering the Rosetta Stone. If we are to believe in the omnipotence of God then the text once decoded should be very familiar to the recipients.

The missionary satellite breaks with traditional missionary practice in one important way – it not only preaches, but it also listens. After every fourth line of transmission the satellite sends out a call sign and invites listeners to reply. The system then enters a listening phase for 30 seconds during which its radio receiver can pick up transmissions and record them. Obviously the on board computing facilities are not powerful enough to decode any alien transmissions received, instead it waits until the end of the listening period before replaying them to the sender. This is designed to indicate to any alien life that the probe is more than the equivalent of an interplanetary junk email.

Although intended to be easily attached to any future deep space probe, its light weight make it an ideal addition to a high altitude balloon (HAB) project. It could be used in this type of mission by people whose faith lets them believe in the presence of a deity closer to earth but above the clouds. The objective in this case would be to encourage God to recognise the purpose of the device and to intercept it and make corrections to the text (if required) before it returned to earth. Returned devices with no changes can be taken as an affirmation that every word is true.

Sadly it should be noted that the device is not designed to withstand the high temperatures that would be involved in a mission to seek a balanced view of religion

For people who lack the imagination required to have any faith at all, the device can still be built and deployed with the text of a favourite book instead of a religious tract. This will obviously not spread the word of god, but may introduce a whole new civilisation to the world of Harry Potter and copyright litigation. Initially three probes will be built, each containing either the Bible, the Koran or The Philosopher’s Stone.

It will be interesting to be able to travel through the universe in 2000 years following the path of these probes and to visit the planets affected by their messages. On how many will we find mosques and sharia law, or cathedrals and a Vatican City? My guess is that worship on these planets will be held in replicas of Hogwarts and involve wand waving and the wearing of blazers.

The Hardware

You will need:

The software

#  The Missionary Satellite Project
#  New testament version
#  Public domain software 2020

import board
import digitalio
import busio
import time

satellite_name = "MISHSAT-1"
WordOfGod = "./NewTestament.txt"
words_per_minute = 18
dot_length = (1200 / words_per_minute)/1000
interoperational_gap = 2
on = True
off = False
TX_on = on
RX_on = off

# Transmitter io
tx_positive = digitalio.DigitalInOut(board.D0)
tx_positive.direction = digitalio.Direction.OUTPUT
tx_ground = digitalio.DigitalInOut(board.D1)
tx_ground.direction = digitalio.Direction.OUTPUT
tx_ground.value = False
tx_positive.value = TX_on

# Receiver io
rx_positive = digitalio.DigitalInOut(board.D3)
rx_positive.direction = digitalio.Direction.OUTPUT
rx_ground = digitalio.DigitalInOut(board.D2)
rx_ground.direction = digitalio.Direction.OUTPUT
rx_ground.value = False
rx_positive.value = RX_on

listen_period = 20

uart = busio.UART(board.TX, board.RX,baudrate = 100, bits = 8, parity=None, stop=1, timeout=20, receiver_buffer_size=64)

led_r = digitalio.DigitalInOut(board.LED_R)
led_r.direction = digitalio.Direction.OUTPUT
led_g = digitalio.DigitalInOut(board.LED_G)
led_g.direction = digitalio.Direction.OUTPUT
led_b = digitalio.DigitalInOut(board.LED_B)
led_b.direction = digitalio.Direction.OUTPUT

red = [False, True, True]
green = [True, False, True]
blue = [True, True, False]
yellow = [False, False, True]

morse = ["-.-.--", ".-..-.", "", "", "", ".-...", ".----.",
         "-.--.", "-.--.-", "", ".-.-.", "--..--", ".-.-.-",
         "-..-.", "-----", ".----", "..---", "...--", "....-",
         ".....", "-....", "--...", "---..", "----.",
         "---...", "", "", "-...-", "", "..--..", ".--.-.",
         ".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
         "....", "..", ".---", "-.-", ".-..", "--",
         "-.", "---", ".--.", "--.-", ".-.", "...", "-",
         "..-", "...-", ".--", "-..-", "-.--", "--..",
         "", "", "", ""]

def listen(wait_response):
    rx_positive.value = on
    tx_positive.value = off
    print("Listening " + str(wait_response) + " secs ...")
    rx_positive.value = off
    tx_positive.value = on

def prepare_code(line, colour):
    count = 0
    tx_positive.value = on
    for letter in line.upper():
        count = count + 1
        if letter == " ":
            character = ord(letter)-34
            if character in range(1, 54):
                send_morse(character, colour)
    tx_positive.value = off

def send_verse(line):
    data = bytearray(line)
    tx_positive.value = on
    tx_positive.value = off

def led_on(colour):
    led_r.value = colour[0]
    led_g.value = colour[1]
    led_b.value = colour[2]

def led_off():
    led_r.value = True
    led_g.value = True
    led_b.value = True

def send_morse(character, colour):
    for keypress in morse[character]:
        tx_positive.value = on
        if keypress == ".":
        tx_positive.value = off

while True:
    fp = open(WordOfGod, 'r')
    line = satellite_name
    line_count = 0

    while line:
        if line_count % 4 == 0:
            line = "CQ CQ CQ de " + satellite_name + " K K K"
            colour = blue
            wait_response = listen_period
            line = fp.readline()
            colour = red
            wait_response = 0

        prepare_code(line, colour)

        line_count = line_count + 1



Putting the satellite together requires some soldering skills (see my friend Finn’s website for an excellent primer on the subject). The illustration below gives you a clue to how to do it. Note that the optional transmitter has been soldered directly to the main controller board.

Satellite wiring layout – note: in the flight version connecting wires will be much shorter and all the components will be contained within a box formed by the four solar cells.

The radio transmitter can be enabled or disabled in the control software. Continuous transmission in land based trials is not encouraged as it will attract the attentions of the regulatory authorities in your area. There is also a risk that car alarms, garage doors and vital medical equipment may be impacted. Wait until just before launch before setting ‘TX = True’ in the main code file. Three digital output pins on the controller board are used to power the transmitter and provide the morse keying. This allows the transmitter to be completely powered down when not required.

Spectral analysis of a test transmission on 433.84 MHz of an extract from Matthew Chapter 1.

Stabilisation system

To ensure that the satellite aligns with the magnetic field of any planet that it encounters, a small bar magnet is glued to the chassis. This will eventually suppress any spinning effect caused when it is released from the parent space craft.

Final Construction

The chassis for the satellite was designed and 3D printed using TinkerCAD and a Fashforge Finder printer. The outer shell supports the solar cells this fits over an inner chassis into which the component boards and battery are fitted. The two parts are held together by strong magnets which also form part of the stabilisation system.

The lithium ion battery is contained in the central gap between the circuit boards and held in place using super glue.

Final wiring, showing the controller board and the solar charger.