Tutorial on how to build a "hall effect sensor" controlled LED

By David Klarbrant, [e-mail]

Short description: A hall effect sensor is a sensor that can detect magnetic flux and switches the output from the sensor once the flux exceeds a specific threshold. This tutorial describes how to control a LED-light to make it light up once the sensor "triggers" and senses a change in the flux. The output will also be shown in a graph using PyBytes which is Pycoms own IoT cloud based platform.

Time estimated to setup from scratch: ~30 mins

Objective:

I chose this project mainly because I wanted to learn the basics of IoT i.e. how to wire sensors, how to program them, how to connect them to the internet, etc. This was done solely with this kit from Electrokit. I wanted to do something other than just using the sensors on the Pysense shield because I wanted to wire some stuff myself and opted for the Hall Effect sensor together with a LED to make it a bit more exciting!

As the project stands now, it doesn't serve much of a purpose other than being an easy entry point to learn the basics of IoT but one could imagine a similar concept where you for example mount a sensor on a door together with a magnet so that you are sent information or a LED lights up when the door is open/closed. There are a lot of things you can do with the concept of a hall effect sensor and a magnet.

This tutorial will give you an easy project to start with using a pre-configured bundle in order to understand the basics around IoT, sensors, programming, internet connection, graphing/visualisation, etc.

Material:

As mentioned previously, everything needed for the project is included in this kit from Electrokit. The kit costs 1499.00 SEK as of June 2022. You can however, find the items for a cheaper price if you buy only the needed items, but it isn't much money you will save.

Here are the specific items needed:

• 1 x Breadboard (~69 SEK)
• 1 x Pycom Fipy (aka microcontroller) (~650 SEK)
• 1 x Micro USB cable (~39 SEK)
• 1 x Pysense 2.0x (aka a shield or expansion board) (~320 SEK)
• 1 x Antennae (~109 SEK)
• 1 x LED (~3 SEK)
• 1 x Resistor 330 ohm (~3 SEK)
• 1 x Magnet (~11 SEK)
• 11 x Jumper Wire (Suggestion: 4xRed, 4xBlue, 1xYellow, 1xOrange, 1xWhite) (~29 SEK)

The total cost of the individual parts is ~1233 SEK so I would recommend just getting the complete kit to make it easy.

What is everything used for?

• The breadboard is used to connect all of the above items into a functional system.
• The FiPy (microcontroller) is a small computer and is used to control the system, the brain so to speak.
• The Pysense (shield) together with the Micro USB cable is in this use case used to supply power to the microcontroller, breadboard and in extension the sensors. It also enables you to connect the FiPy at all. It does also have it's own five sensors that you can use for other ideas but won't be covered in this tutorial.
• The antennae is used to connect the microcontroller the internet using WiFi.
• The LED is used to light up once the Hall Effect sensor is triggered.
• The resistor is used to lower the voltage and limit the current in the circuit.
• The jumper wires are used to connect everything on the breadboard together.

Computer Setup

I've used Atom as my preferred IDE (the program where you write, test and excute your code), it's easy to setup and learn the basics. I've had only some experience with programming and for that I used Visual Studio, ATOM was easier for me to get into than VS was.

To setup Atom and start your IoT journey, you can simply follow these steps:

Step 1: Download and install Node js (here). Node js is needed for the Pymakr plugin below.
Step 2: Download and install Atom (here).
Step 3: Open Atom and the package manager from: File >> Settings >> Install.
Step 4: Look for Pymakr and Install it. (It takes a while; wait until shows it is successfully installed)

Once you have setup your Atom IDE (or other suitable IDE of your choice) you have to update the firmware on your FiPy and Pysense. Otherwise you will get issues and errors once you start pushing your code.

Let's start with the PySense firmware. You should not mount the FiPy (microcontroller) on the PySense for this, just connect the Pysense to the computer using the USB.

Instead of me typing out exactly how to do it, I recommend that you follow the instructions in this video as that will be a way faster way of understanding and doing it. I recommend you to check out more of Core Electronics youtube and website as they have some really useful and cool guides.

FYI, the button that you have to press in that they reference in the video is this one, I spent some time trying the other one…

Now it's time to update the firmware on your microcontroller, simply follow these steps:

Follow these steps:

Step 1: Mount your FiPy on the Pysense shield, remember that the LED of the FiPy is on the same side as the USB port on the Pysense.

Step 2: Connect your PyCom Expansion board to your computer with a USB cable.
Step 3: Download the Firmware Update from this link.
Step 4: Install the downloaded file and open it.
Step 5: Follow these steps to upgrade firmware:

• Press Continue and continue again on the first two pages.
• In port section, select the COM port to your PyCom Expansion board (Could be find in Windows Device Manager) Pic 1.
• In type section, select the development and press continue… Pic 1.
• It should automatically detect your board type, then select Erase during update and CONFIG partion & NVS Partition, and finally press continue. Pic 2.
• It takes some time and finally you can press one Done. Pic 3

Pic 1.

---

Pic 2.

---

Pic 3.

---

If you have done all of the steps for the FiPy above, you should be able to open ATOM and disconnect and reconnect the board. Note that the area where the text "Connecting to COM9…" etc is called REPL.

You are now ready to push some code to the microcontroller! Let's see if it works!

Try print("Hello from PyCom") on REPL and see if it successfully shows the message.

Step 3: We are ready to make our first project now. Create a folder on your computer, on the desktop or anywhere where you want your projects to reside.

Step 4: In Atom click on File > Add Project Folder from the left panel then open the folder you created.

Step 5: Right-click on your project folder from the left panel and choose New File to create a new file, in the opened box enter main.py and press enter. All projects must have a main.py as it is the start point for code execution.

Step 6: Copy the following lines in main.py and save it. The # is used to comment and describe the code to make it easy to follow along what each line or function is doing.

import pycom		#Import pycom to control LED
import time		#Import time to create delays

#We disable LED heartbeat to control it manually
pycom.heartbeat(False)

#Your board run this section over and over
while True:
    #colors in hexadecimal (0xRRGGBB)
    pycom.rgbled(0xFF0000)  # Red
    time.sleep(1)
    pycom.rgbled(0x00FF00)  # Green
    time.sleep(1)
    pycom.rgbled(0x0000FF)  # Blue
    time.sleep(1)

Step 7: Now upload the file to your board from the upload project button:

Step 8: The LED on your board starts to blink different colour

Congrats, you have now created your first project and pushed your first code to your microcontroller!

Putting the hardware together

Set the board up as shown in this image. Note that the Hall Effect should be rotated 180 degrees in reference to the picture so the flat side of the sensor is the other way around, always check the data sheet to see which pin is supply voltage(red wire), GND (blue wire) and output (white wire.)

The cables that goes from the microcontroller directly to the Pysense are the following:

5V <––––––––-> 5V.
GND <–––––––-> GND.
UART_Rx <–––––––-> UART_Rx.
UART_Tx <–––––––-> UART_Tx.

---

IRL it should look something like this. Once again, note the hall effect sensor. The flat side towards you from this point of view.

---

Platform

The IoT platform of my choice was PyBytes which is PyComs own cloud platform used to display information, graphs and so on. I choose this one because I wanted to use their platform as it seemed like the easiest one to connect to as this was totally new to me and to be fair, it was very easy and fast. Getting everything setup was super easy, however, I would not recommend you to use Pybytes for this project if you have other options such as Datacake, Grafana, etc. The reason being that Pybytes free version (I have no experience with the payed version, it might be better) is very down scaled with limited functionality:

• Pybytes only allows you to send you data so often, every 5 minutes to be specific, which may be enough for some use cases, but not this one, at least not for what I envisioned.
• For this use case, the available graphs together with the restrictions of the frequency of data transfer, makes the data visualisation rather useless. The you do get a indication of when the sensor is triggered but you will only see the that is has been triggered every 5 minutes, even if it's continuously triggered.
• The free version does give you a number of graphs to choose from, nothing note worthy I would say.
• It also allows you to connect multiple devices and group them together if you want to, as well as send different data as different "signals" to differentiate easily.

If you have the time and/or knowledge, I do strongly recommend using another visualisation platform for this project.

The code

In the project folder you need two files, the "boot.py" which is the first file to trigger when you start executing the code and start the microcontroller(note that unlike "main.py", the "boot.py" is not required for the software to run but is very useful), this will contain the connection to WiFi, and the "main.py" which contains the code for the functionality of the sensor, sending information to PyBytes and the lighting of the LED.

The "boot.py" should contain the following code:

def do_connect():
    from network import WLAN
    import time
    import pycom
    import machine
    pycom.wifi_mode_on_boot(WLAN.STA)   # choose station mode on boot
    wlan = WLAN() # get current object, without changing the mode
    # Set STA on soft rest
    if machine.reset_cause() != machine.SOFT_RESET:
        wlan.init(mode=WLAN.STA)        # Put modem on Station mode
    if not wlan.isconnected():          # Check if already connected
        print("Connecting to WiFi...")
        # Connect with your WiFi Credential
        wlan.connect('YourSSID', auth=(WLAN.WPA2, 'YourPassword'))
        # Check if it is connected otherwise wait
        while not wlan.isconnected():
            pass
    print("Connected to Wifi")
    time.sleep_ms(500)
    # Print the IP assigned by router
    print('network config:', wlan.ifconfig(id=0))


