Arduino Hall Effect Sensor: A Beginner's Guide to Using an Arduino with a Hall Effect Sensor

Introduction

An Arduino hall effect sensor is a useful sensor for detecting the presence or absence of a magnetic field. In this tutorial, we will use a hall effect sensor to control an LED on an Arduino board.

Hall effect sensors are ideal for detecting objects like gears, screws, or other components for sensing movement e.g. rpm measurement, position, or proximity. For these to work you typically embed a small magnet somewhere on the piece to be measured.

The type of hall effect sensor used here (49e) is a linear output device meaning it outputs an analog voltage proportional to the detected magnetic field.

In this project, we will use a 49e hall effect sensor module to detect a magnet and control an LED on the Arduino. This project will show the basic operation and usage of a hall effect sensor with an Arduino, reading the analog output, and mapping it to LED brightness.

What is a 49e Hall Effect Sensor

The 49e hall effect sensor is a basic hall effect sensor module commonly used with Arduino. Inside the 49e, there is a thin piece of conductive material like gallium arsenide. When a magnetic field is passed through this material, it alters the placement of electrons. This change in electron movement can be measured as a voltage difference.

So the 49e output a voltage 0~5V directly proportional to the magnetic field it experiences.

Unexpected operation of the 49e

The output of the sensor does vary from 0V to 5V in the presence of a magnetic field. So you probably expect a zero reading for no magnetic field.

Warning: The 49e output is not zero Volts for No magnetic field.

However, what is not clear from the datasheet is that the output is offset to the midrail for zero magnetic output i.e. 2.5V

This is done so that the sensor can determine the polarity of the magnetic field i.e. North or South polarity fields.

You can see this effect in the first example program below. Hold a magnet in front of the sensor and then hold it behind the sensor to see the serial output value changing.

Results from the 1st Example program:

This is the type of result you will get (hold the magnet very close to the 49e sensor when doing this to get max. and min. values):

Reading: 520    Volts: 2.54     Bright: 129<BR>
Reading: 520    Volts: 2.54     Bright: 129<BR>
Reading: 520    Volts: 2.54     Bright: 129<BR>
Reading: 521    Volts: 2.54     Bright: 129<BR>
Reading: 874    Volts: 4.27     Bright: 217<BR>
Reading: 875    Volts: 4.27     Bright: 218<BR>
Reading: 520    Volts: 2.54    Bright: 129<BR>
Reading: 520    Volts: 2.54    Bright: 129<BR>
Reading: 174    Volts: 0.85    Bright: 43<BR>
Reading: 174    Volts: 0.85    Bright: 43<BR>
Reading: 175    Volts: 0.85    Bright: 43<BR>
Reading: 173    Volts: 0.84    Bright: 43<BR>
Reading: 520    Volts: 2.54    Bright: 129<BR>
Reading: 520    Volts: 2.54    Bright: 129<BR>

Note that the voltage is estimated assuming a 5V accurate supply (its not that accurate); but for this purpose is close enough.

What you will notice is that:

  • the mid voltage is 2.54V
  • the lowest voltage is 0.84V
  • the highest voltage is 4.27V

Is this right? answer - yes the datasheet indicates that this is the correct output. Here's a graph of the output:

Graph of 49e hall effect Voltage vs Gauss detected

Graph of e49 hall effect Voltage vs Gauss detected

So the measured results from the Example1 program match this characteristic. Now you can create a program that will operate correctly to drive the LED. See Example 2

Required Components

  • Arduino Uno
  • 49e Hall Effect Sensor
  • Breadboard
  • Jumper wires
  • Magnet
  • LED
  • 1k Ohm resistor

Arduino Hall Effect Sensor: Circuit Layout

The circuit connects the 49e hall effect sensor to an Arduino. Vcc of the sensor connects to the 5V pin on the Arduino. GND connects to ground. The 49e's output connects to analog pin A0. As magnetic field strength changes, A0 reads the varying output voltage. This value drives the brightness of an LED via PWM on pin 5.

arduino hall effect sensor
Diagram using Fritzing
arduino hall effect sensor schematic

Diagram using Fritzing

Arduino Hall Effect Sensor: Example Sketch Ex1

Here's an example sketch to get you started with the magnetic sensor 49e. Note this program allows you to see the zero field output voltage, maximum and minimum ADC values detected.

This is a first stab at detecting the magnet and you'll notice that it is not very good at dimming the LED This is because it makes an assumption about the 49e sensor i.e. that it goes from 0V to 5V when a magnetic field is detected. As noted above the 49e sits at the mid point and goes above and below 2.5V, in the presence of a magnetic field.

You can copy and paste the code below into the Arduino IDE (in a new sketch) replacing everything that is in the new sketch window (See "Uploading the code" below).

const float ADCmV=5.0/1024; // Estimated as 5V is not accurate
const int hallSensor = A0;  
const int pwmLED = 5;

void setup(){
  Serial.begin(9600);
  pinMode(pwmLED, OUTPUT);
}

void loop(){
  int reading = analogRead(hallSensor);
  int brightness = map(reading, 0, 1023, 0, 255);
 
  analogWrite(pwmLED, brightness);

  delay(1000);
  Serial.print("Reading: ");
  Serial.print(reading);
  Serial.print("\tVolts: ");
  Serial.print(reading * ADCmV );
  Serial.print("\tBright: ");
  Serial.println(brightness);

}

Arduino Hall Effect Sensor: Ex1 Code Explanation

