Auslesen von Telemetriedaten, Darstellung auf LCD

Hallo zusammen,

ich hoffe auf eure Unterstützung da ich gerade nicht weiterkomme.

Ich bin Modellbauer und besitze ein paar Modellflugzeuge. Jetzt gibt es seit ein paar Monaten ein 2,4Ghz Sendeeinheit der Firma FrSky, die aus China kommen. Der Vorteil ist, das System ist günstig, die Technologie funktioniert aber sehr gut. Ein weiterer Vorteil ist das Senden von Telemetriedaten vom Empfänger des Modellflugzeug runter zum Piloten. Man kann alles mögliche schicken lassen, wie Spannung der Akkus, GPS, Geschwindigkeit, Strom usw. und so sein Modell überwachen.

Bisher muss man das Sendemodul mit einem RS232 Kabel mit dem Rechner verbinden. Über eine Software kann man dann die Daten auslesen.

Ich möchte mir aber den Arduino 2009 mit einem LCD zur Hilfe machen. Ich möchte das alles in eine kompakte Box einbauen, die ich dann an meinen Sender anbringen kann.

So weit, so gut, das LCD habe ich am laufen. Ich kann auch Daten vom COM Port auslesen und darstellen (nur 1 Byte!). Das teste ich mithilfe des Monitors.

Die Daten die der Empfänger runterschickt sind aber 11 Byte lang.

Beispiel:

7E FE 46 5D 5C BE 00 00 00 00 7E

Erklärung:

1,2,11 markieren Anfang und Ende 7,8,9,10 - nicht genutzt 3,4,5,6 - 3=Sensor 1; 4=Sensor 2; 5=Signalstärke

Mit dem Hyperterminal liest man so einen Datensatz aus: 7E FE 46 5D 5B C0 00 00 00 00 7E 7E FE 46 5D 5B C0 00 00 00 00 7E 7E FE 46 5D 5C BF 00 00 00 00 7E 7E FE 46 5D 5D BF 00 00 00 00 7E 7E FE 46 5D 5D BE 00 00 00 00 7E 7E FE 46 5D 5D BE 00 00 00 00 7E 7E FE 46 5D 5D BE 00 00 00 00 7E 7E usw.

Wenn es weiterhilft, das Protokoll ist "offen" und vom Hersteller in der PDF erklärt.

Ich denke ich muß jetzt die 11Bytes auslesen und abspeichern. Aus dieser Zeichenfolge muß ich dann irgendwie das 3.Byte auslesen und aufs LCD schicken. Zum Beispiel Spannung = Byte3

Nur wie mache ich das? Ich habe mir das "Arduino Praxiseinstieg" Buch gekauft, dieses hilft mir nicht weiter.

Wenn es weiterhilft, das Protokoll ist "offen" und vom Hersteller in der PDF erklärt:

http://www.frsky-rc.com/Downloads.asp?id=29

Hi Marc,

Sehr spannendes Projekt! Du kannst immer nur ein byte nach dem anderen auslesen. Der Rest liegt in einem Puffer. Jetzt kannst Du Dir die Mühe machen selbst etwas zu schreiben, oder verwendest eine fertige Library. zB die Massanger Library.

Gruß

Sebastian

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1222259218

Schau dir mal diesen Thread an: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1268672730

Versuche mal 11 Bytes einzulesen und diese dann auf dem Display ausgeben. Anschliessend kannst du auf das gewünschte Byte aus dem Array direkt zugreifen.

Ich versuche es mal wie Webmeister gesagt hat, erst mal ganz simpel einlesen und ausgeben.
Ich möchte eine Zeichenfolge von 1 2 3 4 5 6 7 8 9 0 1 am Monitor eingeben und das LCD soll mir das ausgeben.

Darauf aufbauen kann man ja immer noch.

Denn hier hakt die Sache schon wieder. Daten soll ein Array aus 11 Bytes sein. Mit der for Schleife warte ich bis 11 Bytes da sind, dann wird ausgegeben. Diesen Tip hatte ich durch einen Link von oben erhalten.

Die Ausgabe funktioniert leider gar nicht :frowning:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int Daten[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//volatile byte Daten[11];


void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  Serial.begin(9600);
}

