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@18:d72935b13858, 2012-04-28 (annotated)

Committer:
mbedalvaro
Date:
Sat Apr 28 12:35:21 2012 +0000
Revision:
18:d72935b13858
Parent:
17:356ca5690a59
Child:
19:228430f1350e
this works pretty nicely. I will change some parameters on the elastic loop, as well as compute the KINETIC ENERGY

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 0:345b3bc7a0ea 15 //DigitalOut myled3(LED2);
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 0:345b3bc7a0ea 41 uint8_t destIp[] = { 10, 0, 0, 1};
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 16:2ff1cb2ae1b1 114 blobconf.addOneRigidLoopFollowing();
mbedalvaro 2:34157ebbf56b 115
mbedalvaro 7:0df17f3078bc 116
mbedalvaro 5:73cd58b58f95 117 //blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 118
mbedalvaro 0:345b3bc7a0ea 119 // Important: first, set the initial position for all the blobs, this will be useful because
mbedalvaro 0:345b3bc7a0ea 120 // when changing modes we can use the previous central position...
mbedalvaro 1:a4050fee11f7 121 // blobconf.setInitialPos(CENTER_AD_MIRROR_X, CENTER_AD_MIRROR_Y);
mbedalvaro 1:a4050fee11f7 122
mbedalvaro 5:73cd58b58f95 123 // draw the config once befor activating the laser buffer:
mbedalvaro 5:73cd58b58f95 124 blobconf.draw();
mbedalvaro 13:9f03eac02700 125 lsr.startFullDisplay();
mbedalvaro 1:a4050fee11f7 126
mbedalvaro 0:345b3bc7a0ea 127 // 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 128 lsr.setConfigToRender(&blobconf);
mbedalvaro 1:a4050fee11f7 129
mbedalvaro 1:a4050fee11f7 130 // Timer on the rendering function of the oneLoop object:
mbedalvaro 9:3321170d157c 131 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL); // the address of the object, member function, and interval (in seconds)
mbedalvaro 9:3321170d157c 132 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL); // the address of the object, member function, and interval (in seconds)
mbedalvaro 1:a4050fee11f7 133
mbedalvaro 1:a4050fee11f7 134 // Timer for sending OSC data:
mbedalvaro 9:3321170d157c 135 // timerForSendingData.attach(&blobconf, &blobConfig::sendConfData, 0.025); // time in seconds (25ms -> 40Hz)
mbedalvaro 1:a4050fee11f7 136
mbedalvaro 1:a4050fee11f7 137 //========================================== INFINITE LOOP (in USER PROGRAM CONTEXT) ===================================================================
mbedalvaro 1:a4050fee11f7 138 #ifdef LOOPTIMECOMPUTE
mbedalvaro 1:a4050fee11f7 139 int timeCounterNum=1000;
mbedalvaro 1:a4050fee11f7 140 #endif
mbedalvaro 1:a4050fee11f7 141
mbedalvaro 9:3321170d157c 142 //measureUpdatePeriod.start();
mbedalvaro 1:a4050fee11f7 143
mbedalvaro 1:a4050fee11f7 144 while (true) {
mbedalvaro 1:a4050fee11f7 145
mbedalvaro 13:9f03eac02700 146 if (lsr.endedFullDisplay()) {
mbedalvaro 9:3321170d157c 147
mbedalvaro 9:3321170d157c 148 // measureUpdatePeriod.stop();
mbedalvaro 9:3321170d157c 149 // measureUpdatePeriod.reset();
mbedalvaro 9:3321170d157c 150
mbedalvaro 9:3321170d157c 151 // __disable_irq();
mbedalvaro 9:3321170d157c 152
mbedalvaro 1:a4050fee11f7 153 // update config dynamics (this also could be threaded?):
mbedalvaro 1:a4050fee11f7 154 blobconf.update();
mbedalvaro 1:a4050fee11f7 155
mbedalvaro 10:6f8e48dca1bd 156
mbedalvaro 1:a4050fee11f7 157 // draw the config (note: each kind of blob renders differently)
mbedalvaro 1:a4050fee11f7 158 blobconf.draw();
mbedalvaro 18:d72935b13858 159
mbedalvaro 18:d72935b13858 160
mbedalvaro 18:d72935b13858 161 // (b)Sending Data: // PUT THIS IN AN INTERRUPT OR USE A TIMER!!! it may be TOO FAST...
mbedalvaro 18:d72935b13858 162 // 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 163 // 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 164 // per blob timer counter.
mbedalvaro 18:d72935b13858 165 blobconf.sendConfData();
mbedalvaro 18:d72935b13858 166
mbedalvaro 16:2ff1cb2ae1b1 167
mbedalvaro 16:2ff1cb2ae1b1 168 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 169
mbedalvaro 9:3321170d157c 170
mbedalvaro 9:3321170d157c 171 // __enable_irq();
mbedalvaro 9:3321170d157c 172
mbedalvaro 9:3321170d157c 173 // measureUpdatePeriod.start();
mbedalvaro 10:6f8e48dca1bd 174
mbedalvaro 1:a4050fee11f7 175 }
mbedalvaro 0:345b3bc7a0ea 176
mbedalvaro 2:34157ebbf56b 177
mbedalvaro 1:a4050fee11f7 178 // COMMUNICATION:
mbedalvaro 1:a4050fee11f7 179 // (a) Reading commands:
mbedalvaro 1:a4050fee11f7 180 // Ethernet:
mbedalvaro 1:a4050fee11f7 181 Net::poll(); // this will take care of calling processOSC(UDPSocketEvent e) when a new packet arrives.
mbedalvaro 1:a4050fee11f7 182
mbedalvaro 1:a4050fee11f7 183 // Serial:
mbedalvaro 1:a4050fee11f7 184 #ifdef SERIAL_COMMANDS
mbedalvaro 1:a4050fee11f7 185 if (pc.readable()>0) processSerial();
mbedalvaro 1:a4050fee11f7 186 #endif
mbedalvaro 9:3321170d157c 187
mbedalvaro 9:3321170d157c 188
mbedalvaro 1:a4050fee11f7 189 // text:
mbedalvaro 1:a4050fee11f7 190 /*
mbedalvaro 1:a4050fee11f7 191 sendMes.setTopAddress("/hello");
mbedalvaro 1:a4050fee11f7 192 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 193 int x=(long)10;
mbedalvaro 1:a4050fee11f7 194 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 195 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 196 */
mbedalvaro 1:a4050fee11f7 197
mbedalvaro 0:345b3bc7a0ea 198 #ifdef LOOPTIMECOMPUTE
mbedalvaro 9:3321170d157c 199 if (timeCounterNum>50) myled = 0;
mbedalvaro 9:3321170d157c 200 // if (timeCounterNum%10==0) blobconf.sendConfData();
mbedalvaro 9:3321170d157c 201 if (timeCounterNum>100) {
mbedalvaro 1:a4050fee11f7 202 myled = 1;
mbedalvaro 1:a4050fee11f7 203 measureLoopPeriod.stop();
mbedalvaro 1:a4050fee11f7 204 sendMes.setTopAddress("/timeloop");
mbedalvaro 1:a4050fee11f7 205 sendMes.setSubAddress("/");
mbedalvaro 10:6f8e48dca1bd 206 // long x=(long)(int(measureLoopPeriod.read_us()/100.0));
mbedalvaro 9:3321170d157c 207 // long x=(long)(blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory.size());
mbedalvaro 9:3321170d157c 208 // long x=(long)(blobconf.blobArray[0]->normRecenteringVector);
mbedalvaro 10:6f8e48dca1bd 209 long x=(long)(1000*blobconf.blobArray[0]->displaySensingBuffer.lsdTrajectory[0].intensity);
mbedalvaro 1:a4050fee11f7 210 sendMes.setArgs( "i", &x);
mbedalvaro 1:a4050fee11f7 211 osc.sendOsc( &sendMes );
mbedalvaro 1:a4050fee11f7 212 timeCounterNum=0;
mbedalvaro 1:a4050fee11f7 213 measureLoopPeriod.reset();
mbedalvaro 1:a4050fee11f7 214 measureLoopPeriod.start();
mbedalvaro 1:a4050fee11f7 215 } else timeCounterNum++;
mbedalvaro 0:345b3bc7a0ea 216 #endif
mbedalvaro 0:345b3bc7a0ea 217
mbedalvaro 0:345b3bc7a0ea 218 }
mbedalvaro 0:345b3bc7a0ea 219 }
mbedalvaro 0:345b3bc7a0ea 220
mbedalvaro 1:a4050fee11f7 221 // ================= INTERPRET COMMAND =========================
mbedalvaro 0:345b3bc7a0ea 222 // NOTE: the following arrays are GLOBAL (used in processOSC and processSerial, as well as in interpretCommand function):
mbedalvaro 1:a4050fee11f7 223 // max of two addresses (top and sub), of a max length of 24 characters:
mbedalvaro 0:345b3bc7a0ea 224 char address[2][24];
mbedalvaro 0:345b3bc7a0ea 225 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 226 int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 227
mbedalvaro 1:a4050fee11f7 228 //interpretCommand(const char& address[2][], const int& data[2]) {
mbedalvaro 0:345b3bc7a0ea 229 void interpretCommand() {
mbedalvaro 0:345b3bc7a0ea 230 // (I) =========================================== SPECIAL FUNCTIONS (reset, rescan LUT, etc) ====================================================
mbedalvaro 16:2ff1cb2ae1b1 231 if ( !strcmp(address[0], "takeSnapshot" ) ) {
mbedalvaro 1:a4050fee11f7 232
mbedalvaro 1:a4050fee11f7 233 // for test:
mbedalvaro 1:a4050fee11f7 234 for (int i=0; i<2 ; i++) {
mbedalvaro 1:a4050fee11f7 235 myled = 1;
mbedalvaro 1:a4050fee11f7 236 wait(0.1);
mbedalvaro 1:a4050fee11f7 237 myled = 0;
mbedalvaro 1:a4050fee11f7 238 wait(0.1);
mbedalvaro 1:a4050fee11f7 239 }
mbedalvaro 1:a4050fee11f7 240
mbedalvaro 1:a4050fee11f7 241 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 242 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 243
mbedalvaro 1:a4050fee11f7 244 // Then, do the scan (sending values on serial port):
mbedalvaro 1:a4050fee11f7 245 IO.scan_serial();
mbedalvaro 1:a4050fee11f7 246
mbedalvaro 1:a4050fee11f7 247 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 248 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 249 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 250 }
mbedalvaro 1:a4050fee11f7 251
mbedalvaro 1:a4050fee11f7 252 else if ( !strcmp(address[0], "mbedReset" ) ) mbed_reset();
mbedalvaro 1:a4050fee11f7 253
mbedalvaro 1:a4050fee11f7 254 else if ( !strcmp(address[0], "calibrate" ) ) {
mbedalvaro 1:a4050fee11f7 255 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 256 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 257 // RESCAN (and save LUT table):
mbedalvaro 1:a4050fee11f7 258 IO.scanLUT();
mbedalvaro 1:a4050fee11f7 259 // Finally, start again threaded display:
mbedalvaro 9:3321170d157c 260 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 261 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 262 }
mbedalvaro 1:a4050fee11f7 263
mbedalvaro 1:a4050fee11f7 264 // (II) ========================================= GLOBAL CONFIG and HARDWARE COMMANDS ===========================================
mbedalvaro 1:a4050fee11f7 265
mbedalvaro 1:a4050fee11f7 266 else if ( !strcmp(address[0], "setGreenLaser" ) ) {
mbedalvaro 1:a4050fee11f7 267 int value=data[0];
mbedalvaro 1:a4050fee11f7 268 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 269 if (value==0) IO.setGreenPower(0);
mbedalvaro 1:a4050fee11f7 270 else IO.setGreenPower(1);
mbedalvaro 1:a4050fee11f7 271 }
mbedalvaro 1:a4050fee11f7 272 }
mbedalvaro 1:a4050fee11f7 273
mbedalvaro 1:a4050fee11f7 274 // SIMPLE BEHAVIOUR MODES (to be read from an XML file in the future):
mbedalvaro 11:62f7183a03e7 275 else if (!strcmp(address[0], "elastic_following")) { //
mbedalvaro 1:a4050fee11f7 276 timerForRendering.detach();
mbedalvaro 0:345b3bc7a0ea 277 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 278 blobconf.clearConfig();
mbedalvaro 1:a4050fee11f7 279 blobconf.addOneElasticContourFollowing();
mbedalvaro 1:a4050fee11f7 280 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 281 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 282 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 283
mbedalvaro 11:62f7183a03e7 284 } else if (!strcmp(address[0], "elastic_mouth")) { //
mbedalvaro 1:a4050fee11f7 285 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 286 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 287 blobconf.clearConfig();
mbedalvaro 1:a4050fee11f7 288 blobconf.addOneElasticLoopContractCentral();
mbedalvaro 1:a4050fee11f7 289 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 290 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 291 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 292 }
mbedalvaro 1:a4050fee11f7 293
mbedalvaro 11:62f7183a03e7 294 else if (!strcmp(address[0], "spot_bouncing")) {
mbedalvaro 16:2ff1cb2ae1b1 295 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 296 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 297
mbedalvaro 16:2ff1cb2ae1b1 298 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 299 // blobconf.computeBoundingBox();
mbedalvaro 16:2ff1cb2ae1b1 300 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 301
mbedalvaro 16:2ff1cb2ae1b1 302 for (int i=0; i<value ; i++) blobconf.addOneRigidLoopBouncing();
mbedalvaro 16:2ff1cb2ae1b1 303
mbedalvaro 16:2ff1cb2ae1b1 304 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 305 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 306 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 307 }
mbedalvaro 16:2ff1cb2ae1b1 308 }
mbedalvaro 16:2ff1cb2ae1b1 309
mbedalvaro 16:2ff1cb2ae1b1 310 else if (!strcmp(address[0], "spot_following")) {
mbedalvaro 16:2ff1cb2ae1b1 311 int value=data[0];
mbedalvaro 16:2ff1cb2ae1b1 312 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 16:2ff1cb2ae1b1 313
mbedalvaro 16:2ff1cb2ae1b1 314 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 315 // blobconf.computeBoundingBox();
mbedalvaro 16:2ff1cb2ae1b1 316 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 317 for (int i=0; i<value ; i++) blobconf.addOneRigidLoopFollowing();
mbedalvaro 16:2ff1cb2ae1b1 318 lsr.setConfigToRender(&blobconf);
mbedalvaro 16:2ff1cb2ae1b1 319 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 320 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 321 }
mbedalvaro 16:2ff1cb2ae1b1 322 }
mbedalvaro 16:2ff1cb2ae1b1 323
mbedalvaro 16:2ff1cb2ae1b1 324 else if (!strcmp(address[0], "spot_test")) {
mbedalvaro 0:345b3bc7a0ea 325 timerForRendering.detach();
mbedalvaro 0:345b3bc7a0ea 326 // blobconf.computeBoundingBox();
mbedalvaro 1:a4050fee11f7 327 blobconf.clearConfig();
mbedalvaro 16:2ff1cb2ae1b1 328 blobconf.addOneRigidLoopTest();
mbedalvaro 1:a4050fee11f7 329 lsr.setConfigToRender(&blobconf);
mbedalvaro 9:3321170d157c 330 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 331 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 1:a4050fee11f7 332 }
mbedalvaro 1:a4050fee11f7 333
mbedalvaro 1:a4050fee11f7 334 // other:
mbedalvaro 1:a4050fee11f7 335
mbedalvaro 1:a4050fee11f7 336 else if ( !strcmp(address[0], "standby" ) ) { // will put ALL the spots in stand by mode
mbedalvaro 0:345b3bc7a0ea 337 blobconf.allStandBy(); // will avoid the update function
mbedalvaro 1:a4050fee11f7 338 } else if ( !strcmp(address[0], "resume" ) ) { // will put ALL the spots in stand by mode
mbedalvaro 0:345b3bc7a0ea 339 blobconf.allResume(); // will avoid the update function
mbedalvaro 1:a4050fee11f7 340 }
mbedalvaro 1:a4050fee11f7 341
mbedalvaro 1:a4050fee11f7 342 // (III) ========================================= Loop control (parameters, etc) ===========================================
mbedalvaro 1:a4050fee11f7 343 // NOte: for the time being, we only have ONE loop, so there is no "per loop or per config" mode.
mbedalvaro 1:a4050fee11f7 344
mbedalvaro 1:a4050fee11f7 345 else if (!strcmp( address[0], "sendOSC" ) ) {
mbedalvaro 1:a4050fee11f7 346 int value=data[0];
mbedalvaro 1:a4050fee11f7 347 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 348 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 349 blobconf.blobArray[i]->sendOSC=(value>0);
mbedalvaro 1:a4050fee11f7 350 }
mbedalvaro 1:a4050fee11f7 351 }
mbedalvaro 1:a4050fee11f7 352 }
mbedalvaro 1:a4050fee11f7 353
mbedalvaro 1:a4050fee11f7 354 else if (!strcmp( address[0], "sendArea" ) ) {
mbedalvaro 1:a4050fee11f7 355 int value=data[0];
mbedalvaro 1:a4050fee11f7 356 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 357 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 358 blobconf.blobArray[i]->sendingBlobArea=(value>0);
mbedalvaro 1:a4050fee11f7 359 }
mbedalvaro 1:a4050fee11f7 360 }
mbedalvaro 1:a4050fee11f7 361 }
mbedalvaro 1:a4050fee11f7 362
mbedalvaro 1:a4050fee11f7 363 else if (!strcmp( address[0], "sendPos" ) ) {
mbedalvaro 1:a4050fee11f7 364 int value=data[0];
mbedalvaro 1:a4050fee11f7 365 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 366 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 367 blobconf.blobArray[i]->sendingLoopPositions=(value>0);
mbedalvaro 1:a4050fee11f7 368 }
mbedalvaro 1:a4050fee11f7 369 }
mbedalvaro 1:a4050fee11f7 370 }
mbedalvaro 1:a4050fee11f7 371
mbedalvaro 1:a4050fee11f7 372 else if (!strcmp( address[0], "sendRegions" ) ) {
mbedalvaro 1:a4050fee11f7 373 int value=data[0];
mbedalvaro 1:a4050fee11f7 374 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 375 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 376 blobconf.blobArray[i]->sendingLoopRegions=(value>0);
mbedalvaro 1:a4050fee11f7 377 }
mbedalvaro 1:a4050fee11f7 378 }
mbedalvaro 1:a4050fee11f7 379 }
mbedalvaro 1:a4050fee11f7 380
mbedalvaro 1:a4050fee11f7 381 else if (!strcmp( address[0], "sendTouched" ) ) {
mbedalvaro 1:a4050fee11f7 382 int value=data[0];
mbedalvaro 1:a4050fee11f7 383 if (value!=-1) { // otherwise do nothing, this is a reception error (there was no data)
mbedalvaro 1:a4050fee11f7 384 for (int i=0; i< blobconf.numBlobs; i++) {
mbedalvaro 1:a4050fee11f7 385 blobconf.blobArray[i]->sendingTouched=(value>0);
mbedalvaro 1:a4050fee11f7 386 }
mbedalvaro 1:a4050fee11f7 387 }
mbedalvaro 1:a4050fee11f7 388 }
mbedalvaro 1:a4050fee11f7 389
mbedalvaro 1:a4050fee11f7 390
mbedalvaro 1:a4050fee11f7 391
mbedalvaro 0:345b3bc7a0ea 392 }
mbedalvaro 0:345b3bc7a0ea 393
mbedalvaro 0:345b3bc7a0ea 394 //============= RECEIVE OSC COMMANDS =========================
mbedalvaro 1:a4050fee11f7 395 // This is the callback function called when there are packets on the listening socket. It is not nice to have it
mbedalvaro 1:a4050fee11f7 396 // here, but for the time being having a "wrapping global" is the simplest solution (we cannot pass a member-function pointer
mbedalvaro 1:a4050fee11f7 397 // as handler to the upd object).
mbedalvaro 0:345b3bc7a0ea 398 void processOSC(UDPSocketEvent e) {
mbedalvaro 0:345b3bc7a0ea 399 osc.onUDPSocketEvent(e);
mbedalvaro 0:345b3bc7a0ea 400
mbedalvaro 0:345b3bc7a0ea 401 if (osc.newMessage) {
mbedalvaro 1:a4050fee11f7 402 // 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 403 // 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 404
mbedalvaro 1:a4050fee11f7 405 // Acquire the addresses and arguments and put them in the GLOBAL variables:
mbedalvaro 1:a4050fee11f7 406 strcpy(address[0],"");
mbedalvaro 1:a4050fee11f7 407 strcpy(address[1],"");
mbedalvaro 1:a4050fee11f7 408 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 409 // Acquire data:
mbedalvaro 1:a4050fee11f7 410 data[0]=-1;
mbedalvaro 1:a4050fee11f7 411 data[1]=-1;
mbedalvaro 1:a4050fee11f7 412 for (int i=0; i<recMes.getArgNum(); i++) data[i]=(int)recMes.getArgInt(i);
mbedalvaro 1:a4050fee11f7 413
mbedalvaro 1:a4050fee11f7 414 // Finally, interpret the command:
mbedalvaro 1:a4050fee11f7 415 interpretCommand();//address, data);
mbedalvaro 1:a4050fee11f7 416
mbedalvaro 0:345b3bc7a0ea 417 }
mbedalvaro 1:a4050fee11f7 418 }
mbedalvaro 1:a4050fee11f7 419
mbedalvaro 0:345b3bc7a0ea 420 //============= RECEIVE SERIAL COMMANDS =========================
mbedalvaro 0:345b3bc7a0ea 421 //
mbedalvaro 1:a4050fee11f7 422 // NOTE: - NUMERIC PARAMETERS have to be send BEFORE the command word. They must be sent as ASCII DEC, without end character.
mbedalvaro 0:345b3bc7a0ea 423 // - Commands words SHOULD NOT have numbers in it. They should be C compliant STRINGS (ended with character '0')
mbedalvaro 1:a4050fee11f7 424 // - order is irrelevant: we can send 10 RADIUS or RADIUS 10.
mbedalvaro 0:345b3bc7a0ea 425
mbedalvaro 1:a4050fee11f7 426 // String to store ALPHANUMERIC DATA (i.e., integers, floating point numbers, unsigned ints, etc represented as DEC) sent wirelessly:
mbedalvaro 0:345b3bc7a0ea 427 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 428 int indexStringData=0;//position of the byte in the string
mbedalvaro 0:345b3bc7a0ea 429
mbedalvaro 0:345b3bc7a0ea 430 // String to store COMMAND WORDS:
mbedalvaro 0:345b3bc7a0ea 431 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 432 int indexStringCommand=0;
mbedalvaro 0:345b3bc7a0ea 433 bool commandReady=false; // will become true when receiving the byte 0 (i.e. the '/0' string terminator)
mbedalvaro 0:345b3bc7a0ea 434
mbedalvaro 0:345b3bc7a0ea 435 void processSerial() {
mbedalvaro 0:345b3bc7a0ea 436
mbedalvaro 1:a4050fee11f7 437 while (pc.readable()>0) {
mbedalvaro 1:a4050fee11f7 438
mbedalvaro 14:0fc33a3a7b4b 439
mbedalvaro 1:a4050fee11f7 440 char val =pc.getc();
mbedalvaro 0:345b3bc7a0ea 441 // pc.printf("Got :%d\n", incomingByte);
mbedalvaro 1:a4050fee11f7 442 //pc.putc(incomingByte);
mbedalvaro 1:a4050fee11f7 443
mbedalvaro 1:a4050fee11f7 444 // Save ASCII numeric characters (ASCII 0 - 9) on stringData:
mbedalvaro 1:a4050fee11f7 445 if ((val >= '0') && (val <= '9')) { // this is 45 to 57 (included)
mbedalvaro 1:a4050fee11f7 446 stringData[indexStringData] = val;
mbedalvaro 1:a4050fee11f7 447 indexStringData++;
mbedalvaro 1:a4050fee11f7 448 }
mbedalvaro 1:a4050fee11f7 449
mbedalvaro 1:a4050fee11f7 450 // Save ASCII letters in stringCommand:
mbedalvaro 1:a4050fee11f7 451 if ((val >= 'A') && (val <= 'z')) { // this is 65 to 122 (included)
mbedalvaro 1:a4050fee11f7 452 stringCommand[indexStringCommand] = val;
mbedalvaro 1:a4050fee11f7 453 indexStringCommand++;
mbedalvaro 1:a4050fee11f7 454 }
mbedalvaro 1:a4050fee11f7 455 // is command ready?
mbedalvaro 1:a4050fee11f7 456 if (val=='/') {
mbedalvaro 1:a4050fee11f7 457 commandReady=true;
mbedalvaro 1:a4050fee11f7 458 stringCommand[indexStringCommand] = 0; // string termination.
mbedalvaro 1:a4050fee11f7 459 indexStringCommand=0; // reset index string for acquiring next command
mbedalvaro 1:a4050fee11f7 460 //Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 461 }
mbedalvaro 1:a4050fee11f7 462
mbedalvaro 1:a4050fee11f7 463 // COMMANDS (with or without numeric parameters):
mbedalvaro 1:a4050fee11f7 464 if (commandReady==true) { // it means we can interpret the command string:
mbedalvaro 1:a4050fee11f7 465 commandReady=false;
mbedalvaro 1:a4050fee11f7 466
mbedalvaro 1:a4050fee11f7 467 stringData[indexStringData] = 0 ;// string termination for numeric values;
mbedalvaro 1:a4050fee11f7 468 indexStringData=0;
mbedalvaro 1:a4050fee11f7 469
mbedalvaro 1:a4050fee11f7 470 // PARSE DATA: (TO DO!!!!!!!!!!!!!!):
mbedalvaro 0:345b3bc7a0ea 471
mbedalvaro 1:a4050fee11f7 472 // (a) Parse command (get address[0] and address[1]):
mbedalvaro 1:a4050fee11f7 473 //ex: "/1/standBy" -- > address[0]="1" and address[1]="standBy"
mbedalvaro 1:a4050fee11f7 474 // address[2]
mbedalvaro 1:a4050fee11f7 475
mbedalvaro 1:a4050fee11f7 476 // Serial.println(stringCommand);
mbedalvaro 1:a4050fee11f7 477 // Serial.println(stringData);
mbedalvaro 1:a4050fee11f7 478
mbedalvaro 1:a4050fee11f7 479 // (b) Parse data:
mbedalvaro 1:a4050fee11f7 480
mbedalvaro 1:a4050fee11f7 481 // char address[2][24];
mbedalvaro 1:a4050fee11f7 482 //long auxdata[2]; // to store a max of two arguments (note: we will only use LONGs)
mbedalvaro 1:a4050fee11f7 483 //int data[2]; // this is to have -1 as NO DATA, to detect errors.
mbedalvaro 1:a4050fee11f7 484
mbedalvaro 1:a4050fee11f7 485 // FOR THE TIME BEING there is no parsing for serial commands:
mbedalvaro 1:a4050fee11f7 486
mbedalvaro 1:a4050fee11f7 487 // SCANNING:
mbedalvaro 1:a4050fee11f7 488 if (!strcmp(stringCommand , "takeSnapshot")) {
mbedalvaro 1:a4050fee11f7 489 // First, we need to disable the threaded display for the loop:
mbedalvaro 1:a4050fee11f7 490 timerForRendering.detach();
mbedalvaro 1:a4050fee11f7 491
mbedalvaro 1:a4050fee11f7 492 // Then, do the scan (sending values on serial port):
mbedalvaro 1:a4050fee11f7 493 IO.scan_serial();
mbedalvaro 1:a4050fee11f7 494
mbedalvaro 1:a4050fee11f7 495 // Finally, start again threaded display:
mbedalvaro 4:f9d364f10335 496 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 9:3321170d157c 497 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 498 } else if (!strcmp(stringCommand , "REDON")) IO.setRedPower(1); // pc.printf("%d\n",incomingByte);
mbedalvaro 1:a4050fee11f7 499
mbedalvaro 14:0fc33a3a7b4b 500 else if (!strcmp(stringCommand , "REDOFF")) IO.setRedPower(0);
mbedalvaro 14:0fc33a3a7b4b 501
mbedalvaro 14:0fc33a3a7b4b 502 else if (!strcmp(stringCommand , "READVALUE")) pc.printf("Value read: %f", lockin.getSmoothValue());//lockin.getLastValue());/
mbedalvaro 1:a4050fee11f7 503
mbedalvaro 14:0fc33a3a7b4b 504 else if (!strcmp(stringCommand , "mbedReset")) mbed_reset();
mbedalvaro 16:2ff1cb2ae1b1 505
mbedalvaro 14:0fc33a3a7b4b 506 else if (!strcmp(stringCommand , "calibrate")) {
mbedalvaro 16:2ff1cb2ae1b1 507 // First, we need to disable the threaded display for the loop:
mbedalvaro 16:2ff1cb2ae1b1 508 timerForRendering.detach();
mbedalvaro 16:2ff1cb2ae1b1 509 // RESCAN (and save LUT table):
mbedalvaro 16:2ff1cb2ae1b1 510 IO.scanLUT();
mbedalvaro 16:2ff1cb2ae1b1 511 // Finally, start again threaded display:
mbedalvaro 16:2ff1cb2ae1b1 512 timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThread, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 513 // timerForRendering.attach(&lsr, &simpleLaserSensingRenderer::laserRenderThreadONEBLOBONLY, RENDER_INTERVAL);
mbedalvaro 16:2ff1cb2ae1b1 514 }
mbedalvaro 1:a4050fee11f7 515
mbedalvaro 1:a4050fee11f7 516 // FINALLY, interpret commands (but only after parsing):
mbedalvaro 1:a4050fee11f7 517 // interpretCommand();//address, data);
mbedalvaro 0:345b3bc7a0ea 518
mbedalvaro 0:345b3bc7a0ea 519 }
mbedalvaro 1:a4050fee11f7 520 }
mbedalvaro 1:a4050fee11f7 521 }
mbedalvaro 0:345b3bc7a0ea 522
mbedalvaro 0:345b3bc7a0ea 523
mbedalvaro 0:345b3bc7a0ea 524
mbedalvaro 0:345b3bc7a0ea 525 // ================ MISCELANEA
mbedalvaro 0:345b3bc7a0ea 526
mbedalvaro 0:345b3bc7a0ea 527 /* EXAMPLE SEND/RECEIVE on PROCESSING:
mbedalvaro 0:345b3bc7a0ea 528
mbedalvaro 0:345b3bc7a0ea 529 // oscP5sendreceive by andreas schlegel
mbedalvaro 0:345b3bc7a0ea 530 // example shows how to send and receive osc messages.
mbedalvaro 0:345b3bc7a0ea 531 // oscP5 website at http://www.sojamo.de/oscP5
mbedalvaro 0:345b3bc7a0ea 532
mbedalvaro 0:345b3bc7a0ea 533 import oscP5.*;
mbedalvaro 0:345b3bc7a0ea 534 import netP5.*;
mbedalvaro 1:a4050fee11f7 535
mbedalvaro 0:345b3bc7a0ea 536 OscP5 oscP5;
mbedalvaro 0:345b3bc7a0ea 537 NetAddress myRemoteLocation;
mbedalvaro 0:345b3bc7a0ea 538
mbedalvaro 0:345b3bc7a0ea 539 void setup() {
mbedalvaro 0:345b3bc7a0ea 540 size(400,400);
mbedalvaro 0:345b3bc7a0ea 541 frameRate(25);
mbedalvaro 1:a4050fee11f7 542 // start oscP5, listening for incoming messages at port 12000
mbedalvaro 0:345b3bc7a0ea 543 oscP5 = new OscP5(this,12000);
mbedalvaro 1:a4050fee11f7 544
mbedalvaro 0:345b3bc7a0ea 545 // myRemoteLocation is a NetAddress. a NetAddress takes 2 parameters,
mbedalvaro 0:345b3bc7a0ea 546 // an ip address and a port number. myRemoteLocation is used as parameter in
mbedalvaro 1:a4050fee11f7 547 // oscP5.send() when sending osc packets to another computer, device,
mbedalvaro 0:345b3bc7a0ea 548 // application. usage see below. for testing purposes the listening port
mbedalvaro 0:345b3bc7a0ea 549 // and the port of the remote location address are the same, hence you will
mbedalvaro 0:345b3bc7a0ea 550 // send messages back to this sketch.
mbedalvaro 0:345b3bc7a0ea 551 myRemoteLocation = new NetAddress("10.0.0.2",10000);
mbedalvaro 0:345b3bc7a0ea 552 }
mbedalvaro 0:345b3bc7a0ea 553
mbedalvaro 0:345b3bc7a0ea 554
mbedalvaro 0:345b3bc7a0ea 555 void draw() {
mbedalvaro 1:a4050fee11f7 556 background(0);
mbedalvaro 0:345b3bc7a0ea 557 }
mbedalvaro 0:345b3bc7a0ea 558
mbedalvaro 0:345b3bc7a0ea 559 void mousePressed() {
mbedalvaro 1:a4050fee11f7 560 // in the following different ways of creating osc messages are shown by example
mbedalvaro 0:345b3bc7a0ea 561 OscMessage myMessage = new OscMessage("/mbed/test1");
mbedalvaro 1:a4050fee11f7 562
mbedalvaro 1:a4050fee11f7 563 myMessage.add(123); // add an int to the osc message
mbedalvaro 0:345b3bc7a0ea 564
mbedalvaro 1:a4050fee11f7 565 // send the message
mbedalvaro 1:a4050fee11f7 566 oscP5.send(myMessage, myRemoteLocation);
mbedalvaro 0:345b3bc7a0ea 567 }
mbedalvaro 0:345b3bc7a0ea 568
mbedalvaro 0:345b3bc7a0ea 569
mbedalvaro 1:a4050fee11f7 570 // incoming osc message are forwarded to the oscEvent method.
mbedalvaro 0:345b3bc7a0ea 571 void oscEvent(OscMessage theOscMessage) {
mbedalvaro 1:a4050fee11f7 572 // print the address pattern and the typetag of the received OscMessage
mbedalvaro 0:345b3bc7a0ea 573 print("### received an osc message.");
mbedalvaro 0:345b3bc7a0ea 574 print(" addrpattern: "+theOscMessage.addrPattern());
mbedalvaro 0:345b3bc7a0ea 575 println(" typetag: "+theOscMessage.typetag());
mbedalvaro 0:345b3bc7a0ea 576 }
mbedalvaro 0:345b3bc7a0ea 577
mbedalvaro 0:345b3bc7a0ea 578 */