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