#Navigate a binary tree to decode morse code strings code
#Navigate a binary tree to decode morse code strings plus

#Navigate a binary tree to decode morse code strings code

As we know from our original Morse code chart, a dot equates to one element (unit) of delay (time) and a dash equates to three elements of delay. The thing about Morse code is that everything is relative, because some people can transmit it faster than others. Comparison (code size and execution speed)īefore we plunge into the fray with gusto and abandon, let’s first discuss a few “housekeeping” issues.The reason for this will become clear when I rent the veils asunder and explain the true purpose behind this capriciously cunning contraption, but we'll leave that for a future column.įor the purposes of this exercise, I've decided to compare two different techniques: (a) Storing the Morse code symbols as strings, and (b) packing the symbols for each character into a single byte. On the other hand, it's always a good idea to minimize your code and data size where possible, and it's also gratifying to make your code run as efficiently and as quickly as possible, even if no one else really gives a hoot.įor this particular project, I feel that understandability and maintainability are the two key elements. Transmitting Morse code at human-readable speeds means that - most of the time - the processor is sitting around twiddling its metaphorical thumbs, so speed optimization isn’t really an issue. Jacob Larsen also commented: “You don't mention what you are optimizing for - code size, code maintainability, data size, or instruction speed? I am going to assume maintainability, since Morse code generally doesn't go fast enough to need speed optimization.” Happily, Cdhmanning's scheme can be adapted to accommodate this as shown below, where a 'x' character indicates “don't care” (we'll set these to 0 in the code) and a '?' character indicates a symbol (0 = dot, 1 = dash): In this case, our 'F' character would actually be stored as 100×0100.Īs I mentioned above, I also wish to have two punctuation symbols at my disposal, each of which contains six symbols: ',' (comma = “–.–“) and '.' (period = “.-.-.-“).

In fact, Cdhmanning, actually recommended that the dot-dash symbol bits be “swapped over” such that the first to be transmitted is stored in the LSB, because this will make any downstream processing easier. Meanwhile, the 'x' indicates that we don’t care about this character (we would set it to 0 in the code). This could be represented as 100×0010, where the 100 indicates that this character contains four dot-dash symbols and the 0010 indicates dot-dot-dash-dot. The three MSBs (most-significant bits) would be used to represent the number of bits in the character, while the five LSBs (least-significant bits) would be used to represent the dots and dashes.Ĭonsider the character 'F' (“.-.”), for example. On the one hand, this has the advantage of being relatively simple on the other hand, the numeric character '0' with five dashes (“-–“) would occupy 5 x (3 + 1) = 20 bits, which seems a tad enthusiastic, as it were.Īnother proposal from Cdhmanning was to store each Morse code character in an 8-bit byte. We can encode them as 0b00, 0b01, 0b10 and 0b11, thereby getting four symbols into a byte.Īnother community member, Jacob Larsen, suggested using 0 and 1 bits to represent units of light and darkness, so the character 'A' (“.-“) would be represented as 10111 i.e., dot (1) = LED On = one unit delay inter-symbol space (0) = LED Off = one unit delay and dash (111) = LED On = three unit delays. The space between words (-1 implicit space between parts) The space between letters (-1 implicit space between parts) The dash (+1 implicit space between parts) The dot (+1 implicit space between parts)

Boni in Brazil, who suggested the following scheme, which is very similar to David's:

#Navigate a binary tree to decode morse code strings plus

David also noted that, using this scheme, a 5-symbol code would require 20 bits (5 dots/dashes x 2 bits, plus 4 inter-symbol spaces x 2 bits, plus 1 end character x 2 bits).Īctually, just a few minutes ago whilst I was in the process of writing this column, I received an email from Djones A. My chum David Ashton, for example, suggested 01=dot, 10=dash, 11=space, and 00=end. Several people advocated using two bits per symbol. Sad to say, however, I couldn’t wrap my brain around that one either (“I'm a bear of little brain,” as Winnie-the-Pooh would say). Someone else emailed me proposing a form of run-length encoding.