Monitor a machine with a Pico W

You’ll build a device on a Raspberry Pi Pico W that watches a machine: the agent can read its sensors and trip an emergency-stop relay, and the board itself fires vibration_anomaly when readings cross a threshold, which a handler on the platform stores and hands to the model. You need a Pico W set up as in Run a device on a Raspberry Pi Pico W, an analog vibration sensor on GP26, a temperature sensor on GP27, and a relay on GP16; without sensors the code still runs with noise readings. Verified against lua-cli 3.45.0.

What you’ll build

A MicroPython device cnc-monitor-01 with read_vibration, read_temperature, and emergency_stop.
A main loop that polls, heartbeats, and fires vibration_anomaly every 10 seconds when needed.
A defineDeviceTrigger handler that stores the event and invokes the agent.

Create the credential

From the agent project, issue a device credential for device name cnc-monitor-01; the default operations, commands and triggers, are what the monitor needs. Copy LUA_AGENT_ID and LUA_DEVICE_CREDENTIAL from the file into config.py on the board together with the Wi-Fi settings, as in the Pico W tutorial.

mkdir -p ../cnc-monitor
lua devices credential --device-name cnc-monitor-01 --out ../cnc-monitor/.env.device

Write main.py

The loop mirrors what run() does, so the periodic anomaly check can sit beside command polling: poll messages, heartbeat every 30 seconds, prune the duplicate cache, reconnect on any error. It reaches into the client’s underscore-prefixed members, which a later client version may rename.

main.py

import machine
import time

import config
from lua_device import LuaDevice

vibration_adc = machine.ADC(machine.Pin(26))
temperature_adc = machine.ADC(machine.Pin(27))
estop_relay = machine.Pin(16, machine.Pin.OUT, value=0)
status_led = machine.Pin("LED", machine.Pin.OUT)

VIBRATION_THRESHOLD_G = 3.0


def vibration_g():
    return round(vibration_adc.read_u16() / 65535 * 4.0, 3)  # 0 to 4 g


def bearing_celsius():
    return round(temperature_adc.read_u16() / 65535 * 150.0, 1)  # 0 to 150 C


device = LuaDevice(
    agent_id=config.AGENT_ID,
    api_key=config.DEVICE_CREDENTIAL,
    device_name="cnc-monitor-01",
    wifi_ssid=config.WIFI_SSID,
    wifi_password=config.WIFI_PASSWORD,
    group="factory-floor",
)


@device.command("read_vibration", description="Read the machine vibration in g; above 3 g is abnormal")
def read_vibration(payload):
    return {"amplitude_g": vibration_g()}


@device.command("read_temperature", description="Read the bearing temperature in celsius; above 80 C is critical")
def read_temperature(payload):
    return {"temperature": bearing_celsius(), "unit": "celsius"}


@device.command(
    "emergency_stop",
    description="Trip the emergency-stop relay. Only when the operator asks or a reading is critical.",
    inputSchema={"type": "object", "properties": {"reason": {"type": "string", "maxLength": 120}}},
)
def emergency_stop(payload):
    estop_relay.value(1)
    return {"activated": True, "reason": str(payload.get("reason", "requested"))[:120]}


device.connect()
status_led.value(1)
last_check = time.time()

while True:
    try:
        device._client.check_msg()
        now = time.time()
        if now - device._last_heartbeat >= device._heartbeat_interval:
            device._client.publish(device._topic_prefix + "heartbeat", b"", qos=0)
            device._last_heartbeat = now
        if now - last_check >= 10:
            amplitude = vibration_g()
            if amplitude > VIBRATION_THRESHOLD_G:
                device.trigger("vibration_anomaly", {
                    "amplitude_g": amplitude,
                    "threshold_g": VIBRATION_THRESHOLD_G,
                    "machine": "CNC-Mill-04",
                })
            last_check = now
        if len(device._seen_ids) > 100:
            device._clean_dedup()
        time.sleep_ms(100)
    except Exception as exc:
        print("connection lost:", exc)
        status_led.value(0)
        device._reconnect()
        status_led.value(1)

emergency_stop trips the relay whenever the agent calls it, from any channel the agent is connected to; the description and persona steer the model but don’t gate the call. Add a hardware or firmware interlock if a wrong call is dangerous.

Handle the trigger on the agent

The handler stores every anomaly and asks the model to assess it; device.name identifies the board.

src/devices/VibrationAnomaly.ts

import { Agents, Data, defineDeviceTrigger } from 'lua-cli';
import { z } from 'zod';

// From lua.skill.yaml; env() is empty inside device-trigger handlers.
const AGENT_ID = 'agent_abc123';

export const vibrationAnomaly = defineDeviceTrigger({
  name: 'vibration_anomaly',
  description: 'A machine monitor reports vibration above its threshold',
  payloadSchema: z.object({ amplitude_g: z.number(), threshold_g: z.number(), machine: z.string() }),
  async execute(payload, { device }) {
    await Data.create('vibration-anomalies', { device: device.name, ...payload, at: Date.now() });
    const severity = payload.amplitude_g > payload.threshold_g * 1.5 ? 'critical' : 'warning';
    await Agents.invoke(
      AGENT_ID,
      `${severity}: ${payload.machine} on ${device.name} vibrates at ${payload.amplitude_g} g (threshold ${payload.threshold_g} g). Read its temperature and advise.`
    );
  },
});

src/index.ts

import { LuaAgent } from 'lua-cli';
import { vibrationAnomaly } from './devices/VibrationAnomaly';

export default new LuaAgent({
  name: 'factory-monitor',
  persona: 'You help machine operators. Report readings precisely and recommend an emergency stop only for critical readings.',
  deviceTriggers: [vibrationAnomaly],
});

lua push device-trigger --name vibration_anomaly --auto-deploy

Run and verify

Copy main.py to the board and start it, then read the sensors from chat and watch for the trigger.

mpremote cp main.py :main.py && mpremote run main.py
lua chat -m "What are the vibration and bearing temperature on cnc-monitor-01?"
lua logs --type device-trigger --limit 10

Tap the vibration sensor hard enough to cross 3 g: within 10 seconds the board fires the trigger and the log shows the handler’s run.

What you learned

trigger() on MicroPython returns at once; the acknowledgment arrives on the trigger_ack topic and is printed. See MicroPython device client.
A standalone defineDeviceTrigger matches the name exactly and runs with { device: { name } }. See Handle device triggers.
Triggers are limited to 10 per second per agent, so sample on an interval rather than on every reading. See Reliability and limits.

Get started

Concepts

Build

Channels

Integrations

Devices

Ship and operate

Ship logs to your stack

Marketplace

Build with AI

Examples

Monitor a machine with a Pico W

What you’ll build

What you learned

Next steps

Warehouse station

MQTT protocol

​What you’ll build

​What you learned

​Next steps

Warehouse station

MQTT protocol

What you’ll build

What you learned

Next steps