315 lines
12 KiB
Python
315 lines
12 KiB
Python
"""
|
|
api/raw_elm.py — Сырое взаимодействие с ELM327 (локальное + удалённое через Android).
|
|
|
|
ЛОКАЛЬНЫЙ РЕЖИМ (ELM327 подключён к серверу напрямую):
|
|
POST /api/v1/elm/raw — отправить команду, получить сырой ответ
|
|
POST /api/v1/elm/raw/batch — несколько команд
|
|
POST /api/v1/elm/raw/drain — очистить буфер
|
|
GET /api/v1/elm/raw/available — байт в буфере
|
|
GET /api/v1/elm/raw/log — история команд
|
|
GET /api/v1/elm/raw/mode — режим (normal/raw)
|
|
|
|
УДАЛЁННЫЙ РЕЖИМ (Android-ретранслятор):
|
|
POST /api/v1/elm/raw/hello — Android: «я готов»
|
|
POST /api/v1/elm/raw/cmd — Copilot: поставить команду в очередь
|
|
GET /api/v1/elm/raw/cmd — Android: забрать команду
|
|
POST /api/v1/elm/raw/response — Android: отправить ответ
|
|
GET /api/v1/elm/raw/response — Copilot: прочитать ответ
|
|
GET /api/v1/elm/raw/status — Copilot: статус устройства
|
|
"""
|
|
|
|
import logging
|
|
import threading
|
|
import time
|
|
from flask import jsonify, request, Blueprint
|
|
|
|
logger = logging.getLogger("elmer.raw_api")
|
|
|
|
# ══════════════════════════════════════════════════════════
|
|
# Глобальное состояние
|
|
# ══════════════════════════════════════════════════════════
|
|
|
|
_raw_mode = False
|
|
_raw_elm = None # локальный RawELM
|
|
|
|
# Очередь команд (удалённый режим)
|
|
_lock = threading.Lock()
|
|
_pending_cmd: dict | None = None # команда, которую ждёт Android
|
|
_pending_seq: int = 0 # номер последней команды
|
|
_last_response: dict | None = None # последний ответ от ELM327
|
|
_device_ready: bool = False # Android подключён и готов
|
|
_device_info: dict = {} # информация об устройстве (из hello)
|
|
_history: list[dict] = [] # история команд через Android
|
|
|
|
|
|
def is_raw_mode() -> bool:
|
|
return _raw_mode
|
|
|
|
def set_raw_mode(on: bool):
|
|
global _raw_mode
|
|
_raw_mode = on
|
|
logger.info(f"RawELM mode: {'ON' if on else 'OFF'}")
|
|
|
|
def set_raw_elm(instance):
|
|
global _raw_elm
|
|
_raw_elm = instance
|
|
|
|
|
|
bp = Blueprint("raw_elm", __name__)
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════
|
|
# ЛОКАЛЬНЫЙ РЕЖИМ — ELM327 подключён к серверу напрямую
|
|
# ══════════════════════════════════════════════════════════
|
|
|
|
@bp.route("/api/v1/elm/raw", methods=["POST"])
|
|
def raw_command():
|
|
if not _raw_elm:
|
|
return jsonify({"error": "no local ELM connection"}), 503
|
|
data = request.get_json(silent=True)
|
|
if not data or "cmd" not in data:
|
|
return jsonify({"error": "missing 'cmd'"}), 400
|
|
cmd = data["cmd"].strip()
|
|
if not cmd:
|
|
return jsonify({"error": "empty cmd"}), 400
|
|
timeout = data.get("timeout_ms")
|
|
drain_first = data.get("drain_first", False)
|
|
if drain_first:
|
|
_raw_elm.drain()
|
|
result = _raw_elm.send(cmd, timeout=timeout)
|
|
return jsonify(result)
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/batch", methods=["POST"])
|
|
def raw_batch():
|
|
if not _raw_elm:
|
|
return jsonify({"error": "no local ELM connection"}), 503
|
|
data = request.get_json(silent=True)
|
|
if not data or "cmds" not in data:
|
|
return jsonify({"error": "missing 'cmds'"}), 400
|
|
cmds = data["cmds"]
|
|
if len(cmds) > 100:
|
|
return jsonify({"error": "too many commands (max 100)"}), 400
|
|
timeout = data.get("timeout_ms")
|
|
drain_between = data.get("drain_between", False)
|
|
t0 = time.time()
|
|
results = []
|
|
for cmd in cmds:
|
|
if drain_between:
|
|
_raw_elm.drain()
|
|
results.append(_raw_elm.send(cmd, timeout=timeout))
|
|
total_elapsed = int((time.time() - t0) * 1000)
|
|
return jsonify({"results": results, "total_elapsed_ms": total_elapsed})
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/drain", methods=["POST"])
|
|
def raw_drain():
|
|
if not _raw_elm:
|
|
return jsonify({"error": "no local ELM connection"}), 503
|
|
return jsonify(_raw_elm.drain())
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/available", methods=["GET"])
|
|
def raw_available():
|
|
if not _raw_elm:
|
|
return jsonify({"error": "no local ELM connection"}), 503
|
|
return jsonify({"available": _raw_elm.available()})
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/log", methods=["GET"])
|
|
def raw_log():
|
|
if not _raw_elm:
|
|
return jsonify({"log": _history, "count": len(_history)})
|
|
return jsonify({"log": _raw_elm.log, "count": len(_raw_elm.log)})
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/mode", methods=["GET", "POST"])
|
|
def raw_mode_control():
|
|
global _raw_mode
|
|
if request.method == "POST":
|
|
data = request.get_json(silent=True) or {}
|
|
on = data.get("raw_mode", False)
|
|
set_raw_mode(on)
|
|
return jsonify({"raw_mode": _raw_mode, "has_local_elm": _raw_elm is not None,
|
|
"device_ready": _device_ready})
|
|
return jsonify({"raw_mode": _raw_mode, "has_local_elm": _raw_elm is not None,
|
|
"device_ready": _device_ready})
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════
|
|
# УДАЛЁННЫЙ РЕЖИМ — Android-ретранслятор
|
|
# ══════════════════════════════════════════════════════════
|
|
|
|
@bp.route("/api/v1/elm/raw/hello", methods=["POST"])
|
|
def raw_hello():
|
|
"""Android сообщает: «я подключился к ELM327, готов принимать команды».
|
|
|
|
Body: {
|
|
"device_id": "android-xyz",
|
|
"elm_version": "ELM327 v1.5",
|
|
"protocol": "A4",
|
|
"voltage": "12.3V"
|
|
}
|
|
"""
|
|
global _device_ready, _device_info, _pending_cmd, _pending_seq, _last_response
|
|
data = request.get_json(silent=True) or {}
|
|
with _lock:
|
|
_device_ready = True
|
|
_device_info = {
|
|
"device_id": data.get("device_id", "unknown"),
|
|
"elm_version": data.get("elm_version", "?"),
|
|
"protocol": data.get("protocol", "?"),
|
|
"voltage": data.get("voltage", "?"),
|
|
"connected_at": time.time(),
|
|
}
|
|
_pending_cmd = None
|
|
_pending_seq = 0
|
|
_last_response = None
|
|
logger.info(f"RawELM: device ready — {_device_info['device_id']} "
|
|
f"({_device_info['elm_version']}, proto {_device_info['protocol']})")
|
|
return jsonify({"ok": True, "seq": 0})
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/cmd", methods=["POST"])
|
|
def raw_enqueue_cmd():
|
|
"""Copilot: поставить команду в очередь для Android.
|
|
|
|
Body: {
|
|
"cmd": "0105",
|
|
"timeout_ms": 500,
|
|
"drain_first": false
|
|
}
|
|
"""
|
|
global _pending_cmd, _pending_seq
|
|
data = request.get_json(silent=True)
|
|
if not data or "cmd" not in data:
|
|
return jsonify({"error": "missing 'cmd'"}), 400
|
|
|
|
cmd = data["cmd"].strip()
|
|
if not cmd:
|
|
return jsonify({"error": "empty cmd"}), 400
|
|
|
|
with _lock:
|
|
_pending_seq += 1
|
|
_pending_cmd = {
|
|
"cmd": cmd,
|
|
"timeout_ms": data.get("timeout_ms", 500),
|
|
"drain_first": data.get("drain_first", False),
|
|
"seq": _pending_seq,
|
|
}
|
|
logger.info(f"RawELM: enqueued #{_pending_seq} → {cmd}")
|
|
return jsonify({"ok": True, "seq": _pending_seq, "cmd": cmd})
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/cmd", methods=["GET"])
|
|
def raw_dequeue_cmd():
|
|
"""Android: забрать команду из очереди.
|
|
|
|
Returns:
|
|
200 {"cmd": "0105", "seq": 1, ...} — есть команда
|
|
204 — нет команды, полли дальше
|
|
"""
|
|
global _pending_cmd
|
|
device_id = request.args.get("device_id", "")
|
|
|
|
with _lock:
|
|
if not _device_ready:
|
|
return jsonify({"error": "device not ready"}), 503
|
|
if _pending_cmd is None:
|
|
return "", 204 # No Content — полли дальше
|
|
cmd = _pending_cmd
|
|
_pending_cmd = None # забрали
|
|
|
|
logger.info(f"RawELM: dequeued #{cmd['seq']} → {cmd['cmd']} (device={device_id})")
|
|
return jsonify(cmd)
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/response", methods=["POST"])
|
|
def raw_post_response():
|
|
"""Android: отправить ответ ELM327 на сервер.
|
|
|
|
Body: {
|
|
"device_id": "android-xyz",
|
|
"seq": 1,
|
|
"cmd": "0105",
|
|
"raw": "41 05 5C",
|
|
"prompt": true,
|
|
"elapsed_ms": 48,
|
|
"bytes": 8,
|
|
"error": null
|
|
}
|
|
"""
|
|
global _last_response, _history
|
|
data = request.get_json(silent=True)
|
|
if not data:
|
|
return jsonify({"error": "empty body"}), 400
|
|
|
|
with _lock:
|
|
_last_response = {
|
|
"seq": data.get("seq", 0),
|
|
"cmd": data.get("cmd", ""),
|
|
"raw": data.get("raw", ""),
|
|
"prompt": data.get("prompt", False),
|
|
"elapsed_ms": data.get("elapsed_ms", 0),
|
|
"bytes": data.get("bytes", 0),
|
|
"error": data.get("error"),
|
|
"received_at": time.time(),
|
|
}
|
|
_history.append(dict(_last_response))
|
|
if len(_history) > 1000:
|
|
_history = _history[-500:]
|
|
|
|
logger.info(f"RawELM: response #{_last_response['seq']} ← {_last_response['raw'][:80]}")
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/response", methods=["GET"])
|
|
def raw_get_response():
|
|
"""Copilot: прочитать последний ответ от ELM327.
|
|
|
|
Query: ?wait=30 — ждать до 30 сек пока появится новый ответ
|
|
"""
|
|
global _last_response, _pending_cmd
|
|
wait_s = int(request.args.get("wait", 0))
|
|
seq = int(request.args.get("seq", 0))
|
|
|
|
if wait_s > 0:
|
|
# Ждём пока появится ответ на команду с seq > указанного
|
|
dl = time.time() + wait_s
|
|
while time.time() < dl:
|
|
with _lock:
|
|
if _last_response and _last_response["seq"] > seq:
|
|
return jsonify(_last_response)
|
|
if _pending_cmd is None and _last_response:
|
|
# команд в очереди нет, ответ уже есть
|
|
return jsonify(_last_response)
|
|
time.sleep(0.5)
|
|
|
|
with _lock:
|
|
if _last_response is None:
|
|
return jsonify({"error": "no response yet", "seq": 0})
|
|
return jsonify(_last_response)
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/status", methods=["GET"])
|
|
def raw_status():
|
|
"""Copilot: статус Android-устройства."""
|
|
with _lock:
|
|
return jsonify({
|
|
"device_ready": _device_ready,
|
|
"device_info": _device_info,
|
|
"pending_cmd": bool(_pending_cmd),
|
|
"pending_seq": _pending_seq,
|
|
"last_response_seq": _last_response["seq"] if _last_response else 0,
|
|
"history_count": len(_history),
|
|
})
|
|
|
|
|
|
@bp.route("/api/v1/elm/raw/history", methods=["GET"])
|
|
def raw_history():
|
|
"""Copilot: история всех команд через Android."""
|
|
n = int(request.args.get("n", 50))
|
|
with _lock:
|
|
return jsonify({"history": _history[-n:], "total": len(_history)})
|
|
|