Carrying on the Practical Way by Tony Jones G7ETW

• E-mail: Charles.jones125@yahoo.co.uk

W An Arduino
elcome to my second
Arduino project,
a Morse reader I
call ARD071, Fig. 1.

Morse Reader
Writing this, I’m glad
I developed my Morse sender (ARD070,
PW November) first because this is much
more complicated. A Morse reader has to
process an audio stream first into dots and
dashes, then group them into single Morse
characters, then translate those into text
and display the output − all in real time! Tony Jones G7ETW follows up his Morse Tutor project
To understand this, take a look at Fig.
2. Morse is binary; a low-to-high change (November 2017) with an Arduino-based Morse reader.
means a character element (a dot or a
dash) has just started, and the converse
signifies one has finished. By timing the
states, character elements can be identi-
fied. An Arduino read takes about 1ms,
and at 20 Words per Minute (WPM) a dot
lasts 60ms, so this is all very doable. The
detailed logic is explained in the Decoding
sidebar.
I got ARD071 working using a digital
data stream first. I connected ARD070’s
pin 13 − the LED flasher output − to
ARD071’s digital pin 3. This worked per-
fectly and allowed me to refine the detec-
tion, decoding and display logic with solid
binary input. To see one Arduino sending
random text and another one displaying it
a second later (look for the ‘HHQ’ series in
Fig. 1) was quite spooky, actually. Why the
delay? ARD070 displays text in five-char-
acter groups before it sends it whereas
ARD071 has to wait until each character is
finished before decoding can begin.
A digital-feed only Morse reader was
not the objective, so I reconfigured for an Fig. 1: The completed project in breadboard form.
analogue waveform.
To test, I used ARD070 again, taking
the pulse-width modulated (PWM) audio Dash Dot Dot Dot
output (pin 11) to ARD071’s pin A0 and
found that incoming Morse, regardless of
Dot gap

speed, was displaying as endless letter Es

arriving at 1200 WPM! The reason is sim-
ple − with symmetrical PWM like this, half
of each pulse-cycle is zero. An Arduino
analogue Read consequently stands a
50% chance of returning zero and mis-
detecting the end of a dash or dot.
Some audio processing was required
and, for simplicity, I used a Lowpass RC
filter − see Sidebar 2. Figs. 3a and 3b
show how the filter allows the envelope of
the signal to be passed. The overall level
is reduced (5V to 2V), but we still get a
definite difference between highs and lows
so all is well. ARD071 worked perfectly
with this in place.
I tried a Datong D70 next. As anyone
A B C D E F
3-dot
gap
Fig. 2: Processing the Morse code for ‘DE’ in the input stream. See Decoding sidebar for detailed
explanation.
who has ever repaired one knows, the
D70 has an odd design in that the ‘ring’
connection on the speaker jack socket
is at 5V and the ‘tip’ output is a series of
negative pulses, Fig. 3c. Arduinos read
only positive voltages, so to get audio in
from a D70, the ground and signal must be
G H I J K
reversed!
But does ARD071 work with real
Morse, on air? In all honesty, I don’t know.
I have tried it but I live in a flat and I don’t
have external antennas, so the signals I re-
ceived were too noisy. I am confident it will
work, though, with a louder, cleaner signal.

40 Practical Wireless March 2018

COTPW 4-5 pages.indd 40 18/01/2018 10:38

 Fig. 3a: The raw PWM output from the Ard70 on
