💻 computer science

Logistic Map Pseudo Random Number Generator in FPGA

This paper presents an FPGA-based pseudo-random number generator utilizing the logistic map and Central Limit Theorem to produce Gaussian-distributed outputs, featuring integrated modules for real-time visualization and data transmission to verify the system's statistical properties.

Original authors: Mateo Jalen Andrew Calderon, Lee Jun Lei Lucas, Syarifuddin Azhar Bin Rosli, Stephanie See Hui Ying, Jarell Lim En Yu, Maoyang Xiang, T. Hui Teo

Published 2026-06-25

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Mateo Jalen Andrew Calderon, Lee Jun Lei Lucas, Syarifuddin Azhar Bin Rosli, Stephanie See Hui Ying, Jarell Lim En Yu, Maoyang Xiang, T. Hui Teo

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Idea: Turning Chaos into Order

Imagine you have a machine that creates numbers. You want those numbers to be completely unpredictable, like rolling a die, but you also want them to follow a specific pattern (a "bell curve" or Gaussian distribution) that is useful for science and engineering.

The team at Singapore University of Technology and Design (SUTD) built a digital machine to do exactly this. They used a tiny computer chip called an FPGA (think of it as a Lego set for electronics that you can reprogram instantly) to turn a chaotic mathematical formula into a steady stream of random-looking numbers.

The Secret Ingredient: The "Butterfly Effect" Recipe

At the heart of their machine is something called the Logistic Map.

The Analogy: Imagine a very sensitive pendulum. If you push it just a tiny, tiny bit differently at the start, it swings in a completely different way later on. This is called "chaos."
The Math: The team used a simple equation ( $x_{n+1} = r \cdot x_n(1 - x_n)$ ) that acts like this pendulum. If you start with a specific number (a "seed"), the equation spits out a new number, which becomes the seed for the next round. Because the equation is chaotic, the numbers jump around wildly and never repeat in a predictable pattern.

The Problem: Too Much Chaos

The raw numbers coming out of this chaotic equation are messy. They bounce around too erratically to be useful for many real-world applications that need a "normal" distribution (where most numbers cluster in the middle, and fewer are at the extremes).

The Solution: The "Smoothie Blender" (EWMA)

To fix the messiness, the team used a technique called Exponentially Weighted Moving Average (EWMA).

The Analogy: Imagine you are making a smoothie. Instead of drinking one giant chunk of fruit (the raw chaotic number), you blend it with the fruit from the previous few seconds. You take a little bit of the new number and mix it with a lot of the old average.
The Result: This "blending" smooths out the wild jumps. The paper claims that by doing this, the chaotic numbers start to look like a perfect Bell Curve (Gaussian distribution). They used a mathematical rule called the Central Limit Theorem to explain why this smoothing trick works, even though the original numbers were dependent on each other.

How They Built It (The Hardware)

They didn't just write code on a computer; they built a physical device.

The Seed (The Mic): To start the chaos, they needed a "seed" number. Instead of picking a random number from a hat, they used a microphone. The volume of the sound in the room (or sound from a phone speaker) became the starting number. This makes the system truly responsive to the real world.
The Chip (FPGA): They programmed the logic into a CMOD-A7 chip. This chip has two main jobs:
- Chaotic_Lmap: Calculates the wild, jumping numbers.
- EWMA_avg: Blends those numbers to smooth them out.
The Display: They connected a 7-segment display (like the digital numbers on a microwave) to show the numbers as they were generated.
The Data Stream: They sent the numbers to a laptop via a serial connection (UART) to draw a graph and prove that the numbers actually formed a Bell Curve.

The "Sound Cone" Trick

To make the microphone seed even better, they 3D-printed a conical case (like a megaphone).

They put the microphone inside the cone.
They placed a phone speaker inside the cone too.
Why? The cone concentrates the sound waves, making the microphone pick up a stronger, clearer signal to use as the "seed" for the random number generator.

The Results

When they ran the machine for about 5 minutes (generating roughly 60 iterations per second), they collected the data on their laptop.

The Proof: They plotted a histogram (a bar chart showing how often each number appeared).
The Outcome: The bars formed a shape that looked very much like a smooth Bell Curve. This proved that their method of taking a chaotic system, smoothing it with EWMA, and running it on hardware actually works to create Gaussian-distributed random numbers.

Summary

In short, the team took a chaotic mathematical recipe, added a "blender" to smooth out the rough edges, fed it with sound from a microphone, and built it onto a tiny electronic chip. The result is a device that generates random numbers that look perfectly normal and predictable in their distribution, all while being driven by the chaotic nature of sound.

