Problem bei der Übertragung von Sensordaten an eine Website



  • Hallo alle zusammen,

    Ich hoffe ich bin hier richtig, da ich noch nie etwas in einem Forum gepostet habe.
    Ich möchte mehrere Sensordaten (Temperatur, 3 Achsen von Beschleunigungssensoren, 3 Achsen von Gyrosensoren) auslesen und dann an eine Website vorerst mal "Ubidots" senden.
    Mir ist aufgefallen, wenn ich mehrere Strings definiere, welche ich für die Variablen auf der Website benötige, dass die Werte dann nicht mehr gesendet werden.
    Aktuell ein Beispiel: Wenn man in der Beschleunigung_auslesen() eine String Definition (zur Unterscheidung der Variablen auf der Website) hat, dann Funktioniert alles soweit. Jedoch wenn man eine weitere String Definition hinzufügt (wegen den anderen Achsen) dann zeigt es im SerialMonitor zwar alles richtig an, aber auf der Website komm es nicht mehr an.
    Darum hab ich mal überall Werte im SerialMonitor ausgeben lassen und man sieht das bis zur Funktion save_value(String valor,String idvariable) alles plausibel ist, doch ab der Zeile wo String message = ... definiert wird, steht für den Beschleunigungssensor in der String-Variablen "message" nichts mehr drin. Warum?

    Ich hoffe ich konnte mein Problem schildern.
    Wenn Ihr die Bibliotheken benötigt, kann ich diese noch nach reichen.

    Vielen Dank schon mal.

    #include <SPI.h>
    #include <Wprogram.h>
    #include <Wire.h>
    #include <WiFiShieldOrPmodWiFi_G.h>
    #include <DNETcK.h>
    #include <DWIFIcK.h>
    #include "MPU6000.h"
    #include <string>
    
    //-----------------------------------------------------------------------------------------------------------------------------
    // Verbindung aufbauen mit einem WLAN, um Zugriff aufs Internet zu bekommen
    
    char * szIPServer = "things.ubidots.com";    // Server der Website
    unsigned short portServer = 80;
    const char * szSsid = "Mein WLAN";                // Name des WLANs/Hotspots
    const char * szPassPhrase = "12345abc";     // Passwort des WLANs/Hotspots
    #define USE_WPA2_PASSPHRASE                  // Auswählen des Sicherheitsstandards des WLANs
          //#define USE_WPA2_KEY
          //#define USE_WEP40
          //#define USE_WEP104
          //#define USE_WF_CONFIG_H
    #if defined(USE_WPA2_PASSPHRASE)
        #define WiFiConnectMacro() DWIFIcK::connect(szSsid, szPassPhrase, &status)
    
    #elif defined(USE_WPA2_KEY)
    
        DWIFIcK::WPA2KEY key = { 0x27, 0x2C, 0x89, 0xCC, 0xE9, 0x56, 0x31, 0x1E,
                                0x3B, 0xAD, 0x79, 0xF7, 0x1D, 0xC4, 0xB9, 0x05,
                                0x7A, 0x34, 0x4C, 0x3E, 0xB5, 0xFA, 0x38, 0xC2,
                                0x0F, 0x0A, 0xB0, 0x90, 0xDC, 0x62, 0xAD, 0x58 };
        #define WiFiConnectMacro() DWIFIcK::connect(szSsid, key, &status)
    
    #elif defined(USE_WEP40)
    
        const int iWEPKey = 0;
        DWIFIcK::WEP40KEY keySet = {    0xBE, 0xC9, 0x58, 0x06, 0x97,     // Key 0
                                        0x00, 0x00, 0x00, 0x00, 0x00,     // Key 1
                                        0x00, 0x00, 0x00, 0x00, 0x00,     // Key 2
                                        0x00, 0x00, 0x00, 0x00, 0x00 };   // Key 3
        #define WiFiConnectMacro() DWIFIcK::connect(szSsid, keySet, iWEPKey, &status)
    
    #elif defined(USE_WEP104)
    
        const int iWEPKey = 0;
        DWIFIcK::WEP104KEY keySet = {   0x3E, 0xCD, 0x30, 0xB2, 0x55, 0x2D, 0x3C, 0x50, 0x52, 0x71, 0xE8, 0x83, 0x91,   // Key 0
                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // Key 1
                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // Key 2
                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // Key 3
        #define WiFiConnectMacro() DWIFIcK::connect(szSsid, keySet, iWEPKey, &status)
    
    #elif defined(USE_WF_CONFIG_H)
    
        #define WiFiConnectMacro() DWIFIcK::connect(0, &status)
    
    #else                   // kein Sicherheitsstandard
    
        #define WiFiConnectMacro() DWIFIcK::connect(szSsid, &status)
    
    #endif
    
    //---------------------------------------------------------------------------------------------------------------------------------
    // deklarieren von benötigte Variablen 
    /*
    
    String idGyro_x="54eaf8737625426ca781d8f1";
    String idGyro_y="54eaf8737625426ca781d8f1";
    */
    
    const int sampleWindow=50;
    unsigned tStart = 0;
    typedef enum{          // Zustände der Zustansdsmaschine
        NONE = 0,
        CONNECT,
        TCPCONNECT,
        WRITE,
        READ,
        CLOSE,
        DONE,
    } STATE;
    
    STATE state = CONNECT;
    TcpClient tcpClient;
    
    //------------------------------------------------------------------------------------------------------------------------------
    
    void setup() {
        Serial.begin(9600);
        Serial.println("Versuchsprogramm als Basis fuer I4.0-Applikationen");
        delay(10);
        MPU6000 mpu6000;
        pinMode(MPU6000_CHIP_SELECT, OUTPUT); 
        digitalWrite(MPU6000_CHIP_SELECT, HIGH);
        mpu6000.init(); 
    }
    
    void loop() {
     // hochzaehlen();
      Temp_auslesen();
      Beschleunigung_auslesen();
     // Gyro_auslesen();
    }
    
    //------------------------------------------------------------------------------------------------------------------------------
    
    void hochzaehlen(){
      String idPot="5500339f7625426091e486c1";
      static int millisecond = millis();
      static int value;
      if( millisecond > millis())
      return;
      value += 1;
      if(value==10){
        value=0;
      }
      if(save_value(String(value),idPot)){
          Serial.println(value);
      }
      millisecond += 3000;
    }
    
    void Temp_auslesen(){
      String idTemp="54fee9b1762542644b38a15f";        //Achutung zuviele static
      static int  millisecond = millis();
      if( millisecond > millis ())
      return;
      MPU6000 mpu6000;
      float Temp;
      Temp = float(mpu6000.getRawTemperature())/8/340; 
      String Temp_s = float_string(Temp);
      if(save_value(Temp_s,idTemp)){
          Serial.print("Temperatur vom MPU6000 = ");
          Serial.println(Temp_s);
          Serial.println();
      }
      millisecond += 1000;
    }
    
    void Beschleunigung_auslesen(){
      String idBeschleunigung_y="54feecb47625426949be93ac";
      String idBeschleunigung_z="54feecc07625426b484947b2";
      Serial.println(idBeschleunigung_z);
      static int  millisecond = millis();
      if( millisecond > millis ())
      return;
      //static String idBeschleunigung_x="54feea367625426433a9baae";
      MPU6000 mpu6000;
      MPU6000_RAW_DATA Raw_Accel; 
      Raw_Accel = mpu6000.getRawAccelData(); /*
      Serial.println(Raw_Accel.x);
      Serial.print(" Beschleunigung in x-Richtung = ");
      float B_Wert_x = Beschleunigung_Wert_umrechnen(Raw_Accel.x);
      String string_B_Wert_x = float_string(B_Wert_x);
      if(save_value(string_B_Wert_x,idBeschleunigung_x)){
          Serial.println(string_B_Wert_x);
      }
      Serial.print(" Beschleunigung in y-Richtung = ");
      float B_Wert_y = Beschleunigung_Wert_umrechnen(Raw_Accel.y);
      String string_B_Wert_y = float_string(B_Wert_y);
      if(save_value(string_B_Wert_y,idBeschleunigung_y)){
          Serial.println(string_B_Wert_y);
      }*/
      Serial.print(" Beschleunigung in z-Richtung = ");
      float B_Wert_z = Beschleunigung_Wert_umrechnen(Raw_Accel.z);
      String string_B_Wert_z = float_string(B_Wert_z);
      if(save_value(string_B_Wert_z,idBeschleunigung_z)){
          Serial.println(string_B_Wert_z);
          Serial.println();
      }
      millisecond += 1000;
    }
    /*
    void Gyro_auslesen(){
      MPU6000 mpu6000;
      MPU6000_RAW_DATA Raw_Gyro; 
      Raw_Gyro = mpu6000.getRawGyroData();
      Serial.print("Gyro-Werte um x-Achse = " );
      float G_Wert_x = Gyro_Wert_umrechnen(Raw_Gyro.x);
      String string_G_Wert_x = float_string(G_Wert_x);
      if(save_value(string_G_Wert_x,idGyro_x)){
          Serial.print(string_G_Wert_x);
          Serial.println(" Grad/s");
      }
      Serial.print("Gyro-Werte um y-Achse = " );
      float G_Wert_y = Gyro_Wert_umrechnen(Raw_Gyro.y);
      String string_G_Wert_y = float_string(G_Wert_y);
      if(save_value(string_G_Wert_y,idGyro_y)){
          Serial.print(string_G_Wert_y);
          Serial.println(" Grad/s");
      }
      Serial.print("Gyro-Werte um z-Achse = " );
      float G_Wert_z = Gyro_Wert_umrechnen(Raw_Gyro.z);
      String string_G_Wert_z = float_string(G_Wert_z);
      if(save_value(string_G_Wert_x,idGyro_z)){
          Serial.print(string_G_Wert_z);
          Serial.println(" Grad/s");
      }
    }
    */
    float Beschleunigung_Wert_umrechnen(int RawAccel){
      float Beschleunigung_Wert = float(RawAccel);
      if(Beschleunigung_Wert > 32768){
        Beschleunigung_Wert = (65536 - Beschleunigung_Wert)/4096; 
        Serial.print("-");
      }
      else{
        Beschleunigung_Wert /= 4096;
      }
      return Beschleunigung_Wert;
    }
    
    float Gyro_Wert_umrechnen(int RawGyro){
      float Gyro_Wert = float(RawGyro);
      if(Gyro_Wert > 32768){
        Gyro_Wert = (65536 - Gyro_Wert)/65.5; 
        Serial.print("-");
      }
      else{
        Gyro_Wert /= 65.5;
      }
      return Gyro_Wert;
    }
    
    String float_string(float f){
      float my_float = f;
      String s;
      int my_int = (int)my_float;
      float my_float2 = (my_float - my_int);
      int my_int2 = (int)(my_float2 * 100);
      String my_String = String(my_int);
      String my_String2 = String(my_int2);
      if(my_float2 < 0.1){
        s = my_String + ".0" + my_String2;
      }
      else{
        s = my_String + "." + my_String2;
      } 
      return s;
    }
    
    //------------------------------------------------------------------------------------------------------------------------------
    // sendet Ergebnisse an Ubidots
    
    boolean save_value(String valor,String idvariable){
      Serial.println(valor);
      String token="aOosnUjMzRCQlmswDdl9eKryplkd1hkHziP1VIjetJheOlUeW0g47xxqwHHF";
      int cbRead=0;
      String var = "{\"value\":"+ valor + "}";
      int num = var.length();
      String le = String(num);
      Serial.println(le);
      String message = "POST /api/v1.6/variables/"+idvariable+"/values HTTP/1.1\nContent-Type: application/json\nContent-Length: "+le+"\nX-Auth-Token: "+token+"\nHost: things.ubidots.com\n\n"+var+"\n\n";
      Serial.println(message);
      byte rgbWriteStream[message.length()]  ;
      message.getBytes(rgbWriteStream,message.length() + 1);
      int cbWriteStream = sizeof(rgbWriteStream);
      Serial.println(cbWriteStream);
      state_machine(rgbWriteStream,cbWriteStream);
      return true;
    }
    
    //------------------------------------------------------------------------------------------------------------------------------
    // Zustandsmaschine für die Handhabung der TCP Verbindung
    
    boolean state_machine(byte rgbWriteStream[], int cbWriteStream){
      byte rgbRead[1024];
      int conID = DWIFIcK::INVALID_CONNECTION_ID;
      DNETcK::STATUS status;
      for(;;){
        int cbRead = 0;
        switch(state){
           case CONNECT:
                if((conID = WiFiConnectMacro()) != DWIFIcK::INVALID_CONNECTION_ID){
                    Serial.print("Einen Moment warten, WLAN/TCP-Verbindung wird aufgebaut, ConID = ");
                    Serial.println(conID, DEC);
                    state = TCPCONNECT;
                }
                else{
                    Serial.print("nicht im stande die WiFi-Verbindung aufzubauen, status: ");
                    Serial.println(status, DEC);
                    state = CLOSE;
                }
                break;
           case TCPCONNECT:
                DNETcK::begin();
                tcpClient.connect(szIPServer, portServer);
                state = WRITE;
                break;
           case WRITE:
                if(tcpClient.isConnected()){
                      tcpClient.writeStream(rgbWriteStream, cbWriteStream);
                      state = CLOSE;
                      tStart = (unsigned) millis();
                }
                break;
            case CLOSE:
                tcpClient.close();
                state = DONE;
                break;
            case DONE:
                state = TCPCONNECT;
                return cbRead;
            default:
                break;
        }
        DNETcK::periodicTasks();                       // hält den Stack aufrecht, beim Durchlaufen der loop()
      }
    }
    


  • Was ist denn das für eine Programmiersprache?


  • Mod

    Furble Wurble schrieb:

    Was ist denn das für eine Programmiersprache?

    Gute Frage 😮 . Es ist ganz sicher nicht C, wie der Threadersteller behauptet. Es könnte irgendein C++-Dialekt sein, aber es ist weder C++/CLI noch C#. Mit viel Phantasie wäre es vorstellbar, dass es C++ mit einem dicken Framework ist (welches?). Der Threadersteller wird dringend um Beantwortung dieser Frage gebeten.

    Weiterhin ist der Code nicht umsonst als "Roman" gekennzeichnet worden. Bitte minimierte Beispiele bringen!



  • Hallo Markus,

    Es gibt einen Ubidots API Endpunkt das mehrere Daten zu übertragen erlaubt. Es ist hier zu finden: http://ubidots.com/docs/api/v1_6/collections/post_values.html

    Also, dein "save_value" Funktion würde etwas so aussehen (Beispiel für 3 Variablen):

    /----------------------------------------------------------------------------
    // sendet Ergebnisse an Ubidots 
    
    boolean save_value(String v1, String var1, String v2, String var2, String v3,String var3,){ 
      String token="aOosnUjMzRCQlmswDdl9eKryplkd1hkHziP1VIjetJheOlUeW0g47xxqwHHF"; 
      int cbRead=0; 
      String body = "[{\"variable\":"+ var1 +",\"value\":"+ v1 +"},{\"variable\":"+ var2 +",\"value\":"+ v2 +"},{\"variable\":"+ var3 +",\"value\":"+ v3 +"}]"; 
      int num = body.length(); 
      String le = String(num); 
      Serial.println(le); 
      String message = "POST /api/v1.6/collections/values HTTP/1.1\nContent-Type: application/json\nContent-Length: "+le+"\nX-Auth-Token: "+token+"\nHost: things.ubidots.com\n\n"+var+"\n\n"; 
      Serial.println(message); 
      byte rgbWriteStream[message.length()]  ; 
      message.getBytes(rgbWriteStream,message.length() + 1); 
      int cbWriteStream = sizeof(rgbWriteStream); 
      Serial.println(cbWriteStream); 
      state_machine(rgbWriteStream,cbWriteStream); 
      return true; 
    }
    

    bzw. @Alle zusammen, dieses Programm sieht aus wie Chipkit code, was is ähnlich zu Arduino, was ist eine Mischung zwischen C und C++ 🙂 ).


  • Mod

    aguspg schrieb:

    bzw. @Alle zusammen, dieses Programm sieht aus wie Chipkit code, was is ähnlich zu Arduino, was ist eine Mischung zwischen C und C++ 🙂 ).

    Danke. Ich verschiebe es mal nach C++, da besteht wohl noch die größte Ähnlichkeit.



  • Ich bin noch ein blutiger Anfänger was programmieren betrifft, darum konnte ich das Thema auch nicht richtig einschätzen, ob C oder C++ da beides irgendwie drin ist und ich es selber auch nicht richtig auseinander halten kann.

    @aguspg Vielen Dank für den Hinweis und ja du hast recht, ich verwende ein Chipkit-Board und habe das mal grob umgesetzt.

    void Beschleunigung_auslesen(){
      static int  millisecond = millis();
      if( millisecond > millis ())
      return;
      String idBeschleunigung_x="54feea367625426433a9baae";
      String idBeschleunigung_y="54feecb47625426949be93ac";
      String idBeschleunigung_z="54feecc07625426b484947b2";
      MPU6000 mpu6000;
      MPU6000_RAW_DATA Raw_Accel; 
      Raw_Accel = mpu6000.getRawAccelData(); 
      Serial.print(" Beschleunigung in x-Richtung = ");
      float B_Wert_x = Beschleunigung_Wert_umrechnen(Raw_Accel.x);
      String string_B_Wert_x = float_string(B_Wert_x);
      Serial.print(" Beschleunigung in y-Richtung = ");
      float B_Wert_y = Beschleunigung_Wert_umrechnen(Raw_Accel.y);
      String string_B_Wert_y = float_string(B_Wert_y);
      Serial.print(" Beschleunigung in z-Richtung = ");
      float B_Wert_z = Beschleunigung_Wert_umrechnen(Raw_Accel.z);
      String string_B_Wert_z = float_string(B_Wert_z);
      if(save_value3(string_B_Wert_x, idBeschleunigung_x, string_B_Wert_y, idBeschleunigung_y, string_B_Wert_z, idBeschleunigung_z)){
        Serial.println(string_B_Wert_x);
        Serial.println(string_B_Wert_y);
        Serial.println(string_B_Wert_z);
        Serial.println();
      }
      millisecond += 1000;
    }
    
    boolean save_value1(String valor,String idvariable){
      String token="aOosnUjMzRCQlmswDdl9eKryplkd1hkHziP1VIjetJheOlUeW0g47xxqwHHF";
      int cbRead=0;
      String var = "{\"value\":"+ valor + "}";
      int num = var.length();
      String le = String(num);
      String message = "POST /api/v1.6/collections/values HTTP/1.1\nContent-Type: application/json\nContent-Length: "+le+"\nX-Auth-Token: "+token+"\nHost: things.ubidots.com\n\n"+var+"\n\n";
      Serial.println(message);
      byte rgbWriteStream[message.length()]  ;
      message.getBytes(rgbWriteStream,message.length() + 1);
      int cbWriteStream = sizeof(rgbWriteStream);
      state_machine(rgbWriteStream,cbWriteStream);
      return true;
    }
    
    boolean save_value3(String v1, String var1, String v2, String var2, String v3,String var3){
      Serial.println(v1);
      String token="aOosnUjMzRCQlmswDdl9eKryplkd1hkHziP1VIjetJheOlUeW0g47xxqwHHF";
      int cbRead=0;
      Serial.println(cbRead);
      String body = "[{\"variable\":"+ var1 +",\"value\":"+ v1 +"},{\"variable\":"+ var2 +",\"value\":"+ v2 +"},{\"variable\":"+ var3 +",\"value\":"+ v3 +"}]";
      Serial.print(body);
      int num = body.length();
      String le = String(num);
      Serial.println(le);
      String message = "POST /api/v1.6/collections/values HTTP/1.1\nContent-Type: application/json\nContent-Length: "+le+"\nX-Auth-Token: "+token+"\nHost: things.ubidots.com\n\n"+body+"\n\n";
      Serial.println(message);
      byte rgbWriteStream[message.length()]  ;
      message.getBytes(rgbWriteStream,message.length() + 1);
      int cbWriteStream = sizeof(rgbWriteStream);
      state_machine(rgbWriteStream,cbWriteStream);
      return true;
    }
    

    Habe den Temperatursensor über save_value1(String valor,String idvariable) und die Beschleunigungssesnoren über save_value3(...) realisiert.
    Auf der Website kam nichts an, jedoch im SerialMonitor wurde der Temperatursensor richtig ausgegeben, aber beim Beschleunigungssensor steht im string body eine "0" und danach stellt das Programm sofort seine arbeit ein.

    PS: wie kann ich Beispiele minimiert anzeigen lassen?



  • Wie lang darf ein string denn maximal sein, da ich festgestellt habe, dass wenn die string message größer 1byte also 255 Zeichen ist, dann ist der string leer.
    Wie kann ich einen string vergrößern bzw welche Alternative gibt es für meine Aufgabenstellung?

    Vielen Dank



  • ein_weiterer_Markus schrieb:

    PS: wie kann ich Beispiele minimiert anzeigen lassen?

    "Minimierte Beispiele bringen" ist ein Prozess, der Deine Mitarbeit und Deine grauen Zellen benötigt.
    Die Idee ist, dass wenn Du ein Beispiel bringst, Du dieses bis auf des Pudels Kern entrümpelst und dabei bestenfalls selbst über die Fehlerursache stolperst.

    Du bist ja schon auf dem besten Weg, den Fehler selbst zu lokalisieren.

    Verstehe ich das richtig, dass in diesen Zeilen

    String body = "[{\"variable\":"+ var1 +",\"value\":"+ v1 +"},{\"variable\":"+ var2 +",\"value\":"+ v2 +"},{\"variable\":"+ var3 +",\"value\":"+ v3 +"}]";
      Serial.print(body);
    

    nur eine "0" ausgegeben wird?

    ein_weiterer_markus schrieb:

    Wie lang darf ein string denn maximal sein, da ich festgestellt habe, dass wenn die string message größer 1byte also 255 Zeichen ist, dann ist der string leer.

    Du verwechselst da was. 1 Byte kann 256 verschiedene Werte darstellen - wenn man voraussetzt, dass 1 Byte aus 8 Bit besteht. Jedes Zeichen Deiner Nachricht wird aber ein Byte sein. Also 255 Zeichen => 255 Byte.
    Ansonsten würde es mich wundern, wenn ein Chipkit String nur 255 Zeichen aufnehmen kann.

    Was mir allerdings nicht ganz koscher vorkommt sind diese Zeilen:

    byte rgbWriteStream[message.length()]  ;
      message.getBytes(rgbWriteStream,message.length() + 1);
    

    Wenn ich das richtig interpretiere wird da ein Zeichen mehr kopiert als das Array lang ist.



  • Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C (alle ISO-Standards) in das Forum C++ (alle ISO-Standards) verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • Furble Wurble schrieb:

    ein_weiterer_Markus schrieb:

    PS: wie kann ich Beispiele minimiert anzeigen lassen?

    "Minimierte Beispiele bringen" ist ein Prozess, der Deine Mitarbeit und Deine grauen Zellen benötigt.
    Die Idee ist, dass wenn Du ein Beispiel bringst, Du dieses bis auf des Pudels Kern entrümpelst und dabei bestenfalls selbst über die Fehlerursache stolperst.

    Alles klar,so war das gemeint.

    Furble Wurble schrieb:

    Verstehe ich das richtig, dass in diesen Zeilen

    String body = "[{\"variable\":"+ var1 +",\"value\":"+ v1 +"},{\"variable\":"+ var2 +",\"value\":"+ v2 +"},{\"variable\":"+ var3 +",\"value\":"+ v3 +"}]";
      Serial.print(body);
    

    nur eine "0" ausgegeben wird.

    ein_weiterer_markus schrieb:

    Wie lang darf ein string denn maximal sein, da ich festgestellt habe, dass wenn die string message größer 1byte also 255 Zeichen ist, dann ist der string leer.

    Du verwechselst da was. 1 Byte kann 256 verschiedene Werte darstellen - wenn man voraussetzt, dass 1 Byte aus 8 Bit besteht. Jedes Zeichen Deiner Nachricht wird aber ein Byte sein. Also 255 Zeichen => 255 Byte.
    Ansonsten würde es mich wundern, wenn ein Chipkit String nur 255 Zeichen aufnehmen kann.

    Also nach mehrmaligen Tests mit unterschiedlich langen string, hat sich herausgestellt, dass immer wenn der string kürzer 256 Zeichen, alles richtig ist, jedoch wenn dieser länger als 256 zeichen ist, dann nicht eine '0' ausgibt, sondern unterschiedliche Zeichenfolgen. Mal nur eine '(' oder ein Teil des eigentlichen Inhalts.

    Furble Wurble schrieb:

    Was mir allerdings nicht ganz koscher vorkommt sind diese Zeilen:

    byte rgbWriteStream[message.length()]  ;
      message.getBytes(rgbWriteStream,message.length() + 1);
    

    Wenn ich das richtig interpretiere wird da ein Zeichen mehr kopiert als das Array lang ist

    Diese Zeilen habe ich aus einem Beispielcode von der ubidots Website und hab mich auch über die +1 gewundert.



  • Also es liegt eindeutlig an der String-Länge.
    Ich hab dies mal veranschaulicht.

    http://img4.fotos-hochladen.net/uploads/cforumua6fg8qmc7.jpg

    Man kann erkennen, wenn der String zu lang ist, dann wird dieser nicht richtig beschrieben. Lasse ich das static weg, dann schafft er es beim 2 bzw 3 durchlauf, den String komplett zu beschrieben.

    Kennt jemand den Grund für dieses Verhalten bzw eine Lösung um das zu umgehen?



  • Das wird wohl ein Fehler in der Bibliothek sein.

    Versuch halt eine neuere Version von der Herstellerwebsite zu laden.



  • Stimmt Markus, es sieht aus wie ein Problem mit dem String Operator.

    Obwohl das Ubidots Beispiel gut funktioniert für die Übertragung von wenigen Daten, ich würde dir empfehlen kein String Operator in dein Program zu benützen. Statt solltest du die "char *" und "sprintf" Funktionen verwenden.

    Dieses "Memory" Problem is ganz normal in eingebettete Systeme und Plattformen wie Arduino, ChipKIT, Spark, usw. Wenn man nicht so viel Vorhandenen Speicher hat, dann wird die Konkatenation von Strings problematisch.

    Hier ein paar Links darüber:

    http://chipkit.net/forum/viewtopic.php?f=7&t=241&start=10
    http://chipkit.net/forum/viewtopic.php?f=13&t=3101
    http://chipkit.net/forum/viewtopic.php?f=7&t=705

    Ich würde zuerst ein kürz Beispiel schreiben wo man ein "char *" miteinander durch die "sprintf" Funktion konkateniert.



  • @aguspg vielen dank
    Ich habe mal das Programm gewechselt. Anstatt mpide verwende ich jetzt uecide und siehe da, sogar der alte Programmcode funktioniert.
    Wenn ich genug Zeit habe, dann kann ich es ja noch mit char* versuchen


Anmelden zum Antworten