Andy Lustig / Mbed 2 deprecated stateScript_v2

fork of StateScript

Dependencies:   mbed SOMO_II

Fork of stateScript_v2 by Mattias Karlsson

behave.h@9:f783bce314cd, 2017-04-26 (annotated)

Committer:
alustig3
Date:
Wed Apr 26 16:40:36 2017 +0000
Revision:
9:f783bce314cd
Parent:
8:872b843a3053
Child:
10:f65649c13b5b
synced with 99b7dc5 of bitbucket development branch

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mkarlsso 0:8dbd6bd9167f 1 //#include "mbed.h"
mkarlsso 0:8dbd6bd9167f 2 #include <stdint.h>
mkarlsso 0:8dbd6bd9167f 3 #include <string.h>
mkarlsso 0:8dbd6bd9167f 4 #include <string>
mkarlsso 0:8dbd6bd9167f 5 #include <vector>
mkarlsso 0:8dbd6bd9167f 6 #include <list>
mkarlsso 0:8dbd6bd9167f 7 #include <deque>
mkarlsso 0:8dbd6bd9167f 8 #include <queue>
mkarlsso 0:8dbd6bd9167f 9 #include "hardwareInterface.h"
mkarlsso 0:8dbd6bd9167f 10
mkarlsso 0:8dbd6bd9167f 11
mkarlsso 0:8dbd6bd9167f 12 #define MBEDHARDWARE //here is where we define which platform we are compiling for
mkarlsso 0:8dbd6bd9167f 13 //#define FPGAHARDWARE
mkarlsso 0:8dbd6bd9167f 14
mkarlsso 0:8dbd6bd9167f 15 #define MAXVARNAMESIZE 30 //The maximum number of characters of a variable name
mkarlsso 0:8dbd6bd9167f 16
mkarlsso 0:8dbd6bd9167f 17 #ifdef MBEDHARDWARE
mkarlsso 0:8dbd6bd9167f 18 #include "mbedInterface.h"
mkarlsso 0:8dbd6bd9167f 19 #endif
mkarlsso 0:8dbd6bd9167f 20 #ifdef FPGAHARDWARE
mkarlsso 0:8dbd6bd9167f 21 #include "fpgaInterface.h"
mkarlsso 0:8dbd6bd9167f 22 #endif
mkarlsso 0:8dbd6bd9167f 23
mkarlsso 4:abee20c0bf2a 24 #define BLOCKMEMORYTYPES 1
mkarlsso 4:abee20c0bf2a 25 #define VARIABLEMEMORYTYPES 2
mkarlsso 4:abee20c0bf2a 26 #define ENVSETTINGSMEMORYTYPES 4
mkarlsso 4:abee20c0bf2a 27
mkarlsso 4:abee20c0bf2a 28
mkarlsso 3:d7b0a0890d96 29 /*
mkarlsso 0:8dbd6bd9167f 30 #define NUMEVENTS 50
mkarlsso 0:8dbd6bd9167f 31 #define NUMCONDITIONS 150
mkarlsso 0:8dbd6bd9167f 32 #define NUMINTCOMPARE 150
mkarlsso 0:8dbd6bd9167f 33 #define NUMACTIONS 150
mkarlsso 0:8dbd6bd9167f 34 #define NUMPORTMESSAGES 150
mkarlsso 0:8dbd6bd9167f 35 #define NUMINTOPERATIONS 150
mkarlsso 0:8dbd6bd9167f 36 #define NUMDISPLAYACTIONS 30
mkarlsso 0:8dbd6bd9167f 37 #define NUMTRIGGERACTIONS 30
mkarlsso 3:d7b0a0890d96 38 #define NUMFUNCTIONS 50
mkarlsso 3:d7b0a0890d96 39 #define INPUTCHARBUFFERSIZE 3072
mkarlsso 3:d7b0a0890d96 40 */
mkarlsso 0:8dbd6bd9167f 41
mkarlsso 0:8dbd6bd9167f 42 #define ARITHMATIC_CONDITION 0
mkarlsso 0:8dbd6bd9167f 43 #define OR_CONDITION 1
mkarlsso 0:8dbd6bd9167f 44 #define AND_CONDITION 2
mkarlsso 0:8dbd6bd9167f 45
mkarlsso 3:d7b0a0890d96 46
mkarlsso 0:8dbd6bd9167f 47
mkarlsso 0:8dbd6bd9167f 48 using namespace std;
mkarlsso 0:8dbd6bd9167f 49
mkarlsso 0:8dbd6bd9167f 50 class event; //we foreward declare this because of class interdependencies
mkarlsso 0:8dbd6bd9167f 51
mkarlsso 0:8dbd6bd9167f 52 //used in the digital port class to organize digital change events
mkarlsso 0:8dbd6bd9167f 53 /*
mkarlsso 0:8dbd6bd9167f 54 struct changeEvent {
mkarlsso 0:8dbd6bd9167f 55 uint32_t timeStamp;
mkarlsso 0:8dbd6bd9167f 56 bool triggered;
mkarlsso 0:8dbd6bd9167f 57 };*/
mkarlsso 0:8dbd6bd9167f 58
mkarlsso 8:872b843a3053 59 struct VersionInfo {
mkarlsso 8:872b843a3053 60 int major;
mkarlsso 8:872b843a3053 61 int middle;
mkarlsso 8:872b843a3053 62 int minor;
mkarlsso 8:872b843a3053 63
mkarlsso 8:872b843a3053 64 int updateDay;
mkarlsso 8:872b843a3053 65 int updateMonth;
mkarlsso 8:872b843a3053 66 int updateYear;
mkarlsso 8:872b843a3053 67 };
mkarlsso 8:872b843a3053 68
mkarlsso 7:5fe7329751d4 69 class AbstractPort {
mkarlsso 7:5fe7329751d4 70
mkarlsso 7:5fe7329751d4 71 public:
mkarlsso 7:5fe7329751d4 72 AbstractPort();
mkarlsso 7:5fe7329751d4 73
mkarlsso 7:5fe7329751d4 74 enum Direction{in,out,none};
mkarlsso 7:5fe7329751d4 75 enum DataType{digital, analog};
mkarlsso 7:5fe7329751d4 76
mkarlsso 7:5fe7329751d4 77 Direction portDir;
mkarlsso 7:5fe7329751d4 78 DataType portType;
mkarlsso 7:5fe7329751d4 79
mkarlsso 7:5fe7329751d4 80 virtual void write(int outVal);
mkarlsso 7:5fe7329751d4 81 virtual int read() = 0; //Must be defined in inheriting class
mkarlsso 7:5fe7329751d4 82 virtual void setThresh(int threshVal);
mkarlsso 7:5fe7329751d4 83
mkarlsso 7:5fe7329751d4 84 uint32_t lastChangeTime;
mkarlsso 7:5fe7329751d4 85 uint32_t lastOutChangeTime;
mkarlsso 7:5fe7329751d4 86
mkarlsso 7:5fe7329751d4 87 bool update(); //called from the main loop
mkarlsso 7:5fe7329751d4 88 void setTriggerUpEvent(event* eventInput); //attahces a routine to an upward change
mkarlsso 7:5fe7329751d4 89 void setTriggerDownEvent(event* eventInput); //attahces a routine to a downward change
mkarlsso 7:5fe7329751d4 90 void clearTriggerEvents();
mkarlsso 7:5fe7329751d4 91 void setReportUpdates(bool report);
mkarlsso 7:5fe7329751d4 92 int getLastChangeState();
mkarlsso 7:5fe7329751d4 93 uint32_t getTimeSinceLastChange();
mkarlsso 7:5fe7329751d4 94
mkarlsso 7:5fe7329751d4 95 int state;
alustig3 9:f783bce314cd 96 int* hardwareStatePtr;
mkarlsso 7:5fe7329751d4 97 bool outStateChanged;
mkarlsso 7:5fe7329751d4 98
mkarlsso 7:5fe7329751d4 99 event* triggerUpEventPtr;
mkarlsso 7:5fe7329751d4 100 event* triggerDownEventPtr;
mkarlsso 7:5fe7329751d4 101
mkarlsso 7:5fe7329751d4 102 protected:
mkarlsso 7:5fe7329751d4 103 virtual bool checkForChange();
mkarlsso 7:5fe7329751d4 104 bool hasTriggerFunction;
mkarlsso 7:5fe7329751d4 105 bool reportUpdates;
mkarlsso 7:5fe7329751d4 106
mkarlsso 7:5fe7329751d4 107 int lastInState;
mkarlsso 7:5fe7329751d4 108 int thresh;
mkarlsso 7:5fe7329751d4 109 uint32_t lastChangeInterval;
mkarlsso 7:5fe7329751d4 110
mkarlsso 7:5fe7329751d4 111 private:
mkarlsso 7:5fe7329751d4 112
mkarlsso 7:5fe7329751d4 113 };
mkarlsso 7:5fe7329751d4 114
mkarlsso 7:5fe7329751d4 115 class AnalogPort: public AbstractPort {
mkarlsso 7:5fe7329751d4 116 public:
mkarlsso 7:5fe7329751d4 117 AnalogPort();
mkarlsso 7:5fe7329751d4 118
mkarlsso 7:5fe7329751d4 119 void init(sAnalogIn* IP);
mkarlsso 7:5fe7329751d4 120 void init(sAnalogOut* OP);
mkarlsso 7:5fe7329751d4 121
mkarlsso 7:5fe7329751d4 122 void set(int outVal);
mkarlsso 7:5fe7329751d4 123 int read();
mkarlsso 7:5fe7329751d4 124 void setThresh(int threshVal);
mkarlsso 7:5fe7329751d4 125 void write(int outVal);
mkarlsso 7:5fe7329751d4 126
mkarlsso 7:5fe7329751d4 127 private:
mkarlsso 7:5fe7329751d4 128 sAnalogOut* outPin;
mkarlsso 7:5fe7329751d4 129 sAnalogIn* inPin;
mkarlsso 7:5fe7329751d4 130
mkarlsso 7:5fe7329751d4 131 };
mkarlsso 7:5fe7329751d4 132
mkarlsso 7:5fe7329751d4 133 class DigitalPort: public AbstractPort {
mkarlsso 7:5fe7329751d4 134 public:
mkarlsso 7:5fe7329751d4 135 DigitalPort();
mkarlsso 7:5fe7329751d4 136
mkarlsso 7:5fe7329751d4 137 void init(sDigitalIn* IP);
mkarlsso 7:5fe7329751d4 138 void init(sDigitalOut* OP);
mkarlsso 7:5fe7329751d4 139
mkarlsso 7:5fe7329751d4 140 void set(int outVal);
mkarlsso 7:5fe7329751d4 141 int read();
mkarlsso 7:5fe7329751d4 142 void write(int outVal);
mkarlsso 7:5fe7329751d4 143
mkarlsso 7:5fe7329751d4 144 protected:
mkarlsso 7:5fe7329751d4 145 bool checkForChange();
mkarlsso 7:5fe7329751d4 146
mkarlsso 7:5fe7329751d4 147 private:
mkarlsso 7:5fe7329751d4 148 sDigitalOut* outPin;
mkarlsso 7:5fe7329751d4 149 sDigitalIn* inPin;
mkarlsso 7:5fe7329751d4 150
mkarlsso 7:5fe7329751d4 151 };
mkarlsso 7:5fe7329751d4 152
mkarlsso 0:8dbd6bd9167f 153
mkarlsso 0:8dbd6bd9167f 154 //The digitalPort object directly controls and keeps data about the port. Each port has
mkarlsso 0:8dbd6bd9167f 155 //one digital out and one digital in.
mkarlsso 0:8dbd6bd9167f 156 class digitalPort {
mkarlsso 0:8dbd6bd9167f 157 public:
mkarlsso 0:8dbd6bd9167f 158 digitalPort();
mkarlsso 0:8dbd6bd9167f 159 //digitalPort(sDigitalOut* DOP, sDigitalIn* DIP);
mkarlsso 0:8dbd6bd9167f 160 void init(sDigitalOut* DOP, sDigitalIn* DIP);
mkarlsso 0:8dbd6bd9167f 161 void setDigitalOut(int outVal);
mkarlsso 0:8dbd6bd9167f 162 //int getDigitalOut();
mkarlsso 0:8dbd6bd9167f 163 int getDigitalIn();
mkarlsso 0:8dbd6bd9167f 164 int getLastChangeState();
mkarlsso 0:8dbd6bd9167f 165 uint32_t getTimeSinceLastChange();
mkarlsso 0:8dbd6bd9167f 166 uint32_t lastChangeTime;
mkarlsso 0:8dbd6bd9167f 167 uint32_t lastOutChangeTime;
mkarlsso 0:8dbd6bd9167f 168
mkarlsso 0:8dbd6bd9167f 169 void setTriggerUpEvent(event* eventInput); //attahces a routine to an upward change
mkarlsso 0:8dbd6bd9167f 170 void setTriggerDownEvent(event* eventInput); //attahces a routine to a downward change
mkarlsso 0:8dbd6bd9167f 171 //void addStateChange(int newState, uint32_t timeStamp);
mkarlsso 0:8dbd6bd9167f 172
mkarlsso 0:8dbd6bd9167f 173 bool update(); //called from the main loop
mkarlsso 0:8dbd6bd9167f 174
mkarlsso 0:8dbd6bd9167f 175 int inState;
mkarlsso 0:8dbd6bd9167f 176 int outState;
mkarlsso 0:8dbd6bd9167f 177
mkarlsso 0:8dbd6bd9167f 178 bool outStateChanged;
mkarlsso 0:8dbd6bd9167f 179
mkarlsso 0:8dbd6bd9167f 180 event* triggerUpEventPtr;
mkarlsso 0:8dbd6bd9167f 181 event* triggerDownEventPtr;
mkarlsso 0:8dbd6bd9167f 182
mkarlsso 0:8dbd6bd9167f 183 private:
mkarlsso 0:8dbd6bd9167f 184
mkarlsso 0:8dbd6bd9167f 185 sDigitalOut* outPin;
mkarlsso 0:8dbd6bd9167f 186 sDigitalIn* inPin;
mkarlsso 0:8dbd6bd9167f 187 int lastInState;
mkarlsso 0:8dbd6bd9167f 188 uint32_t lastChangeInterval;
mkarlsso 0:8dbd6bd9167f 189
mkarlsso 0:8dbd6bd9167f 190 //changeEvent lastUpEvent;
mkarlsso 0:8dbd6bd9167f 191 //changeEvent lastDownEvent;
mkarlsso 0:8dbd6bd9167f 192 };
mkarlsso 0:8dbd6bd9167f 193
mkarlsso 0:8dbd6bd9167f 194
mkarlsso 7:5fe7329751d4 195
mkarlsso 7:5fe7329751d4 196
mkarlsso 0:8dbd6bd9167f 197 //an intVariable contains an integer value and the name of that variable within the script
mkarlsso 0:8dbd6bd9167f 198 class intVariable {
mkarlsso 0:8dbd6bd9167f 199
mkarlsso 0:8dbd6bd9167f 200 public:
mkarlsso 0:8dbd6bd9167f 201 intVariable();
mkarlsso 0:8dbd6bd9167f 202 intVariable(std::string& tagInput, int initialValue);
mkarlsso 0:8dbd6bd9167f 203 void set(std::string& tagInput, int initialValue);
mkarlsso 0:8dbd6bd9167f 204 int value;
mkarlsso 0:8dbd6bd9167f 205 //string tag;
mkarlsso 0:8dbd6bd9167f 206 char tag[MAXVARNAMESIZE+1];
mkarlsso 0:8dbd6bd9167f 207 bool isUsed;
mkarlsso 0:8dbd6bd9167f 208
mkarlsso 0:8dbd6bd9167f 209 };
mkarlsso 0:8dbd6bd9167f 210
mkarlsso 0:8dbd6bd9167f 211
mkarlsso 0:8dbd6bd9167f 212 //ACTION SECTION-- an 'action' is a command in the script. It can be a single command,
mkarlsso 0:8dbd6bd9167f 213 //or a block containing a set of actions
mkarlsso 0:8dbd6bd9167f 214 //------------------------------------------------------------------------------------
mkarlsso 0:8dbd6bd9167f 215
mkarlsso 0:8dbd6bd9167f 216 //display actions are used to output text messages via the serial port. The user can display
mkarlsso 0:8dbd6bd9167f 217 //either a static text string or the value of a single variable.
mkarlsso 0:8dbd6bd9167f 218 class displayAction {
mkarlsso 0:8dbd6bd9167f 219
mkarlsso 0:8dbd6bd9167f 220 public:
mkarlsso 0:8dbd6bd9167f 221 displayAction();
mkarlsso 0:8dbd6bd9167f 222 void set(int* variable, string varNameInput);
mkarlsso 0:8dbd6bd9167f 223 void set(string text);
mkarlsso 0:8dbd6bd9167f 224 bool isUsed;
mkarlsso 0:8dbd6bd9167f 225 void execute();
mkarlsso 0:8dbd6bd9167f 226 void release();
mkarlsso 0:8dbd6bd9167f 227
mkarlsso 0:8dbd6bd9167f 228 private:
mkarlsso 0:8dbd6bd9167f 229 int* dVariable;
mkarlsso 0:8dbd6bd9167f 230 string dText;
mkarlsso 0:8dbd6bd9167f 231
mkarlsso 0:8dbd6bd9167f 232 };
mkarlsso 0:8dbd6bd9167f 233
mkarlsso 0:8dbd6bd9167f 234 class triggerFunctionAction {
mkarlsso 0:8dbd6bd9167f 235
mkarlsso 0:8dbd6bd9167f 236 public:
mkarlsso 0:8dbd6bd9167f 237 triggerFunctionAction();
mkarlsso 0:8dbd6bd9167f 238 triggerFunctionAction(int functionNum);
mkarlsso 0:8dbd6bd9167f 239 void set(int functionNum);
mkarlsso 0:8dbd6bd9167f 240 bool isUsed;
mkarlsso 0:8dbd6bd9167f 241 void execute();
mkarlsso 0:8dbd6bd9167f 242 void release();
mkarlsso 0:8dbd6bd9167f 243 private:
mkarlsso 0:8dbd6bd9167f 244 int functionNum;
mkarlsso 0:8dbd6bd9167f 245
mkarlsso 0:8dbd6bd9167f 246
mkarlsso 0:8dbd6bd9167f 247 };
mkarlsso 0:8dbd6bd9167f 248
mkarlsso 0:8dbd6bd9167f 249 //intOpertaion is an action that does addition or subtraction of integers and returns/stores the result
mkarlsso 0:8dbd6bd9167f 250 //these operation are very limited so far (only + or - allowed, and only one operation per object,
mkarlsso 0:8dbd6bd9167f 251 //for example a = b + b works but a = b + c + d does not. The output value can also be set to a random number.
mkarlsso 0:8dbd6bd9167f 252 class intOperation {
mkarlsso 0:8dbd6bd9167f 253
mkarlsso 0:8dbd6bd9167f 254 public:
mkarlsso 0:8dbd6bd9167f 255 intOperation();
mkarlsso 0:8dbd6bd9167f 256
mkarlsso 0:8dbd6bd9167f 257 /*
mkarlsso 0:8dbd6bd9167f 258 intOperation(int randParam, const char* cmpString, int cmpValInput);
mkarlsso 0:8dbd6bd9167f 259 intOperation(int randParam, const char* cmpString, int* cmpIntVarInput);
mkarlsso 0:8dbd6bd9167f 260 intOperation(int* intVarInput, const char* cmpString, int cmpValInput);
mkarlsso 0:8dbd6bd9167f 261 intOperation(int* intVarInput, const char* cmpString, int* cmpIntVarInput);
mkarlsso 0:8dbd6bd9167f 262 intOperation(int* intVarInput, intOperation* operationInput);
mkarlsso 0:8dbd6bd9167f 263 */
mkarlsso 0:8dbd6bd9167f 264
mkarlsso 0:8dbd6bd9167f 265 ~intOperation();
mkarlsso 0:8dbd6bd9167f 266
mkarlsso 0:8dbd6bd9167f 267 //Supported operations with rand:
mkarlsso 0:8dbd6bd9167f 268 //a = rand(x)
mkarlsso 0:8dbd6bd9167f 269 //a = rand(x) + 3
mkarlsso 0:8dbd6bd9167f 270 //a = rand(x) + b
mkarlsso 0:8dbd6bd9167f 271 void setRandOp(int randParam, const char* cmpString, int cmpValInput, bool flipped);
mkarlsso 0:8dbd6bd9167f 272 void setRandOp(int randParam, const char* cmpString, int* cmpIntVarInput, bool flipped);
mkarlsso 0:8dbd6bd9167f 273
mkarlsso 0:8dbd6bd9167f 274 //Supported regular operations
mkarlsso 0:8dbd6bd9167f 275 //a = 5
mkarlsso 0:8dbd6bd9167f 276 //a = b
mkarlsso 0:8dbd6bd9167f 277 //a = b + 6
mkarlsso 0:8dbd6bd9167f 278 //a = b + c
mkarlsso 0:8dbd6bd9167f 279 void set(int* intVarInput, const char* cmpString, int cmpValInput);
mkarlsso 0:8dbd6bd9167f 280 void set(int* intVarInput, const char* cmpString, int* cmpIntVarInput);
mkarlsso 0:8dbd6bd9167f 281 void set(int* intVarInput, intOperation* operationInput);
mkarlsso 0:8dbd6bd9167f 282
mkarlsso 0:8dbd6bd9167f 283
mkarlsso 0:8dbd6bd9167f 284 //Supported operations with clock()
mkarlsso 0:8dbd6bd9167f 285 //a = clock()
mkarlsso 0:8dbd6bd9167f 286 //a = clock() + 5
mkarlsso 0:8dbd6bd9167f 287 //a = clock() + b
mkarlsso 0:8dbd6bd9167f 288 void setClockOp(int* intVarInput);
mkarlsso 0:8dbd6bd9167f 289 void setClockOp(const char* cmpString, int cmpValInput, bool flip);
mkarlsso 0:8dbd6bd9167f 290 void setClockOp(const char* cmpString, int* cmpIntVarInput, bool flip);
mkarlsso 0:8dbd6bd9167f 291
mkarlsso 0:8dbd6bd9167f 292 void release();
mkarlsso 0:8dbd6bd9167f 293 bool isUsed;
mkarlsso 0:8dbd6bd9167f 294 int execute();
mkarlsso 0:8dbd6bd9167f 295
mkarlsso 0:8dbd6bd9167f 296 private:
mkarlsso 0:8dbd6bd9167f 297 int randHigh;
mkarlsso 0:8dbd6bd9167f 298 int* cmpVal;
mkarlsso 0:8dbd6bd9167f 299 int* intVal;
mkarlsso 0:8dbd6bd9167f 300 intOperation* opPtr;
mkarlsso 0:8dbd6bd9167f 301 bool cmpValGlobal;
mkarlsso 0:8dbd6bd9167f 302 bool isClockAssign; //if the current clock value is part of the operation
mkarlsso 0:8dbd6bd9167f 303 bool inputsFlipped;
mkarlsso 0:8dbd6bd9167f 304 int (intOperation::*executePtr)();
mkarlsso 0:8dbd6bd9167f 305 int addAndStore();
mkarlsso 0:8dbd6bd9167f 306 int subtractAndStore();
mkarlsso 0:8dbd6bd9167f 307 int add();
mkarlsso 0:8dbd6bd9167f 308 int subtract();
mkarlsso 0:8dbd6bd9167f 309 int equals();
mkarlsso 0:8dbd6bd9167f 310
mkarlsso 0:8dbd6bd9167f 311 };
mkarlsso 0:8dbd6bd9167f 312
mkarlsso 7:5fe7329751d4 313 //portMessage is an action to change a port state.
mkarlsso 0:8dbd6bd9167f 314 class portMessage {
mkarlsso 0:8dbd6bd9167f 315 public:
mkarlsso 0:8dbd6bd9167f 316
mkarlsso 0:8dbd6bd9167f 317 portMessage();
mkarlsso 0:8dbd6bd9167f 318 //portMessage(digitalPort* portIn, int whichToSet, int value); //whichToSet: 1 DigitalOut; 2 State
mkarlsso 0:8dbd6bd9167f 319 //void setMessage(digitalPort* portIn, int whichToSet, int value); //whichToSet: 1 DigitalOut; 2 State
mkarlsso 0:8dbd6bd9167f 320 //portMessage(int* portIn, int whichToSet, int value); //whichToSet:
mkarlsso 7:5fe7329751d4 321 void setMessage(int* portIn, int whichToSet, int value, AbstractPort** portVector, int portVectorLength); //whichToSet:
mkarlsso 0:8dbd6bd9167f 322
mkarlsso 0:8dbd6bd9167f 323 void execute();
mkarlsso 0:8dbd6bd9167f 324 void release();
mkarlsso 0:8dbd6bd9167f 325 bool isUsed;
mkarlsso 0:8dbd6bd9167f 326
mkarlsso 0:8dbd6bd9167f 327 private:
mkarlsso 0:8dbd6bd9167f 328 int whichToSet; //hard coded port number
mkarlsso 0:8dbd6bd9167f 329 int* port; //alternative variable port number
mkarlsso 0:8dbd6bd9167f 330 int value;
mkarlsso 7:5fe7329751d4 331 int vectorLength;
mkarlsso 0:8dbd6bd9167f 332
mkarlsso 7:5fe7329751d4 333 AbstractPort** portVector;
mkarlsso 0:8dbd6bd9167f 334
mkarlsso 0:8dbd6bd9167f 335 };
mkarlsso 0:8dbd6bd9167f 336
mkarlsso 0:8dbd6bd9167f 337 //holder class for all possible actions. This include general system commands.
mkarlsso 0:8dbd6bd9167f 338 class action {
mkarlsso 0:8dbd6bd9167f 339 public:
mkarlsso 0:8dbd6bd9167f 340
mkarlsso 0:8dbd6bd9167f 341 action();
mkarlsso 0:8dbd6bd9167f 342 ~action();
mkarlsso 0:8dbd6bd9167f 343 action(intOperation* opInput);
mkarlsso 0:8dbd6bd9167f 344 action(portMessage* messageInput);
mkarlsso 0:8dbd6bd9167f 345 action(event* eventInput);
mkarlsso 0:8dbd6bd9167f 346 //action(event* eventInput, uint32_t delay);
mkarlsso 0:8dbd6bd9167f 347 action(displayAction* displayInput);
mkarlsso 0:8dbd6bd9167f 348 action(sSound* soundInput);
mkarlsso 0:8dbd6bd9167f 349 action(triggerFunctionAction* triggerFuncInput);
mkarlsso 0:8dbd6bd9167f 350 action(int8_t sysCommandInput); //for general system commands
mkarlsso 0:8dbd6bd9167f 351
mkarlsso 0:8dbd6bd9167f 352 void set(intOperation* opInput);
mkarlsso 0:8dbd6bd9167f 353 void set(portMessage* messageInput);
mkarlsso 0:8dbd6bd9167f 354 void set(event* eventInput);
mkarlsso 0:8dbd6bd9167f 355 //void set(event* eventInput, uint32_t delay);
mkarlsso 0:8dbd6bd9167f 356
mkarlsso 0:8dbd6bd9167f 357 void set(displayAction* displayInput);
mkarlsso 0:8dbd6bd9167f 358 void set(sSound* soundInput);
mkarlsso 0:8dbd6bd9167f 359 void set(triggerFunctionAction* triggerFuncInput);
mkarlsso 0:8dbd6bd9167f 360 void set(int8_t sysCommandInput);
mkarlsso 0:8dbd6bd9167f 361 void execute();
mkarlsso 0:8dbd6bd9167f 362 void execute(uint32_t blockExecTime);
mkarlsso 0:8dbd6bd9167f 363 void release();
mkarlsso 0:8dbd6bd9167f 364 bool isUsed;
mkarlsso 0:8dbd6bd9167f 365
mkarlsso 0:8dbd6bd9167f 366 private:
mkarlsso 0:8dbd6bd9167f 367 intOperation* op;
mkarlsso 0:8dbd6bd9167f 368 portMessage* message;
mkarlsso 0:8dbd6bd9167f 369 event* eventToCreate;
mkarlsso 0:8dbd6bd9167f 370 displayAction* displayActionPtr;
mkarlsso 0:8dbd6bd9167f 371 sSound* sound;
mkarlsso 0:8dbd6bd9167f 372 triggerFunctionAction* triggerFunc;
mkarlsso 0:8dbd6bd9167f 373 //uint32_t eventDelay;
mkarlsso 0:8dbd6bd9167f 374 int8_t sysCommand;
mkarlsso 0:8dbd6bd9167f 375 char actionType;
mkarlsso 0:8dbd6bd9167f 376
mkarlsso 0:8dbd6bd9167f 377 };
mkarlsso 0:8dbd6bd9167f 378 //-----------------------------------------------------
mkarlsso 0:8dbd6bd9167f 379
mkarlsso 0:8dbd6bd9167f 380 //CONDITION SECTION-- a 'condition' is used in the beginning of a block (if-else blocks or while blocks)
mkarlsso 0:8dbd6bd9167f 381 //If the condition is true, the block is exectuted during a callback
mkarlsso 0:8dbd6bd9167f 382 //------------------------------------------------------------------------------------
mkarlsso 0:8dbd6bd9167f 383
mkarlsso 0:8dbd6bd9167f 384
mkarlsso 0:8dbd6bd9167f 385 //intCompare is a condition class that compares the state value of a port or
mkarlsso 0:8dbd6bd9167f 386 //an integer variable to another integer variable or operation output
mkarlsso 0:8dbd6bd9167f 387 class intCompare {
mkarlsso 0:8dbd6bd9167f 388
mkarlsso 0:8dbd6bd9167f 389 public:
mkarlsso 0:8dbd6bd9167f 390 intCompare();
mkarlsso 7:5fe7329751d4 391 intCompare(AbstractPort* portInput, const char* cmpString, int cmpValInput, int whichToUse);
mkarlsso 7:5fe7329751d4 392 intCompare(AbstractPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse);
mkarlsso 0:8dbd6bd9167f 393 intCompare(int* intVarInput, const char* cmpString, int cmpValInput);
mkarlsso 0:8dbd6bd9167f 394 intCompare(int* intVarInput, const char* cmpString, int* cmpIntVarInput);
mkarlsso 0:8dbd6bd9167f 395 intCompare(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput);
mkarlsso 7:5fe7329751d4 396 intCompare(AbstractPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse);
mkarlsso 0:8dbd6bd9167f 397
mkarlsso 7:5fe7329751d4 398 void set(AbstractPort* portInput, const char* cmpString, int cmpValInput, int whichToUse);
mkarlsso 7:5fe7329751d4 399 void set(AbstractPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse);
mkarlsso 0:8dbd6bd9167f 400 void set(int* intVarInput, const char* cmpString, int cmpValInput);
mkarlsso 0:8dbd6bd9167f 401 void set(int* intVarInput, const char* cmpString, int* cmpIntVarInput);
mkarlsso 0:8dbd6bd9167f 402 void set(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput);
mkarlsso 7:5fe7329751d4 403 void set(AbstractPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse);
mkarlsso 0:8dbd6bd9167f 404
mkarlsso 0:8dbd6bd9167f 405 void release();
mkarlsso 0:8dbd6bd9167f 406
mkarlsso 0:8dbd6bd9167f 407 ~intCompare();
mkarlsso 0:8dbd6bd9167f 408 bool isTrue();
mkarlsso 0:8dbd6bd9167f 409 bool isUsed;
mkarlsso 0:8dbd6bd9167f 410
mkarlsso 0:8dbd6bd9167f 411 private:
mkarlsso 7:5fe7329751d4 412 AbstractPort* port;
mkarlsso 0:8dbd6bd9167f 413 int* portValPtr;
mkarlsso 0:8dbd6bd9167f 414 int* cmpVal;
mkarlsso 0:8dbd6bd9167f 415 int* intVal;
mkarlsso 0:8dbd6bd9167f 416 intOperation* intOp;
mkarlsso 0:8dbd6bd9167f 417 void setPointer(const char* cmpString);
mkarlsso 0:8dbd6bd9167f 418 void setPointer_operation(const char* cmpString);
mkarlsso 0:8dbd6bd9167f 419 bool (intCompare::*isTruePtr)();
mkarlsso 0:8dbd6bd9167f 420 bool cmpValGlobal;
mkarlsso 0:8dbd6bd9167f 421 bool greaterThan();
mkarlsso 0:8dbd6bd9167f 422 bool greaterOrEqual();
mkarlsso 0:8dbd6bd9167f 423 bool lessThan();
mkarlsso 0:8dbd6bd9167f 424 bool lessOrEqual();
mkarlsso 0:8dbd6bd9167f 425 bool equal();
mkarlsso 0:8dbd6bd9167f 426 bool notEqual();
mkarlsso 0:8dbd6bd9167f 427 bool greaterThan_op();
mkarlsso 0:8dbd6bd9167f 428 bool greaterOrEqual_op();
mkarlsso 0:8dbd6bd9167f 429 bool lessThan_op();
mkarlsso 0:8dbd6bd9167f 430 bool lessOrEqual_op();
mkarlsso 0:8dbd6bd9167f 431 bool equal_op();
mkarlsso 0:8dbd6bd9167f 432 bool notEqual_op();
mkarlsso 0:8dbd6bd9167f 433 };
mkarlsso 0:8dbd6bd9167f 434
mkarlsso 0:8dbd6bd9167f 435
mkarlsso 0:8dbd6bd9167f 436 //holder class for all possible conditions (so far only intCompare)
mkarlsso 0:8dbd6bd9167f 437 class condition {
mkarlsso 0:8dbd6bd9167f 438 public:
mkarlsso 0:8dbd6bd9167f 439
mkarlsso 0:8dbd6bd9167f 440 condition();
mkarlsso 0:8dbd6bd9167f 441 condition(intCompare* compareInput);
mkarlsso 0:8dbd6bd9167f 442 condition(condition* condition1, char condType, condition* condition2);
mkarlsso 0:8dbd6bd9167f 443 ~condition();
mkarlsso 0:8dbd6bd9167f 444 void set(intCompare* compareInput);
mkarlsso 0:8dbd6bd9167f 445 void set(condition* condition1, char condType, condition* condition2);
mkarlsso 0:8dbd6bd9167f 446 bool isTrue();
mkarlsso 0:8dbd6bd9167f 447 bool isUsed;
mkarlsso 0:8dbd6bd9167f 448 void release(); //called when the event is no longer being used;
mkarlsso 0:8dbd6bd9167f 449 private:
mkarlsso 0:8dbd6bd9167f 450
mkarlsso 0:8dbd6bd9167f 451 //char conditionType; //1 for intCompare
mkarlsso 0:8dbd6bd9167f 452 intCompare* intCmp;
mkarlsso 0:8dbd6bd9167f 453 condition* conditionPtrs[2];
mkarlsso 0:8dbd6bd9167f 454 char conditionType;
mkarlsso 0:8dbd6bd9167f 455
mkarlsso 0:8dbd6bd9167f 456
mkarlsso 0:8dbd6bd9167f 457 };
mkarlsso 0:8dbd6bd9167f 458 //--------------------------------------------
mkarlsso 0:8dbd6bd9167f 459
mkarlsso 0:8dbd6bd9167f 460
mkarlsso 0:8dbd6bd9167f 461 //queueItem connects a pre-defined event with an exectution time.
mkarlsso 0:8dbd6bd9167f 462 //They are placed in the eventQueue
mkarlsso 0:8dbd6bd9167f 463 struct queueItem {
mkarlsso 0:8dbd6bd9167f 464 uint32_t timeToExecute;
mkarlsso 0:8dbd6bd9167f 465 event* eventPtr;
mkarlsso 0:8dbd6bd9167f 466 };
mkarlsso 0:8dbd6bd9167f 467
mkarlsso 0:8dbd6bd9167f 468
mkarlsso 0:8dbd6bd9167f 469 //Organizes events in a temporal queue. check() is called from the main loop.
mkarlsso 0:8dbd6bd9167f 470 //If the execution time of the event has passed, then the event is exectuted.
mkarlsso 0:8dbd6bd9167f 471 class eventQueue {
mkarlsso 0:8dbd6bd9167f 472 public:
mkarlsso 0:8dbd6bd9167f 473 eventQueue();
mkarlsso 0:8dbd6bd9167f 474 void addEventToQueue(event* eventInput, uint32_t delay);
mkarlsso 0:8dbd6bd9167f 475 void eraseQueue(); //clear all future events
mkarlsso 0:8dbd6bd9167f 476 void check(void);
mkarlsso 0:8dbd6bd9167f 477
mkarlsso 0:8dbd6bd9167f 478 private:
mkarlsso 0:8dbd6bd9167f 479 std::vector<queueItem> events;
mkarlsso 0:8dbd6bd9167f 480 int queueSize;
mkarlsso 0:8dbd6bd9167f 481
mkarlsso 0:8dbd6bd9167f 482 };
mkarlsso 0:8dbd6bd9167f 483
mkarlsso 0:8dbd6bd9167f 484 //An 'event' is a block of 'actions' that can be gated with a boolean 'condition' set. All
mkarlsso 0:8dbd6bd9167f 485 //conditions in the set must be true for the block of actions to be executed. Right now,
mkarlsso 0:8dbd6bd9167f 486 //there is no OR logic (||), only AND (&&).
mkarlsso 0:8dbd6bd9167f 487 //The entire event is placed on the event queue to be executed at a given delay.
mkarlsso 0:8dbd6bd9167f 488 //At that future time, the condition is checked and if true, the block of actions
mkarlsso 0:8dbd6bd9167f 489 //is exectuted. Note: an 'action' can be another event (or even the parent event), allowing
mkarlsso 0:8dbd6bd9167f 490 //nested 'if' and 'while' statements.
mkarlsso 0:8dbd6bd9167f 491 class event {
mkarlsso 0:8dbd6bd9167f 492 public:
mkarlsso 0:8dbd6bd9167f 493
mkarlsso 0:8dbd6bd9167f 494 event();
mkarlsso 0:8dbd6bd9167f 495 event(eventQueue* queueInput);
mkarlsso 0:8dbd6bd9167f 496 ~event();
mkarlsso 0:8dbd6bd9167f 497 void setTimeLag(uint32_t timeLagInput); //the event will be exectuted at this time from now
mkarlsso 0:8dbd6bd9167f 498 void setTimeLag(int* timeLagInput); //the event will be exectuted at this time from now
mkarlsso 0:8dbd6bd9167f 499 void setWhileLoopPeriod(uint32_t period);
mkarlsso 0:8dbd6bd9167f 500 void setWhileLoopPeriod(int* period);
mkarlsso 0:8dbd6bd9167f 501 void addCondition(condition* conditionInput); //contains a set of conditions to check and a truth table
mkarlsso 0:8dbd6bd9167f 502 bool isConditionTrue(void); //checks if the condition is true
mkarlsso 0:8dbd6bd9167f 503 void addAction(action* actionInput); //called during script parsing, when the block is being defined
mkarlsso 0:8dbd6bd9167f 504 void addToQueue(void); //places the event on the event queue with default time lag. When the time
mkarlsso 0:8dbd6bd9167f 505 //lag has expired, the the block is executed
mkarlsso 0:8dbd6bd9167f 506 void addToQueue(uint32_t delay);
mkarlsso 0:8dbd6bd9167f 507 void execute(void); //Execute without checking the condition. Called only from the event queue
mkarlsso 0:8dbd6bd9167f 508 void setNextElseEvent(event* eventInput); //allows for else event block
mkarlsso 0:8dbd6bd9167f 509 uint32_t timeLag; //default time from now when the event will be executed (this is ignored once placed in event queue)
mkarlsso 0:8dbd6bd9167f 510 int* timeLagVar; //exectution time lab defined by a variable
mkarlsso 0:8dbd6bd9167f 511 eventQueue* queuePtr;
mkarlsso 0:8dbd6bd9167f 512 void release(); //called when the event is no longer being used;
mkarlsso 0:8dbd6bd9167f 513
mkarlsso 0:8dbd6bd9167f 514 char blockType; //0 callback
mkarlsso 0:8dbd6bd9167f 515 //1 if ... do block (with conditions)
mkarlsso 0:8dbd6bd9167f 516 //2 do block (no conditions)
mkarlsso 0:8dbd6bd9167f 517 //3 else if ... do block
mkarlsso 0:8dbd6bd9167f 518 //4 else do (no conditions)
mkarlsso 0:8dbd6bd9167f 519 //5 while ... do every ... block
mkarlsso 0:8dbd6bd9167f 520 //6 else while ... do every ... block
mkarlsso 0:8dbd6bd9167f 521 //7 then if ... do block
mkarlsso 0:8dbd6bd9167f 522 //8 then do (no conditions)
mkarlsso 0:8dbd6bd9167f 523
mkarlsso 0:8dbd6bd9167f 524 uint32_t whileLoopPeriod; //if non-zero, the block is a while loop (executed at regular intervals)
mkarlsso 0:8dbd6bd9167f 525 int* whileLoopPeriodVar;
mkarlsso 0:8dbd6bd9167f 526 event* nextElseEventPtr;
mkarlsso 0:8dbd6bd9167f 527 bool isUsed;
mkarlsso 0:8dbd6bd9167f 528 bool timeLagIsConstant;
mkarlsso 0:8dbd6bd9167f 529 bool whileLoopPeriodIsConstant;
mkarlsso 0:8dbd6bd9167f 530 bool hasWhileLoop;
mkarlsso 0:8dbd6bd9167f 531
mkarlsso 0:8dbd6bd9167f 532 private:
mkarlsso 0:8dbd6bd9167f 533 int numConditions;
mkarlsso 0:8dbd6bd9167f 534 int numActions;
mkarlsso 0:8dbd6bd9167f 535 condition* conditionToCheck;
mkarlsso 0:8dbd6bd9167f 536 action* actionArray[20];
mkarlsso 0:8dbd6bd9167f 537
mkarlsso 0:8dbd6bd9167f 538 //if statement (can be left empty, which is interpreted as 'true')
mkarlsso 0:8dbd6bd9167f 539 //std::vector<condition*> conditionArray;
mkarlsso 0:8dbd6bd9167f 540 //std::deque<action*> actionArray;
mkarlsso 0:8dbd6bd9167f 541
mkarlsso 0:8dbd6bd9167f 542 };
mkarlsso 0:8dbd6bd9167f 543
mkarlsso 0:8dbd6bd9167f 544 //each functionItem help a poiter to an action, and the name of the function. Not currently in use.
mkarlsso 0:8dbd6bd9167f 545 class functionItem {
mkarlsso 0:8dbd6bd9167f 546 public:
mkarlsso 0:8dbd6bd9167f 547 functionItem(action* actionInput, string tagInput);
mkarlsso 0:8dbd6bd9167f 548 ~functionItem();
mkarlsso 0:8dbd6bd9167f 549 string tag;
mkarlsso 0:8dbd6bd9167f 550 action* actionPtr;
mkarlsso 0:8dbd6bd9167f 551 };
mkarlsso 0:8dbd6bd9167f 552
mkarlsso 0:8dbd6bd9167f 553 class blockBuffer {
mkarlsso 0:8dbd6bd9167f 554
mkarlsso 0:8dbd6bd9167f 555 public:
mkarlsso 0:8dbd6bd9167f 556 blockBuffer();
mkarlsso 0:8dbd6bd9167f 557 bool addLine(char* input, int numChars);
mkarlsso 0:8dbd6bd9167f 558 string getNextLine();
mkarlsso 0:8dbd6bd9167f 559 int16_t linesAvailable();
mkarlsso 0:8dbd6bd9167f 560 bool empty();
mkarlsso 0:8dbd6bd9167f 561 void resetBuffer();
mkarlsso 0:8dbd6bd9167f 562
mkarlsso 0:8dbd6bd9167f 563 private:
mkarlsso 0:8dbd6bd9167f 564 #ifdef MBEDHARDWARE
mkarlsso 0:8dbd6bd9167f 565 //On the MBED, we need to put this on a different memory bank
mkarlsso 0:8dbd6bd9167f 566 __attribute((section("AHBSRAM1"),aligned)) char charBuffer[INPUTCHARBUFFERSIZE];
mkarlsso 0:8dbd6bd9167f 567 #else
mkarlsso 0:8dbd6bd9167f 568 char charBuffer[INPUTCHARBUFFERSIZE];
mkarlsso 0:8dbd6bd9167f 569 #endif
mkarlsso 0:8dbd6bd9167f 570 int16_t bufferWritePos;
mkarlsso 0:8dbd6bd9167f 571 int16_t bufferReadPos;
mkarlsso 0:8dbd6bd9167f 572 int16_t _linesAvailable;
mkarlsso 0:8dbd6bd9167f 573
mkarlsso 0:8dbd6bd9167f 574 };
mkarlsso 0:8dbd6bd9167f 575
mkarlsso 0:8dbd6bd9167f 576 //Parser for the incoming text. The parser is called when a line terminates with a semicolon (;).
mkarlsso 0:8dbd6bd9167f 577 //Only the final line in a callback block should have a semicolon.
mkarlsso 0:8dbd6bd9167f 578 class scriptStream {
mkarlsso 0:8dbd6bd9167f 579 public:
mkarlsso 7:5fe7329751d4 580 scriptStream(AbstractPort** portVectorInput, int numPortsInput, eventQueue* queueInput, sSystem* system);
mkarlsso 4:abee20c0bf2a 581 void parseBlock(); //Parses everything since the last semicolon was found
mkarlsso 0:8dbd6bd9167f 582 void addLineToCurrentBlock(char* lineInput); // if the line did not end with a semicolon, add it to the current block
mkarlsso 4:abee20c0bf2a 583
mkarlsso 4:abee20c0bf2a 584 private:
mkarlsso 4:abee20c0bf2a 585
mkarlsso 0:8dbd6bd9167f 586 int* findIntVariable(string nameInput); //used to retrieve the pointer to the designated variable if it exists
mkarlsso 0:8dbd6bd9167f 587 int* findIntVariable(const char* nameInput); //used to retrieve the pointer to the designated variable if it exists
mkarlsso 0:8dbd6bd9167f 588 int* findIntVariable(const char* nameInput, int start, int end); //used to retrieve the pointer to the designated variable if it exists
mkarlsso 0:8dbd6bd9167f 589 bool createIntVariable(string nameInput); // creates a new interger variable
mkarlsso 0:8dbd6bd9167f 590 action* evaluateAssignmentForAction(string expression); //parses a numerical assignment or operation (a = b - c)
mkarlsso 0:8dbd6bd9167f 591 action* evaluateAssignmentForAction(const char* expression); //parses a numerical assignment or operation (a = b - c)
mkarlsso 0:8dbd6bd9167f 592 bool evaluateConditions(string& expression, event* currentEvent); //parses a condition statement (a == b && c > d)
mkarlsso 0:8dbd6bd9167f 593 condition* parseConditions(const char* expression,int start, int end); //parses a condition statement (a == b && c > d)
mkarlsso 0:8dbd6bd9167f 594 int findFirstOrOutsideParenth(const char* expression, int start, int end);
mkarlsso 0:8dbd6bd9167f 595 int findFirstAndOutsideParenth(const char* expression, int start, int end);
mkarlsso 0:8dbd6bd9167f 596 bool isOutsideParenth(const char* expression,int foundItem, int start, int end);
mkarlsso 0:8dbd6bd9167f 597 bool isNum(const char* expression, int start, int end);
mkarlsso 0:8dbd6bd9167f 598 bool areStringsSame(const char* str1, const char* str2, int start, int end);
mkarlsso 0:8dbd6bd9167f 599 int getRandomParam(string expression);
mkarlsso 0:8dbd6bd9167f 600 int getRandomParam(const char* expression,int start,int end);
mkarlsso 0:8dbd6bd9167f 601 int findStringLoc(const char* refString,const char* findString,int start, int end);
mkarlsso 4:abee20c0bf2a 602 void clearEnvironmentVariables(int mode);
mkarlsso 0:8dbd6bd9167f 603
mkarlsso 0:8dbd6bd9167f 604 int currentTriggerPort;
mkarlsso 0:8dbd6bd9167f 605 int currentTriggerDir;
mkarlsso 0:8dbd6bd9167f 606 int currentPort;
mkarlsso 0:8dbd6bd9167f 607 int currentFunction;
mkarlsso 0:8dbd6bd9167f 608
mkarlsso 0:8dbd6bd9167f 609 string tmpLine;
mkarlsso 0:8dbd6bd9167f 610 vector<string> tokens;
mkarlsso 0:8dbd6bd9167f 611
mkarlsso 0:8dbd6bd9167f 612 bool lineError;
mkarlsso 0:8dbd6bd9167f 613 int blockDepth;
mkarlsso 0:8dbd6bd9167f 614 bool ifBlockInit;
mkarlsso 0:8dbd6bd9167f 615 bool whileBlockInit;
mkarlsso 0:8dbd6bd9167f 616 bool elseFlag;
mkarlsso 0:8dbd6bd9167f 617 bool thenFlag;
mkarlsso 0:8dbd6bd9167f 618 bool expectingDoStatement;
mkarlsso 0:8dbd6bd9167f 619 int currentDelay;
mkarlsso 0:8dbd6bd9167f 620 event* tmpEvent;
mkarlsso 0:8dbd6bd9167f 621 string tmpString;
mkarlsso 0:8dbd6bd9167f 622
mkarlsso 0:8dbd6bd9167f 623 vector<intVariable*> globalVariables;
mkarlsso 0:8dbd6bd9167f 624 vector<event*> tmpEventPtrArray;
mkarlsso 0:8dbd6bd9167f 625 //event* functionEventArray[NUMFUNCTIONS];
mkarlsso 0:8dbd6bd9167f 626 //bool functionSpotTaken[NUMFUNCTIONS];
mkarlsso 0:8dbd6bd9167f 627
mkarlsso 0:8dbd6bd9167f 628 //vector<functionItem*> functionArray; //any blocks declared outsite callback blocks are stored here
mkarlsso 0:8dbd6bd9167f 629 //list<string> currentBlock;
mkarlsso 0:8dbd6bd9167f 630 blockBuffer currentBlock;
mkarlsso 0:8dbd6bd9167f 631 sSystem* system;
mkarlsso 0:8dbd6bd9167f 632
mkarlsso 7:5fe7329751d4 633 AbstractPort** portVector;
mkarlsso 7:5fe7329751d4 634 int numPorts;
mkarlsso 0:8dbd6bd9167f 635
mkarlsso 7:5fe7329751d4 636 AbstractPort* digInPortVector[NUMDIGINPORTS];
mkarlsso 7:5fe7329751d4 637 uint8_t digInLookup[NUMDIGINPORTS];
mkarlsso 7:5fe7329751d4 638 int numDigInPorts;
mkarlsso 0:8dbd6bd9167f 639
mkarlsso 7:5fe7329751d4 640 AbstractPort* digOutPortVector[NUMDIGOUTPORTS];
mkarlsso 7:5fe7329751d4 641 uint8_t digOutLookup[NUMDIGOUTPORTS];
mkarlsso 7:5fe7329751d4 642 int numDigOutPorts;
mkarlsso 7:5fe7329751d4 643
mkarlsso 7:5fe7329751d4 644 AbstractPort* anInPortVector[NUMANINPORTS];
mkarlsso 7:5fe7329751d4 645 uint8_t anInLookup[NUMANINPORTS];
mkarlsso 7:5fe7329751d4 646 int numAnInPorts;
mkarlsso 7:5fe7329751d4 647
mkarlsso 7:5fe7329751d4 648 AbstractPort* anOutPortVector[NUMANOUTPORTS];
mkarlsso 7:5fe7329751d4 649 uint8_t anOutLookup[NUMANOUTPORTS];
mkarlsso 7:5fe7329751d4 650 int numAnOutPorts;
mkarlsso 7:5fe7329751d4 651
mkarlsso 0:8dbd6bd9167f 652 eventQueue* queuePtr;
mkarlsso 0:8dbd6bd9167f 653
mkarlsso 0:8dbd6bd9167f 654 };
mkarlsso 0:8dbd6bd9167f 655
mkarlsso 0:8dbd6bd9167f 656
mkarlsso 0:8dbd6bd9167f 657 class mainLoop
mkarlsso 0:8dbd6bd9167f 658
mkarlsso 0:8dbd6bd9167f 659 {
mkarlsso 0:8dbd6bd9167f 660 public:
mkarlsso 0:8dbd6bd9167f 661 mainLoop();
mkarlsso 0:8dbd6bd9167f 662 void init();
mkarlsso 0:8dbd6bd9167f 663 void exec();
mkarlsso 0:8dbd6bd9167f 664 private:
mkarlsso 0:8dbd6bd9167f 665 void eraseBuffer();
mkarlsso 0:8dbd6bd9167f 666 uint32_t currentDIOstate[2];
mkarlsso 0:8dbd6bd9167f 667 bool digitalInChanged;
mkarlsso 0:8dbd6bd9167f 668 bool digitalOutChanged;
mkarlsso 0:8dbd6bd9167f 669 scriptStream *parser;
mkarlsso 0:8dbd6bd9167f 670 sSystem *hardware; //hardware interface
mkarlsso 0:8dbd6bd9167f 671 sSerialPort *pc; //communication to computer
mkarlsso 0:8dbd6bd9167f 672 char buffer[256];
mkarlsso 7:5fe7329751d4 673 //digitalPort ports[NUMPORTS];
mkarlsso 0:8dbd6bd9167f 674
mkarlsso 7:5fe7329751d4 675 DigitalPort digInPorts[NUMDIGINPORTS];
mkarlsso 7:5fe7329751d4 676 DigitalPort digOutPorts[NUMDIGOUTPORTS];
mkarlsso 7:5fe7329751d4 677 AnalogPort anInPorts[NUMANINPORTS];
mkarlsso 7:5fe7329751d4 678 AnalogPort anOutPorts[NUMANOUTPORTS];
mkarlsso 0:8dbd6bd9167f 679
mkarlsso 7:5fe7329751d4 680 AbstractPort* ports[NUMDIGINPORTS+NUMDIGOUTPORTS+NUMANINPORTS+NUMANOUTPORTS];
mkarlsso 0:8dbd6bd9167f 681
mkarlsso 0:8dbd6bd9167f 682 };