Technical Summary: Logistic Map Pseudo Random Number Generator in FPGA

Problem Statement
The project addresses the need for a reliable pseudo-random number generator (PRNG) suitable for implementation on digital hardware, specifically Field-Programmable Gate Arrays (FPGAs). While chaotic systems are known for their sensitivity to initial conditions (seeds) and deterministic unpredictability, generating outputs that follow a specific statistical distribution—particularly a Gaussian (Normal) distribution—remains a challenge. Traditional chaotic outputs often exhibit dependencies between successive values, complicating the direct application of the Central Limit Theorem (CLT). Furthermore, implementing continuous chaotic equations on FPGAs is difficult due to the hardware's reliance on discrete integer arithmetic rather than floating-point decimals.

Methodology
The authors developed a PRNG system based on the logistic map, a chaotic model defined by the equation $x_{n+1} = r \cdot x_n(1 - x_n)$ . The implementation followed a top-down approach using Verilog HDL on a CMOD-A7 FPGA board.

Algorithm Adaptation:
- Logistic Map: To accommodate FPGA constraints, the continuous logistic map was rescaled to a 16-bit integer domain (0 to 65,535). The parameter $r$ was set to 4 to ensure chaotic behavior.
- Gaussian Transformation: To transform the chaotic output into a Gaussian distribution, the authors applied an Exponentially Weighted Moving Average (EWMA) technique. This method smooths the data and mitigates correlations between successive values, theoretically allowing the CLT to apply to the dependent variables. The EWMA formula used was $EWA_t = \alpha \cdot r_t + (1 - \alpha) \cdot EWA_{t-1}$ , with $\alpha$ set to $40/50$ based on preliminary Julia simulations.
- Seed Generation: The system utilizes a real-time seed derived from an XADC microphone sensor, which captures ambient sound volume. This ensures the initial conditions are dynamic and dependent on the physical environment.
Hardware Implementation:
- The system architecture includes modules for the chaotic logistic map (chaotic_Lmap), the EWMA averaging (EWMA_avg), a UART transmitter for data logging, a 7-segment display driver for visualization, and clock generators.
- A feedback loop in the top module ensures the output of the logistic map feeds back into its input for iterative generation.
- Data is transmitted via UART to a laptop, where a Python script collects the 16-bit integers, constructs a histogram, and overlays a theoretical normal distribution curve for verification.
Physical Setup:
- The team designed and 3D-printed a conical casing to house the microphone and the FPGA board. This structure concentrates sound from a phone speaker onto the microphone, amplifying the signal to generate robust seeds for the PRNG.

Key Contributions

FPGA Implementation of Chaotic PRNG: The successful translation of the logistic map and EWMA algorithm into a functional Verilog HDL design on a CMOD-A7 FPGA.
Gaussian Distribution via CLT: The demonstration that applying EWMA to chaotic logistic map outputs can yield a Gaussian distribution, validated through hardware simulation and real-world data collection.
Sensor-Driven Seeding: The integration of an analog sensor (microphone) via XADC to provide a dynamic, environment-dependent seed, moving beyond static or purely algorithmic initialization.
End-to-End Verification System: A complete workflow from hardware generation to software analysis (Python histogram plotting) to verify the statistical properties of the generated numbers.

Results
The system was tested over a runtime of approximately 5 minutes (roughly 60 iterations of data collection for the initial analysis). The results showed that the PRNG outputs consistently displayed a Gaussian distribution.

Visual Verification: Histograms of the data received via UART overlaid closely with the theoretical normal distribution curve calculated using the data's mean and standard deviation.
Randomness: Time-series plots of the output values showed no periodic patterns, confirming the chaotic nature of the sequence.
Limitations: The authors note that while the fit to the Gaussian curve was successful, a longer runtime (thousands of iterations) would likely produce a smoother, more precise histogram.

Significance and Claims
The paper claims to demonstrate the practical utility and effectiveness of chaotic systems, specifically the logistic map, in the realm of pseudo-random number generation within digital hardware. By successfully integrating the Central Limit Theorem with EWMA smoothing on an FPGA, the project validates a method for generating Gaussian-distributed pseudo-random numbers from a deterministic chaotic source. The work highlights the potential of using simple chaotic models combined with statistical smoothing techniques to create efficient, dependable, and hardware-implementable PRNGs that can be seeded by real-world physical phenomena.