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@177:9ec90c8e3ce1, 2016-10-04 (annotated)

Committer:
jmarkel44
Date:
Tue Oct 04 15:46:51 2016 +0000
Revision:
177:9ec90c8e3ce1
Parent:
172:51dfb4aabc57
Child:
180:b548e289b648
added "demo" command

Who changed what in which revision?

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