Alvaro Cassinelli / Mbed 2 deprecated skinGames_forktest

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed

Fork of scoreLight_Advanced by Alvaro Cassinelli

main.cpp@37:fa6b1f15819f, 2013-03-13 (annotated)

Committer:
mbedalvaro
Date:
Wed Mar 13 12:29:37 2013 +0000
Revision:
37:fa6b1f15819f
Parent:
36:233b12d0b1f0
Child:
40:ee217eff826c
good version, but THE POTENTIOMETER READOUT IS NOT WORKING (using the adc library - not sure how to go from burst mode to normal mode and viscversa).

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 36:233b12d0b1f0 30 IpAddr(10,0,0,2), //IP Address of the mbed
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 37:fa6b1f15819f 204 //(2) in case the the second switch was pressed, check the current pot value and update the fixed threshold (regardless of the threshold mode)
mbedalvaro 37:fa6b1f15819f 205 if (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 else if (!strcmp(address[0], "vertical_pinball")) {
mbedalvaro 31:5f039cbddee8 497 int value=data[0];
mbedalvaro 31:5f039cbddee8 498 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 31:5f039cbddee8 499
mbedalvaro 31:5f039cbddee8 500 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 501
mbedalvaro 31:5f039cbddee8 502 blobconf.initConfig(VERTICAL_PINBALL_GAME, value);
mbedalvaro 31:5f039cbddee8 503
mbedalvaro 31:5f039cbddee8 504 lsr.setConfigToRender(&blobconf);
mbedalvaro 31:5f039cbddee8 505 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 506 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 507 }
mbedalvaro 31:5f039cbddee8 508 }
mbedalvaro 31:5f039cbddee8 509
mbedalvaro 31:5f039cbddee8 510 else if (!strcmp(address[0], "pac_man")) {
mbedalvaro 31:5f039cbddee8 511 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 512
mbedalvaro 30:d8af03f01cd4 513 blobconf.initConfig(PAC_MAN_GAME);
mbedalvaro 30:d8af03f01cd4 514
mbedalvaro 30:d8af03f01cd4 515 lsr.setConfigToRender(&blobconf);
mbedalvaro 30:d8af03f01cd4 516 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 517 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 518 }
mbedalvaro 30:d8af03f01cd4 519
mbedalvaro 31:5f039cbddee8 520 else if (!strcmp(address[0], "spot_tracking")) {
mbedalvaro 31:5f039cbddee8 521 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 522
mbedalvaro 31:5f039cbddee8 523 blobconf.initConfig(ONE_TRACKING_SPOT); // value is the nb of spots instantiated
mbedalvaro 31:5f039cbddee8 524
mbedalvaro 31:5f039cbddee8 525 lsr.setConfigToRender(&blobconf);
mbedalvaro 31:5f039cbddee8 526 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 527 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 528 }
mbedalvaro 30:d8af03f01cd4 529
mbedalvaro 16:2ff1cb2ae1b1 530 else if (!strcmp(address[0], "spot_test")) {
mbedalvaro 0:345b3bc7a0ea 531 timerForRendering.detach();
mbedalvaro 0:345b3bc7a0ea 532 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 533 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 534 blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 535 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 536 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 537 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 538 }
mbedalvaro 1:a4050fee11f7 539
mbedalvaro 1:a4050fee11f7 540 // other:
mbedalvaro 1:a4050fee11f7 541
mbedalvaro 24:4e52031a495b 542 else if ( !strcmp(address[0], "standby" ) ) { // will put ALL the blobs in stand by mode (no update function)
mbedalvaro 0:345b3bc7a0ea 543 blobconf.allStandBy(); // will avoid the update function
mbedalvaro 24:4e52031a495b 544 }
mbedalvaro 24:4e52031a495b 545 else if ( !strcmp(address[0], "resume" ) ) {
mbedalvaro 24:4e52031a495b 546 blobconf.allResume(); // Update function is called for all the blobs
mbedalvaro 1:a4050fee11f7 547 }
mbedalvaro 1:a4050fee11f7 548
mbedalvaro 1:a4050fee11f7 549 // (III) ========================================= Loop control (parameters, etc) ===========================================
mbedalvaro 19:228430f1350e 550
mbedalvaro 33:43e8bc451ef0 551 else if (!strcmp( address[0], "setSpeed" ) ) {
mbedalvaro 33:43e8bc451ef0 552 int value=data[0]; // value 1 means a speed of 0.1, value 10, a speed of 1, etc.
mbedalvaro 33:43e8bc451ef0 553 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 554 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 33:43e8bc451ef0 555 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 33:43e8bc451ef0 556 blobconf.blobArray[i]->setSpeed((float)(0.1*value));
mbedalvaro 33:43e8bc451ef0 557 }
mbedalvaro 33:43e8bc451ef0 558 }
mbedalvaro 33:43e8bc451ef0 559 }
mbedalvaro 24:4e52031a495b 560 else if (!strcmp( address[0], "speedFactor" ) ) {
mbedalvaro 24:4e52031a495b 561 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 562 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 563 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 24:4e52031a495b 564 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 24:4e52031a495b 565 blobconf.blobArray[i]->speedFactor((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 566 }
mbedalvaro 24:4e52031a495b 567 }
mbedalvaro 24:4e52031a495b 568 }
mbedalvaro 24:4e52031a495b 569
mbedalvaro 33:43e8bc451ef0 570 else if (!strcmp( address[0], "setSize" ) ) {
mbedalvaro 33:43e8bc451ef0 571 int value=data[0]; // this is the direct size of the scafold
mbedalvaro 32:52273c3291fe 572 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 573 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->setSize((float)(1.0*value));
mbedalvaro 32:52273c3291fe 574 }
mbedalvaro 32:52273c3291fe 575 }
mbedalvaro 33:43e8bc451ef0 576 else if (!strcmp( address[0], "sizeFactor" ) ) {
mbedalvaro 33:43e8bc451ef0 577 int value=data[0]; // value 100 means no change of sice. 200 is twice as big, 50 is half as big.
mbedalvaro 33:43e8bc451ef0 578 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 579 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->sizeFactor((float)(1.0*value/100.0));
mbedalvaro 33:43e8bc451ef0 580 }
mbedalvaro 33:43e8bc451ef0 581 }
mbedalvaro 33:43e8bc451ef0 582
mbedalvaro 32:52273c3291fe 583 // ADJUST MIRROR ANGLE CORRECTION:
mbedalvaro 32:52273c3291fe 584 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 32:52273c3291fe 585 int value=data[0]; // this is not a factor, but an additive quantity to the current delay
mbedalvaro 32:52273c3291fe 586 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 587 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 32:52273c3291fe 588 }
mbedalvaro 32:52273c3291fe 589 }
mbedalvaro 32:52273c3291fe 590 else if (!strcmp( address[0], "adjustMinusAngle" ) ) {
mbedalvaro 32:52273c3291fe 591 int value=data[0]; // this is not a factor, but an substractive quantity to the current delay
mbedalvaro 32:52273c3291fe 592 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 593 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(-value);
mbedalvaro 32:52273c3291fe 594 }
mbedalvaro 32:52273c3291fe 595 }
mbedalvaro 32:52273c3291fe 596
mbedalvaro 24:4e52031a495b 597 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 24:4e52031a495b 598 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 599 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 600 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 24:4e52031a495b 601 }
mbedalvaro 24:4e52031a495b 602 }
mbedalvaro 24:4e52031a495b 603
mbedalvaro 33:43e8bc451ef0 604
mbedalvaro 33:43e8bc451ef0 605 // THRESHOLD MODE, and PARAMETERS:
mbedalvaro 34:1244fa3f2559 606 //(1) Set the threshold mode:
mbedalvaro 33:43e8bc451ef0 607 else if (!strcmp( address[0], "autoThreshold" ) ) {
mbedalvaro 34:1244fa3f2559 608 int value=data[0]; // 1 (auto) or 0 (fixed)
mbedalvaro 33:43e8bc451ef0 609 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 610 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setThresholdMode(value);
mbedalvaro 33:43e8bc451ef0 611 }
mbedalvaro 35:35af5086ab4f 612 // set led and switch state (global value of threshold):
mbedalvaro 35:35af5086ab4f 613 IO.setSwitchOneState(value>0);
mbedalvaro 33:43e8bc451ef0 614 }
mbedalvaro 33:43e8bc451ef0 615
mbedalvaro 33:43e8bc451ef0 616 // (a) AUTO THRESHOLD:
mbedalvaro 33:43e8bc451ef0 617 // MINIMUM CONTRAST RATIO:
mbedalvaro 33:43e8bc451ef0 618 // (1) using multiplicative factor:
mbedalvaro 32:52273c3291fe 619 else if (!strcmp( address[0], "adjustMultContrast" ) ) {
mbedalvaro 32:52273c3291fe 620 int value=data[0]; // value 100 means no change of the current contrast value. 200 means a min contrast
mbedalvaro 32:52273c3291fe 621 // that is twice as large and 50 is half as large as before.
mbedalvaro 24:4e52031a495b 622 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 623 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.multMinContrastRatio((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 624 }
mbedalvaro 32:52273c3291fe 625 }
mbedalvaro 32:52273c3291fe 626 // (2) directly:
mbedalvaro 32:52273c3291fe 627 else if (!strcmp( address[0], "adjustContrast" ) ) {
mbedalvaro 32:52273c3291fe 628 int value=data[0]; // value is in PERCENT (100=1, 50 = 0.5...)
mbedalvaro 32:52273c3291fe 629 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 630 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setMinContrastRatio((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 631 }
mbedalvaro 24:4e52031a495b 632 }
mbedalvaro 34:1244fa3f2559 633 // THRESHOLD FACTOR:
mbedalvaro 32:52273c3291fe 634 //(1) using multiplicative factor:
mbedalvaro 32:52273c3291fe 635 else if (!strcmp( address[0], "adjustMultThreshold" ) ) {
mbedalvaro 32:52273c3291fe 636 int value=data[0]; // value 100 means no change of the current contrast value. 200 means a min contrast
mbedalvaro 32:52273c3291fe 637 // that is twice as large and 50 is half as large as before.
mbedalvaro 32:52273c3291fe 638 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 639 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.multThresholdFactor((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 640 }
mbedalvaro 32:52273c3291fe 641 }
mbedalvaro 32:52273c3291fe 642 //(2) directly:
mbedalvaro 32:52273c3291fe 643 else if (!strcmp( address[0], "adjustThresholdFactor" ) ) {
mbedalvaro 32:52273c3291fe 644 int value=data[0]; // value is in PERCENT (100=1, 50 = 0.5...)
mbedalvaro 32:52273c3291fe 645 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 646 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setThresholdFactor((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 647 }
mbedalvaro 32:52273c3291fe 648 }
mbedalvaro 33:43e8bc451ef0 649 // MINIMUM ACCEPTABLE INTENSITY:
mbedalvaro 32:52273c3291fe 650 // Adjust minimum acceptable intensity:
mbedalvaro 32:52273c3291fe 651 else if (!strcmp( address[0], "adjustMinAcceptableIntensity" ) ) {
mbedalvaro 32:52273c3291fe 652 int value=data[0]; // value is DIRECT value (0 to 255)
mbedalvaro 32:52273c3291fe 653 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 654 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setMinAcceptableIntensity(value);
mbedalvaro 32:52273c3291fe 655 }
mbedalvaro 32:52273c3291fe 656 }
mbedalvaro 32:52273c3291fe 657
mbedalvaro 33:43e8bc451ef0 658 // (b) FIXED THRESHOLD:
mbedalvaro 33:43e8bc451ef0 659 // Adjust fixedThreshold (directly):
mbedalvaro 33:43e8bc451ef0 660 else if (!strcmp( address[0], "adjustFixedThreshold" ) ) {
mbedalvaro 33:43e8bc451ef0 661 int value=data[0]; // value is DIRECT value (0 to 255)
mbedalvaro 33:43e8bc451ef0 662 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 663 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setFixedThreshold(value);
mbedalvaro 33:43e8bc451ef0 664 }
mbedalvaro 33:43e8bc451ef0 665 }
mbedalvaro 33:43e8bc451ef0 666
mbedalvaro 33:43e8bc451ef0 667
mbedalvaro 33:43e8bc451ef0 668
mbedalvaro 32:52273c3291fe 669 // ===================== SEND DATA MODES =======================
mbedalvaro 24:4e52031a495b 670
mbedalvaro 1:a4050fee11f7 671 else if (!strcmp( address[0], "sendOSC" ) ) {
mbedalvaro 1:a4050fee11f7 672 int value=data[0];
mbedalvaro 1:a4050fee11f7 673 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 674 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 675 blobconf.blobArray[i]->sendOSC=(value>0);
mbedalvaro 1:a4050fee11f7 676 }
mbedalvaro 1:a4050fee11f7 677 }
mbedalvaro 1:a4050fee11f7 678 }
mbedalvaro 1:a4050fee11f7 679
mbedalvaro 1:a4050fee11f7 680 else if (!strcmp( address[0], "sendArea" ) ) {
mbedalvaro 1:a4050fee11f7 681 int value=data[0];
mbedalvaro 1:a4050fee11f7 682 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 683 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 684 blobconf.blobArray[i]->sendingBlobArea=(value>0);
mbedalvaro 1:a4050fee11f7 685 }
mbedalvaro 1:a4050fee11f7 686 }
mbedalvaro 1:a4050fee11f7 687 }
mbedalvaro 1:a4050fee11f7 688
mbedalvaro 1:a4050fee11f7 689 else if (!strcmp( address[0], "sendPos" ) ) {
mbedalvaro 1:a4050fee11f7 690 int value=data[0];
mbedalvaro 1:a4050fee11f7 691 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 692 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 693 blobconf.blobArray[i]->sendingLoopPositions=(value>0);
mbedalvaro 1:a4050fee11f7 694 }
mbedalvaro 1:a4050fee11f7 695 }
mbedalvaro 1:a4050fee11f7 696 }
mbedalvaro 1:a4050fee11f7 697
mbedalvaro 1:a4050fee11f7 698 else if (!strcmp( address[0], "sendRegions" ) ) {
mbedalvaro 1:a4050fee11f7 699 int value=data[0];
mbedalvaro 1:a4050fee11f7 700 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 701 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 702 blobconf.blobArray[i]->sendingLoopRegions=(value>0);
mbedalvaro 1:a4050fee11f7 703 }
mbedalvaro 1:a4050fee11f7 704 }
mbedalvaro 1:a4050fee11f7 705 }
mbedalvaro 1:a4050fee11f7 706
mbedalvaro 1:a4050fee11f7 707 else if (!strcmp( address[0], "sendTouched" ) ) {
mbedalvaro 1:a4050fee11f7 708 int value=data[0];
mbedalvaro 1:a4050fee11f7 709 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 710 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 711 blobconf.blobArray[i]->sendingTouched=(value>0);
mbedalvaro 1:a4050fee11f7 712 }
mbedalvaro 1:a4050fee11f7 713 }
mbedalvaro 1:a4050fee11f7 714 }
mbedalvaro 1:a4050fee11f7 715
mbedalvaro 1:a4050fee11f7 716
mbedalvaro 1:a4050fee11f7 717
mbedalvaro 0:345b3bc7a0ea 718 }
mbedalvaro 0:345b3bc7a0ea 719
mbedalvaro 0:345b3bc7a0ea 720 //============= RECEIVE OSC COMMANDS =========================
mbedalvaro 1:a4050fee11f7 721 // This is the callback function called when there are packets on the listening socket. It is not nice to have it
mbedalvaro 1:a4050fee11f7 722 // here, but for the time being having a "wrapping global" is the simplest solution (we cannot pass a member-function pointer
mbedalvaro 1:a4050fee11f7 723 // as handler to the upd object).
mbedalvaro 0:345b3bc7a0ea 724 void processOSC(UDPSocketEvent e) {
mbedalvaro 0:345b3bc7a0ea 725 osc.onUDPSocketEvent(e);
mbedalvaro 0:345b3bc7a0ea 726
mbedalvaro 0:345b3bc7a0ea 727 if (osc.newMessage) {
mbedalvaro 1:a4050fee11f7 728 // 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 729 // 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 730
mbedalvaro 1:a4050fee11f7 731 // Acquire the addresses and arguments and put them in the GLOBAL variables:
mbedalvaro 1:a4050fee11f7 732 strcpy(address[0],"");
mbedalvaro 1:a4050fee11f7 733 strcpy(address[1],"");
mbedalvaro 1:a4050fee11f7 734 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 735 // Acquire data:
mbedalvaro 1:a4050fee11f7 736 data[0]=-1;
mbedalvaro 1:a4050fee11f7 737 data[1]=-1;
mbedalvaro 1:a4050fee11f7 738 for (int i=0; i<recMes.getArgNum(); i++) data[i]=(int)recMes.getArgInt(i);
mbedalvaro 1:a4050fee11f7 739
mbedalvaro 1:a4050fee11f7 740 // Finally, interpret the command:
mbedalvaro 1:a4050fee11f7 741 interpretCommand();//address, data);
mbedalvaro 1:a4050fee11f7 742
mbedalvaro 0:345b3bc7a0ea 743 }
mbedalvaro 1:a4050fee11f7 744 }
mbedalvaro 1:a4050fee11f7 745
mbedalvaro 0:345b3bc7a0ea 746 //============= RECEIVE SERIAL COMMANDS =========================
mbedalvaro 0:345b3bc7a0ea 747 //
mbedalvaro 1:a4050fee11f7 748 // NOTE: - NUMERIC PARAMETERS have to be send BEFORE the command word. They must be sent as ASCII DEC, without end character.
mbedalvaro 0:345b3bc7a0ea 749 // - Commands words SHOULD NOT have numbers in it. They should be C compliant STRINGS (ended with character '0')
mbedalvaro 1:a4050fee11f7 750 // - order is irrelevant: we can send 10 RADIUS or RADIUS 10.
mbedalvaro 0:345b3bc7a0ea 751
mbedalvaro 1:a4050fee11f7 752 // String to store ALPHANUMERIC DATA (i.e., integers, floating point numbers, unsigned ints, etc represented as DEC) sent wirelessly:
mbedalvaro 0:345b3bc7a0ea 753 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 754 int indexStringData=0;//position of the byte in the string
mbedalvaro 0:345b3bc7a0ea 755
mbedalvaro 0:345b3bc7a0ea 756 // String to store COMMAND WORDS:
mbedalvaro 0:345b3bc7a0ea 757 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 758 int indexStringCommand=0;
mbedalvaro 0:345b3bc7a0ea 759 bool commandReady=false; // will become true when receiving the byte 0 (i.e. the '/0' string terminator)
mbedalvaro 0:345b3bc7a0ea 760
mbedalvaro 0:345b3bc7a0ea 761 void processSerial() {
mbedalvaro 0:345b3bc7a0ea 762
mbedalvaro 1:a4050fee11f7 763 while (pc.readable()>0) {
mbedalvaro 1:a4050fee11f7 764
mbedalvaro 14:0fc33a3a7b4b 765
mbedalvaro 1:a4050fee11f7 766 char val =pc.getc();
mbedalvaro 0:345b3bc7a0ea 767 // pc.printf("Got :%d\n", incomingByte);
mbedalvaro 1:a4050fee11f7 768 //pc.putc(incomingByte);
mbedalvaro 1:a4050fee11f7 769
mbedalvaro 1:a4050fee11f7 770 // Save ASCII numeric characters (ASCII 0 - 9) on stringData:
mbedalvaro 1:a4050fee11f7 771 if ((val >= '0') && (val <= '9')) { // this is 45 to 57 (included)
mbedalvaro 1:a4050fee11f7 772 stringData[indexStringData] = val;
mbedalvaro 1:a4050fee11f7 773 indexStringData++;
mbedalvaro 1:a4050fee11f7 774 }
mbedalvaro 1:a4050fee11f7 775
mbedalvaro 1:a4050fee11f7 776 // Save ASCII letters in stringCommand:
mbedalvaro 1:a4050fee11f7 777 if ((val >= 'A') && (val <= 'z')) { // this is 65 to 122 (included)
mbedalvaro 1:a4050fee11f7 778 stringCommand[indexStringCommand] = val;
mbedalvaro 1:a4050fee11f7 779 indexStringCommand++;
mbedalvaro 1:a4050fee11f7 780 }
mbedalvaro 1:a4050fee11f7 781 // is command ready?
mbedalvaro 1:a4050fee11f7 782 if (val=='/') {
mbedalvaro 1:a4050fee11f7 783 commandReady=true;
mbedalvaro 1:a4050fee11f7 784 stringCommand[indexStringCommand] = 0; // string termination.
mbedalvaro 1:a4050fee11f7 785 indexStringCommand=0; // reset index string for acquiring next command
mbedalvaro 1:a4050fee11f7 786 //Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 787 }
mbedalvaro 1:a4050fee11f7 788
mbedalvaro 1:a4050fee11f7 789 // COMMANDS (with or without numeric parameters):
mbedalvaro 1:a4050fee11f7 790 if (commandReady==true) { // it means we can interpret the command string:
mbedalvaro 1:a4050fee11f7 791 commandReady=false;
mbedalvaro 1:a4050fee11f7 792
mbedalvaro 1:a4050fee11f7 793 stringData[indexStringData] = 0 ;// string termination for numeric values;
mbedalvaro 1:a4050fee11f7 794 indexStringData=0;
mbedalvaro 1:a4050fee11f7 795
mbedalvaro 1:a4050fee11f7 796 // PARSE DATA: (TO DO!!!!!!!!!!!!!!):
mbedalvaro 0:345b3bc7a0ea 797
mbedalvaro 1:a4050fee11f7 798 // (a) Parse command (get address[0] and address[1]):
mbedalvaro 1:a4050fee11f7 799 //ex: "/1/standBy" -- > address[0]="1" and address[1]="standBy"
mbedalvaro 1:a4050fee11f7 800 // address[2]
mbedalvaro 1:a4050fee11f7 801
mbedalvaro 1:a4050fee11f7 802 // Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 803 // Serial.println(stringData);
mbedalvaro 1:a4050fee11f7 804
mbedalvaro 1:a4050fee11f7 805 // (b) Parse data:
mbedalvaro 1:a4050fee11f7 806
mbedalvaro 1:a4050fee11f7 807 // char address[2][24];
mbedalvaro 1:a4050fee11f7 808 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 809 //int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 810
mbedalvaro 1:a4050fee11f7 811 // FOR THE TIME BEING there is no parsing for serial commands:
mbedalvaro 1:a4050fee11f7 812
mbedalvaro 1:a4050fee11f7 813 // SCANNING:
mbedalvaro 1:a4050fee11f7 814 if (!strcmp(stringCommand , "takeSnapshot")) {
mbedalvaro 1:a4050fee11f7 815 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 816 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 817
mbedalvaro 1:a4050fee11f7 818 // Then, do the scan (sending values on serial port):
mbedalvaro 24:4e52031a495b 819 IO.scan_serial(atoi(stringData));
mbedalvaro 1:a4050fee11f7 820
mbedalvaro 1:a4050fee11f7 821 // Finally, start again threaded display:
mbedalvaro 4:f9d364f10335 822 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 823 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 824 } else if (!strcmp(stringCommand , "REDON")) IO.setRedPower(1); // pc.printf("%d\n",incomingByte);
mbedalvaro 1:a4050fee11f7 825
mbedalvaro 14:0fc33a3a7b4b 826 else if (!strcmp(stringCommand , "REDOFF")) IO.setRedPower(0);
mbedalvaro 14:0fc33a3a7b4b 827
mbedalvaro 14:0fc33a3a7b4b 828 else if (!strcmp(stringCommand , "READVALUE")) pc.printf("Value read: %f", lockin.getSmoothValue());//lockin.getLastValue());/
mbedalvaro 1:a4050fee11f7 829
mbedalvaro 14:0fc33a3a7b4b 830 else if (!strcmp(stringCommand , "mbedReset")) mbed_reset();
mbedalvaro 16:2ff1cb2ae1b1 831
mbedalvaro 14:0fc33a3a7b4b 832 else if (!strcmp(stringCommand , "calibrate")) {
mbedalvaro 16:2ff1cb2ae1b1 833 // First, we need to disable the threaded display for the loop:
mbedalvaro 16:2ff1cb2ae1b1 834 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 835 // RESCAN (and save LUT table):
mbedalvaro 16:2ff1cb2ae1b1 836 IO.scanLUT();
mbedalvaro 16:2ff1cb2ae1b1 837 // Finally, start again threaded display:
mbedalvaro 16:2ff1cb2ae1b1 838 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 839 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 840 }
mbedalvaro 1:a4050fee11f7 841
mbedalvaro 1:a4050fee11f7 842 // FINALLY, interpret commands (but only after parsing):
mbedalvaro 1:a4050fee11f7 843 // interpretCommand();//address, data);
mbedalvaro 0:345b3bc7a0ea 844
mbedalvaro 0:345b3bc7a0ea 845 }
mbedalvaro 1:a4050fee11f7 846 }
mbedalvaro 1:a4050fee11f7 847 }
mbedalvaro 0:345b3bc7a0ea 848
mbedalvaro 0:345b3bc7a0ea 849
mbedalvaro 0:345b3bc7a0ea 850
mbedalvaro 0:345b3bc7a0ea 851 // ================ MISCELANEA
mbedalvaro 0:345b3bc7a0ea 852
mbedalvaro 0:345b3bc7a0ea 853 /* EXAMPLE SEND/RECEIVE on PROCESSING:
mbedalvaro 0:345b3bc7a0ea 854
mbedalvaro 0:345b3bc7a0ea 855 // oscP5sendreceive by andreas schlegel
mbedalvaro 0:345b3bc7a0ea 856 // example shows how to send and receive osc messages.
mbedalvaro 0:345b3bc7a0ea 857 // oscP5 website at http://www.sojamo.de/oscP5
mbedalvaro 0:345b3bc7a0ea 858
mbedalvaro 0:345b3bc7a0ea 859 import oscP5.*;
mbedalvaro 0:345b3bc7a0ea 860 import netP5.*;
mbedalvaro 1:a4050fee11f7 861
mbedalvaro 0:345b3bc7a0ea 862 OscP5 oscP5;
mbedalvaro 0:345b3bc7a0ea 863 NetAddress myRemoteLocation;
mbedalvaro 0:345b3bc7a0ea 864
mbedalvaro 0:345b3bc7a0ea 865 void setup() {
mbedalvaro 0:345b3bc7a0ea 866 size(400,400);
mbedalvaro 0:345b3bc7a0ea 867 frameRate(25);
mbedalvaro 1:a4050fee11f7 868 // start oscP5, listening for incoming messages at port 12000
mbedalvaro 0:345b3bc7a0ea 869 oscP5 = new OscP5(this,12000);
mbedalvaro 1:a4050fee11f7 870
mbedalvaro 0:345b3bc7a0ea 871 // myRemoteLocation is a NetAddress. a NetAddress takes 2 parameters,
mbedalvaro 0:345b3bc7a0ea 872 // an ip address and a port number. myRemoteLocation is used as parameter in
mbedalvaro 1:a4050fee11f7 873 // oscP5.send() when sending osc packets to another computer, device,
mbedalvaro 0:345b3bc7a0ea 874 // application. usage see below. for testing purposes the listening port
mbedalvaro 0:345b3bc7a0ea 875 // and the port of the remote location address are the same, hence you will
mbedalvaro 0:345b3bc7a0ea 876 // send messages back to this sketch.
mbedalvaro 0:345b3bc7a0ea 877 myRemoteLocation = new NetAddress("10.0.0.2",10000);
mbedalvaro 0:345b3bc7a0ea 878 }
mbedalvaro 0:345b3bc7a0ea 879
mbedalvaro 0:345b3bc7a0ea 880
mbedalvaro 0:345b3bc7a0ea 881 void draw() {
mbedalvaro 1:a4050fee11f7 882 background(0);
mbedalvaro 0:345b3bc7a0ea 883 }
mbedalvaro 0:345b3bc7a0ea 884
mbedalvaro 0:345b3bc7a0ea 885 void mousePressed() {
mbedalvaro 1:a4050fee11f7 886 // in the following different ways of creating osc messages are shown by example
mbedalvaro 0:345b3bc7a0ea 887 OscMessage myMessage = new OscMessage("/mbed/test1");
mbedalvaro 1:a4050fee11f7 888
mbedalvaro 1:a4050fee11f7 889 myMessage.add(123); // add an int to the osc message
mbedalvaro 0:345b3bc7a0ea 890
mbedalvaro 1:a4050fee11f7 891 // send the message
mbedalvaro 1:a4050fee11f7 892 oscP5.send(myMessage, myRemoteLocation);
mbedalvaro 0:345b3bc7a0ea 893 }
mbedalvaro 0:345b3bc7a0ea 894
mbedalvaro 0:345b3bc7a0ea 895
mbedalvaro 1:a4050fee11f7 896 // incoming osc message are forwarded to the oscEvent method.
mbedalvaro 0:345b3bc7a0ea 897 void oscEvent(OscMessage theOscMessage) {
mbedalvaro 1:a4050fee11f7 898 // print the address pattern and the typetag of the received OscMessage
mbedalvaro 0:345b3bc7a0ea 899 print("### received an osc message.");
mbedalvaro 0:345b3bc7a0ea 900 print(" addrpattern: "+theOscMessage.addrPattern());
mbedalvaro 0:345b3bc7a0ea 901 println(" typetag: "+theOscMessage.typetag());
mbedalvaro 0:345b3bc7a0ea 902 }
mbedalvaro 0:345b3bc7a0ea 903
mbedalvaro 0:345b3bc7a0ea 904 */