Maskset | Manufacturing, Electronics, Software, Mechanics, & IC Design Notes to Self on Maskset

About

Sat, 08 May 2021 00:00:00 -0400

Contact

Shoot me an email: simon@maskset.net. I’m always happy to hear comments or help out motivated people build useful things.
If you’re in New York come to a Fat Cat Fab Lab open house! Meetup Link.
When I’m in Houston you can usually find me at the ION or hacking at TXRX.

About Me

This is my personal blog mostly focused on the various nonconfidential discoveries and tools made as a measurements system designer with ElectroOptical Innovations. We’re a small highly technical shop designing a wide breadth of challenging systems. Some of the products that we develop are available from Hobbs ElectroOptics.

FreeCAD FEM Workbench Setup

Mon, 29 Sep 2025 20:18:47 -0400

Getting started with a new simulation tool is hard enough without needing to worry about the installation. There’s a lot to love about the FEM Workbench that ships with FreeCAD. Interoperability and ease of setup isn’t it.

Out of the box, the Flatpak build includes:

Gmsh (mesher)
CalculiX (solver)

But it’s missing:

Netgen
Elmer
Z88
Mystran

This Dockerfile pulls in:

The FreeCAD AppImage (which includes Netgen)
Elmer FEM (via PPA)
Z88 Aurora (via official tarball)

Mystran isn’t included — they don’t provide Linux binaries. I may add a build later if needed.

Zephyr and MCUBoot

Fri, 12 Sep 2025 14:38:27 -0400

Introduction

The following goes through a recommended Zephyr project setup and integrates it with a single stage MCUBoot bootloader. The first section uses the Renode emulator and then moves to actual hardware.

In previous posts we introduced Renode Docker Setup on Ubuntu 24.04 and a Bare-metal MCUBoot Port on Renode. This article moves up an abstraction layer and uses Zephyr with MCUBoot. Zephyr and the build tools are installed locally (Ubuntu 24.04), in a way similar to the instructions in the Docs.

Shuffling Strategies in War

Sun, 07 Sep 2025 17:24:26 -0400

TL;DR: Bury your Aces Counterintuitively, in War you don’t want your hand to be packed with strong cards.

Simulation code available here.

Introduction

The card game War is, at its core, a game of dumb luck. Whoever gets the better draw usually walks away with the win. But there’s at least one way to get an edge.

Here’s the version I grew up playing:

Cards you win go into a discard pile.
When your hand runs out, you fold the discard pile back in.
When you recombine you may shuffle.
If your opponent recombines, you can combine and shuffle too.

That single choice of when to shuffle cracks open a surprising little window of strategy in an otherwise mindless game.

Bare-metal MCUBoot Port on Renode

Fri, 29 Aug 2025 15:20:35 -0400

The code for this project is available here.

Why use Renode?

Faster Iterations: It allows faster testing without the delays of physical hardware, especially useful when tweaking bootloader and firmware behavior.
Flash Wear Prevention: Running tests in Renode prevents flash from being worn out due to frequent writes (especially useful while you’re still debugging).
Continuous Integration (CI): Test your actual build in CI setups.
Development Without Hardware: Enables software developers to work on embedded projects without needing the actual hardware.

Setup

Note

Zephyr's CMake or west manager will look after almost all of this for you.

I started with the Interrupt article here on porting MCUBoot to a bare-metal project, ported it to a CMake project and added the Renode and VSCode scripts, building on my previous post: Renode Docker Setup on Ubuntu 24.04.

Renode Docker Setup on Ubuntu 24.04

Wed, 27 Aug 2025 12:24:29 -0400

Renode is a C# based emulator for embedded architecture, it’s like if QEMU was focused only on embedded. It’s lightweight and effective with several preconfigured chips ready to use.

What to use it for and why you should care

Easier, automated testing of distributed systems (think CANBus networks, distributed control robotics, mutli-sensor systems etc)
CI/CD: Integration and smoke tests done with your actual build, one step down from hardware-in-the-loop with way less setup
Low level development (i.e bootloaders): Bootloaders are a pain to write and need to be rock solid. You spend a lot of time dealing with the low level details which you can’t test with unittests on a different architecture without emulation. Emulation lets you speed up iteration time and increase visibility.

Goals

The following uses the Renode Docker container distribution and integrates it into VSCode for visual debugging. The code and configuration for this example can be found here.

SCPI for Embedded Systems

Tue, 26 Aug 2025 20:36:53 -0400

Introduction

When I’m designing the control interface for a new device intended for lab equipment use or an OEM device that doesn’t require constant high data rates, SCPI is the obvious first consideration. It’s human-readable and ASCII-based, which makes it suitable for debugging over serial terminals but less suitable for high-throughput or lossy links (though you could add manual CRCs to detect corrupted responses). It is also the language that every other lab device speaks so sticking to the standard is a good first step.

Ceramic Capacitor Characteristics: Pay attention to C(V)

Tue, 26 Aug 2025 14:45:32 -0400

Introduction

During electronics design reviews, it’s overwhelmingly common to find changes are needed for basic bypass and DC storage caps due to ignoring the C(V).

The Voltage Rating is the maximum operating voltage that doesn’t risk (immediate) damage.

C(V) refers to the the change in capacitance with DC bias (voltage).

For high-density capacitors, the capacitance drop is frequently near 90% at the rated voltage. If this isn’t designed around then it can lead to instability, brownouts, and excess noise.

Setting Up Compile Commands for C & C++ for Neovim

Tue, 26 Aug 2025 12:19:56 -0400

