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@221:2a5e9902003c, 2016-10-14 (annotated)

Committer:
jmarkel44
Date:
Fri Oct 14 21:30:21 2016 +0000
Revision:
221:2a5e9902003c
Parent:
220:dbe21411f962
Child:
229:0d6755d765fd
composite control and composite algorithm implementation

Who changed what in which revision?

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