Amazing Open Source Raspberry Pi Pico 2 Synth, Cutting Edge Power over Skin Research, and much more!

0:00:00 / -

Watch now on YouTube Watch now

Raspberry Pi Magnetometer

About the project

In this project, we use an MCC 118 Voltage Measurement DAQ HAT and Raspberry Pi to read the linear output from a magnetic field sensor.

Project info

Difficulty: Moderate

Platforms: Digilent, Raspberry Pi

Estimated time: 3 hours

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	Raspberry Pi 4 Model B 1GB, 2GB, 4GB or 8GB RAM	x 1
	MCC 118 Voltage Measurement DAQ HAT Voltage Measurement DAQ HAT for Raspberry Pi®, 12-bit, 100 kS/s	x 1
	AD22151 Linear Output Magnetic Field Sensor	x 1
	0.1uF capacitor	x 1
	Resistors R1 = 10k, R2 = 2.2k, and R3 = 100k	x 3
	Half-size Breadboard	x 1
	Wire Kit	x 1

Software apps and online services

	Raspbian os
	GIT
	Python libraries
	MCC DAQ HAT libraries

Story

Software setup

To use the MCC DAQ 118 hat with the Raspberry Pi, the first thing to do is install the libraries provided by the manufacturer.

Here are the steps:

1.Open a terminal window if using the graphical interface and update your package list:

sudo apt update

2. Optional: Update your installed packages and reboot:

sudo apt full-upgrade
sudo reboot

3. If not installed install git:

sudo apt install git

4. Download the package offered by the manufacturer to your user folder with git:

cd ~
git clone https://github.com/mccdaq/daqhats.git

5. Install the library. The installer will ask if you want to install Python 2 and Python 3 support.

 cd ~/daqhats
 sudo ./install.sh

If you want to perform a firmware update or to read more information about the MCC 118 you can visit the MCC DAQ HAT Library documentation.

Hardware setup

For this project, we will need some components besides Raspberry Pi and MCC 118. To create the magnetic field sensor, we will need the following components: AD22151 (Magnetic Field Sensor), three resistors that we will size later, a 0.1µF capacitor, a breadboard, and some wires. To start this project, the first configuration offered by the manufacturer in the datasheet will be used (AD22151 Data Sheet).

R1 is a resistor used for temperature compensation, 10K was chosen from the graph provided, to compensate for small values in temperature deviations.

R2 and R3 are used to set the Gain in this circuit. The values were chosen after performing the calculation with the formula written below. The value of R3 is 100K and for R2, after performing the computer, the value of 2.2K was chosen. Thus, a gain of approximately 19 mV/G is obtained.

Now that we have the measuring circuit, we need to power it. In order to supply 5V and ground, the GPIO ports are used for this task, more precisely port 4 for 5V and port 6 for ground.

The last step for the hardware is to connect the sensor output to one of the MCC 118 channels, channel 0 for this project. The output is between 0 and 5V and the value of 2.5V represents the threshold between the positive and negative output values of the circuit. Further, in the project, the program flow part mentions how you can modify the code to be able to connect several sensors at once.

After completing these steps, your circuit should look similar to the one in the image below.

Program flow

After mounting the components and installation of libraries, the two files attached below must be saved in the same folder. "daqhats_utils.py" is taken from the examples folder, it is in the "daqhats" folder which is installed after performing the steps for installing the libraries using git. “scan.py" is the main file for this project.

Library imports

from __future__ import print_function
from sys import stdout
from time import sleep #allows to introduce a delay in the execution of your program
from daqhats import mcc118, OptionFlags, HatIDs, HatError #import labrary mcc118 to use all the methods for MCC118
from daqhats_utils import select_hat_device, enum_mask_to_string, 
    chan_list_to_mask

To perform the measurement we need some functions offered in the libraries in the git repository and daqhats_utils. We import the entire mcc118 class and some help functions. "OptionFlags" is used to set the mode for scanning the values provided by the channels on the raspberry hat and to identify the id and errors we use the "HatIDs" and "HatError" functions.

Constant declaration and print information

 gain_constant = 52.1376 #determined by the above formula
 v_ref = 2.3
 scan_rate = 2000.0

To determine the value of the magnetic field intensity we use the two constants, gain_constant, and v_ref. "gain_constant" is determined by the above formula, this constant needs to be changed to respect the voltage gain of the circuit. This constant is equal to the inverse of the calculated gain (1/gain). "v_ref" is the voltage reference for the zero point, all the values above it is positive numbers, all the values under it are negative numbers. These two are used in the print function at the end of the program.

