MAX31865 RTD to digital converter
This board provide an easy to use SPI compatible interface for 2 wire, 3 wire and 4 wire Pt100 or Pt1000 sensor element.
The drivers for this and many others sensors useful for citizen scietists are supported out of the box in Box0.
The PCB as usual are open source licensed and has been designed in our favorite free/open source Kicad.
I will upload these shortly on Gitlab and provide a link to the online directory.

Surprise surprise, what we have for you.

Acrylic case for Box0!

Go get one for your self.

You can find the design files at

box0-v5-hardware/case/top.svg

box0-v5-hardware/case/bottom.svg

box0-v5-breakout/case/top_with_side.svg

box0-v5-breakout/case/top_without_side.svg

All these SVG files are designed in our beloved Free/Open-source software — Inkscape.

Introduction

According to Wikipedia,

A Bode plot /ˈboʊdi/ is a graph of the frequency response of a system. It is usually a combination of a Bode magnitude plot, expressing the magnitude (usually in decibels) of the frequency response, and a Bode phase plot, expressing the phase shift.

Note: The code is not specific to RC, you can actually use it for other type of circuits & systems.

Connection

In the circuit, Capacitor = 0.1μF and Resistance = 550Ω.

Using the formula of Cut-off frequency, f = 1/2πRC

That gives us, f=10.000345=2.89KHz

Code

import box0
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
import math

# allocated resources
dev = box0.usb.open_supported()
ain0 = dev.ain(0)
aout0 = dev.aout(0)

# prepare resources

ain0.static_prepare()
ain0.bitsize.current = 12
ain0.chan_seq.current = [0, 1]

aout0.static_prepare()
aout0.bitsize.current = 12
aout0.chan_seq.current = [0]

FREQ = range(100, 5000, 100)

REF_LOW = -3.3
REF_HIGH = 3.3
INPUT_AMPLITUDE = (REF_HIGH - REF_LOW) / 2

data_freq = []
data_phase = []
data_magnitude = []

def set_freq(freq):
    """
    Set frequency to AOUT0.CH0
    :param float freq: Requested frequency
    :return: Actual frequency
    """
    global aout0

    # try to stop aout0 from last run
    try: aout0.static_stop()
    except: pass

    # calculate the actual frequency that can be generated
    count, speed = aout0.static_calc(freq, 12)
    freq = float(speed) / float(count)

    # generate a sine wave
    x = np.linspace(-np.pi, +np.pi, count)
    y = np.sin(x) * INPUT_AMPLITUDE

    # set the configuration to module
    aout0.speed.current = speed
    aout0.static_start(y)

    return freq

def get_best_speed_and_count(freq):
    """
    Find the best sampling frequency at which signal with `freq` can be captured.
    Care is taken to not exceed more than 100ms acquisition duration.
    :param float freq: Frequency of expected signal that need to be captured
    :return: sampling_freq, count
    :rtype: int, int
    """
    sampling_freq = freq * 40 # atleast sample 40 time more than the signal frequency
    max_sample_count = 1000
    max_duration = 0.1 # 100ms

    sample_count = min(max_duration * sampling_freq, max_sample_count)

    # make sample_count multiple of 2, because two channel are being captured
    sample_count = int(sample_count / 2) * 2

    return int(sampling_freq), int(sample_count)

# ref: http://stackoverflow.com/a/26512495/1500988
def curve_fit_sine(t, y, freq):
    """Perform curve fitting of sine data"""
    p0 = (INPUT_AMPLITUDE, 0.0, 0.0)
    p_lo = (0.0, -np.pi, 0.0)
    p_up = (INPUT_AMPLITUDE, np.pi, REF_HIGH)

    def cb(t, amplitude, phase, offset):
        return np.sin(2 * np.pi * t * freq + phase) * amplitude + offset

    fit = curve_fit(cb, t, y, p0=p0, bounds=(p_lo, p_up))
    fit = fit[0]

    return fit[0], math.degrees(fit[1])

