Mattias Karlsson / Mbed 2 deprecated stateScript_v2

Microcontroller firmware that uses a simple, yet powerful scripting language to control the timing of input and output events with high temporal resolution. Written by Mattias Karlsson

Dependencies:   SMARTWAV mbed

behave.h@4:abee20c0bf2a, 2016-01-15 (annotated)

Committer:
mkarlsso
Date:
Fri Jan 15 22:13:23 2016 +0000
Revision:
4:abee20c0bf2a
Parent:
3:d7b0a0890d96
Child:
7:5fe7329751d4
Fixed an issue where syntax errors caused the program to crash instead of just reporting the syntax error.

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