A Morse Code Application for MQTT

1878 Bunnell Telegraph Set

[Github Repo of the Code – see makermorse.py for this script.]

Telegraphy and Morse Code were the first instantaneous long distance form of communication.  Invented in 1844, for the first time, you could communicate in real time with someone you could neither see nor hear.

Telegraphy was huge.  It was the Internet of its day.  But the truth is, it was actually pretty simple:

A telegraph is something you can build in an afternoon.  The basic principle is electro-magnetism.  If you wrap wire around an iron nail, it becomes a magnet when you run electricity through it.

A telegraph sounder like the one below works by becoming magnetic electrically, which causes a spring-loaded tapper to click against it audibly.

1878 Bunnell Telegraph Set
1878 Bunnell Telegraph Set

In the age of Internet communications, this may all seem obsolete, but there are thousands of people around the world who still communicate via Morse code, primarily over radio.  These amateur radio operators, or HAMs, as they are called, don’t need Internet to communicate around the world, so they become of vital importance in times of natural disaster, or any time other forms of communication don’t work, both with voice radio and Morse Code.

In the photo is a pair of telegraph stations manufactured by J. H. Bunnell & Co., in 1878.

Now, many people would put something like that in a nice display case and never play with it, but where’s the fun in that?

Raspberry Pi to the rescue!

The Raspberry Pi has a bank of pins known as General Purpose Input/Output (GPIO) pins that we can use to send a bit of electricity to light up an LED.  It’s not much, only around 3 volts, but we thought it might be just enough to make the sounder click.  With careful adjustment of the sounder’s springs and set screws, we were able to get a good click.

With that first test out of the way, it’s time to write some code!

I started, as all good programmers do, by Googling for some code to steal borrow to save me some of the heavy lifting.  I came across a tutorial from Cambridge University in England.  Linked from that was a Python script that would get us started.

What this script does is ask you to type something and hit enter, then it blinks it out as code on an LED.  That’s close, but to make this interesting, let’s get it hooked up to the Internet, so we can receive Morse messages from anywhere in the world!

MQTT is a server protocol that’s a lot of fun to play with.  It’s a simple way to send messages from one device to any number of other devices.  You can also do a kind of chat with it, since it’s so fast and simple.

Let’s go get the code!  On your Pi, open the terminal.

Pi Terminal
Type the following commands:


cd

This command takes you to your home directory. It’s a good place to work. Next, we’re going to go grab the code from Github:


git clone https://github.com/jimoconnell/electrobrain.git

You should see output that looks like this:

pi_s_X_desktop__jims3_1_
 Type
cd electrobrain

to change to the project’s directory. Next, type

idle ~/electrobrain/makermorse.py

to open the program in the Idle Python Editor:

Idle

Once you have the project open in Idle, try running it by hitting the F5 key on your keyboard, or by clicking “Run > Run Module” with your mouse.

You may get an error.  That’s OK, it’s probably just a missing library.  Probably the MQTT library we use.  To install Python libraries, we use a program called “pip”.  First, let’s make sure we have pip.  We ask Linux if it knows pip:

which pip

It should come back with:

/usr/bin/pip

If you just get a blank line when you hit enter, it means it isn’t installed.  Let’s install it!

sudo apt-get update
sudo apt-get install -y python-pip

OK, pip should be installed now.  We should only need to do that once.

OK, now type:

sudo pip install paho-mqtt

Now try running the script again from Idle. If everything is working, it will say:

Connected to:
     iot.eclipse.org:/test/abcd
with result code: 0

If you get that, pat yourself on the back.  (Seriously.  You’ve actually accomplished quite a bit.)

 

Now it’s time to hook something up to the Pi’s GPIO.  In the program, I’ve specified pin 25 as the one that will turn on.  Below is a diagram of the pins on a Raspberry Pi 3.  The ones on the right are on the outside edge of the board.

pi3_gpio

Get yourself your little breadboard, a resistor (220 Ohm) and an LED.  Hook it up like this diagram:

Pin25LED

Now go back to Idle and run the program again.  It should be listening, ready to blink out your code, but it’s not likely that anyone is sending a message to that channel.  Let’s go send some data!

Open a new terminal and type:

