Hall Sensor Arduino Projects: Wiring, Code, and Debugging the SS49E & A3144

If you need to measure magnetic field strength, detect proximity without physical contact, or calculate RPM, a Hall effect sensor is the right tool. The SS49E outputs a ratiometric analog voltage (typically 0.5V to 4.5V) proportional to magnetic flux density, while the A3144 is a digital open-drain switch that pulls its output low when exposed to a south-pole magnetic field exceeding roughly 3.5mT. Both are cheap, but they fail in very specific, predictable ways when wired incorrectly.

This guide targets the Arduino Nano v3 (ATmega328P) and provides a complete dual-sensor test rig. We will cover the exact hardware spec differences, a noise-filtered codebase, and the specific debugging steps for when your serial monitor spits out garbage or clamped values.

Digital vs. Linear Hall Sensors: Spec-Sheet Breakdown

The most common mistake makers make is buying a "Hall sensor module" without checking if it is digital (switch/latch) or linear (analog). A digital sensor will not give you distance or field strength; a linear sensor requires ADC calibration and noise filtering. Here is how the three most common hobbyist variants compare on the bench.

Hardware Wiring & Pin Mapping

For this build, we are wiring both an SS49E (for analog field mapping) and an A3144 (for digital RPM counting) to a single Arduino Nano v3.

Parts List

• 1x Arduino Nano v3 (ATmega328P, 5V logic)
• 1x SS49E Linear Hall Effect Sensor (TO-92 package)
• 1x A3144 Digital Hall Switch (TO-92 package)
• 1x 10kΩ resistor (pull-up for A3144)
• 1x 100nF (0.1µF) ceramic capacitor (decoupling for SS49E)
• 1x N52 Neodymium magnet (10mm x 3mm disc)

Pin Mapping Table

Wiring Steps

1. Prep the Sensors: The TO-92 package pinout for both sensors, facing the flat side with leads pointing down, is Left=VCC, Center=GND, Right=OUT.
2. Decouple the Analog Line: Solder or breadboard the 100nF capacitor directly across the SS49E VCC and OUT pins, or OUT and GND. Without this, the SS49E's internal op-amp will pick up high-frequency switching noise from the Arduino's clock, resulting in a jittery ADC read.
3. Pull-up the Digital Line: Connect the 10kΩ resistor between the A3144 OUT pin and the 5V rail. The A3144 is open-drain; it can only pull the line to ground. Without the pull-up, the D2 pin will float and trigger phantom interrupts.
4. Verify Voltages: Before plugging in the Nano, use a multimeter to check continuity between VCC and GND to ensure no solder bridges exist.

Complete Arduino Code for Magnetic Field & RPM Logging

This sketch targets the Arduino Nano v3. It uses a hardware interrupt on D2 to calculate RPM without blocking the main loop, and applies a simple exponential moving average (EMA) filter to the A0 analog reads to smooth out magnetic noise. It also includes fault detection for disconnected or saturated sensors.

// Target Board: Arduino Nano v3 (ATmega328P, 16MHz)
// Libraries: None required (Core Arduino AVR)

#define PIN_LINEAR_HALL A0
#define PIN_DIGITAL_HALL 2 // Hardware Interrupt 0 on Nano

// Analog Filtering & Fault Thresholds
const float EMA_ALPHA = 0.15; // Smoothing factor (lower = smoother)
float filteredAnalog = 512.0; // Initialize at mid-scale (2.5V)
const int ADC_CLAMP_LOW = 15;  // Threshold for short-to-ground fault
const int ADC_CLAMP_HIGH = 1008; // Threshold for VCC saturation fault

// RPM Calculation Variables
volatile unsigned long lastPulseMicros = 0;
volatile unsigned long pulseIntervalMicros = 0;
volatile bool newPulseReceived = false;
unsigned long lastRpmPrintMillis = 0;

void setup() {
  Serial.begin(115200);
  while (!Serial && millis() < 2500); // Wait for serial port
  
  pinMode(PIN_LINEAR_HALL, INPUT);
  pinMode(PIN_DIGITAL_HALL, INPUT_PULLUP); // Internal pull-up as backup to external 10k
  
  // Attach interrupt on FALLING edge (A3144 pulls low when magnet is near)
  attachInterrupt(digitalPinToInterrupt(PIN_DIGITAL_HALL), hallISR, FALLING);
  
  Serial.println("Hall Sensor Test Rig Initialized.");
  Serial.println("Format: [Status] | Analog_Raw | Filtered_mV | RPM");
}

