New info example, overall testing helpers. Improved readme
This commit is contained in:
Scott Penrose
@@ -0,0 +1,256 @@
|
||||
/*
|
||||
* meshcore_info.c
|
||||
*
|
||||
* One-shot: open a tty, interrogate the attached MeshCore Companion Radio for
|
||||
* everything it will tell us -- model/firmware/version, radio parameters,
|
||||
* device time, every configured channel (name + PSK), and runtime stats -- then
|
||||
* print it and exit. Read-only; sends only query commands.
|
||||
*
|
||||
* build: via CMakeLists.txt at the repo root, or:
|
||||
* cc -std=c99 -Wall -Wextra -I../../src \
|
||||
* meshcore_info.c ../../src/meshcore_companion.c -o meshcore_info
|
||||
*
|
||||
* run: ./meshcore_info /dev/ttyACM0
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
* Author: Scott Penrose / Digital Dimensions.
|
||||
*/
|
||||
#define _DEFAULT_SOURCE /* cfmakeraw, B115200, clock_gettime on glibc/c99 */
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/select.h>
|
||||
#include <termios.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "meshcore_companion.h"
|
||||
|
||||
#define MAX_CHANNELS 64
|
||||
|
||||
/* ------------------------------------------------------------- collected state */
|
||||
typedef struct {
|
||||
int have_device, have_self, have_time;
|
||||
mc_device_info_t dev;
|
||||
mc_self_info_t self;
|
||||
uint32_t epoch;
|
||||
|
||||
int nchan; /* channels we queried */
|
||||
int chan_got[MAX_CHANNELS];
|
||||
mc_channel_info_t chan[MAX_CHANNELS];
|
||||
|
||||
int have_core, have_radio, have_packets;
|
||||
mc_stats_t core, radio, packets;
|
||||
} info_t;
|
||||
|
||||
/* ------------------------------------------------------------------ tty + I/O */
|
||||
static int tty_open(const char *path) {
|
||||
int fd = open(path, O_RDWR | O_NOCTTY | O_NONBLOCK);
|
||||
if (fd < 0) { fprintf(stderr, "open %s: %s\n", path, strerror(errno)); return -1; }
|
||||
struct termios tio;
|
||||
if (tcgetattr(fd, &tio) != 0) { fprintf(stderr, "tcgetattr: %s\n", strerror(errno)); close(fd); return -1; }
|
||||
cfmakeraw(&tio);
|
||||
cfsetispeed(&tio, B115200);
|
||||
cfsetospeed(&tio, B115200);
|
||||
tio.c_cflag |= (CLOCAL | CREAD);
|
||||
tio.c_cc[VMIN] = 0; tio.c_cc[VTIME] = 0;
|
||||
if (tcsetattr(fd, TCSANOW, &tio) != 0) { fprintf(stderr, "tcsetattr: %s\n", strerror(errno)); close(fd); return -1; }
|
||||
tcflush(fd, TCIOFLUSH);
|
||||
return fd;
|
||||
}
|
||||
|
||||
static void send_payload(int fd, const uint8_t *payload, size_t len) {
|
||||
uint8_t frame[MC_RX_BUFSZ];
|
||||
size_t flen = mc_frame_encode(payload, len, frame, sizeof frame);
|
||||
size_t off = 0;
|
||||
while (off < flen) {
|
||||
ssize_t w = write(fd, frame + off, flen - off);
|
||||
if (w < 0) { if (errno == EAGAIN || errno == EINTR) continue; break; }
|
||||
off += (size_t)w;
|
||||
}
|
||||
}
|
||||
|
||||
static long now_ms(void) {
|
||||
struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
return ts.tv_sec * 1000L + ts.tv_nsec / 1000000L;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ event collection */
|
||||
static void handle(info_t *c, const mc_event_t *ev) {
|
||||
switch (ev->code) {
|
||||
case MC_RESP_DEVICE_INFO: c->dev = ev->u.device_info; c->have_device = 1; break;
|
||||
case MC_RESP_SELF_INFO: c->self = ev->u.self_info; c->have_self = 1; break;
|
||||
case MC_RESP_CURR_TIME: c->epoch = ev->u.curr_time; c->have_time = 1; break;
|
||||
case MC_RESP_CHANNEL_INFO: {
|
||||
uint8_t i = ev->u.channel_info.channel_idx;
|
||||
if (i < MAX_CHANNELS) { c->chan[i] = ev->u.channel_info; c->chan_got[i] = 1; }
|
||||
break;
|
||||
}
|
||||
case MC_RESP_STATS:
|
||||
if (ev->u.stats.subtype == MC_STATS_CORE) { c->core = ev->u.stats; c->have_core = 1; }
|
||||
else if (ev->u.stats.subtype == MC_STATS_RADIO) { c->radio = ev->u.stats; c->have_radio = 1; }
|
||||
else if (ev->u.stats.subtype == MC_STATS_PACKETS) { c->packets = ev->u.stats; c->have_packets = 1; }
|
||||
break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Pump the tty until `done(c)` is satisfied or `cap_ms` elapses. */
|
||||
static void pump(int fd, mc_rx_t *rx, info_t *c, int (*done)(const info_t *), long cap_ms) {
|
||||
long deadline = now_ms() + cap_ms;
|
||||
for (;;) {
|
||||
if (done && done(c)) return;
|
||||
long rem = deadline - now_ms();
|
||||
if (rem <= 0) return;
|
||||
|
||||
fd_set rf; FD_ZERO(&rf); FD_SET(fd, &rf);
|
||||
struct timeval tv = { rem / 1000, (rem % 1000) * 1000 };
|
||||
int r = select(fd + 1, &rf, NULL, NULL, &tv);
|
||||
if (r < 0) { if (errno == EINTR) continue; return; }
|
||||
if (r == 0) return; /* timed out */
|
||||
|
||||
uint8_t in[256];
|
||||
ssize_t got = read(fd, in, sizeof in);
|
||||
if (got <= 0) { if (got < 0 && (errno == EAGAIN || errno == EINTR)) continue; return; }
|
||||
mc_rx_feed(rx, in, (size_t)got);
|
||||
|
||||
uint8_t pl[MC_MAX_PAYLOAD]; size_t pn;
|
||||
while (mc_rx_poll(rx, pl, sizeof pl, &pn)) {
|
||||
mc_event_t ev;
|
||||
if (mc_parse(pl, pn, &ev)) handle(c, &ev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int identity_ready(const info_t *c) { return c->have_device && c->have_self && c->have_time; }
|
||||
static int details_ready(const info_t *c) {
|
||||
for (int i = 0; i < c->nchan; i++) if (!c->chan_got[i]) return 0;
|
||||
return c->have_core && c->have_radio && c->have_packets;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- output */
|
||||
static void print_report(const info_t *c) {
|
||||
if (!c->have_device && !c->have_self) {
|
||||
printf("No response from the radio. Is it the serial companion firmware,\n"
|
||||
"bound to this port at 115200 8N1?\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (c->have_device) {
|
||||
const mc_device_info_t *d = &c->dev;
|
||||
printf("Device\n");
|
||||
printf(" model : %s\n", d->model);
|
||||
printf(" firmware ver : %d\n", d->fw_ver);
|
||||
if (d->ver[0]) printf(" version : %s\n", d->ver);
|
||||
if (d->build_date[0]) printf(" build date : %s\n", d->build_date);
|
||||
printf(" max channels : %u\n", d->max_channels);
|
||||
printf(" max contacts : %u\n", d->max_contacts);
|
||||
printf(" BLE pin : %u\n", d->ble_pin);
|
||||
if (d->have_repeat) printf(" repeater mode : %s\n", d->repeat ? "yes" : "no");
|
||||
if (d->have_path_hash) printf(" path hash mode: %u\n", d->path_hash_mode);
|
||||
}
|
||||
|
||||
if (c->have_self) {
|
||||
const mc_self_info_t *s = &c->self;
|
||||
printf("\nRadio / identity\n");
|
||||
printf(" name : %s\n", s->name);
|
||||
printf(" public key : ");
|
||||
for (int i = 0; i < 8; i++) printf("%02x", s->public_key[i]);
|
||||
printf("...\n");
|
||||
printf(" frequency : %.3f MHz\n", s->radio_freq / 1000.0);
|
||||
printf(" bandwidth : %.1f kHz\n", s->radio_bw / 1000.0);
|
||||
printf(" spreading : SF%u\n", s->radio_sf);
|
||||
printf(" coding rate : 4/%u\n", s->radio_cr);
|
||||
printf(" tx power : %u dBm (max %u)\n", s->tx_power, s->max_tx_power);
|
||||
if (s->adv_lat || s->adv_lon)
|
||||
printf(" advert loc : %.6f, %.6f\n", s->adv_lat / 1e6, s->adv_lon / 1e6);
|
||||
printf(" telemetry mode: base=%u loc=%u env=%u\n", s->tm_base, s->tm_loc, s->tm_env);
|
||||
printf(" multi acks : %u\n", s->multi_acks);
|
||||
}
|
||||
|
||||
if (c->have_time) {
|
||||
time_t t = (time_t)c->epoch;
|
||||
struct tm tmv; char buf[32] = "";
|
||||
if (gmtime_r(&t, &tmv)) strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S UTC", &tmv);
|
||||
printf("\nClock\n device time : %u (%s)\n", c->epoch, buf);
|
||||
}
|
||||
|
||||
if (c->nchan > 0) {
|
||||
printf("\nChannels (%d)\n", c->nchan);
|
||||
for (int i = 0; i < c->nchan; i++) {
|
||||
if (!c->chan_got[i]) { printf(" [%2d] (no response)\n", i); continue; }
|
||||
const mc_channel_info_t *ch = &c->chan[i];
|
||||
int configured = ch->name[0] != 0;
|
||||
if (configured) { // can print unconfigured
|
||||
printf(" [%2d] %-16s psk=", i, configured ? ch->name : "(unconfigured)");
|
||||
if (ch->have_secret) { for (int k = 0; k < MC_SECRET_LEN; k++) printf("%02x", ch->secret[k]); }
|
||||
else printf("(none)");
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (c->have_core || c->have_radio || c->have_packets) {
|
||||
printf("\nStats\n");
|
||||
if (c->have_core)
|
||||
printf(" battery : %u mV uptime %u s errors %u queue %u\n",
|
||||
c->core.u.core.battery_mv, c->core.u.core.uptime_secs,
|
||||
c->core.u.core.errors, c->core.u.core.queue_len);
|
||||
if (c->have_radio)
|
||||
printf(" radio : noise %d last RSSI %d last SNR %.1f dB air tx %u s rx %u s\n",
|
||||
c->radio.u.radio.noise_floor, c->radio.u.radio.last_rssi,
|
||||
(double)MC_SNR_DB(c->radio.u.radio.last_snr_q4),
|
||||
c->radio.u.radio.tx_air_secs, c->radio.u.radio.rx_air_secs);
|
||||
if (c->have_packets) {
|
||||
const mc_stats_t *p = &c->packets;
|
||||
printf(" packets : recv %u sent %u flood tx/rx %u/%u direct tx/rx %u/%u",
|
||||
p->u.packets.recv, p->u.packets.sent, p->u.packets.flood_tx,
|
||||
p->u.packets.flood_rx, p->u.packets.direct_tx, p->u.packets.direct_rx);
|
||||
if (p->has_recv_errors) printf(" recv errors %u", p->u.packets.recv_errors);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- main */
|
||||
int main(int argc, char **argv) {
|
||||
if (argc < 2) {
|
||||
fprintf(stderr, "usage: %s <tty> e.g. /dev/ttyACM0, /dev/ttyUSB0\n", argv[0]);
|
||||
return 2;
|
||||
}
|
||||
int fd = tty_open(argv[1]);
|
||||
if (fd < 0) return 1;
|
||||
|
||||
info_t c;
|
||||
memset(&c, 0, sizeof c);
|
||||
mc_rx_t rx; mc_rx_init(&rx);
|
||||
|
||||
uint8_t cmd[MC_MAX_PAYLOAD]; size_t n;
|
||||
|
||||
/* Identity: AppStart -> SelfInfo, DeviceQuery -> DeviceInfo, plus time. */
|
||||
n = mc_cmd_app_start(cmd, sizeof cmd, "meshcore_info"); if (n) send_payload(fd, cmd, n);
|
||||
n = mc_cmd_device_query(cmd, sizeof cmd, 1); if (n) send_payload(fd, cmd, n);
|
||||
n = mc_cmd_get_device_time(cmd, sizeof cmd); if (n) send_payload(fd, cmd, n);
|
||||
pump(fd, &rx, &c, identity_ready, 2000);
|
||||
|
||||
/* Now that we know the channel count, enumerate channels + ask for stats. */
|
||||
if (c.have_device) {
|
||||
c.nchan = c.dev.max_channels;
|
||||
if (c.nchan > MAX_CHANNELS) c.nchan = MAX_CHANNELS;
|
||||
for (int i = 0; i < c.nchan; i++) {
|
||||
n = mc_cmd_get_channel(cmd, sizeof cmd, (uint8_t)i);
|
||||
if (n) send_payload(fd, cmd, n);
|
||||
}
|
||||
}
|
||||
n = mc_cmd_get_stats(cmd, sizeof cmd, MC_STATS_CORE); if (n) send_payload(fd, cmd, n);
|
||||
n = mc_cmd_get_stats(cmd, sizeof cmd, MC_STATS_RADIO); if (n) send_payload(fd, cmd, n);
|
||||
n = mc_cmd_get_stats(cmd, sizeof cmd, MC_STATS_PACKETS); if (n) send_payload(fd, cmd, n);
|
||||
pump(fd, &rx, &c, details_ready, 3000);
|
||||
|
||||
print_report(&c);
|
||||
close(fd);
|
||||
return c.have_device || c.have_self ? 0 : 1;
|
||||
}
|
||||
Reference in New Issue
Block a user