The Ramblings of ZL1CLH

So I updated it to make it more robust.
I have added Userbits for the Date

Please note this is 25frames per second, I am sure you could modify it for other standards, but I do not need it for anything other than 25Frames per second to drive a time code clock.

This was the .wav file taken from the generation of this code, put into an independent analyzer and you can see 0.040ms differences between each frame, for the full minute of decode, including

• The parsed SMPTE ST 309 date payload.
• The standard SMPTE 12M Time Address tracking in standard broadcast formatting.
• The absolute audio sample index within your audio stream where this specific timecode frame’s biphase wave begins.
• The absolute audio sample index where this specific timecode frame’s biphase wave ends.
• The Window Start Timestamp
• The Window End Timestamp

(Updated Code : 15-06-2026 to remove the sync every 60 seconds, after running if for 2 days, noticed drifting in time, made other frame sync modifications as well)

I have a Leitch Studio Wall Clock and really wanted to get it working properly and usefully.
So with the help of Gemini – I coded up this little bit to get SMPTE timecode generated from the sound card, the code syncs every minute to the PC time to keep the generator in sync, and with the PTP Grandmaster clock locking an NTP server to nanosecond accuracy at home, I have pretty good time keeping on that NTP server for this clock.

Also now, with the update code, it will display the date (DD MM YY 00) in the Userbits if you can decode them.

This clock does not take PTP but can take 1PPS inpulses or SMTP time code.
This is a bit of a Gemini hack to create the timecode – it jams the generator ever 60 seconds, and if you put the timezone in correctly, should take into account Daylight Savings and so forth.

When running correctly it should display this on the terminal

Package Requirements : gcc libasound2-dev libltc-dev

Debian / Ubuntu : sudo apt update sudo apt install gcc libasound2-dev libltc-dev

File : /etc/ltc_master.conf

# /etc/ltc_master.conf
# Set your local operating system timezone identifier
timezone = Pacific/Auckland 
# ALSA audio hardware address to stream audio out of ("hw:0,0" or "null") 
audio_device = hw:0,0  

File : ltc_master.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <alsa/asoundlib.h>
#include <ltc.h>

#define SAMPLE_RATE 48000
#define FPS          25
#define CONFIG_PATH "/etc/ltc_master.conf"

static char tz_setting[128] = "Pacific/Auckland";
static char device_name[128] = "hw:0,0";
static int null_device_mode = 0;
static int rotation_test_mode = 0;

static int hours = 0;
static int minutes = 0;
static int seconds = 0;
static int frame = 0;

// Dynamic tracking variables for the current date payload
static int ui_day = 1;
static int ui_month = 1;
static int ui_year = 2026;

// Track the previous playout second to detect structural transitions (like midnight)
static int prev_playout_day = -1;

// Toggle state tracking for the 'H' halt feature
static int timecode_halted = 0;

// Shared buffers for raw OS diagnostics
static char raw_os_time[32] = "00:00:00.000";

// Non-blocking keyboard state polling helper
static int kbhit(void) {
    struct termios oldt, newt;
    int ch;
    int oldf;
    tcgetattr(STDIN_FILENO, &oldt);
    newt = oldt;
    newt.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
    ch = getchar();
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
    fcntl(STDIN_FILENO, F_SETFL, oldf);
    if(ch != EOF) {
        ungetc(ch, stdin);
        return 1;
    }
    return 0;
}

static void load_config_file() {
    FILE *fp = fopen(CONFIG_PATH, "r");
    if (!fp) {
        printf("Notice: Missing %s. Defaulting to Pacific/Auckland on hw:0,0\n", CONFIG_PATH);
        sleep(2);
        return;
    }

    char line[256];
    while (fgets(line, sizeof(line), fp)) {
        line[strcspn(line, "\r\n")] = 0;
        if (line[0] == '#' || line[0] == '\0' || line[0] == ' ') continue;

        char key[128], val[128];
        if (sscanf(line, "%127[^= ] = %127s", key, val) == 2) {
            if (strcmp(key, "timezone") == 0) {
                strncpy(tz_setting, val, sizeof(tz_setting) - 1);
            } else if (strcmp(key, "audio_device") == 0) {
                strncpy(device_name, val, sizeof(device_name) - 1);
                if (strcasecmp(device_name, "null") == 0) {
                    null_device_mode = 1;
                }
            }
        }
    }
    fclose(fp);

    setenv("TZ", tz_setting, 1);
    tzset();
}

// updates in-place using a carriage return to prevent console cluttering
static void draw_status(uint32_t user_bits) {
    static int last_sec = -1;

    if (seconds == last_sec)
        return;

    last_sec = seconds;

    // \r pulls the cursor back to the start of the line; \033[K clears any trailing junk
    printf("\r%02d:%02d:%02d:%02d | UB=%08X | OS=%s\033[K",
           hours, minutes, seconds, frame, user_bits, raw_os_time);
    fflush(stdout);
}

int main(int argc, char **argv) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--test") == 0) {
            rotation_test_mode = 1;
        }
    }

    load_config_file();

    struct timespec ts_init;
    struct tm tm_init;
    clock_gettime(CLOCK_REALTIME, &ts_init);
    localtime_r(&ts_init.tv_sec, &tm_init);

    ui_day   = tm_init.tm_mday;
    ui_month = tm_init.tm_mon + 1;
    ui_year  = 1900 + tm_init.tm_year;

    printf("\033[2J\033[H");
    printf("==================================================\n");
    printf("          LTC MASTER STARTUP PARAMETERS\n");
    printf("==================================================\n\n");
    printf("Notice: Press [ENTER] directly to utilize the current OS System Date.\n\n");

    char input_buf[64];

    printf("Enter Base Day (1-31) [%02d]: ", ui_day);
    if (fgets(input_buf, sizeof(input_buf), stdin) && input_buf[0] != '\n') {
        ui_day = atoi(input_buf);
    }

    printf("Enter Base Month (1-12) [%02d]: ", ui_month);
    if (fgets(input_buf, sizeof(input_buf), stdin) && input_buf[0] != '\n') {
        ui_month = atoi(input_buf);
    }

    printf("Enter Base Year (4-digit) [%04d]: ", ui_year);
    if (fgets(input_buf, sizeof(input_buf), stdin) && input_buf[0] != '\n') {
        ui_year = atoi(input_buf);
    }

    printf("\nApplying configurations... Initializing audio layer buffers.\n");
    sleep(1);
    printf("\033[2J");

    snd_pcm_t *pcm = NULL;
    snd_pcm_status_t *status = NULL;

    if (!null_device_mode) {
        if (snd_pcm_open(&pcm, device_name, SND_PCM_STREAM_PLAYBACK, 0) < 0) {
            fprintf(stderr, "ALSA target device '%s' open failed.\n", device_name);
            return 1;
        }
        if (snd_pcm_set_params(pcm, SND_PCM_FORMAT_S16_LE, SND_PCM_ACCESS_RW_INTERLEAVED, 2, SAMPLE_RATE, 1, 20000) < 0) {
            fprintf(stderr, "ALSA configuration failed\n");
            if (pcm) snd_pcm_close(pcm);
            return 1;
        }
        snd_pcm_status_alloca(&status);
    }

    LTCEncoder *enc = ltc_encoder_create(SAMPLE_RATE, FPS, LTC_TV_625_50, 0);
    ltc_encoder_set_filter(enc, 0.0);

    // Max sample size allocation buffer payload to accommodate 1921 shifts cleanly
    size_t ltc_max_alloc_size = ltc_encoder_get_buffersize(enc) + 16;
    ltcsnd_sample_t *ltc_buf = malloc(ltc_max_alloc_size * sizeof(ltcsnd_sample_t));
    int16_t *audio = malloc(ltc_max_alloc_size * 2 * sizeof(int16_t));

    if (!ltc_buf || !audio) {
        fprintf(stderr, "Buffer allocation failed\n");
        if (pcm) snd_pcm_close(pcm);
        return 1;
    }

    struct timespec ts_trigger;
    struct timespec ts_hardware;
    struct tm tm_playout;
    struct tm tm_raw_os;
    SMPTETimecode tc;

    int last_sec = -1;
    int last_frame = -1;
    const long frame_duration_ns = 1000000000L / FPS; // 40,000,000 ns per frame

    struct timespec ts_halt_anchor = {0, 0};
    long long accumulated_halt_ns = 0;

    while (1) {
        if (kbhit()) {
            int ch = getchar();
            if (ch == 'H') {
                timecode_halted = !timecode_halted;
                if (timecode_halted) {
                    clock_gettime(CLOCK_REALTIME, &ts_halt_anchor);
                } else {
                    struct timespec ts_resume;
                    clock_gettime(CLOCK_REALTIME, &ts_resume);
                    long long diff_ns = (ts_resume.tv_sec - ts_halt_anchor.tv_sec) * 1000000000LL +
                                        (ts_resume.tv_nsec - ts_halt_anchor.tv_nsec);
                    accumulated_halt_ns += diff_ns;
                }
            }
        }

        // 1. Capture Raw Time Execution Anchor
        clock_gettime(CLOCK_REALTIME, &ts_trigger);
        localtime_r(&ts_trigger.tv_sec, &tm_raw_os);
        snprintf(raw_os_time, sizeof(raw_os_time), "%02d:%02d:%02d.%03ld",
                 tm_raw_os.tm_hour, tm_raw_os.tm_min, tm_raw_os.tm_sec, ts_trigger.tv_nsec / 1000000L);

        snd_pcm_sframes_t delay_frames = 0;
        ts_hardware = ts_trigger;

        // 2. High-Grade Hardware Status Query
        if (!null_device_mode && pcm) {
            if (snd_pcm_status(pcm, status) == 0) {
                delay_frames = snd_pcm_status_get_delay(status);
                snd_pcm_status_get_htstamp(status, &ts_hardware);

                if (ts_hardware.tv_sec == 0) {
                    ts_hardware = ts_trigger;
                }
                if (delay_frames < 0) {
                    delay_frames = 0;
                }
            }
        }

        // 3. Compensation Correction (+n Frame Shift) using live dynamic buffer sizing metrics
        size_t live_frame_buffer_size = ltc_encoder_get_buffersize(enc);
        long long projected_delay_frames = (long long)delay_frames + (long long)live_frame_buffer_size;
        long long delay_ns = (projected_delay_frames * 1000000000LL) / SAMPLE_RATE;

        long long total_ns;
        time_t playout_sec;
        long playout_nsec;

        if (timecode_halted) {
            long long static_ns = (ts_halt_anchor.tv_sec * 1000000000LL + ts_halt_anchor.tv_nsec) - accumulated_halt_ns + delay_ns;
            playout_sec = (time_t)(static_ns / 1000000000LL);
            playout_nsec = (long)(static_ns % 1000000000LL);
        } else {
            total_ns = ts_hardware.tv_nsec + delay_ns - (accumulated_halt_ns % 1000000000LL);
            playout_sec = ts_hardware.tv_sec + (ts_hardware.tv_nsec + delay_ns - accumulated_halt_ns) / 1000000000LL;
            playout_nsec = (long)(total_ns % 1000000000LL);
            if (playout_nsec < 0) {
                playout_nsec += 1000000000LL;
                playout_sec -= 1;
            }
        }

        localtime_r(&playout_sec, &tm_playout);

        int target_frame = (int)(playout_nsec / frame_duration_ns);
        if (target_frame >= FPS) target_frame = FPS - 1;

        // 4. Edge Detector Checking Soundcard Buffer States
        if (tm_playout.tm_sec == last_sec && target_frame == last_frame) {
            long ns_into_current_frame = playout_nsec % frame_duration_ns;
            long ns_remaining = frame_duration_ns - ns_into_current_frame;

            useconds_t sleep_us = (useconds_t)(ns_remaining / 1000L);
            if (sleep_us > 10000) sleep_us = 10000;
            if (sleep_us < 500)   sleep_us = 500;

            usleep(sleep_us);
            continue;
        }

        last_sec = tm_playout.tm_sec;
        last_frame = target_frame;

        // 5. Update Structural Global Variables
        hours   = tm_playout.tm_hour;
        minutes = tm_playout.tm_min;
        seconds = tm_playout.tm_sec;
        frame   = target_frame;

        // Detect dynamic calendar transitions (Midnight Rollover Engine)
        if (prev_playout_day != -1 && tm_playout.tm_mday != prev_playout_day && !timecode_halted) {
            ui_day = tm_playout.tm_mday;
            ui_month = tm_playout.tm_mon + 1;
            ui_year = 1900 + tm_playout.tm_year;
        }
        prev_playout_day = tm_playout.tm_mday;

        // 6. SECTION 6: Conditional Testing and Standard Non-Swapped Bit Packing Block
        tc.hours   = hours;
        tc.mins    = minutes;
        tc.secs    = seconds;
        tc.frame   = frame;

        tc.days    = ui_day;
        tc.months  = ui_month;
        tc.years   = ui_year % 100;

        // Form raw BCD values directly from variables set on initialization
        uint8_t bcd_year  = ((tc.years / 10)  << 4) | (tc.years % 10);
        uint8_t bcd_month = ((tc.months / 10) << 4) | (tc.months % 10);
        uint8_t bcd_day   = ((tc.days / 10)   << 4) | (tc.days % 10);
        uint8_t bcd_tz    = 0x00;

        uint32_t user_bits;

        if (rotation_test_mode && (seconds % 2 != 0)) {
            // Pattern B: Shifted layout translation diagnostic test (DD 00 YY MM)
            user_bits = ((uint32_t)bcd_day   << 24) |
                        ((uint32_t)bcd_tz    << 16) |
                        ((uint32_t)bcd_year  <<  8) |
                        (uint32_t)bcd_month;
        } else {
            // Pattern A: Standard specification mapped natively as (00 YY MM DD) [cite: 178]
            user_bits = ((uint32_t)bcd_tz    << 24) |
                        ((uint32_t)bcd_year  << 16) |
                        ((uint32_t)bcd_month <<  8) |
                        (uint32_t)bcd_day;
        }

        // Relocated paint interface loop step here, post-variable definition, to guard compiler scope layout paths
        draw_status(user_bits);

        ltc_encoder_set_timecode(enc, &tc);
        ltc_encoder_set_user_bits(enc, user_bits);

        ltc_encoder_encode_frame(enc);

        // Dynamically accept variable lengths generated by libltc calculation layers
        int n = ltc_encoder_copy_buffer(enc, ltc_buf);

        // 7. Commit to Hardware Buffer Immediately
        if (!null_device_mode) {
            for (int i = 0; i < n; i++) {
                int16_t sample = ((int16_t)ltc_buf[i] - 128) << 8;
                audio[i * 2]     = sample;
                audio[i * 2 + 1] = sample;
            }

            snd_pcm_sframes_t written = snd_pcm_writei(pcm, audio, n);
            if (written < 0) {
                // Adds a leading newline (\n) so the stack trace error doesn't overwrite your clean single-line clock readout
                fprintf(stderr, "\n[ALSA CRITICAL XRUN EXCEPTION] %s at %02d:%02d:%02d:%02d\n",
                        snd_strerror(written), hours, minutes, seconds, frame);
                snd_pcm_prepare(pcm);
            } else if (written != n) {
                fprintf(stderr, "\n[ALSA PARTIAL WRITE EXCEPTION WARNING] Only %ld of %d audio frames written at %02d:%02d:%02d:%02d\n",
                        written, n, hours, minutes, seconds, frame);
            }
        }
    }

    free(ltc_buf);
    free(audio);
    ltc_encoder_free(enc);
    if (pcm) snd_pcm_close(pcm);
    return 0;
}

