erstellung eines dynamischen Array

hallo zusammen,

ich habe ein dynamisches Array erstellt, das zum Abspeichern von 11 Bytes dient.
die 11 Bytes sind die Antwort meines RFID-Sensor.
wenn ich ein festes 11 Byte langes Array erstelle, dann klappt es ohne Probleme, die gelesene Byte in dem Array zu speichern.
und wenn es ein dynamisches Array ist, das sich immer um ein Byte vergrößere bis der Serielle Datenpuffer leer ist, dann empfange ich mehr Bytes als erwartet.
ich muss es mit einem dynamischen Array machen, da der Sensor, je nach Befehl, Antworte mit unterschielichen Länge liefert.
kann mir Jemand da weiterhelfen und über mein Program schauen was ich da falsch gemacht habe.

Die eigentlichen Bytes die ich erwarte sind folgendes:

0xAA, 0x0B, 0x0B, 0xE0, 0x06, 0x52, 0x03, 0xAC, 0x25, 0xFD, 0xF7

hier das Programm

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 7);
byte message[] = {0xAA, 0x07, 0x07, 0xE0, 0x00, 0xA6, 0x5B};
unsigned char *empf;
unsigned char *temp;
int merker=0;
int i = 1;

void setup() {
  pinMode(6,OUTPUT);
  Serial.begin(115200);
  Senden();
  Empfangen();
}
void loop() {
}

void Senden() {
  digitalWrite(6, HIGH);
  for (int i = 0; i < 7; i = i + 1) {
    Serial.write(message[i]);                         
    Serial.flush();
  }
}

byte Empfangen(){ 
  digitalWrite(6, LOW);
  unsigned long starttime;                                             
  empf = (unsigned char *)malloc(i*sizeof(unsigned char));
  mallocerror();    
  starttime=millis();
  while ( (Serial.available()<0)&&((millis()-starttime) < 10));
  if (Serial.available()<0)
      return 0;
  else{
      do{
          while (merker<i){
            empf[merker]= Serial.read();
            while(!Serial.available());
            delayMicroseconds(1) ;
            merker ++;
          }
         temp= (unsigned char*)malloc(i * sizeof(unsigned char));
         mallocerror();
         for(int a=0; a<i; a++){                      
           temp[a]= empf[a];
           Serial.println("temporary values in temp");
           Serial.println(temp[a], HEX);
          }
        i++; 
        empf = (unsigned char*)malloc(i*sizeof(unsigned char)); 
        mallocerror();
        for(int j=0; j<i; j++){
          empf[j]= temp[j];
        }
        Serial.println("End of Loop");
      }while(Serial.available()>0);
    }
  }

  void mallocerror(){
  if (empf == NULL)
      Serial.println(" malloc failed");
      return ;
  }

Ich halte das Verfahren für unsinnig!

        temp= (unsigned char*)malloc(i * sizeof(unsigned char));
         mallocerror();

// ---
  void mallocerror(){
  if (empf == NULL)
      Serial.println(" malloc failed");
      return ;
  }

Du stopfst den Zeiger in temp, prüfst aber empf.
Wieso?

for(int a=0; a<i; a++){                      
           temp[a]= empf[a];

Wäre da nicht sowas wie memcpy() (oder einer seiner Brüder) viel Sinn behafteter?

Ich sehe reichlich malloc(), aber nirgendwo, dass du Speicher auch wieder frei gibst.

Nee… neee… neee…

softpi:
ich habe ein dynamisches Array erstellt, das zum Abspeichern von 11 Bytes dient.

Wenn es Dir nur darum geht, eine bestimmte kurze Sequenz auszuwerten, brauchst Du kein Array.

Gruß

Gregor

Die paar eingesparten Bytes rechtfertigen keinen komplizierteren Code. Da Arduino keine Gabage Collektion hat kann der RAM Speicher vollgeschrieben werden und darum der Sketch sich blockieren.

Grüße Uwe

gregorss:
Wenn es Dir nur darum geht, eine bestimmte kurze Sequenz auszuwerten, brauchst Du kein Array.

Gruß

Gregor

was brauche ich dann

uwefed:
Die paar eingesparten Bytes rechtfertigen keinen komplizierteren Code. Da Arduino keine Gabage Collektion hat kann der RAM Speicher vollgeschrieben werden und darum der Sketch sich blockieren.

Wenn Du Dich auf mich beziehst: Für einen Vergleich einer Zeichenfolge, die seriell reinkommt, braucht es keinen komplizierten Code. Und RAM wird dabei auch nicht vollgeschrieben.

Gruß

Gregor

Du kannst auch jeweils das aktuelle Byte mit dem gegebenen Array vergleichen.

Das erst mal in Array einzulesen und dann mit memcmp() zu vergleichen geht auch gut, aber dynamischer Speicher ist dabei völlig unnötig. Wenn du weist dass du maximal 11 Bytes hast macht man sein Array 11 Bytes groß und gut ist

softpi:
was brauche ich dann

Wenn Du auf eine bestimmte Zeichenfolge kontrollieren möchtest, ungefähr sowas:

// Byte lesen
// Gucken, ob es dem entspricht, was erwartet wird
// wenn nicht, abbrechen

Die Vorlagen für das, was erwartet wird, speicherst Du im Flash, indem Du sie als const deklarierst. Die Länge der Sequenzen ist dann quasi wurscht.

Gruß

Gregor

gregorss:
Die Vorlagen für das, was erwartet wird, speicherst Du im Flash, indem Du sie als const deklarierst.

Ein const Array belegt immer noch RAM. const heißt da nur dass man nicht schreiben darauf zugreifen kann

Serenifly:
Ein const Array belegt immer noch RAM. const heißt da nur dass man nicht schreiben darauf zugreifen kann

Der Compiler sorgt nicht dafür, dass ein

const bla[]="blubb";

im Flash landet?! Wenn das tatsächlich der Fall ist, möchte ich der C-Lib in den Hintern treten. Für den Vergleich braucht man ja eigentlich nur ein einziges Byte im RAM.

Gruß

Gregor

Deshalb gibt es ja den Umweg über PROGMEM. Das liegt aber eher an der Hardware und wie der Speicherzugriff gestaltet ist

Serenifly:
Deshalb gibt es ja den Umweg über PROGMEM. Das liegt aber eher an der Hardware und wie der Speicherzugriff gestaltet ist

Uh … stimmt ja. Hab’ ich ja auch selber mal geschrieben :-/

Gruß

Gregor