def get_data(freq):
    """
    Get channel data of ain0.
    :param float freq: expected Frequency of the signal that need to be captured
    :return: magnitude_in_db, phase_in_degree
    """
    global ain0

    # retrive data
    sampling_freq, sample_count = get_best_speed_and_count(freq)
    ain0.speed.current = sampling_freq
    data = np.empty(sample_count)
    ain0.static_start(data)

    # process the data
    t = np.linspace(0.0, float(sample_count) / sampling_freq, sample_count, endpoint=False)
    input_amplitude, input_phase = curve_fit_sine(t[0::2], data[0::2], freq)
    output_amplitude, output_phase = curve_fit_sine(t[1::2], data[1::2], freq)

    # extract results
    magnitude = 20 * math.log10(output_amplitude / input_amplitude)
    phase = (output_phase - input_phase) % 360

    # convert phase into a value that is around 0
    if phase < -180:
        phase += 360
    elif phase > 180:
        phase -= 360

    return magnitude, phase

for freq in FREQ:
    #print("capturing ", freq)

    # do the main part!
    freq = set_freq(freq)
    magnitude, phase = get_data(freq)

    # store the results
    data_freq.append(freq)
    data_magnitude.append(magnitude)
    data_phase.append(phase)

# free up resources
ain0.close()
aout0.close()
dev.close()

fig, axs = plt.subplots(nrows=1, ncols=2, sharex=True)
fig.suptitle("Bode Plot")

magnitude = axs[0]
magnitude.grid(True)
magnitude.set_xscale('log')
#magnitude.set_yscale('log')
magnitude.set_xlabel("Frequency (Hz)")
magnitude.set_ylabel("Magnitude (dB)")
magnitude.plot(data_freq, data_magnitude, 'r.-')

phase = axs[1]
phase.grid(True)
phase.set_xscale('log')
phase.set_xlabel("Frequency (Hz)")
phase.set_ylabel("Phase (Degree)")
phase.plot(data_freq, data_phase, 'r.-')

# Show the data
plt.show()

Result

Introduction

Today, we will build a transistor curve tracer using Box0.
We will give current in Base, and read the current throught collector to emitter At a given voltage on collector.

Connection

Code

import box0
import numpy as np
import matplotlib.pyplot as plt

# some constant
RESISTANCE_BASE = 100e3
RESISTANCE_COLLECTOR = 330

# allocate the appropriate resources
dev = box0.usb.open_supported()
ain0 = dev.ain(0)
aout0 = dev.aout(0)

# prepare the resources

ain0.static_prepare()
ain0.chan_seq.current = [0, 1, 2, 3]
ain0.speed.current = 100000 # 100KSPS
ain0.bitsize.current = 12

aout0.static_prepare()
aout0.chan_seq.current = [0, 1]
aout0.speed.current = 100000 # 100KSPS
aout0.bitsize.current = 12

def set_voltage(ch0, ch1):
    """Set voltage on AOUT0 pin"""
    global aout0

    # try to stop aout0 (from previous start)
    try: aout0.static_stop()
    except: pass

    data = np.array([ch0, ch1])
    aout0.static_start(data)

def get_voltage():
    """Get voltage on AIN0 pin"""
    global ain0

    data = np.empty(1000)
    ain0.static_start(data)

    ch0 = np.mean(data[0::4])
    ch1 = np.mean(data[1::4])
    ch2 = np.mean(data[2::4])
    ch3 = np.mean(data[3::4])

    return ch0, ch1, ch2, ch3

def pretty_title_from_base_current(value):
    """return a pretty title using base input current"""
    prefix = ""
    if value < 1e-3:
        prefix = "$\mu$"
        value *= 1e6
    elif base_current < 1:
        prefix = "m"
        value *= 1e3
    return r&apos;$I_{b}$ = %.3f%sA&apos; % (value, prefix)

