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@186:16912aa18c2a, 2016-10-05 (annotated)

Committer:
davidjhoward
Date:
Wed Oct 05 20:47:21 2016 +0000
Revision:
186:16912aa18c2a
Parent:
180:b548e289b648
Child:
188:d35a74bf4e92
added code for demo command and reading modbus 32bit ints

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 161:500f03d11fc4 64 {"cmt", "create multiple timers", cmd_cmt },
jmarkel44 37:7e6986b77f01 65 {"cof", "create a test output file", cmd_cof },
jmarkel44 169:c503848823aa 66 {"create-mn", "create a manual control", cmd_createManual },
jmarkel44 169:c503848823aa 67 {"create-sp", "create a setpoint control", cmd_createSetpoint },
jmarkel44 169:c503848823aa 68 {"create-tm", "create a timer control", cmd_createTimer },
davidjhoward 186:16912aa18c2a 69 {"create-temp", "create temperature input", cmd_createTemp },
jmarkel44 158:36b5a9de58a1 70 {"deep", "dump EEP", cmd_deep },
jmarkel44 177:9ec90c8e3ce1 71 {"demo", "create phase-1 demo files", cmd_demo },
jmarkel44 102:715f754cf5a8 72 {"destroy-control", "destroy a control", cmd_destroy },
jmarkel44 0:65cfa4873284 73 {"heap", "show heap statistics", cmd_heap },
jmarkel44 0:65cfa4873284 74 {"help", "help command", cmd_help },
jmarkel44 158:36b5a9de58a1 75 {"ins-log", "insert log event", cmd_inslog },
jmarkel44 36:f240f5a6d0ed 76 {"log-level", "get/set mDot log level", cmd_logLevel },
jmarkel44 14:cc916fa8dd11 77 {"ls", "list user files", cmd_ls },
jmarkel44 86:189c125d8878 78 {"modify-control", "modify a control", cmd_modify },
davidjhoward 61:ae6dd6692c7d 79 {"modmap", "dump modbus register map", cmd_modmap },
jmarkel44 158:36b5a9de58a1 80 {"peep", "push EEP", cmd_peep },
jmarkel44 0:65cfa4873284 81 {"reset", "reset the controller", cmd_reset },
jmarkel44 35:6235ef67faa1 82 {"reset-stats", "reset current mDot statistics", cmd_resetStats },
jmarkel44 14:cc916fa8dd11 83 {"rm", "remove a user file", cmd_rm },
jmarkel44 35:6235ef67faa1 84 {"rssi-stats", "get current rssi stats", cmd_rssiStats },
jmarkel44 102:715f754cf5a8 85 {"set-time", "set current time", cmd_settime },
jmarkel44 35:6235ef67faa1 86 {"show-controls", "display active controls", cmd_ShowControls },
jmarkel44 86:189c125d8878 87 {"show-outputs", "dump outputs", cmd_outputs },
jmarkel44 35:6235ef67faa1 88 {"snr-stats", "get current SNR stats", cmd_snrStats },
jmarkel44 158:36b5a9de58a1 89 {"sout", "set output", cmd_sout },
jmarkel44 158:36b5a9de58a1 90 {"simin", "simulate input", cmd_simin },
jmarkel44 158:36b5a9de58a1 91 {"show-simin", "show simulated inputs", cmd_showSimin },
jmarkel44 36:f240f5a6d0ed 92 {"stack", "get thread stack usage stats", cmd_stack },
jmarkel44 18:9cf694a764c0 93 {"stats", "get current mDot statistics", cmd_stats },
jmarkel44 62:1b1d7918adf2 94 {"time", "get current time", cmd_time },
davidjhoward 179:a31ea334e2b7 95 {"simall", "simulate multiple inputs", cmd_simall },
jmarkel44 0:65cfa4873284 96 {NULL, NULL, NULL}
jmarkel44 0:65cfa4873284 97 };
jmarkel44 0:65cfa4873284 98
jmarkel44 0:65cfa4873284 99 int func_read(char *buf, int cnt);
jmarkel44 0:65cfa4873284 100 int func_write(const char *buf, int cnt);
jmarkel44 0:65cfa4873284 101 int func_cb_ntshell(const char *text);
jmarkel44 0:65cfa4873284 102 void func_cb_ntopt(int argc, char **argv);
jmarkel44 0:65cfa4873284 103
jmarkel44 0:65cfa4873284 104 /**
jmarkel44 0:65cfa4873284 105 * Serial read function.
jmarkel44 0:65cfa4873284 106 */
jmarkel44 0:65cfa4873284 107 int func_read(char *buf, int cnt)
jmarkel44 0:65cfa4873284 108 {
jmarkel44 0:65cfa4873284 109 for (int i = 0; i < cnt; i++) {
jmarkel44 0:65cfa4873284 110 buf[i] = serial.getc();
jmarkel44 0:65cfa4873284 111 }
jmarkel44 0:65cfa4873284 112 return 0;
jmarkel44 0:65cfa4873284 113 }
jmarkel44 0:65cfa4873284 114
jmarkel44 0:65cfa4873284 115 /**
jmarkel44 0:65cfa4873284 116 * Serial write function.
jmarkel44 0:65cfa4873284 117 */
jmarkel44 0:65cfa4873284 118 int func_write(const char *buf, int cnt)
jmarkel44 0:65cfa4873284 119 {
jmarkel44 0:65cfa4873284 120 for (int i = 0; i < cnt; i++) {
jmarkel44 0:65cfa4873284 121 serial.putc(buf[i]);
jmarkel44 0:65cfa4873284 122 }
jmarkel44 0:65cfa4873284 123 return 0;
jmarkel44 0:65cfa4873284 124 }
jmarkel44 0:65cfa4873284 125
jmarkel44 0:65cfa4873284 126 /**
jmarkel44 0:65cfa4873284 127 * Callback function for ntshell module.
jmarkel44 0:65cfa4873284 128 */
jmarkel44 0:65cfa4873284 129 int func_cb_ntshell(const char *text)
jmarkel44 0:65cfa4873284 130 {
jmarkel44 0:65cfa4873284 131 return ntopt_parse(text, func_cb_ntopt);
jmarkel44 0:65cfa4873284 132 }
jmarkel44 0:65cfa4873284 133
jmarkel44 0:65cfa4873284 134 /**
jmarkel44 0:65cfa4873284 135 * Callback function for ntopt module.
jmarkel44 0:65cfa4873284 136 */
jmarkel44 0:65cfa4873284 137 void func_cb_ntopt(int argc, char **argv)
jmarkel44 0:65cfa4873284 138 {
jmarkel44 0:65cfa4873284 139 if (argc == 0) {
jmarkel44 0:65cfa4873284 140 return;
jmarkel44 0:65cfa4873284 141 }
jmarkel44 0:65cfa4873284 142 int execnt = 0;
jmarkel44 0:65cfa4873284 143 const command_table_t *p = &cmdlist[0];
jmarkel44 0:65cfa4873284 144 while (p->command != NULL) {
jmarkel44 0:65cfa4873284 145 if (strcmp(argv[0], p->command) == 0) {
jmarkel44 0:65cfa4873284 146 p->func(argc, argv);
jmarkel44 0:65cfa4873284 147 execnt++;
jmarkel44 0:65cfa4873284 148 }
jmarkel44 0:65cfa4873284 149 p++;
jmarkel44 0:65cfa4873284 150 }
jmarkel44 0:65cfa4873284 151 if (execnt == 0) {
jmarkel44 0:65cfa4873284 152 printf("Command not found.\r\n");
jmarkel44 0:65cfa4873284 153 }
jmarkel44 0:65cfa4873284 154 wait_ms(250);
jmarkel44 0:65cfa4873284 155 }
jmarkel44 0:65cfa4873284 156
jmarkel44 0:65cfa4873284 157 /************************* callback functions *******************************/
jmarkel44 35:6235ef67faa1 158
jmarkel44 102:715f754cf5a8 159 void cmd_cat(int argc, char **argv)
jmarkel44 102:715f754cf5a8 160 {
jmarkel44 102:715f754cf5a8 161 if ( argc != 2 ) {
jmarkel44 102:715f754cf5a8 162 printf("\rusage: cat <filename>\n");
jmarkel44 102:715f754cf5a8 163 return;
jmarkel44 102:715f754cf5a8 164 }
jmarkel44 113:001ad47df8ec 165 mDot::mdot_file file = GLOBAL_mdot->openUserFile(argv[1], mDot::FM_RDONLY);
jmarkel44 113:001ad47df8ec 166 if ( file.fd < 0 ) {
jmarkel44 113:001ad47df8ec 167 printf("\rFailed to open %s\n", argv[1]);
jmarkel44 113:001ad47df8ec 168 return;
jmarkel44 113:001ad47df8ec 169 }
jmarkel44 113:001ad47df8ec 170 char *data_buf = (char*) malloc(file.size);
jmarkel44 113:001ad47df8ec 171 bool rc = GLOBAL_mdot->readUserFile(file, data_buf, file.size);
jmarkel44 102:715f754cf5a8 172 if ( rc != true ) {
jmarkel44 102:715f754cf5a8 173 printf("\rFailed to read %s\n", argv[1]);
jmarkel44 113:001ad47df8ec 174 goto cleanup;
jmarkel44 102:715f754cf5a8 175 }
jmarkel44 102:715f754cf5a8 176 printf("%s\n", data_buf);
jmarkel44 113:001ad47df8ec 177
jmarkel44 113:001ad47df8ec 178 cleanup:
jmarkel44 113:001ad47df8ec 179 free(data_buf);
jmarkel44 113:001ad47df8ec 180 GLOBAL_mdot->closeUserFile(file);
jmarkel44 102:715f754cf5a8 181 }
jmarkel44 35:6235ef67faa1 182 /*****************************************************************************
jmarkel44 35:6235ef67faa1 183 * Function: cmd_help
jmarkel44 35:6235ef67faa1 184 * Description: displays the list of commands available
jmarkel44 35:6235ef67faa1 185 *
jmarkel44 35:6235ef67faa1 186 * @param argc (not used)
jmarkel44 35:6235ef67faa1 187 * @param argv (not used)
jmarkel44 35:6235ef67faa1 188 * @return none
jmarkel44 35:6235ef67faa1 189 *****************************************************************************/
jmarkel44 0:65cfa4873284 190 void cmd_help(int argc, char **argv)
jmarkel44 0:65cfa4873284 191 {
jmarkel44 0:65cfa4873284 192 UNUSED(argc);
jmarkel44 0:65cfa4873284 193 UNUSED(argv);
jmarkel44 0:65cfa4873284 194
jmarkel44 0:65cfa4873284 195 const command_table_t *tblPtr = cmdlist;
jmarkel44 0:65cfa4873284 196
jmarkel44 0:65cfa4873284 197 while (tblPtr->command) {
jmarkel44 0:65cfa4873284 198 printf("\r%-32s:\t%s\n", tblPtr->command, tblPtr->description);
jmarkel44 0:65cfa4873284 199 tblPtr++;
jmarkel44 0:65cfa4873284 200 }
jmarkel44 0:65cfa4873284 201 printf("\r\n");
jmarkel44 0:65cfa4873284 202 }
jmarkel44 0:65cfa4873284 203
jmarkel44 36:f240f5a6d0ed 204
jmarkel44 36:f240f5a6d0ed 205 /*****************************************************************************
jmarkel44 36:f240f5a6d0ed 206 * Function: cmd_logLevel
davidjhoward 41:e8946fc01ea4 207 * Description: get or set the current log-level
jmarkel44 36:f240f5a6d0ed 208 *
jmarkel44 36:f240f5a6d0ed 209 * @param argc (not used)
jmarkel44 36:f240f5a6d0ed 210 * @param argv (not used)
jmarkel44 36:f240f5a6d0ed 211 * @return none
jmarkel44 36:f240f5a6d0ed 212 *****************************************************************************/
jmarkel44 36:f240f5a6d0ed 213 void cmd_logLevel(int argc, char **argv)
jmarkel44 36:f240f5a6d0ed 214 {
jmarkel44 36:f240f5a6d0ed 215 uint8_t logLevel = 0;
davidjhoward 41:e8946fc01ea4 216
davidjhoward 41:e8946fc01ea4 217 const char *mapper[] = { "NONE",
davidjhoward 41:e8946fc01ea4 218 "FATAL",
davidjhoward 41:e8946fc01ea4 219 "ERROR",
davidjhoward 41:e8946fc01ea4 220 "WARNING",
davidjhoward 41:e8946fc01ea4 221 "INFO",
davidjhoward 41:e8946fc01ea4 222 "DEBUG",
davidjhoward 41:e8946fc01ea4 223 "TRACE"
davidjhoward 41:e8946fc01ea4 224 };
davidjhoward 41:e8946fc01ea4 225
jmarkel44 36:f240f5a6d0ed 226 if ( argc == 1 ) {
davidjhoward 41:e8946fc01ea4 227 printf("\r current log-level set to %s\r\n",
davidjhoward 41:e8946fc01ea4 228 mapper[GLOBAL_mdot->getLogLevel()]);
jmarkel44 36:f240f5a6d0ed 229 goto usage;
jmarkel44 36:f240f5a6d0ed 230 }
jmarkel44 36:f240f5a6d0ed 231
jmarkel44 36:f240f5a6d0ed 232 if ( argc != 2 ) {
jmarkel44 36:f240f5a6d0ed 233 usage:
jmarkel44 36:f240f5a6d0ed 234 printf("\rusage: log-level [0-6]\n");
jmarkel44 36:f240f5a6d0ed 235 printf("\r 0 = NONE\n");
jmarkel44 36:f240f5a6d0ed 236 printf("\r 1 = FATAL\n");
jmarkel44 36:f240f5a6d0ed 237 printf("\r 2 = ERROR\n");
jmarkel44 36:f240f5a6d0ed 238 printf("\r 3 = WARNING\n");
jmarkel44 36:f240f5a6d0ed 239 printf("\r 4 = INFO\n");
jmarkel44 36:f240f5a6d0ed 240 printf("\r 5 = DEBUG\n");
jmarkel44 36:f240f5a6d0ed 241 printf("\r 6 = TRACE\r\n");
jmarkel44 36:f240f5a6d0ed 242 return;
jmarkel44 36:f240f5a6d0ed 243 }
davidjhoward 41:e8946fc01ea4 244
jmarkel44 36:f240f5a6d0ed 245 logLevel = atoi(argv[1]);
davidjhoward 41:e8946fc01ea4 246 if ( logLevel > 6 )
jmarkel44 36:f240f5a6d0ed 247 goto usage;
davidjhoward 41:e8946fc01ea4 248
davidjhoward 41:e8946fc01ea4 249 // reassign the log level
jmarkel44 36:f240f5a6d0ed 250 printf("...setting log-level to %s\r\n", mapper[logLevel]);
davidjhoward 41:e8946fc01ea4 251 GLOBAL_mdot->setLogLevel(logLevel);
jmarkel44 36:f240f5a6d0ed 252 printf("\r\n");
jmarkel44 36:f240f5a6d0ed 253 }
jmarkel44 36:f240f5a6d0ed 254
jmarkel44 35:6235ef67faa1 255 /*****************************************************************************
jmarkel44 35:6235ef67faa1 256 * Function: cmd_ls
jmarkel44 36:f240f5a6d0ed 257 * Description: list the user files on flash
jmarkel44 35:6235ef67faa1 258 *
jmarkel44 35:6235ef67faa1 259 * @param argc (not used)
jmarkel44 35:6235ef67faa1 260 * @param argv (not used)
jmarkel44 35:6235ef67faa1 261 * @return none
jmarkel44 35:6235ef67faa1 262 *****************************************************************************/
jmarkel44 14:cc916fa8dd11 263 void cmd_ls(int argc, char **argv)
jmarkel44 14:cc916fa8dd11 264 {
jmarkel44 35:6235ef67faa1 265 UNUSED(argc);
jmarkel44 35:6235ef67faa1 266 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 267
jmarkel44 14:cc916fa8dd11 268 vector<mDot::mdot_file> userFiles;
jmarkel44 14:cc916fa8dd11 269 userFiles = GLOBAL_mdot->listUserFiles();
jmarkel44 14:cc916fa8dd11 270 vector<mDot::mdot_file>::iterator pos;
jmarkel44 18:9cf694a764c0 271
jmarkel44 14:cc916fa8dd11 272 for ( pos = userFiles.begin(); pos != userFiles.end(); ++pos ) {
jmarkel44 14:cc916fa8dd11 273 printf("\r %-33s %d\n", pos->name, pos->size);
jmarkel44 14:cc916fa8dd11 274 }
jmarkel44 14:cc916fa8dd11 275 printf("\r\n");
jmarkel44 14:cc916fa8dd11 276 }
jmarkel44 14:cc916fa8dd11 277
jmarkel44 35:6235ef67faa1 278 /*****************************************************************************
jmarkel44 35:6235ef67faa1 279 * Function: cmd_ShowControls
jmarkel44 36:f240f5a6d0ed 280 * Description: show active controls
jmarkel44 35:6235ef67faa1 281 *
jmarkel44 35:6235ef67faa1 282 * @param argc (not used)
jmarkel44 35:6235ef67faa1 283 * @param argv (not used)
jmarkel44 35:6235ef67faa1 284 * @return none
jmarkel44 35:6235ef67faa1 285 *****************************************************************************/
jmarkel44 0:65cfa4873284 286 void cmd_ShowControls(int argc, char **argv)
jmarkel44 0:65cfa4873284 287 {
jmarkel44 0:65cfa4873284 288 UNUSED(argc);
jmarkel44 0:65cfa4873284 289 UNUSED(argv);
jmarkel44 12:ea87887ca7ad 290 ConfigurationHandler_showControls();
jmarkel44 18:9cf694a764c0 291 printf("\r\n");
jmarkel44 18:9cf694a764c0 292
jmarkel44 0:65cfa4873284 293 }
jmarkel44 0:65cfa4873284 294
jmarkel44 35:6235ef67faa1 295 /*****************************************************************************
jmarkel44 35:6235ef67faa1 296 * Function: cmd_reset
jmarkel44 36:f240f5a6d0ed 297 * Description: reset the cpu
jmarkel44 35:6235ef67faa1 298 *
jmarkel44 35:6235ef67faa1 299 * @param argc (not used)
jmarkel44 35:6235ef67faa1 300 * @param argv (not used)
jmarkel44 35:6235ef67faa1 301 * @return none
jmarkel44 35:6235ef67faa1 302 *****************************************************************************/
jmarkel44 0:65cfa4873284 303 void cmd_reset(int argc, char **argv)
jmarkel44 0:65cfa4873284 304 {
jmarkel44 0:65cfa4873284 305 UNUSED(argc);
jmarkel44 0:65cfa4873284 306 UNUSED(argv);
jmarkel44 18:9cf694a764c0 307 GLOBAL_mdot->resetCpu();
jmarkel44 0:65cfa4873284 308 }
jmarkel44 0:65cfa4873284 309
jmarkel44 35:6235ef67faa1 310 /*****************************************************************************
jmarkel44 35:6235ef67faa1 311 * Function: cmd_rm
jmarkel44 35:6235ef67faa1 312 * Description: removes a user file from flash
jmarkel44 35:6235ef67faa1 313 *
jmarkel44 35:6235ef67faa1 314 * @param argc-> number of args
jmarkel44 36:f240f5a6d0ed 315 * @param argv-> filename
jmarkel44 35:6235ef67faa1 316 * @return none
jmarkel44 35:6235ef67faa1 317 *****************************************************************************/
jmarkel44 14:cc916fa8dd11 318 void cmd_rm(int argc, char **argv)
jmarkel44 14:cc916fa8dd11 319 {
jmarkel44 18:9cf694a764c0 320 UNUSED(argc);
jmarkel44 14:cc916fa8dd11 321 UNUSED(argv);
jmarkel44 18:9cf694a764c0 322
jmarkel44 14:cc916fa8dd11 323 if ( argc != 2 ) {
jmarkel44 14:cc916fa8dd11 324 printf("\rusage: rm <filename>\n");
jmarkel44 14:cc916fa8dd11 325 return;
jmarkel44 14:cc916fa8dd11 326 }
jmarkel44 43:62de0e05ab6b 327 if ( strcmp(argv[1], "*") == 0 ) {
jmarkel44 43:62de0e05ab6b 328 vector<mDot::mdot_file> userFiles;
jmarkel44 43:62de0e05ab6b 329 userFiles = GLOBAL_mdot->listUserFiles();
jmarkel44 43:62de0e05ab6b 330 vector<mDot::mdot_file>::iterator pos;
jmarkel44 43:62de0e05ab6b 331 for ( pos = userFiles.begin(); pos != userFiles.end(); ++pos ) {
jmarkel44 43:62de0e05ab6b 332 GLOBAL_mdot->deleteUserFile(pos->name);
jmarkel44 43:62de0e05ab6b 333 }
jmarkel44 43:62de0e05ab6b 334 } else {
jmarkel44 43:62de0e05ab6b 335 GLOBAL_mdot->deleteUserFile(argv[1]);
jmarkel44 43:62de0e05ab6b 336 }
jmarkel44 14:cc916fa8dd11 337 }
jmarkel44 18:9cf694a764c0 338
jmarkel44 35:6235ef67faa1 339 /*****************************************************************************
jmarkel44 35:6235ef67faa1 340 * Function: cmd_create
jmarkel44 36:f240f5a6d0ed 341 * Description: create a control
jmarkel44 35:6235ef67faa1 342 *
jmarkel44 35:6235ef67faa1 343 * @param argc-> number of args
jmarkel44 35:6235ef67faa1 344 * @param argv-> control name, control type
jmarkel44 35:6235ef67faa1 345 * @return none
jmarkel44 35:6235ef67faa1 346 *****************************************************************************/
jmarkel44 0:65cfa4873284 347 void cmd_create(int argc, char **argv)
jmarkel44 0:65cfa4873284 348 {
jmarkel44 0:65cfa4873284 349 if ( argc != 3 ) {
jmarkel44 0:65cfa4873284 350 printf("\r\nusage: create [controlName] [controlType]\n");
jmarkel44 18:9cf694a764c0 351 printf("\rcontrolType-> 0=timer, 1=PID, 2=setpoint, 3=composite, 4=manual\r\n");
jmarkel44 0:65cfa4873284 352 return;
jmarkel44 0:65cfa4873284 353 }
jmarkel44 0:65cfa4873284 354 // send a message to the configuration handler to create the control
jmarkel44 0:65cfa4873284 355 Message_t *msg = MailBox.alloc();
jmarkel44 0:65cfa4873284 356 memset(msg, 0, sizeof(Message_t));
jmarkel44 0:65cfa4873284 357 msg->action = ACTION_CREATE;
jmarkel44 0:65cfa4873284 358 msg->control = (Control_t) atoi(argv[2]);
jmarkel44 0:65cfa4873284 359 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 0:65cfa4873284 360
jmarkel44 0:65cfa4873284 361 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 0:65cfa4873284 362 __func__, msg->controlFile, msg->control);
jmarkel44 0:65cfa4873284 363
jmarkel44 0:65cfa4873284 364 MailBox.put(msg);
jmarkel44 18:9cf694a764c0 365 printf("\r\n");
jmarkel44 0:65cfa4873284 366 return;
jmarkel44 0:65cfa4873284 367 }
jmarkel44 0:65cfa4873284 368
jmarkel44 35:6235ef67faa1 369 /*****************************************************************************
jmarkel44 35:6235ef67faa1 370 * Function: cmd_destroy
jmarkel44 36:f240f5a6d0ed 371 * Description: reset the cpu
jmarkel44 35:6235ef67faa1 372 *
jmarkel44 35:6235ef67faa1 373 * @param argc-> number of arguments
jmarkel44 36:f240f5a6d0ed 374 * @param argv-> control name, control type
jmarkel44 35:6235ef67faa1 375 * @return none
jmarkel44 35:6235ef67faa1 376 *****************************************************************************/
jmarkel44 0:65cfa4873284 377 void cmd_destroy(int argc, char **argv)
jmarkel44 0:65cfa4873284 378 {
jmarkel44 12:ea87887ca7ad 379 if ( argc != 3 ) {
jmarkel44 12:ea87887ca7ad 380 printf("\r\nusage: destroy [controlName] [controlType]\n");
jmarkel44 18:9cf694a764c0 381 printf("\rcontrolType-> 0=timer, 1=PID, 2=setpoint, 3=composite, 4=manual\r\n");
jmarkel44 0:65cfa4873284 382 return;
jmarkel44 0:65cfa4873284 383 }
jmarkel44 0:65cfa4873284 384
jmarkel44 0:65cfa4873284 385 // send a message to the configuration handler to destroy the control
jmarkel44 0:65cfa4873284 386 Message_t *msg = MailBox.alloc();
jmarkel44 0:65cfa4873284 387 memset(msg, 0, sizeof(Message_t));
jmarkel44 0:65cfa4873284 388 msg->action = ACTION_DESTROY;
jmarkel44 12:ea87887ca7ad 389 msg->control = (Control_t) atoi(argv[2]);
jmarkel44 0:65cfa4873284 390 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 0:65cfa4873284 391
jmarkel44 0:65cfa4873284 392 printf("%s: Sending a destroy request for control %s\r\n",
jmarkel44 0:65cfa4873284 393 __func__, msg->controlFile);
jmarkel44 0:65cfa4873284 394
jmarkel44 0:65cfa4873284 395 MailBox.put(msg);
jmarkel44 18:9cf694a764c0 396 printf("\r\n");
jmarkel44 0:65cfa4873284 397 return;
jmarkel44 0:65cfa4873284 398 }
jmarkel44 0:65cfa4873284 399
jmarkel44 35:6235ef67faa1 400 /*****************************************************************************
jmarkel44 96:807f04bd5256 401 * Function: cmd_createSetpoint
jmarkel44 37:7e6986b77f01 402 * Description: create control file
jmarkel44 35:6235ef67faa1 403 *
jmarkel44 35:6235ef67faa1 404 * @param argc-> number of args
jmarkel44 36:f240f5a6d0ed 405 * @param argv-> filename
jmarkel44 35:6235ef67faa1 406 * @return none
jmarkel44 35:6235ef67faa1 407 *****************************************************************************/
jmarkel44 96:807f04bd5256 408 void cmd_createSetpoint(int argc, char **argv)
jmarkel44 18:9cf694a764c0 409 {
jmarkel44 169:c503848823aa 410 if ( argc != 8 ) {
jmarkel44 169:c503848823aa 411 printf("\rusage: create-sp <filename> <id> <input> <output> <sp> <dir> <tol>\n");
jmarkel44 169:c503848823aa 412 printf("\rexample: create-sp control_sp_1.json bd i_cond o_rly1 2000 1 15\n");
jmarkel44 18:9cf694a764c0 413 return;
jmarkel44 18:9cf694a764c0 414 }
jmarkel44 36:f240f5a6d0ed 415
jmarkel44 121:650205ffa656 416 if ( strncmp(argv[1], CONTROL_SP_STR, strlen(CONTROL_SP_STR)) != 0 ) {
jmarkel44 121:650205ffa656 417 printf("\rFilename must be prefixed with control_sp_*\n");
jmarkel44 121:650205ffa656 418 return;
jmarkel44 121:650205ffa656 419 }
jmarkel44 121:650205ffa656 420
jmarkel44 177:9ec90c8e3ce1 421 char data_buf[MAX_FILE_SIZE];
jmarkel44 36:f240f5a6d0ed 422 snprintf(data_buf, sizeof(data_buf),
jmarkel44 36:f240f5a6d0ed 423 "{ "
jmarkel44 89:55ac65d7f206 424 "\"id\": \"%s\", "
jmarkel44 96:807f04bd5256 425 "\"priority\": \"800\","
jmarkel44 89:55ac65d7f206 426 "\"input\": \"%s\", "
jmarkel44 89:55ac65d7f206 427 "\"output\": \"%s\", "
jmarkel44 169:c503848823aa 428 "\"setpoint\": \"%s\","
jmarkel44 96:807f04bd5256 429 "\"prodfact\": \"100\","
jmarkel44 93:1553fb156915 430 "\"actingDir\": \"%s\", "
jmarkel44 96:807f04bd5256 431 "\"halert\": \"115\","
jmarkel44 89:55ac65d7f206 432 "\"lalert\": \"85\", "
jmarkel44 96:807f04bd5256 433 "\"hfs\": \"130\","
davidjhoward 123:ce602c91a9c3 434 "\"lfs\": \"70\", "
jmarkel44 169:c503848823aa 435 "\"tol\": \"%s\" }", argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
jmarkel44 18:9cf694a764c0 436
jmarkel44 177:9ec90c8e3ce1 437 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
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 177:9ec90c8e3ce1 484 char data_buf[MAX_FILE_SIZE];
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 161:500f03d11fc4 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 177:9ec90c8e3ce1 495 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
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 161:500f03d11fc4 517 void cmd_cmt(int argc, char **argv)
jmarkel44 161:500f03d11fc4 518 {
jmarkel44 161:500f03d11fc4 519 char time_buf[32];
jmarkel44 161:500f03d11fc4 520 unsigned int counter = 0;
jmarkel44 161:500f03d11fc4 521 char filename[32];
jmarkel44 161:500f03d11fc4 522 Message_t *msg;
jmarkel44 161:500f03d11fc4 523
jmarkel44 161:500f03d11fc4 524 for ( counter = 0; counter < 5; counter++ ) {
jmarkel44 161:500f03d11fc4 525 // stuff the file
jmarkel44 161:500f03d11fc4 526 sprintf(time_buf, "%lu", time(NULL)+5 + (40 * counter));
jmarkel44 177:9ec90c8e3ce1 527 char data_buf[MAX_FILE_SIZE];
jmarkel44 161:500f03d11fc4 528 snprintf(data_buf, sizeof(data_buf),
jmarkel44 161:500f03d11fc4 529 "{ "
jmarkel44 161:500f03d11fc4 530 "\"id\": \"timer-%d\", "
jmarkel44 161:500f03d11fc4 531 "\"output\": \"o_rly1\", "
jmarkel44 161:500f03d11fc4 532 "\"priority\": \"750\", "
jmarkel44 161:500f03d11fc4 533 "\"starttime\": \"%s\", "
jmarkel44 161:500f03d11fc4 534 "\"duration\": \"30\" ", counter, time_buf);
jmarkel44 161:500f03d11fc4 535
jmarkel44 161:500f03d11fc4 536 sprintf(filename, "control_tm_%d_rly1.json", counter);
jmarkel44 161:500f03d11fc4 537
jmarkel44 177:9ec90c8e3ce1 538 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 161:500f03d11fc4 539 msg = MailBox.alloc();
jmarkel44 161:500f03d11fc4 540 memset(msg, 0, sizeof(Message_t));
jmarkel44 161:500f03d11fc4 541 msg->action = ACTION_CREATE;
jmarkel44 161:500f03d11fc4 542 msg->control = CONTROL_TIMER;
jmarkel44 161:500f03d11fc4 543 strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);
jmarkel44 161:500f03d11fc4 544
jmarkel44 161:500f03d11fc4 545 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 161:500f03d11fc4 546 __func__, msg->controlFile, msg->control);
jmarkel44 161:500f03d11fc4 547
jmarkel44 161:500f03d11fc4 548 MailBox.put(msg);
jmarkel44 161:500f03d11fc4 549 Thread::wait(1000);
jmarkel44 161:500f03d11fc4 550 }
jmarkel44 161:500f03d11fc4 551
jmarkel44 161:500f03d11fc4 552 for ( counter = 0; counter < 5; counter++ ) {
jmarkel44 161:500f03d11fc4 553 // stuff the file
jmarkel44 161:500f03d11fc4 554 sprintf(time_buf, "%lu", time(NULL)+5 + (40 * counter));
jmarkel44 177:9ec90c8e3ce1 555 char data_buf[MAX_FILE_SIZE];
jmarkel44 161:500f03d11fc4 556 snprintf(data_buf, sizeof(data_buf),
jmarkel44 161:500f03d11fc4 557 "{ "
jmarkel44 161:500f03d11fc4 558 "\"id\": \"timer-%d\", "
jmarkel44 161:500f03d11fc4 559 "\"output\": \"o_rly2\", "
jmarkel44 161:500f03d11fc4 560 "\"priority\": \"750\", "
jmarkel44 161:500f03d11fc4 561 "\"starttime\": \"%s\", "
jmarkel44 161:500f03d11fc4 562 "\"duration\": \"30\" ", counter, time_buf);
jmarkel44 161:500f03d11fc4 563
jmarkel44 161:500f03d11fc4 564 sprintf(filename, "control_tm_%d_rly2.json", counter);
jmarkel44 161:500f03d11fc4 565
jmarkel44 177:9ec90c8e3ce1 566 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 161:500f03d11fc4 567 msg = MailBox.alloc();
jmarkel44 161:500f03d11fc4 568 memset(msg, 0, sizeof(Message_t));
jmarkel44 161:500f03d11fc4 569 msg->action = ACTION_CREATE;
jmarkel44 161:500f03d11fc4 570 msg->control = CONTROL_TIMER;
jmarkel44 161:500f03d11fc4 571 strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);
jmarkel44 161:500f03d11fc4 572
jmarkel44 161:500f03d11fc4 573 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 161:500f03d11fc4 574 __func__, msg->controlFile, msg->control);
jmarkel44 161:500f03d11fc4 575
jmarkel44 161:500f03d11fc4 576 MailBox.put(msg);
jmarkel44 161:500f03d11fc4 577 Thread::wait(1000);
jmarkel44 161:500f03d11fc4 578 }
jmarkel44 161:500f03d11fc4 579 }
jmarkel44 161:500f03d11fc4 580
jmarkel44 122:4db48b933115 581 /*****************************************************************************
jmarkel44 97:5cf6ab71dcd0 582 * Function: cmd_createManual
jmarkel44 97:5cf6ab71dcd0 583 * Description: create a manual control
jmarkel44 97:5cf6ab71dcd0 584 *
jmarkel44 97:5cf6ab71dcd0 585 * @param argc-> number of args
jmarkel44 97:5cf6ab71dcd0 586 * @param argv-> filename
jmarkel44 97:5cf6ab71dcd0 587 * @return none
jmarkel44 97:5cf6ab71dcd0 588 *****************************************************************************/
jmarkel44 97:5cf6ab71dcd0 589 void cmd_createManual(int argc, char **argv)
jmarkel44 97:5cf6ab71dcd0 590 {
jmarkel44 98:8eab18d03ac2 591 if ( argc != 5 ) {
jmarkel44 98:8eab18d03ac2 592 printf("\rusage: create-manual <filename> <id> <output> <state>\n");
jmarkel44 98:8eab18d03ac2 593 printf("\rexample: create-manual control_mn_1.json man-1 o_rly1 1\r\n");
jmarkel44 97:5cf6ab71dcd0 594 return;
jmarkel44 97:5cf6ab71dcd0 595 }
jmarkel44 97:5cf6ab71dcd0 596
jmarkel44 177:9ec90c8e3ce1 597 char data_buf[MAX_FILE_SIZE];
jmarkel44 97:5cf6ab71dcd0 598 snprintf(data_buf, sizeof(data_buf),
jmarkel44 97:5cf6ab71dcd0 599 "{ "
jmarkel44 98:8eab18d03ac2 600 "\"id\": \"%s\", "
jmarkel44 98:8eab18d03ac2 601 "\"output\": \"%s\", "
jmarkel44 98:8eab18d03ac2 602 "\"type\": \"1\", "
jmarkel44 97:5cf6ab71dcd0 603 "\"priority\": \"100\", "
jmarkel44 98:8eab18d03ac2 604 "\"duration\": \"0\", "
jmarkel44 98:8eab18d03ac2 605 "\"setpoint\": \"0\", "
jmarkel44 98:8eab18d03ac2 606 "\"state\": \"%d\", "
jmarkel44 113:001ad47df8ec 607 "\"percent\": \"100\" }", argv[2], argv[3], atoi(argv[4])
jmarkel44 97:5cf6ab71dcd0 608 );
jmarkel44 97:5cf6ab71dcd0 609
jmarkel44 177:9ec90c8e3ce1 610 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 97:5cf6ab71dcd0 611 if( status != true ) {
jmarkel44 97:5cf6ab71dcd0 612 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 97:5cf6ab71dcd0 613 return;
jmarkel44 97:5cf6ab71dcd0 614 }
davidjhoward 116:7337ed514891 615
davidjhoward 116:7337ed514891 616 // send a message to the configuration handler to create the control
jmarkel44 97:5cf6ab71dcd0 617 Message_t *msg = MailBox.alloc();
jmarkel44 97:5cf6ab71dcd0 618 memset(msg, 0, sizeof(Message_t));
jmarkel44 97:5cf6ab71dcd0 619 msg->action = ACTION_CREATE;
jmarkel44 97:5cf6ab71dcd0 620 msg->control = CONTROL_MANUAL;
jmarkel44 97:5cf6ab71dcd0 621 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 97:5cf6ab71dcd0 622
jmarkel44 97:5cf6ab71dcd0 623 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 97:5cf6ab71dcd0 624 __func__, msg->controlFile, msg->control);
jmarkel44 97:5cf6ab71dcd0 625
jmarkel44 97:5cf6ab71dcd0 626 MailBox.put(msg);
jmarkel44 97:5cf6ab71dcd0 627 printf("\r\n");
jmarkel44 97:5cf6ab71dcd0 628 return;
jmarkel44 97:5cf6ab71dcd0 629 }
jmarkel44 97:5cf6ab71dcd0 630
jmarkel44 97:5cf6ab71dcd0 631 /*****************************************************************************
jmarkel44 37:7e6986b77f01 632 * Function: cmd_cif
jmarkel44 37:7e6986b77f01 633 * Description: create input file
jmarkel44 37:7e6986b77f01 634 *
jmarkel44 37:7e6986b77f01 635 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 636 * @param argv-> filename
jmarkel44 37:7e6986b77f01 637 * @return none
jmarkel44 37:7e6986b77f01 638 *****************************************************************************/
jmarkel44 37:7e6986b77f01 639 void cmd_cif(int argc, char **argv)
jmarkel44 37:7e6986b77f01 640 {
jmarkel44 169:c503848823aa 641 if ( argc != 6 ) {
jmarkel44 169:c503848823aa 642 printf("\rusage: cif <fname> <input> <name> <node> <reg>\n");
jmarkel44 169:c503848823aa 643 printf("\rexample: cif input_i_tra01.json i_tra01 Trasar 5 2\n");
jmarkel44 37:7e6986b77f01 644 return;
jmarkel44 37:7e6986b77f01 645 }
jmarkel44 37:7e6986b77f01 646
jmarkel44 177:9ec90c8e3ce1 647 char data_buf[MAX_FILE_SIZE];
jmarkel44 37:7e6986b77f01 648 snprintf(data_buf, sizeof(data_buf),
jmarkel44 37:7e6986b77f01 649 "{ "
jmarkel44 121:650205ffa656 650 "\"id\": \"%s\", "
jmarkel44 169:c503848823aa 651 "\"name\": \"%s\", "
jmarkel44 37:7e6986b77f01 652 "\"units\": \"PPM\", "
jmarkel44 37:7e6986b77f01 653 "\"min\": \"0\", "
jmarkel44 37:7e6986b77f01 654 "\"max\": \"300\", "
jmarkel44 169:c503848823aa 655 "\"node\": \"%s\", "
jmarkel44 169:c503848823aa 656 "\"reg\": \"%s\", "
jmarkel44 37:7e6986b77f01 657 "\"rtype\": \"1\", "
davidjhoward 54:ec1b03064bbd 658 "\"type\": \"0\", "
davidjhoward 41:e8946fc01ea4 659 "\"size\": \"2\", "
davidjhoward 41:e8946fc01ea4 660 "\"order\": \"2\", "
davidjhoward 41:e8946fc01ea4 661 "\"rfreq\": \"5\", "
jmarkel44 169:c503848823aa 662 "\"fmt\": \"%%.2f\" } ", argv[2], argv[3], argv[4], argv[5]);
jmarkel44 37:7e6986b77f01 663
jmarkel44 177:9ec90c8e3ce1 664 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 37:7e6986b77f01 665 if( status != true ) {
jmarkel44 37:7e6986b77f01 666 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 667 }
davidjhoward 41:e8946fc01ea4 668
davidjhoward 42:c703a60993b1 669 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", argv[1]);
davidjhoward 41:e8946fc01ea4 670 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 41:e8946fc01ea4 671 mail->action = ACTION_READ_FILE;
davidjhoward 41:e8946fc01ea4 672 strncpy( mail->controlFile, argv[1], (sizeof(mail->controlFile)-1));
davidjhoward 41:e8946fc01ea4 673 ModbusMasterMailBox.put(mail);
jmarkel44 37:7e6986b77f01 674 }
jmarkel44 37:7e6986b77f01 675
jmarkel44 37:7e6986b77f01 676 /*****************************************************************************
jmarkel44 96:807f04bd5256 677 * Function: cmd_cmf
jmarkel44 96:807f04bd5256 678 * Description: create manual control file
jmarkel44 96:807f04bd5256 679 *
jmarkel44 96:807f04bd5256 680 * @param argc-> number of args
jmarkel44 96:807f04bd5256 681 * @param argv-> filename
jmarkel44 96:807f04bd5256 682 * @return none
jmarkel44 96:807f04bd5256 683 *****************************************************************************/
jmarkel44 96:807f04bd5256 684 void cmd_cmf(int argc, char **argv)
jmarkel44 96:807f04bd5256 685 {
jmarkel44 96:807f04bd5256 686 if ( argc != 2 ) {
jmarkel44 96:807f04bd5256 687 printf("\rusage: cmf <filename> <relay\r\n");
jmarkel44 96:807f04bd5256 688 printf("\rexmaple: cmd control_mn_1.json o_rly1");
jmarkel44 96:807f04bd5256 689 return;
jmarkel44 96:807f04bd5256 690 }
jmarkel44 96:807f04bd5256 691
jmarkel44 177:9ec90c8e3ce1 692 char data_buf[MAX_FILE_SIZE];
jmarkel44 96:807f04bd5256 693 snprintf(data_buf, sizeof(data_buf),
jmarkel44 96:807f04bd5256 694 "{ "
jmarkel44 96:807f04bd5256 695 "\"id\": \"%s\", "
jmarkel44 96:807f04bd5256 696 "\"type\": \"1\", "
jmarkel44 96:807f04bd5256 697 "\"priority\": \"100\", "
jmarkel44 96:807f04bd5256 698 "\"duration\": \"30\", " // seconds
jmarkel44 96:807f04bd5256 699 "\"setpoint\": \"2000.0\", "
jmarkel44 96:807f04bd5256 700 "\"state\": \"1\", "
jmarkel44 113:001ad47df8ec 701 "\"percent\": \"100\", }", argv[2]
jmarkel44 96:807f04bd5256 702 );
jmarkel44 96:807f04bd5256 703
jmarkel44 177:9ec90c8e3ce1 704 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 96:807f04bd5256 705 if( status != true ) {
jmarkel44 96:807f04bd5256 706 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 96:807f04bd5256 707 }
jmarkel44 96:807f04bd5256 708 }
jmarkel44 96:807f04bd5256 709
jmarkel44 96:807f04bd5256 710
jmarkel44 96:807f04bd5256 711 /*****************************************************************************
jmarkel44 37:7e6986b77f01 712 * Function: cmd_cof
jmarkel44 37:7e6986b77f01 713 * Description: create output file
jmarkel44 37:7e6986b77f01 714 *
jmarkel44 37:7e6986b77f01 715 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 716 * @param argv-> filename
jmarkel44 37:7e6986b77f01 717 * @return none
jmarkel44 37:7e6986b77f01 718 *****************************************************************************/
jmarkel44 37:7e6986b77f01 719 void cmd_cof(int argc, char **argv)
jmarkel44 37:7e6986b77f01 720 {
davidjhoward 81:d45bfa16953a 721 if ( argc != 5 ) {
davidjhoward 81:d45bfa16953a 722 printf("\rusage: cof <filename> <output> <name> <reg>\r\n");
davidjhoward 81:d45bfa16953a 723 printf("\rexample: cof output_rly1.json o_rly1 Relay1 1\r\n");
jmarkel44 37:7e6986b77f01 724 return;
jmarkel44 37:7e6986b77f01 725 }
jmarkel44 37:7e6986b77f01 726
jmarkel44 177:9ec90c8e3ce1 727 char data_buf[MAX_FILE_SIZE];
jmarkel44 37:7e6986b77f01 728
jmarkel44 67:49f266601d83 729 snprintf(data_buf, sizeof(data_buf),
jmarkel44 67:49f266601d83 730 "{ "
jmarkel44 67:49f266601d83 731 "\"id\": \"%s\", "
davidjhoward 81:d45bfa16953a 732 "\"name\": \"%s\", "
davidjhoward 81:d45bfa16953a 733 "\"units\": \"\", "
jmarkel44 67:49f266601d83 734 "\"min\": \"0\", "
jmarkel44 67:49f266601d83 735 "\"max\": \"300\", "
davidjhoward 81:d45bfa16953a 736 "\"node\": \"0\", "
davidjhoward 81:d45bfa16953a 737 "\"reg\": \"%s\", "
jmarkel44 67:49f266601d83 738 "\"rtype\": \"1\", "
jmarkel44 67:49f266601d83 739 "\"type\": \"16\", "
davidjhoward 81:d45bfa16953a 740 "\"size\": \"2\", "
davidjhoward 81:d45bfa16953a 741 "\"order\": \"2\", "
jmarkel44 67:49f266601d83 742 "\"fmt\": \"%%.2f\", "
davidjhoward 81:d45bfa16953a 743 "\"rfreq\": \"5\", "
jmarkel44 67:49f266601d83 744 "\"toperiod\": \"0\", "
jmarkel44 67:49f266601d83 745 "\"scalelo\": \"0\", "
davidjhoward 81:d45bfa16953a 746 "\"scalehi\": \"100\" }", argv[2], argv[3], argv[4]);
davidjhoward 81:d45bfa16953a 747
jmarkel44 177:9ec90c8e3ce1 748 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 37:7e6986b77f01 749 if( status != true ) {
jmarkel44 37:7e6986b77f01 750 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 751 }
jmarkel44 43:62de0e05ab6b 752
jmarkel44 177:9ec90c8e3ce1 753 // send a message to the modbus master
jmarkel44 63:0ded43237b22 754 logInfo("Sending mail to ModbusMasterMailBox, filename=%s", argv[1]);
jmarkel44 63:0ded43237b22 755 Message_t *modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 756 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 63:0ded43237b22 757 strncpy( modbus_mail->controlFile, argv[1], (sizeof(modbus_mail->controlFile)-1));
jmarkel44 63:0ded43237b22 758 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 67:49f266601d83 759
jmarkel44 63:0ded43237b22 760 // send a message to the output master
jmarkel44 63:0ded43237b22 761 logInfo("Sending mail to OutputMaster, filename = %s", argv[1]);
jmarkel44 63:0ded43237b22 762 OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 763 output_mail->action = ACTION_NEW;
jmarkel44 63:0ded43237b22 764 strncpy(output_mail->controlFile, argv[1], sizeof(output_mail->controlFile)-1);
jmarkel44 63:0ded43237b22 765 OutputMasterMailBox.put(output_mail);
jmarkel44 37:7e6986b77f01 766 }
jmarkel44 37:7e6986b77f01 767
jmarkel44 37:7e6986b77f01 768 /*****************************************************************************
jmarkel44 35:6235ef67faa1 769 * Function: cmd_heap
jmarkel44 35:6235ef67faa1 770 * Description: display heap statistics
jmarkel44 35:6235ef67faa1 771 *
jmarkel44 35:6235ef67faa1 772 * @param argc (not used)
jmarkel44 35:6235ef67faa1 773 * @param argv (not used)
jmarkel44 35:6235ef67faa1 774 * @return none
jmarkel44 35:6235ef67faa1 775 *****************************************************************************/
jmarkel44 0:65cfa4873284 776 void cmd_heap(int argc, char **argv)
jmarkel44 0:65cfa4873284 777 {
jmarkel44 0:65cfa4873284 778 UNUSED(argc), UNUSED(argv);
jmarkel44 0:65cfa4873284 779 __heapstats((__heapprt)fprintf,stderr); // print initial free heap size
jmarkel44 0:65cfa4873284 780 }
jmarkel44 0:65cfa4873284 781
jmarkel44 35:6235ef67faa1 782 /*****************************************************************************
jmarkel44 35:6235ef67faa1 783 * Function: cmd_modify
jmarkel44 36:f240f5a6d0ed 784 * Description: modify an active control
jmarkel44 35:6235ef67faa1 785 *
jmarkel44 35:6235ef67faa1 786 * @param argc (not used)
jmarkel44 35:6235ef67faa1 787 * @param argv (not used)
jmarkel44 35:6235ef67faa1 788 * @return none
jmarkel44 35:6235ef67faa1 789 *****************************************************************************/
jmarkel44 0:65cfa4873284 790 void cmd_modify(int argc, char **argv)
jmarkel44 0:65cfa4873284 791 {
jmarkel44 0:65cfa4873284 792 // stubbed
jmarkel44 3:8ea4db957749 793 printf("\rNot yet implemented.\n");
jmarkel44 0:65cfa4873284 794 return;
jmarkel44 0:65cfa4873284 795 }
jmarkel44 0:65cfa4873284 796
jmarkel44 35:6235ef67faa1 797 /*****************************************************************************
jmarkel44 35:6235ef67faa1 798 * Function: cmd_stats
jmarkel44 35:6235ef67faa1 799 * Description: display mDot stats
jmarkel44 35:6235ef67faa1 800 *
jmarkel44 35:6235ef67faa1 801 * @param argc (not used)
jmarkel44 35:6235ef67faa1 802 * @param argv (not used)
jmarkel44 35:6235ef67faa1 803 * @return none
jmarkel44 35:6235ef67faa1 804 *****************************************************************************/
jmarkel44 18:9cf694a764c0 805 void cmd_stats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 806 {
jmarkel44 35:6235ef67faa1 807 UNUSED(argc);
jmarkel44 35:6235ef67faa1 808 UNUSED(argv);
davidjhoward 81:d45bfa16953a 809
jmarkel44 18:9cf694a764c0 810 mDot::mdot_stats stats = GLOBAL_mdot->getStats();
jmarkel44 0:65cfa4873284 811
jmarkel44 44:c73f2ca79669 812 printf("\r Up: %u\n", stats.Up);
jmarkel44 44:c73f2ca79669 813 printf("\r Down: %u\n", stats.Down);
jmarkel44 44:c73f2ca79669 814 printf("\r Joins: %u\n", stats.Joins);
jmarkel44 44:c73f2ca79669 815 printf("\r JoinFails: %u\n", stats.JoinFails);
jmarkel44 44:c73f2ca79669 816 printf("\r MissedAcks: %u\n", stats.MissedAcks);
jmarkel44 44:c73f2ca79669 817 printf("\r CRCErrors: %u\n", stats.CRCErrors);
jmarkel44 44:c73f2ca79669 818 printf("\r\n");
jmarkel44 44:c73f2ca79669 819 printf("\r Freq band: %u\n", GLOBAL_mdot->getFrequencyBand());
jmarkel44 44:c73f2ca79669 820 printf("\r Freq subband: %u\n", GLOBAL_mdot->getFrequencySubBand());
jmarkel44 44:c73f2ca79669 821 printf("\r Session data rate: %u\n", GLOBAL_mdot->getSessionDataRate());
jmarkel44 44:c73f2ca79669 822 printf("\r Public Network Mode: %s\n", GLOBAL_mdot->getPublicNetwork() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 823 printf("\r Application device port: %u\n", GLOBAL_mdot->getAppPort());
jmarkel44 44:c73f2ca79669 824 printf("\r Class: %s\n", GLOBAL_mdot->getClass().c_str());
jmarkel44 44:c73f2ca79669 825 printf("\r Max packet length: %u\n", GLOBAL_mdot->getMaxPacketLength());
jmarkel44 77:43e0a3d9e536 826 std::vector<uint8_t> na = GLOBAL_mdot->getNetworkAddress();
jmarkel44 77:43e0a3d9e536 827 std::string str(na.begin(), na.end());
jmarkel44 77:43e0a3d9e536 828 printf("\r Network address: %s\n", str.c_str());
jmarkel44 44:c73f2ca79669 829 printf("\r Network name: %s\n", GLOBAL_mdot->getNetworkName().c_str());
jmarkel44 77:43e0a3d9e536 830 std::vector<uint8_t> nid = GLOBAL_mdot->getNetworkId();
jmarkel44 77:43e0a3d9e536 831 std::string networkIdStr(nid.begin(), nid.end());
jmarkel44 77:43e0a3d9e536 832 printf("\r Network ID: %s\n", networkIdStr.c_str());
jmarkel44 44:c73f2ca79669 833 printf("\r Join byter order: %s\n", GLOBAL_mdot->getJoinByteOrder() == 0 ? "LSB" : "MSB");
jmarkel44 44:c73f2ca79669 834 printf("\r Join retries: %u\n", GLOBAL_mdot->getJoinRetries());
jmarkel44 44:c73f2ca79669 835 printf("\r Join mode: %u\n", GLOBAL_mdot->getJoinMode());
jmarkel44 44:c73f2ca79669 836 printf("\r Network join status: %s\n", GLOBAL_mdot->getNetworkJoinStatus() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 837 printf("\r Link fail count: %u\n", GLOBAL_mdot->getLinkFailCount());
jmarkel44 44:c73f2ca79669 838 printf("\r Packets Tx'd to gateway: %u\n", GLOBAL_mdot->getUpLinkCounter());
jmarkel44 44:c73f2ca79669 839 printf("\r Packets Rx'd from gateway: %u\n", GLOBAL_mdot->getDownLinkCounter());
jmarkel44 44:c73f2ca79669 840 printf("\r AES encryption: %s\n", GLOBAL_mdot->getAesEncryption() ? "enabled" : "disabled");
jmarkel44 44:c73f2ca79669 841 printf("\r Tx data rate: %u\n", GLOBAL_mdot->getTxDataRate());
jmarkel44 77:43e0a3d9e536 842 printf("\r Datarate Details: %s\n", GLOBAL_mdot->getDateRateDetails(GLOBAL_mdot->getTxDataRate()).c_str());
jmarkel44 44:c73f2ca79669 843 printf("\r Tx power: %u\n", GLOBAL_mdot->getTxPower());
jmarkel44 44:c73f2ca79669 844 printf("\r Antenna gain: %u\n", GLOBAL_mdot->getAntennaGain());
jmarkel44 44:c73f2ca79669 845 printf("\r Min frequency: %u\n", GLOBAL_mdot->getMinFrequency());
jmarkel44 44:c73f2ca79669 846 printf("\r Max frequency: %u\n", GLOBAL_mdot->getMaxFrequency());
jmarkel44 44:c73f2ca79669 847 printf("\r CRC enabled: %s\n", GLOBAL_mdot->getCrc() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 848 printf("\r ACK enabled: %s\n", GLOBAL_mdot->getAck() ? "yes" : "no");
jmarkel44 18:9cf694a764c0 849
jmarkel44 18:9cf694a764c0 850 printf("\r\n");
jmarkel44 18:9cf694a764c0 851 }
jmarkel44 18:9cf694a764c0 852
jmarkel44 35:6235ef67faa1 853 /*****************************************************************************
jmarkel44 35:6235ef67faa1 854 * Function: cmd_resetStats
jmarkel44 35:6235ef67faa1 855 * Description: resets the mDot stats
jmarkel44 35:6235ef67faa1 856 *
jmarkel44 35:6235ef67faa1 857 * @param argc (not used)
jmarkel44 35:6235ef67faa1 858 * @param argv (not used)
jmarkel44 35:6235ef67faa1 859 * @return none
jmarkel44 35:6235ef67faa1 860 *****************************************************************************/
jmarkel44 18:9cf694a764c0 861 void cmd_resetStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 862 {
jmarkel44 35:6235ef67faa1 863 UNUSED(argc);
jmarkel44 35:6235ef67faa1 864 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 865
jmarkel44 18:9cf694a764c0 866 GLOBAL_mdot->resetStats();
jmarkel44 18:9cf694a764c0 867 }
jmarkel44 0:65cfa4873284 868
jmarkel44 35:6235ef67faa1 869 /*****************************************************************************
jmarkel44 35:6235ef67faa1 870 * Function: cmd_rssiStats
jmarkel44 36:f240f5a6d0ed 871 * Description: displays mDot RSSI statistics
jmarkel44 35:6235ef67faa1 872 *
jmarkel44 35:6235ef67faa1 873 * @param argc (not used)
jmarkel44 35:6235ef67faa1 874 * @param argv (not used)
jmarkel44 35:6235ef67faa1 875 * @return none
jmarkel44 35:6235ef67faa1 876 *****************************************************************************/
jmarkel44 18:9cf694a764c0 877 void cmd_rssiStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 878 {
jmarkel44 35:6235ef67faa1 879 UNUSED(argc);
jmarkel44 35:6235ef67faa1 880 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 881
jmarkel44 18:9cf694a764c0 882 mDot::rssi_stats s = GLOBAL_mdot->getRssiStats();
jmarkel44 0:65cfa4873284 883
jmarkel44 18:9cf694a764c0 884 printf("\r Last: %d dB\n", s.last);
jmarkel44 18:9cf694a764c0 885 printf("\r Min: %d dB\n", s.min);
jmarkel44 18:9cf694a764c0 886 printf("\r Max: %d dB\n", s.max);
jmarkel44 18:9cf694a764c0 887 printf("\r Avg: %d dB\n", s.avg);
jmarkel44 18:9cf694a764c0 888
jmarkel44 18:9cf694a764c0 889 printf("\r\n");
jmarkel44 18:9cf694a764c0 890 }
jmarkel44 18:9cf694a764c0 891
jmarkel44 35:6235ef67faa1 892 /*****************************************************************************
jmarkel44 35:6235ef67faa1 893 * Function: cmd_snrStats
jmarkel44 35:6235ef67faa1 894 * Description: displays signal-to-noise ratio stats
jmarkel44 35:6235ef67faa1 895 *
jmarkel44 35:6235ef67faa1 896 * @param argc (not used)
jmarkel44 35:6235ef67faa1 897 * @param argv (not used)
jmarkel44 35:6235ef67faa1 898 * @return none
jmarkel44 35:6235ef67faa1 899 *****************************************************************************/
jmarkel44 18:9cf694a764c0 900 void cmd_snrStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 901 {
jmarkel44 18:9cf694a764c0 902 mDot::snr_stats s = GLOBAL_mdot->getSnrStats();
jmarkel44 18:9cf694a764c0 903
jmarkel44 18:9cf694a764c0 904 printf("\r Last: %d cB\n", s.last);
jmarkel44 18:9cf694a764c0 905 printf("\r Min: %d cB\n", s.min);
jmarkel44 18:9cf694a764c0 906 printf("\r Max: %d cB\n", s.max);
jmarkel44 18:9cf694a764c0 907 printf("\r Avg: %d cB\n", s.avg);
jmarkel44 18:9cf694a764c0 908
jmarkel44 18:9cf694a764c0 909 printf("\r\n");
jmarkel44 18:9cf694a764c0 910 }
jmarkel44 34:f345fdec711d 911
jmarkel44 35:6235ef67faa1 912 /*****************************************************************************
jmarkel44 35:6235ef67faa1 913 * Function: cmd_stack
jmarkel44 36:f240f5a6d0ed 914 * Description: display thread stack statisics
jmarkel44 35:6235ef67faa1 915 *
jmarkel44 35:6235ef67faa1 916 * @param argc (not used)
jmarkel44 35:6235ef67faa1 917 * @param argv (not used)
jmarkel44 35:6235ef67faa1 918 * @return none
jmarkel44 35:6235ef67faa1 919 *****************************************************************************/
jmarkel44 34:f345fdec711d 920 void cmd_stack(int argc, char **argv)
jmarkel44 34:f345fdec711d 921 {
jmarkel44 36:f240f5a6d0ed 922 vector<pair<string, Thread*> > taskList;
davidjhoward 81:d45bfa16953a 923
jmarkel44 71:34856d21f2bf 924 const char *mapper[] = { "Inactive",
jmarkel44 71:34856d21f2bf 925 "Ready",
jmarkel44 71:34856d21f2bf 926 "Running",
jmarkel44 71:34856d21f2bf 927 "WaitingDelay",
jmarkel44 71:34856d21f2bf 928 "WaitingInterval",
jmarkel44 71:34856d21f2bf 929 "WaitingOr",
jmarkel44 71:34856d21f2bf 930 "WaitingAnd",
jmarkel44 71:34856d21f2bf 931 "WaitingSempahore",
jmarkel44 71:34856d21f2bf 932 "WaitingMailbox",
davidjhoward 81:d45bfa16953a 933 "WaitingMutex"
davidjhoward 81:d45bfa16953a 934 };
jmarkel44 36:f240f5a6d0ed 935
jmarkel44 36:f240f5a6d0ed 936 //simply add your task to the list...
jmarkel44 36:f240f5a6d0ed 937 taskList.push_back(make_pair((string)"AnalyticsLogger", GLOBAL_analyticsLogger_thread));
jmarkel44 172:51dfb4aabc57 938 //taskList.push_back(make_pair((string)"BLEHandler", GLOBAL_BLE_thread));
jmarkel44 36:f240f5a6d0ed 939 taskList.push_back(make_pair((string)"CloudDataHandler", GLOBAL_CDH_thread));
jmarkel44 36:f240f5a6d0ed 940 taskList.push_back(make_pair((string)"ConfigHandler", GLOBAL_configHandler_thread));
jmarkel44 36:f240f5a6d0ed 941 taskList.push_back(make_pair((string)"ControlTask", GLOBAL_controlTask_thread));
jmarkel44 36:f240f5a6d0ed 942 taskList.push_back(make_pair((string)"ModbusMaster", GLOBAL_modbusMaster_thread));
jmarkel44 48:1c7861d80d16 943 taskList.push_back(make_pair((string)"OutputTask", GLOBAL_outputTask_thread));
jmarkel44 36:f240f5a6d0ed 944
jmarkel44 36:f240f5a6d0ed 945 for ( vector<pair<string, Thread*> >::iterator pos = taskList.begin();
jmarkel44 36:f240f5a6d0ed 946 pos != taskList.end(); ++ pos) {
jmarkel44 170:f9406996ff5b 947 printf("\r %-32s size/free/used/max = %5u/%5u/%5u/%5u\tpri=%u state=%-20s\n",
davidjhoward 41:e8946fc01ea4 948 pos->first.c_str(),
davidjhoward 41:e8946fc01ea4 949 pos->second->stack_size(),
davidjhoward 41:e8946fc01ea4 950 pos->second->free_stack(),
davidjhoward 41:e8946fc01ea4 951 pos->second->used_stack(),
jmarkel44 71:34856d21f2bf 952 pos->second->max_stack(),
jmarkel44 71:34856d21f2bf 953 pos->second->get_priority(),
jmarkel44 71:34856d21f2bf 954 mapper[pos->second->get_state()]);
jmarkel44 34:f345fdec711d 955 }
jmarkel44 36:f240f5a6d0ed 956
jmarkel44 34:f345fdec711d 957 printf("\r\n");
jmarkel44 34:f345fdec711d 958 }
jmarkel44 62:1b1d7918adf2 959
jmarkel44 62:1b1d7918adf2 960 /*****************************************************************************
davidjhoward 61:ae6dd6692c7d 961 * Function: cmd_modmap
davidjhoward 61:ae6dd6692c7d 962 * Description: dump modbus register map
jmarkel44 62:1b1d7918adf2 963 *****************************************************************************/
davidjhoward 61:ae6dd6692c7d 964 void cmd_modmap(int argc, char **argv)
jmarkel44 62:1b1d7918adf2 965 {
jmarkel44 65:be025ac18fb5 966 UNUSED(argc);
jmarkel44 65:be025ac18fb5 967 UNUSED(argv);
davidjhoward 83:0f76cfbb4eba 968 ModbusValue value;
jmarkel44 67:49f266601d83 969
davidjhoward 61:ae6dd6692c7d 970 std::map<std::string, ModbusRegister>::iterator iter;
davidjhoward 61:ae6dd6692c7d 971 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 83:0f76cfbb4eba 972 ModbusMasterReadRegister( iter->first, &value );
davidjhoward 148:ee3cbaafe355 973 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 974 }
jmarkel44 65:be025ac18fb5 975 }
jmarkel44 65:be025ac18fb5 976
jmarkel44 65:be025ac18fb5 977 /*****************************************************************************
jmarkel44 65:be025ac18fb5 978 * Function: cmd_time
jmarkel44 65:be025ac18fb5 979 * Description: display real-time clock
jmarkel44 65:be025ac18fb5 980 ****************************************************************************/
jmarkel44 65:be025ac18fb5 981 void cmd_time(int argc, char **argv)
jmarkel44 65:be025ac18fb5 982 {
jmarkel44 62:1b1d7918adf2 983 UNUSED(argc);
jmarkel44 62:1b1d7918adf2 984 UNUSED(argv);
davidjhoward 149:950c90425f7c 985
jmarkel44 131:a290a3934132 986 time_t rawtime;
jmarkel44 131:a290a3934132 987 time(&rawtime);
davidjhoward 149:950c90425f7c 988
jmarkel44 62:1b1d7918adf2 989 int iyr=0, imo=0, idy=0, ihr=0, imn=0, isc=0;
jmarkel44 62:1b1d7918adf2 990 rtc_get_time(&iyr, &imo, &idy, &ihr, &imn, &isc);
jmarkel44 131:a290a3934132 991 printf("RTC time: %04d-%02d-%02d %02d:%02d:%02d\r\n", iyr, imo, idy, ihr, imn, isc);
jmarkel44 132:45821e189dd0 992 printf("\repoch timestamp: %lu\r\n", time(NULL));
jmarkel44 66:db1425574b58 993 }
jmarkel44 66:db1425574b58 994
jmarkel44 66:db1425574b58 995 /*****************************************************************************
jmarkel44 131:a290a3934132 996 * Function: cmd_outputs
jmarkel44 66:db1425574b58 997 * Description: display outputs
jmarkel44 66:db1425574b58 998 ****************************************************************************/
jmarkel44 66:db1425574b58 999 void cmd_outputs(int argc, char **argv)
jmarkel44 66:db1425574b58 1000 {
jmarkel44 66:db1425574b58 1001 UNUSED(argc);
jmarkel44 66:db1425574b58 1002 UNUSED(argv);
jmarkel44 67:49f266601d83 1003
jmarkel44 66:db1425574b58 1004 DisplayOutputs();
davidjhoward 81:d45bfa16953a 1005 }
davidjhoward 81:d45bfa16953a 1006
davidjhoward 81:d45bfa16953a 1007 /*****************************************************************************
davidjhoward 81:d45bfa16953a 1008 * Function: cmd_sout
davidjhoward 81:d45bfa16953a 1009 * Description: set output
davidjhoward 81:d45bfa16953a 1010 *
davidjhoward 81:d45bfa16953a 1011 * @param argc-> number of args
davidjhoward 81:d45bfa16953a 1012 * @param argv-> output
davidjhoward 81:d45bfa16953a 1013 * @return none
davidjhoward 81:d45bfa16953a 1014 *****************************************************************************/
davidjhoward 81:d45bfa16953a 1015 void cmd_sout(int argc, char **argv)
davidjhoward 81:d45bfa16953a 1016 {
davidjhoward 81:d45bfa16953a 1017 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 1018
davidjhoward 81:d45bfa16953a 1019 if ( argc != 3 ) {
davidjhoward 81:d45bfa16953a 1020 printf("\rusage: sout <output> <value>\r\n");
davidjhoward 81:d45bfa16953a 1021 printf("\rexample: sout o_rly1 1\r\n");
davidjhoward 81:d45bfa16953a 1022 return;
davidjhoward 116:7337ed514891 1023 }
davidjhoward 83:0f76cfbb4eba 1024 ModbusMasterWriteRegister( argv[1], value );
davidjhoward 82:f3e495a98877 1025 }
davidjhoward 82:f3e495a98877 1026
davidjhoward 82:f3e495a98877 1027 /*****************************************************************************
jmarkel44 102:715f754cf5a8 1028 * Function: cmd_settime
jmarkel44 102:715f754cf5a8 1029 * Description: set real-time clock
jmarkel44 102:715f754cf5a8 1030 *
jmarkel44 102:715f754cf5a8 1031 * @param argc-> number of args
jmarkel44 102:715f754cf5a8 1032 * @param argv-> input
jmarkel44 102:715f754cf5a8 1033 * @return none
jmarkel44 102:715f754cf5a8 1034 *****************************************************************************/
jmarkel44 102:715f754cf5a8 1035 void cmd_settime(int argc, char **argv)
jmarkel44 102:715f754cf5a8 1036 {
davidjhoward 116:7337ed514891 1037
jmarkel44 102:715f754cf5a8 1038 if ( argc != 7 ) {
jmarkel44 102:715f754cf5a8 1039 printf("\rusage: set-time <yyyy> <mm> <dd> <hh> <mm> <ss>\n");
jmarkel44 102:715f754cf5a8 1040 printf("\rexample: set-time 2016 12 25 12 0 0\r\n");
jmarkel44 102:715f754cf5a8 1041 return;
jmarkel44 102:715f754cf5a8 1042 }
davidjhoward 116:7337ed514891 1043
jmarkel44 102:715f754cf5a8 1044 rtc_set_time(atoi(argv[1]), // year
jmarkel44 102:715f754cf5a8 1045 atoi(argv[2]), // month
jmarkel44 102:715f754cf5a8 1046 atoi(argv[3]), // day
jmarkel44 102:715f754cf5a8 1047 atoi(argv[4]), // hr
jmarkel44 102:715f754cf5a8 1048 atoi(argv[5]), // min
jmarkel44 102:715f754cf5a8 1049 atoi(argv[6])); // sec
jmarkel44 102:715f754cf5a8 1050 }
jmarkel44 102:715f754cf5a8 1051
jmarkel44 102:715f754cf5a8 1052 /*****************************************************************************
davidjhoward 82:f3e495a98877 1053 * Function: cmd_simin
davidjhoward 82:f3e495a98877 1054 * Description: simulat input
davidjhoward 82:f3e495a98877 1055 *
davidjhoward 82:f3e495a98877 1056 * @param argc-> number of args
davidjhoward 82:f3e495a98877 1057 * @param argv-> input
davidjhoward 82:f3e495a98877 1058 * @return none
davidjhoward 82:f3e495a98877 1059 *****************************************************************************/
davidjhoward 82:f3e495a98877 1060 void cmd_simin(int argc, char **argv)
davidjhoward 82:f3e495a98877 1061 {
davidjhoward 82:f3e495a98877 1062 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 1063
davidjhoward 82:f3e495a98877 1064 if ( argc < 3 ) {
davidjhoward 150:4db35c8234b4 1065 printf("\rusage: simin <input> <value> <low> <hi> <up_step> <down_step>\r\n");
davidjhoward 150:4db35c8234b4 1066 printf("\rexample: simin i_tra01 100 94 106 1 .25\r\n");
davidjhoward 150:4db35c8234b4 1067 printf("\rexample: simin i_bdcond01 2000 1990 2006 .25 1\r\n");
davidjhoward 82:f3e495a98877 1068 return;
davidjhoward 82:f3e495a98877 1069 }
davidjhoward 82:f3e495a98877 1070
davidjhoward 82:f3e495a98877 1071 SimulateInputMap[argv[1]].start_value = atof(argv[2]);
davidjhoward 116:7337ed514891 1072
davidjhoward 82:f3e495a98877 1073 ModbusRegisterMap[argv[1]].simulated = true;
davidjhoward 82:f3e495a98877 1074
davidjhoward 82:f3e495a98877 1075 if ( argc < 3 ) {
davidjhoward 82:f3e495a98877 1076 SimulateInputMap[argv[1]].min = 0;
davidjhoward 82:f3e495a98877 1077 SimulateInputMap[argv[1]].max = 0;
davidjhoward 179:a31ea334e2b7 1078 SimulateInputMap[argv[1]].moving_up = false;
davidjhoward 82:f3e495a98877 1079 return;
davidjhoward 82:f3e495a98877 1080 }
davidjhoward 82:f3e495a98877 1081 SimulateInputMap[argv[1]].min = atof(argv[3]);
davidjhoward 82:f3e495a98877 1082 SimulateInputMap[argv[1]].max = atof(argv[4]);
davidjhoward 150:4db35c8234b4 1083 SimulateInputMap[argv[1]].up_step = atof(argv[5]);
davidjhoward 150:4db35c8234b4 1084 SimulateInputMap[argv[1]].down_step = atof(argv[6]);
davidjhoward 179:a31ea334e2b7 1085 SimulateInputMap[argv[1]].moving_up = true;
davidjhoward 150:4db35c8234b4 1086
davidjhoward 179:a31ea334e2b7 1087 }
davidjhoward 179:a31ea334e2b7 1088
davidjhoward 179:a31ea334e2b7 1089 /*****************************************************************************
davidjhoward 179:a31ea334e2b7 1090 * Function: cmd_simall
davidjhoward 179:a31ea334e2b7 1091 * Description: simulat multiple inputs
davidjhoward 179:a31ea334e2b7 1092 *
davidjhoward 179:a31ea334e2b7 1093 * @return none
davidjhoward 179:a31ea334e2b7 1094 *****************************************************************************/
davidjhoward 179:a31ea334e2b7 1095 void cmd_simall(int argc, char **argv)
davidjhoward 179:a31ea334e2b7 1096 {
davidjhoward 179:a31ea334e2b7 1097
davidjhoward 179:a31ea334e2b7 1098 if ( argc > 1 ) {
davidjhoward 179:a31ea334e2b7 1099 printf("\rsetting: simin i_tra01 100\r\n");
davidjhoward 179:a31ea334e2b7 1100 printf("\rsetting: simin i_bdcond01 2000\r\n");
davidjhoward 179:a31ea334e2b7 1101
davidjhoward 179:a31ea334e2b7 1102 ModbusRegisterMap["i_tra01"].simulated = true;
davidjhoward 179:a31ea334e2b7 1103 SimulateInputMap["i_tra01"].start_value = 100;
davidjhoward 179:a31ea334e2b7 1104 SimulateInputMap["i_tra01"].min = 0;
davidjhoward 179:a31ea334e2b7 1105 SimulateInputMap["i_tra01"].max = 0;
davidjhoward 179:a31ea334e2b7 1106 SimulateInputMap["i_tra01"].up_step = 0;
davidjhoward 179:a31ea334e2b7 1107 SimulateInputMap["i_tra01"].down_step = 0;
davidjhoward 179:a31ea334e2b7 1108 SimulateInputMap["i_tra01"].moving_up = true;
davidjhoward 179:a31ea334e2b7 1109
davidjhoward 179:a31ea334e2b7 1110 ModbusRegisterMap["i_bdcond01"].simulated = true;
davidjhoward 179:a31ea334e2b7 1111 SimulateInputMap["i_bdcond01"].start_value = 2000;
davidjhoward 179:a31ea334e2b7 1112 SimulateInputMap["i_bdcond01"].min = 0;
davidjhoward 179:a31ea334e2b7 1113 SimulateInputMap["i_bdcond01"].max = 0;
davidjhoward 179:a31ea334e2b7 1114 SimulateInputMap["i_bdcond01"].up_step = 0;
davidjhoward 179:a31ea334e2b7 1115 SimulateInputMap["i_bdcond01"].down_step = 0;
davidjhoward 179:a31ea334e2b7 1116 SimulateInputMap["i_bdcond01"].moving_up = true;
davidjhoward 179:a31ea334e2b7 1117
davidjhoward 179:a31ea334e2b7 1118 return;
davidjhoward 179:a31ea334e2b7 1119 }
davidjhoward 179:a31ea334e2b7 1120
davidjhoward 179:a31ea334e2b7 1121 printf("\rsetting: simin i_tra01 100 94 106 1 .25\r\n");
davidjhoward 179:a31ea334e2b7 1122 printf("\rsetting: simin i_bdcond01 2000 1990 2006 .25 1\r\n");
davidjhoward 179:a31ea334e2b7 1123
davidjhoward 179:a31ea334e2b7 1124 ModbusRegisterMap["i_tra01"].simulated = true;
davidjhoward 179:a31ea334e2b7 1125 SimulateInputMap["i_tra01"].start_value = 100;
davidjhoward 179:a31ea334e2b7 1126 SimulateInputMap["i_tra01"].min = 94;
davidjhoward 179:a31ea334e2b7 1127 SimulateInputMap["i_tra01"].max = 106;
davidjhoward 179:a31ea334e2b7 1128 SimulateInputMap["i_tra01"].up_step = 1;
davidjhoward 179:a31ea334e2b7 1129 SimulateInputMap["i_tra01"].down_step = .25;
davidjhoward 179:a31ea334e2b7 1130
davidjhoward 179:a31ea334e2b7 1131 ModbusRegisterMap["i_bdcond01"].simulated = true;
davidjhoward 179:a31ea334e2b7 1132 SimulateInputMap["i_bdcond01"].start_value = 2000;
davidjhoward 179:a31ea334e2b7 1133 SimulateInputMap["i_bdcond01"].min = 1990;
davidjhoward 179:a31ea334e2b7 1134 SimulateInputMap["i_bdcond01"].max = 2006;
davidjhoward 179:a31ea334e2b7 1135 SimulateInputMap["i_bdcond01"].up_step = .25;
davidjhoward 179:a31ea334e2b7 1136 SimulateInputMap["i_bdcond01"].down_step = 1;
davidjhoward 82:f3e495a98877 1137
davidjhoward 116:7337ed514891 1138 }
davidjhoward 116:7337ed514891 1139
davidjhoward 116:7337ed514891 1140 void cmd_deep( int argc, char **argv )
davidjhoward 116:7337ed514891 1141 {
davidjhoward 116:7337ed514891 1142 UNUSED(argc);
davidjhoward 116:7337ed514891 1143 UNUSED(argv);
davidjhoward 116:7337ed514891 1144
davidjhoward 123:ce602c91a9c3 1145 char logString[LOG_BYTES_PER_ENTRY];
davidjhoward 116:7337ed514891 1146
davidjhoward 116:7337ed514891 1147 LogLocalApi_PopEntry( logString );
davidjhoward 123:ce602c91a9c3 1148 if( logString[0] != '\0' ) {
davidjhoward 116:7337ed514891 1149 printf("%s\r\n", logString );
davidjhoward 123:ce602c91a9c3 1150 } else {
davidjhoward 116:7337ed514891 1151 printf("%s\r\n", "No String Found" );
davidjhoward 116:7337ed514891 1152 }
davidjhoward 116:7337ed514891 1153 }
davidjhoward 116:7337ed514891 1154
davidjhoward 116:7337ed514891 1155 void cmd_peep( int argc, char **argv )
davidjhoward 116:7337ed514891 1156 {
davidjhoward 116:7337ed514891 1157 UNUSED(argc);
davidjhoward 116:7337ed514891 1158 UNUSED(argv);
davidjhoward 116:7337ed514891 1159
davidjhoward 116:7337ed514891 1160 std::string logString = "This is a string to log";
davidjhoward 116:7337ed514891 1161
davidjhoward 116:7337ed514891 1162 LogLocalApi_PushEntry( logString.c_str() );
davidjhoward 123:ce602c91a9c3 1163 }
davidjhoward 123:ce602c91a9c3 1164
davidjhoward 123:ce602c91a9c3 1165 void cmd_inslog( int argc, char **argv )
davidjhoward 123:ce602c91a9c3 1166 {
davidjhoward 123:ce602c91a9c3 1167 UNUSED(argc);
davidjhoward 123:ce602c91a9c3 1168 UNUSED(argv);
davidjhoward 123:ce602c91a9c3 1169
davidjhoward 123:ce602c91a9c3 1170 EventReasonStruct_t eventReason;
davidjhoward 123:ce602c91a9c3 1171 eventReason.eventReason = EVENT_REASON_AUTO;
davidjhoward 123:ce602c91a9c3 1172 eventReason.inputValue = 100.00;
davidjhoward 123:ce602c91a9c3 1173 strncpy(eventReason.inputTag, "i_stub01", sizeof(eventReason.inputTag) );
davidjhoward 123:ce602c91a9c3 1174 eventReason.outputValue = 0.0;
davidjhoward 123:ce602c91a9c3 1175 strncpy(eventReason.outputTag, "o_stub01", sizeof(eventReason.outputTag) );
davidjhoward 123:ce602c91a9c3 1176 EventLoggerApi( eventReason );
davidjhoward 149:950c90425f7c 1177 }
davidjhoward 149:950c90425f7c 1178
davidjhoward 149:950c90425f7c 1179 void cmd_showSimin( int argc, char **argv )
davidjhoward 149:950c90425f7c 1180 {
davidjhoward 149:950c90425f7c 1181 std::map<std::string, SimulateInput>::iterator iter;
davidjhoward 149:950c90425f7c 1182 for (iter = SimulateInputMap.begin(); iter != SimulateInputMap.end(); ++iter) {
davidjhoward 150:4db35c8234b4 1183 printf("simulated input=%s, min=%2.2f, max=%2.2f, start_value=%2.2f, up_step=%2.2f, down_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].up_step, SimulateInputMap[iter->first].down_step);
davidjhoward 149:950c90425f7c 1184 }
jmarkel44 177:9ec90c8e3ce1 1185 }
jmarkel44 177:9ec90c8e3ce1 1186
jmarkel44 177:9ec90c8e3ce1 1187 void cmd_demo(int argc, char **argv)
jmarkel44 177:9ec90c8e3ce1 1188 {
jmarkel44 177:9ec90c8e3ce1 1189 UNUSED(argc);
jmarkel44 177:9ec90c8e3ce1 1190 UNUSED(argv);
jmarkel44 177:9ec90c8e3ce1 1191
jmarkel44 177:9ec90c8e3ce1 1192 // inputs:
jmarkel44 177:9ec90c8e3ce1 1193 // input_i_tra01.json
jmarkel44 177:9ec90c8e3ce1 1194 // input_i_bdcond01.json
jmarkel44 177:9ec90c8e3ce1 1195 // outputs:
jmarkel44 177:9ec90c8e3ce1 1196 // output_o_rly01.json
jmarkel44 177:9ec90c8e3ce1 1197 // output_o_rly02.json
jmarkel44 177:9ec90c8e3ce1 1198 // controls
jmarkel44 177:9ec90c8e3ce1 1199 // control_sp_INH_TRA_01.json
jmarkel44 177:9ec90c8e3ce1 1200 // control_sp_BLOWDOWN_01.json
jmarkel44 177:9ec90c8e3ce1 1201
jmarkel44 177:9ec90c8e3ce1 1202
jmarkel44 177:9ec90c8e3ce1 1203 // INPUT: Trasar
jmarkel44 177:9ec90c8e3ce1 1204 char buf[MAX_FILE_SIZE];
jmarkel44 177:9ec90c8e3ce1 1205 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1206 "{ "
jmarkel44 177:9ec90c8e3ce1 1207 "\"id\": \"i_tra01\","
jmarkel44 177:9ec90c8e3ce1 1208 "\"name\": \"Trasar\", "
jmarkel44 177:9ec90c8e3ce1 1209 "\"units\": \"PPM\", "
jmarkel44 177:9ec90c8e3ce1 1210 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1211 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1212 "\"node\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1213 "\"reg\": \"9\", "
jmarkel44 177:9ec90c8e3ce1 1214 "\"rtype\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1215 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1216 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1217 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1218 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1219 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1220 "\"rfreq\": \"5\" }");
jmarkel44 177:9ec90c8e3ce1 1221 bool rc = GLOBAL_mdot->saveUserFile("input_i_tra01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1222 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1223 printf("\rFailed to save input_i_tra01.json\n");
jmarkel44 177:9ec90c8e3ce1 1224 return;
jmarkel44 177:9ec90c8e3ce1 1225 } else {
jmarkel44 177:9ec90c8e3ce1 1226 printf("\r...generated input_i_tra01.json\n");
jmarkel44 177:9ec90c8e3ce1 1227 }
jmarkel44 177:9ec90c8e3ce1 1228
jmarkel44 177:9ec90c8e3ce1 1229 Message_t *mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1230 mail->action = ACTION_READ_FILE;
jmarkel44 177:9ec90c8e3ce1 1231 strncpy( mail->controlFile, "input_i_tra01.json", (sizeof(mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1232 ModbusMasterMailBox.put(mail);
jmarkel44 177:9ec90c8e3ce1 1233
jmarkel44 177:9ec90c8e3ce1 1234 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1235
jmarkel44 177:9ec90c8e3ce1 1236
jmarkel44 177:9ec90c8e3ce1 1237 // INPUT: Conductivity
jmarkel44 177:9ec90c8e3ce1 1238 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1239 "{ "
jmarkel44 177:9ec90c8e3ce1 1240 "\"id\": \"i_bdcond01\","
jmarkel44 177:9ec90c8e3ce1 1241 "\"name\": \"Tower Conductivity\", "
davidjhoward 186:16912aa18c2a 1242 "\"units\": \"uS\","
davidjhoward 186:16912aa18c2a 1243 "\"min\": \"0\","
davidjhoward 186:16912aa18c2a 1244 "\"max\": \"6000\","
davidjhoward 186:16912aa18c2a 1245 "\"node\": \"21\","
davidjhoward 186:16912aa18c2a 1246 "\"reg\": \"18\","
davidjhoward 186:16912aa18c2a 1247 "\"rtype\": \"1\","
davidjhoward 186:16912aa18c2a 1248 "\"type\": \"1\","
davidjhoward 186:16912aa18c2a 1249 "\"size\": \"2\","
davidjhoward 186:16912aa18c2a 1250 "\"order\": \"2\","
davidjhoward 186:16912aa18c2a 1251 "\"fmt\": \"%%.2f\","
davidjhoward 186:16912aa18c2a 1252 "\"vcmd\": \"\","
jmarkel44 177:9ec90c8e3ce1 1253 "\"rfreq\": \"5\" }");
jmarkel44 177:9ec90c8e3ce1 1254 rc = GLOBAL_mdot->saveUserFile("input_i_bdcond01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1255 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1256 printf("\rFailed to save input_i_bdcond01.json\n");
jmarkel44 177:9ec90c8e3ce1 1257 return;
jmarkel44 177:9ec90c8e3ce1 1258 } else {
jmarkel44 177:9ec90c8e3ce1 1259 printf("\r...generated input_i_bdcond01.json\n");
jmarkel44 177:9ec90c8e3ce1 1260 }
jmarkel44 177:9ec90c8e3ce1 1261
jmarkel44 177:9ec90c8e3ce1 1262 mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1263 mail->action = ACTION_READ_FILE;
davidjhoward 186:16912aa18c2a 1264 strncpy( mail->controlFile, "input_i_bdcond01.json", (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 1265 ModbusMasterMailBox.put(mail);
davidjhoward 186:16912aa18c2a 1266
davidjhoward 186:16912aa18c2a 1267 Thread::wait(1000);
davidjhoward 186:16912aa18c2a 1268
davidjhoward 186:16912aa18c2a 1269 // INPUT: Conductivity Temperature
davidjhoward 186:16912aa18c2a 1270 snprintf(buf, sizeof(buf),
davidjhoward 186:16912aa18c2a 1271 "{ "
davidjhoward 186:16912aa18c2a 1272 "\"id\": \"i_temp01\","
davidjhoward 186:16912aa18c2a 1273 "\"name\": \"Temp Conductivity\","
davidjhoward 186:16912aa18c2a 1274 "\"units\": \"C\","
davidjhoward 186:16912aa18c2a 1275 "\"min\": \"0\","
davidjhoward 186:16912aa18c2a 1276 "\"max\": \"80\","
davidjhoward 186:16912aa18c2a 1277 "\"node\": \"21\","
davidjhoward 186:16912aa18c2a 1278 "\"reg\": \"10\","
davidjhoward 186:16912aa18c2a 1279 "\"rtype\": \"1\","
davidjhoward 186:16912aa18c2a 1280 "\"type\": \"1\","
davidjhoward 186:16912aa18c2a 1281 "\"size\": \"2\","
davidjhoward 186:16912aa18c2a 1282 "\"order\": \"2\","
davidjhoward 186:16912aa18c2a 1283 "\"fmt\": \"%%.2f\","
davidjhoward 186:16912aa18c2a 1284 "\"vcmd\": \"\","
davidjhoward 186:16912aa18c2a 1285 "\"rfreq\": \"5\" }");
davidjhoward 186:16912aa18c2a 1286 rc = GLOBAL_mdot->saveUserFile("input_i_temp01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 186:16912aa18c2a 1287 if ( rc != true ) {
davidjhoward 186:16912aa18c2a 1288 printf("\rFailed to save input_i_temp01.json\n");
davidjhoward 186:16912aa18c2a 1289 return;
davidjhoward 186:16912aa18c2a 1290 } else {
davidjhoward 186:16912aa18c2a 1291 printf("\r...generated input_i_temp01.json\n");
davidjhoward 186:16912aa18c2a 1292 }
davidjhoward 186:16912aa18c2a 1293
davidjhoward 186:16912aa18c2a 1294 mail = ModbusMasterMailBox.alloc();
davidjhoward 186:16912aa18c2a 1295 mail->action = ACTION_READ_FILE;
davidjhoward 186:16912aa18c2a 1296 strncpy( mail->controlFile, "input_i_temp01.json", (sizeof(mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1297 ModbusMasterMailBox.put(mail);
jmarkel44 177:9ec90c8e3ce1 1298
jmarkel44 177:9ec90c8e3ce1 1299 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1300
jmarkel44 177:9ec90c8e3ce1 1301 // OUTPUT: Relay 01
jmarkel44 177:9ec90c8e3ce1 1302 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1303 "{ "
jmarkel44 177:9ec90c8e3ce1 1304 "\"id\": \"o_rly01\", "
jmarkel44 177:9ec90c8e3ce1 1305 "\"name\": \"Blowdown\", "
jmarkel44 177:9ec90c8e3ce1 1306 "\"units\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1307 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1308 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1309 "\"node\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1310 "\"reg\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1311 "\"rtype\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1312 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1313 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1314 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1315 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1316 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1317 "\"rfreq\": \"5\", "
jmarkel44 177:9ec90c8e3ce1 1318 "\"toperiod\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1319 "\"scalelo\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1320 "\"scalehi\": \"100\" }");
jmarkel44 177:9ec90c8e3ce1 1321 rc = GLOBAL_mdot->saveUserFile("output_o_rly01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1322 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1323 printf("\rFailed to save output_o_rly01.json\n");
jmarkel44 177:9ec90c8e3ce1 1324 return;
jmarkel44 177:9ec90c8e3ce1 1325 } else {
jmarkel44 177:9ec90c8e3ce1 1326 printf("\r...generated output_o_rly01.json\n");
jmarkel44 177:9ec90c8e3ce1 1327 }
jmarkel44 177:9ec90c8e3ce1 1328
jmarkel44 177:9ec90c8e3ce1 1329 // send a message to the modbus master
jmarkel44 177:9ec90c8e3ce1 1330 Message_t *modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1331 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 177:9ec90c8e3ce1 1332 strncpy( modbus_mail->controlFile, "output_o_rly01.json", (sizeof(modbus_mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1333 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 177:9ec90c8e3ce1 1334
jmarkel44 177:9ec90c8e3ce1 1335 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1336
jmarkel44 177:9ec90c8e3ce1 1337 // send a message to the output master
jmarkel44 177:9ec90c8e3ce1 1338 OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1339 output_mail->action = ACTION_NEW;
jmarkel44 177:9ec90c8e3ce1 1340 strncpy(output_mail->controlFile, "output_o_rly01.json", sizeof(output_mail->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 1341 OutputMasterMailBox.put(output_mail);
jmarkel44 177:9ec90c8e3ce1 1342
jmarkel44 177:9ec90c8e3ce1 1343 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1344
jmarkel44 177:9ec90c8e3ce1 1345 // OUTPUT: Relay 02
jmarkel44 177:9ec90c8e3ce1 1346 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1347 "{ "
jmarkel44 177:9ec90c8e3ce1 1348 "\"id\": \"o_rly02\", "
jmarkel44 177:9ec90c8e3ce1 1349 "\"name\": \"3DTS86\", "
jmarkel44 177:9ec90c8e3ce1 1350 "\"units\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1351 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1352 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1353 "\"node\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1354 "\"reg\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1355 "\"rtype\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1356 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1357 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1358 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1359 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1360 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1361 "\"rfreq\": \"5\", "
jmarkel44 177:9ec90c8e3ce1 1362 "\"toperiod\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1363 "\"scalelo\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1364 "\"scalehi\": \"100\" }");
jmarkel44 177:9ec90c8e3ce1 1365 rc = GLOBAL_mdot->saveUserFile("output_o_rly02.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1366 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1367 printf("\rFailed to save output_o_rly02.json\n");
jmarkel44 177:9ec90c8e3ce1 1368 return;
jmarkel44 177:9ec90c8e3ce1 1369 } else {
jmarkel44 177:9ec90c8e3ce1 1370 printf("\r...generated output_o_rly02.json\n");
jmarkel44 177:9ec90c8e3ce1 1371 }
jmarkel44 177:9ec90c8e3ce1 1372
jmarkel44 177:9ec90c8e3ce1 1373 // send a message to the modbus master
jmarkel44 177:9ec90c8e3ce1 1374 modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1375 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 177:9ec90c8e3ce1 1376 strncpy( modbus_mail->controlFile, "output_o_rly02.json", (sizeof(modbus_mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1377 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 177:9ec90c8e3ce1 1378
jmarkel44 177:9ec90c8e3ce1 1379 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1380
jmarkel44 177:9ec90c8e3ce1 1381 // send a message to the output master
jmarkel44 177:9ec90c8e3ce1 1382 output_mail = OutputMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1383 output_mail->action = ACTION_NEW;
jmarkel44 177:9ec90c8e3ce1 1384 strncpy(output_mail->controlFile, "output_o_rly02.json", sizeof(output_mail->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 1385 OutputMasterMailBox.put(output_mail);
jmarkel44 177:9ec90c8e3ce1 1386
jmarkel44 177:9ec90c8e3ce1 1387 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1388
jmarkel44 177:9ec90c8e3ce1 1389 // SETPOINT: Blowdown
jmarkel44 177:9ec90c8e3ce1 1390 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1391 "{ "
jmarkel44 177:9ec90c8e3ce1 1392 "\"id\": \"BLOWDOWN_01\", "
jmarkel44 177:9ec90c8e3ce1 1393 "\"priority\": \"800\", "
jmarkel44 177:9ec90c8e3ce1 1394 "\"input\": \"i_bdcond01\", "
jmarkel44 177:9ec90c8e3ce1 1395 "\"output\": \"o_rly01\", "
jmarkel44 177:9ec90c8e3ce1 1396 "\"setpoint\": \"2000\", "
jmarkel44 177:9ec90c8e3ce1 1397 "\"prodfact\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1398 "\"actingDir\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1399 "\"halert\": \"2100\", "
jmarkel44 177:9ec90c8e3ce1 1400 "\"lalert\": \"1900\", "
jmarkel44 177:9ec90c8e3ce1 1401 "\"hfs\": \"2200\", "
jmarkel44 177:9ec90c8e3ce1 1402 "\"lfs\": \"1800\", "
jmarkel44 177:9ec90c8e3ce1 1403 "\"tol\": \"5\" }");
jmarkel44 177:9ec90c8e3ce1 1404 rc = GLOBAL_mdot->saveUserFile("control_sp_bd01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1405 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1406 printf("\rFailed to save control_sp_bd01.json\n");
jmarkel44 177:9ec90c8e3ce1 1407 return;
jmarkel44 177:9ec90c8e3ce1 1408 } else {
jmarkel44 177:9ec90c8e3ce1 1409 printf("\r...generated control_sp_bd01.json\n");
jmarkel44 177:9ec90c8e3ce1 1410 }
jmarkel44 177:9ec90c8e3ce1 1411
jmarkel44 177:9ec90c8e3ce1 1412 Message_t *sp_msg = MailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1413 memset(sp_msg, 0, sizeof(Message_t));
jmarkel44 177:9ec90c8e3ce1 1414 sp_msg->action = ACTION_CREATE;
jmarkel44 177:9ec90c8e3ce1 1415 sp_msg->control = CONTROL_SETPOINT;
jmarkel44 177:9ec90c8e3ce1 1416 strncpy(sp_msg->controlFile, "control_sp_bd01.json", sizeof(sp_msg->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 1417
jmarkel44 177:9ec90c8e3ce1 1418 MailBox.put(sp_msg);
jmarkel44 177:9ec90c8e3ce1 1419
jmarkel44 177:9ec90c8e3ce1 1420 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1421
jmarkel44 177:9ec90c8e3ce1 1422 // SETPOINT: Trasar
jmarkel44 177:9ec90c8e3ce1 1423 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1424 "{ "
jmarkel44 177:9ec90c8e3ce1 1425 "\"id\": \"INH_TRA_01\", "
jmarkel44 177:9ec90c8e3ce1 1426 "\"priority\": \"800\", "
jmarkel44 177:9ec90c8e3ce1 1427 "\"input\": \"i_tra01\", "
jmarkel44 177:9ec90c8e3ce1 1428 "\"output\": \"o_rly02\", "
jmarkel44 177:9ec90c8e3ce1 1429 "\"setpoint\": \"100\", "
jmarkel44 177:9ec90c8e3ce1 1430 "\"prodfact\": \"100\", "
jmarkel44 177:9ec90c8e3ce1 1431 "\"actingDir\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1432 "\"halert\": \"115\", "
jmarkel44 177:9ec90c8e3ce1 1433 "\"lalert\": \"85\", "
jmarkel44 177:9ec90c8e3ce1 1434 "\"hfs\": \"130\", "
jmarkel44 177:9ec90c8e3ce1 1435 "\"lfs\": \"70\", "
jmarkel44 177:9ec90c8e3ce1 1436 "\"tol\": \"5\" }");
jmarkel44 177:9ec90c8e3ce1 1437 rc = GLOBAL_mdot->saveUserFile("control_sp_tra01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1438 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1439 printf("\rFailed to save control_sp_tra01.json\n");
jmarkel44 177:9ec90c8e3ce1 1440 return;
jmarkel44 177:9ec90c8e3ce1 1441 } else {
jmarkel44 177:9ec90c8e3ce1 1442 printf("\r...generated control_sp_tra01.json\n");
jmarkel44 177:9ec90c8e3ce1 1443 Thread::wait(500);
jmarkel44 177:9ec90c8e3ce1 1444 }
jmarkel44 177:9ec90c8e3ce1 1445
jmarkel44 177:9ec90c8e3ce1 1446 sp_msg = MailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1447 memset(sp_msg, 0, sizeof(Message_t));
jmarkel44 177:9ec90c8e3ce1 1448 sp_msg->action = ACTION_CREATE;
jmarkel44 177:9ec90c8e3ce1 1449 sp_msg->control = CONTROL_SETPOINT;
jmarkel44 177:9ec90c8e3ce1 1450 strncpy(sp_msg->controlFile, "control_sp_tra01.json", sizeof(sp_msg->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 1451
jmarkel44 177:9ec90c8e3ce1 1452 MailBox.put(sp_msg);
jmarkel44 177:9ec90c8e3ce1 1453 Thread::wait(1000);
davidjhoward 186:16912aa18c2a 1454 }
davidjhoward 186:16912aa18c2a 1455
davidjhoward 186:16912aa18c2a 1456 /*****************************************************************************
davidjhoward 186:16912aa18c2a 1457 * Function: cmd_createTemp
davidjhoward 186:16912aa18c2a 1458 * Description: create input file
davidjhoward 186:16912aa18c2a 1459 *
davidjhoward 186:16912aa18c2a 1460 * @param argc-> number of args
davidjhoward 186:16912aa18c2a 1461 * @param argv-> filename
davidjhoward 186:16912aa18c2a 1462 * @return none
davidjhoward 186:16912aa18c2a 1463 *****************************************************************************/
davidjhoward 186:16912aa18c2a 1464 void cmd_createTemp(int argc, char **argv)
davidjhoward 186:16912aa18c2a 1465 {
davidjhoward 186:16912aa18c2a 1466 char data_buf[MAX_FILE_SIZE];
davidjhoward 186:16912aa18c2a 1467 snprintf(data_buf, sizeof(data_buf),
davidjhoward 186:16912aa18c2a 1468 "{ "
davidjhoward 186:16912aa18c2a 1469 "\"id\": \"i_temp01\", "
davidjhoward 186:16912aa18c2a 1470 "\"name\": \"Temp Conductivity\", "
davidjhoward 186:16912aa18c2a 1471 "\"units\": \"C\", "
davidjhoward 186:16912aa18c2a 1472 "\"min\": \"0\", "
davidjhoward 186:16912aa18c2a 1473 "\"max\": \"300\", "
davidjhoward 186:16912aa18c2a 1474 "\"node\": \"21\", "
davidjhoward 186:16912aa18c2a 1475 "\"reg\": \"10\", "
davidjhoward 186:16912aa18c2a 1476 "\"rtype\": \"1\", "
davidjhoward 186:16912aa18c2a 1477 "\"type\": \"1\", "
davidjhoward 186:16912aa18c2a 1478 "\"size\": \"2\", "
davidjhoward 186:16912aa18c2a 1479 "\"order\": \"2\", "
davidjhoward 186:16912aa18c2a 1480 "\"rfreq\": \"5\", "
davidjhoward 186:16912aa18c2a 1481 "\"vcmd\": \"\","
davidjhoward 186:16912aa18c2a 1482 "\"fmt\": \"%%.2f\" } ");
davidjhoward 186:16912aa18c2a 1483
davidjhoward 186:16912aa18c2a 1484 bool status = GLOBAL_mdot->saveUserFile("input_i_temp01.json", (void *)data_buf, MAX_FILE_SIZE);
davidjhoward 186:16912aa18c2a 1485 if( status != true ) {
davidjhoward 186:16912aa18c2a 1486 logInfo("(%d)save file failed, status=%d", __LINE__, status);
davidjhoward 186:16912aa18c2a 1487 }
davidjhoward 186:16912aa18c2a 1488
davidjhoward 186:16912aa18c2a 1489 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", "input_i_temp01.json");
davidjhoward 186:16912aa18c2a 1490 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 186:16912aa18c2a 1491 mail->action = ACTION_READ_FILE;
davidjhoward 186:16912aa18c2a 1492 strncpy( mail->controlFile, "input_i_temp01.json", (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 1493 ModbusMasterMailBox.put(mail);
davidjhoward 186:16912aa18c2a 1494 }
davidjhoward 186:16912aa18c2a 1495
davidjhoward 186:16912aa18c2a 1496 /*****************************************************************************
davidjhoward 186:16912aa18c2a 1497 * Function: cmd_createBDCond
davidjhoward 186:16912aa18c2a 1498 * Description: create input file
davidjhoward 186:16912aa18c2a 1499 *
davidjhoward 186:16912aa18c2a 1500 * @param argc-> number of args
davidjhoward 186:16912aa18c2a 1501 * @param argv-> filename
davidjhoward 186:16912aa18c2a 1502 * @return none
davidjhoward 186:16912aa18c2a 1503 *****************************************************************************/
davidjhoward 186:16912aa18c2a 1504 void cmd_createBDCond(int argc, char **argv)
davidjhoward 186:16912aa18c2a 1505 {
davidjhoward 186:16912aa18c2a 1506 if ( argc != 6 ) {
davidjhoward 186:16912aa18c2a 1507 printf("\rusage: createBDCond <fname> <input> <name> <node> <reg>\n");
davidjhoward 186:16912aa18c2a 1508 printf("\rexample: createBDCond input_i_bdcond.json i_bdcond01 TowerConductivity 21 18\n");
davidjhoward 186:16912aa18c2a 1509 return;
davidjhoward 186:16912aa18c2a 1510 }
davidjhoward 186:16912aa18c2a 1511
davidjhoward 186:16912aa18c2a 1512 char data_buf[MAX_FILE_SIZE];
davidjhoward 186:16912aa18c2a 1513 snprintf(data_buf, sizeof(data_buf),
davidjhoward 186:16912aa18c2a 1514 "{ "
davidjhoward 186:16912aa18c2a 1515 "\"id\": \"%s\", "
davidjhoward 186:16912aa18c2a 1516 "\"name\": \"%s\", "
davidjhoward 186:16912aa18c2a 1517 "\"units\": \"uS\", "
davidjhoward 186:16912aa18c2a 1518 "\"min\": \"0\", "
davidjhoward 186:16912aa18c2a 1519 "\"max\": \"300\", "
davidjhoward 186:16912aa18c2a 1520 "\"node\": \"%s\", "
davidjhoward 186:16912aa18c2a 1521 "\"reg\": \"%s\", "
davidjhoward 186:16912aa18c2a 1522 "\"rtype\": \"1\", "
davidjhoward 186:16912aa18c2a 1523 "\"type\": \"0\", "
davidjhoward 186:16912aa18c2a 1524 "\"size\": \"2\", "
davidjhoward 186:16912aa18c2a 1525 "\"order\": \"2\", "
davidjhoward 186:16912aa18c2a 1526 "\"rfreq\": \"5\", "
davidjhoward 186:16912aa18c2a 1527 "\"vcmd\": \"\","
davidjhoward 186:16912aa18c2a 1528 "\"fmt\": \"%%.2f\" } ", argv[2], argv[3], argv[4], argv[5]);
davidjhoward 186:16912aa18c2a 1529
davidjhoward 186:16912aa18c2a 1530 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
davidjhoward 186:16912aa18c2a 1531 if( status != true ) {
davidjhoward 186:16912aa18c2a 1532 logInfo("(%d)save file failed, status=%d", __LINE__, status);
davidjhoward 186:16912aa18c2a 1533 }
davidjhoward 186:16912aa18c2a 1534
davidjhoward 186:16912aa18c2a 1535 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", argv[1]);
davidjhoward 186:16912aa18c2a 1536 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 186:16912aa18c2a 1537 mail->action = ACTION_READ_FILE;
davidjhoward 186:16912aa18c2a 1538 strncpy( mail->controlFile, argv[1], (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 1539 ModbusMasterMailBox.put(mail);
jmarkel44 62:1b1d7918adf2 1540 }