Linear Feedback Shift Registers for the Uninitiated, Part XIII: System Identification
Jason Sachs shows how the output of a linear feedback shift register can be used for active system identification, not just spread-spectrum testing. The article compares traditional sine-wave probing with LFSR-based PRBS methods, demonstrates a worked Ra-Rb-C example, and unpacks practical issues such as reflected pseudonoise, ADC quantization, sample counts, and noise-shaping tricks to improve estimates.
A Wish for Things That Work
Jason Sachs revisits his long-running gripe with poor user interfaces, cataloguing annoyances from his Toyota Prius dashboard to desktop apps and browsers. He mixes sharp, real-world examples with a short, practical wishlist for 2018 aimed at making embedded displays, update behavior, security cues, and developer tools noticeably less frustrating for engineers and end users alike.
Linear Feedback Shift Registers for the Uninitiated, Part XII: Spread-Spectrum Fundamentals
Jason Sachs shows why LFSR-generated pseudonoise is a natural fit for direct-sequence spread spectrum, then walks through Fourier basics, spectral plots, and runnable Python examples. The article demonstrates how DSSS multiplies a UART bitstream with a chipping sequence to spread energy, how despreading concentrates the desired signal while scrambling narrowband interference, and how multiple transmitters can share bandwidth when using uncorrelated sequences.
Linear Feedback Shift Registers for the Uninitiated, Part XI: Pseudorandom Number Generation
Jason Sachs breaks down when linear feedback shift registers make good pseudorandom sources and when they fail. He shows why LFSR output bits look very different from full-state integer samples, explains their two-valued autocorrelation and quasi-random behavior, and gives practical guidance on when an LFSR is acceptable for fast hardware bit generation and when you should use a proper PRNG instead.
Linear Feedback Shift Registers for the Uninitiated, Part X: Counters and Encoders
Jason Sachs shows how linear feedback shift registers can be practical counters and compact absolute encoders, and why the choice of polynomial matters. He explains using primitive and reducible polynomials to get long but decode-friendly periods, demonstrates a 48-bit example, and lays out a De Bruijn chain-code encoder that turns an extra track into quick absolute resynchronization. Read to learn implementation tradeoffs and decoding strategies.
Linear Feedback Shift Registers for the Uninitiated, Part IX: Decimation, Trace Parity, and Cyclotomic Cosets
Taking every jth bit of a maximal-length LFSR uncovers a surprising algebraic structure. Jason Sachs walks through cyclotomic cosets, shows why decimation by powers of two preserves minimal polynomials, and connects LFSR output to trace parity and simple bitmask parity computations. The article uses hands-on Python with libgf2, Berlekamp-Massey, and state recovery so you can reproduce and automate these analyses.
Linear Feedback Shift Registers for the Uninitiated, Part VIII: Matrix Methods and State Recovery
Matrix methods for LFSRs look intimidating, but Jason Sachs walks through companion-matrix representations and shows why they matter for time shifts and state recovery. He derives lookahead masks from powers of the companion matrix, then translates those matrix insights into efficient bitwise and finite-field algorithms. The article includes two simple state-recovery methods and working Python/libgf2 examples you can run and adapt.
Linear Feedback Shift Registers for the Uninitiated, Part VII: LFSR Implementations, Idiomatic C, and Compiler Explorer
Jason Sachs takes LFSR theory back to real hardware, showing multiple C implementations and dsPIC33E assembly to squeeze cycles out of Galois LFSR updates. He digs into idiomatic C pitfalls like rotate idioms, demonstrates tricks using unions and 16/32-bit views, and shows when inline assembly with SL/RLC and conditional-skip instructions pays off. The article also uses Compiler Explorer and supplies an MPLAB X test harness for verification.
Lazy Properties in Python Using Descriptors
Python descriptors let you outsource attribute lookup, and Jason Sachs walks through a practical use: lazy, cached properties. He presents a LazyProperty descriptor that defaults to a WeakKeyDictionary cache so computed results are stored on first access and automatically purged when objects are garbage collected. The post shows how to share caches by value using attrkey or swap cache classes for different use cases.
Linear Feedback Shift Registers for the Uninitiated, Part VI: Sing Along with the Berlekamp-Massey Algorithm
Jason Sachs breaks down the Berlekamp-Massey algorithm and shows how to recover an LFSR's minimal connection polynomial from a stream of output bits. The article mixes intuition, worked examples, and Python code to demonstrate the update rule, visual debugging tables, and when the solution is unique. Expect practical implementation notes, a complexity discussion, and a libgf2 example you can run in an IPython notebook.
Ten Little Algorithms, Part 1: Russian Peasant Multiplication
Jason Sachs revisits a centuries-old multiplication trick and shows why it still matters. He lays out Russian Peasant Multiplication with simple Python code, then reveals how the same shift-and-add pattern maps to GF(2) polynomial arithmetic and to exponentiation by squaring. The post mixes historical context with practical bitwise techniques that are useful for embedded and low-level math work.
Padé Delay is Okay Today
High-order Padé approximations for time delays break in surprising ways, but the failure is not magic. Jason Sachs walks through why coefficient-based transfer functions and companion-form state-space are numerically fragile, shows how to compute poles and zeros directly from the hypergeometric form with Newton iteration, and demonstrates building modal or block-diagonal state-space realizations to make high-order Padé delays practical while noting remaining limits.
Turn It On Again: Modeling Power MOSFET Turn-On Dependence on Source Inductance
This is a short article explaining how to analyze part of the behavior of a power MOSFET during turn-on, and how it is influenced by the parasitic inductance at the source terminal. The brief qualitative reason that source inductance is undesirable is that it uses up voltage when current starts increasing during turn-on (remember, V = L dI/dt), voltage that would otherwise be available to turn the transistor on faster. But I want to show a quantitative approximation to understand the impact of additional source inductance, and I want to compare it to the effects of extra inductance at the gate or drain.
Important Programming Concepts (Even on Embedded Systems) Part IV: Singletons
Singletons are convenient but often a modularity killer, especially in embedded firmware. Jason Sachs walks through the many faces of singletons, from static members and globals to hardware registers and user-visible application singletons, and shows practical ways to avoid tight coupling. Read this for concrete embedded examples and pragmatic fixes like passing state explicitly, using interfaces or factories, and isolating unavoidable globals in a HAL.
Ten Little Algorithms, Part 5: Quadratic Extremum Interpolation and Chandrupatla's Method
Today we will be drifting back into the topic of numerical methods, and look at an algorithm that takes in a series of discretely-sampled data points, and estimates the maximum value of the waveform they were sampled from.
Analog-to-Digital Confusion: Pitfalls of Driving an ADC
Wayne's thermistor board showed one ADC channel changing when another was heated, a classic case of ADC input cross-coupling. The post walks through how multiplexed ADCs, the small sample-and-hold capacitor, source impedance, sampling time, repeated sampling rates, and added charge reservoirs interact to create errors. Learn practical fixes including increasing sample time, sizing external caps, adding op-amp buffers, and using an RC dampener with PCB layout tips.
Modeling Gate Drive Diodes
This is a short article about how to analyze the diode in some gate drive circuits when figuring out turn-off characteristics --- specifically, determining the relationship between gate drive current and gate voltage during turn-off of a power transistor.
Linear Feedback Shift Registers for the Uninitiated, Part VI: Sing Along with the Berlekamp-Massey Algorithm
Jason Sachs breaks down the Berlekamp-Massey algorithm and shows how to recover an LFSR's minimal connection polynomial from a stream of output bits. The article mixes intuition, worked examples, and Python code to demonstrate the update rule, visual debugging tables, and when the solution is unique. Expect practical implementation notes, a complexity discussion, and a libgf2 example you can run in an IPython notebook.
Help, My Serial Data Has Been Framed: How To Handle Packets When All You Have Are Streams
Framing byte streams is easier to get wrong than you think, and a bad scheme can leave your embedded device acting on the wrong packet. Jason Sachs walks through common plaintext and binary framing approaches, explains why CRCs alone can still permit false resynchronization, and demonstrates COBS as a simple, low-overhead byte-stuffing method that prevents delimiter collisions and guarantees resynchronization.
Linear Feedback Shift Registers for the Uninitiated, Part IX: Decimation, Trace Parity, and Cyclotomic Cosets
Taking every jth bit of a maximal-length LFSR uncovers a surprising algebraic structure. Jason Sachs walks through cyclotomic cosets, shows why decimation by powers of two preserves minimal polynomials, and connects LFSR output to trace parity and simple bitmask parity computations. The article uses hands-on Python with libgf2, Berlekamp-Massey, and state recovery so you can reproduce and automate these analyses.
Second-Order Systems, Part I: Boing!!
Jason Sachs takes the spring 'boing' of a doorstop into the math of second-order systems, using the series LRC circuit as a concrete example. He shows two standard transfer-function forms, explains why ωn only scales time while ζ sets the response shape, and derives pole locations plus an exact overshoot formula that helps tune embedded-system responses.
Padé Delay is Okay Today
High-order Padé approximations for time delays break in surprising ways, but the failure is not magic. Jason Sachs walks through why coefficient-based transfer functions and companion-form state-space are numerically fragile, shows how to compute poles and zeros directly from the hypergeometric form with Newton iteration, and demonstrates building modal or block-diagonal state-space realizations to make high-order Padé delays practical while noting remaining limits.
Oscilloscope Dreams
Jason Sachs walks through practical oscilloscope buying criteria for embedded engineers, focusing on bandwidth, channel count, hi-res acquisition, and probing. He explains why mixed-signal scopes and hi-res mode matter, when a 100 MHz scope is sufficient and when to keep a higher-bandwidth instrument, and how probe grounding and waveform export can ruin measurements. Real-world brand notes and try-before-you-buy advice round out the guidance.
Important Programming Concepts (Even on Embedded Systems) Part II: Immutability
Immutable data can make embedded code easier to reason about, reduce concurrency bugs, and eliminate defensive copies. Jason Sachs walks through practical techniques that work in resource-constrained systems, from using const and pseudo-immutability to separating old and new state, to the limits of fully persistent data structures when you lack dynamic memory. The article also compares register-level state flow and advocates message passing as a concurrency alternative.
Ten Little Algorithms, Part 4: Topological Sort
Jason Sachs detours from signal processing to make topological sort feel practical and even a little funny, using a Martian Stew recipe to illustrate dependencies and cycles. He walks through two canonical algorithms, Kahn’s method and the depth-first-search variant, compares adjacency-list and matrix graph representations, and provides complete Python implementations so you can run and inspect cycle detection and ordering yourself.
Ten Little Algorithms, Part 5: Quadratic Extremum Interpolation and Chandrupatla's Method
Today we will be drifting back into the topic of numerical methods, and look at an algorithm that takes in a series of discretely-sampled data points, and estimates the maximum value of the waveform they were sampled from.
The Other Kind of Bypass Capacitor
Most engineers treat bypass capacitors as supply decoupling, but Jason Sachs digs into the other kind: a capacitor placed in the feedback path to tame unpredictable high-frequency plant behavior. He walks through real examples, Bode plots, and a simple RC model to show how the cap forces unity-gain feedback at high frequency, stabilizing switching regulators and wideband amplifiers while revealing the speed versus stability tradeoff.
Return of the Delta-Sigma Modulators, Part 1: Modulation
Jason Sachs returns to delta-sigma modulators with a hands-on, code-first treatment that focuses on the DAC side of things. Part 1 walks through first- and second-order kernels, linearized analysis, spectra, and practical coefficient choices while illustrating results with Python simulations. Expect clear rules of thumb for A, R, and B, a derivation of noise shaping behavior, and a useful error bound for RC filtering.
Linear Feedback Shift Registers for the Uninitiated, Part XVIII: Primitive Polynomial Generation
Jason Sachs walks through how to find primitive polynomials for GF(2) LFSRs, moving from naive exhaustive checks to smarter synthetic constructions. The article compares sieve and constructive methods, shows practical optimizations like parity checks and companion-matrix updates, and demonstrates decimation plus Berlekamp-Massey to generate all primitives from one seed; it also teases a novel Falling Coyote Algorithm for additional speedups.
Another 10 Circuit Components You Should Know
Jason Sachs walks through ten underrated circuit components every embedded engineer should know, from bus switches and thermocouple signal ICs to PCB stiffeners and opto-FET isolators. He mixes practical part examples, high-current hardware tips, and MCU features like CTMU and Peripheral Pin Select so you can pick the right trick when space, isolation, or precision matter.
