22 |
23 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/utils/arduino/ArduinoOSCSender/ArduinoOSCSender.ino:
--------------------------------------------------------------------------------
1 |
2 | #include
3 |
4 | #if defined(CORE_TEENSY)
5 | #include
6 | #else
7 | #include
8 | #endif
9 |
10 | #if defined(CORE_TEENSY)
11 | SLIPEncodedUSBSerial SLIPSerial(Serial);
12 | #else
13 | SLIPEncodedSerial SLIPSerial(Serial);
14 | #endif
15 |
16 | void setup() {
17 | Serial.begin(9600); // Rate is ignored for USB devices such as the Teensy.
18 | }
19 |
20 | void loop() {
21 |
22 | String address = String("/knobs/0");
23 | int addressLength = address.length() + 1;
24 | char addressBuffer[addressLength];
25 |
26 | address.toCharArray(addressBuffer, addressLength);
27 | OSCMessage msg(addressBuffer);
28 | msg.add(random(100)/100.0);
29 |
30 | msg.send(SLIPSerial);
31 | SLIPSerial.endPacket();
32 | msg.empty();
33 |
34 | delay(1000);
35 |
36 | }
37 |
38 |
39 |
--------------------------------------------------------------------------------
/send-to-supercollider/index.js:
--------------------------------------------------------------------------------
1 | var osc = require("osc");
2 |
3 | var udpPort = new osc.UDPPort({
4 | // This is the port we're listening on.
5 | localAddress: "127.0.0.1",
6 | localPort: 57121,
7 |
8 | // This is where sclang is listening for OSC messages.
9 | remoteAddress: "127.0.0.1",
10 | remotePort: 57120,
11 | metadata: true
12 | });
13 |
14 | // Open the socket.
15 | udpPort.open();
16 |
17 | // Every second, send an OSC message to SuperCollider
18 | setInterval(function() {
19 | var msg = {
20 | address: "/hello/from/oscjs",
21 | args: [
22 | {
23 | type: "f",
24 | value: Math.random()
25 | },
26 | {
27 | type: "f",
28 | value: Math.random()
29 | }
30 | ]
31 | };
32 |
33 | console.log("Sending message", msg.address, msg.args, "to", udpPort.options.remoteAddress + ":" + udpPort.options.remotePort);
34 | udpPort.send(msg);
35 | }, 1000);
36 |
--------------------------------------------------------------------------------
/electron/src/serialport-logger.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var fluid = require("infusion"),
4 | osc = require("osc"),
5 | oscjsExamples = fluid.registerNamespace("oscjsExamples");
6 |
7 | fluid.defaults("oscjsExamples.electron.serialPortLogger", {
8 | gradeNames: "fluid.component",
9 |
10 | members: {
11 | serialPort: "@expand:oscjsExamples.electron.createSerialPort()"
12 | },
13 |
14 | events: {
15 | onMessage: null
16 | },
17 |
18 | listeners: {
19 | "onCreate.bindMessageLogger": {
20 | "this": "{that}.serialPort",
21 | method: "on",
22 | args: ["message", "{that}.events.onMessage.fire"]
23 | },
24 |
25 | "onCreate.openPort": {
26 | priority: "last",
27 | "this": "{that}.serialPort",
28 | method: "open"
29 | },
30 |
31 | "onMessage.print": {
32 | "this": "console",
33 | method: "log",
34 | args: "{arguments}.0"
35 | }
36 | }
37 | });
38 |
39 | oscjsExamples.electron.createSerialPort = function () {
40 | return new osc.SerialPort({
41 | devicePath: process.argv[2] || "/dev/tty.usbmodem221361"
42 | });
43 | };
44 |
--------------------------------------------------------------------------------
/electron/src/app.js:
--------------------------------------------------------------------------------
1 | /*jshint node:true*/
2 |
3 | "use strict";
4 |
5 | var fluid = require("infusion"),
6 | oscjsExamples = fluid.registerNamespace("oscjsExamples");
7 |
8 | require("infusion-electron");
9 |
10 | fluid.defaults("oscjsExamples.electron.app", {
11 | gradeNames: "electron.app",
12 |
13 | components: {
14 | mainWindow: {
15 | createOnEvent: "onReady",
16 | type: "oscjsExamples.electron.window"
17 | },
18 |
19 | serialPortLogger: {
20 | type: "oscjsExamples.electron.serialPortLogger"
21 | }
22 | }
23 | });
24 |
25 |
26 | fluid.defaults("oscjsExamples.electron.window", {
27 | gradeNames: "electron.browserWindow",
28 |
29 | windowOptions: {
30 | title: "osc.js Electron serial port example",
31 | x: 0,
32 | y: 0,
33 | width: 640,
34 | height: 480
35 | },
36 |
37 |
38 | model: {
39 | url: {
40 | expander: {
41 | funcName: "fluid.stringTemplate",
42 | args: [
43 | "%url/src/client/html/main-window.html",
44 | "{app}.env.appRoot"
45 | ]
46 | }
47 | }
48 | }
49 | });
50 |
--------------------------------------------------------------------------------
/udp-browser/README.md:
--------------------------------------------------------------------------------
1 | # Bi-directional UDP <-> web browser example
2 |
3 | This example opens a Web Socket in a web page that communicates with a Node.js server.
4 | The server is responsible for relaying OSC messages bidirectionally between the web page and set of
5 | example Python scripts.
6 |
7 | ## Installation
8 |
9 | From the command line:
10 | 1. Run npm install
11 | 2. In the web folder, run npm install
12 | 3. Use [pip](https://pypi.python.org/pypi/pip) to install pyosc: sudo pip install pyosc --pre
13 | ** On Mac OS X, pip can be easily installed using the command sudo easy_install pip.
14 |
15 | ## Running the Demo
16 |
17 | 1. In the udp-browser folder, start the Node.js server: node .
18 | 2. In web folder, open index.html in a web browser; a log message will be printed to the terminal when you have connected.
19 | 3. To send an OSC message via UDP to the browser, run python testSend.py in a new terminal window; an OSC message should appear in the web browser window.
20 | 4. To send an OSC message from the browser to the UDP socket, run python testReceive.py. This will start a Python-based UDP OSC server. Then in the browser, click the 'Send OSC message' button. An OSC message should appear in the terminal window where you ran testReceive.py.
21 |
--------------------------------------------------------------------------------
/udp-browser/web/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | osc.js Web Socket Demo
5 |
6 |
7 |
8 |
9 |
30 |
31 |
32 |
33 |
osc.js Web Socket Demo
34 |
35 |
36 |
OSC Message:
37 |
38 |
39 |
40 |
41 |
42 |
43 |
--------------------------------------------------------------------------------
/nodejs/index.js:
--------------------------------------------------------------------------------
1 | var osc = require("osc");
2 |
3 | /*******************
4 | * OSC Over Serial *
5 | *******************/
6 |
7 | // Instantiate a new OSC Serial Port.
8 | var serialPort = new osc.SerialPort({
9 | devicePath: process.argv[2] || "/dev/tty.usbmodem221361"
10 | });
11 |
12 | serialPort.on("message", function (oscMessage) {
13 | console.log(oscMessage);
14 | });
15 |
16 | // Open the port.
17 | serialPort.open();
18 |
19 |
20 | /****************
21 | * OSC Over UDP *
22 | ****************/
23 |
24 | var getIPAddresses = function () {
25 | var os = require("os"),
26 | interfaces = os.networkInterfaces(),
27 | ipAddresses = [];
28 |
29 | for (var deviceName in interfaces) {
30 | var addresses = interfaces[deviceName];
31 | for (var i = 0; i < addresses.length; i++) {
32 | var addressInfo = addresses[i];
33 | if (addressInfo.family === "IPv4" && !addressInfo.internal) {
34 | ipAddresses.push(addressInfo.address);
35 | }
36 | }
37 | }
38 |
39 | return ipAddresses;
40 | };
41 |
42 | var udpPort = new osc.UDPPort({
43 | localAddress: "0.0.0.0",
44 | localPort: 57121
45 | });
46 |
47 | udpPort.on("ready", function () {
48 | var ipAddresses = getIPAddresses();
49 |
50 | console.log("Listening for OSC over UDP.");
51 | ipAddresses.forEach(function (address) {
52 | console.log(" Host:", address + ", Port:", udpPort.options.localPort);
53 | });
54 | });
55 |
56 | udpPort.on("message", function (oscMessage) {
57 | console.log(oscMessage);
58 | });
59 |
60 | udpPort.on("error", function (err) {
61 | console.log(err);
62 | });
63 |
64 | udpPort.open();
65 |
--------------------------------------------------------------------------------
/udp-browser/index.js:
--------------------------------------------------------------------------------
1 | //--------------------------------------------------
2 | // Bi-Directional OSC messaging Websocket <-> UDP
3 | //--------------------------------------------------
4 | var osc = require("osc"),
5 | WebSocket = require("ws");
6 |
7 | var getIPAddresses = function () {
8 | var os = require("os"),
9 | interfaces = os.networkInterfaces(),
10 | ipAddresses = [];
11 |
12 | for (var deviceName in interfaces){
13 | var addresses = interfaces[deviceName];
14 |
15 | for (var i = 0; i < addresses.length; i++) {
16 | var addressInfo = addresses[i];
17 |
18 | if (addressInfo.family === "IPv4" && !addressInfo.internal) {
19 | ipAddresses.push(addressInfo.address);
20 | }
21 | }
22 | }
23 |
24 | return ipAddresses;
25 | };
26 |
27 | var udp = new osc.UDPPort({
28 | localAddress: "0.0.0.0",
29 | localPort: 7400,
30 | remoteAddress: "127.0.0.1",
31 | remotePort: 7500
32 | });
33 |
34 | udp.on("ready", function () {
35 | var ipAddresses = getIPAddresses();
36 | console.log("Listening for OSC over UDP.");
37 | ipAddresses.forEach(function (address) {
38 | console.log(" Host:", address + ", Port:", udp.options.localPort);
39 | });
40 | console.log("Broadcasting OSC over UDP to", udp.options.remoteAddress + ", Port:", udp.options.remotePort);
41 | });
42 |
43 | udp.open();
44 |
45 | var wss = new WebSocket.Server({
46 | port: 8081
47 | });
48 |
49 | wss.on("connection", function (socket) {
50 | console.log("A Web Socket connection has been established!");
51 | var socketPort = new osc.WebSocketPort({
52 | socket: socket
53 | });
54 |
55 | var relay = new osc.Relay(udp, socketPort, {
56 | raw: true
57 | });
58 | });
59 |
--------------------------------------------------------------------------------
/browser/README.md:
--------------------------------------------------------------------------------
1 | # UDP -> Web Socket Example
2 |
3 | This example illustrates a Node.js server that will relay OSC messages sent via
4 | a UDP socket (listening on port 57121) to a web page using a Web Socket connection.
5 |
6 | By default, it is configured to handle OSC messages via UDP from Lemur's AB Faderlab project.
7 | It maps four parameters of a simple Flocking-based FM synthesizer to the first four
8 | faders in the Lemur project. Here is the mapping:
9 |
10 |
11 |
12 |
OSC Address
13 |
OSC Argument Type
14 |
Synth Paramter
15 |
16 |
17 |
/fader1/out
18 |
float 0.0 - 1.0
19 |
carrier frequency
20 |
21 |
22 |
/fader2/out
23 |
float 0.0 - 1.0
24 |
carrier amplitude
25 |
26 |
27 |
/fader3/out
28 |
float 0.0 - 1.0
29 |
modulator frequency
30 |
31 |
32 |
/fader4/out
33 |
float 0.0 - 1.0
34 |
modulator amplitude
35 |
36 |
37 |
38 | If you don't have a copy of Lemur, you can use the SuperCollider test client created by [Jascha Narveson](https://github.com/jaschanarveson), which is located in the [utils](../utils/supercollider-lemur-faderlab-style-client.scd) directory.
39 |
40 | ## Installation
41 |
42 | 1. Run npm install in the terminal to install all required Node dependencies
43 | 2. In the web directory, run npm install to install all web dependencies
44 |
45 | ## Running the Example
46 |
47 | 1. Run node . in the Terminal
48 | 2. Open http://localhost:8081 in your browser
49 | 3. Control the synth using OSC messages sent from Lemur or another OSC server
50 |
--------------------------------------------------------------------------------
/browser/index.js:
--------------------------------------------------------------------------------
1 | var osc = require("osc"),
2 | express = require("express"),
3 | WebSocket = require("ws");
4 |
5 | var getIPAddresses = function () {
6 | var os = require("os"),
7 | interfaces = os.networkInterfaces(),
8 | ipAddresses = [];
9 |
10 | for (var deviceName in interfaces) {
11 | var addresses = interfaces[deviceName];
12 | for (var i = 0; i < addresses.length; i++) {
13 | var addressInfo = addresses[i];
14 | if (addressInfo.family === "IPv4" && !addressInfo.internal) {
15 | ipAddresses.push(addressInfo.address);
16 | }
17 | }
18 | }
19 |
20 | return ipAddresses;
21 | };
22 |
23 | // Bind to a UDP socket to listen for incoming OSC events.
24 | var udpPort = new osc.UDPPort({
25 | localAddress: "0.0.0.0",
26 | localPort: 57121
27 | });
28 |
29 | udpPort.on("ready", function () {
30 | var ipAddresses = getIPAddresses();
31 | console.log("Listening for OSC over UDP.");
32 | ipAddresses.forEach(function (address) {
33 | console.log(" Host:", address + ", Port:", udpPort.options.localPort);
34 | });
35 | console.log("To start the demo, go to http://localhost:8081 in your web browser.");
36 | });
37 |
38 | udpPort.open();
39 |
40 | // Create an Express-based Web Socket server to which OSC messages will be relayed.
41 | var appResources = __dirname + "/web",
42 | app = express(),
43 | server = app.listen(8081),
44 | wss = new WebSocket.Server({
45 | server: server
46 | });
47 |
48 | app.use("/", express.static(appResources));
49 | wss.on("connection", function (socket) {
50 | console.log("A Web Socket connection has been established!");
51 | var socketPort = new osc.WebSocketPort({
52 | socket: socket
53 | });
54 |
55 | var relay = new osc.Relay(udpPort, socketPort, {
56 | raw: true
57 | });
58 | });
59 |
--------------------------------------------------------------------------------
/nodejs/README.md:
--------------------------------------------------------------------------------
1 | # Node.js Serial and UDP Example
2 |
3 | This example illustrates a Node.js application that accepts OSC messages
4 | from the serial port and a UDP socket (listening on port 57121).
5 |
6 | ## OSC Messages Over UDP
7 | By default, this example is configured to handle OSC messages via from Lemur's AB Faderlab project.
8 | It maps four parameters of a simple Flocking-based FM synthesizer to the first four
9 | faders in the Lemur project. Here is the mapping:
10 |
11 |
12 |
13 |
OSC Address
14 |
OSC Argument Type
15 |
Synth Paramter
16 |
17 |
18 |
/fader1/out
19 |
float 0.0 - 1.0
20 |
carrier frequency
21 |
22 |
23 |
/fader2/out
24 |
float 0.0 - 1.0
25 |
carrier amplitude
26 |
27 |
28 |
/fader3/out
29 |
float 0.0 - 1.0
30 |
modulator frequency
31 |
32 |
33 |
/fader4/out
34 |
float 0.0 - 1.0
35 |
modulator amplitude
36 |
37 |
38 |
39 | If you don't have a copy of Lemur, you can use the SuperCollider test client created by [Jascha Narveson](https://github.com/jaschanarveson), which is located in the [utils](../utils/supercollider-lemur-faderlab-style-client.scd) directory.
40 |
41 | ## OSC Messages Over Serial
42 | This example also listens for OSC messages over the serial port (which can be specified as the first argument to Node.js when starting the server). Here is the mapping:
43 |
44 |
45 |
46 |
OSC Address
47 |
OSC Argument Type
48 |
Synth Paramter
49 |
50 |
51 |
/knobs/0
52 |
float 0.0 - 1.0
53 |
carrier frequency
54 |
55 |
56 |
/knobs/1
57 |
float 0.0 - 1.0
58 |
carrier amplitude
59 |
60 |
61 |
/knobs/2
62 |
float 0.0 - 1.0
63 |
modulator frequency
64 |
65 |
66 |
/knobs/3
67 |
float 0.0 - 1.0
68 |
modulator amplitude
69 |
70 |
71 |
72 | ## Installing and Running the Example
73 |
74 | 0. Run npm install in the terminal to install all required dependencies
75 | 1. Run node . to start the Node.js application
76 | 2. Control the synth using OSC messages sent from Lemur, another source of OSC messages sent via UDP, or via a serial device that sends OSC messages (such as an Arduino project)
77 |
--------------------------------------------------------------------------------
/chrome-app/js/example-synth.js:
--------------------------------------------------------------------------------
1 | var flock = flock || require("../../nodejs/node_modules/flocking"),
2 | example = example || {};
3 |
4 | (function () {
5 |
6 | "use strict";
7 |
8 | flock.init();
9 |
10 | // A nice little FM synth.
11 | // Incoming OSC messages control the frequency and amplitude
12 | // of both the modulator and the carrier oscillators.
13 | example.synth = flock.synth({
14 | synthDef: {
15 | id: "carrier",
16 | ugen: "flock.ugen.sin",
17 | freq: {
18 | ugen: "flock.ugen.value",
19 | rate: "audio",
20 | value: 400,
21 | add: {
22 | id: "modulator",
23 | ugen: "flock.ugen.sin",
24 | freq: {
25 | ugen: "flock.ugen.value",
26 | rate: "audio",
27 | value: 124
28 | },
29 | mul: 100
30 | }
31 | },
32 | mul: 0.3
33 | }
34 | });
35 |
36 | var freqTransform = function (value) {
37 | return (value * 6000) + 60;
38 | };
39 |
40 | var identityTransform = function (value) {
41 | return value;
42 | };
43 |
44 | var carrierSpec = {
45 | freq: {
46 | inputPath: "carrier.freq.value",
47 | transform: freqTransform
48 | },
49 | mul: {
50 | inputPath: "carrier.mul",
51 | transform: identityTransform
52 | }
53 | };
54 |
55 | var modulatorSpec = {
56 | freq: {
57 | inputPath: "modulator.freq.value",
58 | transform: freqTransform
59 | },
60 | mul: {
61 | inputPath: "modulator.mul",
62 | transform: freqTransform
63 | }
64 | };
65 |
66 | example.synthValueMap = {
67 | "/knobs/0": carrierSpec.freq,
68 | "/fader1/out": carrierSpec.freq,
69 |
70 | "/knobs/1": carrierSpec.mul,
71 | "/fader2/out": carrierSpec.mul,
72 |
73 | "/knobs/2": modulatorSpec.freq,
74 | "/fader3/out": modulatorSpec.freq,
75 |
76 | "/knobs/3": modulatorSpec.mul,
77 | "/fader4/out": modulatorSpec.mul
78 | };
79 |
80 | example.mapOSCToSynth = function (oscMessage, synth, valueMap) {
81 | var address = oscMessage.address;
82 | var value = oscMessage.args[0];
83 | var transformSpec = valueMap[address];
84 |
85 | if (transformSpec) {
86 | var transformed = transformSpec.transform(value);
87 | synth.set(transformSpec.inputPath, transformed);
88 | }
89 | };
90 |
91 | // If we're in a require-compatible environment, export ourselves.
92 | if (typeof module !== "undefined" && module.exports) {
93 | module.exports = example;
94 | }
95 |
96 | }());
97 |
--------------------------------------------------------------------------------
/chrome-app/README.md:
--------------------------------------------------------------------------------
1 | # Chrome App Serial and UDP Example
2 |
3 | This example illustrates a Chrome application that accepts OSC messages
4 | from the serial port and a UDP socket (listening on port 57121).
5 |
6 | ## OSC Messages Over UDP
7 | By default, this example is configured to handle OSC messages via from Lemur's AB Faderlab project.
8 | It maps four parameters of a simple Flocking-based FM synthesizer to the first four
9 | faders in the Lemur project. Here is the mapping:
10 |
11 |
12 |
13 |
OSC Address
14 |
OSC Argument Type
15 |
Synth Paramter
16 |
17 |
18 |
/fader1/out
19 |
float 0.0 - 1.0
20 |
carrier frequency
21 |
22 |
23 |
/fader2/out
24 |
float 0.0 - 1.0
25 |
carrier amplitude
26 |
27 |
28 |
/fader3/out
29 |
float 0.0 - 1.0
30 |
modulator frequency
31 |
32 |
33 |
/fader4/out
34 |
float 0.0 - 1.0
35 |
modulator amplitude
36 |
37 |
38 |
39 | If you don't have a copy of Lemur, you can use the SuperCollider test client created by [Jascha Narveson](https://github.com/jaschanarveson), which is located in the [utils](../utils/supercollider-lemur-faderlab-style-client.scd) directory.
40 |
41 | ## OSC Messages Over Serial
42 | This example also listens for OSC messages over the serial port, which can be selected from the dropdown menu in the app. Here is the mapping:
43 |
44 |
45 |
46 |
OSC Address
47 |
OSC Argument Type
48 |
Synth Paramter
49 |
50 |
51 |
/knobs/0
52 |
float 0.0 - 1.0
53 |
carrier frequency
54 |
55 |
56 |
/knobs/1
57 |
float 0.0 - 1.0
58 |
carrier amplitude
59 |
60 |
61 |
/knobs/2
62 |
float 0.0 - 1.0
63 |
modulator frequency
64 |
65 |
66 |
/knobs/3
67 |
float 0.0 - 1.0
68 |
modulator amplitude
69 |
70 |
71 |
72 | ## Installation
73 |
74 | 1. Run npm install in the Terminal
75 | 2. Open Chrome's _Extensions_ window (_More Tools > Extensions_)
76 | 3. Enable the _Developer Mode_ checkbox
77 | 4. Choose _Load unpacked extension..._ and navigate to the chrome-app directory
78 |
79 | ## Running the Example
80 | 1. In Chrome's _Extensions_ window, click the _Launch_ link for the OSC.js Chrome App Demo extension
81 | 2. Control the synth using OSC messages sent from Lemur, another source of OSC messages sent via UDP, or via a serial device that sends OSC messages (such as an Arduino project).
82 |
--------------------------------------------------------------------------------
/chrome-app/js/app.js:
--------------------------------------------------------------------------------
1 | (function () {
2 |
3 | "use strict";
4 |
5 | var oscMessageListener = function (oscMessage) {
6 | example.mapOSCToSynth(oscMessage, example.synth, example.synthValueMap);
7 | $("#message").text(fluid.prettyPrintJSON(oscMessage));
8 | };
9 |
10 | /*******************
11 | * OSC Over Serial *
12 | *******************/
13 |
14 | // Enumerate all the serial port devices and render them to the dropdown.
15 | chrome.serial.getDevices(function (ports) {
16 | var portSelector = $("#portSelector");
17 |
18 | portSelector.empty();
19 | ports.forEach(function (port) {
20 | var label = port.displayName || port.path;
21 | var option = $("");
22 | portSelector.append(option);
23 | });
24 |
25 | var selectPort = function () {
26 | var selectedDevice = $("#portSelector").val();
27 | connectToSerialPort(selectedDevice);
28 | };
29 |
30 | portSelector.change(selectPort);
31 |
32 | if (ports.length === 1) {
33 | selectPort();
34 | }
35 |
36 | });
37 |
38 | var connectToSerialPort = function (devicePath) {
39 | // Instantiate a new OSC Serial Port.
40 | var serialPort = new osc.SerialPort({
41 | devicePath: devicePath
42 | });
43 |
44 | // Listen for the message event and map the OSC message to the synth.
45 | serialPort.on("message", oscMessageListener);
46 |
47 | // Open the port.
48 | serialPort.open();
49 | };
50 |
51 |
52 | /****************
53 | * OSC Over UDP *
54 | ****************/
55 |
56 | var getIPAddresses = function () {
57 | var ipAddresses = [];
58 | chrome.system.network.getNetworkInterfaces(function (interfaces) {
59 | interfaces.forEach(function (iface) {
60 | if (iface.prefixLength === 24) {
61 | ipAddresses.push(iface.address);
62 | }
63 | });
64 | });
65 |
66 | return ipAddresses;
67 | };
68 |
69 | // Also bind to a UDP socket.
70 | var udpPort = new osc.UDPPort({
71 | localAddress: "0.0.0.0",
72 | localPort: 57121
73 | });
74 |
75 | udpPort.on("ready", function () {
76 | var ipAddresses = getIPAddresses(),
77 | addressPortStrings = [];
78 |
79 | ipAddresses.forEach(function (address) {
80 | addressPortStrings.push(address + ":" + udpPort.options.localPort);
81 | });
82 |
83 | $("#udpStatus").append("