So You Want To Build A Beacon - My Gongshow

[737999]

This thread is going to be an ongoing update about my attempts to build a beacon. I figured centralizing my studies here might be helpful, so at least everything is in one place, and maybe I can save some headache for the next guy who tries this.

***

Hello internet,

So this story starts with the usual thought that never ends well for me: "How hard can it be?" In my specific case, I wanted to build an HF beacon. Initially, this project was driven by mild curiosity. I read about the Desert Whooper beacon, and wondered if I, a complete radio newb who knows zero about electronics, could build something similar. However, in the last two weeks, it has turned into a need to build this thing simply out of principle: (1) To prove it can be done, and (2) to push back against all the Ham-Karens that argue that it can't be done.

For this project, my intent was to build a cheap CW beacon using off-the-shelf plug-and-play parts. No soldering, no kits, no wiring diagrams. Just hit up Amazon, buy X,Y,Z, plug them all in, and you're in business. Easy as lego.

First road block encountered: Modularity like I'd hoped for appears to not exist. Or at least as far as I can tell. The difficulty appears to be in getting the various components to "Talk" to each other. If I can get past that hurdle, this should work I think.

Speaking of components, here's what a guy needs for this build:

- A thing to create a CW signal.
- A transmitter.
- An antenna.

There's other misc bits and pieces, and I'll get to those at a later stage. But for now, the above appears to be all a guy needs.

I'll wrap things up before this turns into a stream of consciousness. Updates will follow as I work through this mess. Have a nice day.

[737999]

Hello Internet,

To start this off, I've done a ton of reading. The problem is I'm not a radio guy. I'm not an electronics guy. I'm clueless about this whole world. But, my super power is blindly charging forwarding, wasting blood, money, and tears, and then weeks later wondering why I made such questionable life choices. So, here we are.

I've ordered up some components: Arduino, Raspberry Pi's (Pi 3+ and Zero), a Pixie, an aliexpress uSDX garbage radio, and some miscellaneous parts and wires. All off-the-shelf, pre-assembled stuff, obtained with the click of a button (And a sip of coffee.) Some of the stuff I currently have, others will be here later in the week. 

At the moment, here's my theory on the stages needed to make this gongshow work:

(1) R-pi/Arduino auto-generates "The Signal" ---> (2) Feed The Signal to Pixie ---> (3) Pixie transmits The Signal.

I'm going to break this down to chunks of work. For now, focus on Step 1 = Generate The Signal.



Arduino
Fortunately a bunch of smarter people have thought of this before, and done the hard work. For an Arduino, a guy named Mark Van de Wettering wrote a simple program that has an Arduino generate a CW message.

https://brainwagon.org/2009/11/14/another-try-at-an-arduino-based-morse-beacon/

My understanding is that you copy/paste the code to the Arduino, edit the message you want to send, and the Arduino will kick out a CW signal pulse to Pin 13. Easy.

Except here's where I hit a wall with the Arduino. Apparently you can't just hook "Pin 13" up to a Pixie. I don't know why (Remember, I'm not a radio guy) but the Internet tells me This Is Bad/Won't Work (TIBWW). So somehow you need to convert the Pin 13 signal to something that the Pixie can read (Step 2 above.) For a basic CW radio, the easiest way to do this is hack the morse code key thing (The thing you go tappy-tap-tap on.) If you can pipe the Arduino signal through a 3.5mm audio cable to the keyer in a way the keyer can understand you'll get the Pixie to transmit.

Mark appears to have accomplished having the arduino send The Signal to his own radio, but I can't see how he did this. (The video is too low resolution for me to decipher what I'm looking.) Limited documentation exists on this. He said:

 "... put in any NPN transistor (base in pin 13, emitter to ground) and then use the collector/emitter [to trigger the keyer.]" I'm not smart enough to quite grasp what that means. I'll have to experiment I guess. I think this bit is key though.   

