How to Succeed in Motor Control: Olaus Magnus, Donald Rumsfeld, and YouTube
Jason Sachs turned frustration with algorithm-heavy motor-control app notes into a practical MASTERs class, now available on YouTube. He walks through building a fifteen-minute field-oriented control refresher, the hazards teams commonly miss, and the months of prep required to make a polished technical lecture. Read for a candid behind-the-scenes look at teaching motor control to engineers and tips you can apply to your next drive project.
Round Round Get Around: Why Fixed-Point Right-Shifts Are Just Fine
Jason Sachs explains why, in most embedded systems, simple bitwise right-shifts are an acceptable way to do fixed-point division rather than paying the runtime cost to round. He shows the cheap trick of adding 2^(N-1) to implement round-to-nearest, explains unbiased "round-to-even" issues, and compares arithmetic error to much larger ADC and sensor errors. The takeaway: save cycles unless your algorithm or inputs require extra precision.
Scorchers, Part 1: Tools and Burn Rate
Small purchases often pay for themselves faster than you expect, and Jason Sachs walks through the math to prove it. He shows how to compute a fully burdened labor rate, including taxes, benefits, overhead, holidays, and productive hours, then compares that rate to the price of common tools. The practical conclusion is simple: if a sub-$100 utility saves about an hour of productive work, just buy it.
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.
Margin Call: Fermi Problems, Highway Horrors, Black Swans, and Why You Should Worry About When You Should Worry
Jason Sachs walks through practical strategies for choosing engineering margin, from split-second Fermi estimates to industry-grade safety factors. He blends highway and boiler anecdotes with a MOSFET thermal example to show why probabilistic thinking, experiments, and documentation matter when you must decide fast or later justify your choices. Read this to learn how to balance conservatism, cost, and risk in real projects.
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 Dilemma of Unwritten Requirements
Unwritten requirements quietly wreck projects, and Jason Sachs uses a humble wooden spool to illustrate how small mechanical and manufacturing choices become visible system behaviors. He contrasts craft-store spools with industrial ones to show where hidden assumptions like concentricity get dropped in the name of cost. The post urges engineers to surface externally visible trade-offs to customers or contractors and to iteratively capture discovered requirements.
Trust, but Verify: Examining the Output of an Embedded Compiler
Jason Sachs argues embedded engineers should read their compiler's assembly even if they rarely write assembly. He walks through Microchip XC16 output for dsPIC33 devices, showing how simple C variants and optimization flags produce very different code. The article demonstrates practical verification techniques and a tiny Python helper, pyxc16, to quickly inspect assembly for timing-sensitive firmware without rewriting everything in assembly.
How to Read a Power MOSFET Datasheet
Jason Sachs takes a soapbox to stop a recurring mistake: misreading power MOSFET datasheets. This practical guide separates marketing blurbs and typical graphs from the specifications you can actually rely on, and explains how to use RDS(on), VGS, gate charge, SOA and thermal data in real designs. Read this before you pick a MOSFET or size a gate driver.
Lessons Learned from Embedded Code Reviews (Including Some Surprises)
Jason Sachs recounts a round of motor-controller code reviews and the practical lessons his team learned about quality and tooling. He explains how a simple "ready for review" checklist and automated style checks kept meetings focused on substantive issues, and why choosing the right review tool matters after discovering lost comments in Stash. Read for concrete tips on process, subgit mirroring, vera++, and Upsource.
Voltage Drops Are Falling on My Head: Operating Points, Linearization, Temperature Coefficients, and Thermal Runaway
A lot of the neat, tidy diode and transistor rules you learned in school are really just approximations. Jason Sachs shows how operating points, linearization, and temperature coefficients give you a better mental model for real circuits, then uses that framework to explain why thermal runaway happens. Along the way, he connects the theory to practical device behavior, op-amp output stages, and the design tricks that keep parts from letting out the magic smoke.
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.
Optimizing Optoisolators, and Other Stories of Making Do With Less
Jason Sachs digs into how to squeeze speed and reliability from low-cost optoisolators, showing practical tweaks that often outperform default datasheet usage. He mixes hands-on circuits — using 4N35 base-emitter resistors, Schottky clamps, input speedup caps, and output buffering — with transistor-switching theory and a cautionary production story to show when to optimize and when to splurge on pricier isolators.
Jaywalking Around the Compiler
Messing with inline assembly can feel powerful until the compiler silently undoes you. Jason Sachs walks through a real bug on a Microchip dsPIC33E where pushing CORCON and writing a fixed value corrupts compiler-managed state and produces wrong results when the compiler reorders code. The post shows why the stack and certain registers are off-limits to raw inline asm, and gives practical, safe patterns to save and restore mode bits.
The Least Interesting Circuit in the World
Jason Sachs pulls apart the humble power-on reset and shows why the common RC-and-Schmitt trick is the least interesting but most dangerous circuit in your design. He walks through voltage thresholds, brown-out reset behavior, and how slow or noisy Vdd ramps can let parts start in indeterminate states. Read this for practical rules on choosing supervisors, comparators, and reset pulse timing to ensure reliable embedded startup.
Linear Feedback Shift Registers for the Uninitiated, Part XIV: Gold Codes
Gold codes solve a practical spread-spectrum problem, sharing one PRBS across many transmitters eventually runs into ugly synchronization and correlation issues. Jason Sachs walks through why shifted copies of a single LFSR sequence are not enough, then shows how preferred pairs of m-sequences create a family of Gold codes with bounded cross-correlation. The post wraps with Python experiments and a UART DSSS demo that decodes multiple overlapping messages cleanly.
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.
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.
Important Programming Concepts (Even on Embedded Systems) Part III: Volatility
Jason Sachs takes volatility out of the basement and into practical embedded programming. He shows why data that can change outside your thread of control breaks assumptions, how the volatile qualifier in C/C++ and Java affects compiler and CPU behavior, and when to prefer shadow registers, locks, or proper concurrency libraries instead of ad hoc volatile usage.
Racing to Sleep
Jason Sachs walks through a realistic field sensor case study, the BigBrotherBear 2000, to show how a careful power budget exposes surprising energy costs. He demonstrates that radios and data transmission often dwarf quiescent MCU current, explains the race-to-sleep principle for computation-bound tasks, and outlines practical wake-up and measurement trade-offs so engineers can extend battery lifetime in real deployments.
Bad Hash Functions and Other Stories: Trapped in a Cage of Irresponsibility and Garden Rakes
A tiny filename decision in MATLAB's publish() can silently swap rendered equations, and Jason Sachs shows why that matters. He reproduces the bug, walks through hash-function basics and collision math, and contrasts safe and unsafe caching strategies. The piece then broadens into practical lessons about software fringes, legacy constraints, and the usability traps that leave engineers repeatedly stumbling over avoidable design choices.
Lost Secrets of the H-Bridge, Part II: Ripple Current in the DC Link Capacitor
DC link capacitor ripple often determines capacitor life, yet the H-bridge waveform has a lot more structure than you might expect. Jason Sachs separates capacitor current into ramp and pulse components, derives closed-form peak and RMS expressions for edge and center PWM, and shows harmonic amplitudes. The post includes Python simulation so you can visualize the waveforms and apply the formulas to capacitor selection and EMI analysis.
Fluxions for Fun and Profit: Euler, Trapezoidal, Verlet, or Runge-Kutta?
Which ODE solver should you pick for resource‑constrained embedded simulations? Jason Sachs walks through practical numerical methods — Euler, trapezoidal, midpoint, 4th‑order Runge‑Kutta, semi‑implicit Euler, Verlet and the Forest–Ruth symplectic scheme — using hands‑on examples (damped bead, Kepler orbit, pendulum). He highlights accuracy vs. function‑evaluation cost, timestep guidance, and why symplectic methods beat general solvers for long‑term energy conservation.
10 More (Obscure) Circuit Components You Should Know
Jason Sachs follows up his earlier primer with ten more underused but practical parts that can simplify embedded hardware designs. From MOSFET-based ideal diode controllers that eliminate diode drops to TAOS light-to-frequency sensors that expand dynamic range, the post explains what each component does, when to choose it, and real-world tradeoffs learned from field use. Ideal for engineers looking to broaden their parts toolbox.
Linear Feedback Shift Registers for the Uninitiated, Part II: libgf2 and Primitive Polynomials
Jason Sachs digs into practical finite-field arithmetic for LFSRs, using his libgf2 Python library as the hands-on guide. He shows how to test whether a polynomial is primitive, why that matters for maximal-length sequences, and how the library implements addition, multiplication, exponentiation, and shifts over GF(2). The post is both a math refresher and a code walkthrough for engineers who want to compute with LFSRs instead of just talk about them.
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.
10 Items of Test Equipment You Should Know
Jason Sachs walks through ten often-overlooked pieces of test gear that make debugging embedded hardware faster, safer, and more precise. From clamp-on and Rogowski current probes to spring-tip probes, IC test clips, and compact DAQ systems, each tool targets a common bench frustration. Practical buying notes and use cases help you choose tools that save time and reduce guesswork.
How to Analyze a Differential Amplifier
Jason Sachs walks through the algebra and intuition behind the classic four-resistor differential amplifier. He derives the exact output equation, isolates error terms from resistor mismatch and op-amp imperfections, and explains why common-mode gain depends on mismatch not on the differential gain. Read this for clear formulas, modal insight into common-mode versus differential-mode, and practical steps to reduce offsets in real designs.
Stairway to Thévenin
Jason Sachs strips away classroom mystique to show how Thevenin and Norton equivalents are practical tools for real embedded work. Using a simple two-terminal black-box example he shows how two measurements give Vth and Rth, then applies that model to voltage-divider references, potentiometer RC filters, and combining multiple sources with Millman's theorem. Read it for fast, practical ways to predict output impedance, droop, and filter time constants.
Optimizing Optoisolators, and Other Stories of Making Do With Less
Jason Sachs digs into how to squeeze speed and reliability from low-cost optoisolators, showing practical tweaks that often outperform default datasheet usage. He mixes hands-on circuits — using 4N35 base-emitter resistors, Schottky clamps, input speedup caps, and output buffering — with transistor-switching theory and a cautionary production story to show when to optimize and when to splurge on pricier isolators.
