S.I.💡 Archived Development Logs: This post compiles the early records of our project (Chapters 01–14). Since I didn't have time to write massive foundational articles while building the hardware in parallel, I used AI to help structure the text for these early logs. (Starting from our latest log where we successfully observed the FID signal, everything is written 100% in my own words!)
01. What is a Quantum Computer?
First, the computers inside our smartphones and PCs are called "classical computers."
Differences from Classical Computers
Simply put, quantum computers are orders of magnitude faster at specific calculations. For example, Google reported that their quantum computer (Willow) solved a calculation in 300 seconds that would take a supercomputer longer than the age of the universe (about 13.8 billion years). That makes it roughly 1.5 quadrillion times faster. However, quantum computers have strengths and weaknesses—they aren't faster at everything, and classical computers still beat them in many everyday tasks.
What Can They Do? (Present & Future)
Quantum computers excel at simulations and optimization, analyzing far more patterns than classical machines.
- Current Applications: Optimizing delivery routes and factory production lines (Japan Post, Denso), financial simulations (MUFG), exploring stable chemical structures for drug discovery (PeptiDream, Fujitsu), and elucidating chemical reaction mechanisms (Mitsubishi Chemical).
- Future Potential: Next-gen material discovery (more efficient solar panels, CO2 capture), molecular-level drug simulations with zero side effects, hyper-accurate weather forecasting, infrastructure optimization (solving traffic jams), artificial photosynthesis, breaking current cryptography (driving the shift to post-quantum cryptography), and advancing fundamental physics (I personally hope quantum simulations bring us one step closer to the "Theory of Everything").
Timeline & What Students Should Do
As of 2026, quantum computers are entering the practical phase, though still far from perfect. Near-complete machines are expected around 2030, and fault-tolerant general-purpose quantum computers around 2050. For students looking to dive in: start with an introductory book with good illustrations, attend quantum events to hear from experts in person, and try cloud quantum services like IBM Quantum to experience it firsthand!
*Note: The illustrations in Chapter 01 were generated using Gemini.
02. Starting a DIY Quantum Computer Using the Earth's Magnetic Field!
In April 2026, I officially started a personal project to build my own quantum computer! You might think a quantum computer requires a massive cryostat cooled to -273°C, but I am using a method called EFNMR (Earth's Field Nuclear Magnetic Resonance).
Using the Earth Itself as a Giant Magnet
While hospital MRIs and standard NMR machines use ultra-powerful superconducting magnets, our Earth itself is a giant magnet with a North and South pole. EFNMR uses this natural magnetic field to control nuclear spins (qubits). Because it needs no massive cooling system, you can observe and manipulate quantum mechanical phenomena right on your desk by building your own coils and circuits.
What We Are Building (Full-Scratch)
- Polarizing & Receiver Coil: Enamel wire hand-wound in many layers around a transparent PVC pipe holding a pure water sample.
- Signal Processing Circuit: A custom op-amp amplifier inside an aluminum shielding enclosure to pick up nanovolt-to-microvolt signals.
- FPGA: Dedicated digital circuitry for high-speed, precision pulse control.
- Python: FID signal analysis, noise removal, and Fast Fourier Transform (FFT).
- Power & Control: Lead-acid battery + MOSFET circuit to minimize power noise, controlled and monitored by an M5Stack.
03 & 04. Simulating NMR Signals in Python: FFT and Pulse Control
Before touching the soldering iron, let's look at how we observe and manipulate the quantum world using Python.
The Message from the Quantum World: "FID Signal" & Noise
We need to catch the extremely weak radio wave (NMR signal) emitted by nuclear spins—a smooth, periodic sine wave that decays over time, called an FID (Free Induction Decay) signal, expressed as s(t) = A * sin(2πft) * exp(-t/T2). Here is the ideal waveform simulated in Python (NumPy & Matplotlib):
However, in reality, cosmic noise and thermal noise from electronic circuits bury this clean signal. Adding white noise (mean 0, standard deviation 0.2) turns it into a jagged mess:
The Magic of "FFT" (Fast Fourier Transform)
To find the target frequency in a sea of noise, we use FFT, which acts like a prism separating light into colors. While standard Fourier Transform takes O(N²) operations, FFT reduces it to O(N log N). For real-number signals, I used complex FFT (np.fft.rfft). While testing by mixing 2100Hz and 2150Hz waves, I also discovered that if frequencies are too close, they are hard to resolve cleanly.
How Pulse Control Manipulates Qubits
- Identify the resonant frequency (Hz) of the qubit using FFT.
- Fire a manipulation pulse (radio wave) at that exact Hz toward the qubit.
- The atom absorbs energy ("resonance"), and the spin direction changes.
- Analyze the resulting FID signal with FFT after the pulse ends.
If there is no FFT peak, the state is |0⟩; if there is a peak, it is |1⟩ (or a superposition). By adjusting the duration of this pulse, we can freely control the quantum state!
05. Learning FPGA: Where All Circuits Run Simultaneously!
To generate ultra-precise pulses to control nuclear spins, I took on the challenge of FPGAs and Verilog HDL (Register Transfer Level / RTL).
Unlike standard PC programs that run sequentially line-by-line, all circuits inside an FPGA run simultaneously. To create sequential steps ("do B after A") in a concurrent world, we use:
- Clock Dividers: Counters that divide the fast base clock into slower reference clocks.
- Finite State Machines (FSM): Remembering the current state and transitioning to the next upon a trigger—essential for executing complex pulse sequences.
- NCO (Numerically Controlled Oscillator) & DDS (Direct Digital Synthesis): Calculating phase angles digitally (e.g., representing 360° as a 16-bit number) and converting those numbers into actual analog voltage waves of any target frequency.
module my_chip(
input clk, // Clock
input rst_n, // Reset button
output led
);
endmodule
06. Hand-Drawn Schematics & Dual-Layer Amplifier Protection
Here are the original hand-drawn schematics for our EFNMRQC, drafted on graph paper. CAD software is great, but nothing beats sketching on paper when brainstorming current flow and component layouts.
Two-Stage Protection Against High Current
During polarization, we run a massive current through the sensor coil. If that current enters the sensitive amplifier circuit, the op-amps will fry instantly. Initially, I added a Fast Recovery Diode to block current from flowing into the amp. To be 100% sure, I added a second failsafe: an M5 Relay Unit. This physically disconnects the amplifier circuit while strong pulses are fired, creating a rock-solid fail-safe system.
07. Switching Circuits with M5Stack and Relays
Using an M5Stack CoreS3 Lite and a Mini Relay Unit, I wrote a basic state-machine program in Arduino IDE (using the M5Unified library) to safely alternate between Polarization and Receiving phases.
// --- 1. Polarization Phase ---
digitalWrite(RELAY_PIN, LOW); // Relay OFF
M5.Display.println("1. Polarizing...");
M5.Display.println("Relay: OFF (Charge)");
delay(5000); // Polarize for 5 seconds
// --- 2. Receiving Phase ---
digitalWrite(RELAY_PIN, HIGH); // Relay ON
M5.Display.println("2. Receiving...");
M5.Display.println("Relay: ON (Listen)");
delay(3000); // Listen for signal for 3 seconds
08. High-Current Switching Circuit Test
To prevent power supply noise from wall outlets, our main polarization power source is a 12V sealed lead-acid battery (12V12Ah WP12-12). Since the M5Stack only outputs 3.3V signals, connecting it directly would destroy the microcontroller. I designed a drive circuit using an N-ch Power MOSFET (Toshiba 2SK4017(Q), 60V/5A).
Before connecting the massive coil, I tested the circuit on a breadboard (EIC-102BJ) with an LED dummy load and checked the switching waveform on a portable oscilloscope:
The rise and fall times were razor-sharp with almost zero ringing! To prepare for the massive back-EMF (surge voltage) when cutting off current to the real inductive coil, we procured a Kyocera 20NFA40 (400V/2A) Fast Recovery Diode to act as a flyback diode in parallel with the coil.
09. Capturing Room Audio and Running Real-Time FFT!
To digitize the analog signals from the coil into the PC, I introduced a 96KHz / 24-bit Hi-Fi USB External Sound Card, connected via a shielded BNC cable and a BNC-to-3.5mm mono adapter.
Using PyAudio, NumPy, and Matplotlib, I built a real-time FFT analyzer applying a Hamming window to reduce edge noise:
# Execute Fast Fourier Transform (FFT)
# Apply Hamming window to reduce noise at both ends
window = np.hamming(CHUNK)
fft_data = np.abs(np.fft.rfft(audio_data * window))
The "EFNMR Real-time FFT Analyzer" plotted the frequency spectrum! However, low-frequency environmental noise peaks showed up—the system is so sensitive it picks up voices and tiny footsteps. Absolute silence will be mandatory for our quantum experiments.
10. Soldering the PCBs (I Never Want to Do This Again!)
With breadboard verification done, we moved to soldering onto double-sided through-hole universal PCBs (B-type, 95x72mm).
1. Polarization MOSFET Board
We mounted the 2SK4017(Q) MOSFET and soldered the 20NFA40 flyback diode on the back with thick solder traces to handle high current. We used AWG18 UL1007 heat-resistant wire and added an inline 5A blade fuse on the positive battery terminal for short-circuit protection.
2. The SMD Op-Amp Nightmare
To amplify the microscopic FID signal, we used the AD797BRZ ultra-low noise op-amp. Because it's a tiny grain-of-rice SMD chip, we had to solder it onto a SOP8-to-DIP8 adapter board.
Honest confession: Soldering this op-amp was pure hell. The pin pitch is microscopic. The trick was melting a tiny bit of solder on the tip and letting surface tension pull it onto the pad—otherwise, pins bridge instantly. Desoldering braid (solder wick) saved my life. I honestly never want to solder an SMD op-amp again (lol).
11. Winding 250 Meters of Enamel Wire by Hand (1,600 Turns!)
To build the sensor coil bobbin, we cut a 48mm OD transparent PVC pipe with a pipe cutter and wound 0.5mm 2UEW enamel wire around it—1,600 turns, totaling ~250 meters!
3 Survival Tips for Hand-Winding Coils:
- Tape it down frequently: If your hand slips and the wire unspools, you have to start over in despair.
- Always work in pairs: One person rotates the PVC pipe while the other keeps tension on the wire. Doing it solo is nearly impossible.
- Take breaks: Keeping constant tension exhausts your hands faster than you think.
We connected the finished coil to the MOSFET board and 12V lead-acid battery for a high-current test. Thanks to the 20NFA40 flyback diode absorbing the massive inductive kickback, the MOSFET survived without a scratch!
12. Completing the Complex Analog Amplifier Circuit!
We assembled the analog receiver circuit on a breadboard around our DIP-adapted AD797BRZ op-amps, incorporating 1μF 100V metallized polyester film capacitors for coupling and noise filtering.
When we powered it on and hooked up the portable oscilloscope, we saw a clean sine wave of Vp-p: 8.80mV!
Even more exciting: the frequency read 2.04kHz—the exact Larmor frequency band of protons in the Earth's magnetic field! This proved our amplifier could cleanly process our target frequency.
13. Full Sequence Control: The Magic 50 Milliseconds
To integrate the MOSFET polarization circuit and Op-Amp receiver circuit without frying the AD797BRZ with residual coil surge voltage, I programmed a 3-stage sequence on the M5Stack CoreS3 Lite with a critical 50ms dead-time delay:
// ==========================================
// 2. Surge Decay Phase (Dead Time) *CRITICAL*
// ==========================================
// Turn OFF MOSFET to cut current
digitalWrite(MOSFET_PIN, LOW);
M5.Display.println("2. Surge Waiting...");
// Wait for coil back-EMF to dissipate through the flyback diode
// *Without this delay, the receiver circuit will be destroyed!
delay(50);
// ==========================================
// 3. Receiving Phase (Receiving / FID)
// ==========================================
// After the surge is gone, connect the receiver circuit via relay
digitalWrite(RELAY_PIN, HIGH);
14. System Integration & Debugging Hell (Magic Smoke!)
We mounted the 1,600-turn coil, MOSFET driver, and op-amp receiver inside the aluminum enclosure and connected it to the PC via the StarTech USB sound card.
At first, no signal reached the PC. After hours of checking wiring and microphone permissions, the culprit was a dead 9V battery powering the op-amp. Relieved, I rushed to buy a new battery, plugged it in hurriedly, and... accidentally reversed the polarity.
A wisp of smoke rose from the ultra-low noise AD797BRZ op-amp. All that painful SMD soldering went up in smoke in a split second. Thankfully, I had a spare op-amp and repaired the circuit, vowing to always double-check polarity before applying power.
After recovery, the OS finally detected the microphone signal input! However, our Python script (efnmr_monitor.py) still showed a flat line due to an audio device ID configuration issue—setting the stage for our next breakthrough where we finally captured the real FID signal!
Follow Our Journey!
- Real-time updates on X (Twitter): https://x.com/nmrqcproject
- Detailed development logs and source code on GitHub: https://github.com/nmrqcproject/nmr-qc-project
- Detailed development logs in Japanese / 日本語での詳しい開発記録 (Zenn): https://zenn.dev/nmrqcp
Discussions
Become a Hackaday.io Member
Create an account to leave a comment. Already have an account? Log In.