Step‑by‑Step Guide: Building a Flash‑Based State Machine Using Programmable Logic Arrays

Ever wondered why your coffee‑maker seems to “know” when to stop brewing? That little piece of magic is a tiny state machine tucked inside a flash‑based programmable logic array (PLA). In today’s fast‑moving world of IoT gadgets, being able to design such a machine yourself can save you time, money, and a lot of head‑scratching. Let’s walk through the whole process, from concept to a working prototype, in plain language and with a few stories from my own lab bench.

What is a Flash‑Based State Machine?

A state machine is simply a circuit that moves through a series of defined conditions, called states, based on inputs it receives. Think of it as a flowchart that lives in silicon. When we say “flash‑based,” we mean the logic is stored in non‑volatile flash memory, so the device remembers its configuration even when power is removed. A PLA is a type of programmable logic device that lets you implement any Boolean function by programming a set of AND and OR planes. Combining flash with a PLA gives you a compact, low‑power way to run a state machine without a full microcontroller.

Why Use a PLA for This Project?

• Simplicity – No need to write firmware; the logic is hard‑wired.
• Speed – Changes happen at the speed of a gate, not a CPU instruction.
• Power – Flash‑based PLAs draw far less current than a tiny MCU running a loop.
• Flexibility – You can re‑program the flash if you need to tweak the state table later.

When I was a graduate student, I built a traffic‑light controller using a tiny CPLD (a cousin of the PLA). The first time I saw the lights change without any code running, I felt like a wizard. That thrill is exactly what we’ll aim for here.

Step 1: Define the State Diagram

Start by listing every condition your system can be in and how it moves from one to another. For illustration, let’s design a simple three‑state machine that controls an LED strip:

1. OFF – LED off, waiting for a button press.
2. FADE_IN – LED brightness ramps up.
3. FADE_OUT – LED brightness ramps down, then returns to OFF.

Draw the diagram on paper or a whiteboard. Label each transition with the input that triggers it (e.g., button press, timer overflow). Keep the number of states low; PLAs handle a few dozen states comfortably.

Step 2: Choose Your Flash Memory

You need a flash cell that can be programmed in‑system (SPI flash works well). Make sure it supports the voltage levels of your PLA (usually 3.3 V). I like the 8 Mb SPI flash from Winbond because it’s cheap and has a simple command set, making it suitable for a low‑power flash‑based state machine. The flash will store the truth table that the PLA reads each clock cycle.

Step 3: Translate the State Table to a PLA Truth Table

A PLA works with binary inputs and outputs. Create a table where each row represents a possible combination of current state bits and input bits, and each column shows the next state bits and output bits.

Notice we used two bits for the state because three states fit comfortably in a 2‑bit binary code. The PLA will implement the Boolean equations that generate the next‑state bits and the LED output from the current state and input.

Step 4: Derive the Boolean Equations

From the table, write the logic for each next‑state bit (NS1, NS0) and the output (LED). Use a Karnaugh map or a simple truth‑table reduction. For this example the equations turn out to be:

• NS1 = (S0 AND I) OR (S1 AND NOT I)
• NS0 = (NOT S1 AND NOT S0 AND I) OR (S1 AND NOT I)
• LED = S1 OR S0

Here, S1 and S0 are the current state bits, and I is the button input. “NOT” means logical inversion, “AND” means both conditions true, “OR” means either condition true.

Step 5: Program the PLA

Most PLAs have a simple programming interface: you supply a list of product terms for the AND plane and a list of sums for the OR plane. Use the flash memory to store these lists. The steps are:

1. Create a binary file that encodes the product‑term matrix. Each row corresponds to a minterm (a specific combination of inputs) and each column to an output line.
2. Load the file into the flash using a SPI programmer. Many hobbyist programmers (like the CH341A) work fine.
3. Verify the flash contents by reading them back and comparing to the original file.

If you prefer a graphical tool, the open‑source “pla‑designer” utility lets you draw the logic and export the binary file directly, and you can learn more about low‑power PLA design in our dedicated guide.

Step 6: Wire Up the Circuit

Here’s a quick parts list:

• 1 × 8 Mb SPI flash (3.3 V)
• 1 × PLA chip (e.g., Lattice ispMACH)
• 1 × push‑button (debounced with a 10 kΩ resistor)
• 1 × LED strip with a MOSFET driver
• Power supply (3.3 V regulator)
• Breadboard and jumper wires

Connect the flash’s SPI pins (MOSI, MISO, SCK, CS) to the PLA’s configuration pins. Tie the button to a PLA input pin, and route the LED output pin through the MOSFET to the strip. Don’t forget a pull‑up resistor on the button line so the PLA sees a clean high when the button is not pressed.

Step 7: Test and Debug

Power the board and press the button. You should see the LED strip fade in, then fade out, then turn off. If nothing happens:

• Check the flash – is it correctly programmed? Re‑read the data.
• Verify the wiring – a loose wire on the button can cause a stuck input.
• Look at the PLA pins – some PLAs require a reset pulse after power‑up.

A handy trick I use is to add a “debug LED” that lights whenever the PLA’s internal state bits are both high. That gives you a visual cue that the state machine is actually moving.

Step 8: Refine and Expand

Now that the basic machine works, you can add more states (e.g., a “blink” mode) or more inputs (like a temperature sensor). Just update the state table, regenerate the Boolean equations, and re‑program the flash. For another flash‑based project, see our guide on building a flash‑based bootloader for ARM Cortex‑M microcontrollers. Because the flash is non‑volatile, the new logic stays in place even if you unplug the board.

A Little Personal Note

When I first tried to build a flash‑based controller for a solar‑tracker, I spent an entire weekend soldering the wrong pins on the PLA. The result was a faint smell of burnt plastic and a very patient lab partner. After swapping the chip, the tracker followed the sun like a loyal dog. That mishap taught me two things: always double‑check pinouts, and never underestimate the joy of seeing a circuit finally behave as you imagined.

Building a flash‑based state machine with a PLA is a rewarding blend of digital logic and hands‑on hardware. It gives you the speed of hardware with the flexibility of software updates, all while keeping the design simple enough for a weekend project. Grab a PLA, a flash chip, and start mapping out those states – your next smart gadget is just a few logic equations away.