Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
260934f58This file is pinned to the selected release. Download the original to open it in your design tool.
/* command.c
Copyright (C) 2021-2026 Timo Kokkonen <tjko@iki.fi>
SPDX-License-Identifier: GPL-3.0-or-later
This file is part of FanPico.
FanPico is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
FanPico is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with FanPico. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <time.h>
#include <string.h>
#include <ctype.h>
#include <wctype.h>
#include <assert.h>
#include "pico/stdlib.h"
#include "pico/unique_id.h"
#include "pico/bootrom.h"
#include "pico/util/datetime.h"
#include "pico/aon_timer.h"
#include "pico/rand.h"
#include "hardware/watchdog.h"
#include "cJSON.h"
#include "b64/ccommon.h"
#include "fanpico.h"
#include "command_util.h"
#include "pico_sensor_lib.h"
#include "lfs.h"
#ifdef WIFI_SUPPORT
#include "lwip/ip_addr.h"
#include "lwip/stats.h"
#include "wolfssl/version.h"
#include "wolfssh/version.h"
#include "pico_telnetd/util.h"
#include "util_net.h"
#endif
#include "util_rp2.h"
struct error_t {
const char *error;
int error_num;
};
/* For now, mimic some actual instrument error codes/responses... */
const struct error_t error_codes[] = {
{ "No Error", 0 },
{ "Command Error", -100 },
{ "Syntax Error", -102 },
{ "Undefined Header", -113 },
{ NULL, 0 }
};
int last_error_num = 0;
const struct fanpico_state *st = NULL;
struct fanpico_config *conf = NULL;
/* credits.s */
extern const char fanpico_credits_text[];
/* Command functions */
int cmd_idn(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int i;
pico_unique_board_id_t board_id;
if (!query)
return 1;
printf("TJKO Industries,FANPICO-%s,", FANPICO_MODEL);
pico_get_unique_board_id(&board_id);
for (i = 0; i < PICO_UNIQUE_BOARD_ID_SIZE_BYTES; i++)
printf("%02x", board_id.id[i]);
printf(",%s%s\n", FANPICO_VERSION, FANPICO_BUILD_TAG);
return 0;
}
int cmd_exit(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
#if WIFI_SUPPORT
telnetserver_disconnect();
sshserver_disconnect();
#endif
return 0;
}
int cmd_who(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
#if WIFI_SUPPORT
telnetserver_who();
sshserver_who();
#endif
return 0;
}
int cmd_usb_boot(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
char buf[64];
const char *msg[] = {
"FIRMWARE UPGRADE MODE",
"=====================",
"Use file (.uf2):",
buf,
"",
"Copy file to: RPI-RP2",
"",
"Press RESET to abort.",
};
if (query)
return 1;
snprintf(buf, sizeof(buf), " fanpico-%s-%s", FANPICO_MODEL, PICO_BOARD);
display_message(8, msg);
reset_usb_boot(0, 0);
return 0; /* should never get this far... */
}
int cmd_board(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (cmd && !query)
return 1;
print_rp2_board_info();
return 0;
}
int cmd_version(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
const char* credits = fanpico_credits_text;
if (cmd && !query)
return 1;
printf("FanPico-%s v%s%s (%s; %s; SDK v%s; %s)\n\n",
FANPICO_MODEL,
FANPICO_VERSION,
FANPICO_BUILD_TAG,
__DATE__,
PICO_CMAKE_BUILD_TYPE,
PICO_SDK_VERSION_STRING,
PICO_BOARD);
if (query) {
printf("%s\n", credits);
#ifdef __GNUC__
printf("Compiled with: GCC v%s\n", __VERSION__);
#endif
printf("littlefs: %d.%d\n", LFS_VERSION_MAJOR, LFS_VERSION_MINOR);
printf("cJSON: %d.%d.%d\n", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);
printf("libb64: %d.%d\n", BASE64_VER_MAJOR, BASE64_VER_MINOR);
#ifdef WIFI_SUPPORT
printf("wolfSSH: %s\n", LIBWOLFSSH_VERSION_STRING);
printf("wolfSSL: %s\n", LIBWOLFSSL_VERSION_STRING);
#endif
printf("\n");
}
return 0;
}
int cmd_fans(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
printf("%d\n", FAN_COUNT);
return 0;
}
int cmd_led(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int mode;
if (query) {
printf("%d\n", conf->led_mode);
} else if (str_to_int(args, &mode, 10)) {
if (mode >= 0 && mode <= 2) {
log_msg(LOG_NOTICE, "Set system LED mode: %d -> %d", conf->led_mode, mode);
conf->led_mode = mode;
}
}
return 0;
}
int cmd_mbfans(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
printf("%d\n", MBFAN_COUNT);
return 0;
}
int cmd_sensors(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
printf("%d\n", SENSOR_COUNT);
return 0;
}
int cmd_vsensors(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
printf("%d\n", VSENSOR_COUNT);
return 0;
}
int cmd_vsensors_sources(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
for (int i = 0; i < VSENSOR_COUNT; i++) {
const struct vsensor_input *v = &conf->vsensors[i];
printf("vsensor%d,%s", i + 1, vsmode2str(v->mode));
switch (v->mode) {
case VSMODE_MANUAL:
printf(",%0.2f,%ld", v->default_temp, v->timeout);
break;
case VSMODE_ONEWIRE:
printf(",%016llx", v->onewire_addr);
break;
case VSMODE_I2C:
printf(",0x%02x,%s", v->i2c_addr, i2c_sensor_type_str(v->i2c_type));
break;
default:
for (int j = 0; j < VSENSOR_SOURCE_MAX_COUNT; j++) {
if (v->sensors[j])
printf(",%d", v->sensors[j]);
}
break;
}
printf("\n");
}
return 0;
}
int cmd_null(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
log_msg(LOG_INFO, "null command: %s %s (query=%d)", cmd, args, query);
return 0;
}
int cmd_debug(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int level;
if (query) {
printf("%d\n", get_debug_level());
} else if (str_to_int(args, &level, 10)) {
set_debug_level((level < 0 ? 0 : level));
}
return 0;
}
int cmd_log_level(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int level = get_log_level();
int new_level;
const char *name, *new_name;
name = log_priority2str(level);
if (query) {
if (name) {
printf("%s\n", name);
} else {
printf("%d\n", level);
}
} else {
if ((new_level = str2log_priority(args)) < 0)
return 1;
new_name = log_priority2str(new_level);
log_msg(LOG_NOTICE, "Change log level: %s (%d) -> %s (%d)",
(name ? name : ""), level, new_name, new_level);
set_log_level(new_level);
}
return 0;
}
int cmd_syslog_level(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int level = get_syslog_level();
int new_level;
const char *name, *new_name;
name = log_priority2str(level);
if (query) {
if (name) {
printf("%s\n", name);
} else {
printf("%d\n", level);
}
} else {
if ((new_level = str2log_priority(args)) < 0)
return 1;
new_name = log_priority2str(new_level);
log_msg(LOG_NOTICE, "Change syslog level: %s (%d) -> %s (%d)",
(name ? name : "N/A"), level, new_name, new_level);
set_syslog_level(new_level);
}
return 0;
}
int cmd_echo(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->local_echo, "Command Echo");
}
int cmd_display_type(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->display_type, sizeof(conf->display_type), "Display Type", NULL);
}
int cmd_display_theme(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->display_theme, sizeof(conf->display_theme), "Display Theme", NULL);
}
int cmd_display_logo(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->display_logo, sizeof(conf->display_logo), "Display Logo", NULL);
}
int cmd_display_layout_r(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->display_layout_r, sizeof(conf->display_layout_r),
"Display Layout (Right)", NULL);
}
int cmd_reset(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
const char *msg[] = {
" Rebooting...",
};
if (query)
return 1;
log_msg(LOG_ALERT, "Initiating reboot...");
display_message(1, msg);
update_persistent_memory();
watchdog_disable();
sleep_ms(500);
watchdog_reboot(0, SRAM_END, 1);
while (1);
/* Should never get this far... */
return 0;
}
int cmd_save_config(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
save_config();
return 0;
}
int cmd_print_config(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
print_config();
return 0;
}
int cmd_upload_config(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
#if WATCHDOG_ENABLED
watchdog_disable();
#endif
upload_config();
#if WATCHDOG_ENABLED
watchdog_enable(WATCHDOG_REBOOT_DELAY, 1);
#endif
return 0;
}
int cmd_delete_config(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
delete_config();
return 0;
}
int cmd_one(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
printf("1\n");
return 0;
}
int cmd_zero(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
printf("0\n");
return 0;
}
int cmd_read(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int i;
double rpm, pwm;
if (!query)
return 1;
for (i = 0; i < MBFAN_COUNT; i++) {
rpm = st->mbfan_freq[i] * 60 / conf->mbfans[i].rpm_factor;
printf("mbfan%d,\"%s\",%.0lf,%.2f,%.1f\n", i+1,
conf->mbfans[i].name,
rpm,
st->mbfan_freq[i],
st->mbfan_duty[i]);
}
for (i = 0; i < FAN_COUNT; i++) {
rpm = st->fan_freq[i] * 60 / conf->fans[i].rpm_factor;
printf("fan%d,\"%s\",%.0lf,%.2f,%.1f\n", i+1,
conf->fans[i].name,
rpm,
st->fan_freq[i],
st->fan_duty[i]);
}
for (i = 0; i < SENSOR_COUNT; i++) {
pwm = sensor_get_duty(&conf->sensors[i].map, st->temp[i]);
printf("sensor%d,\"%s\",%.1lf,%.1f\n", i+1,
conf->sensors[i].name,
st->temp[i],
pwm);
}
for (i = 0; i < VSENSOR_COUNT; i++) {
pwm = sensor_get_duty(&conf->vsensors[i].map, st->vtemp[i]);
printf("vsensor%d,\"%s\",%.1lf,%.1f\n", i+1,
conf->vsensors[i].name,
st->vtemp[i],
pwm);
}
return 0;
}
int cmd_vsensors_read(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int i;
if (!query)
return 1;
for (i = 0; i < VSENSOR_COUNT; i++) {
printf("vsensor%d,\"%s\",%.1lf,%.0f,%0.0f\n", i+1,
conf->vsensors[i].name,
st->vtemp[i],
st->vhumidity[i],
st->vpressure[i]);
}
return 0;
}
int cmd_fan_name(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_string_setting(cmd, args, query, prev_cmd, 0, conf->fans, FAN_COUNT,
sizeof(conf->fans[0]),
offsetof(struct fan_output, name), sizeof(conf->fans[0].name),
"fan%d: Name", NULL);
}
int cmd_fan_min_pwm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_uint8_setting(cmd, args, query, prev_cmd, 0, conf->fans, FAN_COUNT,
sizeof(conf->fans[0]), offsetof(struct fan_output, min_pwm),
"fan%d: Min PWM", 0, 100);
}
int cmd_fan_max_pwm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_uint8_setting(cmd, args, query, prev_cmd, 0, conf->fans, FAN_COUNT,
sizeof(conf->fans[0]), offsetof(struct fan_output, max_pwm),
"fan%d: Max PWM", 0, 100);
}
int cmd_fan_pwm_coef(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 0, conf->fans, FAN_COUNT,
sizeof(conf->fans[0]), offsetof(struct fan_output, pwm_coefficient),
"fan%d: PWM Coefficient", 0.0, 1000.0);
}
int cmd_fan_pwm_map(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan, i, count;
int val;
char *arg, *t, *saveptr;
struct pwm_map *map;
struct pwm_map new_map;
int ret = 0;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan < 0 || fan >= FAN_COUNT)
return 1;
map = &conf->fans[fan].map;
new_map.points = 0;
if (query) {
for (i = 0; i < map->points; i++) {
if (i > 0)
printf(",");
printf("%u,%u", map->pwm[i][0], map->pwm[i][1]);
}
printf("\n");
} else {
if (!(arg = strdup(args)))
return 2;
count = 0;
t = strtok_r(arg, ",", &saveptr);
while (t && count < MAX_MAP_POINTS * 2) {
val = atoi(t);
new_map.pwm[count / 2][count % 2] = val;
count++;
t = strtok_r(NULL, ",", &saveptr);
}
if (!t && (count >= 4) && (count % 2 == 0)) {
new_map.points = count / 2;
*map = new_map;
} else {
log_msg(LOG_WARNING, "fan%d: invalid new map: %s", fan + 1, args);
ret = 2;
}
free(arg);
}
return ret;
}
int cmd_fan_filter(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
int ret = 0;
char *tok, *saveptr, *param;
struct fan_output *f;
enum signal_filter_types new_filter;
void *new_ctx;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan < 0 || fan >= FAN_COUNT)
return 1;
f = &conf->fans[fan];
if (query) {
printf("%s", filter2str(f->filter));
tok = filter_print_args(f->filter, f->filter_ctx);
if (tok) {
printf(",%s\n", tok);
free(tok);
} else {
printf(",\n");
}
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
new_filter = str2filter(tok);
new_ctx = filter_parse_args(new_filter, saveptr ? saveptr : "");
if (new_filter == FILTER_NONE || new_ctx != NULL) {
f->filter = new_filter;
if (f->filter_ctx)
free(f->filter_ctx);
f->filter_ctx = new_ctx;
} else {
ret = 1;
}
}
free(param);
}
return ret;
}
int cmd_fan_rpm_factor(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_uint8_setting(cmd, args, query, prev_cmd, 0, conf->fans, FAN_COUNT,
sizeof(conf->fans[0]), offsetof(struct fan_output, rpm_factor),
"fan%d: RPM factor", 1, 8);
}
int cmd_fan_rpm_mode(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int ret = 0;
int fan, val;
struct fan_output *f;
char *tok, *saveptr, *param;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan < 0 || fan >= FAN_COUNT)
return 1;
f = &conf->fans[fan];
if (query) {
printf("%s", rpm_mode2str(f->rpm_mode));
if (f->rpm_mode == RMODE_LRA)
printf(",%d,%d", f->lra_low, f->lra_high);
printf("\n");
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
val = str2rpm_mode(tok);
if (val != f->rpm_mode) {
log_msg(LOG_NOTICE, "fan%d: rpm_mode change '%s' --> '%s'",
fan + 1, rpm_mode2str(f->rpm_mode), rpm_mode2str(val));
f->rpm_mode = val;
}
if (f->rpm_mode == RMODE_LRA) {
if ((tok = strtok_r(NULL, ",", &saveptr)) != NULL) {
if (str_to_int(tok, &val, 10)) {
f->lra_low = clamp_int(val, 0, 100000);
}
if ((tok = strtok_r(NULL, ",", &saveptr)) != NULL) {
if (str_to_int(tok, &val, 10)) {
f->lra_high = clamp_int(val, 0, 100000);
}
}
}
}
} else {
ret = 2;
}
free(param);
}
return ret;
}
int cmd_fan_source(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
int type, val, d_o, d_n;
char *tok, *saveptr, *param;
int ret = 0;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan < 0 || fan >= FAN_COUNT)
return 1;
if (query) {
val = conf->fans[fan].s_id;
if (conf->fans[fan].s_type != PWM_FIXED)
val++;
printf("%s,%u\n",
pwm_source2str(conf->fans[fan].s_type),
val);
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
type = str2pwm_source(tok);
d_n = (type != PWM_FIXED ? 1 : 0);
if ((tok = strtok_r(NULL, ",", &saveptr)) != NULL) {
val = atoi(tok) - d_n;
if (valid_pwm_source_ref(type, val)) {
d_o = (conf->fans[fan].s_type != PWM_FIXED ? 1 : 0);
log_msg(LOG_NOTICE, "fan%d: change source %s,%u --> %s,%u",
fan + 1,
pwm_source2str(conf->fans[fan].s_type),
conf->fans[fan].s_id + d_o,
pwm_source2str(type),
val + d_n);
conf->fans[fan].s_type = type;
conf->fans[fan].s_id = val;
} else {
log_msg(LOG_WARNING, "fan%d: invalid source: %s",
fan + 1, args);
ret = 2;
}
}
}
free(param);
}
return ret;
}
int cmd_fan_tacho_hys(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 1, conf->fans, FAN_COUNT,
sizeof(conf->fans[0]), offsetof(struct fan_output, tacho_hyst),
"fan%d: Tachometer Hysteresis", 0.0, 10000.0);
}
int cmd_fan_pwm_hys(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 1, conf->fans, FAN_COUNT,
sizeof(conf->fans[0]), offsetof(struct fan_output, pwm_hyst),
"fan%d: PWM Hysteresis", 0.0, 10000.0);
}
int cmd_fan_rpm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
double rpm;
if (!query)
return 1;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan >= 0 && fan < FAN_COUNT) {
rpm = st->fan_freq[fan] * 60.0 / conf->fans[fan].rpm_factor;
log_msg(LOG_DEBUG, "fan%d (tacho = %fHz) rpm = %.1lf", fan + 1,
st->fan_freq[fan], rpm);
printf("%.0lf\n", rpm);
return 0;
}
return 1;
}
int cmd_fan_tacho(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
float f;
if (!query)
return 1;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan >= 0 && fan < FAN_COUNT) {
f = st->fan_freq[fan];
log_msg(LOG_DEBUG, "fan%d tacho = %fHz", fan + 1, f);
printf("%.1f\n", f);
return 0;
}
return 1;
}
int cmd_fan_pwm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
float d;
if (!query)
return 1;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan >= 0 && fan < FAN_COUNT) {
d = st->fan_duty[fan];
log_msg(LOG_DEBUG, "fan%d duty = %f%%", fan + 1, d);
printf("%.0f\n", d);
return 0;
}
return 1;
}
int cmd_fan_read(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
double rpm;
float d, f;
if (!query)
return 1;
if (!strncasecmp(get_prev_cmd(prev_cmd, 0), "fan", 3)) {
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
} else {
fan = get_cmd_index(cmd) - 1;
}
if (fan >= 0 && fan < FAN_COUNT) {
d = st->fan_duty[fan];
f = st->fan_freq[fan];
rpm = f * 60.0 / conf->fans[fan].rpm_factor;
log_msg(LOG_DEBUG, "fan%d duty = %f%%, freq = %fHz, speed = %fRPM",
fan + 1, d, f, rpm);
printf("%.0f,%.1f,%.0f\n", d, f, rpm);
return 0;
}
return 1;
}
int cmd_mbfan_name(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_string_setting(cmd, args, query, prev_cmd, 0, conf->mbfans, MBFAN_COUNT,
sizeof(conf->mbfans[0]),
offsetof(struct mb_input, name), sizeof(conf->mbfans[0].name),
"mbfan%d: Name", NULL);
}
int cmd_mbfan_min_rpm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_uint16_setting(cmd, args, query, prev_cmd, 0, conf->mbfans, MBFAN_COUNT,
sizeof(conf->mbfans[0]), offsetof(struct mb_input, min_rpm),
"mbfan%d: Min RPM", 0, 50000);
}
int cmd_mbfan_max_rpm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_uint16_setting(cmd, args, query, prev_cmd, 0, conf->mbfans, MBFAN_COUNT,
sizeof(conf->mbfans[0]), offsetof(struct mb_input, max_rpm),
"mbfan%d: Max RPM", 0, 50000);
}
int cmd_mbfan_rpm_coef(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 0, conf->mbfans, MBFAN_COUNT,
sizeof(conf->mbfans[0]), offsetof(struct mb_input, rpm_coefficient),
"mbfan%d: RPM Coefficient", 0.0, 1000.0);
}
int cmd_mbfan_rpm_factor(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_uint8_setting(cmd, args, query, prev_cmd, 0, conf->mbfans, MBFAN_COUNT,
sizeof(conf->mbfans[0]), offsetof(struct mb_input, rpm_factor),
"mbfan%d: RPM factor", 1, 8);
}
int cmd_mbfan_rpm_map(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan, i, count;
int val;
char *arg, *t, *saveptr;
struct tacho_map *map;
struct tacho_map new_map;
int ret = 0;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan < 0 || fan >= MBFAN_COUNT)
return 0;
map = &conf->mbfans[fan].map;
new_map.points = 0;
if (query) {
for (i = 0; i < map->points; i++) {
if (i > 0)
printf(",");
printf("%u,%u", map->tacho[i][0], map->tacho[i][1]);
}
printf("\n");
} else {
if (!(arg = strdup(args)))
return 2;
count = 0;
t = strtok_r(arg, ",", &saveptr);
while (t && count < MAX_MAP_POINTS * 2) {
val = atoi(t);
new_map.tacho[count / 2][count % 2] = val;
count++;
t = strtok_r(NULL, ",", &saveptr);
}
if (!t && (count >= 4) && (count % 2 == 0)) {
new_map.points = count / 2;
*map = new_map;
} else {
log_msg(LOG_WARNING, "mbfan%d: invalid new map: %s", fan + 1, args);
ret = 2;
}
free(arg);
}
return ret;
}
int cmd_mbfan_rpm_mode(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int ret = 0;
int fan, val;
char *tok, *saveptr, *param;
struct mb_input *m;
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan < 0 || fan >= MBFAN_COUNT)
return 1;
m = &conf->mbfans[fan];
if (query) {
printf("%s", rpm_mode2str(m->rpm_mode));
if (m->rpm_mode == RMODE_LRA)
printf(",%d,%s", m->lra_treshold, (m->lra_invert ? "HIGH" : "LOW"));
printf("\n");
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
val = str2rpm_mode(tok);
if (val != m->rpm_mode) {
log_msg(LOG_NOTICE, "mbfan%d: rpm_mode change '%s' -> '%s'",
fan + 1, rpm_mode2str(m->rpm_mode), rpm_mode2str(val));
m->rpm_mode = val;
}
if (m->rpm_mode == RMODE_LRA) {
if ((tok = strtok_r(NULL, ",", &saveptr)) != NULL) {
if (str_to_int(tok, &val, 10)) {
m->lra_treshold = clamp_int(val, 0, 100000);
}
if ((tok = strtok_r(NULL, ",", &saveptr)) != NULL) {
bool invert = false;
if (!strncasecmp(tok, "HIGH", 1))
invert = true;
m->lra_invert = invert;
}
}
}
} else {
ret = 2;
}
free(param);
}
return ret;
}
int cmd_mbfan_source(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
int type, val, d_o, d_n, ocount;
char *tok, *saveptr, *param;
uint8_t new_sources[FAN_MAX_COUNT];
enum tacho_source_types s_type;
int ret = 0;
memset(new_sources, 0, sizeof(new_sources));
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan < 0 || fan >= MBFAN_COUNT)
return 1;
s_type = conf->mbfans[fan].s_type;
if (query) {
printf("%s,", tacho_source2str(s_type));
switch (s_type) {
case TACHO_FIXED:
case TACHO_FAN:
val = conf->mbfans[fan].s_id;
if (s_type != TACHO_FIXED)
val++;
printf("%u", val);
break;
case TACHO_MIN:
case TACHO_MAX:
case TACHO_AVG:
ocount = 0;
for (int i = 0; i < FAN_COUNT; i++) {
if (conf->mbfans[fan].sources[i]) {
if (ocount > 0)
printf(",");
printf("%u", i + 1);
ocount++;
}
}
break;
}
printf("\n");
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
type = str2tacho_source(tok);
d_n = (type != TACHO_FIXED ? 1 : 0);
while ((tok = strtok_r(NULL, ",", &saveptr)) != NULL) {
val = atoi(tok) - d_n;
if (valid_tacho_source_ref(type, val)) {
if (type == TACHO_FIXED || type == TACHO_FAN) {
d_o = (conf->mbfans[fan].s_type != TACHO_FIXED ? 1 : 0);
log_msg(LOG_NOTICE, "mbfan%d: change source %s,%u --> %s,%u",
fan + 1,
tacho_source2str(conf->mbfans[fan].s_type),
conf->mbfans[fan].s_id + d_o,
tacho_source2str(type),
val + d_n);
conf->mbfans[fan].s_type = type;
conf->mbfans[fan].s_id = val;
break;
}
new_sources[val] = 1;
} else {
log_msg(LOG_WARNING, "mbfan%d: invalid source: %s",
fan + 1, args);
ret = 2;
break;
}
}
if (type == TACHO_MIN || type == TACHO_MAX || type == TACHO_AVG) {
int scount = 0;
for (int i = 0; i < FAN_COUNT; i++) {
if (new_sources[i])
scount++;
}
if (scount >= 2) {
log_msg(LOG_NOTICE, "mbfan%d: new source %s", fan + 1, args);
conf->mbfans[fan].s_type = type;
conf->mbfans[fan].s_id = 0;
memcpy(conf->mbfans[fan].sources, new_sources,
sizeof(conf->mbfans[fan].sources));
} else {
log_msg(LOG_WARNING, "mbfan%d: too few parameters: %s",
fan + 1, args);
ret = 2;
}
}
}
free(param);
}
return ret;
}
int cmd_mbfan_rpm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
double rpm;
if (query) {
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan >= 0 && fan < MBFAN_COUNT) {
rpm = st->mbfan_freq[fan] * 60.0 / conf->mbfans[fan].rpm_factor;
log_msg(LOG_DEBUG, "mbfan%d (tacho = %fHz) rpm = %.1lf", fan+1,
st->mbfan_freq[fan], rpm);
printf("%.0lf\n", rpm);
return 0;
}
}
return 1;
}
int cmd_mbfan_tacho(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
float f;
if (query) {
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan >= 0 && fan < MBFAN_COUNT) {
f = st->mbfan_freq[fan];
log_msg(LOG_DEBUG, "mbfan%d tacho = %fHz", fan + 1, f);
printf("%.1f\n", f);
return 0;
}
}
return 1;
}
int cmd_mbfan_pwm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
float d;
if (query) {
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (fan >= 0 && fan < MBFAN_COUNT) {
d = st->mbfan_duty[fan];
log_msg(LOG_DEBUG, "mbfan%d duty = %f%%", fan + 1, d);
printf("%.0f\n", d);
return 0;
}
}
return 1;
}
int cmd_mbfan_read(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int fan;
double rpm;
float d, f;
if (!query)
return 1;
if (!strncasecmp(get_prev_cmd(prev_cmd, 0), "mbfan", 5)) {
fan = get_prev_cmd_index(prev_cmd, 0) - 1;
} else {
fan = get_cmd_index(cmd) - 1;
}
if (fan >= 0 && fan < MBFAN_COUNT) {
d = st->mbfan_duty[fan];
f = st->mbfan_freq[fan];
rpm = f * 60.0 / conf->mbfans[fan].rpm_factor;
log_msg(LOG_DEBUG, "mbfan%d duty = %f%%, freq = %fHz, speed = %fRPM",
fan + 1, d, f, rpm);
printf("%.0f,%.1f,%.0f\n", d, f, rpm);
return 0;
}
return 1;
}
int cmd_mbfan_filter(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int mbfan;
int ret = 0;
char *tok, *saveptr, *param;
struct mb_input *m;
enum signal_filter_types new_filter;
void *new_ctx;
mbfan = get_prev_cmd_index(prev_cmd, 0) - 1;
if (mbfan < 0 || mbfan >= MBFAN_COUNT)
return 1;
m = &conf->mbfans[mbfan];
if (query) {
printf("%s", filter2str(m->filter));
tok = filter_print_args(m->filter, m->filter_ctx);
if (tok) {
printf(",%s\n", tok);
free(tok);
} else {
printf(",\n");
}
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
new_filter = str2filter(tok);
new_ctx = filter_parse_args(new_filter, saveptr ? saveptr : "");
if (new_filter == FILTER_NONE || new_ctx != NULL) {
m->filter = new_filter;
if (m->filter_ctx)
free(m->filter_ctx);
m->filter_ctx = new_ctx;
} else {
ret = 1;
}
}
free(param);
}
return ret;
}
int cmd_sensor_name(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_string_setting(cmd, args, query, prev_cmd, 0, conf->sensors, SENSOR_COUNT,
sizeof(conf->sensors[0]),
offsetof(struct sensor_input, name), sizeof(conf->sensors[0].name),
"sensor%d: Name", NULL);
}
int cmd_sensor_temp_offset(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 0, conf->sensors, SENSOR_COUNT,
sizeof(conf->sensors[0]), offsetof(struct sensor_input, temp_offset),
"sensor%d: Temperature Offset", -10000.0, 10000.0);
}
int cmd_sensor_temp_coef(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 0, conf->sensors, SENSOR_COUNT,
sizeof(conf->sensors[0]), offsetof(struct sensor_input, temp_coefficient),
"sensor%d: Temperature Coefficient", 0.0, 1000.0);
}
int cmd_sensor_temp_nominal(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 0, conf->sensors, SENSOR_COUNT,
sizeof(conf->sensors[0]), offsetof(struct sensor_input, temp_nominal),
"sensor%d: Temperature Nominal", -50.0, 100.0);
}
int cmd_sensor_ther_nominal(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 0, conf->sensors, SENSOR_COUNT,
sizeof(conf->sensors[0]), offsetof(struct sensor_input, thermistor_nominal),
"sensor%d: Thermistor Nominal", 0.0, 100000.0);
}
int cmd_adc_vref(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return float_setting(cmd, args, query, prev_cmd,
&conf->adc_vref, 0.0, 100.0, "ADC Reference Voltage");
}
int cmd_sensor_beta_coef(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_float_setting(cmd, args, query, prev_cmd, 0, conf->sensors, SENSOR_COUNT,
sizeof(conf->sensors[0]), offsetof(struct sensor_input, beta_coefficient),
"sensor%d: Beta Coefficient", 0.0, 100000.0);
}
int cmd_sensor_temp_map(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor, i, count;
float val;
char *arg, *t, *saveptr;
struct temp_map *map;
struct temp_map new_map;
int ret = 0;
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
if (sensor < 0 || sensor >= SENSOR_COUNT)
return 1;
map = &conf->sensors[sensor].map;
new_map.points = 0;
if (query) {
for (i = 0; i < map->points; i++) {
if (i > 0)
printf(",");
printf("%f,%f", map->temp[i][0], map->temp[i][1]);
}
printf("\n");
} else {
if (!(arg = strdup(args)))
return 2;
count = 0;
t = strtok_r(arg, ",", &saveptr);
while (t && count < MAX_MAP_POINTS * 2) {
val = atof(t);
new_map.temp[count / 2][count % 2] = val;
count++;
t = strtok_r(NULL, ",", &saveptr);
}
if (!t && (count >= 4) && (count % 2 == 0)) {
new_map.points = count / 2;
*map = new_map;
} else {
log_msg(LOG_WARNING, "sensor%d: invalid new map: %s", sensor + 1, args);
ret = 2;
}
free(arg);
}
return ret;
}
int cmd_sensor_temp(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor;
float d;
if (!query)
return 1;
if (!strncasecmp(get_prev_cmd(prev_cmd, 0), "sensor", 6)) {
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
} else {
sensor = get_cmd_index(cmd) - 1;
}
if (sensor >= 0 && sensor < SENSOR_COUNT) {
d = st->temp[sensor];
log_msg(LOG_DEBUG, "sensor%d temperature = %fC", sensor + 1, d);
printf("%.0f\n", d);
return 0;
}
return 1;
}
int cmd_sensor_filter(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor;
int ret = 0;
char *tok, *saveptr, *param;
struct sensor_input *s;
enum signal_filter_types new_filter;
void *new_ctx;
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
if (sensor < 0 || sensor >= SENSOR_COUNT)
return 1;
s = &conf->sensors[sensor];
if (query) {
printf("%s", filter2str(s->filter));
tok = filter_print_args(s->filter, s->filter_ctx);
if (tok) {
printf(",%s\n", tok);
free(tok);
} else {
printf(",\n");
}
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
new_filter = str2filter(tok);
new_ctx = filter_parse_args(new_filter, saveptr ? saveptr : "");
if (new_filter == FILTER_NONE || new_ctx != NULL) {
s->filter = new_filter;
if (s->filter_ctx)
free(s->filter_ctx);
s->filter_ctx = new_ctx;
} else {
ret = 1;
}
}
free(param);
}
return ret;
}
int cmd_vsensor_name(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return array_string_setting(cmd, args, query, prev_cmd, 0, conf->vsensors, VSENSOR_COUNT,
sizeof(conf->vsensors[0]), offsetof(struct vsensor_input, name),
sizeof(conf->vsensors[0].name), "vensor%d: Name", NULL);
}
int cmd_vsensor_source(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
struct vsensor_input *v;
int sensor, val, i;
uint8_t vsmode, selected[VSENSOR_SOURCE_MAX_COUNT];
float default_temp;
int timeout;
char *tok, *saveptr, *param, temp_str[32], tmp[8];
int ret = 0;
int count = 0;
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
if (sensor < 0 || sensor >= VSENSOR_COUNT)
return 1;
v = &conf->vsensors[sensor];
if (query) {
printf("%s", vsmode2str(v->mode));
if (v->mode == VSMODE_MANUAL) {
printf(",%0.2f,%ld", v->default_temp, v->timeout);
} else if (v->mode == VSMODE_ONEWIRE) {
printf(",%016llx", v->onewire_addr);
} else if (v->mode == VSMODE_I2C) {
printf(",0x%02x,%s", v->i2c_addr, i2c_sensor_type_str(v->i2c_type));
} else {
for(i = 0; i < VSENSOR_SOURCE_MAX_COUNT; i++) {
if (v->sensors[i])
printf(",%d", v->sensors[i]);
}
}
printf("\n");
} else {
ret = 2;
if ((param = strdup(args)) == NULL)
return 1;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
vsmode = str2vsmode(tok);
if (vsmode == VSMODE_MANUAL) {
tok = strtok_r(NULL, ",", &saveptr);
if (str_to_float(tok, &default_temp)) {
tok = strtok_r(NULL, ",", &saveptr);
if (str_to_int(tok, &timeout, 10)) {
if (timeout < 0)
timeout = 0;
log_msg(LOG_NOTICE, "vsensor%d: set source to %s,%0.2f,%d",
sensor + 1,
vsmode2str(vsmode),
default_temp,
timeout);
v->mode = vsmode;
v->default_temp = default_temp;
v->timeout = timeout;
ret = 0;
}
}
} else if (vsmode == VSMODE_ONEWIRE) {
tok = strtok_r(NULL, ",", &saveptr);
uint64_t addr = strtoull(tok, NULL, 16);
if (addr > 0) {
log_msg(LOG_NOTICE, "vsensor%d: set source to %s,%016llx",
sensor + 1,
vsmode2str(vsmode),
addr);
v->mode = vsmode;
v->onewire_addr = addr;
ret = 0;
}
} else if (vsmode == VSMODE_I2C) {
tok = strtok_r(NULL, ",", &saveptr);
if (str_to_int(tok, &val, 16)) {
if (val > 0 && val < 128 && !i2c_reserved_address(val)) {
tok = strtok_r(NULL, ",", &saveptr);
uint type = get_i2c_sensor_type(tok);
if (type > 0) {
log_msg(LOG_NOTICE, "vsensor%d: set source to %s,0x%02x,%s",
sensor + 1,
vsmode2str(vsmode),
val,
i2c_sensor_type_str(type));
v->mode = vsmode;
v->i2c_type = type;
v->i2c_addr = val;
ret = 0;
}
}
}
} else {
temp_str[0] = 0;
for(i = 0; i < VSENSOR_SOURCE_MAX_COUNT; i++)
selected[i] = 0;
while((tok = strtok_r(NULL, ",", &saveptr)) != NULL) {
if (count < VSENSOR_SOURCE_MAX_COUNT && str_to_int(tok, &val, 10)) {
if ((val >= 1 && val <= SENSOR_COUNT)
|| (val >= 101 && val <= 100 + VSENSOR_COUNT)) {
selected[count++] = val;
snprintf(tmp, sizeof(tmp), ",%d", val);
strncatenate(temp_str, tmp, sizeof(temp_str));
}
}
}
if (count >= 2) {
log_msg(LOG_NOTICE, "vsensor%d: set source to %s%s",
sensor + 1,
vsmode2str(vsmode),
temp_str);
v->mode = vsmode;
for(i = 0; i < SENSOR_COUNT; i++) {
v->sensors[i] = selected[i];
}
ret = 0;
}
}
}
free(param);
}
return ret;
}
int cmd_vsensor_temp_map(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor, i, count;
float val;
char *arg, *t, *saveptr;
struct temp_map *map;
struct temp_map new_map;
int ret = 0;
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
if (sensor < 0 || sensor >= VSENSOR_COUNT)
return 1;
map = &conf->vsensors[sensor].map;
new_map.points = 0;
if (query) {
for (i = 0; i < map->points; i++) {
if (i > 0)
printf(",");
printf("%f,%f", map->temp[i][0], map->temp[i][1]);
}
printf("\n");
} else {
if (!(arg = strdup(args)))
return 2;
count = 0;
t = strtok_r(arg, ",", &saveptr);
while (t && count < MAX_MAP_POINTS * 2) {
val = atof(t);
new_map.temp[count / 2][count % 2] = val;
count++;
t = strtok_r(NULL, ",", &saveptr);
}
if (!t && (count >= 4) && (count % 2 == 0)) {
new_map.points = count / 2;
*map = new_map;
} else {
log_msg(LOG_WARNING, "vsensor%d: invalid new map: %s", sensor + 1, args);
ret = 2;
}
free(arg);
}
return ret;
}
int cmd_vsensor_temp(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor;
float d;
if (!query)
return 1;
if (!strncasecmp(get_prev_cmd(prev_cmd, 0), "vsensor", 7)) {
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
} else {
sensor = get_cmd_index(cmd) - 1;
}
if (sensor >= 0 && sensor < VSENSOR_COUNT) {
d = st->vtemp[sensor];
log_msg(LOG_DEBUG, "vsensor%d temperature = %fC", sensor + 1, d);
printf("%.0f\n", d);
return 0;
}
return 1;
}
int cmd_vsensor_humidity(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor;
float d;
if (!query)
return 1;
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
if (sensor >= 0 && sensor < VSENSOR_COUNT) {
d = st->vhumidity[sensor];
log_msg(LOG_DEBUG, "vsensor%d humidity = %f%%", sensor + 1, d);
printf("%.0f\n", d);
return 0;
}
return 1;
}
int cmd_vsensor_pressure(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor;
float d;
if (!query)
return 1;
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
if (sensor >= 0 && sensor < VSENSOR_COUNT) {
d = st->vpressure[sensor];
log_msg(LOG_DEBUG, "vsensor%d pressure = %fhPa", sensor + 1, d);
printf("%.0f\n", d);
return 0;
}
return 1;
}
int cmd_vsensor_filter(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor;
int ret = 0;
char *tok, *saveptr, *param;
struct vsensor_input *s;
enum signal_filter_types new_filter;
void *new_ctx;
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
if (sensor < 0 || sensor >= VSENSOR_COUNT)
return 1;
s = &conf->vsensors[sensor];
if (query) {
printf("%s", filter2str(s->filter));
tok = filter_print_args(s->filter, s->filter_ctx);
if (tok) {
printf(",%s\n", tok);
free(tok);
} else {
printf(",\n");
}
} else {
if (!(param = strdup(args)))
return 2;
if ((tok = strtok_r(param, ",", &saveptr)) != NULL) {
new_filter = str2filter(tok);
new_ctx = filter_parse_args(new_filter, saveptr ? saveptr : "");
if (new_filter == FILTER_NONE || new_ctx != NULL) {
s->filter = new_filter;
if (s->filter_ctx)
free(s->filter_ctx);
s->filter_ctx = new_ctx;
} else {
ret = 1;
}
}
free(param);
}
return ret;
}
int cmd_vsensor_write(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int sensor;
float val;
if (query)
return 1;
if (!strncasecmp(get_prev_cmd(prev_cmd, 0), "vsensor", 7)) {
sensor = get_prev_cmd_index(prev_cmd, 0) - 1;
} else {
sensor = get_cmd_index(cmd) - 1;
}
if (sensor >= 0 && sensor < VSENSOR_COUNT) {
if (conf->vsensors[sensor].mode == VSMODE_MANUAL) {
if (str_to_float(args, &val)) {
log_msg(LOG_INFO, "vsensor%d: write temperature = %fC", sensor + 1, val);
conf->vtemp[sensor] = val;
conf->vtemp_updated[sensor] = get_absolute_time();
return 0;
}
} else {
return 2;
}
}
return 1;
}
int cmd_wifi(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query) {
#ifdef WIFI_SUPPORT
if (rp2_is_picow()) {
printf("1\n");
return 0;
}
#endif
printf("0\n");
return 0;
}
return 1;
}
#ifdef WIFI_SUPPORT
int cmd_wifi_ip(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return ip_change(cmd, args, query, prev_cmd, "IP", &conf->ip);
}
int cmd_wifi_netmask(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return ip_change(cmd, args, query, prev_cmd, "Netmask", &conf->netmask);
}
int cmd_wifi_gateway(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return ip_change(cmd, args, query, prev_cmd, "Default Gateway", &conf->gateway);
}
int cmd_wifi_dns(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return ip_list_change(cmd, args, query, prev_cmd, "DNS Servers", conf->dns_servers,
DNS_MAX_SERVERS);
}
int cmd_wifi_syslog_client(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd, &conf->syslog_active, "Syslog Client");
}
int cmd_wifi_syslog(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return ip_change(cmd, args, query, prev_cmd, "Syslog Server", &conf->syslog_server);
}
int cmd_wifi_ntp_client(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd, &conf->ntp_active, "NTP Client");
}
int cmd_wifi_ntp(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return ip_list_change(cmd, args, query, prev_cmd, "NTP Servers", conf->ntp_servers,
SNTP_MAX_SERVERS);
}
int cmd_wifi_mac(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query) {
printf("%s\n", mac_address_str(net_state->mac));
return 0;
}
return 1;
}
int cmd_wifi_ssid(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->wifi_ssid, sizeof(conf->wifi_ssid), "WiFi SSID", NULL);
}
int cmd_wifi_status(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query) {
wifi_status();
return 0;
}
return 1;
}
int cmd_wifi_stats(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query) {
stats_display();
return 0;
}
return 1;
}
int cmd_wifi_info(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query) {
wifi_info_display();
return 0;
}
return 1;
}
int cmd_wifi_rejoin(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query) {
wifi_rejoin();
return 0;
}
return 1;
}
int cmd_wifi_country(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->wifi_country, sizeof(conf->wifi_country),
"WiFi Country", valid_wifi_country);
}
int cmd_wifi_password(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return secret_setting(cmd, args, query, prev_cmd,
conf->wifi_passwd, sizeof(conf->wifi_passwd), "WiFi Password", NULL);
}
int cmd_wifi_hostname(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->hostname, sizeof(conf->hostname),
"WiFi Hostname", valid_hostname);
}
int cmd_wifi_auth_mode(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
uint32_t type;
if (query) {
printf("%s\n", conf->wifi_auth_mode);
} else {
if (!wifi_get_auth_type(args, &type))
return 1;
if (strncmp(conf->wifi_auth_mode, args, sizeof(conf->wifi_auth_mode))) {
log_msg(LOG_NOTICE, "WiFi Auth Type change %s --> %s",
conf->wifi_auth_mode, args);
strncopy(conf->wifi_auth_mode, args, sizeof(conf->wifi_auth_mode));
}
}
return 0;
}
int cmd_wifi_mode(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint8_setting(cmd, args, query, prev_cmd,
&conf->wifi_mode, 0, 1, "WiFi Mode");
}
int cmd_mqtt_server(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_server, sizeof(conf->mqtt_server), "MQTT Server", NULL);
}
int cmd_mqtt_port(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_port, 0, 65535, "MQTT Port");
}
int cmd_mqtt_user(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_user, sizeof(conf->mqtt_user), "MQTT User", NULL);
}
int cmd_mqtt_pass(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return secret_setting(cmd, args, query, prev_cmd,
conf->mqtt_pass, sizeof(conf->mqtt_pass), "MQTT Password", NULL);
}
int cmd_mqtt_status_interval(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint32_setting(cmd, args, query, prev_cmd,
&conf->mqtt_status_interval, 0, (86400 * 30), "MQTT Publish Status Interval");
}
int cmd_mqtt_temp_interval(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint32_setting(cmd, args, query, prev_cmd,
&conf->mqtt_temp_interval, 0, (86400 * 30), "MQTT Publish Temp Interval");
}
int cmd_mqtt_vsensor_interval(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint32_setting(cmd, args, query, prev_cmd,
&conf->mqtt_vsensor_interval, 0, (86400 * 30), "MQTT Publish VSENSOR Interval");
}
int cmd_mqtt_rpm_interval(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint32_setting(cmd, args, query, prev_cmd,
&conf->mqtt_rpm_interval, 0, (86400 * 30), "MQTT Publish RPM Interval");
}
int cmd_mqtt_duty_interval(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint32_setting(cmd, args, query, prev_cmd,
&conf->mqtt_duty_interval, 0, (86400 * 30), "MQTT Publish PWM Interval");
}
int cmd_mqtt_allow_scpi(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->mqtt_allow_scpi, "MQTT Allow SCPI Commands");
}
int cmd_mqtt_status_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_status_topic, sizeof(conf->mqtt_status_topic),
"MQTT Status Topic", NULL);
}
int cmd_mqtt_cmd_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_cmd_topic, sizeof(conf->mqtt_cmd_topic),
"MQTT Command Topic", NULL);
}
int cmd_mqtt_resp_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_resp_topic,
sizeof(conf->mqtt_resp_topic), "MQTT Response Topic", NULL);
}
int cmd_mqtt_temp_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_temp_topic,
sizeof(conf->mqtt_temp_topic), "MQTT Temperature Topic", NULL);
}
int cmd_mqtt_vtemp_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_vtemp_topic,
sizeof(conf->mqtt_vtemp_topic), "MQTT VTemperature Topic", NULL);
}
int cmd_mqtt_vhumidity_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_vhumidity_topic,
sizeof(conf->mqtt_vhumidity_topic), "MQTT VHumidity Topic", NULL);
}
int cmd_mqtt_vpressure_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_vpressure_topic,
sizeof(conf->mqtt_vpressure_topic), "MQTT VPressure Topic", NULL);
}
int cmd_mqtt_fan_rpm_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_fan_rpm_topic,
sizeof(conf->mqtt_fan_rpm_topic), "MQTT Fan RPM Topic", NULL);
}
int cmd_mqtt_fan_duty_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_fan_duty_topic,
sizeof(conf->mqtt_fan_duty_topic), "MQTT Fan PWM Topic", NULL);
}
int cmd_mqtt_mbfan_rpm_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_mbfan_rpm_topic,
sizeof(conf->mqtt_mbfan_rpm_topic), "MQTT MBFan RPM Topic", NULL);
}
int cmd_mqtt_mbfan_duty_topic(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_mbfan_duty_topic,
sizeof(conf->mqtt_mbfan_duty_topic), "MQTT MBFan PWM Topic", NULL);
}
int cmd_mqtt_ha_discovery(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->mqtt_ha_discovery_prefix,
sizeof(conf->mqtt_ha_discovery_prefix), "MQTT Home Assistant Discovery Prefix", NULL);
}
int cmd_mqtt_mask_temp(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_temp_mask, SENSOR_MAX_COUNT,
1, "MQTT Temperature Mask");
}
int cmd_mqtt_mask_vtemp(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_vtemp_mask, VSENSOR_MAX_COUNT,
1, "MQTT VSENSOR Temperature Mask");
}
int cmd_mqtt_mask_vhumidity(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_vhumidity_mask, VSENSOR_MAX_COUNT,
1, "MQTT VSENSOR Humidity Mask");
}
int cmd_mqtt_mask_vpressure(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_vpressure_mask, VSENSOR_MAX_COUNT,
1, "MQTT VSENSOR Pressure Mask");
}
int cmd_mqtt_mask_fan_rpm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_fan_rpm_mask, FAN_MAX_COUNT,
1, "MQTT Fan RPM Mask");
}
int cmd_mqtt_mask_fan_duty(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_fan_duty_mask, FAN_MAX_COUNT,
1, "MQTT Fan PWM Mask");
}
int cmd_mqtt_mask_mbfan_rpm(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_mbfan_rpm_mask, MBFAN_MAX_COUNT,
1, "MQTT MBFan RPM Mask");
}
int cmd_mqtt_mask_mbfan_duty(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->mqtt_mbfan_duty_mask, MBFAN_MAX_COUNT,
1, "MQTT MBFan PWM Mask");
}
#if TLS_SUPPORT
int cmd_mqtt_tls(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->mqtt_tls, "MQTT TLS Mode");
}
int cmd_tls_pkey(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
char *buf;
uint32_t buf_len = 4096;
uint32_t file_size;
int incount = 1;
int res = 0;
if (query) {
res = flash_read_file(&buf, &file_size, "key.pem");
if (res == 0 && buf != NULL) {
printf("%s\n", buf);
free(buf);
return 0;
} else {
printf("No private key present.\n");
}
return 2;
}
if ((buf = malloc(buf_len)) == NULL) {
log_msg(LOG_ERR,"cmd_tls_pkey(): not enough memory");
return 2;
}
buf[0] = 0;
#if WATCHDOG_ENABLED
watchdog_disable();
#endif
if (!strncasecmp(args, "DELETE", 7)) {
res = flash_delete_file("key.pem");
if (res == -2) {
printf("No private key present.\n");
res = 0;
}
else if (res) {
printf("Failed to delete private key: %d\n", res);
res = 2;
} else {
printf("Private key successfully deleted.\n");
}
}
else {
int v;
if (str_to_int(args, &v, 10)) {
if (v >= 1 && v <= 3)
incount = v;
}
printf("Paste private key in PEM format:\n");
for(int i = 0; i < incount; i++) {
if (read_pem_file(buf, buf_len, 5000, true) != 1) {
printf("Invalid private key!\n");
res = 2;
break;
}
}
if (res == 0) {
res = flash_write_file(buf, strlen(buf) + 1, "key.pem");
if (res) {
printf("Failed to save private key.\n");
res = 2;
} else {
printf("Private key successfully saved. (length=%u)\n",
strlen(buf));
res = 0;
}
}
}
#if WATCHDOG_ENABLED
watchdog_enable(WATCHDOG_REBOOT_DELAY, 1);
#endif
free(buf);
return res;
}
int cmd_tls_cert(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
char *buf;
uint32_t buf_len = 8192;
uint32_t file_size;
int res = 0;
if (query) {
res = flash_read_file(&buf, &file_size, "cert.pem");
if (res == 0 && buf != NULL) {
printf("%s\n", buf);
free(buf);
return 0;
} else {
printf("No certificate present.\n");
}
return 2;
}
if ((buf = malloc(buf_len)) == NULL) {
log_msg(LOG_ERR,"cmd_tls_cert(): not enough memory");
return 2;
}
buf[0] = 0;
#if WATCHDOG_ENABLED
watchdog_disable();
#endif
if (!strncasecmp(args, "DELETE", 7)) {
res = flash_delete_file("cert.pem");
if (res == -2) {
printf("No certificate present.\n");
res = 0;
}
else if (res) {
printf("Failed to delete certificate: %d\n", res);
res = 2;
} else {
printf("Certificate successfully deleted.\n");
}
}
else {
printf("Paste certificate in PEM format:\n");
if (read_pem_file(buf, buf_len, 5000, false) != 1) {
printf("Invalid private key!\n");
res = 2;
} else {
res = flash_write_file(buf, strlen(buf) + 1, "cert.pem");
if (res) {
printf("Failed to save certificate.\n");
res = 2;
} else {
printf("Certificate successfully saved. (length=%u)\n",
strlen(buf));
res = 0;
}
}
}
#if WATCHDOG_ENABLED
watchdog_enable(WATCHDOG_REBOOT_DELAY, 1);
#endif
free(buf);
return res;
}
#endif /* TLS_SUPPORT */
int cmd_ssh_auth(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->ssh_auth, "SSH Server Authentication");
}
int cmd_ssh_server(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd, &conf->ssh_active, "SSH Server");
}
int cmd_ssh_port(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint16_setting(cmd, args, query, prev_cmd,
&conf->ssh_port, 0, 65535, "SSH Port");
}
int cmd_ssh_user(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->ssh_user, sizeof(conf->ssh_user),
"SSH Username", NULL);
}
int cmd_ssh_pass(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query) {
printf("%s\n", cfg->ssh_pwhash);
return 0;
}
if (strlen(args) > 0) {
strncopy(conf->ssh_pwhash, generate_sha512crypt_pwhash(args),
sizeof(conf->ssh_pwhash));
} else {
conf->ssh_pwhash[0] = 0;
log_msg(LOG_NOTICE, "SSH password removed.");
}
return 0;
}
int cmd_ssh_pkey(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
ssh_list_pkeys();
return 0;
}
int cmd_ssh_pkey_create(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
return ssh_create_pkey(args);
}
int cmd_ssh_pkey_del(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
return ssh_delete_pkey(args);
}
int cmd_ssh_pubkey(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int count = 0;
char tmp[255];
if (!query)
return 1;
for (int i = 0; i < SSH_MAX_PUB_KEYS; i++) {
struct ssh_public_key *k = &conf->ssh_pub_keys[i];
if (k->pubkey_size == 0 || strlen(k->username) < 1)
continue;
printf("%d: %s, %s\n", ++count, k->username,
ssh_pubkey_to_str(k, tmp, sizeof(tmp)));
}
if (count < 1) {
printf("No SSH (authentication) public keys found.\n");
}
return 0;
}
int cmd_ssh_pubkey_add(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
struct ssh_public_key pubkey;
char *s, *username, *pkey, *saveptr;
int res = 0;
if (query)
return 1;
if (!(s = strdup(args)))
return 2;
if ((username = strtok_r(s, " ", &saveptr))) {
username = trim_str(username);
if (strlen(username) < 1)
username = NULL;
}
if ((pkey = strtok_r(NULL, ",", &saveptr))) {
pkey = trim_str(pkey);
if (str_to_ssh_pubkey(pkey, &pubkey))
pkey = NULL;
}
if (username && pkey) {
int idx = -1;
/* Check for first available slot */
for(int i = 0; i < SSH_MAX_PUB_KEYS; i++) {
if (conf->ssh_pub_keys[i].pubkey_size == 0) {
idx = i;
break;
}
}
if (idx < 0) {
printf("Maximum number of public keys already added.\n");
res = 2;
} else {
strncopy(pubkey.username, username, sizeof(pubkey.username));
conf->ssh_pub_keys[idx] = pubkey;
log_msg(LOG_INFO, "SSH Public key added: slot %d: %s (%s)\n", idx + 1,
pubkey.type, pubkey.username);
}
}
free(s);
return res;
}
int cmd_ssh_pubkey_del(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int idx;
if (query)
return 1;
if (!str_to_int(args, &idx, 10))
return 2;
if (idx < 1 || idx > SSH_MAX_PUB_KEYS)
return 2;
idx--;
if (conf->ssh_pub_keys[idx].pubkey_size > 0) {
log_msg(LOG_INFO, "SSH Public key deleted: slot %d: %s:%s (%s)\n", idx + 1,
conf->ssh_pub_keys[idx].username,
conf->ssh_pub_keys[idx].type,
conf->ssh_pub_keys[idx].name);
memset(&conf->ssh_pub_keys[idx], 0, sizeof(struct ssh_public_key));
}
return 0;
}
int cmd_ssh_acls(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return acl_list_change(cmd, args, query, prev_cmd, "SSH Server ACLs", conf->ssh_acls,
SSH_MAX_ACL_ENTRIES);
}
int cmd_telnet_auth(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->telnet_auth, "Telnet Server Authentication");
}
int cmd_telnet_rawmode(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->telnet_raw_mode, "Telnet Server Raw Mode");
}
int cmd_telnet_server(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->telnet_active, "Telnet Server");
}
int cmd_telnet_port(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint16_setting(cmd, args, query, prev_cmd,
&conf->telnet_port, 0, 65535, "Telnet Port");
}
int cmd_telnet_user(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->telnet_user, sizeof(conf->telnet_user),
"Telnet Username", NULL);
}
int cmd_telnet_pass(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query) {
printf("%s\n", cfg->telnet_pwhash);
return 0;
}
if (strlen(args) > 0) {
strncopy(conf->telnet_pwhash, generate_sha512crypt_pwhash(args),
sizeof(conf->telnet_pwhash));
} else {
conf->telnet_pwhash[0] = 0;
log_msg(LOG_NOTICE, "Telnet password removed.");
}
return 0;
}
int cmd_telnet_acls(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return acl_list_change(cmd, args, query, prev_cmd, "Telnet Server ACLs",
conf->telnet_acls, TELNET_MAX_ACL_ENTRIES);
}
int cmd_snmp_agent(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->snmp_active, "SNMP Agent");
}
int cmd_snmp_community(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->snmp_community, sizeof(conf->snmp_community),
"SNMP Community", NULL);
}
int cmd_snmp_community_write(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->snmp_community_write, sizeof(conf->snmp_community_write),
"SNMP Community (Write)", NULL);
}
int cmd_snmp_contact(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->snmp_contact, sizeof(conf->snmp_contact),
"SNMP sysContact", NULL);
}
int cmd_snmp_location(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->snmp_location, sizeof(conf->snmp_location),
"SNMP sysLocation", NULL);
}
int cmd_snmp_auth_traps(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->snmp_auth_traps, "SNMP Authentication Traps");
}
int cmd_snmp_community_trap(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->snmp_community_trap, sizeof(conf->snmp_community_trap),
"SNMP Traps Community", NULL);
}
int cmd_snmp_trap_dst(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return ip_change(cmd, args, query, prev_cmd, "SNMP Trap Destination", &conf->snmp_trap_dst);
}
int cmd_http_server(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->http_active, "HTTP Server");
}
int cmd_http_port(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint16_setting(cmd, args, query, prev_cmd,
&conf->http_port, 0, 65535, "HTTP Server Port");
}
int cmd_http_tlsport(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint16_setting(cmd, args, query, prev_cmd,
&conf->https_port, 0, 65535, "HTTPS Server Port");
}
int cmd_http_mask_fan(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->http_fan_mask, FAN_MAX_COUNT,
1, "HTTP Fan Mask");
}
int cmd_http_mask_mbfan(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->http_mbfan_mask, MBFAN_MAX_COUNT,
1, "HTTP MBFan Mask");
}
int cmd_http_mask_sensor(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->http_sensor_mask, SENSOR_MAX_COUNT,
1, "HTTP Sensor Mask");
}
int cmd_http_mask_vsensor(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bitmask16_setting(cmd, args, query, prev_cmd,
&conf->http_vsensor_mask, VSENSOR_MAX_COUNT,
1, "HTTP Virtual Sensor Mask");
}
#endif /* WIFI_SUPPOERT */
int cmd_time(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
struct timespec ts;
time_t t;
char buf[32];
if (query) {
if (aon_timer_is_running()) {
aon_timer_get_time(&ts);
time_t_to_str(buf, sizeof(buf), timespec_to_time_t(&ts));
printf("%s\n", buf);
}
return 0;
}
if (str_to_time_t(args, &t)) {
time_t_to_timespec(t, &ts);
if (aon_timer_is_running()) {
aon_timer_set_time(&ts);
} else {
aon_timer_start(&ts);
}
time_t_to_str(buf, sizeof(buf), t);
log_msg(LOG_NOTICE, "Set system clock: %s", buf);
return 0;
}
return 2;
}
int cmd_timezone(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->timezone, sizeof(conf->timezone), "Timezone", NULL);
}
int cmd_uptime(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
const struct persistent_memory_block *m = persistent_mem;
struct timespec ts;
uint64_t uptime;
char buf[32];
if (!query)
return 1;
if (aon_timer_is_running()) {
if (aon_timer_get_time(&ts)) {
time_t_to_str(buf, sizeof(buf), timespec_to_time_t(&ts));
printf("%s ", buf + 11);
}
}
uptime = to_us_since_boot(get_absolute_time());
uptime_to_str(buf, sizeof(buf), uptime, false);
printf("up %s%s\n", buf,
(rebooted_by_watchdog ? " [rebooted by watchdog]" : ""));
uptime_to_str(buf, sizeof(buf), uptime + m->total_uptime, false);
printf("since cold boot %s (soft reset count: %lu)\n",
buf, m->warmstart);
return 0;
}
int cmd_err(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
for (int i = 0; error_codes[i].error != NULL; i++) {
if (error_codes[i].error_num == last_error_num) {
printf("%d,\"%s\"\n", last_error_num, error_codes[i].error);
last_error_num = 0;
return 0;
}
}
printf("-1,\"Internal Error\"\n");
return 0;
}
int cmd_name(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return string_setting(cmd, args, query, prev_cmd,
conf->name, sizeof(conf->name), "System Name", NULL);
}
int cmd_lfs(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
size_t size, free, used, files, dirs;
if (!query)
return 1;
if (flash_get_fs_info(&size, &free, &files, &dirs, NULL) < 0)
return 2;
used = size - free;
printf("Filesystem size: %u\n", size);
printf("Filesystem used: %u\n", used);
printf("Filesystem free: %u\n", free);
printf("Number of files: %u\n", files);
printf("Number of subdirectories: %u\n", dirs);
return 0;
}
int cmd_lfs_del(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
if (strlen(args) < 1)
return 2;
if (flash_delete_file(args))
return 2;
return 0;
}
int cmd_lfs_dir(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
flash_list_directory("/", true);
return 0;
}
int cmd_lfs_format(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
printf("Formatting flash filesystem...\n");
if (flash_format(true))
return 2;
printf("Filesystem successfully formatted.\n");
return 0;
}
int cmd_lfs_ren(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
char *saveptr, *oldname, *newname, *arg;
int res = 2;
if (query)
return 1;
if (!(arg = strdup(args)))
return 2;
oldname = strtok_r(arg, " \t", &saveptr);
if (oldname && strlen(oldname) > 0) {
newname = strtok_r(NULL, " \t", &saveptr);
if (newname && strlen(newname) > 0) {
if (!flash_rename_file(oldname, newname)) {
res = 0;
}
}
}
free(arg);
return res;
}
int cmd_lfs_copy(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
char *saveptr, *srcname, *dstname, *arg;
int res = 2;
if (query)
return 1;
if (!(arg = strdup(args)))
return 2;
srcname = strtok_r(arg, " \t", &saveptr);
if (srcname && strlen(srcname) > 0) {
dstname = strtok_r(NULL, " \t", &saveptr);
if (dstname && strlen(dstname) > 0) {
if (strcmp(srcname, dstname)) {
if (!flash_copy_file(srcname, dstname, false)) {
res = 0;
}
}
}
}
free(arg);
return res;
}
int cmd_flash(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
print_rp2040_flashinfo();
return 0;
}
int cmd_psram(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
print_psram_info();
return 0;
}
/* Disable optimizations since GCC 15.2 causes test for largest available memory block to fail... */
int __attribute__((optimize("O0"))) cmd_memory(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
const int TEST_MEM_SIZE = 1024 * 1024;
int blocksize;
if (query) {
print_rp2_meminfo();
printf("mallinfo:\n");
print_mallinfo();
return 0;
}
if (str_to_int(args, &blocksize, 10)) {
if (blocksize < 512)
blocksize = 512;
if (blocksize > 8192)
blocksize= 8192;
} else {
blocksize = 1024;
}
/* Test for largest available memory block... */
void *buf = NULL;
size_t bufsize = blocksize;
do {
if (!(buf = malloc(bufsize)))
break;
free(buf);
bufsize += blocksize;
} while (bufsize <= TEST_MEM_SIZE);
printf("Largest available memory block: %u bytes\n",
bufsize - blocksize);
/* Test how much memory available in 'blocksize' blocks... */
int i = 0;
int max = TEST_MEM_SIZE / blocksize + 1;
size_t refbufsize = max * sizeof(void*);
void **refbuf = malloc(refbufsize);
if (refbuf) {
memset(refbuf, 0, refbufsize);
while (i < max) {
if (!(refbuf[i] = malloc(blocksize)))
break;
i++;
}
}
printf("Total available memory: %u bytes\n",
i * blocksize + refbufsize);
if (refbuf) {
i = 0;
while (i < max && refbuf[i]) {
free(refbuf[i++]);
}
free(refbuf);
}
return 0;
}
int cmd_memtest(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (query)
return 1;
#if WATCHDOG_ENABLED
watchdog_disable();
#endif
rp2_memtest();
#if WATCHDOG_ENABLED
watchdog_enable(WATCHDOG_REBOOT_DELAY, 1);
#endif
return 0;
}
int cmd_onewire(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->onewire_active, "1-Wire Bus status");
}
int cmd_onewire_sensors(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
int i;
if (!query)
return 1;
if (!conf->onewire_active)
return -1;
for (i = 0; i < ONEWIRE_MAX_COUNT; i++) {
uint64_t addr = onewire_address(i);
if (addr)
printf("%d,%016llx,%1.1f\n", i + 1,
addr, st->onewire_temp[i]);
}
return 0;
}
int cmd_i2c(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
display_i2c_status();
return 0;
}
int cmd_i2c_scan(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
if (!query)
return 1;
scan_i2c_bus();
return 0;
}
int cmd_i2c_speed(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return uint32_setting(cmd, args, query, prev_cmd,
&conf->i2c_speed, 10000, 3400000, "I2C Bus Speed (Hz)");
}
int cmd_serial(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->serial_active, "Serial Console status");
}
int cmd_spi(const char *cmd, const char *args, int query, struct prev_cmd_t *prev_cmd)
{
return bool_setting(cmd, args, query, prev_cmd,
&conf->spi_active, "SPI (LCD Display) status");
}
const struct cmd_t display_commands[] = {
{ "LAYOUTR", 7, NULL, cmd_display_layout_r },
{ "LOGO", 4, NULL, cmd_display_logo },
{ "THEMe", 4, NULL, cmd_display_theme },
{ 0, 0, 0, 0 }
};
const struct cmd_t lfs_commands[] = {
{ "COPY", 4, NULL, cmd_lfs_copy },
{ "DELete", 3, NULL, cmd_lfs_del },
{ "DIRectory", 3, NULL, cmd_lfs_dir },
{ "FORMAT", 6, NULL, cmd_lfs_format },
{ "REName", 3, NULL, cmd_lfs_ren },
{ 0, 0, 0, 0 }
};
const struct cmd_t wifi_commands[] = {
#ifdef WIFI_SUPPORT
{ "AUTHmode", 4, NULL, cmd_wifi_auth_mode },
{ "COUntry", 3, NULL, cmd_wifi_country },
{ "GATEway", 4, NULL, cmd_wifi_gateway },
{ "HOSTname", 4, NULL, cmd_wifi_hostname },
{ "IPaddress", 2, NULL, cmd_wifi_ip },
{ "MAC", 3, NULL, cmd_wifi_mac },
{ "NETMask", 4, NULL, cmd_wifi_netmask },
{ "DNS", 3, NULL, cmd_wifi_dns },
{ "NTPClient", 4, NULL, cmd_wifi_ntp_client },
{ "NTP", 3, NULL, cmd_wifi_ntp },
{ "MODE", 4, NULL, cmd_wifi_mode },
{ "PASSword", 4, NULL, cmd_wifi_password },
{ "REJOIN", 6, NULL, cmd_wifi_rejoin },
{ "SSID", 4, NULL, cmd_wifi_ssid },
{ "STATS", 5, NULL, cmd_wifi_stats },
{ "STATus", 4, NULL, cmd_wifi_status },
{ "INFO", 4, NULL, cmd_wifi_info },
{ "SYSLOGClient", 7, NULL, cmd_wifi_syslog_client },
{ "SYSLOG", 6, NULL, cmd_wifi_syslog },
#endif
{ 0, 0, 0, 0 }
};
#ifdef WIFI_SUPPORT
const struct cmd_t http_mask_commands[] = {
{ "SENSOR", 6, NULL, cmd_http_mask_sensor },
{ "VSENSOR", 7, NULL, cmd_http_mask_vsensor },
{ "FAN", 3, NULL, cmd_http_mask_fan },
{ "MBFAN", 5, NULL, cmd_http_mask_mbfan },
{ 0, 0, 0, 0 }
};
const struct cmd_t http_commands[] = {
{ "MASK", 4, http_mask_commands, NULL },
{ "PORT", 4, NULL, cmd_http_port },
{ "TLSPORT", 7, NULL, cmd_http_tlsport },
{ "SERVer", 4, NULL, cmd_http_server },
{ 0, 0, 0, 0 }
};
const struct cmd_t mqtt_mask_commands[] = {
{ "TEMP", 4, NULL, cmd_mqtt_mask_temp },
{ "VTEMP", 5, NULL, cmd_mqtt_mask_vtemp },
{ "VHUMidity", 4, NULL, cmd_mqtt_mask_vhumidity },
{ "VPREssure", 4, NULL, cmd_mqtt_mask_vpressure },
{ "FANRPM", 6, NULL, cmd_mqtt_mask_fan_rpm },
{ "FANPWM", 6, NULL, cmd_mqtt_mask_fan_duty },
{ "MBFANRPM", 8, NULL, cmd_mqtt_mask_mbfan_rpm },
{ "MBFANPWM", 8, NULL, cmd_mqtt_mask_mbfan_duty },
{ 0, 0, 0, 0 }
};
const struct cmd_t mqtt_interval_commands[] = {
{ "STATUS", 6, NULL, cmd_mqtt_status_interval },
{ "TEMP", 4, NULL, cmd_mqtt_temp_interval },
{ "VSENsor", 4, NULL, cmd_mqtt_vsensor_interval },
{ "RPM", 3, NULL, cmd_mqtt_rpm_interval },
{ "PWM", 3, NULL, cmd_mqtt_duty_interval },
{ 0, 0, 0, 0 }
};
const struct cmd_t mqtt_topic_commands[] = {
{ "STATus", 4, NULL, cmd_mqtt_status_topic },
{ "COMMand", 4, NULL, cmd_mqtt_cmd_topic },
{ "RESPonse", 4, NULL, cmd_mqtt_resp_topic },
{ "TEMP", 4, NULL, cmd_mqtt_temp_topic },
{ "VTEMP", 5, NULL, cmd_mqtt_vtemp_topic },
{ "VHUMidity", 4, NULL, cmd_mqtt_vhumidity_topic },
{ "VPREssure", 4, NULL, cmd_mqtt_vpressure_topic },
{ "FANRPM", 6, NULL, cmd_mqtt_fan_rpm_topic },
{ "FANPWM", 6, NULL, cmd_mqtt_fan_duty_topic },
{ "MBFANRPM", 8, NULL, cmd_mqtt_mbfan_rpm_topic },
{ "MBFANPWM", 8, NULL, cmd_mqtt_mbfan_duty_topic },
{ 0, 0, 0, 0 }
};
const struct cmd_t mqtt_ha_commands[] = {
{ "DISCovery", 4, NULL, cmd_mqtt_ha_discovery },
{ 0, 0, 0, 0 }
};
const struct cmd_t mqtt_commands[] = {
{ "SERVer", 4, NULL, cmd_mqtt_server },
{ "PORT", 4, NULL, cmd_mqtt_port },
{ "USER", 4, NULL, cmd_mqtt_user },
{ "PASSword", 4, NULL, cmd_mqtt_pass },
{ "SCPI", 4, NULL, cmd_mqtt_allow_scpi },
#if TLS_SUPPORT
{ "TLS", 3, NULL, cmd_mqtt_tls },
#endif
{ "HA", 2, mqtt_ha_commands, NULL },
{ "INTerval", 3, mqtt_interval_commands, NULL },
{ "MASK", 4, mqtt_mask_commands, NULL },
{ "TOPIC", 5, mqtt_topic_commands, NULL },
{ 0, 0, 0, 0 }
};
const struct cmd_t snmp_trap_commands[] = {
{ "AUTH", 4, NULL, cmd_snmp_auth_traps },
{ "COMMunity", 4, NULL, cmd_snmp_community_trap },
{ "DESTination", 4, NULL, cmd_snmp_trap_dst },
{ 0, 0, 0, 0 }
};
const struct cmd_t snmp_commands[] = {
{ "AGENT", 5, NULL, cmd_snmp_agent },
{ "COMMunity", 4, NULL, cmd_snmp_community },
{ "CONTact", 4, NULL, cmd_snmp_contact },
{ "LOCAtion", 4, NULL, cmd_snmp_location },
{ "TRAPs", 4, snmp_trap_commands, NULL },
{ "WRITecommunity", 4, NULL, cmd_snmp_community_write },
{ 0, 0, 0, 0 }
};
const struct cmd_t ssh_pkey_commands[] = {
{ "CREate", 3, NULL, cmd_ssh_pkey_create },
{ "DELete", 3, NULL, cmd_ssh_pkey_del },
{ "LIST", 4, NULL, cmd_ssh_pkey },
{ 0, 0, 0, 0 }
};
const struct cmd_t ssh_pubkey_commands[] = {
{ "ADD", 3, NULL, cmd_ssh_pubkey_add },
{ "DELete", 3, NULL, cmd_ssh_pubkey_del },
{ "LIST", 4, NULL, cmd_ssh_pubkey },
{ 0, 0, 0, 0 }
};
const struct cmd_t ssh_commands[] = {
{ "ACLs", 3, NULL, cmd_ssh_acls },
{ "AUTH", 4, NULL, cmd_ssh_auth },
{ "PORT", 4, NULL, cmd_ssh_port },
{ "SERVer", 4, NULL, cmd_ssh_server },
{ "PASSword", 4, NULL, cmd_ssh_pass },
{ "USER", 4, NULL, cmd_ssh_user },
{ "KEY", 3, ssh_pkey_commands, cmd_ssh_pkey },
{ "PUBKEY", 6, ssh_pubkey_commands, cmd_ssh_pubkey },
{ 0, 0, 0, 0 }
};
const struct cmd_t telnet_commands[] = {
{ "ACLs", 3, NULL, cmd_telnet_acls },
{ "AUTH", 4, NULL, cmd_telnet_auth },
{ "PORT", 4, NULL, cmd_telnet_port },
{ "RAWmode", 3, NULL, cmd_telnet_rawmode },
{ "SERVer", 4, NULL, cmd_telnet_server },
{ "PASSword", 4, NULL, cmd_telnet_pass },
{ "USER", 4, NULL, cmd_telnet_user },
{ 0, 0, 0, 0 }
};
const struct cmd_t tls_commands[] = {
#if TLS_SUPPORT
{ "CERT", 4, NULL, cmd_tls_cert },
{ "PKEY", 4, NULL, cmd_tls_pkey },
#endif
{ 0, 0, 0, 0 }
};
#endif
const struct cmd_t i2c_commands[] = {
{ "SCAN", 4, NULL, cmd_i2c_scan },
{ "SPEED", 5, NULL, cmd_i2c_speed },
{ 0, 0, 0, 0 }
};
#if ONEWIRE_SUPPORT
const struct cmd_t onewire_commands[] = {
{ "SENsors", 3, NULL, cmd_onewire_sensors },
{ 0, 0, 0, 0 }
};
#endif
const struct cmd_t system_commands[] = {
{ "BOARD", 5, NULL, cmd_board },
{ "DEBUG", 5, NULL, cmd_debug }, /* Obsolete ? */
{ "DISPlay", 4, display_commands, cmd_display_type },
{ "ECHO", 4, NULL, cmd_echo },
{ "ERRor", 3, NULL, cmd_err },
{ "FANS", 4, NULL, cmd_fans },
{ "FLASH", 5, NULL, cmd_flash },
{ "I2C", 3, i2c_commands, cmd_i2c },
{ "LED", 3, NULL, cmd_led },
{ "LFS", 3, lfs_commands, cmd_lfs },
{ "LOG", 3, NULL, cmd_log_level },
{ "MBFANS", 6, NULL, cmd_mbfans },
{ "MEMTEST", 7, NULL, cmd_memtest },
{ "MEMory", 3, NULL, cmd_memory },
{ "NAME", 4, NULL, cmd_name },
#if ONEWIRE_SUPPORT
{ "ONEWIRE", 7, onewire_commands, cmd_onewire },
#endif
{ "PSRAM", 5, NULL, cmd_psram },
{ "SENSORS", 7, NULL, cmd_sensors },
{ "SERIAL", 6, NULL, cmd_serial },
{ "SPI", 3, NULL, cmd_spi },
{ "SYSLOG", 6, NULL, cmd_syslog_level },
{ "TIMEZONE", 8, NULL, cmd_timezone },
{ "TIME", 4, NULL, cmd_time },
{ "UPGRADE", 7, NULL, cmd_usb_boot },
{ "UPTIme", 4, NULL, cmd_uptime },
{ "VERsion", 3, NULL, cmd_version },
{ "VREFadc", 4, NULL, cmd_adc_vref },
{ "VSENSORS", 8, NULL, cmd_vsensors },
{ "WIFI", 4, wifi_commands, cmd_wifi },
#if WIFI_SUPPORT
{ "IFCONFIG", 8, NULL, cmd_wifi_info },
{ "HTTP", 4, http_commands, NULL },
{ "MQTT", 4, mqtt_commands, NULL },
{ "SNMP", 4, snmp_commands, NULL },
{ "TELNET", 6, telnet_commands, NULL },
{ "SSH", 3, ssh_commands, NULL },
{ "TLS", 3, tls_commands, NULL },
#endif
{ 0, 0, 0, 0 }
};
const struct cmd_t fan_hyst_commands[] = {
{ "TACho", 3, NULL, cmd_fan_tacho_hys },
{ "PWM", 3, NULL, cmd_fan_pwm_hys },
{ 0, 0, 0, 0 }
};
const struct cmd_t fan_c_commands[] = {
{ "FILTER", 6, NULL, cmd_fan_filter },
{ "MAXpwm", 3, NULL, cmd_fan_max_pwm },
{ "MINpwm", 3, NULL, cmd_fan_min_pwm },
{ "NAME", 4, NULL, cmd_fan_name },
{ "PWMCoeff", 4, NULL, cmd_fan_pwm_coef },
{ "PWMMap", 4, NULL, cmd_fan_pwm_map },
{ "RPMFactor", 4, NULL, cmd_fan_rpm_factor },
{ "RPMMOde", 5, NULL, cmd_fan_rpm_mode },
{ "SOUrce", 3, NULL, cmd_fan_source },
{ "HYSTeresis",4, fan_hyst_commands, NULL },
{ 0, 0, 0, 0 }
};
const struct cmd_t mbfan_c_commands[] = {
{ "FILTER", 6, NULL, cmd_mbfan_filter },
{ "MAXrpm", 3, NULL, cmd_mbfan_max_rpm },
{ "MINrpm", 3, NULL, cmd_mbfan_min_rpm },
{ "NAME", 4, NULL, cmd_mbfan_name },
{ "RPMCoeff", 4, NULL, cmd_mbfan_rpm_coef },
{ "RPMFactor", 4, NULL, cmd_mbfan_rpm_factor },
{ "RPMMOde", 5, NULL, cmd_mbfan_rpm_mode },
{ "RPMMap", 4, NULL, cmd_mbfan_rpm_map },
{ "SOUrce", 3, NULL, cmd_mbfan_source },
{ 0, 0, 0, 0 }
};
const struct cmd_t sensor_c_commands[] = {
{ "BETAcoeff", 4, NULL, cmd_sensor_beta_coef },
{ "FILTER", 6, NULL, cmd_sensor_filter },
{ "NAME", 4, NULL, cmd_sensor_name },
{ "TEMPCoeff", 5, NULL, cmd_sensor_temp_coef },
{ "TEMPMap", 5, NULL, cmd_sensor_temp_map },
{ "TEMPNominal", 5, NULL, cmd_sensor_temp_nominal },
{ "TEMPOffset", 5, NULL, cmd_sensor_temp_offset },
{ "THERmistor", 4, NULL, cmd_sensor_ther_nominal },
{ 0, 0, 0, 0 }
};
const struct cmd_t vsensor_c_commands[] = {
{ "FILTER", 6, NULL, cmd_vsensor_filter },
{ "NAME", 4, NULL, cmd_vsensor_name },
{ "SOUrce", 3, NULL, cmd_vsensor_source },
{ "TEMPMap", 5, NULL, cmd_vsensor_temp_map },
{ 0, 0, 0, 0 }
};
const struct cmd_t vsensors_c_commands[] = {
{ "SOUrce", 3, NULL, cmd_vsensors_sources },
{ 0, 0, 0, 0 }
};
const struct cmd_t config_commands[] = {
{ "DELete", 3, NULL, cmd_delete_config, 0 },
{ "FAN", 3, fan_c_commands, NULL, CMD_INDEX },
{ "MBFAN", 5, mbfan_c_commands, NULL, CMD_INDEX },
{ "Read", 1, NULL, cmd_print_config, 0 },
{ "SAVe", 3, NULL, cmd_save_config, 0 },
{ "SENSOR", 6, sensor_c_commands, NULL, CMD_INDEX },
{ "UPLOAD", 6, NULL, cmd_upload_config, 0 },
{ "VSENSORS", 8, vsensors_c_commands, cmd_vsensors_sources, 0 },
{ "VSENSOR", 7, vsensor_c_commands, NULL, CMD_INDEX },
{ 0, 0, 0, 0, 0 }
};
const struct cmd_t fan_commands[] = {
{ "PWM", 3, NULL, cmd_fan_pwm },
{ "Read", 1, NULL, cmd_fan_read },
{ "RPM", 3, NULL, cmd_fan_rpm },
{ "TACho", 3, NULL, cmd_fan_tacho },
{ 0, 0, 0, 0 }
};
const struct cmd_t mbfan_commands[] = {
{ "PWM", 3, NULL, cmd_mbfan_pwm },
{ "Read", 1, NULL, cmd_mbfan_read },
{ "RPM", 3, NULL, cmd_mbfan_rpm },
{ "TACho", 3, NULL, cmd_mbfan_tacho },
{ 0, 0, 0, 0 }
};
const struct cmd_t sensor_commands[] = {
{ "Read", 1, NULL, cmd_sensor_temp },
{ "TEMP", 4, NULL, cmd_sensor_temp },
{ 0, 0, 0, 0 }
};
const struct cmd_t vsensor_commands[] = {
{ "HUMidity", 3, NULL, cmd_vsensor_humidity },
{ "PREssure", 3, NULL, cmd_vsensor_pressure },
{ "Read", 1, NULL, cmd_vsensor_temp },
{ "TEMP", 4, NULL, cmd_vsensor_temp },
{ 0, 0, 0, 0 }
};
const struct cmd_t measure_commands[] = {
{ "FAN", 3, fan_commands, cmd_fan_read, CMD_INDEX },
{ "MBFAN", 5, mbfan_commands, cmd_mbfan_read, CMD_INDEX },
{ "Read", 1, NULL, cmd_read, 0 },
{ "SENSOR", 6, sensor_commands, cmd_sensor_temp, CMD_INDEX },
{ "VSENSORS", 8, NULL, cmd_vsensors_read, 0 },
{ "VSENSOR", 7, vsensor_commands, cmd_vsensor_temp, CMD_INDEX },
{ 0, 0, 0, 0, 0 }
};
const struct cmd_t write_commands[] = {
{ "VSENSOR", 7, NULL, cmd_vsensor_write },
{ 0, 0, 0, 0 }
};
const struct cmd_t commands[] = {
{ "*CLS", 4, NULL, cmd_null },
{ "*ESE", 4, NULL, cmd_null },
{ "*ESR", 4, NULL, cmd_zero },
{ "*IDN", 4, NULL, cmd_idn },
{ "*OPC", 4, NULL, cmd_one },
{ "*RST", 4, NULL, cmd_reset },
{ "*SRE", 4, NULL, cmd_zero },
{ "*STB", 4, NULL, cmd_zero },
{ "*TST", 4, NULL, cmd_zero },
{ "*WAI", 4, NULL, cmd_null },
{ "CONFigure", 4, config_commands, cmd_print_config },
{ "EXIT", 4, NULL, cmd_exit },
{ "MEAsure", 3, measure_commands, NULL },
{ "SYStem", 3, system_commands, NULL },
{ "Read", 1, NULL, cmd_read },
{ "WHO", 3, NULL, cmd_who },
{ "WRIte", 3, write_commands, NULL },
{ 0, 0, 0, 0 }
};
/**
* Process command string received from user.
*
* Splits command string into multiple commands by ';' character.
* And executes each command using run_cmd() function.
*
* @param state Current system state.
* @param config Current system configuration.
* @param command command string
*/
void process_command(const struct fanpico_state *state, struct fanpico_config *config, char *command)
{
char *saveptr, *cmd;
struct prev_cmd_t cmd_stack;
const struct cmd_t *cmd_level = commands;
if (!state || !config || !command)
return;
st = state;
conf = config;
cmd = strtok_r(command, ";", &saveptr);
while (cmd) {
cmd = trim_str(cmd);
/* log_msg(LOG_DEBUG, "command: '%s'", cmd); */
if (cmd && strlen(cmd) > 0) {
cmd_stack.depth = 0;
cmd_stack.cmds[0] = NULL;
cmd_level = run_cmd(cmd, commands, cmd_level, &cmd_stack,
&last_error_num);
}
cmd = strtok_r(NULL, ";", &saveptr);
}
}
/**
* Return last command status code.
*
* @return status code
*/
int last_command_status()
{
return last_error_num;
}