UDP.write sendet nicht/ UDP.parsePacket() ist 0

Hallo an alle,

zwar wird das Thema schon in meiner anderen Frage kurz diskutiert aber passt nicht zum Post deshalb mache ich einen neuen. Wenn man mal Probleme hat und danach sucht findet man es leichter.

Also ich wandle einen String zu einem char array um und will diesen dann per UDP senden.
Leider kommt an der anderen seite nichts an, also "parsePacket" ist leer.

Hier mein Code vom sender:

int16_t  actoffset[6]; 


String off = ofst + "," + id_name + "," + String(actoffset[0]) + "," + String(actoffset[1]) + "," + String(actoffset[2]) + "," + String(actoffset[3]) + "," + String(actoffset[4]) + "," + String(actoffset[5]) + "," + String(actoffset[6]);

  
  char buf[51];
  off.toCharArray((char *)buf, 50);
  Serial.println(buf);
  //Serial.println(itoa(buf, buffer, 10));
  UdpTwo.begin(PORTOFF);
  UdpTwo.beginPacket(unicastIP, PORTOFF);
  UdpTwo.write(buf, sizeof(buf));
  //Udp.print(text);
  UdpTwo.endPacket();

Empfänger sieht so aus;

char packetBuffer[51];

int packetSize1 = UdpTwo.parsePacket();

        if (packetSize1) {
          int len = UdpTwo.read(packetBuffer, sizeof(packetBuffer));

          if (len > 0) packetBuffer[len] = 0;

          Serial.println("Contents:");

          Serial.println(packetBuffer);
        }

Und wenn ich das laufen lasse kommt er nie in die if schleife also

int packetSize1 = UdpTwo.parsePacket();

ist immer 0.

Wenn ich aber beim senden anstatt:

UdpTwo.write(buf, sizeof(buf));

das hier sende;

UdpTwo.write("Hallo");

funktioniert alles richtig.

Wäre jemand so nett mir zu erklären woran das liegt und wie ich das beheben kann?

Danke an alle!!!

mfg

Kein Mensch kann sagen, ob Du überhaupt Netz hast!
Du kommst mit jedem neuen Thread immer nur mit irgendwelchen Schnipseln, und jetzt sollen alle raten, was Du da gebaut hast und was dabei rauskommen soll.
Bau doch mal endlich irgendwas zusammen, an dem sich orientiert werden kann!

Mit Deiner Heimlichtuerei macht das Lesen Deiner Probleme keinen Sinn.

Na denn...

Wenn etwas nicht richtig funktioniert, gibt es meist eine Fehlermeldung. Warum verheimlichst du uns die ?
Und es gibt keine "if-Schleife"

Ich hab meinen code hier schon 100 mal gepostet, aber der ist lange und mit den wichtigen Sachen wollte ich es den Helfenden leichter machen.
Und genau in meinen letzte 2 post war es das einzige mal das ich ausschnitte gepostet habe und nicht alles!

Und da muss ich auch mal sagen, warum es so oft vorkommt, dass wenn jemand nur Teile seines Codes postet, sofort Heimlichtuerei vorgeworfen wird?

Manche meinen das einfach nett und mittlerweile habe ich schon so oft gepostet und jede Frage die mir gestellt wurde nett beantwortet (auch wenn manchmal komische antworten zurück kamen) und man sich denk warum auf eine nette Frage so eine Antwort kommt.
Vor allem du hast mir auch schon paar mal geantwortet und solltest wissen, das ich immer auf Nachfragen oder sowas Antworte und fast jedes mal mein ganzer Code von Anfang an gepostet habe.

Ich bin immer dankbar für die Hilfe aber das was du gerade schreibst stimmt überhaupt nicht und du solltest das wissen aus meinen anderen Posts.

Ich versteh schon das das deutsche Forum von ein paar netten Leuten lebt die allen anderen Helfen und sag immer danke und halte nie Code zurück oder sonst was.

ist nicht böse gemeint, sondern eine Verteidigung auf Aussagen die so nicht stimmen!

Sorry es gibt keine if schleifen sondern nur if abfragen.
Aber meinte genau diese if abfrage.

Dachte man versteht was ich meine...

Und für dich auch ich verheimliche garnichts!
Es gibt keine Fehlermeldung sonst hätte ich diese gepostet.
Aus Vermutungen anderen etwas Unterstellen wenn man selber schon schreibt das es nur "meistens" eine Fehlermeldung gibt...

Hallo,
Wenn es doch mit "Hallo" läuft das kann es doch nur an der gesendeten Zeichenkette liegen. Versuch doch mal den Vorschlag mit sprintf() den ich Dir in dem anderen Post in #11 gemacht habe.
Heinz

Hallo,, ach ok das mit sprintf() habe ich nicht gewusst was du genau meinst.

Anstelle von was soll ich sprintf() benutzen?

Statt:

UdpTwo.write(buf, sizeof(buf));

?

danke das du dich hier nochmal einbringst!

mfg

Nein. Statt dem ganzen Kram mit Strings und +

sprintf() erstellt einen formatierten C String in einem Puffer. Den kann man dann mit einem Funktionsaufruf senden. Was mit print()/println() nicht geht.

