Expanding HUMS: Integrating Multi-Sensor Monitoring

Introduction

A few months ago, we created a simple Health and Usage Monitoring System (HUMS) based around the AMD MicroBlaze™ V processor. This previous project focused on using accelerometers in all three directions, and logging those using Python remotely. One nice thing about this previous project is that we created a Command Line Interpreter (CLI) that makes the solutions scalable.

We are going to expand on this base project to monitor a much wider range of sensors. We will be using the following sensors:

• Pmod NAV - Provides acceleration in X, Y, Z
• Pmod Hygro - Provides humidity
• Pmod RTCC - Real Time Clock provides reference time stamp
• Pmod TC - Uses a platinum resistance thermometer to measure temperature
• Pmod ALS - Monitors the ambient light level
• XADC - Measures temperature using a negative temperature coefficient thermistor

To create the conversion from the XADC value to temperature, we are going to use the Simulink to create an IP block which performs the conversion.

NTC Thermistor Algorithm

To get started with updating the design, first we are going to create an IP block which converts between the XADC values received from the NTC, the resistor network, and the actual temperature.

The equation we need to implement is:

However, we do not know the value of Rntc from our XADC circuit. Instead, we have an ADC value, from which we need to convert to a resistance using the equation below:

As we need to implement some complex math, we have two options the first is to approximate it using a polynomial approximation. However, I wanted to get the best accuracy so this will be implemented directly using Simulink and HDL Coder to generate IP core.

The output from the XADC will be a 12 bit value, as we will be using he XADC in a unipolar mode. The input voltage will be between 0 and 1V from the analogue front end network.

The Simulink design, will split the implementation into two elements the first to calculate the Rntc. As the input will be provided from the XADC using an AXI stream, there the input to the block will be a 16 bit vector and a valid signal. These can be mapped to tWe have two options to implement this complex math. The first is to approximate it using a polynomial approximation. However, I want to get the best accuracy, so instead I will directly implement this using Simulink and HDL Coder to generate the IP core.

The output from the XADC will be a 12-bit value, as we will be using the XADC in a unipolar mode. The input voltage will be between 0V and 1V from the analog front-end network.

The Simulink design will split the implementation into two elements. The first element will be used to calculate the Rntc. As the input will be provided from the XADC using an AXI stream, the input to the block will be a 16-bit vector and a valid signal. These can be mapped to the AXI Stream’s tData and tValid signals in the AMD Vivado™ Design Suite design.he AXI Stream tData and tValid signals in the AMD Vivado™ Design Suite design.

We will be using fixed point mathematics for most of this implementation. If you are not familiar with fixed point math and how it works, take a look at these resources (blog, webinar).

Internal to the Rntc block, I implemented the following approach. This block contains two real divider blocks which implement the first conversion from the ADC value to the thermistor resistance. The first divider performs the division of the ADC resolution, (in this case 4096) by the measured ADC Value.

After the first division, the result has one subtracted from it before being used in the second divider. The result of this division gives the resistance value of the thermistor.

At this point, we could take the Rntc output and use the MicroBlaze V processor to calculate the actual temperature. However, I want the IP block to be able to be implemented in devices which do not use a processor. As such, the second element of the temperature calculation is implemented as shown.

In this solution, we have to convert between fixed-point, floating-point, and back to fixed-point again to be able to use the natural logarithm feature.

The first thing we do is register the input, and then perform the calculation of the 1/Rnom. To do this, I use a multiplier and the reciprocal of the thermistors nominal resistance. Next up is to convert from fixed point to floating point and implement the logarithm, ln(Rntc/Rnom). The result of this is then multiplied by the reciprocal of the Beta (3950) and the reciprocal of T0 (298 Kelvin). The final step is to take the reciprocal of the result and then convert back to a fixed-point number.

To test this, I set several of the nets to be logged by the internal logic analyzer in Simulink and ran the simulation with a range of input values to determine the output.

This shows the results one would expect. (E.g. for an input of 2048 from the ADC, we should see a room temperature output of 298 Kelvin).

The next step is to configure the code generation. I wanted the design to be able to connect to the XADC AXI stream output. I also wanted the result to be available in an AXI Memory map so that I could read the calculated easily.

