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@121:650205ffa656, 2016-09-23 (annotated)

Committer:
jmarkel44
Date:
Fri Sep 23 12:45:49 2016 +0000
Revision:
121:650205ffa656
Parent:
118:2a131efdfd5a
Child:
122:4db48b933115
event logging of manual controls;

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