https://www.cplusplus.com/reference/cstdio/sprintf/

Composes a string with the same text that would be printed if format was used on printf, but instead of being printed, the content is stored as a C string in the buffer pointed by str .

Hallo und auch dir danke für deine Antwort.

Leider verstehe ich trotzdem nicht was ich jetzt im code ändern soll bzw ersetzten soll?

Sorry für meine dummheit aber bin erst ein paar wochen dabei..

mfg

Hallo,
jein du hast da noch ein Ei drin du willst die Länge der Zeichenkette senden, nicht die länge des reservierten Speichers.

sizeof(buf) // länge des Speichers mit allem Rest und Müll drin drin
strlen(buff) // Länge der Zeichenkette bis 0 Terminator 

ist nicht das Gleiche.

schau dir noch mal das an was ich in meiner Bastelkiste gefunden hatte
die Zeile
sprintf(sendPack, "%4d;%4.2f;%4.2f;%4.2f;%4.2f", devAdress, temp, hum, pres, Vcc);

musst Du ersetzen eigendlich ersetzen durch das was in #11 steht

sprintf(buff, "UH,%i,%i,%i,%i,%i", offset[0], offset[1],offset[2], offset[3], offset[4], offset[5]);

und dann später

int len = strlen(buff);
UdpTwo.write(buff, len));

so schwer kann das doch nicht sein. :wink:

Hier der Link zu dem anderen Post damit das komplett ist

Heinz

ach ok jetzt verstehe ich was du damit meinst.
Dachte sprintf() ist ein ersatz fürs senden und ich kenn mich nicht aus...
Jetzt wird mir das klarer.

Ok danke ich versuch das mal gleich und sag dann bescheid!

den anderen post habe ich sogar gelesen aber auch nicht verstanden was damit gemeint ist, aber jetzt weiß ich es, danke nochmals

Hi , beginner_new_123,
für weitere Situationen, wenn Du ein Post liest , und es nicht verstehst , bitte keine Scheu oder Scham haben : mit einem '@ (name des posters dessen post du nicht verstehst)' direkt nachfragen. Sage ihm, dass Du das nicht verstanden hast, noch besser sage ihm möglichst genau, WAS Du nicht verstanden hast und bitte um Erklärung. Solange Du Dich redlich bemühst , zu verstehen, ist es keine Schande, wenn du was nicht verstehst und nachfragen musst, da wird Dir niemand böse sein.

Weiterhin viel Spass mit Arduino

Du kannst auch bei Google "Arduino sprintf" sehr viele Hilfestellungen finden und nachlesen bzw. probieren.

Und wenn du dir die Seite von Fips mal ansiehst, findest du auch für dein Problem eine Lösung.

Hallo,

danke für deine Antwort und Hilfe!
Ich hab das auch schon so versucht.

Mein Problem ist jedoch, dass ich eigentlich gerne ein Struct senden würde, wie ich auch schon mit der Quaternion mache.
Dabei habe ich jeweils die ID von wem es gesendet wird dabei um so dann beim Emofänger unterscheiden zu könne.
Jetzt würde ich gerne das selbe mit den Offset machen, da stecke ich aber.
Ich bekomme alles gesendet aber es werden nur komische zeichen angezeigt!
Wie gesagt beim senden der anderen daten funktioniert es.
Hier ein ausschnitt vom seriel monitor:

Hand sends:
0
⸮⸮

Vlt sollte ich noch sagen, das ich einen Button verwende (beim AP) der mir das neue initalisieren vom Offset beim Client (Sensor) startet, jedoch wir beim ersten mal drücken nichts gesendet.
Da liegt mein zweites Problem.

vlt hättet du ja eine Lösung.

Hier der Ausschnitt vom Empfänger der Probleme bereitet (Rest unten im kompletten Code):

int packetSize1 = UdpTwo.parsePacket();
  Serial.println(packetSize1);
  if (packetSize1) {
    while (UdpTwo.read((uint8_t*)&msgoffval, sizeof(msgoffval)) == sizeof(msgoffval)) {
      Serial.println(msgoffval.sender);
      Serial.println(msgoffval.response);
      if (msgoffval.sender == "Hand") {
        Serial.println("Hand sends: ");
        Serial.println(msgoffval.sender);
        Serial.println(msgoffval.response);
      }
      else if (msgoffval.sender == "UnderArm") {
        Serial.println("UnderArm sends: ");
        Serial.println(msgoffval.sender);
        Serial.println(msgoffval.response);
      }
      else if (msgoffval.sender == "UpperArm") {
        Serial.println("UpperArm sends: ");
        Serial.println(msgoffval.sender);
        Serial.println(msgoffval.response);
      }
    }
  }

Hier der Code vom Sender der Probleme bereitet:

mpu.getActiveOffsets(actoffset);
  Serial.println("From Offset Data Function:");
  //Serial.println(actoffset[0]);

  String ofst = "Offset";

  String id_name = "Hand"; // Change
  String off = String(actoffset[0]) + "," + String(actoffset[1]) + "," + String(actoffset[2]) + "," + String(actoffset[3]) + "," + String(actoffset[4]) + "," + String(actoffset[5]) + "," + String(actoffset[6]);
  Serial.println(off);

  off.toCharArray((char *)msgoffval.response, 50);
  //id_name.toCharArray((char *)msgoffval.sender, 5);//Change
  //sprintf(response, "UH,%i,%i,%i,%i,%i", actoffset[0], actoffset[1],actoffset[2], actoffset[3], actoffset[4], actoffset[5]);
  Serial.println(msgoffval.response);
  Serial.println(msgoffval.sender);
  UdpTwo.begin(PORTOFF);
  UdpOne.beginPacket(unicastIP, PORTOFF);
  UDP_MESSAGE_OFFVAL msgoffval;
  msgoffval.sender = Hand; //Change
  //msgoffval.response = buf;
  UdpOne.write((uint8_t*)&msgoffval, sizeof(msgoffval));
  UdpOne.endPacket();

So hätte och es gerne da es funktioniert Empfänger:

int packetSize = UdpOne.parsePacket();
    if (packetSize) {
      while (UdpOne.read((uint8_t*)&msg, sizeof(msg)) == sizeof(msg))
      {
        digitalWrite(D7, LOW);
        digitalWrite(D5, HIGH);

        if (msg.sender == Hand)
        {
          //Serial.println("Hand sends: ");
          //Serial.println(msg.sender);
          //Serial.println(msg.q.w);
          //Serial.println(msg.q.x);
          //Serial.println(msg.q.y);
          //Serial.println(msg.q.z);

          String Sender_bez = "Hand";
          String all = Sender_bez + "," + String(msg.q.w) + "," + String(msg.q.x) + "," + String(msg.q.y) + "," + String(msg.q.z);
          Serial.println(all);
        }

        else if (msg.sender == UnderArm)
        {
          //Serial.println("UnderArm sends: ");
          //Serial.println(msg.q.w);
          //Serial.println(msg.q.x);
          //Serial.println(msg.q.y);
          //Serial.println(msg.q.z);

          String Sender_bez = "UnderArm";
          String all = Sender_bez + "," + String(msg.q.w) + "," + String(msg.q.x) + "," + String(msg.q.y) + "," + String(msg.q.z);
          Serial.println(all);
        }
        else if (msg.sender == UpperArm)
        {
          //Serial.println("UpperArm sends: ");
          //Serial.println(msg.q.w);
          //Serial.println(msg.q.x);
          //Serial.println(msg.q.y);
          //Serial.println(msg.q.z);

          String Sender_bez = "UpperArm";
          String all = Sender_bez + "," + String(msg.q.w) + "," + String(msg.q.x) + "," + String(msg.q.y) + "," + String(msg.q.z);
          Serial.println(all);
        }
      }
    }

Hier der Code vom Sender der Funktioniert:

UdpOne.beginPacket(unicastIP, PORT);
        UDP_MESSAGE msg;
        msg.sender = Hand; //Change
        msg.q = q;
        UdpOne.write((uint8_t*)&msg, sizeof(msg));
        UdpOne.endPacket();

Rest bitte hier aus den kompletten Code für Empfänger entnehmen:
Client (es werde für den Anfang 3 Clients sein, später noch mehr):


#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <WiFiUdp.h>
#include "MPU6050_6Axis_MotionApps20.h"


const char *ssid = "ESPap";
const char *password = "thereisnospoon";

ESP8266WebServer server(80);

IPAddress unicastIPHand(192, 168, 4, 2);
IPAddress unicastIPUnderArm(192, 168, 4, 3);
IPAddress unicastIPUpperArm(192, 168, 4, 4);
constexpr uint16_t PORT = 8266;
constexpr uint16_t PORTOFF = 8999;
//#define MAX_CLIENTS 8
WiFiUDP UdpOne;
WiFiUDP UdpTwo;

void handleRoot() {
  server.send(200, "text/html", "<h1>You are connected</h1>");
  String addy = server.client().remoteIP().toString();
  Serial.println(addy);
}

enum UDP_CLIENT_ID {Hand, UnderArm, UpperArm};

struct UDP_MESSAGE {
  UDP_CLIENT_ID sender;
  Quaternion q;
};

enum UDP_CLIENT_OFFSET {Start};

struct UDP_MESSAGE_OFFSET {
  UDP_CLIENT_OFFSET offset;
};

enum UDP_CLIENT_WIFICONRESP {Connected, NConnected};

struct UDP_MESSAGE_OFFVAL {
  UDP_CLIENT_ID sender;
  char response[51];
};

UDP_MESSAGE msg;
UDP_MESSAGE_OFFSET msgoff;
UDP_MESSAGE_OFFVAL msgoffval;
int pin = 0;
int start_count = 0;
int16_t  actoffset[6];   // Values of active offset
char packetBuffer[51];
long myTimer = 0;
long myTimeout = 50000;
char buf[51];

/*===================================================================== */
void udp_off() {

  int packetSize1 = UdpTwo.parsePacket();
  Serial.println(packetSize1);
  if (packetSize1) {
    while (UdpTwo.read((uint8_t*)&msgoffval, sizeof(msgoffval)) == sizeof(msgoffval)) {
      Serial.println(msgoffval.sender);
      Serial.println(msgoffval.response);
      if (msgoffval.sender == "Hand") {
        Serial.println("Hand sends: ");
        Serial.println(msgoffval.sender);
        Serial.println(msgoffval.response);
      }
      else if (msgoffval.sender == "UnderArm") {
        Serial.println("UnderArm sends: ");
        Serial.println(msgoffval.sender);
        Serial.println(msgoffval.response);
      }
      else if (msgoffval.sender == "UpperArm") {
        Serial.println("UpperArm sends: ");
        Serial.println(msgoffval.sender);
        Serial.println(msgoffval.response);
      }
    }
  }
}
/*===================================================================== */
void setup() {

  Serial.begin(115200);
  pinMode(D5, OUTPUT);
  pinMode(D6, INPUT);
  pinMode(D7, OUTPUT);
  Serial.println();
  Serial.print("Configuring access point...");
  WiFi.softAP(ssid, password);

  IPAddress myIP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(myIP);
  server.on("/", handleRoot);
  server.begin();
  Serial.println("HTTP server started");

  Serial.println("Starting UDP");
  UdpOne.begin(PORT);
  Serial.printf("Now listening at IP %s, UDP port %d\n", WiFi.softAPIP().toString().c_str(), PORT);
  UdpTwo.begin(PORTOFF);
  Serial.printf("Now listening at IP %s, UDP port %d\n", WiFi.softAPIP().toString().c_str(), PORTOFF);

}

/*===================================================================== */

void loop() {
  server.handleClient();
  //Serial.printf("Anzahl der Verbundenen Geräte= %d\n", WiFi.softAPgetStationNum());
  /*
    if (millis() > myTimeout + myTimer ) {
      myTimer = millis();
      int packetSize1 = UdpTwo.parsePacket();

      if (packetSize1) {
        int len = UdpTwo.read(packetBuffer, sizeof(packetBuffer));

        if (len > 0) packetBuffer[len] = 0;

        Serial.println("Contents:");

        Serial.println(packetBuffer);
      }
    }
  */
  //udp_off();

  pin = digitalRead(D6);
  //Serial.print("Pin Status für if- Schleife: ");
  //Serial.println(pin);
  if (pin == LOW) {
    int packetSize = UdpOne.parsePacket();
    if (packetSize) {
      while (UdpOne.read((uint8_t*)&msg, sizeof(msg)) == sizeof(msg))
      {
        digitalWrite(D7, LOW);
        digitalWrite(D5, HIGH);

        if (msg.sender == Hand)
        {
          //Serial.println("Hand sends: ");
          //Serial.println(msg.sender);
          //Serial.println(msg.q.w);
          //Serial.println(msg.q.x);
          //Serial.println(msg.q.y);
          //Serial.println(msg.q.z);

          String Sender_bez = "Hand";
          String all = Sender_bez + "," + String(msg.q.w) + "," + String(msg.q.x) + "," + String(msg.q.y) + "," + String(msg.q.z);
          Serial.println(all);
        }

        else if (msg.sender == UnderArm)
        {
          //Serial.println("UnderArm sends: ");
          //Serial.println(msg.q.w);
          //Serial.println(msg.q.x);
          //Serial.println(msg.q.y);
          //Serial.println(msg.q.z);

          String Sender_bez = "UnderArm";
          String all = Sender_bez + "," + String(msg.q.w) + "," + String(msg.q.x) + "," + String(msg.q.y) + "," + String(msg.q.z);
          Serial.println(all);
        }
        else if (msg.sender == UpperArm)
        {
          //Serial.println("UpperArm sends: ");
          //Serial.println(msg.q.w);
          //Serial.println(msg.q.x);
          //Serial.println(msg.q.y);
          //Serial.println(msg.q.z);

          String Sender_bez = "UpperArm";
          String all = Sender_bez + "," + String(msg.q.w) + "," + String(msg.q.x) + "," + String(msg.q.y) + "," + String(msg.q.z);
          Serial.println(all);
        }
      }
    }
  }
  else if (pin == HIGH) {

    start_count = 1;
    if (start_count == 1) {
      digitalWrite(D5, LOW);
      digitalWrite(D7, HIGH);

      Serial.println("Offset einrichten");

      UDP_MESSAGE_OFFSET msgoff;

      UdpOne.beginPacket(unicastIPHand, PORT);
      //UDP_MESSAGE_OFFSET msgoff;
      msgoff.offset = Start;
      UdpOne.write((uint8_t*)&msgoff, sizeof(msgoff));
      UdpOne.endPacket();

      UdpOne.beginPacket(unicastIPUnderArm, PORT);
      //UDP_MESSAGE_OFFSET msgoff;
      msgoff.offset = Start;
      UdpOne.write((uint8_t*)&msgoff, sizeof(msgoff));
      UdpOne.endPacket();

      UdpOne.beginPacket(unicastIPUpperArm, PORT);
      //UDP_MESSAGE_OFFSET msgoff;
      msgoff.offset = Start;
      UdpOne.write((uint8_t*)&msgoff, sizeof(msgoff));
      UdpOne.endPacket();

      udp_off();
      /*
            if (millis() > myTimeout + myTimer ) {
              myTimer = millis();
              int packetSize1 = UdpTwo.parsePacket();
              Serial.println(packetSize1);

              if (packetSize1) {
                int len = UdpTwo.read(packetBuffer, sizeof(packetBuffer));

                if (len > 0) packetBuffer[len] = 0;

                Serial.println("Contents:");

                Serial.println(packetBuffer);
              }
              if (packetSize1 == 0) {
                Serial.println("Packetsize is 0:");
              }
            }
      */
    }
    start_count = 0;
    pin = LOW;
    delay(2000);
  }
}

