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@16:2ff1cb2ae1b1, 2012-04-13 (annotated)

Committer:
mbedalvaro
Date:
Fri Apr 13 07:43:09 2012 +0000
Revision:
16:2ff1cb2ae1b1
Parent:
14:0fc33a3a7b4b
Child:
17:356ca5690a59
works pretty well with up to 12 bouncing/follwong spots!!; - will now correct the display routine to avoid having redundant drawing when there is only one spot;; - also, in case of multiple spots, instead of WAITING for the first point, we can just SWITC...

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