EmbeddedRelated.com

Linear Feedback Shift Registers for the Uninitiated, Part XIII: System Identification

Jason SachsJason Sachs March 12, 20181 comment

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.


Circuit Board Standoffs

Ed NutterEd Nutter February 2, 20183 comments

Can't find the exact standoff size for your PCB? This post shows how to fabricate custom standoffs from tubing or solid rod, with practical guidance on material choices, measurement, cutting, lathe facing, and drilling and tapping. The walkthrough uses brass as an accessible option, lists the correct drill size for 4-40 screws, and explains how to create chassis threads if needed.


Is it a Bug or an Error?

Michael BarrMichael Barr January 31, 20184 comments

The famous moth-in-the-relay story helped 'bug' and 'debugging' become everyday terms, but this piece questions whether that cozy label softens accountability. It argues software failures usually come from human mistakes in requirements or implementation, not literal insects, and asks whether using words like 'error' or 'mistake' would push engineers to treat safety and reliability more seriously. Join the conversation.


A Wish for Things That Work

Jason SachsJason Sachs January 1, 20182 comments

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 SachsJason Sachs December 29, 20171 comment

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 SachsJason Sachs December 20, 2017

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 SachsJason Sachs December 9, 2017

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

Jason SachsJason Sachs December 3, 2017

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

Jason SachsJason Sachs November 21, 20174 comments

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.


Obsolete? Yes. Still in use? Yes. How do you use it? Ummm...

Ed NutterEd Nutter November 14, 20175 comments

Old technology refuses to die, and sometimes you must keep it running. This post looks at real-world examples from Voyager needing FORTRAN support to nuclear subs and hospitals still on Windows XP, and argues for practical preservation steps: digitize datasheets and manuals, back them up locally, document code thoroughly, and cross-train personnel. It explains why upgrades help, but why archives and training matter more for unreachable systems.


Working with Strings in Embedded C++

Niall CoolingNiall Cooling June 1, 20233 comments

This article discusses the use of strings in embedded systems. It explains how the need for and use of strings in embedded systems has changed with the advent of cheaper, full graphic displays and the growth of the ‘Internet of Things’ (IoT). The article also covers character literals, C-Strings and string literals, and the difference in memory models between them. It also highlights the safety and security issues that arise from using strings in embedded systems. Finally, it explains how C++11 introduced a Raw string literal type that is useful for storing file paths or regular expressions.


Beware of Analog Switch Leakage Current

Jason SachsJason Sachs June 27, 20251 comment

Leakage currents in analog switches can quietly wreck precision reference circuits at elevated temperature. Jason M. Sachs walks through three switch-topology implementations for a switchable 1.25 V reference and shows which topology gives the smallest worst-case output error using real part specs. He explains why op amp input bias is usually negligible and gives practical fixes: lower resistances, better switches, or limiting temperature range.


Getting Started With Zephyr: Devicetrees

Mohammed BillooMohammed Billoo July 18, 20232 comments

This blog post provides an introduction to the "Devicetree", another unique concept in The Zephyr Project. We learn about the basic syntax of a device tree and how its structure and hierarchy mirror hardware, from the SoC to the final board. We also see how hardware described in a devicetree can be referenced and controlled in the source code of a Zephyr-based application.


A Working Real Time Clock (RTC) Implementation

Dr Cagri TanrioverDr Cagri Tanriover March 25, 20132 comments

When the GPRS modem would not provide network time, Dr Cagri Tanriover implemented a compact hardware real time clock using the NXP PCF8523T. The post highlights why automatic backup switching, I2C integration, BCD register handling, and alarm/timer features matter for embedded timestamps. It also shows battery-life math with a CR1225 and offers practical build notes after an initial ESD-related failure.


BusyBox; The Swiss Army Knife of Embedded Linux

George EmadGeorge Emad March 2, 2024

In this article we cover the BusyBox, how it's designed to be optimized for embedded targets, and how to configure and build it in different ways, we also covered the license and limitation, which led to the development of ToyBox, I hope you enjoyed the article, please leave a comment for any correction or suggestions.


Linear Regression with Evenly-Spaced Abscissae

Jason SachsJason Sachs May 1, 20181 comment

Jason Sachs cuts through the matrix algebra to show a tiny trick for linear regression when x values are evenly spaced. You can compute the intercept as the mean and the slope as a simple weighted sum with arithmetic weights, using q = 12/(m^3 - m). The post includes Python examples and a compact routine to get least-squares coefficients without matrix solvers.


New book on Elliptic Curve Cryptography

Mike RosingMike Rosing August 30, 20235 comments

New book on Elliptic Curve Cryptography now online. Deep discount for early purchase. Will really appreciate comments on how to improve the book because physical printing won't happen for a few more months. Check it out here: http://mng.bz/D9NA


Dark Corners of C - The Comma Operator

Stephen FriederichsStephen Friederichs July 23, 20158 comments

Ever seen a line like if (!dry_run && ((stdout_closed = true), close_stream(stdout) != 0)) and wondered what that comma means? Stephen Friederichs unpacks the rarely-discussed C comma operator, shows a circular-buffer example where it seemed to simplify looping, then demonstrates how precedence and readability problems (and even MISRA C bans) make it dangerous in practice. Read on for practical uses and cautionary lessons.


Linear Feedback Shift Registers for the Uninitiated, Part IV: Easy Discrete Logarithms and the Silver-Pohlig-Hellman Algorithm

Jason SachsJason Sachs September 16, 20174 comments

Discrete logarithms can be either trivial or infeasible depending on how group elements are represented, and Jason Sachs shows a practical route when they are intentionally easy. This article walks through using LFSRs as fast counters, why a smooth group order matters, and how the Silver-Pohlig-Hellman algorithm plus the Chinese Remainder Theorem recovers exponents in GF(2) with small prime factors.


Choosing a Microcontroller for Your Vehicle

Ed NutterEd Nutter June 7, 20161 comment

Picking the right microcontroller can make or break an autonomous vehicle project, and this post gives a practical checklist to help. It walks through voltage and power needs, memory and IO planning, cost and availability tradeoffs, and when to step up from an 8-bit MCU to a 32-bit controller or single-board computer. Real-world board examples illustrate the choices.