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@29:2fc8c12822eb, 2012-06-20 (annotated)

Committer:
mbedalvaro
Date:
Wed Jun 20 03:25:49 2012 +0000
Revision:
29:2fc8c12822eb
Parent:
28:44b7b6e35548
Child:
30:d8af03f01cd4
compiled at asahiTV

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 0:345b3bc7a0ea 332 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 333 blobconf.clearConfig();
mbedalvaro 1:a4050fee11f7 334 blobconf.addOneElasticContourFollowing();
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 1:a4050fee11f7 341 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 342 blobconf.clearConfig();
mbedalvaro 1:a4050fee11f7 343 blobconf.addOneElasticLoopContractCentral();
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 19:228430f1350e 350 // blobconf.computeBoundingBox();
mbedalvaro 19:228430f1350e 351 blobconf.clearConfig();
mbedalvaro 19:228430f1350e 352 blobconf.addOneElasticLoopContractCentralFast();
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
mbedalvaro 16:2ff1cb2ae1b1 361 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 362 // blobconf.computeBoundingBox();
mbedalvaro 16:2ff1cb2ae1b1 363 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 364
mbedalvaro 22:d87317d7ca91 365 // HACK for the time being:
mbedalvaro 24:4e52031a495b 366 /*
mbedalvaro 22:d87317d7ca91 367 int aux=rand()%100;
mbedalvaro 22:d87317d7ca91 368 if (aux<70) value=1;
mbedalvaro 22:d87317d7ca91 369 else if (aux<80) value=2;
mbedalvaro 22:d87317d7ca91 370 else value=3;
mbedalvaro 24:4e52031a495b 371 */
mbedalvaro 22:d87317d7ca91 372
mbedalvaro 16:2ff1cb2ae1b1 373 for (int i=0; i<value ; i++) blobconf.addOneRigidLoopBouncing();
mbedalvaro 16:2ff1cb2ae1b1 374
mbedalvaro 16:2ff1cb2ae1b1 375 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 376 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 377 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 378 }
mbedalvaro 16:2ff1cb2ae1b1 379 }
mbedalvaro 16:2ff1cb2ae1b1 380
mbedalvaro 27:1ce994629ffc 381 else if (!strcmp(address[0], "spot_fountain")) {
mbedalvaro 27:1ce994629ffc 382 int value=data[0];
mbedalvaro 27:1ce994629ffc 383 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 27:1ce994629ffc 384
mbedalvaro 27:1ce994629ffc 385 timerForRendering.detach();
mbedalvaro 27:1ce994629ffc 386 // blobconf.computeBoundingBox();
mbedalvaro 27:1ce994629ffc 387 blobconf.clearConfig();
mbedalvaro 27:1ce994629ffc 388
mbedalvaro 27:1ce994629ffc 389 for (int i=0; i<value ; i++) blobconf.addOneRigidLoopFountain();
mbedalvaro 27:1ce994629ffc 390
mbedalvaro 27:1ce994629ffc 391 lsr.setConfigToRender(&blobconf);
mbedalvaro 27:1ce994629ffc 392 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 393 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 27:1ce994629ffc 394 }
mbedalvaro 27:1ce994629ffc 395 }
mbedalvaro 28:44b7b6e35548 396
mbedalvaro 28:44b7b6e35548 397 else if (!strcmp(address[0], "air_hockey")) {
mbedalvaro 28:44b7b6e35548 398 int value=data[0];
mbedalvaro 28:44b7b6e35548 399 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 28:44b7b6e35548 400
mbedalvaro 28:44b7b6e35548 401 timerForRendering.detach();
mbedalvaro 28:44b7b6e35548 402 // blobconf.computeBoundingBox();
mbedalvaro 28:44b7b6e35548 403 blobconf.clearConfig();
mbedalvaro 28:44b7b6e35548 404
mbedalvaro 28:44b7b6e35548 405 for (int i=0; i<value ; i++) blobconf.addOneRigidLoopAirHockey();
mbedalvaro 28:44b7b6e35548 406
mbedalvaro 28:44b7b6e35548 407 lsr.setConfigToRender(&blobconf);
mbedalvaro 28:44b7b6e35548 408 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 409 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 28:44b7b6e35548 410 }
mbedalvaro 28:44b7b6e35548 411 }
mbedalvaro 28:44b7b6e35548 412
mbedalvaro 28:44b7b6e35548 413 else if (!strcmp(address[0], "spot_following")) {
mbedalvaro 16:2ff1cb2ae1b1 414 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 415 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 416
mbedalvaro 16:2ff1cb2ae1b1 417 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 418 // blobconf.computeBoundingBox();
mbedalvaro 16:2ff1cb2ae1b1 419 blobconf.clearConfig();
mbedalvaro 22:d87317d7ca91 420
mbedalvaro 22:d87317d7ca91 421 // HACK for the time being:
mbedalvaro 24:4e52031a495b 422 /*
mbedalvaro 22:d87317d7ca91 423 int aux=rand()%100;
mbedalvaro 22:d87317d7ca91 424 if (aux<70) value=1;
mbedalvaro 22:d87317d7ca91 425 else if (aux<80) value=2;
mbedalvaro 22:d87317d7ca91 426 else value=6;
mbedalvaro 24:4e52031a495b 427 */
mbedalvaro 22:d87317d7ca91 428
mbedalvaro 16:2ff1cb2ae1b1 429 for (int i=0; i<value ; i++) blobconf.addOneRigidLoopFollowing();
mbedalvaro 22:d87317d7ca91 430
mbedalvaro 22:d87317d7ca91 431
mbedalvaro 16:2ff1cb2ae1b1 432 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 433 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 434 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 435 }
mbedalvaro 16:2ff1cb2ae1b1 436 }
mbedalvaro 16:2ff1cb2ae1b1 437
mbedalvaro 16:2ff1cb2ae1b1 438 else if (!strcmp(address[0], "spot_test")) {
mbedalvaro 0:345b3bc7a0ea 439 timerForRendering.detach();
mbedalvaro 0:345b3bc7a0ea 440 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 441 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 442 blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 443 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 444 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 445 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 446 }
mbedalvaro 1:a4050fee11f7 447
mbedalvaro 1:a4050fee11f7 448 // other:
mbedalvaro 1:a4050fee11f7 449
mbedalvaro 24:4e52031a495b 450 else if ( !strcmp(address[0], "standby" ) ) { // will put ALL the blobs in stand by mode (no update function)
mbedalvaro 0:345b3bc7a0ea 451 blobconf.allStandBy(); // will avoid the update function
mbedalvaro 24:4e52031a495b 452 }
mbedalvaro 24:4e52031a495b 453 else if ( !strcmp(address[0], "resume" ) ) {
mbedalvaro 24:4e52031a495b 454 blobconf.allResume(); // Update function is called for all the blobs
mbedalvaro 1:a4050fee11f7 455 }
mbedalvaro 1:a4050fee11f7 456
mbedalvaro 1:a4050fee11f7 457 // (III) ========================================= Loop control (parameters, etc) ===========================================
mbedalvaro 19:228430f1350e 458
mbedalvaro 24:4e52031a495b 459 else if (!strcmp( address[0], "speedFactor" ) ) {
mbedalvaro 24:4e52031a495b 460 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 461 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 462 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 24:4e52031a495b 463 //if ((!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))||(!strcmp(blobconf.blobArray[i].spotName, "rigid_following"))) {
mbedalvaro 24:4e52031a495b 464 blobconf.blobArray[i]->speedFactor((float)(1.0*value/100.0));
mbedalvaro 24:4e52031a495b 465 }
mbedalvaro 24:4e52031a495b 466 }
mbedalvaro 24:4e52031a495b 467 }
mbedalvaro 24:4e52031a495b 468
mbedalvaro 24:4e52031a495b 469 else if (!strcmp( address[0], "adjustPlusAngle" ) ) {
mbedalvaro 24:4e52031a495b 470 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 471 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 472 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(value);
mbedalvaro 24:4e52031a495b 473 }
mbedalvaro 24:4e52031a495b 474 }
mbedalvaro 24:4e52031a495b 475
mbedalvaro 24:4e52031a495b 476 else if (!strcmp( address[0], "adjustMinusAngle" ) ) {
mbedalvaro 24:4e52031a495b 477 int value=data[0]; // value 100 means no change of speed. 200 is twice as fast, 50 is half as fast.
mbedalvaro 24:4e52031a495b 478 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 24:4e52031a495b 479 for (int i=0; i< blobconf.numBlobs; i++) blobconf.blobArray[i]->displaySensingBuffer.addDelayMirrors(-value);
mbedalvaro 24:4e52031a495b 480 }
mbedalvaro 24:4e52031a495b 481 }
mbedalvaro 24:4e52031a495b 482
mbedalvaro 1:a4050fee11f7 483 else if (!strcmp( address[0], "sendOSC" ) ) {
mbedalvaro 1:a4050fee11f7 484 int value=data[0];
mbedalvaro 1:a4050fee11f7 485 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 486 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 487 blobconf.blobArray[i]->sendOSC=(value>0);
mbedalvaro 1:a4050fee11f7 488 }
mbedalvaro 1:a4050fee11f7 489 }
mbedalvaro 1:a4050fee11f7 490 }
mbedalvaro 1:a4050fee11f7 491
mbedalvaro 1:a4050fee11f7 492 else if (!strcmp( address[0], "sendArea" ) ) {
mbedalvaro 1:a4050fee11f7 493 int value=data[0];
mbedalvaro 1:a4050fee11f7 494 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 495 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 496 blobconf.blobArray[i]->sendingBlobArea=(value>0);
mbedalvaro 1:a4050fee11f7 497 }
mbedalvaro 1:a4050fee11f7 498 }
mbedalvaro 1:a4050fee11f7 499 }
mbedalvaro 1:a4050fee11f7 500
mbedalvaro 1:a4050fee11f7 501 else if (!strcmp( address[0], "sendPos" ) ) {
mbedalvaro 1:a4050fee11f7 502 int value=data[0];
mbedalvaro 1:a4050fee11f7 503 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 504 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 505 blobconf.blobArray[i]->sendingLoopPositions=(value>0);
mbedalvaro 1:a4050fee11f7 506 }
mbedalvaro 1:a4050fee11f7 507 }
mbedalvaro 1:a4050fee11f7 508 }
mbedalvaro 1:a4050fee11f7 509
mbedalvaro 1:a4050fee11f7 510 else if (!strcmp( address[0], "sendRegions" ) ) {
mbedalvaro 1:a4050fee11f7 511 int value=data[0];
mbedalvaro 1:a4050fee11f7 512 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 513 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 514 blobconf.blobArray[i]->sendingLoopRegions=(value>0);
mbedalvaro 1:a4050fee11f7 515 }
mbedalvaro 1:a4050fee11f7 516 }
mbedalvaro 1:a4050fee11f7 517 }
mbedalvaro 1:a4050fee11f7 518
mbedalvaro 1:a4050fee11f7 519 else if (!strcmp( address[0], "sendTouched" ) ) {
mbedalvaro 1:a4050fee11f7 520 int value=data[0];
mbedalvaro 1:a4050fee11f7 521 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 522 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 523 blobconf.blobArray[i]->sendingTouched=(value>0);
mbedalvaro 1:a4050fee11f7 524 }
mbedalvaro 1:a4050fee11f7 525 }
mbedalvaro 1:a4050fee11f7 526 }
mbedalvaro 1:a4050fee11f7 527
mbedalvaro 1:a4050fee11f7 528
mbedalvaro 1:a4050fee11f7 529
mbedalvaro 0:345b3bc7a0ea 530 }
mbedalvaro 0:345b3bc7a0ea 531
mbedalvaro 0:345b3bc7a0ea 532 //============= RECEIVE OSC COMMANDS =========================
mbedalvaro 1:a4050fee11f7 533 // This is the callback function called when there are packets on the listening socket. It is not nice to have it
mbedalvaro 1:a4050fee11f7 534 // here, but for the time being having a "wrapping global" is the simplest solution (we cannot pass a member-function pointer
mbedalvaro 1:a4050fee11f7 535 // as handler to the upd object).
mbedalvaro 0:345b3bc7a0ea 536 void processOSC(UDPSocketEvent e) {
mbedalvaro 0:345b3bc7a0ea 537 osc.onUDPSocketEvent(e);
mbedalvaro 0:345b3bc7a0ea 538
mbedalvaro 0:345b3bc7a0ea 539 if (osc.newMessage) {
mbedalvaro 1:a4050fee11f7 540 // 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 541 // 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 542
mbedalvaro 1:a4050fee11f7 543 // Acquire the addresses and arguments and put them in the GLOBAL variables:
mbedalvaro 1:a4050fee11f7 544 strcpy(address[0],"");
mbedalvaro 1:a4050fee11f7 545 strcpy(address[1],"");
mbedalvaro 1:a4050fee11f7 546 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 547 // Acquire data:
mbedalvaro 1:a4050fee11f7 548 data[0]=-1;
mbedalvaro 1:a4050fee11f7 549 data[1]=-1;
mbedalvaro 1:a4050fee11f7 550 for (int i=0; i<recMes.getArgNum(); i++) data[i]=(int)recMes.getArgInt(i);
mbedalvaro 1:a4050fee11f7 551
mbedalvaro 1:a4050fee11f7 552 // Finally, interpret the command:
mbedalvaro 1:a4050fee11f7 553 interpretCommand();//address, data);
mbedalvaro 1:a4050fee11f7 554
mbedalvaro 0:345b3bc7a0ea 555 }
mbedalvaro 1:a4050fee11f7 556 }
mbedalvaro 1:a4050fee11f7 557
mbedalvaro 0:345b3bc7a0ea 558 //============= RECEIVE SERIAL COMMANDS =========================
mbedalvaro 0:345b3bc7a0ea 559 //
mbedalvaro 1:a4050fee11f7 560 // NOTE: - NUMERIC PARAMETERS have to be send BEFORE the command word. They must be sent as ASCII DEC, without end character.
mbedalvaro 0:345b3bc7a0ea 561 // - Commands words SHOULD NOT have numbers in it. They should be C compliant STRINGS (ended with character '0')
mbedalvaro 1:a4050fee11f7 562 // - order is irrelevant: we can send 10 RADIUS or RADIUS 10.
mbedalvaro 0:345b3bc7a0ea 563
mbedalvaro 1:a4050fee11f7 564 // String to store ALPHANUMERIC DATA (i.e., integers, floating point numbers, unsigned ints, etc represented as DEC) sent wirelessly:
mbedalvaro 0:345b3bc7a0ea 565 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 566 int indexStringData=0;//position of the byte in the string
mbedalvaro 0:345b3bc7a0ea 567
mbedalvaro 0:345b3bc7a0ea 568 // String to store COMMAND WORDS:
mbedalvaro 0:345b3bc7a0ea 569 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 570 int indexStringCommand=0;
mbedalvaro 0:345b3bc7a0ea 571 bool commandReady=false; // will become true when receiving the byte 0 (i.e. the '/0' string terminator)
mbedalvaro 0:345b3bc7a0ea 572
mbedalvaro 0:345b3bc7a0ea 573 void processSerial() {
mbedalvaro 0:345b3bc7a0ea 574
mbedalvaro 1:a4050fee11f7 575 while (pc.readable()>0) {
mbedalvaro 1:a4050fee11f7 576
mbedalvaro 14:0fc33a3a7b4b 577
mbedalvaro 1:a4050fee11f7 578 char val =pc.getc();
mbedalvaro 0:345b3bc7a0ea 579 // pc.printf("Got :%d\n", incomingByte);
mbedalvaro 1:a4050fee11f7 580 //pc.putc(incomingByte);
mbedalvaro 1:a4050fee11f7 581
mbedalvaro 1:a4050fee11f7 582 // Save ASCII numeric characters (ASCII 0 - 9) on stringData:
mbedalvaro 1:a4050fee11f7 583 if ((val >= '0') && (val <= '9')) { // this is 45 to 57 (included)
mbedalvaro 1:a4050fee11f7 584 stringData[indexStringData] = val;
mbedalvaro 1:a4050fee11f7 585 indexStringData++;
mbedalvaro 1:a4050fee11f7 586 }
mbedalvaro 1:a4050fee11f7 587
mbedalvaro 1:a4050fee11f7 588 // Save ASCII letters in stringCommand:
mbedalvaro 1:a4050fee11f7 589 if ((val >= 'A') && (val <= 'z')) { // this is 65 to 122 (included)
mbedalvaro 1:a4050fee11f7 590 stringCommand[indexStringCommand] = val;
mbedalvaro 1:a4050fee11f7 591 indexStringCommand++;
mbedalvaro 1:a4050fee11f7 592 }
mbedalvaro 1:a4050fee11f7 593 // is command ready?
mbedalvaro 1:a4050fee11f7 594 if (val=='/') {
mbedalvaro 1:a4050fee11f7 595 commandReady=true;
mbedalvaro 1:a4050fee11f7 596 stringCommand[indexStringCommand] = 0; // string termination.
mbedalvaro 1:a4050fee11f7 597 indexStringCommand=0; // reset index string for acquiring next command
mbedalvaro 1:a4050fee11f7 598 //Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 599 }
mbedalvaro 1:a4050fee11f7 600
mbedalvaro 1:a4050fee11f7 601 // COMMANDS (with or without numeric parameters):
mbedalvaro 1:a4050fee11f7 602 if (commandReady==true) { // it means we can interpret the command string:
mbedalvaro 1:a4050fee11f7 603 commandReady=false;
mbedalvaro 1:a4050fee11f7 604
mbedalvaro 1:a4050fee11f7 605 stringData[indexStringData] = 0 ;// string termination for numeric values;
mbedalvaro 1:a4050fee11f7 606 indexStringData=0;
mbedalvaro 1:a4050fee11f7 607
mbedalvaro 1:a4050fee11f7 608 // PARSE DATA: (TO DO!!!!!!!!!!!!!!):
mbedalvaro 0:345b3bc7a0ea 609
mbedalvaro 1:a4050fee11f7 610 // (a) Parse command (get address[0] and address[1]):
mbedalvaro 1:a4050fee11f7 611 //ex: "/1/standBy" -- > address[0]="1" and address[1]="standBy"
mbedalvaro 1:a4050fee11f7 612 // address[2]
mbedalvaro 1:a4050fee11f7 613
mbedalvaro 1:a4050fee11f7 614 // Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 615 // Serial.println(stringData);
mbedalvaro 1:a4050fee11f7 616
mbedalvaro 1:a4050fee11f7 617 // (b) Parse data:
mbedalvaro 1:a4050fee11f7 618
mbedalvaro 1:a4050fee11f7 619 // char address[2][24];
mbedalvaro 1:a4050fee11f7 620 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 621 //int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 622
mbedalvaro 1:a4050fee11f7 623 // FOR THE TIME BEING there is no parsing for serial commands:
mbedalvaro 1:a4050fee11f7 624
mbedalvaro 1:a4050fee11f7 625 // SCANNING:
mbedalvaro 1:a4050fee11f7 626 if (!strcmp(stringCommand , "takeSnapshot")) {
mbedalvaro 1:a4050fee11f7 627 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 628 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 629
mbedalvaro 1:a4050fee11f7 630 // Then, do the scan (sending values on serial port):
mbedalvaro 24:4e52031a495b 631 IO.scan_serial(atoi(stringData));
mbedalvaro 1:a4050fee11f7 632
mbedalvaro 1:a4050fee11f7 633 // Finally, start again threaded display:
mbedalvaro 4:f9d364f10335 634 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 635 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 636 } else if (!strcmp(stringCommand , "REDON")) IO.setRedPower(1); // pc.printf("%d\n",incomingByte);
mbedalvaro 1:a4050fee11f7 637
mbedalvaro 14:0fc33a3a7b4b 638 else if (!strcmp(stringCommand , "REDOFF")) IO.setRedPower(0);
mbedalvaro 14:0fc33a3a7b4b 639
mbedalvaro 14:0fc33a3a7b4b 640 else if (!strcmp(stringCommand , "READVALUE")) pc.printf("Value read: %f", lockin.getSmoothValue());//lockin.getLastValue());/
mbedalvaro 1:a4050fee11f7 641
mbedalvaro 14:0fc33a3a7b4b 642 else if (!strcmp(stringCommand , "mbedReset")) mbed_reset();
mbedalvaro 16:2ff1cb2ae1b1 643
mbedalvaro 14:0fc33a3a7b4b 644 else if (!strcmp(stringCommand , "calibrate")) {
mbedalvaro 16:2ff1cb2ae1b1 645 // First, we need to disable the threaded display for the loop:
mbedalvaro 16:2ff1cb2ae1b1 646 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 647 // RESCAN (and save LUT table):
mbedalvaro 16:2ff1cb2ae1b1 648 IO.scanLUT();
mbedalvaro 16:2ff1cb2ae1b1 649 // Finally, start again threaded display:
mbedalvaro 16:2ff1cb2ae1b1 650 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 651 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 652 }
mbedalvaro 1:a4050fee11f7 653
mbedalvaro 1:a4050fee11f7 654 // FINALLY, interpret commands (but only after parsing):
mbedalvaro 1:a4050fee11f7 655 // interpretCommand();//address, data);
mbedalvaro 0:345b3bc7a0ea 656
mbedalvaro 0:345b3bc7a0ea 657 }
mbedalvaro 1:a4050fee11f7 658 }
mbedalvaro 1:a4050fee11f7 659 }
mbedalvaro 0:345b3bc7a0ea 660
mbedalvaro 0:345b3bc7a0ea 661
mbedalvaro 0:345b3bc7a0ea 662
mbedalvaro 0:345b3bc7a0ea 663 // ================ MISCELANEA
mbedalvaro 0:345b3bc7a0ea 664
mbedalvaro 0:345b3bc7a0ea 665 /* EXAMPLE SEND/RECEIVE on PROCESSING:
mbedalvaro 0:345b3bc7a0ea 666
mbedalvaro 0:345b3bc7a0ea 667 // oscP5sendreceive by andreas schlegel
mbedalvaro 0:345b3bc7a0ea 668 // example shows how to send and receive osc messages.
mbedalvaro 0:345b3bc7a0ea 669 // oscP5 website at http://www.sojamo.de/oscP5
mbedalvaro 0:345b3bc7a0ea 670
mbedalvaro 0:345b3bc7a0ea 671 import oscP5.*;
mbedalvaro 0:345b3bc7a0ea 672 import netP5.*;
mbedalvaro 1:a4050fee11f7 673
mbedalvaro 0:345b3bc7a0ea 674 OscP5 oscP5;
mbedalvaro 0:345b3bc7a0ea 675 NetAddress myRemoteLocation;
mbedalvaro 0:345b3bc7a0ea 676
mbedalvaro 0:345b3bc7a0ea 677 void setup() {
mbedalvaro 0:345b3bc7a0ea 678 size(400,400);
mbedalvaro 0:345b3bc7a0ea 679 frameRate(25);
mbedalvaro 1:a4050fee11f7 680 // start oscP5, listening for incoming messages at port 12000
mbedalvaro 0:345b3bc7a0ea 681 oscP5 = new OscP5(this,12000);
mbedalvaro 1:a4050fee11f7 682
mbedalvaro 0:345b3bc7a0ea 683 // myRemoteLocation is a NetAddress. a NetAddress takes 2 parameters,
mbedalvaro 0:345b3bc7a0ea 684 // an ip address and a port number. myRemoteLocation is used as parameter in
mbedalvaro 1:a4050fee11f7 685 // oscP5.send() when sending osc packets to another computer, device,
mbedalvaro 0:345b3bc7a0ea 686 // application. usage see below. for testing purposes the listening port
mbedalvaro 0:345b3bc7a0ea 687 // and the port of the remote location address are the same, hence you will
mbedalvaro 0:345b3bc7a0ea 688 // send messages back to this sketch.
mbedalvaro 0:345b3bc7a0ea 689 myRemoteLocation = new NetAddress("10.0.0.2",10000);
mbedalvaro 0:345b3bc7a0ea 690 }
mbedalvaro 0:345b3bc7a0ea 691
mbedalvaro 0:345b3bc7a0ea 692
mbedalvaro 0:345b3bc7a0ea 693 void draw() {
mbedalvaro 1:a4050fee11f7 694 background(0);
mbedalvaro 0:345b3bc7a0ea 695 }
mbedalvaro 0:345b3bc7a0ea 696
mbedalvaro 0:345b3bc7a0ea 697 void mousePressed() {
mbedalvaro 1:a4050fee11f7 698 // in the following different ways of creating osc messages are shown by example
mbedalvaro 0:345b3bc7a0ea 699 OscMessage myMessage = new OscMessage("/mbed/test1");
mbedalvaro 1:a4050fee11f7 700
mbedalvaro 1:a4050fee11f7 701 myMessage.add(123); // add an int to the osc message
mbedalvaro 0:345b3bc7a0ea 702
mbedalvaro 1:a4050fee11f7 703 // send the message
mbedalvaro 1:a4050fee11f7 704 oscP5.send(myMessage, myRemoteLocation);
mbedalvaro 0:345b3bc7a0ea 705 }
mbedalvaro 0:345b3bc7a0ea 706
mbedalvaro 0:345b3bc7a0ea 707
mbedalvaro 1:a4050fee11f7 708 // incoming osc message are forwarded to the oscEvent method.
mbedalvaro 0:345b3bc7a0ea 709 void oscEvent(OscMessage theOscMessage) {
mbedalvaro 1:a4050fee11f7 710 // print the address pattern and the typetag of the received OscMessage
mbedalvaro 0:345b3bc7a0ea 711 print("### received an osc message.");
mbedalvaro 0:345b3bc7a0ea 712 print(" addrpattern: "+theOscMessage.addrPattern());
mbedalvaro 0:345b3bc7a0ea 713 println(" typetag: "+theOscMessage.typetag());
mbedalvaro 0:345b3bc7a0ea 714 }
mbedalvaro 0:345b3bc7a0ea 715
mbedalvaro 0:345b3bc7a0ea 716 */