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@149:950c90425f7c, 2016-09-30 (annotated)

Committer:
davidjhoward
Date:
Fri Sep 30 12:22:20 2016 +0000
Revision:
149:950c90425f7c
Parent:
148:ee3cbaafe355
Child:
150:4db35c8234b4
Child:
158:36b5a9de58a1
base for virtual inputs/outputs

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