3  仮想デバイスを動かす

PC の Python プログラムを「赤外線リモコン」に見立てて、Shadow 経由で操作します。

3.1 ターミナルを 3 つ使う

code/ で、仮想環境を有効にした(source .venv/bin/activate)ターミナルを 3 つ開きます。

ターミナル 実行するもの 役割
A python device/virtual_device.py デバイス。delta を受け取って「赤外線を送信」する
B python device/send.py watch 監視。Shadow の version と delta を 2 秒ごとに表示
C python device/send.py ... 操作。Alexa の代わりに desired を書き込む

3.2 デバイスを起動する

ターミナル A:

python device/virtual_device.py
[   0.0s] handson-aircon-01 として xxxx-ats.iot.ap-northeast-1.amazonaws.com に接続します(bug=none, poll=5.0s)
[   0.1s] 接続しました(Success)
[   0.1s]   <<< reported 更新: {"power": false, "mode": "cool", "temp": 26, "fan": "auto"}

接続すると、まず 今の状態を reported に書き、続けて get で切断中に来ていた delta を取りに行きます(第 6 章)。

ターミナル B:

python device/send.py watch
Ctrl+C で終了。version が増え続けていたら、すぐに `send.py stop`
21:03:10  version=1  delta=null

3.3 照明ボタンを押す

ターミナル C:

python device/send.py slot 5
desired を更新: {"sendSlot": "5-1791382552299"} → version 2

ターミナル A(デバイス)に、次のように出れば成功です。

[   5.2s] delta 受信(push): {"sendSlot": "5-1791382552299"}
[   5.2s]   >>> 赤外線送信 #1: スロット 5「照明 トグル」
[   5.2s]   <<< reported 更新: {"sendSlot": "5-1791382552299"}
  1. send.py が desired に sendSlot を書く(version 2)
  2. reported と違うので、AWS が delta をデバイスに push する
  3. デバイスは赤外線を送信し、受け取った値をそのまま reported に書き戻す(version 3)
  4. desired と reported が一致したので、delta が消える

ターミナル B では、version が 1 → 3 に増え、delta が null に戻るのが見えます。

ノートなぜ "5-1791382552299" なのか

スロット番号の後ろに 送信した時刻(ミリ秒) を付けています。素の 5 にしない理由は、次の章で実験します。

3.4 エアコンを操作する

python device/send.py ac --power on --temp 24
[  30.1s] delta 受信(push): {"power": true, "temp": 24, "cmdId": "1791382569430"}
[  30.1s]   >>> 赤外線送信 #2: エアコン {'power': True, 'mode': 'cool', 'temp': 24, 'fan': 'auto'}
[  30.1s]   <<< reported 更新: {"power": true, "mode": "cool", "temp": 24, "fan": "auto", "cmdId": "1791382569430"}

delta には、送ったフィールド(power・temp)と cmdId だけが入っています。デバイスは、届いたフィールドだけを今の状態に上書きして、すべてのフィールドを 1 回で reported に書き戻します。

今の Shadow 全体は get で見られます。

python device/send.py get

3.5 デバイスのコードを読む

中心は process_delta() です。届いた delta を見て、

  • sendSlot(ボタン):コマンド型。押すたびに 1 回だけ送信したい
  • power・mode・temp・fan(エアコン):状態型。「この状態にしてほしい」

の 2 種類を処理します。

device/virtual_device.py
"""仮想デバイス:赤外線リモコン(学習済みボタン + エアコン)のふりをする Python プログラム

AWS IoT Core の Device Shadow を MQTT で購読し、delta(やってほしいこと)を受け取ったら
「赤外線を送信した」ことにして、結果を reported に書き戻す。

    python device/virtual_device.py                 # 正しい実装
    python device/virtual_device.py --bug null      # 事故の再現(第5章)

--bug で、実際に起きた不具合を再現できる(重複チェックも外れ、当時と同じ動きになる):
    none       正しい実装(既定)
    nowrite    処理しても reported に書き戻さない
    null       reported を null にする(=フィールドを消す)
    number     cmdId を数値で書き戻す(desired は文字列)
    split      エアコンの状態と cmdId を 2 回に分けて書き戻す
    nodedup    書き戻しは正しいが、処理済みコマンドの重複チェックをしない
"""
import argparse
import json
import os
import ssl
import threading
import time

import paho.mqtt.client as mqtt

parser = argparse.ArgumentParser()
parser.add_argument("--config", default="device/config.json")
parser.add_argument("--bug", choices=["none", "nowrite", "null", "number", "split", "nodedup"], default="none")
parser.add_argument("--poll", type=float, default=5.0, help="shadow/get で取り直す間隔(秒)。0 で無効")
parser.add_argument("--max-exec", type=int, default=10, help="安全装置:赤外線送信がこの回数を超えたら停止")
args = parser.parse_args()

cfg = json.load(open(args.config))
THING = cfg["thing_name"]
BASE = f"$aws/things/{THING}/shadow"
DEDUP = args.bug == "none"   # バグ再現モードでは、当時と同じく重複チェックなし

# 学習済みボタン(スロット番号 → 名前)
SLOTS = {0: "テレビ 電源", 1: "テレビ 音量+", 5: "照明 トグル"}
# エアコンの現在の状態(デバイスが本当に知っている値)
ac = {"power": False, "mode": "cool", "temp": 26, "fan": "auto"}
AC_KEYS = list(ac)

exec_count = 0
done_ids = set()        # 処理済みのコマンド(sendSlot の値・cmdId)
lock = threading.Lock()
t0 = time.time()