void loop() { 
  
  while (Serial.available()<11) {}
  for(int n=0; n<11; n++)
   
  Daten [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] = Serial.read();
  
  Serial.print (Daten[0]);
  Serial.print (Daten[1]);  
  
  
  lcd.setCursor(0,0);
  lcd.print("Byte0:");  
  lcd.print (Daten[0]);  
 
  lcd.setCursor(0,1);
  lcd.print("Byte1:");  
  lcd.print (Daten[1]) ;  

  lcd.setCursor(6,0);
  lcd.print("Byte9:");  
  lcd.print (Daten[9]);  
  
  lcd.setCursor(6,1);
  lcd.print("Byte10:");  
  lcd.print (Daten[10]);  
  
  delay(3000);

  
  // clear screen for the next loop:
  lcd.clear();
  
}

ich weiß nich ob man das so machen kann:

for(int n=0; n<11; n++)
  
  Daten [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] = Serial.read();

Wo hast Du das her?

das funktioniert aber:

const int anzahl = 3;

int Daten[anzahl];
//volatile byte Daten[11];


void setup() {
  // Print a message to the LCD.
  Serial.begin(9600);
}

void loop() {

  while (Serial.available()<anzahl) {
  }
  for(int n=0; n<anzahl; n++){
    Daten[n] = Serial.read();
  }

  for(int n=0; n<anzahl; n++){
    Serial.print (Daten[n]);
    Serial.print (",");
  }
  Serial.println();
}
for(int n=0; n<11; n++)
Daten [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] = Serial.read();

