AMD MicroBlaze™ V Processor Health and Usage Monitoring

Introduction

Being able to monitor the stresses and strains equipment experiences in operation can be vital for determining its lifespan and ensuring it does not see anything outside the ordinary. For this reason, many systems include a health and monitoring units (HUMS). The function of the HUMS is to monitor and log the stresses to which equipment is exposed. The equipment could be anything from an aircraft subsystem, to power generation, and beyond.

In this project, we are going to create a simple HUMS system using the AMD Spartan™ 7 FPGA, which falls within the cost optimized portfolio. One great use for the data from the HUMS system is to create data sets to enable failure and anomaly detection. This can then be used with machine learning inferences to examine the data in real time and indicate any issues outside the ordinary.

My ultimate goal is to combine this project with the Spartan 7 FPGA stamp design which is shown here, showcasing how we can leverage small FPGAs for industrial applications.

AMD Vivado™ Design Suite

To get started, we are going to create a new project targeting the Digilent Arty S7-50 board.

One of the targets of this design is to leverage internal BRAM for the MicroBlaze processor application such that it can be implemented without the need for external memory. This will also demonstrate the code compression capabilities of the MicroBlaze V processor.

Once the project is created, we can create a new block diagram.

Add in a MicroBlaze V from the IP Catalog:

From the board tab drag over the AXI GPIO for the LED control:

Run the block automation. For this application, I set the local memory ECC as it is something I would like to explore more.

This will create the system as shown below:

Add in the USB UART from the Board Tab:

Run the connection automation:

Clone the Digilent Vivado Library, and add it into the AMD Vivado Design Suite IP library:

Several IPs will be found, including the AMD Vivado Design Suite drivers for the Pmods we want to use:

All of the Pmod HW drivers should be visible under the IP catalog:

Add in the Pmod Nav and Pmod Hygro:

Once both are added the next step is to run the connection automation to connect the nets:

From the board tab we can then drag and drop across the connectors Pmod NAV will be on JB while the HYGRO will be on JA:

The next stage is to connect up the interrupts:

While the final stage is to configure the clock wizard, set the frequency to 12 MHz:

The output frequency to 100 MHz and remove the reset input:

Make the clock in pin external:

Connect the external SPI clock to the AXI Clock on the Pmod Nav IP:

Connect the locked pin to the external reset in on the main processor system reset:

Validate the design and create a new XDC file:

Add in the constraints below:

set_property PACKAGE_PIN F14 [get_ports clk_in1_0]
set_property IOSTANDARD LVCMOS33 [get_ports clk_in1_0]
set_property PACKAGE_PIN L17 [get_ports ja_pin1_io]
set_property PACKAGE_PIN L18 [get_ports ja_pin2_io]
set_property PACKAGE_PIN M16 [get_ports ja_pin7_io]
set_property PACKAGE_PIN M17 [get_ports ja_pin8_io]
set_property PACKAGE_PIN M18 [get_ports ja_pin9_io]
set_property PACKAGE_PIN N18 [get_ports ja_pin10_io]
set_property IOSTANDARD LVCMOS33 [get_ports ja_pin1_io]
set_property IOSTANDARD LVCMOS33 [get_ports ja_pin2_io]
set_property IOSTANDARD LVCMOS33 [get_ports ja_pin7_io]
set_property IOSTANDARD LVCMOS33 [get_ports ja_pin8_io]
set_property IOSTANDARD LVCMOS33 [get_ports ja_pin9_io]
set_property IOSTANDARD LVCMOS33 [get_ports ja_pin10_io]

Create a wrapper, and let the AMD Vivado Design Suite manage it:

Build and export the XSA for use in AMD Vitis™ Unified Software Platform:

Development with AMD Vitis Unified Software Suite

The next software application we are going to develop is going to be a little more advanced than previous applications we have created.

This is because I want to be able to scale the application simply and easily as we add capabilities or port it to different devices (including the stamp).

The first thing we are going to do is create the CLI application. This will read a command over the serial port and parse though the command to perform an action. Along with running tests, this will also be able to provide peek and poke into the AXI network.

