Pages: [1]   Go Down
Author Topic: Raw UDP on Arduino  (Read 737 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 4
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hello

I need to send Raw UDP messages, and I'm a little confused by various posts in the forum.

I've tried:

byte outBuf[] = {0xF0, 0x43, 0x10, 0x3E, 0x7F, 0x01, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xF7};

// This sends all 14 bytes, zeros and all
Udp.write(outBuf, 14);

But this doesn't seem to work...

Any help would be most appreciated!
Logged

Seattle, WA USA
Offline Offline
Brattain Member
*****
Karma: 614
Posts: 49386
Seattle, WA USA
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
But this doesn't seem to work...
Your evidence?
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 4
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

I'm trying to send the Raw UDP (over WiFi) back to an iPhone.  When I send messages to the iPhone (over WiFi) using a MAX patcher (using sadam.udpsender) everything works.  Is there any way I can monitor this (I've tried Wireshark, but there's too much traffic).  Is there a Processing example for RawUDP?  I'm sure I'm very close here, not sure what to try next...
Logged

Seattle, WA USA
Offline Offline
Brattain Member
*****
Karma: 614
Posts: 49386
Seattle, WA USA
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

That was a hint for you to post your code.
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 4
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Sorry, I didn't get that...

Thanks for your replies!

My hardware setup is:  Arduino Uno, Arduino Ethernet Shield connected to TP-Link Nano Wireless router, MIDI Shield.
My aim is to build a standalone RawUDP->MIDI, MIDI->RawUDP standalone interface using Arduino modules.

The RawUDP part is the issue...  I'm sure it's a small coding error.

Code:
#include <MIDI.h>
#include <SPI.h>         // needed for Arduino versions later than 0018
#include <Ethernet.h>
#include <EthernetUdp.h>         // UDP library from: bjoern@cs.stanford.edu 12/30/2008


// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 
  0x90, 0xA2, 0xDA, 0x0D, 0xFC, 0xDD };
IPAddress ip(192,168,0,21);
int led = 6;
unsigned int localPort = 9000;      // local port to listen on
 IPAddress destinationIP(192, 168, 0, 223);  // Address of target machine
  unsigned int destinationPort = 9001;      // Port to send to

// buffers for receiving and sending data
char packetBuffer[14]; //buffer to hold incoming packet,
char  ReplyBuffer[] = "acknowledged";       // a string to send back

// An EthernetUDP instance to let us send and receive packets over UDP
EthernetUDP Udp;

void setup() {
   pinMode(led, OUTPUT);
  // start the Ethernet and UDP:
  Ethernet.begin(mac,ip);
  Udp.begin(localPort);

  //Serial.begin(9600);
}

void loop() {
  // if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  if(packetSize)
  {
 
     digitalWrite(led, HIGH);
   
    // read the packet into packetBufffer
    Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);
   
   
   
   
    // send a reply, to the IP address and port that sent us the packet we received
    delay(10);
    // The message is UDP equivalent of a MIDI SysEx message to turn channel 2 of an 01v96 console ON...
   byte outBuf[] = {0xF0, 0x43, 0x10, 0x3E, 0x7F, 0x01, 0x1A, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xF7};

   // This should send all 14 bytes, zeros and all - this is not working!
   Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
   Udp.write(outBuf, 14);
   Udp.endPacket();

   
   
    Serial.flush();
    delay(2);
    Serial.end();
 
 // Change the arduino's baud rate to that of MIDI...
 
  Serial.begin(31250);
 //Send received string out via MIDI - this is working.
    Serial.write(240);  //F0
  //  Serial.println("SysEx Sent:");
   // Serial.print(240);
    //Serial.print(" ");
    for (int n = 1; n< packetSize - 1; n++)
    {
      Serial.write(packetBuffer[n]);
     // Serial.print(packetBuffer[n], DEC);
     // Serial.print(" ");
    }
    Serial.write(247); //F7
    Serial.flush();
   delay(2);
    Serial.end();
   digitalWrite(led, LOW);
 
     
  }
 
   
  delay(10);
}

I'm receiving fine from the iPhone, and the MIDI is output correctly.  But the UDP send back to the iPhone (which should turn channel 2 on in the iOS App) never gets received. That's my only stumbling block.  Please note, I need the output to be Raw UDP, sent to the correct IP and Port.  I think that's where the problem lies.

Hope you can help!
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 4
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Anyone?
Logged

