Serielle Verbindung bricht ab

[Paul (Gast)]

Hallo,

mein Arduino empfängt alle 500ms ein Datenpaket mit einer Zahl darin, 
dieses wird in ein char Array gespeichert und zu einem MD5 hash gehasht. 
Danach wird an den Hash noch 456 (ID) dran gehängt.
Funktioniert alles problemlos, jedenfalls 1-2 Minuten. Danach stoppt die 
Serielle Kommunikation des Arduinos einfach. Die LED-leuchtet nicht 
mehr, durch die Arduino IDE kommt nichts mehr an und auch nicht in 
Putty.  Komisch ist wenn ich das serielle Fenster in der Arduino IDE 
beende und danach wieder öffne klappt die Ausgabe wieder für 1-2 
Minuten. Bin echt ratlos..

Baudrate wurde mit 9600 und 115200 versucht.

#include <MD5.h>
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>




int udppacket=0;
int arraygroesse= 0;
int clientarraygroesse=0;
byte sendestatus=0;
byte hashzaehler = 0;
unsigned long clientzeit=0;



char recieveddata[100];
char hasharray[100]; //Ein MD5 Hash hat 32 Zeichen, hier von 0-31, die Zeichen 32-34 dient zur Zuordnung des Hashes, die restlichen fuer die Clientzeit
char clientzeitbuffer[100];


//Lokale Adresse:

byte clientmac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEB };
IPAddress clientip(192, 168, 3, 2);
IPAddress clientsubnet(255, 255, 255, 0);
IPAddress gateway(192, 168, 3, 1);
int clientport = 8002; //Lokaler Port

//Serveradresse:

IPAddress serverip(192, 168, 3, 1); //Address to send UDP packe to
IPAddress servergateway(292, 168, 3, 1);
int serverport = 8001;


char packetbuffer[UDP_TX_PACKET_MAX_SIZE]; //Bufferspeicher um Empfangene Pakete bis zur Bearbeitung zu speichern.
EthernetUDP Udp; //Beginnt eine UDP-Instanz


//########################################################################################################################################################################


void setup() {

  Ethernet.begin(clientmac, clientip, clientsubnet, gateway);
  Udp.begin(clientport);
  Serial.begin(115200);

}

//########################################################################################################################################################################



void loop() {


  char udppacket = Udp.parsePacket();
  if (udppacket) {
    Serial.println(udppacket);


    Udp.read(packetbuffer, udppacket);
    Serial.println(packetbuffer);


    //Speichert die Empfangenen Daten in ein char Array
    for (int i = 0; i < udppacket; i++) {
      recieveddata[i] = packetbuffer[i];
      Serial.print("Empfangene Zeit:");
      Serial.println(recieveddata[i]);

    }

    //Ermittelt die tatsächliche größe des Arrays
    arraygroesse = (unsigned)strlen(recieveddata);
    Serial.print("Arraygroesse ");
    Serial.print(arraygroesse);
    Serial.print("\n");

  }


   //########################################################################################################################################################################


  //if (arraygroesse!=0 && arraygroesse<31 && sendestatus==0) { //Die erste Zeit wird empfangen und gehasht.
if(arraygroesse >0){

    
    Serial.println("Der Mikrocontroller ist am HASH-Erstellen");
    unsigned char* hash = MD5::make_hash(recieveddata);
    char *md5str = MD5::make_digest(hash, 16);
    free(hash);
    //Serial.println(md5str);


    //Gibt den Hash in der seriellen Konsole & speichert ihn in ein neues Array.
    //Serial.println (hasharray[32]);
    for (int i = 0; i < 32; i++) {
      hasharray[i] = md5str[i];
     // Serial.print(hasharray[i]);
    }

    //Hängt an den Hash eine ID-an um dem Server Polls von Befehlen zu unterscheiden.
    hasharray[32] = '4';
    hasharray[33] = '5';
    hasharray[34] = '6';



    Serial.println("Hash mit 1"); //Ausgabe des Arrays in die Serielle Konsole
    for (int i = 0; i < 35; i++) {
      Serial.print(hasharray[i]);
    }
}
 
  udppacket=0;
  arraygroesse=0;
  }

Jemand eine Idee?

[g457 (Gast)]

> char *md5str = [..]

leakt Speicher

[Paul (Gast)]

Danke für diese Antwort aber damit kann ich eigentlich gar nichts 
anfangen..könntest du das genauer erklären?

[думлихер троль (Gast)]

Ich hab das Gefuehl, die serielle Schnittstelle ist blockierend. Dann 
wird sie mit viel zuviel Zeug zugemuellt.

Zu Beginn wuerd ich nur das UDP Packet byte fuer byte auf die Serielle 
kopieren, ohne zusaetzliches Zeug.

[g457 (Gast)]

> könntest du das genauer erklären?

Der Funktionsaufruf in besagter Zeile allokiert Ressourcen (hier: 
Speicher), die Du nie wieder freigibst (hier: das zugehörige 
free(md5str) fehlt) -> nach ein paar Runden ist die Ressource 
aufgebraucht (hier: kein freier Speicher mehr verfügbar) und es 
passieren lustige Sachen.

[Tom (Gast)]

Paul schrieb:
> Danke für diese Antwort aber damit kann ich eigentlich gar nichts
> anfangen.

Zu jedem malloc gehört ein passendes free (siehe Grundlagen dynamischer 
Speicherverwaltung im Buch Deiner Wahl). Also in den Quelltext von 
MD5::make_hash und MD5::make_digest sehen, ob dort ein malloc passiert.