def http_get(url = 'http://detectportal.firefox.com/'):
    import socket                           # Used by HTML get request
    import time                             # Used for delay
    _, _, host, path = url.split('/', 3)    # Separate URL request
    addr = socket.getaddrinfo(host, 80)[0][-1]  # Get IP address of host
    s = socket.socket()                     # Initialise the socket
    s.connect(addr)                         # Try connecting to host address
    # Send HTTP request to the host with specific path
    s.send(bytes('GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n' % (path, host), 'utf8'))
    time.sleep(1)                           # Sleep for a second
    rec_bytes = s.recv(10000)               # Receve response
    print(rec_bytes)                        # Print the response
    s.close()                               # Close connection

# WiFi Connection
do_connect()
# HTTP request
http_get()

It contains some unnecessary code that is not relevant to the acctual connecting but can help you verifiy that you actually connect. I believe you can remove the last function "def http_get" etc but the code doesn't "hurt" or change any functionality. You can actually use visit http://detectportal.firefox.com/ and verify that data was succesfully sent/recieved.

Make sure you edit "YourSSID" (xxx in the picture) and "YourPassword"(xxx in the picture) to your own SSID and network password.

---

The "main.py" should contain the following code:

from machine import Pin
import time

halleffect = Pin('P11', mode=Pin.IN, pull=Pin.PULL_UP) #Connect the variable of "halleffect to pin P11 of the microcontroller. 
led = Pin('P10', Pin.OUT) #Connect the variable of "led" to pin P10 of the microcontroller.

def upload(hallvalue): #This code created a function called "upload".-
    pybytes.send_signal(1,hallvalue) #Sends the hallvalue to pybytes as signal 1. 
    print("sending: {}".format(hallvalue)) #Prints the value in the REPL screen below, so you can see what value is sent 

while True: #Creates a loop that never ends since it has no break statement.
    hallvalue = not halleffect() #Reverse the hallvalue since we only want to send the informatin when the sensor is triggered, not when it's just checking and no changes is noted. 
    if hallvalue == True: #If the hallvalue is of the boolean variable True then do the following
        hallvalue = 0 #Set the value to 0 instead of True since Pybytes graph wants 0 or 1 as input instead of boolean.
        upload(hallvalue) #Call the function called "upload".
        print(hallvalue) #Pring the value in REPL.
        led.value(1) #LED is 1 which makes it light up.
        time.sleep(5) #Sleeps for 5 seconds
        led.value(0) #LED is 0 which makes it turn off.

---

Transmitting the data
The data is sent using WiFi and is sent every time the sensor is triggered within a timeframe of 5 seconds (can't be triggered more often than that). As mentioned before though, the free pybytes version is limited to 5 minutes so that is how often it will show updated data in Pybytes and uses MQTT altough the code contains some HTTP since I reused it from the tutorial.

Presenting the data

As mentioned before, the Pybytes visualisation for this use case isn't all that exciting, as been below you can see 3 different widgets/charts. The past hour/day data only shows the amount of data sent i.e bytes over time.

---

The third one named "test" shows a flatline and will only indicate that FiPy1 has sent a signal named 1 with the value 0, which is the value that the sensor sends when it is triggered by a magnet. The plan was to make this a bit more exciting and send all the value 1:s as well so that you can see in real time whenever the sensor is not triggered and exactly when it gets triggered and sends a 0 instead. But due to the limitations previously mentioned about how often you can send/store data (once again limited to 5 minutes) to Pybytes free version, it makes then visualisation dull to say the least, but it works!

Finalizing the design

The final result is kind of what I was expecting in terms of functionality of the hardware/software. As mentioned multiple times earlier I was quite disappointed in Pybytes limitations and hence moving forward, I will not use Pybytes for my future projects. Due to the circumstances with shortages and longer delivery times I only just received the sensors that I wanted to use originally so I believe I can make a much more exciting project in the future, using the experience and knowledge I've acquired during the course. And for me that was the whole point of this course, learn, try, make mistakes and try again. I will remain within the Discord community seeing that it is very active and filled with great knowledgeable people, both teachers, teacher assistants and students that have all been very helpful for someone who was new to this.

If you are new to IoT, programming and hardware wiring I can definitely recommend this project as one with very low skill level, you will understand the basics and from here on move to more advanced and fun projects! Check out the video if you want to see it in action, it's not the coolest thing but it works! :)

Video of the final result:
https://youtu.be/KT2Rq_VL6-8

Best regards, David!