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@111:d31b3a347e6a, 2016-09-22 (annotated)

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