Alvaro Cassinelli / Mbed 2 deprecated skinGames_forktest

just a test

Dependencies:   mbed

Fork of scoreLight_Advanced by Alvaro Cassinelli

main.cpp@34:1244fa3f2559, 2012-11-07 (annotated)

Committer:
mbedalvaro
Date:
Wed Nov 07 14:41:55 2012 +0000
Revision:
34:1244fa3f2559
Parent:
33:43e8bc451ef0
Child:
35:35af5086ab4f
added hardware button & potentiometer to select the thresholding mode and parameters. Problems with the ADC conversion though...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbedalvaro 0:345b3bc7a0ea 1 #include "mbed.h"
mbedalvaro 0:345b3bc7a0ea 2 #include "hardwareIO.h"
mbedalvaro 0:345b3bc7a0ea 3 #include "mbedOSC.h"
mbedalvaro 0:345b3bc7a0ea 4 #include "blobConfig.h"
mbedalvaro 0:345b3bc7a0ea 5 #include "simpleLaserRenderer.h"
mbedalvaro 0:345b3bc7a0ea 6
mbedalvaro 0:345b3bc7a0ea 7 extern "C" void mbed_reset();
mbedalvaro 0:345b3bc7a0ea 8
mbedalvaro 0:345b3bc7a0ea 9 blobConfig blobconf;
mbedalvaro 0:345b3bc7a0ea 10 simpleLaserSensingRenderer lsr;
mbedalvaro 0:345b3bc7a0ea 11
mbedalvaro 0:345b3bc7a0ea 12 // For tests:
mbedalvaro 0:345b3bc7a0ea 13 DigitalOut myled(LED1);
mbedalvaro 0:345b3bc7a0ea 14 DigitalOut myled2(LED2);
mbedalvaro 23:bf666fcc61bc 15 DigitalOut myled3(LED3);
mbedalvaro 0:345b3bc7a0ea 16
mbedalvaro 0:345b3bc7a0ea 17
mbedalvaro 1:a4050fee11f7 18 // To test the time it takes for executing one loop in the main program:
mbedalvaro 10:6f8e48dca1bd 19 //#define LOOPTIMECOMPUTE
mbedalvaro 1:a4050fee11f7 20
mbedalvaro 1:a4050fee11f7 21 // To get serial commands (for debug, or other things using a Terminal - for instance, a laser scan)
mbedalvaro 14:0fc33a3a7b4b 22 #define SERIAL_COMMANDS
mbedalvaro 0:345b3bc7a0ea 23
mbedalvaro 0:345b3bc7a0ea 24 //---------- ETHERNET / OSC related (in the future, put somewhere else...): -------------------------------------------
mbedalvaro 0:345b3bc7a0ea 25 // mbed IP address (server):
mbedalvaro 0:345b3bc7a0ea 26 #ifdef DHCP
mbedalvaro 0:345b3bc7a0ea 27 EthernetNetIf eth;
mbedalvaro 0:345b3bc7a0ea 28 #else
mbedalvaro 0:345b3bc7a0ea 29 EthernetNetIf eth(
mbedalvaro 1:a4050fee11f7 30 IpAddr(10,0,0,2), //IP Address
mbedalvaro 1:a4050fee11f7 31 IpAddr(255,255,255,0), //Network Mask
mbedalvaro 1:a4050fee11f7 32 IpAddr(10,0,0,1), //Gateway
mbedalvaro 1:a4050fee11f7 33 IpAddr(10,0,0,1) //DNS
mbedalvaro 0:345b3bc7a0ea 34 );
mbedalvaro 0:345b3bc7a0ea 35 #endif
mbedalvaro 0:345b3bc7a0ea 36
mbedalvaro 0:345b3bc7a0ea 37 //uint8_t serverMac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
mbedalvaro 0:345b3bc7a0ea 38 uint8_t serverIp[] = { 10, 0, 0, 2 }; // not needed perhaps!
mbedalvaro 0:345b3bc7a0ea 39 int serverPort = 10000;
mbedalvaro 1:a4050fee11f7 40
mbedalvaro 32:52273c3291fe 41 //uint8_t destIp[] = {10, 0, 0, 3};
mbedalvaro 32:52273c3291fe 42 uint8_t destIp[] = {255, 255, 255, 255}; // broadcast, so we can use several computers for sound, etc
mbedalvaro 0:345b3bc7a0ea 43 int destPort = 12000;
mbedalvaro 1:a4050fee11f7 44
mbedalvaro 0:345b3bc7a0ea 45 char *topAddress="/mbed";
mbedalvaro 0:345b3bc7a0ea 46 char *subAddress[3]={ "/test1" , "/test2" , "/test3" };
mbedalvaro 1:a4050fee11f7 47
mbedalvaro 0:345b3bc7a0ea 48 OSCMessage recMes;
mbedalvaro 0:345b3bc7a0ea 49 OSCMessage sendMes;
mbedalvaro 1:a4050fee11f7 50
mbedalvaro 1:a4050fee11f7 51 OSCClass osc;
mbedalvaro 1:a4050fee11f7 52 //OSCClass osc(&recMes); // instantiate OSC communication object, and set the receiver container from the OSC packets
mbedalvaro 1:a4050fee11f7 53
mbedalvaro 1:a4050fee11f7 54 void processOSC(UDPSocketEvent e);
mbedalvaro 0:345b3bc7a0ea 55 // ----------------------------------------------------------------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 56
mbedalvaro 2:34157ebbf56b 57 // Tickers:
mbedalvaro 0:345b3bc7a0ea 58 Ticker timerForRendering;
mbedalvaro 2:34157ebbf56b 59 //Ticker timerForSendingData; // better use a timer, so as not to interrupt the exact laser display ticker
mbedalvaro 2:34157ebbf56b 60
mbedalvaro 9:3321170d157c 61 // Timers:
mbedalvaro 0:345b3bc7a0ea 62 Timer measureLoopPeriod;
mbedalvaro 9:3321170d157c 63 //Timer measureUpdatePeriod;
mbedalvaro 18:d72935b13858 64
mbedalvaro 0:345b3bc7a0ea 65
mbedalvaro 1:a4050fee11f7 66 // to get serial commands (not necessary perhaps)
mbedalvaro 0:345b3bc7a0ea 67 void processSerial();
mbedalvaro 1:a4050fee11f7 68
mbedalvaro 0:345b3bc7a0ea 69 int main() {
mbedalvaro 1:a4050fee11f7 70
mbedalvaro 0:345b3bc7a0ea 71 // Initialize the hardware (laser powers, positions...):
mbedalvaro 0:345b3bc7a0ea 72 IO.init();
mbedalvaro 0:345b3bc7a0ea 73
mbedalvaro 1:a4050fee11f7 74 // -------------------------------
mbedalvaro 1:a4050fee11f7 75 // Set the Ethernet port:
mbedalvaro 1:a4050fee11f7 76 printf("Setting up...\r\n");
mbedalvaro 1:a4050fee11f7 77 EthernetErr ethErr = eth.setup();
mbedalvaro 1:a4050fee11f7 78 if (ethErr) {
mbedalvaro 1:a4050fee11f7 79 printf("Error %d in setup.\r\n", ethErr);
mbedalvaro 1:a4050fee11f7 80 return -1;
mbedalvaro 1:a4050fee11f7 81 }
mbedalvaro 1:a4050fee11f7 82 printf("Setup OK\r\n");
mbedalvaro 1:a4050fee11f7 83
mbedalvaro 1:a4050fee11f7 84 //(1) Sending message:
mbedalvaro 1:a4050fee11f7 85 // Set IP and Port:
mbedalvaro 1:a4050fee11f7 86 sendMes.setIp( destIp );
mbedalvaro 1:a4050fee11f7 87 sendMes.setPort( destPort );
mbedalvaro 1:a4050fee11f7 88 // Set data:
mbedalvaro 1:a4050fee11f7 89 // sendMes.setTopAddress(topAddress);
mbedalvaro 1:a4050fee11f7 90
mbedalvaro 1:a4050fee11f7 91 //setting osc functionnality:
mbedalvaro 1:a4050fee11f7 92 //(2) Receiving:
mbedalvaro 1:a4050fee11f7 93 // recMes.setIp( serverIp ); // not needed?
mbedalvaro 1:a4050fee11f7 94 osc.setReceiveMessage(&recMes); // this sets the receiver container for the OSC packets (we can avoid doing this if we use osc.getMessage() to get messages)
mbedalvaro 1:a4050fee11f7 95 osc.begin(serverPort, &processOSC); // binds the upd (osc) messages to an arbitrary listening port ("server" port), and callback function
mbedalvaro 1:a4050fee11f7 96 // -------------------------------
mbedalvaro 1:a4050fee11f7 97
mbedalvaro 0:345b3bc7a0ea 98 /* // sending seems not to work right after setting the osc object??
mbedalvaro 0:345b3bc7a0ea 99 wait(1);
mbedalvaro 0:345b3bc7a0ea 100 sendMes.setTopAddress("starting");
mbedalvaro 1:a4050fee11f7 101 sendMes.setSubAddress("");
mbedalvaro 0:345b3bc7a0ea 102 osc.sendOsc( &sendMes );
mbedalvaro 0:345b3bc7a0ea 103 */
mbedalvaro 1:a4050fee11f7 104
mbedalvaro 0:345b3bc7a0ea 105 // initialize with the desired blob configuration:
mbedalvaro 1:a4050fee11f7 106
mbedalvaro 0:345b3bc7a0ea 107 // Tested modes:
mbedalvaro 1:a4050fee11f7 108 blobconf.clearConfig();
mbedalvaro 10:6f8e48dca1bd 109 // blobconf.addOneElasticLoopContractCentral();
mbedalvaro 11:62f7183a03e7 110 // blobconf.addOneElasticContourFollowing();
mbedalvaro 1:a4050fee11f7 111
mbedalvaro 14:0fc33a3a7b4b 112 // blobconf.addOneRigidLoopBouncing();
mbedalvaro 9:3321170d157c 113 // blobconf.addOneRigidLoopBouncing();
mbedalvaro 16:2ff1cb2ae1b1 114 //blobconf.addOneRigidLoopFollowing();
mbedalvaro 29:2fc8c12822eb 115 // blobconf.addOneRigidLoopFollowing();
mbedalvaro 32:52273c3291fe 116 //blobconf.addOneElasticLoopContractCentralFast();
mbedalvaro 32:52273c3291fe 117 //blobconf.addOneRigidLoopTest();
mbedalvaro 2:34157ebbf56b 118
mbedalvaro 32:52273c3291fe 119 // START WITH TWO FOLLOWING SPOTS (exhibition Tokyo Design Week):
mbedalvaro 32:52273c3291fe 120 blobconf.initConfig(FOLLOWING_SPOTS, 2); // value is the nb of spots instantiated
mbedalvaro 32:52273c3291fe 121 // Make them of different color:
mbedalvaro 32:52273c3291fe 122 blobconf.blobArray[0]->setBlueColor(1);
mbedalvaro 32:52273c3291fe 123 blobconf.blobArray[1]->setGreenColor(1);
mbedalvaro 32:52273c3291fe 124 // start in no stand by mode:
mbedalvaro 32:52273c3291fe 125 blobconf.allResume();
mbedalvaro 1:a4050fee11f7 126
mbedalvaro 0:345b3bc7a0ea 127 // Important: first, set the initial position for all the blobs, this will be useful because
mbedalvaro 0:345b3bc7a0ea 128 // when changing modes we can use the previous central position...
mbedalvaro 1:a4050fee11f7 129 // blobconf.setInitialPos(CENTER_AD_MIRROR_X, CENTER_AD_MIRROR_Y);
mbedalvaro 1:a4050fee11f7 130
mbedalvaro 24:4e52031a495b 131 // draw the config once before activating the laser buffer:
mbedalvaro 5:73cd58b58f95 132 blobconf.draw();
mbedalvaro 13:9f03eac02700 133 lsr.startFullDisplay();
mbedalvaro 1:a4050fee11f7 134
mbedalvaro 0:345b3bc7a0ea 135 // RENRERER (attn: setConfigToRender must be called when the blobconf is set - i.e., the number of blobs and number of points/blob is fixed)
mbedalvaro 1:a4050fee11f7 136 lsr.setConfigToRender(&blobconf);
mbedalvaro 1:a4050fee11f7 137
mbedalvaro 1:a4050fee11f7 138 // Timer on the rendering function of the oneLoop object:
mbedalvaro 9:3321170d157c 139 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL); // the address of the object, member function, and interval (in seconds)
mbedalvaro 9:3321170d157c 140 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL); // the address of the object, member function, and interval (in seconds)
mbedalvaro 1:a4050fee11f7 141
mbedalvaro 1:a4050fee11f7 142 // Timer for sending OSC data:
mbedalvaro 9:3321170d157c 143 // timerForSendingData.attach(&blobconf, &blobConfig::sendConfData, 0.025); // time in seconds (25ms -> 40Hz)
mbedalvaro 1:a4050fee11f7 144
mbedalvaro 1:a4050fee11f7 145 //========================================== INFINITE LOOP (in USER PROGRAM CONTEXT) ===================================================================
mbedalvaro 1:a4050fee11f7 146 #ifdef LOOPTIMECOMPUTE
mbedalvaro 1:a4050fee11f7 147 int timeCounterNum=1000;
mbedalvaro 1:a4050fee11f7 148 #endif
mbedalvaro 1:a4050fee11f7 149
mbedalvaro 9:3321170d157c 150 //measureUpdatePeriod.start();
mbedalvaro 1:a4050fee11f7 151
mbedalvaro 1:a4050fee11f7 152 while (true) {
mbedalvaro 1:a4050fee11f7 153
mbedalvaro 13:9f03eac02700 154 if (lsr.endedFullDisplay()) {
mbedalvaro 9:3321170d157c 155
mbedalvaro 9:3321170d157c 156 // measureUpdatePeriod.stop();
mbedalvaro 9:3321170d157c 157 // measureUpdatePeriod.reset();
mbedalvaro 9:3321170d157c 158
mbedalvaro 9:3321170d157c 159 // __disable_irq();
mbedalvaro 9:3321170d157c 160
mbedalvaro 1:a4050fee11f7 161 // update config dynamics (this also could be threaded?):
mbedalvaro 1:a4050fee11f7 162 blobconf.update();
mbedalvaro 1:a4050fee11f7 163
mbedalvaro 10:6f8e48dca1bd 164
mbedalvaro 1:a4050fee11f7 165 // draw the config (note: each kind of blob renders differently)
mbedalvaro 1:a4050fee11f7 166 blobconf.draw();
mbedalvaro 18:d72935b13858 167
mbedalvaro 18:d72935b13858 168
mbedalvaro 18:d72935b13858 169 // (b)Sending Data: // PUT THIS IN AN INTERRUPT OR USE A TIMER!!! it may be TOO FAST...
mbedalvaro 18:d72935b13858 170 // NOTE: better use a timer, so the only ISR "ticker" is the laser rendering (otherwise the laser rendering will be interrupted by the sending of data - the other way is ok):
mbedalvaro 18:d72935b13858 171 // NOTE: timer for sending is now not COMMON to all blobs, but depends on the blob (it could depend on the CONFIG only, but this can be simulated by using
mbedalvaro 18:d72935b13858 172 // per blob timer counter.
mbedalvaro 18:d72935b13858 173 blobconf.sendConfData();
mbedalvaro 18:d72935b13858 174
mbedalvaro 16:2ff1cb2ae1b1 175
mbedalvaro 23:bf666fcc61bc 176 lsr.startFullDisplay(); // this start the point-display counter (wherever the actual laser is). Before update and draw, the counter needs to be reset.
mbedalvaro 16:2ff1cb2ae1b1 177
mbedalvaro 9:3321170d157c 178
mbedalvaro 9:3321170d157c 179 // __enable_irq();
mbedalvaro 9:3321170d157c 180
mbedalvaro 9:3321170d157c 181 // measureUpdatePeriod.start();
mbedalvaro 10:6f8e48dca1bd 182
mbedalvaro 1:a4050fee11f7 183 }
mbedalvaro 0:345b3bc7a0ea 184
mbedalvaro 2:34157ebbf56b 185
mbedalvaro 1:a4050fee11f7 186 // COMMUNICATION:
mbedalvaro 1:a4050fee11f7 187 // (a) Reading commands:
mbedalvaro 1:a4050fee11f7 188 // Ethernet:
mbedalvaro 1:a4050fee11f7 189 Net::poll(); // this will take care of calling processOSC(UDPSocketEvent e) when a new packet arrives.
mbedalvaro 1:a4050fee11f7 190
mbedalvaro 1:a4050fee11f7 191 // Serial:
mbedalvaro 1:a4050fee11f7 192 #ifdef SERIAL_COMMANDS
mbedalvaro 1:a4050fee11f7 193 if (pc.readable()>0) processSerial();
mbedalvaro 1:a4050fee11f7 194 #endif
mbedalvaro 9:3321170d157c 195
mbedalvaro 34:1244fa3f2559 196 // Potentiometer, switches, etc:
mbedalvaro 34:1244fa3f2559 197 //(1) Check for change of threshold mode button (switch one):
mbedalvaro 34:1244fa3f2559 198 //!!! ATTENTION: this does not work very well to say the truth: bouncing+adc settings problems...
mbedalvaro 34:1244fa3f2559 199 bool stateswitch;
mbedalvaro 34:1244fa3f2559 200 if (IO.switchOneCheck(stateswitch)) {
mbedalvaro 34:1244fa3f2559 201 if (stateswitch) pc.printf("Setting AUTO threshold mode\n"); else pc.printf("Setting FIXED threshold mode\n");
mbedalvaro 34:1244fa3f2559 202 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setThresholdMode((stateswitch? 1 : 0));
mbedalvaro 34:1244fa3f2559 203 }
mbedalvaro 34:1244fa3f2559 204 //(2) in case the threshold mode is set to fixed, check the current pot value and update the threshold when pressing second switch:
mbedalvaro 34:1244fa3f2559 205 if ((blobconf.blobArray[0]->displaySensingBuffer.modeThreshold==FIXED)&&(IO.switchTwoCheck(stateswitch))) {
mbedalvaro 34:1244fa3f2559 206 IO.updatePotValue();
mbedalvaro 34:1244fa3f2559 207 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setFixedThreshold(IO.potValue);
mbedalvaro 34:1244fa3f2559 208 pc.printf("Got :%d\n", IO.potValue);
mbedalvaro 34:1244fa3f2559 209 }
mbedalvaro 34:1244fa3f2559 210
mbedalvaro 9:3321170d157c 211
mbedalvaro 1:a4050fee11f7 212 // text:
mbedalvaro 1:a4050fee11f7 213 /*
mbedalvaro 1:a4050fee11f7 214 sendMes.setTopAddress("/hello");
mbedalvaro 1:a4050fee11f7 215 sendMes.setSubAddress("/daito"); // ATTENTION: the host computer needs to know in advance how many points are in the loop (I did not implement "bundle" messages yet...)
mbedalvaro 1:a4050fee11f7 216 int x=(long)10;
mbedalvaro 1:a4050fee11f7 217 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 218 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 219 */
mbedalvaro 1:a4050fee11f7 220
mbedalvaro 0:345b3bc7a0ea 221 #ifdef LOOPTIMECOMPUTE
mbedalvaro 9:3321170d157c 222 if (timeCounterNum>50) myled = 0;
mbedalvaro 9:3321170d157c 223 // if (timeCounterNum%10==0) blobconf.sendConfData();
mbedalvaro 9:3321170d157c 224 if (timeCounterNum>100) {
mbedalvaro 1:a4050fee11f7 225 myled = 1;
mbedalvaro 1:a4050fee11f7 226 measureLoopPeriod.stop();
mbedalvaro 1:a4050fee11f7 227 sendMes.setTopAddress("/timeloop");
mbedalvaro 1:a4050fee11f7 228 sendMes.setSubAddress("/");
mbedalvaro 10:6f8e48dca1bd 229 // long x=(long)(int(measureLoopPeriod.read_us()/100.0));
mbedalvaro 9:3321170d157c 230 // long x=(long)(blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory.size());
mbedalvaro 9:3321170d157c 231 // long x=(long)(blobconf.blobArray[0]->normRecenteringVector);
mbedalvaro 10:6f8e48dca1bd 232 long x=(long)(1000*blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory[0].intensity);
mbedalvaro 1:a4050fee11f7 233 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 234 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 235 timeCounterNum=0;
mbedalvaro 1:a4050fee11f7 236 measureLoopPeriod.reset();
mbedalvaro 1:a4050fee11f7 237 measureLoopPeriod.start();
mbedalvaro 1:a4050fee11f7 238 } else timeCounterNum++;
mbedalvaro 0:345b3bc7a0ea 239 #endif
mbedalvaro 0:345b3bc7a0ea 240
mbedalvaro 0:345b3bc7a0ea 241 }
mbedalvaro 0:345b3bc7a0ea 242 }
mbedalvaro 0:345b3bc7a0ea 243
mbedalvaro 1:a4050fee11f7 244 // ================= INTERPRET COMMAND =========================
mbedalvaro 0:345b3bc7a0ea 245 // NOTE: the following arrays are GLOBAL (used in processOSC and processSerial, as well as in interpretCommand function):
mbedalvaro 1:a4050fee11f7 246 // max of two addresses (top and sub), of a max length of 24 characters:
mbedalvaro 0:345b3bc7a0ea 247 char address[2][24];
mbedalvaro 0:345b3bc7a0ea 248 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 249 int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 250
mbedalvaro 1:a4050fee11f7 251 //interpretCommand(const char& address[2][], const int& data[2]) {
mbedalvaro 0:345b3bc7a0ea 252 void interpretCommand() {
mbedalvaro 0:345b3bc7a0ea 253 // (I) =========================================== SPECIAL FUNCTIONS (reset, rescan LUT, etc) ====================================================
mbedalvaro 16:2ff1cb2ae1b1 254 if ( !strcmp(address[0], "takeSnapshot" ) ) {
mbedalvaro 24:4e52031a495b 255 int value=data[0];
mbedalvaro 24:4e52031a495b 256 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 257
mbedalvaro 1:a4050fee11f7 258 // for test:
mbedalvaro 1:a4050fee11f7 259 for (int i=0; i<2 ; i++) {
mbedalvaro 1:a4050fee11f7 260 myled = 1;
mbedalvaro 1:a4050fee11f7 261 wait(0.1);
mbedalvaro 1:a4050fee11f7 262 myled = 0;
mbedalvaro 1:a4050fee11f7 263 wait(0.1);
mbedalvaro 1:a4050fee11f7 264 }
mbedalvaro 1:a4050fee11f7 265
mbedalvaro 1:a4050fee11f7 266 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 267 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 268
mbedalvaro 24:4e52031a495b 269 // Then, do the scan (sending values on SERIAL port):
mbedalvaro 24:4e52031a495b 270 IO.scan_serial(value);
mbedalvaro 1:a4050fee11f7 271
mbedalvaro 1:a4050fee11f7 272 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 273 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 274 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 24:4e52031a495b 275
mbedalvaro 24:4e52031a495b 276 }
mbedalvaro 1:a4050fee11f7 277 }
mbedalvaro 1:a4050fee11f7 278
mbedalvaro 1:a4050fee11f7 279 else if ( !strcmp(address[0], "mbedReset" ) ) mbed_reset();
mbedalvaro 22:d87317d7ca91 280
mbedalvaro 22:d87317d7ca91 281 else if (!strcmp(address[0], "showMirrorLimits")) {
mbedalvaro 22:d87317d7ca91 282 int value=data[0];
mbedalvaro 22:d87317d7ca91 283 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 22:d87317d7ca91 284 timerForRendering.detach();
mbedalvaro 24:4e52031a495b 285 IO.showLimitsMirrors(value);
mbedalvaro 22:d87317d7ca91 286 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 24:4e52031a495b 287 }
mbedalvaro 22:d87317d7ca91 288 }
mbedalvaro 1:a4050fee11f7 289
mbedalvaro 1:a4050fee11f7 290 else if ( !strcmp(address[0], "calibrate" ) ) {
mbedalvaro 1:a4050fee11f7 291 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 292 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 293 // RESCAN (and save LUT table):
mbedalvaro 1:a4050fee11f7 294 IO.scanLUT();
mbedalvaro 1:a4050fee11f7 295 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 296 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 297 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 298 }
mbedalvaro 1:a4050fee11f7 299
mbedalvaro 1:a4050fee11f7 300 // (II) ========================================= GLOBAL CONFIG and HARDWARE COMMANDS ===========================================
mbedalvaro 1:a4050fee11f7 301
mbedalvaro 32:52273c3291fe 302 else if ( !strcmp(address[0], "setAllColor" ) ) {
mbedalvaro 32:52273c3291fe 303 int value=data[0]; // this is the color (RGB bits)
mbedalvaro 32:52273c3291fe 304 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 305 blobconf.allSetColor(value);
mbedalvaro 32:52273c3291fe 306 }
mbedalvaro 32:52273c3291fe 307 }
mbedalvaro 33:43e8bc451ef0 308
mbedalvaro 33:43e8bc451ef0 309 else if ( !strcmp(address[0], "setAllRandomColor" ) ) {
mbedalvaro 33:43e8bc451ef0 310 blobconf.randomizeAllColors();
mbedalvaro 33:43e8bc451ef0 311 }
mbedalvaro 32:52273c3291fe 312
mbedalvaro 32:52273c3291fe 313 else if ( !strcmp(address[0], "setAllGreenColor" ) ) {
mbedalvaro 1:a4050fee11f7 314 int value=data[0];
mbedalvaro 1:a4050fee11f7 315 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 25:74cb85b85fd2 316 if (value==0)
mbedalvaro 32:52273c3291fe 317 blobconf.allSetGreen(1);
mbedalvaro 25:74cb85b85fd2 318 else
mbedalvaro 32:52273c3291fe 319 blobconf.allSetGreen(0);
mbedalvaro 1:a4050fee11f7 320 }
mbedalvaro 1:a4050fee11f7 321 }
mbedalvaro 23:bf666fcc61bc 322
mbedalvaro 32:52273c3291fe 323 else if ( !strcmp(address[0], "setAllBlueColor" ) ) {
mbedalvaro 32:52273c3291fe 324 int value=data[0];
mbedalvaro 32:52273c3291fe 325 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 326 if (value==0)
mbedalvaro 32:52273c3291fe 327 blobconf.allSetBlue(1);
mbedalvaro 32:52273c3291fe 328 else
mbedalvaro 32:52273c3291fe 329 blobconf.allSetBlue(0);
mbedalvaro 32:52273c3291fe 330 }
mbedalvaro 32:52273c3291fe 331 }
mbedalvaro 32:52273c3291fe 332
mbedalvaro 32:52273c3291fe 333 // NOTE: RED either afect the lock in, or some other red laser... not yet done.
mbedalvaro 32:52273c3291fe 334
mbedalvaro 23:bf666fcc61bc 335 else if ( !strcmp(address[0], "testPower" ) ) {
mbedalvaro 23:bf666fcc61bc 336 // First, we need to disable the threaded display for the loop:
mbedalvaro 23:bf666fcc61bc 337 timerForRendering.detach();
mbedalvaro 23:bf666fcc61bc 338
mbedalvaro 23:bf666fcc61bc 339 // Note: arguments is first 3 bits to set the laser powers (3 LSB bits to set each color)
mbedalvaro 23:bf666fcc61bc 340 // and then the second argument is the number of seconds to wait for the measurment
mbedalvaro 23:bf666fcc61bc 341 int value1=data[0], value2=data[1];
mbedalvaro 23:bf666fcc61bc 342 if ((value1!=-1)&&(value2!=-1)) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 23:bf666fcc61bc 343
mbedalvaro 23:bf666fcc61bc 344 // Set position of mirrors:
mbedalvaro 23:bf666fcc61bc 345 IO.writeOutX(CENTER_AD_MIRROR_X);
mbedalvaro 23:bf666fcc61bc 346 IO.writeOutY(CENTER_AD_MIRROR_Y);
mbedalvaro 23:bf666fcc61bc 347
mbedalvaro 23:bf666fcc61bc 348 for (int i=0; i<3 ; i++) {
mbedalvaro 23:bf666fcc61bc 349 myled3 = 1;
mbedalvaro 23:bf666fcc61bc 350 wait(0.2);
mbedalvaro 23:bf666fcc61bc 351 myled3 = 0;
mbedalvaro 23:bf666fcc61bc 352 wait(0.2);
mbedalvaro 23:bf666fcc61bc 353 }
mbedalvaro 23:bf666fcc61bc 354
mbedalvaro 23:bf666fcc61bc 355 // Set laser power:
mbedalvaro 23:bf666fcc61bc 356 IO.setRGBPower((unsigned char)value1);
mbedalvaro 23:bf666fcc61bc 357
mbedalvaro 23:bf666fcc61bc 358 // Wait...
mbedalvaro 23:bf666fcc61bc 359 wait(value2);// in seconds
mbedalvaro 23:bf666fcc61bc 360 //Timer t;
mbedalvaro 23:bf666fcc61bc 361 //t.start();
mbedalvaro 23:bf666fcc61bc 362 //while(t.read_ms()<value2*1000);
mbedalvaro 23:bf666fcc61bc 363 //t.stop();
mbedalvaro 23:bf666fcc61bc 364 }
mbedalvaro 23:bf666fcc61bc 365
mbedalvaro 23:bf666fcc61bc 366 // Finally, start again threaded display:
mbedalvaro 23:bf666fcc61bc 367 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 23:bf666fcc61bc 368
mbedalvaro 23:bf666fcc61bc 369 }
mbedalvaro 23:bf666fcc61bc 370
mbedalvaro 23:bf666fcc61bc 371
mbedalvaro 1:a4050fee11f7 372
mbedalvaro 1:a4050fee11f7 373 // SIMPLE BEHAVIOUR MODES (to be read from an XML file in the future):
mbedalvaro 11:62f7183a03e7 374 else if (!strcmp(address[0], "elastic_following")) { //
mbedalvaro 1:a4050fee11f7 375 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 376
mbedalvaro 30:d8af03f01cd4 377 blobconf.initConfig(ONE_ELASTIC_FOLLOWING);
mbedalvaro 30:d8af03f01cd4 378
mbedalvaro 1:a4050fee11f7 379 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 380 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 381 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 382
mbedalvaro 11:62f7183a03e7 383 } else if (!strcmp(address[0], "elastic_mouth")) { //
mbedalvaro 1:a4050fee11f7 384 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 385
mbedalvaro 30:d8af03f01cd4 386 blobconf.initConfig(ONE_ELASTIC_MOUTH);
mbedalvaro 30:d8af03f01cd4 387
mbedalvaro 1:a4050fee11f7 388 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 389 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 390 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 19:228430f1350e 391
mbedalvaro 19:228430f1350e 392 } else if (!strcmp(address[0], "elastic_mouth_small")) { //
mbedalvaro 19:228430f1350e 393 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 394
mbedalvaro 30:d8af03f01cd4 395 blobconf.initConfig(ONE_ELASTIC_MOUTH_SMALL);
mbedalvaro 30:d8af03f01cd4 396
mbedalvaro 19:228430f1350e 397 lsr.setConfigToRender(&blobconf);
mbedalvaro 19:228430f1350e 398 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 19:228430f1350e 399 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 400 }
mbedalvaro 11:62f7183a03e7 401 else if (!strcmp(address[0], "spot_bouncing")) {
mbedalvaro 16:2ff1cb2ae1b1 402 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 403 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 404 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 405
mbedalvaro 30:d8af03f01cd4 406 blobconf.initConfig(BOUNCING_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 16:2ff1cb2ae1b1 407
mbedalvaro 16:2ff1cb2ae1b1 408 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 409 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 410 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 411 }
mbedalvaro 16:2ff1cb2ae1b1 412 }
mbedalvaro 16:2ff1cb2ae1b1 413
mbedalvaro 30:d8af03f01cd4 414 else if (!strcmp(address[0], "spot_lorentz")) {
mbedalvaro 27:1ce994629ffc 415 int value=data[0];
mbedalvaro 27:1ce994629ffc 416 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 27:1ce994629ffc 417 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 418
mbedalvaro 30:d8af03f01cd4 419 blobconf.initConfig(LORENTZ_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 27:1ce994629ffc 420
mbedalvaro 27:1ce994629ffc 421 lsr.setConfigToRender(&blobconf);
mbedalvaro 27:1ce994629ffc 422 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 423 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 424 }
mbedalvaro 27:1ce994629ffc 425 }
mbedalvaro 28:44b7b6e35548 426
mbedalvaro 28:44b7b6e35548 427 else if (!strcmp(address[0], "air_hockey")) {
mbedalvaro 28:44b7b6e35548 428 int value=data[0];
mbedalvaro 28:44b7b6e35548 429 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 28:44b7b6e35548 430 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 431
mbedalvaro 30:d8af03f01cd4 432 blobconf.initConfig(AIR_HOCKEY_GAME, value); // value is the nb of spots instantiated
mbedalvaro 28:44b7b6e35548 433
mbedalvaro 28:44b7b6e35548 434 lsr.setConfigToRender(&blobconf);
mbedalvaro 28:44b7b6e35548 435 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 436 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 437 }
mbedalvaro 28:44b7b6e35548 438 }
mbedalvaro 32:52273c3291fe 439
mbedalvaro 32:52273c3291fe 440 else if (!strcmp(address[0], "rain_mode")) {
mbedalvaro 32:52273c3291fe 441 int value=data[0];
mbedalvaro 32:52273c3291fe 442 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 443 timerForRendering.detach();
mbedalvaro 32:52273c3291fe 444
mbedalvaro 32:52273c3291fe 445 blobconf.initConfig(RAIN_MODE, value); // value is the nb of spots instantiated
mbedalvaro 32:52273c3291fe 446
mbedalvaro 32:52273c3291fe 447 lsr.setConfigToRender(&blobconf);
mbedalvaro 32:52273c3291fe 448 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 32:52273c3291fe 449 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 32:52273c3291fe 450 }
mbedalvaro 32:52273c3291fe 451 }
mbedalvaro 32:52273c3291fe 452
mbedalvaro 28:44b7b6e35548 453
mbedalvaro 28:44b7b6e35548 454 else if (!strcmp(address[0], "spot_following")) {
mbedalvaro 16:2ff1cb2ae1b1 455 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 456 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 457
mbedalvaro 16:2ff1cb2ae1b1 458 timerForRendering.detach();
mbedalvaro 22:d87317d7ca91 459
mbedalvaro 30:d8af03f01cd4 460 blobconf.initConfig(FOLLOWING_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 22:d87317d7ca91 461
mbedalvaro 16:2ff1cb2ae1b1 462 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 463 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 464 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 465 }
mbedalvaro 16:2ff1cb2ae1b1 466 }
mbedalvaro 16:2ff1cb2ae1b1 467
mbedalvaro 30:d8af03f01cd4 468 else if (!strcmp(address[0], "circular_pong")) {
mbedalvaro 30:d8af03f01cd4 469 int value=data[0];
mbedalvaro 30:d8af03f01cd4 470 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 30:d8af03f01cd4 471
mbedalvaro 30:d8af03f01cd4 472 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 473
mbedalvaro 30:d8af03f01cd4 474 blobconf.initConfig(CIRCULAR_PONG_GAME, value); // value is the nb of spots instantiated
mbedalvaro 30:d8af03f01cd4 475
mbedalvaro 30:d8af03f01cd4 476 lsr.setConfigToRender(&blobconf);
mbedalvaro 30:d8af03f01cd4 477 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 478 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 479 }
mbedalvaro 30:d8af03f01cd4 480 }
mbedalvaro 31:5f039cbddee8 481
mbedalvaro 31:5f039cbddee8 482 else if (!strcmp(address[0], "fish_net")) {
mbedalvaro 30:d8af03f01cd4 483 int value=data[0];
mbedalvaro 30:d8af03f01cd4 484 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 30:d8af03f01cd4 485
mbedalvaro 30:d8af03f01cd4 486 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 487
mbedalvaro 31:5f039cbddee8 488 blobconf.initConfig(FISH_NET_GAME, value); // value is the nb of spots instantiated
mbedalvaro 31:5f039cbddee8 489
mbedalvaro 31:5f039cbddee8 490 lsr.setConfigToRender(&blobconf);
mbedalvaro 31:5f039cbddee8 491 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 492 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 493 }
mbedalvaro 31:5f039cbddee8 494 }
mbedalvaro 31:5f039cbddee8 495
mbedalvaro 31:5f039cbddee8 496
mbedalvaro 31:5f039cbddee8 497 else if (!strcmp(address[0], "vertical_pinball")) {
mbedalvaro 31:5f039cbddee8 498 int value=data[0];
mbedalvaro 31:5f039cbddee8 499 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 31:5f039cbddee8 500
mbedalvaro 31:5f039cbddee8 501 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 502
mbedalvaro 31:5f039cbddee8 503 blobconf.initConfig(VERTICAL_PINBALL_GAME, value);
mbedalvaro 31:5f039cbddee8 504
mbedalvaro 31:5f039cbddee8 505 lsr.setConfigToRender(&blobconf);
mbedalvaro 31:5f039cbddee8 506 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 507 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 508 }
mbedalvaro 31:5f039cbddee8 509 }
mbedalvaro 31:5f039cbddee8 510
mbedalvaro 31:5f039cbddee8 511 else if (!strcmp(address[0], "pac_man")) {
mbedalvaro 31:5f039cbddee8 512 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 513
mbedalvaro 30:d8af03f01cd4 514 blobconf.initConfig(PAC_MAN_GAME);
mbedalvaro 30:d8af03f01cd4 515
mbedalvaro 30:d8af03f01cd4 516 lsr.setConfigToRender(&blobconf);
mbedalvaro 30:d8af03f01cd4 517 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 518 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 519 }
mbedalvaro 30:d8af03f01cd4 520
mbedalvaro 31:5f039cbddee8 521 else if (!strcmp(address[0], "spot_tracking")) {
mbedalvaro 31:5f039cbddee8 522 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 523
mbedalvaro 31:5f039cbddee8 524 blobconf.initConfig(ONE_TRACKING_SPOT); // value is the nb of spots instantiated
mbedalvaro 31:5f039cbddee8 525
mbedalvaro 31:5f039cbddee8 526 lsr.setConfigToRender(&blobconf);
mbedalvaro 31:5f039cbddee8 527 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 528 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 529 }
mbedalvaro 30:d8af03f01cd4 530
mbedalvaro 16:2ff1cb2ae1b1 531 else if (!strcmp(address[0], "spot_test")) {
mbedalvaro 0:345b3bc7a0ea 532 timerForRendering.detach();
mbedalvaro 0:345b3bc7a0ea 533 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 534 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 535 blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 536 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 537 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 538 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 539 }
mbedalvaro 1:a4050fee11f7 540
mbedalvaro 1:a4050fee11f7 541 // other:
mbedalvaro 1:a4050fee11f7 542
mbedalvaro 24:4e52031a495b 543 else if ( !strcmp(address[0], "standby" ) ) { // will put ALL the blobs in stand by mode (no update function)
mbedalvaro 0:345b3bc7a0ea 544 blobconf.allStandBy(); // will avoid the update function
mbedalvaro 24:4e52031a495b 545 }
mbedalvaro 24:4e52031a495b 546 else if ( !strcmp(address[0], "resume" ) ) {
mbedalvaro 24:4e52031a495b 547 blobconf.allResume(); // Update function is called for all the blobs
mbedalvaro 1:a4050fee11f7 548 }
mbedalvaro 1:a4050fee11f7 549
mbedalvaro 1:a4050fee11f7 550 // (III) ========================================= Loop control (parameters, etc) ===========================================
mbedalvaro 19:228430f1350e 551
mbedalvaro 33:43e8bc451ef0 552 else if (!strcmp( address[0], "setSpeed" ) ) {
mbedalvaro 33:43e8bc451ef0 553 int value=data[0]; // value 1 means a speed of 0.1, value 10, a speed of 1, etc.
mbedalvaro 33:43e8bc451ef0 554 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 555 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 33:43e8bc451ef0 556 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 33:43e8bc451ef0 557 blobconf.blobArray[i]->setSpeed((float)(0.1*value));
mbedalvaro 33:43e8bc451ef0 558 }
mbedalvaro 33:43e8bc451ef0 559 }
mbedalvaro 33:43e8bc451ef0 560 }
mbedalvaro 24:4e52031a495b 561 else if (!strcmp( address[0], "speedFactor" ) ) {
mbedalvaro 24:4e52031a495b 562 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 563 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 564 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 24:4e52031a495b 565 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 24:4e52031a495b 566 blobconf.blobArray[i]->speedFactor((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 567 }
mbedalvaro 24:4e52031a495b 568 }
mbedalvaro 24:4e52031a495b 569 }
mbedalvaro 24:4e52031a495b 570
mbedalvaro 33:43e8bc451ef0 571 else if (!strcmp( address[0], "setSize" ) ) {
mbedalvaro 33:43e8bc451ef0 572 int value=data[0]; // this is the direct size of the scafold
mbedalvaro 32:52273c3291fe 573 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 574 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->setSize((float)(1.0*value));
mbedalvaro 32:52273c3291fe 575 }
mbedalvaro 32:52273c3291fe 576 }
mbedalvaro 33:43e8bc451ef0 577 else if (!strcmp( address[0], "sizeFactor" ) ) {
mbedalvaro 33:43e8bc451ef0 578 int value=data[0]; // value 100 means no change of sice. 200 is twice as big, 50 is half as big.
mbedalvaro 33:43e8bc451ef0 579 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 580 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->sizeFactor((float)(1.0*value/100.0));
mbedalvaro 33:43e8bc451ef0 581 }
mbedalvaro 33:43e8bc451ef0 582 }
mbedalvaro 33:43e8bc451ef0 583
mbedalvaro 32:52273c3291fe 584 // ADJUST MIRROR ANGLE CORRECTION:
mbedalvaro 32:52273c3291fe 585 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 32:52273c3291fe 586 int value=data[0]; // this is not a factor, but an additive quantity to the current delay
mbedalvaro 32:52273c3291fe 587 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 588 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 32:52273c3291fe 589 }
mbedalvaro 32:52273c3291fe 590 }
mbedalvaro 32:52273c3291fe 591 else if (!strcmp( address[0], "adjustMinusAngle" ) ) {
mbedalvaro 32:52273c3291fe 592 int value=data[0]; // this is not a factor, but an substractive quantity to the current delay
mbedalvaro 32:52273c3291fe 593 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 594 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(-value);
mbedalvaro 32:52273c3291fe 595 }
mbedalvaro 32:52273c3291fe 596 }
mbedalvaro 32:52273c3291fe 597
mbedalvaro 24:4e52031a495b 598 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 24:4e52031a495b 599 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 600 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 601 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 24:4e52031a495b 602 }
mbedalvaro 24:4e52031a495b 603 }
mbedalvaro 24:4e52031a495b 604
mbedalvaro 33:43e8bc451ef0 605
mbedalvaro 33:43e8bc451ef0 606 // THRESHOLD MODE, and PARAMETERS:
mbedalvaro 34:1244fa3f2559 607 //(1) Set the threshold mode:
mbedalvaro 33:43e8bc451ef0 608 else if (!strcmp( address[0], "autoThreshold" ) ) {
mbedalvaro 34:1244fa3f2559 609 int value=data[0]; // 1 (auto) or 0 (fixed)
mbedalvaro 33:43e8bc451ef0 610 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 611 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setThresholdMode(value);
mbedalvaro 33:43e8bc451ef0 612 }
mbedalvaro 33:43e8bc451ef0 613 }
mbedalvaro 33:43e8bc451ef0 614
mbedalvaro 33:43e8bc451ef0 615 // (a) AUTO THRESHOLD:
mbedalvaro 33:43e8bc451ef0 616 // MINIMUM CONTRAST RATIO:
mbedalvaro 33:43e8bc451ef0 617 // (1) using multiplicative factor:
mbedalvaro 32:52273c3291fe 618 else if (!strcmp( address[0], "adjustMultContrast" ) ) {
mbedalvaro 32:52273c3291fe 619 int value=data[0]; // value 100 means no change of the current contrast value. 200 means a min contrast
mbedalvaro 32:52273c3291fe 620 // that is twice as large and 50 is half as large as before.
mbedalvaro 24:4e52031a495b 621 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 622 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.multMinContrastRatio((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 623 }
mbedalvaro 32:52273c3291fe 624 }
mbedalvaro 32:52273c3291fe 625 // (2) directly:
mbedalvaro 32:52273c3291fe 626 else if (!strcmp( address[0], "adjustContrast" ) ) {
mbedalvaro 32:52273c3291fe 627 int value=data[0]; // value is in PERCENT (100=1, 50 = 0.5...)
mbedalvaro 32:52273c3291fe 628 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 629 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setMinContrastRatio((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 630 }
mbedalvaro 24:4e52031a495b 631 }
mbedalvaro 34:1244fa3f2559 632 // THRESHOLD FACTOR:
mbedalvaro 32:52273c3291fe 633 //(1) using multiplicative factor:
mbedalvaro 32:52273c3291fe 634 else if (!strcmp( address[0], "adjustMultThreshold" ) ) {
mbedalvaro 32:52273c3291fe 635 int value=data[0]; // value 100 means no change of the current contrast value. 200 means a min contrast
mbedalvaro 32:52273c3291fe 636 // that is twice as large and 50 is half as large as before.
mbedalvaro 32:52273c3291fe 637 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 638 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.multThresholdFactor((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 639 }
mbedalvaro 32:52273c3291fe 640 }
mbedalvaro 32:52273c3291fe 641 //(2) directly:
mbedalvaro 32:52273c3291fe 642 else if (!strcmp( address[0], "adjustThresholdFactor" ) ) {
mbedalvaro 32:52273c3291fe 643 int value=data[0]; // value is in PERCENT (100=1, 50 = 0.5...)
mbedalvaro 32:52273c3291fe 644 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 645 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setThresholdFactor((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 646 }
mbedalvaro 32:52273c3291fe 647 }
mbedalvaro 33:43e8bc451ef0 648 // MINIMUM ACCEPTABLE INTENSITY:
mbedalvaro 32:52273c3291fe 649 // Adjust minimum acceptable intensity:
mbedalvaro 32:52273c3291fe 650 else if (!strcmp( address[0], "adjustMinAcceptableIntensity" ) ) {
mbedalvaro 32:52273c3291fe 651 int value=data[0]; // value is DIRECT value (0 to 255)
mbedalvaro 32:52273c3291fe 652 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 653 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setMinAcceptableIntensity(value);
mbedalvaro 32:52273c3291fe 654 }
mbedalvaro 32:52273c3291fe 655 }
mbedalvaro 32:52273c3291fe 656
mbedalvaro 33:43e8bc451ef0 657 // (b) FIXED THRESHOLD:
mbedalvaro 33:43e8bc451ef0 658 // Adjust fixedThreshold (directly):
mbedalvaro 33:43e8bc451ef0 659 else if (!strcmp( address[0], "adjustFixedThreshold" ) ) {
mbedalvaro 33:43e8bc451ef0 660 int value=data[0]; // value is DIRECT value (0 to 255)
mbedalvaro 33:43e8bc451ef0 661 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 662 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setFixedThreshold(value);
mbedalvaro 33:43e8bc451ef0 663 }
mbedalvaro 33:43e8bc451ef0 664 }
mbedalvaro 33:43e8bc451ef0 665
mbedalvaro 33:43e8bc451ef0 666
mbedalvaro 33:43e8bc451ef0 667
mbedalvaro 32:52273c3291fe 668 // ===================== SEND DATA MODES =======================
mbedalvaro 24:4e52031a495b 669
mbedalvaro 1:a4050fee11f7 670 else if (!strcmp( address[0], "sendOSC" ) ) {
mbedalvaro 1:a4050fee11f7 671 int value=data[0];
mbedalvaro 1:a4050fee11f7 672 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 673 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 674 blobconf.blobArray[i]->sendOSC=(value>0);
mbedalvaro 1:a4050fee11f7 675 }
mbedalvaro 1:a4050fee11f7 676 }
mbedalvaro 1:a4050fee11f7 677 }
mbedalvaro 1:a4050fee11f7 678
mbedalvaro 1:a4050fee11f7 679 else if (!strcmp( address[0], "sendArea" ) ) {
mbedalvaro 1:a4050fee11f7 680 int value=data[0];
mbedalvaro 1:a4050fee11f7 681 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 682 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 683 blobconf.blobArray[i]->sendingBlobArea=(value>0);
mbedalvaro 1:a4050fee11f7 684 }
mbedalvaro 1:a4050fee11f7 685 }
mbedalvaro 1:a4050fee11f7 686 }
mbedalvaro 1:a4050fee11f7 687
mbedalvaro 1:a4050fee11f7 688 else if (!strcmp( address[0], "sendPos" ) ) {
mbedalvaro 1:a4050fee11f7 689 int value=data[0];
mbedalvaro 1:a4050fee11f7 690 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 691 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 692 blobconf.blobArray[i]->sendingLoopPositions=(value>0);
mbedalvaro 1:a4050fee11f7 693 }
mbedalvaro 1:a4050fee11f7 694 }
mbedalvaro 1:a4050fee11f7 695 }
mbedalvaro 1:a4050fee11f7 696
mbedalvaro 1:a4050fee11f7 697 else if (!strcmp( address[0], "sendRegions" ) ) {
mbedalvaro 1:a4050fee11f7 698 int value=data[0];
mbedalvaro 1:a4050fee11f7 699 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 700 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 701 blobconf.blobArray[i]->sendingLoopRegions=(value>0);
mbedalvaro 1:a4050fee11f7 702 }
mbedalvaro 1:a4050fee11f7 703 }
mbedalvaro 1:a4050fee11f7 704 }
mbedalvaro 1:a4050fee11f7 705
mbedalvaro 1:a4050fee11f7 706 else if (!strcmp( address[0], "sendTouched" ) ) {
mbedalvaro 1:a4050fee11f7 707 int value=data[0];
mbedalvaro 1:a4050fee11f7 708 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 709 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 710 blobconf.blobArray[i]->sendingTouched=(value>0);
mbedalvaro 1:a4050fee11f7 711 }
mbedalvaro 1:a4050fee11f7 712 }
mbedalvaro 1:a4050fee11f7 713 }
mbedalvaro 1:a4050fee11f7 714
mbedalvaro 1:a4050fee11f7 715
mbedalvaro 1:a4050fee11f7 716
mbedalvaro 0:345b3bc7a0ea 717 }
mbedalvaro 0:345b3bc7a0ea 718
mbedalvaro 0:345b3bc7a0ea 719 //============= RECEIVE OSC COMMANDS =========================
mbedalvaro 1:a4050fee11f7 720 // This is the callback function called when there are packets on the listening socket. It is not nice to have it
mbedalvaro 1:a4050fee11f7 721 // here, but for the time being having a "wrapping global" is the simplest solution (we cannot pass a member-function pointer
mbedalvaro 1:a4050fee11f7 722 // as handler to the upd object).
mbedalvaro 0:345b3bc7a0ea 723 void processOSC(UDPSocketEvent e) {
mbedalvaro 0:345b3bc7a0ea 724 osc.onUDPSocketEvent(e);
mbedalvaro 0:345b3bc7a0ea 725
mbedalvaro 0:345b3bc7a0ea 726 if (osc.newMessage) {
mbedalvaro 1:a4050fee11f7 727 // in fact, there is no need to check this if using the method of a global callback function - it is clear this is a new packet... however, it may be
mbedalvaro 1:a4050fee11f7 728 // interesting to use a timer, and process data (answers, etc) only after a certain amount of time, so as to avoid blocking the program in IRQ context...
mbedalvaro 1:a4050fee11f7 729
mbedalvaro 1:a4050fee11f7 730 // Acquire the addresses and arguments and put them in the GLOBAL variables:
mbedalvaro 1:a4050fee11f7 731 strcpy(address[0],"");
mbedalvaro 1:a4050fee11f7 732 strcpy(address[1],"");
mbedalvaro 1:a4050fee11f7 733 for (int i=0; i<recMes.getAddressNum(); i++) strcpy(address[i],recMes.getAddress(i)); // NOTE: up to the rest of the program to check if address[1] is really not null
mbedalvaro 1:a4050fee11f7 734 // Acquire data:
mbedalvaro 1:a4050fee11f7 735 data[0]=-1;
mbedalvaro 1:a4050fee11f7 736 data[1]=-1;
mbedalvaro 1:a4050fee11f7 737 for (int i=0; i<recMes.getArgNum(); i++) data[i]=(int)recMes.getArgInt(i);
mbedalvaro 1:a4050fee11f7 738
mbedalvaro 1:a4050fee11f7 739 // Finally, interpret the command:
mbedalvaro 1:a4050fee11f7 740 interpretCommand();//address, data);
mbedalvaro 1:a4050fee11f7 741
mbedalvaro 0:345b3bc7a0ea 742 }
mbedalvaro 1:a4050fee11f7 743 }
mbedalvaro 1:a4050fee11f7 744
mbedalvaro 0:345b3bc7a0ea 745 //============= RECEIVE SERIAL COMMANDS =========================
mbedalvaro 0:345b3bc7a0ea 746 //
mbedalvaro 1:a4050fee11f7 747 // NOTE: - NUMERIC PARAMETERS have to be send BEFORE the command word. They must be sent as ASCII DEC, without end character.
mbedalvaro 0:345b3bc7a0ea 748 // - Commands words SHOULD NOT have numbers in it. They should be C compliant STRINGS (ended with character '0')
mbedalvaro 1:a4050fee11f7 749 // - order is irrelevant: we can send 10 RADIUS or RADIUS 10.
mbedalvaro 0:345b3bc7a0ea 750
mbedalvaro 1:a4050fee11f7 751 // String to store ALPHANUMERIC DATA (i.e., integers, floating point numbers, unsigned ints, etc represented as DEC) sent wirelessly:
mbedalvaro 0:345b3bc7a0ea 752 char stringData[24]; // note: an integer is two bytes long, represented with a maximum of 5 digits, but we may send floats or unsigned int...
mbedalvaro 0:345b3bc7a0ea 753 int indexStringData=0;//position of the byte in the string
mbedalvaro 0:345b3bc7a0ea 754
mbedalvaro 0:345b3bc7a0ea 755 // String to store COMMAND WORDS:
mbedalvaro 0:345b3bc7a0ea 756 char stringCommand[24]; // note: an integer is two bytes long, represented with a maximum of 5 digits, but we may send floats or unsigned int...
mbedalvaro 0:345b3bc7a0ea 757 int indexStringCommand=0;
mbedalvaro 0:345b3bc7a0ea 758 bool commandReady=false; // will become true when receiving the byte 0 (i.e. the '/0' string terminator)
mbedalvaro 0:345b3bc7a0ea 759
mbedalvaro 0:345b3bc7a0ea 760 void processSerial() {
mbedalvaro 0:345b3bc7a0ea 761
mbedalvaro 1:a4050fee11f7 762 while (pc.readable()>0) {
mbedalvaro 1:a4050fee11f7 763
mbedalvaro 14:0fc33a3a7b4b 764
mbedalvaro 1:a4050fee11f7 765 char val =pc.getc();
mbedalvaro 0:345b3bc7a0ea 766 // pc.printf("Got :%d\n", incomingByte);
mbedalvaro 1:a4050fee11f7 767 //pc.putc(incomingByte);
mbedalvaro 1:a4050fee11f7 768
mbedalvaro 1:a4050fee11f7 769 // Save ASCII numeric characters (ASCII 0 - 9) on stringData:
mbedalvaro 1:a4050fee11f7 770 if ((val >= '0') && (val <= '9')) { // this is 45 to 57 (included)
mbedalvaro 1:a4050fee11f7 771 stringData[indexStringData] = val;
mbedalvaro 1:a4050fee11f7 772 indexStringData++;
mbedalvaro 1:a4050fee11f7 773 }
mbedalvaro 1:a4050fee11f7 774
mbedalvaro 1:a4050fee11f7 775 // Save ASCII letters in stringCommand:
mbedalvaro 1:a4050fee11f7 776 if ((val >= 'A') && (val <= 'z')) { // this is 65 to 122 (included)
mbedalvaro 1:a4050fee11f7 777 stringCommand[indexStringCommand] = val;
mbedalvaro 1:a4050fee11f7 778 indexStringCommand++;
mbedalvaro 1:a4050fee11f7 779 }
mbedalvaro 1:a4050fee11f7 780 // is command ready?
mbedalvaro 1:a4050fee11f7 781 if (val=='/') {
mbedalvaro 1:a4050fee11f7 782 commandReady=true;
mbedalvaro 1:a4050fee11f7 783 stringCommand[indexStringCommand] = 0; // string termination.
mbedalvaro 1:a4050fee11f7 784 indexStringCommand=0; // reset index string for acquiring next command
mbedalvaro 1:a4050fee11f7 785 //Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 786 }
mbedalvaro 1:a4050fee11f7 787
mbedalvaro 1:a4050fee11f7 788 // COMMANDS (with or without numeric parameters):
mbedalvaro 1:a4050fee11f7 789 if (commandReady==true) { // it means we can interpret the command string:
mbedalvaro 1:a4050fee11f7 790 commandReady=false;
mbedalvaro 1:a4050fee11f7 791
mbedalvaro 1:a4050fee11f7 792 stringData[indexStringData] = 0 ;// string termination for numeric values;
mbedalvaro 1:a4050fee11f7 793 indexStringData=0;
mbedalvaro 1:a4050fee11f7 794
mbedalvaro 1:a4050fee11f7 795 // PARSE DATA: (TO DO!!!!!!!!!!!!!!):
mbedalvaro 0:345b3bc7a0ea 796
mbedalvaro 1:a4050fee11f7 797 // (a) Parse command (get address[0] and address[1]):
mbedalvaro 1:a4050fee11f7 798 //ex: "/1/standBy" -- > address[0]="1" and address[1]="standBy"
mbedalvaro 1:a4050fee11f7 799 // address[2]
mbedalvaro 1:a4050fee11f7 800
mbedalvaro 1:a4050fee11f7 801 // Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 802 // Serial.println(stringData);
mbedalvaro 1:a4050fee11f7 803
mbedalvaro 1:a4050fee11f7 804 // (b) Parse data:
mbedalvaro 1:a4050fee11f7 805
mbedalvaro 1:a4050fee11f7 806 // char address[2][24];
mbedalvaro 1:a4050fee11f7 807 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 808 //int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 809
mbedalvaro 1:a4050fee11f7 810 // FOR THE TIME BEING there is no parsing for serial commands:
mbedalvaro 1:a4050fee11f7 811
mbedalvaro 1:a4050fee11f7 812 // SCANNING:
mbedalvaro 1:a4050fee11f7 813 if (!strcmp(stringCommand , "takeSnapshot")) {
mbedalvaro 1:a4050fee11f7 814 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 815 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 816
mbedalvaro 1:a4050fee11f7 817 // Then, do the scan (sending values on serial port):
mbedalvaro 24:4e52031a495b 818 IO.scan_serial(atoi(stringData));
mbedalvaro 1:a4050fee11f7 819
mbedalvaro 1:a4050fee11f7 820 // Finally, start again threaded display:
mbedalvaro 4:f9d364f10335 821 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 822 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 823 } else if (!strcmp(stringCommand , "REDON")) IO.setRedPower(1); // pc.printf("%d\n",incomingByte);
mbedalvaro 1:a4050fee11f7 824
mbedalvaro 14:0fc33a3a7b4b 825 else if (!strcmp(stringCommand , "REDOFF")) IO.setRedPower(0);
mbedalvaro 14:0fc33a3a7b4b 826
mbedalvaro 14:0fc33a3a7b4b 827 else if (!strcmp(stringCommand , "READVALUE")) pc.printf("Value read: %f", lockin.getSmoothValue());//lockin.getLastValue());/
mbedalvaro 1:a4050fee11f7 828
mbedalvaro 14:0fc33a3a7b4b 829 else if (!strcmp(stringCommand , "mbedReset")) mbed_reset();
mbedalvaro 16:2ff1cb2ae1b1 830
mbedalvaro 14:0fc33a3a7b4b 831 else if (!strcmp(stringCommand , "calibrate")) {
mbedalvaro 16:2ff1cb2ae1b1 832 // First, we need to disable the threaded display for the loop:
mbedalvaro 16:2ff1cb2ae1b1 833 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 834 // RESCAN (and save LUT table):
mbedalvaro 16:2ff1cb2ae1b1 835 IO.scanLUT();
mbedalvaro 16:2ff1cb2ae1b1 836 // Finally, start again threaded display:
mbedalvaro 16:2ff1cb2ae1b1 837 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 838 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 839 }
mbedalvaro 1:a4050fee11f7 840
mbedalvaro 1:a4050fee11f7 841 // FINALLY, interpret commands (but only after parsing):
mbedalvaro 1:a4050fee11f7 842 // interpretCommand();//address, data);
mbedalvaro 0:345b3bc7a0ea 843
mbedalvaro 0:345b3bc7a0ea 844 }
mbedalvaro 1:a4050fee11f7 845 }
mbedalvaro 1:a4050fee11f7 846 }
mbedalvaro 0:345b3bc7a0ea 847
mbedalvaro 0:345b3bc7a0ea 848
mbedalvaro 0:345b3bc7a0ea 849
mbedalvaro 0:345b3bc7a0ea 850 // ================ MISCELANEA
mbedalvaro 0:345b3bc7a0ea 851
mbedalvaro 0:345b3bc7a0ea 852 /* EXAMPLE SEND/RECEIVE on PROCESSING:
mbedalvaro 0:345b3bc7a0ea 853
mbedalvaro 0:345b3bc7a0ea 854 // oscP5sendreceive by andreas schlegel
mbedalvaro 0:345b3bc7a0ea 855 // example shows how to send and receive osc messages.
mbedalvaro 0:345b3bc7a0ea 856 // oscP5 website at http://www.sojamo.de/oscP5
mbedalvaro 0:345b3bc7a0ea 857
mbedalvaro 0:345b3bc7a0ea 858 import oscP5.*;
mbedalvaro 0:345b3bc7a0ea 859 import netP5.*;
mbedalvaro 1:a4050fee11f7 860
mbedalvaro 0:345b3bc7a0ea 861 OscP5 oscP5;
mbedalvaro 0:345b3bc7a0ea 862 NetAddress myRemoteLocation;
mbedalvaro 0:345b3bc7a0ea 863
mbedalvaro 0:345b3bc7a0ea 864 void setup() {
mbedalvaro 0:345b3bc7a0ea 865 size(400,400);
mbedalvaro 0:345b3bc7a0ea 866 frameRate(25);
mbedalvaro 1:a4050fee11f7 867 // start oscP5, listening for incoming messages at port 12000
mbedalvaro 0:345b3bc7a0ea 868 oscP5 = new OscP5(this,12000);
mbedalvaro 1:a4050fee11f7 869
mbedalvaro 0:345b3bc7a0ea 870 // myRemoteLocation is a NetAddress. a NetAddress takes 2 parameters,
mbedalvaro 0:345b3bc7a0ea 871 // an ip address and a port number. myRemoteLocation is used as parameter in
mbedalvaro 1:a4050fee11f7 872 // oscP5.send() when sending osc packets to another computer, device,
mbedalvaro 0:345b3bc7a0ea 873 // application. usage see below. for testing purposes the listening port
mbedalvaro 0:345b3bc7a0ea 874 // and the port of the remote location address are the same, hence you will
mbedalvaro 0:345b3bc7a0ea 875 // send messages back to this sketch.
mbedalvaro 0:345b3bc7a0ea 876 myRemoteLocation = new NetAddress("10.0.0.2",10000);
mbedalvaro 0:345b3bc7a0ea 877 }
mbedalvaro 0:345b3bc7a0ea 878
mbedalvaro 0:345b3bc7a0ea 879
mbedalvaro 0:345b3bc7a0ea 880 void draw() {
mbedalvaro 1:a4050fee11f7 881 background(0);
mbedalvaro 0:345b3bc7a0ea 882 }
mbedalvaro 0:345b3bc7a0ea 883
mbedalvaro 0:345b3bc7a0ea 884 void mousePressed() {
mbedalvaro 1:a4050fee11f7 885 // in the following different ways of creating osc messages are shown by example
mbedalvaro 0:345b3bc7a0ea 886 OscMessage myMessage = new OscMessage("/mbed/test1");
mbedalvaro 1:a4050fee11f7 887
mbedalvaro 1:a4050fee11f7 888 myMessage.add(123); // add an int to the osc message
mbedalvaro 0:345b3bc7a0ea 889
mbedalvaro 1:a4050fee11f7 890 // send the message
mbedalvaro 1:a4050fee11f7 891 oscP5.send(myMessage, myRemoteLocation);
mbedalvaro 0:345b3bc7a0ea 892 }
mbedalvaro 0:345b3bc7a0ea 893
mbedalvaro 0:345b3bc7a0ea 894
mbedalvaro 1:a4050fee11f7 895 // incoming osc message are forwarded to the oscEvent method.
mbedalvaro 0:345b3bc7a0ea 896 void oscEvent(OscMessage theOscMessage) {
mbedalvaro 1:a4050fee11f7 897 // print the address pattern and the typetag of the received OscMessage
mbedalvaro 0:345b3bc7a0ea 898 print("### received an osc message.");
mbedalvaro 0:345b3bc7a0ea 899 print(" addrpattern: "+theOscMessage.addrPattern());
mbedalvaro 0:345b3bc7a0ea 900 println(" typetag: "+theOscMessage.typetag());
mbedalvaro 0:345b3bc7a0ea 901 }
mbedalvaro 0:345b3bc7a0ea 902
mbedalvaro 0:345b3bc7a0ea 903 */