Hier der ganze Code für den Empfänger:


#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
//#include "MPU6050.h" // not necessary if using MotionApps include file
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif
#include <FS.h>          // this needs to be first, or it all crashes and burns...
#include <WiFiManager.h> // https://github.com/tzapu/WiFiManager
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include "MPU6050.h"
#include <WiFiClient.h>

WiFiUDP UdpOne;
WiFiUDP UdpTwo;
WiFiManager wifiManager;

IPAddress unicastIP(192, 168, 4, 1);
constexpr uint16_t PORT = 8266;
constexpr uint16_t PORTOFF = 8999;

WiFiClient client;

IPAddress staticIP(192, 168, 4, 2); //Change
IPAddress subnet(255, 255, 255, 0);
IPAddress dns(8, 8, 8, 8);
char ssid[] = "ESPap";           // SSID of your AP
char pass[] = "thereisnospoon";         // password of your AP
// class default I2C address is 0x68
// specific I2C addresses may be passed as a parameter here
// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board)
// AD0 high = 0x69
MPU6050 mpu;
//MPU6050 mpu(0x69); // <-- use for AD0 high

enum UDP_CLIENT_ID {Hand, UnderArm, UpperArm};

struct UDP_MESSAGE {
  UDP_CLIENT_ID sender;
  Quaternion q;
};

//enum UDP_CLIENT_OFFVALID {Hand, UnderArm, UpperArm};


struct UDP_MESSAGE_OFFVAL {
  UDP_CLIENT_ID sender;
  char response[51];
};

enum UDP_CLIENT_OFFSET {Start};

struct UDP_MESSAGE_OFFSET {
  UDP_CLIENT_OFFSET offset;
};

UDP_MESSAGE msg;
UDP_MESSAGE_OFFSET msgoff;
UDP_MESSAGE_OFFVAL msgoffval;

int start_count = 0;
int pin = 0;
char buf[51];
/*===================================================================== */

// uncomment "OUTPUT_READABLE_QUATERNION" if you want to see the actual
// quaternion components in a [w, x, y, z] format (not best for parsing
// on a remote host such as Processing or something though)
#define OUTPUT_READABLE_QUATERNION

// uncomment "OUTPUT_READABLE_EULER" if you want to see Euler angles
// (in degrees) calculated from the quaternions coming from the FIFO.
// Note that Euler angles suffer from gimbal lock (for more info, see
// http://en.wikipedia.org/wiki/Gimbal_lock)
//#define OUTPUT_READABLE_EULER

// uncomment "OUTPUT_READABLE_YAWPITCHROLL" if you want to see the yaw/
// pitch/roll angles (in degrees) calculated from the quaternions coming
// from the FIFO. Note this also requires gravity vector calculations.
// Also note that yaw/pitch/roll angles suffer from gimbal lock (for
// more info, see: http://en.wikipedia.org/wiki/Gimbal_lock)
//#define OUTPUT_READABLE_YAWPITCHROLL

// uncomment "OUTPUT_READABLE_REALACCEL" if you want to see acceleration
// components with gravity removed. This acceleration reference frame is
// not compensated for orientation, so +X is always +X according to the
// sensor, just without the effects of gravity. If you want acceleration
// compensated for orientation, us OUTPUT_READABLE_WORLDACCEL instead.
//#define OUTPUT_READABLE_REALACCEL

// uncomment "OUTPUT_READABLE_WORLDACCEL" if you want to see acceleration
// components with gravity removed and adjusted for the world frame of
// reference (yaw is relative to initial orientation, since no magnetometer
// is present in this case). Could be quite handy in some cases.
//#define OUTPUT_READABLE_WORLDACCEL

// uncomment "OUTPUT_TEAPOT" if you want output that matches the
// format used for the InvenSense teapot demo
//#define OUTPUT_TEAPOT


#define INTERRUPT_PIN 2  // use pin 2 on Arduino Uno & most boards

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer
int16_t  actoffset[6];   // Values of active offset

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector

// packet structure for InvenSense teapot demo
uint8_t teapotPacket[14] = { ''$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\r', '\n' };

// ================================================================
// ===               INTERRUPT DETECTION ROUTINE                ===
// ================================================================

volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
void ICACHE_RAM_ATTR dmpDataReady() {
  mpuInterrupt = true;
}

// ================================================================
// ===                      Functions                      ===
// ================================================================

void get_offset_data() {

  mpu.getActiveOffsets(actoffset);
  Serial.println("From Offset Data Function:");
  //Serial.println(actoffset[0]);

  String ofst = "Offset";

  String id_name = "UnderArm"; // Change
  String off = String(actoffset[0]) + "," + String(actoffset[1]) + "," + String(actoffset[2]) + "," + String(actoffset[3]) + "," + String(actoffset[4]) + "," + String(actoffset[5]) + "," + String(actoffset[6]);
  Serial.println(off);

  off.toCharArray((char *)msgoffval.response, 50);
  //id_name.toCharArray((char *)msgoffval.sender, 5);//Change
  //sprintf(response, "UH,%i,%i,%i,%i,%i", actoffset[0], actoffset[1],actoffset[2], actoffset[3], actoffset[4], actoffset[5]);
  Serial.println(msgoffval.response);
  Serial.println(msgoffval.sender);
  UdpTwo.begin(PORTOFF);
  UdpOne.beginPacket(unicastIP, PORTOFF);
  UDP_MESSAGE_OFFVAL msgoffval;
  msgoffval.sender = UnderArm; //Change
  //msgoffval.response = buf;
  UdpOne.write((uint8_t*)&msgoffval, sizeof(msgoffval));
  UdpOne.endPacket();

}
// ================================================================

void calibration_dmp() {
  Serial.println(F("Initializing I2C devices..."));
  mpu.initialize();
  pinMode(INTERRUPT_PIN, INPUT);

  // verify connection
  Serial.println(F("Testing device connections..."));
  Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

  // wait for ready
  //Serial.println(F("\nSend any character to begin DMP programming and demo: "));
  //while (Serial.available() && Serial.read()); // empty buffer
  //while (!Serial.available());                 // wait for data
  //while (Serial.available() && Serial.read()); // empty buffer again

  // load and configure the DMP
  Serial.println(F("Initializing DMP..."));
  devStatus = mpu.dmpInitialize();

  // supply your own gyro offsets here, scaled for min sensitivity
  mpu.setXGyroOffset(220);
  mpu.setYGyroOffset(76);
  mpu.setZGyroOffset(-85);
  mpu.setZAccelOffset(1788); // 1688 factory default for my test chip

  // make sure it worked (returns 0 if so)
  if (devStatus == 0) {
    // Calibration Time: generate offsets and calibrate our MPU6050
    mpu.CalibrateAccel(6);
    mpu.CalibrateGyro(6);
    mpu.PrintActiveOffsets();
    // turn on the DMP, now that it's ready
    Serial.println(F("Enabling DMP..."));
    mpu.setDMPEnabled(true);

    // enable Arduino interrupt detection
    Serial.print(F("Enabling interrupt detection (Arduino external interrupt "));
    Serial.print(digitalPinToInterrupt(INTERRUPT_PIN));
    Serial.println(F(")..."));
    attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING);
    mpuIntStatus = mpu.getIntStatus();

    // set our DMP Ready flag so the main loop() function knows it's okay to use it
    Serial.println(F("DMP ready! Waiting for first interrupt..."));
    dmpReady = true;

    // get expected DMP packet size for later comparison
    packetSize = mpu.dmpGetFIFOPacketSize();
  } else {
    // ERROR!
    // 1 = initial memory load failed
    // 2 = DMP configuration updates failed
    // (if it's going to break, usually the code will be 1)
    Serial.print(F("DMP Initialization failed (code "));
    Serial.print(devStatus);
    Serial.println(F(")"));
  }
  get_offset_data();
}

// ================================================================

void auto_conn_new() {
  wifiManager.setSTAStaticIPConfig(staticIP, subnet, dns);
  //tries to connect to last known settings
  //if it does not connect it starts an access point with the specified name
  //here  "AutoConnectAP" with password "password"
  //and goes into a blocking loop awaiting configuration
  if (!wifiManager.autoConnect("AutoConnectAP", "password")) {
    Serial.println("failed to connect and hit timeout");
    delay(3000);
    // if we still have not connected restart and try all over again
    ESP.restart();
    delay(5000);
  }

  Serial.println();
  Serial.println("Connected");
  Serial.print("LocalIP:"); Serial.println(WiFi.localIP());
  Serial.println("MAC:" + WiFi.macAddress());
  Serial.print("Gateway:"); Serial.println(WiFi.gatewayIP());
  Serial.print("AP MAC:"); Serial.println(WiFi.BSSIDstr());

  //if (WiFi.status() == WL_CONNECTED) {
  //UdpOne.beginPacket(unicastIP, PORT);
  //UDP_MESSAGE_WIFICONRESP msgconresp;
  //msgconresp.sender = Hand; //Change
  //msgconresp.response = Connected;
  //UdpOne.write((uint8_t*)&msgconresp, sizeof(msgconresp));
  //UdpOne.endPacket();
  //}
}

// ================================================================

void i2c_conn() {

  // join I2C bus (I2Cdev library doesn't do this automatically)
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
  Wire.begin();
  Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
  Fastwire::setup(400, true);
#endif
}

// ================================================================

