The Lost Art of Tree Fishing

Now that the Northeast seems to have finally shaken off the icy grip of winter, I've taken the first reluctant steps outside of my cave to engage in some outdoor activities. This week I found myself "tree fishing" - which is my self-coined euphemism for hanging a random wire style antenna in one of my backyard trees to use for ham radio communications. This process involved me, standing outside and hurling a spool of bright yellow fishing line into the tree, over and over again, until I managed to toss it over a branch of sufficient height. I then attached some thin nylon rope to the line and pulled it over the branch, finally completing the process by securing 29 feet of suitable wire to the rope and hoisting that up into the air. The antenna was connected to a 9:1 UnUn transformer, which I housed in a water proof box mounted on some stockade fence a short distance from the tree. The UnUn also has connections on the box for a ground wire - which is running across the yard perpendicular from the antenna and a RG58 coax which is running up to the second floor office where it is connected to a 20 watt Xiegu G90 HF transceiver. This configuration works fairly well with bands 10 - 40 meters, and I had great success hearing stations as far away as Ireland and Scotland on 20 meters. I'll probably keep this up as a temporary HF solution through the summer while I figure out a more permanent installation for the fall.

 

My Neighbors must have been scratching their heads to see me flinging a spool of fishing line up into the tree over and over again. We finally managed to get the antenna hung from a reasonable height. 

 

The Xiegu G90. A surprisingly capable low-watt HF transceiver. Now if only 10 meters would open up!

 

 

 

-=CYBERDECKS=- (and why build one?)

A cyberdeck is a personal, portable computer inspired by classic cyberpunk fiction—think Neuromancer, Ghost in the Shell, or Blade Runner. Unlike a laptop or phone, a cyberdeck is usually hand-built, customized, and unapologetically weird. It might live in a Pelican case, a 3D-printed shell, or a hacked-together metal box, often featuring a small screen, mechanical keyboard, exposed wiring, and blinking LEDs. Under the hood, it’s commonly powered by a Raspberry Pi or similar single-board computer, running Linux and whatever tools the builder finds interesting.

People build cyberdecks not because they’re practical, but because they’re personal. A cyberdeck is a rejection of sealed, disposable technology in favor of something tactile, understandable, and modular. Building one is a way to learn about Linux, electronics, networking, radio, programming, and hardware—all while making something that feels like it came out of science fiction. 

 

I built my cyberdeck with a spare Raspberry Pi 3B+ board I had lying around, running Raspberry Pi Lite OS. I extended 2 of the USB ports and the ethernet port out to the main panel, which is made of ABS plastic, cut to fit into the opening on a Pelican 1300 case. My plan is to use this machine for software development, networking experiments, and maybe some software defined radio experimentation (more on that to come).

 

To give the Deck more cyberpunk street cred, I slapped a sweet "Legalize Recreational Plutonium" on the side. My plan is to expand the functionality of this unit over time. Some enhancements I'm considering include some blinking LEDs (maybe to give a visual indication of wi-fi strength or some other signal), adding an Arduino to the mix, and creating a custom speaker/antenna mount to handle software defined radio stuff.

Building a tiny Lisp interpreter with C++

I made a very simple Lisp interpreter using C++. I decided to focus on Lisp after a failed experience of trying to write a tiny BASIC interpreter for a cyberdeck build I'm working on putting together. I ended up shifting to Lisp for a variety of reasons. It is an interpreted language, meaning it relies on a program to act as a sort of middle man to execute the code versus compiling it to machine language. It also is one of the oldest computer languages with an extremely simple syntax. I decided to use C++ rather than Python for this task. C++ runs extremely fast compared to Python (which is also an interpreted language), and interpreters really require that speed provided by the program running as native machine code. This project could have been done using Python, but my guess is that running the program would have suffered from the increased headroom necessary of running in interpreter within an interpreter.

The interpreter is very basic by any standard. It currently can process the following mathematical operations: addition, subtraction, multiplication, division, absolute value, square root, and calculating powers. It can define and set variables, as well as print both numbers and strings to the console. It can handle floating point numbers. Essentially, it's an extremely simple programmable calculator!

So what did I learn from this? The first thing is, under the hood, there is nothing basic about BASIC. I was shocked at how challenging it is to write a simple interpreter for such as simple language. The second is the robustness and honestly the beauty of Lisp. The language, even in it's extremely simplified form is a joy to work with. I've always thought that there is magic to be found when working with limitations, and while Lisp seems to be extremely limited compared to more modern interpreted languages like Python, the structure of the language lends itself to some really creative solutions. 

Here is an example of code that runs in my interpreter to solve quadratic equations:

> (define a 1)
=> 1
> (define b -5)
=> -5
> (define c 6)
=> 6
> (define discriminant (- (* b b) (* 4 (* a c))))
=> 1
> (define x1 (/ (+ (- 0 b) (sqrt discriminant)) (* 2 a)))
=> 3
> (define x2 (/ (- (- 0 b) (sqrt discriminant)) (* 2 a)))
=> 2
> (print "Solutions: x1 =" x1 ", x2 =" x2)
Solutions: x1 = 3 , x2 = 2

 Below is a video of me running a demo of the interpreter to show the basic syntax for some of the operations and showing how to set up a simple program that converts Celsius to Fahrenheit.

 

The robotic voice in the video was created by a separate program I built with Python that converts text to speech and then saves the output as a .WAV file. Still working out some of the kinks with that, but it's fine for now.

 

Housing a Linux computer inside a broken Atari 2600 cartridge

 I started thinking pretty soon after completing the custom cable channel project of housing a Raspberry Pi UNO into a repurposed cable box from the 1980s about other novel and interesting ideas to house single board computers. I recently was tidying up my work space and my eyes fell on a stack of Atari 2600 cartridges that failed to boot when testing them. It was during the process of taking the casing for a fairly grimy copy of Surround apart it dawned on me that these cases are the perfect size to house a Raspberry Pi Zero W, which I happened to have a couple just sitting on the desk mocking me for not using them.

The first stage was to completely disassemble the old cartridge, which honestly is a bit more challenging than it probably should be. I got pretty lucky removing the original labels, so I was able to reuse them after everything is assemble. There is only 1 phillips head screw to remove, but there are 6 plastic clips which require you to deal with before the casing will come apart. I used a small sized slotted screwdriver to carefully push the clips in and manage to get the thing apart, but I could definitely see people breaking the tabs and/or scarring up the plastic of the cartridge while trying to get these things disengaged. After that it's pretty straightforward. The dust cover assembly slides out, and nothing is holding the game ROM in place. I opted to save my ROM, since I'm still going to see if I can rehab the pins to check if it might actually boot after a good scrubbing.

The next step was to hot glue the offsets in place inside the cartridge to mount the Raspberry Pi. I decided to run a very bare bones distro of the Raspberry Pi OS Lite (32-bit) which comes with no desktop. My goal here is a totally basic Linux system hidden inside an old Atari cartridge. Maybe I'll install Stella or some other 2600 emulator on it at some point - I imagine it would be pretty cool to play 2600 games on a computer housed inside an actually 2600 game.

After testing to make sure everything worked, I reassemble the case and glued the orginal labels back into place. Since the Pi Zero W uses 2 micro USB connections (one for USB stuff and one to power the board) I decided to put a red dot of paint underneath the power connection, since you can't easily read the board to prevent me from inadvertently mixing up the connections.

 Fun project that was totally a spontaneous use of time that I should have allocated to doing something else. 

Zarphield Says...

While grappling with the daily existential crisis that modern life has devolved into, I wrote an app in Python that sits on my desktop and spits out a fusion of quotes by 80's cat icon Garfield and swinging space pirate Zaphod Beeblebrox. This is Zarphield. Feed him lasagna, Earth man.

 

Psuedo Spectrum Analyzer

Earlier this year I acquired two Elegoo MEGA2560 kits through Facebook market place. These kits are excellent entry points into the Arduino maker space. They come with boards and enough components and modules to keep the average nerd busy for awhile. Lately I've been looking at some of the modules that I didn't have strong thoughts on what to utilize them for and have started brainstorming ideas build some unique things. One of the modules in particular, the sound sensor module, got my attention. This module has a built in microphone and can be used for a variety of applications, such as a sound activated trigger or to capture audio for processing. After reading up on the module (this is one of the odd ball modules included in the kit that doesn't have a readily available board number associated with it), I decided to pair it with an old favorite of mine, the MAX7219 8x8 LED display. I used the MAX7219 to great effect in the cable box I built a couple of weeks ago and I love this one, in particular because it's super easy to get it working with an Arduino board and looks super cool in action. My goal was to create a sort of "spectrum analyzer" like you might see in older hi-fi stereo equipment racks. When I was a kid I had a spectrum analyzer program that I ran on my beloved Tandy Color Computer 2 that accepted input via a set of stereo RCA cables and displayed a dancing set of colorful bars that pulsed to the audio it was fed. This version would be much simpler. I would use the microphone from the sound sensor to listen for audio from the room it was setup in, and process the audio via a UNO R3 board, segmenting the sound into degrees of volume, and then display these lines of differing audio strength signals on the MAX7219.

 

Wiring up the components (the sound sensor and the MAX7219 display) was very straightforward. Both components are labeled clearly which pins do what (i.e. VCC, ground, etc.) unlike a couple of modules I've encountered in these kits (looking squarely at you DHT11 Temperature and Humidity Module). One everything was wired up it really was just a matter of getting the sketch pulled together to get the setup to capture the audio, "rank" the volume levels, and then display the results in an understandable way. There are essentially 6 steps in this process:

1. Read sound from microphone.

The sound sensor outputs and analog voltage that changes with the sound. It can output digital, but I ran into some issues getting that to reliably be read, so I opted for the easy route with analog output. The sound ranges in value from 0-1023.

 int raw = analogRead(micPin);

2. Compare the sound to a dynamic baseline.

A baseline is used to represent the normal quite noise in the room. This gives us the difference between the current sound and the background. The sketch allows the baseline to adapt over time, which keeps the analyzer stable, even if the room becomes noiser over time.

 int diff = abs(raw - baseline);

baseline = (baseline * 98 + raw * 2) / 100; 

3. Convert sound level into bar height.

The difference is scale into a value from 0-8, matching the height of the MAX7219's 8x8 matrix.

int level = diff / 8; 

4. Scroll the display to the left.

The entire display is shifted one column to the left. This is meant to mimic the way a real spectrum analyzer scrolls over time.

 scrollLeft();

5. Draw the new bar on the right side.

The new sound level becomes a vertical bar in the far right column. Each LED row is turned on or off depending on the bar height.

 drawColumn(level);

6. Update and refresh the MAX7219 display.

The display is updated all at once for a smooth animation.

 matrix.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON);