print('{:10.5f}'.format((read_result.data[index+i]-v_ref)*gain_constant), 'Gaus', end='')
#print('{:10.5f}'.format(read_result.data[index+i]), 'V', end='') #Use to measured the threshold

The program will show in the terminal a number consisting of a maximum of ten digits and five digits after the comma. To calibrate the out, uncomment the next line and change the value of "v_ref" with the value measured.

The per-channel rate of the internal scan clock is set in the variable "scan_rate" and the expected maximum rate of an external scan clock, max 100 000.

Channels declaration

  channels = [0] #if you want to use other channel replace "0" with the channel you want
  #or to add more channels add to array like in this example channels = [0, 1, 2, 3, 4, 5, 6, 7]
 channel_mask = chan_list_to_mask(channels)
 num_channels = len(channels)

The channels used must be declared in a vector. To add more channels, modify the vector by adding the channels you want to use. For example:

channels = [0, 1, 2, 3, 4, 5, 6, 7]

uses all the eight channels to measure. All the functions in MCC 118 class use vectors to determine the channels in use and for this, it is needed to know the length of the vector.

Read and display data

total_samples_read = 0
 
read_request_size = READ_ALL_AVAILABLE
 
timeout = 5.0
 
while True:
 
    read_result = hat.a_in_scan_read(read_request_size, timeout)
 
    # Check for an overrun error
    if read_result.hardware_overrun:
        print('nnHardware overrunn')
        break
    elif read_result.buffer_overrun:
        print('nnBuffer overrunn')
        break
 
    samples_read_per_channel = int(len(read_result.data) / num_channels)
    total_samples_read += samples_read_per_channel
 
    # Display the last sample for each channel,in a maximum number of 12 digits.
    print('r{:12}'.format(samples_read_per_channel),
          ' {:12} '.format(total_samples_read), end='')
            #r is use to write over the existing line
 
    if samples_read_per_channel > 0:
        index = samples_read_per_channel * num_channels - num_channels
        for i in range(num_channels):
            #Display the value number of 10 digits and 5 digits after the comma
            print('{:10.5f}'.format((read_result.data[index+i]-v_ref)*gain_constant), 'Gaus', end='')
            #print('{:10.5f}'.format(read_result.data[index+i]), 'V', end='') #Use to measured the threshold
        stdout.flush()
 
        sleep(0.1)
 
print('n')

The readings are executed in a loop that continues until the user stops the scan or an overrun error is detected. All the available samples are read (up to the size of the read_buffer). Since the read_request_size is set to -1 (READ_ALL_AVAILABLE), the function “hat.a_in_scan_read” returns immediately with samples are available at the moment and the timeout parameter is ignored. The function “hat.a_in_scan_read” returns multiple elements: running, hardware overrun, buffer overrun, triggered, and timeout with all is a bool type and data that is a list o float. The data return is the one we will use next to display the information read from the buffer.

    samples_read_per_channel = int(len(read_result.data) / num_channels)
    total_samples_read += samples_read_per_channel

“samples_read_per_channel” is used to show the number in the data list at which the purchase was made and displayed. “total_samples_read” stores the total number of samples. These numbers are displayed in 12-digit format.

If there are samples in the buffer, then the program will start displaying. For each channel its result is saved to a certain value in the list, the position for each value is a multiple of the number of channels used. To display we use an index that saves for each reading the position of each sample on each channel.

    if samples_read_per_channel > 0:
        index = samples_read_per_channel * num_channels - num_channels
        for i in range(num_channels):
            #Display the value number of 10 digits and 5 digits after the comma
            print('{:10.5f}'.format((read_result.data[index+i]-v_ref)*gain_constant), 'Gaus', end='')
            #print('{:10.5f}'.format(read_result.data[index+i]), 'V', end='') #Use to measured the threshold

Launch the script

To launch the python script, open a terminal in the folder where you saved the 2 files with the command below.

python scan.py

After that, in the terminal will appear the address at which MCC 118 is located, the way in which the hat works, the channels in use and the scan rate at which it works is set to work. After pressing the ENTER key, the program will start to scan.

The interpretation of the display is as follows:
Samples Read is the number of samples displayed and resets back to 0 after the buffer fills.
Scan Count is the total numbers of the samples read, it does not reset when the buffer is full and continues to count.
Channel 0 is the value read by that channel, after this the following channels added later will appear.

Code

scan

#!/usr/bin/env python
#  -*- coding: utf-8 -*-

"""
    Purpose:
        Perform a continuous acquisition on channel 0.

    Description:
        Continuously acquires blocks of analog input data from a
        helping circuit to measure the magnetic field.
"""
from __future__ import print_function
from sys import stdout
from time import sleep #allows to introduce a delay in the execution of your program
from daqhats import mcc118, OptionFlags, HatIDs, HatError #import labrary mcc118 to use all the methods for MCC118
from daqhats_utils import select_hat_device, enum_mask_to_string, \
    chan_list_to_mask

