Expert Report on the Construction of an

Arduino-Controlled Nonvolatile
Magnetic Core Memory System

Section I: Magnetic Memory Fundamentals and

Theoretical Foundation

The construction of a functional magnetic core memory requires a deep understanding of the
electromagnetic principles that govern data storage at the fundamental level. This system
relies on the persistent magnetic state of a specialized material, known as magnetic
hysteresis, to achieve nonvolatile storage.1

1.1 The Physics of Digital Magnetism: Ferrites and Toroids

Magnetic core memory utilizes small toroidal rings (cores) made from a specific class of
ferromagnetic material, typically a semi-hard ferrite.1 Ferrite itself is a ceramic primarily
composed of iron oxide.3 Each toroidal core serves as a single bit cell, storing data by
orienting its magnetic flux either clockwise or anti-clockwise.2

The essential prerequisite for memory functionality is the magnetic characteristic of the core
material. Memory cores must exhibit a high degree of magnetic remanence ($B_r$), which
quantifies the material's ability to remain highly magnetized after the external field is
removed.1 This property ensures the memory is non-volatile; the stored data is retained even
when power is removed.1

A critical distinction must be made regarding material selection. The technology relies on
magnetically hard ferrites, which possess a "properly rectangular" B-H hysteresis loop.6 This
rectangularity signifies two key traits: high remanence and a sharp coercive field ($H_c$)
threshold. Conversely, "soft" ferrites—the type commonly used in transformers and
inductors—have low remanence and low coercivity.4 Using soft magnetic cores results in
failure because the stored state is not retained, leading to constant signal noise and data
corruption.8

1.2 Understanding the B-H Hysteresis Loop: Remanence and

Coercivity

The B-H loop plots the magnetic flux density ($B$) against the applied magnetic field
strength ($H$). The non-retraceability of this curve is known as hysteresis, relating to the
alignment of internal magnetic domains.4

For reliable binary switching, the core must have a distinct coercive field, $H_c$. The physical
mechanism of switching is governed by Ampère's Law, which defines the applied magnetic
field strength ($H$) generated by the drive current ($I$):

$$H = \frac{NI}{L}$$

where $N$ is the number of turns (typically 1 for core memory drive lines), and $L$ is the
mean magnetic path length of the core.
Switching the core's magnetic polarity (flipping the stored bit) occurs only when the applied
field $H$ exceeds the coercive field $H_c$. The relationship between $H_c$ and the current
is crucial for system scaling. Smaller cores are preferred in modern hobbyist implementations
(e.g., 1 mm diameter cores) because they require less switching current ($I$) to achieve the
necessary $H_c$, simplifying the high-current driver requirements significantly.7

The rectangular shape of the hysteresis loop establishes the stability margin. If the coercivity
is too low, the core risks accidental switching due to partial currents or environmental noise. If
the loop is insufficiently rectangular, the half-select currents ($I/2$) applied during the
addressing process may cause cumulative partial flips in unselected cores, leading to "read
disturb" errors and general instability over time.

1.3 The Coincident Current Selection Principle

To address and manipulate a single core within a two-dimensional array (plane), the
coincident current selection technique is employed.1 This method leverages the highly
rectangular nature of the core material's B-H loop.

The cores are arranged in an X-Y grid, with drive wires running through each row (X-lines) and
each column (Y-lines).1 To select a specific core, a current pulse equal to half the required
switching current ($I/2$) is applied simultaneously to the selected X-line and the selected
Y-line.1

The core situated at the intersection receives the cumulative force of both pulses, totaling $I =
I/2 + I/2$. This full current $I$ exceeds the switching threshold $H_c$, causing the core's
magnetic flux to reverse direction. All other cores in the array receive only $I/2$ (or zero
current). These half-selected cores receive sufficient magnetic disturbance to align their
domains slightly but should not undergo a permanent change in their major magnetic state.9

The fundamental reliability of the entire memory system depends critically on maintaining a
precise and stable current margin between $I/2$ (non-switching) and $I$ (switching). Current
drift or non-uniform core material properties compromise this margin, necessitating the use
of highly regulated power supplies and precision current-limiting components.10

1.4 The Destructive Readout (DRO) Cycle

Magnetic core memory is a form of Random-Access Memory (RAM) but operates using a
Destructive Readout (DRO) cycle.1