The code is for testing and viewing Arduino hall effect sensor output
  • Const float ADCmV=5.0/1024 defines a constant for the analog to digital converter voltage reference which is estimated at 5V divided by 1024 possible readings
  • Const int hallSensor = A0 defines the analog pin A0 to read the hall sensor voltage
  • Const int pwmLED = 5 defines the pin 5 to control the brightness of the LED using PWM
  • Setup initializes the serial port at 9600 baud and sets pin 5 to OUTPUT for PWM
  • Loop continuously runs the following:
    • Reads the analog value from the hall sensor pin into an int variable called reading
    • Maps the reading from 0-1023 range to 0-255 for brightness level
    • Writes the brightness level to the PWM pin to control LED brightness
    • Prints the reading, voltage calculated from reading, and brightness level to the serial monitor
    • Adds a 1 second delay before repeating
  • It converts the raw analog reading to a voltage and maps it to a brightness level to control the LED based on the hall sensor voltage reading

Arduino Hall Effect Sensor: Uploading the Code

There are a few steps to uploading the code using the Arduino IDE:

  1. Connect the Arduino Uno to the PC with a USB cable.
  2. Select the Arduino Uno hardware.
  3. Open a new sketch.
  4. Paste the code above into the new page (overwrite everything).
  5. Press the upload button (right arrow at top).

You can find a more detailed tutorial on the Arduino IDE page.

Arduino Hall Effect Sensor: Example Sketch Ex2

This code gives a far better response to the magnetic field when the LED is dimmed as the ADC readings are automatically detected for midpoint, maximum and minimum values.

To get the code working correctly, calibrate the sensor each time. Slowly bring the magnet in front of the sensor to touching the sensor, then do the same for the back side of the sensor.

Now when the magnet approaches from either side, the LED will slowly get brighter. Note that the sensing distance is far better than the previous code operation

const int hallSensor = A0;  
const int pwmLED = 5;
int midValue = 0;  // Auto cal 1st 500ms
int minValue = 0;  // Auto cal.
int maxValue = 0;  // Auto cal.
const float ADCmV=5.0/1024; // Estimated as 5V is not accurate.

void setup(){
  Serial.begin(9600);
  pinMode(pwmLED, OUTPUT);

  // Gather readings over 500ms and calibrate the mid point.
  // Assumes no magnet is near.
  for(int i=0; i<5; i++) {
    midValue += analogRead(hallSensor);
    delay(100);
  }
  midValue /=5;
  minValue = midValue;  // Auto cal.
  maxValue = midValue;  // Auto cal.
}

void loop(){
  int brightness;
  int reading = analogRead(hallSensor);

  // Calibrate for min max measured Gauss
  if (reading < minValue) minValue = reading;
  if (reading > maxValue) maxValue = reading;

  if (reading>=midValue)
    brightness = map(reading, midValue, maxValue, 0, 255); // map readings above 2.5V
  else
    brightness = map(reading, midValue, minValue, 0, 255); // map readings below 2.5V
 
  analogWrite(pwmLED, brightness);

  delay(200);  

  Serial.print("Reading: ");
  Serial.print(reading);
  Serial.print("\tVolts: ");
  Serial.print(reading * ADCmV );  
  Serial.print("\tMin: ");
  Serial.print(minValue);
  Serial.print("\tMax: ");
  Serial.print(maxValue);  
  Serial.print("\tBright: ");
  Serial.println(brightness);

}

Code Explanation Ex2

Initially, over 500ms, 5 readings are taken to get the midpoint ADC value - assuming that no magnet is nearby. After that maximum and minimum readings are used to get the limits of the magnetic field which is then mapped onto a PWM LED. This gives a greater range of dimming than the 1st Example because it does not assume incorrect ADC values.

It's using an analog hall effect sensor connected to analog pin A0 to read the magnetic field strength.

It's controlling the brightness of an LED connected to PWM pin 5 based on the hall sensor reading.

The variables midValue, minValue, maxValue are used to calibrate the sensor readings.

In setup():
  • It initializes serial communication at 9600 baud
  • Sets pin 5 as output for the LED
  • Takes 5 analog readings over 500ms from the hall sensor pin
  • Averages these readings to determine the mid/center value with no magnet present
  • Initializes minValue and maxValue to this mid value

In loop():

  • Takes a new reading from the hall sensor
  • Updates minValue if reading is lower
  • Updates maxValue if reading is higher
  • Maps the reading to a PWM brightness value:
    • Above midValue maps to top half of brightness range
    • Below midValue maps to bottom half
  • Writes brightness value to LED pin
  • Prints debug values over serial

It's continuously calibrating the sensor's min/max readings and controlling LED brightness based on the hall sensor reading, mapped between its calibrated range.

The end result is the LED brightness responds to the strength of the magnetic field detected by the hall sensor.

Testing the Circuit

Sweep a magnet near the 49e sensor. The LED should change brightness proportionally to the magnetic field detected. This demonstrates how to interface a linear hall sensor for proportional sensing applications.

Conclusions

In this tutorial you learned how to use a hall effect sensor to detect magnetic fields and control an Arduino output. Hall effect sensors are very useful for proximity, position, and motion sensing.

This is a basic example but demonstrates the core concept of using a hall effect sensor with an Arduino. There are many ways to expand on this project, such as integrating the sensor into a larger electronic project for automatic control or feedback.

It is interesting to note that using a more complex program allows the magnet to be detected more easily at greater distance.



Further reading: For a more complex Arduino Hall Effect sensor (measures magnetic field in 3 directions x, y, z - for orientation detection) check out the HMC5883L chip.


Written by John Main who has a degree in Electronic Engineering.

Note: Parts of this page were written using claude-instant as a research assistant.


Comments

Have your say about what you just read! Leave me a comment in the box below.

Don’t see the comments box? Log in to your Facebook account, give Facebook consent, then return to this page and refresh it.



Privacy Policy | Contact | About Me

Site Map | Terms of Use