Results 

The result is a series of bars of different heights, continually scrolling to the left, with the bar height continually reacting to the volume of the sound it picks up. I can't really call this an actual spectrum analyzer, since there is only one sensor monitoring the room and not a series devoted to the various frequencies across the audio spectrum, but it still looks pretty cool. 

 

Low-Powered FM Radio Transmitter with an Arduino and Si4713

Arduino boards are fantastic and versatile for constructing a wide range of electronics projects. One of the greatest strengths are the abundance of electronic modules that are available to add project specific functionality. I picked up a Si4713 board awhile back and decided to spend some time setting it up with an Arduino to see if I could get a functional low-powered FM transmitter running. The Si4713 boards are easy to come by and relatively cheap (I think I paid well under $20 including shipping for mine from a seller on ebay), and have minimal work required to get them hooked up. They come with headers that will need to be soldered onto the board and a very thin wire that is meant to serve as an antenna (which will also need to be soldered to the board). 

The wiring between the Si4713 and the Arduino (I used an Elegoo Mega 2560 R3 I had lying around for this project) is as follows. Adjust the wiring and code as necessary depending on the model of the Arduino you use and your preferences for the reset pin.

Wiring:

VIN

-

5V

GND

-

GND

SDA

-

SDA (Pin 20)

SCL

-

SCL (Pin 21)

RST

-

Pin 2

GPIO1

Optional (RDS interrupt)

leave unconnected unless needed

You will need to install the following Adafruit libraries for the board to work: 

Adafruit_Si4713 Library

Adafruit_BusIO

Adafruit_GFX (if you want to later display station info)

I tried a couple variations on getting a functional sketch. I finally figured out that a persistent problem I was having involved the reset pin not properly resetting after the Mega has been disconnected from the power source and then rebooted. Modifying the sketch to allow for a delay to allow the pin to reset properly seemed to correct this. The updated sketch is below:

#include <Wire.h>
#include <Adafruit_Si4713.h>

#define RESET_PIN 2 // match whatever wiring you selected
Adafruit_Si4713 radio(RESET_PIN);

void setup() {
  Serial.begin(115200);
  delay(500);             // time for power to stabilise
  pinMode(RESET_PIN, OUTPUT);

  // Toggle reset: LOW -> HIGH with pauses
  digitalWrite(RESET_PIN, LOW);
  delay(50);
  digitalWrite(RESET_PIN, HIGH);
  delay(200);

  Wire.begin();
  Serial.println("Attempting to find Si4713...");

  if (!radio.begin()) {
    Serial.println("Couldn't find Si4713");
    while (1) {
      delay(500);
      Serial.println("Retrying...");
      if (radio.begin()) {
        Serial.println("Found Si4713 on retry!");
        break;
      }
    }
  }

  Serial.println("Si4713 found!");
  radio.tuneFM(10110);
  radio.setTXpower(88);
}
void loop(){}

After I verified that the transmitter was operational, I decided I needed something cool to transmit. One of my first exposures to short wave radio was listening to "numbers stations", which are famously mysterious stations that broadcast cryptic messages. I fired up Garageband and recorded some esoteric sounding number station inspired audio ala' "Stranger Things" that I could endlessly loop on my station. I grabbed a receiver capable of tuning in FM and dialed up my frequency. I don't have to tell you how cool it was to hear my message looping over the radio! I did some proximity testing, moving the radio around the room and it seems like the effective transmission distance using the basic thin wire antenna provided with the Si4713 is about 15 feet. I believe I could improve the distance by building a better antenna, such as an optimized quarter-wave antenna - which might possibly extend the reach a bit more (maybe 25-30 feet).

Some future enhancements to this little radio station I can envision include: building a better antenna, fitting everything into a suitable enclosure, and adding an old ipad shuffle for audio to make this a truly mobile radio station.