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@231:f22901955e0c, 2016-10-19 (annotated)

Committer:
jmarkel44
Date:
Wed Oct 19 15:55:40 2016 +0000
Revision:
231:f22901955e0c
Parent:
230:11765008ff3a
Child:
235:ce028fbf054d
Child:
239:cfb1a917e7f7
deprecated "demo" command; added "preload" command.;

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 207:55aabde2d4bf 45 #include "MbedJSONValue.h"
jmarkel44 0:65cfa4873284 46
jmarkel44 0:65cfa4873284 47 Serial serial(USBTX, USBRX);
jmarkel44 0:65cfa4873284 48 ntshell_t ntshell;
jmarkel44 0:65cfa4873284 49
jmarkel44 14:cc916fa8dd11 50 extern mDot *GLOBAL_mdot;
jmarkel44 14:cc916fa8dd11 51
jmarkel44 0:65cfa4873284 52 typedef struct {
jmarkel44 0:65cfa4873284 53 char *command; // command (from shell)
jmarkel44 0:65cfa4873284 54 char *description; // descrption
jmarkel44 0:65cfa4873284 55 void (*func)(int argc, char **argv); // callback function
jmarkel44 0:65cfa4873284 56 } command_table_t;
jmarkel44 0:65cfa4873284 57
jmarkel44 0:65cfa4873284 58 // see cmd.h
jmarkel44 0:65cfa4873284 59 const command_table_t cmdlist[] = {
jmarkel44 0:65cfa4873284 60 {"?", "help command", cmd_help },
davidjhoward 116:7337ed514891 61 //{"create-control", "create a control", cmd_create },
jmarkel44 102:715f754cf5a8 62 {"cat", "cat a file", cmd_cat },
jmarkel44 37:7e6986b77f01 63 {"cif", "create a test input file", cmd_cif },
jmarkel44 96:807f04bd5256 64 {"cmf", "create a manual control file", cmd_cmf },
jmarkel44 161:500f03d11fc4 65 {"cmt", "create multiple timers", cmd_cmt },
jmarkel44 37:7e6986b77f01 66 {"cof", "create a test output file", cmd_cof },
jmarkel44 231:f22901955e0c 67 {"create-ca", "create a control algorithm file", cmd_createCAlg },
jmarkel44 220:dbe21411f962 68 {"create-comp", "craete a composite control file", cmd_createComposite },
jmarkel44 169:c503848823aa 69 {"create-mn", "create a manual control", cmd_createManual },
jmarkel44 169:c503848823aa 70 {"create-sp", "create a setpoint control", cmd_createSetpoint },
jmarkel44 169:c503848823aa 71 {"create-tm", "create a timer control", cmd_createTimer },
davidjhoward 186:16912aa18c2a 72 {"create-temp", "create temperature input", cmd_createTemp },
jmarkel44 158:36b5a9de58a1 73 {"deep", "dump EEP", cmd_deep },
jmarkel44 231:f22901955e0c 74 {"preload", "pre-load phase-1 demo files", cmd_preload },
jmarkel44 102:715f754cf5a8 75 {"destroy-control", "destroy a control", cmd_destroy },
jmarkel44 0:65cfa4873284 76 {"heap", "show heap statistics", cmd_heap },
jmarkel44 0:65cfa4873284 77 {"help", "help command", cmd_help },
jmarkel44 158:36b5a9de58a1 78 {"ins-log", "insert log event", cmd_inslog },
jmarkel44 36:f240f5a6d0ed 79 {"log-level", "get/set mDot log level", cmd_logLevel },
jmarkel44 14:cc916fa8dd11 80 {"ls", "list user files", cmd_ls },
jmarkel44 208:784c46652863 81 {"modify-mn", "modify a manual control", cmd_modifyManual },
jmarkel44 207:55aabde2d4bf 82 {"modify-sp", "modify a setpoint control", cmd_modifySetpoint },
davidjhoward 61:ae6dd6692c7d 83 {"modmap", "dump modbus register map", cmd_modmap },
davidjhoward 197:594afd088f32 84 {"mod-cmd", "send command to modbus master", cmd_modbusCmd },
jmarkel44 158:36b5a9de58a1 85 {"peep", "push EEP", cmd_peep },
davidjhoward 214:52ef35bc44ec 86 {"regcmd", "create command to execute on register", cmd_regcmd },
jmarkel44 0:65cfa4873284 87 {"reset", "reset the controller", cmd_reset },
jmarkel44 35:6235ef67faa1 88 {"reset-stats", "reset current mDot statistics", cmd_resetStats },
jmarkel44 14:cc916fa8dd11 89 {"rm", "remove a user file", cmd_rm },
jmarkel44 35:6235ef67faa1 90 {"rssi-stats", "get current rssi stats", cmd_rssiStats },
jmarkel44 102:715f754cf5a8 91 {"set-time", "set current time", cmd_settime },
jmarkel44 221:2a5e9902003c 92 {"show-ca", "show composite algorithms", cmd_ShowAlgorithms },
jmarkel44 35:6235ef67faa1 93 {"show-controls", "display active controls", cmd_ShowControls },
jmarkel44 86:189c125d8878 94 {"show-outputs", "dump outputs", cmd_outputs },
jmarkel44 35:6235ef67faa1 95 {"snr-stats", "get current SNR stats", cmd_snrStats },
jmarkel44 158:36b5a9de58a1 96 {"sout", "set output", cmd_sout },
jmarkel44 158:36b5a9de58a1 97 {"simin", "simulate input", cmd_simin },
jmarkel44 158:36b5a9de58a1 98 {"show-simin", "show simulated inputs", cmd_showSimin },
jmarkel44 36:f240f5a6d0ed 99 {"stack", "get thread stack usage stats", cmd_stack },
jmarkel44 18:9cf694a764c0 100 {"stats", "get current mDot statistics", cmd_stats },
jmarkel44 62:1b1d7918adf2 101 {"time", "get current time", cmd_time },
davidjhoward 179:a31ea334e2b7 102 {"simall", "simulate multiple inputs", cmd_simall },
davidjhoward 214:52ef35bc44ec 103 {"trim-temp", "adjust temperature from ICE Tube", cmd_trimTemp },
jmarkel44 0:65cfa4873284 104 {NULL, NULL, NULL}
jmarkel44 0:65cfa4873284 105 };
jmarkel44 0:65cfa4873284 106
jmarkel44 0:65cfa4873284 107 int func_read(char *buf, int cnt);
jmarkel44 0:65cfa4873284 108 int func_write(const char *buf, int cnt);
jmarkel44 0:65cfa4873284 109 int func_cb_ntshell(const char *text);
jmarkel44 0:65cfa4873284 110 void func_cb_ntopt(int argc, char **argv);
jmarkel44 0:65cfa4873284 111
jmarkel44 0:65cfa4873284 112 /**
jmarkel44 0:65cfa4873284 113 * Serial read function.
jmarkel44 0:65cfa4873284 114 */
jmarkel44 0:65cfa4873284 115 int func_read(char *buf, int cnt)
jmarkel44 0:65cfa4873284 116 {
jmarkel44 0:65cfa4873284 117 for (int i = 0; i < cnt; i++) {
jmarkel44 0:65cfa4873284 118 buf[i] = serial.getc();
jmarkel44 0:65cfa4873284 119 }
jmarkel44 0:65cfa4873284 120 return 0;
jmarkel44 0:65cfa4873284 121 }
jmarkel44 0:65cfa4873284 122
jmarkel44 0:65cfa4873284 123 /**
jmarkel44 0:65cfa4873284 124 * Serial write function.
jmarkel44 0:65cfa4873284 125 */
jmarkel44 0:65cfa4873284 126 int func_write(const char *buf, int cnt)
jmarkel44 0:65cfa4873284 127 {
jmarkel44 0:65cfa4873284 128 for (int i = 0; i < cnt; i++) {
jmarkel44 0:65cfa4873284 129 serial.putc(buf[i]);
jmarkel44 0:65cfa4873284 130 }
jmarkel44 0:65cfa4873284 131 return 0;
jmarkel44 0:65cfa4873284 132 }
jmarkel44 0:65cfa4873284 133
jmarkel44 0:65cfa4873284 134 /**
jmarkel44 0:65cfa4873284 135 * Callback function for ntshell module.
jmarkel44 0:65cfa4873284 136 */
jmarkel44 0:65cfa4873284 137 int func_cb_ntshell(const char *text)
jmarkel44 0:65cfa4873284 138 {
jmarkel44 0:65cfa4873284 139 return ntopt_parse(text, func_cb_ntopt);
jmarkel44 0:65cfa4873284 140 }
jmarkel44 0:65cfa4873284 141
jmarkel44 0:65cfa4873284 142 /**
jmarkel44 0:65cfa4873284 143 * Callback function for ntopt module.
jmarkel44 0:65cfa4873284 144 */
jmarkel44 0:65cfa4873284 145 void func_cb_ntopt(int argc, char **argv)
jmarkel44 0:65cfa4873284 146 {
jmarkel44 0:65cfa4873284 147 if (argc == 0) {
jmarkel44 0:65cfa4873284 148 return;
jmarkel44 0:65cfa4873284 149 }
jmarkel44 0:65cfa4873284 150 int execnt = 0;
jmarkel44 0:65cfa4873284 151 const command_table_t *p = &cmdlist[0];
jmarkel44 0:65cfa4873284 152 while (p->command != NULL) {
jmarkel44 0:65cfa4873284 153 if (strcmp(argv[0], p->command) == 0) {
jmarkel44 0:65cfa4873284 154 p->func(argc, argv);
jmarkel44 0:65cfa4873284 155 execnt++;
jmarkel44 0:65cfa4873284 156 }
jmarkel44 0:65cfa4873284 157 p++;
jmarkel44 0:65cfa4873284 158 }
jmarkel44 0:65cfa4873284 159 if (execnt == 0) {
jmarkel44 0:65cfa4873284 160 printf("Command not found.\r\n");
jmarkel44 0:65cfa4873284 161 }
jmarkel44 0:65cfa4873284 162 wait_ms(250);
jmarkel44 0:65cfa4873284 163 }
jmarkel44 0:65cfa4873284 164
jmarkel44 0:65cfa4873284 165 /************************* callback functions *******************************/
jmarkel44 35:6235ef67faa1 166
jmarkel44 102:715f754cf5a8 167 void cmd_cat(int argc, char **argv)
jmarkel44 102:715f754cf5a8 168 {
jmarkel44 102:715f754cf5a8 169 if ( argc != 2 ) {
jmarkel44 102:715f754cf5a8 170 printf("\rusage: cat <filename>\n");
jmarkel44 102:715f754cf5a8 171 return;
jmarkel44 102:715f754cf5a8 172 }
jmarkel44 113:001ad47df8ec 173 mDot::mdot_file file = GLOBAL_mdot->openUserFile(argv[1], mDot::FM_RDONLY);
jmarkel44 113:001ad47df8ec 174 if ( file.fd < 0 ) {
jmarkel44 113:001ad47df8ec 175 printf("\rFailed to open %s\n", argv[1]);
jmarkel44 113:001ad47df8ec 176 return;
jmarkel44 113:001ad47df8ec 177 }
jmarkel44 113:001ad47df8ec 178 char *data_buf = (char*) malloc(file.size);
jmarkel44 113:001ad47df8ec 179 bool rc = GLOBAL_mdot->readUserFile(file, data_buf, file.size);
jmarkel44 102:715f754cf5a8 180 if ( rc != true ) {
jmarkel44 102:715f754cf5a8 181 printf("\rFailed to read %s\n", argv[1]);
jmarkel44 113:001ad47df8ec 182 goto cleanup;
jmarkel44 102:715f754cf5a8 183 }
jmarkel44 102:715f754cf5a8 184 printf("%s\n", data_buf);
jmarkel44 113:001ad47df8ec 185
jmarkel44 113:001ad47df8ec 186 cleanup:
jmarkel44 113:001ad47df8ec 187 free(data_buf);
jmarkel44 113:001ad47df8ec 188 GLOBAL_mdot->closeUserFile(file);
jmarkel44 102:715f754cf5a8 189 }
jmarkel44 35:6235ef67faa1 190 /*****************************************************************************
jmarkel44 35:6235ef67faa1 191 * Function: cmd_help
jmarkel44 35:6235ef67faa1 192 * Description: displays the list of commands available
jmarkel44 35:6235ef67faa1 193 *
jmarkel44 35:6235ef67faa1 194 * @param argc (not used)
jmarkel44 35:6235ef67faa1 195 * @param argv (not used)
jmarkel44 35:6235ef67faa1 196 * @return none
jmarkel44 35:6235ef67faa1 197 *****************************************************************************/
jmarkel44 0:65cfa4873284 198 void cmd_help(int argc, char **argv)
jmarkel44 0:65cfa4873284 199 {
jmarkel44 0:65cfa4873284 200 UNUSED(argc);
jmarkel44 0:65cfa4873284 201 UNUSED(argv);
jmarkel44 0:65cfa4873284 202
jmarkel44 0:65cfa4873284 203 const command_table_t *tblPtr = cmdlist;
jmarkel44 0:65cfa4873284 204
jmarkel44 0:65cfa4873284 205 while (tblPtr->command) {
jmarkel44 0:65cfa4873284 206 printf("\r%-32s:\t%s\n", tblPtr->command, tblPtr->description);
jmarkel44 0:65cfa4873284 207 tblPtr++;
jmarkel44 0:65cfa4873284 208 }
jmarkel44 0:65cfa4873284 209 printf("\r\n");
jmarkel44 0:65cfa4873284 210 }
jmarkel44 0:65cfa4873284 211
jmarkel44 36:f240f5a6d0ed 212
jmarkel44 36:f240f5a6d0ed 213 /*****************************************************************************
jmarkel44 36:f240f5a6d0ed 214 * Function: cmd_logLevel
davidjhoward 41:e8946fc01ea4 215 * Description: get or set the current log-level
jmarkel44 36:f240f5a6d0ed 216 *
jmarkel44 36:f240f5a6d0ed 217 * @param argc (not used)
jmarkel44 36:f240f5a6d0ed 218 * @param argv (not used)
jmarkel44 36:f240f5a6d0ed 219 * @return none
jmarkel44 36:f240f5a6d0ed 220 *****************************************************************************/
jmarkel44 36:f240f5a6d0ed 221 void cmd_logLevel(int argc, char **argv)
jmarkel44 36:f240f5a6d0ed 222 {
jmarkel44 36:f240f5a6d0ed 223 uint8_t logLevel = 0;
davidjhoward 41:e8946fc01ea4 224
davidjhoward 41:e8946fc01ea4 225 const char *mapper[] = { "NONE",
davidjhoward 41:e8946fc01ea4 226 "FATAL",
davidjhoward 41:e8946fc01ea4 227 "ERROR",
davidjhoward 41:e8946fc01ea4 228 "WARNING",
davidjhoward 41:e8946fc01ea4 229 "INFO",
davidjhoward 41:e8946fc01ea4 230 "DEBUG",
davidjhoward 41:e8946fc01ea4 231 "TRACE"
davidjhoward 41:e8946fc01ea4 232 };
davidjhoward 41:e8946fc01ea4 233
jmarkel44 36:f240f5a6d0ed 234 if ( argc == 1 ) {
davidjhoward 41:e8946fc01ea4 235 printf("\r current log-level set to %s\r\n",
davidjhoward 41:e8946fc01ea4 236 mapper[GLOBAL_mdot->getLogLevel()]);
jmarkel44 36:f240f5a6d0ed 237 goto usage;
jmarkel44 36:f240f5a6d0ed 238 }
jmarkel44 36:f240f5a6d0ed 239
jmarkel44 36:f240f5a6d0ed 240 if ( argc != 2 ) {
jmarkel44 36:f240f5a6d0ed 241 usage:
jmarkel44 36:f240f5a6d0ed 242 printf("\rusage: log-level [0-6]\n");
jmarkel44 36:f240f5a6d0ed 243 printf("\r 0 = NONE\n");
jmarkel44 36:f240f5a6d0ed 244 printf("\r 1 = FATAL\n");
jmarkel44 36:f240f5a6d0ed 245 printf("\r 2 = ERROR\n");
jmarkel44 36:f240f5a6d0ed 246 printf("\r 3 = WARNING\n");
jmarkel44 36:f240f5a6d0ed 247 printf("\r 4 = INFO\n");
jmarkel44 36:f240f5a6d0ed 248 printf("\r 5 = DEBUG\n");
jmarkel44 36:f240f5a6d0ed 249 printf("\r 6 = TRACE\r\n");
jmarkel44 36:f240f5a6d0ed 250 return;
jmarkel44 36:f240f5a6d0ed 251 }
davidjhoward 41:e8946fc01ea4 252
jmarkel44 36:f240f5a6d0ed 253 logLevel = atoi(argv[1]);
davidjhoward 41:e8946fc01ea4 254 if ( logLevel > 6 )
jmarkel44 36:f240f5a6d0ed 255 goto usage;
davidjhoward 41:e8946fc01ea4 256
davidjhoward 41:e8946fc01ea4 257 // reassign the log level
jmarkel44 36:f240f5a6d0ed 258 printf("...setting log-level to %s\r\n", mapper[logLevel]);
davidjhoward 41:e8946fc01ea4 259 GLOBAL_mdot->setLogLevel(logLevel);
jmarkel44 36:f240f5a6d0ed 260 printf("\r\n");
jmarkel44 36:f240f5a6d0ed 261 }
jmarkel44 36:f240f5a6d0ed 262
jmarkel44 35:6235ef67faa1 263 /*****************************************************************************
jmarkel44 35:6235ef67faa1 264 * Function: cmd_ls
jmarkel44 36:f240f5a6d0ed 265 * Description: list the user files on flash
jmarkel44 35:6235ef67faa1 266 *
jmarkel44 35:6235ef67faa1 267 * @param argc (not used)
jmarkel44 35:6235ef67faa1 268 * @param argv (not used)
jmarkel44 35:6235ef67faa1 269 * @return none
jmarkel44 35:6235ef67faa1 270 *****************************************************************************/
jmarkel44 14:cc916fa8dd11 271 void cmd_ls(int argc, char **argv)
jmarkel44 14:cc916fa8dd11 272 {
jmarkel44 35:6235ef67faa1 273 UNUSED(argc);
jmarkel44 35:6235ef67faa1 274 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 275
jmarkel44 14:cc916fa8dd11 276 vector<mDot::mdot_file> userFiles;
jmarkel44 14:cc916fa8dd11 277 userFiles = GLOBAL_mdot->listUserFiles();
jmarkel44 14:cc916fa8dd11 278 vector<mDot::mdot_file>::iterator pos;
jmarkel44 18:9cf694a764c0 279
jmarkel44 14:cc916fa8dd11 280 for ( pos = userFiles.begin(); pos != userFiles.end(); ++pos ) {
jmarkel44 14:cc916fa8dd11 281 printf("\r %-33s %d\n", pos->name, pos->size);
jmarkel44 14:cc916fa8dd11 282 }
jmarkel44 14:cc916fa8dd11 283 printf("\r\n");
jmarkel44 14:cc916fa8dd11 284 }
jmarkel44 14:cc916fa8dd11 285
jmarkel44 35:6235ef67faa1 286 /*****************************************************************************
jmarkel44 35:6235ef67faa1 287 * Function: cmd_ShowControls
jmarkel44 36:f240f5a6d0ed 288 * Description: show active controls
jmarkel44 35:6235ef67faa1 289 *
jmarkel44 35:6235ef67faa1 290 * @param argc (not used)
jmarkel44 35:6235ef67faa1 291 * @param argv (not used)
jmarkel44 35:6235ef67faa1 292 * @return none
jmarkel44 35:6235ef67faa1 293 *****************************************************************************/
jmarkel44 0:65cfa4873284 294 void cmd_ShowControls(int argc, char **argv)
jmarkel44 0:65cfa4873284 295 {
jmarkel44 0:65cfa4873284 296 UNUSED(argc);
jmarkel44 0:65cfa4873284 297 UNUSED(argv);
jmarkel44 12:ea87887ca7ad 298 ConfigurationHandler_showControls();
jmarkel44 18:9cf694a764c0 299 printf("\r\n");
jmarkel44 18:9cf694a764c0 300
jmarkel44 0:65cfa4873284 301 }
jmarkel44 0:65cfa4873284 302
jmarkel44 221:2a5e9902003c 303 void cmd_ShowAlgorithms(int argc, char **argv)
jmarkel44 221:2a5e9902003c 304 {
jmarkel44 221:2a5e9902003c 305 UNUSED(argc);
jmarkel44 221:2a5e9902003c 306 UNUSED(argv);
jmarkel44 221:2a5e9902003c 307 ConfigurationHandler_showAlgorithms();
jmarkel44 221:2a5e9902003c 308 printf("\r\n");
jmarkel44 221:2a5e9902003c 309 }
jmarkel44 221:2a5e9902003c 310
jmarkel44 35:6235ef67faa1 311 /*****************************************************************************
jmarkel44 35:6235ef67faa1 312 * Function: cmd_reset
jmarkel44 36:f240f5a6d0ed 313 * Description: reset the cpu
jmarkel44 35:6235ef67faa1 314 *
jmarkel44 35:6235ef67faa1 315 * @param argc (not used)
jmarkel44 35:6235ef67faa1 316 * @param argv (not used)
jmarkel44 35:6235ef67faa1 317 * @return none
jmarkel44 35:6235ef67faa1 318 *****************************************************************************/
jmarkel44 0:65cfa4873284 319 void cmd_reset(int argc, char **argv)
jmarkel44 0:65cfa4873284 320 {
jmarkel44 0:65cfa4873284 321 UNUSED(argc);
jmarkel44 0:65cfa4873284 322 UNUSED(argv);
jmarkel44 18:9cf694a764c0 323 GLOBAL_mdot->resetCpu();
jmarkel44 0:65cfa4873284 324 }
jmarkel44 0:65cfa4873284 325
jmarkel44 35:6235ef67faa1 326 /*****************************************************************************
jmarkel44 35:6235ef67faa1 327 * Function: cmd_rm
jmarkel44 35:6235ef67faa1 328 * Description: removes a user file from flash
jmarkel44 35:6235ef67faa1 329 *
jmarkel44 35:6235ef67faa1 330 * @param argc-> number of args
jmarkel44 36:f240f5a6d0ed 331 * @param argv-> filename
jmarkel44 35:6235ef67faa1 332 * @return none
jmarkel44 35:6235ef67faa1 333 *****************************************************************************/
jmarkel44 14:cc916fa8dd11 334 void cmd_rm(int argc, char **argv)
jmarkel44 14:cc916fa8dd11 335 {
jmarkel44 18:9cf694a764c0 336 UNUSED(argc);
jmarkel44 14:cc916fa8dd11 337 UNUSED(argv);
jmarkel44 18:9cf694a764c0 338
jmarkel44 14:cc916fa8dd11 339 if ( argc != 2 ) {
jmarkel44 14:cc916fa8dd11 340 printf("\rusage: rm <filename>\n");
jmarkel44 14:cc916fa8dd11 341 return;
jmarkel44 14:cc916fa8dd11 342 }
jmarkel44 43:62de0e05ab6b 343 if ( strcmp(argv[1], "*") == 0 ) {
jmarkel44 43:62de0e05ab6b 344 vector<mDot::mdot_file> userFiles;
jmarkel44 43:62de0e05ab6b 345 userFiles = GLOBAL_mdot->listUserFiles();
jmarkel44 43:62de0e05ab6b 346 vector<mDot::mdot_file>::iterator pos;
jmarkel44 43:62de0e05ab6b 347 for ( pos = userFiles.begin(); pos != userFiles.end(); ++pos ) {
jmarkel44 43:62de0e05ab6b 348 GLOBAL_mdot->deleteUserFile(pos->name);
jmarkel44 43:62de0e05ab6b 349 }
jmarkel44 43:62de0e05ab6b 350 } else {
jmarkel44 43:62de0e05ab6b 351 GLOBAL_mdot->deleteUserFile(argv[1]);
jmarkel44 43:62de0e05ab6b 352 }
jmarkel44 14:cc916fa8dd11 353 }
jmarkel44 18:9cf694a764c0 354
jmarkel44 35:6235ef67faa1 355 /*****************************************************************************
jmarkel44 35:6235ef67faa1 356 * Function: cmd_create
jmarkel44 36:f240f5a6d0ed 357 * Description: create a control
jmarkel44 35:6235ef67faa1 358 *
jmarkel44 35:6235ef67faa1 359 * @param argc-> number of args
jmarkel44 35:6235ef67faa1 360 * @param argv-> control name, control type
jmarkel44 35:6235ef67faa1 361 * @return none
jmarkel44 35:6235ef67faa1 362 *****************************************************************************/
jmarkel44 0:65cfa4873284 363 void cmd_create(int argc, char **argv)
jmarkel44 0:65cfa4873284 364 {
jmarkel44 0:65cfa4873284 365 if ( argc != 3 ) {
jmarkel44 0:65cfa4873284 366 printf("\r\nusage: create [controlName] [controlType]\n");
jmarkel44 18:9cf694a764c0 367 printf("\rcontrolType-> 0=timer, 1=PID, 2=setpoint, 3=composite, 4=manual\r\n");
jmarkel44 0:65cfa4873284 368 return;
jmarkel44 0:65cfa4873284 369 }
jmarkel44 0:65cfa4873284 370 // send a message to the configuration handler to create the control
jmarkel44 0:65cfa4873284 371 Message_t *msg = MailBox.alloc();
jmarkel44 0:65cfa4873284 372 memset(msg, 0, sizeof(Message_t));
jmarkel44 0:65cfa4873284 373 msg->action = ACTION_CREATE;
jmarkel44 0:65cfa4873284 374 msg->control = (Control_t) atoi(argv[2]);
jmarkel44 0:65cfa4873284 375 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 0:65cfa4873284 376
jmarkel44 0:65cfa4873284 377 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 0:65cfa4873284 378 __func__, msg->controlFile, msg->control);
jmarkel44 0:65cfa4873284 379
jmarkel44 0:65cfa4873284 380 MailBox.put(msg);
jmarkel44 18:9cf694a764c0 381 printf("\r\n");
jmarkel44 0:65cfa4873284 382 return;
jmarkel44 0:65cfa4873284 383 }
jmarkel44 0:65cfa4873284 384
jmarkel44 35:6235ef67faa1 385 /*****************************************************************************
jmarkel44 35:6235ef67faa1 386 * Function: cmd_destroy
jmarkel44 36:f240f5a6d0ed 387 * Description: reset the cpu
jmarkel44 35:6235ef67faa1 388 *
jmarkel44 35:6235ef67faa1 389 * @param argc-> number of arguments
jmarkel44 36:f240f5a6d0ed 390 * @param argv-> control name, control type
jmarkel44 35:6235ef67faa1 391 * @return none
jmarkel44 35:6235ef67faa1 392 *****************************************************************************/
jmarkel44 0:65cfa4873284 393 void cmd_destroy(int argc, char **argv)
jmarkel44 0:65cfa4873284 394 {
jmarkel44 12:ea87887ca7ad 395 if ( argc != 3 ) {
jmarkel44 12:ea87887ca7ad 396 printf("\r\nusage: destroy [controlName] [controlType]\n");
jmarkel44 18:9cf694a764c0 397 printf("\rcontrolType-> 0=timer, 1=PID, 2=setpoint, 3=composite, 4=manual\r\n");
jmarkel44 0:65cfa4873284 398 return;
jmarkel44 0:65cfa4873284 399 }
jmarkel44 0:65cfa4873284 400
jmarkel44 0:65cfa4873284 401 // send a message to the configuration handler to destroy the control
jmarkel44 0:65cfa4873284 402 Message_t *msg = MailBox.alloc();
jmarkel44 0:65cfa4873284 403 memset(msg, 0, sizeof(Message_t));
jmarkel44 0:65cfa4873284 404 msg->action = ACTION_DESTROY;
jmarkel44 12:ea87887ca7ad 405 msg->control = (Control_t) atoi(argv[2]);
jmarkel44 0:65cfa4873284 406 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 0:65cfa4873284 407
jmarkel44 0:65cfa4873284 408 printf("%s: Sending a destroy request for control %s\r\n",
jmarkel44 0:65cfa4873284 409 __func__, msg->controlFile);
jmarkel44 0:65cfa4873284 410
jmarkel44 0:65cfa4873284 411 MailBox.put(msg);
jmarkel44 18:9cf694a764c0 412 printf("\r\n");
jmarkel44 0:65cfa4873284 413 return;
jmarkel44 0:65cfa4873284 414 }
jmarkel44 0:65cfa4873284 415
jmarkel44 221:2a5e9902003c 416 void cmd_creatCAlg(int argc, char **argv)
jmarkel44 221:2a5e9902003c 417 {
jmarkel44 231:f22901955e0c 418
jmarkel44 221:2a5e9902003c 419 }
jmarkel44 221:2a5e9902003c 420
jmarkel44 35:6235ef67faa1 421 /*****************************************************************************
jmarkel44 96:807f04bd5256 422 * Function: cmd_createSetpoint
jmarkel44 37:7e6986b77f01 423 * Description: create control file
jmarkel44 35:6235ef67faa1 424 *
jmarkel44 35:6235ef67faa1 425 * @param argc-> number of args
jmarkel44 36:f240f5a6d0ed 426 * @param argv-> filename
jmarkel44 35:6235ef67faa1 427 * @return none
jmarkel44 35:6235ef67faa1 428 *****************************************************************************/
jmarkel44 96:807f04bd5256 429 void cmd_createSetpoint(int argc, char **argv)
jmarkel44 18:9cf694a764c0 430 {
jmarkel44 169:c503848823aa 431 if ( argc != 8 ) {
jmarkel44 169:c503848823aa 432 printf("\rusage: create-sp <filename> <id> <input> <output> <sp> <dir> <tol>\n");
jmarkel44 169:c503848823aa 433 printf("\rexample: create-sp control_sp_1.json bd i_cond o_rly1 2000 1 15\n");
jmarkel44 18:9cf694a764c0 434 return;
jmarkel44 18:9cf694a764c0 435 }
jmarkel44 36:f240f5a6d0ed 436
jmarkel44 121:650205ffa656 437 if ( strncmp(argv[1], CONTROL_SP_STR, strlen(CONTROL_SP_STR)) != 0 ) {
jmarkel44 121:650205ffa656 438 printf("\rFilename must be prefixed with control_sp_*\n");
jmarkel44 121:650205ffa656 439 return;
jmarkel44 121:650205ffa656 440 }
jmarkel44 121:650205ffa656 441
jmarkel44 177:9ec90c8e3ce1 442 char data_buf[MAX_FILE_SIZE];
jmarkel44 36:f240f5a6d0ed 443 snprintf(data_buf, sizeof(data_buf),
jmarkel44 36:f240f5a6d0ed 444 "{ "
jmarkel44 89:55ac65d7f206 445 "\"id\": \"%s\", "
jmarkel44 96:807f04bd5256 446 "\"priority\": \"800\","
jmarkel44 89:55ac65d7f206 447 "\"input\": \"%s\", "
jmarkel44 89:55ac65d7f206 448 "\"output\": \"%s\", "
jmarkel44 169:c503848823aa 449 "\"setpoint\": \"%s\","
jmarkel44 96:807f04bd5256 450 "\"prodfact\": \"100\","
jmarkel44 93:1553fb156915 451 "\"actingDir\": \"%s\", "
jmarkel44 96:807f04bd5256 452 "\"halert\": \"115\","
jmarkel44 89:55ac65d7f206 453 "\"lalert\": \"85\", "
jmarkel44 96:807f04bd5256 454 "\"hfs\": \"130\","
davidjhoward 123:ce602c91a9c3 455 "\"lfs\": \"70\", "
jmarkel44 169:c503848823aa 456 "\"tol\": \"%s\" }", argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
jmarkel44 18:9cf694a764c0 457
jmarkel44 177:9ec90c8e3ce1 458 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 18:9cf694a764c0 459 if( status != true ) {
jmarkel44 18:9cf694a764c0 460 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 96:807f04bd5256 461 return;
jmarkel44 18:9cf694a764c0 462 }
davidjhoward 116:7337ed514891 463
davidjhoward 116:7337ed514891 464 // send a message to the configuration handler to create the control
jmarkel44 96:807f04bd5256 465 Message_t *msg = MailBox.alloc();
jmarkel44 96:807f04bd5256 466 memset(msg, 0, sizeof(Message_t));
jmarkel44 96:807f04bd5256 467 msg->action = ACTION_CREATE;
jmarkel44 96:807f04bd5256 468 msg->control = CONTROL_SETPOINT;
jmarkel44 96:807f04bd5256 469 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 96:807f04bd5256 470
jmarkel44 96:807f04bd5256 471 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 96:807f04bd5256 472 __func__, msg->controlFile, msg->control);
jmarkel44 96:807f04bd5256 473
jmarkel44 96:807f04bd5256 474 MailBox.put(msg);
jmarkel44 96:807f04bd5256 475 printf("\r\n");
jmarkel44 96:807f04bd5256 476 return;
jmarkel44 18:9cf694a764c0 477 }
jmarkel44 18:9cf694a764c0 478
jmarkel44 35:6235ef67faa1 479 /*****************************************************************************
jmarkel44 122:4db48b933115 480 * Function: cmd_createTimer
jmarkel44 122:4db48b933115 481 * Description: create control file
jmarkel44 122:4db48b933115 482 *
jmarkel44 122:4db48b933115 483 * @param argc-> number of args
jmarkel44 122:4db48b933115 484 * @param argv-> filename
jmarkel44 122:4db48b933115 485 * @return none
jmarkel44 122:4db48b933115 486 *****************************************************************************/
jmarkel44 122:4db48b933115 487 void cmd_createTimer(int argc, char **argv)
jmarkel44 122:4db48b933115 488 {
jmarkel44 133:c871de2d2b90 489 if ( argc != 6 ) {
jmarkel44 133:c871de2d2b90 490 printf("\rusage: create-timer <filename> <id> <output> <priority> <duration>\n");
jmarkel44 133:c871de2d2b90 491 printf("\rexample: create-timer control_tm_1.json timer-1 o_rly1 750 60\n");
jmarkel44 132:45821e189dd0 492 printf("\r <startTime> is epoch time\n");
jmarkel44 132:45821e189dd0 493 printf("\r <duration> is in seconds\r\n");
jmarkel44 122:4db48b933115 494 return;
jmarkel44 122:4db48b933115 495 }
jmarkel44 122:4db48b933115 496
jmarkel44 122:4db48b933115 497 if ( strncmp(argv[1], CONTROL_TM_STR, strlen(CONTROL_TM_STR)) != 0 ) {
jmarkel44 122:4db48b933115 498 printf("\rFilename must be prefixed with control_tm_*\n");
jmarkel44 122:4db48b933115 499 return;
jmarkel44 122:4db48b933115 500 }
davidjhoward 149:950c90425f7c 501
jmarkel44 133:c871de2d2b90 502 char time_buf[32];
jmarkel44 133:c871de2d2b90 503 sprintf(time_buf, "%lu", time(NULL)+5);
jmarkel44 122:4db48b933115 504
jmarkel44 177:9ec90c8e3ce1 505 char data_buf[MAX_FILE_SIZE];
jmarkel44 122:4db48b933115 506 snprintf(data_buf, sizeof(data_buf),
jmarkel44 122:4db48b933115 507 "{ "
jmarkel44 122:4db48b933115 508 "\"id\": \"%s\", "
jmarkel44 122:4db48b933115 509 "\"output\": \"%s\", "
jmarkel44 132:45821e189dd0 510 "\"priority\": \"%s\", "
jmarkel44 132:45821e189dd0 511 "\"starttime\": \"%s\", "
jmarkel44 161:500f03d11fc4 512 "\"duration\": \"%s\" ", argv[2], argv[3], argv[4], time_buf, argv[5]
davidjhoward 149:950c90425f7c 513 );
davidjhoward 149:950c90425f7c 514
jmarkel44 122:4db48b933115 515
jmarkel44 177:9ec90c8e3ce1 516 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 122:4db48b933115 517 if( status != true ) {
jmarkel44 122:4db48b933115 518 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 122:4db48b933115 519 return;
jmarkel44 122:4db48b933115 520 }
davidjhoward 149:950c90425f7c 521
jmarkel44 122:4db48b933115 522 // send a message to the configuration handler to create the control
jmarkel44 122:4db48b933115 523 Message_t *msg = MailBox.alloc();
jmarkel44 122:4db48b933115 524 memset(msg, 0, sizeof(Message_t));
jmarkel44 122:4db48b933115 525 msg->action = ACTION_CREATE;
jmarkel44 122:4db48b933115 526 msg->control = CONTROL_TIMER;
jmarkel44 122:4db48b933115 527 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 122:4db48b933115 528
jmarkel44 122:4db48b933115 529 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 122:4db48b933115 530 __func__, msg->controlFile, msg->control);
jmarkel44 122:4db48b933115 531
jmarkel44 122:4db48b933115 532 MailBox.put(msg);
jmarkel44 122:4db48b933115 533 printf("\r\n");
jmarkel44 122:4db48b933115 534 return;
jmarkel44 122:4db48b933115 535
jmarkel44 122:4db48b933115 536 }
jmarkel44 122:4db48b933115 537
jmarkel44 161:500f03d11fc4 538 void cmd_cmt(int argc, char **argv)
jmarkel44 161:500f03d11fc4 539 {
jmarkel44 161:500f03d11fc4 540 char time_buf[32];
jmarkel44 161:500f03d11fc4 541 unsigned int counter = 0;
jmarkel44 161:500f03d11fc4 542 char filename[32];
jmarkel44 161:500f03d11fc4 543 Message_t *msg;
jmarkel44 161:500f03d11fc4 544
jmarkel44 161:500f03d11fc4 545 for ( counter = 0; counter < 5; counter++ ) {
jmarkel44 161:500f03d11fc4 546 // stuff the file
jmarkel44 161:500f03d11fc4 547 sprintf(time_buf, "%lu", time(NULL)+5 + (40 * counter));
jmarkel44 177:9ec90c8e3ce1 548 char data_buf[MAX_FILE_SIZE];
jmarkel44 161:500f03d11fc4 549 snprintf(data_buf, sizeof(data_buf),
jmarkel44 161:500f03d11fc4 550 "{ "
jmarkel44 161:500f03d11fc4 551 "\"id\": \"timer-%d\", "
jmarkel44 161:500f03d11fc4 552 "\"output\": \"o_rly1\", "
jmarkel44 161:500f03d11fc4 553 "\"priority\": \"750\", "
jmarkel44 161:500f03d11fc4 554 "\"starttime\": \"%s\", "
jmarkel44 161:500f03d11fc4 555 "\"duration\": \"30\" ", counter, time_buf);
jmarkel44 161:500f03d11fc4 556
jmarkel44 161:500f03d11fc4 557 sprintf(filename, "control_tm_%d_rly1.json", counter);
jmarkel44 161:500f03d11fc4 558
jmarkel44 177:9ec90c8e3ce1 559 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 161:500f03d11fc4 560 msg = MailBox.alloc();
jmarkel44 161:500f03d11fc4 561 memset(msg, 0, sizeof(Message_t));
jmarkel44 161:500f03d11fc4 562 msg->action = ACTION_CREATE;
jmarkel44 161:500f03d11fc4 563 msg->control = CONTROL_TIMER;
jmarkel44 161:500f03d11fc4 564 strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);
jmarkel44 161:500f03d11fc4 565
jmarkel44 161:500f03d11fc4 566 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 161:500f03d11fc4 567 __func__, msg->controlFile, msg->control);
jmarkel44 161:500f03d11fc4 568
jmarkel44 161:500f03d11fc4 569 MailBox.put(msg);
jmarkel44 161:500f03d11fc4 570 Thread::wait(1000);
jmarkel44 161:500f03d11fc4 571 }
jmarkel44 161:500f03d11fc4 572
jmarkel44 161:500f03d11fc4 573 for ( counter = 0; counter < 5; counter++ ) {
jmarkel44 161:500f03d11fc4 574 // stuff the file
jmarkel44 161:500f03d11fc4 575 sprintf(time_buf, "%lu", time(NULL)+5 + (40 * counter));
jmarkel44 177:9ec90c8e3ce1 576 char data_buf[MAX_FILE_SIZE];
jmarkel44 161:500f03d11fc4 577 snprintf(data_buf, sizeof(data_buf),
jmarkel44 161:500f03d11fc4 578 "{ "
jmarkel44 161:500f03d11fc4 579 "\"id\": \"timer-%d\", "
jmarkel44 161:500f03d11fc4 580 "\"output\": \"o_rly2\", "
jmarkel44 161:500f03d11fc4 581 "\"priority\": \"750\", "
jmarkel44 161:500f03d11fc4 582 "\"starttime\": \"%s\", "
jmarkel44 161:500f03d11fc4 583 "\"duration\": \"30\" ", counter, time_buf);
jmarkel44 161:500f03d11fc4 584
jmarkel44 161:500f03d11fc4 585 sprintf(filename, "control_tm_%d_rly2.json", counter);
jmarkel44 161:500f03d11fc4 586
jmarkel44 177:9ec90c8e3ce1 587 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 161:500f03d11fc4 588 msg = MailBox.alloc();
jmarkel44 161:500f03d11fc4 589 memset(msg, 0, sizeof(Message_t));
jmarkel44 161:500f03d11fc4 590 msg->action = ACTION_CREATE;
jmarkel44 161:500f03d11fc4 591 msg->control = CONTROL_TIMER;
jmarkel44 161:500f03d11fc4 592 strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);
jmarkel44 161:500f03d11fc4 593
jmarkel44 161:500f03d11fc4 594 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 161:500f03d11fc4 595 __func__, msg->controlFile, msg->control);
jmarkel44 161:500f03d11fc4 596
jmarkel44 161:500f03d11fc4 597 MailBox.put(msg);
jmarkel44 161:500f03d11fc4 598 Thread::wait(1000);
jmarkel44 161:500f03d11fc4 599 }
jmarkel44 161:500f03d11fc4 600 }
jmarkel44 161:500f03d11fc4 601
jmarkel44 221:2a5e9902003c 602 void cmd_createCAlg(int argc, char **argv)
jmarkel44 221:2a5e9902003c 603 {
jmarkel44 230:11765008ff3a 604 if ( argc != 1 ) {
jmarkel44 221:2a5e9902003c 605 printf("\rusage: create-ca control_ca_equal.json");
jmarkel44 221:2a5e9902003c 606 return;
jmarkel44 221:2a5e9902003c 607 }
jmarkel44 231:f22901955e0c 608
jmarkel44 231:f22901955e0c 609 char buf[MAX_FILE_SIZE];
jmarkel44 231:f22901955e0c 610 std::string filename = "control_ca_eq1.json";
jmarkel44 231:f22901955e0c 611 snprintf(buf, sizeof(buf),
jmarkel44 231:f22901955e0c 612 "{"
jmarkel44 231:f22901955e0c 613 "\"id\": \"EQUAL_TO_1\", "
jmarkel44 231:f22901955e0c 614 "\"opr\": \"1\", "
jmarkel44 231:f22901955e0c 615 "\"op\": \"==\", "
jmarkel44 231:f22901955e0c 616 "\"true\": \"responseA\", "
jmarkel44 231:f22901955e0c 617 "\"false\": \"nothing\" "
jmarkel44 231:f22901955e0c 618 "}");
jmarkel44 231:f22901955e0c 619
jmarkel44 231:f22901955e0c 620 bool rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 621 if ( rc != true ) {
jmarkel44 231:f22901955e0c 622 printf("\rFailed to save user file %s\n", filename.c_str());
jmarkel44 221:2a5e9902003c 623 return;
jmarkel44 231:f22901955e0c 624 } else {
jmarkel44 231:f22901955e0c 625 printf("\r...generated %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 626 }
jmarkel44 231:f22901955e0c 627
jmarkel44 221:2a5e9902003c 628 // send a message to the configuration handler to create the control
jmarkel44 221:2a5e9902003c 629 Message_t *msg = MailBox.alloc();
jmarkel44 221:2a5e9902003c 630 memset(msg, 0, sizeof(Message_t));
jmarkel44 221:2a5e9902003c 631 msg->action = ACTION_CREATE;
jmarkel44 221:2a5e9902003c 632 msg->control = CONTROL_ALGORITHM;
jmarkel44 231:f22901955e0c 633 strncpy(msg->controlFile, filename.c_str(), sizeof(msg->controlFile)-1);
jmarkel44 231:f22901955e0c 634
jmarkel44 230:11765008ff3a 635 MailBox.put(msg);
jmarkel44 231:f22901955e0c 636
jmarkel44 230:11765008ff3a 637 Thread::wait(2000);
jmarkel44 231:f22901955e0c 638
jmarkel44 231:f22901955e0c 639 // == 129
jmarkel44 231:f22901955e0c 640 filename = "control_ca_eq129.json";
jmarkel44 231:f22901955e0c 641 snprintf(buf, sizeof(buf),
jmarkel44 231:f22901955e0c 642 "{"
jmarkel44 231:f22901955e0c 643 "\"id\": \"EQUAL_TO_1\", "
jmarkel44 231:f22901955e0c 644 "\"opr\": \"1\", "
jmarkel44 231:f22901955e0c 645 "\"op\": \"==\", "
jmarkel44 231:f22901955e0c 646 "\"true\": \"responseA\", "
jmarkel44 231:f22901955e0c 647 "\"false\": \"nothing\" "
jmarkel44 231:f22901955e0c 648 "}");
jmarkel44 231:f22901955e0c 649
jmarkel44 231:f22901955e0c 650 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 651 if ( rc != true ) {
jmarkel44 231:f22901955e0c 652 printf("\rFailed to save user file %s\n", filename.c_str());
jmarkel44 230:11765008ff3a 653 return;
jmarkel44 231:f22901955e0c 654 } else {
jmarkel44 231:f22901955e0c 655 printf("\r...generated %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 656 }
jmarkel44 231:f22901955e0c 657
jmarkel44 230:11765008ff3a 658 // send a message to the configuration handler to create the control
jmarkel44 230:11765008ff3a 659 msg = MailBox.alloc();
jmarkel44 230:11765008ff3a 660 memset(msg, 0, sizeof(Message_t));
jmarkel44 230:11765008ff3a 661 msg->action = ACTION_CREATE;
jmarkel44 230:11765008ff3a 662 msg->control = CONTROL_ALGORITHM;
jmarkel44 230:11765008ff3a 663 strncpy(msg->controlFile, "control_ca_greq1.json", sizeof(msg->controlFile)-1);
jmarkel44 221:2a5e9902003c 664
jmarkel44 221:2a5e9902003c 665 MailBox.put(msg);
jmarkel44 221:2a5e9902003c 666 }
jmarkel44 221:2a5e9902003c 667
jmarkel44 220:dbe21411f962 668 void cmd_createComposite(int argc, char **argv)
jmarkel44 220:dbe21411f962 669 {
jmarkel44 230:11765008ff3a 670 if ( argc != 1 ) {
jmarkel44 230:11765008ff3a 671 printf("\rusage: create-comp");
jmarkel44 220:dbe21411f962 672 return;
jmarkel44 220:dbe21411f962 673 }
jmarkel44 231:f22901955e0c 674
jmarkel44 230:11765008ff3a 675 char data_buf[MAX_FILE_SIZE];
jmarkel44 230:11765008ff3a 676 bool status;
jmarkel44 230:11765008ff3a 677 Message_t *msg = NULL;
jmarkel44 220:dbe21411f962 678
jmarkel44 231:f22901955e0c 679 #if 1
jmarkel44 230:11765008ff3a 680 // FLOW
jmarkel44 220:dbe21411f962 681 snprintf(data_buf, sizeof(data_buf),
jmarkel44 220:dbe21411f962 682 "{ "
jmarkel44 229:0d6755d765fd 683 "\"id\": \"FLOW_OVERRIDE\", "
jmarkel44 229:0d6755d765fd 684 "\"tag\": \"i_flowsw01\", "
jmarkel44 229:0d6755d765fd 685 "\"ca\": \"EQUAL_TO_1\", "
jmarkel44 229:0d6755d765fd 686 "\"priority\": \"400\", "
jmarkel44 231:f22901955e0c 687 "\"entries\": \"2\", "
jmarkel44 220:dbe21411f962 688 "\"outputs\": [ "
jmarkel44 220:dbe21411f962 689 "{"
jmarkel44 231:f22901955e0c 690 "\"tag\": \"o_rly01\", "
jmarkel44 231:f22901955e0c 691 "\"responseA\": \"fixed off\" "
jmarkel44 220:dbe21411f962 692 "},"
jmarkel44 220:dbe21411f962 693 "{"
jmarkel44 231:f22901955e0c 694 "\"tag\": \"o_rly02\", "
jmarkel44 231:f22901955e0c 695 "\"responseA\": \"fixed off\" "
jmarkel44 220:dbe21411f962 696 "}"
jmarkel44 220:dbe21411f962 697 "]"
jmarkel44 220:dbe21411f962 698 "}"
jmarkel44 231:f22901955e0c 699 );
jmarkel44 231:f22901955e0c 700 status = GLOBAL_mdot->saveUserFile("control_comp_flow.json", (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 701 if ( status != true ) {
jmarkel44 230:11765008ff3a 702 printf("\rFailed to save user file control_comp_flow.json\n");
jmarkel44 220:dbe21411f962 703 return;
jmarkel44 220:dbe21411f962 704 }
jmarkel44 231:f22901955e0c 705
jmarkel44 220:dbe21411f962 706 // send a message to the configuration handler to create the control
jmarkel44 230:11765008ff3a 707 msg = MailBox.alloc();
jmarkel44 220:dbe21411f962 708 memset(msg, 0, sizeof(Message_t));
jmarkel44 220:dbe21411f962 709 msg->action = ACTION_CREATE;
jmarkel44 220:dbe21411f962 710 msg->control = CONTROL_COMPOSITE;
jmarkel44 230:11765008ff3a 711 strncpy(msg->controlFile, "control_comp_flow.json", sizeof(msg->controlFile)-1);
jmarkel44 231:f22901955e0c 712
jmarkel44 230:11765008ff3a 713 printf("\rDEBUG: sending a request for composite control %s\n", msg->controlFile);
jmarkel44 220:dbe21411f962 714
jmarkel44 230:11765008ff3a 715 MailBox.put(msg);
jmarkel44 231:f22901955e0c 716
jmarkel44 230:11765008ff3a 717 Thread::wait(2000);
jmarkel44 231:f22901955e0c 718
jmarkel44 231:f22901955e0c 719 #endif
jmarkel44 231:f22901955e0c 720
jmarkel44 230:11765008ff3a 721 // LOCKOUT
jmarkel44 230:11765008ff3a 722 snprintf(data_buf, sizeof(data_buf),
jmarkel44 230:11765008ff3a 723 "{ "
jmarkel44 230:11765008ff3a 724 "\"id\": \"LOCKOUT_BLOWDOWN\", "
jmarkel44 230:11765008ff3a 725 "\"tag\": \"o_rly01\", "
jmarkel44 230:11765008ff3a 726 "\"ca\": \"EQUAL_TO_129\", "
jmarkel44 230:11765008ff3a 727 "\"priority\": \"400\", "
jmarkel44 231:f22901955e0c 728 "\"entries\": \"1\", "
jmarkel44 230:11765008ff3a 729 "\"outputs\": [ "
jmarkel44 230:11765008ff3a 730 "{"
jmarkel44 231:f22901955e0c 731 "\"tag\": \"o_rly02\", "
jmarkel44 231:f22901955e0c 732 "\"responseA\": \"fixed off\" "
jmarkel44 230:11765008ff3a 733 "}"
jmarkel44 230:11765008ff3a 734 "]"
jmarkel44 230:11765008ff3a 735 "}"
jmarkel44 231:f22901955e0c 736 );
jmarkel44 230:11765008ff3a 737 status = GLOBAL_mdot->saveUserFile("control_comp_lockout.json", (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 230:11765008ff3a 738 if ( status != true ) {
jmarkel44 230:11765008ff3a 739 printf("\rFailed to save user file control_comp_lockout.json\n");
jmarkel44 230:11765008ff3a 740 return;
jmarkel44 230:11765008ff3a 741 }
jmarkel44 231:f22901955e0c 742
jmarkel44 230:11765008ff3a 743 // send a message to the configuration handler to create the control
jmarkel44 230:11765008ff3a 744 msg = MailBox.alloc();
jmarkel44 230:11765008ff3a 745 memset(msg, 0, sizeof(Message_t));
jmarkel44 230:11765008ff3a 746 msg->action = ACTION_CREATE;
jmarkel44 230:11765008ff3a 747 msg->control = CONTROL_COMPOSITE;
jmarkel44 230:11765008ff3a 748 strncpy(msg->controlFile, "control_comp_lockout.json", sizeof(msg->controlFile)-1);
jmarkel44 231:f22901955e0c 749
jmarkel44 230:11765008ff3a 750 printf("\rDEBUG: sending a request for composite control %s\n", msg->controlFile);
jmarkel44 220:dbe21411f962 751
jmarkel44 220:dbe21411f962 752 MailBox.put(msg);
jmarkel44 220:dbe21411f962 753 }
jmarkel44 220:dbe21411f962 754
jmarkel44 122:4db48b933115 755 /*****************************************************************************
jmarkel44 97:5cf6ab71dcd0 756 * Function: cmd_createManual
jmarkel44 97:5cf6ab71dcd0 757 * Description: create a manual control
jmarkel44 97:5cf6ab71dcd0 758 *
jmarkel44 97:5cf6ab71dcd0 759 * @param argc-> number of args
jmarkel44 97:5cf6ab71dcd0 760 * @param argv-> filename
jmarkel44 97:5cf6ab71dcd0 761 * @return none
jmarkel44 97:5cf6ab71dcd0 762 *****************************************************************************/
jmarkel44 97:5cf6ab71dcd0 763 void cmd_createManual(int argc, char **argv)
jmarkel44 97:5cf6ab71dcd0 764 {
jmarkel44 212:289f63158d2b 765 std::string relayState;
jmarkel44 98:8eab18d03ac2 766 if ( argc != 5 ) {
jmarkel44 98:8eab18d03ac2 767 printf("\rusage: create-manual <filename> <id> <output> <state>\n");
jmarkel44 98:8eab18d03ac2 768 printf("\rexample: create-manual control_mn_1.json man-1 o_rly1 1\r\n");
jmarkel44 97:5cf6ab71dcd0 769 return;
jmarkel44 97:5cf6ab71dcd0 770 }
jmarkel44 220:dbe21411f962 771
jmarkel44 212:289f63158d2b 772 string state(argv[4]);
jmarkel44 97:5cf6ab71dcd0 773
jmarkel44 212:289f63158d2b 774 if ( state == "on" ) {
jmarkel44 212:289f63158d2b 775 relayState = "1";
jmarkel44 212:289f63158d2b 776 } else if ( state == "off" ) {
jmarkel44 212:289f63158d2b 777 relayState = "0";
jmarkel44 212:289f63158d2b 778 } else {
jmarkel44 212:289f63158d2b 779 printf("\r<state> must be on or off\r\n");
jmarkel44 212:289f63158d2b 780 return;
jmarkel44 212:289f63158d2b 781 }
jmarkel44 220:dbe21411f962 782
jmarkel44 177:9ec90c8e3ce1 783 char data_buf[MAX_FILE_SIZE];
jmarkel44 97:5cf6ab71dcd0 784 snprintf(data_buf, sizeof(data_buf),
jmarkel44 97:5cf6ab71dcd0 785 "{ "
jmarkel44 98:8eab18d03ac2 786 "\"id\": \"%s\", "
jmarkel44 98:8eab18d03ac2 787 "\"output\": \"%s\", "
jmarkel44 98:8eab18d03ac2 788 "\"type\": \"1\", "
jmarkel44 97:5cf6ab71dcd0 789 "\"priority\": \"100\", "
jmarkel44 98:8eab18d03ac2 790 "\"duration\": \"0\", "
jmarkel44 98:8eab18d03ac2 791 "\"setpoint\": \"0\", "
jmarkel44 212:289f63158d2b 792 "\"state\": \"%s\", "
jmarkel44 212:289f63158d2b 793 "\"percent\": \"100\" }", argv[2], argv[3], relayState.c_str()
jmarkel44 97:5cf6ab71dcd0 794 );
jmarkel44 97:5cf6ab71dcd0 795
jmarkel44 177:9ec90c8e3ce1 796 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 97:5cf6ab71dcd0 797 if( status != true ) {
jmarkel44 97:5cf6ab71dcd0 798 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 97:5cf6ab71dcd0 799 return;
jmarkel44 97:5cf6ab71dcd0 800 }
davidjhoward 116:7337ed514891 801
davidjhoward 116:7337ed514891 802 // send a message to the configuration handler to create the control
jmarkel44 97:5cf6ab71dcd0 803 Message_t *msg = MailBox.alloc();
jmarkel44 97:5cf6ab71dcd0 804 memset(msg, 0, sizeof(Message_t));
jmarkel44 97:5cf6ab71dcd0 805 msg->action = ACTION_CREATE;
jmarkel44 97:5cf6ab71dcd0 806 msg->control = CONTROL_MANUAL;
jmarkel44 97:5cf6ab71dcd0 807 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 97:5cf6ab71dcd0 808
jmarkel44 97:5cf6ab71dcd0 809 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 97:5cf6ab71dcd0 810 __func__, msg->controlFile, msg->control);
jmarkel44 97:5cf6ab71dcd0 811
jmarkel44 97:5cf6ab71dcd0 812 MailBox.put(msg);
jmarkel44 97:5cf6ab71dcd0 813 printf("\r\n");
jmarkel44 97:5cf6ab71dcd0 814 return;
jmarkel44 97:5cf6ab71dcd0 815 }
jmarkel44 97:5cf6ab71dcd0 816
jmarkel44 97:5cf6ab71dcd0 817 /*****************************************************************************
jmarkel44 37:7e6986b77f01 818 * Function: cmd_cif
jmarkel44 37:7e6986b77f01 819 * Description: create input file
jmarkel44 37:7e6986b77f01 820 *
jmarkel44 37:7e6986b77f01 821 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 822 * @param argv-> filename
jmarkel44 37:7e6986b77f01 823 * @return none
jmarkel44 37:7e6986b77f01 824 *****************************************************************************/
jmarkel44 37:7e6986b77f01 825 void cmd_cif(int argc, char **argv)
jmarkel44 37:7e6986b77f01 826 {
jmarkel44 169:c503848823aa 827 if ( argc != 6 ) {
jmarkel44 169:c503848823aa 828 printf("\rusage: cif <fname> <input> <name> <node> <reg>\n");
jmarkel44 169:c503848823aa 829 printf("\rexample: cif input_i_tra01.json i_tra01 Trasar 5 2\n");
jmarkel44 37:7e6986b77f01 830 return;
jmarkel44 37:7e6986b77f01 831 }
jmarkel44 37:7e6986b77f01 832
jmarkel44 177:9ec90c8e3ce1 833 char data_buf[MAX_FILE_SIZE];
jmarkel44 37:7e6986b77f01 834 snprintf(data_buf, sizeof(data_buf),
jmarkel44 37:7e6986b77f01 835 "{ "
jmarkel44 121:650205ffa656 836 "\"id\": \"%s\", "
jmarkel44 169:c503848823aa 837 "\"name\": \"%s\", "
jmarkel44 37:7e6986b77f01 838 "\"units\": \"PPM\", "
jmarkel44 37:7e6986b77f01 839 "\"min\": \"0\", "
jmarkel44 37:7e6986b77f01 840 "\"max\": \"300\", "
jmarkel44 169:c503848823aa 841 "\"node\": \"%s\", "
jmarkel44 169:c503848823aa 842 "\"reg\": \"%s\", "
jmarkel44 37:7e6986b77f01 843 "\"rtype\": \"1\", "
davidjhoward 54:ec1b03064bbd 844 "\"type\": \"0\", "
davidjhoward 41:e8946fc01ea4 845 "\"size\": \"2\", "
davidjhoward 41:e8946fc01ea4 846 "\"order\": \"2\", "
davidjhoward 41:e8946fc01ea4 847 "\"rfreq\": \"5\", "
jmarkel44 169:c503848823aa 848 "\"fmt\": \"%%.2f\" } ", argv[2], argv[3], argv[4], argv[5]);
jmarkel44 37:7e6986b77f01 849
jmarkel44 177:9ec90c8e3ce1 850 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 37:7e6986b77f01 851 if( status != true ) {
jmarkel44 37:7e6986b77f01 852 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 853 }
davidjhoward 41:e8946fc01ea4 854
davidjhoward 42:c703a60993b1 855 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", argv[1]);
davidjhoward 41:e8946fc01ea4 856 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 41:e8946fc01ea4 857 mail->action = ACTION_READ_FILE;
davidjhoward 41:e8946fc01ea4 858 strncpy( mail->controlFile, argv[1], (sizeof(mail->controlFile)-1));
davidjhoward 41:e8946fc01ea4 859 ModbusMasterMailBox.put(mail);
jmarkel44 37:7e6986b77f01 860 }
jmarkel44 37:7e6986b77f01 861
jmarkel44 37:7e6986b77f01 862 /*****************************************************************************
jmarkel44 96:807f04bd5256 863 * Function: cmd_cmf
jmarkel44 96:807f04bd5256 864 * Description: create manual control file
jmarkel44 96:807f04bd5256 865 *
jmarkel44 96:807f04bd5256 866 * @param argc-> number of args
jmarkel44 96:807f04bd5256 867 * @param argv-> filename
jmarkel44 96:807f04bd5256 868 * @return none
jmarkel44 96:807f04bd5256 869 *****************************************************************************/
jmarkel44 96:807f04bd5256 870 void cmd_cmf(int argc, char **argv)
jmarkel44 96:807f04bd5256 871 {
jmarkel44 96:807f04bd5256 872 if ( argc != 2 ) {
jmarkel44 96:807f04bd5256 873 printf("\rusage: cmf <filename> <relay\r\n");
jmarkel44 96:807f04bd5256 874 printf("\rexmaple: cmd control_mn_1.json o_rly1");
jmarkel44 96:807f04bd5256 875 return;
jmarkel44 96:807f04bd5256 876 }
jmarkel44 96:807f04bd5256 877
jmarkel44 177:9ec90c8e3ce1 878 char data_buf[MAX_FILE_SIZE];
jmarkel44 96:807f04bd5256 879 snprintf(data_buf, sizeof(data_buf),
jmarkel44 96:807f04bd5256 880 "{ "
jmarkel44 96:807f04bd5256 881 "\"id\": \"%s\", "
jmarkel44 96:807f04bd5256 882 "\"type\": \"1\", "
jmarkel44 96:807f04bd5256 883 "\"priority\": \"100\", "
jmarkel44 96:807f04bd5256 884 "\"duration\": \"30\", " // seconds
jmarkel44 96:807f04bd5256 885 "\"setpoint\": \"2000.0\", "
jmarkel44 96:807f04bd5256 886 "\"state\": \"1\", "
jmarkel44 113:001ad47df8ec 887 "\"percent\": \"100\", }", argv[2]
jmarkel44 96:807f04bd5256 888 );
jmarkel44 96:807f04bd5256 889
jmarkel44 177:9ec90c8e3ce1 890 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 96:807f04bd5256 891 if( status != true ) {
jmarkel44 96:807f04bd5256 892 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 96:807f04bd5256 893 }
jmarkel44 96:807f04bd5256 894 }
jmarkel44 96:807f04bd5256 895
jmarkel44 96:807f04bd5256 896
jmarkel44 96:807f04bd5256 897 /*****************************************************************************
jmarkel44 37:7e6986b77f01 898 * Function: cmd_cof
jmarkel44 37:7e6986b77f01 899 * Description: create output file
jmarkel44 37:7e6986b77f01 900 *
jmarkel44 37:7e6986b77f01 901 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 902 * @param argv-> filename
jmarkel44 37:7e6986b77f01 903 * @return none
jmarkel44 37:7e6986b77f01 904 *****************************************************************************/
jmarkel44 37:7e6986b77f01 905 void cmd_cof(int argc, char **argv)
jmarkel44 37:7e6986b77f01 906 {
davidjhoward 81:d45bfa16953a 907 if ( argc != 5 ) {
davidjhoward 81:d45bfa16953a 908 printf("\rusage: cof <filename> <output> <name> <reg>\r\n");
davidjhoward 81:d45bfa16953a 909 printf("\rexample: cof output_rly1.json o_rly1 Relay1 1\r\n");
jmarkel44 37:7e6986b77f01 910 return;
jmarkel44 37:7e6986b77f01 911 }
jmarkel44 37:7e6986b77f01 912
jmarkel44 177:9ec90c8e3ce1 913 char data_buf[MAX_FILE_SIZE];
jmarkel44 37:7e6986b77f01 914
jmarkel44 67:49f266601d83 915 snprintf(data_buf, sizeof(data_buf),
jmarkel44 67:49f266601d83 916 "{ "
jmarkel44 67:49f266601d83 917 "\"id\": \"%s\", "
davidjhoward 81:d45bfa16953a 918 "\"name\": \"%s\", "
davidjhoward 81:d45bfa16953a 919 "\"units\": \"\", "
jmarkel44 67:49f266601d83 920 "\"min\": \"0\", "
jmarkel44 67:49f266601d83 921 "\"max\": \"300\", "
davidjhoward 81:d45bfa16953a 922 "\"node\": \"0\", "
davidjhoward 81:d45bfa16953a 923 "\"reg\": \"%s\", "
jmarkel44 67:49f266601d83 924 "\"rtype\": \"1\", "
jmarkel44 67:49f266601d83 925 "\"type\": \"16\", "
davidjhoward 81:d45bfa16953a 926 "\"size\": \"2\", "
davidjhoward 81:d45bfa16953a 927 "\"order\": \"2\", "
jmarkel44 67:49f266601d83 928 "\"fmt\": \"%%.2f\", "
davidjhoward 81:d45bfa16953a 929 "\"rfreq\": \"5\", "
jmarkel44 67:49f266601d83 930 "\"toperiod\": \"0\", "
jmarkel44 67:49f266601d83 931 "\"scalelo\": \"0\", "
davidjhoward 81:d45bfa16953a 932 "\"scalehi\": \"100\" }", argv[2], argv[3], argv[4]);
davidjhoward 81:d45bfa16953a 933
jmarkel44 177:9ec90c8e3ce1 934 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 37:7e6986b77f01 935 if( status != true ) {
jmarkel44 37:7e6986b77f01 936 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 937 }
jmarkel44 43:62de0e05ab6b 938
jmarkel44 177:9ec90c8e3ce1 939 // send a message to the modbus master
jmarkel44 63:0ded43237b22 940 logInfo("Sending mail to ModbusMasterMailBox, filename=%s", argv[1]);
jmarkel44 63:0ded43237b22 941 Message_t *modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 942 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 63:0ded43237b22 943 strncpy( modbus_mail->controlFile, argv[1], (sizeof(modbus_mail->controlFile)-1));
jmarkel44 63:0ded43237b22 944 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 67:49f266601d83 945
jmarkel44 63:0ded43237b22 946 // send a message to the output master
jmarkel44 63:0ded43237b22 947 logInfo("Sending mail to OutputMaster, filename = %s", argv[1]);
jmarkel44 63:0ded43237b22 948 OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 949 output_mail->action = ACTION_NEW;
jmarkel44 63:0ded43237b22 950 strncpy(output_mail->controlFile, argv[1], sizeof(output_mail->controlFile)-1);
jmarkel44 63:0ded43237b22 951 OutputMasterMailBox.put(output_mail);
jmarkel44 37:7e6986b77f01 952 }
jmarkel44 37:7e6986b77f01 953
jmarkel44 37:7e6986b77f01 954 /*****************************************************************************
jmarkel44 35:6235ef67faa1 955 * Function: cmd_heap
jmarkel44 35:6235ef67faa1 956 * Description: display heap statistics
jmarkel44 35:6235ef67faa1 957 *
jmarkel44 35:6235ef67faa1 958 * @param argc (not used)
jmarkel44 35:6235ef67faa1 959 * @param argv (not used)
jmarkel44 35:6235ef67faa1 960 * @return none
jmarkel44 35:6235ef67faa1 961 *****************************************************************************/
jmarkel44 0:65cfa4873284 962 void cmd_heap(int argc, char **argv)
jmarkel44 0:65cfa4873284 963 {
jmarkel44 0:65cfa4873284 964 UNUSED(argc), UNUSED(argv);
jmarkel44 0:65cfa4873284 965 __heapstats((__heapprt)fprintf,stderr); // print initial free heap size
jmarkel44 0:65cfa4873284 966 }
jmarkel44 0:65cfa4873284 967
jmarkel44 0:65cfa4873284 968
jmarkel44 35:6235ef67faa1 969 /*****************************************************************************
jmarkel44 35:6235ef67faa1 970 * Function: cmd_stats
jmarkel44 35:6235ef67faa1 971 * Description: display mDot stats
jmarkel44 35:6235ef67faa1 972 *
jmarkel44 35:6235ef67faa1 973 * @param argc (not used)
jmarkel44 35:6235ef67faa1 974 * @param argv (not used)
jmarkel44 35:6235ef67faa1 975 * @return none
jmarkel44 35:6235ef67faa1 976 *****************************************************************************/
jmarkel44 18:9cf694a764c0 977 void cmd_stats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 978 {
jmarkel44 35:6235ef67faa1 979 UNUSED(argc);
jmarkel44 35:6235ef67faa1 980 UNUSED(argv);
davidjhoward 81:d45bfa16953a 981
jmarkel44 18:9cf694a764c0 982 mDot::mdot_stats stats = GLOBAL_mdot->getStats();
jmarkel44 0:65cfa4873284 983
jmarkel44 44:c73f2ca79669 984 printf("\r Up: %u\n", stats.Up);
jmarkel44 44:c73f2ca79669 985 printf("\r Down: %u\n", stats.Down);
jmarkel44 44:c73f2ca79669 986 printf("\r Joins: %u\n", stats.Joins);
jmarkel44 44:c73f2ca79669 987 printf("\r JoinFails: %u\n", stats.JoinFails);
jmarkel44 44:c73f2ca79669 988 printf("\r MissedAcks: %u\n", stats.MissedAcks);
jmarkel44 44:c73f2ca79669 989 printf("\r CRCErrors: %u\n", stats.CRCErrors);
jmarkel44 44:c73f2ca79669 990 printf("\r\n");
jmarkel44 44:c73f2ca79669 991 printf("\r Freq band: %u\n", GLOBAL_mdot->getFrequencyBand());
jmarkel44 44:c73f2ca79669 992 printf("\r Freq subband: %u\n", GLOBAL_mdot->getFrequencySubBand());
jmarkel44 44:c73f2ca79669 993 printf("\r Session data rate: %u\n", GLOBAL_mdot->getSessionDataRate());
jmarkel44 44:c73f2ca79669 994 printf("\r Public Network Mode: %s\n", GLOBAL_mdot->getPublicNetwork() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 995 printf("\r Application device port: %u\n", GLOBAL_mdot->getAppPort());
jmarkel44 44:c73f2ca79669 996 printf("\r Class: %s\n", GLOBAL_mdot->getClass().c_str());
jmarkel44 44:c73f2ca79669 997 printf("\r Max packet length: %u\n", GLOBAL_mdot->getMaxPacketLength());
jmarkel44 77:43e0a3d9e536 998 std::vector<uint8_t> na = GLOBAL_mdot->getNetworkAddress();
jmarkel44 77:43e0a3d9e536 999 std::string str(na.begin(), na.end());
jmarkel44 77:43e0a3d9e536 1000 printf("\r Network address: %s\n", str.c_str());
jmarkel44 44:c73f2ca79669 1001 printf("\r Network name: %s\n", GLOBAL_mdot->getNetworkName().c_str());
jmarkel44 77:43e0a3d9e536 1002 std::vector<uint8_t> nid = GLOBAL_mdot->getNetworkId();
jmarkel44 77:43e0a3d9e536 1003 std::string networkIdStr(nid.begin(), nid.end());
jmarkel44 77:43e0a3d9e536 1004 printf("\r Network ID: %s\n", networkIdStr.c_str());
jmarkel44 44:c73f2ca79669 1005 printf("\r Join byter order: %s\n", GLOBAL_mdot->getJoinByteOrder() == 0 ? "LSB" : "MSB");
jmarkel44 44:c73f2ca79669 1006 printf("\r Join retries: %u\n", GLOBAL_mdot->getJoinRetries());
jmarkel44 44:c73f2ca79669 1007 printf("\r Join mode: %u\n", GLOBAL_mdot->getJoinMode());
jmarkel44 44:c73f2ca79669 1008 printf("\r Network join status: %s\n", GLOBAL_mdot->getNetworkJoinStatus() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 1009 printf("\r Link fail count: %u\n", GLOBAL_mdot->getLinkFailCount());
jmarkel44 44:c73f2ca79669 1010 printf("\r Packets Tx'd to gateway: %u\n", GLOBAL_mdot->getUpLinkCounter());
jmarkel44 44:c73f2ca79669 1011 printf("\r Packets Rx'd from gateway: %u\n", GLOBAL_mdot->getDownLinkCounter());
jmarkel44 44:c73f2ca79669 1012 printf("\r AES encryption: %s\n", GLOBAL_mdot->getAesEncryption() ? "enabled" : "disabled");
jmarkel44 44:c73f2ca79669 1013 printf("\r Tx data rate: %u\n", GLOBAL_mdot->getTxDataRate());
jmarkel44 77:43e0a3d9e536 1014 printf("\r Datarate Details: %s\n", GLOBAL_mdot->getDateRateDetails(GLOBAL_mdot->getTxDataRate()).c_str());
jmarkel44 44:c73f2ca79669 1015 printf("\r Tx power: %u\n", GLOBAL_mdot->getTxPower());
jmarkel44 44:c73f2ca79669 1016 printf("\r Antenna gain: %u\n", GLOBAL_mdot->getAntennaGain());
jmarkel44 44:c73f2ca79669 1017 printf("\r Min frequency: %u\n", GLOBAL_mdot->getMinFrequency());
jmarkel44 44:c73f2ca79669 1018 printf("\r Max frequency: %u\n", GLOBAL_mdot->getMaxFrequency());
jmarkel44 44:c73f2ca79669 1019 printf("\r CRC enabled: %s\n", GLOBAL_mdot->getCrc() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 1020 printf("\r ACK enabled: %s\n", GLOBAL_mdot->getAck() ? "yes" : "no");
jmarkel44 18:9cf694a764c0 1021
jmarkel44 18:9cf694a764c0 1022 printf("\r\n");
jmarkel44 18:9cf694a764c0 1023 }
jmarkel44 18:9cf694a764c0 1024
jmarkel44 35:6235ef67faa1 1025 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1026 * Function: cmd_resetStats
jmarkel44 35:6235ef67faa1 1027 * Description: resets the mDot stats
jmarkel44 35:6235ef67faa1 1028 *
jmarkel44 35:6235ef67faa1 1029 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1030 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1031 * @return none
jmarkel44 35:6235ef67faa1 1032 *****************************************************************************/
jmarkel44 18:9cf694a764c0 1033 void cmd_resetStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 1034 {
jmarkel44 35:6235ef67faa1 1035 UNUSED(argc);
jmarkel44 35:6235ef67faa1 1036 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 1037
jmarkel44 18:9cf694a764c0 1038 GLOBAL_mdot->resetStats();
jmarkel44 18:9cf694a764c0 1039 }
jmarkel44 0:65cfa4873284 1040
jmarkel44 35:6235ef67faa1 1041 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1042 * Function: cmd_rssiStats
jmarkel44 36:f240f5a6d0ed 1043 * Description: displays mDot RSSI statistics
jmarkel44 35:6235ef67faa1 1044 *
jmarkel44 35:6235ef67faa1 1045 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1046 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1047 * @return none
jmarkel44 35:6235ef67faa1 1048 *****************************************************************************/
jmarkel44 18:9cf694a764c0 1049 void cmd_rssiStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 1050 {
jmarkel44 35:6235ef67faa1 1051 UNUSED(argc);
jmarkel44 35:6235ef67faa1 1052 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 1053
jmarkel44 18:9cf694a764c0 1054 mDot::rssi_stats s = GLOBAL_mdot->getRssiStats();
jmarkel44 0:65cfa4873284 1055
jmarkel44 18:9cf694a764c0 1056 printf("\r Last: %d dB\n", s.last);
jmarkel44 18:9cf694a764c0 1057 printf("\r Min: %d dB\n", s.min);
jmarkel44 18:9cf694a764c0 1058 printf("\r Max: %d dB\n", s.max);
jmarkel44 18:9cf694a764c0 1059 printf("\r Avg: %d dB\n", s.avg);
jmarkel44 18:9cf694a764c0 1060
jmarkel44 18:9cf694a764c0 1061 printf("\r\n");
jmarkel44 18:9cf694a764c0 1062 }
jmarkel44 18:9cf694a764c0 1063
jmarkel44 35:6235ef67faa1 1064 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1065 * Function: cmd_snrStats
jmarkel44 35:6235ef67faa1 1066 * Description: displays signal-to-noise ratio stats
jmarkel44 35:6235ef67faa1 1067 *
jmarkel44 35:6235ef67faa1 1068 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1069 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1070 * @return none
jmarkel44 35:6235ef67faa1 1071 *****************************************************************************/
jmarkel44 18:9cf694a764c0 1072 void cmd_snrStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 1073 {
jmarkel44 18:9cf694a764c0 1074 mDot::snr_stats s = GLOBAL_mdot->getSnrStats();
jmarkel44 18:9cf694a764c0 1075
jmarkel44 18:9cf694a764c0 1076 printf("\r Last: %d cB\n", s.last);
jmarkel44 18:9cf694a764c0 1077 printf("\r Min: %d cB\n", s.min);
jmarkel44 18:9cf694a764c0 1078 printf("\r Max: %d cB\n", s.max);
jmarkel44 18:9cf694a764c0 1079 printf("\r Avg: %d cB\n", s.avg);
jmarkel44 18:9cf694a764c0 1080
jmarkel44 18:9cf694a764c0 1081 printf("\r\n");
jmarkel44 18:9cf694a764c0 1082 }
jmarkel44 34:f345fdec711d 1083
jmarkel44 35:6235ef67faa1 1084 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1085 * Function: cmd_stack
jmarkel44 36:f240f5a6d0ed 1086 * Description: display thread stack statisics
jmarkel44 35:6235ef67faa1 1087 *
jmarkel44 35:6235ef67faa1 1088 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1089 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1090 * @return none
jmarkel44 35:6235ef67faa1 1091 *****************************************************************************/
jmarkel44 34:f345fdec711d 1092 void cmd_stack(int argc, char **argv)
jmarkel44 34:f345fdec711d 1093 {
jmarkel44 36:f240f5a6d0ed 1094 vector<pair<string, Thread*> > taskList;
davidjhoward 81:d45bfa16953a 1095
jmarkel44 71:34856d21f2bf 1096 const char *mapper[] = { "Inactive",
jmarkel44 71:34856d21f2bf 1097 "Ready",
jmarkel44 71:34856d21f2bf 1098 "Running",
jmarkel44 71:34856d21f2bf 1099 "WaitingDelay",
jmarkel44 71:34856d21f2bf 1100 "WaitingInterval",
jmarkel44 71:34856d21f2bf 1101 "WaitingOr",
jmarkel44 71:34856d21f2bf 1102 "WaitingAnd",
jmarkel44 71:34856d21f2bf 1103 "WaitingSempahore",
jmarkel44 71:34856d21f2bf 1104 "WaitingMailbox",
davidjhoward 81:d45bfa16953a 1105 "WaitingMutex"
davidjhoward 81:d45bfa16953a 1106 };
jmarkel44 36:f240f5a6d0ed 1107
jmarkel44 36:f240f5a6d0ed 1108 //simply add your task to the list...
jmarkel44 36:f240f5a6d0ed 1109 taskList.push_back(make_pair((string)"AnalyticsLogger", GLOBAL_analyticsLogger_thread));
jmarkel44 172:51dfb4aabc57 1110 //taskList.push_back(make_pair((string)"BLEHandler", GLOBAL_BLE_thread));
jmarkel44 36:f240f5a6d0ed 1111 taskList.push_back(make_pair((string)"CloudDataHandler", GLOBAL_CDH_thread));
jmarkel44 36:f240f5a6d0ed 1112 taskList.push_back(make_pair((string)"ConfigHandler", GLOBAL_configHandler_thread));
jmarkel44 36:f240f5a6d0ed 1113 taskList.push_back(make_pair((string)"ControlTask", GLOBAL_controlTask_thread));
jmarkel44 36:f240f5a6d0ed 1114 taskList.push_back(make_pair((string)"ModbusMaster", GLOBAL_modbusMaster_thread));
jmarkel44 48:1c7861d80d16 1115 taskList.push_back(make_pair((string)"OutputTask", GLOBAL_outputTask_thread));
jmarkel44 36:f240f5a6d0ed 1116
jmarkel44 36:f240f5a6d0ed 1117 for ( vector<pair<string, Thread*> >::iterator pos = taskList.begin();
jmarkel44 36:f240f5a6d0ed 1118 pos != taskList.end(); ++ pos) {
jmarkel44 170:f9406996ff5b 1119 printf("\r %-32s size/free/used/max = %5u/%5u/%5u/%5u\tpri=%u state=%-20s\n",
davidjhoward 41:e8946fc01ea4 1120 pos->first.c_str(),
davidjhoward 41:e8946fc01ea4 1121 pos->second->stack_size(),
davidjhoward 41:e8946fc01ea4 1122 pos->second->free_stack(),
davidjhoward 41:e8946fc01ea4 1123 pos->second->used_stack(),
jmarkel44 71:34856d21f2bf 1124 pos->second->max_stack(),
jmarkel44 71:34856d21f2bf 1125 pos->second->get_priority(),
jmarkel44 71:34856d21f2bf 1126 mapper[pos->second->get_state()]);
jmarkel44 34:f345fdec711d 1127 }
jmarkel44 36:f240f5a6d0ed 1128
jmarkel44 34:f345fdec711d 1129 printf("\r\n");
jmarkel44 34:f345fdec711d 1130 }
jmarkel44 62:1b1d7918adf2 1131
jmarkel44 62:1b1d7918adf2 1132 /*****************************************************************************
davidjhoward 61:ae6dd6692c7d 1133 * Function: cmd_modmap
davidjhoward 61:ae6dd6692c7d 1134 * Description: dump modbus register map
jmarkel44 62:1b1d7918adf2 1135 *****************************************************************************/
davidjhoward 61:ae6dd6692c7d 1136 void cmd_modmap(int argc, char **argv)
jmarkel44 62:1b1d7918adf2 1137 {
jmarkel44 65:be025ac18fb5 1138 UNUSED(argc);
jmarkel44 65:be025ac18fb5 1139 UNUSED(argv);
davidjhoward 83:0f76cfbb4eba 1140 ModbusValue value;
jmarkel44 67:49f266601d83 1141
davidjhoward 61:ae6dd6692c7d 1142 std::map<std::string, ModbusRegister>::iterator iter;
davidjhoward 61:ae6dd6692c7d 1143 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 83:0f76cfbb4eba 1144 ModbusMasterReadRegister( iter->first, &value );
davidjhoward 190:af7ab603c9fe 1145 printf("tag=%s, name=%s, units=%s, node=%d, reg=%d, rtype=%d size=%d, order=%d, value=%2.2f, errflag=%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.rtype, iter->second.size, iter->second.order, value.value, value.errflag );
davidjhoward 61:ae6dd6692c7d 1146 }
jmarkel44 65:be025ac18fb5 1147 }
jmarkel44 65:be025ac18fb5 1148
jmarkel44 65:be025ac18fb5 1149 /*****************************************************************************
jmarkel44 208:784c46652863 1150 * Function: cmd_modifyManual
jmarkel44 208:784c46652863 1151 * Description: modify a manual control
jmarkel44 208:784c46652863 1152 *****************************************************************************/
jmarkel44 208:784c46652863 1153 void cmd_modifyManual(int argc, char **argv)
jmarkel44 208:784c46652863 1154 {
jmarkel44 208:784c46652863 1155 std::string relayState;
jmarkel44 220:dbe21411f962 1156
jmarkel44 208:784c46652863 1157 if ( argc != 3 ) {
jmarkel44 208:784c46652863 1158 printf("\rusage: modify-mn <controlFile> <state>\n");
jmarkel44 208:784c46652863 1159 printf("\rexample: modify-mn control_mn_rly1.json on\n");
jmarkel44 208:784c46652863 1160 return;
jmarkel44 208:784c46652863 1161 }
jmarkel44 220:dbe21411f962 1162
jmarkel44 208:784c46652863 1163 string state(argv[2]);
jmarkel44 208:784c46652863 1164 if ( state == "on" ) {
jmarkel44 208:784c46652863 1165 relayState = "1";
jmarkel44 208:784c46652863 1166 } else if ( state == "off" ) {
jmarkel44 208:784c46652863 1167 relayState = "0";
jmarkel44 220:dbe21411f962 1168 } else {
jmarkel44 208:784c46652863 1169 printf("\r<state> must be ON or OFF\n");
jmarkel44 208:784c46652863 1170 return;
jmarkel44 208:784c46652863 1171 }
jmarkel44 220:dbe21411f962 1172
jmarkel44 208:784c46652863 1173 char buf[MAX_FILE_SIZE];
jmarkel44 208:784c46652863 1174 bool rc = GLOBAL_mdot->readUserFile(argv[1], (void*)buf, MAX_FILE_SIZE);
jmarkel44 208:784c46652863 1175 if ( rc != true ) {
jmarkel44 208:784c46652863 1176 printf("\rFailed to read %s\n", argv[1]);
jmarkel44 208:784c46652863 1177 return;
jmarkel44 208:784c46652863 1178 }
jmarkel44 220:dbe21411f962 1179
jmarkel44 208:784c46652863 1180 MbedJSONValue json_value;
jmarkel44 208:784c46652863 1181 parse(json_value, buf);
jmarkel44 208:784c46652863 1182
jmarkel44 208:784c46652863 1183 json_value["state"] = relayState;
jmarkel44 220:dbe21411f962 1184
jmarkel44 208:784c46652863 1185 std::string s = json_value.serialize();
jmarkel44 220:dbe21411f962 1186
jmarkel44 208:784c46652863 1187 rc = GLOBAL_mdot->saveUserFile(argv[1], (void*)s.c_str(), MAX_FILE_SIZE);
jmarkel44 208:784c46652863 1188 if ( rc != true ) {
jmarkel44 208:784c46652863 1189 printf("\rFailed to write %s\n", argv[1]);
jmarkel44 208:784c46652863 1190 return;
jmarkel44 208:784c46652863 1191 }
jmarkel44 220:dbe21411f962 1192
jmarkel44 208:784c46652863 1193 // send a message to the configuration handler to create the control
jmarkel44 208:784c46652863 1194 Message_t *msg = MailBox.alloc();
jmarkel44 208:784c46652863 1195 memset(msg, 0, sizeof(Message_t));
jmarkel44 208:784c46652863 1196 msg->action = ACTION_MODIFY;
jmarkel44 208:784c46652863 1197 msg->control = CONTROL_MANUAL;
jmarkel44 208:784c46652863 1198 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 208:784c46652863 1199
jmarkel44 208:784c46652863 1200 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 208:784c46652863 1201 __func__, msg->controlFile, msg->control);
jmarkel44 208:784c46652863 1202
jmarkel44 208:784c46652863 1203 MailBox.put(msg);
jmarkel44 208:784c46652863 1204 printf("\r\n");
jmarkel44 208:784c46652863 1205 return;
jmarkel44 208:784c46652863 1206 }
jmarkel44 208:784c46652863 1207
jmarkel44 208:784c46652863 1208 /*****************************************************************************
jmarkel44 207:55aabde2d4bf 1209 * Function: cmd_modifySetpoint
jmarkel44 207:55aabde2d4bf 1210 * Description: modify a setpoint control
jmarkel44 207:55aabde2d4bf 1211 *****************************************************************************/
jmarkel44 207:55aabde2d4bf 1212 void cmd_modifySetpoint(int argc, char**argv)
jmarkel44 207:55aabde2d4bf 1213 {
jmarkel44 207:55aabde2d4bf 1214 if ( argc != 4) {
jmarkel44 207:55aabde2d4bf 1215 printf("\rusage: modify-sp <controlFile> <setpoint> <tol>\n");
jmarkel44 207:55aabde2d4bf 1216 printf("\rexample: modify-sp control_sp_1.json 2200 10\n");
jmarkel44 207:55aabde2d4bf 1217 return;
jmarkel44 207:55aabde2d4bf 1218 }
jmarkel44 207:55aabde2d4bf 1219
jmarkel44 207:55aabde2d4bf 1220 // read the file
jmarkel44 207:55aabde2d4bf 1221 char buf[MAX_FILE_SIZE];
jmarkel44 207:55aabde2d4bf 1222 bool rc = GLOBAL_mdot->readUserFile(argv[1], (void*)buf, MAX_FILE_SIZE);
jmarkel44 207:55aabde2d4bf 1223 if ( rc != true ) {
jmarkel44 207:55aabde2d4bf 1224 printf("\rFailed to read %s\n", argv[1]);
jmarkel44 207:55aabde2d4bf 1225 return;
jmarkel44 207:55aabde2d4bf 1226 }
jmarkel44 207:55aabde2d4bf 1227
jmarkel44 207:55aabde2d4bf 1228 MbedJSONValue json_value;
jmarkel44 207:55aabde2d4bf 1229 parse(json_value, buf);
jmarkel44 207:55aabde2d4bf 1230
jmarkel44 207:55aabde2d4bf 1231 json_value["setpoint"] = argv[2];
jmarkel44 207:55aabde2d4bf 1232 json_value["tol"] = argv[3];
jmarkel44 220:dbe21411f962 1233
jmarkel44 207:55aabde2d4bf 1234 std::string s = json_value.serialize();
jmarkel44 220:dbe21411f962 1235
jmarkel44 207:55aabde2d4bf 1236 rc = GLOBAL_mdot->saveUserFile(argv[1], (void*)s.c_str(), MAX_FILE_SIZE);
jmarkel44 207:55aabde2d4bf 1237 if ( rc != true ) {
jmarkel44 207:55aabde2d4bf 1238 printf("\rFailed to write %s\n", argv[1]);
jmarkel44 207:55aabde2d4bf 1239 return;
jmarkel44 207:55aabde2d4bf 1240 }
jmarkel44 220:dbe21411f962 1241
jmarkel44 207:55aabde2d4bf 1242 // send a message to the configuration handler to create the control
jmarkel44 207:55aabde2d4bf 1243 Message_t *msg = MailBox.alloc();
jmarkel44 207:55aabde2d4bf 1244 memset(msg, 0, sizeof(Message_t));
jmarkel44 207:55aabde2d4bf 1245 msg->action = ACTION_MODIFY;
jmarkel44 207:55aabde2d4bf 1246 msg->control = CONTROL_SETPOINT;
jmarkel44 207:55aabde2d4bf 1247 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 207:55aabde2d4bf 1248
jmarkel44 207:55aabde2d4bf 1249 printf("%s: Sending a MODIFY request for control %s type = %u\r\n",
jmarkel44 207:55aabde2d4bf 1250 __func__, msg->controlFile, msg->control);
jmarkel44 207:55aabde2d4bf 1251
jmarkel44 207:55aabde2d4bf 1252 MailBox.put(msg);
jmarkel44 207:55aabde2d4bf 1253 printf("\r\n");
jmarkel44 207:55aabde2d4bf 1254 return;
jmarkel44 207:55aabde2d4bf 1255
jmarkel44 207:55aabde2d4bf 1256 }
jmarkel44 207:55aabde2d4bf 1257
jmarkel44 207:55aabde2d4bf 1258 /*****************************************************************************
jmarkel44 65:be025ac18fb5 1259 * Function: cmd_time
jmarkel44 65:be025ac18fb5 1260 * Description: display real-time clock
jmarkel44 65:be025ac18fb5 1261 ****************************************************************************/
jmarkel44 65:be025ac18fb5 1262 void cmd_time(int argc, char **argv)
jmarkel44 65:be025ac18fb5 1263 {
jmarkel44 62:1b1d7918adf2 1264 UNUSED(argc);
jmarkel44 62:1b1d7918adf2 1265 UNUSED(argv);
davidjhoward 149:950c90425f7c 1266
jmarkel44 131:a290a3934132 1267 time_t rawtime;
jmarkel44 131:a290a3934132 1268 time(&rawtime);
davidjhoward 149:950c90425f7c 1269
jmarkel44 62:1b1d7918adf2 1270 int iyr=0, imo=0, idy=0, ihr=0, imn=0, isc=0;
jmarkel44 62:1b1d7918adf2 1271 rtc_get_time(&iyr, &imo, &idy, &ihr, &imn, &isc);
jmarkel44 131:a290a3934132 1272 printf("RTC time: %04d-%02d-%02d %02d:%02d:%02d\r\n", iyr, imo, idy, ihr, imn, isc);
jmarkel44 132:45821e189dd0 1273 printf("\repoch timestamp: %lu\r\n", time(NULL));
jmarkel44 66:db1425574b58 1274 }
jmarkel44 66:db1425574b58 1275
jmarkel44 66:db1425574b58 1276 /*****************************************************************************
jmarkel44 131:a290a3934132 1277 * Function: cmd_outputs
jmarkel44 66:db1425574b58 1278 * Description: display outputs
jmarkel44 66:db1425574b58 1279 ****************************************************************************/
jmarkel44 66:db1425574b58 1280 void cmd_outputs(int argc, char **argv)
jmarkel44 66:db1425574b58 1281 {
jmarkel44 66:db1425574b58 1282 UNUSED(argc);
jmarkel44 66:db1425574b58 1283 UNUSED(argv);
jmarkel44 67:49f266601d83 1284
jmarkel44 66:db1425574b58 1285 DisplayOutputs();
davidjhoward 81:d45bfa16953a 1286 }
davidjhoward 81:d45bfa16953a 1287
davidjhoward 81:d45bfa16953a 1288 /*****************************************************************************
davidjhoward 81:d45bfa16953a 1289 * Function: cmd_sout
davidjhoward 81:d45bfa16953a 1290 * Description: set output
davidjhoward 81:d45bfa16953a 1291 *
davidjhoward 81:d45bfa16953a 1292 * @param argc-> number of args
davidjhoward 81:d45bfa16953a 1293 * @param argv-> output
davidjhoward 81:d45bfa16953a 1294 * @return none
davidjhoward 81:d45bfa16953a 1295 *****************************************************************************/
davidjhoward 81:d45bfa16953a 1296 void cmd_sout(int argc, char **argv)
davidjhoward 81:d45bfa16953a 1297 {
davidjhoward 81:d45bfa16953a 1298 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 1299
davidjhoward 81:d45bfa16953a 1300 if ( argc != 3 ) {
davidjhoward 81:d45bfa16953a 1301 printf("\rusage: sout <output> <value>\r\n");
davidjhoward 81:d45bfa16953a 1302 printf("\rexample: sout o_rly1 1\r\n");
davidjhoward 81:d45bfa16953a 1303 return;
davidjhoward 116:7337ed514891 1304 }
davidjhoward 83:0f76cfbb4eba 1305 ModbusMasterWriteRegister( argv[1], value );
davidjhoward 82:f3e495a98877 1306 }
davidjhoward 82:f3e495a98877 1307
davidjhoward 82:f3e495a98877 1308 /*****************************************************************************
jmarkel44 102:715f754cf5a8 1309 * Function: cmd_settime
jmarkel44 102:715f754cf5a8 1310 * Description: set real-time clock
jmarkel44 102:715f754cf5a8 1311 *
jmarkel44 102:715f754cf5a8 1312 * @param argc-> number of args
jmarkel44 102:715f754cf5a8 1313 * @param argv-> input
jmarkel44 102:715f754cf5a8 1314 * @return none
jmarkel44 102:715f754cf5a8 1315 *****************************************************************************/
jmarkel44 102:715f754cf5a8 1316 void cmd_settime(int argc, char **argv)
jmarkel44 102:715f754cf5a8 1317 {
davidjhoward 116:7337ed514891 1318
jmarkel44 102:715f754cf5a8 1319 if ( argc != 7 ) {
jmarkel44 102:715f754cf5a8 1320 printf("\rusage: set-time <yyyy> <mm> <dd> <hh> <mm> <ss>\n");
jmarkel44 102:715f754cf5a8 1321 printf("\rexample: set-time 2016 12 25 12 0 0\r\n");
jmarkel44 102:715f754cf5a8 1322 return;
jmarkel44 102:715f754cf5a8 1323 }
davidjhoward 116:7337ed514891 1324
jmarkel44 102:715f754cf5a8 1325 rtc_set_time(atoi(argv[1]), // year
jmarkel44 102:715f754cf5a8 1326 atoi(argv[2]), // month
jmarkel44 102:715f754cf5a8 1327 atoi(argv[3]), // day
jmarkel44 102:715f754cf5a8 1328 atoi(argv[4]), // hr
jmarkel44 102:715f754cf5a8 1329 atoi(argv[5]), // min
jmarkel44 102:715f754cf5a8 1330 atoi(argv[6])); // sec
jmarkel44 102:715f754cf5a8 1331 }
jmarkel44 102:715f754cf5a8 1332
jmarkel44 102:715f754cf5a8 1333 /*****************************************************************************
davidjhoward 82:f3e495a98877 1334 * Function: cmd_simin
davidjhoward 82:f3e495a98877 1335 * Description: simulat input
davidjhoward 82:f3e495a98877 1336 *
davidjhoward 82:f3e495a98877 1337 * @param argc-> number of args
davidjhoward 82:f3e495a98877 1338 * @param argv-> input
davidjhoward 82:f3e495a98877 1339 * @return none
davidjhoward 82:f3e495a98877 1340 *****************************************************************************/
davidjhoward 82:f3e495a98877 1341 void cmd_simin(int argc, char **argv)
davidjhoward 82:f3e495a98877 1342 {
davidjhoward 82:f3e495a98877 1343 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 1344
davidjhoward 82:f3e495a98877 1345 if ( argc < 3 ) {
davidjhoward 150:4db35c8234b4 1346 printf("\rusage: simin <input> <value> <low> <hi> <up_step> <down_step>\r\n");
davidjhoward 150:4db35c8234b4 1347 printf("\rexample: simin i_tra01 100 94 106 1 .25\r\n");
davidjhoward 150:4db35c8234b4 1348 printf("\rexample: simin i_bdcond01 2000 1990 2006 .25 1\r\n");
davidjhoward 82:f3e495a98877 1349 return;
davidjhoward 82:f3e495a98877 1350 }
davidjhoward 82:f3e495a98877 1351
davidjhoward 82:f3e495a98877 1352 SimulateInputMap[argv[1]].start_value = atof(argv[2]);
davidjhoward 116:7337ed514891 1353
davidjhoward 82:f3e495a98877 1354 ModbusRegisterMap[argv[1]].simulated = true;
davidjhoward 82:f3e495a98877 1355
davidjhoward 82:f3e495a98877 1356 if ( argc < 3 ) {
davidjhoward 82:f3e495a98877 1357 SimulateInputMap[argv[1]].min = 0;
davidjhoward 82:f3e495a98877 1358 SimulateInputMap[argv[1]].max = 0;
davidjhoward 179:a31ea334e2b7 1359 SimulateInputMap[argv[1]].moving_up = false;
davidjhoward 82:f3e495a98877 1360 return;
davidjhoward 82:f3e495a98877 1361 }
davidjhoward 82:f3e495a98877 1362 SimulateInputMap[argv[1]].min = atof(argv[3]);
davidjhoward 82:f3e495a98877 1363 SimulateInputMap[argv[1]].max = atof(argv[4]);
davidjhoward 150:4db35c8234b4 1364 SimulateInputMap[argv[1]].up_step = atof(argv[5]);
davidjhoward 150:4db35c8234b4 1365 SimulateInputMap[argv[1]].down_step = atof(argv[6]);
davidjhoward 179:a31ea334e2b7 1366 SimulateInputMap[argv[1]].moving_up = true;
davidjhoward 150:4db35c8234b4 1367
davidjhoward 179:a31ea334e2b7 1368 }
davidjhoward 179:a31ea334e2b7 1369
davidjhoward 179:a31ea334e2b7 1370 /*****************************************************************************
davidjhoward 179:a31ea334e2b7 1371 * Function: cmd_simall
davidjhoward 179:a31ea334e2b7 1372 * Description: simulat multiple inputs
davidjhoward 179:a31ea334e2b7 1373 *
davidjhoward 179:a31ea334e2b7 1374 * @return none
davidjhoward 179:a31ea334e2b7 1375 *****************************************************************************/
davidjhoward 179:a31ea334e2b7 1376 void cmd_simall(int argc, char **argv)
davidjhoward 179:a31ea334e2b7 1377 {
davidjhoward 179:a31ea334e2b7 1378
davidjhoward 179:a31ea334e2b7 1379 if ( argc > 1 ) {
davidjhoward 179:a31ea334e2b7 1380 printf("\rsetting: simin i_tra01 100\r\n");
davidjhoward 179:a31ea334e2b7 1381 printf("\rsetting: simin i_bdcond01 2000\r\n");
davidjhoward 179:a31ea334e2b7 1382
davidjhoward 179:a31ea334e2b7 1383 ModbusRegisterMap["i_tra01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1384 SimulateInputMap["i_tra01"].start_value = 130;
davidjhoward 179:a31ea334e2b7 1385 SimulateInputMap["i_tra01"].min = 0;
davidjhoward 179:a31ea334e2b7 1386 SimulateInputMap["i_tra01"].max = 0;
davidjhoward 179:a31ea334e2b7 1387 SimulateInputMap["i_tra01"].up_step = 0;
davidjhoward 179:a31ea334e2b7 1388 SimulateInputMap["i_tra01"].down_step = 0;
davidjhoward 179:a31ea334e2b7 1389 SimulateInputMap["i_tra01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1390
davidjhoward 199:d65ed41d4dd4 1391 ModbusRegisterMap["i_tag01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1392 SimulateInputMap["i_tag01"].start_value = 100;
davidjhoward 199:d65ed41d4dd4 1393 SimulateInputMap["i_tag01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1394 SimulateInputMap["i_tag01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1395 SimulateInputMap["i_tag01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1396 SimulateInputMap["i_tag01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1397 SimulateInputMap["i_tag01"].moving_up = true;
davidjhoward 179:a31ea334e2b7 1398
davidjhoward 179:a31ea334e2b7 1399 ModbusRegisterMap["i_bdcond01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1400 SimulateInputMap["i_bdcond01"].start_value = 1800;
davidjhoward 179:a31ea334e2b7 1401 SimulateInputMap["i_bdcond01"].min = 0;
davidjhoward 179:a31ea334e2b7 1402 SimulateInputMap["i_bdcond01"].max = 0;
davidjhoward 179:a31ea334e2b7 1403 SimulateInputMap["i_bdcond01"].up_step = 0;
davidjhoward 179:a31ea334e2b7 1404 SimulateInputMap["i_bdcond01"].down_step = 0;
davidjhoward 179:a31ea334e2b7 1405 SimulateInputMap["i_bdcond01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1406
davidjhoward 199:d65ed41d4dd4 1407 ModbusRegisterMap["i_cond_temp01"].simulated = true;
davidjhoward 214:52ef35bc44ec 1408 SimulateInputMap["i_cond_temp01"].start_value = 25000.0;
davidjhoward 199:d65ed41d4dd4 1409 SimulateInputMap["i_cond_temp01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1410 SimulateInputMap["i_cond_temp01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1411 SimulateInputMap["i_cond_temp01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1412 SimulateInputMap["i_cond_temp01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1413 SimulateInputMap["i_cond_temp01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1414
davidjhoward 199:d65ed41d4dd4 1415 ModbusRegisterMap["i_ph01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1416 SimulateInputMap["i_ph01"].start_value = 8;
davidjhoward 199:d65ed41d4dd4 1417 SimulateInputMap["i_ph01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1418 SimulateInputMap["i_ph01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1419 SimulateInputMap["i_ph01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1420 SimulateInputMap["i_ph01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1421 SimulateInputMap["i_ph01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1422
davidjhoward 199:d65ed41d4dd4 1423 ModbusRegisterMap["i_ph_temp01"].simulated = true;
davidjhoward 214:52ef35bc44ec 1424 SimulateInputMap["i_ph_temp01"].start_value = 25000.0;
davidjhoward 199:d65ed41d4dd4 1425 SimulateInputMap["i_ph_temp01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1426 SimulateInputMap["i_ph_temp01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1427 SimulateInputMap["i_ph_temp01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1428 SimulateInputMap["i_ph_temp01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1429 SimulateInputMap["i_ph_temp01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1430
davidjhoward 199:d65ed41d4dd4 1431 ModbusRegisterMap["i_orp01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1432 SimulateInputMap["i_orp01"].start_value = 350;
davidjhoward 199:d65ed41d4dd4 1433 SimulateInputMap["i_orp01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1434 SimulateInputMap["i_orp01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1435 SimulateInputMap["i_orp01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1436 SimulateInputMap["i_orp01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1437 SimulateInputMap["i_orp01"].moving_up = true;
davidjhoward 179:a31ea334e2b7 1438
davidjhoward 179:a31ea334e2b7 1439 return;
davidjhoward 179:a31ea334e2b7 1440 }
davidjhoward 179:a31ea334e2b7 1441
davidjhoward 199:d65ed41d4dd4 1442 printf("\rsetting: simin i_tra01 130 120 140 1 .25\r\n");
davidjhoward 199:d65ed41d4dd4 1443 printf("\rsetting: simin i_tag01 100 90 110 1 .25\r\n");
davidjhoward 199:d65ed41d4dd4 1444 printf("\rsetting: simin i_bdcond01 1800 1725 1875 1 5\r\n");
davidjhoward 199:d65ed41d4dd4 1445 printf("\rsetting: simin i_ph01 8.0 7.25 8.75 .0. .1\r\n");
davidjhoward 199:d65ed41d4dd4 1446 printf("\rsetting: simin i_orp01 350 300 400 5 1\r\n");
davidjhoward 179:a31ea334e2b7 1447
davidjhoward 179:a31ea334e2b7 1448 ModbusRegisterMap["i_tra01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1449 SimulateInputMap["i_tra01"].start_value = 130;
davidjhoward 199:d65ed41d4dd4 1450 SimulateInputMap["i_tra01"].min = 120;
davidjhoward 199:d65ed41d4dd4 1451 SimulateInputMap["i_tra01"].max = 140;
davidjhoward 179:a31ea334e2b7 1452 SimulateInputMap["i_tra01"].up_step = 1;
davidjhoward 179:a31ea334e2b7 1453 SimulateInputMap["i_tra01"].down_step = .25;
jmarkel44 207:55aabde2d4bf 1454
davidjhoward 199:d65ed41d4dd4 1455 ModbusRegisterMap["i_tag01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1456 SimulateInputMap["i_tag01"].start_value = 100;
davidjhoward 199:d65ed41d4dd4 1457 SimulateInputMap["i_tag01"].min = 90;
davidjhoward 199:d65ed41d4dd4 1458 SimulateInputMap["i_tag01"].max = 110;
davidjhoward 199:d65ed41d4dd4 1459 SimulateInputMap["i_tag01"].up_step = 1;
davidjhoward 199:d65ed41d4dd4 1460 SimulateInputMap["i_tag01"].down_step = .25;
davidjhoward 179:a31ea334e2b7 1461
davidjhoward 179:a31ea334e2b7 1462 ModbusRegisterMap["i_bdcond01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1463 SimulateInputMap["i_bdcond01"].start_value = 1800;
davidjhoward 199:d65ed41d4dd4 1464 SimulateInputMap["i_bdcond01"].min = 1725;
davidjhoward 199:d65ed41d4dd4 1465 SimulateInputMap["i_bdcond01"].max = 1875;
davidjhoward 199:d65ed41d4dd4 1466 SimulateInputMap["i_bdcond01"].up_step = 1;
davidjhoward 199:d65ed41d4dd4 1467 SimulateInputMap["i_bdcond01"].down_step = 5;
jmarkel44 207:55aabde2d4bf 1468
davidjhoward 199:d65ed41d4dd4 1469 ModbusRegisterMap["i_ph01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1470 SimulateInputMap["i_ph01"].start_value = 8;
davidjhoward 199:d65ed41d4dd4 1471 SimulateInputMap["i_ph01"].min = 7.25;
davidjhoward 199:d65ed41d4dd4 1472 SimulateInputMap["i_ph01"].max = 8.75;
davidjhoward 199:d65ed41d4dd4 1473 SimulateInputMap["i_ph01"].up_step = .05;
davidjhoward 199:d65ed41d4dd4 1474 SimulateInputMap["i_ph01"].down_step = .1;
jmarkel44 207:55aabde2d4bf 1475
davidjhoward 199:d65ed41d4dd4 1476 ModbusRegisterMap["i_orp01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1477 SimulateInputMap["i_orp01"].start_value = 350;
davidjhoward 199:d65ed41d4dd4 1478 SimulateInputMap["i_orp01"].min = 300;
davidjhoward 199:d65ed41d4dd4 1479 SimulateInputMap["i_orp01"].max = 400;
davidjhoward 199:d65ed41d4dd4 1480 SimulateInputMap["i_orp01"].up_step = 5;
davidjhoward 199:d65ed41d4dd4 1481 SimulateInputMap["i_orp01"].down_step = 1;
davidjhoward 82:f3e495a98877 1482
davidjhoward 116:7337ed514891 1483 }
davidjhoward 116:7337ed514891 1484
davidjhoward 116:7337ed514891 1485 void cmd_deep( int argc, char **argv )
davidjhoward 116:7337ed514891 1486 {
davidjhoward 116:7337ed514891 1487 UNUSED(argc);
davidjhoward 116:7337ed514891 1488 UNUSED(argv);
davidjhoward 116:7337ed514891 1489
davidjhoward 123:ce602c91a9c3 1490 char logString[LOG_BYTES_PER_ENTRY];
davidjhoward 116:7337ed514891 1491
davidjhoward 116:7337ed514891 1492 LogLocalApi_PopEntry( logString );
davidjhoward 123:ce602c91a9c3 1493 if( logString[0] != '\0' ) {
davidjhoward 116:7337ed514891 1494 printf("%s\r\n", logString );
davidjhoward 123:ce602c91a9c3 1495 } else {
davidjhoward 116:7337ed514891 1496 printf("%s\r\n", "No String Found" );
davidjhoward 116:7337ed514891 1497 }
davidjhoward 116:7337ed514891 1498 }
davidjhoward 116:7337ed514891 1499
davidjhoward 116:7337ed514891 1500 void cmd_peep( int argc, char **argv )
davidjhoward 116:7337ed514891 1501 {
davidjhoward 116:7337ed514891 1502 UNUSED(argc);
davidjhoward 116:7337ed514891 1503 UNUSED(argv);
davidjhoward 116:7337ed514891 1504
davidjhoward 116:7337ed514891 1505 std::string logString = "This is a string to log";
davidjhoward 116:7337ed514891 1506
davidjhoward 116:7337ed514891 1507 LogLocalApi_PushEntry( logString.c_str() );
davidjhoward 123:ce602c91a9c3 1508 }
davidjhoward 123:ce602c91a9c3 1509
davidjhoward 123:ce602c91a9c3 1510 void cmd_inslog( int argc, char **argv )
davidjhoward 123:ce602c91a9c3 1511 {
davidjhoward 123:ce602c91a9c3 1512 UNUSED(argc);
davidjhoward 123:ce602c91a9c3 1513 UNUSED(argv);
davidjhoward 123:ce602c91a9c3 1514
davidjhoward 123:ce602c91a9c3 1515 EventReasonStruct_t eventReason;
davidjhoward 123:ce602c91a9c3 1516 eventReason.eventReason = EVENT_REASON_AUTO;
davidjhoward 123:ce602c91a9c3 1517 eventReason.inputValue = 100.00;
davidjhoward 123:ce602c91a9c3 1518 strncpy(eventReason.inputTag, "i_stub01", sizeof(eventReason.inputTag) );
davidjhoward 123:ce602c91a9c3 1519 eventReason.outputValue = 0.0;
davidjhoward 123:ce602c91a9c3 1520 strncpy(eventReason.outputTag, "o_stub01", sizeof(eventReason.outputTag) );
davidjhoward 123:ce602c91a9c3 1521 EventLoggerApi( eventReason );
davidjhoward 149:950c90425f7c 1522 }
davidjhoward 149:950c90425f7c 1523
davidjhoward 149:950c90425f7c 1524 void cmd_showSimin( int argc, char **argv )
davidjhoward 149:950c90425f7c 1525 {
davidjhoward 149:950c90425f7c 1526 std::map<std::string, SimulateInput>::iterator iter;
davidjhoward 149:950c90425f7c 1527 for (iter = SimulateInputMap.begin(); iter != SimulateInputMap.end(); ++iter) {
davidjhoward 150:4db35c8234b4 1528 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 1529 }
jmarkel44 177:9ec90c8e3ce1 1530 }
jmarkel44 177:9ec90c8e3ce1 1531
jmarkel44 231:f22901955e0c 1532 void cmd_preload(int argc, char **argv)
jmarkel44 177:9ec90c8e3ce1 1533 {
jmarkel44 177:9ec90c8e3ce1 1534 UNUSED(argc);
jmarkel44 177:9ec90c8e3ce1 1535 UNUSED(argv);
jmarkel44 177:9ec90c8e3ce1 1536
jmarkel44 177:9ec90c8e3ce1 1537 char buf[MAX_FILE_SIZE];
jmarkel44 231:f22901955e0c 1538 bool rc;
jmarkel44 177:9ec90c8e3ce1 1539
jmarkel44 231:f22901955e0c 1540 // PRELOADER:
jmarkel44 231:f22901955e0c 1541 //
jmarkel44 231:f22901955e0c 1542 // Inputs:
jmarkel44 231:f22901955e0c 1543 // input_i_bdcond.json // conductivity probe
jmarkel44 231:f22901955e0c 1544 // input_i_bdcond_temp.json // conductivity probe : temperature
jmarkel44 231:f22901955e0c 1545 // input_i_flowsw01.json // flow switch
jmarkel44 231:f22901955e0c 1546 // input_i_orp01.json // ORP probe
jmarkel44 231:f22901955e0c 1547 // input_i_ph01.json // pH probe
jmarkel44 231:f22901955e0c 1548 // input_i_ph01_temp.json // pH probe : temperature
jmarkel44 231:f22901955e0c 1549 // input_i_tag01.json // tag (flu)
jmarkel44 231:f22901955e0c 1550 // input_i_tra01.json // Trasar
jmarkel44 231:f22901955e0c 1551 //
jmarkel44 231:f22901955e0c 1552 // Outputs:
jmarkel44 231:f22901955e0c 1553 // output_o_rly01.json // relay-1
jmarkel44 231:f22901955e0c 1554 // output_o_rly02.json // relay-2
jmarkel44 231:f22901955e0c 1555 //
jmarkel44 231:f22901955e0c 1556 // Standard Controls:
jmarkel44 231:f22901955e0c 1557 // control_sp_bd01.json // blowdown
jmarkel44 231:f22901955e0c 1558 // control_sp_tra01.json // Trasar
jmarkel44 231:f22901955e0c 1559 //
jmarkel44 231:f22901955e0c 1560 // Control Algorithms:
jmarkel44 231:f22901955e0c 1561 // control_ca_eq1.json // == 1
jmarkel44 231:f22901955e0c 1562 // control_ca_eq129.json // == 129
jmarkel44 231:f22901955e0c 1563 //
jmarkel44 231:f22901955e0c 1564 // Composite Controls:
jmarkel44 231:f22901955e0c 1565 // control_comp_flow.json // flow override
jmarkel44 231:f22901955e0c 1566 // control_comp_lockout.json // lockout blowdown
davidjhoward 197:594afd088f32 1567
jmarkel44 231:f22901955e0c 1568 std::string filename = "input_i_bdcond.json";
jmarkel44 177:9ec90c8e3ce1 1569
jmarkel44 177:9ec90c8e3ce1 1570 // INPUT: Conductivity
jmarkel44 177:9ec90c8e3ce1 1571 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1572 "{ "
jmarkel44 177:9ec90c8e3ce1 1573 "\"id\": \"i_bdcond01\","
jmarkel44 177:9ec90c8e3ce1 1574 "\"name\": \"Tower Conductivity\", "
davidjhoward 186:16912aa18c2a 1575 "\"units\": \"uS\","
davidjhoward 186:16912aa18c2a 1576 "\"min\": \"0\","
davidjhoward 186:16912aa18c2a 1577 "\"max\": \"6000\","
davidjhoward 186:16912aa18c2a 1578 "\"node\": \"21\","
davidjhoward 186:16912aa18c2a 1579 "\"reg\": \"18\","
davidjhoward 190:af7ab603c9fe 1580 "\"rtype\": \"4\","
davidjhoward 186:16912aa18c2a 1581 "\"type\": \"1\","
davidjhoward 186:16912aa18c2a 1582 "\"size\": \"2\","
davidjhoward 186:16912aa18c2a 1583 "\"order\": \"2\","
davidjhoward 186:16912aa18c2a 1584 "\"fmt\": \"%%.2f\","
davidjhoward 186:16912aa18c2a 1585 "\"vcmd\": \"\","
jmarkel44 177:9ec90c8e3ce1 1586 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1587 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1588 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1589 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1590 return;
jmarkel44 177:9ec90c8e3ce1 1591 } else {
jmarkel44 231:f22901955e0c 1592 printf("\r...generated %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1593 }
jmarkel44 177:9ec90c8e3ce1 1594
jmarkel44 231:f22901955e0c 1595 Thread::wait(1000);
davidjhoward 197:594afd088f32 1596
davidjhoward 197:594afd088f32 1597 // INPUT: Conductivity Temperature
jmarkel44 231:f22901955e0c 1598 filename = "input_i_bdcond_temp.json";
davidjhoward 186:16912aa18c2a 1599 snprintf(buf, sizeof(buf),
davidjhoward 186:16912aa18c2a 1600 "{ "
davidjhoward 199:d65ed41d4dd4 1601 "\"id\": \"i_cond_temp01\","
davidjhoward 186:16912aa18c2a 1602 "\"name\": \"Temp Conductivity\","
davidjhoward 186:16912aa18c2a 1603 "\"units\": \"C\","
davidjhoward 186:16912aa18c2a 1604 "\"min\": \"0\","
davidjhoward 186:16912aa18c2a 1605 "\"max\": \"80\","
davidjhoward 186:16912aa18c2a 1606 "\"node\": \"21\","
davidjhoward 186:16912aa18c2a 1607 "\"reg\": \"10\","
davidjhoward 190:af7ab603c9fe 1608 "\"rtype\": \"4\","
davidjhoward 186:16912aa18c2a 1609 "\"type\": \"1\","
davidjhoward 186:16912aa18c2a 1610 "\"size\": \"2\","
davidjhoward 186:16912aa18c2a 1611 "\"order\": \"2\","
davidjhoward 186:16912aa18c2a 1612 "\"fmt\": \"%%.2f\","
davidjhoward 186:16912aa18c2a 1613 "\"vcmd\": \"\","
davidjhoward 186:16912aa18c2a 1614 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1615 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
davidjhoward 186:16912aa18c2a 1616 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1617 printf("\rFailed to save %s\n", filename.c_str());
davidjhoward 186:16912aa18c2a 1618 return;
davidjhoward 186:16912aa18c2a 1619 } else {
jmarkel44 231:f22901955e0c 1620 printf("\r...generated %s\n", filename.c_str());
davidjhoward 186:16912aa18c2a 1621 }
davidjhoward 186:16912aa18c2a 1622
jmarkel44 231:f22901955e0c 1623 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1624
jmarkel44 231:f22901955e0c 1625 // INPUT: Flow Switch
jmarkel44 231:f22901955e0c 1626 filename = "input_i_flowsw01.json";
davidjhoward 190:af7ab603c9fe 1627 snprintf(buf, sizeof(buf),
davidjhoward 190:af7ab603c9fe 1628 "{ "
jmarkel44 231:f22901955e0c 1629 "\"id\": \"i_flowsw01\","
jmarkel44 231:f22901955e0c 1630 "\"name\": \"Flow\","
jmarkel44 231:f22901955e0c 1631 "\"units\": \"\","
jmarkel44 231:f22901955e0c 1632 "\"min\": \"0\","
jmarkel44 231:f22901955e0c 1633 "\"max\": \"1\","
jmarkel44 231:f22901955e0c 1634 "\"node\": \"0\","
jmarkel44 231:f22901955e0c 1635 "\"reg\": \"1\","
jmarkel44 231:f22901955e0c 1636 "\"rtype\": \"0\","
jmarkel44 231:f22901955e0c 1637 "\"type\": \"3\","
jmarkel44 231:f22901955e0c 1638 "\"size\": \"2\","
jmarkel44 231:f22901955e0c 1639 "\"order\": \"0\","
jmarkel44 231:f22901955e0c 1640 "\"fmt\": \"%%d\","
jmarkel44 231:f22901955e0c 1641 "\"vcmd\": \"\","
jmarkel44 231:f22901955e0c 1642 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1643 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 1644 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1645 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1646 return;
jmarkel44 231:f22901955e0c 1647 } else {
jmarkel44 231:f22901955e0c 1648 printf("\r...generated %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1649 }
jmarkel44 231:f22901955e0c 1650
jmarkel44 231:f22901955e0c 1651 Thread::wait(1000);
jmarkel44 231:f22901955e0c 1652
jmarkel44 231:f22901955e0c 1653 // INPUT: ORP
jmarkel44 231:f22901955e0c 1654 filename = "input_i_orp01.json";
jmarkel44 231:f22901955e0c 1655 snprintf(buf, sizeof(buf),
jmarkel44 231:f22901955e0c 1656 "{ "
jmarkel44 231:f22901955e0c 1657 "\"id\": \"i_orp01\","
jmarkel44 231:f22901955e0c 1658 "\"name\": \"ORP\","
jmarkel44 231:f22901955e0c 1659 "\"units\": \"mV\","
davidjhoward 190:af7ab603c9fe 1660 "\"min\": \"0\","
davidjhoward 199:d65ed41d4dd4 1661 "\"max\": \"10\","
jmarkel44 231:f22901955e0c 1662 "\"node\": \"23\","
jmarkel44 231:f22901955e0c 1663 "\"reg\": \"14\","
davidjhoward 199:d65ed41d4dd4 1664 "\"rtype\": \"4\","
davidjhoward 199:d65ed41d4dd4 1665 "\"type\": \"1\","
davidjhoward 190:af7ab603c9fe 1666 "\"size\": \"2\","
davidjhoward 190:af7ab603c9fe 1667 "\"order\": \"2\","
davidjhoward 190:af7ab603c9fe 1668 "\"fmt\": \"%%.2f\","
davidjhoward 190:af7ab603c9fe 1669 "\"vcmd\": \"\","
davidjhoward 190:af7ab603c9fe 1670 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1671 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
davidjhoward 190:af7ab603c9fe 1672 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1673 printf("\rFailed to save %s\n", filename.c_str());
davidjhoward 190:af7ab603c9fe 1674 return;
davidjhoward 190:af7ab603c9fe 1675 } else {
jmarkel44 231:f22901955e0c 1676 printf("\r...generated %s\n", filename.c_str());
davidjhoward 190:af7ab603c9fe 1677 }
davidjhoward 190:af7ab603c9fe 1678
jmarkel44 231:f22901955e0c 1679 Thread::wait(1000);
jmarkel44 207:55aabde2d4bf 1680
jmarkel44 207:55aabde2d4bf 1681 // INPUT: pH
jmarkel44 231:f22901955e0c 1682 filename = "input_i_ph01.json";
davidjhoward 199:d65ed41d4dd4 1683 snprintf(buf, sizeof(buf),
davidjhoward 199:d65ed41d4dd4 1684 "{ "
davidjhoward 199:d65ed41d4dd4 1685 "\"id\": \"i_ph01\","
davidjhoward 199:d65ed41d4dd4 1686 "\"name\": \"pH\","
davidjhoward 199:d65ed41d4dd4 1687 "\"units\": \"pH\","
davidjhoward 199:d65ed41d4dd4 1688 "\"min\": \"0\","
davidjhoward 199:d65ed41d4dd4 1689 "\"max\": \"10\","
davidjhoward 199:d65ed41d4dd4 1690 "\"node\": \"22\","
davidjhoward 199:d65ed41d4dd4 1691 "\"reg\": \"18\","
davidjhoward 199:d65ed41d4dd4 1692 "\"rtype\": \"4\","
davidjhoward 199:d65ed41d4dd4 1693 "\"type\": \"1\","
davidjhoward 199:d65ed41d4dd4 1694 "\"size\": \"2\","
davidjhoward 199:d65ed41d4dd4 1695 "\"order\": \"2\","
davidjhoward 199:d65ed41d4dd4 1696 "\"fmt\": \"%%.2f\","
davidjhoward 199:d65ed41d4dd4 1697 "\"vcmd\": \"\","
davidjhoward 199:d65ed41d4dd4 1698 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1699 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
davidjhoward 199:d65ed41d4dd4 1700 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1701 printf("\rFailed to save %s\n", filename.c_str());
davidjhoward 199:d65ed41d4dd4 1702 return;
davidjhoward 199:d65ed41d4dd4 1703 } else {
jmarkel44 231:f22901955e0c 1704 printf("\r...generated %s\n", filename.c_str());
davidjhoward 199:d65ed41d4dd4 1705 }
davidjhoward 199:d65ed41d4dd4 1706
jmarkel44 231:f22901955e0c 1707 Thread::wait(1000);
davidjhoward 199:d65ed41d4dd4 1708
jmarkel44 231:f22901955e0c 1709 // INPUT: pH Temperature
jmarkel44 231:f22901955e0c 1710 filename = "input_i_ph01_temp.json";
davidjhoward 199:d65ed41d4dd4 1711 snprintf(buf, sizeof(buf),
davidjhoward 199:d65ed41d4dd4 1712 "{ "
jmarkel44 231:f22901955e0c 1713 "\"id\": \"i_ph_temp01\","
jmarkel44 231:f22901955e0c 1714 "\"name\": \"Temp pH\","
jmarkel44 231:f22901955e0c 1715 "\"units\": \"C\","
davidjhoward 199:d65ed41d4dd4 1716 "\"min\": \"0\","
davidjhoward 199:d65ed41d4dd4 1717 "\"max\": \"10\","
jmarkel44 231:f22901955e0c 1718 "\"node\": \"22\","
jmarkel44 231:f22901955e0c 1719 "\"reg\": \"10\","
davidjhoward 199:d65ed41d4dd4 1720 "\"rtype\": \"4\","
davidjhoward 199:d65ed41d4dd4 1721 "\"type\": \"1\","
davidjhoward 199:d65ed41d4dd4 1722 "\"size\": \"2\","
davidjhoward 199:d65ed41d4dd4 1723 "\"order\": \"2\","
davidjhoward 199:d65ed41d4dd4 1724 "\"fmt\": \"%%.2f\","
davidjhoward 199:d65ed41d4dd4 1725 "\"vcmd\": \"\","
davidjhoward 199:d65ed41d4dd4 1726 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1727 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
davidjhoward 199:d65ed41d4dd4 1728 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1729 printf("\rFailed to save %s\n", filename.c_str());
davidjhoward 199:d65ed41d4dd4 1730 return;
davidjhoward 199:d65ed41d4dd4 1731 } else {
jmarkel44 231:f22901955e0c 1732 printf("\r...generated %s\n", filename.c_str());
davidjhoward 203:9d735375f218 1733 }
davidjhoward 203:9d735375f218 1734
jmarkel44 231:f22901955e0c 1735 Thread::wait(1000);
davidjhoward 203:9d735375f218 1736
jmarkel44 231:f22901955e0c 1737 // INPUT: Tag
jmarkel44 231:f22901955e0c 1738 filename = "input_i_tag01.json";
davidjhoward 214:52ef35bc44ec 1739 snprintf(buf, sizeof(buf),
davidjhoward 214:52ef35bc44ec 1740 "{ "
jmarkel44 231:f22901955e0c 1741 "\"id\": \"i_tag01\","
jmarkel44 231:f22901955e0c 1742 "\"name\": \"Tag\", "
jmarkel44 231:f22901955e0c 1743 "\"units\": \"PPM\", "
jmarkel44 231:f22901955e0c 1744 "\"min\": \"0\", "
jmarkel44 231:f22901955e0c 1745 "\"max\": \"300\", "
jmarkel44 231:f22901955e0c 1746 "\"node\": \"1\", "
jmarkel44 231:f22901955e0c 1747 "\"reg\": \"11\", "
jmarkel44 231:f22901955e0c 1748 "\"rtype\": \"4\", "
jmarkel44 231:f22901955e0c 1749 "\"type\": \"0\", "
jmarkel44 231:f22901955e0c 1750 "\"size\": \"2\", "
jmarkel44 231:f22901955e0c 1751 "\"order\": \"2\", "
jmarkel44 231:f22901955e0c 1752 "\"fmt\": \"%%.2f\", "
jmarkel44 231:f22901955e0c 1753 "\"vcmd\": \"\", "
jmarkel44 231:f22901955e0c 1754 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1755 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 1756 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1757 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1758 return;
jmarkel44 231:f22901955e0c 1759 } else {
jmarkel44 231:f22901955e0c 1760 printf("\r...generated %s\n", filename.c_str());
davidjhoward 214:52ef35bc44ec 1761 }
davidjhoward 214:52ef35bc44ec 1762
jmarkel44 231:f22901955e0c 1763 Thread::wait(1000);
jmarkel44 220:dbe21411f962 1764
jmarkel44 231:f22901955e0c 1765 // INPUT: Trasar
jmarkel44 231:f22901955e0c 1766 filename = "input_i_tra01.json";
davidjhoward 216:7783e894f7e0 1767 snprintf(buf, sizeof(buf),
davidjhoward 216:7783e894f7e0 1768 "{ "
jmarkel44 231:f22901955e0c 1769 "\"id\": \"i_tra01\","
jmarkel44 231:f22901955e0c 1770 "\"name\": \"Trasar\", "
jmarkel44 231:f22901955e0c 1771 "\"units\": \"PPM\", "
jmarkel44 231:f22901955e0c 1772 "\"min\": \"0\", "
jmarkel44 231:f22901955e0c 1773 "\"max\": \"300\", "
jmarkel44 231:f22901955e0c 1774 "\"node\": \"1\", "
jmarkel44 231:f22901955e0c 1775 "\"reg\": \"9\", "
jmarkel44 231:f22901955e0c 1776 "\"rtype\": \"4\", "
jmarkel44 231:f22901955e0c 1777 "\"type\": \"0\", "
jmarkel44 231:f22901955e0c 1778 "\"size\": \"2\", "
jmarkel44 231:f22901955e0c 1779 "\"order\": \"2\", "
jmarkel44 231:f22901955e0c 1780 "\"fmt\": \"%%.2f\", "
jmarkel44 231:f22901955e0c 1781 "\"vcmd\": \"\", "
jmarkel44 231:f22901955e0c 1782 "\"rfreq\": \"5\" }");
jmarkel44 231:f22901955e0c 1783 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 1784 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1785 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1786 return;
jmarkel44 231:f22901955e0c 1787 } else {
jmarkel44 231:f22901955e0c 1788 printf("\r...generated %s\n", filename.c_str());
davidjhoward 216:7783e894f7e0 1789 }
davidjhoward 216:7783e894f7e0 1790
jmarkel44 231:f22901955e0c 1791 Thread::wait(1000);
davidjhoward 214:52ef35bc44ec 1792
jmarkel44 177:9ec90c8e3ce1 1793 // OUTPUT: Relay 01
jmarkel44 231:f22901955e0c 1794 filename = "output_o_rly01.json";
jmarkel44 177:9ec90c8e3ce1 1795 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1796 "{ "
jmarkel44 177:9ec90c8e3ce1 1797 "\"id\": \"o_rly01\", "
jmarkel44 177:9ec90c8e3ce1 1798 "\"name\": \"Blowdown\", "
jmarkel44 177:9ec90c8e3ce1 1799 "\"units\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1800 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1801 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1802 "\"node\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1803 "\"reg\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1804 "\"rtype\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1805 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1806 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1807 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1808 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1809 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1810 "\"rfreq\": \"5\", "
jmarkel44 177:9ec90c8e3ce1 1811 "\"toperiod\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1812 "\"scalelo\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1813 "\"scalehi\": \"100\" }");
jmarkel44 231:f22901955e0c 1814 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1815 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1816 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1817 return;
jmarkel44 177:9ec90c8e3ce1 1818 } else {
jmarkel44 231:f22901955e0c 1819 printf("\r...generated %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1820 }
jmarkel44 177:9ec90c8e3ce1 1821
jmarkel44 231:f22901955e0c 1822 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1823
jmarkel44 177:9ec90c8e3ce1 1824 // OUTPUT: Relay 02
jmarkel44 231:f22901955e0c 1825 filename = "output_o_rly02.json";
jmarkel44 177:9ec90c8e3ce1 1826 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1827 "{ "
jmarkel44 177:9ec90c8e3ce1 1828 "\"id\": \"o_rly02\", "
jmarkel44 177:9ec90c8e3ce1 1829 "\"name\": \"3DTS86\", "
jmarkel44 177:9ec90c8e3ce1 1830 "\"units\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1831 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1832 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1833 "\"node\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1834 "\"reg\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1835 "\"rtype\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1836 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1837 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1838 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1839 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1840 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1841 "\"rfreq\": \"5\", "
jmarkel44 177:9ec90c8e3ce1 1842 "\"toperiod\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1843 "\"scalelo\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1844 "\"scalehi\": \"100\" }");
jmarkel44 231:f22901955e0c 1845 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1846 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1847 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1848 return;
jmarkel44 177:9ec90c8e3ce1 1849 } else {
jmarkel44 231:f22901955e0c 1850 printf("\r...generated %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1851 }
jmarkel44 177:9ec90c8e3ce1 1852
jmarkel44 231:f22901955e0c 1853 Thread::wait(1000);
davidjhoward 203:9d735375f218 1854
jmarkel44 177:9ec90c8e3ce1 1855 // SETPOINT: Blowdown
jmarkel44 231:f22901955e0c 1856 filename = "control_sp_bd01.json";
jmarkel44 177:9ec90c8e3ce1 1857 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1858 "{ "
jmarkel44 177:9ec90c8e3ce1 1859 "\"id\": \"BLOWDOWN_01\", "
jmarkel44 177:9ec90c8e3ce1 1860 "\"priority\": \"800\", "
jmarkel44 177:9ec90c8e3ce1 1861 "\"input\": \"i_bdcond01\", "
jmarkel44 177:9ec90c8e3ce1 1862 "\"output\": \"o_rly01\", "
davidjhoward 199:d65ed41d4dd4 1863 "\"setpoint\": \"1800\", "
jmarkel44 177:9ec90c8e3ce1 1864 "\"prodfact\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1865 "\"actingDir\": \"1\", "
davidjhoward 199:d65ed41d4dd4 1866 "\"halert\": \"2400\", "
davidjhoward 199:d65ed41d4dd4 1867 "\"lalert\": \"800\", "
davidjhoward 199:d65ed41d4dd4 1868 "\"hfs\": \"2700\", "
davidjhoward 199:d65ed41d4dd4 1869 "\"lfs\": \"700\", "
davidjhoward 199:d65ed41d4dd4 1870 "\"tol\": \"30\" }");
jmarkel44 231:f22901955e0c 1871 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1872 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1873 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1874 return;
jmarkel44 177:9ec90c8e3ce1 1875 } else {
jmarkel44 231:f22901955e0c 1876 printf("\r...generated %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1877 }
jmarkel44 177:9ec90c8e3ce1 1878
jmarkel44 231:f22901955e0c 1879 Thread::wait(1000);
jmarkel44 177:9ec90c8e3ce1 1880
jmarkel44 177:9ec90c8e3ce1 1881 // SETPOINT: Trasar
jmarkel44 231:f22901955e0c 1882 filename = "control_sp_tra01.json";
jmarkel44 177:9ec90c8e3ce1 1883 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1884 "{ "
jmarkel44 177:9ec90c8e3ce1 1885 "\"id\": \"INH_TRA_01\", "
jmarkel44 177:9ec90c8e3ce1 1886 "\"priority\": \"800\", "
jmarkel44 177:9ec90c8e3ce1 1887 "\"input\": \"i_tra01\", "
jmarkel44 177:9ec90c8e3ce1 1888 "\"output\": \"o_rly02\", "
davidjhoward 199:d65ed41d4dd4 1889 "\"setpoint\": \"130\", "
jmarkel44 177:9ec90c8e3ce1 1890 "\"prodfact\": \"100\", "
jmarkel44 177:9ec90c8e3ce1 1891 "\"actingDir\": \"0\", "
davidjhoward 199:d65ed41d4dd4 1892 "\"halert\": \"190\", "
davidjhoward 199:d65ed41d4dd4 1893 "\"lalert\": \"92\", "
davidjhoward 199:d65ed41d4dd4 1894 "\"hfs\": \"200\", "
jmarkel44 177:9ec90c8e3ce1 1895 "\"lfs\": \"70\", "
davidjhoward 199:d65ed41d4dd4 1896 "\"tol\": \"4\" }");
jmarkel44 231:f22901955e0c 1897 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1898 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1899 printf("\rFailed to save %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1900 return;
jmarkel44 177:9ec90c8e3ce1 1901 } else {
jmarkel44 231:f22901955e0c 1902 printf("\r...generated %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1903 }
jmarkel44 231:f22901955e0c 1904
jmarkel44 231:f22901955e0c 1905 Thread::wait(1000);
jmarkel44 231:f22901955e0c 1906
jmarkel44 231:f22901955e0c 1907 // ALGORITHM == 1
jmarkel44 231:f22901955e0c 1908 filename = "control_ca_eq1.json";
jmarkel44 231:f22901955e0c 1909 snprintf(buf, sizeof(buf),
jmarkel44 231:f22901955e0c 1910 "{"
jmarkel44 231:f22901955e0c 1911 "\"id\": \"EQUAL_TO_1\", "
jmarkel44 231:f22901955e0c 1912 "\"opr\": \"1\", "
jmarkel44 231:f22901955e0c 1913 "\"op\": \"==\", "
jmarkel44 231:f22901955e0c 1914 "\"true\": \"responseA\", "
jmarkel44 231:f22901955e0c 1915 "\"false\": \"nothing\" "
jmarkel44 231:f22901955e0c 1916 "}");
jmarkel44 231:f22901955e0c 1917
jmarkel44 231:f22901955e0c 1918 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 1919 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1920 printf("\rFailed to save user file %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1921 return;
jmarkel44 231:f22901955e0c 1922 } else {
jmarkel44 231:f22901955e0c 1923 printf("\r...generated %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1924 }
jmarkel44 231:f22901955e0c 1925
jmarkel44 231:f22901955e0c 1926 Thread::wait(1000);
jmarkel44 231:f22901955e0c 1927
jmarkel44 231:f22901955e0c 1928 // ALGORITHM == 129
jmarkel44 231:f22901955e0c 1929 filename = "control_ca_greq129.json";
jmarkel44 231:f22901955e0c 1930 snprintf(buf, sizeof(buf),
jmarkel44 231:f22901955e0c 1931 "{"
jmarkel44 231:f22901955e0c 1932 "\"id\": \"EQUAL_TO_129\", "
jmarkel44 231:f22901955e0c 1933 "\"opr\": \"129\", "
jmarkel44 231:f22901955e0c 1934 "\"op\": \"==\", "
jmarkel44 231:f22901955e0c 1935 "\"true\": \"responseA\", "
jmarkel44 231:f22901955e0c 1936 "\"false\": \"nothing\" "
jmarkel44 231:f22901955e0c 1937 "}");
jmarkel44 231:f22901955e0c 1938
jmarkel44 231:f22901955e0c 1939 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 1940 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1941 printf("\rFailed to save user file %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1942 return;
jmarkel44 231:f22901955e0c 1943 } else {
jmarkel44 231:f22901955e0c 1944 printf("\r...generated %s\n", filename.c_str());
jmarkel44 177:9ec90c8e3ce1 1945 }
jmarkel44 177:9ec90c8e3ce1 1946
jmarkel44 231:f22901955e0c 1947 // FLOW
jmarkel44 231:f22901955e0c 1948 filename = "control_comp_flow.json";
jmarkel44 231:f22901955e0c 1949 snprintf(buf, sizeof(buf),
jmarkel44 231:f22901955e0c 1950 "{ "
jmarkel44 231:f22901955e0c 1951 "\"id\": \"FLOW_OVERRIDE\", "
jmarkel44 231:f22901955e0c 1952 "\"tag\": \"i_flowsw01\", "
jmarkel44 231:f22901955e0c 1953 "\"ca\": \"EQUAL_TO_1\", "
jmarkel44 231:f22901955e0c 1954 "\"priority\": \"400\", "
jmarkel44 231:f22901955e0c 1955 "\"entries\": \"2\", "
jmarkel44 231:f22901955e0c 1956 "\"outputs\": [ "
jmarkel44 231:f22901955e0c 1957 "{"
jmarkel44 231:f22901955e0c 1958 "\"tag\": \"o_rly01\", "
jmarkel44 231:f22901955e0c 1959 "\"responseA\": \"fixed off\" "
jmarkel44 231:f22901955e0c 1960 "},"
jmarkel44 231:f22901955e0c 1961 "{"
jmarkel44 231:f22901955e0c 1962 "\"tag\": \"o_rly02\", "
jmarkel44 231:f22901955e0c 1963 "\"responseA\": \"fixed off\" "
jmarkel44 231:f22901955e0c 1964 "}"
jmarkel44 231:f22901955e0c 1965 "]"
jmarkel44 231:f22901955e0c 1966 "}"
jmarkel44 231:f22901955e0c 1967 );
jmarkel44 231:f22901955e0c 1968 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 1969 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1970 printf("\rFailed to save user file %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1971 return;
jmarkel44 231:f22901955e0c 1972 } else {
jmarkel44 231:f22901955e0c 1973 printf("\r...generated %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1974 }
davidjhoward 203:9d735375f218 1975
jmarkel44 231:f22901955e0c 1976 // LOCKOUT
jmarkel44 231:f22901955e0c 1977 filename = "control_comp_lockout.json";
jmarkel44 231:f22901955e0c 1978 snprintf(buf, sizeof(buf),
jmarkel44 231:f22901955e0c 1979 "{ "
jmarkel44 231:f22901955e0c 1980 "\"id\": \"LOCKOUT_BLOWDOWN\", "
jmarkel44 231:f22901955e0c 1981 "\"tag\": \"o_rly01\", "
jmarkel44 231:f22901955e0c 1982 "\"ca\": \"EQUAL_TO_129\", "
jmarkel44 231:f22901955e0c 1983 "\"priority\": \"400\", "
jmarkel44 231:f22901955e0c 1984 "\"entries\": \"1\", "
jmarkel44 231:f22901955e0c 1985 "\"outputs\": [ "
jmarkel44 231:f22901955e0c 1986 "{"
jmarkel44 231:f22901955e0c 1987 "\"tag\": \"o_rly02\", "
jmarkel44 231:f22901955e0c 1988 "\"responseA\": \"fixed off\" "
jmarkel44 231:f22901955e0c 1989 "}"
jmarkel44 231:f22901955e0c 1990 "]"
jmarkel44 231:f22901955e0c 1991 "}"
jmarkel44 231:f22901955e0c 1992 );
jmarkel44 231:f22901955e0c 1993 rc = GLOBAL_mdot->saveUserFile(filename.c_str(), (void *)buf, MAX_FILE_SIZE);
jmarkel44 231:f22901955e0c 1994 if ( rc != true ) {
jmarkel44 231:f22901955e0c 1995 printf("\rFailed to save user file %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1996 return;
jmarkel44 231:f22901955e0c 1997 } else {
jmarkel44 231:f22901955e0c 1998 printf("\r...generated %s\n", filename.c_str());
jmarkel44 231:f22901955e0c 1999 }
jmarkel44 231:f22901955e0c 2000
jmarkel44 231:f22901955e0c 2001 printf("\r\nIssue \"reset\" command to invoke changes\r\n\r\n\r\n");
jmarkel44 207:55aabde2d4bf 2002
davidjhoward 186:16912aa18c2a 2003 }
davidjhoward 186:16912aa18c2a 2004
davidjhoward 186:16912aa18c2a 2005 /*****************************************************************************
davidjhoward 186:16912aa18c2a 2006 * Function: cmd_createTemp
davidjhoward 186:16912aa18c2a 2007 * Description: create input file
davidjhoward 186:16912aa18c2a 2008 *
davidjhoward 186:16912aa18c2a 2009 * @param argc-> number of args
davidjhoward 186:16912aa18c2a 2010 * @param argv-> filename
davidjhoward 186:16912aa18c2a 2011 * @return none
davidjhoward 186:16912aa18c2a 2012 *****************************************************************************/
davidjhoward 186:16912aa18c2a 2013 void cmd_createTemp(int argc, char **argv)
davidjhoward 186:16912aa18c2a 2014 {
davidjhoward 186:16912aa18c2a 2015 char data_buf[MAX_FILE_SIZE];
davidjhoward 186:16912aa18c2a 2016 snprintf(data_buf, sizeof(data_buf),
davidjhoward 186:16912aa18c2a 2017 "{ "
davidjhoward 186:16912aa18c2a 2018 "\"id\": \"i_temp01\", "
davidjhoward 186:16912aa18c2a 2019 "\"name\": \"Temp Conductivity\", "
davidjhoward 186:16912aa18c2a 2020 "\"units\": \"C\", "
davidjhoward 186:16912aa18c2a 2021 "\"min\": \"0\", "
davidjhoward 186:16912aa18c2a 2022 "\"max\": \"300\", "
davidjhoward 186:16912aa18c2a 2023 "\"node\": \"21\", "
davidjhoward 186:16912aa18c2a 2024 "\"reg\": \"10\", "
davidjhoward 186:16912aa18c2a 2025 "\"rtype\": \"1\", "
davidjhoward 186:16912aa18c2a 2026 "\"type\": \"1\", "
davidjhoward 186:16912aa18c2a 2027 "\"size\": \"2\", "
davidjhoward 186:16912aa18c2a 2028 "\"order\": \"2\", "
davidjhoward 186:16912aa18c2a 2029 "\"rfreq\": \"5\", "
davidjhoward 186:16912aa18c2a 2030 "\"vcmd\": \"\","
davidjhoward 186:16912aa18c2a 2031 "\"fmt\": \"%%.2f\" } ");
davidjhoward 186:16912aa18c2a 2032
davidjhoward 186:16912aa18c2a 2033 bool status = GLOBAL_mdot->saveUserFile("input_i_temp01.json", (void *)data_buf, MAX_FILE_SIZE);
davidjhoward 186:16912aa18c2a 2034 if( status != true ) {
davidjhoward 186:16912aa18c2a 2035 logInfo("(%d)save file failed, status=%d", __LINE__, status);
davidjhoward 186:16912aa18c2a 2036 }
davidjhoward 186:16912aa18c2a 2037
davidjhoward 186:16912aa18c2a 2038 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", "input_i_temp01.json");
davidjhoward 186:16912aa18c2a 2039 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 186:16912aa18c2a 2040 mail->action = ACTION_READ_FILE;
davidjhoward 186:16912aa18c2a 2041 strncpy( mail->controlFile, "input_i_temp01.json", (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 2042 ModbusMasterMailBox.put(mail);
davidjhoward 186:16912aa18c2a 2043 }
davidjhoward 186:16912aa18c2a 2044
davidjhoward 186:16912aa18c2a 2045 /*****************************************************************************
davidjhoward 186:16912aa18c2a 2046 * Function: cmd_createBDCond
davidjhoward 186:16912aa18c2a 2047 * Description: create input file
davidjhoward 186:16912aa18c2a 2048 *
davidjhoward 186:16912aa18c2a 2049 * @param argc-> number of args
davidjhoward 186:16912aa18c2a 2050 * @param argv-> filename
davidjhoward 186:16912aa18c2a 2051 * @return none
davidjhoward 186:16912aa18c2a 2052 *****************************************************************************/
davidjhoward 197:594afd088f32 2053 void cmd_modbusCmd(int argc, char **argv)
davidjhoward 186:16912aa18c2a 2054 {
davidjhoward 197:594afd088f32 2055 if ( (argc != 7) && (argc != 8)) {
davidjhoward 199:d65ed41d4dd4 2056 printf("\r\nusage: mod-cmd <node> <func> <sreg> <nreg> <dtype> <order> <value>\r\n");
davidjhoward 199:d65ed41d4dd4 2057 printf("example (read product factor): mod-cmd 1 3 40 2 0 2\r\n");
davidjhoward 199:d65ed41d4dd4 2058 printf("example (write product factor): mod-cmd 1 16 40 2 0 2 100.0\r\n");
davidjhoward 186:16912aa18c2a 2059 return;
davidjhoward 186:16912aa18c2a 2060 }
davidjhoward 186:16912aa18c2a 2061
davidjhoward 197:594afd088f32 2062 char snd_buf[128];
davidjhoward 186:16912aa18c2a 2063
davidjhoward 197:594afd088f32 2064 memset( snd_buf, '\0', 128 );
davidjhoward 197:594afd088f32 2065 snprintf(snd_buf, sizeof(snd_buf),
davidjhoward 197:594afd088f32 2066 "{"
davidjhoward 197:594afd088f32 2067 "\"id\":\"%s\","
davidjhoward 197:594afd088f32 2068 "\"node\":\"%s\","
davidjhoward 197:594afd088f32 2069 "\"func\":\"%s\","
davidjhoward 197:594afd088f32 2070 "\"sreg\":\"%s\","
davidjhoward 197:594afd088f32 2071 "\"nreg\":\"%s\","
davidjhoward 197:594afd088f32 2072 "\"dtype\":\"%s\","
davidjhoward 197:594afd088f32 2073 "\"order\":\"%s\","
davidjhoward 197:594afd088f32 2074 "\"value\":\"%s\"}",
davidjhoward 197:594afd088f32 2075 "READ_MODBUS",
davidjhoward 197:594afd088f32 2076 argv[1],
davidjhoward 197:594afd088f32 2077 argv[2],
davidjhoward 197:594afd088f32 2078 argv[3],
davidjhoward 197:594afd088f32 2079 argv[4],
davidjhoward 197:594afd088f32 2080 argv[5],
davidjhoward 197:594afd088f32 2081 argv[6],
davidjhoward 197:594afd088f32 2082 argv[7]
davidjhoward 197:594afd088f32 2083 );
davidjhoward 186:16912aa18c2a 2084
davidjhoward 197:594afd088f32 2085 printf("Sending Command To ModbusMasterMailBox: %s : len=%d\r\n", snd_buf, strlen(snd_buf));
davidjhoward 186:16912aa18c2a 2086 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 197:594afd088f32 2087 mail->action = ACTION_EXEC_CMD;
davidjhoward 197:594afd088f32 2088 strncpy( mail->controlFile, snd_buf, (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 2089 ModbusMasterMailBox.put(mail);
davidjhoward 214:52ef35bc44ec 2090 }
davidjhoward 214:52ef35bc44ec 2091
davidjhoward 214:52ef35bc44ec 2092 /*****************************************************************************
davidjhoward 214:52ef35bc44ec 2093 * Function: cmd_regcmd
davidjhoward 214:52ef35bc44ec 2094 * Description: create register command
davidjhoward 214:52ef35bc44ec 2095 *
davidjhoward 214:52ef35bc44ec 2096 * @param argc-> number of args
davidjhoward 214:52ef35bc44ec 2097 * @param argv-> filename
davidjhoward 214:52ef35bc44ec 2098 * @return none
davidjhoward 214:52ef35bc44ec 2099 *****************************************************************************/
davidjhoward 214:52ef35bc44ec 2100 void cmd_regcmd(int argc, char **argv)
davidjhoward 214:52ef35bc44ec 2101 {
davidjhoward 214:52ef35bc44ec 2102 char filename[64];
jmarkel44 220:dbe21411f962 2103
davidjhoward 214:52ef35bc44ec 2104 printf("argc=%d\r\n",argc);
jmarkel44 220:dbe21411f962 2105
davidjhoward 214:52ef35bc44ec 2106 if ( argc != 7 ) {
davidjhoward 214:52ef35bc44ec 2107 printf("\rusage: regcmd <if> <tag> <opl> <opr> <op> <c>\n");
davidjhoward 214:52ef35bc44ec 2108 printf("\rexample: regcmd TEMP_CONV_PH01 i_ph_temp01 i_ph_temp01 - / 1000\n");
davidjhoward 214:52ef35bc44ec 2109 return;
davidjhoward 214:52ef35bc44ec 2110 }
jmarkel44 220:dbe21411f962 2111
davidjhoward 214:52ef35bc44ec 2112 memset( filename, 0, 64 );
davidjhoward 214:52ef35bc44ec 2113 snprintf( filename, 63, "%s%s%s", "vcmd_", argv[1], ".json" );
davidjhoward 214:52ef35bc44ec 2114 printf("filename=%s\r\n",filename);
jmarkel44 220:dbe21411f962 2115
davidjhoward 214:52ef35bc44ec 2116 std::string opl(argv[4]);
jmarkel44 220:dbe21411f962 2117
davidjhoward 214:52ef35bc44ec 2118 printf("argv[4]=%s, opl=%s\r\n",argv[4], opl.c_str());
jmarkel44 220:dbe21411f962 2119 if( opl.c_str()[0] == '-' ) {
davidjhoward 214:52ef35bc44ec 2120 printf("argv[4]=%s, SETTING TO NULL\r\n",argv[4]);
davidjhoward 214:52ef35bc44ec 2121 opl = "";
davidjhoward 214:52ef35bc44ec 2122 }
davidjhoward 214:52ef35bc44ec 2123
davidjhoward 214:52ef35bc44ec 2124 char data_buf[MAX_FILE_SIZE];
davidjhoward 214:52ef35bc44ec 2125 snprintf(data_buf, sizeof(data_buf),
davidjhoward 214:52ef35bc44ec 2126 "{ "
davidjhoward 214:52ef35bc44ec 2127 "\"id\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2128 "\"tag\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2129 "\"opl\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2130 "\"opr\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2131 "\"op\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2132 "\"c\":\"%s\" } ", argv[1], argv[2], argv[3], opl.c_str(), argv[5], argv[6]);
jmarkel44 220:dbe21411f962 2133
davidjhoward 214:52ef35bc44ec 2134 printf("JSON=%s\r\n",data_buf);
jmarkel44 220:dbe21411f962 2135
davidjhoward 214:52ef35bc44ec 2136 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
davidjhoward 214:52ef35bc44ec 2137 if( status != true ) {
davidjhoward 214:52ef35bc44ec 2138 logInfo("(%d)save file failed, status=%d", __LINE__, status);
davidjhoward 214:52ef35bc44ec 2139 }
davidjhoward 214:52ef35bc44ec 2140
davidjhoward 214:52ef35bc44ec 2141 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", filename);
davidjhoward 214:52ef35bc44ec 2142 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 214:52ef35bc44ec 2143 mail->action = ACTION_READ_FILE;
davidjhoward 214:52ef35bc44ec 2144 strncpy( mail->controlFile, filename, (sizeof(mail->controlFile)-1));
davidjhoward 214:52ef35bc44ec 2145 ModbusMasterMailBox.put(mail);
davidjhoward 214:52ef35bc44ec 2146 }
davidjhoward 214:52ef35bc44ec 2147
davidjhoward 214:52ef35bc44ec 2148 /*****************************************************************************
davidjhoward 214:52ef35bc44ec 2149 * Function: cmd_trimTemp
davidjhoward 214:52ef35bc44ec 2150 * Description: create register command
davidjhoward 214:52ef35bc44ec 2151 *
davidjhoward 214:52ef35bc44ec 2152 * @param argc-> number of args
davidjhoward 214:52ef35bc44ec 2153 * @param argv-> filename
davidjhoward 214:52ef35bc44ec 2154 * @return none
davidjhoward 214:52ef35bc44ec 2155 *****************************************************************************/
davidjhoward 214:52ef35bc44ec 2156 void cmd_trimTemp(int argc, char **argv)
davidjhoward 214:52ef35bc44ec 2157 {
jmarkel44 220:dbe21411f962 2158 /*
jmarkel44 220:dbe21411f962 2159
jmarkel44 220:dbe21411f962 2160 char filename[64];
davidjhoward 214:52ef35bc44ec 2161
jmarkel44 220:dbe21411f962 2162 memset( filename, 0, 64 );
jmarkel44 220:dbe21411f962 2163 snprintf( filename, 63, "%s%s%s", "vcmd_", "2_DIV_TEMP_PH01", ".json" );
jmarkel44 220:dbe21411f962 2164 printf("filename=%s\r\n",filename);
davidjhoward 214:52ef35bc44ec 2165
jmarkel44 220:dbe21411f962 2166 char data_buf[MAX_FILE_SIZE];
jmarkel44 220:dbe21411f962 2167 snprintf(data_buf, sizeof(data_buf),
jmarkel44 220:dbe21411f962 2168 "{ "
jmarkel44 220:dbe21411f962 2169 "\"id\":\"%s\", "
jmarkel44 220:dbe21411f962 2170 "\"tag\":\"%s\", "
jmarkel44 220:dbe21411f962 2171 "\"opl\":\"%s\", "
jmarkel44 220:dbe21411f962 2172 "\"opr\":\"%s\", "
jmarkel44 220:dbe21411f962 2173 "\"op\":\"%s\", "
jmarkel44 220:dbe21411f962 2174 "\"c\":\"%s\" } ", "2_DIV_TEMP_PH01", "i_ph_temp01", "i_ph_temp01", "", "/", "1000.0");
jmarkel44 220:dbe21411f962 2175
jmarkel44 220:dbe21411f962 2176 printf("JSON=%s\r\n",data_buf);
jmarkel44 220:dbe21411f962 2177
jmarkel44 220:dbe21411f962 2178 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 2179 if( status != true ) {
jmarkel44 220:dbe21411f962 2180 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 220:dbe21411f962 2181 }
jmarkel44 220:dbe21411f962 2182
jmarkel44 220:dbe21411f962 2183 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", filename);
jmarkel44 220:dbe21411f962 2184 Message_t *mail = ModbusMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 2185 mail->action = ACTION_READ_FILE;
jmarkel44 220:dbe21411f962 2186 strncpy( mail->controlFile, filename, (sizeof(mail->controlFile)-1));
jmarkel44 220:dbe21411f962 2187 ModbusMasterMailBox.put(mail);
davidjhoward 214:52ef35bc44ec 2188
jmarkel44 220:dbe21411f962 2189 Thread::wait(5000);
jmarkel44 220:dbe21411f962 2190
jmarkel44 220:dbe21411f962 2191 memset( filename, 0, 64 );
jmarkel44 220:dbe21411f962 2192 snprintf( filename, 63, "%s%s%s", "vcmd_", "1_CONST_TEMP_PH01", ".json" );
jmarkel44 220:dbe21411f962 2193 printf("filename=%s\r\n",filename);
jmarkel44 220:dbe21411f962 2194
jmarkel44 220:dbe21411f962 2195 snprintf(data_buf, sizeof(data_buf),
jmarkel44 220:dbe21411f962 2196 "{ "
jmarkel44 220:dbe21411f962 2197 "\"id\":\"%s\", "
jmarkel44 220:dbe21411f962 2198 "\"tag\":\"%s\", "
jmarkel44 220:dbe21411f962 2199 "\"opl\":\"%s\", "
jmarkel44 220:dbe21411f962 2200 "\"opr\":\"%s\", "
jmarkel44 220:dbe21411f962 2201 "\"op\":\"%s\", "
jmarkel44 220:dbe21411f962 2202 "\"c\":\"%s\" } ", "1_CONST_TEMP_PH01", "i_ph_temp01", "i_ph_temp01", "", "=", "26000.0");
davidjhoward 214:52ef35bc44ec 2203
jmarkel44 220:dbe21411f962 2204 printf("JSON=%s\r\n",data_buf);
jmarkel44 220:dbe21411f962 2205
jmarkel44 220:dbe21411f962 2206 status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 2207 if( status != true ) {
jmarkel44 220:dbe21411f962 2208 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 220:dbe21411f962 2209 }
davidjhoward 214:52ef35bc44ec 2210
jmarkel44 220:dbe21411f962 2211 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", filename);
jmarkel44 220:dbe21411f962 2212 mail = ModbusMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 2213 mail->action = ACTION_READ_FILE;
jmarkel44 220:dbe21411f962 2214 strncpy( mail->controlFile, filename, (sizeof(mail->controlFile)-1));
jmarkel44 220:dbe21411f962 2215 ModbusMasterMailBox.put(mail);
jmarkel44 220:dbe21411f962 2216
jmarkel44 220:dbe21411f962 2217 Thread::wait(5000);
jmarkel44 220:dbe21411f962 2218 */
jmarkel44 62:1b1d7918adf2 2219 }