Alvaro Cassinelli / Mbed 2 deprecated skinGames_forktest

just a test

Dependencies:   mbed

Fork of scoreLight_Advanced by Alvaro Cassinelli

main.cpp@32:52273c3291fe, 2012-10-29 (annotated)

Committer:
mbedalvaro
Date:
Mon Oct 29 14:28:47 2012 +0000
Revision:
32:52273c3291fe
Parent:
31:5f039cbddee8
Child:
33:43e8bc451ef0
code for Tokyo design week (starting with two colored following spots, and NO standby mode)

Who changed what in which revision?

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