void loop() {
  // 1. Read and Filter Analog Sensor (SS49E)
  int rawAnalog = analogRead(PIN_LINEAR_HALL);
  filteredAnalog = (EMA_ALPHA * rawAnalog) + ((1.0 - EMA_ALPHA) * filteredAnalog);
  
  // Convert to millivolts (Assuming 5V reference on Nano)
  float voltageMv = (filteredAnalog / 1023.0) * 5000.0;
  
  // 2. Error Handling & Fault Detection
  String status = "OK";
  if (rawAnalog <= ADC_CLAMP_LOW) {
    status = "ERR: LINEAR_SHORT_GND";
  } else if (rawAnalog >= ADC_CLAMP_HIGH) {
    status = "ERR: LINEAR_SATURATION_HIGH";
  }
  
  // 3. Calculate RPM safely
  float currentRPM = 0.0;
  noInterrupts(); // Critical section: read volatile variables
  unsigned long intervalCopy = pulseIntervalMicros;
  bool pulseCopy = newPulseReceived;
  newPulseReceived = false;
  interrupts();
  
  if (pulseCopy && intervalCopy > 0) {
    // Microseconds per revolution -> Revolutions per minute
    currentRPM = 60000000.0 / (float)intervalCopy;
  } else if (millis() - (lastPulseMicros / 1000) > 2000) {
    currentRPM = 0.0; // Timeout: magnet is gone or motor stopped
  }

  // 4. Print Data (Throttled to 10Hz to avoid serial buffer flooding)
  if (millis() - lastRpmPrintMillis >= 100) {
    lastRpmPrintMillis = millis();
    Serial.print("["); Serial.print(status); Serial.print("] | ");
    Serial.print(rawAnalog); Serial.print(" | ");
    Serial.print(voltageMv, 1); Serial.print(" mV | ");
    Serial.print(currentRPM, 1); Serial.println(" RPM");
  }
}

// Interrupt Service Routine (ISR) for A3144 Digital Switch
void hallISR() {
  unsigned long currentMicros = micros();
  if (lastPulseMicros > 0) {
    pulseIntervalMicros = currentMicros - lastPulseMicros;
    newPulseReceived = true;
  }
  lastPulseMicros = currentMicros;
}

Debugging: When Readings Clamp or Drift

Hall sensors are notoriously susceptible to power rail noise and magnetic hysteresis. If your build fails, do not immediately rewrite the code. Hardware faults account for 95% of Hall sensor issues. Here is the exact decision path for the most common failures.

Symptom: Serial Monitor prints ERR: LINEAR_SATURATION_HIGH

This exact error string triggers when the ADC reads consistently above 1008 (approx 4.92V). The sensor is maxing out the Arduino's ADC reference.

1. Check Magnet Proximity: The SS49E saturates at roughly ±100mT. An N52 neodymium magnet placed closer than 5mm will easily exceed this. Move the magnet back to 15mm and re-test.
2. Measure VCC at the Sensor: Do not measure the Nano's 5V pin. Put your multimeter probes directly on the SS49E VCC and GND legs. If the voltage is below 4.8V, the internal op-amp rail is collapsing, pushing the output high. This is usually caused by powering the Nano via a weak USB port. Use a powered hub or the VIN pin with a 9V wall adapter.
3. Verify the Decoupling Capacitor: If the 100nF capacitor is missing or placed more than 1cm away from the sensor pins on the breadboard, high-frequency noise will cause the ADC to sample voltage spikes, triggering the saturation threshold.

Symptom: RPM Reads 0.0 or Bounces Wildly

If the analog side works but the A3144 digital interrupt fails, check these three items:

1. Magnet Polarity: The A3144 is a unipolar switch that only responds to the South pole of a magnet. Flip your neodymium disc over. If the RPM suddenly registers, you had the North pole facing the sensor.
2. Pull-up Resistor Presence: Measure the voltage on Arduino Pin D2 with the magnet removed. It must read 5.0V. If it reads 0V or floats around 1.2V, your 10kΩ pull-up resistor is disconnected or broken.
3. Interrupt Pin Mapping: Ensure you are using Pin D2 or D3 on the Nano. Pins like D4 or A1 do not support hardware interrupts on the ATmega328P. The code explicitly uses digitalPinToInterrupt(2).

Extending and Simplifying the Build

Depending on your end goal, the baseline Nano + SS49E/A3144 rig might need to be scaled up for precision or scaled down for cost and simplicity.

How to Extend for Higher Precision

The Arduino Nano's internal ADC is 10-bit (1024 steps). Over a 5V range, that is roughly 4.8mV per step. Given the SS49E's sensitivity of 1.4mV/G, your magnetic resolution is limited to about ~3.5 Gauss per step. To fix this:

• Add an I2C ADC: Wire an ADS1115 (16-bit ADC) to the I2C pins (A4/A5 on Nano). This drops your resolution down to 0.18mV per step, allowing you to detect micro-movements in magnetic levitation projects or precise fluid level sensing.
• Use a Bipolar Latch: If you are building a motor encoder, swap the A3144 for a DRV5012 bipolar latch. It triggers on both North and South poles, effectively doubling your RPM resolution without changing the magnet size.

How to Simplify for Basic Proximity

If you only need to know "is the door open or closed" or "is the gear engaged", you do not need an Arduino or an analog sensor.

• Drop the Microcontroller: Wire the A3144 directly to a 5V relay coil (with a flyback diode) or an optocoupler. When the magnet approaches, the A3144 pulls low, sinking current through the optocoupler LED and switching your secondary circuit.
• Use a Reed Switch: If you don't need to survive high vibration or high RPMs, a $0.10 glass reed switch requires zero power, zero code, and zero pull-up resistors. It simply closes a mechanical contact in the presence of any magnetic field.

By selecting the correct Hall variant for your specific flux-density requirements and respecting the decoupling and pull-up requirements on the breadboard, you eliminate the erratic "ghost readings" that plague most beginner magnetometer projects.