A read operation is performed by applying a current pulse designed to forcibly switch the
addressed core to a predetermined magnetic state, conventionally defined as '0'.1
1.​ If the core was holding a '1': The core's magnetic flux rapidly reverses direction (flips
from '1' to '0'). This rapid change in magnetic flux induces a small voltage pulse in a
separate wire, known as the Sense line, due to electromagnetic induction (Faraday's
Law).1
2.​ If the core was already holding a '0': The applied magnetic field attempts to set the
state to '0' but no flux reversal occurs. Consequently, no voltage pulse is induced in the
Sense line.7

Because the read operation inherently resets a '1' to a '0', the original data is destroyed.1
Therefore, the system electronics must immediately execute a mandatory re-write cycle
(Read-Modify-Write, or RMW) to restore the bit's original value if a '1' was detected.1 This
requirement doubles the operational time for every memory access, imposing a significant
constraint on the system's cycle time.5 The firmware must treat the read-restore sequence as
an atomic operation to ensure data integrity.

Section II: System Architecture and Component

Selection

The practical construction of core memory necessitates designing three interdependent

subsystems: the mechanical core array, the high-current drive system, and the low-level
analog sensing system.

2.1 Designing the Memory Plane

Historically, production core memory planes were substantial, often 32x32, storing 1024 bits.1
For a demonstration system using an Arduino, complexity dictates a smaller scale. A feasible
array size is $4 \times 8$ (32 bits), which stores four 8-bit ASCII characters. This size
minimizes the complexity of external address decoding while still providing a functional
demonstration of text storage.

2.2 Core Material Selection and Sourcing Strategy

The single most critical and challenging component to source is the hard ferrite core itself.
Standard toroidal cores used for radio frequency filtering or transformers are typically "soft"
ferrites and are inappropriate for memory.7

The required cores are small (typically $1$ to $2$ mm in diameter).7 Due to their
obsolescence, finding hard ferrite toroids in current production is difficult. Recommended
sourcing strategies include:
1.​ Salvage/Surplus: Searching for raw, unused cores from surplus vendors or collecting
cores from older components, such as tiny timing transformers sometimes found in older
Compact Fluorescent Lamps (CFLs).12
2.​ Hobbyist Resale: Acquiring batches of raw cores via online marketplaces, where they
occasionally appear from decommissioned systems.7
It is essential to confirm that the selected cores are the hard, rectangular-loop type suitable
for memory, not soft materials intended for filtering or induction.7

2.3 Choosing the Microcontroller and Drive Components

The microcontroller (MCU) chosen for this project must reliably generate the precise, rapid
current pulses necessary for switching. The Arduino Nano or Uno platform is suitable for
controlling the system logic.7

However, standard Arduino digital pins cannot provide the required high current (up to 1 Amp
peak) to switch the cores. Therefore, a dedicated high-current driver circuit is essential.

The SN754410 Dual H-Bridge IC is an effective choice for the drive circuit.7 This component
can handle the necessary pulsed current (estimated to be less than 1 Amp for X/Y lines) and
provides the required bidirectional current control necessary to set the magnetic polarity
(Write 1 vs. Write 0).1

A fundamental requirement for reliable operation is power supply isolation. The SN754410
uses split supplies:
1.​ Logic Supply ($V_{CC1}$, Pin 16): Supplied by the Arduino's 5V output. This powers the
control logic.
2.​ Drive Current Supply ($V_{CC2}$, Pin 8): Must be connected to a robust, external 5V
power supply (e.g., 5V, 3A capacity).7

Separating the high-current path prevents the inductive noise and ground bounce generated
by the massive switching current pulses from corrupting the sensitive digital logic of the
Arduino or, critically, the minute analog signal captured by the Sense Amplifier.7

The current is regulated using series resistors on each drive output. For 5V drive, an empirical
starting point is a $10\Omega$, 2 Watt resistor in series with each X/Y output line.7 These
resistors ensure that the current applied to a single selected drive line is exactly $I/2$.

Table Title: Component Subsystem Selection Criteria

Component Critical Part Selection Criteria Example

Subsystem Component
 Core Array Hard Ferrite Toroids Rectangular B-H Salvaged memory
loop, high cores 7
remanence, small
diameter (1-2 mm).

X/Y Drivers H-Bridge IC Bidirectional drive, TI SN754410 Dual

peak pulsed H-Bridge 7
current capability
($\approx 1$A
total).

Current Control Series Resistors High precision, high $10\Omega$, 2

wattage ($\ge 2$W) Watt Resistor 7
for limiting $I/2$.

Sense Amplification Analog Front End High-speed, BJT amplifier +

high-gain transient Comparator
pulse detection (LM311/Op-Amp) 7
(mV level).

Power Supply Dedicated 5V Stable voltage, high 5V, 3A External

Supply current capacity for Supply 7
$V_{CC2}$.

Section III: Subsystem Construction: The Core Array

and Threading

The physical assembly of the core array is highly demanding and critical to overall function.

3.1 Detailed Guide to Array Wiring: X-Drive and Y-Drive Lines

The cores must be mounted precisely on a flat surface, such as a custom PCB or perforated
prototyping board, to maintain a uniform grid. Small-gauge, insulated copper wire is threaded
manually through the array:
 1.​ X-Drive Lines: One wire is threaded horizontally through all cores in a single row.
2.​ Y-Drive Lines: One wire is threaded vertically through all cores in a single column.​
Each X and Y line is connected to one output terminal of the SN754410 H-bridge driver
via a series resistor.

3.2 The Sense Line Challenge: Serpentine Threading for Noise

Mitigation

In addition to the X and Y drive lines, a third wire—the Sense line—must pass through every
core.7 This line detects the induced voltage pulse when a core flips.1

The Sense line threading pattern is not a simple straight line; it must follow a serpentine or
alternating alignment pattern.2 This specific routing is a crucial noise mitigation technique.

When the high current pulses are applied to the X/Y lines, they act as primary windings of a
transformer, inducing large, synchronous voltage spikes (noise) across the Sense line.7 By
threading the Sense line through adjacent cores in opposite directions (e.g., clockwise
through core 1, then counter-clockwise through core 2), the noise voltages induced by the
non-selected half-current pulses in neighboring cores tend to cancel one another out through
common-mode rejection.2 This physical cancellation leaves a much cleaner, though still
minuscule, signal derived only from the single, selected core that fully flipped. This
cancellation is mandatory for isolating the genuine data signal from the pervasive switching
noise.

3.3 The Inhibit Line Context

Traditional large-scale core memory systems (3D architectures) often incorporated a fourth
wire, the Inhibit line, running parallel to the Y-lines.1 The Inhibit line is used exclusively during
the write cycle.1 When writing a word (a byte or more) across multiple memory planes, the
Inhibit line carries an $I/2$ current to counteract the full $I$ current at the selected bit,
thereby suppressing the write operation and ensuring the selected core retains a '0' state.1

For a simplified 2D hobbyist array, the Inhibit line is typically omitted. The 'Write 0' operation is
usually accomplished by executing the destructive 'Read' pulse (which sets the core to '0')
and then explicitly skipping the subsequent restoration step.11
Section IV: Subsystem Construction: Drive Circuitry
and Calibration

4.1 Circuit Diagram: Arduino to H-Bridge Interface Schematic

The drive circuitry must interface the low-voltage, low-current logic signals of the Arduino
with the high-current requirements of the core array. The SN754410 serves as the translator
and power switch.

The current-limiting resistors ($R_{series}$) are placed in series with the four output lines (for
a minimal 2x2 array, or more outputs if using external decoders for a larger array).

Table Title: Arduino to SN754410 H-Bridge Pin Mapping (Example 2x2 Array)

Arduino Pin (Digital) SN754410 Pin Function

5V (Logic Supply) Pin 16 ($V_{CC1}$) Logic Power Supply

External 5V 3A (+) Pin 8 ($V_{CC2}$) Drive Current Supply

D2 Pin 1 (1,2 EN) X-Line Pulse Enable

D3 Pin 2 (1A) X-Line 0 Drive Input

D4 Pin 7 (2A) X-Line 1 Drive Input

D5 (Can be tied to D2) Pin 9 (3,4 EN) Y-Line Pulse Enable

D6 Pin 10 (3A) Y-Line 0 Drive Input

D7 Pin 15 (4A) Y-Line 1 Drive Input

To perform a write operation to core (X0, Y0), the following steps are executed:
1.​ Set D3 (X0 Input) and D6 (Y0 Input) to the desired polarity (e.g., HIGH for one direction,
LOW for the reverse).
2.​ Enable the pulse by briefly setting D2 and D5 (Enables) to HIGH for the required duration
(microseconds).

4.2 Current Calculation and Determination of $I/2$

The drive current calculation requires precise component selection. Based on empirical
testing with small cores and a 5V drive voltage, a $10\Omega$ series resistor provides the
necessary half-select current ($I/2$).7

Using Ohm's Law, the resulting current through a single active line is:

$$I_{line} = \frac{V_{drive}}{R_{series}} \approx \frac{5V}{10\Omega} = 500 \text{ mA}$$

This $500$ mA approximates the $I/2$ required to disturb, but not flip, the cores.
Consequently, the full switching current ($I_{switch}$) required at the selected intersection is
approximately $1$ Amp. This low current requirement validates the use of common IC drivers
like the SN754410, which can handle currents in this range.7

4.3 Calibrating the Drive Pulse: Amplitude and Duration

Reliable core memory operation depends on the stability and shape of the current pulse.10
Calibration must confirm two criteria:
1.​ Reliable Switching: The full current $I$ must reliably flip the core and produce a clear
sense signal.
2.​ No Disturb: The half-current $I/2$ must not cause measurable flux degradation or
produce a false sense signal, even after thousands of repetitive pulses.

Calibration Procedure:
1.​ Initial Test Setup: Begin with a single core threaded with X, Y, and Sense wires (a
"one-bit" test rig).7
2.​ Measure $I$ and $I/2$: Use a shunt resistor and an oscilloscope to measure the current
amplitude and shape provided by the $R_{series}$ configuration.
 3.​ Adjust Amplitude: Systematically adjust the value of $R_{series}$ until the full pulse
($I$, generated by activating both X and Y lines) reliably flips the core, and the half-pulse
($I/2$, generated by activating only the X or Y line) causes no measurable sense output.
If the selected core is sluggish, reduce $R_{series}$; if half-selected cores are unstable,
increase $R_{series}$.
4.​ Tune Pulse Duration ($T_{pulse}$): Core switching takes time (microseconds). The
Arduino must be programmed to generate a pulse wide enough to ensure full magnetic
reversal. Monitor the Sense pulse decay time; the drive pulse must remain active slightly
longer than the time required for the core to completely flip. Utilize fast, low-level port
manipulation in the Arduino firmware instead of standard digitalWrite() commands to
ensure precise timing and linear rise time control.10

Section V: Subsystem Construction: Sense

Amplification and Readout

The core memory's most challenging analog task is detecting the minute, transient voltage
pulse induced during a flip operation. This requires a highly sensitive Sense Amplifier.

5.1 Principles of Induced Voltage Detection

The fundamental principle is electromagnetic induction. The rapid change in magnetic flux
($\Phi$) within the core when it flips generates a voltage ($V$) in the Sense line, governed by
Faraday’s Law of Induction:

$$V_{induced} = -N \frac{d\Phi}{dt}$$

Since $N=1$ for the Sense line, the voltage spike is directly proportional to the rate of flux
change. This pulse is typically on the order of millivolts (mV) and appears shortly after the
drive pulse is initiated, reflecting the propagation delay required for magnetic domain
reversal.7

5.2 Design Choices for the Sense Amplifier

A successful Sense Amplifier requires high gain, high bandwidth, and robust noise rejection. A
two-stage architecture is recommended for the hobbyist:
1.​ Preamplifier Stage: Utilizes a high-speed, low-noise Bipolar Junction Transistor (BJT,
e.g., 2N3904) or a fast Op-Amp configuration to provide initial high gain.
2.​ Digital Conversion Stage: A fast comparator (e.g., LM311) is essential to convert the
amplified analog pulse into a clean, digital HIGH/LOW signal that the Arduino can reliably
read.7 The comparator must be tuned with a precise voltage threshold ($V_{ref}$) to
distinguish a genuine '1' pulse from residual noise spikes.

5.3 Filtering and Timing Synchronization

Due to the powerful drive currents, significant inductive noise is generated that swamps the
tiny genuine sense signal.7 While serpentine threading cancels much of the common-mode
noise 2, the remaining noise must be managed by precise synchronization, often called time
windowing or gating.