To Compile execute :   gcc ltc_master.c -o ltc_master -lasound -lltc
To Execute : ./ltc_master

---

So, another year, and another trip to Dayton Ohio for Hamvention.
ZL1RKO and I are doing a bit of a road trip and as well as Hamvention – see some of the US and hopefully get to see some AM towers and other broadcasting related sites around the country.

But when I pulled out the TinyTracker4,what do you know, the EEPROM is no longer accepting updates to the config, this being 2 and a bit weeks out from flying out…. OUCH.

I was looking forward to using APRS VoiceAlert while driving around and trying to meet some other Hams either on their way to Dayton – or just to socialise.

So in a very rushed thought process – decided to dust off the old Direwolf config, and see if I can modify it to do some more interesting things.

My current plan – as at 26 April 2024 – is to get Direwolf to hotspot to the mobile phone while driving – but with a twist.

As I have an iPhone push notifications *have* to go through the Apple Notifications service which is annoying – so I am going to try and get Direwolf to push a notification via Signal Messenger when either the RF or iGate detects someone within 10km of me – or push notification when someone has VoiceAlert but need to investigate that a bit more too.

The advantage of using this system, is I can also get GPSD to log my entire drive so I dont miss anything where iGates are not present.

My intention is update here as I get things working satisfactory – but with only 2 weeks to go, I might be unsuccessful – but hey – gotta give these things a go right..