To ensure reusability, I am going to create the CLI in its own “c” and header files. The basics of the CLI are that it will:

• Receive a command over the serial port - echoing it back as typed.
• When it sees a CR character this will be parsed to determine the command.
• If the command is “w” or “r” it is expected, an AXI Write or Read is required and will be followed by an address and data (for write.) E.g. “R 0” will read the based AXI register at address 0 plus the offset of the AXI Base address in hardware.
• The CLI will store the memory of the last issued command. Use the UP Arrow to present the previous command.
• The CLI will separate tokens in the command using the " " delimiter.

The CLI Code can be seen below (the correctly formatted source is attached to the project.)

XUartLite Uart;
char receive_buffer[CLI_BUFFER_SIZE];    /* Buffer for Receiving Data */
char receive_buffer_lst[CLI_BUFFER_SIZE];    /* Buffer for Receiving Data */
int mesg_ready;
int test_id = 0;
int test_stop = 0;
int test_oneshot = 0;
char command_delim[] = " ";
int init_uart0()
{
    int Status;
    Status = XUartLite_Initialize(&Uart, XPAR_XUARTLITE_0_BASEADDR);
    if (Status != XST_SUCCESS) {
        return XST_FAILURE;
    }
    return XST_SUCCESS;
}

int read_serial(char *buffer)
{
static u8 read_val[3] = {0,0,0};
unsigned int received_count = 0;
static int fisrt = 1;
static int index = 0;
static int index_lst = 0;

received_count =    XUartLite_Recv(&Uart, &read_val[received_count], 1);
if (received_count > 0)
{
    if (read_val[0] == '\r'){
        buffer[index] = '\0';
        // Save the entered command for when we use Arrow up
        index_lst = index;
        strcpy(receive_buffer_lst,receive_buffer);
        index = 0;
        fisrt = 0;
        xil_printf("\n\r");
        return 1;
}
// Handles "arrow up" key press
if (read_val[2] == 27 && read_val[1] == 91 && read_val[0] == 65 && fisrt == 0){
// restore last entered command
    strcpy(receive_buffer,receive_buffer_lst);
    index = index_lst;
    xil_printf("\b%s",receive_buffer);
    return 0;
}
// Handles backspace
if (read_val[0] == 8)
{
    xil_printf("\b \b");
    if (index > 0)
    {
        index--;
    }
}
// Prevents buffer overflow
    if (index >= CLI_BUFFER_SIZE-1)
    {
        buffer[index] = '\0';
        index = 0;
        xil_printf("\n\r");
        return 1;
    }
// Prevents not printable characters from being added to the buffer
if (read_val[0] >= 32 && read_val[0] <= 126)
{
    buffer[index++] = read_val[0];
    xil_printf("%c", read_val[0]);
}
    read_val[2] = read_val[1];
    read_val[1] = read_val[0];
}
return 0;
}
void cli_parse_command()
{
// /static u32 block = 0;
static u32 val = 0;
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");
}
else if (strcmp(receive_buffer, "read_accel_y") == 0)
{
    xil_printf("read_accel_y\n\r");
}
else if (strcmp(receive_buffer, "read_accel_z") == 0)
{
    xil_printf("read_accel_z\n\r");
}
else
{
char *ptr = strtok(receive_buffer, command_delim);

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");
            }
        }
    }
}
int char_to_int(int len, char* buffer)
{
int value = 0, char_val, scalar = 1;
for (int i = len - 1; i >= 0; i--) {
    char_val = (int)(buffer[i] - '0');
    value = value + (char_val * scalar);
    scalar = scalar * 10;
}
return value;
}

When testing this on the Arty S7 board with the LEDs, we are able to turn them on and off using the CLI.

The CLI provides hooks in the code to enable it to be modified to support tests. These are shown in the string comparison is taking places against a string such as "read_accel_x" and just echo's back a print statement. This shows correct parsing of the results.

Using the CLI will enable a software script running externally or on another part of a distributed system to be able to control the exact behavior of the system.

As we are working on a small micro controller, using printf gives a large footprint size. However, we can also use Xil_printf for small footprint interaction with stdin stdout. Sadly, Xil_printf does not support outputting floating point numbers, therefore I wrote my own function which splits the number into an integer and fractional part and outputs them as a floating point.

int xil_printf_float(float x){
    int integer, fraction, abs_frac;
    integer = x;
    fraction = (x - integer) * 100;
    abs_frac = abs(fraction);
    xil_printf("%d.%3d\n\r", integer, abs_frac);
}

The complete application allows us to read the X, Y and Z values from the Pmod Nav.The host application is developed using Python and sends commands over the serial port and captures the resultant values to display in a logging element. To do this, we will be using animations and matplot lib.

Correctly formatted files are attached:

Host Application

The host application is developed using python and sends commands down over the serial port and captures the resultant values for displaying in a logging element. To do this we will be using animations and matplot lib.

Correctly formatted files are attached.

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
        #print(f"Received: {response}")  # Print the received value for debugging
        if response.isdigit():
            response = int(response)
        elif response.replace('.', '', 1).isdigit():
            response = float(response)
        return float(response)
    except Exception as e:
        print(f"Error during send/receive: {e}")
        return None

# Function to update the plot
def update_plot(frame, ser, command, x_data, y_data, line, start_time):
    response = send_command(ser, command)
    #print("sending")
    if response is not None:
        #print(f"Received: {response}")  # Print the received value for debugging
        x_data.append(time.time() - start_time)
        y_data.append(response)
        line.set_data(x_data, y_data)
        ax.relim()
        ax.autoscale_view()
        return line,

# Main function
def main(serial_port, baud_rate, command):
    ser = initialize_serial(serial_port, baud_rate)
    if ser is None:
        return
    # Initialize plot data
    x_data, y_data = [], []
    start_time = time.time()
    # Create plot
    global fig, ax # Ensure these remain in scope
    fig, ax = plt.subplots()
    line, = ax.plot([], [], 'r-')
    ax.set_title('Real-Time Serial Data')
    ax.set_xlabel('Time (s)')
    ax.set_ylabel('Received Value')
    # 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, command, x_data, y_data, line, start_time), interval=1000, blit=False, cache_frame_data=False)
    # Display the plot
    plt.show()
    # Close the serial connection when the plot is closed
    ser.close()

if __name__ == "__main__":
    serial_port = 'COM15' # Replace with your serial port
    baud_rate = 9600 # Replace with your baud rate
    command = 'read_accel_z\r' # Replace with the command you want to send
try:
    main(serial_port, baud_rate, command)
except KeyboardInterrupt:
    print("Interrupted!")

Logging one channel, in this case the Z Axis

It is a simple extension to make them log all three channels of the accelerometer:

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):
    for i, command in enumerate(commands):
        response = send_command(ser, command)
        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])
       ax.relim()
       ax.autoscale_view()
        return lines

# Main function
def main(serial_port, baud_rate, commands):
    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 plot
    global fig, ax # Ensure these remain in scope
    fig, ax = plt.subplots()
    lines = [ax.plot([], [], label=labels[i])[0] for i in range(len(commands))]
    ax.set_title('Real-Time Serial Data')
    ax.set_xlabel('Time (s)')
    ax.set_ylabel('Received Value')
    ax.legend()
    # 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), interval=1000, blit=False, cache_frame_data=False)
    # Display the plot
    plt.show()
    # Close the serial connection when the plot is closed
    ser.close()

if __name__ == "__main__":
    serial_port = 'COM15' # 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']  # Replace with the commands you want to send
    labels = ['Accel X', 'Accel Y', 'Accel Z']  # Labels for each data series
    try:
    main(serial_port, baud_rate, commands)
except KeyboardInterrupt:
    print("Interrupted!")

Logging all three channels:

Leaving the module to log for a little longer:

Wrap Up

This project has shown how we are able to create a simple AMD MicroBlaze V process application which monitors the health and usage levels of a remote system. The design can be evolved in the following ways:

• Read more parameters from the Pmod Nav and Hygro.
• Add in the capability to store to a QSPI Flash.

This is a pretty exciting project that showcases the capabilities of AMD MicroBlaze V processor for real world applications.