Danke für deine Antwort. Du hast Recht, ich hätte mich wirklich präziser ausdrücken sollen.
Gern hätte ich jetzt die relevanten Teile aus dem Code hier mittels Codefenster dargestellt, aber leider ist die Eingabemaske so bescheiden das ich dann nichts mehr Tippen kann.
Ja es ist die UART_C1 Schnittstelle. UART_F0 nutze ich nur um größere Datenmengen zu Fehlersuche am PC auswerten zu können.
Einen Ringbuffer nutze ich bereits. In diesen wird per ISR geschrieben. In der Funktion "void X4_Auswertung (void)" wird ausgewertet, dies kann auch per Interrupt unterbrochen werden. Aufruf erfolgt in der Hauptschleife. Abspeicherung der Daten erfolgt Global.
Relevanter Code aus der ISR für den Empfang:
Code:
if (X4_TypeCode == 0x81)
{
if (UART_X4_Buff[UART_X4_Rx_CNT] != 0)
{ X4_Err |= 0x01; //Buffer beim Schreiben nicht LEER, daher Fehler und Auswertung zu langsam
}
else
{ //UART_X4_Buff[UART_X4_Rx_CNT] = USARTC1.DATA; // da 5 Zeilen weiter unten, nicht genutzt
}
//gehört eigentlich in else
UART_X4_Buff[UART_X4_Rx_CNT] = USARTC1.DATA;
if (UART_X4_Rx_CNT >= (UART_X4_Buff_SIZE - 1)) //Zähler Überlauf verhindern
{ UART_X4_Rx_CNT = 0;
}
else
{ UART_X4_Rx_CNT++;
}
} //ENDE TypeCode == 0x81
Der Sensor selbst sendet selbstständig nach dem Einschalten eine länger "welcomme Message" gefolgt vom "Helth Status". Es können 5 verschiedene Befehle gesendet werden. Antwort erfolgt in einen Übergeordneten Protokoll. Wurde der Befehl "start scanning" (0x60) gesendet, kann die Protokolllänge des Übergeordneten Protokolls ignoriert werden. Die nun folgenden Daten werden kontinuierlich vom Sensor übertragen, bis ein "stop" (0x65) gesendet wird. Markiert ist die kontinuierliche Datenübertragung durch "TypeCode= 0x81". Daher ist der Rest in der ISR auch irrelevant.
Ein Datensatz, aus der kontinuierlichen Übertragung, besteht auch einen Header (10Byte) und verschieden vielen Datensätzen. Ein Datensatz besteht aus 2 Byte. Es gibt in der Regel 40 Datensätze, kann aber auch abweichend sein (z.B. 1, 20). Somit ist ein Durchschnittlicher Datensatz 90Byte lang.
Diese werden in den Ringbuffer abgelegt. "UART_X4_Buff[UART_X4_Rx_CNT]"
Die Funktion "void X4_Auswertung (void)" sucht nach dem Header (0xA5 & 0x5A) und fragt die Paketlänge ab "X4_AnzahlPakete".
Als nächsten wird geprüft ob der Empfangszähler "UART_X4_Rx_CNT" bereits das Ende des Datensatzes erreicht hat (eigentlich größer ist als Empfangszähler, bzw kleiner als Empfangszähler "X4_AusWert_CNT").
Die Einzelpakete werden in einer Schleife "while(((X4_Pakete_CNT + 1) < X4_AnzahlPakete) && (X4_AnzahlPakete > 1))" ausgewertet.
Anschließend wird noch auf Plausibilität (CheckCode) geprüft und ggf. global abgespeichert.
Mein Problem ist nun das es bei manchen Empfangenen Datensatz zu Fehlern kommt. Wenn dies der Fall ist, dann tritt es immer dann auf wenn der Datensatzanfang in der nähe des Bufferende liegt, und das Datensatzende in der nähe des Bufferanfang. Also der Datensatz mit einer länge von 90Byte das Ringbufferende überschreitet. Außerdem kommt es beim Schreiben in den Ringbuffer (ISR) zum Fehler das dieser nicht immer leer ist.
Ich gehe davon aus das beides zusammen hängt.
Als Test habe ich die gesamte Übertragung vom Sensor zum µC mitgeschrieben. Die Auswertung, inkl. des Lesens aus dem Buffer, wurde solange aufgezeichnet bis es zum Fehler im "checkCode" (Prüfsumme) kam. Im Excel konnte ich nun den Fehlerhaften Datensatz einzeln betrachten. Passend dazu habe ich den Datensatz aus der Aufzeichnung (gesamte Übertragung Sensor->µC) herausgefiltert.
Man sieht das am Ende 6 Byte fehlen, die eigentlich übertragen wurden. Aber wohin sind diese verschwunden? Es kam zu keinen "Buffer Over Flow". Und warum sind diese Byte noch im Buffer und wurden nicht ausgewertet?
Ich kann es mir nicht mehr erklären. Und Frage daher nach Hilfe.
Anbei nochmal der Code zur Auswertung des Ringbuffer. Bereinigt um den Testcode.
Code:
uint16_t UART_X4_Massage_CNT = 0; //Übergeordneter Counter für eine Nachricht, es kann Scan Command, Device Info und Healt Status unterschieden werden
uint16_t UART_X4_Rx_CNT = 0; //Counter für Empfangsschleife
uint8_t UART_X4_Tx_CNT = 0; //Zähler für Aufruf senden
#define UART_X4_Buff_SIZE 320 //Größe des Empfangsbuffers /immer mit Ändern wenn Buffergröße geändert wird
uint8_t UART_X4_Buff[UART_X4_Buff_SIZE]; //Empfangsbuffer
#define X4_DATA_Size 100 //Buffergröße X4_DATA zwischenspeicher
signed int X4_DATA_zwichenSP [2] [X4_DATA_Size]; //Empfangene Daten (Zwischenspeicher) [0] Winkel in 1° / [1] Entfernung in 1 mm
uint16_t X4_DATA_Ausw [361]; //Auswertung der Entfernungsdaten. Stelle im Array entspricht Winkel in vollen Grad
uint8_t X4_Final_WRT_CNT = 0; //Zähler um errechnete Daten abzuspeichern. "UART_X4_Buff" muss immer um 2Byte geschoben werden, daher separater Zähler zum Abspeichern
int16_t X4_AusWert_CNT = 0; //Zähler für Auswertung des Buffer der empfangenen Daten aus YDLidar X4 über UART (muss zur Prüfung auch kleiner 0 werden dürfen)
uint8_t X4_Mode = 0; //Empfangsmodus 0x00 = Single response / 0x01 = Continuous response / 0x02 & 0x03 gibt es nicht
uint8_t X4_TypeCode = 0; //Empfangen Typecode für Auswertung: 0x81 = Continuous response (Scan Command) / 0x04 = Single response (Device Info) / 0x06 = Single response (Health Status)
uint8_t X4_StatusCode = 0; //0x00 = running normally / 0x01 = device running / 0x02 = running incorrectly
uint16_t X4_HW_Err = 0; //Hardwarefehler vom X4 0x00 alles O.K. (ohne Spezifikation)
uint8_t X4_ZeroPacket = 0; //erkanntes ZeroPacket der Nachricht
uint8_t X4_AnzahlPakete = 0; //Anzahl der Pakete in dieser Nachricht (bestimmt die Länge der Nachricht) ---offensichtlich liegt das MAXIMUM bei 40---
uint8_t X4_Pakete_CNT = 0; //erfasst die abgearbeiteten Pakete (nach dem Abarbeiten hochzählen, da erstes Paket bereits erledigt)
uint16_t X4_FSA = 0; //first sample point in the sampled data
uint16_t X4_LSA = 0; //last sample point in the sampled data
uint16_t X4_CheckCode = 0; //check code of the current data packet uses a two-byte exclusive OR
uint16_t X4_CheckCode_Ausw = 0; //zur Berechnung der Empfangenen Daten mittels CheckCode.Hier werden die Daten XOR eingelesen
uint16_t X4_Err = 0; //Fehler 0x01 = Buffer RX Overflow (bereits bei Empfang Anzahl Pakete erkannt) / 0x02 = zu Empfangene Daten Pakete passen nicht in den Buffer / 0x04 Hardwarefehler (siehe X4_StatusCode & X4_HW_Err) / 0x08 UART Parity Error / 0x10 UART Buffer Overflow / 0x20 UART Frame Error / 0x40 CheckDIGIT Error FSA / 0x80 CheckDIGIT Error LSA / 0x100 X4_DATA zwischenspeicher zu klein, da Anzahl Pakete größer 80
float X4_Zero_Winkel = 0; //Speichert den Winkelwert aus ZeroPaket ab
float X4_Korrekturwinkel = 0; //Korrekturwinkel FSA aus Distancemessung
float X4_Start_Winkel = 0;
float X4_End_Winkel = 0;
float X4_Dif_Winkel_LSN = 0; //Differenzwinkel aus (Startwinkel und Endwinkel) geteielt durch Anzahl Pakete - 1
void X4_Auswertung (void)
{ //Fehler beim UART C1 Empfang erkennen (Hardwarfehler)
X4_Err |= ((USARTC1.STATUS & 0x1C) << 1);
X4_ZeroPacket = 0;
X4_AnzahlPakete = 0; //unnötige durchläufe verhindern
uint16_t X4_Distance = 0; //Zwischenspeicher für Distanzewert aus Entfangenen Daten
//diese schleife wird solange abgearbeitet bis die ganze Funktion verlassen wird "return". Aber nur wenn Typcode auf Entfernungsmessung steht
while(X4_TypeCode == 0x81)
{
uint16_t Dauerschleife = 0;
//Den Lesezähler so lange Hochzählen bis Startaufruf (170 & 85) (AA & 55) erkannt werden.
while( ! ( ((X4_AusWert_CNT > 0) && (UART_X4_Buff[X4_AusWert_CNT - 1] == 0xAA) && (UART_X4_Buff[X4_AusWert_CNT] == 0x55))
|| ((X4_AusWert_CNT == 0) && (UART_X4_Buff[UART_X4_Buff_SIZE - 1] == 0xAA) && (UART_X4_Buff[X4_AusWert_CNT] == 0x55)) )
)
{
X4_AusWert_CNT_PLUS (1); //im Buffer +1 um PaketHeader zu finden
//Dauerschleife verhindern
Dauerschleife++;
if (Dauerschleife > (UART_X4_Buff_SIZE))
{
break;
}
}
//für nächste Abfrage des Buffer, noch um 1 Hochzählen
X4_AusWert_CNT_PLUS (1);
//Erkennung ob es ein ZeroPaket ist. Dann nur 1 Datenpaket und FSA=LSA=ZeroAngle
X4_ZeroPacket = UART_X4_Buff[X4_AusWert_CNT];
X4_AusWert_CNT_PLUS (1);
//LSN (Sample quantity) Anzahl Pakete erkennen
if (X4_AusWert_CNT != UART_X4_Rx_CNT)
{ X4_AnzahlPakete = UART_X4_Buff[X4_AusWert_CNT];
}
else
{ X4_AnzahlPakete = 0; //Abbruch
}
X4_AusWert_CNT_PLUS (1);
//Prüfen ob alle Pakete im Buffer aufgenommen werden konnten (pro Paket 2 Byte + 10 Byte für den Header)
if (((X4_AnzahlPakete * 2) + 10) > UART_X4_Buff_SIZE)
{
X4_Err |= 0x02; //Bufferüberlauf da Anzahlpakete nicht vollständig aufgenommen werden kann/konnte
}
//Prüfung ob zu lesendes Paket schon vollständig empfangen wurde. Schreibzähler (UART_X4_Rx_CNT) muss um Anzahl Pakete + 10 (10 Byte Header -4 Byte Startaufruf/Auswertungen) höher liegen als Lesezähler (UART_X4_AusWert_CNT).
//Sonst sind die Daten nicht korrekt.
if ((X4_AusWert_CNT + (X4_AnzahlPakete * 2) + 6) <= (UART_X4_Buff_SIZE - 1)) //alle Pakete passen (ohne Überlauf) in den Buffer
{
if ( (((X4_AusWert_CNT + (X4_AnzahlPakete * 2) + 6) >= UART_X4_Rx_CNT) && (UART_X4_Rx_CNT >= X4_AusWert_CNT))
|| (X4_AnzahlPakete == 0)
) //es wurden noch nicht alle Pakete empfangen (Ende des letzen Paketes liegt oberhalb des Empfangszähler UND Empfangszähler ist oberhalb Auswertezähler)
{
//Da Abbruch der Auswertung, wird der Auswertezähler wieder auf Ausgangswert für nächsten Startaufruf (170 & 85) zurückgesetzt
if (X4_AusWert_CNT >= 4) //erkennung auf Zählerüberlauf
{ X4_AusWert_CNT = X4_AusWert_CNT - 4; //für nächsten Einsprung Zähler zurücksetzen um Startaufruf zu erkennen
}
else
{
X4_AusWert_CNT = UART_X4_Buff_SIZE - 1 + X4_AusWert_CNT - 4 + 1; //für nächsten Einsprung Zähler zurücksetzen um Startaufruf zu erkennen
}
break;
}
}
else //alle Pakete passen nicht (ohne Überlauf) in den Buffer
{
//letzter Datensatz liegt hinter dem Empfangscounter (Ende des Datensatz nach Bufferüberlauf liegt hinter Empfangsbuffer) || Datensatzende ist 0 und Empfangszähler ist zwischen Datensatz Anfang/Ende
if ( (((X4_AusWert_CNT + (X4_AnzahlPakete * 2) + 6 - UART_X4_Buff_SIZE) >= UART_X4_Rx_CNT)
|| (((X4_AusWert_CNT + (X4_AnzahlPakete * 2) + 6 - UART_X4_Buff_SIZE) == 0) && (UART_X4_Rx_CNT >= X4_AusWert_CNT))
|| (X4_AnzahlPakete == 0))
)
{
//Da Abbruch der Auswertung, wird der Auswertezähler wieder auf Ausgangswert für nächsten Startaufruf (170 & 85) zurückgesetzt
if (X4_AusWert_CNT >= 4) //erkennung auf Zählerüberlauf
{ X4_AusWert_CNT = X4_AusWert_CNT - 4; //für nächsten Einsprung Zähler zurücksetzen um Startaufruf zu erkennen
}
else
{
X4_AusWert_CNT = UART_X4_Buff_SIZE - 1 + X4_AusWert_CNT - 4 + 1; //für nächsten Einsprung Zähler zurücksetzen um Startaufruf zu erkennen
}
break;
}
}
//Buffer (mit Inhalt Header) löschen, wenn kein return; / falls return; ausgelöst dann werden Daten für den nächsten Einsprung, die Headerdaten noch benötigt
//i=1 i<5 bedeutet: da Zähler bereits hochgezählt muss eine Stelle weiter vorn im Buffer gelöscht werden. 4 Durchläufe bis Startaufruf 170 nötig
for (int8_t i=1 ; i<5 ; i++)
{
if ((X4_AusWert_CNT - i) >= 0)
{
UART_X4_Buff[(X4_AusWert_CNT - i)] = 0; //Buffer löschen damit fehler beim beschreiben registriert werden
}
else
{
UART_X4_Buff[(UART_X4_Buff_SIZE + X4_AusWert_CNT - i)] = 0; //Buffer löschen damit fehler beim beschreiben registriert werden
}
}
//für CheckCode Auswertung Startaufruf eintragen (ist bei TypeCode=0x81 immer 0x55AA
X4_CheckCode_Ausw = 0x55AA; //Startaufruf eintragen
//Abspeichern der Winkeldaten
//FSA (FirstAngle) Startwinkel
//HighByte
X4_FSA = UART_X4_Buff[X4_AusWert_CNT];
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//LowByte
X4_FSA |= (UART_X4_Buff[X4_AusWert_CNT] << 8);
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//Check DIGIT prüfen (muss 1 sein)
if (!(X4_FSA & 0x01))
{ X4_Err |= 0x40;
}
//CheckCode mit FSA Xor
X4_CheckCode_Ausw ^= X4_FSA; //schreibe FSA für CheckCode Auswertung
//Anfangswinkel FSA (First_Angle) berechnen
X4_Start_Winkel = ((X4_FSA>>1)/64);
//LSA (LastAngle) Endwinkel
//HighByte
X4_LSA = UART_X4_Buff[X4_AusWert_CNT];
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//LowByte
X4_LSA |= (UART_X4_Buff[X4_AusWert_CNT] << 8);
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//Check DIGIT prüfen (muss 1 sein)
if (!(X4_LSA & 0x01))
{ X4_Err |= 0x80;
}
//Endwinkelberechnung (LSA)
X4_End_Winkel = ((X4_LSA>>1)/64);
//CheckCode empfangen
//HighByte
X4_CheckCode = UART_X4_Buff[X4_AusWert_CNT];
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//LowByte
X4_CheckCode |= (UART_X4_Buff[X4_AusWert_CNT] << 8);
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//Korrekturwinkel für Startwinkel aus Entfernung berechnen / nur beim ersten Datensatz / Wenn Distance = 0 dann ist auch der Winkel = 0
//erster Datensatz
X4_Distance = UART_X4_Buff[X4_AusWert_CNT];
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
X4_Distance |= (UART_X4_Buff[X4_AusWert_CNT] << 8);
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//CheckCode mit ersten Datensatz Xor
X4_CheckCode_Ausw ^= X4_Distance; //schreibe Datensatz 1 für CheckCode Auswertung
if (X4_Distance == 0)
{ X4_Korrekturwinkel = 0; //Wenn Distance Wert == 0 dann ist auch die Korrektur 0
}
else
{ X4_Korrekturwinkel = atan(21.8*((155.3-X4_Distance)/(155.3 * X4_Distance)))*180/M_PI; //Korrekturwinkel FSA (First_Angle) berechnen
//X4_Korrekturwinkel = (float)atan(21.8*((155.3-X4_Distance)/(155.3 * X4_Distance)))*180/M_PI; //Korrekturwinkel FSA (First_Angle) berechnen
}
//Datenauswertung, wenn ZeroPaket dann nur einmal Daten
if (X4_ZeroPacket == 1)
{ //im Zeropaket werden die Daten für den Startwinkel übertragen. Wird zur Erkennung "start der Messung" benötigt. Ist Übersprung 359° (Startwinkle ist größer Endwinkel)
X4_Zero_Winkel = ((X4_LSA>>1)/64);
}
else
{//kein ZeroPaket
X4_Pakete_CNT = 0; //vor der nutzung auf 0 setzen, sonst Fehler //erfasst die abgearbeiteten Pakete (nach dem Abarbeiten hochzählen, da erstes Paket bereits erledigt)
X4_Final_WRT_CNT = 0; //für erste Paket auf 0 setzen
//Differenzwinkel geteielt durch Anzahl Pakete -1 (Grad Pro empfangenen Paket)
//hier nur einmal berechnen um nicht jedes mal (Anzahl Pakete / 40x) in der do..while zu berechnen
if ((X4_Start_Winkel == X4_Zero_Winkel) && (X4_End_Winkel < X4_Start_Winkel)) //Verhindert "blinden Felck" zwischen ~342° bis 359°
{ X4_Dif_Winkel_LSN = (360 - X4_Start_Winkel + X4_End_Winkel) / (X4_AnzahlPakete - 1); //Startwinkel ist gleich Winkeldaten aus ZeroPaket (348°) und Endwinkel ist über 359°/ ist kleiner Startwinkel
}
else
{ X4_Dif_Winkel_LSN = (X4_End_Winkel - X4_Start_Winkel) / (X4_AnzahlPakete - 1);
}
//Ersten Datensatz anders Berechnen, sonst Rechenfehler
X4_DATA_zwichenSP [1] [X4_Final_WRT_CNT] = (X4_Distance / 4); //Entfernungsdaten in mm
X4_DATA_zwichenSP [0] [X4_Final_WRT_CNT] = (X4_Start_Winkel + X4_Korrekturwinkel); //Winkeldaten in 1°
X4_Final_WRT_CNT++;
//Datensätze bis zum Ende berechnen (Anzahl Pakete), danach Sprung nach oben und prüfen ob die nächsten Datensätze ausgewertet werden können (wenn vollständig empfangen)
//nicht durchlaufen wenn nur ein Datenpaket
while(((X4_Pakete_CNT + 1) < X4_AnzahlPakete) && (X4_AnzahlPakete > 1))
{
//zuerst die Entfernung berechnen
X4_Distance = UART_X4_Buff[X4_AusWert_CNT];
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
X4_Distance |= (UART_X4_Buff[X4_AusWert_CNT] << 8);
UART_X4_Buff[X4_AusWert_CNT] = 0; //Bufferlöschen damit fehler beim beschreiben registriert werden
X4_AusWert_CNT_PLUS (1);
//CheckCode mit Datensatz XX Xor
X4_CheckCode_Ausw ^= X4_Distance; //schreibe Datensatz # für CheckCode Auswertung
//Berechnung des Korrekturwinkel
if (X4_Distance == 0)
{ X4_Korrekturwinkel = 0; //Wenn Distance Wert == 0 dann ist auch die Korrektur 0
X4_DATA_zwichenSP [1] [X4_Final_WRT_CNT] = 0; //Entfernungsdaten in mm
}
else
{ X4_Korrekturwinkel = atan(21.8 *((155.3-X4_Distance)/(155.3 * X4_Distance))) * 57.295779;//*180/M_PI; //Korrekturwinkel FSA (First_Angle) berechnen (57.295779 = 180/M_PI)
//X4_Korrekturwinkel = (float)atan(21.8*((155.3-X4_Distance)/(155.3 * X4_Distance)))*180/M_PI; //Korrekturwinkel FSA (First_Angle) berechnen
X4_DATA_zwichenSP [1] [X4_Final_WRT_CNT] = (X4_Distance / 4); //Entfernungsdaten in mm
}
//Endwinkel wurde bereits berechnet, daher auswahl ob letzter Datensatz im Buffer
//Grad pro Paket: ((X4_End_Winkel - X4_Start_Winkel) / (X4_AnzahlPakete - 1))
//mal Aufsummieren: * (X4_Pakete_CNT)
if ((X4_Pakete_CNT + 2) < X4_AnzahlPakete)
{
X4_DATA_zwichenSP [0] [X4_Final_WRT_CNT] = ((X4_Dif_Winkel_LSN * (X4_Pakete_CNT)) + X4_Start_Winkel + X4_Korrekturwinkel); //Winkeldaten in 1°
}
else //Endwinkel
{
X4_DATA_zwichenSP [0] [X4_Final_WRT_CNT] = (X4_End_Winkel + X4_Korrekturwinkel); //Winkeldaten in 1°
}
X4_Final_WRT_CNT++;
if (X4_Final_WRT_CNT >= X4_DATA_Size) //Anzahl Pakete größer 80
{ X4_Err |= 0x100; //Bufferüberlauf
}
//Paket abgearbeitet, hochzählen
X4_Pakete_CNT++;
} //ENDE while (X4_Pakete_CNT + 1 weil ein Paket schon vor der Schleife ausgewertet wurde)
//weiter berechnung CheckCode und Auswertung nur wenn alle Pakete verarbeitet wurden, nicht bei break;
if (((X4_Pakete_CNT + 1) == X4_AnzahlPakete) || (X4_AnzahlPakete == 1))
{
X4_CheckCode_Ausw ^= (((int)X4_AnzahlPakete << 8) | (X4_ZeroPacket)); //schreibe CT und LSN für CheckCode Auswertung
X4_CheckCode_Ausw ^= X4_LSA; //schreibe LSA für CheckCode Auswertung
//auswerten ob CheckCode fehler im Empfang erkannt hat, oder CheckDigit FSA/LSA Fehlerhaft
if ((X4_CheckCode_Ausw != X4_CheckCode) || (X4_Err & 0xC0))
{ //Fehler
//lösche den gesameten Zwischenspeicher, da Fehlerhafter Empfang/Auswertung
for (uint8_t i = 0; i < X4_DATA_Size ; i++)
{ X4_DATA_zwichenSP [0] [i] = 0;
X4_DATA_zwichenSP [1] [i] = 0;
}
}
else
{ //kein Fehler Auswertung möglich
for (uint8_t i = 0; i < X4_AnzahlPakete ; i++)
{ //ArrayStelle enspricht vollem Grad und Entfernung in mm. Anzeige auflösung sowieso nur 1mm.
//Startwinkel kann wie normaler Winkel ausgewertet werden (Fehlt hier noch)
//Endwinkel ist anders zu berechnen (siehe weiter Oben)
//Alle Werte sind falsch, bis ZeroPaket empfangen wurde. Also Endwinkelkorrektur
//Prüfung bei Abspeichern auf < 0 und >360 noch machen
//Werte Größer 360 ° ausblenden
if (X4_DATA_zwichenSP [0] [i] < 360)
{
if (X4_DATA_zwichenSP [0] [i] < 0) //negative Winkel (kleiner 0° = 360°-)
{ //dürfte es nicht mehr geben, daher prüfen und raus
X4_DATA_Ausw [(360 + (X4_DATA_zwichenSP [0] [i]))] = X4_DATA_zwichenSP [1] [i]; //Negative Winkel von 360° abziehen
}
else
{ X4_DATA_Ausw [(X4_DATA_zwichenSP [0] [i])] = X4_DATA_zwichenSP [1] [i]; //Positive Winkelwerte
}
}
else
{ //nur bei Startwinkel = 348°
X4_DATA_Ausw [(360 - (X4_DATA_zwichenSP [0] [i]))] = X4_DATA_zwichenSP [1] [i];
}
//Daten aus Zwischenspeicher löschen
X4_DATA_zwichenSP [0] [i] = 0;
X4_DATA_zwichenSP [1] [i] = 0;
} //ENDE for
} //ENDE else (Empfang korrekt)
} //ENDE if (auswertung CheckCode nach vollständigen Empfang)
X4_CheckCode_Ausw = 0; //Rücksetzen
X4_Err &= 0xFF3F; //CheckDIGIT Fehler Rücksetzen
}//if (UART_X4_ZeroPacket == 1) else
}//ENDE Datenauswertung while(UART_X4_TypeCode == 0x81)
}//ENDE Funktion "X4_Auswertung(void)"
//ENDE Auswerten YDLidar-X4
Lesezeichen