a 5V scale.
I look forward to doing more testing.
The Hardware
I used an Arduino Mega2560 board this
time, again a genuine one. This board has
four times as much memory as an Uno
and over twice as many pins, but my main
reason for using it was simply to show
another Arduino variant. An Uno should be
fine for this project.
A sixteen (char) by two (row) display
was adequate for ARD070, which only had
to display five characters at a time. For
ARD071 this would have been very limit-
ing, so I used a Sainsmart 20 character by
four row display I bought on Amazon for
£11.98. This is an I2C type display - see
Sidebar 3.
See Fig. 4 for a schematic. The build is
very easy. There are three sync-indication
LEDs. LED1 shows the dots and dashes
coming in and LED3 echoes them when
the code has ‘locked on’. If LED2 is used,
it will be much fainter.
The Code
ARD071 V1.4 uses more advanced C syn-
tax than ARD070 v3.5 (the version printed
in PW) did, and features character pointers
and arrays. Pointers in C are generally
used to pass values to and from functions
and while this may seem more complex, it
actually simplifies the code. See Sidebar 4
for a brief explanation.
Improvements
The following are possible areas for im-
provement.
Ambient Sound Input
ARD071 does not take a microphone in-
put. I did try to get this working, using Ar-
duino electret microphone boards and my
own LM358 microphone preamplifiers. But
electret microphones are just too sensitive
and even in a quiet room the background
noise pickup is too much for the beeps to
stand out enough.
I think the answer is to make an exter-
nal CW digitiser, which would allow me to
March 2018 Practical Wireless
COTPW 4-5 pages.indd 41
3b: Signal from 3a after the RC filter - the level
is not dropping to zero in the envelope.
go back to using a digital input. But that is
another project.
Isolation
ARD071 has to be connected to the audio-
out socket of what’s driving it. It would be
better, for both pieces of kit, if they were
isolated. Opto-isolators using infra-red
LEDs and phototransistors are available
and would provide valuable protection.
Slave Audio Out
If ARD071 is plugged into a headphone
socket, there is no sound to hear. It would
be easy to put a sounder in, driven off a
PWM output pin. There are even speech
boards for Arduino, so ARD071 could
speak the message out loud, albeit as a
string of letters and numbers. To break it
into words − now that is a challenge!
Better Character Decoding
Decoding at the moment is done by a
sequential array search. There is a ‘binary
tree’ method that decodes characters in
flight, for example, if two dots have al-
ready been detected and the next element
is another dot, then the only possibilities
are S, H, V, 4 and 5. This should be faster
but would be quite complex to code.
ARD071 can only handle A-Z and 0-9.
Adding punctuation and other procedural
characters would also be useful.
Combined Single-Arduino Sender and
Reader
The idea of a combined sender and reader
was suggested by a PW reader who
e-mailed me. My thanks to all those who
did contact me after that earlier article; it
is always nice to get reader feedback and
that particular idea is an excellent one. The
data structures and variables are compat-
ible and some of the code such as the
display logic could be common.
A rotary encoder would be needed for
controls (to free up analogue pins A4 and
A5 - see Sidebar 3 again) and that would
make the final product smaller and more
modern.
A custom board would be nice too.
Sometimes I feel I‘ve unleashed a
monster...
3c: The raw (negative-going) output from the
Datong D70 on a 5V scale.
Conclusion
That’s it for ARD071. It works really well
for such simple code and is a joy to watch
running. Since starting in Arduino develop-
ment, I have learned a lot and I have other
projects in mind, for example, a laser-op-
erated remote antenna switcher. It is great
fun combining IT and amateur radio in this
way and I urge you to have a go.
Decoding
Look at point A on Fig. 2. We are at
the end of a character-to-character
three dot gap. The input has gone
high, so a new character has begun.
The gone-high time is stored and a
series of reads return high. No action
is necessary for this character yet but
the last character read is stored as
dots and dashes and still needs to be
decoded. For this explanation, let’s
ignore that.
At point D the input has flipped
and the gone-low time is stored.
The time the waveform was high is
calculated and by comparing this with
a dot’s length we know we just had a
dash. This becomes the first stored
element for this character.
Reads continue, returning lows.
We’re in a gap, either between char-
acter elements or between charac-
ters.
At point E the waveform goes
high again. The low gap’s duration is
calculated and the code finds it was
a dot. We’re still in this character and
another element is starting.
The cycle repeats and as we go
through F, G and H we piece together
dash dot dot.
We’re at point K now. This time the
low gap was three dots long so K is
the start of a new character. The dash
dot dot we have stored is decoded
into N and displayed.
41
18/01/2018 10:39
 Carrying on the Practical Way
