Erick / Mbed 2 deprecated ICE_BLE_TEST

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   NaturalTinyShell_ice libmDot-12Sept mbed-rtos mbed

Fork of ICE by Erick

src/CommandParser/cmd.cpp@97:5cf6ab71dcd0, 2016-09-21 (annotated)

Committer:
jmarkel44
Date:
Wed Sep 21 16:17:12 2016 +0000
Revision:
97:5cf6ab71dcd0
Parent:
96:807f04bd5256
Child:
98:8eab18d03ac2
initial spin of manual controls ; included create-manual command; verifies the output task map of vectors data struct; ;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jmarkel44 0:65cfa4873284 1 /*
jmarkel44 0:65cfa4873284 2 * ===============================================================
jmarkel44 0:65cfa4873284 3 * Natural Tiny Shell (NT-Shell) Application example.
jmarkel44 0:65cfa4873284 4 * Version 0.0.6
jmarkel44 0:65cfa4873284 5 * ===============================================================
jmarkel44 0:65cfa4873284 6 * Copyright (c) 2010-2011 Shinichiro Nakamura
jmarkel44 0:65cfa4873284 7 *
jmarkel44 0:65cfa4873284 8 * Permission is hereby granted, free of charge, to any person
jmarkel44 0:65cfa4873284 9 * obtaining a copy of this software and associated documentation
jmarkel44 0:65cfa4873284 10 * files (the "Software"), to deal in the Software without
jmarkel44 0:65cfa4873284 11 * restriction, including without limitation the rights to use,
jmarkel44 0:65cfa4873284 12 * copy, modify, merge, publish, distribute, sublicense, and/or
jmarkel44 0:65cfa4873284 13 * sell copies of the Software, and to permit persons to whom the
jmarkel44 0:65cfa4873284 14 * Software is furnished to do so, subject to the following
jmarkel44 0:65cfa4873284 15 * conditions:
jmarkel44 0:65cfa4873284 16 *
jmarkel44 0:65cfa4873284 17 * The above copyright notice and this permission notice shall be
jmarkel44 0:65cfa4873284 18 * included in all copies or substantial portions of the Software.
jmarkel44 0:65cfa4873284 19 *
jmarkel44 0:65cfa4873284 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
jmarkel44 0:65cfa4873284 21 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
jmarkel44 0:65cfa4873284 22 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
jmarkel44 0:65cfa4873284 23 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
jmarkel44 0:65cfa4873284 24 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
jmarkel44 0:65cfa4873284 25 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
jmarkel44 0:65cfa4873284 26 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
jmarkel44 0:65cfa4873284 27 * OTHER DEALINGS IN THE SOFTWARE.
jmarkel44 0:65cfa4873284 28 * ===============================================================
jmarkel44 0:65cfa4873284 29 */
jmarkel44 0:65cfa4873284 30
jmarkel44 0:65cfa4873284 31 #include "cmd.h"
jmarkel44 0:65cfa4873284 32 #include <mbed.h>
jmarkel44 36:f240f5a6d0ed 33 #include <utility>
jmarkel44 0:65cfa4873284 34 #include "ntshell.h"
jmarkel44 0:65cfa4873284 35 #include "ntopt.h"
jmarkel44 0:65cfa4873284 36 #include "global.h"
jmarkel44 0:65cfa4873284 37 #include "ConfigurationHandler.h"
davidjhoward 83:0f76cfbb4eba 38 #include "ModbusMasterApi.h"
jmarkel44 66:db1425574b58 39 #include "OutputTask.h"
jmarkel44 3:8ea4db957749 40 #include "mDot.h"
jmarkel44 34:f345fdec711d 41 #include "rtos.h"
jmarkel44 62:1b1d7918adf2 42 #include "rtc.h"
jmarkel44 0:65cfa4873284 43
jmarkel44 0:65cfa4873284 44 Serial serial(USBTX, USBRX);
jmarkel44 0:65cfa4873284 45 ntshell_t ntshell;
jmarkel44 0:65cfa4873284 46
jmarkel44 14:cc916fa8dd11 47 extern mDot *GLOBAL_mdot;
jmarkel44 14:cc916fa8dd11 48
jmarkel44 0:65cfa4873284 49 typedef struct {
jmarkel44 0:65cfa4873284 50 char *command; // command (from shell)
jmarkel44 0:65cfa4873284 51 char *description; // descrption
jmarkel44 0:65cfa4873284 52 void (*func)(int argc, char **argv); // callback function
jmarkel44 0:65cfa4873284 53 } command_table_t;
jmarkel44 0:65cfa4873284 54
jmarkel44 0:65cfa4873284 55 // see cmd.h
jmarkel44 0:65cfa4873284 56 const command_table_t cmdlist[] = {
jmarkel44 0:65cfa4873284 57 {"?", "help command", cmd_help },
jmarkel44 97:5cf6ab71dcd0 58 {"create-manual", "create a manual control", cmd_createManual },
jmarkel44 97:5cf6ab71dcd0 59 //{"create-control", "create a control", cmd_create },
jmarkel44 96:807f04bd5256 60 {"create-setpoint", "create a setpoint control", cmd_createSetpoint },
jmarkel44 86:189c125d8878 61 {"destroy-control", "destroy a control", cmd_destroy },
jmarkel44 37:7e6986b77f01 62 {"cif", "create a test input file", cmd_cif },
jmarkel44 96:807f04bd5256 63 {"cmf", "create a manual control file", cmd_cmf },
jmarkel44 37:7e6986b77f01 64 {"cof", "create a test output file", cmd_cof },
jmarkel44 0:65cfa4873284 65 {"heap", "show heap statistics", cmd_heap },
jmarkel44 0:65cfa4873284 66 {"help", "help command", cmd_help },
jmarkel44 36:f240f5a6d0ed 67 {"log-level", "get/set mDot log level", cmd_logLevel },
jmarkel44 14:cc916fa8dd11 68 {"ls", "list user files", cmd_ls },
jmarkel44 86:189c125d8878 69 {"modify-control", "modify a control", cmd_modify },
davidjhoward 61:ae6dd6692c7d 70 {"modmap", "dump modbus register map", cmd_modmap },
jmarkel44 0:65cfa4873284 71 {"reset", "reset the controller", cmd_reset },
jmarkel44 35:6235ef67faa1 72 {"reset-stats", "reset current mDot statistics", cmd_resetStats },
jmarkel44 14:cc916fa8dd11 73 {"rm", "remove a user file", cmd_rm },
jmarkel44 35:6235ef67faa1 74 {"rssi-stats", "get current rssi stats", cmd_rssiStats },
jmarkel44 35:6235ef67faa1 75 {"show-controls", "display active controls", cmd_ShowControls },
jmarkel44 86:189c125d8878 76 {"show-outputs", "dump outputs", cmd_outputs },
jmarkel44 35:6235ef67faa1 77 {"snr-stats", "get current SNR stats", cmd_snrStats },
jmarkel44 36:f240f5a6d0ed 78 {"stack", "get thread stack usage stats", cmd_stack },
jmarkel44 18:9cf694a764c0 79 {"stats", "get current mDot statistics", cmd_stats },
jmarkel44 62:1b1d7918adf2 80 {"time", "get current time", cmd_time },
davidjhoward 81:d45bfa16953a 81 {"sout", "set output", cmd_sout },
davidjhoward 82:f3e495a98877 82 {"simin", "simulate input", cmd_simin },
davidjhoward 82:f3e495a98877 83
davidjhoward 81:d45bfa16953a 84
jmarkel44 0:65cfa4873284 85 {NULL, NULL, NULL}
jmarkel44 0:65cfa4873284 86 };
jmarkel44 0:65cfa4873284 87
jmarkel44 0:65cfa4873284 88 int func_read(char *buf, int cnt);
jmarkel44 0:65cfa4873284 89 int func_write(const char *buf, int cnt);
jmarkel44 0:65cfa4873284 90 int func_cb_ntshell(const char *text);
jmarkel44 0:65cfa4873284 91 void func_cb_ntopt(int argc, char **argv);
jmarkel44 0:65cfa4873284 92
jmarkel44 0:65cfa4873284 93 /**
jmarkel44 0:65cfa4873284 94 * Serial read function.
jmarkel44 0:65cfa4873284 95 */
jmarkel44 0:65cfa4873284 96 int func_read(char *buf, int cnt)
jmarkel44 0:65cfa4873284 97 {
jmarkel44 0:65cfa4873284 98 for (int i = 0; i < cnt; i++) {
jmarkel44 0:65cfa4873284 99 buf[i] = serial.getc();
jmarkel44 0:65cfa4873284 100 }
jmarkel44 0:65cfa4873284 101 return 0;
jmarkel44 0:65cfa4873284 102 }
jmarkel44 0:65cfa4873284 103
jmarkel44 0:65cfa4873284 104 /**
jmarkel44 0:65cfa4873284 105 * Serial write function.
jmarkel44 0:65cfa4873284 106 */
jmarkel44 0:65cfa4873284 107 int func_write(const char *buf, int cnt)
jmarkel44 0:65cfa4873284 108 {
jmarkel44 0:65cfa4873284 109 for (int i = 0; i < cnt; i++) {
jmarkel44 0:65cfa4873284 110 serial.putc(buf[i]);
jmarkel44 0:65cfa4873284 111 }
jmarkel44 0:65cfa4873284 112 return 0;
jmarkel44 0:65cfa4873284 113 }
jmarkel44 0:65cfa4873284 114
jmarkel44 0:65cfa4873284 115 /**
jmarkel44 0:65cfa4873284 116 * Callback function for ntshell module.
jmarkel44 0:65cfa4873284 117 */
jmarkel44 0:65cfa4873284 118 int func_cb_ntshell(const char *text)
jmarkel44 0:65cfa4873284 119 {
jmarkel44 0:65cfa4873284 120 return ntopt_parse(text, func_cb_ntopt);
jmarkel44 0:65cfa4873284 121 }
jmarkel44 0:65cfa4873284 122
jmarkel44 0:65cfa4873284 123 /**
jmarkel44 0:65cfa4873284 124 * Callback function for ntopt module.
jmarkel44 0:65cfa4873284 125 */
jmarkel44 0:65cfa4873284 126 void func_cb_ntopt(int argc, char **argv)
jmarkel44 0:65cfa4873284 127 {
jmarkel44 0:65cfa4873284 128 if (argc == 0) {
jmarkel44 0:65cfa4873284 129 return;
jmarkel44 0:65cfa4873284 130 }
jmarkel44 0:65cfa4873284 131 int execnt = 0;
jmarkel44 0:65cfa4873284 132 const command_table_t *p = &cmdlist[0];
jmarkel44 0:65cfa4873284 133 while (p->command != NULL) {
jmarkel44 0:65cfa4873284 134 if (strcmp(argv[0], p->command) == 0) {
jmarkel44 0:65cfa4873284 135 p->func(argc, argv);
jmarkel44 0:65cfa4873284 136 execnt++;
jmarkel44 0:65cfa4873284 137 }
jmarkel44 0:65cfa4873284 138 p++;
jmarkel44 0:65cfa4873284 139 }
jmarkel44 0:65cfa4873284 140 if (execnt == 0) {
jmarkel44 0:65cfa4873284 141 printf("Command not found.\r\n");
jmarkel44 0:65cfa4873284 142 }
jmarkel44 0:65cfa4873284 143 wait_ms(250);
jmarkel44 0:65cfa4873284 144 }
jmarkel44 0:65cfa4873284 145
jmarkel44 0:65cfa4873284 146 /************************* callback functions *******************************/
jmarkel44 35:6235ef67faa1 147
jmarkel44 35:6235ef67faa1 148 /*****************************************************************************
jmarkel44 35:6235ef67faa1 149 * Function: cmd_help
jmarkel44 35:6235ef67faa1 150 * Description: displays the list of commands available
jmarkel44 35:6235ef67faa1 151 *
jmarkel44 35:6235ef67faa1 152 * @param argc (not used)
jmarkel44 35:6235ef67faa1 153 * @param argv (not used)
jmarkel44 35:6235ef67faa1 154 * @return none
jmarkel44 35:6235ef67faa1 155 *****************************************************************************/
jmarkel44 0:65cfa4873284 156 void cmd_help(int argc, char **argv)
jmarkel44 0:65cfa4873284 157 {
jmarkel44 0:65cfa4873284 158 UNUSED(argc);
jmarkel44 0:65cfa4873284 159 UNUSED(argv);
jmarkel44 0:65cfa4873284 160
jmarkel44 0:65cfa4873284 161 const command_table_t *tblPtr = cmdlist;
jmarkel44 0:65cfa4873284 162
jmarkel44 0:65cfa4873284 163 while (tblPtr->command) {
jmarkel44 0:65cfa4873284 164 printf("\r%-32s:\t%s\n", tblPtr->command, tblPtr->description);
jmarkel44 0:65cfa4873284 165 tblPtr++;
jmarkel44 0:65cfa4873284 166 }
jmarkel44 0:65cfa4873284 167 printf("\r\n");
jmarkel44 0:65cfa4873284 168 }
jmarkel44 0:65cfa4873284 169
jmarkel44 36:f240f5a6d0ed 170
jmarkel44 36:f240f5a6d0ed 171 /*****************************************************************************
jmarkel44 36:f240f5a6d0ed 172 * Function: cmd_logLevel
davidjhoward 41:e8946fc01ea4 173 * Description: get or set the current log-level
jmarkel44 36:f240f5a6d0ed 174 *
jmarkel44 36:f240f5a6d0ed 175 * @param argc (not used)
jmarkel44 36:f240f5a6d0ed 176 * @param argv (not used)
jmarkel44 36:f240f5a6d0ed 177 * @return none
jmarkel44 36:f240f5a6d0ed 178 *****************************************************************************/
jmarkel44 36:f240f5a6d0ed 179 void cmd_logLevel(int argc, char **argv)
jmarkel44 36:f240f5a6d0ed 180 {
jmarkel44 36:f240f5a6d0ed 181 uint8_t logLevel = 0;
davidjhoward 41:e8946fc01ea4 182
davidjhoward 41:e8946fc01ea4 183 const char *mapper[] = { "NONE",
davidjhoward 41:e8946fc01ea4 184 "FATAL",
davidjhoward 41:e8946fc01ea4 185 "ERROR",
davidjhoward 41:e8946fc01ea4 186 "WARNING",
davidjhoward 41:e8946fc01ea4 187 "INFO",
davidjhoward 41:e8946fc01ea4 188 "DEBUG",
davidjhoward 41:e8946fc01ea4 189 "TRACE"
davidjhoward 41:e8946fc01ea4 190 };
davidjhoward 41:e8946fc01ea4 191
jmarkel44 36:f240f5a6d0ed 192 if ( argc == 1 ) {
davidjhoward 41:e8946fc01ea4 193 printf("\r current log-level set to %s\r\n",
davidjhoward 41:e8946fc01ea4 194 mapper[GLOBAL_mdot->getLogLevel()]);
jmarkel44 36:f240f5a6d0ed 195 goto usage;
jmarkel44 36:f240f5a6d0ed 196 }
jmarkel44 36:f240f5a6d0ed 197
jmarkel44 36:f240f5a6d0ed 198 if ( argc != 2 ) {
jmarkel44 36:f240f5a6d0ed 199 usage:
jmarkel44 36:f240f5a6d0ed 200 printf("\rusage: log-level [0-6]\n");
jmarkel44 36:f240f5a6d0ed 201 printf("\r 0 = NONE\n");
jmarkel44 36:f240f5a6d0ed 202 printf("\r 1 = FATAL\n");
jmarkel44 36:f240f5a6d0ed 203 printf("\r 2 = ERROR\n");
jmarkel44 36:f240f5a6d0ed 204 printf("\r 3 = WARNING\n");
jmarkel44 36:f240f5a6d0ed 205 printf("\r 4 = INFO\n");
jmarkel44 36:f240f5a6d0ed 206 printf("\r 5 = DEBUG\n");
jmarkel44 36:f240f5a6d0ed 207 printf("\r 6 = TRACE\r\n");
jmarkel44 36:f240f5a6d0ed 208 return;
jmarkel44 36:f240f5a6d0ed 209 }
davidjhoward 41:e8946fc01ea4 210
jmarkel44 36:f240f5a6d0ed 211 logLevel = atoi(argv[1]);
davidjhoward 41:e8946fc01ea4 212 if ( logLevel > 6 )
jmarkel44 36:f240f5a6d0ed 213 goto usage;
davidjhoward 41:e8946fc01ea4 214
davidjhoward 41:e8946fc01ea4 215 // reassign the log level
jmarkel44 36:f240f5a6d0ed 216 printf("...setting log-level to %s\r\n", mapper[logLevel]);
davidjhoward 41:e8946fc01ea4 217 GLOBAL_mdot->setLogLevel(logLevel);
jmarkel44 36:f240f5a6d0ed 218 printf("\r\n");
jmarkel44 36:f240f5a6d0ed 219 }
jmarkel44 36:f240f5a6d0ed 220
jmarkel44 35:6235ef67faa1 221 /*****************************************************************************
jmarkel44 35:6235ef67faa1 222 * Function: cmd_ls
jmarkel44 36:f240f5a6d0ed 223 * Description: list the user files on flash
jmarkel44 35:6235ef67faa1 224 *
jmarkel44 35:6235ef67faa1 225 * @param argc (not used)
jmarkel44 35:6235ef67faa1 226 * @param argv (not used)
jmarkel44 35:6235ef67faa1 227 * @return none
jmarkel44 35:6235ef67faa1 228 *****************************************************************************/
jmarkel44 14:cc916fa8dd11 229 void cmd_ls(int argc, char **argv)
jmarkel44 14:cc916fa8dd11 230 {
jmarkel44 35:6235ef67faa1 231 UNUSED(argc);
jmarkel44 35:6235ef67faa1 232 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 233
jmarkel44 14:cc916fa8dd11 234 vector<mDot::mdot_file> userFiles;
jmarkel44 14:cc916fa8dd11 235 userFiles = GLOBAL_mdot->listUserFiles();
jmarkel44 14:cc916fa8dd11 236 vector<mDot::mdot_file>::iterator pos;
jmarkel44 18:9cf694a764c0 237
jmarkel44 14:cc916fa8dd11 238 for ( pos = userFiles.begin(); pos != userFiles.end(); ++pos ) {
jmarkel44 14:cc916fa8dd11 239 printf("\r %-33s %d\n", pos->name, pos->size);
jmarkel44 14:cc916fa8dd11 240 }
jmarkel44 14:cc916fa8dd11 241 printf("\r\n");
jmarkel44 14:cc916fa8dd11 242 }
jmarkel44 14:cc916fa8dd11 243
jmarkel44 35:6235ef67faa1 244 /*****************************************************************************
jmarkel44 35:6235ef67faa1 245 * Function: cmd_ShowControls
jmarkel44 36:f240f5a6d0ed 246 * Description: show active controls
jmarkel44 35:6235ef67faa1 247 *
jmarkel44 35:6235ef67faa1 248 * @param argc (not used)
jmarkel44 35:6235ef67faa1 249 * @param argv (not used)
jmarkel44 35:6235ef67faa1 250 * @return none
jmarkel44 35:6235ef67faa1 251 *****************************************************************************/
jmarkel44 0:65cfa4873284 252 void cmd_ShowControls(int argc, char **argv)
jmarkel44 0:65cfa4873284 253 {
jmarkel44 0:65cfa4873284 254 UNUSED(argc);
jmarkel44 0:65cfa4873284 255 UNUSED(argv);
jmarkel44 12:ea87887ca7ad 256 ConfigurationHandler_showControls();
jmarkel44 18:9cf694a764c0 257 printf("\r\n");
jmarkel44 18:9cf694a764c0 258
jmarkel44 0:65cfa4873284 259 }
jmarkel44 0:65cfa4873284 260
jmarkel44 35:6235ef67faa1 261 /*****************************************************************************
jmarkel44 35:6235ef67faa1 262 * Function: cmd_reset
jmarkel44 36:f240f5a6d0ed 263 * Description: reset the cpu
jmarkel44 35:6235ef67faa1 264 *
jmarkel44 35:6235ef67faa1 265 * @param argc (not used)
jmarkel44 35:6235ef67faa1 266 * @param argv (not used)
jmarkel44 35:6235ef67faa1 267 * @return none
jmarkel44 35:6235ef67faa1 268 *****************************************************************************/
jmarkel44 0:65cfa4873284 269 void cmd_reset(int argc, char **argv)
jmarkel44 0:65cfa4873284 270 {
jmarkel44 0:65cfa4873284 271 UNUSED(argc);
jmarkel44 0:65cfa4873284 272 UNUSED(argv);
jmarkel44 18:9cf694a764c0 273 GLOBAL_mdot->resetCpu();
jmarkel44 0:65cfa4873284 274 }
jmarkel44 0:65cfa4873284 275
jmarkel44 35:6235ef67faa1 276 /*****************************************************************************
jmarkel44 35:6235ef67faa1 277 * Function: cmd_rm
jmarkel44 35:6235ef67faa1 278 * Description: removes a user file from flash
jmarkel44 35:6235ef67faa1 279 *
jmarkel44 35:6235ef67faa1 280 * @param argc-> number of args
jmarkel44 36:f240f5a6d0ed 281 * @param argv-> filename
jmarkel44 35:6235ef67faa1 282 * @return none
jmarkel44 35:6235ef67faa1 283 *****************************************************************************/
jmarkel44 14:cc916fa8dd11 284 void cmd_rm(int argc, char **argv)
jmarkel44 14:cc916fa8dd11 285 {
jmarkel44 18:9cf694a764c0 286 UNUSED(argc);
jmarkel44 14:cc916fa8dd11 287 UNUSED(argv);
jmarkel44 18:9cf694a764c0 288
jmarkel44 14:cc916fa8dd11 289 if ( argc != 2 ) {
jmarkel44 14:cc916fa8dd11 290 printf("\rusage: rm <filename>\n");
jmarkel44 14:cc916fa8dd11 291 return;
jmarkel44 14:cc916fa8dd11 292 }
jmarkel44 43:62de0e05ab6b 293 if ( strcmp(argv[1], "*") == 0 ) {
jmarkel44 43:62de0e05ab6b 294 vector<mDot::mdot_file> userFiles;
jmarkel44 43:62de0e05ab6b 295 userFiles = GLOBAL_mdot->listUserFiles();
jmarkel44 43:62de0e05ab6b 296 vector<mDot::mdot_file>::iterator pos;
jmarkel44 43:62de0e05ab6b 297 for ( pos = userFiles.begin(); pos != userFiles.end(); ++pos ) {
jmarkel44 43:62de0e05ab6b 298 GLOBAL_mdot->deleteUserFile(pos->name);
jmarkel44 43:62de0e05ab6b 299 }
jmarkel44 43:62de0e05ab6b 300 } else {
jmarkel44 43:62de0e05ab6b 301 GLOBAL_mdot->deleteUserFile(argv[1]);
jmarkel44 43:62de0e05ab6b 302 }
jmarkel44 14:cc916fa8dd11 303 }
jmarkel44 18:9cf694a764c0 304
jmarkel44 35:6235ef67faa1 305 /*****************************************************************************
jmarkel44 35:6235ef67faa1 306 * Function: cmd_create
jmarkel44 36:f240f5a6d0ed 307 * Description: create a control
jmarkel44 35:6235ef67faa1 308 *
jmarkel44 35:6235ef67faa1 309 * @param argc-> number of args
jmarkel44 35:6235ef67faa1 310 * @param argv-> control name, control type
jmarkel44 35:6235ef67faa1 311 * @return none
jmarkel44 35:6235ef67faa1 312 *****************************************************************************/
jmarkel44 0:65cfa4873284 313 void cmd_create(int argc, char **argv)
jmarkel44 0:65cfa4873284 314 {
jmarkel44 0:65cfa4873284 315 if ( argc != 3 ) {
jmarkel44 0:65cfa4873284 316 printf("\r\nusage: create [controlName] [controlType]\n");
jmarkel44 18:9cf694a764c0 317 printf("\rcontrolType-> 0=timer, 1=PID, 2=setpoint, 3=composite, 4=manual\r\n");
jmarkel44 0:65cfa4873284 318 return;
jmarkel44 0:65cfa4873284 319 }
jmarkel44 0:65cfa4873284 320 // send a message to the configuration handler to create the control
jmarkel44 0:65cfa4873284 321 Message_t *msg = MailBox.alloc();
jmarkel44 0:65cfa4873284 322 memset(msg, 0, sizeof(Message_t));
jmarkel44 0:65cfa4873284 323 msg->action = ACTION_CREATE;
jmarkel44 0:65cfa4873284 324 msg->control = (Control_t) atoi(argv[2]);
jmarkel44 0:65cfa4873284 325 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 0:65cfa4873284 326
jmarkel44 0:65cfa4873284 327 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 0:65cfa4873284 328 __func__, msg->controlFile, msg->control);
jmarkel44 0:65cfa4873284 329
jmarkel44 0:65cfa4873284 330 MailBox.put(msg);
jmarkel44 18:9cf694a764c0 331 printf("\r\n");
jmarkel44 0:65cfa4873284 332 return;
jmarkel44 0:65cfa4873284 333 }
jmarkel44 0:65cfa4873284 334
jmarkel44 35:6235ef67faa1 335 /*****************************************************************************
jmarkel44 35:6235ef67faa1 336 * Function: cmd_destroy
jmarkel44 36:f240f5a6d0ed 337 * Description: reset the cpu
jmarkel44 35:6235ef67faa1 338 *
jmarkel44 35:6235ef67faa1 339 * @param argc-> number of arguments
jmarkel44 36:f240f5a6d0ed 340 * @param argv-> control name, control type
jmarkel44 35:6235ef67faa1 341 * @return none
jmarkel44 35:6235ef67faa1 342 *****************************************************************************/
jmarkel44 0:65cfa4873284 343 void cmd_destroy(int argc, char **argv)
jmarkel44 0:65cfa4873284 344 {
jmarkel44 12:ea87887ca7ad 345 if ( argc != 3 ) {
jmarkel44 12:ea87887ca7ad 346 printf("\r\nusage: destroy [controlName] [controlType]\n");
jmarkel44 18:9cf694a764c0 347 printf("\rcontrolType-> 0=timer, 1=PID, 2=setpoint, 3=composite, 4=manual\r\n");
jmarkel44 0:65cfa4873284 348 return;
jmarkel44 0:65cfa4873284 349 }
jmarkel44 0:65cfa4873284 350
jmarkel44 0:65cfa4873284 351 // send a message to the configuration handler to destroy the control
jmarkel44 0:65cfa4873284 352 Message_t *msg = MailBox.alloc();
jmarkel44 0:65cfa4873284 353 memset(msg, 0, sizeof(Message_t));
jmarkel44 0:65cfa4873284 354 msg->action = ACTION_DESTROY;
jmarkel44 12:ea87887ca7ad 355 msg->control = (Control_t) atoi(argv[2]);
jmarkel44 0:65cfa4873284 356 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 0:65cfa4873284 357
jmarkel44 0:65cfa4873284 358 printf("%s: Sending a destroy request for control %s\r\n",
jmarkel44 0:65cfa4873284 359 __func__, msg->controlFile);
jmarkel44 0:65cfa4873284 360
jmarkel44 0:65cfa4873284 361 MailBox.put(msg);
jmarkel44 18:9cf694a764c0 362 printf("\r\n");
jmarkel44 0:65cfa4873284 363 return;
jmarkel44 0:65cfa4873284 364 }
jmarkel44 0:65cfa4873284 365
jmarkel44 35:6235ef67faa1 366 /*****************************************************************************
jmarkel44 96:807f04bd5256 367 * Function: cmd_createSetpoint
jmarkel44 37:7e6986b77f01 368 * Description: create control file
jmarkel44 35:6235ef67faa1 369 *
jmarkel44 35:6235ef67faa1 370 * @param argc-> number of args
jmarkel44 36:f240f5a6d0ed 371 * @param argv-> filename
jmarkel44 35:6235ef67faa1 372 * @return none
jmarkel44 35:6235ef67faa1 373 *****************************************************************************/
jmarkel44 96:807f04bd5256 374 void cmd_createSetpoint(int argc, char **argv)
jmarkel44 18:9cf694a764c0 375 {
jmarkel44 96:807f04bd5256 376 if ( argc != 7 ) {
jmarkel44 96:807f04bd5256 377 printf("\rusage: create-setpoint <filename> <id> <input> <output> <direction> <tolerance>\n");
jmarkel44 96:807f04bd5256 378 printf("\rexample: create-setpoint control_sp_1.json SPC_01 i_tra01 o_rly1 1 5\r\n");
jmarkel44 18:9cf694a764c0 379 return;
jmarkel44 18:9cf694a764c0 380 }
jmarkel44 36:f240f5a6d0ed 381
jmarkel44 18:9cf694a764c0 382 char data_buf[1024];
jmarkel44 36:f240f5a6d0ed 383 snprintf(data_buf, sizeof(data_buf),
jmarkel44 36:f240f5a6d0ed 384 "{ "
jmarkel44 89:55ac65d7f206 385 "\"id\": \"%s\", "
jmarkel44 96:807f04bd5256 386 "\"priority\": \"800\","
jmarkel44 89:55ac65d7f206 387 "\"input\": \"%s\", "
jmarkel44 89:55ac65d7f206 388 "\"output\": \"%s\", "
jmarkel44 96:807f04bd5256 389 "\"setpoint\": \"100\","
jmarkel44 96:807f04bd5256 390 "\"prodfact\": \"100\","
jmarkel44 93:1553fb156915 391 "\"actingDir\": \"%s\", "
jmarkel44 96:807f04bd5256 392 "\"halert\": \"115\","
jmarkel44 89:55ac65d7f206 393 "\"lalert\": \"85\", "
jmarkel44 96:807f04bd5256 394 "\"hfs\": \"130\","
jmarkel44 96:807f04bd5256 395 "\"lfs\": \"70\", "
jmarkel44 96:807f04bd5256 396 "\"tol\": \"%s\" ", argv[2], argv[3], argv[4], argv[5], argv[6]
jmarkel44 36:f240f5a6d0ed 397 );
jmarkel44 18:9cf694a764c0 398
jmarkel44 18:9cf694a764c0 399 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, 1024);
jmarkel44 18:9cf694a764c0 400 if( status != true ) {
jmarkel44 18:9cf694a764c0 401 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 96:807f04bd5256 402 return;
jmarkel44 18:9cf694a764c0 403 }
jmarkel44 96:807f04bd5256 404
jmarkel44 96:807f04bd5256 405 // send a message to the configuration handler to create the control
jmarkel44 96:807f04bd5256 406 Message_t *msg = MailBox.alloc();
jmarkel44 96:807f04bd5256 407 memset(msg, 0, sizeof(Message_t));
jmarkel44 96:807f04bd5256 408 msg->action = ACTION_CREATE;
jmarkel44 96:807f04bd5256 409 msg->control = CONTROL_SETPOINT;
jmarkel44 96:807f04bd5256 410 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 96:807f04bd5256 411
jmarkel44 96:807f04bd5256 412 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 96:807f04bd5256 413 __func__, msg->controlFile, msg->control);
jmarkel44 96:807f04bd5256 414
jmarkel44 96:807f04bd5256 415 MailBox.put(msg);
jmarkel44 96:807f04bd5256 416 printf("\r\n");
jmarkel44 96:807f04bd5256 417 return;
jmarkel44 18:9cf694a764c0 418 }
jmarkel44 18:9cf694a764c0 419
jmarkel44 35:6235ef67faa1 420 /*****************************************************************************
jmarkel44 97:5cf6ab71dcd0 421 * Function: cmd_createManual
jmarkel44 97:5cf6ab71dcd0 422 * Description: create a manual control
jmarkel44 97:5cf6ab71dcd0 423 *
jmarkel44 97:5cf6ab71dcd0 424 * @param argc-> number of args
jmarkel44 97:5cf6ab71dcd0 425 * @param argv-> filename
jmarkel44 97:5cf6ab71dcd0 426 * @return none
jmarkel44 97:5cf6ab71dcd0 427 *****************************************************************************/
jmarkel44 97:5cf6ab71dcd0 428 void cmd_createManual(int argc, char **argv)
jmarkel44 97:5cf6ab71dcd0 429 {
jmarkel44 97:5cf6ab71dcd0 430 if ( argc != 4 ) {
jmarkel44 97:5cf6ab71dcd0 431 printf("\rusage: create-manual <filename> <output> <state>\n");
jmarkel44 97:5cf6ab71dcd0 432 printf("\rexample: create-manual control_mn_1.json o_rly1 1\n");
jmarkel44 97:5cf6ab71dcd0 433 return;
jmarkel44 97:5cf6ab71dcd0 434 }
jmarkel44 97:5cf6ab71dcd0 435
jmarkel44 97:5cf6ab71dcd0 436 char data_buf[1024];
jmarkel44 97:5cf6ab71dcd0 437 snprintf(data_buf, sizeof(data_buf),
jmarkel44 97:5cf6ab71dcd0 438 "{ "
jmarkel44 97:5cf6ab71dcd0 439 "\"id\": \"%s\", "
jmarkel44 97:5cf6ab71dcd0 440 "\"type\": \"1\","
jmarkel44 97:5cf6ab71dcd0 441 "\"priority\": \"100\", "
jmarkel44 97:5cf6ab71dcd0 442 "\"duration\": \"0\", "
jmarkel44 97:5cf6ab71dcd0 443 "\"setpoint\": \"0\","
jmarkel44 97:5cf6ab71dcd0 444 "\"state\": \"%d\","
jmarkel44 97:5cf6ab71dcd0 445 "\"percent\": \"100\" ", argv[2], atoi(argv[3])
jmarkel44 97:5cf6ab71dcd0 446 );
jmarkel44 97:5cf6ab71dcd0 447
jmarkel44 97:5cf6ab71dcd0 448 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, 1024);
jmarkel44 97:5cf6ab71dcd0 449 if( status != true ) {
jmarkel44 97:5cf6ab71dcd0 450 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 97:5cf6ab71dcd0 451 return;
jmarkel44 97:5cf6ab71dcd0 452 }
jmarkel44 97:5cf6ab71dcd0 453
jmarkel44 97:5cf6ab71dcd0 454 // send a message to the configuration handler to create the control
jmarkel44 97:5cf6ab71dcd0 455 Message_t *msg = MailBox.alloc();
jmarkel44 97:5cf6ab71dcd0 456 memset(msg, 0, sizeof(Message_t));
jmarkel44 97:5cf6ab71dcd0 457 msg->action = ACTION_CREATE;
jmarkel44 97:5cf6ab71dcd0 458 msg->control = CONTROL_MANUAL;
jmarkel44 97:5cf6ab71dcd0 459 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 97:5cf6ab71dcd0 460
jmarkel44 97:5cf6ab71dcd0 461 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 97:5cf6ab71dcd0 462 __func__, msg->controlFile, msg->control);
jmarkel44 97:5cf6ab71dcd0 463
jmarkel44 97:5cf6ab71dcd0 464 MailBox.put(msg);
jmarkel44 97:5cf6ab71dcd0 465 printf("\r\n");
jmarkel44 97:5cf6ab71dcd0 466 return;
jmarkel44 97:5cf6ab71dcd0 467 }
jmarkel44 97:5cf6ab71dcd0 468
jmarkel44 97:5cf6ab71dcd0 469 /*****************************************************************************
jmarkel44 37:7e6986b77f01 470 * Function: cmd_cif
jmarkel44 37:7e6986b77f01 471 * Description: create input file
jmarkel44 37:7e6986b77f01 472 *
jmarkel44 37:7e6986b77f01 473 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 474 * @param argv-> filename
jmarkel44 37:7e6986b77f01 475 * @return none
jmarkel44 37:7e6986b77f01 476 *****************************************************************************/
jmarkel44 37:7e6986b77f01 477 void cmd_cif(int argc, char **argv)
jmarkel44 37:7e6986b77f01 478 {
jmarkel44 37:7e6986b77f01 479 if ( argc != 2 ) {
jmarkel44 37:7e6986b77f01 480 printf("\rusage: cif <filename>\r\n");
jmarkel44 37:7e6986b77f01 481 return;
jmarkel44 37:7e6986b77f01 482 }
jmarkel44 37:7e6986b77f01 483
jmarkel44 37:7e6986b77f01 484 char data_buf[1024];
jmarkel44 37:7e6986b77f01 485 snprintf(data_buf, sizeof(data_buf),
jmarkel44 37:7e6986b77f01 486 "{ "
davidjhoward 41:e8946fc01ea4 487 "\"id\": \"i_tra01\", "
jmarkel44 37:7e6986b77f01 488 "\"name\": \"TRASAR\", "
jmarkel44 37:7e6986b77f01 489 "\"units\": \"PPM\", "
jmarkel44 37:7e6986b77f01 490 "\"min\": \"0\", "
jmarkel44 37:7e6986b77f01 491 "\"max\": \"300\", "
davidjhoward 41:e8946fc01ea4 492 "\"node\": \"1\", "
davidjhoward 41:e8946fc01ea4 493 "\"reg\": \"9\", "
jmarkel44 37:7e6986b77f01 494 "\"rtype\": \"1\", "
davidjhoward 54:ec1b03064bbd 495 "\"type\": \"0\", "
davidjhoward 41:e8946fc01ea4 496 "\"size\": \"2\", "
davidjhoward 41:e8946fc01ea4 497 "\"order\": \"2\", "
davidjhoward 41:e8946fc01ea4 498 "\"rfreq\": \"5\", "
jmarkel44 37:7e6986b77f01 499 "\"fmt\": \"%%.2f\" } "
jmarkel44 37:7e6986b77f01 500 );
jmarkel44 37:7e6986b77f01 501
jmarkel44 37:7e6986b77f01 502 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, 1024);
jmarkel44 37:7e6986b77f01 503 if( status != true ) {
jmarkel44 37:7e6986b77f01 504 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 505 }
davidjhoward 41:e8946fc01ea4 506
davidjhoward 42:c703a60993b1 507 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", argv[1]);
davidjhoward 41:e8946fc01ea4 508 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 41:e8946fc01ea4 509 mail->action = ACTION_READ_FILE;
davidjhoward 41:e8946fc01ea4 510 strncpy( mail->controlFile, argv[1], (sizeof(mail->controlFile)-1));
davidjhoward 41:e8946fc01ea4 511 ModbusMasterMailBox.put(mail);
jmarkel44 37:7e6986b77f01 512 }
jmarkel44 37:7e6986b77f01 513
jmarkel44 37:7e6986b77f01 514 /*****************************************************************************
jmarkel44 96:807f04bd5256 515 * Function: cmd_cmf
jmarkel44 96:807f04bd5256 516 * Description: create manual control file
jmarkel44 96:807f04bd5256 517 *
jmarkel44 96:807f04bd5256 518 * @param argc-> number of args
jmarkel44 96:807f04bd5256 519 * @param argv-> filename
jmarkel44 96:807f04bd5256 520 * @return none
jmarkel44 96:807f04bd5256 521 *****************************************************************************/
jmarkel44 96:807f04bd5256 522 void cmd_cmf(int argc, char **argv)
jmarkel44 96:807f04bd5256 523 {
jmarkel44 96:807f04bd5256 524 if ( argc != 2 ) {
jmarkel44 96:807f04bd5256 525 printf("\rusage: cmf <filename> <relay\r\n");
jmarkel44 96:807f04bd5256 526 printf("\rexmaple: cmd control_mn_1.json o_rly1");
jmarkel44 96:807f04bd5256 527 return;
jmarkel44 96:807f04bd5256 528 }
jmarkel44 96:807f04bd5256 529
jmarkel44 96:807f04bd5256 530 char data_buf[1024];
jmarkel44 96:807f04bd5256 531 snprintf(data_buf, sizeof(data_buf),
jmarkel44 96:807f04bd5256 532 "{ "
jmarkel44 96:807f04bd5256 533 "\"id\": \"%s\", "
jmarkel44 96:807f04bd5256 534 "\"type\": \"1\", "
jmarkel44 96:807f04bd5256 535 "\"priority\": \"100\", "
jmarkel44 96:807f04bd5256 536 "\"duration\": \"30\", " // seconds
jmarkel44 96:807f04bd5256 537 "\"setpoint\": \"2000.0\", "
jmarkel44 96:807f04bd5256 538 "\"state\": \"1\", "
jmarkel44 96:807f04bd5256 539 "\"percent\": \"100\", ", argv[2]
jmarkel44 96:807f04bd5256 540
jmarkel44 96:807f04bd5256 541 );
jmarkel44 96:807f04bd5256 542
jmarkel44 96:807f04bd5256 543 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, 1024);
jmarkel44 96:807f04bd5256 544 if( status != true ) {
jmarkel44 96:807f04bd5256 545 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 96:807f04bd5256 546 }
jmarkel44 96:807f04bd5256 547 }
jmarkel44 96:807f04bd5256 548
jmarkel44 96:807f04bd5256 549
jmarkel44 96:807f04bd5256 550 /*****************************************************************************
jmarkel44 37:7e6986b77f01 551 * Function: cmd_cof
jmarkel44 37:7e6986b77f01 552 * Description: create output file
jmarkel44 37:7e6986b77f01 553 *
jmarkel44 37:7e6986b77f01 554 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 555 * @param argv-> filename
jmarkel44 37:7e6986b77f01 556 * @return none
jmarkel44 37:7e6986b77f01 557 *****************************************************************************/
jmarkel44 37:7e6986b77f01 558 void cmd_cof(int argc, char **argv)
jmarkel44 37:7e6986b77f01 559 {
davidjhoward 81:d45bfa16953a 560 if ( argc != 5 ) {
davidjhoward 81:d45bfa16953a 561 printf("\rusage: cof <filename> <output> <name> <reg>\r\n");
davidjhoward 81:d45bfa16953a 562 printf("\rexample: cof output_rly1.json o_rly1 Relay1 1\r\n");
jmarkel44 37:7e6986b77f01 563 return;
jmarkel44 37:7e6986b77f01 564 }
jmarkel44 37:7e6986b77f01 565
jmarkel44 37:7e6986b77f01 566 char data_buf[1024];
jmarkel44 67:49f266601d83 567 #if 0
jmarkel44 37:7e6986b77f01 568 snprintf(data_buf, sizeof(data_buf),
jmarkel44 37:7e6986b77f01 569 "{ "
davidjhoward 41:e8946fc01ea4 570 "\"id\": \"o_r05\", "
davidjhoward 41:e8946fc01ea4 571 "\"name\": \"Relay 5\", "
jmarkel44 37:7e6986b77f01 572 "\"min\": \"0\", "
jmarkel44 37:7e6986b77f01 573 "\"max\": \"300\", "
jmarkel44 37:7e6986b77f01 574 "\"node\": \"20\", "
jmarkel44 37:7e6986b77f01 575 "\"reg\": \"21\", "
jmarkel44 37:7e6986b77f01 576 "\"rtype\": \"1\", "
jmarkel44 37:7e6986b77f01 577 "\"type\": \"16\", "
jmarkel44 37:7e6986b77f01 578 "\"fmt\": \"%%.2f\", "
jmarkel44 37:7e6986b77f01 579 "\"toperiod\": \"0\", "
jmarkel44 37:7e6986b77f01 580 "\"scalelo\": \"0\", "
jmarkel44 37:7e6986b77f01 581 "\"scalehi\": \"100\" }"
davidjhoward 41:e8946fc01ea4 582 );
jmarkel44 67:49f266601d83 583 #endif
jmarkel44 37:7e6986b77f01 584
jmarkel44 67:49f266601d83 585 snprintf(data_buf, sizeof(data_buf),
jmarkel44 67:49f266601d83 586 "{ "
jmarkel44 67:49f266601d83 587 "\"id\": \"%s\", "
davidjhoward 81:d45bfa16953a 588 "\"name\": \"%s\", "
davidjhoward 81:d45bfa16953a 589 "\"units\": \"\", "
jmarkel44 67:49f266601d83 590 "\"min\": \"0\", "
jmarkel44 67:49f266601d83 591 "\"max\": \"300\", "
davidjhoward 81:d45bfa16953a 592 "\"node\": \"0\", "
davidjhoward 81:d45bfa16953a 593 "\"reg\": \"%s\", "
jmarkel44 67:49f266601d83 594 "\"rtype\": \"1\", "
jmarkel44 67:49f266601d83 595 "\"type\": \"16\", "
davidjhoward 81:d45bfa16953a 596 "\"size\": \"2\", "
davidjhoward 81:d45bfa16953a 597 "\"order\": \"2\", "
jmarkel44 67:49f266601d83 598 "\"fmt\": \"%%.2f\", "
davidjhoward 81:d45bfa16953a 599 "\"rfreq\": \"5\", "
jmarkel44 67:49f266601d83 600 "\"toperiod\": \"0\", "
jmarkel44 67:49f266601d83 601 "\"scalelo\": \"0\", "
davidjhoward 81:d45bfa16953a 602 "\"scalehi\": \"100\" }", argv[2], argv[3], argv[4]);
davidjhoward 81:d45bfa16953a 603
jmarkel44 37:7e6986b77f01 604 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, 1024);
jmarkel44 37:7e6986b77f01 605 if( status != true ) {
jmarkel44 37:7e6986b77f01 606 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 607 }
jmarkel44 43:62de0e05ab6b 608
jmarkel44 63:0ded43237b22 609 // send a message to the modbust master
jmarkel44 63:0ded43237b22 610 logInfo("Sending mail to ModbusMasterMailBox, filename=%s", argv[1]);
jmarkel44 63:0ded43237b22 611 Message_t *modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 612 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 63:0ded43237b22 613 strncpy( modbus_mail->controlFile, argv[1], (sizeof(modbus_mail->controlFile)-1));
jmarkel44 63:0ded43237b22 614 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 67:49f266601d83 615
jmarkel44 63:0ded43237b22 616 // send a message to the output master
jmarkel44 63:0ded43237b22 617 logInfo("Sending mail to OutputMaster, filename = %s", argv[1]);
jmarkel44 63:0ded43237b22 618 OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 619 output_mail->action = ACTION_NEW;
jmarkel44 63:0ded43237b22 620 strncpy(output_mail->controlFile, argv[1], sizeof(output_mail->controlFile)-1);
jmarkel44 63:0ded43237b22 621 OutputMasterMailBox.put(output_mail);
jmarkel44 37:7e6986b77f01 622 }
jmarkel44 37:7e6986b77f01 623
jmarkel44 37:7e6986b77f01 624 /*****************************************************************************
jmarkel44 35:6235ef67faa1 625 * Function: cmd_heap
jmarkel44 35:6235ef67faa1 626 * Description: display heap statistics
jmarkel44 35:6235ef67faa1 627 *
jmarkel44 35:6235ef67faa1 628 * @param argc (not used)
jmarkel44 35:6235ef67faa1 629 * @param argv (not used)
jmarkel44 35:6235ef67faa1 630 * @return none
jmarkel44 35:6235ef67faa1 631 *****************************************************************************/
jmarkel44 0:65cfa4873284 632 void cmd_heap(int argc, char **argv)
jmarkel44 0:65cfa4873284 633 {
jmarkel44 0:65cfa4873284 634 UNUSED(argc), UNUSED(argv);
jmarkel44 0:65cfa4873284 635 __heapstats((__heapprt)fprintf,stderr); // print initial free heap size
jmarkel44 0:65cfa4873284 636 }
jmarkel44 0:65cfa4873284 637
jmarkel44 35:6235ef67faa1 638 /*****************************************************************************
jmarkel44 35:6235ef67faa1 639 * Function: cmd_modify
jmarkel44 36:f240f5a6d0ed 640 * Description: modify an active control
jmarkel44 35:6235ef67faa1 641 *
jmarkel44 35:6235ef67faa1 642 * @param argc (not used)
jmarkel44 35:6235ef67faa1 643 * @param argv (not used)
jmarkel44 35:6235ef67faa1 644 * @return none
jmarkel44 35:6235ef67faa1 645 *****************************************************************************/
jmarkel44 0:65cfa4873284 646 void cmd_modify(int argc, char **argv)
jmarkel44 0:65cfa4873284 647 {
jmarkel44 0:65cfa4873284 648 // stubbed
jmarkel44 3:8ea4db957749 649 printf("\rNot yet implemented.\n");
jmarkel44 0:65cfa4873284 650 return;
jmarkel44 0:65cfa4873284 651 }
jmarkel44 0:65cfa4873284 652
jmarkel44 35:6235ef67faa1 653 /*****************************************************************************
jmarkel44 35:6235ef67faa1 654 * Function: cmd_stats
jmarkel44 35:6235ef67faa1 655 * Description: display mDot stats
jmarkel44 35:6235ef67faa1 656 *
jmarkel44 35:6235ef67faa1 657 * @param argc (not used)
jmarkel44 35:6235ef67faa1 658 * @param argv (not used)
jmarkel44 35:6235ef67faa1 659 * @return none
jmarkel44 35:6235ef67faa1 660 *****************************************************************************/
jmarkel44 18:9cf694a764c0 661 void cmd_stats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 662 {
jmarkel44 35:6235ef67faa1 663 UNUSED(argc);
jmarkel44 35:6235ef67faa1 664 UNUSED(argv);
davidjhoward 81:d45bfa16953a 665
jmarkel44 18:9cf694a764c0 666 mDot::mdot_stats stats = GLOBAL_mdot->getStats();
jmarkel44 0:65cfa4873284 667
jmarkel44 44:c73f2ca79669 668 printf("\r Up: %u\n", stats.Up);
jmarkel44 44:c73f2ca79669 669 printf("\r Down: %u\n", stats.Down);
jmarkel44 44:c73f2ca79669 670 printf("\r Joins: %u\n", stats.Joins);
jmarkel44 44:c73f2ca79669 671 printf("\r JoinFails: %u\n", stats.JoinFails);
jmarkel44 44:c73f2ca79669 672 printf("\r MissedAcks: %u\n", stats.MissedAcks);
jmarkel44 44:c73f2ca79669 673 printf("\r CRCErrors: %u\n", stats.CRCErrors);
jmarkel44 44:c73f2ca79669 674 printf("\r\n");
jmarkel44 44:c73f2ca79669 675 printf("\r Freq band: %u\n", GLOBAL_mdot->getFrequencyBand());
jmarkel44 44:c73f2ca79669 676 printf("\r Freq subband: %u\n", GLOBAL_mdot->getFrequencySubBand());
jmarkel44 44:c73f2ca79669 677 printf("\r Session data rate: %u\n", GLOBAL_mdot->getSessionDataRate());
jmarkel44 44:c73f2ca79669 678 printf("\r Public Network Mode: %s\n", GLOBAL_mdot->getPublicNetwork() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 679 printf("\r Application device port: %u\n", GLOBAL_mdot->getAppPort());
jmarkel44 44:c73f2ca79669 680 printf("\r Class: %s\n", GLOBAL_mdot->getClass().c_str());
jmarkel44 44:c73f2ca79669 681 printf("\r Max packet length: %u\n", GLOBAL_mdot->getMaxPacketLength());
jmarkel44 77:43e0a3d9e536 682 std::vector<uint8_t> na = GLOBAL_mdot->getNetworkAddress();
jmarkel44 77:43e0a3d9e536 683 std::string str(na.begin(), na.end());
jmarkel44 77:43e0a3d9e536 684 printf("\r Network address: %s\n", str.c_str());
jmarkel44 44:c73f2ca79669 685 printf("\r Network name: %s\n", GLOBAL_mdot->getNetworkName().c_str());
jmarkel44 77:43e0a3d9e536 686 std::vector<uint8_t> nid = GLOBAL_mdot->getNetworkId();
jmarkel44 77:43e0a3d9e536 687 std::string networkIdStr(nid.begin(), nid.end());
jmarkel44 77:43e0a3d9e536 688 printf("\r Network ID: %s\n", networkIdStr.c_str());
jmarkel44 44:c73f2ca79669 689 printf("\r Join byter order: %s\n", GLOBAL_mdot->getJoinByteOrder() == 0 ? "LSB" : "MSB");
jmarkel44 44:c73f2ca79669 690 printf("\r Join retries: %u\n", GLOBAL_mdot->getJoinRetries());
jmarkel44 44:c73f2ca79669 691 printf("\r Join mode: %u\n", GLOBAL_mdot->getJoinMode());
jmarkel44 44:c73f2ca79669 692 printf("\r Network join status: %s\n", GLOBAL_mdot->getNetworkJoinStatus() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 693 printf("\r Link fail count: %u\n", GLOBAL_mdot->getLinkFailCount());
jmarkel44 44:c73f2ca79669 694 printf("\r Packets Tx'd to gateway: %u\n", GLOBAL_mdot->getUpLinkCounter());
jmarkel44 44:c73f2ca79669 695 printf("\r Packets Rx'd from gateway: %u\n", GLOBAL_mdot->getDownLinkCounter());
jmarkel44 44:c73f2ca79669 696 printf("\r AES encryption: %s\n", GLOBAL_mdot->getAesEncryption() ? "enabled" : "disabled");
jmarkel44 44:c73f2ca79669 697 printf("\r Tx data rate: %u\n", GLOBAL_mdot->getTxDataRate());
jmarkel44 77:43e0a3d9e536 698 printf("\r Datarate Details: %s\n", GLOBAL_mdot->getDateRateDetails(GLOBAL_mdot->getTxDataRate()).c_str());
jmarkel44 44:c73f2ca79669 699 printf("\r Tx power: %u\n", GLOBAL_mdot->getTxPower());
jmarkel44 44:c73f2ca79669 700 printf("\r Antenna gain: %u\n", GLOBAL_mdot->getAntennaGain());
jmarkel44 44:c73f2ca79669 701 printf("\r Min frequency: %u\n", GLOBAL_mdot->getMinFrequency());
jmarkel44 44:c73f2ca79669 702 printf("\r Max frequency: %u\n", GLOBAL_mdot->getMaxFrequency());
jmarkel44 44:c73f2ca79669 703 printf("\r CRC enabled: %s\n", GLOBAL_mdot->getCrc() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 704 printf("\r ACK enabled: %s\n", GLOBAL_mdot->getAck() ? "yes" : "no");
jmarkel44 18:9cf694a764c0 705
jmarkel44 18:9cf694a764c0 706 printf("\r\n");
jmarkel44 18:9cf694a764c0 707 }
jmarkel44 18:9cf694a764c0 708
jmarkel44 35:6235ef67faa1 709 /*****************************************************************************
jmarkel44 35:6235ef67faa1 710 * Function: cmd_resetStats
jmarkel44 35:6235ef67faa1 711 * Description: resets the mDot stats
jmarkel44 35:6235ef67faa1 712 *
jmarkel44 35:6235ef67faa1 713 * @param argc (not used)
jmarkel44 35:6235ef67faa1 714 * @param argv (not used)
jmarkel44 35:6235ef67faa1 715 * @return none
jmarkel44 35:6235ef67faa1 716 *****************************************************************************/
jmarkel44 18:9cf694a764c0 717 void cmd_resetStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 718 {
jmarkel44 35:6235ef67faa1 719 UNUSED(argc);
jmarkel44 35:6235ef67faa1 720 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 721
jmarkel44 18:9cf694a764c0 722 GLOBAL_mdot->resetStats();
jmarkel44 18:9cf694a764c0 723 }
jmarkel44 0:65cfa4873284 724
jmarkel44 35:6235ef67faa1 725 /*****************************************************************************
jmarkel44 35:6235ef67faa1 726 * Function: cmd_rssiStats
jmarkel44 36:f240f5a6d0ed 727 * Description: displays mDot RSSI statistics
jmarkel44 35:6235ef67faa1 728 *
jmarkel44 35:6235ef67faa1 729 * @param argc (not used)
jmarkel44 35:6235ef67faa1 730 * @param argv (not used)
jmarkel44 35:6235ef67faa1 731 * @return none
jmarkel44 35:6235ef67faa1 732 *****************************************************************************/
jmarkel44 18:9cf694a764c0 733 void cmd_rssiStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 734 {
jmarkel44 35:6235ef67faa1 735 UNUSED(argc);
jmarkel44 35:6235ef67faa1 736 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 737
jmarkel44 18:9cf694a764c0 738 mDot::rssi_stats s = GLOBAL_mdot->getRssiStats();
jmarkel44 0:65cfa4873284 739
jmarkel44 18:9cf694a764c0 740 printf("\r Last: %d dB\n", s.last);
jmarkel44 18:9cf694a764c0 741 printf("\r Min: %d dB\n", s.min);
jmarkel44 18:9cf694a764c0 742 printf("\r Max: %d dB\n", s.max);
jmarkel44 18:9cf694a764c0 743 printf("\r Avg: %d dB\n", s.avg);
jmarkel44 18:9cf694a764c0 744
jmarkel44 18:9cf694a764c0 745 printf("\r\n");
jmarkel44 18:9cf694a764c0 746 }
jmarkel44 18:9cf694a764c0 747
jmarkel44 35:6235ef67faa1 748 /*****************************************************************************
jmarkel44 35:6235ef67faa1 749 * Function: cmd_snrStats
jmarkel44 35:6235ef67faa1 750 * Description: displays signal-to-noise ratio stats
jmarkel44 35:6235ef67faa1 751 *
jmarkel44 35:6235ef67faa1 752 * @param argc (not used)
jmarkel44 35:6235ef67faa1 753 * @param argv (not used)
jmarkel44 35:6235ef67faa1 754 * @return none
jmarkel44 35:6235ef67faa1 755 *****************************************************************************/
jmarkel44 18:9cf694a764c0 756 void cmd_snrStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 757 {
jmarkel44 18:9cf694a764c0 758 mDot::snr_stats s = GLOBAL_mdot->getSnrStats();
jmarkel44 18:9cf694a764c0 759
jmarkel44 18:9cf694a764c0 760 printf("\r Last: %d cB\n", s.last);
jmarkel44 18:9cf694a764c0 761 printf("\r Min: %d cB\n", s.min);
jmarkel44 18:9cf694a764c0 762 printf("\r Max: %d cB\n", s.max);
jmarkel44 18:9cf694a764c0 763 printf("\r Avg: %d cB\n", s.avg);
jmarkel44 18:9cf694a764c0 764
jmarkel44 18:9cf694a764c0 765 printf("\r\n");
jmarkel44 18:9cf694a764c0 766 }
jmarkel44 34:f345fdec711d 767
jmarkel44 35:6235ef67faa1 768 /*****************************************************************************
jmarkel44 35:6235ef67faa1 769 * Function: cmd_stack
jmarkel44 36:f240f5a6d0ed 770 * Description: display thread stack statisics
jmarkel44 35:6235ef67faa1 771 *
jmarkel44 35:6235ef67faa1 772 * @param argc (not used)
jmarkel44 35:6235ef67faa1 773 * @param argv (not used)
jmarkel44 35:6235ef67faa1 774 * @return none
jmarkel44 35:6235ef67faa1 775 *****************************************************************************/
jmarkel44 34:f345fdec711d 776 void cmd_stack(int argc, char **argv)
jmarkel44 34:f345fdec711d 777 {
jmarkel44 36:f240f5a6d0ed 778 vector<pair<string, Thread*> > taskList;
davidjhoward 81:d45bfa16953a 779
jmarkel44 71:34856d21f2bf 780 const char *mapper[] = { "Inactive",
jmarkel44 71:34856d21f2bf 781 "Ready",
jmarkel44 71:34856d21f2bf 782 "Running",
jmarkel44 71:34856d21f2bf 783 "WaitingDelay",
jmarkel44 71:34856d21f2bf 784 "WaitingInterval",
jmarkel44 71:34856d21f2bf 785 "WaitingOr",
jmarkel44 71:34856d21f2bf 786 "WaitingAnd",
jmarkel44 71:34856d21f2bf 787 "WaitingSempahore",
jmarkel44 71:34856d21f2bf 788 "WaitingMailbox",
davidjhoward 81:d45bfa16953a 789 "WaitingMutex"
davidjhoward 81:d45bfa16953a 790 };
jmarkel44 36:f240f5a6d0ed 791
jmarkel44 36:f240f5a6d0ed 792 //simply add your task to the list...
jmarkel44 36:f240f5a6d0ed 793 taskList.push_back(make_pair((string)"AnalyticsLogger", GLOBAL_analyticsLogger_thread));
jmarkel44 36:f240f5a6d0ed 794 taskList.push_back(make_pair((string)"BLEHandler", GLOBAL_BLE_thread));
jmarkel44 36:f240f5a6d0ed 795 taskList.push_back(make_pair((string)"CloudDataHandler", GLOBAL_CDH_thread));
jmarkel44 36:f240f5a6d0ed 796 taskList.push_back(make_pair((string)"ConfigHandler", GLOBAL_configHandler_thread));
jmarkel44 36:f240f5a6d0ed 797 taskList.push_back(make_pair((string)"ControlTask", GLOBAL_controlTask_thread));
jmarkel44 36:f240f5a6d0ed 798 taskList.push_back(make_pair((string)"ModbusMaster", GLOBAL_modbusMaster_thread));
jmarkel44 48:1c7861d80d16 799 taskList.push_back(make_pair((string)"OutputTask", GLOBAL_outputTask_thread));
jmarkel44 36:f240f5a6d0ed 800
jmarkel44 36:f240f5a6d0ed 801 for ( vector<pair<string, Thread*> >::iterator pos = taskList.begin();
jmarkel44 36:f240f5a6d0ed 802 pos != taskList.end(); ++ pos) {
jmarkel44 71:34856d21f2bf 803 printf("\r %-32s size/free/used/max = %u/%u/%u/%u\tpri=%-8u state=%-20s\n",
davidjhoward 41:e8946fc01ea4 804 pos->first.c_str(),
davidjhoward 41:e8946fc01ea4 805 pos->second->stack_size(),
davidjhoward 41:e8946fc01ea4 806 pos->second->free_stack(),
davidjhoward 41:e8946fc01ea4 807 pos->second->used_stack(),
jmarkel44 71:34856d21f2bf 808 pos->second->max_stack(),
jmarkel44 71:34856d21f2bf 809 pos->second->get_priority(),
jmarkel44 71:34856d21f2bf 810 mapper[pos->second->get_state()]);
jmarkel44 34:f345fdec711d 811 }
jmarkel44 36:f240f5a6d0ed 812
jmarkel44 34:f345fdec711d 813 printf("\r\n");
jmarkel44 34:f345fdec711d 814 }
jmarkel44 62:1b1d7918adf2 815
jmarkel44 62:1b1d7918adf2 816 /*****************************************************************************
davidjhoward 61:ae6dd6692c7d 817 * Function: cmd_modmap
davidjhoward 61:ae6dd6692c7d 818 * Description: dump modbus register map
jmarkel44 62:1b1d7918adf2 819 *****************************************************************************/
davidjhoward 61:ae6dd6692c7d 820 void cmd_modmap(int argc, char **argv)
jmarkel44 62:1b1d7918adf2 821 {
jmarkel44 65:be025ac18fb5 822 UNUSED(argc);
jmarkel44 65:be025ac18fb5 823 UNUSED(argv);
davidjhoward 83:0f76cfbb4eba 824 ModbusValue value;
jmarkel44 67:49f266601d83 825
davidjhoward 61:ae6dd6692c7d 826 std::map<std::string, ModbusRegister>::iterator iter;
davidjhoward 61:ae6dd6692c7d 827 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 83:0f76cfbb4eba 828 ModbusMasterReadRegister( iter->first, &value );
davidjhoward 83:0f76cfbb4eba 829 printf("tag=%s, name=%s, units=%s, node=%d, reg=%d, size=%d, order=%d, value=%2.2f\r\n", iter->first.c_str(), iter->second.name.c_str(), iter->second.units.c_str(), iter->second.node, iter->second.reg, iter->second.size, iter->second.order, value.value );
davidjhoward 61:ae6dd6692c7d 830 }
jmarkel44 65:be025ac18fb5 831 }
jmarkel44 65:be025ac18fb5 832
jmarkel44 65:be025ac18fb5 833 /*****************************************************************************
jmarkel44 65:be025ac18fb5 834 * Function: cmd_time
jmarkel44 65:be025ac18fb5 835 * Description: display real-time clock
jmarkel44 65:be025ac18fb5 836 ****************************************************************************/
jmarkel44 65:be025ac18fb5 837 void cmd_time(int argc, char **argv)
jmarkel44 65:be025ac18fb5 838 {
jmarkel44 62:1b1d7918adf2 839 UNUSED(argc);
jmarkel44 62:1b1d7918adf2 840 UNUSED(argv);
jmarkel44 62:1b1d7918adf2 841
jmarkel44 62:1b1d7918adf2 842 int iyr=0, imo=0, idy=0, ihr=0, imn=0, isc=0;
jmarkel44 62:1b1d7918adf2 843 rtc_get_time(&iyr, &imo, &idy, &ihr, &imn, &isc);
jmarkel44 62:1b1d7918adf2 844 printf("%04d-%02d-%02d %02d:%02d:%02d\r\n", iyr, imo, idy, ihr, imn, isc);
jmarkel44 66:db1425574b58 845 }
jmarkel44 66:db1425574b58 846
jmarkel44 66:db1425574b58 847 /*****************************************************************************
jmarkel44 66:db1425574b58 848 * Function: cmd_time
jmarkel44 66:db1425574b58 849 * Description: display outputs
jmarkel44 66:db1425574b58 850 ****************************************************************************/
jmarkel44 66:db1425574b58 851 void cmd_outputs(int argc, char **argv)
jmarkel44 66:db1425574b58 852 {
jmarkel44 66:db1425574b58 853 UNUSED(argc);
jmarkel44 66:db1425574b58 854 UNUSED(argv);
jmarkel44 67:49f266601d83 855
jmarkel44 66:db1425574b58 856 DisplayOutputs();
davidjhoward 81:d45bfa16953a 857 }
davidjhoward 81:d45bfa16953a 858
davidjhoward 81:d45bfa16953a 859 /*****************************************************************************
davidjhoward 81:d45bfa16953a 860 * Function: cmd_sout
davidjhoward 81:d45bfa16953a 861 * Description: set output
davidjhoward 81:d45bfa16953a 862 *
davidjhoward 81:d45bfa16953a 863 * @param argc-> number of args
davidjhoward 81:d45bfa16953a 864 * @param argv-> output
davidjhoward 81:d45bfa16953a 865 * @return none
davidjhoward 81:d45bfa16953a 866 *****************************************************************************/
davidjhoward 81:d45bfa16953a 867 void cmd_sout(int argc, char **argv)
davidjhoward 81:d45bfa16953a 868 {
davidjhoward 81:d45bfa16953a 869 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 870
davidjhoward 81:d45bfa16953a 871 if ( argc != 3 ) {
davidjhoward 81:d45bfa16953a 872 printf("\rusage: sout <output> <value>\r\n");
davidjhoward 81:d45bfa16953a 873 printf("\rexample: sout o_rly1 1\r\n");
davidjhoward 81:d45bfa16953a 874 return;
davidjhoward 83:0f76cfbb4eba 875 }
davidjhoward 83:0f76cfbb4eba 876 ModbusMasterWriteRegister( argv[1], value );
davidjhoward 82:f3e495a98877 877 }
davidjhoward 82:f3e495a98877 878
davidjhoward 82:f3e495a98877 879 /*****************************************************************************
davidjhoward 82:f3e495a98877 880 * Function: cmd_simin
davidjhoward 82:f3e495a98877 881 * Description: simulat input
davidjhoward 82:f3e495a98877 882 *
davidjhoward 82:f3e495a98877 883 * @param argc-> number of args
davidjhoward 82:f3e495a98877 884 * @param argv-> input
davidjhoward 82:f3e495a98877 885 * @return none
davidjhoward 82:f3e495a98877 886 *****************************************************************************/
davidjhoward 82:f3e495a98877 887 void cmd_simin(int argc, char **argv)
davidjhoward 82:f3e495a98877 888 {
davidjhoward 82:f3e495a98877 889 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 890
davidjhoward 82:f3e495a98877 891 if ( argc < 3 ) {
davidjhoward 82:f3e495a98877 892 printf("\rusage: simin <input> <value> <low> <hi> <step>\r\n");
davidjhoward 82:f3e495a98877 893 printf("\rexample: simin i_tra01 100 90 110 5\r\n");
davidjhoward 82:f3e495a98877 894 return;
davidjhoward 82:f3e495a98877 895 }
davidjhoward 82:f3e495a98877 896
davidjhoward 82:f3e495a98877 897 SimulateInputMap[argv[1]].start_value = atof(argv[2]);
davidjhoward 82:f3e495a98877 898
davidjhoward 82:f3e495a98877 899 ModbusRegisterMap[argv[1]].simulated = true;
davidjhoward 82:f3e495a98877 900
davidjhoward 82:f3e495a98877 901 if ( argc < 3 ) {
davidjhoward 82:f3e495a98877 902 SimulateInputMap[argv[1]].min = 0;
davidjhoward 82:f3e495a98877 903 SimulateInputMap[argv[1]].max = 0;
davidjhoward 82:f3e495a98877 904 return;
davidjhoward 82:f3e495a98877 905 }
davidjhoward 82:f3e495a98877 906 SimulateInputMap[argv[1]].min = atof(argv[3]);
davidjhoward 82:f3e495a98877 907 SimulateInputMap[argv[1]].max = atof(argv[4]);
davidjhoward 82:f3e495a98877 908 SimulateInputMap[argv[1]].step = atof(argv[5]);
davidjhoward 82:f3e495a98877 909
jmarkel44 62:1b1d7918adf2 910 }