OhmPi V2023 (64 electrodes and 12V)

Warning

OhmPi is a participative project open to all, it requires skills in electronics and to respect the safety rules. OhmPi must be assembled in a professional context and by people competent in electronics. The OhmPi team cannot be held responsible for any material or human damage which would be associated with the use or the assembly of OhmPi. The OhmPi team cannot be held responsible if the equipment does not work after assembly.

OhmPi V: 2023.0.0-rc1

Note

In this version, we have developed two new board types that allow the assembly of OhmPi v2023, a measurement board and a multiplexer board. This new version is made up of:

  1. A measurement board for four-point measurement

  2. 4 multiplexer cards

  3. A box

The OhmPi V2023 software has been adapted to handle this new boards and also includes many new functionalities.

The philosophy of OhmPi

The philosophy of OhmPi V2023 is to offer a new DIY multi-electrode resistivity meter. It is a resistivity meter with 64 electrodes, which can be upgraded to 128 electrodes. It is limited to low-current injection, but suitable for small laboratory experiments and small field time-lapse monitoring. OhmPi is developed by a team that seeks to share its experience and wishes to improve and offer a more and more robust tool to the community. OhmPi 2023 is completely different version from the previous one. We will stop the development on the version V1.0x, to dedicate our efforts on this new version.


Hardware

Specifications

Parameter

V1.0x

Units

v2023

Units

Electrodes

32

64 to 128

Operating temperature

-0 to 50

°c

-25 to 50

°C

Power consumption of CPU and control system

18.5

W

18.5

W

Voltage injection

12

V

12

V

Battery

9

V

12

V

Current

0 to 40

mA

0 to 40

mA

Min pulse duration

150

ms

150

ms

Input impedance

80

MOhm

80

MOhm

Data storage

micro SD card

micro SD card

Resolution

0.01

Ohm

0.01

Ohm

Building an OhmPi V2023 step by step

Software and operation

System architecture

The OhmPi V2023 software is designed around a new architecture whose main components are summarized in the figure below.

_images/architecture.png

Software architecture of OhmPi V2023.

The general system configuration is defined in the config.py file covered in the Configuration file section. The acquisition settings (i.e. injection duration, stacks…) are defined in a separate JSON file (default: ohmpi_settings.json).

The central software component is the ohmpi.py file that contains the OhmPi class that interacts with the hardware. Other python files include utils and handlers (see the Loggers section for more details). A communication layer (I/O interface) on top of OhmPi allows for different user interfaces depending on the use cases (see Interfaces and applications).

Loggers

Loggers have been introduced in this release. They use the excellent logging python package. Specific handlers have been implemented for running with ohmpi.py (one for logging to an mqtt broker (see MQTT interface for more details) and one for creating zipped rotated logs on disk).

Two loggers have been defined. The first one is dedicated to log operations execution. It is named exec_logger. The second one, named data_logger, is dedicated to log data. A third one is planned to log the state of health (SOH) of the system in a future version.

By default, logs are written to the console (print-like), stored locally in files (a zip is created after some time i.e. every day and/or when the size of the log exceeds a maximum size) and sent to an MQTT broker. Different logging levels may be defined for the different logs and handlers in the Configuration file.

Advanced users may write new handlers and edit the setup_loggers.py file to customize the logging mechanisms to their needs.

Configuration file

The configuration of the OhmPi file config.py allows to configure the OhmPi. A default version of config.py is provided in the repository. This file should be edited to customize the configuration following the user’s needs and preferences.

The configuration includes setting the logging level desired for the different loggers and handlers, setting the mqtt broker(s) used for logging and control of the OhmPi and defining the options used for MQTT communication (i.e. username, password, security options…)

One should make sure to understand the parameters before altering them. It is also recommended to keep a copy of the default configuration.

Interfaces and applications

Different interfaces can be used to interact with the OhmPi.

Available interfaces are: - Web interface (=HTTP interface): run in bash: bash run_http_interface.sh - Python API: import the OhmPi class from Python script: from ohmpi import OhmPi (see Python interface) - MQTT: IoT messaging through a broker (see MQTT interface)

Web interface

This is a user friendly graphical interface for new users as well as running quick and easy acquisitions.

The Raspberry Pi of the OhmPi is used as a Wi-Fi Access Point (AP) and runs a small webserver to serve the ‘index.html’ interface. Using a laptop or a mobile phone connected to the Wi-Fi of the Raspberry Pi, one can see this interface, upload sequences, change parameters, run a sequence and download data.

To configure the Raspberry Pi to act as an access point and run the webserver automatically on start, see instructions on raspap.com and in ‘runOnStart.sh’.

Once configured, the webserver should start by itself on start and once connected to the Pi, the user can go to 10.3.141.1:8080 to access the interface.

_images/http-interface-pseudo-section.png

Web interface with its interactive pseudo-section.

_images/http-interface-evolution.png

Evolution of quadrupole apparent resistivity with time.

_images/http-interface-rs.png

Contact resistance check.

Python interface

This interface offers a more direct access to the software components especially well suited for testing or automation on the Raspberry Pi.

By importing the OhmPi class from the ohmpi.py, one can control the OhmPi using interactive IPython. Typically, it involves using the terminal or an Python IDE such as Thonny on the Raspberry Pi. One can also connect using ssh and run the Python interface (see PuTTY on Windows or ssh command on macOS/Linux).