RC Lowpass Filter
This is a ‘first order’ filter because it
has one stage.
As the incoming frequency rises,
the reactance of the capacitor drops
and the signal is increasingly ground-
ed. At low frequencies the reactance
is very high so the voltage at the out-
put is much nearer to that at the input.
The formula to determine the cut-
off frequency is:
f = 1 / (2 ×π × R × C)
R is 2.2kΩ and C is 1µF, giving a
cut-off frequency of about 70Hz. This
was a pretty arbitrary decision − it just
needed to be low compared to the
PWM frequency (around 700Hz).
See Useful Links for an online RC
filter calculator.
I2C LCD Displays
I2C, short for ‘Inter-Integrated Circuit’
was developed by Philips in the 1970s
as a way to network boards under
central control, each of them able to
send and receive data via a ‘bus’.
An I2C display connects to Arduino
using four standard connections: 5V,
ground, SDA (data) and SCL (clock).
On an Arduino Uno, SDA and SCL
also connect to analogue pins A4 and
A5, as a PW reader painfully dis-
covered when using one to build his
ARD070.
Boards connected to an I2C bus
system have unique addresses. My
LCD display’s address is hex 27 − it
was documented in the Amazon list-
ing! This seems to be standard but it’s
wise find this out when purchasing a
display.
Please note the inclusion of the
Wire.h and LiquidCrystal_I2c.h librar-
ies, which provide support for the
display.
Wire.h is a standard Arduino
library but LiquidCrystal_I2C.h is not.
I learned of this by reading the Ama-
zon reviews of the display I bought.
Previous purchasers recommended a
library made available by F Malpar-
tida and that’s what I used.
Please look in Useful Links for
more information on I2C and Liquid-
Crystal_I2C.h (where to get it and how
to install it).
42
COTPW 4-5 pages.indd 42
5V
Arduino
Mega2560
Low-pass filter
R1
2k2
A0
C1
0V
1µ
LED1 LED2
Fig. 4: Overall schematic, with Arduino and display.
Useful Links:
Lowpass Filter calculator:
https://tinyurl.com/ya2t7auf
I2C: https://tinyurl.com/y8j6uwv9
LiquidCrystal_I2C.h library:
https://tinyurl.com/p2uzjw8
C Pointers
Explaining pointers is not easy. I shall do
my best.
Every variable has its own memory
location.
Say there are three integer variables
x, y and z at locations 100, 200 and 300.
Say there are two integer pointer
variables p1 and p2. (Tutorials often
call these px and py, giving the impres-
sion that the variable names matter.
They don’t. Types do but that’s another
minefield.)
An integer pointer is a pointer that
holds the address of another integer.
There are two pointer ‘operators’,
which allow programmers to do things
with pointers:
• The ampersand ‘address of’ operator
gives access to a variable’s location and
is how pointers are setup.
• The asterisk ‘value at address’ opera-
tor gives access to pointed-to variable’s
value and can be used like peek and
poke in BASIC.
All clear so far?
Here are some pointers in action.
integers x, y and z exist with values
of 10, 20 and 30.
Two pointers are declared.
Int * p1
Int * p2
Their contents are indeterminate until
they are initialised.
+5V
5V
SDA SDA 20 column x 4 row LCD with I2C
SCL SCL
interface
0V
D12
All LEDs are 5V types (with internal resistor)
LED3 0V All are optional, though LED3 is highly recommended
C-pointers: Dan Gookin’s Beginning
Programming with C, chapters 18 and 19,
I found very good. If you want more of a
reference (no pun intended), there is:
http://boredzo.org/pointers
p1 = &x
p2 = &y
This sets p1 to the location of x and
p2 to y’s location.
In C parlance, p1 ‘points to’ x.
p1 has a value of 100.
*p1 has a value of 10.
Do not read on until that makes
sense. Conceptually, that is all there is
to pointers.
z = *p1
This sets z to 10.
*p1 = *p2
This makes x = y
*p2 = z
This sets y to z, which is what x had
before we started. After these instruc-
tions have taken place x, y and z have
values of 20, 10 and 10. Precisely this
code can be found in sort routines.
This could have been done far more
simply without pointers, of course. But
moving data around takes process-
ing time. Three variables’ values have
changed but only one actual move-
ment of data − the setting of z − took
place. The other changes were achieved
by swapping pointers. If z had had a
pointer too, all of this could have taken
place with no data moving at all, which
is why so many C string functions use
pointers all the time.
Please see Useful Links for a much
better introduction to use of C pointers.
Practical Wireless March 2018
18/01/2018 10:39
 //------------------ start sketch ARD71 readtm = millis ();
