I felt kinda bad about being mean to Len, so I'll try to meet him
halfway with a Morse code topic. So maybe we can ressurect this old one...

I hear lots of Hams declare that Morse code is a binary mode.

It is most certainly not.

Let us look at the situation.

Is the Dit a "0"?
Is the Dah a "1"?

Is the space between characters a "0"? and the Dih a "1"? Oh wait, what
is the Dah then? Oh, and what about the space between words?

It isn't binary, and the way our noodles process it isn't binary.

It's not binary.

- Mike KB3EIA -

thats funny, the program i am writing represents it very nicely with just
1's and 0's.

"Michael Coslo" wrote in message
...
I felt kinda bad about being mean to Len, so I'll try to meet him
halfway with a Morse code topic. So maybe we can ressurect this old one...

I hear lots of Hams declare that Morse code is a binary mode.

It is most certainly not.

Let us look at the situation.

Is the Dit a "0"?
Is the Dah a "1"?

Is the space between characters a "0"? and the Dih a "1"? Oh wait, what
is the Dah then? Oh, and what about the space between words?

It isn't binary, and the way our noodles process it isn't binary.

It's not binary.

- Mike KB3EIA -

Dave wrote:
thats funny, the program i am writing represents it very nicely with just
1's and 0's.

Looking at it that way, all things that can be put into a digital
program are digital, such as photographs, word processing, database, etc.

Let us put it to the test, Dave.
Write out a short sentence, or even a CQ de (your callsign) in binary
format, and let me read it right off the screen. If Morse code is
binary, it will be no problem.

This is a screen readable approximation of me calling CQ

..-.- --.- -.. . -.- -... ...-- . .. .- .--. ... . -.-

it is not binary.

- Mike KB3EIA -



"Michael Coslo" wrote in message
...

I felt kinda bad about being mean to Len, so I'll try to meet him
halfway with a Morse code topic. So maybe we can ressurect this old one...

I hear lots of Hams declare that Morse code is a binary mode.

It is most certainly not.

Let us look at the situation.

Is the Dit a "0"?
Is the Dah a "1"?

Is the space between characters a "0"? and the Dih a "1"? Oh wait, what
is the Dah then? Oh, and what about the space between words?

It isn't binary, and the way our noodles process it isn't binary.

It's not binary.

- Mike KB3EIA -

In article ,
Mike Coslo wrote:

| Let us put it to the test, Dave.
| Write out a short sentence, or even a CQ de (your callsign) in binary
| format, and let me read it right off the screen. If Morse code is
| binary, it will be no problem.

That's actually a reasonable test. And I shall give you an answer,
though I don't think you expected one. And I'm not Dave.

Here is a binary representation of `CQ DE K' (this gets rather tedious,
so I'll only do the first few characters) :

10111010111000111011101011100000001110101000100011 1010111000

And to explain that further --

dit = 1
dah = 111
space between dit/dah = 0
space between letters = 000
space between words = 0000000

So, `CQ DE K' translates to :

C 10111010111
000
Q 1110111010111
0000000
D 1110101
000
E 1
000
K 111010111
000

(the letters and newlines are there *only* to help make it readable.)

To play this back is very simple --

-- Pick a time period -- for example, 1 = 1/10 th of a second.
-- go through the list, going through each chracter --
1 = play a tone for 1/10th of a second
0 = be completely silent for 1/10th of a second

It's really that simple.

If you want a program to do it --