The Arduino must meticulously control the timing sequence 7:

1.​ The Arduino initiates the Read pulse.
2.​ The system waits for a predetermined time delay ($T_{delay}$), corresponding to the
magnetic reversal time and signal propagation.7
3.​ The Sense Amplifier's output is sampled only within the narrow sampling window
($T_{read}$) where the induced voltage pulse is expected to peak, thereby excluding the
initial burst of switching noise and the subsequent signal decay. If the sampling window
is delayed or too narrow, the genuine '1' signal may be missed.

Section VI: Firmware Development and Logic

Implementation (Arduino)

The Arduino firmware must manage two primary tasks: pulse generation with microsecond
precision and the complex atomic logic of the Read-Restore cycle.

6.1 Setting Up the Arduino Environment and Pin Definitions

The setup involves defining the roles of all digital pins connected to the SN754410 H-Bridge
and the Sense Amplifier output. Pulse timing requires utilizing microsecond-level functions,
such as delayMicroseconds(), to control the duration of $T_{pulse}$. Furthermore, achieving
the sharp, repeatable pulse rise times required for optimum core switching often necessitates
using direct port manipulation (e.g., manipulating the PORTD register) instead of the slower
digitalWrite() function, which introduces jitter and timing inconsistencies.

6.2 Low-Level Driver Functions: void drive_pulse(X, Y, polarity)

A low-level function is needed to execute a current pulse of specific polarity to a specific

core. Polarity defines whether the core is being set to '0' (Read pulse direction) or '1' (Write
pulse direction, opposite of Read).1

This function manages the selection logic (setting input pins 1A/2A and 3A/4A) and controls
the duration of the current flow via the Enable/Strobe pins (1,2 EN and 3,4 EN).

6.3 The Read Cycle and Sense Timing

The Read_Bit(X, Y) function executes the destructive read:

1.​ Set the X and Y drive lines for the '0' (Read) polarity.
2.​ Apply the current pulse by toggling the Enable lines HIGH for $T_{pulse}$.
3.​ During this pulse, monitor the Sense Amplifier output. Wait $T_{delay}$ after pulse
initiation.
4.​ Sample the Sense Amplifier output during the $T_{read}$ window.
5.​ End the current pulse.​
If a HIGH signal is detected during the sampling window, the core previously held a '1'. If
LOW, it held a '0'.

6.4 The Critical Re-Write Logic: Implementing Atomic DRO Correction

The central complexity of core memory is the absolute necessity of restoring data after every
read.1 The firmware must ensure the Read-Restore sequence is executed as a single,
uninterrupted unit to prevent data loss.

The resulting high-level function, Read_Restore_Bit(X, Y), manages the complete atomic
operation:

Algorithm Detail:

C++

// Pseudocode for Atomic Read-Restore Operation​

int Read_Restore_Bit(int X, int Y) {​
// 1. EXECUTE DESTRUCTIVE READ (Core is set to 0)​
Apply_Read_Pulse(X, Y); // Current sets core to 0​
// Wait for flux reversal delay​
delayMicroseconds(T_delay); ​
​
// 2. SAMPLE SENSE LINE​
int R = digitalRead(SENSE_PIN); ​
​
// Stop the Read pulse​
End_Read_Pulse(); ​
​
// 3. RESTORE (Write back the original value R)​
if (R == 1) {​
// If it was 1, we must write 1 back.​
Apply_Write_Pulse_1(X, Y); ​
}​
// If R was 0, the destructive read already set the core to 0, ​
// so no further write pulse is necessary in the 2D configuration.​
​
return R;​
}​

This atomic sequence ensures that the non-volatility of the core is maintained while masking
the destructive nature of the read cycle from the higher-level text processing software.

Section VII: Text Storage Management and Software

Interface

The user requirement to read and write text necessitates a structured method for converting
ASCII characters into binary bits and mapping these bits to physical core locations.

7.1 ASCII Encoding and Byte Storage Mapping

Standard ASCII characters are typically represented by 7 bits, often stored within an 8-bit
byte, with the eighth (highest-order) bit sometimes used for parity.15 For practical
implementation, each character (byte) must be stored sequentially using eight contiguous
cores.