// D71 sketch written by Tony Jones September 2017 if (prevmd != micdig) {
// V1.4 22 Nov 2017 switch (micdig) {
// if high, a gap has just ended.. if low, a dash or a dot has just ended
#include <Wire.h> case HIGH : {
#include <LiquidCrystal_I2C.h> if (wentlowwtm > 0) {
return (readtm - wentlowwtm);
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); } break;
}
const char * cwalph[] = {“.-”, // A,0th element case LOW : {
“-...”, // B if (wentlowwtm == 0) {
“-.-.”, // C wentlowwtm = readtm;
“-..”, // D } break;
“.”, // E }
“..-.”, // F } // end case
“--.”, // G prevmd = micdig; digitalWrite(cwledop, micdig);
“....”, // H } // end if
“..”, // I } //end while
“.---”, // J
“-.-”, // K }
“.-..”, // L //------------------ endd findgap
“--”, // M //------------------ start loop
“-.”, // N void loop()
“---”, // O {
“.--.”, // P int j, k, twodot;
“--.-”, // Q char segsch[6], showstr [LCDCHARS];
“.-.”, // R boolean micdig, prevmd;
“...”, // S unsigned long hightm, lowwtm, readtm, wenthightm, wentlowwtm;
“-”, // T
“..-”, // U prevmd = LOW;
“...-”, // V wenthightm = 0; wentlowwtm = 0;
“.--”, // W
“-..-”, // X strcpy(segsch, “”); j = -1; k = -1;
“-.--”, // Y
“--..”, // Z,25th element while (HIGH) {
“-----”, // 0,26th element micval = analogRead (A0); micdig = (micval > miclvl) ;
“.----”, // 1 readtm = millis ();
“..---”, // 2 if (prevmd != micdig) {
“...--”, // 3 switch (micdig) { // if high, a gap has just ended.. if low, a dash or a
“....-”, // 4 dot has just ended
“.....”, // 5 case HIGH : {
“-....”, // 6 wenthightm = readtm;
“--...”, // 7 lowwtm = readtm - wentlowwtm;
“---..”, // 8 if (wentlowwtm > 0 && lowwtm > twodotlen) {
“----.”}; // 9,35th element; segsch[++j] = ‘\0’;
// compiler substitutions LCDmanage (cwdecode (segsch)); j = -1; // cwdecode returns integer
eg E is 69
#define ASCAVAL 65 // decimal value of character ‘A’ in ASCII }
#define ASC0VAL 48 // decimal value of character ‘0’ in ASCII break;
#define CWPATTERNS 35 // A to Z, 0 to 9 makes 36 minus 1 because its an array }
#define NUMBERLETTERS 26 // A to Z case LOW : {
wentlowwtm = readtm;
#define TWOSEC 2000 hightm = readtm - wenthightm;
#define LCDCHARS 16 // I decided not use all the width - can’t remember why if (wenthightm > 0 && hightm > twodotlen) {
#define LCDTOTCHARS 20 // change LCDTOTCHARS just once to use different lcd display segsch[++j] = ‘-’;
#define LCDROWS 4 // change LCDROWS just once to use different lcd display } else {
segsch[++j] = ‘.’;
// constants }
const int cwledop = 12; break;
}
// changing global variables } // end case
unsigned long dotgaplen, longaplen, twodotlen; prevmd = micdig; digitalWrite(cwledop, micdig);
int miclvl, micval; } // end if
} // endwhile
char LCDline1 [LCDCHARS + 1] ;
char LCDline2 [LCDCHARS + 1] ; }// bot func
char LCDline3 [LCDCHARS + 1] ; //------------------ enddd loop

