Skad00sh / Mbed OS ES_CW2_Dev

Callum and Adel's changes on 12/02/19

Dependencies:   Crypto

main.cpp@19:805c87360b55, 2019-03-14 (annotated)

Committer:
CallumAlder
Date:
Thu Mar 14 16:08:50 2019 +0000
Revision:
19:805c87360b55
Parent:
18:7ee632098fd4
Child:
20:c60f4785b556
Callum and Adel's changes on 12/02/19

Who changed what in which revision?

UserRevisionLine numberNew contents of line
CallumAlder 14:4e312fb83330 1 #include "SHA256.h"
estott 0:de4320f74764 2 #include "mbed.h"
CallumAlder 19:805c87360b55 3 #include <iostream>
CallumAlder 19:805c87360b55 4 #include "rtos.h"
CallumAlder 14:4e312fb83330 5
CallumAlder 19:805c87360b55 6 /*TODO:
CallumAlder 19:805c87360b55 7 Change
CallumAlder 19:805c87360b55 8 Indx
CallumAlder 19:805c87360b55 9 newCmd
CallumAlder 19:805c87360b55 10 MAXCMDLENGTH
CallumAlder 19:805c87360b55 11 */
estott 0:de4320f74764 12
estott 0:de4320f74764 13 //Photointerrupter input pins
estott 10:a4b5723b6c9d 14 #define I1pin D3
estott 10:a4b5723b6c9d 15 #define I2pin D6
estott 10:a4b5723b6c9d 16 #define I3pin D5
estott 2:4e88faab6988 17
estott 2:4e88faab6988 18 //Incremental encoder input pins
estott 10:a4b5723b6c9d 19 #define CHApin D12
estott 10:a4b5723b6c9d 20 #define CHBpin D11
estott 0:de4320f74764 21
estott 0:de4320f74764 22 //Motor Drive output pins //Mask in output byte
estott 10:a4b5723b6c9d 23 #define L1Lpin D1 //0x01
estott 10:a4b5723b6c9d 24 #define L1Hpin A3 //0x02
estott 10:a4b5723b6c9d 25 #define L2Lpin D0 //0x04
estott 10:a4b5723b6c9d 26 #define L2Hpin A6 //0x08
estott 10:a4b5723b6c9d 27 #define L3Lpin D10 //0x10
estott 10:a4b5723b6c9d 28 #define L3Hpin D2 //0x20
estott 10:a4b5723b6c9d 29
estott 10:a4b5723b6c9d 30 #define PWMpin D9
estott 5:08f338b5e4d9 31
estott 5:08f338b5e4d9 32 //Motor current sense
estott 5:08f338b5e4d9 33 #define MCSPpin A1
estott 5:08f338b5e4d9 34 #define MCSNpin A0
estott 0:de4320f74764 35
estott 0:de4320f74764 36 //Mapping from sequential drive states to motor phase outputs
estott 0:de4320f74764 37 /*
estott 0:de4320f74764 38 State L1 L2 L3
estott 0:de4320f74764 39 0 H - L
estott 0:de4320f74764 40 1 - H L
estott 0:de4320f74764 41 2 L H -
estott 0:de4320f74764 42 3 L - H
estott 0:de4320f74764 43 4 - L H
estott 0:de4320f74764 44 5 H L -
estott 0:de4320f74764 45 6 - - -
estott 0:de4320f74764 46 7 - - -
estott 0:de4320f74764 47 */
estott 0:de4320f74764 48 //Drive state to output table
estott 0:de4320f74764 49 const int8_t driveTable[] = {0x12,0x18,0x09,0x21,0x24,0x06,0x00,0x00};
estott 2:4e88faab6988 50
estott 0:de4320f74764 51 //Mapping from interrupter inputs to sequential rotor states. 0x00 and 0x07 are not valid
estott 2:4e88faab6988 52 const int8_t stateMap[] = {0x07,0x05,0x03,0x04,0x01,0x00,0x02,0x07};
estott 2:4e88faab6988 53 //const int8_t stateMap[] = {0x07,0x01,0x03,0x02,0x05,0x00,0x04,0x07}; //Alternative if phase order of input or drive is reversed
estott 2:4e88faab6988 54
estott 2:4e88faab6988 55 //Phase lead to make motor spin
estott 3:569b35e2a602 56 const int8_t lead = 2; //2 for forwards, -2 for backwards
estott 0:de4320f74764 57
estott 0:de4320f74764 58 //Status LED
estott 0:de4320f74764 59 DigitalOut led1(LED1);
estott 0:de4320f74764 60
estott 0:de4320f74764 61 //Photointerrupter inputs
iachinweze1 12:41b3112021a3 62 InterruptIn I1(I1pin);
iachinweze1 12:41b3112021a3 63 InterruptIn I2(I2pin);
iachinweze1 12:41b3112021a3 64 InterruptIn I3(I3pin);
estott 0:de4320f74764 65
estott 0:de4320f74764 66 //Motor Drive outputs
CallumAlder 19:805c87360b55 67 PwmOut L1L(L1Lpin);
estott 0:de4320f74764 68 DigitalOut L1H(L1Hpin);
CallumAlder 19:805c87360b55 69 PwmOut L2L(L2Lpin);
estott 0:de4320f74764 70 DigitalOut L2H(L2Hpin);
CallumAlder 19:805c87360b55 71 PwmOut L3L(L3Lpin);
estott 0:de4320f74764 72 DigitalOut L3H(L3Hpin);
estott 0:de4320f74764 73
CallumAlder 19:805c87360b55 74
CallumAlder 19:805c87360b55 75 //Declare and start threads
CallumAlder 19:805c87360b55 76 class T_{
estott 0:de4320f74764 77
CallumAlder 19:805c87360b55 78 protected:
CallumAlder 19:805c87360b55 79
CallumAlder 19:805c87360b55 80 uint32_t motorPower; // motor toque
CallumAlder 19:805c87360b55 81 float targetVel;
CallumAlder 19:805c87360b55 82 float targetRot;
CallumAlder 19:805c87360b55 83
CallumAlder 19:805c87360b55 84 Thread *p_comm_in;
CallumAlder 19:805c87360b55 85 Thread *p_comm_out;
CallumAlder 19:805c87360b55 86 Thread *p_motor_ctrl;
estott 2:4e88faab6988 87
CallumAlder 19:805c87360b55 88 public:
CallumAlder 19:805c87360b55 89
CallumAlder 19:805c87360b55 90 T_(){
CallumAlder 19:805c87360b55 91 //(priority, stack size,
CallumAlder 19:805c87360b55 92 Thread comm_in(osPriorityAboveNormal, 1024);
CallumAlder 19:805c87360b55 93 Thread comm_out(osPriorityAboveNormal, 1024);
CallumAlder 19:805c87360b55 94 Thread motor_ctrl(osPriorityAboveNormal, 1024);
CallumAlder 19:805c87360b55 95
CallumAlder 19:805c87360b55 96 p_comm_in = &comm_in;
CallumAlder 19:805c87360b55 97 p_comm_out = &comm_out;
CallumAlder 19:805c87360b55 98 p_motor_ctrl = &motor_ctrl;
CallumAlder 19:805c87360b55 99
CallumAlder 19:805c87360b55 100 motorPower = 300;
CallumAlder 19:805c87360b55 101 targetVel = 45.0;
CallumAlder 19:805c87360b55 102 targetRot = 459.0;
CallumAlder 19:805c87360b55 103
CallumAlder 19:805c87360b55 104 }
CallumAlder 19:805c87360b55 105
CallumAlder 19:805c87360b55 106 ~T_(){
CallumAlder 19:805c87360b55 107 if (p_comm_in->get_state() == 2)
CallumAlder 19:805c87360b55 108 p_comm_in->terminate();
CallumAlder 19:805c87360b55 109 if (p_comm_out->get_state() == 2)
CallumAlder 19:805c87360b55 110 p_comm_out->terminate();
CallumAlder 19:805c87360b55 111 if (p_motor_ctrl->get_state() == 2)
CallumAlder 19:805c87360b55 112 p_motor_ctrl->terminate();
CallumAlder 19:805c87360b55 113 }
CallumAlder 19:805c87360b55 114 };
CallumAlder 19:805c87360b55 115
CallumAlder 19:805c87360b55 116
CallumAlder 19:805c87360b55 117 class Motor : public T_{
CallumAlder 19:805c87360b55 118
CallumAlder 19:805c87360b55 119 private:
CallumAlder 19:805c87360b55 120 int32_t MAXPWM;
CallumAlder 19:805c87360b55 121 int8_t orState; // Rotor offset at motor state 0
CallumAlder 19:805c87360b55 122 int8_t intStateOld; // Motor old state, may change in ISR
CallumAlder 19:805c87360b55 123
CallumAlder 19:805c87360b55 124 int32_t motorPos;
CallumAlder 19:805c87360b55 125
CallumAlder 19:805c87360b55 126
CallumAlder 19:805c87360b55 127 public:
CallumAlder 19:805c87360b55 128
CallumAlder 19:805c87360b55 129 Motor(){
CallumAlder 19:805c87360b55 130 MAXPWM = 1000;
CallumAlder 19:805c87360b55 131 orState = 0;
CallumAlder 19:805c87360b55 132 intStateOld = 0;
CallumAlder 19:805c87360b55 133 }
CallumAlder 19:805c87360b55 134
CallumAlder 19:805c87360b55 135
CallumAlder 19:805c87360b55 136 //~~~~~~~~~~~~Set a given drive state~~~~~~~~~~~~
CallumAlder 19:805c87360b55 137 void motorOut(int8_t driveState, uint32_t pw){
CallumAlder 19:805c87360b55 138
CallumAlder 19:805c87360b55 139 //Lookup the output byte from the drive state.
CallumAlder 19:805c87360b55 140 int8_t driveOut = driveTable[driveState & 0x07];
CallumAlder 19:805c87360b55 141
CallumAlder 19:805c87360b55 142 //Turn off first
CallumAlder 19:805c87360b55 143 if (~driveOut & 0x01) L1L.pulsewidth_us(0);
CallumAlder 19:805c87360b55 144 if (~driveOut & 0x02) L1H = 1;
CallumAlder 19:805c87360b55 145 if (~driveOut & 0x04) L2L.pulsewidth_us(0);
CallumAlder 19:805c87360b55 146 if (~driveOut & 0x08) L2H = 1;
CallumAlder 19:805c87360b55 147 if (~driveOut & 0x10) L3L.pulsewidth_us(0);
CallumAlder 19:805c87360b55 148 if (~driveOut & 0x20) L3H = 1;
CallumAlder 19:805c87360b55 149
CallumAlder 19:805c87360b55 150 //Then turn on
CallumAlder 19:805c87360b55 151 if (driveOut & 0x01) L1L.pulsewidth_us(pw);
CallumAlder 19:805c87360b55 152 if (driveOut & 0x02) L1H = 0;
CallumAlder 19:805c87360b55 153 if (driveOut & 0x04) L2L.pulsewidth_us(pw);
CallumAlder 19:805c87360b55 154 if (driveOut & 0x08) L2H = 0;
CallumAlder 19:805c87360b55 155 if (driveOut & 0x10) L3L.pulsewidth_us(pw);
CallumAlder 19:805c87360b55 156 if (driveOut & 0x20) L3H = 0;
CallumAlder 19:805c87360b55 157 }
CallumAlder 19:805c87360b55 158
CallumAlder 19:805c87360b55 159 inline int8_t readRotorState(){
CallumAlder 19:805c87360b55 160 return stateMap[I1 + 2*I2 + 4*I3];
CallumAlder 19:805c87360b55 161 }
CallumAlder 19:805c87360b55 162
CallumAlder 19:805c87360b55 163 int8_t motorHome() {
CallumAlder 19:805c87360b55 164 //Put the motor in drive state 0 and wait for it to stabilise
CallumAlder 19:805c87360b55 165 motorOut(0, MAXPWM); // set to max PWM
CallumAlder 19:805c87360b55 166 wait(2.0);
CallumAlder 19:805c87360b55 167
CallumAlder 19:805c87360b55 168 //Get the rotor state
CallumAlder 19:805c87360b55 169 return readRotorState();
CallumAlder 19:805c87360b55 170 }
CallumAlder 19:805c87360b55 171
CallumAlder 19:805c87360b55 172 void motorISR() {
CallumAlder 19:805c87360b55 173 static int8_t oldRotorState;
CallumAlder 19:805c87360b55 174 int8_t rotorState = readRotorState();
CallumAlder 19:805c87360b55 175
CallumAlder 19:805c87360b55 176 motorOut((rotorState-orState+lead+6)%6,motorPower);
CallumAlder 19:805c87360b55 177
CallumAlder 19:805c87360b55 178 // update motorPosition and oldRotorState
CallumAlder 19:805c87360b55 179 if (rotorState - oldRotorState == 5) motorPos--;
CallumAlder 19:805c87360b55 180 else if (rotorState - oldRotorState == -5) motorPos++;
CallumAlder 19:805c87360b55 181 else motorPos += (rotorState - oldRotorState);
CallumAlder 19:805c87360b55 182 oldRotorState = rotorState;
CallumAlder 19:805c87360b55 183 }
CallumAlder 19:805c87360b55 184
CallumAlder 19:805c87360b55 185 void stateUpdate(int8_t *params[]) { // () { // **params
CallumAlder 19:805c87360b55 186 *params[0] = readRotorState();
CallumAlder 19:805c87360b55 187 int8_t currentState = *params[0];
CallumAlder 19:805c87360b55 188 int8_t offset = *params[1];
CallumAlder 19:805c87360b55 189
CallumAlder 19:805c87360b55 190 motorOut((currentState - offset + lead + 6) % 6, MAXPWM);
CallumAlder 19:805c87360b55 191 }
CallumAlder 19:805c87360b55 192 };
CallumAlder 19:805c87360b55 193
CallumAlder 19:805c87360b55 194
CallumAlder 19:805c87360b55 195 class Comm : public T_{
estott 0:de4320f74764 196
CallumAlder 19:805c87360b55 197 private:
CallumAlder 19:805c87360b55 198 bool _RUN;
CallumAlder 19:805c87360b55 199
CallumAlder 19:805c87360b55 200 RawSerial pc;
CallumAlder 19:805c87360b55 201 Queue<void, 8> inCharQ; // Input Character Queue
estott 0:de4320f74764 202
CallumAlder 19:805c87360b55 203 volatile uint64_t newKey; // hash key
CallumAlder 19:805c87360b55 204 Mutex newKey_mutex; // Restrict access to prevent deadlock.
CallumAlder 19:805c87360b55 205
CallumAlder 19:805c87360b55 206 static const char MsgChar[11];
CallumAlder 19:805c87360b55 207
CallumAlder 19:805c87360b55 208 uint8_t MAXCMDLENGTH;
CallumAlder 19:805c87360b55 209 char newCmd[];
CallumAlder 19:805c87360b55 210 uint8_t cmdIndx;
CallumAlder 19:805c87360b55 211
iachinweze1 12:41b3112021a3 212
adehadd 16:db7ef0a4aa23 213
CallumAlder 19:805c87360b55 214 enum msgType {motorState, posIn, velIn, posOut, velOut,
CallumAlder 19:805c87360b55 215
CallumAlder 19:805c87360b55 216 hashRate, keyAdded, nonceMatch,
CallumAlder 19:805c87360b55 217
CallumAlder 19:805c87360b55 218 torque, rotations,
CallumAlder 19:805c87360b55 219
CallumAlder 19:805c87360b55 220 error};
CallumAlder 19:805c87360b55 221
CallumAlder 19:805c87360b55 222
CallumAlder 19:805c87360b55 223 typedef struct {
CallumAlder 19:805c87360b55 224 msgType type;
CallumAlder 19:805c87360b55 225 uint32_t message;
CallumAlder 19:805c87360b55 226 } msg;
CallumAlder 19:805c87360b55 227
CallumAlder 19:805c87360b55 228 Mail<msg, 32> mailStack;
CallumAlder 19:805c87360b55 229
CallumAlder 19:805c87360b55 230 void serialISR(){
CallumAlder 19:805c87360b55 231 uint8_t newChar = pc.getc();
CallumAlder 19:805c87360b55 232 inCharQ.put((void*)newChar);
CallumAlder 19:805c87360b55 233 }
CallumAlder 19:805c87360b55 234
CallumAlder 19:805c87360b55 235 void commInFn() {
CallumAlder 19:805c87360b55 236 if (_RUN)
CallumAlder 19:805c87360b55 237 pc.attach(callback(this, &Comm::serialISR));
CallumAlder 19:805c87360b55 238 while (_RUN) {
CallumAlder 19:805c87360b55 239 osEvent newEvent = inCharQ.get();
CallumAlder 19:805c87360b55 240 uint8_t newChar = ((uint8_t)(&newEvent.value.p));
CallumAlder 19:805c87360b55 241 pc.putc(newChar);
CallumAlder 19:805c87360b55 242 if(cmdIndx >= MAXCMDLENGTH){ //Make sure there is no overflow in comand.
CallumAlder 19:805c87360b55 243 cmdIndx = 0;
CallumAlder 19:805c87360b55 244 putMessage(error, 1);
CallumAlder 19:805c87360b55 245 }
CallumAlder 19:805c87360b55 246 else{
CallumAlder 19:805c87360b55 247 if(newChar != '\r'){ //While the command is not over,
CallumAlder 19:805c87360b55 248 newCmd[cmdIndx] = newChar; //save input character and
CallumAlder 19:805c87360b55 249 cmdIndx++; //advance index
CallumAlder 19:805c87360b55 250 }
CallumAlder 19:805c87360b55 251 else{
CallumAlder 19:805c87360b55 252 newCmd[cmdIndx] = '\0'; //When the command is finally over,
CallumAlder 19:805c87360b55 253 cmdIndx = 0; //reset index and
CallumAlder 19:805c87360b55 254 cmdParser(); //parse the command for decoding.
CallumAlder 19:805c87360b55 255 }
CallumAlder 19:805c87360b55 256 }
CallumAlder 19:805c87360b55 257 }
CallumAlder 19:805c87360b55 258 }
CallumAlder 19:805c87360b55 259
CallumAlder 19:805c87360b55 260 void cmdParser(){
CallumAlder 19:805c87360b55 261 switch(newCmd[0]) {
CallumAlder 19:805c87360b55 262 case 'K':
CallumAlder 19:805c87360b55 263 newKey_mutex.lock(); //Ensure there is no deadlock
CallumAlder 19:805c87360b55 264 sscanf(newCmd, "K%x", &newKey); //Find desired the Key code
CallumAlder 19:805c87360b55 265 putMessage(keyAdded, newKey); //Print it out
CallumAlder 19:805c87360b55 266 newKey_mutex.unlock();
CallumAlder 19:805c87360b55 267 break;
CallumAlder 19:805c87360b55 268 case 'V':
CallumAlder 19:805c87360b55 269 sscanf(newCmd, "V%f", &targetVel); //Find desired the target velocity
CallumAlder 19:805c87360b55 270 putMessage(velIn, targetVel); //Print it out
CallumAlder 19:805c87360b55 271 break;
CallumAlder 19:805c87360b55 272 case 'R':
CallumAlder 19:805c87360b55 273 sscanf(newCmd, "R%f", &targetRot); //Find desired target rotation
CallumAlder 19:805c87360b55 274 putMessage(posIn, targetRot); //Print it out
CallumAlder 19:805c87360b55 275 break;
CallumAlder 19:805c87360b55 276 case 'T':
CallumAlder 19:805c87360b55 277 sscanf(newCmd, "T%d", &motorPower); //Find desired target torque
CallumAlder 19:805c87360b55 278 putMessage(torque, motorPower); //Print it out
CallumAlder 19:805c87360b55 279 break;
CallumAlder 19:805c87360b55 280 default: break;
CallumAlder 19:805c87360b55 281 }
CallumAlder 19:805c87360b55 282 }
CallumAlder 19:805c87360b55 283
CallumAlder 19:805c87360b55 284 //~~~~~Decode messages to print on serial port~~~~~
CallumAlder 19:805c87360b55 285 void commOutFn() {
CallumAlder 19:805c87360b55 286 while (_RUN) {
CallumAlder 19:805c87360b55 287 osEvent newEvent = mailStack.get();
CallumAlder 19:805c87360b55 288 msg *pMessage = (msg*)newEvent.value.p; // ADEL ??
CallumAlder 19:805c87360b55 289
CallumAlder 19:805c87360b55 290 //Case switch to choose serial output based on incoming message
CallumAlder 19:805c87360b55 291 switch(pMessage->type) {
CallumAlder 19:805c87360b55 292 case motorState:
CallumAlder 19:805c87360b55 293 pc.printf("The motor is currently in state %x\n\r", pMessage->message);
CallumAlder 19:805c87360b55 294 break;
CallumAlder 19:805c87360b55 295 case hashRate:
CallumAlder 19:805c87360b55 296 pc.printf("Mining at a rate of %.2f Hash/s\n\r", (int32_t)pMessage->message);
CallumAlder 19:805c87360b55 297 break;
CallumAlder 19:805c87360b55 298 case nonceMatch:
CallumAlder 19:805c87360b55 299 pc.printf("Nonce found: %x\n\r", pMessage->message);
CallumAlder 19:805c87360b55 300 break;
CallumAlder 19:805c87360b55 301 case keyAdded:
CallumAlder 19:805c87360b55 302 pc.printf("New key added:\t0x%016x\n\r", pMessage->message);
CallumAlder 19:805c87360b55 303 break;
CallumAlder 19:805c87360b55 304 case torque:
CallumAlder 19:805c87360b55 305 pc.printf("Motor torque set to:\t%d\n\r", pMessage->message);
CallumAlder 19:805c87360b55 306 break;
CallumAlder 19:805c87360b55 307 case velIn:
CallumAlder 19:805c87360b55 308 pc.printf("Target velocity set to:\t%.2f\n\r", targetVel);
CallumAlder 19:805c87360b55 309 break;
CallumAlder 19:805c87360b55 310 case velOut:
CallumAlder 19:805c87360b55 311 pc.printf("Current Velocity:\t%.2f\n\r", \
CallumAlder 19:805c87360b55 312 (float)((int32_t)pMessage->message / 6));
CallumAlder 19:805c87360b55 313 break;
CallumAlder 19:805c87360b55 314 case posIn:
CallumAlder 19:805c87360b55 315 pc.printf("Target rotation set to:\t%.2f\n\r", \
CallumAlder 19:805c87360b55 316 (float)((int32_t)pMessage->message / 6));
CallumAlder 19:805c87360b55 317 break;
CallumAlder 19:805c87360b55 318 case posOut:
CallumAlder 19:805c87360b55 319 pc.printf("Current position:\t%.2f\n\r", \
CallumAlder 19:805c87360b55 320 (float)((int32_t)pMessage->message / 6));
CallumAlder 19:805c87360b55 321 break;
CallumAlder 19:805c87360b55 322 case error:
CallumAlder 19:805c87360b55 323 pc.printf("Debugging position:%x\n\r", pMessage->message);
CallumAlder 19:805c87360b55 324 break;
CallumAlder 19:805c87360b55 325 default:
CallumAlder 19:805c87360b55 326 pc.printf("Unknown Error. Message: %x\n\r", pMessage->message);
CallumAlder 19:805c87360b55 327 break;
CallumAlder 19:805c87360b55 328 }
CallumAlder 19:805c87360b55 329 mailStack.free(pMessage);
CallumAlder 19:805c87360b55 330 }
CallumAlder 19:805c87360b55 331 }
CallumAlder 19:805c87360b55 332
CallumAlder 19:805c87360b55 333
CallumAlder 19:805c87360b55 334 //TODO: stop function, maybe use parent deconstructor
CallumAlder 19:805c87360b55 335 //void stop_comm{}
CallumAlder 19:805c87360b55 336
CallumAlder 19:805c87360b55 337 public:
adehadd 18:7ee632098fd4 338
CallumAlder 19:805c87360b55 339 Comm(): pc(SERIAL_TX, SERIAL_RX), T_(){ // inherit from the RawSerial constructor
CallumAlder 19:805c87360b55 340
CallumAlder 19:805c87360b55 341 MAXCMDLENGTH = 18;
CallumAlder 19:805c87360b55 342 newCmd[MAXCMDLENGTH] = '0';
CallumAlder 19:805c87360b55 343 cmdIndx = 0;
CallumAlder 19:805c87360b55 344
CallumAlder 19:805c87360b55 345 motorPower = 300;
CallumAlder 19:805c87360b55 346 targetVel = 45.0;
CallumAlder 19:805c87360b55 347 targetRot = 459.0;
CallumAlder 19:805c87360b55 348 }
CallumAlder 19:805c87360b55 349
CallumAlder 19:805c87360b55 350
CallumAlder 19:805c87360b55 351 void putMessage(msgType type, uint32_t message){
CallumAlder 19:805c87360b55 352 msg *p_msg = mailStack.alloc();
CallumAlder 19:805c87360b55 353 p_msg->type = type;
CallumAlder 19:805c87360b55 354 p_msg->message = message;
CallumAlder 19:805c87360b55 355 mailStack.put(p_msg);
CallumAlder 19:805c87360b55 356 }
CallumAlder 19:805c87360b55 357
CallumAlder 19:805c87360b55 358 void start_comm(){
CallumAlder 19:805c87360b55 359 p_comm_in->start(callback(this, &Comm::commInFn));
CallumAlder 19:805c87360b55 360 p_comm_out->start(callback(this, &Comm::commOutFn));
CallumAlder 19:805c87360b55 361
CallumAlder 19:805c87360b55 362 _RUN = true;
CallumAlder 19:805c87360b55 363 }
CallumAlder 19:805c87360b55 364 };
CallumAlder 19:805c87360b55 365
iachinweze1 12:41b3112021a3 366
estott 0:de4320f74764 367 //Main
estott 0:de4320f74764 368 int main() {
CallumAlder 19:805c87360b55 369
CallumAlder 19:805c87360b55 370 // std::ios::sync_with_stdio(false);
CallumAlder 14:4e312fb83330 371 SHA256::SHA256 Miner;
CallumAlder 14:4e312fb83330 372
CallumAlder 14:4e312fb83330 373 uint8_t sequence[] = {0x45,0x6D,0x62,0x65,0x64,0x64,0x65,0x64,
CallumAlder 14:4e312fb83330 374 0x20,0x53,0x79,0x73,0x74,0x65,0x6D,0x73,
CallumAlder 14:4e312fb83330 375 0x20,0x61,0x72,0x65,0x20,0x66,0x75,0x6E,
CallumAlder 14:4e312fb83330 376 0x20,0x61,0x6E,0x64,0x20,0x64,0x6F,0x20,
CallumAlder 14:4e312fb83330 377 0x61,0x77,0x65,0x73,0x6F,0x6D,0x65,0x20,
CallumAlder 14:4e312fb83330 378 0x74,0x68,0x69,0x6E,0x67,0x73,0x21,0x20,
CallumAlder 14:4e312fb83330 379 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
CallumAlder 14:4e312fb83330 380 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
CallumAlder 14:4e312fb83330 381 uint64_t* key = (uint64_t*)((int)sequence + 48);
CallumAlder 14:4e312fb83330 382 uint64_t* nonce = (uint64_t*)((int)sequence + 56);
CallumAlder 14:4e312fb83330 383 uint8_t hash[32];
CallumAlder 14:4e312fb83330 384 uint32_t length64 = 64;
CallumAlder 15:2f95f2fb68e3 385 uint32_t hashCounter = 0;
CallumAlder 15:2f95f2fb68e3 386 Timer timer;
estott 0:de4320f74764 387
adehadd 16:db7ef0a4aa23 388 // Motor States
adehadd 16:db7ef0a4aa23 389 int8_t orState = 0; //Rotot offset at motor state 0
adehadd 16:db7ef0a4aa23 390 int8_t currentState = 0; //Rotot offset at motor state 0
adehadd 18:7ee632098fd4 391 int8_t stateList[6]; //Rotot offset at motor state 0
estott 0:de4320f74764 392 //Run the motor synchronisation
CallumAlder 19:805c87360b55 393
CallumAlder 19:805c87360b55 394
CallumAlder 19:805c87360b55 395 Motor motor;
CallumAlder 19:805c87360b55 396 Motor* p_motor = &motor;
CallumAlder 19:805c87360b55 397 orState = p_motor->motorHome();
iachinweze1 12:41b3112021a3 398
CallumAlder 15:2f95f2fb68e3 399 // Add callbacks
CallumAlder 19:805c87360b55 400 // I1.fall(&stateUpdate);
CallumAlder 19:805c87360b55 401 // I2.fall(&stateUpdate);
CallumAlder 19:805c87360b55 402 // I3.fall(&stateUpdate);
adehadd 16:db7ef0a4aa23 403 int8_t* params[2];
adehadd 16:db7ef0a4aa23 404 params[0] = &currentState;
adehadd 16:db7ef0a4aa23 405 params[1] = &orState;
adehadd 16:db7ef0a4aa23 406
CallumAlder 19:805c87360b55 407 I1.fall(callback(*(p_motor->stateUpdate),params));
adehadd 16:db7ef0a4aa23 408 I2.fall(callback(&stateUpdate,params));
adehadd 16:db7ef0a4aa23 409 I3.fall(callback(&stateUpdate,params));
iachinweze1 12:41b3112021a3 410
adehadd 18:7ee632098fd4 411 I1.rise(callback(&stateUpdate,params));
adehadd 18:7ee632098fd4 412 I2.rise(callback(&stateUpdate,params));
adehadd 18:7ee632098fd4 413 I3.rise(callback(&stateUpdate,params));
adehadd 18:7ee632098fd4 414
CallumAlder 15:2f95f2fb68e3 415 // Push motor to move
iachinweze1 12:41b3112021a3 416 currentState = readRotorState();
iachinweze1 12:41b3112021a3 417 motorOut((currentState-orState+lead+6)%6); // We push it digitally
estott 0:de4320f74764 418
CallumAlder 19:805c87360b55 419 pc.printf("Rotor origin: %x\n\r",orState);
CallumAlder 19:805c87360b55 420 orState is subtracted from future rotor state inputs to align rotor and motor states
CallumAlder 19:805c87360b55 421 intState = readRotorState();
CallumAlder 19:805c87360b55 422 if (intState != intStateOld) {
CallumAlder 19:805c87360b55 423 pc.printf("old:%d \t new:%d \t next:%d \n\r",intStateOld, intState, (intState-orState+lead+6)%6);
CallumAlder 19:805c87360b55 424 intStateOld = intState;
CallumAlder 19:805c87360b55 425 motorOut((intState-orState+lead+6)%6); //+6 to make sure the remainder is positive
CallumAlder 19:805c87360b55 426 }
iachinweze1 12:41b3112021a3 427
CallumAlder 15:2f95f2fb68e3 428
iachinweze1 12:41b3112021a3 429 // Keep the program running indefinitely
CallumAlder 15:2f95f2fb68e3 430 timer.start(); // start timer
adehadd 18:7ee632098fd4 431 int stateCount = 0;
CallumAlder 15:2f95f2fb68e3 432 while (1) {
CallumAlder 19:805c87360b55 433 pc.printf("Current:%d \t Next:%d \n\r", currentState, (currentState-orState+lead+6)%6);
CallumAlder 15:2f95f2fb68e3 434 Miner.computeHash(hash, sequence, length64);
CallumAlder 15:2f95f2fb68e3 435 hashCounter++;
CallumAlder 15:2f95f2fb68e3 436 if ((hash[0]==0) && (hash[1]==0)){
CallumAlder 19:805c87360b55 437 //pc.printf("hash: ");
CallumAlder 19:805c87360b55 438 //for(int i = 0; i < 32; ++i)
CallumAlder 19:805c87360b55 439 //pc.printf("%02x", hash[i]);
CallumAlder 19:805c87360b55 440 //pc.printf("\n\r");
CallumAlder 15:2f95f2fb68e3 441 }
CallumAlder 15:2f95f2fb68e3 442
CallumAlder 19:805c87360b55 443 // // Try a new nonce
CallumAlder 15:2f95f2fb68e3 444 (*nonce)++;
CallumAlder 15:2f95f2fb68e3 445
adehadd 18:7ee632098fd4 446 if (stateCount<6){
adehadd 18:7ee632098fd4 447 stateList[stateCount] = currentState;
adehadd 18:7ee632098fd4 448 stateCount++;
adehadd 18:7ee632098fd4 449 }
adehadd 18:7ee632098fd4 450 else {
CallumAlder 19:805c87360b55 451 //pc.printf("states");
CallumAlder 19:805c87360b55 452 //for(int i = 0; i < 6; ++i)
CallumAlder 19:805c87360b55 453 //pc.printf("%02i,", stateList[i]);
CallumAlder 19:805c87360b55 454 //pc.printf("\n\r");
adehadd 18:7ee632098fd4 455 stateCount = 0;
adehadd 18:7ee632098fd4 456 }
adehadd 18:7ee632098fd4 457
CallumAlder 19:805c87360b55 458 // // Per Second i.e. when greater or equal to 1
CallumAlder 15:2f95f2fb68e3 459 if (timer.read() >= 1){
CallumAlder 19:805c87360b55 460 //pc.printf("HashRate = %02u \n\r",hashCounter);
CallumAlder 15:2f95f2fb68e3 461 hashCounter=0;
CallumAlder 15:2f95f2fb68e3 462 timer.reset();
CallumAlder 15:2f95f2fb68e3 463 }
CallumAlder 15:2f95f2fb68e3 464 }
CallumAlder 15:2f95f2fb68e3 465
CallumAlder 19:805c87360b55 466 }