Das kann so nicht gehen. >:(
Jedes empfangene Byte muss an einer eigenen Position im Array abgelegt werden. So ist es auch im von mir erwähnten Thread erklärt.

Da du Testdaten im Array abgelegt hast, kannst du diese auch direkt wieder ausgeben.

Das Beispiel von stundenblume zeigt wie das Empfangen und Ausgeben gedacht ist.

Empfangen:

Daten[n] = Serial.read();

Senden/Ausgeben:

Serial.print (Daten[n]);

n: ist jeweils die Position der einzelnen Bytes im Array.

So oder so ähnlich könnte es klappen

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

#define FRAMESIZE 11
int Daten[FRAMESIZE];
int counter;
boolean stuffFlag;

void setup() {
      // set up the LCD's number of columns and rows:
      lcd.begin(16, 2);
      // Print a message to the LCD.
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Ready.");

      Serial.begin(9600);
}

void loop() {
      while (Serial.available()) {
            byte b = Serial.read();
            if (b == 0x7E && counter == FRAMESIZE-1 && Daten[0] == 0x7E && Daten[1] == 0xFE) {
                  // Sieht nach dem Ende eines validen Frame aus
                  //lcd.clear(); // Wenn ueberhaupt dann erst jetzt das Display loeschen, sonst flackerts...
                  lcd.setCursor(0,0);
                  lcd.print("P1:");
                  lcd.print (Daten[2], DEC);
                  lcd.print("   ");
                  lcd.setCursor(0,1);
                  lcd.print("P2:");
                  lcd.print (Daten[3], DEC);
                  lcd.print("   ");
                  lcd.setCursor(6,0);
                  lcd.print("LQ:");
                  lcd.print (Daten[4], DEC);
                  lcd.print("   ");
            } else if (b == 0x7D) { // Byte stuffing!
                  stuffFlag = true;
                  continue; // Dieses Byte nur als Flag benutzen, nicht speichern!
            } else if (b == 0x7E) {
                  counter = 0; // Start eines Frames. Hoffentlich.
            }
            if (stuffFlag) { // Byte stuffing!
                  b ^= 0x20;
                  stuffFlag = false;
            }
            Daten[counter++] = b;
      }
}

Natürlich kann ich es leider nicht testen, also wie immer ohne Gewähr… :wink:

Den Hersteller kannte ich noch nicht, find ich klasse, dass die das so offen legen! :sunglasses:

Ok,

Danke für die vielen comments und die Unterstützung hier.
Ich habe schon gemerkt, dass mir noch die Grundlagen fehlen, aber ich werde nicht so schnell aufgeben. :wink:

Ich bin jetzt so weit, dass ich 11Bytes (12345678912) eingeben und dargestellt bekomme.

Kommt jetzt allerdings so ein Zeichensatz: 7E FE 46 5D 5C BE 00 00 00 00 7E kommt natürlich Müll raus.
Muss der Array jetzt länger werden damit die Zeichen alle reinpassen? Z.B. Byte1 = 7; Byte2= E; Byte3= _; Byte4= F; usw.?
Wie macht man das dem Arduino klar, dass Byte1 = 7E sein muss?

Die Umwandlung von Ascii habe ich einfach gemacht, indem ich 48 von dem Byte abziehe. Da gibt es bestimmt elegantere Lösungen.

@ Stundenblume: Danke für den Code, das hat mich weiter gebracht.
Das mit der Messenger Library habe ich mir angeschaut, muss mich aber weiter damit beschäftigen. Ich will jetzt erst mal an meinem Code weiterarbeiten.

@Webmeister [smiley=thumbup.gif] Verstanden

@ Joghurt Dein Code ist für mich erst mal schwer verständlich. Da sind für mich zu viele “Unbekannte” drin. Leider funktioniert er auch nicht, er bleibt in “Ready.” stehen, egal was ich eingebe. Ich habe etwas dran rumgespielt, konnte ihn aber nicht zum Laufen bringen.

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int Daten[11];
int AD1;
int AD2;
int RSSI;

void setup() {
  
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(5,0);
  lcd.print("ready");

  Serial.begin(9600);
}

void loop() {
  
  lcd.clear();
  lcd.setCursor(5,0);
  lcd.print("ready");

  
  while (Serial.available()<11) {}
  
  for(int n=0; n<11; n++)
  {  
  Daten[n] = Serial.read();
  }
  
  AD1 = Daten[0]-48;
  AD2 = Daten[1]-48;
  RSSI = Daten[2]-48;
  
  lcd.clear();
  Serial.print (Daten[0],DEC);
  Serial.print (Daten[1], DEC);  
  Serial.print (Daten[2], DEC);  
 
   
  lcd.setCursor(0,0);
  lcd.print("AD1:");  
  lcd.print (AD1, DEC);  

  lcd.setCursor(0,1);
  lcd.print("AD2:");  
  lcd.print (AD2, DEC) ;  
  
  lcd.setCursor(7,0);
  lcd.print("RSSI:");  
  lcd.print (RSSI, DEC);  
 
  delay(2500);

  
  // clear screen for the next loop:
  lcd.clear();
  
}

Moin Marc,

schau Dir mal das folgende Beispiel an: File > Examples > 4. Communication > ASCII Table

Über den Serial Monitor werden ASCII Zeichen gesendet. Wie Du schon gemerkt hast, kommt ja beim Arduino nicht der Wert 1 an wenn Du eine 1 über den Serial Monitor schickst. Es ist das ASCII Zeichen für 1. Wenn Du also eine 7E schicken möchtest ist das nichts anderes, als wenn Du eine ~ sendest.

Beispiel am Buchstaben z:
ASCII:z = Dezimal: 122 = HEX: 7A = bin: 1111010

Somit: z = 122 = 7A = 1111010 //Es ist alles das selbe, nur die andere Schreibweise eines Bytes!

Gruß

Sebastian

Da sind für mich zu viele "Unbekannte" drin.

Was genau meinst Du?

Leider funktioniert er auch nicht, er bleibt in "Ready." stehen, egal was ich eingebe. Ich habe etwas dran rumgespielt, konnte ihn aber nicht zum Laufen bringen.

Hast Du den Code an der Fernsteuerung probiert oder am Terminal? Am Terminal wird er nicht funktionieren, weil Du zumindest das "FE" dort nicht erzeugen kannst.

Mein Code reagiert nicht nach 11 x-beliebigen Zeichen sondern nur auf einen Datensatz der mit "7E" beginnt und endet, als zweites Zeichen ein "FE" hat und elf Zeichen lang ist. Dabei gehts darum, dass Du ja nicht 100%ig sicher sein kannst, ob auch wirklich alle 11 zeichen übertragen werden oder ob nicht eines verschluckt wird oder ob es auch wirklich beim Anfang anfängt. ;)

Und er berücksichtigt das "Stuffing", welches in der Protokollbeschreibung auftaucht...

@ Stundenblume: Das ist mir jetzt klar. Ich habe nicht gewußt dass der Serial Monitor Ascii Zeichen schickt. Das erklärt dann einiges. Deshalb hat die Umwandlung in DEC nie funktioniert, da Ascii 1 = Dec 49. Ich habe mich immer gewundert warum der 49 ausspuckt. ;D

