A Tangible Artifact
Lots of boards headed my way
As Project Yamhill nears actual physical implementation, it’s time to start building some more real-time, two-way communication. If you’d like to participate in Project Yamhill chat, please click on the link below. Thank you!
I got a nice fire lit under my butt immediately after my last post on this newsletter. I immediately dove into the work in KiCad needed to send all of the first tranche of Project Yamhill PCBs off to fabrication, along with a couple of extra projects, the Party Line 80 transceiver and a brand new, cheap and cheerful CW memory keyer, which I’m calling EtherKeyer Mini. I was able to convert the Project Yamhill Front Panel to a 4-layer PCB a bit quicker than I expected. I’m not sure if that’s a good thing or a bad thing. I did relentlessly run the design rules checker tool over and over until I felt that I had done everything reasonably possible to ensure it was going to work.
Below you can see an image of the board after this rework. The digital ground and 3.3 V power planes were added as the two inner layers, and after that it was a mostly a matter of removing those planes/traces from the two outer layers, then reconnecting all of those component connections to the inner layers via vias. I feel kind of stupid for not immediately starting out with the 4-layer process, as it also gave me much tighter clearances to work with, which were needed around the small-pitched Si5351C in QFN package that is used on this board.
Once that was complete, I generated Gerbers for each board, and then reviewed them in gerbview for a final check before sending the whole batch off to JLCPCB. It’s been a few years since I’ve had PCBs fabricated, and I wanted to mention that so far working with JLCPCB has been fantastic. Their web interface is very easy to navigate, and they actually give you very fine-grained details on the production status of each of your boards while they are in process. I’m not sponsored or paid by them, just wanted to mention my current satisfaction with them.
I was able to get my order in last Thursday evening, and it was very quickly approved for production and fabrication started. I was a little surprised that the 4-layer front panel board passed muster on the first go, but I guess that shows that I set up my DRC rules correctly. I got notification last night that production was already finished and that my order was shipped out. I paid a bit extra for relatively speedy shipping, so it looks like there’s a chance that I’ll have boards in hand by Friday! That’s around 9 days from submission to finished product on my bench. Impressive.
With this portion of Project Yamhill in a slight holding pattern, I needed something to keep my busy. So I turned to coding the firmware for EtherKeyer Mini.
EtherKeyer Mini
So what’s the impetus behind this project? I recently created the Party Line 80 CW transceiver, which is very old-school and has no integrated circuits in it. So on its own, you’ve got to use a straight key to operate it. However, as fond as I am of straight keys, even I will want to use it with a paddle and keyer quite often. I do have a Idiom Press CMOS-4 keyer that I can use, but in looking at future plans, I wanted to develop my own keyer, since there are a lot of potential future products that will need that functionality. The most obvious one being Project Yamhill. Well, I won’t need a new keyer design itself for that, but the code that I develop for a keyer will be easily ported to Project Yamhill.
It occurred to me that it would be nice to have a cheap and simple keyer in a DIP-8 package that I could put into a standalone keyer, as well as integrate into other simple transceivers in the future. This is definitely not a new idea by any means, but I’ve been wanting to execute my own version of this for a while, using my own code.
Slipping back into KiCad for an evening with a basic idea and the goal to crank out a design came easier than I thought. I settled on an old friend for the microcontroller: the ATtiny85. I figured that it had just enough resources on-board to do the basic keyer functions that I wanted. Given this choice, the rest of the design flowed pretty naturally.
Every I/O available on the ATtiny85 was utilized. The paddle input lines are shared with the UART interface, which allows me to squeeze serial port functionality onto the keyer, but only when the keyer is placed into a specific mode to do so. The message memory buttons are placed on the RESET pin, which happens to have an ADC input on it. This means that I can place a variety of buttons in voltage divider configuration on this pin, as long as none of them will bring the RESET line below the reset voltage threshold. Real-life experience has informed me that it’s important to be able to easily and quickly change the keying speed so that you can QRS if necessary, so the keyer speed is controlled on the front panel by a potentiometer.
EtherKeyer Mini can be powered via the UART interface (it’s meant to be connected to a UART bridge board such as a CP210X) but its main power source is a CR2032 coin cell on the underside of the PCB. Basic switching circuitry has been included so that the +5V rail from the UART can be connected to the board while the coin cell is installed. Utilizing sleep mode in the ATtiny85 should allow the single coin cell to run the keyer for quite a long time, without need for a power switch.
The ATtiny85 has an Urboot bootloader installed so that it’s easy and fast for me to write code in Arduino IDE and then upload it via command line (unfortunately, the ATTinyCore doesn’t support this bootloader yet, but I’m hoping it will in the near future). Users will also find it pretty easy to tweak and update the firmware on their own boards, if they so desire.
While I’m waiting on the circuit boards to arrive, I’ve breadboarded the circuit so that I can confirm that it works as expected, and so that I can get a head-start on the coding. Over the weekend, I was able to knock out nearly all of the functions for EtherKeyer Mini. Keying via paddles works as I would expect, and the speed knob does the job exactly as I would expect. Three non-volatile message memories are available for playback via button press, and can be set via the UART interface. Message playback can be canceled by pressing any of the buttons or a paddle input. Here’s a quick video showing you the keyer in basic operation, used in conjunction with my Twin-T code practice oscillator:
If you’re interested in the Twin-T CPO seen in the above video and could use it to help train others in Morse Code, contact me and I can send you one to try out for cheap.
I created my keyer code basically from first principles, without relying on someone else’s code. I did leverage my own Etherkit Morse library for the message playback, but the live keying code is all new.
What’s Next
Next up will be a significant update. I should have all of the PCBs in hand by then, and will start working on building them up and testing them. I’m not sure which order I will go in, but I’ll probably first build up a Power Distribution module and then start working on getting the front panel up and running. That’s the only one that I’m really concerned about, since it’s so complex. The other modules should be fairly straightforward, and I’ll check those out in the coming weeks.
I also plan to design an enclosure for EtherKeyer Mini for printing on my FDM printer, so I may tackle that this upcoming week while I’m waiting for my boards to get here. Once I get that design nailed down, I will be doing the same for Party Line 80. The two projects should make a nice pair.