sudo apt-get update
sudo apt-get install -y mosquitto-clients

When that’s finished, we’re ready to send!

mosquitto_pub -h "iot.eclipse.org" -t "test/abcd" -m "What Hath God Wrought!"

Why “What Hath God Wrought!”?  Well, as it turns out, that was the first message sent by inventor Samuel F.B. Morse on May 24, 1844.

Did it work? (If it didn’t, feel free to leave a comment below.)

If so, try this:

mosquitto_pub -h "iot.eclipse.org" -t "test/abcd" -l

Then type one message per line and hit enter.  Each line should be sent to your LED as Morse Code!

Electrobrain

Get the Code on Github

Electrobrain

Introduction

I’ve been leading a workshop on beginning programming, Rasperry Pi using Python, and Arduino. The ages of the participants has ranged from 8 years old, (he’s 9 now,) to adult. This project aims to be a set of programs that are simple, but not simplistic, that do interesting things with the Pi and especially its GPIO pins.

The original program in this group is a status indicator that I made for my RPi3, which lives under a glass dome,http://imgur.com/3HmyNV5 as well as for the web server of waycoolbeans.com, which lives in a glass head.

I’ve also added a few other python scripts that explore the GPIO output pins. Throughout, I use Broadcom numbering in my code. You’ll see it declared as: GPIO.setmode(GPIO.BCM)

led.py

Usage:

From a command line, run the following command:

python led.py

(May be called “_led.py” in the repository. It can be safely renamed or run as is.)

Script details

A python script to creatively illuminate “LED copper wire” lights using the Raspberry Pi’s PWM GPIO pins. (As the Pi will live inside a head-shaped glass jar, it got the name “electrobrain”) Quick and crappy video may be available herebut I’m not sure if my Facebook settings will allow you to see it. image I’m starting out with a script by Alex Eames (http://RasPi.tv) that I found for working with PWM on the Raspberry Pi see: http://RasPi.tv/2013/how-to-use-soft-pwm-in-rpi-gpio-pt-2-led-dimming-and-motor-speed-control The script is a simple way to incrementally dim and brighten an LED that’s attached to (and powered by)the Pi’s PWM-capable GPIO pins.

The original demo I saw used a simple LED, but I recently happened upon some “LED Copper Wire” strings in a shop and bought them on impulse, knowing I might do something cool with them. They’re made from a pair of very thin strands of varnished wire with tiny surface-mount LEDs attached every few inches, with a blob of some sort of resin covering each LED, which both protects the LED and acts like a diffuser. The strings can be cut to desired lengths.

Strobing the LED strands has a very pleasing effect. The wires have just a bit of stiffness, so they are easy to form and keep their shape a bit.

The glass head we are using is the kind commonly used as a hat stand or for sunglasses. A quick eBay search is here.

The goal of this project is to combine several strands of lights to make a passive informational display. So far, I’ve gotten it to watch system load and have the lights go nuts when the load gets high.

morse_code.py

Usage:

From a command line, run the following command:

python morse_code.py

Script details

DJ, our 9 year old inventor and I both have a certain fascination with telegraphy and morse code, so I found a script from Cambridge University that converts text to code, then blinks out the message in Morse.

The original is here And is licensed under a Creative Commons 3 Share Alike license.

This script, when run, simply prompts the user for a string of text, thich it then flashes out on a GPIO pin.

MessageBlinker.py

Usage:

From a command line, run the following command:

python MessageBlinker.py

Script details

This script is a bit different—it listens to an MQTT server for an incoming message on the topic you specify at runtime. When it receives a message, it does a triple-blink on two GPIO pins (BCM 24 & 25) and prints out the message to the terminal:

(The first time you run it, you'll first want to install the MQTT python library with:

`sudo pip install paho-mqtt`

That's a one-time operation.)

python MessageBlinker.py

Connected with result code 0

Type a topic/channel:

test/abcd (<– Your input)

At this point, you can open another terminal, even on a different machine and install some MQTT tools:

sudo apt-get install -y mosquitto-clients

Then try:

mosquitto_pub -h iot.eclipse.org -t "test/abcd" -m "Hello World"

(This uses a public MQTT server located at iot.eclipse.org.)