With more and more people frequenting the annual Table Sales around the North Island, I decided to attempt to keep a calendar up to date with the sale dates, locations, start times and other details of as many table sale and contest weekends as I can.

I am going to try and keep it as up to date as possible, but if I miss one please let me know, zl1clh@hodgetts.geek.nz, and I will include it in the future.

I am going to also try and add contest weekends and other information to this as well – my intention is to attempt to create a ‘Ham Radio Event Calendar’ you can share with your friends, club members or any interested party.

The calendar, which is on the right hand site of this blog looking out for the next 3 events, is available with the following links :

If you want to integrate into your iOS calendar, or other calendar software please use this this link :

ICAL Calendar Link

If you just want to view the calendar just on a webpage, please follow this link :

Web Page Calendar Link

Please note : I take no responsibility for the accuracy of the information contained within the calendar, HOWEVER every effort is made to keep the information accurate and as up to date as possible.
Cancellations or postponements of events, might not filter through to me, so may be missed, and events that always occur on the same weekend every year, is set as a recurring event, and is usually overlooked by me (think Jock White Field Day).

As always – please get in touch if you would like to help out maintaining the information within the calendar, or you find it useful, or have just stumbled across my blog..

73’s – ZL1CLH

Hey, so this is here because I keep losing it on the Internet, and I keep building a new Raspberry Pi every now and then, and the poor fish’s lights don’t get turned on or off automatically anymore..
This code is here, from a git hub repository so I can find it easily again :