This other dude on youtube seems to have built exactly what I'm trying to do, but unfortunately limited documentation exists for how the guy did it. I'm finding a trend. https://www.youtube.com/watch?v=__tLWFw6RjY

Raspberry Pi

I have a few Pi Zeros on the shelf, so thought I'd try this option too. And good news: After a ton of research, I came across this: PixiePi https://github.com/lu7did/PixiePi

Except that the usual "Radio" thing happened. The material is written by a well-meaning, smart person. Meaning that I can't understand any of it. It's extremely frustrating for me, as a guy has clearly built this same project that I'm trying to build. And instead of being able to easily follow and copy what was done, I'm left going ""

Moving on, there's a github called "CWBeacon." This is a python script that generates a CW message. Great - Just what I need. https://github.com/gerryk/cwbeacon Except the pictures are broken. And to be honest I can't figure out what R-Pi GPIO pin it uses for output of the CW signal. Oh well.

***

To wrap things up, it's been a good few days. There's lots of resources out there for creating The Signal. So I think it's safe to say that Step 1 is nailed down. I've got some code for both the Arduino and the R-Pi's, so it's now a matter of installing the code, and getting an actual signal generated.

Looking ahead, getting The Signal sent to the Pixie in a format the Pixie can understand (Step2) is going to be hard. Mostly because it appears that this step requires some electronics knowledge, of which I have none. Joy.

Have a nice day.

[Stretchyman]

I think it would be far simpler and cheaper to solder the parts together. What have you got against soldering?

You only need 3 parts (components)

PIC+OSC+CLASSE PA.

Str.

[737999]

And you sir would be 100% correct. But this assumes a person (1) has a soldering iron, and (2) has the skill to use one. I have neither, so my caveman brain has to rely on the electronics equivalent of lego blocks.

Like the title says, welcome to the gongshow.

I think it would be far simpler and cheaper to solder the parts together. What have you got against soldering?

You only need 3 parts (components)

PIC+OSC+CLASSE PA.

Str.

[newq]

Soldering isn't that hard. I think a lot of people regard it as the electronics equivalent of software development, but it's not. 99% of the time, especially if you're just assembling kits, it's just sticking parts through holes and melting metal to secure them and make an electrical contact. You don't even need to know how the components you're working with work or what they do. It's just like reading instructions on a Lego kit except you melt metal to stick the parts together instead.

If you need more details, just ask and me and others will help you, but seriously, I would recommend abandoning this project if you're that allergic to the concept of soldering.

[Stretchyman]

Indeed. Electronics is held together with solder. If you can't solder then learn, it's no more difficult, infact it's easier than rubbing two sticks together!

Get a scope too!

2 things electronics demands, good soldering skills and a scope.

Engineers have to learn new skills everyday. Part of the fun, learning and saving money too!

Str.

[737999]

Hello internet,

Last night was a solid night, and got a whole bunch done: rigged up two ways to create an auto-generated Signal, and also managed to stumble my way through building a keying circuit. Unfortunately I don't have an Arduino yet, so today's stuff is limited to Raspberry Pi only.

Fldigi + Xdotool

Conceptually, this option consists of using a keyboard macro program (Xdotool) to "push" a button in Fldigi. When that button is pushed, it triggers an Fldigi key macro, which triggers Fldigi to generate a pre-prepared message and then transmit that message. This process is repeated on a loop.

Step 1 - Fldigi

First, install fldigi. You want a 4.x.xx version. Go to "add software", type in Fldigi, click the checkbox, and push "OK". Your Pi will install the program. Repeat this step for Xdotool.

Next, you need to autostart Fldigi on startup. So you'll need to fire up the old text editor and write a file to make this happen. Open a terminal, and type:

Code: [Select]

sudo nano  /etc/xdg/autostart/fldigi.desktop
Next, type (or copy/paste) the following text into the file you just created, save, and exit:

Code: [Select]

[Desktop Entry]
Name = fldifi
Exec=fldigi
Congrats, Fldigi will now autostart every time your Pi starts up.