def log(msg):
    print(f"[{time.time() - t0:6.1f}s] {msg}", flush=True)


def send_ir(text):
    """赤外線を送信したことにする。安全装置つき。"""
    global exec_count
    exec_count += 1
    log(f"  >>> 赤外線送信 #{exec_count}: {text}")
    if exec_count >= args.max_exec:
        log(f"!!! 安全装置: 送信が {args.max_exec} 回に達したので停止します。")
        log("!!! 別のターミナルで `python device/send.py stop` を実行して desired を消してください。")
        client.disconnect()
        os._exit(1)   # MQTT の受信スレッドからでもプロセスごと止める


def report(state):
    """reported を更新する(1 回の publish = 1 回の Shadow 更新)"""
    client.publish(BASE + "/update", json.dumps({"state": {"reported": state}}), qos=1)
    log(f"  <<< reported 更新: {json.dumps(state, ensure_ascii=False)}")


def process_delta(delta, source):
    if not delta:
        return
    log(f"delta 受信({source}): {json.dumps(delta, ensure_ascii=False)}")

    # --- 学習済みボタンの送信(コマンド型:毎回変わる値 "<slot>-<時刻>" で届く) ---
    if "sendSlot" in delta:
        raw = delta["sendSlot"]
        slot = int(str(raw).split("-")[0])
        if DEDUP and raw in done_ids:
            log(f"  ({raw} は処理済みなので送信しない)")
        else:
            send_ir(f"スロット {slot}「{SLOTS.get(slot, '未登録')}」")
            done_ids.add(raw)
        if args.bug == "nowrite":
            pass                                # 書き戻さない → desired と永遠に食い違う
        elif args.bug == "null":
            report({"sendSlot": None})          # null は「フィールド削除」になる
        else:
            report({"sendSlot": raw})           # 受け取った値をそのまま書き戻す

    # --- エアコン(状態型:変わったフィールドだけ届く。cmdId は毎回変わる) ---
    if any(k in delta for k in AC_KEYS) or "cmdId" in delta:
        cmd_id = delta.get("cmdId")
        for k in AC_KEYS:                       # 届いたフィールドだけ上書きし、残りは現在値のまま
            if k in delta:
                ac[k] = delta[k]
        if DEDUP and cmd_id is not None and cmd_id in done_ids:
            log(f"  (cmdId {cmd_id} は処理済みなので送信しない)")
        else:
            send_ir(f"エアコン {ac}")
            if cmd_id is not None:
                done_ids.add(cmd_id)
        if args.bug == "split":
            report(dict(ac))                    # 1 回目:状態だけ
            if cmd_id is not None:
                report({"cmdId": cmd_id})       # 2 回目:cmdId
        elif args.bug == "number" and cmd_id is not None:
            report({**ac, "cmdId": int(cmd_id)})  # 型が違う(数値)
        elif args.bug == "nowrite":
            pass
        else:
            out = dict(ac)
            if cmd_id is not None:
                out["cmdId"] = cmd_id           # 届いた値・型のまま
            report(out)                         # 1 回の publish にまとめる


def on_message(c, userdata, msg):
    body = json.loads(msg.payload or b"{}")
    with lock:
        if msg.topic.endswith("/update/delta"):
            process_delta(body.get("state", {}), "push")
        elif msg.topic.endswith("/get/accepted"):
            process_delta(body.get("state", {}).get("delta", {}), "get")
        elif msg.topic.endswith("/rejected"):
            log(f"rejected: {body}")


def on_connect(c, userdata, flags, reason_code, properties):
    log(f"接続しました({reason_code})")
    c.subscribe([(BASE + "/update/delta", 1), (BASE + "/get/accepted", 1),
                 (BASE + "/update/rejected", 1), (BASE + "/get/rejected", 1)])
    report(dict(ac))                            # 今の状態を知らせる
    c.publish(BASE + "/get", "", qos=1)         # 切断中に来ていた delta を取りに行く


client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=THING)
client.tls_set(ca_certs=cfg["ca"], certfile=cfg["cert"], keyfile=cfg["key"],
               tls_version=ssl.PROTOCOL_TLS_CLIENT)
client.on_connect = on_connect
client.on_message = on_message
log(f"{THING} として {cfg['endpoint']} に接続します(bug={args.bug}, poll={args.poll}s)")
client.connect(cfg["endpoint"], 8883, keepalive=60)
client.loop_start()
try:
    while True:
        time.sleep(args.poll if args.poll > 0 else 3600)
        if args.poll > 0 and client.is_connected():
            client.publish(BASE + "/get", "", qos=1)  # push の取りこぼし対策のポーリング
except KeyboardInterrupt:
    log("終了します")
    client.disconnect()

ポイント:

  • on_connect で delta と get/accepted を購読 し、今の状態を報告 してから get を送る
  • on_message は、push された delta(/update/delta)と、get の応答の中の delta(/get/accepted の state.delta)を、同じ process_delta() で処理する
  • 5 秒ごとに get を送り、push を取りこぼしても拾えるようにしている(第 6 章)
  • 処理済みのコマンド(done_ids)を覚えておき、同じコマンドを 2 回実行しない(第 6 章)
  • --max-exec(既定 10 回)を超えて送信したら、自分で止まる安全装置(第 5 章)

3.6 止める

ターミナル A・B は Ctrl+C で止めます。次の章でも同じ 3 つのターミナルを使います。

重要この章のまとめ
  • デバイスは delta を受け取る → 実行 → 受け取った値を reported に書き戻す
  • 接続したら 今の状態を報告 し、get で取りこぼしを拾う
  • send.py watch で version と delta を見ながら 操作する