#!/usr/bin/perl -w
#
# Based on 
#  http://forums.ninjablocks.com/index.php?
#   p=/discussion/2931/aldi-remote-controlled-power-points-5-july-2014/p1
#  and 
#   http://pastebin.ca/2818088

use strict;
use IO::Socket;
use IO::Select;
use Data::Dumper;

my $port = 10000;

my $fbk_preamble = pack('C*', (0x68,0x64,0x00,0x1e,0x63,0x6c));
my $ctl_preamble = pack('C*', (0x68,0x64,0x00,0x17,0x64,0x63));
my $ctl_on       = pack('C*', (0x00,0x00,0x00,0x00,0x01));
my $ctl_off      = pack('C*', (0x00,0x00,0x00,0x00,0x00));
my $twenties     = pack('C*', (0x20,0x20,0x20,0x20,0x20,0x20));
my $onoff        = pack('C*', (0x68,0x64,0x00,0x17,0x73,0x66));
my $subscribed   = pack('C*', (0x68,0x64,0x00,0x18,0x63,0x6c));

sub findBauhn($)
{
    my ($mac) = @_;

    my $bauhn;
    my $reversed_mac = scalar(reverse($mac));
    my $subscribe    = $fbk_preamble.$mac.$twenties.$reversed_mac.$twenties;

    my $socket = IO::Socket::INET->new(Proto=>'udp', LocalPort=>$port, Broadcast=>1) ||
                     die "Could not create listen socket: $!\n";
    $socket->autoflush();
    my $select = IO::Select->new($socket) ||
                     die "Could not create Select: $!\n";

    my $to_addr = sockaddr_in($port, INADDR_BROADCAST);
    $socket->send($subscribe, 0, $to_addr) ||
        die "Send error: $!\n";

    my $n = 0;
    while($n < 3) {
        my @ready = $select->can_read(0.5);
        foreach my $fh (@ready) {
            my $packet;
            my $from = $socket->recv($packet,1024) || die "recv: $!";
            if ((substr($packet,0,6) eq $subscribed) && (substr($packet,6,6) eq $mac)) {
                my ($port, $iaddr) = sockaddr_in($from);
                $bauhn->{mac}      = $mac;
                $bauhn->{saddr}    = $from;
                $bauhn->{socket}   = $socket;
                $bauhn->{on}       = (substr($packet,-1,1) eq chr(1));
                return $bauhn;
            }
        }
        $n++;
    }
    close($socket);
    return undef;
}

