Hardware & Pi Setup Guide

import time
import board
import adafruit_nau7802

i2c = board.I2C()  # SDA=GPIO2, SCL=GPIO3
nau = adafruit_nau7802.NAU7802(i2c)
nau.gain = 128

SCALE_FACTOR = 2280  # From calibration
OFFSET = 0
TARGET_WEIGHT = 15.0  # grams
TOLERANCE = 1.0

def get_weight(samples=5):
    readings = [nau.read() for _ in range(samples)]
    raw = sum(readings) / len(readings)
    return (raw - OFFSET) / SCALE_FACTOR

def monitor_scoop():
    """Beep when scoop reaches target weight."""
    while True:
        weight = get_weight(5)
        if abs(weight - TARGET_WEIGHT) < TOLERANCE:
            buzz(0.5)  # 500ms beep
            log_sample(weight, time.time())
        time.sleep(0.2)

import spidev
import numpy as np

spi = spidev.SpiDev()
spi.open(0, 0)
spi.max_speed_hz = 1000000

def run_swv(start_v=-0.2, end_v=0.8, step=0.004,
            amplitude=0.025, freq=25):
    """Square Wave Voltammetry scan."""
    voltages = np.arange(start_v, end_v, step)
    currents = []

    for v in voltages:
        # Apply forward pulse (v + amplitude)
        set_dac_voltage(v + amplitude)
        time.sleep(1 / (2 * freq))
        i_forward = read_adc_current()

        # Apply reverse pulse (v - amplitude)
        set_dac_voltage(v - amplitude)
        time.sleep(1 / (2 * freq))
        i_reverse = read_adc_current()

        currents.append(i_forward - i_reverse)

    return voltages, np.array(currents)

def measure_gold_concentration(voltages, currents):
    """Find gold peak and convert to concentration."""
    # Gold peak expected at +0.4 to +0.6V
    mask = (voltages >= 0.35) & (voltages <= 0.65)
    peak_current = currents[mask].max()

    # Apply calibration: concentration = a * peak_current + b
    concentration_ppm = (
        CALIB_SLOPE * peak_current + CALIB_INTERCEPT
    )
    return max(0, concentration_ppm)

import sounddevice as sd
import numpy as np
import tflite_runtime.interpreter as tflite

interpreter = tflite.Interpreter(
    model_path="engine_classifier.tflite"
)
interpreter.allocate_tensors()

def classify_audio(device_id, duration=1.0, sr=16000):
    """Classify engine state from audio."""
    audio = sd.rec(
        int(duration * sr), samplerate=sr,
        channels=1, device=device_id, dtype='float32'
    )
    sd.wait()

    # Extract MFCC features
    mfccs = extract_mfcc(audio.flatten(), sr, n_mfcc=13)

    # Run inference
    input_details = interpreter.get_input_details()
    interpreter.set_tensor(
        input_details[0]['index'],
        mfccs.reshape(1, -1, 13).astype(np.float32)
    )
    interpreter.invoke()

    output = interpreter.get_tensor(
        interpreter.get_output_details()[0]['index']
    )

    states = ['off', 'idle', 'running']
    return states[np.argmax(output)]

import json
import hashlib
import requests
from cryptography.hazmat.primitives.asymmetric.ed25519 \
    import Ed25519PrivateKey

def sign_daily_report(data: dict,
                      private_key: Ed25519PrivateKey):
    """Sign daily report for tamper-proof custody."""
    payload = json.dumps(
        data, sort_keys=True
    ).encode()
    signature = private_key.sign(payload)

    return {
        'data': data,
        'signature': signature.hex(),
        'hash': hashlib.sha256(payload).hexdigest(),
        'prev_hash': get_previous_day_hash(),
    }

def sync_to_cloud(report):
    """Sync signed report when connectivity available."""
    try:
        response = requests.post(
            'https://api.mineguard.app/reports',
            json=report, timeout=30
        )
        if response.ok:
            mark_synced(report['data']['date'])
    except requests.ConnectionError:
        pass  # Will retry next sync cycle