To store $N$ characters, $N \times 8$ cores are required. If a $4 \times 8$ array is built (32
bits), it can store 4 characters.

7.2 Memory Mapping: Assigning Core Addresses to Text Bytes

A memory map defines how logical addresses (Byte 0, Bit 3) translate into physical
coordinates (X-line, Y-line). A common approach treats each X-line as a row address for a
byte (or word), and the Y-lines as the individual bit addresses within that byte.

Table Title: Memory Address Mapping for a 4x8 Core Array (32 Bits / 4 Bytes)

Byte Index Bit Index (LSB to Core Core

(Character MSB) X-Coordinate Y-Coordinates (Bit
Address) (Row Address) Address)

Byte 0 (Character b0 through b7 X0 Y0 through Y7

1)

Byte 1 (Character 2) b0 through b7 X1 Y0 through Y7

Byte 2 (Character b0 through b7 X2 Y0 through Y7

 3)

Byte 3 (Character b0 through b7 X3 Y0 through Y7

4)

7.3 Implementing High-Level Text Read/Write Functions

The firmware requires high-level functions to handle the serial data stream:
1.​ write_byte(X_address, data_byte): This function receives an 8-bit integer (the ASCII
value) and iterates 8 times. In each iteration, it extracts one bit using bitwise operations
and calls the low-level drive_pulse function to write that bit to the core located at
$(X\_address, Y_i)$.
2.​ read_byte(X_address): This function iterates 8 times, calling the critical
Read_Restore_Bit(X_address, Y_i) for each bit. It then uses bitwise operations to
assemble the 8 received bits into a single byte before returning the resulting ASCII value,
which can be printed as a character via the serial interface.

7.4 Creating the User Interface

The Arduino Serial Monitor can serve as a simple command-line interface. Users can input
specific commands to interact with the memory. For instance, a command structure such as
W 1 65 could instruct the system to write the ASCII value 65 ('A') to byte address 1.
Alternatively, as seen in some historical projects, a custom GUI application running on a
connected PC can interface with the Arduino's serial port to provide a visual interface for
managing the memory contents.13

Section VIII: Advanced Challenges and

Troubleshooting

Building a functional core memory system is an intricate electromechanical endeavor, prone

to specific failure modes related to physics and precise timing.

8.1 Core Physical Assembly and Wiring Errors

Problem: The memory consistently fails to detect written '1's or exhibits random data
corruption (flips).
Likely Cause: Improper core material or incorrect Sense line threading.
Solution: Verify that the cores are indeed hard ferrites with a rectangular loop; soft ferrites will
not retain data.7 Crucially, re-examine the Sense line. If the serpentine pattern is incorrectly
implemented, the common-mode cancellation of transformer noise fails, overwhelming the
minuscule signal from the single flipping core. This requires careful verification, possibly using
magnification, especially if using 1 mm cores.7

8.2 Electrical Noise and Crosstalk (The "Noisy Core")

Problem: The Sense Amplifier triggers randomly, even when no read operation is active, or
detects faint signals from half-selected cores.
Likely Cause: Insufficient power isolation or residual inductive coupling.
Solution:
1.​ Power Isolation: Ensure the dedicated, high-current supply for the SN754410
($V_{CC2}$) is entirely separate from the Arduino logic supply ($V_{CC1}$) to mitigate
ground bounce noise.7
2.​ External Shielding: In excessively noisy environments, shielding the core array with
copper may be necessary to suppress external EMI.12
3.​ Timing Gate: Verify that the Sense Amplifier is only enabled (or sampled by the Arduino)
during the brief $T_{read}$ window, effectively isolating the system from the main noise
spikes generated by the driver enables.

8.3 Drive Pulse Errors: Inconsistent Flipping

Problem: The selected core flips inconsistently, or adjacent, unselected cores show
progressive data degradation (gradual partial switching) after many half-current pulses.
Diagnosis: This indicates a failure in the coincident current selection margin. The resistance
calculation for $I/2$ is incorrect relative to the specific core's $H_c$.
Solution: Recalibrate the drive current using an oscilloscope. If $I/2$ is causing degradation,
increase the series resistance ($R_{series}$) slightly to reduce the half-select current. If the
full pulse $I$ is weak, ensure the drive power supply is stable and not experiencing voltage
sag under peak pulsed load. The $I$ current must be sufficient to exceed $H_c$ reliably, while
the $I/2$ current must be clearly below the critical threshold.