sub controlBauhn($$)
{
    my ($bauhn,$action) = @_;

 
   my $mac = $bauhn->{mac};

    if ($action eq "on") {
        $action   = $ctl_preamble.$mac.$twenties.$ctl_on;
    }
    if ($action eq "off") {
        $action   = $ctl_preamble.$mac.$twenties.$ctl_off;
    }

    my $select = IO::Select->new($bauhn->{socket}) ||
                     die "Could not create Select: $!\n";

    my $n = 0;
    while($n < 2) {
        $bauhn->{socket}->send($action, 0, $bauhn->{saddr}) ||
            die "Send error: $!\n";

        my @ready = $select->can_read(0.5);
        foreach my $fh (@ready) {
            my $packet;
            my $from = $bauhn->{socket}->recv($packet,1024) ||
                           die "recv: $!";
            my @data = unpack("C*", $packet);
            my @packet_mac = @data[6..11];
            if (($onoff eq substr($packet,0,6)) && ($mac eq substr($packet,6,6))) {
                return 1;
            }
        }
        $n++;
    }
    return 0;
}

($#ARGV == 1) || die "Usage: $0 XX:XX:XX:XX:XX:XX <on|off|status>\n";

my @mac = split(':', $ARGV[0]);
($#mac == 5) || die "Usage: $0 XX:XX:XX:XX:XX:XX <on|off|status>\n";

@mac = map { hex("0x".$_) } split(':', $ARGV[0]);
my $mac = pack('C*', @mac);


my $bauhn = findBauhn($mac);
defined($bauhn) || die "Could not find Bauhn with mac of $ARGV[0]\n";
if ($ARGV[1] eq "status") {
    print $bauhn->{on} ? "on\n" : "off\n";
    exit(0);
}
($ARGV[1] ne "on" && $ARGV[1] ne "off") && die "Usage: $0 XX:XX:XX:XX:XX:XX <on|off|status>\n";

for(my $n=0; $n<3; $n++) {
    controlBauhn($bauhn, $ARGV[1]) && exit(0);
}
die "Could not change Bauhn to $ARGV[1]\n";

https://github.com/franc-carter/bauhn-wifi

Work has been having some issues with wireless microphones getting interfered with, so thought we would investigate something like this.

This uses Raspberry Pi’s and RTL-SDR’s to cheaply locate rogue transmitters.

Wanting to see how well it works – and if it could help with the issues, I was think about putting it around the stadium and seeing if we can locate the source of some of the interference.

Please check out the following video :

You can download a copy of the ArchLinux ISO from the following location

http://www.panoradio-sdr.de/wp-content/uploads/2019/04/pi_image_tdoa_v2.zip

I am just going to document my setup here for future use or deployment.

Write image to SD card in the usual way, and power up the Pi.
This image has an unknown root password, and I need to get Wifi working, so take out the SD card after booting and edit the following.

This install of Arch Linux does not have wpa_supplicant running, so it’s not as easy it as it on Raspbian – and given the custom build of this I want to ensure I am not changing to much of either kernel modules or the user space environment.

So to change the root password, which is unknown on this build, you will need to perform this to get into ‘single user mode’.

Mount SD card in another computer
Edit the file : 'cmdline.txt'
Add the following after the text rootwait init=/bin/bash
save the file, exit
Reinsert SD card into pi, and power up.

Once the PI has booted, you should see a prompt:

sh-5.0#

This indicates that you are in single user mode, and you should now be able to do the following.

At the command prompt type: 
passwd <enter>
New password: <enter the new root password>
Retype new password: <enter the same password as above>

Once you are back at the sh-5.0# prompt you can power down the Pi, and you will need to reverse what you did, so it no longer boots in Single User Mode.

mount the SD card into another computer and edit the cmdline.txt file and remove the init=/bin/sh after the rootwait

Save the file, and unmount the SD card, and put it back into the Pi and power up again.
This will create your new Root password as what you entered before.

Once you are at the alarmpi login: prompt you should be able to login now as
root
<your root password>

Once you have logged in as root, type

wifi-menu

This will take you into the Wifi-Menu where you will be able to connect it to your wifi if you chose.
Select your WiFi name in the menu, and enter the password.
This should connect you to the wifi network and give you an IP address.

Confirm this by pinging something inside your network, or even if you can outside your network (8.8.8.8) for example.

ping 8.8.8.8

Once you have successfully confirmed you can ping 8.8.8.8 or something inside your network, you will need to make the wifi adaptor come up on boot.
For this you will need to run the following command

systemctl enable netctl-auto@wlan0.service

The Pi is now ready to go.
For safety and double checking, reboot the pi and make sure it boots correctly and comes back up to the login prompt.

Log back in as root, and confirm you can ping internal and external services again.
Once you have confirmed that, log out – either exit, or pressing CTL+D and login with the following username and password

username: alarm
password: alarm

Actually we should start with changing the password of the alarm user – at the command prompt please type

passwd

and change the password to something you will remember, but hard to guess.

Because this image has an authorized_keys entry for the user ‘alarm’ and I don’t trust that at all, please edit the file (with any editor of your choice) and remove the user : stefan@ubuntu – with this in there, he *could* login without a password

cd .ssh
vi authorized_keys
<double press d> and the line should be removed
type : then wq and then press enter.

It should drop you back to the shell prompt.
From here we will create some new SSH keys for this user – to allow the server to connect to it, to start the scripts and to copy the recorded files for processing.

These SSH keys will enable the server to login without the need for a password, once you have created these, you really need to be very careful who you give them to.
Let’s create the ssh keys:

ssh-keygen -o -a 100 -t ed25519

You can press enter for the name of the file, and please do not use ‘passphrases’ you can just press enter for them twice.
Once the key is made, you should have two new files.
id_ed25519 and id_ed25519.pub

However, once you have created the key pairs, you will need to share the .pub file with your server administrator , and they will need to share their .pub with you for the user that is created on the server for this task.

You will need to put each opposite pair’s .pub contents into the ~.ssh/authorized_keys file.
Once the server has the clients’ .pub entered in, and the client has the server’s .pub contents in the authorized_keys file, seamless interaction should now be able to take place.

However, in the first instance, it would be beneficial to ‘ssh’ to the remote party first, so as to approve the ‘host identity’ interactive prompt that happens when you connect to a machine for the first time.

To attempt to make this as deployable as possible, and not have to run with pinholes through routers and firewalls, I am going to make the pi create a reverse SSH tunnel.
That is, get the pi to connect to the master server via SSH and allow a port to come back through that created tunnel to be able to log into the server without the need of any port forwards or vpn’s.

Not ideal, I would prefer a VPN service, but this is a bit more robust.

Log out of ‘alarm’ and log back into root.
Create a script called the following name:

vi /usr/local/bin/ssh.sh

In that file enter the following details

#!/bin/bash
/usr/bin/ssh \
  -o ServerAliveInterval=20 \
  -o ServerAliveCountMax=3 \
  -o ExitOnForwardFailure=yes \
  -o StrictHostKeyChecking=no \
  -i /home/alarm/.ssh/id_ed25519 \
  -N -T -R####:localhost:22 rftracker@PUT-YOUR-TUNNEL-SERVER-HOST-HERE

Please see your server administrator on what port number #### to use, this will enable the server to reverse tunnel once this is running – which we will do on boot, but each of these ports need to be unique to the install.

Once that file is created please make it executable by

chmod a+x /usr/local/bin/ssh.sh

Now we need to make is start on system boot.

Enter the following

vi /etc/systemd/system/sshtunnel.service

[Unit]
Description=MyScript

[Service]
ExecStart=/usr/local/bin/ssh.sh

[Install]
WantedBy=multi-user.target

Now we will create a ‘timer’ script to wait 1 minute after power on, and make sure that wlan0 is running before it will start the tunnel..
This is to ensure that all parts of the system are running.

So create the timer service like so

vi /etc/systemd/system/sshtunnel.timer

[Unit]
Description=Runs myscript one minute after boot

[Timer]
# Time to wait after booting before activation
OnBootSec=1min
Unit=sshtunnel.service

[Install]
WantedBy=multi-user.target

Set permissions and executable bits on the two services

chmod 755 /etc/systemd/system/ssh*

Then we need to enable the sshtimer service to run

systemctl enable sshtunnel.timer
systemctl start sshtunnel.timer

Reboot the Pi.
Once you log in as alarm with your new password, you should have the reverse SSH tunnel running and should see something like

ps aux |grep ssh

/usr/bin/ssh -o ServerAliveInterval=20 -o ServerAliveCountMax=3 -o ExitOnForwardFailure=yes -o StrictHostKeyChecking=no -i /home/alarm/.ssh/id_ed25519 -N -T -R2021:localhost:22 rftracker@10.30.0.1

If that line is in your process list, then you have a successful SSH tunnel to the server, and the server now can log into , copy and start scripts from this connected host.

I am pretty sure that is all that is needed for now.
More updates and the final test results should be published once we have it up and running and tested.

Just one thing to note, for future ZL1CLH when he comes to try and work out what he did to get this going…
You will need to use 127.0.0.1 as the ‘localhost’ address when connecting to the ‘remote’ Pi’s if you use localhost, you will actually be connecting to the IPv6 address of the SSH server running on the server, and not actually make it over to the pi.
but 127.0.0.1 will use the port re-direction as specified in the reverse tunnel setup earlier.

So after all the testing, and building of the Direwolf Raspberry Pi Tracker, I took it to the US.

It performed really well in California.
I tethered to my mobile phone and discovered that I needed to sit in the personal hot spot screen for the device to actually connect every time.

Not sure why, but from the second picture, I do wonder if it was the cause of the loss of packets in Texas.

---

Well, it was a bit of an interesting experience, and experiment to be honest.


Here is a track of my drive, as you can see, I had two little oddities with leaving home till just before Whangaparaoa and heading home till just before Waipu.
Not sure what’s going on there but restarting Direwolf seemed to have corrected it for both issues – so it might have been an issue with it swapping Wireless networks or something else, but there was nothing to indicate an error – perhaps the iGate servers do not like a change of IP address without a disconnection – but I am sure I can work it out over time.

I did not Digipeat any traffic on the drive north, and just to put that into perspective,
the last packet on the drive north to be pick up by an RF station was:

2019-07-27 07:55:56 NZST: ZL1CLH-12>APDW15,WIDE1-1,WIDE2-1,qAR,ZL1AOX:!/`uGSzZun>+TG/A=000549

And the first packet to be re-aquired by an RF station on the drive north was:
2019-07-27 09:02:01 NZST: ZL1CLH-12>APDW15,WIDE1-1,WIDE2-1,qAR,ZL1BSW-10:!/`c,xzU_u>&RG/A=000982

Total time of 01:06:05 when I was in TCP/IP land only – and in that time no other stations were heard.

But as you can see from the following, there were not too many APRS users attending the sale – but the sale was well represented – and some very good equipment was brought by everyone.

The Cars with APRS at the sale:

The tracks they made to attend the sale:

The pink line was mine in both directions, with me going wild through the water on my return leg home.

Worthwhile I have to say – but also a little disappointing.
In a few weeks there is a sale on in Hamilton (South of Auckland) so might try this again then, and see if I get better performance on the south bouth destination.

But I had so much fun attending this sale (my first one in this region) and will attend again next year.

---

Let us just keep a record of the map as it is at 06:30am NZTime.

I will be driving from the little red car at the bottom of the screen grab, oddly to the red car ZL1DMA-9 in Whangarei – but between Wellsford and Marsden Point there is not a lot of digipeaters, so that is why I decided to do this little experiment.

From the rag chewing I heard on the local 2meter repeaters, there are quite a few people heading north today – so fingers crossed this little experiment will be successful – and I will consider any packet that is not mine captured via RF and iGated and Digipeaters between those areas as a success.

See you in 15 hours or so.