Thinking about a new product#

Today I found myself thinking about a new product while waiting for the parts and PCB for my weather station project to arrive.

The idea is a digital sequencer — a programmable timing and automation controller that could be used in a range of scenarios:

  • Lighting rigs
  • Industrial test rigs
  • Manufacturing sequences
  • General automation

The concept, at least initially, is intentionally simple.

The user would define a sequence — something akin to a hymn sheet. Instead of musical notes, however, each “note” represents a digital pulse on an output.

(If you remember S3M or MOD trackers from the Amiga or Atari ST, it’s a similar idea — just applied to digital outputs rather than audio.)

For example, the device might expose a number of output pins (say, 1 through 8), and the sequence would control:

  • Which pin is active
  • When it activates
  • How long it remains active

Each step in the sequence becomes a deterministic event, allowing precise and repeatable control over external systems.

For example, a simple sequence might look like:

  • Pin 1: HIGH for 100ms, then LOW
  • Pin 2: HIGH for 500ms, delayed by 200ms
  • Repeat 10 times

Even with a small number of steps, this allows fairly complex and repeatable behaviour to be described.

Where this becomes more interesting is in how the sequence is defined.

Rather than forcing the user to create long, repetitive instruction lists, the system would support:

  • Reusable blocks of instructions
  • Repeatable patterns
  • Looping constructs

This allows complex behaviour to be built from relatively small definitions, reducing memory usage while keeping sequences readable and manageable.

In other words, instead of writing everything out in full, the user can define patterns once and reuse them — much like repeating sections in music, but applied to digital control signals.

At this stage, the idea is still forming, but it feels like something that could sit in a useful space between:

  • Low-level microcontroller programming
  • And fully-fledged industrial controllers

Simple enough to use, but powerful enough to be genuinely useful.

The concept is relatively straightforward if limited to simple digital signal outputs. This could be achieved using a capable microcontroller such as an ESP32, STM32, RP2040, or RP2350.

More constrained devices (such as traditional AVR-based boards like the Arduino) may struggle once sequencing complexity and timing precision increase.

From a hardware perspective, the architecture would likely follow a simple and expandable pattern:

  • Microcontroller GPIOs
  • → Shift registers (e.g. 74HC595) to expand the number of outputs
  • → MOSFETs or drivers for actual switching
  • → Optional daughter boards for interfacing with external systems

Using shift registers allows the number of outputs to scale without consuming excessive GPIO pins, while keeping the core design relatively simple.

The output stage would need to be flexible depending on the use case — anything from low-voltage logic signals to driving relays, optocouplers, or higher-power loads via external circuitry.

What will ultimately determine whether this becomes a useful product is not the hardware, but how easy it is to define and manage sequences.

The challenge is less about generating signals, and more about creating a system that allows users to describe timing and behaviour clearly, without needing to think like a programmer.

That’s likely where most of the effort will go next.

If you need custom control hardware, programmable timing systems, or embedded firmware designed for your automation needs, discover how we build solutions at Protoworks (NI).