@Joghurt Ok, der Monitor ist wohl nicht zu verwenden. Ich habe versucht, mit dem Programm RealTerm Hexadezimal zu senden, macht der aber auch nicht. Nur Binär und Ascii. Wenn Du eine Software kennst, die das simulieren kann, würde ich das gerne wissen. So könnte ich das alles vorab testen. Meine Hardware ist gerade zerlegt und läuft nicht, da das Provisorium jetzt sauber in den Sender integriert wird.

@all

Ich möchte noch gerne etwas zum Projekt sagen. Ich erhielt eine Bitte per pm, etwas mehr zur Telemetrie zu erklären. Es kam auch die Frage, ob man dieses Telemetrie-Set auch "Standalone", also ohne Fernsteuerung (Sender) und Modellflugzeug verwenden kann. Hierzu kann ich schon sagen, dass das möglich sein muss.

Ein kleine Darstellung zur Telemtrie:

Der Pilot steuert sein Modell mit dem Sender in der Hand. Das Sendemodul ist im Sender intergriert, wandelt die Steuerbefehle digital um und schickt sie hoch zum Empfänger. Dieser dekodiert die Signale und gibt sie weiter an die Servos, die in den bis zu 8 Steckplätzen befestigt sind. Die Servos bewegen dann die Ruder und das Modell folgt den Befehlen des Piloten. Die roten Pfeile auf dem Bild stellen diesen Weg dar. So war es noch bis zu den letzten Jahren. Heutzutage gibt es Sendeeinheiten mit Telemetrie. Bidirektional, also gehen Signale nicht nur vom Sender zum Empfänger, sonder auch wieder vom Empfänger zum Sender zurück. Also ist der Sender zeitgleich Empfänger und andersherum auch. Diesen Weg stellen die blauen Pfeile dar. Zum Beispiel wird gerne die Akkuspannung überwacht, unterschreitet der Akku eine bestimmte Spannung, kann ich mich warnen lassen und langsam die Landung einleiten.

Der Hersteller FrSky bietet bis heute noch keine "Box" an, wo die Daten visuell dargestellt werden. Man kann die Schwellenspannung einstellen und sich per Beeper warnen lassen. Schöner ist die Anzeige an einem LCD. Außerdem reizt mich die Programmierung von einem Mikrokontroller. Da mein Aquarium schon mit einer SPS läuft, soll dies mein nächstes Projekt werde. Da ich zudem bald ein Haus baue, sollen dort viele Arduinos intergiert werden, die einmal die Lichtsteuerung und die Entlüftungsanlage steuern sollen.

Für mich wäre es ideal, wenn ich bei einem von euch das Interesse wecken könnte. So könnte man gemeinsam am Code entwickeln.

Durch das Senden über 2,4Ghz sind super Möglichkeiten gegeben. Man stelle sich vor, der Arduino empfängt über den Telemtriekanal Daten von Sensoren. So könnte man die Temperaturen im Gewächshaus überwachen, oder eine tolle Wetterstation betreiben. Möglichkeiten gibts hier bestimmt viele. Da fällt euch bestimmt viel dazu ein. ;)

Das Sendemodul mit einem Empfänger kauft man direkt in China, bei einem riesigen Modellbauhändler. Bezahlt wird per Paypal, Versand kostet je nach Gewicht 7-30 Euro. Man muß nicht mal per Express (1 Woche Versand) bestellen, über Airmail dauert es ca. 10-20 Tage. Mit Steuer und Versand wird es circa 50 Euro kosten. Über Importeure kann man sich das Frsky Zubehör auch holen, dann kostet es aber mehr als das doppelte. Für euch sind dort bestimmt noch andere Dinge interessant (Servos,Akkus,Motoren usw., schaut euch mal im ganzen Shop um. HobbyKing: http://hobbyking.com/hobbycity/store/uh_viewItem.asp?idProduct=14355

Das Modul müsste eigentlich sofort mit dem Senden und Empfanger starten, wenn es mit dem Empfänger "gebunden" ist und beide Komponenten Spannung haben. Der Empfänger braucht 4,8-6V, das Sendemodul 6-13V (laut Hersteller).

Am Empfänger der die Daten an das Sendemodul zurückschickt, gibt es drei Anschlüsse. Zwei für analoge Sensoren ( 0-3,3V) und einen RS232. Hier könnte man sogar einen zweiten Arduino anbinden. Diese könnten miteinander kommunizieren, bei einer Reichweite mit minimum 1500 Meter.

Wer noch mehr dazu lesen will, in amerikanisch Foren tut sich da recht viel.

http://www.rcgroups.com/forums/showthread.php?t=1200443 http://www.rcgroups.com/forums/showthread.php?t=1176328

Für mich wäre es ideal, wenn ich bei einem von euch das Interesse wecken könnte.

Ja, das hast du.

Man stelle sich vor, der Arduino empfängt über den Telemtriekanal Daten von Sensoren. So könnte man die Temperaturen im Gewächshaus überwachen, oder eine tolle Wetterstation betreiben. Möglichkeiten gibts hier bestimmt viele.

In diese Richtung könnte ich mir Projekte vorstellen. Habe ich ja bereits per PM geschrieben. ;)