8.4 Debugging Read Errors: Sense Amplifier Sensitivity and Timing

Problem: Data is written successfully (verified by the write pulse current), but the read
operation consistently returns '0' when it should be '1'.
Diagnosis: This is typically a problem with the analog front end.
Solution:
1.​ Sensitivity: The Sense Amplifier gain may be too low, or the comparator threshold may
be set too high to reliably register the genuine millivolt-level pulse. Increase the amplifier
gain or slightly lower the comparator reference voltage.
2.​ Timing: The most subtle error is incorrect timing synchronization ($T_{delay}$). The
Arduino must sample the Sense line precisely during the narrow window where the
induced pulse peaks. If the sampling occurs too early, it catches noise; too late, the
signal has decayed.7 Adjust $T_{delay}$ empirically while monitoring the Sense amplifier
output with an oscilloscope to find the peak timing.

Conclusions and Recommendations

The construction of a nonvolatile magnetic core memory system is a feasible, yet highly
complex, project for an advanced hobbyist utilizing an Arduino microcontroller. Success
hinges not merely on assembling the components but on mastering three core principles: the
physics of hard ferrite hysteresis, the precision of coincident current selection, and the
synchronization required for destructive readout management.

The primary technical challenges are the sourcing of suitable rectangular-loop ferrite cores
and the robust design of the analog Sense Amplifier, which must reliably isolate a
microsecond-scale millivolt signal from high-amperage switching noise.

Actionable Recommendations:
1.​ Prioritize Calibration: Dedicate significant effort to calibrating the drive currents ($I$
and $I/2$) using an oscilloscope to ensure a robust switching margin, preventing data
disturb errors in the array.
2.​ Ensure Power Isolation: Implement the split power supply architecture (separate VCC1
and VCC2) to isolate the sensitive logic from the high-current drive path.
3.​ Verify Physical Threading: Meticulously confirm the serpentine threading pattern of the
Sense wire to maximize passive noise cancellation, minimizing the burden on the Sense
Amplifier.
4.​ Utilize Low-Level Control: Implement firmware using direct port manipulation and
microsecond timing to achieve the necessary speed and precision for current pulse
generation and read gate synchronization.

Works cited

1.​ Magnetic-core memory - Wikipedia, accessed November 17, 2025,

[Link]
2.​ Ben North, Oliver Nash - Magnetic core memory reborn, accessed November 17,
2025, [Link]
3.​ Magnetic Core Memory - Magnet Academy - National MagLab, accessed
November 17, 2025,
[Link]
gnetic-core-memory/
4.​ Coercivity and Remanence in Permanent Magnets - HyperPhysics, accessed
November 17, 2025,
[Link]
5.​ An introduction to magnetic core memory CORE - [Link], accessed November
17, 2025, [Link]
6.​ A Coincident-Current Magnetic Memory Unit, - DTIC, accessed November 17,
2025, [Link]
7.​ Wayne's Tinkering Page - One Bit Ferrite Core Memory - Google Sites, accessed
November 17, 2025,
[Link]
8.​ The issue with noisy cores and how to solve them - Acal BFi, accessed November
17, 2025,
[Link]
9.​ Coincident current magnetic core memories - K-REx, accessed November 17,
2025,
[Link]
67c7e94f1d/content
10.​core memory system manual - [Link], accessed November 17, 2025,
[Link]
df/DEC-11-HMELA-B-D%20ME11-L%20Core%20Memory%20System%20Manual.
pdf
11.​ How magnetic core memory works - Rolfe Bozier, accessed November 17, 2025,
[Link]
12.​Core Memory (magnetic memory) - All About Circuits Forum, accessed
November 17, 2025,
[Link]
 65/
13.​Building a Magnetic Core Storage Interface from Scratch! Arduino, Design,
Schematic, PCB, KiCad - YouTube, accessed November 17, 2025,
[Link]
14.​Magnetic Core Memory description, accessed November 17, 2025,
[Link]
15.​2.13 Storing Characters - Robert G. Plantz, accessed November 17, 2025,
[Link]
16.​How characters are stored in memory - Log2Base2, accessed November 17, 2025,
[Link]