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@30:d8af03f01cd4, 2012-09-21 (annotated)

Committer:
mbedalvaro
Date:
Fri Sep 21 10:02:35 2012 +0000
Revision:
30:d8af03f01cd4
Parent:
29:2fc8c12822eb
Child:
31:5f039cbddee8
first commit. Not yet functional. Added ghost and pacman game modes, but the behaviour of these "rigid spots" is not implemented yet

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 21:bc9b9383f4b6 41 uint8_t destIp[] = {10, 0, 0, 3};
mbedalvaro 0:345b3bc7a0ea 42 int destPort = 12000;
mbedalvaro 1:a4050fee11f7 43
mbedalvaro 0:345b3bc7a0ea 44 char *topAddress="/mbed";
mbedalvaro 0:345b3bc7a0ea 45 char *subAddress[3]={ "/test1" , "/test2" , "/test3" };
mbedalvaro 1:a4050fee11f7 46
mbedalvaro 0:345b3bc7a0ea 47 OSCMessage recMes;
mbedalvaro 0:345b3bc7a0ea 48 OSCMessage sendMes;
mbedalvaro 1:a4050fee11f7 49
mbedalvaro 1:a4050fee11f7 50 OSCClass osc;
mbedalvaro 1:a4050fee11f7 51 //OSCClass osc(&recMes); // instantiate OSC communication object, and set the receiver container from the OSC packets
mbedalvaro 1:a4050fee11f7 52
mbedalvaro 1:a4050fee11f7 53 void processOSC(UDPSocketEvent e);
mbedalvaro 0:345b3bc7a0ea 54 // ----------------------------------------------------------------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 55
mbedalvaro 2:34157ebbf56b 56 // Tickers:
mbedalvaro 0:345b3bc7a0ea 57 Ticker timerForRendering;
mbedalvaro 2:34157ebbf56b 58 //Ticker timerForSendingData; // better use a timer, so as not to interrupt the exact laser display ticker
mbedalvaro 2:34157ebbf56b 59
mbedalvaro 9:3321170d157c 60 // Timers:
mbedalvaro 0:345b3bc7a0ea 61 Timer measureLoopPeriod;
mbedalvaro 9:3321170d157c 62 //Timer measureUpdatePeriod;
mbedalvaro 18:d72935b13858 63
mbedalvaro 0:345b3bc7a0ea 64
mbedalvaro 1:a4050fee11f7 65 // to get serial commands (not necessary perhaps)
mbedalvaro 0:345b3bc7a0ea 66 void processSerial();
mbedalvaro 1:a4050fee11f7 67
mbedalvaro 0:345b3bc7a0ea 68 int main() {
mbedalvaro 1:a4050fee11f7 69
mbedalvaro 0:345b3bc7a0ea 70 // Initialize the hardware (laser powers, positions...):
mbedalvaro 0:345b3bc7a0ea 71 IO.init();
mbedalvaro 0:345b3bc7a0ea 72
mbedalvaro 1:a4050fee11f7 73 // -------------------------------
mbedalvaro 1:a4050fee11f7 74 // Set the Ethernet port:
mbedalvaro 1:a4050fee11f7 75 printf("Setting up...\r\n");
mbedalvaro 1:a4050fee11f7 76 EthernetErr ethErr = eth.setup();
mbedalvaro 1:a4050fee11f7 77 if (ethErr) {
mbedalvaro 1:a4050fee11f7 78 printf("Error %d in setup.\r\n", ethErr);
mbedalvaro 1:a4050fee11f7 79 return -1;
mbedalvaro 1:a4050fee11f7 80 }
mbedalvaro 1:a4050fee11f7 81 printf("Setup OK\r\n");
mbedalvaro 1:a4050fee11f7 82
mbedalvaro 1:a4050fee11f7 83 //(1) Sending message:
mbedalvaro 1:a4050fee11f7 84 // Set IP and Port:
mbedalvaro 1:a4050fee11f7 85 sendMes.setIp( destIp );
mbedalvaro 1:a4050fee11f7 86 sendMes.setPort( destPort );
mbedalvaro 1:a4050fee11f7 87 // Set data:
mbedalvaro 1:a4050fee11f7 88 // sendMes.setTopAddress(topAddress);
mbedalvaro 1:a4050fee11f7 89
mbedalvaro 1:a4050fee11f7 90 //setting osc functionnality:
mbedalvaro 1:a4050fee11f7 91 //(2) Receiving:
mbedalvaro 1:a4050fee11f7 92 // recMes.setIp( serverIp ); // not needed?
mbedalvaro 1:a4050fee11f7 93 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 94 osc.begin(serverPort, &processOSC); // binds the upd (osc) messages to an arbitrary listening port ("server" port), and callback function
mbedalvaro 1:a4050fee11f7 95 // -------------------------------
mbedalvaro 1:a4050fee11f7 96
mbedalvaro 0:345b3bc7a0ea 97 /* // sending seems not to work right after setting the osc object??
mbedalvaro 0:345b3bc7a0ea 98 wait(1);
mbedalvaro 0:345b3bc7a0ea 99 sendMes.setTopAddress("starting");
mbedalvaro 1:a4050fee11f7 100 sendMes.setSubAddress("");
mbedalvaro 0:345b3bc7a0ea 101 osc.sendOsc( &sendMes );
mbedalvaro 0:345b3bc7a0ea 102 */
mbedalvaro 1:a4050fee11f7 103
mbedalvaro 0:345b3bc7a0ea 104 // initialize with the desired blob configuration:
mbedalvaro 1:a4050fee11f7 105
mbedalvaro 0:345b3bc7a0ea 106 // Tested modes:
mbedalvaro 1:a4050fee11f7 107 blobconf.clearConfig();
mbedalvaro 10:6f8e48dca1bd 108 // blobconf.addOneElasticLoopContractCentral();
mbedalvaro 11:62f7183a03e7 109 // blobconf.addOneElasticContourFollowing();
mbedalvaro 1:a4050fee11f7 110
mbedalvaro 14:0fc33a3a7b4b 111 // blobconf.addOneRigidLoopBouncing();
mbedalvaro 9:3321170d157c 112 // blobconf.addOneRigidLoopBouncing();
mbedalvaro 16:2ff1cb2ae1b1 113 //blobconf.addOneRigidLoopFollowing();
mbedalvaro 29:2fc8c12822eb 114 // blobconf.addOneRigidLoopFollowing();
mbedalvaro 29:2fc8c12822eb 115
mbedalvaro 29:2fc8c12822eb 116 blobconf.addOneElasticLoopContractCentralFast();
mbedalvaro 2:34157ebbf56b 117
mbedalvaro 7:0df17f3078bc 118
mbedalvaro 5:73cd58b58f95 119 //blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 120
mbedalvaro 0:345b3bc7a0ea 121 // Important: first, set the initial position for all the blobs, this will be useful because
mbedalvaro 0:345b3bc7a0ea 122 // when changing modes we can use the previous central position...
mbedalvaro 1:a4050fee11f7 123 // blobconf.setInitialPos(CENTER_AD_MIRROR_X, CENTER_AD_MIRROR_Y);
mbedalvaro 1:a4050fee11f7 124
mbedalvaro 24:4e52031a495b 125 // draw the config once before activating the laser buffer:
mbedalvaro 5:73cd58b58f95 126 blobconf.draw();
mbedalvaro 13:9f03eac02700 127 lsr.startFullDisplay();
mbedalvaro 1:a4050fee11f7 128
mbedalvaro 0:345b3bc7a0ea 129 // 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 130 lsr.setConfigToRender(&blobconf);
mbedalvaro 1:a4050fee11f7 131
mbedalvaro 1:a4050fee11f7 132 // Timer on the rendering function of the oneLoop object:
mbedalvaro 9:3321170d157c 133 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL); // the address of the object, member function, and interval (in seconds)
mbedalvaro 9:3321170d157c 134 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL); // the address of the object, member function, and interval (in seconds)
mbedalvaro 1:a4050fee11f7 135
mbedalvaro 1:a4050fee11f7 136 // Timer for sending OSC data:
mbedalvaro 9:3321170d157c 137 // timerForSendingData.attach(&blobconf, &blobConfig::sendConfData, 0.025); // time in seconds (25ms -> 40Hz)
mbedalvaro 1:a4050fee11f7 138
mbedalvaro 1:a4050fee11f7 139 //========================================== INFINITE LOOP (in USER PROGRAM CONTEXT) ===================================================================
mbedalvaro 1:a4050fee11f7 140 #ifdef LOOPTIMECOMPUTE
mbedalvaro 1:a4050fee11f7 141 int timeCounterNum=1000;
mbedalvaro 1:a4050fee11f7 142 #endif
mbedalvaro 1:a4050fee11f7 143
mbedalvaro 9:3321170d157c 144 //measureUpdatePeriod.start();
mbedalvaro 1:a4050fee11f7 145
mbedalvaro 1:a4050fee11f7 146 while (true) {
mbedalvaro 1:a4050fee11f7 147
mbedalvaro 13:9f03eac02700 148 if (lsr.endedFullDisplay()) {
mbedalvaro 9:3321170d157c 149
mbedalvaro 9:3321170d157c 150 // measureUpdatePeriod.stop();
mbedalvaro 9:3321170d157c 151 // measureUpdatePeriod.reset();
mbedalvaro 9:3321170d157c 152
mbedalvaro 9:3321170d157c 153 // __disable_irq();
mbedalvaro 9:3321170d157c 154
mbedalvaro 1:a4050fee11f7 155 // update config dynamics (this also could be threaded?):
mbedalvaro 1:a4050fee11f7 156 blobconf.update();
mbedalvaro 1:a4050fee11f7 157
mbedalvaro 10:6f8e48dca1bd 158
mbedalvaro 1:a4050fee11f7 159 // draw the config (note: each kind of blob renders differently)
mbedalvaro 1:a4050fee11f7 160 blobconf.draw();
mbedalvaro 18:d72935b13858 161
mbedalvaro 18:d72935b13858 162
mbedalvaro 18:d72935b13858 163 // (b)Sending Data: // PUT THIS IN AN INTERRUPT OR USE A TIMER!!! it may be TOO FAST...
mbedalvaro 18:d72935b13858 164 // 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 165 // 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 166 // per blob timer counter.
mbedalvaro 18:d72935b13858 167 blobconf.sendConfData();
mbedalvaro 18:d72935b13858 168
mbedalvaro 16:2ff1cb2ae1b1 169
mbedalvaro 23:bf666fcc61bc 170 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 171
mbedalvaro 9:3321170d157c 172
mbedalvaro 9:3321170d157c 173 // __enable_irq();
mbedalvaro 9:3321170d157c 174
mbedalvaro 9:3321170d157c 175 // measureUpdatePeriod.start();
mbedalvaro 10:6f8e48dca1bd 176
mbedalvaro 1:a4050fee11f7 177 }
mbedalvaro 0:345b3bc7a0ea 178
mbedalvaro 2:34157ebbf56b 179
mbedalvaro 1:a4050fee11f7 180 // COMMUNICATION:
mbedalvaro 1:a4050fee11f7 181 // (a) Reading commands:
mbedalvaro 1:a4050fee11f7 182 // Ethernet:
mbedalvaro 1:a4050fee11f7 183 Net::poll(); // this will take care of calling processOSC(UDPSocketEvent e) when a new packet arrives.
mbedalvaro 1:a4050fee11f7 184
mbedalvaro 1:a4050fee11f7 185 // Serial:
mbedalvaro 1:a4050fee11f7 186 #ifdef SERIAL_COMMANDS
mbedalvaro 1:a4050fee11f7 187 if (pc.readable()>0) processSerial();
mbedalvaro 1:a4050fee11f7 188 #endif
mbedalvaro 9:3321170d157c 189
mbedalvaro 9:3321170d157c 190
mbedalvaro 1:a4050fee11f7 191 // text:
mbedalvaro 1:a4050fee11f7 192 /*
mbedalvaro 1:a4050fee11f7 193 sendMes.setTopAddress("/hello");
mbedalvaro 1:a4050fee11f7 194 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 195 int x=(long)10;
mbedalvaro 1:a4050fee11f7 196 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 197 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 198 */
mbedalvaro 1:a4050fee11f7 199
mbedalvaro 0:345b3bc7a0ea 200 #ifdef LOOPTIMECOMPUTE
mbedalvaro 9:3321170d157c 201 if (timeCounterNum>50) myled = 0;
mbedalvaro 9:3321170d157c 202 // if (timeCounterNum%10==0) blobconf.sendConfData();
mbedalvaro 9:3321170d157c 203 if (timeCounterNum>100) {
mbedalvaro 1:a4050fee11f7 204 myled = 1;
mbedalvaro 1:a4050fee11f7 205 measureLoopPeriod.stop();
mbedalvaro 1:a4050fee11f7 206 sendMes.setTopAddress("/timeloop");
mbedalvaro 1:a4050fee11f7 207 sendMes.setSubAddress("/");
mbedalvaro 10:6f8e48dca1bd 208 // long x=(long)(int(measureLoopPeriod.read_us()/100.0));
mbedalvaro 9:3321170d157c 209 // long x=(long)(blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory.size());
mbedalvaro 9:3321170d157c 210 // long x=(long)(blobconf.blobArray[0]->normRecenteringVector);
mbedalvaro 10:6f8e48dca1bd 211 long x=(long)(1000*blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory[0].intensity);
mbedalvaro 1:a4050fee11f7 212 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 213 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 214 timeCounterNum=0;
mbedalvaro 1:a4050fee11f7 215 measureLoopPeriod.reset();
mbedalvaro 1:a4050fee11f7 216 measureLoopPeriod.start();
mbedalvaro 1:a4050fee11f7 217 } else timeCounterNum++;
mbedalvaro 0:345b3bc7a0ea 218 #endif
mbedalvaro 0:345b3bc7a0ea 219
mbedalvaro 0:345b3bc7a0ea 220 }
mbedalvaro 0:345b3bc7a0ea 221 }
mbedalvaro 0:345b3bc7a0ea 222
mbedalvaro 1:a4050fee11f7 223 // ================= INTERPRET COMMAND =========================
mbedalvaro 0:345b3bc7a0ea 224 // NOTE: the following arrays are GLOBAL (used in processOSC and processSerial, as well as in interpretCommand function):
mbedalvaro 1:a4050fee11f7 225 // max of two addresses (top and sub), of a max length of 24 characters:
mbedalvaro 0:345b3bc7a0ea 226 char address[2][24];
mbedalvaro 0:345b3bc7a0ea 227 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 228 int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 229
mbedalvaro 1:a4050fee11f7 230 //interpretCommand(const char& address[2][], const int& data[2]) {
mbedalvaro 0:345b3bc7a0ea 231 void interpretCommand() {
mbedalvaro 0:345b3bc7a0ea 232 // (I) =========================================== SPECIAL FUNCTIONS (reset, rescan LUT, etc) ====================================================
mbedalvaro 16:2ff1cb2ae1b1 233 if ( !strcmp(address[0], "takeSnapshot" ) ) {
mbedalvaro 24:4e52031a495b 234 int value=data[0];
mbedalvaro 24:4e52031a495b 235 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 236
mbedalvaro 1:a4050fee11f7 237 // for test:
mbedalvaro 1:a4050fee11f7 238 for (int i=0; i<2 ; i++) {
mbedalvaro 1:a4050fee11f7 239 myled = 1;
mbedalvaro 1:a4050fee11f7 240 wait(0.1);
mbedalvaro 1:a4050fee11f7 241 myled = 0;
mbedalvaro 1:a4050fee11f7 242 wait(0.1);
mbedalvaro 1:a4050fee11f7 243 }
mbedalvaro 1:a4050fee11f7 244
mbedalvaro 1:a4050fee11f7 245 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 246 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 247
mbedalvaro 24:4e52031a495b 248 // Then, do the scan (sending values on SERIAL port):
mbedalvaro 24:4e52031a495b 249 IO.scan_serial(value);
mbedalvaro 1:a4050fee11f7 250
mbedalvaro 1:a4050fee11f7 251 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 252 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 253 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 24:4e52031a495b 254
mbedalvaro 24:4e52031a495b 255 }
mbedalvaro 1:a4050fee11f7 256 }
mbedalvaro 1:a4050fee11f7 257
mbedalvaro 1:a4050fee11f7 258 else if ( !strcmp(address[0], "mbedReset" ) ) mbed_reset();
mbedalvaro 22:d87317d7ca91 259
mbedalvaro 22:d87317d7ca91 260 else if (!strcmp(address[0], "showMirrorLimits")) {
mbedalvaro 22:d87317d7ca91 261 int value=data[0];
mbedalvaro 22:d87317d7ca91 262 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 22:d87317d7ca91 263 timerForRendering.detach();
mbedalvaro 24:4e52031a495b 264 IO.showLimitsMirrors(value);
mbedalvaro 22:d87317d7ca91 265 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 24:4e52031a495b 266 }
mbedalvaro 22:d87317d7ca91 267 }
mbedalvaro 1:a4050fee11f7 268
mbedalvaro 1:a4050fee11f7 269 else if ( !strcmp(address[0], "calibrate" ) ) {
mbedalvaro 1:a4050fee11f7 270 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 271 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 272 // RESCAN (and save LUT table):
mbedalvaro 1:a4050fee11f7 273 IO.scanLUT();
mbedalvaro 1:a4050fee11f7 274 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 275 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 276 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 277 }
mbedalvaro 1:a4050fee11f7 278
mbedalvaro 1:a4050fee11f7 279 // (II) ========================================= GLOBAL CONFIG and HARDWARE COMMANDS ===========================================
mbedalvaro 1:a4050fee11f7 280
mbedalvaro 1:a4050fee11f7 281 else if ( !strcmp(address[0], "setGreenLaser" ) ) {
mbedalvaro 1:a4050fee11f7 282 int value=data[0];
mbedalvaro 1:a4050fee11f7 283 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 25:74cb85b85fd2 284 if (value==0)
mbedalvaro 25:74cb85b85fd2 285 blobconf.allSetColor(0x04);// only red (note that we are in blue for "test" mode... so the blue will appear when touching something anyway
mbedalvaro 25:74cb85b85fd2 286 else
mbedalvaro 25:74cb85b85fd2 287 blobconf.allSetColor(0x06); // RED and GREEN (note: in the future, make a method to set colors properly! one by one...)
mbedalvaro 1:a4050fee11f7 288 }
mbedalvaro 1:a4050fee11f7 289 }
mbedalvaro 23:bf666fcc61bc 290
mbedalvaro 23:bf666fcc61bc 291 else if ( !strcmp(address[0], "testPower" ) ) {
mbedalvaro 23:bf666fcc61bc 292 // First, we need to disable the threaded display for the loop:
mbedalvaro 23:bf666fcc61bc 293 timerForRendering.detach();
mbedalvaro 23:bf666fcc61bc 294
mbedalvaro 23:bf666fcc61bc 295 // Note: arguments is first 3 bits to set the laser powers (3 LSB bits to set each color)
mbedalvaro 23:bf666fcc61bc 296 // and then the second argument is the number of seconds to wait for the measurment
mbedalvaro 23:bf666fcc61bc 297 int value1=data[0], value2=data[1];
mbedalvaro 23:bf666fcc61bc 298 if ((value1!=-1)&&(value2!=-1)) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 23:bf666fcc61bc 299
mbedalvaro 23:bf666fcc61bc 300 // Set position of mirrors:
mbedalvaro 23:bf666fcc61bc 301 IO.writeOutX(CENTER_AD_MIRROR_X);
mbedalvaro 23:bf666fcc61bc 302 IO.writeOutY(CENTER_AD_MIRROR_Y);
mbedalvaro 23:bf666fcc61bc 303
mbedalvaro 23:bf666fcc61bc 304 for (int i=0; i<3 ; i++) {
mbedalvaro 23:bf666fcc61bc 305 myled3 = 1;
mbedalvaro 23:bf666fcc61bc 306 wait(0.2);
mbedalvaro 23:bf666fcc61bc 307 myled3 = 0;
mbedalvaro 23:bf666fcc61bc 308 wait(0.2);
mbedalvaro 23:bf666fcc61bc 309 }
mbedalvaro 23:bf666fcc61bc 310
mbedalvaro 23:bf666fcc61bc 311 // Set laser power:
mbedalvaro 23:bf666fcc61bc 312 IO.setRGBPower((unsigned char)value1);
mbedalvaro 23:bf666fcc61bc 313
mbedalvaro 23:bf666fcc61bc 314 // Wait...
mbedalvaro 23:bf666fcc61bc 315 wait(value2);// in seconds
mbedalvaro 23:bf666fcc61bc 316 //Timer t;
mbedalvaro 23:bf666fcc61bc 317 //t.start();
mbedalvaro 23:bf666fcc61bc 318 //while(t.read_ms()<value2*1000);
mbedalvaro 23:bf666fcc61bc 319 //t.stop();
mbedalvaro 23:bf666fcc61bc 320 }
mbedalvaro 23:bf666fcc61bc 321
mbedalvaro 23:bf666fcc61bc 322 // Finally, start again threaded display:
mbedalvaro 23:bf666fcc61bc 323 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 23:bf666fcc61bc 324
mbedalvaro 23:bf666fcc61bc 325 }
mbedalvaro 23:bf666fcc61bc 326
mbedalvaro 23:bf666fcc61bc 327
mbedalvaro 1:a4050fee11f7 328
mbedalvaro 1:a4050fee11f7 329 // SIMPLE BEHAVIOUR MODES (to be read from an XML file in the future):
mbedalvaro 11:62f7183a03e7 330 else if (!strcmp(address[0], "elastic_following")) { //
mbedalvaro 1:a4050fee11f7 331 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 332
mbedalvaro 30:d8af03f01cd4 333 blobconf.initConfig(ONE_ELASTIC_FOLLOWING);
mbedalvaro 30:d8af03f01cd4 334
mbedalvaro 1:a4050fee11f7 335 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 336 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 337 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 338
mbedalvaro 11:62f7183a03e7 339 } else if (!strcmp(address[0], "elastic_mouth")) { //
mbedalvaro 1:a4050fee11f7 340 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 341
mbedalvaro 30:d8af03f01cd4 342 blobconf.initConfig(ONE_ELASTIC_MOUTH);
mbedalvaro 30:d8af03f01cd4 343
mbedalvaro 1:a4050fee11f7 344 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 345 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 346 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 19:228430f1350e 347
mbedalvaro 19:228430f1350e 348 } else if (!strcmp(address[0], "elastic_mouth_small")) { //
mbedalvaro 19:228430f1350e 349 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 350
mbedalvaro 30:d8af03f01cd4 351 blobconf.initConfig(ONE_ELASTIC_MOUTH_SMALL);
mbedalvaro 30:d8af03f01cd4 352
mbedalvaro 19:228430f1350e 353 lsr.setConfigToRender(&blobconf);
mbedalvaro 19:228430f1350e 354 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 19:228430f1350e 355 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 356 }
mbedalvaro 11:62f7183a03e7 357 else if (!strcmp(address[0], "spot_bouncing")) {
mbedalvaro 16:2ff1cb2ae1b1 358 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 359 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 360 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 361
mbedalvaro 30:d8af03f01cd4 362 blobconf.initConfig(BOUNCING_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 16:2ff1cb2ae1b1 363
mbedalvaro 16:2ff1cb2ae1b1 364 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 365 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 366 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 367 }
mbedalvaro 16:2ff1cb2ae1b1 368 }
mbedalvaro 16:2ff1cb2ae1b1 369
mbedalvaro 30:d8af03f01cd4 370 else if (!strcmp(address[0], "spot_lorentz")) {
mbedalvaro 27:1ce994629ffc 371 int value=data[0];
mbedalvaro 27:1ce994629ffc 372 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 27:1ce994629ffc 373 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 374
mbedalvaro 30:d8af03f01cd4 375 blobconf.initConfig(LORENTZ_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 27:1ce994629ffc 376
mbedalvaro 27:1ce994629ffc 377 lsr.setConfigToRender(&blobconf);
mbedalvaro 27:1ce994629ffc 378 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 379 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 380 }
mbedalvaro 27:1ce994629ffc 381 }
mbedalvaro 28:44b7b6e35548 382
mbedalvaro 28:44b7b6e35548 383 else if (!strcmp(address[0], "air_hockey")) {
mbedalvaro 28:44b7b6e35548 384 int value=data[0];
mbedalvaro 28:44b7b6e35548 385 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 28:44b7b6e35548 386 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 387
mbedalvaro 30:d8af03f01cd4 388 blobconf.initConfig(AIR_HOCKEY_GAME, value); // value is the nb of spots instantiated
mbedalvaro 28:44b7b6e35548 389
mbedalvaro 28:44b7b6e35548 390 lsr.setConfigToRender(&blobconf);
mbedalvaro 28:44b7b6e35548 391 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 392 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 393 }
mbedalvaro 28:44b7b6e35548 394 }
mbedalvaro 28:44b7b6e35548 395
mbedalvaro 28:44b7b6e35548 396 else if (!strcmp(address[0], "spot_following")) {
mbedalvaro 16:2ff1cb2ae1b1 397 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 398 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 399
mbedalvaro 16:2ff1cb2ae1b1 400 timerForRendering.detach();
mbedalvaro 22:d87317d7ca91 401
mbedalvaro 30:d8af03f01cd4 402 blobconf.initConfig(FOLLOWING_SPOTS, value); // value is the nb of spots instantiated
mbedalvaro 22:d87317d7ca91 403
mbedalvaro 16:2ff1cb2ae1b1 404 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 405 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 406 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 407 }
mbedalvaro 16:2ff1cb2ae1b1 408 }
mbedalvaro 16:2ff1cb2ae1b1 409
mbedalvaro 30:d8af03f01cd4 410 else if (!strcmp(address[0], "circular_pong")) {
mbedalvaro 30:d8af03f01cd4 411 int value=data[0];
mbedalvaro 30:d8af03f01cd4 412 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 30:d8af03f01cd4 413
mbedalvaro 30:d8af03f01cd4 414 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 415
mbedalvaro 30:d8af03f01cd4 416 blobconf.initConfig(CIRCULAR_PONG_GAME, value); // value is the nb of spots instantiated
mbedalvaro 30:d8af03f01cd4 417
mbedalvaro 30:d8af03f01cd4 418 lsr.setConfigToRender(&blobconf);
mbedalvaro 30:d8af03f01cd4 419 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 420 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 421 }
mbedalvaro 30:d8af03f01cd4 422 }
mbedalvaro 30:d8af03f01cd4 423
mbedalvaro 30:d8af03f01cd4 424 else if (!strcmp(address[0], "pac_man")) {
mbedalvaro 30:d8af03f01cd4 425 int value=data[0];
mbedalvaro 30:d8af03f01cd4 426 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 30:d8af03f01cd4 427
mbedalvaro 30:d8af03f01cd4 428 timerForRendering.detach();
mbedalvaro 30:d8af03f01cd4 429
mbedalvaro 30:d8af03f01cd4 430 blobconf.initConfig(PAC_MAN_GAME);
mbedalvaro 30:d8af03f01cd4 431
mbedalvaro 30:d8af03f01cd4 432 lsr.setConfigToRender(&blobconf);
mbedalvaro 30:d8af03f01cd4 433 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 434 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 30:d8af03f01cd4 435 }
mbedalvaro 30:d8af03f01cd4 436 }
mbedalvaro 30:d8af03f01cd4 437
mbedalvaro 30:d8af03f01cd4 438
mbedalvaro 16:2ff1cb2ae1b1 439 else if (!strcmp(address[0], "spot_test")) {
mbedalvaro 0:345b3bc7a0ea 440 timerForRendering.detach();
mbedalvaro 0:345b3bc7a0ea 441 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 442 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 443 blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 444 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 445 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 446 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 447 }
mbedalvaro 1:a4050fee11f7 448
mbedalvaro 1:a4050fee11f7 449 // other:
mbedalvaro 1:a4050fee11f7 450
mbedalvaro 24:4e52031a495b 451 else if ( !strcmp(address[0], "standby" ) ) { // will put ALL the blobs in stand by mode (no update function)
mbedalvaro 0:345b3bc7a0ea 452 blobconf.allStandBy(); // will avoid the update function
mbedalvaro 24:4e52031a495b 453 }
mbedalvaro 24:4e52031a495b 454 else if ( !strcmp(address[0], "resume" ) ) {
mbedalvaro 24:4e52031a495b 455 blobconf.allResume(); // Update function is called for all the blobs
mbedalvaro 1:a4050fee11f7 456 }
mbedalvaro 1:a4050fee11f7 457
mbedalvaro 1:a4050fee11f7 458 // (III) ========================================= Loop control (parameters, etc) ===========================================
mbedalvaro 19:228430f1350e 459
mbedalvaro 24:4e52031a495b 460 else if (!strcmp( address[0], "speedFactor" ) ) {
mbedalvaro 24:4e52031a495b 461 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 462 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 463 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 24:4e52031a495b 464 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 24:4e52031a495b 465 blobconf.blobArray[i]->speedFactor((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 466 }
mbedalvaro 24:4e52031a495b 467 }
mbedalvaro 24:4e52031a495b 468 }
mbedalvaro 24:4e52031a495b 469
mbedalvaro 24:4e52031a495b 470 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 24:4e52031a495b 471 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 472 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 473 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 24:4e52031a495b 474 }
mbedalvaro 24:4e52031a495b 475 }
mbedalvaro 24:4e52031a495b 476
mbedalvaro 24:4e52031a495b 477 else if (!strcmp( address[0], "adjustMinusAngle" ) ) {
mbedalvaro 24:4e52031a495b 478 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 479 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 480 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(-value);
mbedalvaro 24:4e52031a495b 481 }
mbedalvaro 24:4e52031a495b 482 }
mbedalvaro 24:4e52031a495b 483
mbedalvaro 1:a4050fee11f7 484 else if (!strcmp( address[0], "sendOSC" ) ) {
mbedalvaro 1:a4050fee11f7 485 int value=data[0];
mbedalvaro 1:a4050fee11f7 486 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 487 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 488 blobconf.blobArray[i]->sendOSC=(value>0);
mbedalvaro 1:a4050fee11f7 489 }
mbedalvaro 1:a4050fee11f7 490 }
mbedalvaro 1:a4050fee11f7 491 }
mbedalvaro 1:a4050fee11f7 492
mbedalvaro 1:a4050fee11f7 493 else if (!strcmp( address[0], "sendArea" ) ) {
mbedalvaro 1:a4050fee11f7 494 int value=data[0];
mbedalvaro 1:a4050fee11f7 495 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 496 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 497 blobconf.blobArray[i]->sendingBlobArea=(value>0);
mbedalvaro 1:a4050fee11f7 498 }
mbedalvaro 1:a4050fee11f7 499 }
mbedalvaro 1:a4050fee11f7 500 }
mbedalvaro 1:a4050fee11f7 501
mbedalvaro 1:a4050fee11f7 502 else if (!strcmp( address[0], "sendPos" ) ) {
mbedalvaro 1:a4050fee11f7 503 int value=data[0];
mbedalvaro 1:a4050fee11f7 504 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 505 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 506 blobconf.blobArray[i]->sendingLoopPositions=(value>0);
mbedalvaro 1:a4050fee11f7 507 }
mbedalvaro 1:a4050fee11f7 508 }
mbedalvaro 1:a4050fee11f7 509 }
mbedalvaro 1:a4050fee11f7 510
mbedalvaro 1:a4050fee11f7 511 else if (!strcmp( address[0], "sendRegions" ) ) {
mbedalvaro 1:a4050fee11f7 512 int value=data[0];
mbedalvaro 1:a4050fee11f7 513 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 514 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 515 blobconf.blobArray[i]->sendingLoopRegions=(value>0);
mbedalvaro 1:a4050fee11f7 516 }
mbedalvaro 1:a4050fee11f7 517 }
mbedalvaro 1:a4050fee11f7 518 }
mbedalvaro 1:a4050fee11f7 519
mbedalvaro 1:a4050fee11f7 520 else if (!strcmp( address[0], "sendTouched" ) ) {
mbedalvaro 1:a4050fee11f7 521 int value=data[0];
mbedalvaro 1:a4050fee11f7 522 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 523 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 524 blobconf.blobArray[i]->sendingTouched=(value>0);
mbedalvaro 1:a4050fee11f7 525 }
mbedalvaro 1:a4050fee11f7 526 }
mbedalvaro 1:a4050fee11f7 527 }
mbedalvaro 1:a4050fee11f7 528
mbedalvaro 1:a4050fee11f7 529
mbedalvaro 1:a4050fee11f7 530
mbedalvaro 0:345b3bc7a0ea 531 }
mbedalvaro 0:345b3bc7a0ea 532
mbedalvaro 0:345b3bc7a0ea 533 //============= RECEIVE OSC COMMANDS =========================
mbedalvaro 1:a4050fee11f7 534 // This is the callback function called when there are packets on the listening socket. It is not nice to have it
mbedalvaro 1:a4050fee11f7 535 // here, but for the time being having a "wrapping global" is the simplest solution (we cannot pass a member-function pointer
mbedalvaro 1:a4050fee11f7 536 // as handler to the upd object).
mbedalvaro 0:345b3bc7a0ea 537 void processOSC(UDPSocketEvent e) {
mbedalvaro 0:345b3bc7a0ea 538 osc.onUDPSocketEvent(e);
mbedalvaro 0:345b3bc7a0ea 539
mbedalvaro 0:345b3bc7a0ea 540 if (osc.newMessage) {
mbedalvaro 1:a4050fee11f7 541 // 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 542 // 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 543
mbedalvaro 1:a4050fee11f7 544 // Acquire the addresses and arguments and put them in the GLOBAL variables:
mbedalvaro 1:a4050fee11f7 545 strcpy(address[0],"");
mbedalvaro 1:a4050fee11f7 546 strcpy(address[1],"");
mbedalvaro 1:a4050fee11f7 547 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 548 // Acquire data:
mbedalvaro 1:a4050fee11f7 549 data[0]=-1;
mbedalvaro 1:a4050fee11f7 550 data[1]=-1;
mbedalvaro 1:a4050fee11f7 551 for (int i=0; i<recMes.getArgNum(); i++) data[i]=(int)recMes.getArgInt(i);
mbedalvaro 1:a4050fee11f7 552
mbedalvaro 1:a4050fee11f7 553 // Finally, interpret the command:
mbedalvaro 1:a4050fee11f7 554 interpretCommand();//address, data);
mbedalvaro 1:a4050fee11f7 555
mbedalvaro 0:345b3bc7a0ea 556 }
mbedalvaro 1:a4050fee11f7 557 }
mbedalvaro 1:a4050fee11f7 558
mbedalvaro 0:345b3bc7a0ea 559 //============= RECEIVE SERIAL COMMANDS =========================
mbedalvaro 0:345b3bc7a0ea 560 //
mbedalvaro 1:a4050fee11f7 561 // NOTE: - NUMERIC PARAMETERS have to be send BEFORE the command word. They must be sent as ASCII DEC, without end character.
mbedalvaro 0:345b3bc7a0ea 562 // - Commands words SHOULD NOT have numbers in it. They should be C compliant STRINGS (ended with character '0')
mbedalvaro 1:a4050fee11f7 563 // - order is irrelevant: we can send 10 RADIUS or RADIUS 10.
mbedalvaro 0:345b3bc7a0ea 564
mbedalvaro 1:a4050fee11f7 565 // String to store ALPHANUMERIC DATA (i.e., integers, floating point numbers, unsigned ints, etc represented as DEC) sent wirelessly:
mbedalvaro 0:345b3bc7a0ea 566 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 567 int indexStringData=0;//position of the byte in the string
mbedalvaro 0:345b3bc7a0ea 568
mbedalvaro 0:345b3bc7a0ea 569 // String to store COMMAND WORDS:
mbedalvaro 0:345b3bc7a0ea 570 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 571 int indexStringCommand=0;
mbedalvaro 0:345b3bc7a0ea 572 bool commandReady=false; // will become true when receiving the byte 0 (i.e. the '/0' string terminator)
mbedalvaro 0:345b3bc7a0ea 573
mbedalvaro 0:345b3bc7a0ea 574 void processSerial() {
mbedalvaro 0:345b3bc7a0ea 575
mbedalvaro 1:a4050fee11f7 576 while (pc.readable()>0) {
mbedalvaro 1:a4050fee11f7 577
mbedalvaro 14:0fc33a3a7b4b 578
mbedalvaro 1:a4050fee11f7 579 char val =pc.getc();
mbedalvaro 0:345b3bc7a0ea 580 // pc.printf("Got :%d\n", incomingByte);
mbedalvaro 1:a4050fee11f7 581 //pc.putc(incomingByte);
mbedalvaro 1:a4050fee11f7 582
mbedalvaro 1:a4050fee11f7 583 // Save ASCII numeric characters (ASCII 0 - 9) on stringData:
mbedalvaro 1:a4050fee11f7 584 if ((val >= '0') && (val <= '9')) { // this is 45 to 57 (included)
mbedalvaro 1:a4050fee11f7 585 stringData[indexStringData] = val;
mbedalvaro 1:a4050fee11f7 586 indexStringData++;
mbedalvaro 1:a4050fee11f7 587 }
mbedalvaro 1:a4050fee11f7 588
mbedalvaro 1:a4050fee11f7 589 // Save ASCII letters in stringCommand:
mbedalvaro 1:a4050fee11f7 590 if ((val >= 'A') && (val <= 'z')) { // this is 65 to 122 (included)
mbedalvaro 1:a4050fee11f7 591 stringCommand[indexStringCommand] = val;
mbedalvaro 1:a4050fee11f7 592 indexStringCommand++;
mbedalvaro 1:a4050fee11f7 593 }
mbedalvaro 1:a4050fee11f7 594 // is command ready?
mbedalvaro 1:a4050fee11f7 595 if (val=='/') {
mbedalvaro 1:a4050fee11f7 596 commandReady=true;
mbedalvaro 1:a4050fee11f7 597 stringCommand[indexStringCommand] = 0; // string termination.
mbedalvaro 1:a4050fee11f7 598 indexStringCommand=0; // reset index string for acquiring next command
mbedalvaro 1:a4050fee11f7 599 //Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 600 }
mbedalvaro 1:a4050fee11f7 601
mbedalvaro 1:a4050fee11f7 602 // COMMANDS (with or without numeric parameters):
mbedalvaro 1:a4050fee11f7 603 if (commandReady==true) { // it means we can interpret the command string:
mbedalvaro 1:a4050fee11f7 604 commandReady=false;
mbedalvaro 1:a4050fee11f7 605
mbedalvaro 1:a4050fee11f7 606 stringData[indexStringData] = 0 ;// string termination for numeric values;
mbedalvaro 1:a4050fee11f7 607 indexStringData=0;
mbedalvaro 1:a4050fee11f7 608
mbedalvaro 1:a4050fee11f7 609 // PARSE DATA: (TO DO!!!!!!!!!!!!!!):
mbedalvaro 0:345b3bc7a0ea 610
mbedalvaro 1:a4050fee11f7 611 // (a) Parse command (get address[0] and address[1]):
mbedalvaro 1:a4050fee11f7 612 //ex: "/1/standBy" -- > address[0]="1" and address[1]="standBy"
mbedalvaro 1:a4050fee11f7 613 // address[2]
mbedalvaro 1:a4050fee11f7 614
mbedalvaro 1:a4050fee11f7 615 // Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 616 // Serial.println(stringData);
mbedalvaro 1:a4050fee11f7 617
mbedalvaro 1:a4050fee11f7 618 // (b) Parse data:
mbedalvaro 1:a4050fee11f7 619
mbedalvaro 1:a4050fee11f7 620 // char address[2][24];
mbedalvaro 1:a4050fee11f7 621 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 622 //int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 623
mbedalvaro 1:a4050fee11f7 624 // FOR THE TIME BEING there is no parsing for serial commands:
mbedalvaro 1:a4050fee11f7 625
mbedalvaro 1:a4050fee11f7 626 // SCANNING:
mbedalvaro 1:a4050fee11f7 627 if (!strcmp(stringCommand , "takeSnapshot")) {
mbedalvaro 1:a4050fee11f7 628 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 629 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 630
mbedalvaro 1:a4050fee11f7 631 // Then, do the scan (sending values on serial port):
mbedalvaro 24:4e52031a495b 632 IO.scan_serial(atoi(stringData));
mbedalvaro 1:a4050fee11f7 633
mbedalvaro 1:a4050fee11f7 634 // Finally, start again threaded display:
mbedalvaro 4:f9d364f10335 635 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 636 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 637 } else if (!strcmp(stringCommand , "REDON")) IO.setRedPower(1); // pc.printf("%d\n",incomingByte);
mbedalvaro 1:a4050fee11f7 638
mbedalvaro 14:0fc33a3a7b4b 639 else if (!strcmp(stringCommand , "REDOFF")) IO.setRedPower(0);
mbedalvaro 14:0fc33a3a7b4b 640
mbedalvaro 14:0fc33a3a7b4b 641 else if (!strcmp(stringCommand , "READVALUE")) pc.printf("Value read: %f", lockin.getSmoothValue());//lockin.getLastValue());/
mbedalvaro 1:a4050fee11f7 642
mbedalvaro 14:0fc33a3a7b4b 643 else if (!strcmp(stringCommand , "mbedReset")) mbed_reset();
mbedalvaro 16:2ff1cb2ae1b1 644
mbedalvaro 14:0fc33a3a7b4b 645 else if (!strcmp(stringCommand , "calibrate")) {
mbedalvaro 16:2ff1cb2ae1b1 646 // First, we need to disable the threaded display for the loop:
mbedalvaro 16:2ff1cb2ae1b1 647 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 648 // RESCAN (and save LUT table):
mbedalvaro 16:2ff1cb2ae1b1 649 IO.scanLUT();
mbedalvaro 16:2ff1cb2ae1b1 650 // Finally, start again threaded display:
mbedalvaro 16:2ff1cb2ae1b1 651 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 652 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 653 }
mbedalvaro 1:a4050fee11f7 654
mbedalvaro 1:a4050fee11f7 655 // FINALLY, interpret commands (but only after parsing):
mbedalvaro 1:a4050fee11f7 656 // interpretCommand();//address, data);
mbedalvaro 0:345b3bc7a0ea 657
mbedalvaro 0:345b3bc7a0ea 658 }
mbedalvaro 1:a4050fee11f7 659 }
mbedalvaro 1:a4050fee11f7 660 }
mbedalvaro 0:345b3bc7a0ea 661
mbedalvaro 0:345b3bc7a0ea 662
mbedalvaro 0:345b3bc7a0ea 663
mbedalvaro 0:345b3bc7a0ea 664 // ================ MISCELANEA
mbedalvaro 0:345b3bc7a0ea 665
mbedalvaro 0:345b3bc7a0ea 666 /* EXAMPLE SEND/RECEIVE on PROCESSING:
mbedalvaro 0:345b3bc7a0ea 667
mbedalvaro 0:345b3bc7a0ea 668 // oscP5sendreceive by andreas schlegel
mbedalvaro 0:345b3bc7a0ea 669 // example shows how to send and receive osc messages.
mbedalvaro 0:345b3bc7a0ea 670 // oscP5 website at http://www.sojamo.de/oscP5
mbedalvaro 0:345b3bc7a0ea 671
mbedalvaro 0:345b3bc7a0ea 672 import oscP5.*;
mbedalvaro 0:345b3bc7a0ea 673 import netP5.*;
mbedalvaro 1:a4050fee11f7 674
mbedalvaro 0:345b3bc7a0ea 675 OscP5 oscP5;
mbedalvaro 0:345b3bc7a0ea 676 NetAddress myRemoteLocation;
mbedalvaro 0:345b3bc7a0ea 677
mbedalvaro 0:345b3bc7a0ea 678 void setup() {
mbedalvaro 0:345b3bc7a0ea 679 size(400,400);
mbedalvaro 0:345b3bc7a0ea 680 frameRate(25);
mbedalvaro 1:a4050fee11f7 681 // start oscP5, listening for incoming messages at port 12000
mbedalvaro 0:345b3bc7a0ea 682 oscP5 = new OscP5(this,12000);
mbedalvaro 1:a4050fee11f7 683
mbedalvaro 0:345b3bc7a0ea 684 // myRemoteLocation is a NetAddress. a NetAddress takes 2 parameters,
mbedalvaro 0:345b3bc7a0ea 685 // an ip address and a port number. myRemoteLocation is used as parameter in
mbedalvaro 1:a4050fee11f7 686 // oscP5.send() when sending osc packets to another computer, device,
mbedalvaro 0:345b3bc7a0ea 687 // application. usage see below. for testing purposes the listening port
mbedalvaro 0:345b3bc7a0ea 688 // and the port of the remote location address are the same, hence you will
mbedalvaro 0:345b3bc7a0ea 689 // send messages back to this sketch.
mbedalvaro 0:345b3bc7a0ea 690 myRemoteLocation = new NetAddress("10.0.0.2",10000);
mbedalvaro 0:345b3bc7a0ea 691 }
mbedalvaro 0:345b3bc7a0ea 692
mbedalvaro 0:345b3bc7a0ea 693
mbedalvaro 0:345b3bc7a0ea 694 void draw() {
mbedalvaro 1:a4050fee11f7 695 background(0);
mbedalvaro 0:345b3bc7a0ea 696 }
mbedalvaro 0:345b3bc7a0ea 697
mbedalvaro 0:345b3bc7a0ea 698 void mousePressed() {
mbedalvaro 1:a4050fee11f7 699 // in the following different ways of creating osc messages are shown by example
mbedalvaro 0:345b3bc7a0ea 700 OscMessage myMessage = new OscMessage("/mbed/test1");
mbedalvaro 1:a4050fee11f7 701
mbedalvaro 1:a4050fee11f7 702 myMessage.add(123); // add an int to the osc message
mbedalvaro 0:345b3bc7a0ea 703
mbedalvaro 1:a4050fee11f7 704 // send the message
mbedalvaro 1:a4050fee11f7 705 oscP5.send(myMessage, myRemoteLocation);
mbedalvaro 0:345b3bc7a0ea 706 }
mbedalvaro 0:345b3bc7a0ea 707
mbedalvaro 0:345b3bc7a0ea 708
mbedalvaro 1:a4050fee11f7 709 // incoming osc message are forwarded to the oscEvent method.
mbedalvaro 0:345b3bc7a0ea 710 void oscEvent(OscMessage theOscMessage) {
mbedalvaro 1:a4050fee11f7 711 // print the address pattern and the typetag of the received OscMessage
mbedalvaro 0:345b3bc7a0ea 712 print("### received an osc message.");
mbedalvaro 0:345b3bc7a0ea 713 print(" addrpattern: "+theOscMessage.addrPattern());
mbedalvaro 0:345b3bc7a0ea 714 println(" typetag: "+theOscMessage.typetag());
mbedalvaro 0:345b3bc7a0ea 715 }
mbedalvaro 0:345b3bc7a0ea 716
mbedalvaro 0:345b3bc7a0ea 717 */