Step 2 - Xdotool

So now that you've got Fldigi installed and running, you need a way to have it create a message. This is where xdotool comes in. Xdo tool is a program that simulates keystrokes. Except instead of you pushing buttons, the program "pushes" the buttons instead. The trick is you need to generate a file to tell Xdotool what buttons to push, and when. So open a terminal and do the following.

terminal, and type:

Code: [Select]

sudo nano  /etc/xdg/autostart/xdoscript.desktop
Next, type (or copy/paste) the following text into the file you just created, save, and exit:

Code: [Select]

[Desktop Entry]
Name = xdoscript
Exec=/home/pi/xdoscript.sh
What you've done here is made it so that every time your Pi starts, it will run fldigi, and a program called "Xdoscript". The catch is you have to create that program. So on to the next step.

Step 3 - Xdoscript

**Note here: This assumes you have your pi configured like all pi's: The username is "pi". If you've used a different username, substitute it for "pi" in the following text.**

In a terminal, type in

Code: [Select]

sudo nano /home/pi/xdoscript.sh
Next, enter the following text (or copy/paste), save, and exit:

Code: [Select]

xdotool sleep 30;
xdotool search --class fldigi windowactivate --sync %1 key F9 windowactivate $(xdotool getactivewindow)
What you've done here is two things:

-- On startup, xdotool will wait 30 seconds.
-- After 30 seconds, it will "push" the F9 function key and send that keystroke directly to fldigi.

Note: I'll detail a separate xdoscript later that sends stuff hourly, on repeat, for 2.7 years. It's better discussed in a separate post.

Step 4 - Fldigi Hotkey

Okay last step. Open Fldigi and right-click the blue "T/R" button towards the bottom right of the screen. A window will pop up, with the text "<TX/RX>". Replace that text with the following:

Code: [Select]

<TX>
hello world
<RX>
Click "Apply", then close.

What you've done is made it so that every time you hit the F9 key, fldigi will generate and transmit "hello world." Obviously, in your own stuff, you'll replace "hello world" with your proper callsign and beacon text etc.

***

So in summary, when you've done the above steps, you've made it so that every time the Rpi starts:

-- Fldigi fires up.
-- 30 seconds later Fldigi creates a "hello world" message.
-- Fldigi transmits that message.

Ideally, you'd repeat this process on a loop. I have a script I'll upload that does this, but it's an ugly, horrendous, inelegant thing and not needed for this post. I'll reference it later.

Congratulations, you've now created The Signal.

Speaking of horrendous, inelegant stuff, this whole process/program detailed here is an ugly way to do things. But it works. More importantly, it's hugely functional for the following reason: It allows a person to auto-generate a beacon message that can be sent out using Fldigi's digital modes. Want a psk31 beacon? This will generate the text and auto-send it.

Anyway, that's enough for now. I'll update my other results in my next posts.

 

[737999]

The Signal - Part 2

Again, this is for Raspberry Pi, and I think a much simpler option than the Fldigi route. A dude named GerryK wrote this program, but it's a bit dated now, and I don't know how well it is maintained. Reference here:

http://gerryk.com/posts/morse_code_beacon_for_the_raspberry_pi/
https://github.com/gerryk/cwbeacon

Because it was written a while back, I had to make a few syntax changes to the code. I also learned the hard way that Gerry's code references the actual pin number, not the GPIO number. Once I got that figured out, I was able to make it work. With that in mind, here's what you do:

Step 1 - Groundwork

Open your Raspberry Pi, and navigate to your home directory (/home/pi). Create a new folder called "cwbeacon". Inside that folder, create a new file called "beacon.py" Then, copy/paste the code below into that file, save, and exit

Code: [Select]