Der Autor der MD5-Lib hätte auch die C++-Möglichkeiten nutzen können 
(RAII), statt eine Klasse als überflüssigen Behälter für simple C-artige 
Funktionen zu verwenden.

[Paul (Gast)]

Ah, vielen Dank!
Habe es nun geändert.

   Serial.println("Der Mikrocontroller ist am HASH-Erstellen");
    unsigned char* hash = MD5::make_hash(recieveddata);
    char *md5str = MD5::make_digest(hash, 16);
    free(md5str);

Jedoch besteht das selbe Problem weiterhin.
Weitere Ideen?

[Paul (Gast)]

Ah, natürlich gehört

free(hash);

auch noch ergänzt :)
Jetzt klappt es..ich danke dir/euch ;)

[Stefan F. (Gast)]

Serielle Schnittstellen können physikalisch nicht blockieren. Und 
Verbindungsabbrüche hat amn nur, wenn man das Kabel unterbricht.

[Rufus Τ. F. (rufus)]

Stefan Us schrieb:
> Serielle Schnittstellen können physikalisch nicht blockieren.

Wenn sie Hardwarehandshake machen, schon.

[Paul (Gast)]

Hallo,

nun habe ich ein weiteres Problem, der Hash wird erstellt jedoch stimmt 
dieser nur teilweise überein.. wäre toll wenn mir wieder jemand einen 
Tipp geben könnte. Das Array welches an die Hashfunktion gegeben wird 
enthält den  richtigen Inhalt, auch der generierte Hash stimmt, jedoch 
fehlen unterscheiden sich die Hashes:

z.B.

Klartext: 7377913

Arduino-Hash

1a6363927d7bfc6ff1cbd7048760d57378914

Normal generierter Hash

691a6363927d7bfc6ff1cbd7048760d5


Jemand eine Ahnung?

#include <MD5.h>
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>


int udppacket = 0;
int arraygroesse = 0;
int clientarraygroesse = 0;
byte sendestatus = 0;
byte hashzaehler = 0;
unsigned long clientzeit = 0;



char recieveddata[100];
char hasharray[100]; //Ein MD5 Hash hat 32 Zeichen, hier von 0-31, die Zeichen 32-34 dient zur Zuordnung des Hashes, die restlichen fuer die Clientzeit
char clientzeitbuffer[100];


//Lokale Adresse:

byte clientmac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEB };
IPAddress clientip(192, 168, 3, 2);
IPAddress clientsubnet(255, 255, 255, 0);
IPAddress gateway(192, 168, 3, 1);
int clientport = 8002; //Lokaler Port

//Serveradresse:

IPAddress serverip(192, 168, 3, 1); //Address to send UDP packe to
IPAddress servergateway(292, 168, 3, 1);
int serverport = 8001;


char packetbuffer[UDP_TX_PACKET_MAX_SIZE]; //Bufferspeicher um Empfangene Pakete bis zur Bearbeitung zu speichern.
EthernetUDP Udp; //Beginnt eine UDP-Instanz


//########################################################################################################################################################################


void setup() {

  Ethernet.begin(clientmac, clientip, clientsubnet, gateway);
  Udp.begin(clientport);
  Serial.begin(9600);

}

//########################################################################################################################################################################



void loop() {


  udppacket = Udp.parsePacket();
  if (udppacket) {

    Udp.read(packetbuffer, udppacket);
    Serial.println(packetbuffer);


    //Speichert die Empfangenen Daten in ein char Array
    for (int i = 0; i < udppacket; i++) {
      recieveddata[i] = packetbuffer[i];
      Serial.println("Empfangene Zeit:");
      Serial.println(recieveddata[i]);
      Serial.println(packetbuffer[i]);


    }

    //Ermittelt die tatsächliche größe des Arrays
    arraygroesse = (unsigned)strlen(recieveddata);
    Serial.print("Arraygroesse ");
    Serial.print(arraygroesse);
    Serial.print("\n");

  }


  //########################################################################################################################################################################


  //if (arraygroesse!=0 && arraygroesse<31 && sendestatus==0) { //Die erste Zeit wird empfangen und gehasht.
  if (arraygroesse > 0) {


    Serial.println("HASH-Erstellen");
    unsigned char* hash = MD5::make_hash(recieveddata);
    char *md5str = MD5::make_digest(hash, 16);
    free(hash);
    free(md5str);



    for (int i = 0; i < 32; i++) {
      Serial.print(md5str[i]);
    }
    arraygroesse = 0;    
    memset(recieveddata, 0, sizeof(recieveddata));


  }
}

[Peter II (Gast)]

Paul schrieb:
> free(md5str);
>
>     for (int i = 0; i < 32; i++) {
>       Serial.print(md5str[i]);

du darfst nicht den Speicher freigeben und dann später wieder darauf 
zugreifen.

Ich würde das Programm so umschreiben, das man überhaupt keine 
dynamischen Speicher braucht, lege doch das hash objekt global an. Das 
kann auch mehrfacher verwendet werden.

Keine Ahnung wie Arduino reagiert, wenn kein Speicher mehr frei ist bzw. 
wenn er zu stark fragmentiert ist.

[Paul (Gast)]

Vielen Dank, du hast mir sehr geholfen!


Ja ich habe jetzt md5str vor der Speicherfreigabe in ein neues char 
Array geschrieben und jetzt klappt es... :)

[Peter II (Gast)]

Paul schrieb:
> Ja ich habe jetzt md5str vor der Speicherfreigabe in ein neues char
> Array geschrieben und jetzt klappt es... :)

und warum? hast du zu viel ram oder cpu zeit das du sinnlos zeug 
rumkopieren musst?

Kannst du es nicht gleich in eine Variabel schreiben lassen?