To access the Python API, make sure the file ohmpi.py is in the same directory as where you run the commands/script. The file ohmpi.py can be found on the OhmPi gitlab repository. We recommend downloading the entire repository as ohmpi.py import other .py files and default configuration files (.json and .py).

Example of using the Python API to control OhmPi
import os
import numpy as np
import time
os.chdir("/home/pi/OhmPi")
from ohmpi import OhmPi

### Define object from class OhmPi
k = OhmPi()  # this loads default parameters from the disk

### Default parameters can also be edited manually
k.settings['injection_duration'] = 0.5  # injection time in seconds
k.settings['nb_stack'] = 1  # one stack is two half-cycles
k.settings['nbr_meas'] = 1  # number of time the sequence is repeated

### Update settings if needed
k.update_settings({"injection_duration":0.2})

### Set or load sequence
k.sequence = np.array([[1,2,3,4]])    # set numpy array of shape (n,4)
# k.set_sequence('1 2 3 4\n2 3 4 5')    # call function set_sequence and pass a string
# k.load_sequence('ABMN.txt')    # load sequence from a local file

### Run contact resistance check
k.rs_check()

### Run sequence (synchronously - it will wait that all
# sequence is measured before returning the prompt
k.run_sequence()
# k.run_sequence_async()  # sequence is run in a separate thread and the prompt returns immediately
# time.sleep(2)
# k.interrupt()  # kill the asynchron sequence

### Run multiple sequences at given time interval
k.settings['nb_meas'] = 3  # run sequence three times
k.settings['sequence_delay'] = 100 # every 100 s
k.run_multiple_sequences()  # asynchron
# k.interrupt()  # kill the asynchron sequence

### Single measurement can also be taken with
k.switch_mux_on([1, 4, 2, 3])
k.run_measurement()  # use default acquisition parameters
k.switch_mux_off([1, 4, 2, 3])  # don't forget this! risk of short-circuit

### Custom or adaptative argument, see help(k.run_measurement)
k.run_measurement(nb_stack=4,  # do 4 stacks (8 half-cycles)
                  injection_duration=2,  # inject for 2 seconds
                  autogain=True)  # adapt gain of ADS to get good resolution

MQTT interface

This is an interface designed for an advanced remote usage of the OhmPi such as remote automation, data consumption by multiple processes and interaction with other sensors in the scope of a monitoring. It is based on the MQTT protocol, designed for the Internet of Things (IoT), to interact with the OhmPi.

This option allows interacting remotely with a single OhmPi, a network of OhmPis, as well as auxiliary instruments and sensors. The communication is based on a publish/subscribe approach and involves a MQTT broker.

An example of MQTT broker that can be used is Mosquitto. Depending on the monitoring needs, an MQTT broker can be set up locally on the Raspberry Pi, on a local network or any remote server reachable through the net. A local Mosquitto broker can be set up and enabled to run as a service on the OhmPi using the bash script install_local_mqtt_broker.sh.

MQTT messages include logging messages from the OhmPi and commands sent to the OhmPi. These messages can be examined easily using a third party software such as MQTT Explorer.

Commands sent on the broker are received by the ohmpi.py script that runs on the OhmPi (make sure ohmpi.py starts on reboot) and further processed. MQTT commands are sent in JSON format following the Python API with kwargs as illustrated below:

Updating acquisition settings.
{
  "cmd_id": "3fzxv121UITwGjWYgcz4xw",
  "cmd": "update_settings", Depending on the experiment needs, MQTT brokers can be set up locally on the Raspberry Pi or on a local or remote server.
  "kwargs": {
    "config": {
      "nb_meas": 2,
      "nb_electrodes": 10,
      "nb_stack": 2,
      "injection_duration": 2,
      "sequence_delay": 100
    }
  }
}
Check contact resistances
{
  "cmd_id": "3fzxv121UITwGjWYgcz4xw",
  "cmd": "rs_check",
}
Running a sequence.
{
  "cmd_id": "3fzxv121UITwGjWYgcz4Yw",
  "cmd": "run_sequence",
}
Running same sequence multiple times (nb_meas).
{
  "cmd_id": "3fzxv121UITwGjWYgcz4Yw",
  "cmd": "run_multiple_sequences",
}
Interrupt current acquisition.
{
  "cmd_id": "3fzxv121UITwGjWYgcz4xw",
  "cmd": "interrupt",
}

Custom processing of messages and tailor-made dashboards for monitoring experiments may be designed using a browser-based flow editor such as Node-red. This may help designing complex IoT experiments and monitoring systems in which OhmPi is a component.

Examples incorporating execution commands and data outputs from OhmPi can be found in the OhmPi examples. Once Node-RED is installed on the OhmPi, these examples can be accessed separately by running a command in the console such as :

These examples may require installing some additional node packages in order to work properly. This can be done in the `Palette Manager <https://nodered.org/docs/user-guide/editor/palette/manager> within Node-RED.

_images/node-red_flow.png

Example flow in node-red to interact with an OhmPi.

_images/node-red_interface_control.png

Example of a dashboard UI created with node-red to interact with an OhmPi - control tab.

_images/node-red_interface_data.png

Example of a dashboard UI created with node-red to interact with an OhmPi - data visualization tab.

For more documentation dedicated to node-red, please refer to the Node-red cookbooks.