//------------------ start setup // ------------------begin called functions

void setup()
{ //------------------ start cwdecode
pinMode (cwledop, OUTPUT); int cwdecode( char * cwchar)
pinMode (A0, INPUT); { int x;

unsigned long gap; for (x = 0; x < CWPATTERNS; x++) {

int i, maxmic, minmic; if (strcmp(cwchar, cwalph [x]) == 0) {
break;
Serial.begin(9600); }
}
lcd.begin(LCDTOTCHARS, LCDROWS);
lcd.clear(); lcd.setCursor(0, 0); lcd.print(F(“D71 V1.4”)); if (x < NUMBERLETTERS) {
delay(TWOSEC); return x += ASCAVAL; // a letter
}
strcpy(LCDline1,” “); else {
strcpy(LCDline2,” “); return x += (ASC0VAL - NUMBERLETTERS); // a number
strcpy(LCDline3,” “); }

maxmic = 0; minmic = 2000; }

for (i=0; i<500; i++) { //------------------ enddd cwdecode
micval = analogRead (A0); delay(2); void LCDmanage (int nextchar)
if (micval > maxmic) { maxmic = micval; } {
if (micval < minmic) { minmic = micval; }
} char x = nextchar;
miclvl = 10 + (1.1 * minmic); // constant 10 needed when minmic is very low eg int linelen = strlen(LCDline1);
when reading off ARD070 float adjgap,spd;

dotgaplen = 30000; longaplen = 0; adjgap = (float) (longaplen / (3.0 * dotgaplen));

for (i = 0; i < 4; i++) {
gap = findgap(); if (linelen == LCDCHARS) {
if (gap < dotgaplen ) { strcpy(LCDline3, LCDline2);
dotgaplen = gap ; strcpy(LCDline2, LCDline1);
} // end if linelen = 0;
if (gap > longaplen ) { }
longaplen = gap ;
} // end if lcd.clear();
} // end for loop lcd.setCursor(0, 0); spd = float( 1200.0 / dotgaplen ); // 1200 ms is one dot
twodotlen = dotgaplen * 2; at 1 wpm
} lcd.print(spd, 1); lcd.print(F(“ wpm “));
//------------------ enddd setup lcd.print(F(“gap “)); lcd.print(adjgap, 1); lcd.print(F(“ dots”));
//------------------ start findgap
unsigned long findgap () LCDline1 [linelen] = x; LCDline1 [linelen + 1] = ‘\0’;
{
boolean micdig, prevmd; lcd.setCursor(0, 1); lcd.print(LCDline1);
unsigned long gap, lowwtm, readtm, wentlowwtm; lcd.setCursor(0, 2); lcd.print(LCDline2);
lcd.setCursor(0, 3); lcd.print(LCDline3);
prevmd = 0; wentlowwtm = 0;
int i; }

while (gap == 0) { //-------------------enddd called functions

micval = analogRead (A0); micdig = (micval > miclvl) ; //------------------ enddd sketch ARD71

Sketch Code: Here is the code. It is also available to download from my website.

March 2018 Practical Wireless 43

COTPW 4-5 pages.indd 43 18/01/2018 10:39