import time
import RPi.GPIO as GPIO
class CWString(object):
    letters = { 'a' : '.-',
           'b' : '-...',
           'c' : '-.-.',
           'd' : '-..',
           'e' : '.',
           'f' : '..-.',
           'g' : '--.',
           'h' : '....',
           'i' : '..',
           'j' : '.---',
           'k' : '-.-',
           'l' : '.-..',
           'm' : '--',
           'n' : '-.',
           'o' : '---',
           'p' : '.--.',
           'q' : '--.-',
           'r' : '.-.',
           's' : '...',
           't' : '-',
           'u' : '..-',
           'v' : '...-',
           'w' : '.--',
           'x' : '-..-',
           'y' : '-.--',
           'z' : '--..',
           '1' : '.----',
           '2' : '..---',
           '3' : '...--',
           '4' : '....-',
           '5' : '.....',
           '6' : '-....',
           '7' : '--...',
           '8' : '---..',
           '9' : '----.',
           '0' : '-----',
           '.' : '.-.-.-',
           '/' : '-..-.',
           ',' : '--..--',
           '?' : '..--..'
          }
    cw = ""
    def encode(self, m):
        self.cw = ""
        new_word = True
        for i in m:
            if i in self.letters:
                if not new_word:
                    self.cw = self.cw + " "
                self.cw = self.cw + self.letters[i]
                new_word = False
            elif i == " ":
                self.cw = self.cw + "/"
                new_word = True
            else: # Unrecognised character... what now?
                pass
        return self.cw
class CWSender(object):
    cps = None
    timer = None
    def __init__(self, cps):
        self.cps = cps
        self.dit_length = 1.0/cps
        self.dah_length = self.dit_length*3
    def send(self, m):
        for i in m:
            if i == '.':
                self.dit()
                self.pause()
            if i == '-':
                self.dah()
                self.pause()
            if i == ' ':
                self.cspace()
            if i == '/':
                self.wspace()
    def dit(self):
        GPIO.output(37,True)
        time.sleep(self.dit_length)
        GPIO.output(37,False)
    def dah(self):
        GPIO.output(37,True)
        time.sleep(self.dah_length)
        GPIO.output(37,False)
    def wspace(self):
        time.sleep(self.dah_length * 3)
    def cspace(self):
        time.sleep(self.dah_length)
    def pause(self):
        time.sleep(self.dit_length)
def main():
    import argparse
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(37, GPIO.OUT)
    GPIO.output(37,False)
    parser = argparse.ArgumentParser('CW Beacon Sender - uses GPIO pin')
    parser.add_argument('-c', '--cps', type=int, default='15', help='Characters per second to send')
    parser.add_argument('message', nargs='+', help='Text string to send as CW')
    args = parser.parse_args()
    cw = CWString()
    message = ' '.join(args.message)
    message = ' '.join(args.message).lower()
    encoded = cw.encode(message)
    sender = CWSender(args.cps)
    sender.send(encoded)
if __name__ == "__main__":
    main()
Again, all credit goes to GerryK and his original code here https://github.com/gerryk/cwbeacon  I've made a couple of syntax fixes, and re-routed the output signal to GPIO26

Step 2 - Create a Message

So this part is easy. Open a terminal, and type

Code: [Select]

python /home/pi/cwbeacon/beacon.py -c 20 hello world
What you've done is the following:

-- You're sending "hello world" as The Signal.
-- It's being sent in 20 words per minute morse code.
-- The code will be tapped out via the RPi's GPIO 26 pin

Note the above bold text: My changes to Gerry's code make it so that GPIO 26 is your huckleberry. Use that pin. Only that pin. The pin shall be GPIO 26, nothing more, nothing less.

Step 3 - Automate the beacon

So if you follow the above, you'll generate a one-time message of "hello world." That's not helpful. Because this is for a beacon, we want the code to send out nonstop forever. So to do that, you need to run a "task scheduler." In linux/Rpi, this is called crontab.

So, do the following. Open a terminal on your Rpi, and type

Code: [Select]

crontab -e
Next, copy/paste or type in the following, save, and exit.

Code: [Select]

