Home on Lloyd Rochester's Geek Blog

Hello World on SSD1306 using Arduino

Sun, 12 May 2024 00:00:00 +0000

Hello World on SSD1306 using Arduino

After looking through numerous libraries and examples to control the SSD1306 with Arduino, I’ve found nothing simple. There are some really powerful libraries with lots of support. In this post I’ll post the simplest possible “Hello World” example on an SSD1306 using an Arduino Due. Note, if you need to draw shapes, lines, movement you’ll have to extend this example.

DNS Proxy in C

Sat, 30 Dec 2023 00:00:00 +0000

DNS Proxy in C

This post provides a simple example of a DNS proxy. A client would query a DNS record from our program as if it was a server. This query will be passed on to a DNS server and eventuall back to the client.

Proxy Server Paradigm

A proxy server is an intermediary server. Instead of a client requesting direct to a server the request goes to a proxy server that will handle the request on behalf of the client.

Network Programming Rant

Wed, 28 Jun 2023 00:00:00 +0000

Network Programming Rant

When I mow the lawn I typically try to find a good podcast to listen to. Every once in a while I get lucky. This time I found a great pod cast on The Origins of the Internet Internet with John Day. There are two episodes dedicated with (Professor John Day’s)[https://www.bu.edu/met/profile/john-day/] thoughts. Hearing what John Day had to say about the design and evolution of the Internet was intriguing to me. Many times when working with computers we just take for granted how things are and assume their design is the best approach. John has a deep understanding of the Internet’s origin and witnessed it’s infancy from ARPA Net to what it is and isn’t today.

Browser UI using sshuttle VPN in WSL

Tue, 30 May 2023 00:00:00 +0000

Browser UI using sshuttle VPN in WSL

Browser viewing a UI in Windows using sshuttle in WSL as a VPN

In this post we will create VPN connections using sshuttle in WSL for Windows 11. This post will focus on pointing a Browser to a URL in a private network in Windows. The private network - VPN - can be reached from sshuttle running in WSL. For this setup we unfortunately need to have a “double networking hop” in that Windows needs to be configured to send traffic to WSL (1) and WSL needs will then use sshuttle to (2) forward that traffic to the public network.

Learn the FFT

Sun, 12 Feb 2023 00:00:00 +0000

Learn the FFT

In this post I’d like to attempt to explain how the Fast Fourier Transform algorithm works. This post is inspired by many attempts others have made that don’t really do a good job explaining the FFT. Hopefully, I can do a better job. For explanation we’ll use the Cooley–Tukey algorithm which is the most common.

FFT Butterfly Diagram

Above is the so-called Butterfly Diagram which we will arrive at. Refer to the Example FFT Computation in C to see a program that will compute the FFT.

Time Conversion in C

Tue, 27 Dec 2022 00:00:00 +0000

Time Conversion in C

In the Unix Operating System we have multiple ways that time can be represented: as a epoch, broken down and as a string. Conversion between these three representation can be cumbersom. This blog post outlines the ways time is represented in the C programming language and provides a reference for conversions. Many other languages will follow very closely or exactly to what is done in C.

Understanding Process Execution

Tue, 29 Nov 2022 00:00:00 +0000

Understanding Process Execution

In this post we will dive in to command execution from inside a program. The ability to execute commands from inside a program to obtain their output and exit code is very common for automation and testing use cases. Unfortunately, due to how Operating Systems work it is not a simple process to obtain the output and exit code from a running program.

Remote Process Execution

Take for an example a program that from within we execute a command and capture the output in real time, as well as, capture the exit code once the program ends.

UART Theory and Programming on the Raspberry Pi

Tue, 16 Aug 2022 00:00:00 +0000

UART Theory and Programming on the Raspberry Pi

This post outlines how to control the UART in a Raspberry Pi using the C programming language. We will also explore parity checks and handling. Parity checking was the main driver for this post, however, if you’re looking for C code to control a UART that is also asynchronous please keep reading. This post contains a small command line tool that can asynchronously read and write to standard input and output through two connected UARTs. The command line tool has a number of options to set the speed, tty, parity and number of stop bits.

Understanding memory reallocation with realloc

Wed, 03 Aug 2022 00:00:00 +0000

Understanding memory reallocation with realloc

Let’s better understand how memory is allocated, then reallocated on the heap. When we allocate blocks of memory they are stacked on top of the heap with increasing memory addresses. What happens when we reallocate a memory block to make it larger when it’s isn’t the last item on the heap?

Heap Example

Let’s create an example using malloc(3) and realloc(3p) that gives good insight. Here is how our example will play out:

Read a File into an Array in C

Mon, 01 Aug 2022 00:00:00 +0000

Read a File into an Array in C

In this post we’ll explore how to read a file into an array of strings. Doing this in C isn’t as trivial as it maybe in other languages because of memory allocation and the dynamic nature of a text file. The file will be read into a jagged array. This program uses realloc(3) to make the most efficient use of the heap possible.

Timer example in systemd

Sat, 09 Jul 2022 00:00:00 +0000

Timer example in systemd

We can use systemd instead of cron timers in Unix. Using systemd timers is easy and provides numerous benefits over using Cron which are documented below. These timers more are complicated than cron, however, they are much more powerful.

Creating a `systemd` timer

Let us look at the logical hierarchy of a timer on systemd and the files associated before we look at an example.

Logical Requirements

To create a systemd timer the following are required:

Differences between lists in Unix

Mon, 27 Jun 2022 00:00:00 +0000

Differences between lists in Unix

Unix comm command - Difference between two lists

Using the comm(1) command in Unix we can output the difference between sorted lists. The comm command takes two sorted files as inputs and will output lines unique in FILE1, lines unique in FILE2 and lines common to FILE1 and FILE2. The comm command requires the files to be sorted.

Examples

 comm -12 file1 file2
 Print only lines present in both file1 and file2.

 comm -3 file1 file2
 Print lines in file1 not in file2, and vice versa.

Example with Files

Let’s see an example by creating two lists in file a.txt and file b.txt. Then use the comm command to output what is only in a.txt, in b.txt and in both a.txt and b.txt - the union between them.

Realtime Lidar Measurements with NodeJS

Sat, 19 Mar 2022 00:00:00 +0000

In this blog post we will plot near realtime Lidar Measurements on a browser. We will use a Raspberry Pi connected to the TF Mini+ Lidar from Benewake. At the end post of this you’ll be able to see a Realtime Graph of Lidar measurements. Each measurement is in centimeters and has an associated strength reading.

End Result

Here is what the graph looks like on a browser. There is both a distance and strength measurement on a plot. On the y-axis for distance we have a measurement in centimeters. The signal strength is the second graph. The strength is a 16-bit value.

Unix Command for Epoch Time

Sun, 06 Feb 2022 00:00:00 +0000

Unix Command for Epoch Time

This post provides some examples using the Unix date(1) command to interact with Epoch Time. We commonly need to print or parse the Epoch.

Print the Epoch

Using the Unix date command we can print the Epoch. We need to use the %s format.

$ date +%s
1644156059

The %s format is seconds since the Epoch (1970-01-01 00:00 UTC). The Epoch is always in the UTC or Zulu time zone.

Skull with Blinking Red Eyes for Halloween

Mon, 25 Oct 2021 00:00:00 +0000

For Halloween I attempted to do a little electronics with my young daughters to make a scary Halloween Skull with Blinking Red Eyes.

Circuit Functions

The circuit is easy to build and consists of 4 parts.

Photo Diode that triggers the circuit to be activated only at night
LM555 Timer to blink the Red LEDs for the Skull’s eyes
Transistors to Drive the diodes
A +9V Battery for Power

Circuit

Here is the circuit we created. From left to right you can see the Photo Diode, the LM555 in astable mode, and the NPN Transistor powering the two red LEDs.

Ebyte e32 Lora Module - Client Socket Examples

Fri, 23 Jul 2021 00:00:00 +0000

Ebyte e32 Lora Module - Client Socket Examples

This post currently has a example client in Python that sends information through Unix Domain Sockets when the e32 is running as a service. Adding clients in other programming languages is a hopeful future addition. See Getting Started.

Prerequisites

Ensure either you have the e32 programming running with sockets enabled. Or, preferred, running as a service.

More background on can be found in e32 sockets.

Ebyte e32 Lora Module - Wiring and Configuring the Raspberry Pi

Sun, 18 Jul 2021 00:00:00 +0000

This post explains how to wire up the UART and the mode pins. We need 5 connections between the Raspberry Pi and EByte E32, as well as a power and a ground. See this software installation after the wiring is complete.

Wiring

Here is the wiring between the E32 and the Raspberry Pi. Please make sure the UART TX of the RPI is wired to the RX of the E32 and vice-versa.

Ebyte E32 Lora Module - systemd service

Fri, 18 Jun 2021 00:00:00 +0000

Ebyte E32 Lora Module - systemd service

The e32 program is intended to be run as a service in the backround with communication through sockets. This way you can write software in any langauge and just have to deal with the easy job of reading and writing to a socket. Once the e32 service is started and running it can be accessed at any time by a client. In this post we’ll document the actual systemd service. We have some client examples demonstrating clients interfacing with the socket.

Ebyte E32 Lora Module - Transfer Files

Fri, 18 Jun 2021 00:00:00 +0000

Ebyte E32 Lora Module - Transfer Files

This post explains how to transfer files over Lora using the e32 program. See getting started for the background.

Prerequisites

We must first assume the e32 is not running as a service. If not sure run a sudo systemctl stop e32 to stop it.

Transferring Files Between two Raspberry Pi Boards

We obviously need at least two Ebyte e32 lora modules for this.

Receiving

From one Raspberry Pi with the e32 installed. We need to be receiving before we transmit the file.

Stack Protection with a Canary

Fri, 11 Jun 2021 00:00:00 +0000

Stack Protection with a Canary

Buffer overflows can be detected by inserting a canary into a function. These canaries are inserted when a function’s stack frame is created. Before a function’s return we check for the canary on the stack frame. If the canary isn’t found then buffer overflow or stack smashing is detected.

Example

Let’s first create a deliberate buffer overflow. Then we can see how it behaves with and without stack protection.

Ebyte e32 - Sockets

Tue, 08 Jun 2021 00:00:00 +0000

Ebyte e32 - Sockets

The e32 program can run as a daemon and listen on Unix Domain Sockets for data to transmit and receive. This post documents the functionality of the sockets the e32 software is listening on.

Intention of the Sockets

The software for the e32 is written in the C Programming Language. I’m a huge fan of C, but it isn’t for everyone, nor, is it for every application. The sockets are created so we can interface any program to the e32. Instead of having to write C code to do what you want, you can just use the e32 as a driver and write a client in any language. When this client writes and reads from the socket it’s transmitting and receiving wireless data. Since the sockets are Unix Domain Sockets they are reliable.

Finding Libriaries and Headers for C Programs in Unix

Thu, 27 May 2021 00:00:00 +0000

Need to list the installed libraries on a Unix system? Want to use a library in C and don’t know the linker flags to use? Need to find where header files are located for a package? This post answers these questions.

An example from the beginning

Let’s say I want to write a C program that uses libxml2. We know we’re going to need #include directives for the libxml2 package to refer to the header files. When we compile the program we need to have a linker flag with -l to link in it’s shared library. Keep this example in mind as you read this post. Here are the steps to arrive with what we need:

Using libgpiod to detect input events

Mon, 17 May 2021 00:00:00 +0000

Using libgpiod to detect input events

One of the most fundamental requirements for GPIO is the ability to execute user defined code when an external event has happened. This is typically done when a GPIO pin, configured as an input, changes from high-to-low, or low-to-high. In this case we detect on the falling edge or rising edge of this pin change. For example a sensor we communicate through GPIO has data ready. In the micro-controller world this is called as an interrupt where the CPU will change it program counter and handle the interrupt. The interrupt makes sense when we have no Operating System. In the case of Linux and the Raspberry Pi it’s not an interrupt but considered an event as we likely have in interrupt deep inside the kernel code, however, we’re several levels of abstraction past this. Unix has the “Universal File Model” so this input pin is mapped to a file. With Unix we have many multiple ways to know if “events” have happened to this file. Examples of events are that the file is ready for reading, writing, or other events have happened.

GPIO Input with libgpiod

Mon, 10 May 2021 00:00:00 +0000

GPIO Input with libgpiod

We can use the libgpiod library to configure a GPIO line as input and read it’s value. We’ll create a switch circuit so we can test the value is a logic high or low. More info on libgpiod can be found in my libgpiod intro for installation and usage.

Here is a previous post to blink an LED using libgpiod.

Input Circuit

Into our Raspberry Pi we’ll use GPIO 4 and configure this pin as an input. We’re going to add some resistors to control the current into this circuit. When the switch is in one direction you can see current will essentially not flow.

Blinking an LED with libgpiod

Mon, 03 May 2021 00:00:00 +0000

Blinking an LED with libgpiod

In the previous post we introduced libgpiod. In this post we’ll use the command line tools to blink an LED. Finally, we’ll write some C code to blink the LED using the libgpiod library.

LED Driver Circuit

Skip this section if you already have a good circuit to drive an LED. A simple NPN Transistor is a cheap and robust LED drive that only requires two resistors.

The new GPIO Interface on the Raspberry PI: libgpiod

Sun, 02 May 2021 00:00:00 +0000

The new GPIO Interface on the Raspberry PI: libgpiod

Allegedly, The GPIO Sysfs Interface is deprecated. The deprecated Sysfs would interact with GPIO using the /sys/class/gpio pseudo-filesytem. The Application Binary Interface - ABI - provides a character device based device driver and tools. The ABI is the new way to interact with GPIO on the Raspberry Pi. I really don’t like the name ABI, as it’s WAY too generic of a name. Rather, I believe the proper name for this project is libgpiod.

Raspberry Pi SPI Explained

Wed, 21 Apr 2021 00:00:00 +0000

Raspberry Pi SPI Explained

This post attempts to provide some finer details when using SPI on Raspberry Pi as it pertains to using the Chip Select pins and multiple SPI Interfaces. Note, I will not use MOSI and MISO to ditch the old master/slave nomenclature and use SPO and SPI instead.

Here is a quick diagram which will be explained in the following sections.

The Basics of SPI on the Raspberry Pi

If you use raspi-config you can enable SPI.

Implementing a Timeout for a read in C

Mon, 12 Apr 2021 00:00:00 +0000

Implementing a Timeout for a read in C

Need to wait a specified amount of time for a read call to return before giving up and continuing on?

In Unix when we read from a file we can have a non-blocking read where if the file is not ready the read call will pass through. We can also specify a blocking read where the read will wait forever. What if we want read to wait a specified amount of time not zero or infinity?

Audio Clip Capture by Threshold

Sat, 10 Apr 2021 00:00:00 +0000

Audio Clip Capture by Threshold

Updated December 28th 2022

Here is a command line tool to capture audio clips based on two thresholds. Keep the tool running and it will write a number of audio files with audio that is loud enough for long enough. How loud and how long are the thresholds that are inputs to the program. For example we may want to record audio clips that only exceed 3 seconds. The loudness level is meant to keep us from recording noise.

Movement in Emacs

Tue, 06 Apr 2021 00:00:00 +0000

Movement in Emacs

A little cheat sheet for movement in emacs. Tried to capture all the ways you can move up, down, left and right in a buffer.

Moving by Character and Line

Think next and previous for lines, and backward and forward for characters.

 Previous Line C-p
 ^
 |
Previous Character C-b <---+---> Next Character C-f
 |
		 v
 Next Line C-n

Moving by Word and Sentence

 Backward Sentence M-a
 ^
 |
Backward Word M-b <---+---> Forward Word M-f
 |
		 v
 Forward Sentence M-e

Moving to Beginning of Line and Buffer

 Buffer Start M-<
 ^
 |
Line Beginning C-a <---+---> Line End C-e
 |
		 v
 Buffer End M->

Moving to first non-whitespace Character

The M-m will run back-to-indentation.

BPSK Receiver Theory

Wed, 17 Feb 2021 00:00:00 +0000

Let’s look at some BPSK Receiver Theory. This is the 3rd post in the PSK Series. We’ll cover the theory before we go into the implementation.

PSK Series

Here is a summary of where we are in the PSK Series.

BPSK Transmit Theory - This post shows graphs and has audio files of what this tool does.
BPSK Implementation
BPSK Receiver Theory - This Post
BPSK Receiver Implementation - Coming Soon
QPSK - Coming Soon

What are we going to receive?

See my previous post on BPSK Transmitter Theory for what the waveform transmitted. For this post we’ll receive and decode this waveform. Effectively, we’re sending symbols that are Root Raised Cosine waveforms multiplied with sinusoids. Below is the encoded text t represented by our alphabet as $ 10100 $. Note, the amplitude of $ ~1000 $, all the “peaks” both positive and negative, and the duration between the peaks. We’ll delve into all these details shortly.

BPSK Transmitter Implementation

Sun, 24 Jan 2021 00:00:00 +0000

BPSK Transmitter Implementation

In the previous post we discussed BPSK Transmit Theory. This post will discuss the implementation of it. This implementation will be in the C programming language and it will also be a command line tool.

PSK Series

I’m doing a series on PSK here is where we are:

BPSK Transmit Theory - This post shows graphs and has audio files of what this tool does.
BPSK Implementation - This Post.
BPSK Receiver Theory - Coming Soon
BPSK Receiver Theory - Coming Soon
QPSK - Coming Soon

Using the Command Line Tool

I like to start out with how the tool is used as it gives insight about the implementation. It’s quite simple, provide text input as a program argument and the tool will output a .wav file with the content. The example below converts the text hello world to the psk31.wav audio file.

BPSK Transmitter Theory

Thu, 14 Jan 2021 00:00:00 +0000

BPSK Transmitter Theory

In this post we’ll get into the theory of Binary Phase Shift Key - BPSK. We’ll then get into the implementation of the transmitter, followed by the same for the receiver. The transmitter will have text as input, for output we will produce an audio .wav file and a CSV file for analysis. I created a bunch of graphs which really illustrate some of the theory.

Transmit Process

Let’s start with the overall transmit process.

Convolution Examples

Mon, 11 Jan 2021 00:00:00 +0000

Convolution Examples

Understanding convolution is not complete without some examples to visual the results. These examples are meant to aid in one’s ability to visualize the result of a convolution. It’s most important to flip one function horizontally and slide it through the other. As this function slides through we multiply and sum to obtain the result of the convolution.

Convolution is used mainly in two ways:

To mathematically determine how correlated two functions are
To shape a function by convolving it with another function. Examples would be filtering, smoothing, etc …

Note: There are some typos in the frequency labels for some of the sinusoids I need to fix. You can trust the graphs.

USB 3D Sound on the Raspberry Pi

Fri, 01 Jan 2021 00:00:00 +0000

USB 3D Sound on the Raspberry Pi

I recently bought the USB 3D Sound Card to play around with some C ALSA Programming on the Raspberry Pi. It worked without a problem and wanted to jot down some notes in this post on it’s specifications and how to use it. I didn’t have to make any modifications to the Raspberry Pi at all and sound worked right out of the box. I ran this on a Raspberry Pi B+ on Raspian.

Timestamps in C

Wed, 02 Dec 2020 00:00:00 +0000

Timestamps in C

In this post I’ll provide some ways to create, convert and print timestamps using C. We’ll first create a Unix epoch which corresponds to seconds since January 1st 1970 at 00:00:00 UTC. We will also represent the epoch in milliseconds, as a double, and finally convert to an ISO 8601 Timestamp. We’ll conclude with the challenge of using fractional seconds.

Epoch using `clock_gettime` from `time.h`

Get the epoch in seconds and nanoseconds using clock_gettime. This is POSIX.1-2001. We will use CLOCK_REALTIME since all implementations will support this per man 3 clock_gettime.

Unix Process Tutorial

Sat, 28 Nov 2020 00:00:00 +0000

Unix Process Tutorial

In this blog post I’ll go over a quick tutorial on Unix Processes. We’ll start with some theory and then go into some real world examples. It’s meant to be quick, to the point, and provide the necessary information to have a good understanding about how Unix Processes are designed.

SSH’ing into a Unix Machine

Let’s start with a common scenario. This scenario is to simply ssh into another Unix machine. From a Unix process perspective what happens?

COI with Dovecot

Fri, 20 Nov 2020 00:00:00 +0000

COI with Dovecot

I recently discovered Chat Over IMAP. It looks like a promising technology that has a lot to offer. I’m currently hosting email on my lloydroc.github.io domain with Postfix/Dovecot and in this post I’ll modify my Dovecot configuration to work with COIand then try the Delta Chat application. I had originally planned for an hour or two of work, however, to get COI configured on Dovecot literally less than 5 minutes!

Improved Scanning of JSON with Flex/Bison

Tue, 27 Oct 2020 00:00:00 +0000

Improved Scanning of JSON with Flex/Bison

Using Flex/Bison in the last post we Parsed JSON into an AST. In the first post we setup a Simple Example to Parse JSON. In this post we will improve our Flex Scanner to tokenize and validate more JSON cases. We will continue to align with the grammar at json.org. We will add rules and tokens for DQUOTE (double-quote), string, HEX, and CHARACTERS not in our previous implementation.

Parse JSON into an Abstract Syntax Tree using Flex/Bison

Sun, 25 Oct 2020 00:00:00 +0000

Parse JSON into an Abstract Syntax Tree using Flex/Bison

In a previous post we Parsed JSON using Flex/Bison. This example was very basic. We used a FLEX scanner to tokenize our JSON and created grammar rules in BISON to parse this token stream. This post will take it further and create an Abstract Syntax Tree (AST). The AST is a power data structure typically used in compilers that will store the structure of our JSON. Effectively we will read in the JSON structure a tree-like data structure in C.

TF Mini Plus Unix Agent for the Raspberry Pi

Mon, 12 Oct 2020 00:00:00 +0000

TF Mini Plus Unix Agent for the Raspberry Pi

In this post we will create a Unix agent for the TF Mini+ LiDAR Range Finder. We’ll run the agent on a Raspberry Pi B+ as a daemon. This agent will send out UDP datagrams with each LiDAR Reading. Also, we can use the tfmini program as a command line tool to read from the LiDAR and change the configuration. Overall, I’ve noticed the TF Mini+ is quite accurate and snappy.

Disassembly of Recursion in C

Fri, 25 Sep 2020 00:00:00 +0000

Disassembly of Recursion in C

Let’s disassemble a recursive function in C to ARM assembly. We can use the textbook example of a recursive factorial function. We’ll play around with optimization levels and touch on Tail Recursion or Tail Calls at the end of the blog post.

C Code

Below is the C code we’ll use to disassemble. This code is a text book function that implements a factorial using recursion.

Retry in Bash

Mon, 21 Sep 2020 00:00:00 +0000

Retry in Bash

In this blog post we’ll have two examples in bash that will retry in the following ways:

Retry a command N times before failing
Retry command for X minutes before failing

In both of these examples we’ll use true and false as examples to test the script. These would need to be changed for your use case.

Retry a Command X Times

A script to run a command N times. We will fail after 3 attempts, and delay for 10 seconds between attempts.

Ebyte e32 LoRa Module - Getting Started

Tue, 15 Sep 2020 00:00:00 +0000

Ebyte e32 LoRa Module - Getting Started

This page documents software for the Ebyte e32 Lora module that runs on the Raspberry Pi which can be found in this github repo. See below for software installation.

Resources

Wire up the Ebyte e32 Lora Module to the Raspberry Pi first. Then check out the other resources listed below:

Software Installation

Before you install the e32 program be sure to have completed the Wiring and Pi Configuration. These instructions are to be run on your Raspberry Pi. Download e32. See instructions below.

Favorite Idioms

Wed, 19 Aug 2020 00:00:00 +0000

Some of my favorite idioms. Sorry I don’t have the author of them currently, and the context will have to be determined for each of them.

Open the Kimono
Always better to keep your pants on with a belt and suspenders
Not even pregnant and already asking the sex
When knee deep in alligators you need to drain the swamp
When someone comes in your office with a Monkey; make sure they leave with the monkey
Look a gift horse in the mouth
Spend all our time chasing the hogs and never fix the fence
Just because it’s an ugly baby doesn’t mean were not going to deliver it
It only takes one doctor to deliver a baby
Clean up after the elephant
The most dangerous thing about being a life guard is saving someone else’s life
A bird in one hand is worth two in the bush
All stick and no carrot
Tell me what time it is; don’t build me a watch
The #1 rule of the wing walker is to make sure you have firm grasp in one hand before releasing the other
There are lies and there are statistics, what is the difference?
Catching a falling knife
Iron fist in a velvet glove
Move heaven and earth to get something done
Fruit from the poison tree
Say FU in 1000 words
Can’t unring a bell
Drowning in a tea-cup
Gold ring in a pigs snout
Bring a knife to a gun fight
Hard to dance with a devil on your back
Beat your swords into plowshares
When x gets its prostate checked it’s y who gets tickled
I like the dreams of the future rather than the history of the past
Trash can of history
They’re all pregnant and know one knows who the father is
See the forest from the trees
Be fruitful and multiply
The harvest is plentiful but he laborers are few
Like putting an anorexic on a diet
Can’t Stop looking at the windsheild wipers and see where going
A rut is only a few feet shallower than a grave.
Adapted like a poisonous snake - looks the same - but when comes time to execute it can’t
Sunshine is the best disinfectant
Dumpster Fire
Those who do not understand Autoconf are condemned to reinvent it, poorly.
No plan ever survives first contact with the enemy
Everyone has a plan until they get punched in the face
There isn’t a cow on the ice. Meaning it’s not an emergency.
Stand on the shoulders of giants
Never argue with an idiot. They will drag you down to their level and beat you with experience. –Twain

Systemd: Timers

Tue, 30 Jun 2020 00:00:00 +0000

Systemd: Timers

In the fourth post on how to create a service in systemd we will create a timer that will run every minute sending messages to our example foo service over a socket. We’re essentially creating a cron job socket client.

Project Creation of an autotools project and start/stop a daemon service.
Journalling/Syslog to enable logging, notify of state changes and accept reloads.
Socket creation of a Unix Domain Socket for other processes to send messages to our service through remote procedure calls.

What the example will do?

We already have a Unix Domain Socket created by systemd that is listening on /var/log/foo.socket. We also have a service called foo.service that is listening to this socket . When messages are received on the socket the service will log them to the journal and syslog.

Systemd: A Service and a Socket

Fri, 26 Jun 2020 00:00:00 +0000

Systemd: A Service and a Socket

This is the third post on how to create a service in systemd. See the first post to create a autotools project and start/stop a daemon service. Or the second post to enable logging, notify of state changes and accept reloads. In this post we’ll create a Unix Domain Socket so that other processes can send messages to our service through remote procedure calls.

The socket we will use in this post is a Unix Socket with domain AF_UNIX of type SOCK_DGRAM. This type of socket is well suited for example purposes and is also ideal for remote procedure call applications. It is limited to communication on the same host, not over the internet. Unix Domain sockets are always reliable and are guaranteed to be delivered in order without duplication. Since this example uses a datagram socket we can receive the full message on each reception. Typically, the size of a datagram socket is under 2048 bytes see socket(7) and look for the SO_SNDBUF option for more details on maximum datagram size.

Status, Reloading and Journalling in Systemd

Tue, 23 Jun 2020 00:00:00 +0000

Status, Reloading and Journalling in Systemd

This is the second post on how to create a service in systemd. In the first post we created an autotools project and were able to start, stop and get basic status on the service. In this post we’ll build on the autotools project to add logging to syslog and journald. We will also give an example on how we could reload the service with a systemctl reload foo. We will also use the sd_notify(3) API to notify the service manager the status of what the service is doing.

Systemd and Autotools

Mon, 22 Jun 2020 00:00:00 +0000

Systemd and Autotools

This post starts a tutorial series on how to create a systemd service in Linux. This first post is likely the hardest part as we create an autotools project with the source code and systemd unit files. Having this setup in autotools saves significant time installing unit files that systemd requires, building our C code, installing, and uninstalling our program. If you can get through this first post the following posts should come easily.

LSM9DS1 Command Line Tool for Raspberry Pi

Wed, 03 Jun 2020 00:00:00 +0000

LSM9DS1 Command Line Tool for Raspberry Pi

I recently created a LSM9DS1 Command Line Tool for the Raspberry Pi. This tool was used to capture Accelerometer and Gyroscope data. I did an experiment to see what the readings look like, how the sensor behaves and the noise levels. This experiment is far from perfect but gives good insight and understanding.

Sensor Setup

The LSM9DS1 was taped to the tread of a $ 16" $stroller tire. The location was directly on top of the tread so the wheel had to be spun up in the air. The wheel was parallel to the ground as the stroller was on it’s side. The axis of the Accelerometer had Z facing outward, X facing along the rotation of the wheel, and Y facing perpendicular to the rotation of the wheel.

Viterbi Example

Fri, 01 May 2020 00:00:00 +0000

Viterbi Example

Here we go! In this post I’m going to go through how Viterbi Decoders work. There is a lot to cover since we need to touch on Convolutional Coding, State Machines, Trellis Diagrams, Hamming Distances and Trellis Diagrams. I’ll illustrate this with the absolute simplest example possible and walk you through every step of the way. I highly recommending taking out a pencil and paper for this.

What is Viterbi Decoding?

Viterbi Decoding allows us to detect and correct errors that were transmitted through a noisy channel.

I/O Multiplexing in Unix

Sun, 26 Apr 2020 00:00:00 +0000

I/O Multiplexing in Unix

In Unix a process performs I/O on a single file descriptor at a time. When we talk about I/O on a file think read() and write() calls which are blocking. To get around blocking on a I/O call there are a number of ways. You can imagine how blocking on a single I/O call could bring the performance of a program to it’s knees. In this post we’ll quickly compare non-blocking I/O Models. Namely, select(), poll(), Signal Driven I/O, and epoll().

SSD1306 Display Module to Raspberry Pi Wiring

Wed, 22 Apr 2020 00:00:00 +0000

I recently bought a DIY Display Module using the SSD1306 Driver from Alibaba AliExpress. In this post we discuss the physical wiring from the display module to the Raspberry Pi and the SPI Mode to interface with it. The goal is to control it in a C program.

Hardware Required

SSD1306 Module 7-pin 1.3" with with 128x32 OLED Display
Raspberry Pi B+
Connecting Wires

The module I got was a GME12864-83 1.3" SPI OLED SH1106 for $3.52 USD from the S+S+S+.

A CLI Tool to Recommend Text

Tue, 14 Apr 2020 00:00:00 +0000

A CLI Tool to Recommend Text

Computers are fast at comparing one string to another, however, when we need to find which string is closest to other strings things become more challenging. In this post we’ll create an command line utility that will recommend a string by comparing it to a list of strings. We’ll recommend the string that is the closest one to our input string.

Spell checkers and search engines have similar algorithms to this to recommend and match queries for search results.

The Stack of Frames in C with ARM Assembly Example

Fri, 03 Apr 2020 08:34:05 -0600

Function calls in the C programming language make heavy use of the stack, also called the call stack. When functions are called they create the so-called stack of frames. Each function call creates a frame, and these frames are allocated on the stack. This stack frame is used to allocate memory for local variables and intermediate values. The stack frame also contains the previous frame pointer and program counter’s value to execute from once the frame is popped off the stack. We will disassemble C function calls to understand the stack of frames in ARM assembly.

Converting C Conditionals to ARM Assembly

Fri, 27 Mar 2020 00:00:00 +0000

Converting C Conditionals to ARM Assembly

In this post we can explore how to the gcc compiler converts to C to ARM assembly language. We’ll specifically look at conditional logic. We’ll look at examples of if statements, if statements with else if and else, then end with a switch statement. To convert C to ARM assembly we will use the -S flag on GCC. All these examples were done on a Raspberry Pi running Raspbian.

Unix Command Line Tool Timeline

Wed, 25 Mar 2020 00:00:00 +0000

A compact timeline of Unix command line tools, ordered by the earliest release or broad adoption date.

These entries focus on the core command line utilities that power Unix shells and classic Unix-style workflows. The list intentionally avoids large application suites, window managers, or programming languages used only incidentally as commands.

Timeline

Year	Tool	Notes
1971	`sh`	The original Bourne shell, the foundation of Unix command-line scripting.
1971	`cat`, `cp`, `mv`, `rm`, `ls`, `mkdir`, `rmdir`, `pwd`, `chmod`	Core file and directory utilities from early Unix releases.
1973	`grep`	Pattern searching on files, one of the most widely used Unix commands.
1974	`awk`	A powerful text-processing tool designed for Unix data manipulation.
1974	`sed`	Stream editing for filtering and transforming text.
1974	`find`	Recursive file discovery and selection.
1975	`sort`, `uniq`, `cut`, `paste`, `head`, `tail`	Classic text processing commands for pipeline workflows.
1975	`tar`	Archive creation and extraction, important for backups and distribution.
1979	`make`	Build automation for compiling and managing source trees.

Scope

This page is meant to capture the history of Unix-style shell tools, not every executable that happens to offer a CLI. If a tool feels like an integral Unix utility, it belongs here; if it is primarily a larger application or programming environment, it does not.

Delay Lines in C

Mon, 23 Mar 2020 08:43:05 +0000

Delay Lines in C

There are many scenarios where a delay line is needed in signal processing. Scenarios ranging from Digital Filters, Convolution, Reverberation, Echo and others. Delay lines have a fixed length of N samples. When delay lines take in a new sample they discard the oldest sample. In this post we discuss how delay lines work and implement a delay line in the C programming language.

A Theoretical Delay Line

For our purposes we will store primitive data types in an array. We’ll spare for this example both non-primitive data types, as well as, non-contiguous memory. The primitive data type in this array would be any of the following types: int, char, complex, double, or float. The memory for the delay line is monotonically increasing and continuous, meaning all memory addresses for samples are next to one another. Essentially, we’ll have a int delay[N] to declare our delay line. The delay line will store N samples. With each new sample we’ll throw out the oldest sample. Below is a figure to depict the state of the delay line on each new sample received.

UART Between Raspberry Pi and Arduino

Wed, 18 Mar 2020 14:02:54 +0000

Using a 2-wire serial connection we can communicate from a Raspberry Pi (RPi) to an Arduino. For the Raspberry Pi we’ll use the built in UART accessed through a tty, and the Arduino we’ll use the Serial Communication Library.

What this Example Does?

This example will use a RPi and Arduino to send a fixed message from the RPi to the Arduino. The Arduino will then echo what it receives back the RPi. The hardware used was a RPi B+ and the Arduino Due. The code is all in C/C++.

Daemon Example in C

Thu, 05 Mar 2020 08:24:36 +0000

Daemon Example in C

In this post we’ll look at daemon creation and demonstrate how to programmatically create daemons. We’ll go into the SysV recommendation of “double forking” for daemon creation.

What are Daemons?

Daemons are long running processes that run in the background with no controlling terminal - tty. Use cases for daemons are when the program needs to be available at all times and managed by the scheduler. Popular examples are nginx, postfix, httpd, sshd, cron, inetd. Many of these end in “d”, which is a convention for the name of a daemon. Daemons typically do not have the ability to write to stdout, or stderr, and have no means to connect to stdin because they have no controlling terminal. Having no controlling terminal is a big deal in daemons. If they could connect to a controlling terminal they could be used in nefarious ways. We guarantee the daemon cannot take on a controlling terminal by doing the so-called “double fork”. Usually, output from the daemon is done by writing to log files. These logs are typically written in the in /var/log directory. Input to a daemon, when necessary, is typically through sockets and signals. Let’s write an example daemon in C that runs on Unix.

Unix UDP Example in C

Thu, 27 Feb 2020 17:14:45 +0000

Unix UDP Example in C

In this post we’ll create an example client and server that communicate over UDP in C using Unix as the Operating System. UDP is a connection-less, unreliable datagram packet service. The term connection-less means there is no handshake between the client and server before information is exchanged. The term “fire and forget” applies here since the client sends and beforehand has no negotiation with the server. The term unreliable means there is no guarantee of delivery, ordering or duplicate protection. UDP is best for time-sensitive applications where it is preferable to discard packets rather than waiting for delayed ones.

Listing files in a Directory using C

Mon, 24 Feb 2020 17:40:14 +0000

Listing files in a Directory using C

Use the glibc scandir function from <dirent.h> to list all the files in a directory using the C programming language. The scandir function allows for sorting, comparing and filtering the names of files in the directory. There are default options to list alphabetically through the alphasort() glibc standard function. We’ll make an example in C that shows how to list all the files in a directory and give the name and type of each file in the directory.

Parse JSON with Flex and Bison

Sat, 22 Feb 2020 00:00:00 +0000

Parse JSON with Flex and Bison

A simple example that will parse JSON in C using Flex and Bison. Forewarning, while this example works well it’s not going to handle every JSON case. I’ll highlight the limitations of what cannot be parsed towards the end of the post. It’s a perfect example to build upon and extend though.

FLEX Scanner to Parse JSON

The scanner will create a token stream. Tokens are just regex matches made by flex that can also have values. For example a DECIMAL token we return a float by calling atof(yytext). Whereas, we also tokenize { to LCURLY, but there is no value. The ECHO macro is turned off, and can be turned on for further debug info.

Unix Virtual Network Device Types

Fri, 07 Feb 2020 00:00:00 +0000

Unix Virtual Network Device Types

This blog post attempts to list and describe the majority of Virtual Network Device types in Unix. Networking with Linux is a hot topic especially in the IoT and Datacenter areas. Read on and you’ll see a large array of Device Types found in Unix.

Background on Network Configuration in Unix

The iproute2 framework replaces ifconfig as well as many other commands. The command family ip link deals with network device configuration in Unix. We can use iproute2 to add, change, and delete network configurations. When adding a network using iproute2 we can do a ip link add name NAME type TYPE where TYPE is one of the many Linux Networking Device Types.

Creating IP Tunnels in Linux with iproute2

Tue, 04 Feb 2020 07:40:31 +0000

Creating IP Tunnels in Linux with iproute2

In this post we’ll use iproute2 to create tunnels between two unix hosts. This will be the simplest form of an IP-in-IP tunnel.

How the Tunnels will work

In this example we have two Unix hosts with IP addresses 10.255.254.96 and 10.255.254.196 on a 10.255.254.0/24 network and a gateway address of 10.255.254.2. These two hosts are on the same network. For this tunnel example we are going to add dummy interfaces to each of our hosts and assign addresses 192.168.2.111 and 192.168.2.222 addresses to each of them respectively. Once the tunnels are up we will be able to send a ping from the first tunnel to the second tunnel as if the hosts are on the same network. This is known as encapsulation, since inside an IPv4 packet with a source of 10.255.254.96 and destination of 10.255.254.196 we have another IPv4 packet encapsulated inside with a source of 192.168.2.111 and destination of 192.168.2.222.

Comparing Linux Distributions in Docker

Mon, 03 Feb 2020 07:12:23 +0000

I have the situation where I need to compare packages, settings, configurations across multiple Linux distributions. Docker is a great tool to pull images from all of the linux distributions to compare and contrast nearly anything you can think of. In this post we’ll create a simple docker compose file and run containers from the centos, alpine, ubuntu, archlinux, busybox and debian images.

The docker-compose.yaml file

First we’ll need to install docker-ce and docker-compose. Then create a simple docker-compose.yaml with the following content:

version: '3'
services:
 ubuntu:
 container_name: ubuntu
 image: ubuntu:latest
 command: tail -f /dev/null

 centos:
 container_name: centos
 image: centos:latest
 command: tail -f /dev/null

 busybox:
 container_name: busybox
 image: busybox:latest
 command: tail -f /dev/null

 alpine:
 container_name: alpine
 image: alpine:latest
 command: tail -f /dev/null

 archlinux:
 container_name: arch
 image: archlinux:latest
 command: tail -f /dev/null

 debian:
 container_name: debian
 image: debian:latest
 command: tail -f /dev/null

Regular Expressions in C

Sat, 01 Feb 2020 13:29:10 +0000

In this blog post we will construe some simple examples of regular expressions in C, also known as a regex. We will use the popular libraries PCRE and PCRE2. If you don’t know what a regex is or have never used them, then you can close this tab right now! Learning regular expressions in in C is probably the wrong way to go. Start with something more easy like Python, Perl, or anything else because doing them in C is difficult. If you know regular expressions from other languages, learning them in C will strengthen your understanding of the concept. This example is meant to be easy to understand, simple and useful.

HTML Select List for All Timezones

Fri, 31 Jan 2020 06:23:05 +0000

HTML Select List for All Timezones

I needed an HTML select for every Timezone and really couldn’t find what I was looking for. Here is an abbreviated version so you know what I’m talking about:

Abbreviated HTML Select of Timezones

A smaller HTML select with timezones which maybe a good starting point in the USA.

<select id="timezone" name="timezone" class="custom-select">
 <option value="Pacific/Honolulu">Pacific/Honolulu GMT-10:00</option>
 <option value="America/Anchorage">America/Anchorage GMT-9:00</option>
 <option value="America/Los_Angeles">America/Los_Angeles GMT-8:00</option>
 <option value="America/Boise">America/Boise GMT-7:00</option>
 <option value="America/Denver">America/Denver GMT-7:00</option>
 <option value="America/Phoenix">America/Phoenix GMT-7:00</option>
 <option value="America/Chicago">America/Chicago GMT-6:00</option>
 <option value="America/Detroit">America/Detroit GMT-5:00</option>
 <option value="America/New_York">America/New_York GMT-5:00</option>
</select>

Abbreviated HTML Select of Timezones in Action

What I especially liked about the value field here is it standard across platforms and programming languages. The reason is because this the value field if from the tz database. Other values you will see for the HTML option have offsets and all sorts of different ideas. These usually fail because when dealing with time one has to account for the dreaded Daylight Savings Time.

User Name Search with Apache Lucene

Thu, 30 Jan 2020 10:53:31 +0000

User Name Search with Apache Lucene

I wanted to use Apache Lucene to search User Names. It’s definitely not straightforward. This post explains how to do it by defining our own custom Analyzer and explaining how we form the Document, index the user names and query with a PrefixQuery.

First of all if you’re using Apache Lucene you’re my type of person! It’s an awesome project, but the documentation and examples are severely lacking.

VIM formatting JSON

Tue, 28 Jan 2020 08:44:41 +0000

VIM formatting JSON

Have you ever needed to format some gnarly JSON that is unreadable and/or too large to look through? It’s super easy to format it with vim. We can use the popular jq tool - link at the end of this blog post.

Simple Steps to format JSON in VIM

Here is an example with a file called hello.json.

Open a file vim hello.json
Open the file in VIM vim hello.json
We can format with the command :%!jq . -
Save the file :wq

Explanation

All we need is the command :%!jq . -. Let’s break this command down.

Why static declarations are confusing in C

Thu, 22 Aug 2019 18:32:31 +0000

The static variable in C is unnecessarily confusing because it is used for both the memory management model and for linkage. Since these two concerns are mutually exclusive another keyword would have really cleared things up in the linkage case.

A single keyword for memory management and linkage?

As you may know in C there are 3 methods of memory management models: automatic, static and manual. Automatic variables are what most programming languages use. Manual is memory allocated with malloc() and de-allocated with free(). It’s manual meaning you control allocation and de-allocation of memory. It’s static memory management we’re focused on in this post.

Implementing FIR Filters in C

Mon, 19 Aug 2019 16:00:21 +0000

Implementing FIR Filters in C

Implementing FIR filters in C is much easier if we make use of the static variables declared in our functions. In this blog post we will create some simple example FIR filters, and get their impulse response. To understand this post you will have to have the basic theory of FIR filtering down.

FIR Filter Implementation

There are a lot of ways to implement a FIR filter in C. The method provided makes the implementation simple because we can simply put the last time sample into the filter and the filtered result will come out. The filter function itself will handle the delay line of the time samples. It’s a bit abstract so let’s take an example of just creating a delay line of samples. Then later we’ll add in the FIR filter coefficients.

pthread barrier example

Mon, 12 Aug 2019 14:30:06 +0000

A Barrier in computing is a synchronization method where a group of threads cannot proceed until a condition allows the blocked threads to proceed. In this post we will construct an example of a Barrier that relates to men and women at the dinner table using pthreads. We will men waiting to get their food, but the men will be blocked until the woman has eaten, thus, trigger the start state of the Barrier. Ladies First!

Example FFT in C

Thu, 08 Aug 2019 00:00:00 +0000

Example FFT in C

In this post we’ll provide the simplest possible Fast Fourier Transform (FFT) example in C. After understanding this example it can be adapted to modify for performance or computer architecture.

FFT Example Usage

In the example below we’ll perform an FFT on a complex (real + imaginary) array of 32 elements. After the FFT has completed it will write over the provided arrays as the FFT is done in place. Note, we’re using floating point here and not fixed width. Thus, if you don’t have a math coprocessor it will be very slow.

pbcopy/pbpaste in WSL

Tue, 30 Jul 2019 00:00:00 +0000

pbcopy/pbpaste in WSL

If you’re looking to replicate the pbcopy and pbpaste commands in WSL then you’ve found the right place! In this post we will make some simple shell scripts to replicate pbcopy and pbpaste in OS X. If you’re accustomed to pbcopy/pbpaste in Mac OS X, it’s hard to not have the equivalent in WSL. One spoiler alert the commands just are not as fast as they are in OS X.

A Useful Linked List

Fri, 26 Jul 2019 22:23:08 +0000

A Useful Linked List}

In this post we will create a useful Linked List in the C Programming Language. This is opposed to all the useless linked lists that I’ve seen on the internet. They are numerious, typically written by academics that haven’t much experience programming. It’s not the logic or syntax that is bad, but the API and functions they create that make the usage of the Linked List obtuse and awkward. This implementation of a Linked List in C is something meant to be used over and over again in projects.

Learning how the Internet Works

Fri, 26 Jul 2019 07:28:41 +0000

Learning how the Internet Works

The Internet is the most complex public service ever created! The Internet is truly amazing. Curriculums from four year College Institutions focused on Computer Science and/or Programming Background don’t spend much time teaching The Internet.

Recently, I found myself tired of the Interenet being a black box and pursued a deeper understanding. I wanted to post about how I obtained a deeper understanding of the internet and jot down some of my notes and references.

SQLite Transactions Part 1

Tue, 09 Jul 2019 06:43:41 +0000

In the world of software these days it is expected that applications do multiple things at once. With that said it’s pretty typical that multiple processes or threads have read and write access to a database. In this post we will go over transactions in SQLite which prohibits changes made to the database unless they are inside a transaction.

Defining a Database Transaction

Let’s first define a database transaction which is essentially to carry out or conduct to a conclusion. In the context of a database a transaction is a grouping of SQL commands. We can consider this transaction to be atomic in the sense that all the commands will execute successfully or it will fail.

Adding SQLite to a C Project

Sat, 06 Jul 2019 10:43:41 +0000

Adding SQLite to a C Project

Let’s add SQLite to your C project. It’s easy and straightforward. We’ll use the SQLite.org recommended way by adding the so-called “amalgamation” to our C project and compile from source. In the words of SQLite.org “the use of the amalgamation is recommended for all applications.” In this blog post we’ll download, compile and use SQLite in our C project.

Step 1 - Download the SQLite Amalgamation

In Step 1 we’ll download the amalgamation and look at the contents of the files. This is done by doing to the SQLite downloads and downloading the zip file in the “C Source Code as an amalgamation” section. Let’s download the zip file and see what is inside it:

Enable CORS when not Supported

Fri, 05 Jul 2019 07:40:01 +0000

Some services don’t support CORS, but we can use NGINX to make CORS supported with this simple hack! To enable CORS on any service we need to have NGINX configured as a Reverse Proxy and have NGINX add a successful pre-flight response to the CORS pre-flight request. Read on to get this simple example to work.

Let’s back all the way up on why CORS is needed? Security! What if we could write Javacript on a server somewhere and that Javascript could use any back-end server it wanted for requests? That would introduce huge security vulnerabilities. For example, I could write a webpage that looks like a store, but not have a back-end for the store at all and send bogus orders to another store somewhere else on the internet that my site isn’t affiliated with. CORS gives us security that a front-end and back-end match up. From the back-end we can control what front-end has access to the back-end and also what requests that front-end can make.

Flex/Bison Autotools Project Creation

Tue, 25 Jun 2019 11:15:00 +0000

Let’s create a basic Flex/Bison Project with Autotools. The GNU Documentation for Automake specifies Flex/Bison Support. We will take it a step further and provide a complete example with a Flex Scanner and Bison parser.

See the previous post Autotools Project Create Template. This allows us to create a boilerplate Autotools project. Then we can add the Flex/Bison support on top of the basic autotools project.

Let’s create a project called fbbasic with the Autotools Project Creation Template:

Copy Paste with Neovim in WSL

Tue, 25 Jun 2019 00:00:00 +0000

Copy Paste with Neovim in WSL

Copy (Yank) and Paste doesn’t work in neovim because it cannot access the System Clipboard on WSL - Windows Subsystem Linux. This simple small hack solves this issue. This hack works without having to install X Windows or any other tools.

Update Neovim Official Solution. The solution posted in this blog post works, however, at the time there was no official solution. Now see the official solution using the win32yank binary. I honestly have not tried the solution posted herein for sometime as I no longer have WSL. There maybe a neovim clipboard provider that works and is built in. In the solution provided we create a pair of Unix scripts to act as that provider if you don’t have the win32yank binary.

Autotools Project Creation Template

Mon, 24 Jun 2019 07:26:00 +0000

Autotools Project Creation Template

This post has a simple bash script to create a basic Hello World autotools project with a single command. The justification for this autotools script is I’ve not seen a consolidated script that keeps it simple in one place. The script creates a boiler plate autotools hello world project. Here is what it does:

Creation of configure.ac with project name, version, and email
Creation of root Makefile.am which just points to the src/Makefile.am
Creation of src/Makefile.am which will make a binary and has a single source file main.c
Creation of a autogen.sh which will run autoreconf --install
Creation of a .gitignore so we know what autotools files should be under version control
Creation of a main.c which just prints “hello world” to stdout.

After we have created the files above all we need to do is run a ./autogen.sh and our project will be ready to run the infamous ./configure, make and make install.

Passing Datagrams Between Python and C

Tue, 18 Jun 2019 06:45:00 +0000

Let’s discuss how to pass data from a C program to a Python Script and vice-versa. This subject involves IPC - Inter-Process Communications. In this blog post we’ll discuss the more exotic IPC mechanism of the Unix domain datagram socket. Specifically, this is domain AF_UNIX and type SOCK_DGRAM type of socket. Before you consider this method let’s address some of it’s benefits and limitations of using Unix Domain Sockets for Interprocess Communications:

C Double Pointers

Mon, 17 Jun 2019 16:45:00 +0000

C Double Pointers

double pointers in c

Updated December 19, 2022

Examples and explanations of single pointers are used throughout many programming languages including C. This blog post explains and explores use cases for double pointers in the C programming language. Toward the end we’ll look at a glibc example that uses a triple pointer.

Use Cases

The primary use cases I’ve found are the following:

Arrays of strings char *. These strings are typically not fixed length. Thus, char *buf[N] is a bit misleading since N will vary.
Functions that allocate memory for the caller. In this case the caller is expected to free the allocated memory after finished.

Mental Model

What is the difference between a char **foo and char *foo[]? Let’s take an example program:

Autotools Hello World

Thu, 30 May 2019 14:46:00 +0000

Autotools Hello World

Don’t Listen to the Autotools Haters

Being an avid C and Unix Geek, I decided to ignore all the hate out there about GNU Autotools and try it for myself. For those of you that don’t know the GNU Autotools suite consists of Autoconf, Automake and Libtool. You’ll see some major criticisms out there from people saying it’s way too complex, challenging, hard to use as well as all sorts of other criticisms. Let’s face it though, build systems are complex. I’ve used all sorts of them. Communities love to re-invent the wheel and build their own tool but at the end of the day to support everything is a massive endeavor.

Processing Emails with a script in Postfix

Sat, 27 Apr 2019 07:56:00 +0000

Updated Feb 7, 2020

After thinking about this post more, it’s true you can process emails with a script in Postfix. The post provides the right answer to the wrong question!! You can certainly process emails with Postfix but it’s hard, brittle, reduces performance and really isn’t recommended. What is better is to have a client program that reads the mail and does what you desire. This client can be put on a cron job, triggered or run however you want. The client is very flexible and so many different programming languages support them. This gives a lot of power to mark emails read, manage folders, etc … It’s just a cleaner, better, easier to use and test architecture than having a script in Postfix. So I’ll leave this up, but, I wouldn’t use it unless there is some reason I cannot think of how it would be better.

Java Cyclic Barrier

Mon, 25 Feb 2019 08:00:00 +0000

Java Cyclic Barrier

Imagine a scenario where you have N threads and can only do something when M of them are ready. Java already has this built in since 1.5 with the CyclicBarrier.

From the Javadoc we see the CyclicBarrier is A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point. CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other. The barrier is called cyclic because it can be re-used after the waiting threads are released.

Java Multicore Example

Sun, 24 Feb 2019 14:57:00 +0000

Java Multicore Example

Any program these days that does any significant computational load should utilize the available processor cores. In this post we’ll show an example using Java where we schedule Callables on all available processor cores. In Java a Callable is task that returns a result and may throw an exception. It is very similar to a Thread, but gives a much easier way to return the result asynchronous computation. I typically don’t see many reasons to not use Callables over Threads, since even if you don’t want or need to return the result you can still return some sort of status code. This blurb is directly from the Javadoc The Callable interface is similar to Runnable, in that both are designed for classes whose instances are potentially executed by another thread. A Runnable, however, does not return a result and cannot throw a checked exception.

PSK31 Convolutional Decoder Implementation in C

Wed, 13 Feb 2019 00:00:00 +0000

PSK31 Convolutional Decoder

In my humble opinion decoding a convolutionally encoded PSK31 output stream is the most challenging part of all. Decoding is also where all the magic happens. The Viterbi Decoder corrects the erroneous bits and allows reception of the intended bit stream.

If this is the first time you’ve heard of a Viterbi Decoder please look at the former link from Wikipedia as well as these great examples that are in links below. What these examples allow you do is better visualize the entire state machine since they have a very small value for K and only 4 states. What we have here in QPSK31 is 32 states and it makes it a bit inconvenient to use this as the first example to learn Viterbi Decoding. Also, be very comfortable with PSK31 Convolutional Encoding and the state machine it uses, the generator functions, shift register and process to encode a bit stream with the PSK31 convolutional encoder.

PSK31 Convolutional Encoder implementation in C

Wed, 13 Feb 2019 00:00:00 +0000

PSK31 Convolutional Encoder implementation in C

PSK31 Convolution Encoding

Convolutional Codes are often charactarized by three aspects:

n Base Code Rate - Number of bits into the encoder
k Output Symbol Rate - Number of bits out for an input
K Memory Depth

For QPSK31 we have [n,k,K] = [1,2,5]. We give the encoder 1-bit of input, out comes 2-bits, and 5-bits of input are stored in our shift register. For the 2-bits of output 1-bit is In-Phase and the other is Quadrature. Let’s look at a diagram that allows us to envision [n,k,K].

Root Raised Cosine Filter in C

Wed, 13 Feb 2019 00:00:00 +0000

Root Raised Cosine Filter in C

Root Raised Cosine Filtering

The PSK31 Standard uses Root Raised Cosine Filters as a matched filter. Our PSK31 signal is convolved by the Root Raised Cosine waveform to mimimize Inter-Symbol Interference. For this project we can easily compute the RRC filter and then convolve it with our output stream. For the computation of the RRC we need a couple of constants specific to the PSK31 standard.

Simple SQLite C API Example

Sat, 02 Feb 2019 16:45:00 +0000

When getting started on the SQLite C API they recommend 2 basic ways: sqlite3_exec() and sqlite3_get_table() both are convenience wrappers around the core API Calls. They give good examples for the sqlite3_exec() call, and the sqlite3_get_table() is deprecated in the documentation. Using sqlite3_exec() employs a callback function which gives the advantage of speed and low memory usage - due to being able to process each row at a time. It however, does not allow for knowing when all the rows are returned, as well as, being synchronous.

Simple Convolution in C

Wed, 17 Oct 2018 06:10:00 +0000

Simple Convolution in C

Updated April 21, 2020

In this blog post we’ll create a simple 1D convolution in C. We’ll show the classic example of convolving two squares to create a triangle. When convolution is performed it’s usually between two discrete signals, or time series. In this example we’ll use C arrays to represent each signal.

When implementing convolution it’s important to know the length of convolution result, since the resulting array is bigger than the two input arrays. This can cause memory problems. Computing the length of the convolution result is actually a simple computation. If you have array H convolved with array X, where the lengths are 5 and 5 respectively, the resulting size of Y=H*X (H convolved with X to make Y) will be Length(H) + Length(X) - 1. For this example the resulting length of two size 5 arrays will be 5+5-1 = 9. This convolution is typically done where H is a digital filter and X is a time series to be filtered. The output array Y is the time series that results after filtering. For our example we have input arrays H and X. The output of array of our convolution will be called Y.

NGINX/CouchDB Reverse Proxy

Wed, 10 Oct 2018 03:10:00 +0000

Using NGINX as a front-end server to forward to multiple back-end services works great by configuring NGINX as a reverse proxy. The reverse proxy configuration will have NGINX serve HTTP/HTTPS URLs and forward them to them to network addresses such as a database listening on HTTP at a specific port, API servers, static websites, etc. Basically we can turn NGINX into an HTTP router. NGINX is also a great front man for back-end services such as HTTPS and HTTP/2. For instance if you had a Database, API Server and static site you could have an SSL certificate just for NGINX and they would all be behind HTTPS and the reverse proxy would convert the HTTPS and send HTTP. That’s a post for another time however.

Viterbi Error Correction

Sat, 06 Oct 2018 08:30:48 +0000

Viterbi Error Correction

I’ve built a little PSK31 convolutional encoder and decoder and originally wanted to make a graph showing the error correction capabilities as a function of encoder output length and number of bit errors into the decoder. Making a long story short; I couldn’t devise a good method of creating this graph and stuck to hand making error cases to see the performance of the decoder. Note, the quantization for both the encoder and decoder are hard metrics using the Hamming Distance which doesn’t perform as good as soft metrics. First, let’s define the convolution encoder input and output.

Number of Programming Languages

Fri, 21 Sep 2018 09:14:48 +0000

Number of Programming Languages

What are the similarities and differences between spoken languages and programming languages?

What are the effects of having a large number of programming languages?

When I mow the lawn or drive to work I often listen to Podcasts if I don’t listen to audio books. I recently came across a Podcast Freakonomics - Why Don’t We All Speak the Same Language? (Earth 2.0 Series) and being a programmer myself I related the discussion of human languages to programming languages. Here are the points from the Podcast relevant to this dicussion on human languages that I want to use to relate to my view on Programming Languages:

First Post

Sun, 16 Sep 2018 14:40:48 +0000

Hello All! This is the first time I’ve tried blogging. I “do” IT for a living and am involved in all sorts of Software. I’m usually tinkering around doing technical projects with software and hardware so I figure I’d blog about it. Mostly to just blog on what I’ve been doing, hopefully I’ll get a good discussion going and maybe help someone along the way. There are a couple of Open Source projects I’d like to get kicked off. We’ll see where it goes …

PSK31

Sun, 16 Sep 2018 14:40:48 +0000

PSK31

A little side project - that actually turned in to a larger project is an implementation of the PSK31 Specification. I’m hoping to create an Open Source Project likely called OpenPSK31 or something similar. This specification could use some improvements with all the advancements we have in computational power and software over years since the specification was created in 1998. I’ve created a place on this site for PSK31 to document the project I’ve done. Not all the content is there yet, but I’ll be blogging about the updates as they come in. A fully working PSK31 system has a lot of moving parts and I hope to power through and get something that can both send and receive PSK31. The focus will be on the QPSK31 part of the specification so the convolutional encoding and decoding is used to correct bit errors.

About

Mon, 01 Jan 0001 00:00:00 +0000

Welcome to my Geek Blog!

About

I’m a Husband and Father of two Beautiful Girls who lives in Colorado. I currently work in IT. My background is in Computer Engineering and I’m interested in all things involving Software and Hardware.

Opinions

The opinions in this blog are my own and don’t represent that of my current, or past employers.

Contact Me

Contact me at lloyd.rochester@gmail.com. However, don’t contact me if you’re a student and want me to do your homework!

License

Mon, 01 Jan 0001 00:00:00 +0000

License

The work contained in this blog is licensed under a

Lloyd Rochester’s Geek Blog is licensed under a Creative Commons Attribution 4.0 International License. Based on a work at [/].

Navigate

Mon, 01 Jan 0001 00:00:00 +0000

Home on Lloyd Rochester's Geek Blog

Hello World on SSD1306 using Arduino

Hello World on SSD1306 using Arduino

DNS Proxy in C

DNS Proxy in C

Proxy Server Paradigm

Network Programming Rant

Network Programming Rant

Browser UI using sshuttle VPN in WSL

Browser UI using sshuttle VPN in WSL

Browser viewing a UI in Windows using sshuttle in WSL as a VPN

Learn the FFT

Learn the FFT

FFT Butterfly Diagram

Time Conversion in C

Time Conversion in C

Understanding Process Execution

Understanding Process Execution

Remote Process Execution

UART Theory and Programming on the Raspberry Pi

UART Theory and Programming on the Raspberry Pi

Understanding memory reallocation with realloc

Understanding memory reallocation with realloc

Table of Contents

Heap Example

Read a File into an Array in C

Read a File into an Array in C

Timer example in systemd

Timer example in systemd

Creating a systemd timer

Logical Requirements

Differences between lists in Unix

Differences between lists in Unix

Unix comm command - Difference between two lists

Examples

Example with Files

Realtime Lidar Measurements with NodeJS

End Result

Unix Command for Epoch Time

Unix Command for Epoch Time

Table of Contents

Print the Epoch

Skull with Blinking Red Eyes for Halloween

Circuit Functions

Circuit

Ebyte e32 Lora Module - Client Socket Examples

Ebyte e32 Lora Module - Client Socket Examples

Prerequisites

Ebyte e32 Lora Module - Wiring and Configuring the Raspberry Pi

Wiring

Ebyte E32 Lora Module - systemd service

Ebyte E32 Lora Module - systemd service

Ebyte E32 Lora Module - Transfer Files

Ebyte E32 Lora Module - Transfer Files

Prerequisites

Transferring Files Between two Raspberry Pi Boards

Receiving

Stack Protection with a Canary

Stack Protection with a Canary

Example

Ebyte e32 - Sockets

Ebyte e32 - Sockets

Intention of the Sockets

Finding Libriaries and Headers for C Programs in Unix

An example from the beginning

Using libgpiod to detect input events

Using libgpiod to detect input events

GPIO Input with libgpiod

GPIO Input with libgpiod

Input Circuit

Blinking an LED with libgpiod

Blinking an LED with libgpiod

Table of Contents

LED Driver Circuit

The new GPIO Interface on the Raspberry PI: libgpiod

The new GPIO Interface on the Raspberry PI: libgpiod

Raspberry Pi SPI Explained

Raspberry Pi SPI Explained

The Basics of SPI on the Raspberry Pi

Implementing a Timeout for a read in C

Creating a `systemd` timer

Epoch using `clock_gettime` from `time.h`