Using the workflow advisor, I configured the target device and tools chain settings.

I also used the workflow controller to define the interfaces I wanted.

With this, we have an RTL IP core we are able to add into our AMD Vivado™ Design Suite project.

AMD Vivado™ Design Suite

With the NTC Thermistor IP core created, we need to add the IP core into AMD Vivado Design Suite project. As I said in the introduction, we are going to be adding functionality to the existing HUMS project which is available here.

To do this, open the IP Library view in AMD Vivado Design Suite and right click “Add IP to Repository”.

Select the IP core compressed zip file.

This will add the IP to the IP library.

We are now in a position where we can add in the IPs to the IP Integrator block diagram.

Add in the following:

• PmodTC
• Pmod Hygro
• Pmod RTCC
• Pmod ALS
• XADC
• Steinhart - Hart IP
• AXI Stream Subset Convertor - Strips the lower 12 bits from the XADC output

We already have the PmodNav within the design from its previous configuration.

Configure the XADC as shown below: No Interface, AXI Stream Enabled, and Continuous Sampling.

Set the channel averaging for 256.

Disable the alarms.

Set the Single channel to the VP/VN input.

Connect the XADC to the Stein Hart Block via the AXI Stream Subset convertor.

Make the XADC Vp/Vn external and let the connection automation run to connect the Stein Hart IP block to the processor AXI network.

Set the AXI Subset Convertor as shown below and strip out the lower 12 bits. The XADC gives a 16-bit output, with the upper 12 bits being the conversion.

We can make this mapping the in the AXI Subset convertor.

Add in the additional Pmods, connect the Hygro to Pmod A, RTCC to Pmod C, and the Pmod TC to Pmod D. The Pmod ALS we will connect to the shield connector using flying leads.

Let the block automation control the connection to the AXI network.

Our updated block diagram should look as below.

The AMD Vivado Design Suite is board aware, so its configuration knows the pin outs for the additional Pmods and XADC (with the exception of the Pmod ALS that is allocated as below within the XDC file).

set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin1_io]
set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin2_io]
set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin3_io]
set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin4_io]
set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin7_io]
set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin8_io]
set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin9_io]
set_property IOSTANDARD LVCMOS33 [get_ports Pmod_ALS_pin10_io]
set_property PACKAGE_PIN L13 [get_ports Pmod_ALS_pin1_io]
set_property PACKAGE_PIN N13 [get_ports Pmod_ALS_pin2_io]
set_property PACKAGE_PIN L16 [get_ports Pmod_ALS_pin3_io]
set_property PACKAGE_PIN R14 [get_ports Pmod_ALS_pin4_io]
set_property PACKAGE_PIN T14 [get_ports Pmod_ALS_pin7_io]
set_property PACKAGE_PIN R16 [get_ports Pmod_ALS_pin8_io]
set_property PACKAGE_PIN R17 [get_ports Pmod_ALS_pin9_io]
set_property PACKAGE_PIN V17 [get_ports Pmod_ALS_pin10_io]

The resource utilisation of the implemented design is.

With that, we are ready to build the bitstream, and generate the XSA an update our software application.

AMD Vitis™ Unified Software

The architecture of the software was designed to be modular in the baseline project.

At the heart of the project is a simple command line interpreter which parses commands received over the serial interface, and takes the appropriate action.

All of the CLI and software configuration files are available on the linked GitHub.

Each of the functions implemented is contained within its own folder and provides a header file with a list of the functions provided. I split the application for a Pmod (e.g. reading the temperature from the Pmod driver). Also, as several Pmods use the same IO drivers (e.g. SPI or I2C), I also created folders containing the driver files.

This requires the Pmod drivers to be modified slightly to enable multiple Pmods using the same AMD driver IP.

Under each app are several functions that will initialise the peripheral, and interact Under each app, are several functions that will initialize the peripheral, and interact with it to obtain the appropriate sensor reading.

The CLI is responsible for interacting with the applications. It parses commands received over the serial link, calls the correct function, and returns the sensor reading.

To demonstrate this concept, the CLI processing code can be seen below:

void cli_parse_command()
{
// /static u32 block = 0;
static u32 val = 0;
u8 light = 0;
RTCC_Time time;
float temp_degc, hum_perrh, temp_degf;
mesg_ready = read_serial(receive_buffer);
if (mesg_ready == 1)
{
//xil_printf("cmd> %s\n\r", receive_buffer);
if (strcmp(receive_buffer, "") == 0)
{
val = 0; // NOP
}
else if (strcmp(receive_buffer, "read_accel_x") == 0)
{
//xil_printf("read_accel_x\n\r");
NAV_GetData(&nav);
xil_printf_float(nav.acclData.X);
}
else if (strcmp(receive_buffer, "read_accel_y") == 0)
{
//xil_printf("read_accel_y\n\r");
NAV_GetData(&nav);
xil_printf_float(nav.acclData.Y);
}
else if (strcmp(receive_buffer, "read_accel_z") == 0)
{
//xil_printf("read_accel_z\n\r");
NAV_GetData(&nav);
xil_printf_float(nav.acclData.Z);
}
else if (strcmp(receive_buffer, "get_humidity") == 0)
{
hum_perrh = HYGRO_getHumidity(&HygroDevice);
xil_printf_float(hum_perrh);
}
else if (strcmp(receive_buffer, "get_temp") == 0)
{
TCGetTemp();
}
else if (strcmp(receive_buffer, "get_als") == 0)
{
light = ALS_read(&ALS);
xil_printf("Light = %d\n\r", light);
}
else if (strcmp(receive_buffer, "get_xadc") == 0)
{
get_xadc();
}
else if (strcmp(receive_buffer, "get_time") == 0)
{
GetTime( RTCC_TARGET_RTCC);
}
else
{
char *ptr = strtok(receive_buffer, command_delim);
if (strcmp(ptr, "set_time") == 0)
{
ptr = strtok(NULL, command_delim);
time.day    = char_to_int(strlen(ptr), ptr);
ptr = strtok(NULL, command_delim);
time.date   = char_to_int(strlen(ptr), ptr);
ptr = strtok(NULL, command_delim);
time.month  = char_to_int(strlen(ptr), ptr);
ptr = strtok(NULL, command_delim);
time.year   = char_to_int(strlen(ptr), ptr);
ptr = strtok(NULL, command_delim);
time.hour   = char_to_int(strlen(ptr), ptr);
ptr = strtok(NULL, command_delim);
time.minute = char_to_int(strlen(ptr), ptr);
ptr = strtok(NULL, command_delim);
time.second  = char_to_int(strlen(ptr), ptr);
SetTime(RTCC_TARGET_RTCC,  time);
}
else if (strcmp(ptr, "r") == 0)
{
ptr = strtok(NULL, command_delim);
u32 addr = char_to_int(strlen(ptr), ptr);
val = Xil_In32( XPAR_XGPIO_0_BASEADDR + addr);
xil_printf("Addr: 0x%x (%d)  Val: 0x%x (%d)\r\n",addr,addr, val, val);
}
else if (strcmp(ptr, "w") == 0)
{
ptr = strtok(NULL, command_delim);
u32 addr = char_to_int(strlen(ptr), ptr);
ptr = strtok(NULL, command_delim);
val = char_to_int(strlen(ptr), ptr);
Xil_Out32(XPAR_XGPIO_0_BASEADDR + addr,val);
val = Xil_In32( XPAR_XGPIO_0_BASEADDR + addr);
xil_printf("Addr: 0x%x (%d)  Val: 0x%x (%d)\r\n",addr,addr, val, val);
}
else
{
xil_printf("Command not found.\n\r");
}
}
}

Host Application

To be able to log this information on the host, we need to update our Python application. We can select which sensor data we want by making the appropriate call over the serial port.

The updated Python can be found below:

import serial
import time
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# Function to initialize the serial connection
def initialize_serial(serial_port, baud_rate):
    try:
        ser = serial.Serial(serial_port, baud_rate, timeout=1)
        time.sleep(2)  # Wait for the serial connection to initialize
        return ser
    except serial.SerialException as e:
        print(f"Serial error: {e}")
        return None

# Function to send a command and receive the response
def send_command(ser, command):
    try:
        ser.write(command.encode('utf-8'))
        time.sleep(0.5)
        response = ser.readline().decode('utf-8').strip()
        response = response.replace(' ', '')  # Remove any spaces
        try:
            # Convert response to a float if possible
            return float(response)
        except ValueError:
            print(f"Non-numeric response received: {response}")
            return None
    except Exception as e:
        print(f"Error during send/receive: {e}")
        return None

# Function to update the plot
def update_plot(frame, ser, commands, x_data, y_data, lines, start_time, axes):
    for i, command in enumerate(commands):
        response = send_command(ser, command)
        if command == 'get_xadc\r' and response is not None:
            response -= 273
        if response is not None:
            print(f"Received for {command}: {response}")  # Print the received value for debugging
            x_data[i].append(time.time() - start_time)
            y_data[i].append(response)
            lines[i].set_data(x_data[i], y_data[i])
    for ax in axes:
        ax.relim()
        ax.autoscale_view()
    return lines

# Main function
def main(serial_port, baud_rate, commands, labels):
    ser = initialize_serial(serial_port, baud_rate)
    if ser is None:
        return

    # Initialize plot data for multiple series
    x_data = [[] for _ in commands]
    y_data = [[] for _ in commands]
    start_time = time.time()

    # Create subplots for different sensor groups
    global fig, axes  # Ensure these remain in scope
    fig, axes = plt.subplots(3, 1, figsize=(10, 15))

    # Acceleration plot (Accel X, Y, Z)
    accel_indices = [0, 1, 2]
    accel_lines = [axes[0].plot([], [], label=labels[i])[0] for i in accel_indices]
    axes[0].set_title('Acceleration Data')
    axes[0].set_xlabel('Time (s)')
    axes[0].set_ylabel('Acceleration (g)')
    axes[0].legend()

    # Temperature and Humidity plot (Humidity, Thermocouple Temp, XADC Temp)
    temp_humid_indices = [3, 4, 5]
    temp_humid_lines = [axes[1].plot([], [], label=labels[i])[0] for i in temp_humid_indices]
    axes[1].set_title('Temperature and Humidity Data')
    axes[1].set_xlabel('Time (s)')
    axes[1].set_ylabel('Temperature (°C)')
    ax2 = axes[1].twinx()  # Create a second y-axis for humidity
    ax2.set_ylabel('Humidity (%)')
    axes[1].legend()

    # Ambient Light plot (Ambient Light)
    light_indices = [6]
    light_lines = [axes[2].plot([], [], label=labels[i])[0] for i in light_indices]
    axes[2].set_title('Ambient Light Data')
    axes[2].set_xlabel('Time (s)')
    axes[2].set_ylabel('Light Intensity')
    axes[2].legend()

    # Combine all lines for updating
    lines = accel_lines + temp_humid_lines + light_lines

    # Set up plot to call update_plot function periodically
    global ani  # Ensure the animation object remains in scope
    ani = FuncAnimation(fig, update_plot, fargs=(ser, commands, x_data, y_data, lines, start_time, axes), interval=1000, blit=False, cache_frame_data=False)

    # Display the plot
    plt.tight_layout()
    plt.show()

    # Close the serial connection when the plot is closed
    ser.close()

if __name__ == "__main__":
    serial_port = 'COM59'  # Replace with your serial port
    baud_rate = 9600       # Replace with your baud rate
    commands = [
        'read_accel_x\r',
        'read_accel_y\r',
        'read_accel_z\r',
        'get_humidity\r',
        'get_temp\r',
        'get_xadc\r',
        'get_als\r'
    ]  # Commands to get data from the sensors
    labels = [
        'Accel X',
        'Accel Y',
        'Accel Z',
        'Humidity',
        'Thermocouple Temp',
        'XADC Temp',
        'Ambient Light'
    ]  # Labels for each data series
    try:
        main(serial_port, baud_rate, commands, labels)
    except KeyboardInterrupt:
        print("Interrupted!")

Wrap Up

This project has been fun it has demonstrated how we can add additional sensor modalities to the existing design which greatly expand its capabilities.This fun project has demonstrated how we can add additional sensor modalities to the existing design to greatly expand its capabilities.

The files to recreate the project are available here.

AMD sponsored this project. AMD, and the AMD Arrow logo, MicroBlaze, Vitis, Vivado, Zynq, and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective companies.