Schleifen Problem

Hallo!

Ich programmiere mC in C und nachdem mein Programm ein "reines" C-Problem ist, poste ich es in dieses Forum!

Es geht um folgendes:

Ich möchte Befehle, welche über USB an den mC kommen, auslesen und auswerten, da sie dann an weitere Geräte geschickt werden. Hierzu habe ich folgende Abfrage-Routine:

// Receive data
i = 0;
while (i < NUM_BYTES) 
{
    if (USART_RXBufferData_Available(&USART_data)) 
    {
        receiveArray[i] = USART_RXBuffer_GetByte(&USART_data);
    }
}

NUM_BYTES bezeichnet die Anzahl der einzulesenden Bytes (Also die Länge des Befehls). Nun möchte ich unterschiedlich lange Befehle einlesen, welche jeweils mit einem Zeichen terminiert werden. Wird dieses Zeichen als i-tes Element eingelesen, soll der Einlesevorgang beendet werden.
Ich habe es mit if-Abfragen probiert, aber irgendwie bekomme ich es nicht so hin wie ich möchte, da die Zeichen nach dem Terminierungszeichen trotzdem eingelesen werden und im Puffer stehen.
Ich würde mir das ganze so vorstellen, dass der Puffer nach dem Terminierungszeichen gelöscht wird und somit nur die Zeichen vorher im ReceiveArray stehen.

_matze

Du kannst doch einfach nach dem Einlesen vergleichen, ob receiveArray[i] gleich deinem Terminierungszeichen ist und dann die Schleife mit break verlassen. Die Anzahl der eingelesenen Bytes steht dann in i (Voraussetzung ist allerdings, dass du i auch inkrementierst, das hast du vergessen). Das ist es doch dann schon, oder habe ich das Problem falsch verstanden?

Ja, so habe ich das auch probiert:

i = 0;
    	while (i < NUM_BYTES) 
    	{
        	if (USART_RXBufferData_Available(&USART_data)) 
        	{
				receiveArray[i] = USART_RXBuffer_GetByte(&USART_data);
				if (receiveArray[i] == 'Q')
					break;
				else
					i++;

			}
		}

Wenn ich nun allerdings z.B. "tQss" schreibe, sind die Zeichen nach dem Q noch im Puffer...

Wie teilt dir denn USART_RXBuffer_GetByte() mit, dass kein Zeichen mehr da ist?

Über diese Funktion hier:

uint8_t USART_RXBuffer_GetByte(USART_data_t * usart_data)
{
	USART_Buffer_t * bufPtr;
	uint8_t ans;

	bufPtr = &usart_data->buffer;
	ans = (bufPtr->RX[bufPtr->RX_Tail]);

	/* Advance buffer tail. */
	bufPtr->RX_Tail = (bufPtr->RX_Tail + 1) & USART_RX_BUFFER_MASK;

	return ans;
}

Wutz

So sollte es prinzipiell funktionieren, alle Befehle werden zunächst mal aufgesammelt und in einem Stringarray gespeichert, die Bearbeitung kann dann anschließend und somit gekapselt zur Datenabfrage ablaufen:

char **befehle=0, trenner='Q', c=trenner;
int z=0;
do
{
  if( c==trenner )
  {
    befehle=realloc(befehle,++z*sizeof*befehle);
    befehle[z-1]=calloc(1,1);
  }
  else
  {
    befehle[z-1]=realloc(befehle[z-1],strlen(befehle[z-1])+2);
    strncat(befehle[z-1],&c,1);
  }
}
while(USART_RXBufferData_Available(&USART_data)&&(c=USART_RXBuffer_GetByte(&USART_data)||1));
while( z-- )
  puts(befehle[z]),free(befehle[z]);
free(befehle);

Danke Wutz, das muss ich mir noch genauer ansehen

Aber eine Frage noch: Gibt es eine "einfachere" Möglichkeit, einfach den Puffer zu leeren, wenn z.B. 'Q' eingelesen wird? Ev. in einer ISR nach jedem Zeichen, das an das ReceiveArray übergeben wurde?