5,10,15,20,25,30,35,40,45,50,55,0 * * * * python /home/pi/cwbeacon/beacon.py -c 20 hello world
You've just created a crontab schedule.

What the above means is that every 5 minutes (on the 5, then the 10, then the 15, and so on) the RPi will tap a CW message of "hello world" out to GPIO26. And it will do this indefinitely.

So for your final version, you'll obviously replace "hello world" with your callsign and all that stuff.

***

To wrap up, I really like this one. It's a proper, clean, decent way to create The Signal with a raspberry pi. It's also extremely easy on resources, meaning you can get away with using a bare-bones and cheap Raspberry Pi zero for this.

[737999]

Hello internet,

Like usual, about the only way I know how to do things is to first do the wrong thing many, many, times, along with a lot of swearing. So I bought a breadboard kit from Amazon, and started plugging in wires. So I commenced plugging, and my 3 year old learned some new words...

Anyway, I'll save you the trial and error, and just skip to the end result: A contraption that will take your Rpi signal from the GPIO26 pin, and pulse it out to a 3.5mm male TRS jack. Behold this beauty:






This is my best attempt at drawing/explaining something in plain english for the non-radio and electric engineering types. For you smart radio people/engineers, feel free to laugh at my expense. For reference, it took me about 4 hours of random plugging/unplugging wires and googling to figure this out. (I hope it's correct.) Total cost is probably $4 if I had to guess? A transistor, two resistors, some wire, and a 3.5mm jack.

One question I did have was whether or not the orientation of the BC458 transistor matters. I built this contraption with the visible text on the BC458 facing me, so I included that in my drawing. No clue if this matters or not, but it's what I did.

Anyway, best I can tell is that when the RPi starts pulsing a beacon signal out on GPIO 26 (Reference GerryK's "cwbeacon" python program I edited above.) that signal goes out to the TRS 3.5mm plug with about ~1 volts. I think that's safe.

Normally this is the part where I'd hook it up to the Pixie and give it a shot, but the Pixie hasn't arrived yet. Oh well. It will give me some time to build a ghetto keyer out of some automotive wire and plywood.

I'd like to attach a photo here just in case imgur decides to nuke itself in the future a'la photobucket, but I don't know how to do this. Is there a way to hard-attach an image on this forum?

[737999]

I know I've been a bit cheeky with my replies, so I'll try and be a bit more serious.

I don't disagree that soldering is the way to go. I do, in fact, have a soldering iron, and can make ugly connections. The trouble I find is that the electronics, and radio world especially, makes stuff out to be overly complicated. There is no "explain it like I'm 5 years old" anywhere in the how-to's or youtube videos or forums. And that's fine when you're dealing with smart, skilled people. But for total newbs (like me) it's incredibly frustrating.

So when someone is told "You need to know how to solder, or just don't even bother doing anything ever" I believe it sends the wrong message.

My intention with this thread is to show that you can piece together a piece of kit with some basic wires, a RPi or Arduino, and some electrical tape. Is it the best or most robust way to do this? No it sure isn't. But will it work for a simple beacon project? Yes.

Indeed. Electronics is held together with solder. If you can't solder then learn, it's no more difficult, infact it's easier than rubbing two sticks together!

Get a scope too!

2 things electronics demands, good soldering skills and a scope.

Engineers have to learn new skills everyday. Part of the fun, learning and saving money too!

Str.

[Stretchyman]

Oh dear, no one is saying don't do it but you've gone about it the most complex way imaginable. Could be put together with literally 3 components and some solder!!

Practice makes perfect and most soldering irons are crap. I only use METCAL and only use SMT and a produced PCB makes things very simple.

Please carry on and report your findings. I can only offer sane advice as it's all I know in my job, hobby & career for 40+ years.

I can't write SW and have to get others to do that for me but the benefit of that is they get paid and I get exactly what I want!

Have fun bud.

Keep it coming.

Str

[737999]

Seeing as this thread is about figuring out ways to make the end result work, maybe I could trouble you to expand on one of your earlier comments:

You only need 3 parts (components)

PIC+OSC+CLASSE PA.

I don't know what those are, so if you'd be open to humouring me and expanding on this, I'm all for it.

Oh dear, no one is saying don't do it but you've gone about it the most complex way imaginable. Could be put together with literally 3 components and some solder!!

Practice makes perfect and most soldering irons are crap. I only use METCAL and only use SMT and a produced PCB makes things very simple.

Please carry on and report your findings. I can only offer sane advice as it's all I know in my job, hobby & career for 40+ years.

I can't write SW and have to get others to do that for me but the benefit of that is they get paid and I get exactly what I want!

Have fun bud.

Keep it coming.

Str

[Stretchyman]

Sure thing ..

PIC is a microchip, this will will take care of all the timings and control of the transmitter.

OSC is the oscillator. Cardinal make programmable ones as do others, takes care of frequency generation and gives a strong 5V squarewave output.

CLASS E PA is the simple and efficient amplifier to generate up as much as 10W with 12V but can, of course be much less seeing as this is a beacon.

You may need a driver between the OSC and PA as this could be switched by the PIC to give CW.

I would expect the whole circuit to cost about $10.

I'd also add a LiPo charge controller, solar charging etc again all controlled by by the PIC.

That's about it!

Str

[Stretchyman]

Further to my ramblings.....

Using a PIC or Attiny with built in clock etc.

Processor in deep sleep.

Wakes up every xx mins

Enables OSC, delay whilst settles.

Enables PA.

Applies modulation.

Goes to sleep.

Something like that...

Str.

[737999]

Hello internet,

I've been poking away at a few things this week, and figured I'd do a post on how to build an antenna for your beacon. Now before you start thinking "Oh man, here comes a bunch of technical engineering jargon," this isn't one of those posts. I'll show you how to build an antenna, from scratch, in under 5 min, and you don't need to know anything about radios or electronics to do the build.

Materials

Here's what you need:

-- 100ft speaker wire
-- Zip ties
-- BNC-to-Binding Post connector (also called "Banana connector")
-- Tape measure
-- Sharpie
-- Beverage





Length
This will be a 40m dipole antenna, specifically cut/tuned for around 7.023mhz. This means the whole antenna will be 66' 7 11/16", with each leg of the dipole measuring 33' 3 13/16". How do I know this? Cause there's apps out there that calculate the science for you, so I used one. Punch in your frequency and antenna type into the app, and pow. Easy.

Building

-- Take the end of your speaker wire, and tie a Figure 8 knot in the end of it.

-- Measure out 33' 3 13/16" of speaker wire, starting from the inside of the Figure 8 knot you just tied.

-- Once you get to 33' 3 13/16", snug up two zip ties right at that measurement. (Do them super tight.)



-- Untie the Figure 8, and split the ends of the wire all the way down to the zip ties.



-- You now have two loose wires. Tie new Figure 8's into each end.


-- Thread a zip tie loop through each Figure 8. (These zip tie loops are called "isolators")





-- Find the other end of the wire (the part that you didn't split) and split about 4". Strip a bit of insulation off the ends so you have bare wires.

-- Unthread the red/black connectors on the BNC/Post connector, and stick the stripped ends of the speaker wire into the red/black terminals. Then tighten the connectors.




-- Done.



Congratulations. You're now finished and you have a 40m antenna. Go enjoy that beverage.

***

Building this took me all of 5 minutes, and that was with taking pictures. You can probably do it in 3 min. You now have an antenna ready to go for your beacon.

"But but but but ... SWR!" Sure, it's already handled. But to see for yourself, here's what the meter said after I hung up the dipole in an NVIS setup (Hung from my fence at about 5.5ft high, parallel with the ground.)



Should work okay for my purposes. But don't just take my word for it. Here's one of the many youtube dudes who've already done this, and had success.

https://www.youtube.com/watch?v=sSMDazjkuUk