#Specify a negative number to return all available samples immediately and ignore timeout or 0 to only read the scan status and return no data.
READ_ALL_AVAILABLE = -1

""""
    ANSI terminal control sequence, use to control terminal 
    x1b = ESCAPE in ASCII, with the combination of other caracters we obtain:
    x1b[0K is CLEAR
    x1b[2D is move left 2 space
"""
CURSOR_BACK_2 = '\x1b[2D'
ERASE_TO_END_OF_LINE = '\x1b[0K'

gain_constant = 52.1376 #determined by the formula from documentation

"""
    To measure the intensity of the magnetic field the circuit outputs a voltage between 0V and the power supply given
    by the 5v port on the raspbbery pi. The code used the variable v_ref to set the threshold of 0 Gauas.
    This threshold  can be measured and change in the variable below, for this uncomment the line 160, comment the
    line 159 and change the value of v_ref with the value measured.
"""
v_ref = 2.3


def main():
    
    channels = [0] #if you want to use other channel replace "0" with the channel you want
    #or to add more channels add to array like in this example channels = [0, 1, 2, 3, 4, 5, 6, 7]
    channel_mask = chan_list_to_mask(channels)
    num_channels = len(channels)

    samples_per_channel = 0

    options = OptionFlags.CONTINUOUS

    scan_rate = 2000.0

    try:
        # Select an MCC 118 HAT device to use.
        address = select_hat_device(HatIDs.MCC_118)
        hat = mcc118(address)

        print('\nSelected MCC 118 HAT device at address', address)

        actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate)
        calibration_date = hat.calibration_date()
        
        print('\nMCC 118 continuous scan')
        print('    Channels: ', end='')
        print(', '.join([str(chan) for chan in channels]))
        print('    Requested scan rate: ', scan_rate)
        print('    Actual scan rate: ', actual_scan_rate)

        try:
            input('\nPress ENTER to continue ...')
        except (NameError, SyntaxError):
            pass

        hat.a_in_scan_start(channel_mask, samples_per_channel, scan_rate, options)
        
        count_scan=hat.a_in_scan_channel_count()
        print('Starting scan ...\nPress Ctrl-C to stop\n')
       
        # Display the header row for the data table.
        print('Samples Read    Scan Count', end='')
        for chan, item in enumerate(channels):
            print('    Channel ', item, sep='', end='')
        print('')

        try:
            read_and_display_data(hat, num_channels)

        except KeyboardInterrupt:
            # Clear the '^C' from the display.
            print(CURSOR_BACK_2, ERASE_TO_END_OF_LINE, '\n')
            print('\nStopping')
            hat.a_in_scan_stop()
            hat.a_in_scan_cleanup()

    except (HatError, ValueError) as err:
        print('\n', err)


def read_and_display_data(hat, num_channels):
    """
    Reads data from the specified channels on the specified DAQ HAT devices
    and updates the data on the terminal display.  The reads are executed in a
    loop that continues until the user stops the scan or an overrun error is
    detected.
    """
    total_samples_read = 0

    """
    Read all of the available samples (up to the size of the read_buffer which
    is specified by the user_buffer_size).  Since the read_request_size is set
    to -1 (READ_ALL_AVAILABLE), this function returns immediately with
    samples are available (up to user_buffer_size) and the timeout
    parameter is ignored.
    """

    read_request_size = READ_ALL_AVAILABLE

    """
    When doing a continuous scan, the timeout value will be ignored in the
    call to a_in_scan_read because we will be requesting that all available
    samples (up to the default buffer size) be returned.
    """
    timeout = 5.0

    while True:
        """
        The analog input scan is started with a_in_scan_start() and runs in the background. 
        This function reads the status of that background scan and optionally reads sampled data from the scan buffer.
        This fuction will return a data list of float.
        """
        read_result = hat.a_in_scan_read(read_request_size, timeout)

        # Check for an overrun error
        if read_result.hardware_overrun:
            print('\n\nHardware overrun\n')
            break
        elif read_result.buffer_overrun:
            print('\n\nBuffer overrun\n')
            break

        samples_read_per_channel = int(len(read_result.data) / num_channels)
        total_samples_read += samples_read_per_channel

        # Display the last sample for each channel,in a maximum number of 12 digits.
        print('\r{:12}'.format(samples_read_per_channel),
              ' {:12} '.format(total_samples_read), end='')
                #\r is use to write over the existing line
        """
        The samples read per channel is greater than 0, the index whil be updated with the new possition dependig of
        the number of samples readed and the number of channels. Then the number store in the buffer of the hat will 
        appear on the screen. 
        """
        if samples_read_per_channel > 0:
            index = samples_read_per_channel * num_channels - num_channels
            for i in range(num_channels):
                #Display the value number of 10 digits and 5 digits after the comma
                print('{:10.5f}'.format((read_result.data[index+i]-v_ref)*gain_constant), 'Gaus', end='')
                #print('{:10.5f}'.format(read_result.data[index+i]), 'V', end='') #Use to measured the threshold
            stdout.flush()

            sleep(0.1)

    print('\n')

