Programmable Test-Rig (Part 1)

Update:

1. The test-rig was redesigned, to place the touchscreen at the top of the instrument, and to place the breadboard lower, which allows easier connection with accessory hardware.

2. I've also built a miniature version, intended for work with the prototype AirLoop incubator. The smaller version is functionally similar, with Totem Arduino board, 4.3" 4D Systems touch screen (vs. 7"), and breadboard for circuit expansion. Interfaces developed on the larger system can be adapted for implementation on the smaller, lower cost device.

More details below.

Design of a programmable test-rig

The availability of low cost electronics, optics and open software environments is triggering new opportunities in the development of bioinstrumentation - where biologists can use no-code programming approaches to develop prototype devices for use in the lab, field or clinic. This approach has been developed in the Biomaker initiative (https://www.biomaker.org), and many example projects are housed on Hackster (https://www.hackster.io/biomaker).

This project describes the use of the visual programming environment, XOD (https://xod.io) with Arduino-based electronics, touchscreen display and Totemmaker construction tools (https://totemmaker.net) to build a programmable rig for prototyping instrumentation. The integration of no-code programming and programmable touchscreen means that the instrument is highly flexible, and easily repurposed. In this project, we tested its use to control and monitor a reaction chamber for molecular diagnostics. For example, loop-mediated isothermal amplification (LAMP) is a single-tube technique for the amplification of DNA that can form the basis for a low-cost assay for detection of viruses and other pathogens or pest of medical and agricultural importance. The reaction requires incubation at controlled temperatures, and development of a cheap, portable incubator would be of great use.

The main design challenge for building the test-rig was to find a way of combining the flexibility of Arduino-based electronics with code-free programming in XOD - and speed up the integration of I/O interfaces. In the Biomaker initiative, we have focused on tools for the integration of programmable touchscreen panels to simplify the design and prototyping of instrumentation - and that approach has been extended here. A 4D Systems 7" touchscreen was chosen as the centerpiece of the test-rig. The 4DS Gen4 µLCD screens are connected via serial port, and include a processor and storage to handle graphics manipulation autonomously. Other similar touchscreens are available more cheaply, but the 4D Systems screens come with strong software support, with the free 4D Workshop package (https://4dsystems.com.au/workshop4) that allows drag-and-drop programming of multi-screen user interfaces, with a corresponding set of Arduino libraries. Further, XOD programmers have converted the Arduino IDE libraries to XOD libraries, with a set of nodes that allow simple visual coding of interactions between the microcontroller and screen. For example, the touchscreen can provide multiple sets of switches, knobs, gauges and level settings and sophisticated display of parameter settings or sensor measurements - all reconfigurable in software.

Building the stand

The integration of these devices and design of a test-rig was inspired by the Mini Lab, produced by Totem, a small Lithuanian company that sell a system of beams, sheets and connectors that can be used for building physical assemblies, like chassis, robots and toy vehicles. The construction system is brilliantly clever - implementing a modular scheme for flexible construction based on easily cut plastic beams/sheets and a comprehensive set of metal connectors. There is a good set of descriptive documents available at: https://totemmaker.net/wikis/cat-1/assembly_books/. Highly recommended to investigate this!

The Totem Mini Lab includes an Arduino UNO compatible board and expansion panel that provide convenient port access, programmable voltage source, frequency and pulse counter, etc. - and an additional set of shield sockets. It was relatively simple to convert the Mini Lab chassis into an extended version that included space for the 7" 4D Systems touch screen (shown above). The addition of the screen requires a considerably larger stand. Additional parts from a Totem Starter Kit were used to widen and extend the existing structure. The modular nature of the Totem parts will make easy any future modifications.

Connecting the touchscreen

The touchscreen was mounted on the chassis frame using standard Totem components (https://totemmaker.net/blog/mounting-electronics-totem-mechanics/), and connected to the Arduino board via standard ribbon cable and 4D Systems Arduino shield (https://4dsystems.com.au/4d-arduino-adaptor-shield-ii). The screen consumes around 500mA, 5V in operation. Higher capacity USB-C connections are sufficient to power both the Arduino and screen, but lower power spec connections (e.g. USB-A) may struggle, and use of an external power supply may be required (the screen may flicker or not illuminate if underpowered). The screen was positioned towards the bottom part of the stand for stability, and ease of touchscreen access.

4D systems provides a Windows-only software package that can be used to program the touchscreen. The software can be downloaded from: https://4dsystems.com.au/products/software. There are four different development environments with different levels of coding required. The Visi-Genie mode does not require any coding at all. Everything is done automatically, the display is simply laid out with screen objects, parameters adjusted, events set to drive them, the code is written automatically and downloaded directly to the display hardware. A more complete description of the process and available screen widgets can be found at: https://www.hackster.io/jim-haseloff/biomaker-tutorial-4-programming-the-4ds-touchscreen-3b2006. There are also comprehensive documentation and application notes available at: https://4dsystems.com.au.

The Arduino device and the touchscreen are connected via the Arduino shield, and communication is established by setting up a serial port connection through the UART node. Links to documentation can be found at 4D Systems (https://4dsystems.com.au/products/4d-intelligent-hmi-display-modules/arduino-compatible-kits/gen4-ulcd-32dt-ar).

Points to note:

(i) There are two types of connections required. First, temporary connection via a USB port(s) to programme the 4DS screen and download graphics data to the µSD card - from a computer running the 4D Workshop development environment. Second, for connection to a serial communication port on the Arduino microcontroller, and the custom Arduino shield is provided for this. The open back of the Test-rig stand allows access for disconnection and reconnection of these cables. In the future

(ii) When connecting screens and adapter via the provided ribbon cable, the blue marking on the cable should be positioned on the rear of the cable.

(iii) The default serial port for communication is Com0, which causes conflict with the only hardware serial port (D1, D2) on Arduino UNO compatible boards. Shift jumpers J3 and J4 on the 4DS shield adapter to select Com1, which will rely on software-based serial communications, but means that you won't have to unplug the screen everytime the Arduino is being programmed. Details can be found at: https://4dsystems.com.au/mwdownloads/download/link/id/85/.

Programming the touchscreen

XOD is an open source software development environment that can be used to programme the Arduino microcontroller board. It uses a graphical interface that represents hardware and computing elements as nodes that can be wired together to allow data flow between the objects. XOD allows a hierarchical and dataflow driven approach, avoids the complexities of text management and syntax, and can be used to directly programme Arduino boards. We think that this provides a simple way for non-programmers (i.e. biologists) to develop useful skills and understanding - without needing to deal with the complications of programming languages and syntax. We have chosen XOD as an accessible tool for Biomaker training and device development. The software can be downloaded from: (https://xod.io). There are versions of the desktop IDE for Windows, Mac OSX and Linux.

When you open up a project in XOD your will find a series of “patches”. A patch is the working area for a XOD program. It is similar to a “sketch” in the standard Arduino IDE, but instead of text code - the patch is built with graphical “nodes”, which are the basic elements in a XOD program. A node can represent many different things: an electronic component, a logic function, a signal or timing generator, a mathematical function, conversion function, or display device. Each node is represented by a rectangular box that has one or more circular connections on the top and bottom. These connectors are called “pins”.

“Input pins” are located on the top side of each node, while those on the bottom are “output pins”. The pins on a node are like variables and can contain parameter values. The pins on a node can have different data types, represented by colors: Green Pins represent numbers; Blue pins represent pulses; Violet pins represent boolean values; Orange pins represent strings. The values can be left at their default values, or selected and set using the “Inspector”, or receive new values via connection to the output pins of other nodes. A XOD program consists of nodes connected together in one or more patches. There are variety of introductory tutorials for XOD available at: https://xod.io/docs/tutorial/

Arduino code for reading and writing the 4DSystems touchscreen has been encapsulated in XOD nodes, and can be used for rapid prototyping of control interfaces. These can be loaded as two XOD libraries: gabbapeople/4d-ulcd/and bradzilla84/visi-genie-extra-library. The libraries provide a set of nodes that allow communication between Arduino and touchscreen, and reading and writing of information determined by the interface widgets programmed in the display. For example, the simple starter screen above shows two toggle switches to control a heater and fan, gauges for heating block and air temperature, corresponding LED readouts, and realtime plots of the temperatures. These stock graphical devices were assembled in the 4DS Workshop4 environment, programmed into the display, and read and written to, using the XOD code displayed above.

The use of encapsulated code in Workshop4 and XOD makes changes easy to implement. Further, the display can hold multiple pages - allowing a user to switch between multiple interfaces, which can each be separately addressed by different XOD patches. This allows the creation of custom test-rigs that can be easily switched between different functions.

Making temperature measurements

This project has arisen from a need to test different designs for low-cost incubators for diagnostics, and related molecular reactions - where temperature control is an important factor. DS19B20 devices provide simple, low-cost and pre-calibrated digital sensors for temperature measurement. The chips provide 9-bit to 12-bit Celsius temperature measurements (and has an alarm function with nonvolatile user-programmable upper and lower trigger points). The DS18B20 chip communicates over a 1-Wire bus that requires only one data line. Each DS18B20 has a unique 64-bit serial code, which allows multiple sensors to be placed on the same 1-Wire bus. XOD provides a node in the "common hardware" library that can read single 18DSB20 devices in a circuit.

The sensor measures temperatures from -55°C to +125°C with better than ±0.5°C Accuracy from -10°C to +85°C (see graph) - the chip is internally calibrated and returns a digital measurement that can be displayed directly.

For more information, see: https://create.arduino.cc/projecthub/TheGadgetBoy/ds18b20-digital-temperature-sensor-and-arduino-9cc806

Constructing a thermal probe

The bare component looks like a transistor, with epoxy housing and three pins. The identity of the pins and circuit for wiring to an Arduino board are shown above. The component can be incorporated into a compact thermal probe by removing the plastic housing from the ends of three female jumper leads and soldering the component to the end of the leads. Heat shrink tubing makes good insulators to prevent shorting of the component leads.

This results in a compact and robust probe that can be fixed in place for temperature measurements. Heat sink epoxy resin compounds are useful to make permanent mounts. For example, Arctic Silver Thermal Adhesive is an epoxy resin with good thermal conduction characteristics, and poor electrical conductance, that solidifies after about 5 minutes after mixing. These types of adhesives can be used to effectively fix probes in place, and ensure more accurate temperature readings.

Reading temperatures in XOD

DS18B20 components are wired into circuits in the following way: a ground and 5V power supply can be provided directly to pins 1 and 3 (or the DS18B20 can obtain power directly from the data lines in some implementations). Beware: if pins 1 and 3 are reversed, the component heats up very quickly, and can lead to destruction. The middle data pin should be connected to a suitable data port on the Arduino board. It is important to include a pull-up resistor, connected to the 5V line.

The standard distribution of XOD provides a "common-hardware" library. This includes a node "ds18b20-thermometer" that provides all of the code required to read a single device attached to a particular digital port, and provide a number value corresponding to the current temperature in Celsius. Each read can be triggered by an input pulse, and the node exports a pulse after a successful read event. The output can be modified or sent directly to a suitable display device - such as in our example, a screen gauge or LED digits.

Revised designs

The modular nature of the TotemMaker connectors make it easy to adjust or rebuild the test-rig chassis. First, the order of display, electronic and breadboard panels was rearranged, to place the display higher, and to make the breadboard more accessible for connection with peripheral sensors, heating elements and fans.

Compact control unit

The test-rig provides a base for controlling and monitoring prototype instruments, such as the recirculating air micro-incubator that we are developing (https://www.hackster.io/jim-haseloff/airloop-i-5d2a72). The large programmable display and Totem Mini-Lab components are useful for this work. The test-rig allows us to develop custom hardware, graphical user interface and control software - using fast no-code programming tools. In order to then adopt the interface for real-world instrumentation, we're experimenting with compact lower-cost hardware that can be used to build instruments. These can range from "bare-bone" Arduino board setups to units with small touchscreens for graphical user interfaces. An example of the latter is shown below.

Again, TotemMaker struts and connectors were used to build different prototypes. The Totem system is very cleverly engineered, with easily cut plastic beams and sheets, and a wide range of modular connectors that allow one to experiment quickly with new designs, and to adapt designs to new hardware on the fly. It's the best system for chassis building that I've seen - and well worth exploring (https://totemmaker.net).

To build a cheaper and more compact control unit, a Totem Arduino board was integrated with a smaller (4.3") touchscreen display and small breadboard. The Totem board is a standard UNO R3 compatible Arduino (Totemduino), and used in their Mini and Micro Labs (https://totemmaker.net/product/totemduino-microlab/). The Totemduino has a high capacity 1.5A, 5V regulator, short circuit protection for its ports, and (especially) an extender board that makes work with breadboard wiring easier (https://totemmaker.net/product/breadboard-friendly-extension-to-totemduino/).

We're using the full size test-rig to experiment with control systems and user interfaces for various hardware combinations. The compact control unit is also compatible with Arduino hardwrae and the XOD and 4D Systems Workshop no-code development environments for developing control systems - so it is relatively straightforward to the control software from the test-rig to the compact control unit, which is better suited for instrument construction.

We are continuing to build new control units, and expect to integrate miniature OLED displays, sensor systems, etc. - as we pursue new 3D printed microreactor designs - there is plenty of opportunity to lower costs, shrink and integrate new devices.

Testing prototype heating circuits

The prototype incubator is designed for heating small (0.2 µL) reaction tubes to around 60 degrees Celsius. To minimise costs and complexity, a positive temperature coefficient (PTC) heater was trialled as a heat source. PTC heaters provide resistive heating. When cool, the device draw a relatively large current. As the temperature rises, the resistance increases - resulting in a fall in current. This continues until the heater reaches a maximum temperature. Therefore PTC heaters do not overheat, and this simplifies the design of both the prototype control system and vessel. The prototype was intended to exploit air heating (rather than metal block heating) and vessel shape and baffles to maximise efficient heat exchange with the incubator. Air heating is facilitated by the use of blower fans or use of a heat sink with integrated fan. The first of these are being documented at https://www.hackster.io/jim-haseloff/airloop-i-5d2a72

Support for control and visualisation in XOD

The XOD graphical development environment contains a number of pre-packaged nodes that are useful for (i) controlling heater output and air circulation, (ii) readout of accurate temperature sensors, and (iii) collection of user input and display through touchscreens or other displays. A wide range of Arduino libraries have been converted to XOD, and these provide a wide range of functions to explore - easy even for non-programmers. More info about getting started at: https://xod.io/docs/tutorial/ and https://www.biomaker.org/xod-software.

For example, there is XOD support for reading and writing to 4D Systems touchscreens. Input devices, such as switches, knobs, sliders, and output such as LED indicators, digital numbers, gauges, dials and plots. The image below shows the plotted output of DS18B20 temperature sensors in a prototype incubator, showing heating from room temperature (24 degrees C) to a target of 60 degrees. The heater output was controlled from XOD, and the temperature increase was logged onscreen. (The x-axis graticule marks are 20 secs apart). The use of a programmable touchscreen makes it easy to experiment with new user interfaces.

Components for prototype microtube reactor

Open software, cheap microcontrollers and 3D printing can add value to low cost hardware components. For example the bill of goods for a prototype microreactor runs to:

PTC heater, 110 degrees C (£3.50)

Blower fan, 12V, 100mA (£2.50)

2x Flat heatsinks (£2.00 ea.)

2x DS18B20 digital thermometers (£1.00 ea)

High power MOSFET switch module (£1.80)

Coaxial connector (£0.60)

12V 5A mains power supply (£10.00)

all sourced at retail prices in the UK.

https://www.hackster.io/jim-haseloff/airloop-i-5d2a72