Ich schaue mir über die Feiertage das ganze etwas genauer an und komme allenfalls wieder auf dich zu.

@marcSHA Willst du auch etwas über dich in meinem Thread von heute schreiben? http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1291915516

So, ich habe weiter an dem Joghurtschen Code geübt. Ich denke dieser Code ist der richtige Weg, da hier schon die Start und End Bytes vom Frame mitverarbeitet werden.

Mit dem Realterm kann man Hex senden, nur muß man die Nullen mit $ ersetzen. Schicke ich dieses, kommt auch etwas an: $7E $FE $46 $5D $5C $BE $0 $0 $0 $0 $7E Wieder was gelernt.

Was ich nicht verstanden habe:

Für was steht #define?

define FRAMESIZE 11

Was passiert in dieser Bedingung? counter == FRAMESIZE-1

Und was passiert beim stuffing mit b ^ ? b ^= 0x20;

Das wäre nett wenn Du mir das erklären könntest @Joghurt. Danke mal im Voraus.

Klar. :)

define ist eine Anweisung, die den Preprozessor veranlasst, besagte Stelle mit besagtem Wert zu ersetzen. Quasi steht im Code dann überall, wo im Quelltext FRAMESIZE steht dann die Zahl 11. Gemacht hab ich das für den Fall dass FrFSky die Framesize verändert (war ja schließlich schon mal 10), dann musst Du dort nur die neue Zahl eintragen und fertig. :)

counter == FRAMESIZE-1 überprüft, ob counter den Wert 10 enthält. Damit prüfe ich ab, ob es wirklich das Ende-Byte ist.

Stuffing nennt FrSky die Lösung für das Problem, dass 7E (was ja das Start- und Ende-Byte ist) auch als Wert im Frame auftauchen können, was dann den Algorithmus durcheinander bringen würde. Das lösen sie, indem sie das durch zwei Bytes substituieren, mit 7D als erstem. Und mit der b ^= 0x20 wird genau das Bit verdreht, dass dafür sorgt, dass dann wieder 7E oder 7D als Nutzbytes rauskommen. Steht in dem PDF, das Du verlinkt hast. :)

Hallo mal wieder,

jetzt habe ich das Modul sauber in meine Fernsteuerung integriert. Natürlich war ich sehr ambitioniert, zum testen mit dem Arduino. Leider tat sich gar nix.

Hier mal die Bytes was ich über den ComPort mit RealTerm ausgelesen habe:

00 00 00 00 7E 7E FE 47 5E 5E B8 00 00 00 00 7E 7E FE 47 5E 5F B8 00 00 00 00 7E 7E FE 47 5E 5D B8 00 00 00 00 7E 7E FE 47 5E 5E BB 00 00 00 00 7E 7E FE 47 5E 5D BB 00 00 00 00 7E 7E FE 47 5E 5E B9 00 00 00 00 7E 7E FE 47 5E 5F B9 00 00 00 00 7E 7E FE 47 5E 5D B9 00 00 00 00 7E 7E FE 46 5E 5E BB 00 00 00 00 7E 7E FE 47 5E 5C BC 00 00 00 00 7E 7E FE 47 5E 5E BA 00 00 00 00 7E 7E FE 47 5E 5F BB 00 00 00 00 7E 7E FE 47 5E 5D BA 00 00 00 00 7E 7E FE 47 5E 5E BD 00 00 00 00 7E 7E FE 47 5E 5C BD 00 00 00 00 7E 7E FE 47 5E 5D BB 00 00 00 00 7E 7E FE 47 5E 5E BC 00 00 00 00 7E 7E FE 47 5E 5D BB 00 00 00 00 7E 7E FE 47 5E 5E BD 00 00 00 00 7E 7E FE 47 5E 5C BD 00 00 00 00 7E 7E FE 47 5E 5E BC 00 00 00 00 7E 7E FE 46 5E 5D BC 00 00 00 00 7E 7E FE 47 5E 5D BC 00 00 00 00 7E 7E FE 47 5E 5F BC 00 00 00 00 7E 7E FE 47 5E 5C BC 00 00 00 00 7E 7E FE 47 5E 5E BC 00 00 00 00 7E 7E FE 47 5E 5D BC 00 00 00 00 7E 7E FE 47 5E 5D BB 00 00 00 00 7E 7E FE 47 5E 5F BB 00 00 00 00 7E 7E FE 47 5E 5D BB 00 00 00 00 7E 7E FE 47 5E 5E BB 00 00 00 00 7E 7E FE 47 5E 5D BC 00 00 00 00 7E 7E FE 47 5E 5D BA 00 00 00 00 7E 7E FE 47 5E 5F BA 00 00 00 00 7E 7E FE 46 5E 5D BA 00 00 00 00 7E 7E FE 47 5E 5F BB 00 00 00 00 7E 7E FE 47 5E 5D BC 00 00 00 00 7E 7E FE 47 5E 5D B9 00 00 00 00 7E 7E FE 47 5E 5F B9 00 FE 00 00 7E 7E FE 47 5E 5D B9 00 00 00 00 7E

Die Start und Endbytes kommen doch alle an, an was kann das denn liegen?

Hardwareseitig habe ich Masse Arduino mit Masse Sender, sowie TX Sender mit RX Arduino verbunden. Das müßte ja reichen.

Also am Algorithmus liegts nicht, ich hab mir jetzt mal die Zeit genommen und ihn getestet: Sieht gut aus. :slight_smile:

byte data[] = {
0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5F, 0xB8, 0x00, 0x00,
0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xBB, 0x00, 0x00, 0x00, 0x00,
0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E,
0xFE, 0x47, 0x5E, 0x5F, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x46,
0x5E, 0x5E, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5C, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E,
0xBA, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5F, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBA, 0x00,
0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5C, 0xBD, 0x00, 0x00, 0x00,
0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E,
0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE,
0x47, 0x5E, 0x5C, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x46, 0x5E,
0x5D, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5F, 0xBC,
0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5C, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5E, 0xBC, 0x00, 0x00,
0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBB, 0x00, 0x00, 0x00, 0x00,
0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5F, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E,
0xFE, 0x47, 0x5E, 0x5E, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47,
0x5E, 0x5D, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5F, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x46, 0x5E, 0x5D,
0xBA, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5F, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xBC, 0x00,
0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5F, 0xB9, 0x00, 0xFE, 0x00,
0x00, 0x7E, 0x7E, 0xFE, 0x47, 0x5E, 0x5D, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x7E
};

#define FRAMESIZE 11
int Daten[FRAMESIZE];
int counter;
boolean stuffFlag;

void setup() {
      Serial.begin(57600);

      for (int t=0; t<445; t++) {
            byte b = data[t];

            if (b == 0x7E && counter == FRAMESIZE-1 && Daten[0] == 0x7E && Daten[1] == 0xFE) {
                  // Sieht nach dem Ende eines validen Frame aus
                  //lcd.clear(); // Wenn ueberhaupt dann erst jetzt das Display loeschen, sonst flackerts...
                  Serial.print("P1:");
                  Serial.print (Daten[2], DEC);
                  Serial.print("   ");
                  Serial.print("P2:");
                  Serial.print (Daten[3], DEC);
                  Serial.print("   ");
                  Serial.print("LQ:");
                  Serial.print (Daten[4], DEC);
                  Serial.println();
            } else if (b == 0x7D) { // Byte stuffing!
                  stuffFlag = true;
                  continue; // Dieses Byte nur als Flag benutzen, nicht speichern!
            } else if (b == 0x7E) {
                  counter = 0; // Start eines Frames. Hoffentlich.
            }
            if (stuffFlag) { // Byte stuffing!
                  b ^= 0x20;
                  stuffFlag = false;
            }
            Daten[counter++] = b;
      }
}

void loop() {
}

Spuckt aus:

P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:95
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:95
P1:71 P2:94 LQ:93
P1:70 P2:94 LQ:94
P1:71 P2:94 LQ:92
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:95
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:92
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:92
P1:71 P2:94 LQ:94
P1:70 P2:94 LQ:93
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:95
P1:71 P2:94 LQ:92
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:95
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:94
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:95
P1:70 P2:94 LQ:93
P1:71 P2:94 LQ:95
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:93
P1:71 P2:94 LQ:95
P1:71 P2:94 LQ:93

Hallo,

die letzten Tage habe ich es immer wieder mal versucht, bin aber nicht recht weiter gekommen.
Deinen letzten Code habe ich getestet, das funktioniert ja mit der Ausgabe am seriellen Port.

Jetzt wollte ich mal den Code stark verainfachen, um sicherzustellen, dass hardwareseitig alles in Ordnung ist.
Dazu habe ich Newsoftserial eingebunden, um am Port 7 lesen zu können. So kann ich das USB Kabel stecken lassen und damit die Daten am LCD und am seriellen Monitor wiedergeben.

Nach weiteren erfolglosen Versuchen habe dann mal jedes Byte im array anzeigen lassen. Mich hat diese Ausgabe stark verwundert:

0=160   1=128   2=0   3=0   4=0
5=0   6=0   7=0
8=0   9=0   10=0   11=2   
0=160   1=128   2=165   3=0   4=0
5=0   6=0   7=0
8=0   9=0   10=0   11=3

Das Startbyte 7E (126) und FE (254) war nicht zu finden. So kanns ja nicht gehen!
Dann habe ich einfach mit dem NewSoftSerial die Signaleingabe invertiert und plötzlich geht es.

Trotzdem verstehe ich das nicht ganz. Ich habe versucht die Hex Zahl selbst zu invertieren:
7E (hex)= 1111110(bin) invertiert: 0000001(bin) = 1(hex)

Die 1 finde ich im array trotzdem nicht.

Das wäre schön, wenn mir das jemand erklären könnte.

Ansonsten bin ich jetzt erst mal sehr froh, dass es jetzt mal läuft.
Jetzt möchte ich die Anzeige noch etwas träger machen, die letzte Ziffer flackert etwas, die Signalstärke springt zum Beispiel immer zwischen 81 und 82 umher.
Ich versuche mal so zu programmieren, dass erst bei einer Differenz von 2 eine Wertänderung ausgegeben werden soll.
Dann soll jetzt auch noch ein Buzzer ran, mit dem ich Alarmtöne wiedergeben kann.

Vielen Dank für die tolle Unterstützung! [smiley=thumbsup.gif]

#include <LiquidCrystal.h>
#include <NewSoftSerial.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

#define FRAMESIZE 11
int Daten[FRAMESIZE];
int counter;
boolean stuffFlag;
NewSoftSerial Sky_in(7,8,true); //rx 7; tx8 


void setup() {
      // set up the LCD's number of columns and rows:
      lcd.begin(16, 2);
      // Print a message to the LCD.
      lcd.clear();
      lcd.setCursor(5,0);
      lcd.print("ready");
        Sky_in.begin(9600);
      
}

void loop() {
        
 
      while (Sky_in.available()) {
            
                byte b = Sky_in.read();
                                 
            if (b == 0x7E && counter == FRAMESIZE-1 && Daten[0] == 0x7E && Daten[1] == 0xFE) {
                  // Sieht nach dem Ende eines validen Frame aus
                  //lcd.clear(); // Wenn ueberhaupt dann erst jetzt das Display loeschen, sonst flackerts...
                  lcd.setCursor(0,0);
                  lcd.print("P1:");
                  lcd.print (Daten[2], DEC);
                  lcd.print("   ");
                  lcd.setCursor(0,1);
                  lcd.print("P2:");
                  lcd.print (Daten[3], DEC);
                  lcd.print("   ");
                  lcd.setCursor(9,0);
                  lcd.print("LQ:");
                  lcd.print (Daten[4], DEC);
                  lcd.print("   ");
                        
            } else if (b == 0x7D) { // Byte stuffing!
                  stuffFlag = true;
                  continue; // Dieses Byte nur als Flag benutzen, nicht speichern!
            } else if (b == 0x7E) {
                  counter = 0; // Start eines Frames. Hoffentlich.
            }

            if (stuffFlag) { // Byte stuffing!
                  b ^= 0x20;
                  stuffFlag = false;
            }
            Daten[counter++] = b;
                
      }


}