Quick tip on enabling Neovim LSP for C/C++ using Clangd

TL;DR: Add this to your CMakeLists.txt:

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

This will generate a compile_commands.json file in your build directory. Copy or symlink it into your project root so that clangd (and Neovim) can use it.

Language servers are wonderful for navigating large codebases. Being able to jump to a definition really speeds up understanding the code you’re staring at (especially in library heavy codebases). Neovim (especially with distros like LazyVim has excellent LSP support, but C and C++ require extra setup compared to languages like Python.

Method for Reading Thermistors

Sat, 02 Aug 2025 10:02:45 -0400

The thermistor model, jupyter notebook and C++ code I used is available here.

Introduction

So you’re using a thermistor to measure temperature and need to digitize it. Let’s assume you’re trying to get an accurate temperature reading in real units (I’ll use kelvin for that scientific flair). Let’s see how good we can make this measurement.

Thermistors have been around for a long time which usually means we should start by looking in The AoE and browsing EDN’s old issues.

Pulse Transitions Library

Sat, 26 Jul 2025 23:15:27 -0400

Github Repo: pulse_transitions

Over the past few months, I’ve found myself repeatedly needing step response analysis for control systems, TDR work, pulsed light sources, photoreceivers, and flash lidar applications. Matlab has a solid set of tools, but nothing equivalent existed in Python so here’s that library.

The control library has a step_info function, but it’s built around transfer functions rather than real waveforms.

Second order transfer function analysis plot

matpulse: Pulse Transition Library Inspired

I haven’t gotten to the multiple transitions yet but the pulse analysis functions are done. The library has a matpulse module that tries to stay as close to the Matlab interface as python can. The same functionality with more reasonable naming schemes are available in the main namespace.

Compact Time Domain Reflectometer

Fri, 25 Jul 2025 14:02:57 -0400

Introduction

TDRs don’t exclusively belong in $10K benchtop boxes. Ours fits in your hand, handles field abuse, and still gets sub-100 ps resolution. We’ve been developing this one for a few precision agriculture and infrastructure monitoring applications. TDR has a lot going for it as a measurement scheme, particularly in industrial, agriculture, and field applications. It’s insanely robust compared to other common methods and can be embedded directly into the sensing element if you design it right.

Enforcing Type Safety in C++

Mon, 14 Jul 2025 09:24:52 -0400

Correction

The examples here are all in microvolts but includes multiplication and division which is dimensionally incorrect. I prefer to remove operator* and operator/ in favor of explicit functions for those calculations which can be done for all the referenced libraries.

Introduction

C++ is a statically typed language with relatively weak type safety. This can be useful and definitely cuts down on the lines of code. Of course so does removing all newlines and comments. Operations like multiplying floats and ints almost always behave as expected, allowing you to ignore the type differences (provided you turn off enough of your compiler warnings). Strong typing helps force the intent of the author to be literal: improving readability while adding compile-time checks. One example I’ve been burned on before is changing the order of operations in an arithmetic statement leading to precision loss. This is not something that we want to happen.

Product Announcement LP870

Wed, 09 Jul 2025 10:59:54 -0400

It’s been a busy couple of decades but one thing that is helping us get some time back is our (relatively) recently launched LP870 Nanosecond LED Pulser. We’re now on Version 2, which improves further on the original’s performance achieving typical 10–90% rise/fall times of 2.2/1.3 ns. This makes the LP870 suitable for testing even some of the fastest photodetectors.

LP870 LED Source

We designed the LP870 as a general-purpose high-speed light source ideal for testing photodiodes, APDs, SPADs, and SiPMs. In most setups, its serves as an infinitely fast optical source perfect for characterizing transient response or bandwidth.

Improving Python CLIs with Pydantic and Dataclasses

Tue, 01 Jul 2025 09:19:26 -0400

I’ve been updating and upgrading some of my favorite CLI tools recently and writing a few parametric tools that benefit from fairly long configuration files. I was originally using vanilla dataclasses with some organic, homemade, grass-fed validation code until I caved and used Pydantic.

Pydantic builds on the dataclass foundation but makes clearly specifying and validating structured data input surprisingly pleasant. Say you’re using a JSON, TOML, YAML, SExpressions, XLSX or whatever input. At some point you’re going to turn that into a dictionary or a dataframe. With Pydantic you can described the whole nested structure as classes with classes as member and shove the entire dictionary into it. If the data is valid and the validation passes then you’ll end up with an instance of your schema that looks and feels like a dataclass.

Using Kicad With Docker to Manage and Upgrade Release Versions

Mon, 30 Jun 2025 09:13:34 -0400

Introduction

KiCad is a wonderful tool that is constantly improving. Part of that is the steady release of new features, along with major version updates (approximately) once per year. Changing versions will give you some new features, fix some bugs, and introduce some new ones just like any other software update. If your system has only one version installed, upgrading becomes a significant decision. Once you update what do you do with older projects made with previous releases? It’s not just the main program either, there are the different parts libraries, the script control bindings, as well as any scripts or tooling that might need to be updated for the new version. All these components need to be managed in a reliable, repeatable way to ensure our designs remain accessible over time. Managing those changes, especially in a production or long-term support environment, isn’t trivial. Designs depend on stable libraries, predictable behavior, and consistent tool outputs. If you’re maintaining a complex board or a product family, one thing you don’t want is for your designs to churn.

FreeCAD 2D Projections

Wed, 18 Jun 2025 11:52:47 -0400

Quick note here. SVG export of a 3D part in FreeCAD’s PartDesign/Part workbench has some flaws. It only works in one dimension and all the edges are superimposed which reliably confuses all the systems I’ve tried. Instead use the draft workbench to do the projection.

Arrange the viewport (the camera) to the angle you want to project.

3D part that we want to take a top down projection of.

Select the part and select ‘Shape 2D View’.

Optimal SMA Launch Layout

Sat, 14 Jun 2025 17:38:04 -0400

Introduction

We’ve recently been working on several compact, robust, and cost effective time domain reflectometers (TDR) devices for integration into larger systems. Our most recent one, the TDR01, has 60ps sampled edges with a unit cost under $15 which we were pretty happy with. This version is a bit more fully featured then our single diode sampler. Phil has a post up on EOI’s page about the project here. We’re working on releasing those as a headless USB controlled model later this year, get in touch if you’re interested in evaluating those.

Tuning PI Controllers for Thermoelectric Coolers

Thu, 12 Jun 2025 08:53:34 -0400

The code and plotting notebook for the following is available here

Summary

This article discusses tuning a thermoelectric cooler (TEC) controller for real-world applications and highlights the unique advantages of TECs. The plant is characterized as a delay-integrator thermal system using a step response and applies Skogestad’s SIMC method for PI tuning. We then explore considerations specific to systems that both heat and cool versus those that only do one and how the models respond to external forcing.

Antmicro Kmake

Mon, 09 Jun 2025 19:22:21 -0400

I came across this tool recently: kicad-make and tried it out. Well it’s actually be floating around in my collection of GitHub stars I periodically extend whenever there’s a new problem to solve. I’ll let the fact that they named their repo the same as mine, kicad-make, slide for now. Antmicro has a solid track record—particularly in contributing to open-source tools for hardware development, which is something I deeply appreciate. So I had high expectations going into this.

Hugo Comments With Docsy and Giscus

Thu, 29 May 2025 10:55:03 -0400

Giscus is a super lightweight comment system powered by GitHub Discussions. It uses a GitHub app plus a small JavaScript snippet to embed a comment section on your site. If someone comments, it automatically creates a GitHub Discussion and syncs replies. See the bottom of this post for a live example. There’s no backend, no database, and if your readers have a GitHub account, that’s all they need. Here’s how I integrated it into a Hugo site using the Docsy theme.

Making an Appimage

Mon, 26 May 2025 19:53:21 -0400

When I updated to Ubuntu 24.04 I had an upsetting number of packages break. One of these was AppCSXCAD. It reads OpenEMS XML geometry files and shows them in a GUI. Nothing exciting until you need it. My first move was making sure I could use the Dockerized version in my OpenEMS Docker build here. That needed some attention but it worked in the end. What I really want is an appimage that I can pull down when needed.

Ordering From Macrofab with KiCad

Sat, 24 May 2025 18:59:14 -0400

TLDR

There’s an example project manufacturing package of the Scopefun V2 up here. Checkout kicad-xyrs and kicad-make for ordering KiCad projects with Macrofab.

Introduction

I recently toured MacroFab’s Houston facility and came away impressed. It’s a clean, efficient shop with a solid reputation among engineers I trust. They have a hybrid model with in-house manufacturing with a North American partner network. That’s a win for prototyping speed, reliability, and a healthier domestic supply chain. For projects that don’t need white glove service this is a great solution. They have an auto-quote engine which does a DFM check when you upload. They have some demos that are worth exploring here.

EDA Tools

Wed, 21 May 2025 10:49:02 -0400

Efficient design depends just as much on project management as on technical tools. Below is a curated list of tools I use and some I maintain for managing electronics design projects.

The majority of the functions eventually make there way into my KiCad Makefile (kicad-make).

There are similar systems, including ones with many more features such as KiBot. I steered away from these methods once kicad-cli was introduced as they are fairly heavy weight in comparison.

Semantic Versioning for Electronics Design

Tue, 20 May 2025 19:26:59 -0400

Updated: 2025-05-20

Summary

This is a practical system for versioning and tagging electronics to streamline prototyping and development. It mirrors Semantic Versioning 2.0 described here but adapts to the realities of hardware. This convention is intended for printed circuit boards (PCBs) and printed circuit board assemblies (PCBAs).

Here we change PATCH to SUBREVISION as PATCH is a software specific term. Given a version number MAJOR.MINOR.SUBREVISION (analog of MAJOR.MINOR.PATCH), increment the:

MAJOR: When you change the interface or mechanical form factor
MINOR: When you change the layout or schematic
SUBREVISION: When you change the BOM or population option

Major Version: Interface & Form Factor

Roll the MAJOR when any of the following occur:

Electromagnetic Simulators List

Mon, 19 May 2025 11:47:46 -0400

OpenEMS Optimizing Simulator

Sat, 17 May 2025 10:59:51 -0400

Introduction

Over at EOI we’ve been working on a time domain reflectometer (TDR) for precision agriculture for the past few months. The waveguide assembly has several competing design constraints. The following is an overview of a a surprisingly effective parameterization and optimization strategy for designing the waveguides structure. Using OpenEMS, OpenSCAD, SciPy, Docker, and a bit of Python we had an optimized form factor after a few days.

Here’s an example of the resulting waveform, showing a 214 ps rise time.

Managing Openscad Projects

Fri, 16 May 2025 00:00:00 -0400

Why Structure Your OpenSCAD Projects?

OpenSCAD is powerful, but as projects grow, managing complexity becomes critical. Plus you’re already ditching the GUI for a descriptive language, are you going to be chained to the GUI for exporting files?

Properly organizing your files and code enables:

Design abstractions with no concrete data. ex. evenly spaced grid of holes in a square plane, holes in a test jig pressure plate, etc.
Simple reuse and updating of a design
Reduced duplication
Scalable part creation and layout logic

Common Challenges and Solutions

Challenge	Solution
Reusing code and libraries	Use `OPENSCADPATH` to add custom library directories to search path
Need access to high-level modules from lower-level files	Instead use dictionary lists for data that must be shared with abstractions
Sharing variables across files	Define accessor functions (e.g., `get_param()`) to expose variable. Avoid if possible.
Sharing parameterized code	Encapsulate reusable abstractions in a dedicated library file and specialize only in top-level designs
Generating manufacturing files	Create a new file for each output type. Put into a separate directory. Each of these files should call out only a single use statement and a single module call.

Project Structure

The project structure I use for OpenSCAD is the same as I use for FreeCAD or shudder with closed source CAD. For a complicated project there’s an Assembly which has all the parts fitting together. Much of the design is done with the Assembly itself. If the project has been decoupled elegantly this may not be as necessary. So you have an assembly of parts composed of abstractions with specialized data passed into the component modules.

Tariff Math for Two-Layer Prototype PCBs: OshPark vs Imported Fabs

Thu, 15 May 2025 00:00:00 -0400

Introduction

If you’re a US-based hobbyist, consultant, or small-batch hardware developer, PCB manufacturing has just changed a bit. Back in 2018 when the first batch of Chinese tariffs were introduced we got hit with a surprise bill and an import nightmare (well minor inconvenience but it felt dramatic at the time). Those tariffs landed during a government shutdown and a CBP computer glitch so our boards ended up doing two laps of the globe before we got them. I use a lot of 2 layer boards as I prefer them to just about any amount of hand-wiring. With the various price cliffs that have been introduced I was interested in what the most cost effective way to get boards are and maybe to justify an SV2 Pro. That’s a joke but The ION Prototyping lab does have a V-One, maybe it’s time to learn how to use it!

FreeCAD Make

Sun, 13 Apr 2025 20:54:33 -0500

Github Repo

Background

If you’re new to FreeCAD scripting, start with this guide on setting up FreeCAD on Linux.

Introduction

I’ve recently been working on a waveguide assembly for a time-domain reflectometer (TDR), designed in OpenSCAD and FreeCAD with simulation in openEMS. FreeCAD’s ability to export solid models (eg. STEP files) means I often do the design in vanilla OpenSCAD and then finalize it in FreeCAD.

This particular design includes multiple interdependent parts that must stay consistent. They tend to change together as the design evolves, so managing them in a coordinated way is critical.

Product Announcement: QL03 Photoreceiver

Sun, 16 Mar 2025 11:25:26 -0400

We’ve just launched a new photoreceiver over at our sister site, Hobbs ElectroOptics: the QL03 Photoreceiver. It’s designed for low-light applications that demand high sensitivity and low noise.

Highlights

150 mm² photodiode with immersion lens for large-area light collection
1 MΩ transimpedance gain, DC–750 kHz bandwidth
Shot-noise-limited above 100 nA input current across its full bandwidth.
Excellent for diffuse sources, spectroscopy, and fluorescence
Bootstrap amplifier topology enables this unusual balance of speed, noise performance, and collection area.
Built for real lab use — not just the datasheet. Faraday cage enclosure keeps the ambient noise down.

This receiver makes alignment easy (you’re aiming at a barn door), while delivering professional-grade performance for demanding optical measurements. Great for lab use, bread / brass board designs, and proof of concepts. When you’re ready to move to production we can help you integrate the design into your product. Whether you’re in a research lab or prototyping a product, it’s ready to go.

Installing OpenEMS on Linux

Sun, 17 Nov 2024 15:41:15 -0600

Docker Source Files are available here.

OpenEMS is an open-source Finite-Difference Time-Domain (FDTD) simulator that has seen some significant adoption. As I go through the setup for the second time, I’m noting down all the steps, common pitfalls, and useful resources to help others get up and running quickly. In this guide, I’ll walk you through the installation process, highlight some useful tools, and share the sections that stumped me.

Interface Choice

There are three fully featured interfaces to openEMS:

System Diagrams / Schematics

Sun, 01 Sep 2024 16:56:44 -0400

Most engineering projects begin as rough sketches on napkins, whiteboards, or air diagrams furiously traced with a finger. But as complexity grows, especially when multiple components or teams are involved, a structured system diagram becomes essential. When dealing with designs that involve multiple separately developed components, a system diagram (sometimes referred to interchangeably with system architecture or system schematic) becomes valuable.

A system diagram helps break the problem into manageable and manufacturable chunks, providing a visual guide for the development.

Device Control GUI and Binary Distribution

Sun, 23 Jun 2024 11:47:33 -0400

Abstract

Built a basic GUI wrapping a CLI and packaged it into a standalone executable to control embedded software updating and diagnostics.

Firmware Updating GUI

Background & Goal

We’ve been working with an agricultural fire prevention company to built ruggedized optical fire detection systems. The installed system is a self contained unit with 2 to 6 detectors that have an analog alert signal and a half-duplex RS-485 MODBUS RTU bus for status and monitoring.

KiCad Coordinate System

Sun, 16 Jun 2024 06:53:50 -0400

The KiCad coordinate system can be unintuitive, especially when scripting or developing plugins. Here’s what I learned while building the JigsApp system and the kicad-testpoints plugin.

The origin and axis settings are global display preferences for the PCB editor (pcbnew) and can be accessed from all of the KiCad programs (eeschema, project, pcbnew, Symbol Editor, Footprint Editor, Gerber Viewer, Image Converter, Calculator Tools, Drawing Sheet Editor, and 3D Viewer).

The origin type and axes settings can only be changed for the PCB Editor.

KiCad 8 Makefile

Tue, 04 Jun 2024 09:45:28 -0400

KiCad 7 introduced the CLI tool which made creating a design release insanely easy. There are other great tools that met the need before like KiBot and KiKit but having the functionality in the main line release is so much nicer. I wrote a post on my KiCad 7 makefile here which made the fast and correct ordering of boards a breeze. All the files are named correctly, it’s all up to date, I can rely on all the same files being in each release, my vias actually get connected, etc.

KiCad Testpoints Plugin

Tue, 04 Jun 2024 01:32:04 -0400

Over the past few months I’ve been working on turning the internal tools we’ve developed at EOI/HEO for various projects into a new company. We recently launched TheJigsApp to make the design and manufacturing of test jigs fast and painless. As will be obvious from this blog I really enjoy KiCad which I recently discovered has the dubious distinction of being one of three EDA programs listed on Wikipedia that has had an update in the last decade that doesn’t have a test point report generation function in the GUI. I know this might be a bit specific but whatever, there’s only so many hours in the day and I’m writing this at 2 am.

KiCad 8 Contributor Shirt

Tue, 21 May 2024 18:29:46 -0400

KiCad 8 has been released, and they were kind enough to send us a contributor shirt! It’s amazing how much the tool has improved over the past five years. I’m looking forward to the API-based version, even though it’s going to break all my plugins.

If you haven’t used the tool before, give it a try, check out the events coming up, and check out KiCad Services Corporation. They’ve been a big addition to the project over the past few years.

Photoreceiver Testing

Thu, 16 May 2024 00:00:00 -0400

At ElectroOptical Innovations (EOI), we build a wide range of optical measurement systems tailored to diverse applications. When a subject matter expert approaches us with a measurement challenge, we collaborate closely to define the measurement principle and proceed with system and instrument design.

Photoreceiver testing is a common and critical part of our work. We’ve tested many photoreceiver devices and helped clients incorporate rigorous testing into their development processes.

It’s easy to fall victim to confirmation bias—especially near project completion. Optical measurement setups can be complex, and device bring-up often takes more calendar days than anticipated. Rigorous testing during bring-up helps avoid missing obvious issues, ruling out what could be wrong early reduces the nebulous issues later. To share our approach, we’ve documented the process we use to test and characterize photoreceivers in the application note: AN-1: Photoreceiver Testing System.

KiCad Custom DRC Rules

Mon, 30 Oct 2023 16:04:00 -0400

I got a board sent back by JLCPCB the other day due to a DRC rule I hadn’t come across before:

“If the copper area is less than 30% of the outer layers, then the trace-trace spacing should be at least 0.15 mm.”

This is in contrast to their usual minimum spacing of 0.09 mm. The fix? A custom DRC rule.

(version 1)
(rule top_bottom_clearance
 (constraint clearance (min 0.15mm))
 (condition "A.Layer == 'F.Cu' || A.Layer == 'B.Cu'"))

Worked great!

Pin 1 Markings and PCB Assembly

Mon, 23 Oct 2023 10:00:00 -0400

Most pick and place files are programmed by hand. Remember this and repeat it to yourself whenever you’re checking your files for PCBA manufacturing.

Chris Denny’s KiCON 2019 talk is essential viewing on this topic—he breaks down the manual process behind pick-and-place programming and how subtle mistakes can creep in.

Assembly layers are a great utility to supplement the silkscreen and help the person programming the pick-and-place machine. We want to make their lives as easy as possible to reduce surprises on the production line.

Spreadsheet Wrangler

Mon, 23 Oct 2023 06:00:00 -0400

Summary

Spreadsheet Wrangler is a command line tool to make working with spreadsheets easier. I use it primarily for handling bill of materials.

Github
PyPi

README

spreadsheet-wrangler

Command line tool for interacting with spreadsheet data

Installation

pypi

pip install spreadsheet-wrangler

Source

git clone https://github.com/snhobbs/spreadsheet-wrangler.git
cd spreadsheet-wrangler
pip install .

Functions

merge: Left merge two spreadsheets and save as xlsx
compare: Compare two spreadsheets on a column name, prints out the discrepancies
cluster: Combine the same values in a specified column as an array with the same name as the clustered column. The remainder of the first rows data is kept.
uncluster: Unpack clustered columns into one entry for each. The row is duplicated for each entry.
filter

Usage Examples

These examples follow the use case of working with a bill of materials (BOM). A specialized tool that uses this library for this use case is available here[https://github.com/snhobbs/BOMTools].

Rectangle Packaging Problem / Efficient 2D Packing

Thu, 19 Oct 2023 06:00:00 -0400

Summary

Automatically fit 2D rectangular parts onto standard-sized CNC panels to reduce waste and manual layout work. This post outlines a Python-based approach using the rectpack library and OpenSCAD for visualization and tool path.

Using `rectpack` for Automated Layout

There’s a Python library called rectpack that implements several efficient algorithms for this task: https://github.com/secnot/rectpack

Background

I need to produce a bunch of 2D parts out of the same material. The parts are roughly rectangular and I need to produce an undefined large number (test jig stands for TheJigsApp.com). There are a ton of available panel sizes but the CNC I’m using can fit panels of 25x36" max. So our problem is to fit different size rectangles into a given rectangle [Wikipedia: Rectangle Packing].

Object Oriented OpenSCAD

Fri, 13 Oct 2023 06:00:00 -0400

Summary

This is a discussion on using vectors in OpenSCAD as objects that can be used polymorphically. I’ve found this to be a powerful approach which encourages more generic algorithms. It’s a bit ugly but it works. Nothing here is revolutionary but I’ve found it to be a useful way to think about the problem.

Background

OpenSCAD is a special purpose, interpreted, functional language with a limited number of built in functions. There aren’t many types and the user can’t define any.

Preparing Laser Cutting Files from SVGs

Thu, 05 Oct 2023 06:00:00 -0400

Here’s a trick I’ve been using to prepare files for laser cutting that have been exported to SVG.

SVG is just an XML file that contains a bunch of vectors and metadata. Here’s an example of one exported from OpenSCAD. Remember this, I didn’t.

<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="76mm" height="80mm" viewBox="-38 -40 76 80" xmlns="http://www.w3.org/2000/svg" version="1.1">
<title>OpenSCAD Model</title>
<path d="
M 37.5,-40 L -37.5,-40 L -37.5,40 L 37.5,40 z
M 34.3605,-35.4061 L 34.2222,-35.4243 L 34.0859,-35.4545 L 33.9528,-35.4965 L 33.8238,-35.5499 L 33.7,-35.6143
 L 33.5823,-35.6893 L 33.4715,-35.7743 L 33.3686,-35.8686 L 33.2743,-35.9715 L 33.1893,-36.0823 L 33.1143,-36.2
 L 33.0499,-36.3238 L 32.9965,-36.4528 L 32.9545,-36.5859 L 32.9243,-36.7222 L 32.9061,-36.8605 L 32.9,-37

 ...

 L -33.1893,37.9177 L -33.2743,38.0285 L -33.3686,38.1314 L -33.4715,38.2257 L -33.5823,38.3106 L -33.7,38.3856
 L -33.8238,38.4501 L -33.9528,38.5035 L -34.0859,38.5455 L -34.2222,38.5757 L -34.3605,38.5939 L -34.5,38.6
 z
" stroke="black" fill="lightgray" stroke-width="0.5"/>
</svg>

The laser cutter software I’m familiar with is Trotec JobControl for the Speedy line (it’s what we have at the Fat Cat Fab Lab). The files need to be prepped for the software with the correct line thickness and color for each process. When using a design program like adobe illustrator or inkscape that’s just part of the design process and isn’t an issue but if you’re designing in a CAD program you’ll need to edit the exported file to set this up. The export style is at least not readily configurable in FreeCAD, KiCad, or OpenSCAD.

pyetest: Electronics Testing Tool & Method

Sat, 30 Sep 2023 03:07:00 -0400

Name: pyetest
Github: https://github.com/snhobbs/pyetest
pypi: TBD

pyetest is a Python library designed to simplify pass/fail test scripting for electronics by leveraging spreadsheets as test descriptions. The goal is to reduce custom code and make automated test setups more accessible to users who may not be programmers. By using structured spreadsheets to define measurements and criteria, pyetest generates both intermediate test data and final pass/fail outcomes making reports easier to generate and debug.

MCU Driver Development that Doesn't Suck

Thu, 18 May 2023 11:44:00 -0400

All I’m going to say here is to make your bed before you get in and close the barn before the horse puts in his two weeks notice.

Writing MCU device drivers can suck. It can suck for many reasons. As someone who recently spent best part of a week tracking down an installation and manufacturing issue that actually turned out to be a clocking issue in the UART driver I feel qualified to write this to remind my future self and possibly you too (not that I’d accuse you of doing anything quite so brain dead).

Setting Up Multiple FTDI Devices

Thu, 20 Apr 2023 12:52:00 -0400

Background

I’m building a test jig for a device that needs both RS-232 and RS-485 transceivers. Since this is a test jig, I prefer to build it using off-the-shelf components—ideally ones that can be delivered overnight.

Inside the jig, I have two USB-to-serial dongles (RS-232 and RS-485) and a LabJack U3, all connected through a USB hub. The hub connects to a USB isolator, which then to a bulkhead-mounted connector for easy disconnection. The jig is controlled using a laptop running Ubuntu with a test suite is written in Python.

Scripting FreeCAD from an AppImage

Wed, 22 Mar 2023 12:36:00 -0400

Introduction

AppImages are another packaging methods for distributing code with all dependencies included. It’s one of the simpler approaches, there’s no package manager for it, you download the image and go. The FreeCAD AppImages (here) work great and is my typical approach to installation.

One of FreeCADs strengths is the scripting interface. The GUI maps button clicks to commands meaning you can script everything out of the gate (mostly, it’s better than most). AppImages make this only a bit more complicated than native installations.

KiCad Board Outlines

Tue, 21 Mar 2023 18:36:00 -0400

I recently posted a video walk through of how I use board outlines and form factors as footprints in KiCad. It’s a useful approach I encourage you to try – especially when you are supporting many different designs. Simplifying and unifying designs can lead to network effects, allowing faster productivity growth with less complexity.

There are a few ways to make a board outline in KiCad:

Drawing shapes directly with built-in tools
Design the outline elsewhere, export to SVG or DXF and import as graphics
Design the outline using either technique, save as a footprint instead of using it directly on the board.

Unless the board is a basic rectangle, I almost always make the board outline a footprint.

KiCad 7 Build Environment

Sun, 26 Feb 2023 18:36:00 -0500

KiCad 7 has some notable improvements, not least among these is the addition of kicad-cli. Check out the Hackaday article for more.

Why a Build Environment?

I am a bit obsessed with pragmatic approaches to building and designing electronics. I want the complexity to not scale linearly in the number of projects I support. With shared design practices, reused sections, and update strategies log(n) complexity should be obtainable.

Setting up every projects in a similar way allows all sorts of automation. This helps reduce the entropy that naturally creeps into hardware projects. Keeping a consistent directory structure keeps down the number of variables in a project. Using a makefile to ensure consistent naming, settings/options, and directory structures are used is a great help in this struggle against the flood of complexity that hardware projects bring.

Semantic Versioning for Hardware

Sun, 26 Feb 2023 12:36:00 -0500

Fixed Point Python Libraries

Thu, 02 Feb 2023 10:00:00 -0500

TL;DR

Use spfpm or numfi.

spfpm behaves exactly like a standard fixed point in a compiled language with exceptions on overflow.
numfi also behaves like a standard fixed point with overflows at the limits, no exceptions are thrown.

Introduction

I’ve been exploring ways to simulate fixed-point arithmetic in Python for algorithm development and testing. Fixed-point arithmetic is especially relevant for embedded systems, DSPs, and hardware modeling where floating-point may not be available or efficient. Since there are several libraries, all a bit different I test out as many as I could find.

Reusing PCB Design Elements

Tue, 13 Dec 2022 00:00:00 -0500

Board template layout

Here’s the scenario: you’ve come up with a great product design, designed the electronics, written the software, set up testing, designed an enclosure, set up manufacturing, and are shipping products. Version 0.1.0 is out the door in the hands of happy customers. You followed good project management steps but had to keep to a tight schedule so there are valuable features you want to add. So you start working on version 0.2.0 (semantic versioning).

Building an Automated Test Jig: Hardware

Sun, 27 Nov 2022 15:39:00 -0500

Merifix MF300 Fixture

Part 2. of figuring out how to build a series of automated testing jigs for Hobbs ElectroOptics and ElectroOptical Innovations. The first part “Requirements and Resources” is available here. Like the first part this focuses on development and low scale manufacturing.

The most straight forward method for sourcing parts is looking at the kits available on the market. Some of the companies that offer kits are listed in “Requirements and Resources”. The parts can obviously purchased in those kits or similar parts can be acquired from suppliers like Digi-key or aliexpress.

Building an Automated Test Jig: Requirements & References

Thu, 24 Nov 2022 15:39:00 -0500

Summary

Here’s a list of design goals to guide the design of a series of related production test system. A list of interesting resources and and companies is included.

Introduction

Blue Clover Tester Chassis

As the number of projects we’re supporting increases, the support requirements grow. There is a dire need of a standardized approach to test the electronics. Currently at Hobbs ElectroOptics and ElectroOptical Innovations we rely on standard flying probe bare board testing and automated optical inspection followed by built-in-self test. Some projects have a functional test stand which often also flashes the firmware. The aim then is to have a testing approach that is more fool proof and easier to transfer to a CM.

kicad-parts-placer

Sat, 19 Nov 2022 01:20:00 -0500

New Tool: kicad-parts-placer

Manually positioning critical components for a design such as pogo pins for test fixtures can be tedious and error-prone. kicad-parts-placer simplifies this process by automating exact batch placement of parts in KiCad layouts using just a centroid files.

This Python tool groups components and moves them as a single unit, ensuring perfect alignment and maintaining fixed spacing. It’s ideal for creating bed-of-nails testers, aligning mounting holes, connectors, sensors, and preserving form factors across designs.

Timing Diagrams

Wed, 09 Nov 2022 08:36:00 -0500

ADC Timing

I have recently been working as part of a team generating some custom silicon for a high speed time of flight LIDAR. The digital logic is very simple but its important to get this correct. The team has several different groups all working remotely which makes clear documentation worth the effort. Timing diagrams for a system that can be understood by a wide audience is an art form; displaying data in a understandable and information dense way is subtle. The work of Edward Tufte is wonderful to look into on this topic, one of the historic pieces of data visualization he references is Charles-Joseph Minard’s piece on Napolean’s invasion of Russia:

Tool: object-symbols-parser

Wed, 26 Oct 2022 11:44:00 -0400

Intro

Link: https://github.com/snhobbs/object_symbols_parser

When the linker can’t complete as the image size is overrunning the section sizes defined in your linker script, it can be a pain to get the symbol table to find out what is causing the overrun. One solution is to increase the declared resources, link the ELF file and read the object table. This is annoying (to me at least). object-symbols-parser has a few modes to make this somewhat more tolerable.

Sigrok + $10 Logic Analyzer

Thu, 13 Oct 2022 15:39:00 -0400

Sometimes, the simplest tools can save hours of frustration. When I found myself on the road, away from the lab, struggling to debug I2C and SPI issues, I turned to a surprisingly capable $10 fx2 logic analyzer, powered by Sigrok.

Logic analyzer opened up

Hardware

While I have access to more fancier equipment in the lab, I was looking for a compact, budget-friendly solution to take on the go. This fx2 logic analyzer fits the bill, offering surprisingly good performance and the price is absurd.

KiCad PCBNew Scripting: Basic scripting beyond the built in terminal

Mon, 13 Jun 2022 21:47:00 -0400

The internal WX based scripting terminal in KiCad’s PCBNew is as bare bones as it gets. You can use a normal interface with the LoadBoard function in the pcbnew scripting interface. There isn’t any documentation to speak of for the API but once you’re using the improved interface the file structure is intuitive. I don’t know who did the naming and structure within the project but it is much better than most large APIs I’ve used (looking at you matplotlib). For power users the ability to automate tasks is astonishing so it’s worth an explore to see what can be done. For me the first step was to figure out how to get out of the integrated terminal.

KiCad PCBNew Scripting: Removing Ref Des From Silk Screen

Sat, 11 Jun 2022 00:00:00 -0400

Purpose

Most boards I design include reference designators on the silkscreen. This way, during bring-up, I can rely solely on the schematic, BOM, and board—no need to cross-reference with CAD. When doing a tight design it may not be possible to fit the labels anywhere that might actually be useful. When that happens you may want to forgo the labels on the silkscreen entirely. The labels are nice to have but are secondary to the operation of the circuit, nicely labeled but nonfunctional is hardly a good trade-off. Here’s what I’m looking at when deciding to remove the silkscreen ref des:

Text Formatting In the Terminal

Thu, 10 Feb 2022 03:07:00 -0500

Rich Table

I wanted to share a useful python library that I finally remembered to use after staring it while browsing Github awhile ago. Finding a new useful library can be incredibly invigorating, sometimes it’s a waste of time, but the other times! The ‘Rich’ library falls into the invigorating category.

Name: Rich
Purpose: Terminal display tools.
Why I Like It: Fast, pretty, and extensible output formatting for scripts.
Pypi: https://pypi.org/project/rich/
Github: https://github.com/Textualize/rich
Tutorial I Used: https://rich.readthedocs.io/en/latest/live.html and https://www.codeunderscored.com/format-terminal-using-pythons-rich-library

I love the way this library can make things look with a few lines but that’s not the main draw to me. My goal is an understandable and usable interface, no clutter, and nothing that behaves any differently than what the user expects.

Jupyter Notebooks & Photon Budgets

Mon, 29 Nov 2021 06:00:00 -0500

Feasibility Analysis / Photon Budgets

When making a measurement the first questions you need to ask are:

What are we measuring
How can it be measured
Is the measurement possible
How good can we get

The order is only for the first iteration of thinking. As with all complex systems, feedback and iteration must exist. A good starting point is doing a basic pass through on a white board or the back of a napkin at lunch. There are always a few spherical cows and references to first order perturbations. The first pass can raise concerns and quantities that can need to be measured or estimated (hopefully both). After a first pass when you’ve figured out what paths you are pursuing it is useful to do a formal analysis which is known generically as a feasibility study/analysis and as a photon budget in some circles for optical measurements.

Jupyter Notebook Tools & Setup

Sat, 20 Nov 2021 06:00:00 -0500

Introduction

The following are a collection of tools I use to improve my Jupyter reports.

Improving PDF Output

Jupyter notebook plots created with Matplotlib are by default PNG. When possible I prefer vector graphics as it allows you to upscale as much as necessary with no quality penalty. The following sets the exporting image format to PDF. The inline images remain PNGs but the export to PDF or LaTeX will use the PDFs.

Blogs & News Sites

Sat, 13 Nov 2021 03:08:00 -0500

Technical Blogs & News

OPML List

Article: Device Control

Fri, 12 Nov 2021 18:39:00 -0500

Article: Device Control Dashboard

Fri, 12 Nov 2021 18:37:00 -0500

Article: Building a Functional Teststand

Fri, 12 Nov 2021 18:36:00 -0500

Article: Embedded Directory Setup

Sun, 12 Sep 2021 18:36:00 -0400

GitHub gist

ISP Programming

Mon, 02 Dec 2019 20:44:00 -0500

Intro

Most microcontrollers these days come with integrated, ROM based, bootloader known as In-System Programming (ISP). You hookup to some default port, follow the protocol described in the docs and you can write/read the flash, query chip information, etc. The port is typically a UART but USB, I2C, and SPI are not unknown. NXP chips will enter the ISP handler if the user code is “not valid” (more on that later) or if the ISP pin is pulled down on reset.

Why You Should Use Latex

Sun, 16 Apr 2017 22:45:39 -0400

LaTeX

Some pronounce it ‘LAA-Tech’, I prefer ‘Lay-Tech’, never ’lay-techs’ that’s the rubber. Latex is amazing, it has sort of a cult following among physicists. Actually a cult, in my undergrad we couldn’t hand in papers unless they were done using LaTeX (the TAs would check the properties section of a PDF to make sure).

What and Why

Skip unless you need convincing LaTeX is a good idea

LaTeX is a typesetting language that lets you specify how a generated document is supposed to look. What you are reading right now is an example of a typesetting language called HTML, you can see how the web page is actually written by right clicking and selecting ‘view-source’. Microsoft Office and Adobe are the main alternatives but are examples of GUI (graphical user interface) programs, referred to as WYSIWYG (what you see is what you get) programs. None of that matters, what matters is that LaTeX gives you complete control over how your document is supposed to look. With a GUI, for instance, you specify where an image, table, etc. is supposed to go by ‘dragging-and-dropping’ it where you want it. You would then drag then use a drop-down menu to resize it or whatever. When you want to change a figure caption number you need to find every instance and change it. To move an image or resize it you INEVITABLY ruin the nicely done formatting below it. To reformat the document you need to do it all by hand again. This is, of course, utter nonsense. With LaTeX you could instead be suffering from a whole slew of different problems instead.