ADPi
・ 弊社 GitHub ページ
・ SPIを用いたラズベリーパイ用高精度A/D変換モジュール「ADPi Pro」のセットアップ
・ IIOサブシステムを用いたラズベリーパイ用高精度A/D変換モジュール「ADPi Pro」のセットアップ

slee-Pi3
・ 弊社 GitHub ページ
・ ラズベリーパイ用電源管理/死活監視モジュール「slee-Pi3」のセットアップ

#!/usr/bin/python3

import spidev
import smbus
import adpi
import sys
from time import sleep
import time
import pandas as pd

RAW_OFFSET = (1 << 23)
RAW_SCALE = (
        0.000596040,
        0.000298020,
        0.000149010,
        0.000074500,
        0.000037250,
        0.000018620,
        0.000009310,
        0.000004650,
        )
TEMP_VREF = 1.17


def v2k(rate, val):
    for k, v in rate.items():
        if v == val:
            return k


def continuous_setting(dev, ch):
    c = dev.adc.channel[ch]
    g, _ = dev.read_configuration()
    dev.write_configuration(g, c)
    _, r = dev.read_mode()
    dev.write_mode(dev.adc.mode['continuous'], r)
    rate = v2k(dev.adc.rate, r)
    return g, rate


def set_calib(dev):
    g = dev.adc.gain['1']
    r = dev.adc.rate['470']
    bias = dev.load_bias(g)
    scale = dev.load_scale(g)
    _, r = dev.read_mode()
    for i in range(dev.channels):
        dev.write_configuration(g, i)
        dev.write_mode(dev.adc.mode['idle'], r)
        dev.write_offset(bias[i])
        dev.write_mode(dev.adc.mode['idle'], r)
        dev.write_fullscale(scale[i])


if __name__ == "__main__":
    spibus = 0
    spics = 0
    eeprombus = 1
    eepromaddr = 0x57
    gpiobus = 1
    gpioaddr = 0x27
    spi = spidev.SpiDev()
    i2c = smbus.SMBus(eeprombus)

    try:
        spi.open(spibus, spics)
        spi.mode = 0b11
        spi.max_speed_hz = 1000000

        ad = adpi.ADPiPro(spi, i2c, eepromaddr, gpioaddr)
        set_calib(ad)
        sleep(0.5)

        ch = '1'
        runs = 100000
        voltages = [0] * runs
        timestamps = [0] * runs

        g, rate = continuous_setting(ad, ch)
        sleep(0.5)

        for i in range(runs):
            while True:
                if not ad.read_status() & 0x80:
                    break

            raw = ad.read_data()
            voltages[i] = RAW_SCALE[g] * (raw - RAW_OFFSET)
            timestamps[i] = time.time()

        intervals = [timestamps[i] - timestamps[i-1] for i in range(1, len(timestamps))]

        df_intervals = pd.DataFrame(intervals)
        df_voltages = pd.DataFrame(voltages)

        pd.options.display.float_format = '{:.6f}'.format

        print(f"Interval\n{df_intervals.describe()}\n")
        print(f"Voltage\n{df_voltages.describe()}")

    except (IndexError, ValueError):
        sys.exit(2)
    finally:
        spi.close()

#!/bin/bash
set -e

IIO_NAME=iio:device0
SPI_NAME=$(find /sys/bus/spi/devices/spi*/ -name "$IIO_NAME" | grep -o -E "spi[0-9]+\.[0-9]+")
SPI_ADDR=$(echo $SPI_NAME | cut -d= -f2)
IIO_PATH=$(find /sys/bus/spi/devices/${SPI_ADDR}/iio:device* -maxdepth 0)

INDEX_OFFSET=-1
CHANNEL=$((1 + $INDEX_OFFSET))
DUMP_FILE=/home/mtx/iio_dump_data
RUNS=100000

function start_buffering() {
  echo 1 | tee $IIO_PATH/scan_elements/in_voltage$1-voltage$1_en >/dev/null
  echo 1 | tee $IIO_PATH/scan_elements/in_timestamp_en >/dev/null
  echo 1 | tee $IIO_PATH/buffer/enable >/dev/null
}

function stop_buffering() {
  echo 0 | tee $IIO_PATH/buffer/enable >/dev/null
  echo 0 | tee $IIO_PATH/scan_elements/in_voltage$1-voltage$1_en >/dev/null
}

function run_hexdump() {
  start_buffering $CHANNEL

  hexdump -C "/dev/$IIO_NAME" > "$DUMP_FILE" &
  HEXDUMP_PID=$!

  while [ $(wc -l "$DUMP_FILE" | awk '{print $1}') -lt "$RUNS" ]
  do
    continue
  done

  kill "$HEXDUMP_PID" || true
  wait "$HEXDUMP_PID" || true
  stop_buffering $CHANNEL
}

run_hexdump
python3 ./calc_statistics.py $CHANNEL $IIO_NAME $SPI_NAME $DUMP_FILE $RUNS

#!/usr/bin/env python3

import sys
import pandas as pd

def read_file(file_path):
    with open(file_path, 'r') as f:
        return f.read().strip()

def main(channel, iio_name, spi_name, dump_file, runs):
    base_path = f"/sys/bus/spi/devices/{spi_name}/{iio_name}"
    scale_path = f"{base_path}/in_voltage-voltage_scale"
    offset_path = f"{base_path}/in_voltage{channel}-voltage{channel}_offset"

    RAW_OFFSET = int(read_file(offset_path))
    RAW_SCALE = float(read_file(scale_path))

    data_hexes = []
    timestamp_hexes = []

    with open(dump_file, "r") as file:
        for line in file:
            data_hex = line[13:21].replace(" ", "")
            timestamp_hex = line[35:58].replace(" ", "")
            data_hexes.append(data_hex)
            timestamp_hexes.append(timestamp_hex)

    voltages = []
    for data_hex in data_hexes:
        data = int(data_hex, 16)
        voltage = RAW_SCALE * (data + RAW_OFFSET)
        voltages.append(voltage)

    timestamps = []
    for timestamp_hex in timestamp_hexes:
        timestamp_be = "".join(reversed([timestamp_hex[i:i+2] for i in range(0, len(timestamp_hex), 2)]))
        timestamp_ns = int(timestamp_be, 16)
        timestamps.append(timestamp_ns)

    voltages = voltages[-runs:]
    timestamps = timestamps[-runs:]

    intervals = [(timestamps[i] - timestamps[i-1]) / 1e9 for i in range(1, len(timestamps))]

    df_intervals = pd.DataFrame(intervals)
    df_voltages = pd.DataFrame(voltages)

    pd.options.display.float_format = '{:.6f}'.format

    print(f"Interval\n{df_intervals.describe()}\n")
    print(f"Voltage\n{df_voltages.describe()}")

if __name__ == "__main__":
    if len(sys.argv) < 5:
        print("Usage: calc_statistics.py <CHANNEL> <IIO_NAME> <SPI_NAME> <DUMP_FILE> <RUNS>")
        sys.exit(1)

    channel = sys.argv[1]
    iio_name = sys.argv[2]
    spi_name = sys.argv[3]
    dump_file = sys.argv[4]
    runs = int(sys.argv[5])

    main(channel, iio_name, spi_name, dump_file, runs)