Daten aus einem array einer Variablen zuweisen.

[Peter L. (lahabole)]

Im moment habe ich ein Problem, mit dem ich nicht klar komme. Über Uart 
empfange ich 3 Byte (ohne \0), die Zahlenwerte enthalten. Diese Werte 
möchte ich Variablen zuweisen, was aber irgentwie nicht geht.

eine kleine Testschleife sieht im moment so aus:

while (1)
  {
    USART0_Gets(MotorData);  //Funktioniert
    //USART0_Puts(MotorData); //Funktioniert auch
    uint8_t test = MotorData[1]; // geht nicht
    USART0_putchar(test);        // geht auch nicht
  }

Wenn ich die Daten als array wieder Ausgebe, Funktionierts wunderbar. 
Also stehen ja Daten im array, nur wenn ich ein arrayelement einer 
Variablen zuweise geht nix. Was hab ich übersehen ?

[Rufus Τ. F. (rufus)]

Was heißt "geht nicht"? Was passiert? Wie ist "MotorData" deklariert?

Wie sehen die "3 Byte (..) die Zahlenwerte enthalten" aus?

Was vermutest Du, sollte USART0_putchar() ausgeben, wenn Du einen 
beliebigen Wert zwischen 0 und 255 übergibst?

Womit überprüfst Du die von dieser Funktion ausgegebenen Werte?

[Peter L. (lahabole)]

putchar schickt immer 0 auf die Leitung. MotorData ist als uint8_t 
initialisiert mit 3 Elementen.

Ich erwarte im moment das putchar mir den wert des 2 arrayelemnts als 
echo auf die leitung schickt. Mit Puts werden die korrekten 3 Bytes als 
echo ausgegeben.

Nachprüfen kann ich es nur mit meinem logicanalyzer, was bissher auch 
gut Funktionierte :)

[Marco (Gast)]

Zeig uns doch bitte mal die 3 Funktionen puts, gets und putchar.

[Peter L. (lahabole)]

Hier mal die Funktionen.

#define Tx0BufSize 16
#define Rx0BufSize 16
volatile unsigned char uart0TxBuf[Tx0BufSize], uart0RxBuf[Rx0BufSize], Tx0Empty = 1;
volatile unsigned int uart0TxInBufPtr = 0, uart0RxInBufPtr = 0;
volatile unsigned int uart0TxOutBufPtr = 0, uart0RxOutBufPtr = 0;
volatile unsigned char Rx0Overflow = 0;

char printBuffer[256];
uint8_t hex[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

extern volatile

//usart0 receive complete interrupt
ISR (USART_RX_vect)
{
  char dummy;
  unsigned int Ptr;

  Ptr = uart0RxInBufPtr + 1;
  if (Ptr >= Rx0BufSize) Ptr = 0;
  if (Ptr != uart0RxOutBufPtr)
  {
    uart0RxBuf[Ptr] = UDR;
    uart0RxInBufPtr = Ptr;
  }
  else        //no more space in ReceiveBuffer, set overflow warning!
  {
    dummy = UDR;
    Rx0Overflow = 1;
  }
}



signed int USART0_getchar(void)
{
  if (uart0RxInBufPtr != uart0RxOutBufPtr)
  {
    uart0RxOutBufPtr++;
    if (uart0RxOutBufPtr >= Rx0BufSize) uart0RxOutBufPtr = 0;
    return (signed int) uart0RxBuf[uart0RxOutBufPtr];
  }
  else return -1;        //sorry, there was nothing to read
}

signed int USART0_putchar(char ch)
{
  unsigned int Ptr;

  Ptr = uart0TxInBufPtr + 1;
  if (Ptr >= Tx0BufSize) Ptr = 0;
  if (Ptr != uart0TxOutBufPtr)
  {
    uart0TxBuf[Ptr] = ch;
    uart0TxInBufPtr = Ptr;
    if (Tx0Empty == 1)
    {
      UCSRA |= (1<<UDRE);    //clear data register empty flag - so interrupt will fire when UDRIE0 is set
      UCSRB |= (1<<UDRIE);    //Enable data register empty interrupt - force interrupt trigger
    }

    Tx0Empty = 0;
      return 0;
  }
  else
  {
    return -1;      //no room - queue is full
  }
}



void USART0_Puts (char *s)
{
    while (*s)
    {   // as long as *s != '\0' which is the "end of string" indicator
        while(USART0_putchar(*s) == -1);
        s++;
    }
}



void USART0_Gets (char *s)
{
  unsigned char dataHere = 1;
  signed int tmp;
  char * ptr;

  ptr = s;
  while(dataHere)
  {
    tmp = USART0_getchar();
    if (tmp < 0)  //no data is available
    {
      dataHere = 0;
      *ptr = 0;    //string termination
    }
    else
    {
      *ptr = tmp;
      ptr++;
    }
  }
}

[Marco (Gast)]

Oha....

Hast du mir noch die Interruptfunktion, welche warscheinlich die Daten 
über den Uart raussendet....

Danke.

[Stefan E. (sternst)]

Peter Lambertz schrieb:
> Hier mal die Funktionen.

Also auf der Basis der Funktionen würde ich das "Funktioniert" hier

while (1)
  {
    USART0_Gets(MotorData);  //Funktioniert
    //USART0_Puts(MotorData); //Funktioniert auch
    uint8_t test = MotorData[1]; // geht nicht
    USART0_putchar(test);        // geht auch nicht
  }

stark bezweifeln. USART0_Gets kopiert alles, was gerade im Puffer ist 
(egal wie viel), und terminiert es. Es gibt keinen Grund, warum das mit 
jedem Schleifendurchlauf immer genau 3 Zeichen sein sollten. Im 
Gegenteil, schon vom Timing her ist das extrem unwahrscheinlich. Was 
wohl tatsächlich passiert, ist, dass in der "funktionierenden" Version 
pro Schleifendurchlauf immer nur 0 bis 1 Wert gelesen und wieder 
ausgegeben wird. Du siehst zwar in der Ausgabe die erwarteten 3 Werte, 
doch entstand diese Ausgabe nicht in einem Durchlauf (und die Werte 
standen auch nicht in MotorData[0-2]), sondern in vielen Durchläufen 
(und der eine Wert stand dann immer in MotorData[0]). Und damit ist dann 
auch klar, dass das

    uint8_t test = MotorData[1]; // geht nicht
    USART0_putchar(test);

immer eine 0 liefert.

[Peter L. (lahabole)]

da könntest du recht haben stefan. ich bin nur von dem logicanalyzer 
ausgegangen. wenn ich die 3 bytes sende fängt er am letzten empfangenen 
an sie zurückzusenden.

etwa so:
lesen  -> ---  ---  ---  ---
echo   ->   ---  ---  ---  ---

daher ging ich mal davon aus das die 3 bytes erst mal empfangen werden. 
nehme ich jetzt die putchar funktion und lass die senden siehts so aus:

lesen  -> ---  ---  ---  ---
echo   -> ------------------

ich probier mal die MotorData[0] aber noch aus wie du gesagt hast.

[Karl H. (kbuchegg)]

Nichts gegen Logic Analyzer.
Aber am einfachsten testet man eine UART indem man sie mit einem 
Terminal verbindet und nachsieht, ob das was man am Terminal tippt auch 
wieder zurückkommt bzw. wie das Programm darauf reagiert.