Offline Offline
Jr. Member
**
Karma: 1
Posts: 55
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Unfortunately I can't post the whole program, it's too long,
but here's the main loop:
Code:
/*
** l o o p
**
** Main loop of udpsensor.ino
*/
void loop(void)
{
    double celsius = 0;
    double fahrenheit = 0;
    unsigned int raw = 0;
    byte cneg = false;
    byte fneg = false;
    byte cfg = 0;
    byte chip = 0;
    byte rom[8];
    byte scratch[12];
    char buff[24];
    char udp[MAGIC];
    char buffer[MAGIC / 2];

    //Serial.println("loop()");

    if (!interrupted) return;

    // Get and send the values for each sensor in turn
    for (int idx = 0 ; idx < (addr_idx / 8) ; idx++) {

        memset(buffer, 0, sizeof(buffer));
        memset(udp, 0, sizeof(udp));

        strcpy(buff, "Sensor 0: ");
        buff[7] = (char) ('0' + idx + 1);
        strcat(udp, buff);
        strcat(buffer, buff);

        // Get the current DS1820 ROM code, displaying
        // it with the MSB to the left.
        for (int j = 0 ; j < 8 ; j++) {
            rom[j] = addresses[idx * 8 + j];
#if 0
            sprintf(buff, "%02x", addresses[idx * 8 + 7 - j]);
            strcat(udp, buff);
            strcat(buffer, buff);
        }
#else
            buff[j * 2] = hex[(addresses[idx * 8 + 7 - j] >> 4) & 0xf];
            buff[j * 2 + 1] = hex[addresses[idx * 8 + 7 - j] & 0xf];
        }
        buff[16] = '\0';
        strcat(udp, buff);
        strcat(buffer, buff);
#endif

        // Add spacing to the output
        strcat(buffer, " ");
        strcat(udp, " ");

        // A sensor has been found and needs to be read
        ds.reset();             // Returns 0 on failure, 1 if device present
        ds.select(rom);         // This is the Match Rom command
        ds.write(CONVERT, 1);   // Start conversion, maintain parasitic power
        delay(CVTDLY);          // Maybe 750ms is enough, maybe not
        // We might do a ds.depower() here, but the reset is sufficient
        ds.reset();
        ds.select(rom);
        ds.write(READSCRATCH);  // Read scratchpad
        for (int j = 0 ; j < 9 ; j++)   // get 9 bytes from sensor
            scratch[j] = ds.read();

        // convert the data to an actual temperature
        // This expression has sign-extension problems.
        //raw = (unsigned int) ((scratch[1] << 8) | scratch[0]);
        raw = scratch[1];
        raw <<= 8;
        r = scratch[0] & 0xff;
        raw |= r;

        // We are using a DS18B20, so chip is always 0
        // 0x60 is 01100000, 0x20 is 00100000, 0x10 is 000100000
        if (chip == 0) {
            cfg = (uint8_t) (scratch[4] & 0x60);
            Serial.print("Conversion delay: ");
            Serial.println(CVTDLY);
            Serial.print("Resolution: ");
            if (cfg == 0x00) {      // 9 bit resolution, 93.75 ms
                Serial.println("9-bit");
                raw = raw & ~3u;
            }
            else if (cfg == 0x20) { // 10 bit res, 187.5 ms
                Serial.println("10-bit");
                raw = raw & ~2u;
            }
            else if (cfg == 0x40) { // 11 bit res, 375 ms
                Serial.println("11-bit");
                raw = raw & ~1u;
            }
            // default is 12 bit resolution, 750 ms conversion time
            else {
                Serial.println("12-bit");
            }
        }
        else {
            raw = raw << 3;     // 9 bit resolution default
            if (scratch[7] == 0x10) {
                // count remaining gives full 12 bit resolution
                raw = (raw & 0xFFF0) + 12 - scratch[6];
            }
        }

        // To get 2s-complement negative value, invert and add 1
        if (raw & 0x800) {
            raw = ~raw;
            raw += 1;
            cneg = true;
        }
        else
            cneg = false;

        // At the 12 bit maximum resolution, each bit is 1/16 of a degree C
        raw = raw & 0x7ff;
        celsius = (double) raw / 16.0;
        if (cneg)
            fahrenheit = 32 - celsius * 1.8;
        else
            fahrenheit = 32 + celsius * 1.8;
        if (fahrenheit < 0) {
            fneg = true;
            fahrenheit = - fahrenheit;
        }
        else
            fneg = false;

        buff[0] = cneg ? '-' : '+';
        d2a(celsius, buff + 1);
        strcat(udp, buff);
        strcat(buffer, buff);
        // Is there a way of avoiding this lvalue ???
        uint32_t a = uint32_t(dest);
        send_packet(udp, (byte *) &a, udp_port);

        // There seems no way to print floating point numbers,
        // despite the documentation. The loop simply hangs.
        // d = 1357;
        // c = 5791;
        // double e = 45.67;

        int c = (int) celsius;
        int f = (int) fahrenheit;
       
        strcpy(buff, "  Temperature =  ");
        buff[16] = cneg ? '-' : '+';
        Serial.print(buff);
        Serial.print(c, DEC);
        strcpy(buff, " Celsius,  ");
        buff[10] = fneg ? '-' : '+';
        Serial.print(buff);
        Serial.print(f, DEC);
        Serial.println(" Fahrenheit");

        // Check for low memory levels.
        Serial.print("Free memory: ");
        Serial.print(freeMemory());
        Serial.println(" bytes\n");

#ifdef WDT
        interrupted = false;
#endif
    }

    // Check at roughly 5 second intervals
    delay(4000);

    return;
}


/*
** s e n d _ p a c k e t
**
** Transmit a UDP packet.
**
** Returns:     Nothing     Always
*/
static void send_packet(const char *data, byte *dst, unsigned int udpport)
{
    //Serial.println("send_packet()");

    udpclient.beginPacket(dst, udpport);
    udpclient.write((byte *) data, MAGIC);
    udpclient.endPacket();

    return;
}
Logged

Pages: [1]   Go Up
Jump to: