#!/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= 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()