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@230:11765008ff3a, 2016-10-18 (annotated)

Committer:
jmarkel44
Date:
Tue Oct 18 20:23:31 2016 +0000
Revision:
230:11765008ff3a
Parent:
229:0d6755d765fd
Child:
231:f22901955e0c
LOCKOUT blowdown

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 230:11765008ff3a 604 if ( argc != 1 ) {
jmarkel44 221:2a5e9902003c 605 printf("\rusage: create-ca control_ca_equal.json");
jmarkel44 221:2a5e9902003c 606 return;
jmarkel44 221:2a5e9902003c 607 }
jmarkel44 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 230:11765008ff3a 619 bool status = GLOBAL_mdot->saveUserFile("control_ca_eq1.json", (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 221:2a5e9902003c 620 if ( status != true ) {
jmarkel44 230:11765008ff3a 621 printf("\rFailed to save user file %s\n", "control_ca_eq1.json");
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 230:11765008ff3a 630 strncpy(msg->controlFile, "control_ca_eq1.json", sizeof(msg->controlFile)-1);
jmarkel44 230:11765008ff3a 631
jmarkel44 230:11765008ff3a 632 MailBox.put(msg);
jmarkel44 230:11765008ff3a 633
jmarkel44 230:11765008ff3a 634 Thread::wait(2000);
jmarkel44 230:11765008ff3a 635
jmarkel44 230:11765008ff3a 636 // >= 1
jmarkel44 230:11765008ff3a 637 snprintf(data_buf, sizeof(data_buf),
jmarkel44 230:11765008ff3a 638 "{"
jmarkel44 230:11765008ff3a 639 "\"id\": \"EQUAL_TO_129\", "
jmarkel44 230:11765008ff3a 640 "\"opr\": \"129\", "
jmarkel44 230:11765008ff3a 641 "\"op\": \"==\", "
jmarkel44 230:11765008ff3a 642 "\"true\": \"responseA\", "
jmarkel44 230:11765008ff3a 643 "\"false\": \"nothing\" "
jmarkel44 230:11765008ff3a 644 "}");
jmarkel44 230:11765008ff3a 645
jmarkel44 230:11765008ff3a 646 status = GLOBAL_mdot->saveUserFile("control_ca_greq1.json", (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 230:11765008ff3a 647 if ( status != true ) {
jmarkel44 230:11765008ff3a 648 printf("\rFailed to save user file %s\n", "control_ca_greq1.json");
jmarkel44 230:11765008ff3a 649 return;
jmarkel44 230:11765008ff3a 650 }
jmarkel44 230:11765008ff3a 651
jmarkel44 230:11765008ff3a 652 // send a message to the configuration handler to create the control
jmarkel44 230:11765008ff3a 653 msg = MailBox.alloc();
jmarkel44 230:11765008ff3a 654 memset(msg, 0, sizeof(Message_t));
jmarkel44 230:11765008ff3a 655 msg->action = ACTION_CREATE;
jmarkel44 230:11765008ff3a 656 msg->control = CONTROL_ALGORITHM;
jmarkel44 230:11765008ff3a 657 strncpy(msg->controlFile, "control_ca_greq1.json", sizeof(msg->controlFile)-1);
jmarkel44 221:2a5e9902003c 658
jmarkel44 221:2a5e9902003c 659 MailBox.put(msg);
jmarkel44 221:2a5e9902003c 660 }
jmarkel44 221:2a5e9902003c 661
jmarkel44 220:dbe21411f962 662 void cmd_createComposite(int argc, char **argv)
jmarkel44 220:dbe21411f962 663 {
jmarkel44 230:11765008ff3a 664 if ( argc != 1 ) {
jmarkel44 230:11765008ff3a 665 printf("\rusage: create-comp");
jmarkel44 220:dbe21411f962 666 return;
jmarkel44 220:dbe21411f962 667 }
jmarkel44 230:11765008ff3a 668
jmarkel44 230:11765008ff3a 669 char data_buf[MAX_FILE_SIZE];
jmarkel44 230:11765008ff3a 670 bool status;
jmarkel44 230:11765008ff3a 671 Message_t *msg = NULL;
jmarkel44 220:dbe21411f962 672
jmarkel44 230:11765008ff3a 673 #if 0
jmarkel44 230:11765008ff3a 674 // FLOW
jmarkel44 220:dbe21411f962 675 char data_buf[MAX_FILE_SIZE];
jmarkel44 220:dbe21411f962 676 snprintf(data_buf, sizeof(data_buf),
jmarkel44 220:dbe21411f962 677 "{ "
jmarkel44 229:0d6755d765fd 678 "\"id\": \"FLOW_OVERRIDE\", "
jmarkel44 229:0d6755d765fd 679 "\"tag\": \"i_flowsw01\", "
jmarkel44 229:0d6755d765fd 680 "\"ca\": \"EQUAL_TO_1\", "
jmarkel44 229:0d6755d765fd 681 "\"priority\": \"400\", "
jmarkel44 229:0d6755d765fd 682 "\"entries\": \"2\", "
jmarkel44 220:dbe21411f962 683 "\"outputs\": [ "
jmarkel44 220:dbe21411f962 684 "{"
jmarkel44 220:dbe21411f962 685 "\"tag\": \"o_rly01\", "
jmarkel44 221:2a5e9902003c 686 "\"responseA\": \"fixed off\" "
jmarkel44 220:dbe21411f962 687 "},"
jmarkel44 220:dbe21411f962 688 "{"
jmarkel44 220:dbe21411f962 689 "\"tag\": \"o_rly02\", "
jmarkel44 221:2a5e9902003c 690 "\"responseA\": \"fixed off\" "
jmarkel44 220:dbe21411f962 691 "}"
jmarkel44 220:dbe21411f962 692 "]"
jmarkel44 220:dbe21411f962 693 "}"
jmarkel44 220:dbe21411f962 694 );
jmarkel44 230:11765008ff3a 695 bool status = GLOBAL_mdot->saveUserFile("control_comp_flow.json", (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 696 if ( status != true ) {
jmarkel44 230:11765008ff3a 697 printf("\rFailed to save user file control_comp_flow.json\n");
jmarkel44 220:dbe21411f962 698 return;
jmarkel44 220:dbe21411f962 699 }
jmarkel44 220:dbe21411f962 700
jmarkel44 220:dbe21411f962 701 // send a message to the configuration handler to create the control
jmarkel44 230:11765008ff3a 702 msg = MailBox.alloc();
jmarkel44 220:dbe21411f962 703 memset(msg, 0, sizeof(Message_t));
jmarkel44 220:dbe21411f962 704 msg->action = ACTION_CREATE;
jmarkel44 220:dbe21411f962 705 msg->control = CONTROL_COMPOSITE;
jmarkel44 230:11765008ff3a 706 strncpy(msg->controlFile, "control_comp_flow.json", sizeof(msg->controlFile)-1);
jmarkel44 230:11765008ff3a 707
jmarkel44 230:11765008ff3a 708 printf("\rDEBUG: sending a request for composite control %s\n", msg->controlFile);
jmarkel44 220:dbe21411f962 709
jmarkel44 230:11765008ff3a 710 MailBox.put(msg);
jmarkel44 230:11765008ff3a 711
jmarkel44 230:11765008ff3a 712 Thread::wait(2000);
jmarkel44 230:11765008ff3a 713
jmarkel44 230:11765008ff3a 714 #endif
jmarkel44 230:11765008ff3a 715
jmarkel44 230:11765008ff3a 716 // LOCKOUT
jmarkel44 230:11765008ff3a 717 snprintf(data_buf, sizeof(data_buf),
jmarkel44 230:11765008ff3a 718 "{ "
jmarkel44 230:11765008ff3a 719 "\"id\": \"LOCKOUT_BLOWDOWN\", "
jmarkel44 230:11765008ff3a 720 "\"tag\": \"o_rly01\", "
jmarkel44 230:11765008ff3a 721 "\"ca\": \"EQUAL_TO_129\", "
jmarkel44 230:11765008ff3a 722 "\"priority\": \"400\", "
jmarkel44 230:11765008ff3a 723 "\"entries\": \"1\", "
jmarkel44 230:11765008ff3a 724 "\"outputs\": [ "
jmarkel44 230:11765008ff3a 725 "{"
jmarkel44 230:11765008ff3a 726 "\"tag\": \"o_rly02\", "
jmarkel44 230:11765008ff3a 727 "\"responseA\": \"fixed off\" "
jmarkel44 230:11765008ff3a 728 "}"
jmarkel44 230:11765008ff3a 729 "]"
jmarkel44 230:11765008ff3a 730 "}"
jmarkel44 230:11765008ff3a 731 );
jmarkel44 230:11765008ff3a 732 status = GLOBAL_mdot->saveUserFile("control_comp_lockout.json", (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 230:11765008ff3a 733 if ( status != true ) {
jmarkel44 230:11765008ff3a 734 printf("\rFailed to save user file control_comp_lockout.json\n");
jmarkel44 230:11765008ff3a 735 return;
jmarkel44 230:11765008ff3a 736 }
jmarkel44 230:11765008ff3a 737
jmarkel44 230:11765008ff3a 738 // send a message to the configuration handler to create the control
jmarkel44 230:11765008ff3a 739 msg = MailBox.alloc();
jmarkel44 230:11765008ff3a 740 memset(msg, 0, sizeof(Message_t));
jmarkel44 230:11765008ff3a 741 msg->action = ACTION_CREATE;
jmarkel44 230:11765008ff3a 742 msg->control = CONTROL_COMPOSITE;
jmarkel44 230:11765008ff3a 743 strncpy(msg->controlFile, "control_comp_lockout.json", sizeof(msg->controlFile)-1);
jmarkel44 230:11765008ff3a 744
jmarkel44 230:11765008ff3a 745 printf("\rDEBUG: sending a request for composite control %s\n", msg->controlFile);
jmarkel44 220:dbe21411f962 746
jmarkel44 220:dbe21411f962 747 MailBox.put(msg);
jmarkel44 220:dbe21411f962 748 }
jmarkel44 220:dbe21411f962 749
jmarkel44 122:4db48b933115 750 /*****************************************************************************
jmarkel44 97:5cf6ab71dcd0 751 * Function: cmd_createManual
jmarkel44 97:5cf6ab71dcd0 752 * Description: create a manual control
jmarkel44 97:5cf6ab71dcd0 753 *
jmarkel44 97:5cf6ab71dcd0 754 * @param argc-> number of args
jmarkel44 97:5cf6ab71dcd0 755 * @param argv-> filename
jmarkel44 97:5cf6ab71dcd0 756 * @return none
jmarkel44 97:5cf6ab71dcd0 757 *****************************************************************************/
jmarkel44 97:5cf6ab71dcd0 758 void cmd_createManual(int argc, char **argv)
jmarkel44 97:5cf6ab71dcd0 759 {
jmarkel44 212:289f63158d2b 760 std::string relayState;
jmarkel44 98:8eab18d03ac2 761 if ( argc != 5 ) {
jmarkel44 98:8eab18d03ac2 762 printf("\rusage: create-manual <filename> <id> <output> <state>\n");
jmarkel44 98:8eab18d03ac2 763 printf("\rexample: create-manual control_mn_1.json man-1 o_rly1 1\r\n");
jmarkel44 97:5cf6ab71dcd0 764 return;
jmarkel44 97:5cf6ab71dcd0 765 }
jmarkel44 220:dbe21411f962 766
jmarkel44 212:289f63158d2b 767 string state(argv[4]);
jmarkel44 97:5cf6ab71dcd0 768
jmarkel44 212:289f63158d2b 769 if ( state == "on" ) {
jmarkel44 212:289f63158d2b 770 relayState = "1";
jmarkel44 212:289f63158d2b 771 } else if ( state == "off" ) {
jmarkel44 212:289f63158d2b 772 relayState = "0";
jmarkel44 212:289f63158d2b 773 } else {
jmarkel44 212:289f63158d2b 774 printf("\r<state> must be on or off\r\n");
jmarkel44 212:289f63158d2b 775 return;
jmarkel44 212:289f63158d2b 776 }
jmarkel44 220:dbe21411f962 777
jmarkel44 177:9ec90c8e3ce1 778 char data_buf[MAX_FILE_SIZE];
jmarkel44 97:5cf6ab71dcd0 779 snprintf(data_buf, sizeof(data_buf),
jmarkel44 97:5cf6ab71dcd0 780 "{ "
jmarkel44 98:8eab18d03ac2 781 "\"id\": \"%s\", "
jmarkel44 98:8eab18d03ac2 782 "\"output\": \"%s\", "
jmarkel44 98:8eab18d03ac2 783 "\"type\": \"1\", "
jmarkel44 97:5cf6ab71dcd0 784 "\"priority\": \"100\", "
jmarkel44 98:8eab18d03ac2 785 "\"duration\": \"0\", "
jmarkel44 98:8eab18d03ac2 786 "\"setpoint\": \"0\", "
jmarkel44 212:289f63158d2b 787 "\"state\": \"%s\", "
jmarkel44 212:289f63158d2b 788 "\"percent\": \"100\" }", argv[2], argv[3], relayState.c_str()
jmarkel44 97:5cf6ab71dcd0 789 );
jmarkel44 97:5cf6ab71dcd0 790
jmarkel44 177:9ec90c8e3ce1 791 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 97:5cf6ab71dcd0 792 if( status != true ) {
jmarkel44 97:5cf6ab71dcd0 793 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 97:5cf6ab71dcd0 794 return;
jmarkel44 97:5cf6ab71dcd0 795 }
davidjhoward 116:7337ed514891 796
davidjhoward 116:7337ed514891 797 // send a message to the configuration handler to create the control
jmarkel44 97:5cf6ab71dcd0 798 Message_t *msg = MailBox.alloc();
jmarkel44 97:5cf6ab71dcd0 799 memset(msg, 0, sizeof(Message_t));
jmarkel44 97:5cf6ab71dcd0 800 msg->action = ACTION_CREATE;
jmarkel44 97:5cf6ab71dcd0 801 msg->control = CONTROL_MANUAL;
jmarkel44 97:5cf6ab71dcd0 802 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 97:5cf6ab71dcd0 803
jmarkel44 97:5cf6ab71dcd0 804 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 97:5cf6ab71dcd0 805 __func__, msg->controlFile, msg->control);
jmarkel44 97:5cf6ab71dcd0 806
jmarkel44 97:5cf6ab71dcd0 807 MailBox.put(msg);
jmarkel44 97:5cf6ab71dcd0 808 printf("\r\n");
jmarkel44 97:5cf6ab71dcd0 809 return;
jmarkel44 97:5cf6ab71dcd0 810 }
jmarkel44 97:5cf6ab71dcd0 811
jmarkel44 97:5cf6ab71dcd0 812 /*****************************************************************************
jmarkel44 37:7e6986b77f01 813 * Function: cmd_cif
jmarkel44 37:7e6986b77f01 814 * Description: create input file
jmarkel44 37:7e6986b77f01 815 *
jmarkel44 37:7e6986b77f01 816 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 817 * @param argv-> filename
jmarkel44 37:7e6986b77f01 818 * @return none
jmarkel44 37:7e6986b77f01 819 *****************************************************************************/
jmarkel44 37:7e6986b77f01 820 void cmd_cif(int argc, char **argv)
jmarkel44 37:7e6986b77f01 821 {
jmarkel44 169:c503848823aa 822 if ( argc != 6 ) {
jmarkel44 169:c503848823aa 823 printf("\rusage: cif <fname> <input> <name> <node> <reg>\n");
jmarkel44 169:c503848823aa 824 printf("\rexample: cif input_i_tra01.json i_tra01 Trasar 5 2\n");
jmarkel44 37:7e6986b77f01 825 return;
jmarkel44 37:7e6986b77f01 826 }
jmarkel44 37:7e6986b77f01 827
jmarkel44 177:9ec90c8e3ce1 828 char data_buf[MAX_FILE_SIZE];
jmarkel44 37:7e6986b77f01 829 snprintf(data_buf, sizeof(data_buf),
jmarkel44 37:7e6986b77f01 830 "{ "
jmarkel44 121:650205ffa656 831 "\"id\": \"%s\", "
jmarkel44 169:c503848823aa 832 "\"name\": \"%s\", "
jmarkel44 37:7e6986b77f01 833 "\"units\": \"PPM\", "
jmarkel44 37:7e6986b77f01 834 "\"min\": \"0\", "
jmarkel44 37:7e6986b77f01 835 "\"max\": \"300\", "
jmarkel44 169:c503848823aa 836 "\"node\": \"%s\", "
jmarkel44 169:c503848823aa 837 "\"reg\": \"%s\", "
jmarkel44 37:7e6986b77f01 838 "\"rtype\": \"1\", "
davidjhoward 54:ec1b03064bbd 839 "\"type\": \"0\", "
davidjhoward 41:e8946fc01ea4 840 "\"size\": \"2\", "
davidjhoward 41:e8946fc01ea4 841 "\"order\": \"2\", "
davidjhoward 41:e8946fc01ea4 842 "\"rfreq\": \"5\", "
jmarkel44 169:c503848823aa 843 "\"fmt\": \"%%.2f\" } ", argv[2], argv[3], argv[4], argv[5]);
jmarkel44 37:7e6986b77f01 844
jmarkel44 177:9ec90c8e3ce1 845 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 37:7e6986b77f01 846 if( status != true ) {
jmarkel44 37:7e6986b77f01 847 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 848 }
davidjhoward 41:e8946fc01ea4 849
davidjhoward 42:c703a60993b1 850 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", argv[1]);
davidjhoward 41:e8946fc01ea4 851 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 41:e8946fc01ea4 852 mail->action = ACTION_READ_FILE;
davidjhoward 41:e8946fc01ea4 853 strncpy( mail->controlFile, argv[1], (sizeof(mail->controlFile)-1));
davidjhoward 41:e8946fc01ea4 854 ModbusMasterMailBox.put(mail);
jmarkel44 37:7e6986b77f01 855 }
jmarkel44 37:7e6986b77f01 856
jmarkel44 37:7e6986b77f01 857 /*****************************************************************************
jmarkel44 96:807f04bd5256 858 * Function: cmd_cmf
jmarkel44 96:807f04bd5256 859 * Description: create manual control file
jmarkel44 96:807f04bd5256 860 *
jmarkel44 96:807f04bd5256 861 * @param argc-> number of args
jmarkel44 96:807f04bd5256 862 * @param argv-> filename
jmarkel44 96:807f04bd5256 863 * @return none
jmarkel44 96:807f04bd5256 864 *****************************************************************************/
jmarkel44 96:807f04bd5256 865 void cmd_cmf(int argc, char **argv)
jmarkel44 96:807f04bd5256 866 {
jmarkel44 96:807f04bd5256 867 if ( argc != 2 ) {
jmarkel44 96:807f04bd5256 868 printf("\rusage: cmf <filename> <relay\r\n");
jmarkel44 96:807f04bd5256 869 printf("\rexmaple: cmd control_mn_1.json o_rly1");
jmarkel44 96:807f04bd5256 870 return;
jmarkel44 96:807f04bd5256 871 }
jmarkel44 96:807f04bd5256 872
jmarkel44 177:9ec90c8e3ce1 873 char data_buf[MAX_FILE_SIZE];
jmarkel44 96:807f04bd5256 874 snprintf(data_buf, sizeof(data_buf),
jmarkel44 96:807f04bd5256 875 "{ "
jmarkel44 96:807f04bd5256 876 "\"id\": \"%s\", "
jmarkel44 96:807f04bd5256 877 "\"type\": \"1\", "
jmarkel44 96:807f04bd5256 878 "\"priority\": \"100\", "
jmarkel44 96:807f04bd5256 879 "\"duration\": \"30\", " // seconds
jmarkel44 96:807f04bd5256 880 "\"setpoint\": \"2000.0\", "
jmarkel44 96:807f04bd5256 881 "\"state\": \"1\", "
jmarkel44 113:001ad47df8ec 882 "\"percent\": \"100\", }", argv[2]
jmarkel44 96:807f04bd5256 883 );
jmarkel44 96:807f04bd5256 884
jmarkel44 177:9ec90c8e3ce1 885 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 96:807f04bd5256 886 if( status != true ) {
jmarkel44 96:807f04bd5256 887 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 96:807f04bd5256 888 }
jmarkel44 96:807f04bd5256 889 }
jmarkel44 96:807f04bd5256 890
jmarkel44 96:807f04bd5256 891
jmarkel44 96:807f04bd5256 892 /*****************************************************************************
jmarkel44 37:7e6986b77f01 893 * Function: cmd_cof
jmarkel44 37:7e6986b77f01 894 * Description: create output file
jmarkel44 37:7e6986b77f01 895 *
jmarkel44 37:7e6986b77f01 896 * @param argc-> number of args
jmarkel44 37:7e6986b77f01 897 * @param argv-> filename
jmarkel44 37:7e6986b77f01 898 * @return none
jmarkel44 37:7e6986b77f01 899 *****************************************************************************/
jmarkel44 37:7e6986b77f01 900 void cmd_cof(int argc, char **argv)
jmarkel44 37:7e6986b77f01 901 {
davidjhoward 81:d45bfa16953a 902 if ( argc != 5 ) {
davidjhoward 81:d45bfa16953a 903 printf("\rusage: cof <filename> <output> <name> <reg>\r\n");
davidjhoward 81:d45bfa16953a 904 printf("\rexample: cof output_rly1.json o_rly1 Relay1 1\r\n");
jmarkel44 37:7e6986b77f01 905 return;
jmarkel44 37:7e6986b77f01 906 }
jmarkel44 37:7e6986b77f01 907
jmarkel44 177:9ec90c8e3ce1 908 char data_buf[MAX_FILE_SIZE];
jmarkel44 37:7e6986b77f01 909
jmarkel44 67:49f266601d83 910 snprintf(data_buf, sizeof(data_buf),
jmarkel44 67:49f266601d83 911 "{ "
jmarkel44 67:49f266601d83 912 "\"id\": \"%s\", "
davidjhoward 81:d45bfa16953a 913 "\"name\": \"%s\", "
davidjhoward 81:d45bfa16953a 914 "\"units\": \"\", "
jmarkel44 67:49f266601d83 915 "\"min\": \"0\", "
jmarkel44 67:49f266601d83 916 "\"max\": \"300\", "
davidjhoward 81:d45bfa16953a 917 "\"node\": \"0\", "
davidjhoward 81:d45bfa16953a 918 "\"reg\": \"%s\", "
jmarkel44 67:49f266601d83 919 "\"rtype\": \"1\", "
jmarkel44 67:49f266601d83 920 "\"type\": \"16\", "
davidjhoward 81:d45bfa16953a 921 "\"size\": \"2\", "
davidjhoward 81:d45bfa16953a 922 "\"order\": \"2\", "
jmarkel44 67:49f266601d83 923 "\"fmt\": \"%%.2f\", "
davidjhoward 81:d45bfa16953a 924 "\"rfreq\": \"5\", "
jmarkel44 67:49f266601d83 925 "\"toperiod\": \"0\", "
jmarkel44 67:49f266601d83 926 "\"scalelo\": \"0\", "
davidjhoward 81:d45bfa16953a 927 "\"scalehi\": \"100\" }", argv[2], argv[3], argv[4]);
davidjhoward 81:d45bfa16953a 928
jmarkel44 177:9ec90c8e3ce1 929 bool status = GLOBAL_mdot->saveUserFile(argv[1], (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 37:7e6986b77f01 930 if( status != true ) {
jmarkel44 37:7e6986b77f01 931 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 37:7e6986b77f01 932 }
jmarkel44 43:62de0e05ab6b 933
jmarkel44 177:9ec90c8e3ce1 934 // send a message to the modbus master
jmarkel44 63:0ded43237b22 935 logInfo("Sending mail to ModbusMasterMailBox, filename=%s", argv[1]);
jmarkel44 63:0ded43237b22 936 Message_t *modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 937 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 63:0ded43237b22 938 strncpy( modbus_mail->controlFile, argv[1], (sizeof(modbus_mail->controlFile)-1));
jmarkel44 63:0ded43237b22 939 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 67:49f266601d83 940
jmarkel44 63:0ded43237b22 941 // send a message to the output master
jmarkel44 63:0ded43237b22 942 logInfo("Sending mail to OutputMaster, filename = %s", argv[1]);
jmarkel44 63:0ded43237b22 943 OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
jmarkel44 63:0ded43237b22 944 output_mail->action = ACTION_NEW;
jmarkel44 63:0ded43237b22 945 strncpy(output_mail->controlFile, argv[1], sizeof(output_mail->controlFile)-1);
jmarkel44 63:0ded43237b22 946 OutputMasterMailBox.put(output_mail);
jmarkel44 37:7e6986b77f01 947 }
jmarkel44 37:7e6986b77f01 948
jmarkel44 37:7e6986b77f01 949 /*****************************************************************************
jmarkel44 35:6235ef67faa1 950 * Function: cmd_heap
jmarkel44 35:6235ef67faa1 951 * Description: display heap statistics
jmarkel44 35:6235ef67faa1 952 *
jmarkel44 35:6235ef67faa1 953 * @param argc (not used)
jmarkel44 35:6235ef67faa1 954 * @param argv (not used)
jmarkel44 35:6235ef67faa1 955 * @return none
jmarkel44 35:6235ef67faa1 956 *****************************************************************************/
jmarkel44 0:65cfa4873284 957 void cmd_heap(int argc, char **argv)
jmarkel44 0:65cfa4873284 958 {
jmarkel44 0:65cfa4873284 959 UNUSED(argc), UNUSED(argv);
jmarkel44 0:65cfa4873284 960 __heapstats((__heapprt)fprintf,stderr); // print initial free heap size
jmarkel44 0:65cfa4873284 961 }
jmarkel44 0:65cfa4873284 962
jmarkel44 0:65cfa4873284 963
jmarkel44 35:6235ef67faa1 964 /*****************************************************************************
jmarkel44 35:6235ef67faa1 965 * Function: cmd_stats
jmarkel44 35:6235ef67faa1 966 * Description: display mDot stats
jmarkel44 35:6235ef67faa1 967 *
jmarkel44 35:6235ef67faa1 968 * @param argc (not used)
jmarkel44 35:6235ef67faa1 969 * @param argv (not used)
jmarkel44 35:6235ef67faa1 970 * @return none
jmarkel44 35:6235ef67faa1 971 *****************************************************************************/
jmarkel44 18:9cf694a764c0 972 void cmd_stats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 973 {
jmarkel44 35:6235ef67faa1 974 UNUSED(argc);
jmarkel44 35:6235ef67faa1 975 UNUSED(argv);
davidjhoward 81:d45bfa16953a 976
jmarkel44 18:9cf694a764c0 977 mDot::mdot_stats stats = GLOBAL_mdot->getStats();
jmarkel44 0:65cfa4873284 978
jmarkel44 44:c73f2ca79669 979 printf("\r Up: %u\n", stats.Up);
jmarkel44 44:c73f2ca79669 980 printf("\r Down: %u\n", stats.Down);
jmarkel44 44:c73f2ca79669 981 printf("\r Joins: %u\n", stats.Joins);
jmarkel44 44:c73f2ca79669 982 printf("\r JoinFails: %u\n", stats.JoinFails);
jmarkel44 44:c73f2ca79669 983 printf("\r MissedAcks: %u\n", stats.MissedAcks);
jmarkel44 44:c73f2ca79669 984 printf("\r CRCErrors: %u\n", stats.CRCErrors);
jmarkel44 44:c73f2ca79669 985 printf("\r\n");
jmarkel44 44:c73f2ca79669 986 printf("\r Freq band: %u\n", GLOBAL_mdot->getFrequencyBand());
jmarkel44 44:c73f2ca79669 987 printf("\r Freq subband: %u\n", GLOBAL_mdot->getFrequencySubBand());
jmarkel44 44:c73f2ca79669 988 printf("\r Session data rate: %u\n", GLOBAL_mdot->getSessionDataRate());
jmarkel44 44:c73f2ca79669 989 printf("\r Public Network Mode: %s\n", GLOBAL_mdot->getPublicNetwork() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 990 printf("\r Application device port: %u\n", GLOBAL_mdot->getAppPort());
jmarkel44 44:c73f2ca79669 991 printf("\r Class: %s\n", GLOBAL_mdot->getClass().c_str());
jmarkel44 44:c73f2ca79669 992 printf("\r Max packet length: %u\n", GLOBAL_mdot->getMaxPacketLength());
jmarkel44 77:43e0a3d9e536 993 std::vector<uint8_t> na = GLOBAL_mdot->getNetworkAddress();
jmarkel44 77:43e0a3d9e536 994 std::string str(na.begin(), na.end());
jmarkel44 77:43e0a3d9e536 995 printf("\r Network address: %s\n", str.c_str());
jmarkel44 44:c73f2ca79669 996 printf("\r Network name: %s\n", GLOBAL_mdot->getNetworkName().c_str());
jmarkel44 77:43e0a3d9e536 997 std::vector<uint8_t> nid = GLOBAL_mdot->getNetworkId();
jmarkel44 77:43e0a3d9e536 998 std::string networkIdStr(nid.begin(), nid.end());
jmarkel44 77:43e0a3d9e536 999 printf("\r Network ID: %s\n", networkIdStr.c_str());
jmarkel44 44:c73f2ca79669 1000 printf("\r Join byter order: %s\n", GLOBAL_mdot->getJoinByteOrder() == 0 ? "LSB" : "MSB");
jmarkel44 44:c73f2ca79669 1001 printf("\r Join retries: %u\n", GLOBAL_mdot->getJoinRetries());
jmarkel44 44:c73f2ca79669 1002 printf("\r Join mode: %u\n", GLOBAL_mdot->getJoinMode());
jmarkel44 44:c73f2ca79669 1003 printf("\r Network join status: %s\n", GLOBAL_mdot->getNetworkJoinStatus() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 1004 printf("\r Link fail count: %u\n", GLOBAL_mdot->getLinkFailCount());
jmarkel44 44:c73f2ca79669 1005 printf("\r Packets Tx'd to gateway: %u\n", GLOBAL_mdot->getUpLinkCounter());
jmarkel44 44:c73f2ca79669 1006 printf("\r Packets Rx'd from gateway: %u\n", GLOBAL_mdot->getDownLinkCounter());
jmarkel44 44:c73f2ca79669 1007 printf("\r AES encryption: %s\n", GLOBAL_mdot->getAesEncryption() ? "enabled" : "disabled");
jmarkel44 44:c73f2ca79669 1008 printf("\r Tx data rate: %u\n", GLOBAL_mdot->getTxDataRate());
jmarkel44 77:43e0a3d9e536 1009 printf("\r Datarate Details: %s\n", GLOBAL_mdot->getDateRateDetails(GLOBAL_mdot->getTxDataRate()).c_str());
jmarkel44 44:c73f2ca79669 1010 printf("\r Tx power: %u\n", GLOBAL_mdot->getTxPower());
jmarkel44 44:c73f2ca79669 1011 printf("\r Antenna gain: %u\n", GLOBAL_mdot->getAntennaGain());
jmarkel44 44:c73f2ca79669 1012 printf("\r Min frequency: %u\n", GLOBAL_mdot->getMinFrequency());
jmarkel44 44:c73f2ca79669 1013 printf("\r Max frequency: %u\n", GLOBAL_mdot->getMaxFrequency());
jmarkel44 44:c73f2ca79669 1014 printf("\r CRC enabled: %s\n", GLOBAL_mdot->getCrc() ? "yes" : "no");
jmarkel44 44:c73f2ca79669 1015 printf("\r ACK enabled: %s\n", GLOBAL_mdot->getAck() ? "yes" : "no");
jmarkel44 18:9cf694a764c0 1016
jmarkel44 18:9cf694a764c0 1017 printf("\r\n");
jmarkel44 18:9cf694a764c0 1018 }
jmarkel44 18:9cf694a764c0 1019
jmarkel44 35:6235ef67faa1 1020 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1021 * Function: cmd_resetStats
jmarkel44 35:6235ef67faa1 1022 * Description: resets the mDot stats
jmarkel44 35:6235ef67faa1 1023 *
jmarkel44 35:6235ef67faa1 1024 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1025 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1026 * @return none
jmarkel44 35:6235ef67faa1 1027 *****************************************************************************/
jmarkel44 18:9cf694a764c0 1028 void cmd_resetStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 1029 {
jmarkel44 35:6235ef67faa1 1030 UNUSED(argc);
jmarkel44 35:6235ef67faa1 1031 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 1032
jmarkel44 18:9cf694a764c0 1033 GLOBAL_mdot->resetStats();
jmarkel44 18:9cf694a764c0 1034 }
jmarkel44 0:65cfa4873284 1035
jmarkel44 35:6235ef67faa1 1036 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1037 * Function: cmd_rssiStats
jmarkel44 36:f240f5a6d0ed 1038 * Description: displays mDot RSSI statistics
jmarkel44 35:6235ef67faa1 1039 *
jmarkel44 35:6235ef67faa1 1040 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1041 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1042 * @return none
jmarkel44 35:6235ef67faa1 1043 *****************************************************************************/
jmarkel44 18:9cf694a764c0 1044 void cmd_rssiStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 1045 {
jmarkel44 35:6235ef67faa1 1046 UNUSED(argc);
jmarkel44 35:6235ef67faa1 1047 UNUSED(argv);
jmarkel44 36:f240f5a6d0ed 1048
jmarkel44 18:9cf694a764c0 1049 mDot::rssi_stats s = GLOBAL_mdot->getRssiStats();
jmarkel44 0:65cfa4873284 1050
jmarkel44 18:9cf694a764c0 1051 printf("\r Last: %d dB\n", s.last);
jmarkel44 18:9cf694a764c0 1052 printf("\r Min: %d dB\n", s.min);
jmarkel44 18:9cf694a764c0 1053 printf("\r Max: %d dB\n", s.max);
jmarkel44 18:9cf694a764c0 1054 printf("\r Avg: %d dB\n", s.avg);
jmarkel44 18:9cf694a764c0 1055
jmarkel44 18:9cf694a764c0 1056 printf("\r\n");
jmarkel44 18:9cf694a764c0 1057 }
jmarkel44 18:9cf694a764c0 1058
jmarkel44 35:6235ef67faa1 1059 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1060 * Function: cmd_snrStats
jmarkel44 35:6235ef67faa1 1061 * Description: displays signal-to-noise ratio stats
jmarkel44 35:6235ef67faa1 1062 *
jmarkel44 35:6235ef67faa1 1063 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1064 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1065 * @return none
jmarkel44 35:6235ef67faa1 1066 *****************************************************************************/
jmarkel44 18:9cf694a764c0 1067 void cmd_snrStats(int argc, char **argv)
jmarkel44 18:9cf694a764c0 1068 {
jmarkel44 18:9cf694a764c0 1069 mDot::snr_stats s = GLOBAL_mdot->getSnrStats();
jmarkel44 18:9cf694a764c0 1070
jmarkel44 18:9cf694a764c0 1071 printf("\r Last: %d cB\n", s.last);
jmarkel44 18:9cf694a764c0 1072 printf("\r Min: %d cB\n", s.min);
jmarkel44 18:9cf694a764c0 1073 printf("\r Max: %d cB\n", s.max);
jmarkel44 18:9cf694a764c0 1074 printf("\r Avg: %d cB\n", s.avg);
jmarkel44 18:9cf694a764c0 1075
jmarkel44 18:9cf694a764c0 1076 printf("\r\n");
jmarkel44 18:9cf694a764c0 1077 }
jmarkel44 34:f345fdec711d 1078
jmarkel44 35:6235ef67faa1 1079 /*****************************************************************************
jmarkel44 35:6235ef67faa1 1080 * Function: cmd_stack
jmarkel44 36:f240f5a6d0ed 1081 * Description: display thread stack statisics
jmarkel44 35:6235ef67faa1 1082 *
jmarkel44 35:6235ef67faa1 1083 * @param argc (not used)
jmarkel44 35:6235ef67faa1 1084 * @param argv (not used)
jmarkel44 35:6235ef67faa1 1085 * @return none
jmarkel44 35:6235ef67faa1 1086 *****************************************************************************/
jmarkel44 34:f345fdec711d 1087 void cmd_stack(int argc, char **argv)
jmarkel44 34:f345fdec711d 1088 {
jmarkel44 36:f240f5a6d0ed 1089 vector<pair<string, Thread*> > taskList;
davidjhoward 81:d45bfa16953a 1090
jmarkel44 71:34856d21f2bf 1091 const char *mapper[] = { "Inactive",
jmarkel44 71:34856d21f2bf 1092 "Ready",
jmarkel44 71:34856d21f2bf 1093 "Running",
jmarkel44 71:34856d21f2bf 1094 "WaitingDelay",
jmarkel44 71:34856d21f2bf 1095 "WaitingInterval",
jmarkel44 71:34856d21f2bf 1096 "WaitingOr",
jmarkel44 71:34856d21f2bf 1097 "WaitingAnd",
jmarkel44 71:34856d21f2bf 1098 "WaitingSempahore",
jmarkel44 71:34856d21f2bf 1099 "WaitingMailbox",
davidjhoward 81:d45bfa16953a 1100 "WaitingMutex"
davidjhoward 81:d45bfa16953a 1101 };
jmarkel44 36:f240f5a6d0ed 1102
jmarkel44 36:f240f5a6d0ed 1103 //simply add your task to the list...
jmarkel44 36:f240f5a6d0ed 1104 taskList.push_back(make_pair((string)"AnalyticsLogger", GLOBAL_analyticsLogger_thread));
jmarkel44 172:51dfb4aabc57 1105 //taskList.push_back(make_pair((string)"BLEHandler", GLOBAL_BLE_thread));
jmarkel44 36:f240f5a6d0ed 1106 taskList.push_back(make_pair((string)"CloudDataHandler", GLOBAL_CDH_thread));
jmarkel44 36:f240f5a6d0ed 1107 taskList.push_back(make_pair((string)"ConfigHandler", GLOBAL_configHandler_thread));
jmarkel44 36:f240f5a6d0ed 1108 taskList.push_back(make_pair((string)"ControlTask", GLOBAL_controlTask_thread));
jmarkel44 36:f240f5a6d0ed 1109 taskList.push_back(make_pair((string)"ModbusMaster", GLOBAL_modbusMaster_thread));
jmarkel44 48:1c7861d80d16 1110 taskList.push_back(make_pair((string)"OutputTask", GLOBAL_outputTask_thread));
jmarkel44 36:f240f5a6d0ed 1111
jmarkel44 36:f240f5a6d0ed 1112 for ( vector<pair<string, Thread*> >::iterator pos = taskList.begin();
jmarkel44 36:f240f5a6d0ed 1113 pos != taskList.end(); ++ pos) {
jmarkel44 170:f9406996ff5b 1114 printf("\r %-32s size/free/used/max = %5u/%5u/%5u/%5u\tpri=%u state=%-20s\n",
davidjhoward 41:e8946fc01ea4 1115 pos->first.c_str(),
davidjhoward 41:e8946fc01ea4 1116 pos->second->stack_size(),
davidjhoward 41:e8946fc01ea4 1117 pos->second->free_stack(),
davidjhoward 41:e8946fc01ea4 1118 pos->second->used_stack(),
jmarkel44 71:34856d21f2bf 1119 pos->second->max_stack(),
jmarkel44 71:34856d21f2bf 1120 pos->second->get_priority(),
jmarkel44 71:34856d21f2bf 1121 mapper[pos->second->get_state()]);
jmarkel44 34:f345fdec711d 1122 }
jmarkel44 36:f240f5a6d0ed 1123
jmarkel44 34:f345fdec711d 1124 printf("\r\n");
jmarkel44 34:f345fdec711d 1125 }
jmarkel44 62:1b1d7918adf2 1126
jmarkel44 62:1b1d7918adf2 1127 /*****************************************************************************
davidjhoward 61:ae6dd6692c7d 1128 * Function: cmd_modmap
davidjhoward 61:ae6dd6692c7d 1129 * Description: dump modbus register map
jmarkel44 62:1b1d7918adf2 1130 *****************************************************************************/
davidjhoward 61:ae6dd6692c7d 1131 void cmd_modmap(int argc, char **argv)
jmarkel44 62:1b1d7918adf2 1132 {
jmarkel44 65:be025ac18fb5 1133 UNUSED(argc);
jmarkel44 65:be025ac18fb5 1134 UNUSED(argv);
davidjhoward 83:0f76cfbb4eba 1135 ModbusValue value;
jmarkel44 67:49f266601d83 1136
davidjhoward 61:ae6dd6692c7d 1137 std::map<std::string, ModbusRegister>::iterator iter;
davidjhoward 61:ae6dd6692c7d 1138 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 83:0f76cfbb4eba 1139 ModbusMasterReadRegister( iter->first, &value );
davidjhoward 190:af7ab603c9fe 1140 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 1141 }
jmarkel44 65:be025ac18fb5 1142 }
jmarkel44 65:be025ac18fb5 1143
jmarkel44 65:be025ac18fb5 1144 /*****************************************************************************
jmarkel44 208:784c46652863 1145 * Function: cmd_modifyManual
jmarkel44 208:784c46652863 1146 * Description: modify a manual control
jmarkel44 208:784c46652863 1147 *****************************************************************************/
jmarkel44 208:784c46652863 1148 void cmd_modifyManual(int argc, char **argv)
jmarkel44 208:784c46652863 1149 {
jmarkel44 208:784c46652863 1150 std::string relayState;
jmarkel44 220:dbe21411f962 1151
jmarkel44 208:784c46652863 1152 if ( argc != 3 ) {
jmarkel44 208:784c46652863 1153 printf("\rusage: modify-mn <controlFile> <state>\n");
jmarkel44 208:784c46652863 1154 printf("\rexample: modify-mn control_mn_rly1.json on\n");
jmarkel44 208:784c46652863 1155 return;
jmarkel44 208:784c46652863 1156 }
jmarkel44 220:dbe21411f962 1157
jmarkel44 208:784c46652863 1158 string state(argv[2]);
jmarkel44 208:784c46652863 1159 if ( state == "on" ) {
jmarkel44 208:784c46652863 1160 relayState = "1";
jmarkel44 208:784c46652863 1161 } else if ( state == "off" ) {
jmarkel44 208:784c46652863 1162 relayState = "0";
jmarkel44 220:dbe21411f962 1163 } else {
jmarkel44 208:784c46652863 1164 printf("\r<state> must be ON or OFF\n");
jmarkel44 208:784c46652863 1165 return;
jmarkel44 208:784c46652863 1166 }
jmarkel44 220:dbe21411f962 1167
jmarkel44 208:784c46652863 1168 char buf[MAX_FILE_SIZE];
jmarkel44 208:784c46652863 1169 bool rc = GLOBAL_mdot->readUserFile(argv[1], (void*)buf, MAX_FILE_SIZE);
jmarkel44 208:784c46652863 1170 if ( rc != true ) {
jmarkel44 208:784c46652863 1171 printf("\rFailed to read %s\n", argv[1]);
jmarkel44 208:784c46652863 1172 return;
jmarkel44 208:784c46652863 1173 }
jmarkel44 220:dbe21411f962 1174
jmarkel44 208:784c46652863 1175 MbedJSONValue json_value;
jmarkel44 208:784c46652863 1176 parse(json_value, buf);
jmarkel44 208:784c46652863 1177
jmarkel44 208:784c46652863 1178 json_value["state"] = relayState;
jmarkel44 220:dbe21411f962 1179
jmarkel44 208:784c46652863 1180 std::string s = json_value.serialize();
jmarkel44 220:dbe21411f962 1181
jmarkel44 208:784c46652863 1182 rc = GLOBAL_mdot->saveUserFile(argv[1], (void*)s.c_str(), MAX_FILE_SIZE);
jmarkel44 208:784c46652863 1183 if ( rc != true ) {
jmarkel44 208:784c46652863 1184 printf("\rFailed to write %s\n", argv[1]);
jmarkel44 208:784c46652863 1185 return;
jmarkel44 208:784c46652863 1186 }
jmarkel44 220:dbe21411f962 1187
jmarkel44 208:784c46652863 1188 // send a message to the configuration handler to create the control
jmarkel44 208:784c46652863 1189 Message_t *msg = MailBox.alloc();
jmarkel44 208:784c46652863 1190 memset(msg, 0, sizeof(Message_t));
jmarkel44 208:784c46652863 1191 msg->action = ACTION_MODIFY;
jmarkel44 208:784c46652863 1192 msg->control = CONTROL_MANUAL;
jmarkel44 208:784c46652863 1193 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 208:784c46652863 1194
jmarkel44 208:784c46652863 1195 printf("%s: Sending a create request for control %s type = %u\r\n",
jmarkel44 208:784c46652863 1196 __func__, msg->controlFile, msg->control);
jmarkel44 208:784c46652863 1197
jmarkel44 208:784c46652863 1198 MailBox.put(msg);
jmarkel44 208:784c46652863 1199 printf("\r\n");
jmarkel44 208:784c46652863 1200 return;
jmarkel44 208:784c46652863 1201 }
jmarkel44 208:784c46652863 1202
jmarkel44 208:784c46652863 1203 /*****************************************************************************
jmarkel44 207:55aabde2d4bf 1204 * Function: cmd_modifySetpoint
jmarkel44 207:55aabde2d4bf 1205 * Description: modify a setpoint control
jmarkel44 207:55aabde2d4bf 1206 *****************************************************************************/
jmarkel44 207:55aabde2d4bf 1207 void cmd_modifySetpoint(int argc, char**argv)
jmarkel44 207:55aabde2d4bf 1208 {
jmarkel44 207:55aabde2d4bf 1209 if ( argc != 4) {
jmarkel44 207:55aabde2d4bf 1210 printf("\rusage: modify-sp <controlFile> <setpoint> <tol>\n");
jmarkel44 207:55aabde2d4bf 1211 printf("\rexample: modify-sp control_sp_1.json 2200 10\n");
jmarkel44 207:55aabde2d4bf 1212 return;
jmarkel44 207:55aabde2d4bf 1213 }
jmarkel44 207:55aabde2d4bf 1214
jmarkel44 207:55aabde2d4bf 1215 // read the file
jmarkel44 207:55aabde2d4bf 1216 char buf[MAX_FILE_SIZE];
jmarkel44 207:55aabde2d4bf 1217 bool rc = GLOBAL_mdot->readUserFile(argv[1], (void*)buf, MAX_FILE_SIZE);
jmarkel44 207:55aabde2d4bf 1218 if ( rc != true ) {
jmarkel44 207:55aabde2d4bf 1219 printf("\rFailed to read %s\n", argv[1]);
jmarkel44 207:55aabde2d4bf 1220 return;
jmarkel44 207:55aabde2d4bf 1221 }
jmarkel44 207:55aabde2d4bf 1222
jmarkel44 207:55aabde2d4bf 1223 MbedJSONValue json_value;
jmarkel44 207:55aabde2d4bf 1224 parse(json_value, buf);
jmarkel44 207:55aabde2d4bf 1225
jmarkel44 207:55aabde2d4bf 1226 json_value["setpoint"] = argv[2];
jmarkel44 207:55aabde2d4bf 1227 json_value["tol"] = argv[3];
jmarkel44 220:dbe21411f962 1228
jmarkel44 207:55aabde2d4bf 1229 std::string s = json_value.serialize();
jmarkel44 220:dbe21411f962 1230
jmarkel44 207:55aabde2d4bf 1231 rc = GLOBAL_mdot->saveUserFile(argv[1], (void*)s.c_str(), MAX_FILE_SIZE);
jmarkel44 207:55aabde2d4bf 1232 if ( rc != true ) {
jmarkel44 207:55aabde2d4bf 1233 printf("\rFailed to write %s\n", argv[1]);
jmarkel44 207:55aabde2d4bf 1234 return;
jmarkel44 207:55aabde2d4bf 1235 }
jmarkel44 220:dbe21411f962 1236
jmarkel44 207:55aabde2d4bf 1237 // send a message to the configuration handler to create the control
jmarkel44 207:55aabde2d4bf 1238 Message_t *msg = MailBox.alloc();
jmarkel44 207:55aabde2d4bf 1239 memset(msg, 0, sizeof(Message_t));
jmarkel44 207:55aabde2d4bf 1240 msg->action = ACTION_MODIFY;
jmarkel44 207:55aabde2d4bf 1241 msg->control = CONTROL_SETPOINT;
jmarkel44 207:55aabde2d4bf 1242 strncpy(msg->controlFile, argv[1], sizeof(msg->controlFile)-1);
jmarkel44 207:55aabde2d4bf 1243
jmarkel44 207:55aabde2d4bf 1244 printf("%s: Sending a MODIFY request for control %s type = %u\r\n",
jmarkel44 207:55aabde2d4bf 1245 __func__, msg->controlFile, msg->control);
jmarkel44 207:55aabde2d4bf 1246
jmarkel44 207:55aabde2d4bf 1247 MailBox.put(msg);
jmarkel44 207:55aabde2d4bf 1248 printf("\r\n");
jmarkel44 207:55aabde2d4bf 1249 return;
jmarkel44 207:55aabde2d4bf 1250
jmarkel44 207:55aabde2d4bf 1251 }
jmarkel44 207:55aabde2d4bf 1252
jmarkel44 207:55aabde2d4bf 1253 /*****************************************************************************
jmarkel44 65:be025ac18fb5 1254 * Function: cmd_time
jmarkel44 65:be025ac18fb5 1255 * Description: display real-time clock
jmarkel44 65:be025ac18fb5 1256 ****************************************************************************/
jmarkel44 65:be025ac18fb5 1257 void cmd_time(int argc, char **argv)
jmarkel44 65:be025ac18fb5 1258 {
jmarkel44 62:1b1d7918adf2 1259 UNUSED(argc);
jmarkel44 62:1b1d7918adf2 1260 UNUSED(argv);
davidjhoward 149:950c90425f7c 1261
jmarkel44 131:a290a3934132 1262 time_t rawtime;
jmarkel44 131:a290a3934132 1263 time(&rawtime);
davidjhoward 149:950c90425f7c 1264
jmarkel44 62:1b1d7918adf2 1265 int iyr=0, imo=0, idy=0, ihr=0, imn=0, isc=0;
jmarkel44 62:1b1d7918adf2 1266 rtc_get_time(&iyr, &imo, &idy, &ihr, &imn, &isc);
jmarkel44 131:a290a3934132 1267 printf("RTC time: %04d-%02d-%02d %02d:%02d:%02d\r\n", iyr, imo, idy, ihr, imn, isc);
jmarkel44 132:45821e189dd0 1268 printf("\repoch timestamp: %lu\r\n", time(NULL));
jmarkel44 66:db1425574b58 1269 }
jmarkel44 66:db1425574b58 1270
jmarkel44 66:db1425574b58 1271 /*****************************************************************************
jmarkel44 131:a290a3934132 1272 * Function: cmd_outputs
jmarkel44 66:db1425574b58 1273 * Description: display outputs
jmarkel44 66:db1425574b58 1274 ****************************************************************************/
jmarkel44 66:db1425574b58 1275 void cmd_outputs(int argc, char **argv)
jmarkel44 66:db1425574b58 1276 {
jmarkel44 66:db1425574b58 1277 UNUSED(argc);
jmarkel44 66:db1425574b58 1278 UNUSED(argv);
jmarkel44 67:49f266601d83 1279
jmarkel44 66:db1425574b58 1280 DisplayOutputs();
davidjhoward 81:d45bfa16953a 1281 }
davidjhoward 81:d45bfa16953a 1282
davidjhoward 81:d45bfa16953a 1283 /*****************************************************************************
davidjhoward 81:d45bfa16953a 1284 * Function: cmd_sout
davidjhoward 81:d45bfa16953a 1285 * Description: set output
davidjhoward 81:d45bfa16953a 1286 *
davidjhoward 81:d45bfa16953a 1287 * @param argc-> number of args
davidjhoward 81:d45bfa16953a 1288 * @param argv-> output
davidjhoward 81:d45bfa16953a 1289 * @return none
davidjhoward 81:d45bfa16953a 1290 *****************************************************************************/
davidjhoward 81:d45bfa16953a 1291 void cmd_sout(int argc, char **argv)
davidjhoward 81:d45bfa16953a 1292 {
davidjhoward 81:d45bfa16953a 1293 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 1294
davidjhoward 81:d45bfa16953a 1295 if ( argc != 3 ) {
davidjhoward 81:d45bfa16953a 1296 printf("\rusage: sout <output> <value>\r\n");
davidjhoward 81:d45bfa16953a 1297 printf("\rexample: sout o_rly1 1\r\n");
davidjhoward 81:d45bfa16953a 1298 return;
davidjhoward 116:7337ed514891 1299 }
davidjhoward 83:0f76cfbb4eba 1300 ModbusMasterWriteRegister( argv[1], value );
davidjhoward 82:f3e495a98877 1301 }
davidjhoward 82:f3e495a98877 1302
davidjhoward 82:f3e495a98877 1303 /*****************************************************************************
jmarkel44 102:715f754cf5a8 1304 * Function: cmd_settime
jmarkel44 102:715f754cf5a8 1305 * Description: set real-time clock
jmarkel44 102:715f754cf5a8 1306 *
jmarkel44 102:715f754cf5a8 1307 * @param argc-> number of args
jmarkel44 102:715f754cf5a8 1308 * @param argv-> input
jmarkel44 102:715f754cf5a8 1309 * @return none
jmarkel44 102:715f754cf5a8 1310 *****************************************************************************/
jmarkel44 102:715f754cf5a8 1311 void cmd_settime(int argc, char **argv)
jmarkel44 102:715f754cf5a8 1312 {
davidjhoward 116:7337ed514891 1313
jmarkel44 102:715f754cf5a8 1314 if ( argc != 7 ) {
jmarkel44 102:715f754cf5a8 1315 printf("\rusage: set-time <yyyy> <mm> <dd> <hh> <mm> <ss>\n");
jmarkel44 102:715f754cf5a8 1316 printf("\rexample: set-time 2016 12 25 12 0 0\r\n");
jmarkel44 102:715f754cf5a8 1317 return;
jmarkel44 102:715f754cf5a8 1318 }
davidjhoward 116:7337ed514891 1319
jmarkel44 102:715f754cf5a8 1320 rtc_set_time(atoi(argv[1]), // year
jmarkel44 102:715f754cf5a8 1321 atoi(argv[2]), // month
jmarkel44 102:715f754cf5a8 1322 atoi(argv[3]), // day
jmarkel44 102:715f754cf5a8 1323 atoi(argv[4]), // hr
jmarkel44 102:715f754cf5a8 1324 atoi(argv[5]), // min
jmarkel44 102:715f754cf5a8 1325 atoi(argv[6])); // sec
jmarkel44 102:715f754cf5a8 1326 }
jmarkel44 102:715f754cf5a8 1327
jmarkel44 102:715f754cf5a8 1328 /*****************************************************************************
davidjhoward 82:f3e495a98877 1329 * Function: cmd_simin
davidjhoward 82:f3e495a98877 1330 * Description: simulat input
davidjhoward 82:f3e495a98877 1331 *
davidjhoward 82:f3e495a98877 1332 * @param argc-> number of args
davidjhoward 82:f3e495a98877 1333 * @param argv-> input
davidjhoward 82:f3e495a98877 1334 * @return none
davidjhoward 82:f3e495a98877 1335 *****************************************************************************/
davidjhoward 82:f3e495a98877 1336 void cmd_simin(int argc, char **argv)
davidjhoward 82:f3e495a98877 1337 {
davidjhoward 82:f3e495a98877 1338 float value = atof( argv[2] );
davidjhoward 82:f3e495a98877 1339
davidjhoward 82:f3e495a98877 1340 if ( argc < 3 ) {
davidjhoward 150:4db35c8234b4 1341 printf("\rusage: simin <input> <value> <low> <hi> <up_step> <down_step>\r\n");
davidjhoward 150:4db35c8234b4 1342 printf("\rexample: simin i_tra01 100 94 106 1 .25\r\n");
davidjhoward 150:4db35c8234b4 1343 printf("\rexample: simin i_bdcond01 2000 1990 2006 .25 1\r\n");
davidjhoward 82:f3e495a98877 1344 return;
davidjhoward 82:f3e495a98877 1345 }
davidjhoward 82:f3e495a98877 1346
davidjhoward 82:f3e495a98877 1347 SimulateInputMap[argv[1]].start_value = atof(argv[2]);
davidjhoward 116:7337ed514891 1348
davidjhoward 82:f3e495a98877 1349 ModbusRegisterMap[argv[1]].simulated = true;
davidjhoward 82:f3e495a98877 1350
davidjhoward 82:f3e495a98877 1351 if ( argc < 3 ) {
davidjhoward 82:f3e495a98877 1352 SimulateInputMap[argv[1]].min = 0;
davidjhoward 82:f3e495a98877 1353 SimulateInputMap[argv[1]].max = 0;
davidjhoward 179:a31ea334e2b7 1354 SimulateInputMap[argv[1]].moving_up = false;
davidjhoward 82:f3e495a98877 1355 return;
davidjhoward 82:f3e495a98877 1356 }
davidjhoward 82:f3e495a98877 1357 SimulateInputMap[argv[1]].min = atof(argv[3]);
davidjhoward 82:f3e495a98877 1358 SimulateInputMap[argv[1]].max = atof(argv[4]);
davidjhoward 150:4db35c8234b4 1359 SimulateInputMap[argv[1]].up_step = atof(argv[5]);
davidjhoward 150:4db35c8234b4 1360 SimulateInputMap[argv[1]].down_step = atof(argv[6]);
davidjhoward 179:a31ea334e2b7 1361 SimulateInputMap[argv[1]].moving_up = true;
davidjhoward 150:4db35c8234b4 1362
davidjhoward 179:a31ea334e2b7 1363 }
davidjhoward 179:a31ea334e2b7 1364
davidjhoward 179:a31ea334e2b7 1365 /*****************************************************************************
davidjhoward 179:a31ea334e2b7 1366 * Function: cmd_simall
davidjhoward 179:a31ea334e2b7 1367 * Description: simulat multiple inputs
davidjhoward 179:a31ea334e2b7 1368 *
davidjhoward 179:a31ea334e2b7 1369 * @return none
davidjhoward 179:a31ea334e2b7 1370 *****************************************************************************/
davidjhoward 179:a31ea334e2b7 1371 void cmd_simall(int argc, char **argv)
davidjhoward 179:a31ea334e2b7 1372 {
davidjhoward 179:a31ea334e2b7 1373
davidjhoward 179:a31ea334e2b7 1374 if ( argc > 1 ) {
davidjhoward 179:a31ea334e2b7 1375 printf("\rsetting: simin i_tra01 100\r\n");
davidjhoward 179:a31ea334e2b7 1376 printf("\rsetting: simin i_bdcond01 2000\r\n");
davidjhoward 179:a31ea334e2b7 1377
davidjhoward 179:a31ea334e2b7 1378 ModbusRegisterMap["i_tra01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1379 SimulateInputMap["i_tra01"].start_value = 130;
davidjhoward 179:a31ea334e2b7 1380 SimulateInputMap["i_tra01"].min = 0;
davidjhoward 179:a31ea334e2b7 1381 SimulateInputMap["i_tra01"].max = 0;
davidjhoward 179:a31ea334e2b7 1382 SimulateInputMap["i_tra01"].up_step = 0;
davidjhoward 179:a31ea334e2b7 1383 SimulateInputMap["i_tra01"].down_step = 0;
davidjhoward 179:a31ea334e2b7 1384 SimulateInputMap["i_tra01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1385
davidjhoward 199:d65ed41d4dd4 1386 ModbusRegisterMap["i_tag01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1387 SimulateInputMap["i_tag01"].start_value = 100;
davidjhoward 199:d65ed41d4dd4 1388 SimulateInputMap["i_tag01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1389 SimulateInputMap["i_tag01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1390 SimulateInputMap["i_tag01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1391 SimulateInputMap["i_tag01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1392 SimulateInputMap["i_tag01"].moving_up = true;
davidjhoward 179:a31ea334e2b7 1393
davidjhoward 179:a31ea334e2b7 1394 ModbusRegisterMap["i_bdcond01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1395 SimulateInputMap["i_bdcond01"].start_value = 1800;
davidjhoward 179:a31ea334e2b7 1396 SimulateInputMap["i_bdcond01"].min = 0;
davidjhoward 179:a31ea334e2b7 1397 SimulateInputMap["i_bdcond01"].max = 0;
davidjhoward 179:a31ea334e2b7 1398 SimulateInputMap["i_bdcond01"].up_step = 0;
davidjhoward 179:a31ea334e2b7 1399 SimulateInputMap["i_bdcond01"].down_step = 0;
davidjhoward 179:a31ea334e2b7 1400 SimulateInputMap["i_bdcond01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1401
davidjhoward 199:d65ed41d4dd4 1402 ModbusRegisterMap["i_cond_temp01"].simulated = true;
davidjhoward 214:52ef35bc44ec 1403 SimulateInputMap["i_cond_temp01"].start_value = 25000.0;
davidjhoward 199:d65ed41d4dd4 1404 SimulateInputMap["i_cond_temp01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1405 SimulateInputMap["i_cond_temp01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1406 SimulateInputMap["i_cond_temp01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1407 SimulateInputMap["i_cond_temp01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1408 SimulateInputMap["i_cond_temp01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1409
davidjhoward 199:d65ed41d4dd4 1410 ModbusRegisterMap["i_ph01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1411 SimulateInputMap["i_ph01"].start_value = 8;
davidjhoward 199:d65ed41d4dd4 1412 SimulateInputMap["i_ph01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1413 SimulateInputMap["i_ph01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1414 SimulateInputMap["i_ph01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1415 SimulateInputMap["i_ph01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1416 SimulateInputMap["i_ph01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1417
davidjhoward 199:d65ed41d4dd4 1418 ModbusRegisterMap["i_ph_temp01"].simulated = true;
davidjhoward 214:52ef35bc44ec 1419 SimulateInputMap["i_ph_temp01"].start_value = 25000.0;
davidjhoward 199:d65ed41d4dd4 1420 SimulateInputMap["i_ph_temp01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1421 SimulateInputMap["i_ph_temp01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1422 SimulateInputMap["i_ph_temp01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1423 SimulateInputMap["i_ph_temp01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1424 SimulateInputMap["i_ph_temp01"].moving_up = true;
jmarkel44 207:55aabde2d4bf 1425
davidjhoward 199:d65ed41d4dd4 1426 ModbusRegisterMap["i_orp01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1427 SimulateInputMap["i_orp01"].start_value = 350;
davidjhoward 199:d65ed41d4dd4 1428 SimulateInputMap["i_orp01"].min = 0;
davidjhoward 199:d65ed41d4dd4 1429 SimulateInputMap["i_orp01"].max = 0;
davidjhoward 199:d65ed41d4dd4 1430 SimulateInputMap["i_orp01"].up_step = 0;
davidjhoward 199:d65ed41d4dd4 1431 SimulateInputMap["i_orp01"].down_step = 0;
davidjhoward 199:d65ed41d4dd4 1432 SimulateInputMap["i_orp01"].moving_up = true;
davidjhoward 179:a31ea334e2b7 1433
davidjhoward 179:a31ea334e2b7 1434 return;
davidjhoward 179:a31ea334e2b7 1435 }
davidjhoward 179:a31ea334e2b7 1436
davidjhoward 199:d65ed41d4dd4 1437 printf("\rsetting: simin i_tra01 130 120 140 1 .25\r\n");
davidjhoward 199:d65ed41d4dd4 1438 printf("\rsetting: simin i_tag01 100 90 110 1 .25\r\n");
davidjhoward 199:d65ed41d4dd4 1439 printf("\rsetting: simin i_bdcond01 1800 1725 1875 1 5\r\n");
davidjhoward 199:d65ed41d4dd4 1440 printf("\rsetting: simin i_ph01 8.0 7.25 8.75 .0. .1\r\n");
davidjhoward 199:d65ed41d4dd4 1441 printf("\rsetting: simin i_orp01 350 300 400 5 1\r\n");
davidjhoward 179:a31ea334e2b7 1442
davidjhoward 179:a31ea334e2b7 1443 ModbusRegisterMap["i_tra01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1444 SimulateInputMap["i_tra01"].start_value = 130;
davidjhoward 199:d65ed41d4dd4 1445 SimulateInputMap["i_tra01"].min = 120;
davidjhoward 199:d65ed41d4dd4 1446 SimulateInputMap["i_tra01"].max = 140;
davidjhoward 179:a31ea334e2b7 1447 SimulateInputMap["i_tra01"].up_step = 1;
davidjhoward 179:a31ea334e2b7 1448 SimulateInputMap["i_tra01"].down_step = .25;
jmarkel44 207:55aabde2d4bf 1449
davidjhoward 199:d65ed41d4dd4 1450 ModbusRegisterMap["i_tag01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1451 SimulateInputMap["i_tag01"].start_value = 100;
davidjhoward 199:d65ed41d4dd4 1452 SimulateInputMap["i_tag01"].min = 90;
davidjhoward 199:d65ed41d4dd4 1453 SimulateInputMap["i_tag01"].max = 110;
davidjhoward 199:d65ed41d4dd4 1454 SimulateInputMap["i_tag01"].up_step = 1;
davidjhoward 199:d65ed41d4dd4 1455 SimulateInputMap["i_tag01"].down_step = .25;
davidjhoward 179:a31ea334e2b7 1456
davidjhoward 179:a31ea334e2b7 1457 ModbusRegisterMap["i_bdcond01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1458 SimulateInputMap["i_bdcond01"].start_value = 1800;
davidjhoward 199:d65ed41d4dd4 1459 SimulateInputMap["i_bdcond01"].min = 1725;
davidjhoward 199:d65ed41d4dd4 1460 SimulateInputMap["i_bdcond01"].max = 1875;
davidjhoward 199:d65ed41d4dd4 1461 SimulateInputMap["i_bdcond01"].up_step = 1;
davidjhoward 199:d65ed41d4dd4 1462 SimulateInputMap["i_bdcond01"].down_step = 5;
jmarkel44 207:55aabde2d4bf 1463
davidjhoward 199:d65ed41d4dd4 1464 ModbusRegisterMap["i_ph01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1465 SimulateInputMap["i_ph01"].start_value = 8;
davidjhoward 199:d65ed41d4dd4 1466 SimulateInputMap["i_ph01"].min = 7.25;
davidjhoward 199:d65ed41d4dd4 1467 SimulateInputMap["i_ph01"].max = 8.75;
davidjhoward 199:d65ed41d4dd4 1468 SimulateInputMap["i_ph01"].up_step = .05;
davidjhoward 199:d65ed41d4dd4 1469 SimulateInputMap["i_ph01"].down_step = .1;
jmarkel44 207:55aabde2d4bf 1470
davidjhoward 199:d65ed41d4dd4 1471 ModbusRegisterMap["i_orp01"].simulated = true;
davidjhoward 199:d65ed41d4dd4 1472 SimulateInputMap["i_orp01"].start_value = 350;
davidjhoward 199:d65ed41d4dd4 1473 SimulateInputMap["i_orp01"].min = 300;
davidjhoward 199:d65ed41d4dd4 1474 SimulateInputMap["i_orp01"].max = 400;
davidjhoward 199:d65ed41d4dd4 1475 SimulateInputMap["i_orp01"].up_step = 5;
davidjhoward 199:d65ed41d4dd4 1476 SimulateInputMap["i_orp01"].down_step = 1;
davidjhoward 82:f3e495a98877 1477
davidjhoward 116:7337ed514891 1478 }
davidjhoward 116:7337ed514891 1479
davidjhoward 116:7337ed514891 1480 void cmd_deep( int argc, char **argv )
davidjhoward 116:7337ed514891 1481 {
davidjhoward 116:7337ed514891 1482 UNUSED(argc);
davidjhoward 116:7337ed514891 1483 UNUSED(argv);
davidjhoward 116:7337ed514891 1484
davidjhoward 123:ce602c91a9c3 1485 char logString[LOG_BYTES_PER_ENTRY];
davidjhoward 116:7337ed514891 1486
davidjhoward 116:7337ed514891 1487 LogLocalApi_PopEntry( logString );
davidjhoward 123:ce602c91a9c3 1488 if( logString[0] != '\0' ) {
davidjhoward 116:7337ed514891 1489 printf("%s\r\n", logString );
davidjhoward 123:ce602c91a9c3 1490 } else {
davidjhoward 116:7337ed514891 1491 printf("%s\r\n", "No String Found" );
davidjhoward 116:7337ed514891 1492 }
davidjhoward 116:7337ed514891 1493 }
davidjhoward 116:7337ed514891 1494
davidjhoward 116:7337ed514891 1495 void cmd_peep( int argc, char **argv )
davidjhoward 116:7337ed514891 1496 {
davidjhoward 116:7337ed514891 1497 UNUSED(argc);
davidjhoward 116:7337ed514891 1498 UNUSED(argv);
davidjhoward 116:7337ed514891 1499
davidjhoward 116:7337ed514891 1500 std::string logString = "This is a string to log";
davidjhoward 116:7337ed514891 1501
davidjhoward 116:7337ed514891 1502 LogLocalApi_PushEntry( logString.c_str() );
davidjhoward 123:ce602c91a9c3 1503 }
davidjhoward 123:ce602c91a9c3 1504
davidjhoward 123:ce602c91a9c3 1505 void cmd_inslog( int argc, char **argv )
davidjhoward 123:ce602c91a9c3 1506 {
davidjhoward 123:ce602c91a9c3 1507 UNUSED(argc);
davidjhoward 123:ce602c91a9c3 1508 UNUSED(argv);
davidjhoward 123:ce602c91a9c3 1509
davidjhoward 123:ce602c91a9c3 1510 EventReasonStruct_t eventReason;
davidjhoward 123:ce602c91a9c3 1511 eventReason.eventReason = EVENT_REASON_AUTO;
davidjhoward 123:ce602c91a9c3 1512 eventReason.inputValue = 100.00;
davidjhoward 123:ce602c91a9c3 1513 strncpy(eventReason.inputTag, "i_stub01", sizeof(eventReason.inputTag) );
davidjhoward 123:ce602c91a9c3 1514 eventReason.outputValue = 0.0;
davidjhoward 123:ce602c91a9c3 1515 strncpy(eventReason.outputTag, "o_stub01", sizeof(eventReason.outputTag) );
davidjhoward 123:ce602c91a9c3 1516 EventLoggerApi( eventReason );
davidjhoward 149:950c90425f7c 1517 }
davidjhoward 149:950c90425f7c 1518
davidjhoward 149:950c90425f7c 1519 void cmd_showSimin( int argc, char **argv )
davidjhoward 149:950c90425f7c 1520 {
davidjhoward 149:950c90425f7c 1521 std::map<std::string, SimulateInput>::iterator iter;
davidjhoward 149:950c90425f7c 1522 for (iter = SimulateInputMap.begin(); iter != SimulateInputMap.end(); ++iter) {
davidjhoward 150:4db35c8234b4 1523 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 1524 }
jmarkel44 177:9ec90c8e3ce1 1525 }
jmarkel44 177:9ec90c8e3ce1 1526
jmarkel44 177:9ec90c8e3ce1 1527 void cmd_demo(int argc, char **argv)
jmarkel44 177:9ec90c8e3ce1 1528 {
jmarkel44 177:9ec90c8e3ce1 1529 UNUSED(argc);
jmarkel44 177:9ec90c8e3ce1 1530 UNUSED(argv);
jmarkel44 177:9ec90c8e3ce1 1531
jmarkel44 177:9ec90c8e3ce1 1532 // inputs:
jmarkel44 177:9ec90c8e3ce1 1533 // input_i_tra01.json
jmarkel44 177:9ec90c8e3ce1 1534 // input_i_bdcond01.json
jmarkel44 177:9ec90c8e3ce1 1535 // outputs:
jmarkel44 177:9ec90c8e3ce1 1536 // output_o_rly01.json
jmarkel44 177:9ec90c8e3ce1 1537 // output_o_rly02.json
jmarkel44 177:9ec90c8e3ce1 1538 // controls
jmarkel44 177:9ec90c8e3ce1 1539 // control_sp_INH_TRA_01.json
jmarkel44 177:9ec90c8e3ce1 1540 // control_sp_BLOWDOWN_01.json
jmarkel44 177:9ec90c8e3ce1 1541
jmarkel44 177:9ec90c8e3ce1 1542
jmarkel44 177:9ec90c8e3ce1 1543 // INPUT: Trasar
jmarkel44 177:9ec90c8e3ce1 1544 char buf[MAX_FILE_SIZE];
jmarkel44 177:9ec90c8e3ce1 1545 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1546 "{ "
jmarkel44 177:9ec90c8e3ce1 1547 "\"id\": \"i_tra01\","
jmarkel44 177:9ec90c8e3ce1 1548 "\"name\": \"Trasar\", "
jmarkel44 177:9ec90c8e3ce1 1549 "\"units\": \"PPM\", "
jmarkel44 177:9ec90c8e3ce1 1550 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1551 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1552 "\"node\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1553 "\"reg\": \"9\", "
davidjhoward 190:af7ab603c9fe 1554 "\"rtype\": \"4\", "
jmarkel44 177:9ec90c8e3ce1 1555 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1556 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1557 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1558 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1559 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1560 "\"rfreq\": \"5\" }");
jmarkel44 230:11765008ff3a 1561 bool rc = GLOBAL_mdot->saveUserFile("input_i_tra01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1562 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1563 printf("\rFailed to save input_i_tra01.json\n");
jmarkel44 177:9ec90c8e3ce1 1564 return;
jmarkel44 177:9ec90c8e3ce1 1565 } else {
jmarkel44 177:9ec90c8e3ce1 1566 printf("\r...generated input_i_tra01.json\n");
jmarkel44 229:0d6755d765fd 1567 }
jmarkel44 177:9ec90c8e3ce1 1568
jmarkel44 177:9ec90c8e3ce1 1569 Message_t *mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1570 mail->action = ACTION_READ_FILE;
jmarkel44 177:9ec90c8e3ce1 1571 strncpy( mail->controlFile, "input_i_tra01.json", (sizeof(mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1572 ModbusMasterMailBox.put(mail);
jmarkel44 177:9ec90c8e3ce1 1573
davidjhoward 203:9d735375f218 1574 Thread::wait(5000);
davidjhoward 197:594afd088f32 1575
davidjhoward 197:594afd088f32 1576 // INPUT: Tag
davidjhoward 188:d35a74bf4e92 1577 snprintf(buf, sizeof(buf),
davidjhoward 188:d35a74bf4e92 1578 "{ "
davidjhoward 188:d35a74bf4e92 1579 "\"id\": \"i_tag01\","
davidjhoward 188:d35a74bf4e92 1580 "\"name\": \"Tag\", "
davidjhoward 188:d35a74bf4e92 1581 "\"units\": \"PPM\", "
davidjhoward 188:d35a74bf4e92 1582 "\"min\": \"0\", "
davidjhoward 188:d35a74bf4e92 1583 "\"max\": \"300\", "
davidjhoward 188:d35a74bf4e92 1584 "\"node\": \"1\", "
davidjhoward 188:d35a74bf4e92 1585 "\"reg\": \"11\", "
davidjhoward 190:af7ab603c9fe 1586 "\"rtype\": \"4\", "
davidjhoward 188:d35a74bf4e92 1587 "\"type\": \"0\", "
davidjhoward 188:d35a74bf4e92 1588 "\"size\": \"2\", "
davidjhoward 188:d35a74bf4e92 1589 "\"order\": \"2\", "
davidjhoward 188:d35a74bf4e92 1590 "\"fmt\": \"%%.2f\", "
davidjhoward 188:d35a74bf4e92 1591 "\"vcmd\": \"\", "
davidjhoward 188:d35a74bf4e92 1592 "\"rfreq\": \"5\" }");
davidjhoward 188:d35a74bf4e92 1593 rc = GLOBAL_mdot->saveUserFile("input_i_tag01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 188:d35a74bf4e92 1594 if ( rc != true ) {
davidjhoward 188:d35a74bf4e92 1595 printf("\rFailed to save input_i_tag01.json\n");
davidjhoward 188:d35a74bf4e92 1596 return;
davidjhoward 188:d35a74bf4e92 1597 } else {
davidjhoward 188:d35a74bf4e92 1598 printf("\r...generated input_i_tag01.json\n");
davidjhoward 188:d35a74bf4e92 1599 }
davidjhoward 188:d35a74bf4e92 1600
davidjhoward 188:d35a74bf4e92 1601 mail = ModbusMasterMailBox.alloc();
davidjhoward 188:d35a74bf4e92 1602 mail->action = ACTION_READ_FILE;
davidjhoward 188:d35a74bf4e92 1603 strncpy( mail->controlFile, "input_i_tag01.json", (sizeof(mail->controlFile)-1));
davidjhoward 188:d35a74bf4e92 1604 ModbusMasterMailBox.put(mail);
davidjhoward 188:d35a74bf4e92 1605
davidjhoward 203:9d735375f218 1606 Thread::wait(5000);
jmarkel44 177:9ec90c8e3ce1 1607
jmarkel44 177:9ec90c8e3ce1 1608
jmarkel44 177:9ec90c8e3ce1 1609 // INPUT: Conductivity
jmarkel44 177:9ec90c8e3ce1 1610 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1611 "{ "
jmarkel44 177:9ec90c8e3ce1 1612 "\"id\": \"i_bdcond01\","
jmarkel44 177:9ec90c8e3ce1 1613 "\"name\": \"Tower Conductivity\", "
davidjhoward 186:16912aa18c2a 1614 "\"units\": \"uS\","
davidjhoward 186:16912aa18c2a 1615 "\"min\": \"0\","
davidjhoward 186:16912aa18c2a 1616 "\"max\": \"6000\","
davidjhoward 186:16912aa18c2a 1617 "\"node\": \"21\","
davidjhoward 186:16912aa18c2a 1618 "\"reg\": \"18\","
davidjhoward 190:af7ab603c9fe 1619 "\"rtype\": \"4\","
davidjhoward 186:16912aa18c2a 1620 "\"type\": \"1\","
davidjhoward 186:16912aa18c2a 1621 "\"size\": \"2\","
davidjhoward 186:16912aa18c2a 1622 "\"order\": \"2\","
davidjhoward 186:16912aa18c2a 1623 "\"fmt\": \"%%.2f\","
davidjhoward 186:16912aa18c2a 1624 "\"vcmd\": \"\","
jmarkel44 177:9ec90c8e3ce1 1625 "\"rfreq\": \"5\" }");
jmarkel44 177:9ec90c8e3ce1 1626 rc = GLOBAL_mdot->saveUserFile("input_i_bdcond01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1627 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1628 printf("\rFailed to save input_i_bdcond01.json\n");
jmarkel44 177:9ec90c8e3ce1 1629 return;
jmarkel44 177:9ec90c8e3ce1 1630 } else {
jmarkel44 177:9ec90c8e3ce1 1631 printf("\r...generated input_i_bdcond01.json\n");
jmarkel44 177:9ec90c8e3ce1 1632 }
jmarkel44 177:9ec90c8e3ce1 1633
jmarkel44 177:9ec90c8e3ce1 1634 mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1635 mail->action = ACTION_READ_FILE;
davidjhoward 186:16912aa18c2a 1636 strncpy( mail->controlFile, "input_i_bdcond01.json", (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 1637 ModbusMasterMailBox.put(mail);
davidjhoward 186:16912aa18c2a 1638
davidjhoward 203:9d735375f218 1639 Thread::wait(5000);
davidjhoward 197:594afd088f32 1640
davidjhoward 197:594afd088f32 1641 // INPUT: Conductivity Temperature
davidjhoward 186:16912aa18c2a 1642 snprintf(buf, sizeof(buf),
davidjhoward 186:16912aa18c2a 1643 "{ "
davidjhoward 199:d65ed41d4dd4 1644 "\"id\": \"i_cond_temp01\","
davidjhoward 186:16912aa18c2a 1645 "\"name\": \"Temp Conductivity\","
davidjhoward 186:16912aa18c2a 1646 "\"units\": \"C\","
davidjhoward 186:16912aa18c2a 1647 "\"min\": \"0\","
davidjhoward 186:16912aa18c2a 1648 "\"max\": \"80\","
davidjhoward 186:16912aa18c2a 1649 "\"node\": \"21\","
davidjhoward 186:16912aa18c2a 1650 "\"reg\": \"10\","
davidjhoward 190:af7ab603c9fe 1651 "\"rtype\": \"4\","
davidjhoward 186:16912aa18c2a 1652 "\"type\": \"1\","
davidjhoward 186:16912aa18c2a 1653 "\"size\": \"2\","
davidjhoward 186:16912aa18c2a 1654 "\"order\": \"2\","
davidjhoward 186:16912aa18c2a 1655 "\"fmt\": \"%%.2f\","
davidjhoward 186:16912aa18c2a 1656 "\"vcmd\": \"\","
davidjhoward 186:16912aa18c2a 1657 "\"rfreq\": \"5\" }");
davidjhoward 199:d65ed41d4dd4 1658 rc = GLOBAL_mdot->saveUserFile("input_i_cond_temp01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 186:16912aa18c2a 1659 if ( rc != true ) {
davidjhoward 199:d65ed41d4dd4 1660 printf("\rFailed to save input_i_cond_temp01.json\n");
davidjhoward 186:16912aa18c2a 1661 return;
davidjhoward 186:16912aa18c2a 1662 } else {
davidjhoward 199:d65ed41d4dd4 1663 printf("\r...generated input_i_cond_temp01.json\n");
davidjhoward 186:16912aa18c2a 1664 }
davidjhoward 186:16912aa18c2a 1665
davidjhoward 186:16912aa18c2a 1666 mail = ModbusMasterMailBox.alloc();
davidjhoward 186:16912aa18c2a 1667 mail->action = ACTION_READ_FILE;
davidjhoward 199:d65ed41d4dd4 1668 strncpy( mail->controlFile, "input_i_cond_temp01.json", (sizeof(mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1669 ModbusMasterMailBox.put(mail);
jmarkel44 177:9ec90c8e3ce1 1670
davidjhoward 203:9d735375f218 1671 Thread::wait(5000);
jmarkel44 207:55aabde2d4bf 1672
jmarkel44 207:55aabde2d4bf 1673 // INPUT: pH Temperature
davidjhoward 190:af7ab603c9fe 1674 snprintf(buf, sizeof(buf),
davidjhoward 190:af7ab603c9fe 1675 "{ "
davidjhoward 199:d65ed41d4dd4 1676 "\"id\": \"i_ph_temp01\","
davidjhoward 199:d65ed41d4dd4 1677 "\"name\": \"Temp pH\","
davidjhoward 199:d65ed41d4dd4 1678 "\"units\": \"C\","
davidjhoward 190:af7ab603c9fe 1679 "\"min\": \"0\","
davidjhoward 199:d65ed41d4dd4 1680 "\"max\": \"10\","
davidjhoward 199:d65ed41d4dd4 1681 "\"node\": \"22\","
davidjhoward 199:d65ed41d4dd4 1682 "\"reg\": \"10\","
davidjhoward 199:d65ed41d4dd4 1683 "\"rtype\": \"4\","
davidjhoward 199:d65ed41d4dd4 1684 "\"type\": \"1\","
davidjhoward 190:af7ab603c9fe 1685 "\"size\": \"2\","
davidjhoward 190:af7ab603c9fe 1686 "\"order\": \"2\","
davidjhoward 190:af7ab603c9fe 1687 "\"fmt\": \"%%.2f\","
davidjhoward 190:af7ab603c9fe 1688 "\"vcmd\": \"\","
davidjhoward 190:af7ab603c9fe 1689 "\"rfreq\": \"5\" }");
davidjhoward 199:d65ed41d4dd4 1690 rc = GLOBAL_mdot->saveUserFile("input_i_ph_temp01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 190:af7ab603c9fe 1691 if ( rc != true ) {
davidjhoward 199:d65ed41d4dd4 1692 printf("\rFailed to save input_i_ph_temp01.json\n");
davidjhoward 190:af7ab603c9fe 1693 return;
davidjhoward 190:af7ab603c9fe 1694 } else {
davidjhoward 199:d65ed41d4dd4 1695 printf("\r...generated input_i_ph_temp01.json\n");
davidjhoward 190:af7ab603c9fe 1696 }
davidjhoward 190:af7ab603c9fe 1697
davidjhoward 190:af7ab603c9fe 1698 mail = ModbusMasterMailBox.alloc();
davidjhoward 190:af7ab603c9fe 1699 mail->action = ACTION_READ_FILE;
davidjhoward 199:d65ed41d4dd4 1700 strncpy( mail->controlFile, "input_i_ph_temp01.json", (sizeof(mail->controlFile)-1));
davidjhoward 199:d65ed41d4dd4 1701 ModbusMasterMailBox.put(mail);
davidjhoward 199:d65ed41d4dd4 1702
davidjhoward 203:9d735375f218 1703 Thread::wait(5000);
jmarkel44 207:55aabde2d4bf 1704
jmarkel44 207:55aabde2d4bf 1705 // INPUT: pH
davidjhoward 199:d65ed41d4dd4 1706 snprintf(buf, sizeof(buf),
davidjhoward 199:d65ed41d4dd4 1707 "{ "
davidjhoward 199:d65ed41d4dd4 1708 "\"id\": \"i_ph01\","
davidjhoward 199:d65ed41d4dd4 1709 "\"name\": \"pH\","
davidjhoward 199:d65ed41d4dd4 1710 "\"units\": \"pH\","
davidjhoward 199:d65ed41d4dd4 1711 "\"min\": \"0\","
davidjhoward 199:d65ed41d4dd4 1712 "\"max\": \"10\","
davidjhoward 199:d65ed41d4dd4 1713 "\"node\": \"22\","
davidjhoward 199:d65ed41d4dd4 1714 "\"reg\": \"18\","
davidjhoward 199:d65ed41d4dd4 1715 "\"rtype\": \"4\","
davidjhoward 199:d65ed41d4dd4 1716 "\"type\": \"1\","
davidjhoward 199:d65ed41d4dd4 1717 "\"size\": \"2\","
davidjhoward 199:d65ed41d4dd4 1718 "\"order\": \"2\","
davidjhoward 199:d65ed41d4dd4 1719 "\"fmt\": \"%%.2f\","
davidjhoward 199:d65ed41d4dd4 1720 "\"vcmd\": \"\","
davidjhoward 199:d65ed41d4dd4 1721 "\"rfreq\": \"5\" }");
davidjhoward 199:d65ed41d4dd4 1722 rc = GLOBAL_mdot->saveUserFile("input_i_ph01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 199:d65ed41d4dd4 1723 if ( rc != true ) {
davidjhoward 199:d65ed41d4dd4 1724 printf("\rFailed to save input_i_ph01.json\n");
davidjhoward 199:d65ed41d4dd4 1725 return;
davidjhoward 199:d65ed41d4dd4 1726 } else {
davidjhoward 199:d65ed41d4dd4 1727 printf("\r...generated input_i_ph01.json\n");
davidjhoward 199:d65ed41d4dd4 1728 }
davidjhoward 199:d65ed41d4dd4 1729
davidjhoward 199:d65ed41d4dd4 1730 mail = ModbusMasterMailBox.alloc();
davidjhoward 199:d65ed41d4dd4 1731 mail->action = ACTION_READ_FILE;
davidjhoward 199:d65ed41d4dd4 1732 strncpy( mail->controlFile, "input_i_ph01.json", (sizeof(mail->controlFile)-1));
davidjhoward 199:d65ed41d4dd4 1733 ModbusMasterMailBox.put(mail);
davidjhoward 199:d65ed41d4dd4 1734
davidjhoward 203:9d735375f218 1735 Thread::wait(5000);
jmarkel44 207:55aabde2d4bf 1736
jmarkel44 207:55aabde2d4bf 1737 // INPUT: ORP
davidjhoward 199:d65ed41d4dd4 1738 snprintf(buf, sizeof(buf),
davidjhoward 199:d65ed41d4dd4 1739 "{ "
davidjhoward 199:d65ed41d4dd4 1740 "\"id\": \"i_orp01\","
davidjhoward 199:d65ed41d4dd4 1741 "\"name\": \"ORP\","
davidjhoward 199:d65ed41d4dd4 1742 "\"units\": \"mV\","
davidjhoward 199:d65ed41d4dd4 1743 "\"min\": \"0\","
davidjhoward 199:d65ed41d4dd4 1744 "\"max\": \"10\","
davidjhoward 211:bca3e42bd4de 1745 "\"node\": \"23\","
davidjhoward 199:d65ed41d4dd4 1746 "\"reg\": \"14\","
davidjhoward 199:d65ed41d4dd4 1747 "\"rtype\": \"4\","
davidjhoward 199:d65ed41d4dd4 1748 "\"type\": \"1\","
davidjhoward 199:d65ed41d4dd4 1749 "\"size\": \"2\","
davidjhoward 199:d65ed41d4dd4 1750 "\"order\": \"2\","
davidjhoward 199:d65ed41d4dd4 1751 "\"fmt\": \"%%.2f\","
davidjhoward 199:d65ed41d4dd4 1752 "\"vcmd\": \"\","
davidjhoward 199:d65ed41d4dd4 1753 "\"rfreq\": \"5\" }");
davidjhoward 199:d65ed41d4dd4 1754 rc = GLOBAL_mdot->saveUserFile("input_i_orp01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 199:d65ed41d4dd4 1755 if ( rc != true ) {
davidjhoward 199:d65ed41d4dd4 1756 printf("\rFailed to save input_i_orp01.json\n");
davidjhoward 199:d65ed41d4dd4 1757 return;
davidjhoward 199:d65ed41d4dd4 1758 } else {
davidjhoward 199:d65ed41d4dd4 1759 printf("\r...generated input_i_orp01.json\n");
davidjhoward 199:d65ed41d4dd4 1760 }
davidjhoward 199:d65ed41d4dd4 1761
davidjhoward 199:d65ed41d4dd4 1762 mail = ModbusMasterMailBox.alloc();
davidjhoward 199:d65ed41d4dd4 1763 mail->action = ACTION_READ_FILE;
davidjhoward 199:d65ed41d4dd4 1764 strncpy( mail->controlFile, "input_i_orp01.json", (sizeof(mail->controlFile)-1));
davidjhoward 190:af7ab603c9fe 1765 ModbusMasterMailBox.put(mail);
davidjhoward 190:af7ab603c9fe 1766
davidjhoward 203:9d735375f218 1767 Thread::wait(5000);
jmarkel44 207:55aabde2d4bf 1768
jmarkel44 207:55aabde2d4bf 1769 // INPUT: Flow Switch
davidjhoward 203:9d735375f218 1770 snprintf(buf, sizeof(buf),
davidjhoward 203:9d735375f218 1771 "{ "
davidjhoward 203:9d735375f218 1772 "\"id\": \"i_flowsw01\","
davidjhoward 203:9d735375f218 1773 "\"name\": \"Flow\","
davidjhoward 203:9d735375f218 1774 "\"units\": \"\","
davidjhoward 203:9d735375f218 1775 "\"min\": \"0\","
davidjhoward 203:9d735375f218 1776 "\"max\": \"1\","
davidjhoward 203:9d735375f218 1777 "\"node\": \"0\","
davidjhoward 203:9d735375f218 1778 "\"reg\": \"1\","
davidjhoward 203:9d735375f218 1779 "\"rtype\": \"0\","
davidjhoward 203:9d735375f218 1780 "\"type\": \"3\","
davidjhoward 203:9d735375f218 1781 "\"size\": \"2\","
davidjhoward 203:9d735375f218 1782 "\"order\": \"0\","
davidjhoward 203:9d735375f218 1783 "\"fmt\": \"%%d\","
davidjhoward 203:9d735375f218 1784 "\"vcmd\": \"\","
davidjhoward 203:9d735375f218 1785 "\"rfreq\": \"5\" }");
davidjhoward 203:9d735375f218 1786 rc = GLOBAL_mdot->saveUserFile("input_i_flowsw01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 203:9d735375f218 1787 if ( rc != true ) {
davidjhoward 203:9d735375f218 1788 printf("\rFailed to save input_i_flowsw01.json\n");
davidjhoward 203:9d735375f218 1789 return;
davidjhoward 203:9d735375f218 1790 } else {
davidjhoward 203:9d735375f218 1791 printf("\r...generated input_i_flowsw01.json\n");
davidjhoward 203:9d735375f218 1792 }
davidjhoward 203:9d735375f218 1793
davidjhoward 203:9d735375f218 1794 mail = ModbusMasterMailBox.alloc();
davidjhoward 203:9d735375f218 1795 mail->action = ACTION_READ_FILE;
davidjhoward 203:9d735375f218 1796 strncpy( mail->controlFile, "input_i_flowsw01.json", (sizeof(mail->controlFile)-1));
davidjhoward 203:9d735375f218 1797 ModbusMasterMailBox.put(mail);
davidjhoward 203:9d735375f218 1798
davidjhoward 203:9d735375f218 1799 Thread::wait(5000);
jmarkel44 177:9ec90c8e3ce1 1800
jmarkel44 230:11765008ff3a 1801 #if 0
davidjhoward 214:52ef35bc44ec 1802 snprintf(buf, sizeof(buf),
davidjhoward 214:52ef35bc44ec 1803 "{ "
davidjhoward 214:52ef35bc44ec 1804 "\"id\":\"%s\", "
davidjhoward 214:52ef35bc44ec 1805 "\"tag\":\"%s\", "
davidjhoward 214:52ef35bc44ec 1806 "\"opl\":\"%s\", "
davidjhoward 214:52ef35bc44ec 1807 "\"opr\":\"%s\", "
davidjhoward 214:52ef35bc44ec 1808 "\"op\":\"%s\", "
davidjhoward 214:52ef35bc44ec 1809 "\"c\":\"%s\" } ", "TEMP_CONV_PH01", "i_ph_temp01", "i_ph_temp01", "", "/", "1000.0");
jmarkel44 220:dbe21411f962 1810
davidjhoward 214:52ef35bc44ec 1811 printf("JSON=%s\r\n",buf);
jmarkel44 220:dbe21411f962 1812
davidjhoward 214:52ef35bc44ec 1813 rc = GLOBAL_mdot->saveUserFile("vcmd_TEMP_CONV_PH01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 214:52ef35bc44ec 1814 if( rc != true ) {
davidjhoward 214:52ef35bc44ec 1815 printf("(%d)save file failed, status=%d\r\n", __LINE__, rc);
davidjhoward 214:52ef35bc44ec 1816 }
davidjhoward 214:52ef35bc44ec 1817
davidjhoward 214:52ef35bc44ec 1818 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", "vcmd_TEMP_CONV_PH01.json");
davidjhoward 214:52ef35bc44ec 1819 mail = ModbusMasterMailBox.alloc();
davidjhoward 214:52ef35bc44ec 1820 mail->action = ACTION_READ_FILE;
davidjhoward 214:52ef35bc44ec 1821 strncpy( mail->controlFile, "vcmd_TEMP_CONV_PH01.json", (sizeof(mail->controlFile)-1));
davidjhoward 214:52ef35bc44ec 1822 ModbusMasterMailBox.put(mail);
jmarkel44 220:dbe21411f962 1823
davidjhoward 214:52ef35bc44ec 1824 Thread::wait(5000);
jmarkel44 220:dbe21411f962 1825
davidjhoward 216:7783e894f7e0 1826 snprintf(buf, sizeof(buf),
davidjhoward 216:7783e894f7e0 1827 "{ "
davidjhoward 216:7783e894f7e0 1828 "\"id\":\"%s\", "
davidjhoward 216:7783e894f7e0 1829 "\"tag\":\"%s\", "
davidjhoward 216:7783e894f7e0 1830 "\"opl\":\"%s\", "
davidjhoward 216:7783e894f7e0 1831 "\"opr\":\"%s\", "
davidjhoward 216:7783e894f7e0 1832 "\"op\":\"%s\", "
davidjhoward 216:7783e894f7e0 1833 "\"c\":\"%s\" } ", "TEMP_CONV_BDCOND01", "i_cond_temp01", "i_cond_temp01", "", "/", "1000.0");
jmarkel44 220:dbe21411f962 1834
davidjhoward 216:7783e894f7e0 1835 printf("JSON=%s\r\n",buf);
jmarkel44 220:dbe21411f962 1836
davidjhoward 216:7783e894f7e0 1837 rc = GLOBAL_mdot->saveUserFile("vcmd_TEMP_CONV_BDCOND01.json", (void *)buf, MAX_FILE_SIZE);
davidjhoward 216:7783e894f7e0 1838 if( rc != true ) {
davidjhoward 216:7783e894f7e0 1839 printf("(%d)save file failed, status=%d\r\n", __LINE__, rc);
davidjhoward 216:7783e894f7e0 1840 }
davidjhoward 216:7783e894f7e0 1841
davidjhoward 216:7783e894f7e0 1842 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", "vcmd_TEMP_CONV_BDCOND01.json");
davidjhoward 216:7783e894f7e0 1843 mail = ModbusMasterMailBox.alloc();
davidjhoward 216:7783e894f7e0 1844 mail->action = ACTION_READ_FILE;
davidjhoward 216:7783e894f7e0 1845 strncpy( mail->controlFile, "vcmd_TEMP_CONV_BDCOND01.json", (sizeof(mail->controlFile)-1));
davidjhoward 216:7783e894f7e0 1846 ModbusMasterMailBox.put(mail);
jmarkel44 220:dbe21411f962 1847
davidjhoward 216:7783e894f7e0 1848 Thread::wait(5000);
jmarkel44 230:11765008ff3a 1849 #endif
davidjhoward 214:52ef35bc44ec 1850
jmarkel44 177:9ec90c8e3ce1 1851 // OUTPUT: Relay 01
jmarkel44 177:9ec90c8e3ce1 1852 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1853 "{ "
jmarkel44 177:9ec90c8e3ce1 1854 "\"id\": \"o_rly01\", "
jmarkel44 177:9ec90c8e3ce1 1855 "\"name\": \"Blowdown\", "
jmarkel44 177:9ec90c8e3ce1 1856 "\"units\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1857 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1858 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1859 "\"node\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1860 "\"reg\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1861 "\"rtype\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1862 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1863 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1864 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1865 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1866 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1867 "\"rfreq\": \"5\", "
jmarkel44 177:9ec90c8e3ce1 1868 "\"toperiod\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1869 "\"scalelo\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1870 "\"scalehi\": \"100\" }");
jmarkel44 177:9ec90c8e3ce1 1871 rc = GLOBAL_mdot->saveUserFile("output_o_rly01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1872 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1873 printf("\rFailed to save output_o_rly01.json\n");
jmarkel44 177:9ec90c8e3ce1 1874 return;
jmarkel44 177:9ec90c8e3ce1 1875 } else {
jmarkel44 177:9ec90c8e3ce1 1876 printf("\r...generated output_o_rly01.json\n");
jmarkel44 177:9ec90c8e3ce1 1877 }
jmarkel44 177:9ec90c8e3ce1 1878
jmarkel44 177:9ec90c8e3ce1 1879 // send a message to the modbus master
jmarkel44 177:9ec90c8e3ce1 1880 Message_t *modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1881 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 177:9ec90c8e3ce1 1882 strncpy( modbus_mail->controlFile, "output_o_rly01.json", (sizeof(modbus_mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1883 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 177:9ec90c8e3ce1 1884
davidjhoward 203:9d735375f218 1885 Thread::wait(5000);
jmarkel44 177:9ec90c8e3ce1 1886
jmarkel44 177:9ec90c8e3ce1 1887 // send a message to the output master
jmarkel44 177:9ec90c8e3ce1 1888 OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1889 output_mail->action = ACTION_NEW;
jmarkel44 177:9ec90c8e3ce1 1890 strncpy(output_mail->controlFile, "output_o_rly01.json", sizeof(output_mail->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 1891 OutputMasterMailBox.put(output_mail);
jmarkel44 177:9ec90c8e3ce1 1892
davidjhoward 203:9d735375f218 1893 Thread::wait(2000);
jmarkel44 177:9ec90c8e3ce1 1894
jmarkel44 177:9ec90c8e3ce1 1895 // OUTPUT: Relay 02
jmarkel44 177:9ec90c8e3ce1 1896 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 1897 "{ "
jmarkel44 177:9ec90c8e3ce1 1898 "\"id\": \"o_rly02\", "
jmarkel44 177:9ec90c8e3ce1 1899 "\"name\": \"3DTS86\", "
jmarkel44 177:9ec90c8e3ce1 1900 "\"units\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1901 "\"min\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1902 "\"max\": \"300\", "
jmarkel44 177:9ec90c8e3ce1 1903 "\"node\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1904 "\"reg\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1905 "\"rtype\": \"1\", "
jmarkel44 177:9ec90c8e3ce1 1906 "\"type\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1907 "\"size\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1908 "\"order\": \"2\", "
jmarkel44 177:9ec90c8e3ce1 1909 "\"fmt\": \"%%.2f\", "
jmarkel44 177:9ec90c8e3ce1 1910 "\"vcmd\": \"\", "
jmarkel44 177:9ec90c8e3ce1 1911 "\"rfreq\": \"5\", "
jmarkel44 177:9ec90c8e3ce1 1912 "\"toperiod\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1913 "\"scalelo\": \"0\", "
jmarkel44 177:9ec90c8e3ce1 1914 "\"scalehi\": \"100\" }");
jmarkel44 177:9ec90c8e3ce1 1915 rc = GLOBAL_mdot->saveUserFile("output_o_rly02.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 1916 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 1917 printf("\rFailed to save output_o_rly02.json\n");
jmarkel44 177:9ec90c8e3ce1 1918 return;
jmarkel44 177:9ec90c8e3ce1 1919 } else {
jmarkel44 177:9ec90c8e3ce1 1920 printf("\r...generated output_o_rly02.json\n");
jmarkel44 177:9ec90c8e3ce1 1921 }
jmarkel44 177:9ec90c8e3ce1 1922
jmarkel44 177:9ec90c8e3ce1 1923 // send a message to the modbus master
jmarkel44 177:9ec90c8e3ce1 1924 modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1925 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 177:9ec90c8e3ce1 1926 strncpy( modbus_mail->controlFile, "output_o_rly02.json", (sizeof(modbus_mail->controlFile)-1));
jmarkel44 177:9ec90c8e3ce1 1927 ModbusMasterMailBox.put(modbus_mail);
jmarkel44 177:9ec90c8e3ce1 1928
davidjhoward 203:9d735375f218 1929 Thread::wait(5000);
jmarkel44 177:9ec90c8e3ce1 1930
jmarkel44 177:9ec90c8e3ce1 1931 // send a message to the output master
jmarkel44 177:9ec90c8e3ce1 1932 output_mail = OutputMasterMailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 1933 output_mail->action = ACTION_NEW;
jmarkel44 177:9ec90c8e3ce1 1934 strncpy(output_mail->controlFile, "output_o_rly02.json", sizeof(output_mail->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 1935 OutputMasterMailBox.put(output_mail);
jmarkel44 177:9ec90c8e3ce1 1936
davidjhoward 203:9d735375f218 1937 Thread::wait(2000);
jmarkel44 207:55aabde2d4bf 1938
jmarkel44 220:dbe21411f962 1939 /*
jmarkel44 220:dbe21411f962 1940 // OUTPUT: Relay 03
jmarkel44 220:dbe21411f962 1941 snprintf(buf, sizeof(buf),
jmarkel44 220:dbe21411f962 1942 "{ "
jmarkel44 220:dbe21411f962 1943 "\"id\": \"o_rly03\", "
jmarkel44 220:dbe21411f962 1944 "\"name\": \"Bleach\", "
jmarkel44 220:dbe21411f962 1945 "\"units\": \"\", "
jmarkel44 220:dbe21411f962 1946 "\"min\": \"0\", "
jmarkel44 220:dbe21411f962 1947 "\"max\": \"300\", "
jmarkel44 220:dbe21411f962 1948 "\"node\": \"50\", "
jmarkel44 220:dbe21411f962 1949 "\"reg\": \"3\", "
jmarkel44 220:dbe21411f962 1950 "\"rtype\": \"1\", "
jmarkel44 220:dbe21411f962 1951 "\"type\": \"0\", "
jmarkel44 220:dbe21411f962 1952 "\"size\": \"2\", "
jmarkel44 220:dbe21411f962 1953 "\"order\": \"2\", "
jmarkel44 220:dbe21411f962 1954 "\"fmt\": \"%%.2f\", "
jmarkel44 220:dbe21411f962 1955 "\"vcmd\": \"\", "
jmarkel44 220:dbe21411f962 1956 "\"rfreq\": \"5\", "
jmarkel44 220:dbe21411f962 1957 "\"toperiod\": \"0\", "
jmarkel44 220:dbe21411f962 1958 "\"scalelo\": \"0\", "
jmarkel44 220:dbe21411f962 1959 "\"scalehi\": \"100\" }");
jmarkel44 220:dbe21411f962 1960 rc = GLOBAL_mdot->saveUserFile("output_o_rly03.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 1961 if ( rc != true ) {
jmarkel44 220:dbe21411f962 1962 printf("\rFailed to save output_o_rly03.json\n");
jmarkel44 220:dbe21411f962 1963 return;
jmarkel44 220:dbe21411f962 1964 } else {
jmarkel44 220:dbe21411f962 1965 printf("\r...generated output_o_rly03.json\n");
jmarkel44 220:dbe21411f962 1966 }
davidjhoward 203:9d735375f218 1967
jmarkel44 220:dbe21411f962 1968 // send a message to the modbus master
jmarkel44 220:dbe21411f962 1969 modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 1970 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 220:dbe21411f962 1971 strncpy( modbus_mail->controlFile, "output_o_rly03.json", (sizeof(modbus_mail->controlFile)-1));
jmarkel44 220:dbe21411f962 1972 ModbusMasterMailBox.put(modbus_mail);
davidjhoward 203:9d735375f218 1973
jmarkel44 220:dbe21411f962 1974 Thread::wait(5000);
davidjhoward 203:9d735375f218 1975
jmarkel44 220:dbe21411f962 1976 // send a message to the output master
jmarkel44 220:dbe21411f962 1977 output_mail = OutputMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 1978 output_mail->action = ACTION_NEW;
jmarkel44 220:dbe21411f962 1979 strncpy(output_mail->controlFile, "output_o_rly03.json", sizeof(output_mail->controlFile)-1);
jmarkel44 220:dbe21411f962 1980 OutputMasterMailBox.put(output_mail);
davidjhoward 203:9d735375f218 1981
jmarkel44 220:dbe21411f962 1982 Thread::wait(2000);
jmarkel44 207:55aabde2d4bf 1983
jmarkel44 220:dbe21411f962 1984 // OUTPUT: Relay 04
jmarkel44 220:dbe21411f962 1985 snprintf(buf, sizeof(buf),
jmarkel44 220:dbe21411f962 1986 "{ "
jmarkel44 220:dbe21411f962 1987 "\"id\": \"o_rly04\", "
jmarkel44 220:dbe21411f962 1988 "\"name\": \"H2SO4\", "
jmarkel44 220:dbe21411f962 1989 "\"units\": \"\", "
jmarkel44 220:dbe21411f962 1990 "\"min\": \"0\", "
jmarkel44 220:dbe21411f962 1991 "\"max\": \"300\", "
jmarkel44 220:dbe21411f962 1992 "\"node\": \"50\", "
jmarkel44 220:dbe21411f962 1993 "\"reg\": \"4\", "
jmarkel44 220:dbe21411f962 1994 "\"rtype\": \"1\", "
jmarkel44 220:dbe21411f962 1995 "\"type\": \"0\", "
jmarkel44 220:dbe21411f962 1996 "\"size\": \"2\", "
jmarkel44 220:dbe21411f962 1997 "\"order\": \"2\", "
jmarkel44 220:dbe21411f962 1998 "\"fmt\": \"%%.2f\", "
jmarkel44 220:dbe21411f962 1999 "\"vcmd\": \"\", "
jmarkel44 220:dbe21411f962 2000 "\"rfreq\": \"5\", "
jmarkel44 220:dbe21411f962 2001 "\"toperiod\": \"0\", "
jmarkel44 220:dbe21411f962 2002 "\"scalelo\": \"0\", "
jmarkel44 220:dbe21411f962 2003 "\"scalehi\": \"100\" }");
jmarkel44 220:dbe21411f962 2004 rc = GLOBAL_mdot->saveUserFile("output_o_rly04.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 2005 if ( rc != true ) {
jmarkel44 220:dbe21411f962 2006 printf("\rFailed to save output_o_rly04.json\n");
jmarkel44 220:dbe21411f962 2007 return;
jmarkel44 220:dbe21411f962 2008 } else {
jmarkel44 220:dbe21411f962 2009 printf("\r...generated output_o_rly04.json\n");
jmarkel44 220:dbe21411f962 2010 }
davidjhoward 203:9d735375f218 2011
jmarkel44 220:dbe21411f962 2012 // send a message to the modbus master
jmarkel44 220:dbe21411f962 2013 modbus_mail = ModbusMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 2014 modbus_mail->action = ACTION_READ_FILE;
jmarkel44 220:dbe21411f962 2015 strncpy( modbus_mail->controlFile, "output_o_rly04.json", (sizeof(modbus_mail->controlFile)-1));
jmarkel44 220:dbe21411f962 2016 ModbusMasterMailBox.put(modbus_mail);
davidjhoward 203:9d735375f218 2017
jmarkel44 220:dbe21411f962 2018 Thread::wait(5000);
davidjhoward 203:9d735375f218 2019
jmarkel44 220:dbe21411f962 2020 // send a message to the output master
jmarkel44 220:dbe21411f962 2021 output_mail = OutputMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 2022 output_mail->action = ACTION_NEW;
jmarkel44 220:dbe21411f962 2023 strncpy(output_mail->controlFile, "output_o_rly04.json", sizeof(output_mail->controlFile)-1);
jmarkel44 220:dbe21411f962 2024 OutputMasterMailBox.put(output_mail);
davidjhoward 203:9d735375f218 2025
jmarkel44 220:dbe21411f962 2026 Thread::wait(2000);
jmarkel44 207:55aabde2d4bf 2027
jmarkel44 220:dbe21411f962 2028 */
jmarkel44 177:9ec90c8e3ce1 2029 // SETPOINT: Blowdown
jmarkel44 177:9ec90c8e3ce1 2030 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 2031 "{ "
jmarkel44 177:9ec90c8e3ce1 2032 "\"id\": \"BLOWDOWN_01\", "
jmarkel44 177:9ec90c8e3ce1 2033 "\"priority\": \"800\", "
jmarkel44 177:9ec90c8e3ce1 2034 "\"input\": \"i_bdcond01\", "
jmarkel44 177:9ec90c8e3ce1 2035 "\"output\": \"o_rly01\", "
davidjhoward 199:d65ed41d4dd4 2036 "\"setpoint\": \"1800\", "
jmarkel44 177:9ec90c8e3ce1 2037 "\"prodfact\": \"\", "
jmarkel44 177:9ec90c8e3ce1 2038 "\"actingDir\": \"1\", "
davidjhoward 199:d65ed41d4dd4 2039 "\"halert\": \"2400\", "
davidjhoward 199:d65ed41d4dd4 2040 "\"lalert\": \"800\", "
davidjhoward 199:d65ed41d4dd4 2041 "\"hfs\": \"2700\", "
davidjhoward 199:d65ed41d4dd4 2042 "\"lfs\": \"700\", "
davidjhoward 199:d65ed41d4dd4 2043 "\"tol\": \"30\" }");
jmarkel44 177:9ec90c8e3ce1 2044 rc = GLOBAL_mdot->saveUserFile("control_sp_bd01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 2045 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 2046 printf("\rFailed to save control_sp_bd01.json\n");
jmarkel44 177:9ec90c8e3ce1 2047 return;
jmarkel44 177:9ec90c8e3ce1 2048 } else {
jmarkel44 177:9ec90c8e3ce1 2049 printf("\r...generated control_sp_bd01.json\n");
jmarkel44 177:9ec90c8e3ce1 2050 }
jmarkel44 177:9ec90c8e3ce1 2051
jmarkel44 177:9ec90c8e3ce1 2052 Message_t *sp_msg = MailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 2053 memset(sp_msg, 0, sizeof(Message_t));
jmarkel44 177:9ec90c8e3ce1 2054 sp_msg->action = ACTION_CREATE;
jmarkel44 177:9ec90c8e3ce1 2055 sp_msg->control = CONTROL_SETPOINT;
jmarkel44 177:9ec90c8e3ce1 2056 strncpy(sp_msg->controlFile, "control_sp_bd01.json", sizeof(sp_msg->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 2057
jmarkel44 177:9ec90c8e3ce1 2058 MailBox.put(sp_msg);
jmarkel44 177:9ec90c8e3ce1 2059
davidjhoward 203:9d735375f218 2060 Thread::wait(2000);
jmarkel44 177:9ec90c8e3ce1 2061
jmarkel44 177:9ec90c8e3ce1 2062 // SETPOINT: Trasar
jmarkel44 177:9ec90c8e3ce1 2063 snprintf(buf, sizeof(buf),
jmarkel44 177:9ec90c8e3ce1 2064 "{ "
jmarkel44 177:9ec90c8e3ce1 2065 "\"id\": \"INH_TRA_01\", "
jmarkel44 177:9ec90c8e3ce1 2066 "\"priority\": \"800\", "
jmarkel44 177:9ec90c8e3ce1 2067 "\"input\": \"i_tra01\", "
jmarkel44 177:9ec90c8e3ce1 2068 "\"output\": \"o_rly02\", "
davidjhoward 199:d65ed41d4dd4 2069 "\"setpoint\": \"130\", "
jmarkel44 177:9ec90c8e3ce1 2070 "\"prodfact\": \"100\", "
jmarkel44 177:9ec90c8e3ce1 2071 "\"actingDir\": \"0\", "
davidjhoward 199:d65ed41d4dd4 2072 "\"halert\": \"190\", "
davidjhoward 199:d65ed41d4dd4 2073 "\"lalert\": \"92\", "
davidjhoward 199:d65ed41d4dd4 2074 "\"hfs\": \"200\", "
jmarkel44 177:9ec90c8e3ce1 2075 "\"lfs\": \"70\", "
davidjhoward 199:d65ed41d4dd4 2076 "\"tol\": \"4\" }");
jmarkel44 177:9ec90c8e3ce1 2077 rc = GLOBAL_mdot->saveUserFile("control_sp_tra01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 177:9ec90c8e3ce1 2078 if ( rc != true ) {
jmarkel44 177:9ec90c8e3ce1 2079 printf("\rFailed to save control_sp_tra01.json\n");
jmarkel44 177:9ec90c8e3ce1 2080 return;
jmarkel44 177:9ec90c8e3ce1 2081 } else {
jmarkel44 177:9ec90c8e3ce1 2082 printf("\r...generated control_sp_tra01.json\n");
jmarkel44 177:9ec90c8e3ce1 2083 Thread::wait(500);
jmarkel44 177:9ec90c8e3ce1 2084 }
jmarkel44 177:9ec90c8e3ce1 2085
jmarkel44 177:9ec90c8e3ce1 2086 sp_msg = MailBox.alloc();
jmarkel44 177:9ec90c8e3ce1 2087 memset(sp_msg, 0, sizeof(Message_t));
jmarkel44 177:9ec90c8e3ce1 2088 sp_msg->action = ACTION_CREATE;
jmarkel44 177:9ec90c8e3ce1 2089 sp_msg->control = CONTROL_SETPOINT;
jmarkel44 177:9ec90c8e3ce1 2090 strncpy(sp_msg->controlFile, "control_sp_tra01.json", sizeof(sp_msg->controlFile)-1);
jmarkel44 177:9ec90c8e3ce1 2091
jmarkel44 177:9ec90c8e3ce1 2092 MailBox.put(sp_msg);
davidjhoward 203:9d735375f218 2093 Thread::wait(2000);
jmarkel44 207:55aabde2d4bf 2094
jmarkel44 220:dbe21411f962 2095 /*
jmarkel44 220:dbe21411f962 2096 // SETPOINT: Acid Base
jmarkel44 220:dbe21411f962 2097 snprintf(buf, sizeof(buf),
jmarkel44 220:dbe21411f962 2098 "{ "
jmarkel44 220:dbe21411f962 2099 "\"id\": \"ACID_BASE_01\", "
jmarkel44 220:dbe21411f962 2100 "\"priority\": \"800\", "
jmarkel44 220:dbe21411f962 2101 "\"input\": \"i_ph01\", "
jmarkel44 220:dbe21411f962 2102 "\"output\": \"o_rly04\", "
jmarkel44 220:dbe21411f962 2103 "\"setpoint\": \"8\", "
jmarkel44 220:dbe21411f962 2104 "\"prodfact\": \"\", "
jmarkel44 220:dbe21411f962 2105 "\"actingDir\": \"1\", "
jmarkel44 220:dbe21411f962 2106 "\"halert\": \"9.10\", "
jmarkel44 220:dbe21411f962 2107 "\"lalert\": \"6.80\", "
jmarkel44 220:dbe21411f962 2108 "\"hfs\": \"9.40\", "
jmarkel44 220:dbe21411f962 2109 "\"lfs\": \"6.40\", "
jmarkel44 220:dbe21411f962 2110 "\"tol\": \".5\" }");
jmarkel44 220:dbe21411f962 2111 rc = GLOBAL_mdot->saveUserFile("control_sp_ph01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 2112 if ( rc != true ) {
jmarkel44 220:dbe21411f962 2113 printf("\rFailed to save control_sp_ph01.json\n");
jmarkel44 220:dbe21411f962 2114 return;
jmarkel44 220:dbe21411f962 2115 } else {
jmarkel44 220:dbe21411f962 2116 printf("\r...generated control_sp_ph01.json\n");
jmarkel44 220:dbe21411f962 2117 Thread::wait(500);
jmarkel44 220:dbe21411f962 2118 }
davidjhoward 203:9d735375f218 2119
jmarkel44 220:dbe21411f962 2120 sp_msg = MailBox.alloc();
jmarkel44 220:dbe21411f962 2121 memset(sp_msg, 0, sizeof(Message_t));
jmarkel44 220:dbe21411f962 2122 sp_msg->action = ACTION_CREATE;
jmarkel44 220:dbe21411f962 2123 sp_msg->control = CONTROL_SETPOINT;
jmarkel44 220:dbe21411f962 2124 strncpy(sp_msg->controlFile, "control_sp_ph01.json", sizeof(sp_msg->controlFile)-1);
davidjhoward 203:9d735375f218 2125
jmarkel44 220:dbe21411f962 2126 MailBox.put(sp_msg);
jmarkel44 220:dbe21411f962 2127 Thread::wait(2000);
jmarkel44 207:55aabde2d4bf 2128
jmarkel44 220:dbe21411f962 2129 // SETPOINT: MicroBio
jmarkel44 220:dbe21411f962 2130 snprintf(buf, sizeof(buf),
jmarkel44 220:dbe21411f962 2131 "{ "
jmarkel44 220:dbe21411f962 2132 "\"id\": \"MICRO_BIO_01\", "
jmarkel44 220:dbe21411f962 2133 "\"priority\": \"800\", "
jmarkel44 220:dbe21411f962 2134 "\"input\": \"i_orp01\", "
jmarkel44 220:dbe21411f962 2135 "\"output\": \"o_rly03\", "
jmarkel44 220:dbe21411f962 2136 "\"setpoint\": \"350\", "
jmarkel44 220:dbe21411f962 2137 "\"prodfact\": \"\", "
jmarkel44 220:dbe21411f962 2138 "\"actingDir\": \"0\", "
jmarkel44 220:dbe21411f962 2139 "\"halert\": \"500\", "
jmarkel44 220:dbe21411f962 2140 "\"lalert\": \"200\", "
jmarkel44 220:dbe21411f962 2141 "\"hfs\": \"525\", "
jmarkel44 220:dbe21411f962 2142 "\"lfs\": \"150\", "
jmarkel44 220:dbe21411f962 2143 "\"tol\": \"25\" }");
jmarkel44 220:dbe21411f962 2144 rc = GLOBAL_mdot->saveUserFile("control_sp_orp01.json", (void *)buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 2145 if ( rc != true ) {
jmarkel44 220:dbe21411f962 2146 printf("\rFailed to save control_sp_orp01.json\n");
jmarkel44 220:dbe21411f962 2147 return;
jmarkel44 220:dbe21411f962 2148 } else {
jmarkel44 220:dbe21411f962 2149 printf("\r...generated control_sp_orp01.json\n");
jmarkel44 220:dbe21411f962 2150 Thread::wait(500);
jmarkel44 220:dbe21411f962 2151 }
davidjhoward 203:9d735375f218 2152
jmarkel44 220:dbe21411f962 2153 sp_msg = MailBox.alloc();
jmarkel44 220:dbe21411f962 2154 memset(sp_msg, 0, sizeof(Message_t));
jmarkel44 220:dbe21411f962 2155 sp_msg->action = ACTION_CREATE;
jmarkel44 220:dbe21411f962 2156 sp_msg->control = CONTROL_SETPOINT;
jmarkel44 220:dbe21411f962 2157 strncpy(sp_msg->controlFile, "control_sp_orp01.json", sizeof(sp_msg->controlFile)-1);
davidjhoward 203:9d735375f218 2158
jmarkel44 220:dbe21411f962 2159 MailBox.put(sp_msg);
jmarkel44 220:dbe21411f962 2160 Thread::wait(2000);
jmarkel44 220:dbe21411f962 2161 */
davidjhoward 186:16912aa18c2a 2162 }
davidjhoward 186:16912aa18c2a 2163
davidjhoward 186:16912aa18c2a 2164 /*****************************************************************************
davidjhoward 186:16912aa18c2a 2165 * Function: cmd_createTemp
davidjhoward 186:16912aa18c2a 2166 * Description: create input file
davidjhoward 186:16912aa18c2a 2167 *
davidjhoward 186:16912aa18c2a 2168 * @param argc-> number of args
davidjhoward 186:16912aa18c2a 2169 * @param argv-> filename
davidjhoward 186:16912aa18c2a 2170 * @return none
davidjhoward 186:16912aa18c2a 2171 *****************************************************************************/
davidjhoward 186:16912aa18c2a 2172 void cmd_createTemp(int argc, char **argv)
davidjhoward 186:16912aa18c2a 2173 {
davidjhoward 186:16912aa18c2a 2174 char data_buf[MAX_FILE_SIZE];
davidjhoward 186:16912aa18c2a 2175 snprintf(data_buf, sizeof(data_buf),
davidjhoward 186:16912aa18c2a 2176 "{ "
davidjhoward 186:16912aa18c2a 2177 "\"id\": \"i_temp01\", "
davidjhoward 186:16912aa18c2a 2178 "\"name\": \"Temp Conductivity\", "
davidjhoward 186:16912aa18c2a 2179 "\"units\": \"C\", "
davidjhoward 186:16912aa18c2a 2180 "\"min\": \"0\", "
davidjhoward 186:16912aa18c2a 2181 "\"max\": \"300\", "
davidjhoward 186:16912aa18c2a 2182 "\"node\": \"21\", "
davidjhoward 186:16912aa18c2a 2183 "\"reg\": \"10\", "
davidjhoward 186:16912aa18c2a 2184 "\"rtype\": \"1\", "
davidjhoward 186:16912aa18c2a 2185 "\"type\": \"1\", "
davidjhoward 186:16912aa18c2a 2186 "\"size\": \"2\", "
davidjhoward 186:16912aa18c2a 2187 "\"order\": \"2\", "
davidjhoward 186:16912aa18c2a 2188 "\"rfreq\": \"5\", "
davidjhoward 186:16912aa18c2a 2189 "\"vcmd\": \"\","
davidjhoward 186:16912aa18c2a 2190 "\"fmt\": \"%%.2f\" } ");
davidjhoward 186:16912aa18c2a 2191
davidjhoward 186:16912aa18c2a 2192 bool status = GLOBAL_mdot->saveUserFile("input_i_temp01.json", (void *)data_buf, MAX_FILE_SIZE);
davidjhoward 186:16912aa18c2a 2193 if( status != true ) {
davidjhoward 186:16912aa18c2a 2194 logInfo("(%d)save file failed, status=%d", __LINE__, status);
davidjhoward 186:16912aa18c2a 2195 }
davidjhoward 186:16912aa18c2a 2196
davidjhoward 186:16912aa18c2a 2197 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", "input_i_temp01.json");
davidjhoward 186:16912aa18c2a 2198 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 186:16912aa18c2a 2199 mail->action = ACTION_READ_FILE;
davidjhoward 186:16912aa18c2a 2200 strncpy( mail->controlFile, "input_i_temp01.json", (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 2201 ModbusMasterMailBox.put(mail);
davidjhoward 186:16912aa18c2a 2202 }
davidjhoward 186:16912aa18c2a 2203
davidjhoward 186:16912aa18c2a 2204 /*****************************************************************************
davidjhoward 186:16912aa18c2a 2205 * Function: cmd_createBDCond
davidjhoward 186:16912aa18c2a 2206 * Description: create input file
davidjhoward 186:16912aa18c2a 2207 *
davidjhoward 186:16912aa18c2a 2208 * @param argc-> number of args
davidjhoward 186:16912aa18c2a 2209 * @param argv-> filename
davidjhoward 186:16912aa18c2a 2210 * @return none
davidjhoward 186:16912aa18c2a 2211 *****************************************************************************/
davidjhoward 197:594afd088f32 2212 void cmd_modbusCmd(int argc, char **argv)
davidjhoward 186:16912aa18c2a 2213 {
davidjhoward 197:594afd088f32 2214 if ( (argc != 7) && (argc != 8)) {
davidjhoward 199:d65ed41d4dd4 2215 printf("\r\nusage: mod-cmd <node> <func> <sreg> <nreg> <dtype> <order> <value>\r\n");
davidjhoward 199:d65ed41d4dd4 2216 printf("example (read product factor): mod-cmd 1 3 40 2 0 2\r\n");
davidjhoward 199:d65ed41d4dd4 2217 printf("example (write product factor): mod-cmd 1 16 40 2 0 2 100.0\r\n");
davidjhoward 186:16912aa18c2a 2218 return;
davidjhoward 186:16912aa18c2a 2219 }
davidjhoward 186:16912aa18c2a 2220
davidjhoward 197:594afd088f32 2221 char snd_buf[128];
davidjhoward 186:16912aa18c2a 2222
davidjhoward 197:594afd088f32 2223 memset( snd_buf, '\0', 128 );
davidjhoward 197:594afd088f32 2224 snprintf(snd_buf, sizeof(snd_buf),
davidjhoward 197:594afd088f32 2225 "{"
davidjhoward 197:594afd088f32 2226 "\"id\":\"%s\","
davidjhoward 197:594afd088f32 2227 "\"node\":\"%s\","
davidjhoward 197:594afd088f32 2228 "\"func\":\"%s\","
davidjhoward 197:594afd088f32 2229 "\"sreg\":\"%s\","
davidjhoward 197:594afd088f32 2230 "\"nreg\":\"%s\","
davidjhoward 197:594afd088f32 2231 "\"dtype\":\"%s\","
davidjhoward 197:594afd088f32 2232 "\"order\":\"%s\","
davidjhoward 197:594afd088f32 2233 "\"value\":\"%s\"}",
davidjhoward 197:594afd088f32 2234 "READ_MODBUS",
davidjhoward 197:594afd088f32 2235 argv[1],
davidjhoward 197:594afd088f32 2236 argv[2],
davidjhoward 197:594afd088f32 2237 argv[3],
davidjhoward 197:594afd088f32 2238 argv[4],
davidjhoward 197:594afd088f32 2239 argv[5],
davidjhoward 197:594afd088f32 2240 argv[6],
davidjhoward 197:594afd088f32 2241 argv[7]
davidjhoward 197:594afd088f32 2242 );
davidjhoward 186:16912aa18c2a 2243
davidjhoward 197:594afd088f32 2244 printf("Sending Command To ModbusMasterMailBox: %s : len=%d\r\n", snd_buf, strlen(snd_buf));
davidjhoward 186:16912aa18c2a 2245 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 197:594afd088f32 2246 mail->action = ACTION_EXEC_CMD;
davidjhoward 197:594afd088f32 2247 strncpy( mail->controlFile, snd_buf, (sizeof(mail->controlFile)-1));
davidjhoward 186:16912aa18c2a 2248 ModbusMasterMailBox.put(mail);
davidjhoward 214:52ef35bc44ec 2249 }
davidjhoward 214:52ef35bc44ec 2250
davidjhoward 214:52ef35bc44ec 2251 /*****************************************************************************
davidjhoward 214:52ef35bc44ec 2252 * Function: cmd_regcmd
davidjhoward 214:52ef35bc44ec 2253 * Description: create register command
davidjhoward 214:52ef35bc44ec 2254 *
davidjhoward 214:52ef35bc44ec 2255 * @param argc-> number of args
davidjhoward 214:52ef35bc44ec 2256 * @param argv-> filename
davidjhoward 214:52ef35bc44ec 2257 * @return none
davidjhoward 214:52ef35bc44ec 2258 *****************************************************************************/
davidjhoward 214:52ef35bc44ec 2259 void cmd_regcmd(int argc, char **argv)
davidjhoward 214:52ef35bc44ec 2260 {
davidjhoward 214:52ef35bc44ec 2261 char filename[64];
jmarkel44 220:dbe21411f962 2262
davidjhoward 214:52ef35bc44ec 2263 printf("argc=%d\r\n",argc);
jmarkel44 220:dbe21411f962 2264
davidjhoward 214:52ef35bc44ec 2265 if ( argc != 7 ) {
davidjhoward 214:52ef35bc44ec 2266 printf("\rusage: regcmd <if> <tag> <opl> <opr> <op> <c>\n");
davidjhoward 214:52ef35bc44ec 2267 printf("\rexample: regcmd TEMP_CONV_PH01 i_ph_temp01 i_ph_temp01 - / 1000\n");
davidjhoward 214:52ef35bc44ec 2268 return;
davidjhoward 214:52ef35bc44ec 2269 }
jmarkel44 220:dbe21411f962 2270
davidjhoward 214:52ef35bc44ec 2271 memset( filename, 0, 64 );
davidjhoward 214:52ef35bc44ec 2272 snprintf( filename, 63, "%s%s%s", "vcmd_", argv[1], ".json" );
davidjhoward 214:52ef35bc44ec 2273 printf("filename=%s\r\n",filename);
jmarkel44 220:dbe21411f962 2274
davidjhoward 214:52ef35bc44ec 2275 std::string opl(argv[4]);
jmarkel44 220:dbe21411f962 2276
davidjhoward 214:52ef35bc44ec 2277 printf("argv[4]=%s, opl=%s\r\n",argv[4], opl.c_str());
jmarkel44 220:dbe21411f962 2278 if( opl.c_str()[0] == '-' ) {
davidjhoward 214:52ef35bc44ec 2279 printf("argv[4]=%s, SETTING TO NULL\r\n",argv[4]);
davidjhoward 214:52ef35bc44ec 2280 opl = "";
davidjhoward 214:52ef35bc44ec 2281 }
davidjhoward 214:52ef35bc44ec 2282
davidjhoward 214:52ef35bc44ec 2283 char data_buf[MAX_FILE_SIZE];
davidjhoward 214:52ef35bc44ec 2284 snprintf(data_buf, sizeof(data_buf),
davidjhoward 214:52ef35bc44ec 2285 "{ "
davidjhoward 214:52ef35bc44ec 2286 "\"id\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2287 "\"tag\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2288 "\"opl\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2289 "\"opr\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2290 "\"op\":\"%s\", "
davidjhoward 214:52ef35bc44ec 2291 "\"c\":\"%s\" } ", argv[1], argv[2], argv[3], opl.c_str(), argv[5], argv[6]);
jmarkel44 220:dbe21411f962 2292
davidjhoward 214:52ef35bc44ec 2293 printf("JSON=%s\r\n",data_buf);
jmarkel44 220:dbe21411f962 2294
davidjhoward 214:52ef35bc44ec 2295 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
davidjhoward 214:52ef35bc44ec 2296 if( status != true ) {
davidjhoward 214:52ef35bc44ec 2297 logInfo("(%d)save file failed, status=%d", __LINE__, status);
davidjhoward 214:52ef35bc44ec 2298 }
davidjhoward 214:52ef35bc44ec 2299
davidjhoward 214:52ef35bc44ec 2300 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", filename);
davidjhoward 214:52ef35bc44ec 2301 Message_t *mail = ModbusMasterMailBox.alloc();
davidjhoward 214:52ef35bc44ec 2302 mail->action = ACTION_READ_FILE;
davidjhoward 214:52ef35bc44ec 2303 strncpy( mail->controlFile, filename, (sizeof(mail->controlFile)-1));
davidjhoward 214:52ef35bc44ec 2304 ModbusMasterMailBox.put(mail);
davidjhoward 214:52ef35bc44ec 2305 }
davidjhoward 214:52ef35bc44ec 2306
davidjhoward 214:52ef35bc44ec 2307 /*****************************************************************************
davidjhoward 214:52ef35bc44ec 2308 * Function: cmd_trimTemp
davidjhoward 214:52ef35bc44ec 2309 * Description: create register command
davidjhoward 214:52ef35bc44ec 2310 *
davidjhoward 214:52ef35bc44ec 2311 * @param argc-> number of args
davidjhoward 214:52ef35bc44ec 2312 * @param argv-> filename
davidjhoward 214:52ef35bc44ec 2313 * @return none
davidjhoward 214:52ef35bc44ec 2314 *****************************************************************************/
davidjhoward 214:52ef35bc44ec 2315 void cmd_trimTemp(int argc, char **argv)
davidjhoward 214:52ef35bc44ec 2316 {
jmarkel44 220:dbe21411f962 2317 /*
jmarkel44 220:dbe21411f962 2318
jmarkel44 220:dbe21411f962 2319 char filename[64];
davidjhoward 214:52ef35bc44ec 2320
jmarkel44 220:dbe21411f962 2321 memset( filename, 0, 64 );
jmarkel44 220:dbe21411f962 2322 snprintf( filename, 63, "%s%s%s", "vcmd_", "2_DIV_TEMP_PH01", ".json" );
jmarkel44 220:dbe21411f962 2323 printf("filename=%s\r\n",filename);
davidjhoward 214:52ef35bc44ec 2324
jmarkel44 220:dbe21411f962 2325 char data_buf[MAX_FILE_SIZE];
jmarkel44 220:dbe21411f962 2326 snprintf(data_buf, sizeof(data_buf),
jmarkel44 220:dbe21411f962 2327 "{ "
jmarkel44 220:dbe21411f962 2328 "\"id\":\"%s\", "
jmarkel44 220:dbe21411f962 2329 "\"tag\":\"%s\", "
jmarkel44 220:dbe21411f962 2330 "\"opl\":\"%s\", "
jmarkel44 220:dbe21411f962 2331 "\"opr\":\"%s\", "
jmarkel44 220:dbe21411f962 2332 "\"op\":\"%s\", "
jmarkel44 220:dbe21411f962 2333 "\"c\":\"%s\" } ", "2_DIV_TEMP_PH01", "i_ph_temp01", "i_ph_temp01", "", "/", "1000.0");
jmarkel44 220:dbe21411f962 2334
jmarkel44 220:dbe21411f962 2335 printf("JSON=%s\r\n",data_buf);
jmarkel44 220:dbe21411f962 2336
jmarkel44 220:dbe21411f962 2337 bool status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 2338 if( status != true ) {
jmarkel44 220:dbe21411f962 2339 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 220:dbe21411f962 2340 }
jmarkel44 220:dbe21411f962 2341
jmarkel44 220:dbe21411f962 2342 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", filename);
jmarkel44 220:dbe21411f962 2343 Message_t *mail = ModbusMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 2344 mail->action = ACTION_READ_FILE;
jmarkel44 220:dbe21411f962 2345 strncpy( mail->controlFile, filename, (sizeof(mail->controlFile)-1));
jmarkel44 220:dbe21411f962 2346 ModbusMasterMailBox.put(mail);
davidjhoward 214:52ef35bc44ec 2347
jmarkel44 220:dbe21411f962 2348 Thread::wait(5000);
jmarkel44 220:dbe21411f962 2349
jmarkel44 220:dbe21411f962 2350 memset( filename, 0, 64 );
jmarkel44 220:dbe21411f962 2351 snprintf( filename, 63, "%s%s%s", "vcmd_", "1_CONST_TEMP_PH01", ".json" );
jmarkel44 220:dbe21411f962 2352 printf("filename=%s\r\n",filename);
jmarkel44 220:dbe21411f962 2353
jmarkel44 220:dbe21411f962 2354 snprintf(data_buf, sizeof(data_buf),
jmarkel44 220:dbe21411f962 2355 "{ "
jmarkel44 220:dbe21411f962 2356 "\"id\":\"%s\", "
jmarkel44 220:dbe21411f962 2357 "\"tag\":\"%s\", "
jmarkel44 220:dbe21411f962 2358 "\"opl\":\"%s\", "
jmarkel44 220:dbe21411f962 2359 "\"opr\":\"%s\", "
jmarkel44 220:dbe21411f962 2360 "\"op\":\"%s\", "
jmarkel44 220:dbe21411f962 2361 "\"c\":\"%s\" } ", "1_CONST_TEMP_PH01", "i_ph_temp01", "i_ph_temp01", "", "=", "26000.0");
davidjhoward 214:52ef35bc44ec 2362
jmarkel44 220:dbe21411f962 2363 printf("JSON=%s\r\n",data_buf);
jmarkel44 220:dbe21411f962 2364
jmarkel44 220:dbe21411f962 2365 status = GLOBAL_mdot->saveUserFile(filename, (void *)data_buf, MAX_FILE_SIZE);
jmarkel44 220:dbe21411f962 2366 if( status != true ) {
jmarkel44 220:dbe21411f962 2367 logInfo("(%d)save file failed, status=%d", __LINE__, status);
jmarkel44 220:dbe21411f962 2368 }
davidjhoward 214:52ef35bc44ec 2369
jmarkel44 220:dbe21411f962 2370 logInfo("Sending Mail To ModbusMasterMailBox, filename=%s", filename);
jmarkel44 220:dbe21411f962 2371 mail = ModbusMasterMailBox.alloc();
jmarkel44 220:dbe21411f962 2372 mail->action = ACTION_READ_FILE;
jmarkel44 220:dbe21411f962 2373 strncpy( mail->controlFile, filename, (sizeof(mail->controlFile)-1));
jmarkel44 220:dbe21411f962 2374 ModbusMasterMailBox.put(mail);
jmarkel44 220:dbe21411f962 2375
jmarkel44 220:dbe21411f962 2376 Thread::wait(5000);
jmarkel44 220:dbe21411f962 2377 */
jmarkel44 62:1b1d7918adf2 2378 }