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@251:e730d7077e46, 2016-10-21 (annotated)

Committer:
jmarkel44
Date:
Fri Oct 21 11:44:40 2016 +0000
Revision:
251:e730d7077e46
Parent:
246:ca91a441b4dc
Parent:
250:1cd8ec63e9e9
Child:
252:3c9863f951b7
merging

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