#!/usr/bin/perl -w
# C Q D E K B 3 E I A P S E K
my $string = ".-.- --.-\n-.. .\n-.- -... ...-- . .. .-\n.--. ... . -.-" ;
foreach my $c (split (//, $string)) {
if ($c eq ".") { print "10" ; next } ;
if ($c eq "-") { print "1110" ; next } ;
if ($c eq " ") { print "00" ; next } ; # Only two 0s, because the last
# character ended with a 0.
if ($c eq "\n") { print "000000" ; next } ; # ditto, but 6.
}
print "\n" ;

And the output of your complete CQ in binary is :

10111010111000111011101011100000001110101000100000 00
11101011100011101010100010101011101110001000101000 101110000000
101110111010001010100010001110101110

new lines and spaces are added by me only to help it fit on the
screen.

| This is a screen readable approximation of me calling CQ
|
| .-.- --.- -.. . -.- -... ...-- . .. .- .--. ... . -.-

| it is not binary.

Binary.

--
Doug McLaren, , AD5RH
... Time is the best teacher, unfortunately it kills all of its students.

Much to do about nothing

Morse code is sounds

Binary in the customary useage is ones and zeroes -- computer stuff.

--
Caveat Lector (Reader Beware)



"Doug McLaren" wrote in message
...
In article ,
Mike Coslo wrote:

| Let us put it to the test, Dave.
| Write out a short sentence, or even a CQ de (your callsign) in binary
| format, and let me read it right off the screen. If Morse code is
| binary, it will be no problem.

That's actually a reasonable test. And I shall give you an answer,
though I don't think you expected one. And I'm not Dave.

Here is a binary representation of `CQ DE K' (this gets rather tedious,
so I'll only do the first few characters) :

10111010111000111011101011100000001110101000100011 1010111000

And to explain that further --

dit = 1
dah = 111
space between dit/dah = 0
space between letters = 000
space between words = 0000000

So, `CQ DE K' translates to :

C 10111010111
000
Q 1110111010111
0000000
D 1110101
000
E 1
000
K 111010111
000

(the letters and newlines are there *only* to help make it readable.)

To play this back is very simple --

-- Pick a time period -- for example, 1 = 1/10 th of a second.
-- go through the list, going through each chracter --
1 = play a tone for 1/10th of a second
0 = be completely silent for 1/10th of a second

It's really that simple.

If you want a program to do it --

#!/usr/bin/perl -w
# C Q D E K B 3 E I A P S E K
my $string = ".-.- --.-\n-.. .\n-.- -... ...-- . .. .-\n.--. ... . -.-"
;
foreach my $c (split (//, $string)) {
if ($c eq ".") { print "10" ; next } ;
if ($c eq "-") { print "1110" ; next } ;
if ($c eq " ") { print "00" ; next } ; # Only two 0s, because the
last
# character ended with a 0.
if ($c eq "\n") { print "000000" ; next } ; # ditto, but 6.
}
print "\n" ;

And the output of your complete CQ in binary is :

10111010111000111011101011100000001110101000100000 00
11101011100011101010100010101011101110001000101000 101110000000
101110111010001010100010001110101110

new lines and spaces are added by me only to help it fit on the
screen.

| This is a screen readable approximation of me calling CQ
|
| .-.- --.- -.. . -.- -... ...-- . .. .- .--. ... . -.-

| it is not binary.

Binary.

--
Doug McLaren, , AD5RH
.. Time is the best teacher, unfortunately it kills all of its students.

Doug McLaren wrote:
In article ,
Mike Coslo wrote:

| Let us put it to the test, Dave.
| Write out a short sentence, or even a CQ de (your callsign) in
binary
| format, and let me read it right off the screen. If Morse code is
| binary, it will be no problem.

That's actually a reasonable test. And I shall give you an answer,
though I don't think you expected one. And I'm not Dave.

Here is a binary representation of `CQ DE K' (this gets rather
tedious,
so I'll only do the first few characters) :

10111010111000111011101011100000001110101000100011 1010111000

And to explain that further --

dit = 1
dah = 111
space between dit/dah = 0
space between letters = 000
space between words = 0000000

So, `CQ DE K' translates to :

C 10111010111
000
Q 1110111010111
0000000
D 1110101
000
E 1
000
K 111010111
000

(the letters and newlines are there *only* to help make it readable.)

To play this back is very simple --

-- Pick a time period -- for example, 1 = 1/10 th of a second.
-- go through the list, going through each chracter --
1 = play a tone for 1/10th of a second
0 = be completely silent for 1/10th of a second

It's really that simple.

If you want a program to do it --

#!/usr/bin/perl -w
# C Q D E K B 3 E I A P S E
K
my $string = ".-.- --.-\n-.. .\n-.- -... ...-- . .. .-\n.--. ... .
-.-" ;
foreach my $c (split (//, $string)) {
if ($c eq ".") { print "10" ; next } ;
if ($c eq "-") { print "1110" ; next } ;
if ($c eq " ") { print "00" ; next } ; # Only two 0s, because
the last
# character ended with
a 0.
if ($c eq "\n") { print "000000" ; next } ; # ditto, but 6.
}
print "\n" ;

And the output of your complete CQ in binary is :

10111010111000111011101011100000001110101000100000 00
11101011100011101010100010101011101110001000101000 101110000000
101110111010001010100010001110101110

new lines and spaces are added by me only to help it fit on the
screen.

| This is a screen readable approximation of me calling CQ
|
| .-.- --.- -.. . -.- -... ...-- . .. .- .--. ... . -.-

| it is not binary.

Binary.

--
Doug McLaren, , AD5RH
.. Time is the best teacher, unfortunately it kills all of its
students.

Doug, please perform the same exercise for all variations of the
Farnsworth code. Thanks.

In article .com,
bb wrote:

| If you want a program to do it --
|
| #!/usr/bin/perl -w
| # C Q D E K B 3 E I A P S E
| K
| my $string = ".-.- --.-\n-.. .\n-.- -... ...-- . .. .-\n.--. ... .-.-" ;
| foreach my $c (split (//, $string)) {
| if ($c eq ".") { print "10" ; next } ;
| if ($c eq "-") { print "1110" ; next } ;
| if ($c eq " ") { print "00" ; next } ; # Only two 0s, because
| the last
| # character ended with
| a 0.
| if ($c eq "\n") { print "000000" ; next } ; # ditto, but 6.
| }
| print "\n" ;
....
| Doug, please perform the same exercise for all variations of the
| Farnsworth code. Thanks.

Um, I'll pass

I'm not sure what the value would be, but if you really think it's
worthwhile, you can work out the timings yourself, and use my program
to print out your 1s and 0s. (perl is available on most operating
systems, including Windows, if you need it.)

All you'd have to do is change the `00' and `000000' print statements
to include more zeros. (But don't forget that there's already a 0
printed as a part of the last character when calculating the timings.)

In any event, the expected timings for `standard' morse code are well
defined -- a dah is 3x as long as a dit, the space between dits and
dahs is as long as a dit, the space between characters is 3x as long
as a dit, and the space between words is 7x as long as a dit. The
Farnsworth method merely makes the 3x and 7x gaps longer.

(My little program uses \n's to indicate the end of a word. This is
needed because the `.-.- --.-' notation really has no standard way of
indicating the difference between a 3-dit long pause and a 7-dit long
pause.)

--
Doug McLaren,
internet, eh? I hear they have that on computers now.

bb wrote:

Doug McLaren wrote:

In article ,
Mike Coslo wrote:

| Let us put it to the test, Dave.
| Write out a short sentence, or even a CQ de (your callsign) in

binary

| format, and let me read it right off the screen. If Morse code is
| binary, it will be no problem.

That's actually a reasonable test. And I shall give you an answer,
though I don't think you expected one. And I'm not Dave.

Here is a binary representation of `CQ DE K' (this gets rather

tedious,

so I'll only do the first few characters) :

10111010111000111011101011100000001110101000100011 1010111000

And to explain that further --

dit = 1
dah = 111
space between dit/dah = 0
space between letters = 000
space between words = 0000000

So, `CQ DE K' translates to :

C 10111010111
000
Q 1110111010111
0000000
D 1110101
000
E 1
000
K 111010111
000

(the letters and newlines are there *only* to help make it readable.)

To play this back is very simple --

-- Pick a time period -- for example, 1 = 1/10 th of a second.
-- go through the list, going through each chracter --
1 = play a tone for 1/10th of a second
0 = be completely silent for 1/10th of a second

It's really that simple.

If you want a program to do it --

#!/usr/bin/perl -w
# C Q D E K B 3 E I A P S E

K

my $string = ".-.- --.-\n-.. .\n-.- -... ...-- . .. .-\n.--. ... .

-.-" ;

foreach my $c (split (//, $string)) {
if ($c eq ".") { print "10" ; next } ;
if ($c eq "-") { print "1110" ; next } ;
if ($c eq " ") { print "00" ; next } ; # Only two 0s, because

the last

# character ended with

a 0.

if ($c eq "\n") { print "000000" ; next } ; # ditto, but 6.
}
print "\n" ;

And the output of your complete CQ in binary is :

10111010111000111011101011100000001110101000100000 00
11101011100011101010100010101011101110001000101000 101110000000
101110111010001010100010001110101110

new lines and spaces are added by me only to help it fit on the
screen.

| This is a screen readable approximation of me calling CQ
|
| .-.- --.- -.. . -.- -... ...-- . .. .- .--. ... . -.-

| it is not binary.

Binary.

--
Doug McLaren, , AD5RH
.. Time is the best teacher, unfortunately it kills all of its

students.

Doug, please perform the same exercise for all variations of the
Farnsworth code. Thanks.

Good point Brian. Farnsworth will have a different representation in
timing. While the human mind will interpret Farnsworth fairly easily,
the software may have some problems?

- Mike KB3EIA -

Doug McLaren wrote:
In article ,
Mike Coslo wrote:

| Let us put it to the test, Dave.
| Write out a short sentence, or even a CQ de (your callsign) in binary
| format, and let me read it right off the screen. If Morse code is
| binary, it will be no problem.

That's actually a reasonable test. And I shall give you an answer,
though I don't think you expected one. And I'm not Dave.

Sorry about that, Doug.


Here is a binary representation of `CQ DE K' (this gets rather tedious,
so I'll only do the first few characters) :

10111010111000111011101011100000001110101000100011 1010111000

-.-. --.- -.. . -.-

Those certainly look different.

And to explain that further --

dit = 1
dah = 111
space between dit/dah = 0
space between letters = 000
space between words = 0000000

So, `CQ DE K' translates to :

C 10111010111
000
Q 1110111010111
0000000
D 1110101
000
E 1
000
K 111010111
000

(the letters and newlines are there *only* to help make it readable.)

To play this back is very simple --

-- Pick a time period -- for example, 1 = 1/10 th of a second.
-- go through the list, going through each chracter --
1 = play a tone for 1/10th of a second
0 = be completely silent for 1/10th of a second

It's really that simple.

If you want a program to do it --

#!/usr/bin/perl -w
# C Q D E K B 3 E I A P S E K
my $string = ".-.- --.-\n-.. .\n-.- -... ...-- . .. .-\n.--. ... . -.-" ;
foreach my $c (split (//, $string)) {
if ($c eq ".") { print "10" ; next } ;
if ($c eq "-") { print "1110" ; next } ;
if ($c eq " ") { print "00" ; next } ; # Only two 0s, because the last
# character ended with a 0.
if ($c eq "\n") { print "000000" ; next } ; # ditto, but 6.
}
print "\n" ;

And the output of your complete CQ in binary is :

10111010111000111011101011100000001110101000100000 00
11101011100011101010100010101011101110001000101000 101110000000
101110111010001010100010001110101110

new lines and spaces are added by me only to help it fit on the
screen.

| This is a screen readable approximation of me calling CQ
|
| .-.- --.- -.. . -.- -... ...-- . .. .- .--. ... . -.-

| it is not binary.

Binary.

I think your explanation kind of proves my point.

You do a pretty good job of showing how a person turns Morse code into
digital 1's and 0's. But that does not make Morse code digital any more
than doing the same for an image makes a photograph digital. The Morse
code had to be translated into binary.

The binary output of that CQ in binary doesn't look like anything that
any Ham I know can read. If you are coding a CW reader, the output will
be translated into words. If Morse was binary, the op could just read
the string of 1's and 0's.

- Mike KB3EIA -

On Wed, 02 Feb 2005 17:50:02 GMT, Doug McLaren wrote:

dit = 1
dah = 111
space between dit/dah = 0
space between letters = 000
space between words = 0000000

So, `CQ DE K' translates to :

C 10111010111
000

In what world is "C" = dit-dah-dit-dah ??? Send that in an
FCC-administered code test and fail.

--
73 de K2ASP - Phil Kane