if __name__ == '__main__':
    main()

daqhats_utils

"""
    This file contains helper functions for the MCC DAQ HAT Python examples.
"""
from __future__ import print_function
from daqhats import hat_list, HatError


def select_hat_device(filter_by_id):
    # type: (HatIDs) -> int
    """
    This function performs a query of available DAQ HAT devices and determines
    the address of a single DAQ HAT device to be used in an example.  If a
    single HAT device is present, the address for that device is automatically
    selected, otherwise the user is prompted to select an address from a list
    of displayed devices.

    Args:
        filter_by_id (int): If this is :py:const:`HatIDs.ANY` return all DAQ
            HATs found.  Otherwise, return only DAQ HATs with ID matching this
            value.

    Returns:
        int: The address of the selected device.

    Raises:
        Exception: No HAT devices are found or an invalid address was selected.

    """
    selected_hat_address = None

    # Get descriptors for all of the available HAT devices.
    hats = hat_list(filter_by_id=filter_by_id)
    number_of_hats = len(hats)

    # Verify at least one HAT device is detected.
    if number_of_hats < 1:
        raise HatError(0, 'Error: No HAT devices found')
    elif number_of_hats == 1:
        selected_hat_address = hats[0].address
    else:
        # Display available HAT devices for selection.
        for hat in hats:
            print('Address ', hat.address, ': ', hat.product_name, sep='')
        print('')

        address = int(input('Select the address of the HAT device to use: '))

        # Verify the selected address if valid.
        for hat in hats:
            if address == hat.address:
                selected_hat_address = address
                break

    if selected_hat_address is None:
        raise ValueError('Error: Invalid HAT selection')

    return selected_hat_address


def enum_mask_to_string(enum_type, bit_mask):
    # type: (Enum, int) -> str
    """
    This function converts a mask of values defined by an IntEnum class to a
    comma separated string of names corresponding to the IntEnum names of the
    values included in a bit mask.

    Args:
        enum_type (Enum): The IntEnum class from which the mask was created.
        bit_mask (int): A bit mask of values defined by the enum_type class.

    Returns:
        str: A comma separated string of names corresponding to the IntEnum
        names of the values included in the mask

    """
    item_names = []
    if bit_mask == 0:
        item_names.append('DEFAULT')
    for item in enum_type:
        if item & bit_mask:
            item_names.append(item.name)
    return ', '.join(item_names)


def chan_list_to_mask(chan_list):
    # type: (list[int]) -> int
    """
    This function returns an integer representing a channel mask to be used
    with the MCC daqhats library with all bit positions defined in the
    provided list of channels to a logic 1 and all other bit positions set
    to a logic 0.

    Args:
        chan_list (int): A list of channel numbers.

    Returns:
        int: A channel mask of all channels defined in chan_list.

    """
    chan_mask = 0

    for chan in chan_list:
        chan_mask |= 0x01 << chan

    return chan_mask


def validate_channels(channel_set, number_of_channels):
    # type: (set, int) -> None
    """
    Raises a ValueError exception if a channel number in the set of
    channels is not in the range of available channels.

    Args:
        channel_set (set): A set of channel numbers.
        number_of_channels (int): The number of available channels.

    Returns:
        None

    Raises:
        ValueError: If there is an invalid channel specified.

    """
    valid_chans = range(number_of_channels)
    if not channel_set.issubset(valid_chans):
        raise ValueError('Error: Invalid channel selected - must be '
                         '{} - {}'.format(min(valid_chans), max(valid_chans)))

Credits

Digilent Inc

Digilent Inc., a National Instruments company, is a leader in the design, manufacture and worldwide distribution of FPGA development boards and Test and Measurement devices for both industry and education. Since our founding in 2000, Digilent has partnered with different leading semiconductor companies including Xilinx, Microchip, Analog Devices, ISSI and Texas Instruments to bring products with the latest embedded & electronics technology. Our expert team of engineers, combined with our manufacturing services and worldwide distribution has made us an ideal partner for several leading technology providers. We want to enable our partners to be successful through well designed, high quality and well manufactured hardware.

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast