Intermediate
20 min

Measure the potential of hydrogen (pH) in various applications with EZO™ pH and PIC32MZ1024EFH064

Your go-to solution for liquid pH analysis!

EZO Carrier Click - pH with PIC32MZ clicker

Published Dec 25, 2023

Click board™

EZO Carrier Click - pH

Dev Board

PIC32MZ clicker

Compiler

NECTO Studio

MCU

PIC32MZ1024EFH064

Determine the acidity or alkalinity of a liquid within a spectrum ranging from strongly acidic to highly alkaline

A

A

Hardware Overview

How does it work?

EZO Carrier Click - pH is based on the EZO™ pH, a pH measurement interface circuit board from Atlas Scientific. It allows you to interface a pH measurement probe, which measures the potential of hydrogen, by sinking the probe into the solvent you want to measure the pH. The EZO Carrier Click - pH comes with the BNC connector for interfacing the appropriate probe, which MIKROE also offers. The EZO™ pH needs to be isolated from the host MCU; therefore, this Click™ board comes with the Si8400AB, a bidirectional isolator from Skyworks. The isolator provides a standard bidirectional and I2C communication with a clock frequency of up to 1.7MHz. The EZO™ pH circuit is a very sensitive

device, and the sensitivity is what gives the pH circuit its accuracy. It is capable of reading micro-voltages that are bleeding into the solvent. So, to eliminate the electrical noise, besides the Si8400AB isolator, the power supply voltage is also isolated. For this purpose, this Click™ board is equipped with the ROE-0505S, a DC/DC converter from Recom. The EZO™ pH has a flexible calibration protocol allowing for single-point, two-point, or three-point calibration. The temperature compensation should be taken into account. The EZO™ pH features sleep mode, continuous operation, find function, export/import calibration, on-module status LED, and more. EZO Carrier

Click - pH can use a standard 2-wire UART interface to communicate with the host MCU with the default baud rate of 9600bps. While using the UART interface, you can use the library we provide or a simple ASCII set of commands. You can also choose a standard 2-wire I2C interface over the COMM SEL jumpers. This Click board™ can operate with either 3.3V or 5V logic voltage levels selected via the VCC SEL jumper. This way, both 3.3V and 5V capable MCUs can use the communication lines properly. Also, this Click board™ comes equipped with a library containing easy-to-use functions and an example code that can be used for further development.

EZO Carrier Click - pH hardware overview image

Features overview

Development board

PIC32MZ Clicker is a compact starter development board that brings the flexibility of add-on Click boards™ to your favorite microcontroller, making it a perfect starter kit for implementing your ideas. It comes with an onboard 32-bit PIC32MZ microcontroller with FPU from Microchip, a USB connector, LED indicators, buttons, a mikroProg connector, and a header for interfacing with external electronics. Thanks to its compact design with clear and easy-recognizable silkscreen markings, it provides a fluid and immersive working experience, allowing access anywhere and under

any circumstances. Each part of the PIC32MZ Clicker development kit contains the components necessary for the most efficient operation of the same board. In addition to the possibility of choosing the PIC32MZ Clicker programming method, using USB HID mikroBootloader, or through an external mikroProg connector for PIC, dsPIC, or PIC32 programmer, the Clicker board also includes a clean and regulated power supply module for the development kit. The USB Micro-B connection can provide up to 500mA of current, which is more than enough to operate all onboard

and additional modules. All communication methods that mikroBUS™ itself supports are on this board, including the well-established mikroBUS™ socket, reset button, and several buttons and LED indicators. PIC32MZ Clicker is an integral part of the Mikroe ecosystem, allowing you to create a new application in minutes. Natively supported by Mikroe software tools, it covers many aspects of prototyping thanks to a considerable number of different Click boards™ (over a thousand boards), the number of which is growing every day.

PIC32MZ clicker double side image

Microcontroller Overview

MCU Card / MCU

default

Architecture

PIC32

MCU Memory (KB)

1024

Silicon Vendor

Microchip

Pin count

64

RAM (Bytes)

524288

You complete me!

Accessories

SMA Male to BNC Female Adapter is a high-performance connector designed for seamless interconnection between devices featuring SMA male and BNC female interfaces. With a 50Ohm impedance and a maximum frequency of 4GHz, this adapter ensures reliable signal integrity. Its gold-plated center contact minimizes signal loss, while the nickel-plated brass body enhances corrosion resistance. Versatile in application, this straight-style adapter is packaged in bulk, bearing the trusted Amphenol RF brand. Its phosphor bronze contact material adds to its durability. This adapter proves indispensable whether used in coax retrofit applications, coaxial extensions, or OEM coax setups requiring interface conversion. In a concise design, it simplifies the interconnection of devices with varying interface types, making it an essential tool for test labs and field environments. The adapter's robust construction and adaptability address interconnection challenges, offering a reliable solution for diverse scenarios where high-quality coaxial connections are crucial.

EZO Carrier Click - pH accessories 2 image

This probe can be used with all pH meters with an input for the BNC connection with a 1m cable. The sensitive part of the probe (in the shape of a ball) is partially protected by a probe's plastic body, which reduces the possibility of mechanical damage. The EPH101 is used to measure the pH value of various liquids (due to the present plastic protection), and it can also be immersed in liquids inflowed in a system). It is stored in a plastic gel bottle with a very long shelf life. A pH (potential of Hydrogen) probe measures the hydrogen ion activity in a liquid. A membrane at the tip of a pH probe permits hydrogen ions from the liquid to be measured to defuse into the outer layer of the membrane while larger ions remain in the solution. The difference in the concentration of hydrogen ions outside the probe vs. inside the pH probe creates a small current proportional to the concentration of hydrogen ions in the measured liquid.

EZO Carrier Click - pH accessories 1 image

Used MCU Pins

mikroBUS™ mapper

NC
NC
AN
NC
NC
RST
ID COMM
RG9
CS
NC
NC
SCK
NC
NC
MISO
NC
NC
MOSI
Power Supply
3.3V
3.3V
Ground
GND
GND
NC
NC
PWM
NC
NC
INT
UART TX
RB2
TX
UART RX
RB0
RX
I2C Clock
RD10
SCL
I2C Data
RD9
SDA
Power Supply
5V
5V
Ground
GND
GND
1

Take a closer look

Schematic

EZO Carrier Click - pH Schematic schematic

Step by step

Project assembly

PIC32MZ clicker front image hardware assembly

Start by selecting your development board and Click board™. Begin with the PIC32MZ clicker as your development board.

PIC32MZ clicker front image hardware assembly
GNSS2 Click front image hardware assembly
Prog-cut hardware assembly
GNSS2 Click complete accessories setup image hardware assembly
Micro B Connector Clicker Access - upright/background hardware assembly
Necto image step 2 hardware assembly
Necto image step 3 hardware assembly
Necto image step 4 hardware assembly
Necto image step 5 hardware assembly
Necto image step 6 hardware assembly
Flip&Click PIC32MZ MCU step hardware assembly
Necto No Display image step 8 hardware assembly
Necto image step 9 hardware assembly
Necto image step 10 hardware assembly
Debug Image Necto Step hardware assembly

Track your results in real time

Application Output via Debug Mode

1. Once the code example is loaded, pressing the "DEBUG" button initiates the build process, programs it on the created setup, and enters Debug mode.

2. After the programming is completed, a header with buttons for various actions within the IDE becomes visible. Clicking the green "PLAY" button starts reading the results achieved with the Click board™. The achieved results are displayed in the Application Output tab.

DEBUG_Application_Output

Software Support

Library Description

This library contains API for EZO Carrier Click - pH driver.

Key functions:

  • ezocarrierph_send_cmd - Send command function.

  • ezocarrierph_send_cmd_with_par - Send command function with parameter.

  • ezocarrierph_send_cmd_check - Check the sent command.

Open Source

Code example

This example can be found in NECTO Studio. Feel free to download the code, or you can copy the code below.

/*!
 * @file main.c
 * @brief EZO Carrier pH Click Example.
 *
 * # Description
 * This example demonstrates the use of EZO Carrier pH click board by processing
 * the incoming data and displaying them on the USB UART.
 *
 * The demo application is composed of two sections :
 *
 * ## Application Init
 * Initializes the driver, performs the click default factory reset, and mid point calibration.
 *
 * ## Application Task
 * Reads and processes all incoming pH value data and displays them on the USB UART.
 *
 * ## Additional Function
 * - static void ezocarrierph_clear_app_buf ( void )
 * - static void ezocarrierph_log_app_buf ( void )
 * - static err_t ezocarrierph_process ( ezocarrierph_t *ctx )
 * - static err_t ezocarrierdo_rsp_check ( ezocarrierdo_t *ctx, uint8_t *rsp )
 * - static void ezocarrierdo_error_check ( err_t error_flag )  
 *
 * @author Stefan Ilic
 *
 */

#include "board.h"
#include "log.h"
#include "ezocarrierph.h"

// Application buffer size
#define APP_BUFFER_SIZE             200
#define PROCESS_BUFFER_SIZE         200

static ezocarrierph_t ezocarrierph;
static log_t logger;

static uint8_t app_buf[ APP_BUFFER_SIZE ] = { 0 };
static int32_t app_buf_len = 0;
static err_t error_flag;

/**
 * @brief EZO Carrier pH clearing application buffer.
 * @details This function clears memory of application buffer and reset its length.
 * @note None.
 */
static void ezocarrierph_clear_app_buf ( void );

/**
 * @brief EZO Carrier pH log application buffer.
 * @details This function logs data from application buffer to USB UART.
 * @note None.
 */
static void ezocarrierph_log_app_buf ( void );

/**
 * @brief EZO Carrier pH data reading function.
 * @details This function reads data from device and concatenates data to application buffer. 
 * @param[in] ctx : Click context object.
 * See #ezocarrierph_t object definition for detailed explanation.
 * @return @li @c  0 - Read some data.
 *         @li @c -1 - Nothing is read.
 * See #err_t definition for detailed explanation.
 * @note None.
 */
static err_t ezocarrierph_process ( ezocarrierph_t *ctx );

/**
 * @brief Response check.
 * @details This function checks for response and
 * returns the status of response.
 * @param[in] rsp  Expected response.
 * @return @li @c  0 - OK response.
 *         @li @c -1 - Error response.
 *         @li @c -2 - Timeout error.
 * See #err_t definition for detailed explanation.
 */
static err_t ezocarrierph_rsp_check ( ezocarrierph_t *ctx, uint8_t *rsp );

/**
 * @brief Check for errors.
 * @details This function checks for different types of
 * errors and logs them on UART or logs the response if no errors occured.
 * @param[in] error_flag  Error flag to check.
 */
static void ezocarrierph_error_check ( err_t error_flag );

void application_init ( void ) 
{
    log_cfg_t log_cfg;  /**< Logger config object. */
    ezocarrierph_cfg_t ezocarrierph_cfg;  /**< Click config object. */

    /** 
     * Logger initialization.
     * Default baud rate: 115200
     * Default log level: LOG_LEVEL_DEBUG
     * @note If USB_UART_RX and USB_UART_TX 
     * are defined as HAL_PIN_NC, you will 
     * need to define them manually for log to work. 
     * See @b LOG_MAP_USB_UART macro definition for detailed explanation.
     */
    LOG_MAP_USB_UART( log_cfg );
    log_init( &logger, &log_cfg );
    log_info( &logger, " Application Init " );

    // Click initialization.
    ezocarrierph_cfg_setup( &ezocarrierph_cfg );
    EZOCARRIERPH_MAP_MIKROBUS( ezocarrierph_cfg, MIKROBUS_1 );
    if ( UART_ERROR == ezocarrierph_init( &ezocarrierph, &ezocarrierph_cfg ) ) 
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }
    
    log_printf( &logger, "Device status \r\n" );
    ezocarrierph_send_cmd( &ezocarrierph, EZOCARRIERPH_CMD_STATUS );
    error_flag = ezocarrierph_rsp_check( &ezocarrierph, EZOCARRIERPH_RSP_OK );
    ezocarrierph_error_check( error_flag );

    log_printf( &logger, "Factory reset \r\n" );
    ezocarrierph_send_cmd( &ezocarrierph, EZOCARRIERPH_CMD_FACTORY );
    error_flag = ezocarrierph_rsp_check( &ezocarrierph, EZOCARRIERPH_RSP_READY );
    ezocarrierph_error_check( error_flag );

    log_printf( &logger, "Device info \r\n" );
    ezocarrierph_send_cmd( &ezocarrierph, EZOCARRIERPH_CMD_DEV_INFO );
    error_flag = ezocarrierph_rsp_check( &ezocarrierph, EZOCARRIERPH_RSP_OK );
    ezocarrierph_error_check( error_flag );

    uint8_t n_cnt = 0;
    uint8_t last_reading[ APP_BUFFER_SIZE ] = { 0 };
    ezocarrierph_clear_app_buf( );
    ezocarrierph_send_cmd( &ezocarrierph, EZOCARRIERPH_CMD_SINGLE_READ );
    ezocarrierph_process ( &ezocarrierph );
    strcpy( last_reading, app_buf );
    log_printf( &logger, "Mid point calibration \r\n" );
    log_printf( &logger, "- - - - - - - - - - - - - - -\r\n" );
    log_printf( &logger, "Place probe into pH neutral solution \r\n" );
    Delay_ms( 5000 );
    log_printf( &logger, "Starting calibration \r\n" );
    log_printf( &logger, "- - - - - - - - - - - - - - -\r\n" );
    log_printf( &logger, "Waiting for stable readings \r\n" );
    while ( n_cnt <= 5 )
    {
        if ( EZOCARRIERPH_OK == ezocarrierph_process ( &ezocarrierph ) )
        {  
            if ( 0 == strstr( app_buf, last_reading ) )
            {
                n_cnt++;
            }
            else
            {
                strcpy( last_reading, app_buf );
                n_cnt = 0;
            }
        }
        log_printf( &logger, "- " );
        Delay_ms( 1000 );
        ezocarrierph_clear_app_buf( );
    }
    
    #define MID_POINT_CALIB         "mid,7.00"
    log_printf( &logger, "\r\n Calibration \r\n" );
    ezocarrierph_send_cmd_with_par( &ezocarrierph, EZOCARRIERPH_CMD_CAL, MID_POINT_CALIB );
    error_flag = ezocarrierph_rsp_check( &ezocarrierph, EZOCARRIERPH_RSP_OK );
    ezocarrierph_error_check( error_flag );

    #define DISABLE_CONT_READ       "0"
    log_printf( &logger, "Disable continuous reading mode \r\n" );
    ezocarrierph_send_cmd_with_par( &ezocarrierph, EZOCARRIERPH_CMD_CONT_READ, DISABLE_CONT_READ );
    error_flag = ezocarrierph_rsp_check( &ezocarrierph, EZOCARRIERPH_RSP_OK );
    ezocarrierph_error_check( error_flag );

    log_info( &logger, " Application Task " );
}

void application_task ( void ) 
{
    log_printf( &logger, "Reading... \r\n" );
    ezocarrierph_send_cmd( &ezocarrierph, EZOCARRIERPH_CMD_SINGLE_READ );
    error_flag = ezocarrierph_rsp_check( &ezocarrierph, EZOCARRIERPH_RSP_OK );
    ezocarrierph_error_check( error_flag );
    Delay_ms( 5000 );
}

void main ( void ) 
{
    application_init( );

    for ( ; ; ) 
    {
        application_task( );
    }
}

static void ezocarrierph_clear_app_buf ( void ) 
{
    memset( app_buf, 0, app_buf_len );
    app_buf_len = 0;
}

static void ezocarrierph_log_app_buf ( void )
{
    for ( int32_t buf_cnt = 0; buf_cnt < app_buf_len; buf_cnt++ )
    {
        log_printf( &logger, "%c", app_buf[ buf_cnt ] );
    }
}

static err_t ezocarrierph_process ( ezocarrierph_t *ctx ) 
{
    uint8_t rx_buf[ PROCESS_BUFFER_SIZE ] = { 0 };
    int32_t overflow_bytes = 0;
    int32_t rx_cnt = 0;
    int32_t rx_size = ezocarrierph_generic_read( ctx, rx_buf, PROCESS_BUFFER_SIZE );
    if ( ( rx_size > 0 ) && ( rx_size <= APP_BUFFER_SIZE ) ) 
    {
        if ( ( app_buf_len + rx_size ) > APP_BUFFER_SIZE ) 
        {
            overflow_bytes = ( app_buf_len + rx_size ) - APP_BUFFER_SIZE;
            app_buf_len = APP_BUFFER_SIZE - rx_size;
            memmove ( app_buf, &app_buf[ overflow_bytes ], app_buf_len );
            memset ( &app_buf[ app_buf_len ], 0, overflow_bytes );
        }
        for ( rx_cnt = 0; rx_cnt < rx_size; rx_cnt++ ) 
        {
            if ( rx_buf[ rx_cnt ] ) 
            {
                app_buf[ app_buf_len++ ] = rx_buf[ rx_cnt ];
            }
        }
        return EZOCARRIERPH_OK;
    }
    return EZOCARRIERPH_ERROR;
}

static err_t ezocarrierph_rsp_check ( ezocarrierph_t *ctx, uint8_t *rsp )
{
    uint32_t timeout_cnt = 0;
    uint32_t timeout = 10000;
    err_t error_flag = EZOCARRIERPH_OK;
    ezocarrierph_clear_app_buf( );
    while ( ( 0 == strstr( app_buf, rsp ) ) &&
    ( 0 == strstr( app_buf, EZOCARRIERPH_RSP_ERROR ) ) )
    {
        error_flag |= ezocarrierph_process( ctx );
        if ( timeout_cnt++ > timeout )
        {
            ezocarrierph_clear_app_buf( );
            return EZOCARRIERPH_ERROR_TIMEOUT;
        }
        Delay_ms( 1 );
    }
    Delay_ms( 100 );
    error_flag |= ezocarrierph_process( ctx );
    if ( strstr( app_buf, rsp ) )
    {
        return EZOCARRIERPH_OK;
     }
    else if ( strstr( app_buf, EZOCARRIERPH_RSP_ERROR ) )
    {
        return EZOCARRIERPH_ERROR;
    }
    else
    {
        return EZOCARRIERPH_ERROR;
    }
}

static void ezocarrierph_error_check ( err_t error_flag )
{
    switch ( error_flag )
    {
        case EZOCARRIERPH_OK:
        {
            ezocarrierph_log_app_buf( );
            break;
        }
        case EZOCARRIERPH_ERROR:
        {
            log_error( &logger, " Error!" );
            break;
        }
        case EZOCARRIERPH_ERROR_TIMEOUT:
        {
            log_error( &logger, " Timeout!" );
            break;
        }
        default:
        {
            log_error( &logger, " Unknown!" );
            break;
        }
    }
    log_printf( &logger, "- - - - - - - - - - - - - - -\r\n" );
    Delay_ms( 500 );
}

// ------------------------------------------------------------------------ END

Additional Support

Resources

Love this project?

'Buy This Kit' button takes you directly to the shopping cart where you can easily add or remove products.