Alvaro Cassinelli / Mbed 2 deprecated laserUI

Laser Sensing Display for UI interfaces in the real world

Dependencies:   mbed

Fork of skinGames_forktest by Alvaro Cassinelli

main.cpp@33:43e8bc451ef0, 2012-11-05 (annotated)

Committer:
mbedalvaro
Date:
Mon Nov 05 06:08:35 2012 +0000
Revision:
33:43e8bc451ef0
Parent:
32:52273c3291fe
Child:
34:1244fa3f2559
added resizing functions, as well as better control on the thresholding modes

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 9:3321170d157c 196
mbedalvaro 1:a4050fee11f7 197 // text:
mbedalvaro 1:a4050fee11f7 198 /*
mbedalvaro 1:a4050fee11f7 199 sendMes.setTopAddress("/hello");
mbedalvaro 1:a4050fee11f7 200 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 201 int x=(long)10;
mbedalvaro 1:a4050fee11f7 202 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 203 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 204 */
mbedalvaro 1:a4050fee11f7 205
mbedalvaro 0:345b3bc7a0ea 206 #ifdef LOOPTIMECOMPUTE
mbedalvaro 9:3321170d157c 207 if (timeCounterNum>50) myled = 0;
mbedalvaro 9:3321170d157c 208 // if (timeCounterNum%10==0) blobconf.sendConfData();
mbedalvaro 9:3321170d157c 209 if (timeCounterNum>100) {
mbedalvaro 1:a4050fee11f7 210 myled = 1;
mbedalvaro 1:a4050fee11f7 211 measureLoopPeriod.stop();
mbedalvaro 1:a4050fee11f7 212 sendMes.setTopAddress("/timeloop");
mbedalvaro 1:a4050fee11f7 213 sendMes.setSubAddress("/");
mbedalvaro 10:6f8e48dca1bd 214 // long x=(long)(int(measureLoopPeriod.read_us()/100.0));
mbedalvaro 9:3321170d157c 215 // long x=(long)(blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory.size());
mbedalvaro 9:3321170d157c 216 // long x=(long)(blobconf.blobArray[0]->normRecenteringVector);
mbedalvaro 10:6f8e48dca1bd 217 long x=(long)(1000*blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory[0].intensity);
mbedalvaro 1:a4050fee11f7 218 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 219 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 220 timeCounterNum=0;
mbedalvaro 1:a4050fee11f7 221 measureLoopPeriod.reset();
mbedalvaro 1:a4050fee11f7 222 measureLoopPeriod.start();
mbedalvaro 1:a4050fee11f7 223 } else timeCounterNum++;
mbedalvaro 0:345b3bc7a0ea 224 #endif
mbedalvaro 0:345b3bc7a0ea 225
mbedalvaro 0:345b3bc7a0ea 226 }
mbedalvaro 0:345b3bc7a0ea 227 }
mbedalvaro 0:345b3bc7a0ea 228
mbedalvaro 1:a4050fee11f7 229 // ================= INTERPRET COMMAND =========================
mbedalvaro 0:345b3bc7a0ea 230 // NOTE: the following arrays are GLOBAL (used in processOSC and processSerial, as well as in interpretCommand function):
mbedalvaro 1:a4050fee11f7 231 // max of two addresses (top and sub), of a max length of 24 characters:
mbedalvaro 0:345b3bc7a0ea 232 char address[2][24];
mbedalvaro 0:345b3bc7a0ea 233 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 234 int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 235
mbedalvaro 1:a4050fee11f7 236 //interpretCommand(const char& address[2][], const int& data[2]) {
mbedalvaro 0:345b3bc7a0ea 237 void interpretCommand() {
mbedalvaro 0:345b3bc7a0ea 238 // (I) =========================================== SPECIAL FUNCTIONS (reset, rescan LUT, etc) ====================================================
mbedalvaro 16:2ff1cb2ae1b1 239 if ( !strcmp(address[0], "takeSnapshot" ) ) {
mbedalvaro 24:4e52031a495b 240 int value=data[0];
mbedalvaro 24:4e52031a495b 241 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 242
mbedalvaro 1:a4050fee11f7 243 // for test:
mbedalvaro 1:a4050fee11f7 244 for (int i=0; i<2 ; i++) {
mbedalvaro 1:a4050fee11f7 245 myled = 1;
mbedalvaro 1:a4050fee11f7 246 wait(0.1);
mbedalvaro 1:a4050fee11f7 247 myled = 0;
mbedalvaro 1:a4050fee11f7 248 wait(0.1);
mbedalvaro 1:a4050fee11f7 249 }
mbedalvaro 1:a4050fee11f7 250
mbedalvaro 1:a4050fee11f7 251 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 252 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 253
mbedalvaro 24:4e52031a495b 254 // Then, do the scan (sending values on SERIAL port):
mbedalvaro 24:4e52031a495b 255 IO.scan_serial(value);
mbedalvaro 1:a4050fee11f7 256
mbedalvaro 1:a4050fee11f7 257 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 258 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 259 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 24:4e52031a495b 260
mbedalvaro 24:4e52031a495b 261 }
mbedalvaro 1:a4050fee11f7 262 }
mbedalvaro 1:a4050fee11f7 263
mbedalvaro 1:a4050fee11f7 264 else if ( !strcmp(address[0], "mbedReset" ) ) mbed_reset();
mbedalvaro 22:d87317d7ca91 265
mbedalvaro 22:d87317d7ca91 266 else if (!strcmp(address[0], "showMirrorLimits")) {
mbedalvaro 22:d87317d7ca91 267 int value=data[0];
mbedalvaro 22:d87317d7ca91 268 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 22:d87317d7ca91 269 timerForRendering.detach();
mbedalvaro 24:4e52031a495b 270 IO.showLimitsMirrors(value);
mbedalvaro 22:d87317d7ca91 271 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 24:4e52031a495b 272 }
mbedalvaro 22:d87317d7ca91 273 }
mbedalvaro 1:a4050fee11f7 274
mbedalvaro 1:a4050fee11f7 275 else if ( !strcmp(address[0], "calibrate" ) ) {
mbedalvaro 1:a4050fee11f7 276 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 277 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 278 // RESCAN (and save LUT table):
mbedalvaro 1:a4050fee11f7 279 IO.scanLUT();
mbedalvaro 1:a4050fee11f7 280 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 281 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 282 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 283 }
mbedalvaro 1:a4050fee11f7 284
mbedalvaro 1:a4050fee11f7 285 // (II) ========================================= GLOBAL CONFIG and HARDWARE COMMANDS ===========================================
mbedalvaro 1:a4050fee11f7 286
mbedalvaro 32:52273c3291fe 287 else if ( !strcmp(address[0], "setAllColor" ) ) {
mbedalvaro 32:52273c3291fe 288 int value=data[0]; // this is the color (RGB bits)
mbedalvaro 32:52273c3291fe 289 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 290 blobconf.allSetColor(value);
mbedalvaro 32:52273c3291fe 291 }
mbedalvaro 32:52273c3291fe 292 }
mbedalvaro 33:43e8bc451ef0 293
mbedalvaro 33:43e8bc451ef0 294 else if ( !strcmp(address[0], "setAllRandomColor" ) ) {
mbedalvaro 33:43e8bc451ef0 295 blobconf.randomizeAllColors();
mbedalvaro 33:43e8bc451ef0 296 }
mbedalvaro 32:52273c3291fe 297
mbedalvaro 32:52273c3291fe 298 else if ( !strcmp(address[0], "setAllGreenColor" ) ) {
mbedalvaro 1:a4050fee11f7 299 int value=data[0];
mbedalvaro 1:a4050fee11f7 300 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 25:74cb85b85fd2 301 if (value==0)
mbedalvaro 32:52273c3291fe 302 blobconf.allSetGreen(1);
mbedalvaro 25:74cb85b85fd2 303 else
mbedalvaro 32:52273c3291fe 304 blobconf.allSetGreen(0);
mbedalvaro 1:a4050fee11f7 305 }
mbedalvaro 1:a4050fee11f7 306 }
mbedalvaro 23:bf666fcc61bc 307
mbedalvaro 32:52273c3291fe 308 else if ( !strcmp(address[0], "setAllBlueColor" ) ) {
mbedalvaro 32:52273c3291fe 309 int value=data[0];
mbedalvaro 32:52273c3291fe 310 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 311 if (value==0)
mbedalvaro 32:52273c3291fe 312 blobconf.allSetBlue(1);
mbedalvaro 32:52273c3291fe 313 else
mbedalvaro 32:52273c3291fe 314 blobconf.allSetBlue(0);
mbedalvaro 32:52273c3291fe 315 }
mbedalvaro 32:52273c3291fe 316 }
mbedalvaro 32:52273c3291fe 317
mbedalvaro 32:52273c3291fe 318 // NOTE: RED either afect the lock in, or some other red laser... not yet done.
mbedalvaro 32:52273c3291fe 319
mbedalvaro 23:bf666fcc61bc 320 else if ( !strcmp(address[0], "testPower" ) ) {
mbedalvaro 23:bf666fcc61bc 321 // First, we need to disable the threaded display for the loop:
mbedalvaro 23:bf666fcc61bc 322 timerForRendering.detach();
mbedalvaro 23:bf666fcc61bc 323
mbedalvaro 23:bf666fcc61bc 324 // Note: arguments is first 3 bits to set the laser powers (3 LSB bits to set each color)
mbedalvaro 23:bf666fcc61bc 325 // and then the second argument is the number of seconds to wait for the measurment
mbedalvaro 23:bf666fcc61bc 326 int value1=data[0], value2=data[1];
mbedalvaro 23:bf666fcc61bc 327 if ((value1!=-1)&&(value2!=-1)) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 23:bf666fcc61bc 328
mbedalvaro 23:bf666fcc61bc 329 // Set position of mirrors:
mbedalvaro 23:bf666fcc61bc 330 IO.writeOutX(CENTER_AD_MIRROR_X);
mbedalvaro 23:bf666fcc61bc 331 IO.writeOutY(CENTER_AD_MIRROR_Y);
mbedalvaro 23:bf666fcc61bc 332
mbedalvaro 23:bf666fcc61bc 333 for (int i=0; i<3 ; i++) {
mbedalvaro 23:bf666fcc61bc 334 myled3 = 1;
mbedalvaro 23:bf666fcc61bc 335 wait(0.2);
mbedalvaro 23:bf666fcc61bc 336 myled3 = 0;
mbedalvaro 23:bf666fcc61bc 337 wait(0.2);
mbedalvaro 23:bf666fcc61bc 338 }
mbedalvaro 23:bf666fcc61bc 339
mbedalvaro 23:bf666fcc61bc 340 // Set laser power:
mbedalvaro 23:bf666fcc61bc 341 IO.setRGBPower((unsigned char)value1);
mbedalvaro 23:bf666fcc61bc 342
mbedalvaro 23:bf666fcc61bc 343 // Wait...
mbedalvaro 23:bf666fcc61bc 344 wait(value2);// in seconds
mbedalvaro 23:bf666fcc61bc 345 //Timer t;
mbedalvaro 23:bf666fcc61bc 346 //t.start();
mbedalvaro 23:bf666fcc61bc 347 //while(t.read_ms()<value2*1000);
mbedalvaro 23:bf666fcc61bc 348 //t.stop();
mbedalvaro 23:bf666fcc61bc 349 }
mbedalvaro 23:bf666fcc61bc 350
mbedalvaro 23:bf666fcc61bc 351 // Finally, start again threaded display:
mbedalvaro 23:bf666fcc61bc 352 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 23:bf666fcc61bc 353
mbedalvaro 23:bf666fcc61bc 354 }
mbedalvaro 23:bf666fcc61bc 355
mbedalvaro 23:bf666fcc61bc 356
mbedalvaro 1:a4050fee11f7 357
mbedalvaro 1:a4050fee11f7 358 // SIMPLE BEHAVIOUR MODES (to be read from an XML file in the future):
mbedalvaro 11:62f7183a03e7 359 else if (!strcmp(address[0], "elastic_following")) { //
mbedalvaro 1:a4050fee11f7 360 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 361
mbedalvaro 30:d8af03f01cd4 362 blobconf.initConfig(ONE_ELASTIC_FOLLOWING);
mbedalvaro 30:d8af03f01cd4 363
mbedalvaro 1:a4050fee11f7 364 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 365 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 366 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 367
mbedalvaro 11:62f7183a03e7 368 } else if (!strcmp(address[0], "elastic_mouth")) { //
mbedalvaro 1:a4050fee11f7 369 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 370
mbedalvaro 30:d8af03f01cd4 371 blobconf.initConfig(ONE_ELASTIC_MOUTH);
mbedalvaro 30:d8af03f01cd4 372
mbedalvaro 1:a4050fee11f7 373 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 374 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 375 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 19:228430f1350e 376
mbedalvaro 19:228430f1350e 377 } else if (!strcmp(address[0], "elastic_mouth_small")) { //
mbedalvaro 19:228430f1350e 378 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 379
mbedalvaro 30:d8af03f01cd4 380 blobconf.initConfig(ONE_ELASTIC_MOUTH_SMALL);
mbedalvaro 30:d8af03f01cd4 381
mbedalvaro 19:228430f1350e 382 lsr.setConfigToRender(&blobconf);
mbedalvaro 19:228430f1350e 383 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 19:228430f1350e 384 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 385 }
mbedalvaro 11:62f7183a03e7 386 else if (!strcmp(address[0], "spot_bouncing")) {
mbedalvaro 16:2ff1cb2ae1b1 387 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 388 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 389 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 390
mbedalvaro 30:d8af03f01cd4 391 blobconf.initConfig(BOUNCING_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 16:2ff1cb2ae1b1 392
mbedalvaro 16:2ff1cb2ae1b1 393 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 394 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 395 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 396 }
mbedalvaro 16:2ff1cb2ae1b1 397 }
mbedalvaro 16:2ff1cb2ae1b1 398
mbedalvaro 30:d8af03f01cd4 399 else if (!strcmp(address[0], "spot_lorentz")) {
mbedalvaro 27:1ce994629ffc 400 int value=data[0];
mbedalvaro 27:1ce994629ffc 401 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 27:1ce994629ffc 402 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 403
mbedalvaro 30:d8af03f01cd4 404 blobconf.initConfig(LORENTZ_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 27:1ce994629ffc 405
mbedalvaro 27:1ce994629ffc 406 lsr.setConfigToRender(&blobconf);
mbedalvaro 27:1ce994629ffc 407 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 408 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 409 }
mbedalvaro 27:1ce994629ffc 410 }
mbedalvaro 28:44b7b6e35548 411
mbedalvaro 28:44b7b6e35548 412 else if (!strcmp(address[0], "air_hockey")) {
mbedalvaro 28:44b7b6e35548 413 int value=data[0];
mbedalvaro 28:44b7b6e35548 414 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 28:44b7b6e35548 415 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 416
mbedalvaro 30:d8af03f01cd4 417 blobconf.initConfig(AIR_HOCKEY_GAME, value); // value is the nb of spots instantiated
mbedalvaro 28:44b7b6e35548 418
mbedalvaro 28:44b7b6e35548 419 lsr.setConfigToRender(&blobconf);
mbedalvaro 28:44b7b6e35548 420 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 421 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 422 }
mbedalvaro 28:44b7b6e35548 423 }
mbedalvaro 32:52273c3291fe 424
mbedalvaro 32:52273c3291fe 425 else if (!strcmp(address[0], "rain_mode")) {
mbedalvaro 32:52273c3291fe 426 int value=data[0];
mbedalvaro 32:52273c3291fe 427 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 428 timerForRendering.detach();
mbedalvaro 32:52273c3291fe 429
mbedalvaro 32:52273c3291fe 430 blobconf.initConfig(RAIN_MODE, value); // value is the nb of spots instantiated
mbedalvaro 32:52273c3291fe 431
mbedalvaro 32:52273c3291fe 432 lsr.setConfigToRender(&blobconf);
mbedalvaro 32:52273c3291fe 433 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 32:52273c3291fe 434 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 32:52273c3291fe 435 }
mbedalvaro 32:52273c3291fe 436 }
mbedalvaro 32:52273c3291fe 437
mbedalvaro 28:44b7b6e35548 438
mbedalvaro 28:44b7b6e35548 439 else if (!strcmp(address[0], "spot_following")) {
mbedalvaro 16:2ff1cb2ae1b1 440 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 441 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 442
mbedalvaro 16:2ff1cb2ae1b1 443 timerForRendering.detach();
mbedalvaro 22:d87317d7ca91 444
mbedalvaro 30:d8af03f01cd4 445 blobconf.initConfig(FOLLOWING_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 22:d87317d7ca91 446
mbedalvaro 16:2ff1cb2ae1b1 447 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 448 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 449 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 450 }
mbedalvaro 16:2ff1cb2ae1b1 451 }
mbedalvaro 16:2ff1cb2ae1b1 452
mbedalvaro 30:d8af03f01cd4 453 else if (!strcmp(address[0], "circular_pong")) {
mbedalvaro 30:d8af03f01cd4 454 int value=data[0];
mbedalvaro 30:d8af03f01cd4 455 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 30:d8af03f01cd4 456
mbedalvaro 30:d8af03f01cd4 457 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 458
mbedalvaro 30:d8af03f01cd4 459 blobconf.initConfig(CIRCULAR_PONG_GAME, value); // value is the nb of spots instantiated
mbedalvaro 30:d8af03f01cd4 460
mbedalvaro 30:d8af03f01cd4 461 lsr.setConfigToRender(&blobconf);
mbedalvaro 30:d8af03f01cd4 462 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 463 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 464 }
mbedalvaro 30:d8af03f01cd4 465 }
mbedalvaro 31:5f039cbddee8 466
mbedalvaro 31:5f039cbddee8 467 else if (!strcmp(address[0], "fish_net")) {
mbedalvaro 30:d8af03f01cd4 468 int value=data[0];
mbedalvaro 30:d8af03f01cd4 469 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 30:d8af03f01cd4 470
mbedalvaro 30:d8af03f01cd4 471 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 472
mbedalvaro 31:5f039cbddee8 473 blobconf.initConfig(FISH_NET_GAME, value); // value is the nb of spots instantiated
mbedalvaro 31:5f039cbddee8 474
mbedalvaro 31:5f039cbddee8 475 lsr.setConfigToRender(&blobconf);
mbedalvaro 31:5f039cbddee8 476 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 477 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 478 }
mbedalvaro 31:5f039cbddee8 479 }
mbedalvaro 31:5f039cbddee8 480
mbedalvaro 31:5f039cbddee8 481
mbedalvaro 31:5f039cbddee8 482 else if (!strcmp(address[0], "vertical_pinball")) {
mbedalvaro 31:5f039cbddee8 483 int value=data[0];
mbedalvaro 31:5f039cbddee8 484 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 31:5f039cbddee8 485
mbedalvaro 31:5f039cbddee8 486 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 487
mbedalvaro 31:5f039cbddee8 488 blobconf.initConfig(VERTICAL_PINBALL_GAME, value);
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], "pac_man")) {
mbedalvaro 31:5f039cbddee8 497 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 498
mbedalvaro 30:d8af03f01cd4 499 blobconf.initConfig(PAC_MAN_GAME);
mbedalvaro 30:d8af03f01cd4 500
mbedalvaro 30:d8af03f01cd4 501 lsr.setConfigToRender(&blobconf);
mbedalvaro 30:d8af03f01cd4 502 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 503 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 504 }
mbedalvaro 30:d8af03f01cd4 505
mbedalvaro 31:5f039cbddee8 506 else if (!strcmp(address[0], "spot_tracking")) {
mbedalvaro 31:5f039cbddee8 507 timerForRendering.detach();
mbedalvaro 31:5f039cbddee8 508
mbedalvaro 31:5f039cbddee8 509 blobconf.initConfig(ONE_TRACKING_SPOT); // value is the nb of spots instantiated
mbedalvaro 31:5f039cbddee8 510
mbedalvaro 31:5f039cbddee8 511 lsr.setConfigToRender(&blobconf);
mbedalvaro 31:5f039cbddee8 512 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 513 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 31:5f039cbddee8 514 }
mbedalvaro 30:d8af03f01cd4 515
mbedalvaro 16:2ff1cb2ae1b1 516 else if (!strcmp(address[0], "spot_test")) {
mbedalvaro 0:345b3bc7a0ea 517 timerForRendering.detach();
mbedalvaro 0:345b3bc7a0ea 518 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 519 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 520 blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 521 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 522 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 523 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 524 }
mbedalvaro 1:a4050fee11f7 525
mbedalvaro 1:a4050fee11f7 526 // other:
mbedalvaro 1:a4050fee11f7 527
mbedalvaro 24:4e52031a495b 528 else if ( !strcmp(address[0], "standby" ) ) { // will put ALL the blobs in stand by mode (no update function)
mbedalvaro 0:345b3bc7a0ea 529 blobconf.allStandBy(); // will avoid the update function
mbedalvaro 24:4e52031a495b 530 }
mbedalvaro 24:4e52031a495b 531 else if ( !strcmp(address[0], "resume" ) ) {
mbedalvaro 24:4e52031a495b 532 blobconf.allResume(); // Update function is called for all the blobs
mbedalvaro 1:a4050fee11f7 533 }
mbedalvaro 1:a4050fee11f7 534
mbedalvaro 1:a4050fee11f7 535 // (III) ========================================= Loop control (parameters, etc) ===========================================
mbedalvaro 19:228430f1350e 536
mbedalvaro 33:43e8bc451ef0 537 else if (!strcmp( address[0], "setSpeed" ) ) {
mbedalvaro 33:43e8bc451ef0 538 int value=data[0]; // value 1 means a speed of 0.1, value 10, a speed of 1, etc.
mbedalvaro 33:43e8bc451ef0 539 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 540 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 33:43e8bc451ef0 541 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 33:43e8bc451ef0 542 blobconf.blobArray[i]->setSpeed((float)(0.1*value));
mbedalvaro 33:43e8bc451ef0 543 }
mbedalvaro 33:43e8bc451ef0 544 }
mbedalvaro 33:43e8bc451ef0 545 }
mbedalvaro 24:4e52031a495b 546 else if (!strcmp( address[0], "speedFactor" ) ) {
mbedalvaro 24:4e52031a495b 547 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 548 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 549 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 24:4e52031a495b 550 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 24:4e52031a495b 551 blobconf.blobArray[i]->speedFactor((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 552 }
mbedalvaro 24:4e52031a495b 553 }
mbedalvaro 24:4e52031a495b 554 }
mbedalvaro 24:4e52031a495b 555
mbedalvaro 33:43e8bc451ef0 556 else if (!strcmp( address[0], "setSize" ) ) {
mbedalvaro 33:43e8bc451ef0 557 int value=data[0]; // this is the direct size of the scafold
mbedalvaro 32:52273c3291fe 558 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 559 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->setSize((float)(1.0*value));
mbedalvaro 32:52273c3291fe 560 }
mbedalvaro 32:52273c3291fe 561 }
mbedalvaro 33:43e8bc451ef0 562 else if (!strcmp( address[0], "sizeFactor" ) ) {
mbedalvaro 33:43e8bc451ef0 563 int value=data[0]; // value 100 means no change of sice. 200 is twice as big, 50 is half as big.
mbedalvaro 33:43e8bc451ef0 564 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 565 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->sizeFactor((float)(1.0*value/100.0));
mbedalvaro 33:43e8bc451ef0 566 }
mbedalvaro 33:43e8bc451ef0 567 }
mbedalvaro 33:43e8bc451ef0 568
mbedalvaro 32:52273c3291fe 569 // ADJUST MIRROR ANGLE CORRECTION:
mbedalvaro 32:52273c3291fe 570 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 32:52273c3291fe 571 int value=data[0]; // this is not a factor, but an additive quantity to the current delay
mbedalvaro 32:52273c3291fe 572 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 573 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 32:52273c3291fe 574 }
mbedalvaro 32:52273c3291fe 575 }
mbedalvaro 32:52273c3291fe 576 else if (!strcmp( address[0], "adjustMinusAngle" ) ) {
mbedalvaro 32:52273c3291fe 577 int value=data[0]; // this is not a factor, but an substractive quantity to the current delay
mbedalvaro 32:52273c3291fe 578 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 579 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(-value);
mbedalvaro 32:52273c3291fe 580 }
mbedalvaro 32:52273c3291fe 581 }
mbedalvaro 32:52273c3291fe 582
mbedalvaro 24:4e52031a495b 583 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 24:4e52031a495b 584 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 585 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 586 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 24:4e52031a495b 587 }
mbedalvaro 24:4e52031a495b 588 }
mbedalvaro 24:4e52031a495b 589
mbedalvaro 33:43e8bc451ef0 590
mbedalvaro 33:43e8bc451ef0 591 // THRESHOLD MODE, and PARAMETERS:
mbedalvaro 33:43e8bc451ef0 592 //(1) using multiplicative factor:
mbedalvaro 33:43e8bc451ef0 593 else if (!strcmp( address[0], "autoThreshold" ) ) {
mbedalvaro 33:43e8bc451ef0 594 int value=data[0]; // value 100 means no change of the current contrast value. 200 means a min contrast
mbedalvaro 33:43e8bc451ef0 595 // that is twice as large and 50 is half as large as before.
mbedalvaro 33:43e8bc451ef0 596 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 597 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setThresholdMode(value);
mbedalvaro 33:43e8bc451ef0 598 }
mbedalvaro 33:43e8bc451ef0 599 }
mbedalvaro 33:43e8bc451ef0 600
mbedalvaro 33:43e8bc451ef0 601 // (a) AUTO THRESHOLD:
mbedalvaro 33:43e8bc451ef0 602 // MINIMUM CONTRAST RATIO:
mbedalvaro 33:43e8bc451ef0 603 // (1) using multiplicative factor:
mbedalvaro 32:52273c3291fe 604 else if (!strcmp( address[0], "adjustMultContrast" ) ) {
mbedalvaro 32:52273c3291fe 605 int value=data[0]; // value 100 means no change of the current contrast value. 200 means a min contrast
mbedalvaro 32:52273c3291fe 606 // that is twice as large and 50 is half as large as before.
mbedalvaro 24:4e52031a495b 607 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 608 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.multMinContrastRatio((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 609 }
mbedalvaro 32:52273c3291fe 610 }
mbedalvaro 32:52273c3291fe 611 // (2) directly:
mbedalvaro 32:52273c3291fe 612 else if (!strcmp( address[0], "adjustContrast" ) ) {
mbedalvaro 32:52273c3291fe 613 int value=data[0]; // value is in PERCENT (100=1, 50 = 0.5...)
mbedalvaro 32:52273c3291fe 614 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 615 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setMinContrastRatio((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 616 }
mbedalvaro 24:4e52031a495b 617 }
mbedalvaro 33:43e8bc451ef0 618 // THESHOLD FACTOR:
mbedalvaro 32:52273c3291fe 619 //(1) using multiplicative factor:
mbedalvaro 32:52273c3291fe 620 else if (!strcmp( address[0], "adjustMultThreshold" ) ) {
mbedalvaro 32:52273c3291fe 621 int value=data[0]; // value 100 means no change of the current contrast value. 200 means a min contrast
mbedalvaro 32:52273c3291fe 622 // that is twice as large and 50 is half as large as before.
mbedalvaro 32:52273c3291fe 623 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 624 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.multThresholdFactor((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 625 }
mbedalvaro 32:52273c3291fe 626 }
mbedalvaro 32:52273c3291fe 627 //(2) directly:
mbedalvaro 32:52273c3291fe 628 else if (!strcmp( address[0], "adjustThresholdFactor" ) ) {
mbedalvaro 32:52273c3291fe 629 int value=data[0]; // value is in PERCENT (100=1, 50 = 0.5...)
mbedalvaro 32:52273c3291fe 630 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 32:52273c3291fe 631 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setThresholdFactor((float)(1.0*value/100.0));
mbedalvaro 32:52273c3291fe 632 }
mbedalvaro 32:52273c3291fe 633 }
mbedalvaro 33:43e8bc451ef0 634 // MINIMUM ACCEPTABLE INTENSITY:
mbedalvaro 32:52273c3291fe 635 // Adjust minimum acceptable intensity:
mbedalvaro 32:52273c3291fe 636 else if (!strcmp( address[0], "adjustMinAcceptableIntensity" ) ) {
mbedalvaro 32:52273c3291fe 637 int value=data[0]; // value is DIRECT value (0 to 255)
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.setMinAcceptableIntensity(value);
mbedalvaro 32:52273c3291fe 640 }
mbedalvaro 32:52273c3291fe 641 }
mbedalvaro 32:52273c3291fe 642
mbedalvaro 33:43e8bc451ef0 643 // (b) FIXED THRESHOLD:
mbedalvaro 33:43e8bc451ef0 644 // Adjust fixedThreshold (directly):
mbedalvaro 33:43e8bc451ef0 645 else if (!strcmp( address[0], "adjustFixedThreshold" ) ) {
mbedalvaro 33:43e8bc451ef0 646 int value=data[0]; // value is DIRECT value (0 to 255)
mbedalvaro 33:43e8bc451ef0 647 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 33:43e8bc451ef0 648 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.setFixedThreshold(value);
mbedalvaro 33:43e8bc451ef0 649 }
mbedalvaro 33:43e8bc451ef0 650 }
mbedalvaro 33:43e8bc451ef0 651
mbedalvaro 33:43e8bc451ef0 652
mbedalvaro 33:43e8bc451ef0 653
mbedalvaro 32:52273c3291fe 654 // ===================== SEND DATA MODES =======================
mbedalvaro 24:4e52031a495b 655
mbedalvaro 1:a4050fee11f7 656 else if (!strcmp( address[0], "sendOSC" ) ) {
mbedalvaro 1:a4050fee11f7 657 int value=data[0];
mbedalvaro 1:a4050fee11f7 658 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 659 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 660 blobconf.blobArray[i]->sendOSC=(value>0);
mbedalvaro 1:a4050fee11f7 661 }
mbedalvaro 1:a4050fee11f7 662 }
mbedalvaro 1:a4050fee11f7 663 }
mbedalvaro 1:a4050fee11f7 664
mbedalvaro 1:a4050fee11f7 665 else if (!strcmp( address[0], "sendArea" ) ) {
mbedalvaro 1:a4050fee11f7 666 int value=data[0];
mbedalvaro 1:a4050fee11f7 667 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 668 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 669 blobconf.blobArray[i]->sendingBlobArea=(value>0);
mbedalvaro 1:a4050fee11f7 670 }
mbedalvaro 1:a4050fee11f7 671 }
mbedalvaro 1:a4050fee11f7 672 }
mbedalvaro 1:a4050fee11f7 673
mbedalvaro 1:a4050fee11f7 674 else if (!strcmp( address[0], "sendPos" ) ) {
mbedalvaro 1:a4050fee11f7 675 int value=data[0];
mbedalvaro 1:a4050fee11f7 676 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 677 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 678 blobconf.blobArray[i]->sendingLoopPositions=(value>0);
mbedalvaro 1:a4050fee11f7 679 }
mbedalvaro 1:a4050fee11f7 680 }
mbedalvaro 1:a4050fee11f7 681 }
mbedalvaro 1:a4050fee11f7 682
mbedalvaro 1:a4050fee11f7 683 else if (!strcmp( address[0], "sendRegions" ) ) {
mbedalvaro 1:a4050fee11f7 684 int value=data[0];
mbedalvaro 1:a4050fee11f7 685 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 686 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 687 blobconf.blobArray[i]->sendingLoopRegions=(value>0);
mbedalvaro 1:a4050fee11f7 688 }
mbedalvaro 1:a4050fee11f7 689 }
mbedalvaro 1:a4050fee11f7 690 }
mbedalvaro 1:a4050fee11f7 691
mbedalvaro 1:a4050fee11f7 692 else if (!strcmp( address[0], "sendTouched" ) ) {
mbedalvaro 1:a4050fee11f7 693 int value=data[0];
mbedalvaro 1:a4050fee11f7 694 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 695 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 696 blobconf.blobArray[i]->sendingTouched=(value>0);
mbedalvaro 1:a4050fee11f7 697 }
mbedalvaro 1:a4050fee11f7 698 }
mbedalvaro 1:a4050fee11f7 699 }
mbedalvaro 1:a4050fee11f7 700
mbedalvaro 1:a4050fee11f7 701
mbedalvaro 1:a4050fee11f7 702
mbedalvaro 0:345b3bc7a0ea 703 }
mbedalvaro 0:345b3bc7a0ea 704
mbedalvaro 0:345b3bc7a0ea 705 //============= RECEIVE OSC COMMANDS =========================
mbedalvaro 1:a4050fee11f7 706 // This is the callback function called when there are packets on the listening socket. It is not nice to have it
mbedalvaro 1:a4050fee11f7 707 // here, but for the time being having a "wrapping global" is the simplest solution (we cannot pass a member-function pointer
mbedalvaro 1:a4050fee11f7 708 // as handler to the upd object).
mbedalvaro 0:345b3bc7a0ea 709 void processOSC(UDPSocketEvent e) {
mbedalvaro 0:345b3bc7a0ea 710 osc.onUDPSocketEvent(e);
mbedalvaro 0:345b3bc7a0ea 711
mbedalvaro 0:345b3bc7a0ea 712 if (osc.newMessage) {
mbedalvaro 1:a4050fee11f7 713 // 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 714 // 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 715
mbedalvaro 1:a4050fee11f7 716 // Acquire the addresses and arguments and put them in the GLOBAL variables:
mbedalvaro 1:a4050fee11f7 717 strcpy(address[0],"");
mbedalvaro 1:a4050fee11f7 718 strcpy(address[1],"");
mbedalvaro 1:a4050fee11f7 719 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 720 // Acquire data:
mbedalvaro 1:a4050fee11f7 721 data[0]=-1;
mbedalvaro 1:a4050fee11f7 722 data[1]=-1;
mbedalvaro 1:a4050fee11f7 723 for (int i=0; i<recMes.getArgNum(); i++) data[i]=(int)recMes.getArgInt(i);
mbedalvaro 1:a4050fee11f7 724
mbedalvaro 1:a4050fee11f7 725 // Finally, interpret the command:
mbedalvaro 1:a4050fee11f7 726 interpretCommand();//address, data);
mbedalvaro 1:a4050fee11f7 727
mbedalvaro 0:345b3bc7a0ea 728 }
mbedalvaro 1:a4050fee11f7 729 }
mbedalvaro 1:a4050fee11f7 730
mbedalvaro 0:345b3bc7a0ea 731 //============= RECEIVE SERIAL COMMANDS =========================
mbedalvaro 0:345b3bc7a0ea 732 //
mbedalvaro 1:a4050fee11f7 733 // NOTE: - NUMERIC PARAMETERS have to be send BEFORE the command word. They must be sent as ASCII DEC, without end character.
mbedalvaro 0:345b3bc7a0ea 734 // - Commands words SHOULD NOT have numbers in it. They should be C compliant STRINGS (ended with character '0')
mbedalvaro 1:a4050fee11f7 735 // - order is irrelevant: we can send 10 RADIUS or RADIUS 10.
mbedalvaro 0:345b3bc7a0ea 736
mbedalvaro 1:a4050fee11f7 737 // String to store ALPHANUMERIC DATA (i.e., integers, floating point numbers, unsigned ints, etc represented as DEC) sent wirelessly:
mbedalvaro 0:345b3bc7a0ea 738 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 739 int indexStringData=0;//position of the byte in the string
mbedalvaro 0:345b3bc7a0ea 740
mbedalvaro 0:345b3bc7a0ea 741 // String to store COMMAND WORDS:
mbedalvaro 0:345b3bc7a0ea 742 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 743 int indexStringCommand=0;
mbedalvaro 0:345b3bc7a0ea 744 bool commandReady=false; // will become true when receiving the byte 0 (i.e. the '/0' string terminator)
mbedalvaro 0:345b3bc7a0ea 745
mbedalvaro 0:345b3bc7a0ea 746 void processSerial() {
mbedalvaro 0:345b3bc7a0ea 747
mbedalvaro 1:a4050fee11f7 748 while (pc.readable()>0) {
mbedalvaro 1:a4050fee11f7 749
mbedalvaro 14:0fc33a3a7b4b 750
mbedalvaro 1:a4050fee11f7 751 char val =pc.getc();
mbedalvaro 0:345b3bc7a0ea 752 // pc.printf("Got :%d\n", incomingByte);
mbedalvaro 1:a4050fee11f7 753 //pc.putc(incomingByte);
mbedalvaro 1:a4050fee11f7 754
mbedalvaro 1:a4050fee11f7 755 // Save ASCII numeric characters (ASCII 0 - 9) on stringData:
mbedalvaro 1:a4050fee11f7 756 if ((val >= '0') && (val <= '9')) { // this is 45 to 57 (included)
mbedalvaro 1:a4050fee11f7 757 stringData[indexStringData] = val;
mbedalvaro 1:a4050fee11f7 758 indexStringData++;
mbedalvaro 1:a4050fee11f7 759 }
mbedalvaro 1:a4050fee11f7 760
mbedalvaro 1:a4050fee11f7 761 // Save ASCII letters in stringCommand:
mbedalvaro 1:a4050fee11f7 762 if ((val >= 'A') && (val <= 'z')) { // this is 65 to 122 (included)
mbedalvaro 1:a4050fee11f7 763 stringCommand[indexStringCommand] = val;
mbedalvaro 1:a4050fee11f7 764 indexStringCommand++;
mbedalvaro 1:a4050fee11f7 765 }
mbedalvaro 1:a4050fee11f7 766 // is command ready?
mbedalvaro 1:a4050fee11f7 767 if (val=='/') {
mbedalvaro 1:a4050fee11f7 768 commandReady=true;
mbedalvaro 1:a4050fee11f7 769 stringCommand[indexStringCommand] = 0; // string termination.
mbedalvaro 1:a4050fee11f7 770 indexStringCommand=0; // reset index string for acquiring next command
mbedalvaro 1:a4050fee11f7 771 //Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 772 }
mbedalvaro 1:a4050fee11f7 773
mbedalvaro 1:a4050fee11f7 774 // COMMANDS (with or without numeric parameters):
mbedalvaro 1:a4050fee11f7 775 if (commandReady==true) { // it means we can interpret the command string:
mbedalvaro 1:a4050fee11f7 776 commandReady=false;
mbedalvaro 1:a4050fee11f7 777
mbedalvaro 1:a4050fee11f7 778 stringData[indexStringData] = 0 ;// string termination for numeric values;
mbedalvaro 1:a4050fee11f7 779 indexStringData=0;
mbedalvaro 1:a4050fee11f7 780
mbedalvaro 1:a4050fee11f7 781 // PARSE DATA: (TO DO!!!!!!!!!!!!!!):
mbedalvaro 0:345b3bc7a0ea 782
mbedalvaro 1:a4050fee11f7 783 // (a) Parse command (get address[0] and address[1]):
mbedalvaro 1:a4050fee11f7 784 //ex: "/1/standBy" -- > address[0]="1" and address[1]="standBy"
mbedalvaro 1:a4050fee11f7 785 // address[2]
mbedalvaro 1:a4050fee11f7 786
mbedalvaro 1:a4050fee11f7 787 // Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 788 // Serial.println(stringData);
mbedalvaro 1:a4050fee11f7 789
mbedalvaro 1:a4050fee11f7 790 // (b) Parse data:
mbedalvaro 1:a4050fee11f7 791
mbedalvaro 1:a4050fee11f7 792 // char address[2][24];
mbedalvaro 1:a4050fee11f7 793 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 794 //int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 795
mbedalvaro 1:a4050fee11f7 796 // FOR THE TIME BEING there is no parsing for serial commands:
mbedalvaro 1:a4050fee11f7 797
mbedalvaro 1:a4050fee11f7 798 // SCANNING:
mbedalvaro 1:a4050fee11f7 799 if (!strcmp(stringCommand , "takeSnapshot")) {
mbedalvaro 1:a4050fee11f7 800 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 801 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 802
mbedalvaro 1:a4050fee11f7 803 // Then, do the scan (sending values on serial port):
mbedalvaro 24:4e52031a495b 804 IO.scan_serial(atoi(stringData));
mbedalvaro 1:a4050fee11f7 805
mbedalvaro 1:a4050fee11f7 806 // Finally, start again threaded display:
mbedalvaro 4:f9d364f10335 807 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 808 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 809 } else if (!strcmp(stringCommand , "REDON")) IO.setRedPower(1); // pc.printf("%d\n",incomingByte);
mbedalvaro 1:a4050fee11f7 810
mbedalvaro 14:0fc33a3a7b4b 811 else if (!strcmp(stringCommand , "REDOFF")) IO.setRedPower(0);
mbedalvaro 14:0fc33a3a7b4b 812
mbedalvaro 14:0fc33a3a7b4b 813 else if (!strcmp(stringCommand , "READVALUE")) pc.printf("Value read: %f", lockin.getSmoothValue());//lockin.getLastValue());/
mbedalvaro 1:a4050fee11f7 814
mbedalvaro 14:0fc33a3a7b4b 815 else if (!strcmp(stringCommand , "mbedReset")) mbed_reset();
mbedalvaro 16:2ff1cb2ae1b1 816
mbedalvaro 14:0fc33a3a7b4b 817 else if (!strcmp(stringCommand , "calibrate")) {
mbedalvaro 16:2ff1cb2ae1b1 818 // First, we need to disable the threaded display for the loop:
mbedalvaro 16:2ff1cb2ae1b1 819 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 820 // RESCAN (and save LUT table):
mbedalvaro 16:2ff1cb2ae1b1 821 IO.scanLUT();
mbedalvaro 16:2ff1cb2ae1b1 822 // Finally, start again threaded display:
mbedalvaro 16:2ff1cb2ae1b1 823 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 824 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 825 }
mbedalvaro 1:a4050fee11f7 826
mbedalvaro 1:a4050fee11f7 827 // FINALLY, interpret commands (but only after parsing):
mbedalvaro 1:a4050fee11f7 828 // interpretCommand();//address, data);
mbedalvaro 0:345b3bc7a0ea 829
mbedalvaro 0:345b3bc7a0ea 830 }
mbedalvaro 1:a4050fee11f7 831 }
mbedalvaro 1:a4050fee11f7 832 }
mbedalvaro 0:345b3bc7a0ea 833
mbedalvaro 0:345b3bc7a0ea 834
mbedalvaro 0:345b3bc7a0ea 835
mbedalvaro 0:345b3bc7a0ea 836 // ================ MISCELANEA
mbedalvaro 0:345b3bc7a0ea 837
mbedalvaro 0:345b3bc7a0ea 838 /* EXAMPLE SEND/RECEIVE on PROCESSING:
mbedalvaro 0:345b3bc7a0ea 839
mbedalvaro 0:345b3bc7a0ea 840 // oscP5sendreceive by andreas schlegel
mbedalvaro 0:345b3bc7a0ea 841 // example shows how to send and receive osc messages.
mbedalvaro 0:345b3bc7a0ea 842 // oscP5 website at http://www.sojamo.de/oscP5
mbedalvaro 0:345b3bc7a0ea 843
mbedalvaro 0:345b3bc7a0ea 844 import oscP5.*;
mbedalvaro 0:345b3bc7a0ea 845 import netP5.*;
mbedalvaro 1:a4050fee11f7 846
mbedalvaro 0:345b3bc7a0ea 847 OscP5 oscP5;
mbedalvaro 0:345b3bc7a0ea 848 NetAddress myRemoteLocation;
mbedalvaro 0:345b3bc7a0ea 849
mbedalvaro 0:345b3bc7a0ea 850 void setup() {
mbedalvaro 0:345b3bc7a0ea 851 size(400,400);
mbedalvaro 0:345b3bc7a0ea 852 frameRate(25);
mbedalvaro 1:a4050fee11f7 853 // start oscP5, listening for incoming messages at port 12000
mbedalvaro 0:345b3bc7a0ea 854 oscP5 = new OscP5(this,12000);
mbedalvaro 1:a4050fee11f7 855
mbedalvaro 0:345b3bc7a0ea 856 // myRemoteLocation is a NetAddress. a NetAddress takes 2 parameters,
mbedalvaro 0:345b3bc7a0ea 857 // an ip address and a port number. myRemoteLocation is used as parameter in
mbedalvaro 1:a4050fee11f7 858 // oscP5.send() when sending osc packets to another computer, device,
mbedalvaro 0:345b3bc7a0ea 859 // application. usage see below. for testing purposes the listening port
mbedalvaro 0:345b3bc7a0ea 860 // and the port of the remote location address are the same, hence you will
mbedalvaro 0:345b3bc7a0ea 861 // send messages back to this sketch.
mbedalvaro 0:345b3bc7a0ea 862 myRemoteLocation = new NetAddress("10.0.0.2",10000);
mbedalvaro 0:345b3bc7a0ea 863 }
mbedalvaro 0:345b3bc7a0ea 864
mbedalvaro 0:345b3bc7a0ea 865
mbedalvaro 0:345b3bc7a0ea 866 void draw() {
mbedalvaro 1:a4050fee11f7 867 background(0);
mbedalvaro 0:345b3bc7a0ea 868 }
mbedalvaro 0:345b3bc7a0ea 869
mbedalvaro 0:345b3bc7a0ea 870 void mousePressed() {
mbedalvaro 1:a4050fee11f7 871 // in the following different ways of creating osc messages are shown by example
mbedalvaro 0:345b3bc7a0ea 872 OscMessage myMessage = new OscMessage("/mbed/test1");
mbedalvaro 1:a4050fee11f7 873
mbedalvaro 1:a4050fee11f7 874 myMessage.add(123); // add an int to the osc message
mbedalvaro 0:345b3bc7a0ea 875
mbedalvaro 1:a4050fee11f7 876 // send the message
mbedalvaro 1:a4050fee11f7 877 oscP5.send(myMessage, myRemoteLocation);
mbedalvaro 0:345b3bc7a0ea 878 }
mbedalvaro 0:345b3bc7a0ea 879
mbedalvaro 0:345b3bc7a0ea 880
mbedalvaro 1:a4050fee11f7 881 // incoming osc message are forwarded to the oscEvent method.
mbedalvaro 0:345b3bc7a0ea 882 void oscEvent(OscMessage theOscMessage) {
mbedalvaro 1:a4050fee11f7 883 // print the address pattern and the typetag of the received OscMessage
mbedalvaro 0:345b3bc7a0ea 884 print("### received an osc message.");
mbedalvaro 0:345b3bc7a0ea 885 print(" addrpattern: "+theOscMessage.addrPattern());
mbedalvaro 0:345b3bc7a0ea 886 println(" typetag: "+theOscMessage.typetag());
mbedalvaro 0:345b3bc7a0ea 887 }
mbedalvaro 0:345b3bc7a0ea 888
mbedalvaro 0:345b3bc7a0ea 889 */