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/OutputTask/OutputTask.cpp@195:21df85341cb3, 2016-10-06 (annotated)

Committer:
jmarkel44
Date:
Thu Oct 06 19:31:13 2016 +0000
Revision:
195:21df85341cb3
Parent:
185:5ac6ab1ed875
Child:
212:289f63158d2b
general cleanup and additional logging

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jmarkel44 70:7427f4959201 1 /******************************************************************************
jmarkel44 70:7427f4959201 2 *
jmarkel44 70:7427f4959201 3 * File: OutputTask.cpp
jmarkel44 70:7427f4959201 4 * Desciption: source for the ICE Output task
jmarkel44 70:7427f4959201 5 *
jmarkel44 70:7427f4959201 6 *****************************************************************************/
jmarkel44 67:49f266601d83 7 #include "OutputTask.h"
jmarkel44 48:1c7861d80d16 8 #include "global.h"
jmarkel44 66:db1425574b58 9 #include "MbedJSONValue.h"
jmarkel44 94:18ae2fd82638 10 #include "ModbusMasterApi.h"
davidjhoward 120:539b20bd3816 11 #include "LoggerApi.h"
jmarkel44 185:5ac6ab1ed875 12 #include "Control.h"
jmarkel44 70:7427f4959201 13 #include <vector>
jmarkel44 77:43e0a3d9e536 14 #include <string>
jmarkel44 77:43e0a3d9e536 15 #include <algorithm>
jmarkel44 48:1c7861d80d16 16
jmarkel44 114:c24aebb8b473 17 // local functions
jmarkel44 67:49f266601d83 18 static int createOutput(const char *controlFile);
jmarkel44 66:db1425574b58 19 static void loadPersistentOutputs(void);
jmarkel44 195:21df85341cb3 20 static void writeOutputs(const std::string, const std::string);
jmarkel44 115:1558e01d04c6 21 static int enableOutputReq(OutputControlMsg_t *msg);
jmarkel44 115:1558e01d04c6 22 static int disableOutputReq(OutputControlMsg_t *msg);
jmarkel44 72:3754b352f156 23 static int unregisterControl(const char *id, unsigned int pri, const char *output);
jmarkel44 71:34856d21f2bf 24
jmarkel44 84:7b7cad3ba139 25 // The Output Map
jmarkel44 114:c24aebb8b473 26 //
jmarkel44 84:7b7cad3ba139 27 // this is the main data structure used to distinguish which control has
jmarkel44 84:7b7cad3ba139 28 // priority of an output. the layout is as-follows:
jmarkel44 84:7b7cad3ba139 29 //
jmarkel44 183:44f7fea6b208 30 // outputMap["o_rly1"]-> Control<"ManCtrl_rly1", 100, ON > <<- highest pri control manipulates relay
jmarkel44 183:44f7fea6b208 31 // Control<"SetpointCtrl_rly1", 800, OFF> <<- lowest pri (queued up)
jmarkel44 84:7b7cad3ba139 32 // outputMap["o_rly2"]-> Control<"SetpointCtrl_rly2", 800, ON >
jmarkel44 84:7b7cad3ba139 33 // outputMap["o_rly3"]-> Control<"TimerControl_rl3", 500, ON>
jmarkel44 84:7b7cad3ba139 34 //
jmarkel44 84:7b7cad3ba139 35 // The Control Vector (per relay) is always sorted by priority, whereas
jmarkel44 183:44f7fea6b208 36 // the highest priority control is at the front (v.front()) of the
jmarkel44 114:c24aebb8b473 37 // list.
jmarkel44 84:7b7cad3ba139 38
jmarkel44 195:21df85341cb3 39 typedef std::map<std::string, vector<Control> > StringOutputVector_t;
jmarkel44 77:43e0a3d9e536 40 StringOutputVector_t outputMap;
jmarkel44 66:db1425574b58 41
jmarkel44 84:7b7cad3ba139 42 // operator for sorting the outputs vectors per output
jmarkel44 80:b12b0adfcdc2 43 bool operator<(const Control &control1, const Control &control2)
jmarkel44 80:b12b0adfcdc2 44 {
jmarkel44 77:43e0a3d9e536 45 return control1.getPriority() < control2.getPriority();
jmarkel44 77:43e0a3d9e536 46 }
jmarkel44 63:0ded43237b22 47
jmarkel44 70:7427f4959201 48 /*****************************************************************************
jmarkel44 70:7427f4959201 49 * Function: OutputTask
jmarkel44 70:7427f4959201 50 * Description: Main entry point for the Output Task
jmarkel44 70:7427f4959201 51 *
jmarkel44 70:7427f4959201 52 * @param args -> not used
jmarkel44 70:7427f4959201 53 * @return none
jmarkel44 70:7427f4959201 54 *****************************************************************************/
jmarkel44 48:1c7861d80d16 55 void OutputTask(void const *args)
jmarkel44 48:1c7861d80d16 56 {
jmarkel44 80:b12b0adfcdc2 57 int rc;
jmarkel44 51:66b820f203a5 58 UNUSED(args);
jmarkel44 70:7427f4959201 59
jmarkel44 67:49f266601d83 60 printf("\r%s has started...\n", __func__);
jmarkel44 63:0ded43237b22 61
jmarkel44 66:db1425574b58 62 loadPersistentOutputs();
jmarkel44 75:96512ccc0443 63 osSignalSet(mainThreadId, sig_output_continue);
jmarkel44 75:96512ccc0443 64
jmarkel44 48:1c7861d80d16 65 while (true) {
jmarkel44 51:66b820f203a5 66 // wait for an event
jmarkel44 56:225786c56315 67 osEvent evt = OutputMasterMailBox.get();
jmarkel44 51:66b820f203a5 68 if (evt.status == osEventMail) {
jmarkel44 80:b12b0adfcdc2 69
jmarkel44 63:0ded43237b22 70 OutputControlMsg_t *msg = (OutputControlMsg_t*) evt.value.p;
jmarkel44 63:0ded43237b22 71
jmarkel44 63:0ded43237b22 72 switch ( msg->action ) {
jmarkel44 63:0ded43237b22 73 case ACTION_NEW:
jmarkel44 63:0ded43237b22 74 // read the file and and create an output entry
jmarkel44 80:b12b0adfcdc2 75 rc = createOutput(msg->controlFile);
jmarkel44 80:b12b0adfcdc2 76 if ( rc != 0 ) {
jmarkel44 80:b12b0adfcdc2 77 logError("%s: failed to create output %s\n",
jmarkel44 80:b12b0adfcdc2 78 __func__, msg->controlFile);
jmarkel44 80:b12b0adfcdc2 79 }
jmarkel44 63:0ded43237b22 80 break;
jmarkel44 71:34856d21f2bf 81 case ACTION_CONTROL_ON:
jmarkel44 115:1558e01d04c6 82 logInfo("%s is requesting ON control of %s", msg->id, msg->output_tag);
jmarkel44 115:1558e01d04c6 83 rc = enableOutputReq(msg);
jmarkel44 80:b12b0adfcdc2 84 if ( rc != 0 ) {
jmarkel44 80:b12b0adfcdc2 85 logError("%s: failed to enabled output for %s",
jmarkel44 80:b12b0adfcdc2 86 __func__, msg->id);
jmarkel44 80:b12b0adfcdc2 87 }
jmarkel44 71:34856d21f2bf 88 break;
jmarkel44 71:34856d21f2bf 89 case ACTION_CONTROL_OFF:
jmarkel44 115:1558e01d04c6 90 logInfo("%s is requesting OFF control of %s", msg->id, msg->output_tag);
jmarkel44 115:1558e01d04c6 91 rc = disableOutputReq(msg);
jmarkel44 80:b12b0adfcdc2 92 if ( rc != 0 ) {
jmarkel44 80:b12b0adfcdc2 93 printf("%s: failed to disabled output for %s",
jmarkel44 80:b12b0adfcdc2 94 __func__, msg->id);
jmarkel44 80:b12b0adfcdc2 95 }
jmarkel44 71:34856d21f2bf 96 break;
jmarkel44 72:3754b352f156 97 case ACTION_CONTROL_UNREGISTER:
jmarkel44 115:1558e01d04c6 98 logInfo("%s is requesting its deletion from %s", msg->id, msg->output_tag);
jmarkel44 115:1558e01d04c6 99 rc = unregisterControl(msg->id, msg->priority, msg->output_tag);
jmarkel44 80:b12b0adfcdc2 100 if ( rc != 0 ) {
jmarkel44 80:b12b0adfcdc2 101 printf("%s: failed to unregister control %s",
jmarkel44 84:7b7cad3ba139 102 __func__, msg->id);
jmarkel44 80:b12b0adfcdc2 103 }
jmarkel44 72:3754b352f156 104 break;
jmarkel44 63:0ded43237b22 105 default:
jmarkel44 63:0ded43237b22 106 break;
jmarkel44 63:0ded43237b22 107 }
jmarkel44 63:0ded43237b22 108
jmarkel44 56:225786c56315 109 // free the message
jmarkel44 56:225786c56315 110 OutputMasterMailBox.free(msg);
jmarkel44 114:c24aebb8b473 111
jmarkel44 114:c24aebb8b473 112 // refresh the outputs
jmarkel44 195:21df85341cb3 113 writeOutputs(msg->id, msg->output_tag);
jmarkel44 84:7b7cad3ba139 114 }
jmarkel44 84:7b7cad3ba139 115 }
jmarkel44 84:7b7cad3ba139 116 }
jmarkel44 84:7b7cad3ba139 117
jmarkel44 128:534bf29132f8 118 /*****************************************************************************
jmarkel44 128:534bf29132f8 119 * Function: recordEvent
jmarkel44 133:c871de2d2b90 120 * Description: send an event to the logger
jmarkel44 128:534bf29132f8 121 *
jmarkel44 133:c871de2d2b90 122 * @param output -> the output channel
jmarkel44 133:c871de2d2b90 123 * @param control -> the control, this can be null
jmarkel44 128:534bf29132f8 124 * @return none
jmarkel44 128:534bf29132f8 125 *****************************************************************************/
jmarkel44 115:1558e01d04c6 126 void recordEvent(std::string output, const Control *control)
jmarkel44 114:c24aebb8b473 127 {
jmarkel44 121:650205ffa656 128
jmarkel44 115:1558e01d04c6 129 EventReasonStruct_t ev;
jmarkel44 121:650205ffa656 130 ModbusValue input_value;
jmarkel44 121:650205ffa656 131 ModbusValue output_value;
jmarkel44 115:1558e01d04c6 132 memset(&ev, 0, sizeof(ev));
jmarkel44 121:650205ffa656 133
jmarkel44 128:534bf29132f8 134 if ( !control ) {
jmarkel44 128:534bf29132f8 135 ev.eventReason = EVENT_REASON_NO_CONTROL;
jmarkel44 128:534bf29132f8 136 ModbusMasterReadRegister(output, &output_value);
jmarkel44 128:534bf29132f8 137 strncpy(ev.outputTag, output.c_str(), sizeof(ev.outputTag));
jmarkel44 128:534bf29132f8 138 ev.outputValue = output_value.value;
jmarkel44 128:534bf29132f8 139
jmarkel44 128:534bf29132f8 140 printf("\rEVENT RECORD\n");
jmarkel44 128:534bf29132f8 141 printf("\rev.eventReason = %d\n", ev.eventReason);
jmarkel44 128:534bf29132f8 142 printf("\rev.outputTag = %s\n", ev.outputTag);
jmarkel44 128:534bf29132f8 143 printf("\rev.outputValue = %.02f\n", ev.outputValue);
jmarkel44 128:534bf29132f8 144
jmarkel44 128:534bf29132f8 145 EventLoggerApi(ev);
jmarkel44 128:534bf29132f8 146 return;
jmarkel44 128:534bf29132f8 147 }
jmarkel44 128:534bf29132f8 148
jmarkel44 115:1558e01d04c6 149 switch ( control->getControlType() ) {
jmarkel44 121:650205ffa656 150 case CONTROL_SETPOINT:
jmarkel44 115:1558e01d04c6 151 ev.eventReason = EVENT_REASON_AUTO;
jmarkel44 115:1558e01d04c6 152 strncpy(ev.inputTag, control->getInput().c_str(), sizeof(ev.inputTag));
jmarkel44 115:1558e01d04c6 153 strncpy(ev.outputTag, output.c_str(), sizeof(ev.outputTag));
jmarkel44 115:1558e01d04c6 154 ModbusMasterReadRegister(control->getInput(), &input_value);
jmarkel44 115:1558e01d04c6 155 ModbusMasterReadRegister(output, &output_value);
jmarkel44 115:1558e01d04c6 156 ev.inputValue = input_value.value;
jmarkel44 115:1558e01d04c6 157 ev.outputValue = output_value.value;
jmarkel44 115:1558e01d04c6 158 printf("\rEVENT RECORD\n");
jmarkel44 115:1558e01d04c6 159 printf("\rev.eventReason = %d\n", ev.eventReason);
jmarkel44 115:1558e01d04c6 160 printf("\rev.outputTag = %s\n", ev.outputTag);
jmarkel44 115:1558e01d04c6 161 printf("\rev.outputValue = %.02f\n", ev.outputValue);
jmarkel44 115:1558e01d04c6 162 EventLoggerApi(ev);
jmarkel44 115:1558e01d04c6 163 break;
jmarkel44 133:c871de2d2b90 164
jmarkel44 115:1558e01d04c6 165 case CONTROL_MANUAL:
jmarkel44 121:650205ffa656 166 ev.eventReason = EVENT_REASON_MANUAL;
jmarkel44 121:650205ffa656 167 strncpy(ev.outputTag, output.c_str(), sizeof(ev.outputTag));
jmarkel44 121:650205ffa656 168 ModbusMasterReadRegister(output, &output_value);
jmarkel44 121:650205ffa656 169 ev.outputValue = output_value.value;
jmarkel44 121:650205ffa656 170 printf("\rEVENT RECORD\n");
jmarkel44 121:650205ffa656 171 printf("\rev.eventReason = %d\n", ev.eventReason);
jmarkel44 121:650205ffa656 172 printf("\rev.outputTag = %s\n", ev.outputTag);
jmarkel44 121:650205ffa656 173 printf("\rev.outputValue = %.02f\n", ev.outputValue);
jmarkel44 121:650205ffa656 174 EventLoggerApi(ev);
jmarkel44 121:650205ffa656 175 break;
jmarkel44 133:c871de2d2b90 176
jmarkel44 133:c871de2d2b90 177 case CONTROL_TIMER:
jmarkel44 133:c871de2d2b90 178 ev.eventReason = EVENT_REASON_TIMER;
jmarkel44 133:c871de2d2b90 179 strncpy(ev.outputTag, output.c_str(), sizeof(ev.outputTag));
jmarkel44 133:c871de2d2b90 180 ModbusMasterReadRegister(output, &output_value);
jmarkel44 133:c871de2d2b90 181 ev.outputValue = output_value.value;
jmarkel44 133:c871de2d2b90 182 printf("\rEVENT RECORD\n");
jmarkel44 133:c871de2d2b90 183 printf("\rev.eventReason = %d\n", ev.eventReason);
jmarkel44 133:c871de2d2b90 184 printf("\rev.outputTag = %s\n", ev.outputTag);
jmarkel44 133:c871de2d2b90 185 printf("\rev.outputValue = %.02f\n", ev.outputValue);
jmarkel44 133:c871de2d2b90 186 EventLoggerApi(ev);
jmarkel44 133:c871de2d2b90 187 break;
jmarkel44 133:c871de2d2b90 188
jmarkel44 115:1558e01d04c6 189 default:
jmarkel44 115:1558e01d04c6 190 break;
jmarkel44 115:1558e01d04c6 191 }
jmarkel44 114:c24aebb8b473 192 }
jmarkel44 84:7b7cad3ba139 193
jmarkel44 84:7b7cad3ba139 194 /*****************************************************************************
jmarkel44 195:21df85341cb3 195 * Function: writeOutputs
jmarkel44 84:7b7cad3ba139 196 * Description: send a message to the modbus master of who's in control
jmarkel44 84:7b7cad3ba139 197 *
jmarkel44 84:7b7cad3ba139 198 *
jmarkel44 84:7b7cad3ba139 199 * @param args -> not used
jmarkel44 84:7b7cad3ba139 200 * @return none
jmarkel44 84:7b7cad3ba139 201 *****************************************************************************/
jmarkel44 195:21df85341cb3 202 static void writeOutputs(const std::string id, const std::string output_tag)
jmarkel44 84:7b7cad3ba139 203 {
jmarkel44 195:21df85341cb3 204 UNUSED(id);
jmarkel44 195:21df85341cb3 205
jmarkel44 133:c871de2d2b90 206 if ( output_tag.empty() ) return;
jmarkel44 133:c871de2d2b90 207
jmarkel44 84:7b7cad3ba139 208 StringOutputVector_t::iterator pos;
jmarkel44 84:7b7cad3ba139 209
jmarkel44 195:21df85341cb3 210 // find the output
jmarkel44 128:534bf29132f8 211 pos = outputMap.find(output_tag);
jmarkel44 128:534bf29132f8 212 if ( pos != outputMap.end() ) {
jmarkel44 195:21df85341cb3 213 // we found the ouput, but nothing's controlling it...
jmarkel44 128:534bf29132f8 214 if ( pos->second.empty() ) {
jmarkel44 185:5ac6ab1ed875 215 ModbusMasterWriteRegister(pos->first, RELAY_STATUS_NOT_CONTROLLED);
jmarkel44 128:534bf29132f8 216 recordEvent(pos->first, NULL);
jmarkel44 195:21df85341cb3 217 } else {
jmarkel44 185:5ac6ab1ed875 218 ModbusMasterWriteRegister(pos->first, pos->second.begin()->getMappedState());
jmarkel44 185:5ac6ab1ed875 219 printf("\rDEBUG: wrote %u to the modbus map\n", pos->second.begin()->getMappedState());
jmarkel44 128:534bf29132f8 220 recordEvent(pos->first, (Control*)pos->second.begin());
jmarkel44 128:534bf29132f8 221 }
jmarkel44 128:534bf29132f8 222 } else {
jmarkel44 128:534bf29132f8 223 logError("%s failed to find the selected output %s",
jmarkel44 128:534bf29132f8 224 __func__, output_tag.c_str());
jmarkel44 128:534bf29132f8 225 }
jmarkel44 66:db1425574b58 226 }
jmarkel44 66:db1425574b58 227
jmarkel44 70:7427f4959201 228 /*****************************************************************************
jmarkel44 70:7427f4959201 229 * Function: DisplayOutputs
jmarkel44 70:7427f4959201 230 * Description: Display a list of outputs and its controls
jmarkel44 70:7427f4959201 231 *
jmarkel44 70:7427f4959201 232 * @param args -> not used
jmarkel44 70:7427f4959201 233 * @return none
jmarkel44 70:7427f4959201 234 *****************************************************************************/
jmarkel44 66:db1425574b58 235 void DisplayOutputs(void)
jmarkel44 66:db1425574b58 236 {
jmarkel44 66:db1425574b58 237 StringOutputVector_t::iterator pos;
jmarkel44 164:7cecd731882e 238
jmarkel44 66:db1425574b58 239 for ( pos = outputMap.begin(); pos != outputMap.end(); ++pos ) {
jmarkel44 71:34856d21f2bf 240 if ( pos->second.empty() ) {
jmarkel44 71:34856d21f2bf 241 printf("\r [%s]->[no controls]\n", pos->first.c_str());
jmarkel44 71:34856d21f2bf 242 } else {
jmarkel44 71:34856d21f2bf 243 printf("\r [%s]->", pos->first.c_str());
jmarkel44 71:34856d21f2bf 244 vector<Control>::iterator i;
jmarkel44 71:34856d21f2bf 245 for ( i = pos->second.begin(); i != pos->second.end(); ++i ) {
jmarkel44 71:34856d21f2bf 246 i->display();
jmarkel44 71:34856d21f2bf 247 }
jmarkel44 71:34856d21f2bf 248 printf("\n");
jmarkel44 71:34856d21f2bf 249 }
jmarkel44 66:db1425574b58 250 }
jmarkel44 66:db1425574b58 251 printf("\r\n");
jmarkel44 66:db1425574b58 252 }
jmarkel44 66:db1425574b58 253
jmarkel44 71:34856d21f2bf 254
jmarkel44 71:34856d21f2bf 255 /*****************************************************************************
jmarkel44 72:3754b352f156 256 * Function: createOutput
jmarkel44 72:3754b352f156 257 * Description:
jmarkel44 71:34856d21f2bf 258 *
jmarkel44 77:43e0a3d9e536 259 * @param controlFile -> name of output file
jmarkel44 71:34856d21f2bf 260 * @return none
jmarkel44 71:34856d21f2bf 261 *****************************************************************************/
jmarkel44 77:43e0a3d9e536 262 static int createOutput(const char *outputFile)
jmarkel44 66:db1425574b58 263 {
jmarkel44 177:9ec90c8e3ce1 264 char dataBuf[MAX_FILE_SIZE];
jmarkel44 77:43e0a3d9e536 265 int status = GLOBAL_mdot->readUserFile(outputFile, (void *)dataBuf, sizeof(dataBuf));
jmarkel44 67:49f266601d83 266 if ( status != true ) {
jmarkel44 77:43e0a3d9e536 267 logError("%s failed to read %s", __func__, outputFile);
jmarkel44 66:db1425574b58 268 return -1;
jmarkel44 66:db1425574b58 269 }
jmarkel44 66:db1425574b58 270
jmarkel44 66:db1425574b58 271 MbedJSONValue json_value;
jmarkel44 66:db1425574b58 272 parse(json_value, dataBuf);
jmarkel44 195:21df85341cb3 273
jmarkel44 195:21df85341cb3 274 if ( !json_value.hasMember("id") ) {
jmarkel44 195:21df85341cb3 275 logError("Output file is missing expected tags");
jmarkel44 195:21df85341cb3 276 return -1;
jmarkel44 195:21df85341cb3 277 }
jmarkel44 66:db1425574b58 278
jmarkel44 66:db1425574b58 279 // extract the relay information
jmarkel44 195:21df85341cb3 280 std::string id = json_value["id"].get<string>();
jmarkel44 66:db1425574b58 281
jmarkel44 77:43e0a3d9e536 282 // maps don't allow duplicates, and the vector is empty for now
jmarkel44 71:34856d21f2bf 283 vector<Control> v;
jmarkel44 71:34856d21f2bf 284 outputMap[id] = v;
jmarkel44 71:34856d21f2bf 285
jmarkel44 71:34856d21f2bf 286 return 0;
jmarkel44 71:34856d21f2bf 287 }
jmarkel44 71:34856d21f2bf 288
jmarkel44 71:34856d21f2bf 289 /*****************************************************************************
jmarkel44 72:3754b352f156 290 * Function: enableOutputReq
jmarkel44 71:34856d21f2bf 291 * Description: Display a list of outputs and its controls
jmarkel44 71:34856d21f2bf 292 *
jmarkel44 71:34856d21f2bf 293 * @param args -> not used
jmarkel44 71:34856d21f2bf 294 * @return none
jmarkel44 71:34856d21f2bf 295 *****************************************************************************/
jmarkel44 115:1558e01d04c6 296 static int enableOutputReq(OutputControlMsg_t *msg)
jmarkel44 71:34856d21f2bf 297 {
jmarkel44 71:34856d21f2bf 298 // attempt to find the output in the map
jmarkel44 71:34856d21f2bf 299 StringOutputVector_t::iterator pos;
jmarkel44 71:34856d21f2bf 300
jmarkel44 115:1558e01d04c6 301 pos = outputMap.find(msg->output_tag);
jmarkel44 71:34856d21f2bf 302 if ( pos == outputMap.end() ) {
jmarkel44 71:34856d21f2bf 303 printf("%s: failed to find the designated output %s\n",
jmarkel44 115:1558e01d04c6 304 __func__, msg->output_tag);
jmarkel44 71:34856d21f2bf 305 return -1;
jmarkel44 71:34856d21f2bf 306 }
jmarkel44 71:34856d21f2bf 307
jmarkel44 71:34856d21f2bf 308 if ( pos->second.empty() ) {
jmarkel44 71:34856d21f2bf 309 // this is a new request
jmarkel44 195:21df85341cb3 310 std::string cid(msg->id);
jmarkel44 195:21df85341cb3 311 std::string input(msg->input_tag);
jmarkel44 115:1558e01d04c6 312 Control c(cid, msg->controlType, input, msg->priority, CONTROL_ON);
jmarkel44 71:34856d21f2bf 313 pos->second.push_back(c);
jmarkel44 71:34856d21f2bf 314 } else {
jmarkel44 71:34856d21f2bf 315 // find this control in the list
jmarkel44 71:34856d21f2bf 316 vector<Control>::iterator v;
jmarkel44 71:34856d21f2bf 317 for ( v = pos->second.begin(); v != pos->second.end(); ++v ) {
jmarkel44 115:1558e01d04c6 318 if ( strcmp(v->getId().c_str(), msg->id) == 0 ) {
jmarkel44 71:34856d21f2bf 319 v->setState(CONTROL_ON);
jmarkel44 77:43e0a3d9e536 320 break;
jmarkel44 71:34856d21f2bf 321 }
jmarkel44 71:34856d21f2bf 322 }
jmarkel44 77:43e0a3d9e536 323 if ( v == pos->second.end() ) {
jmarkel44 77:43e0a3d9e536 324 // this is a new request, so add it and sort the vector
jmarkel44 195:21df85341cb3 325 std::string cid(msg->id);
jmarkel44 195:21df85341cb3 326 std::string input(msg->input_tag);
jmarkel44 115:1558e01d04c6 327 Control c(cid, msg->controlType, input, msg->priority, CONTROL_ON);
jmarkel44 77:43e0a3d9e536 328 pos->second.push_back(c);
jmarkel44 77:43e0a3d9e536 329 std::sort(pos->second.begin(), pos->second.end());
jmarkel44 77:43e0a3d9e536 330 }
jmarkel44 71:34856d21f2bf 331 }
jmarkel44 71:34856d21f2bf 332
jmarkel44 71:34856d21f2bf 333 return 0;
jmarkel44 71:34856d21f2bf 334 }
jmarkel44 71:34856d21f2bf 335
jmarkel44 71:34856d21f2bf 336 /*****************************************************************************
jmarkel44 72:3754b352f156 337 * Function: disableOutputReq
jmarkel44 72:3754b352f156 338 * Description:
jmarkel44 71:34856d21f2bf 339 *
jmarkel44 71:34856d21f2bf 340 * @param args -> not used
jmarkel44 71:34856d21f2bf 341 * @return none
jmarkel44 71:34856d21f2bf 342 *****************************************************************************/
jmarkel44 115:1558e01d04c6 343 static int disableOutputReq(OutputControlMsg_t *msg)
jmarkel44 71:34856d21f2bf 344 {
jmarkel44 71:34856d21f2bf 345 // attempt to find the output in the map
jmarkel44 71:34856d21f2bf 346 StringOutputVector_t::iterator pos;
jmarkel44 71:34856d21f2bf 347
jmarkel44 115:1558e01d04c6 348 pos = outputMap.find(msg->output_tag);
jmarkel44 71:34856d21f2bf 349 if ( pos == outputMap.end() ) {
jmarkel44 71:34856d21f2bf 350 printf("%s: failed to find the designated output %s\n",
jmarkel44 115:1558e01d04c6 351 __func__, msg->output_tag);
jmarkel44 71:34856d21f2bf 352 return -1;
jmarkel44 71:34856d21f2bf 353 }
jmarkel44 71:34856d21f2bf 354
jmarkel44 80:b12b0adfcdc2 355 // if the control list is empty, push this control on the list
jmarkel44 71:34856d21f2bf 356 if ( pos->second.empty() ) {
jmarkel44 195:21df85341cb3 357 std::string cid(msg->id);
jmarkel44 195:21df85341cb3 358 std::string input(msg->input_tag);
jmarkel44 115:1558e01d04c6 359 Control c(cid, msg->controlType, input, msg->priority, CONTROL_OFF);
jmarkel44 71:34856d21f2bf 360 pos->second.push_back(c);
jmarkel44 71:34856d21f2bf 361 } else {
jmarkel44 71:34856d21f2bf 362 // find this control in the list
jmarkel44 71:34856d21f2bf 363 vector<Control>::iterator v;
jmarkel44 71:34856d21f2bf 364 for ( v = pos->second.begin(); v != pos->second.end(); ++v ) {
jmarkel44 115:1558e01d04c6 365 if ( strcmp(v->getId().c_str(), msg->id) == 0 ) {
jmarkel44 71:34856d21f2bf 366 v->setState(CONTROL_OFF);
jmarkel44 77:43e0a3d9e536 367 break;
jmarkel44 71:34856d21f2bf 368 }
jmarkel44 71:34856d21f2bf 369 }
jmarkel44 80:b12b0adfcdc2 370
jmarkel44 80:b12b0adfcdc2 371 if ( v == pos->second.end() ) {
jmarkel44 80:b12b0adfcdc2 372 // this is a new request, so add it and sort the vector
jmarkel44 195:21df85341cb3 373 std::string cid(msg->id);
jmarkel44 195:21df85341cb3 374 std::string input(msg->input_tag);
jmarkel44 115:1558e01d04c6 375 Control c(cid, msg->controlType, input, msg->priority, CONTROL_OFF);
jmarkel44 80:b12b0adfcdc2 376 pos->second.push_back(c);
jmarkel44 80:b12b0adfcdc2 377 std::sort(pos->second.begin(), pos->second.end());
jmarkel44 80:b12b0adfcdc2 378 }
jmarkel44 71:34856d21f2bf 379 }
jmarkel44 66:db1425574b58 380
jmarkel44 66:db1425574b58 381 return 0;
jmarkel44 66:db1425574b58 382 }
jmarkel44 66:db1425574b58 383
jmarkel44 74:03ccf04998b5 384 /*****************************************************************************
jmarkel44 74:03ccf04998b5 385 * Function: unregisterControl
jmarkel44 74:03ccf04998b5 386 * Description:
jmarkel44 74:03ccf04998b5 387 *
jmarkel44 74:03ccf04998b5 388 * @param id -> control identifier
jmarkel44 74:03ccf04998b5 389 * @param pri -> priority
jmarkel44 74:03ccf04998b5 390 * @param output -> output (e.g. "o_rly5)
jmarkel44 74:03ccf04998b5 391 *
jmarkel44 74:03ccf04998b5 392 * @return 0 on success; -1 on error
jmarkel44 74:03ccf04998b5 393 *****************************************************************************/
jmarkel44 72:3754b352f156 394 static int unregisterControl(const char *id, unsigned int pri, const char *output)
jmarkel44 72:3754b352f156 395 {
jmarkel44 72:3754b352f156 396 // attempt to find the output in the map
jmarkel44 72:3754b352f156 397 StringOutputVector_t::iterator pos;
jmarkel44 80:b12b0adfcdc2 398 bool found = false;
jmarkel44 72:3754b352f156 399
jmarkel44 72:3754b352f156 400 pos = outputMap.find(output);
jmarkel44 72:3754b352f156 401 if ( pos == outputMap.end() ) {
jmarkel44 72:3754b352f156 402 printf("%s: failed to find the designated output %s\n",
jmarkel44 72:3754b352f156 403 __func__, output);
jmarkel44 72:3754b352f156 404 return -1;
jmarkel44 72:3754b352f156 405 }
jmarkel44 72:3754b352f156 406
jmarkel44 72:3754b352f156 407 // find the control in the list
jmarkel44 72:3754b352f156 408 vector<Control>::iterator v;
jmarkel44 72:3754b352f156 409 for ( v = pos->second.begin(); v != pos->second.end(); ++v) {
jmarkel44 72:3754b352f156 410 if ( strcmp(v->getId().c_str(), id) == 0 ) {
jmarkel44 72:3754b352f156 411 // delete this entry
jmarkel44 72:3754b352f156 412 pos->second.erase(v);
jmarkel44 80:b12b0adfcdc2 413 found = true;
jmarkel44 72:3754b352f156 414 break;
jmarkel44 72:3754b352f156 415 }
jmarkel44 74:03ccf04998b5 416 }
jmarkel44 128:534bf29132f8 417
jmarkel44 80:b12b0adfcdc2 418 if ( !found ) {
jmarkel44 80:b12b0adfcdc2 419 logError("%s: failed to find control %s in list", __func__, id);
jmarkel44 80:b12b0adfcdc2 420 return -1;
jmarkel44 80:b12b0adfcdc2 421 }
jmarkel44 72:3754b352f156 422 return 0;
jmarkel44 72:3754b352f156 423 }
jmarkel44 72:3754b352f156 424
jmarkel44 72:3754b352f156 425 /*****************************************************************************
jmarkel44 72:3754b352f156 426 * Function: loadPersistentOutputs
jmarkel44 72:3754b352f156 427 * Description: pump up the output map based on persistent files
jmarkel44 72:3754b352f156 428 *
jmarkel44 72:3754b352f156 429 * @param args -> not used
jmarkel44 72:3754b352f156 430 * @return none
jmarkel44 72:3754b352f156 431 *****************************************************************************/
jmarkel44 66:db1425574b58 432 static void loadPersistentOutputs(void)
jmarkel44 66:db1425574b58 433 {
jmarkel44 66:db1425574b58 434 bool status;
jmarkel44 66:db1425574b58 435 MbedJSONValue json_value;
jmarkel44 71:34856d21f2bf 436
jmarkel44 77:43e0a3d9e536 437 printf("\rLoading persistent outputs:\n");
jmarkel44 66:db1425574b58 438
jmarkel44 66:db1425574b58 439 std::vector<mDot::mdot_file> file_list = GLOBAL_mdot->listUserFiles();
jmarkel44 70:7427f4959201 440
jmarkel44 66:db1425574b58 441 for (std::vector<mDot::mdot_file>::iterator i = file_list.begin(); i != file_list.end(); ++i) {
jmarkel44 67:49f266601d83 442 if( strncmp( i->name, OUTPUT_STR, strlen(OUTPUT_STR)) == 0 ) {
jmarkel44 66:db1425574b58 443
jmarkel44 66:db1425574b58 444 logInfo("%s: FOUND OUTPUT FILE: %s", __func__, i->name);
jmarkel44 66:db1425574b58 445
jmarkel44 177:9ec90c8e3ce1 446 char scratchBuf[MAX_FILE_SIZE];
jmarkel44 66:db1425574b58 447
jmarkel44 177:9ec90c8e3ce1 448 status = GLOBAL_mdot->readUserFile(i->name, scratchBuf, MAX_FILE_SIZE);
jmarkel44 66:db1425574b58 449 if( status != true ) {
jmarkel44 66:db1425574b58 450 logInfo("(%d)read file failed, status=%d", __LINE__, status);
jmarkel44 66:db1425574b58 451 } else {
jmarkel44 66:db1425574b58 452 logInfo("(%d)Read File SUCCESS: %s", __LINE__, scratchBuf );
jmarkel44 66:db1425574b58 453 }
jmarkel44 66:db1425574b58 454
jmarkel44 66:db1425574b58 455 parse( json_value, scratchBuf );
jmarkel44 195:21df85341cb3 456
jmarkel44 195:21df85341cb3 457 if ( !json_value.hasMember("id") ) {
jmarkel44 195:21df85341cb3 458 logError("Output file %s is missing expected tags", i->name);
jmarkel44 195:21df85341cb3 459 continue;
jmarkel44 195:21df85341cb3 460 }
jmarkel44 66:db1425574b58 461
jmarkel44 195:21df85341cb3 462 std::string id = json_value["id"].get<string>();
jmarkel44 77:43e0a3d9e536 463 printf("\r output %s loaded\n", i->name);
jmarkel44 74:03ccf04998b5 464
jmarkel44 80:b12b0adfcdc2 465 // emplace the empty control vector into the output map
jmarkel44 71:34856d21f2bf 466 vector<Control> v;
jmarkel44 71:34856d21f2bf 467 outputMap[id] = v;
jmarkel44 66:db1425574b58 468 }
jmarkel44 66:db1425574b58 469 }
jmarkel44 185:5ac6ab1ed875 470 }
jmarkel44 185:5ac6ab1ed875 471