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@197:594afd088f32, 2016-10-06 (annotated)

Committer:
davidjhoward
Date:
Thu Oct 06 20:59:59 2016 +0000
Revision:
197:594afd088f32
Parent:
190:af7ab603c9fe
Child:
199:d65ed41d4dd4
adding modbus writes

Who changed what in which revision?

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