colors = [&apos;#ff7f0e&apos;, &apos;#2ca02c&apos;, &apos;#d62728&apos;, &apos;#7f7f7f&apos;, &apos;#9467bd&apos;, &apos;#8c564b&apos;]
for aout0_ch0 in [0.4, 0.7, 0.9, 1.1, 1.3, 1.5]:
    arr_current_base = []
    arr_curent_collector = []
    arr_voltage_collector_emitter = []

    for aout0_ch1 in np.arange(0, 3, 0.05):
        # set the values
        set_voltage(aout0_ch0, aout0_ch1)

        # get the values
        ain0_ch0, ain0_ch1, ain0_ch2, ain0_ch3 = get_voltage()

        # do the calculation
        current_base = (ain0_ch0 - ain0_ch2) / RESISTANCE_BASE
        curent_collector = (ain0_ch1 - ain0_ch3) / RESISTANCE_COLLECTOR
        voltage_collector_emitter = ain0_ch3

        # append to list
        arr_current_base.append(current_base)
        arr_curent_collector.append(curent_collector)
        arr_voltage_collector_emitter.append(voltage_collector_emitter)

    # plot it
    title = pretty_title_from_base_current(np.mean(arr_current_base))
    color = colors.pop(0)
    arr_curent_collector = [x * 1e3 for x in arr_curent_collector] # to mA
    line = plt.plot(arr_voltage_collector_emitter, arr_curent_collector, label=title, color=color, linewidth=2)
    plt.text(arr_voltage_collector_emitter[-1], arr_curent_collector[-1], title, fontsize=13, color=color)

# try to stop aout0 (from previous start)
try: aout0.static_stop()
except: pass

# close the resources
ain0.close()
aout0.close()
dev.close()

#plt.legend()
plt.grid(True)
plt.xlabel(r"$V_{ce}$ (V)")
plt.ylabel(r"$I_{c}$ (mA)")
plt.show()

Output

Introduction

Today we will make a REST server using Node.js.
For this tutorial, it is assume that you are familiar Node.js & Express

API

URL: /
Method: GET
Response: {"name":"Box0","manuf":"Mad Resistor","serial":"A2005400E015843503134302"}

URL: /dio/0
Method: GET
Success Response: {"name":"DIO0","count":8,"ref":{"low":"0.000000","high":"3.300000"}}

URL: /dio/0/:pin
Method: GET
Success Response: {"pin":0,"name":"0","value":"low","dir":"input","hiz":"enabled"}

URL: /dio/0/:pin/value
Method: GET
Success Response: {"pin":0,"value":"low"}

URL: /dio/0/:pin/value/:value
Method: GET
Note: :value can be low or high
Success Response: {"pin":0}

URL: /dio/0/:pin/toggle
Method: GET
Success Response: {"pin":0}
Note: Should only be called when pin is in output direction

URL: /dio/0/:pin/dir
Method: GET
Success Response: {"pin":0,"dir":"input"}

URL: /dio/0/:pin/dir/:value
Method: GET
Note: :value can be input or output
Success Response: {"pin":0}

URL: /dio/0/:pin/hiz
Method: GET
Success Response: {"pin":0,"hiz":"enabled"}

URL: /dio/0/:pin/hiz/:value
Method: GET
Note: :value can be enable or disable
Success Response: {"pin":0}

Common Error Response:

• Device related problem (example: communication)
  Code: 500 Internal Server Error
  Type: text/plain
  Content: B0_ERR_IO: Device I/O error
• Invalid argument
  Code: 400 Bad Request
  Type: text/plain
  Content: Invalid pin "a"

Code

"use strict";

var express = require('express')
var box0 = require('box0')
var util = require('util')

var dev = box0.usb.open_supported()
var dio0 = dev.dio()

var app = express()

function invalid_arg(res, msg) {
    res.set('Content-Type', 'text/plain')
    res.status(400).send(msg)
}

function handle_exception(res, cb) {
    try {
        cb();
    } catch (e) {
        res.set('Content-Type', 'text/plain')
        res.status(500).send(e.message)
    }
}

app.get('/', function (req, res) {
    res.json({
        name: dev.name,
        manuf: dev.manuf,
        serial: dev.serial
    })
})

app.get('/dio/0', function (req, res) {
    var low = dio0.ref.low.toFixed(6)
    var high = dio0.ref.high.toFixed(6)

    res.json({
        name: dio0.header.name,
        count: dio0.count.value,
        ref: {low, high}
    })
})

app.param('pin', function(req, res, next, pin) {
    var pin_value = parseInt(pin)
    if (pin_value >= 0 && pin_value < dio0.count.value) {
        req.pin = pin_value
        next()
        return
    }

    invalid_arg(res, util.format(&apos;Invalid pin "%s"&apos;, pin))
})

app.get(&apos;/dio/0/:pin&apos;, function (req, res) {
    handle_exception(res, function () {
        var pin = req.pin
        var name = (pin < dio0.label.values.length) ?
                dio0.label.values[pin] : &apos;CH&apos; + pin

        var value = dio0.value_get(pin)
        var dir = dio0.dir_get(pin)
        var hiz = dio0.hiz_get(pin)

        value = {true: &apos;high&apos;, false: &apos;low&apos;}[value]
        dir = {true: &apos;output&apos;, false: &apos;input&apos;}[dir]
        hiz = {true: &apos;enabled&apos;, false: &apos;disabled&apos;}[hiz]

        res.json({pin, name, value, dir, hiz})
    })
})

app.get(&apos;/dio/0/:pin/value&apos;, function (req, res) {
    handle_exception(res, function () {
        var pin = req.pin
        var value = dio0.value_get(pin)
        value = {true: &apos;high&apos;, false: &apos;low&apos;}[value]
        res.json({pin, value})
    })
})

app.get(&apos;/dio/0/:pin/dir&apos;, function (req, res) {
    handle_exception(res, function () {
        var pin = req.pin
        var dir = dio0.dir_get(pin)
        dir = {true: &apos;output&apos;, false: &apos;input&apos;}[dir]
        res.json({pin, dir})
    })
})

app.get(&apos;/dio/0/:pin/hiz&apos;, function (req, res) {
    handle_exception(res, function () {
        var pin = req.pin
        var hiz = dio0.hiz_get(pin)
        hiz = {true: &apos;enabled&apos;, false: &apos;disabled&apos;}[hiz]
        res.json({pin, hiz})
    })
})

app.get(&apos;/dio/0/:pin/toggle&apos;, function (req, res) {
    handle_exception(res, function () {
        var pin = req.pin
        dio0.value_toggle(pin)
        res.json({pin})
    })
})

app.get(&apos;/dio/0/:pin/value/:value&apos;, function (req, res) {
    var pin = req.pin
    var value = String(req.params.value).toLowerCase()
    value = {&apos;high&apos;: true, &apos;low&apos;: false}[value]

    if (value === undefined) {
        var msg = util.format(&apos;Invalid value "%s"&apos;, req.params.value)
        return invalid_arg(res, msg)
    }

    handle_exception(res, function () {
        dio0.value_set(pin, value)
        res.json({pin})
    })
})

app.get(&apos;/dio/0/:pin/dir/:value&apos;, function (req, res) {
    var pin = req.pin
    var value = String(req.params.value).toLowerCase()
    value = {&apos;output&apos;: true, &apos;input&apos;: false}[value]

    if (value === undefined) {
        var msg = util.format(&apos;Invalid value "%s"&apos;, req.params.value)
        return invalid_arg(res, msg)
    }

    handle_exception(res, function () {
        dio0.dir_set(pin, value)
        res.json({pin})
    })
})

app.get(&apos;/dio/0/:pin/hiz/:value&apos;, function (req, res) {
    var pin = req.pin
    var value = String(req.params.value).toLowerCase()
    value = {&apos;enable&apos;: true, &apos;disable&apos;: false}[value]

    if (value === undefined) {
        var msg = util.format(&apos;Invalid value "%s"&apos;, req.params.value)
        return invalid_arg(res, msg)
    }

    handle_exception(res, function () {
        dio0.hiz_set(pin, value)
        res.json({pin})
    })
})

app.listen(3000, function () {
    console.log(&apos;Listening on port 3000!&apos;)
})

process.on(&apos;SIGINT&apos;, function() {
    console.log("\nGracefully shutting down from SIGINT (Ctrl+C)")
    dio0.close()
    dev.close()
    process.exit(1)
})

Interacting

You can use your Internet Browser / telnet to interact with the REST server.

Get device information

Request: GET /
Response: {"name":"Box0","manuf":"Mad Resistor","serial":"A2005400E015843503134302"}

Get DIO0 module information

Request: GET /dio/0
Response: {"name":"DIO0","count":8,"ref":{"low":"0.000000","high":"3.300000"}}

There are 8 pins for this device with low voltage 0V and high voltage 3.3V
You can reference 8 pins via 0, 1, 2, ... 7

Turn On LED on pin number 3

Requests:

1. GET /dio/0/3/dir/output
2. GET /dio/0/3/value/high
3. GET /dio/0/3/hiz/disable

Your led will blink

Reading from pin 4

Requests:

1. GET /dio/0/4/dir/input
2. GET /dio/0/4/hiz/disable
3. GET /dio/0/4/value

Resonse (from 3rd query): {"pin":4,"value":"low"}
This tells that pin 4 is LOW.

Toggle pin 3 value

Requests:

1. GET /dio/0/3/dir/output
2. GET /dio/0/3/value/low
3. GET /dio/0/3/hiz/disable
4. GET /dio/0/3/toggle
5. GET /dio/0/3/toggle
6. GET /dio/0/3/toggle

and continue toggling it!

Everybody and their cat, is showing their graph.
But, do you know how much CPU does it take for interaction and plotting?
NO! static images do not convey the information of interaction and plotting lag.

Initally, we started with PyQtGraph (Python)
It does all the stuff for quick and easy plotting with good results.

Then,
After being more productive with C than Python + good result comming with it.
We switched to C for developement (and C++ due to Qt).
Started writing software in Qt5 (with QCustomPlot).
QCustomplot was ok but had performance problem and memory wastage problem.
Then, We switched to Qwt and used for a long time.

Also,
Since Qwt had OpenGL support, we gave it a try.
result: no practical gain.
Qwt was the best library that work was working (though with some lags).

Alternatively,
I tried Vispy (though Python test program) in between but it had problem.
Sometime back tried PyQtGraph (again), i just discovered that PyQtGraph (on Qt5) is slow than (on Qt4).

Finally,
I was a corner cat.
I had to write a plotting library.
Requirement:

• Use GPU
• Do not abtract the GPU
• Work with OpenGL and OpenGLES
• No specific to any GUI Toolkit
• Written in a language that can be used for multiple platform (C)
• No Lag

Initally, A plotting code was designed for Android using GPU.
(using the code, achieved: less cpu usage [power saving], effecient and lag free)
The Android code was ported to desktop (but didnt work properly).
Then, I wrote libreplot (reusing code from the android code)

libreplot would have never been possible without OpenGL Scientific Arch on Wikibooks.
Some of the code is adapted from the Wikibook OpenGL Programming project.

We use it for everything.
This includes

• Box0 Studio for Desktop
• LiaB Studio for Desktop
• Box0 Studio for Android
• LiaB Studio for Android

We pushed plotting on Desktop and Android to another limit.

Note: as of 18 April 2016, libreplot only support 2D cartesian plot.
Note: libreplot can be used on any platform that support OpenGL(ES).

Introduction

We will draw I-V characteristics of thee led (Red, Green, Blue) on one graph.
The three led’s have different behaviour at different voltage and we can clearly see that on the graph.

Connections

Code

import box0
import numpy as np
import matplotlib.pyplot as plt

# allocate the appropriate resources
dev = box0.usb.open_supported()
ain0 = dev.ain()
aout0 = dev.aout()

# prepare AIN0
ain0.static_prepare()
ain0.chan_seq.current = [0, 1, 2, 3]
ain0.speed.current = 100000

# prepare AOUT0
aout0.static_prepare()

# generate voltage, read voltage, calculate current and store the result
# AIN0.CH0 = Voltage across Red led
# AIN0.CH1 = Voltage across Green led
# AIN0.CH2 = Voltage across Blue led
# AIN0.CH3 = AOUT0.CH0 = generated signal
# current across LED  = (AIN0.CH3 - AIN0.CHi) / Ri

SAMPLES = 100

red_res = 330.0
red_x = np.empty(SAMPLES)
red_y = np.empty(SAMPLES)

green_res = 330.0
green_x = np.empty(SAMPLES)
green_y = np.empty(SAMPLES)

blue_res = 120.0
blue_x = np.empty(SAMPLES)
blue_y = np.empty(SAMPLES)

voltages = np.linspace(0.0, 3.3, SAMPLES)
aout0_running = False

for i in range(SAMPLES):
    if aout0_running:
        aout0.static_stop()

    # output "v" value on AOUT0.CH0
    aout0.static_start(voltages[i:(i+1)])
    aout0_running = True

    # read back AIN0.CH0 and AIN0.CH1
    readed_data = np.empty(1000)
    ain0.static_start(readed_data)

    # do the calculation
    ch0 = np.mean(readed_data[0::4])
    ch1 = np.mean(readed_data[1::4])
    ch2 = np.mean(readed_data[2::4])
    ch3 = np.mean(readed_data[3::4])

    # store the result
    red_x[i] = ch0
    red_y[i] = (ch3 - ch0) / red_res
    green_x[i] = ch1
    green_y[i] = (ch3 - ch1) / green_res
    blue_x[i] = ch2
    blue_y[i] = (ch3 - ch2) / blue_res

# stop if AOUT0 running
if aout0_running:
    aout0.static_stop()

# close the resources
ain0.close()
aout0.close()
dev.close()

# A to mA
red_y *= 1000.0
green_y *= 1000.0
blue_y *= 1000.0

# now, plot the data
plt.xlabel('Voltage (V)')
plt.ylabel('Current (mA)')
plt.grid(True)
plt.plot(red_x, red_y, 'r-', green_x, green_y, 'g-', blue_x, blue_y, 'b-', linewidth=1.5)
plt.show()

Conclusion

You can clearly see the behaviour at increasing voltage.

First RED bias then, Green and then Blue.

In this tutorial, I will show you 5 working “Hello World” example for Box0.

Purpose

All the 5 example does one thing.
Collect 100 samples from AIN0.CH0 at 100KSPS and 12bit in static mode.

Code

Python

• Speciality:
• Easy
• Beginner Friendly
• Widely Used in Science & Enginnering
• Well Known
• Lots of community support

Python support is provided by pyBox0

import box0
import numpy as np

dev = box0.usb.open_supported()
ain = dev.ain()

ain.static_prepare()
ain.speed.current = 100000 # 100KSPS
ain.bitsize.current = 12 # 12bit

values = np.empty(100)
ain.static_start(values)
print("collected data", values)

ain.close()
dev.close()

Julia

• Speciality:
• Powerful
• Effecient
• Designed for Scientific Computing

Julia support is provided by Box0.jl

using Box0

dev = Box0.Usb.open_supported()
ain = Box0.ain(dev)

Box0.static_prepare(ain)
Box0.set(Box0.speed(ain), 100000)
Box0.set(Box0.bitsize(ain), 12)

data = Array{Float32}(100)
Box0.static_start(ain, data)

println("collected data ", data)

Box0.close(ain)
Box0.close(dev)

Java (and Android)

Speciality:

• Widely used in “Industry”
• Well Know

Java/Android support is provided by jBox0

import com.madresistor.box0.Device;
import com.madresistor.box0.backend.Usb;
import com.madresistor.box0.ResultException;
import com.madresistor.box0.module.Ain;

class java
{
    public static void main(String[] args) {
        double[] data = new double[100];
        Device dev = null;
        Ain ain = null;

        try {
            dev = Usb.openSupported();
            ain = dev.ain(0);

            ain.staticPrepare();
            ain.speed.set((short)12);
            ain.speed.set((long)100000);
            ain.staticStart(data);
        } catch(ResultException e) {
            System.out.println("error:" + e.toString() + "|" + e.explain());
            return;
        }

        System.out.print("collected data");
        for(double value : data) {
            System.out.print(" " + value);
        }
        System.out.println();

        try {
            ain.close();
            dev.close();
        } catch(ResultException e) {
            System.out.println("error:" + e.toString() + "|" + e.explain());
        }
    }
}

Javascript (using NodeJs)

Speciality:

• Used in Browser (Client Side)
• Well Know between Web development

Note: Using NodeJS, Javscript is run on Server side

NodeJS support is provided by node-box0

var box0 = require("box0")

var dev = box0.usb.open_supported()
var ain = dev.ain()

ain.static_prepare()
ain.speed.set(100000)
ain.bitsize.set(12)

var data = new Float32Array(100)
ain.static_start(data)
console.log("collected data " + data)

ain.close()
dev.close()

C

• Speciality:
• Widely know
• All of the above langauges have atleast some part written in C
• Run on all platform
• Lots of work done

(The same code will work C++ too)

C/C++ support is provided by libbox0

#include <libbox0/libbox0.h>
#include <libbox0/backend/usb/usb.h>
#include <stdio.h>

#define DATA_COUNT 1000

int main(int argc, char *argv[])
{
    b0_device *dev;
    b0_ain *ain;
    float data[DATA_COUNT];

    if (B0_ERR_RC(b0_usb_open_supported(&dev))) {
        fprintf(stderr, "Unable to open device");
        goto done;
    }

    if (B0_ERR_RC(b0_ain_open(dev, &ain, 0))) {
        fprintf(stderr, "Unable to open device");
        goto close_device;
    }

    if (B0_ERR_RC(b0_ain_static_prepare(ain))) {
        fprintf(stderr, "Unable to prepare module for static mode");
        goto close_module;
    }

    if (B0_ERR_RC(b0_speed_set(ain->speed, 100000))) {
        fprintf(stderr, "Unable to set speed");
        goto close_module;
    }

    if (B0_ERR_RC(b0_bitsize_set(ain->bitsize, 12))) {
        fprintf(stderr, "Unable to set speed");
        goto close_module;
    }

    if (B0_ERR_RC(b0_ain_static_start_float(ain, data, DATA_COUNT))) {
        fprintf(stderr, "Unable to start");
        goto close_module;
    }

    printf("collected data");
    for (size_t i = 0; i < DATA_COUNT; i++) {
        printf(" %f", data[i]);
    }
    putchar(&apos;\n&apos;);

    close_module:
    if (B0_ERR_RC(b0_ain_close(ain))) {
        fprintf(stderr, "problem closing module");
    }

    close_device:
    if (B0_ERR_RC(b0_device_close(dev))) {
        fprintf(stderr, "problem closing device");
    }

    done:
    return 0;
}

Output

Above example will print something like (Python in the below case)

collected data [-0.06606445 -0.06606445 -0.06606445 -0.06606445 -0.06606445 -0.06767578
 -0.06928711 -0.06928711 -0.06767578 -0.06928711 -0.06767578 -0.06928711
 -0.06928711 -0.06928711 -0.06928711 -0.07089844 -0.06928711 -0.06928711
 -0.07089844 -0.06928711 -0.07089844 -0.07089844 -0.07089844 -0.07089844
 -0.07250976 -0.07089844 -0.07250976 -0.07250976 -0.07250976 -0.07089844
 -0.07250976 -0.07250976 -0.07412109 -0.07412109 -0.07250976 -0.07412109
 -0.07250976 -0.07250976 -0.07412109 -0.07412109 -0.07573242 -0.07573242
 -0.07573242 -0.07573242 -0.07573242 -0.07412109 -0.07573242 -0.07734375
 -0.07573242 -0.07573242 -0.07734375 -0.07573242 -0.07734375 -0.07734375
 -0.07573242 -0.07734375 -0.07895508 -0.07734375 -0.07895508 -0.07895508
 -0.07895508 -0.07895508 -0.07895508 -0.07734375 -0.07895508 -0.08056641
 -0.08056641 -0.08217773 -0.08217773 -0.08056641 -0.08056641 -0.08056641
 -0.08056641 -0.08217773 -0.08217773 -0.08217773 -0.08217773 -0.08378906
 -0.08217773 -0.08378906 -0.08378906 -0.08217773 -0.08540039 -0.08378906
 -0.08540039 -0.08540039 -0.08540039 -0.08540039 -0.08540039 -0.08540039
 -0.08540039 -0.08701172 -0.08701172 -0.08701172 -0.08862305 -0.08701172
 -0.08701172 -0.08701172 -0.08540039 -0.08701172]

Hope you liked the code dump!

Not happy because you favourite language not listed?
No problem! you can write libbox0 binding for your favourite language.
Tip: libbox0 is written in C and you will probebly find a Foreign Function Interfacing module/library for your favourite language.