Files

882 lines
32 KiB
Python
Raw Permalink Normal View History

#!/usr/bin/env python3
import os, threading, signal, json, time, argparse, socket, re, datetime, collections
import serial
from .. import __version__ as _AIMBEDDED_VERSION
from ..libs.logging import init_logger, set_logging_level, log_levels
import subprocess
from ina219 import INA219, SmbusI2cDevice
import psutil
try:
import redis
except ImportError:
redis = None
logger = init_logger(level="info")
def send_at_command(ser, command, timeout=1):
"""
Sends an AT command to the modem and reads the response.
"""
ser.write((command + "\r\n").encode())
time.sleep(timeout)
response = ser.read_all().decode(errors="ignore").strip()
return response
def map_csq_rssi(rssi):
"""
Maps RSSI value to dBm.
"""
if rssi == 0:
return -113 # -113 dBm or less
elif rssi == 31:
return -51 # -51 dBm or greater
elif 1 <= rssi <= 30:
return -113 + (rssi * 2) # dBm
elif rssi == 99:
return None
return None
def map_csq_ber(ber):
"""
Maps BER value to percentage range.
"""
ber_mapping = {
0: 0.1,
1: 0.3,
2: 0.6,
3: 1.2,
4: 2.4,
5: 5.0,
6: 9.0,
7: 13.0,
99: None,
}
return ber_mapping.get(ber, None)
def parse_csq(response):
"""
Parses AT+CSQ response for signal quality.
"""
match = re.search(r'\+CSQ: (\d+),(\d+)', response)
if match:
rssi = int(match.group(1))
ber = int(match.group(2))
rssi_dbm = map_csq_rssi(rssi)
ber_percent = map_csq_ber(ber)
return rssi_dbm, ber_percent
return None, None
def parse_cesq(response):
"""
Parses AT+CESQ response and interprets rsrq and rsrp.
"""
match = re.search(r'\+CESQ: (\d+),(\d+),(\d+),(\d+),(\d+),(\d+)', response)
if match:
# Extract rsrq and rsrp values (ignore first 4 values)
rsrq = int(match.group(5))
rsrp = int(match.group(6))
# Map rsrq to dB ranges
rsrq_db = (
-19.5 + (rsrq * 0.5) if 0 <= rsrq <= 34
else None if rsrq == 255
else None
)
# Map rsrp to dBm ranges
rsrp_dbm = (
-140 + rsrp if 0 <= rsrp <= 97
else None if rsrp == 255
else None
)
return rsrq_db, rsrp_dbm
return None, None
def parse_cereg(response):
"""
Parses AT+CEREG? response into a registration status string.
"""
mapping = {0: "not_registered", 1: "home", 2: "searching",
3: "denied", 4: "unknown", 5: "roaming"}
match = re.search(r'\+CEREG: \d+,(\d+)', response)
if match:
return mapping.get(int(match.group(1)), "unknown")
return None
def parse_cgact(response):
"""
Parses AT+CGACT? response. Returns the list of active PDP context ids.
"""
return [int(m.group(1)) for m in re.finditer(r'\+CGACT: (\d+),1', response)]
def parse_cgpaddr(response):
"""
Parses AT+CGPADDR=<cid> response. Returns the PDP address or None.
"""
match = re.search(r'\+CGPADDR: \d+,"([^"]+)"', response)
if match and match.group(1) != "0.0.0.0":
return match.group(1)
return None
def get_network_info(response):
"""
Extracts network operator and technology from the response.
"""
match = re.search(r'\+COPS: \d,(\d),"([^"]+)",(\d+)', response)
if match:
mode = int(match.group(1))
operator = match.group(2)
technology = int(match.group(3))
tech_mapping = {0: "GSM", 2: "UMTS", 3: "LTE", 7: "E-UTRAN"}
return operator, tech_mapping.get(technology, "Unknown")
return None, None
class systemInfo(threading.Thread):
# BusVoltage trend analysis: sliding window and classification deadband.
# INA219 bus voltage LSB is 4 mV, so slopes below a few mV/min are noise.
TREND_WINDOW_S = 60
TREND_MIN_SAMPLES = 10
TREND_MIN_SPAN_S = 30
TREND_THRESHOLD_MV_MIN = 2.5
# Rest voltage vs state-of-charge for a 4S LiFePO4 pack (12.8 V nominal).
# The curve is very flat between 30% and 80%, so mid-range estimates are
# coarse and only reliable when the battery is not under charge.
LIFEPO4_OCV_SOC = [
(10.0, 0), (12.0, 10), (12.5, 20), (12.8, 30), (12.9, 40),
(13.0, 50), (13.1, 60), (13.2, 70), (13.3, 80), (13.4, 90), (13.6, 100),
]
RUNTIME_MIN_CURRENT_MA = 50
# Effective series resistance [Ohm] between battery and INA219 bus
# measurement: pack internal resistance + wiring + 100 mOhm shunt.
# Measured 0.34 Ohm on a deployed unit via a load-step V/I regression
# (R^2 = 0.93). Without IR compensation, load changes masquerade as
# charge/discharge swings on LiFePO4's flat voltage curve.
BATTERY_R_OHM_DEFAULT = 0.34
def __init__(
self,
system_name=None,
device=1,
enable_logging=False,
no_modem=False,
refresh_rate=1,
battery_capacity_ah=None,
battery_r_ohm=BATTERY_R_OHM_DEFAULT,
config_folder="/etc/aimsight",
redis_socket=None,
redis_host=None,
redis_port=None,
):
self.config_folder = config_folder
self.system_name = system_name
self.device_index = device
self.stop_service = threading.Event()
self.event_notification = threading.Condition()
self.refresh_rate = refresh_rate
self.enable_logging = enable_logging
self.modem = not no_modem
self.power_monitor = self.init_ina(i2cBus=device)
self.voltage_history = collections.deque()
self.battery_state = "unknown"
self.battery_capacity_ah = battery_capacity_ah
self.battery_r_ohm = battery_r_ohm
self.accumulator = None
self.last_sync = time.time()
self.modem_count = 0
self.modem_resp = None
self.network_count = 0
self.network_resp = None
# Redis init (graceful degradation)
self._redis = None
if redis is not None:
try:
if redis_socket:
self._redis = redis.Redis(unix_socket_path=redis_socket, decode_responses=False)
else:
self._redis = redis.Redis(
host=redis_host or "localhost",
port=redis_port or 6379,
decode_responses=False,
)
self._redis.ping()
logger.info("Redis connection established")
except Exception as e:
logger.warning("Redis not available: %s", e)
self._redis = None
else:
logger.warning("redis-py not installed")
super().__init__()
def stop(self):
logger.info("Stop instruction received. notifing acquisition thread.")
self.stop_service.set()
with self.event_notification:
self.event_notification.notify()
def init_ina(self, shunt_ohms=0.1, i2cBus=1):
i2c_addr = INA219.I2C_ADDR_DEFAULT
i2c_device = SmbusI2cDevice(interface=1, address=i2c_addr)
ina_device = INA219(i2c_device, shunt_ohms=shunt_ohms) # Using the BBB I2C bus nb.2
try:
ina_device.configure(INA219.RANGE_32V, INA219.GAIN_8_320MV)
except OSError:
logger.fatal("INA219: Cannot communicate with peripheral %d", i2cBus)
return ina_device
def _store_in_redis(self, key, data, ttl):
"""Store data as a Redis hash with TTL. No-op if Redis is unavailable."""
if self._redis is None:
return
try:
mapping = {"_updated_at": str(time.time())}
for k, v in data.items():
if v is None:
mapping[k] = ""
elif isinstance(v, (list, tuple)):
mapping[k] = json.dumps(v)
else:
mapping[k] = str(v)
self._redis.hset(key, mapping=mapping)
self._redis.expire(key, ttl)
except Exception as e:
logger.warning("Redis store failed for %s: %s", key, e)
def _get_gateways(self):
"""Parse 'ip route' to build a {iface: gateway} map."""
gateways = {}
try:
output = subprocess.check_output(["ip", "route"], text=True)
for line in output.splitlines():
# e.g. "default via 192.168.1.1 dev eth0 ..."
parts = line.split()
if "via" in parts and "dev" in parts:
gw = parts[parts.index("via") + 1]
iface = parts[parts.index("dev") + 1]
if parts[0] == "default":
gateways[iface] = gw
except Exception:
pass
return gateways
def get_interface_info(self):
"""Get network interface info (IP, netmask, gateway). Returns flat dict or None."""
self.network_count = (self.network_count + 1) % 5
if self.network_count > 0 and self.network_resp is not None:
return self.network_resp
try:
result = {}
addrs = psutil.net_if_addrs()
gateways = self._get_gateways()
skip_prefixes = ("lo", "docker", "br-")
for iface, addr_list in addrs.items():
if any(iface.startswith(p) for p in skip_prefixes):
continue
for addr in addr_list:
if addr.family == socket.AF_INET:
result[f"{iface}_ip"] = addr.address
result[f"{iface}_netmask"] = addr.netmask
result[f"{iface}_gateway"] = gateways.get(iface)
break
self.network_resp = result if result else None
except Exception as e:
logger.warning("Failed to get network info: %s", e)
return self.network_resp
def publish_new_system_info(self):
power_info = self.get_power_info()
proc_info = self.get_proc_info()
thermal_info = self.get_thermal_info()
self._store_in_redis("system_info:power", power_info, 60)
self._store_in_redis("system_info:proc", proc_info, 60)
self._store_in_redis("system_info:temperature", thermal_info, 60)
modem_info = None
if self.modem:
modem_info = self.get_modem_info()
if modem_info is not None:
self._store_in_redis("system_info:modem", modem_info, 120)
network_info = self.get_interface_info()
if network_info is not None:
self._store_in_redis("system_info:network", network_info, 120)
if self.enable_logging:
logger.info("Power: %s", power_info)
logger.info("Proc : %s", proc_info)
logger.info("Temp : %s", thermal_info)
if self.modem:
logger.info("Modem: %s", modem_info)
logger.info("Net : %s", network_info)
def update_voltage_trend(self, voltage):
"""
Tracks BusVoltage over a sliding time window and classifies the
battery state from its slope.
Returns (slope_mv_per_min, state) with state one of "charging",
"discharging", "stable" or "unknown".
"""
now = time.time()
self.voltage_history.append((now, voltage))
while now - self.voltage_history[0][0] > self.TREND_WINDOW_S:
self.voltage_history.popleft()
n = len(self.voltage_history)
span = self.voltage_history[-1][0] - self.voltage_history[0][0]
if n < self.TREND_MIN_SAMPLES or span < self.TREND_MIN_SPAN_S:
return None, "unknown"
# Least-squares slope of voltage vs time, converted to mV/min
t_mean = sum(t for t, _ in self.voltage_history) / n
v_mean = sum(v for _, v in self.voltage_history) / n
num = sum((t - t_mean) * (v - v_mean) for t, v in self.voltage_history)
den = sum((t - t_mean) ** 2 for t, _ in self.voltage_history)
if den == 0:
return None, "unknown"
slope_mv_min = num / den * 1000 * 60
if slope_mv_min > self.TREND_THRESHOLD_MV_MIN:
self.battery_state = "charging"
elif slope_mv_min < -self.TREND_THRESHOLD_MV_MIN:
self.battery_state = "discharging"
else:
self.battery_state = "stable"
return slope_mv_min, self.battery_state
def battery_percent(self, voltage):
"""
Estimates state-of-charge [%] from pack voltage by linear
interpolation of the LiFePO4 OCV table. While charging, the bus
follows the charger voltage and the estimate saturates at 100%.
"""
table = self.LIFEPO4_OCV_SOC
if voltage <= table[0][0]:
return 0.0
if voltage >= table[-1][0]:
return 100.0
for (v0, p0), (v1, p1) in zip(table, table[1:]):
if voltage <= v1:
return p0 + (p1 - p0) * (voltage - v0) / (v1 - v0)
return 100.0
def get_power_info(self):
bus_voltage = self.power_monitor.voltage()
power_info = {"BusVoltage": bus_voltage}
try:
power_info.update({
"BusCurrent": self.power_monitor.current(),
"Power": self.power_monitor.power(),
"ShuntVoltage": self.power_monitor.shunt_voltage(),
})
except Exception as exception:
# Current out of device range with specified shunt resistor
logger.error("INA219: %s", exception.__repr__())
# Compensate the IR drop (V_ocv ~ V_bus + I*R) so that trend and SoC
# track the battery, not the load: a load step sags the bus voltage
# and would otherwise read as a discharge, and the relaxation after
# load release as a charge.
current_ma = power_info.get("BusCurrent")
if current_ma is not None:
ocv = bus_voltage + (current_ma / 1000) * self.battery_r_ohm
else:
ocv = bus_voltage
slope_mv_min, battery_state = self.update_voltage_trend(ocv)
# SoC from the windowed mean of the compensated voltage: filters
# INA219 quantization noise and residual load transients.
mean_ocv = sum(v for _, v in self.voltage_history) / len(self.voltage_history)
soc = self.battery_percent(mean_ocv)
power_info.update({
"BusVoltageOCV": round(ocv, 3),
"BusVoltageTrend": round(slope_mv_min, 2) if slope_mv_min is not None else None,
"BatteryState": battery_state,
"BatteryPercent": round(soc, 1),
})
if self.battery_capacity_ah is not None:
remaining_ah = self.battery_capacity_ah * soc / 100
power_info["BatteryRemainingAh"] = round(remaining_ah, 2)
current_ma = power_info.get("BusCurrent")
if (battery_state == "discharging" and current_ma is not None
and current_ma > self.RUNTIME_MIN_CURRENT_MA):
power_info["BatteryRuntime_h"] = round(remaining_ah / (current_ma / 1000), 1)
return power_info
def get_thermal_info(self):
folder_skeleton = "/sys/devices/virtual/thermal/thermal_zone{}/temp"
thermal_info = {}
mapping = {"A0": 0, "CPU": 1, "GPU": 2, "PLL": 3, "thermal": 5}
for k, i in mapping.items():
with open(folder_skeleton.format(i), "r") as fp:
value = fp.read()
thermal_info[k] = int(value) / 1000
return thermal_info
def get_proc_info(self):
gpu_load_file = "/sys/devices/gpu.0/load"
with open(gpu_load_file, "r") as fp:
value = fp.read()
gpu_load = int(value)/10
data_storage = psutil.disk_usage('/data')
proc_info = {
"gpu_load_percent": gpu_load,
"cpu_load_percent": psutil.cpu_percent(),
"percpu_load_percent": psutil.cpu_percent(percpu=True),
"cpu_load_info": psutil.getloadavg(),
"data_storage_percent": data_storage.percent,
"data_storage_free_gb": data_storage.free / 1024**3,
"data_storage_used_gb": data_storage.used / 1024**3,
"data_storage_total_gb": data_storage.total / 1024**3,
}
return proc_info
def get_modem_info(self):
self.modem_count = (self.modem_count + 1) % 10
if self.modem_count > 0 and self.modem_resp is not None:
return self.modem_resp
try:
ser = serial.Serial(
port="/dev/ttyTHS1",
baudrate=115200,
timeout=1,
write_timeout=1
)
if not ser.is_open:
ser.open()
response = send_at_command(ser, "AT+CSQ")
rssi_dbm, ber_percent = parse_csq(response)
response = send_at_command(ser, "AT+CESQ")
rsrq_db, rsrp_dbm = parse_cesq(response)
response = send_at_command(ser, "AT+COPS?")
operator, technology = get_network_info(response)
response = send_at_command(ser, "AT#CCID")
match = re.search(r'#CCID: (\d+)', response)
ccid = ""
if match:
ccid = match.group(1)
# Link status and IP from the PDP context, mode-agnostic: works
# in both PPP and ECM since it asks the modem about the cellular
# session, not the host interface (in ECM the host only sees the
# modem's NAT LAN address, e.g. 192.168.225.x on wwan0).
response = send_at_command(ser, "AT+CEREG?", timeout=0.5)
registration = parse_cereg(response)
response = send_at_command(ser, "AT+CGACT?", timeout=0.5)
active_cids = parse_cgact(response)
ip = None
if active_cids:
response = send_at_command(ser, "AT+CGPADDR=%d" % active_cids[0], timeout=0.5)
ip = parse_cgpaddr(response)
link = "up" if ip is not None else "down"
ser.close()
except:
# Report an explicit "down" default instead of returning the
# cached response: stale good values would keep telling the
# cloud the link is fine while the modem is unreachable.
logger.exception("Error when reading modem, reporting link down")
self.modem_resp = {
"SIM_CCID": None,
"rsrq_dB": None,
"rsrp_dBm": None,
"rssi_dbm": None,
"ber_percent": None,
"network_operator": None,
"network_technology": None,
"registration": None,
"link": "down",
"ip": None,
}
else:
self.modem_resp = {
"SIM_CCID": ccid,
"rsrq_dB": rsrq_db,
"rsrp_dBm": rsrp_dbm,
"rssi_dbm": rssi_dbm,
"ber_percent": ber_percent,
"network_operator": operator,
"network_technology": technology,
"registration": registration,
"link": link,
"ip": ip,
}
return self.modem_resp
def run(self):
jiter_time = 0
while "Running Indefinitely":
if self.refresh_rate is None:
timeout = None
else:
refresh_interval = 1 / self.refresh_rate
timeout = refresh_interval - jiter_time - 0.002
if timeout < 0:
timeout = 0
with self.event_notification:
self.event_notification.wait(timeout=timeout)
if self.stop_service.is_set():
break
t0 = time.time()
self.publish_new_system_info()
jiter_time = time.time() - t0
if self.accumulator is not None:
self.accumulator.commit()
if self._redis is not None:
try:
self._redis.close()
except Exception:
pass
def _add_redis_args(parser):
"""Add common Redis connection arguments to a parser/subparser."""
redis_group = parser.add_argument_group("Redis", "Redis connection options")
redis_group.add_argument(
"--redis-socket",
default=os.environ.get("SYSTEM_INFO_REDIS_SOCKET"),
help="Unix socket path (takes precedence over host:port)",
)
redis_group.add_argument(
"--redis-host",
default=os.environ.get("SYSTEM_INFO_REDIS_HOST", "localhost"),
help="Redis host (default: localhost)",
)
redis_group.add_argument(
"--redis-port",
type=int,
default=int(os.environ.get("SYSTEM_INFO_REDIS_PORT", 6379)),
help="Redis port (default: 6379)",
)
redis_group.add_argument(
"--redis-password",
default=os.environ.get("SYSTEM_INFO_REDIS_PASSWORD"),
help="Redis password",
)
redis_group.add_argument(
"--redis-db",
type=int,
default=int(os.environ.get("SYSTEM_INFO_REDIS_DB", 0)),
help="Redis database number (default: 0)",
)
redis_group.add_argument(
"--redis-stream",
default=os.environ.get("SYSTEM_INFO_REDIS_STREAM", "aimsight:sync"),
help="Redis stream name (default: aimsight:sync)",
)
return redis_group
def _redis_kwargs(args):
"""Extract Redis connection kwargs from parsed args."""
return {
"socket": args.redis_socket,
"host": args.redis_host,
"port": args.redis_port,
"password": args.redis_password,
"db": args.redis_db,
}
def cmd_monitor(args):
"""Run the system info monitor (default command)."""
ENABLE_LOGGING = json.loads(os.environ.get("SYSTEM_INFO_ENABLE_LOGGING", "false"))
DISABLE_MODEM = json.loads(os.environ.get("SYSTEM_INFO_DISABLE_MODEM", "false"))
pw = systemInfo(
device=args.device,
system_name=args.system_name,
enable_logging=args.enable_logging or ENABLE_LOGGING,
refresh_rate=args.refresh,
no_modem=args.modem or DISABLE_MODEM,
battery_capacity_ah=args.battery_capacity,
battery_r_ohm=args.battery_resistance,
redis_socket=args.redis_socket,
redis_host=args.redis_host,
redis_port=args.redis_port,
)
signal.signal(signal.SIGTERM, lambda x, y: pw.stop())
signal.signal(signal.SIGINT, lambda x, y: pw.stop())
pw.start()
while pw.is_alive():
pw.join(1)
# Per-Redis-topic sync spec: each topic maps to a list of directives, applied
# in order against the topic's decoded hash. Directive shapes:
#
# {"fields": [key, ...]}
# Heterogeneous quantities: publish each key as its own metric whose
# data_type is the key itself.
#
# {"metric": name, "label": key, "fields": {redis_key: label_value, ...}}
# Same-unit scalar series that only differ along one dimension: publish
# every field under a single metric ``name``, distinguished by a
# Prometheus-style ``label=label_value`` label instead of baking the
# dimension into the metric name.
#
# {"metric": name, "label": key, "list": redis_key, "list_labels": [...]}
# A list-valued field (one element per series member): publish one metric
# ``name`` per element, labelled by ``list_labels[i]`` (or the index).
SYNC_SPEC = {
"power": [
{"fields": [
"Power", "BusCurrent", "BusVoltage", "BusVoltageOCV", "ShuntVoltage",
"BusVoltageTrend", "BatteryState", "BatteryPercent",
"BatteryRemainingAh", "BatteryRuntime_h",
]},
],
"modem": [
# ``ip`` is published as ip_address{interface="modem"}, see below.
{"fields": [
"rsrq_dB", "SIM_CCID", "rsrp_dBm", "rssi_dbm", "ber_percent",
"network_operator", "network_technology", "registration", "link",
]},
],
"temperature": [
{"metric": "temperature_deg_c", "label": "sensor",
"fields": {"A0": "A0", "CPU": "CPU", "GPU": "GPU", "PLL": "PLL", "thermal": "thermal"}},
],
"proc": [
{"fields": ["data_storage_percent"]},
{"metric": "data_storage_gb", "label": "state",
"fields": {
"data_storage_free_gb": "free",
"data_storage_used_gb": "used",
"data_storage_total_gb": "total",
}},
{"metric": "load_percent", "label": "unit",
"fields": {"cpu_load_percent": "cpu", "gpu_load_percent": "gpu"}},
{"metric": "cpu_load_percent", "label": "cpu", "list": "percpu_load_percent"},
{"metric": "load_average", "label": "window", "list": "cpu_load_info",
"list_labels": ["1m", "5m", "15m"]},
],
}
# Interface IPs published as ip_address{interface=...}, one series per link.
# nebula1 is the Nebula overlay tun (config ``tun.dev``), only present while the
# VPN is up; the modem IP is the cellular PDP address from the modem topic.
IP_SOURCES = [
("eth0", "network", "eth0_ip"),
("nebula", "network", "nebula1_ip"),
("modem", "modem", "ip"),
]
def _emit_directive(publisher, data, directive):
"""Publish one directive's metrics from a decoded Redis hash.
Returns the number of metrics published. None-valued fields/elements and a
missing (or non-list) ``list`` source are skipped.
"""
metric = directive.get("metric")
label = directive.get("label")
count = 0
list_key = directive.get("list")
if list_key is not None:
values = data.get(list_key)
if not isinstance(values, list):
return 0
list_labels = directive.get("list_labels")
for i, value in enumerate(values):
if value is None:
continue
label_value = list_labels[i] if list_labels and i < len(list_labels) else str(i)
publisher.metric(json.dumps(value), data_type=metric, labels={label: label_value})
count += 1
return count
if label is not None:
for redis_key, label_value in directive["fields"].items():
value = data.get(redis_key)
if value is None:
continue
publisher.metric(json.dumps(value), data_type=metric, labels={label: label_value})
count += 1
return count
for key in directive["fields"]:
value = data.get(key)
if value is None:
continue
publisher.metric(json.dumps(value), data_type=key)
count += 1
return count
def _module_version(*dist_names):
"""Best-effort version of an installed distribution, or None.
Reads distribution metadata (does not import the package, so no heavy
optional deps are pulled in); tries each candidate name in turn.
"""
try:
from importlib.metadata import version, PackageNotFoundError
except ImportError:
return None
for dist in dist_names:
try:
return version(dist)
except PackageNotFoundError:
continue
except Exception:
return None
return None
def _distro_version(path="/etc/build"):
"""Parse ``DISTRO_VERSION`` from the image build file, or None if absent."""
try:
with open(path) as fp:
for line in fp:
if line.startswith("DISTRO_VERSION"):
_, _, value = line.partition("=")
return value.strip().strip('"').strip("'") or None
except OSError:
return None
return None
def _software_versions():
"""Component versions for the ``software_version`` info-metric labels.
Missing components report "unknown" so the series keeps a stable set of
label keys.
"""
return {
"aimbedded": _AIMBEDDED_VERSION or "unknown",
"aimsight_optical": _module_version("aimsight-optical", "aimsight_optical") or "unknown",
"distro": _distro_version() or "unknown",
}
def _ntp_synchronized():
"""Whether the system clock is NTP-synchronized, or None if undetermined.
Read live from ``timedatectl`` (an unprivileged query): a drifted clock
breaks TLS and makes every reported timestamp suspect, so it is worth
surfacing on its own.
"""
try:
out = subprocess.check_output(
["timedatectl", "show", "-p", "NTPSynchronized", "--value"],
text=True, stderr=subprocess.DEVNULL, timeout=5,
).strip().lower()
except Exception:
return None
if out in ("yes", "true", "1"):
return True
if out in ("no", "false", "0"):
return False
return None
def cmd_sync(args):
"""Sync system_info snapshot from Redis to cloud via MQTT."""
from .client import SystemInfoClient
from ..mqtt_sync.publisher import SyncPublisher
redis_kw = _redis_kwargs(args)
with SystemInfoClient(**redis_kw) as client, \
SyncPublisher(**redis_kw, stream=args.redis_stream) as publisher:
snap = client.snapshot()
if not snap:
logger.warning("No system_info data in Redis, skipping sync")
return
count = 0
for topic, directives in SYNC_SPEC.items():
data = snap.get(topic)
if not data:
continue
for directive in directives:
count += _emit_directive(publisher, data, directive)
# Interface IPs, one series per interface via an ``interface`` label.
for label, topic, key in IP_SOURCES:
ip = (snap.get(topic) or {}).get(key)
if ip:
publisher.metric(json.dumps(ip), data_type="ip_address", labels={"interface": label})
count += 1
# Clock health: 1 synchronized, 0 drifted. Reported even when 0 (a
# de-synced clock must be visible, not merely absent); omitted only
# when it cannot be determined.
ntp = _ntp_synchronized()
if ntp is not None:
publisher.metric(json.dumps(1 if ntp else 0), data_type="ntp_synchronized")
count += 1
# Component versions as a Prometheus-style info metric (value 1, the
# versions carried as labels).
publisher.metric(json.dumps(1), data_type="software_version", labels=_software_versions())
count += 1
publisher.metric(json.dumps(datetime.datetime.now().isoformat()), data_type="last_sync")
logger.info("Synced %d system_info metrics to cloud", count + 1)
def main():
SYSTEM_NAME = os.environ.get("SYSTEM_NAME", None)
REFRESH_RATE = os.environ.get("SYSTEM_INFO_REFRESH_RATE", "1")
parser = argparse.ArgumentParser(description="System info collector")
subparsers = parser.add_subparsers(dest="command")
# --- monitor (default) ---
monitor_parser = subparsers.add_parser("monitor", help="Run system info monitor")
monitor_parser.add_argument("-d", "--device", type=int, help="device index", default=1)
monitor_parser.add_argument("-s", "--system_name", help="System name", default=SYSTEM_NAME)
monitor_parser.add_argument("-r", "--refresh", type=float, help="Refresh rate in [Hz]", default=REFRESH_RATE)
monitor_parser.add_argument("-l", "--enable_logging", action="store_true", help="print values")
monitor_parser.add_argument("-m", "--modem", action="store_true", help="disable modem")
BATTERY_CAPACITY = os.environ.get("SYSTEM_INFO_BATTERY_CAPACITY_AH")
monitor_parser.add_argument(
"-c", "--battery-capacity", type=float,
default=float(BATTERY_CAPACITY) if BATTERY_CAPACITY else None,
help="Battery capacity in Ah (7.3 or 19); enables remaining-Ah and runtime estimates",
)
BATTERY_R = os.environ.get("SYSTEM_INFO_BATTERY_R_OHM")
monitor_parser.add_argument(
"--battery-resistance", type=float,
default=float(BATTERY_R) if BATTERY_R else systemInfo.BATTERY_R_OHM_DEFAULT,
help="Effective series resistance battery-to-INA219 in Ohm, for IR compensation "
"(default: %(default)s, measured via load-step V/I regression)",
)
_add_redis_args(monitor_parser)
# --- sync ---
sync_parser = subparsers.add_parser("sync", help="Sync system_info snapshot to cloud")
_add_redis_args(sync_parser)
args = parser.parse_args()
if args.command == "sync":
cmd_sync(args)
else:
# Default to monitor (handles both explicit "monitor" and no subcommand)
if args.command is None:
args = monitor_parser.parse_args()
cmd_monitor(args)
if __name__ == "__main__":
main()