// ================================================================
// ===                      INITIAL SETUP                       ===
// ================================================================

void setup() {

  Serial.begin(115200);
  pinMode(D5, OUTPUT);
  pinMode(D7, OUTPUT);
  pinMode(D6, INPUT);
  pinMode(D8, OUTPUT);

  auto_conn_new();
  i2c_conn();
  calibration_dmp();

  Serial.println("Starting UDP");
  UdpOne.begin(PORT);
  Serial.printf("Now listening at IP %s, UDP port %d\n", WiFi.softAPIP().toString().c_str(), PORT);
}

// ================================================================
// ===                    MAIN PROGRAM LOOP                     ===
// ================================================================

void loop() {

  pin = digitalRead(D6);

  if (pin == HIGH) {
    digitalWrite(D8, HIGH);
    digitalWrite(D5, LOW);
    wifiManager.setSTAStaticIPConfig(staticIP, subnet, dns);
    wifiManager.startConfigPortal("AutoConnectAP", "password");
    wifiManager.startWebPortal();
    if (WiFi.status() == WL_CONNECTED) {
      //UdpOne.beginPacket(unicastIP, PORT);
      //UDP_MESSAGE_WIFICONRESP msgconresp;
      //msgconresp.sender = Hand; //Change
      //msgconresp.response = Connected;
      //UdpOne.write((uint8_t*)&msgconresp, sizeof(msgconresp));
      //UdpOne.endPacket();
      wifiManager.stopWebPortal();
    }
  }
  else if (pin == LOW) {
    // if programming failed, don't try to do anything
    digitalWrite(D8, LOW);
    if (!dmpReady) return;
    int packetSize = UdpOne.parsePacket();
    if (packetSize) {
      while (UdpOne.read((uint8_t*)&msgoff, sizeof(msgoff)) == sizeof(msgoff))
      {
        digitalWrite(D5, LOW);
        digitalWrite(D7, HIGH);
        if (msgoff.offset == Start)
        {
          start_count = 1;
          if (start_count == 1) {
            Serial.println("calibration_dmp start");
            calibration_dmp();
          }
          start_count = 0;
          delay(2000);
        }
      }
    }
    else {
      // read a packet from FIFO
      if (mpu.dmpGetCurrentFIFOPacket(fifoBuffer)) { // Get the Latest packet
#ifdef OUTPUT_READABLE_QUATERNION
        // display quaternion values in easy matrix form: w x y z
        mpu.dmpGetQuaternion(&q, fifoBuffer);
        Serial.print("quat\t");
        Serial.print(q.w);
        Serial.print("\t");
        Serial.print(q.x);
        Serial.print("\t");
        Serial.print(q.y);
        Serial.print("\t");
        Serial.println(q.z);
        //digitalWrite(D5, HIGH);
#endif

#ifdef OUTPUT_READABLE_EULER
        // display Euler angles in degrees
        mpu.dmpGetQuaternion(&q, fifoBuffer);
        mpu.dmpGetEuler(euler, &q);
        Serial.print("euler\t");
        Serial.print(euler[0] * 180 / M_PI);
        Serial.print("\t");
        Serial.print(euler[1] * 180 / M_PI);
        Serial.print("\t");
        Serial.println(euler[2] * 180 / M_PI);
#endif

#ifdef OUTPUT_READABLE_YAWPITCHROLL
        // display Euler angles in degrees
        mpu.dmpGetQuaternion(&q, fifoBuffer);
        mpu.dmpGetGravity(&gravity, &q);
        mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
        Serial.print("ypr\t");
        Serial.print(ypr[0] * 180 / M_PI);
        Serial.print("\t");
        Serial.print(ypr[1] * 180 / M_PI);
        Serial.print("\t");
        Serial.println(ypr[2] * 180 / M_PI);
#endif

#ifdef OUTPUT_READABLE_REALACCEL
        // display real acceleration, adjusted to remove gravity
        mpu.dmpGetQuaternion(&q, fifoBuffer);
        mpu.dmpGetAccel(&aa, fifoBuffer);
        mpu.dmpGetGravity(&gravity, &q);
        mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
        Serial.print("areal\t");
        Serial.print(aaReal.x);
        Serial.print("\t");
        Serial.print(aaReal.y);
        Serial.print("\t");
        Serial.println(aaReal.z);
#endif

#ifdef OUTPUT_READABLE_WORLDACCEL
        // display initial world-frame acceleration, adjusted to remove gravity
        // and rotated based on known orientation from quaternion
        mpu.dmpGetQuaternion(&q, fifoBuffer);
        mpu.dmpGetAccel(&aa, fifoBuffer);
        mpu.dmpGetGravity(&gravity, &q);
        mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
        mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);
        Serial.print("aworld\t");
        Serial.print(aaWorld.x);
        Serial.print("\t");
        Serial.print(aaWorld.y);
        Serial.print("\t");
        Serial.println(aaWorld.z);
#endif

#ifdef OUTPUT_TEAPOT
        // display quaternion values in InvenSense Teapot demo format:
        teapotPacket[2] = fifoBuffer[0];
        teapotPacket[3] = fifoBuffer[1];
        teapotPacket[4] = fifoBuffer[4];
        teapotPacket[5] = fifoBuffer[5];
        teapotPacket[6] = fifoBuffer[8];
        teapotPacket[7] = fifoBuffer[9];
        teapotPacket[8] = fifoBuffer[12];
        teapotPacket[9] = fifoBuffer[13];
        Serial.write(teapotPacket, 14);
        teapotPacket[11]++; // packetCount, loops at 0xFF on purpose
#endif

        digitalWrite(D5, HIGH);
        digitalWrite(D7, LOW);
        UdpOne.beginPacket(unicastIP, PORT);
        UDP_MESSAGE msg;
        msg.sender = UnderArm; //Change
        msg.q = q;
        UdpOne.write((uint8_t*)&msg, sizeof(msg));
        UdpOne.endPacket();
      }
    }
  }
}

Bin für jeden Verbesserungsvorschlag offen und danke jedem der sich die Zeit nimmt!!!!

Danke!!

Sorry, aber da steig ich nicht mehr durch.
Das ist mir einfach zu durcheinander. Ich sehe da keinerlei Konzept.

Hallo,
Tut mir leid ich kann nicht erkennen wo die Offset Werte in einer Stuct sein sollen .
Eigendlich hast du die in einem Array
Die struct die du hast besteht aus einer einzigen Zeichenkette . Wozu also die struct so die musste dann schon anders aussehen und alles enthalten was gesendet werden soll. Inc der Status Info usw.
Heinz

Hallo,

sorry hatte gerade gemerkt das beim kopieren vom Code vom Sender etwas gefehlt hat bzw. sogar der großteil weg war.

Falls du list hast, hab jetzt alles ergänzt

Danke

mfg

Hallo,
ich hab mal was gebastelt. ein ganz kleines Beispiel das Dir zeigen soll wie man Deine Daten in einer Struct versenden könnte. Ich mach das auf die Serielle Schnittstelle , ist aber egal ob Du das mit UDP machst oder mit Serial, es geht um das write, da ist bei beiden gleich. :wink:
Damit Du das Beispiel probieren kannst benötigst Du allerdings ein Termial Programm das eine HEX anzeige hat. (z.B term) Ich habe die Ausgabe mal mit angehängt. Also es gibt eine Struct mit einer Zeichenkette und einem Array für 5 Integer, das ist ja so in Etwa das was Du brauchst wenn ich das richtig sehe.
Zuerst wird da was reingeschrieben, anschließend als Text angezeigt, das hab ich aber mal auskommentiert. Dann werden die Daten als Paket ausgegeben.
Die HEX anzeige der Daten sieht dann so aus

48 61 6E 64 00 00 00 00 00 00 64 00 65 00 66 00 67 00 68 00

48=H
61=a
usw insgesamt 10 byte
.
64=100 L Byte des ersten Integer
00 = 0 H Byte des ersten Integer
usw.
Wenn Du das mit dem von mir bereits angesprochen Paketsender machst kannst Du die Daten auch HEX anzeigen lassen und so sehen was da alles kommt oder auch nicht. Wenn Du diese Beispiel jetzt ein bischen umbaust und anstatt Serial UDP verwendest und jede Sekunde einmal sendest Sollte auf Deinem Empfänger mit der selben Struct die Daten auch ankommen und du kannst sie direkt auslesen.
Dann noch ein Tip : fang doch erst klein an, Wenn Du an ein Problem kommst dann mach Dir ein kleines Beispiel um das eine Problem zu lösen. Das kannst Du besser hier ins Forum stellen. Dann kann man dir auch besser Helfen. So ein Bandwurm da will sich keiner reindenken. Und ein Schnipsel ist nicht lauffähig. Wie sollen wir das dann testen können. Gewöhne Dir an den Sketch zu strukturieren nutze Funktionen. Lass unnötigen Kram weg das verwirrt nur.
hier der Sketch

struct data {
  char id[10];
  int16_t offset[5];
};
data mydata;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  strcpy(mydata.id, "Hand"); // zeichenkette Schreiben
  for (byte i = 0; i < 5; i++) {
    mydata.offset[i] = 100 + i;// 5 Integer schreiben
  }

  //Serial.println(mydata.id);  // Daten lesbar ausgeben
  for (byte i = 0; i < 5; i++) {
    //Serial.println(mydata.offset[i]);
  }
  Serial.write((byte*)&mydata, sizeof(mydata)); // Daten als Paket ausgeben 
}

void loop() {
  // put your main code here, to run repeatedly:

}

Heinz

ist ok.

Aber deshalb hab ich nicht alles gepostet weil ich mir gedacht habe das es keinen sinn hat und meine Fragen dann so gestellt habe das Ihr also die Helfenden es verstehen könnt.
Und nicht weil ich etwas verheimlichen wollte...

Und ja der Code ist nicht schön aber ich kenne mich aus und wenn er mal funktioniert dann werde ich das strukturieren und so weiter..

Ich werde versuchen meine Frage neu und mit Code der für euch lesbar ist nochmal zu stellen.

Dauert jetzt aber 20min

mfg