Hexadezimale Zeichen über UART einlesen

[Steffen (Gast)]

Hallo,

ich habe eine MSP430 und wollte fragen, ob man hexadezimale Zeichen 
einlesen kann? Ich sende per H-Term 0xAA und in der Variablen steht 
nichts drinn.
Bei einzelnen Ascii Zeichen funktioniert dieses jedoch.

#pragma vector=USART0RX_VECTOR
__interrupt void Usart0_rx (void)
{
  while (!(IFG1 & UTXIFG0));
  recive = RXBUF0;
};

[Steffen (Gast)]

Eine Andere Frage ist noch wie man das mit Mehreren Werten machen kann? 
Also wenn ich 0xAA und 0xCC sende hintereinander.

[ich (Gast)]

Steffen schrieb:
> Hallo,
>
> ich habe eine MSP430 und wollte fragen, ob man hexadezimale Zeichen
> einlesen kann? Ich sende per H-Term 0xAA und in der Variablen steht
> nichts drinn.
> Bei einzelnen Ascii Zeichen funktioniert dieses jedoch.
>
> #pragma vector=USART0RX_VECTOR
> __interrupt void Usart0_rx (void)
> {
>   while (!(IFG1 & UTXIFG0));
>   recive = RXBUF0;
> };

Was möchtest du denn machen? Ich denke, du willst einfach ein Byte 
übertragen. Und ob das jetzt auf dem Bildschirm hexadezimal, binär, 
oktal oder dezimal angezeigt wird, bleibt sich doch gleich. Das 
interessiert doch die UART nicht. Sie überträgt ein Byte, fertig. Und 
wenn das nicht funktioniert, hängt das nicht daran, in welcher 
Darstellungsform es auf dem Bildschirm erscheint.

Mach doch einfach mal eine Schleife, wo reihum die Bytes von 0,1,2..255 
(0xFF) übertragen werden, und wenn am Empfänger bestimmte Bytes nicht 
ankommen oder verändert ankommen, dann kannst du weitersuchen, warum das 
so ist.

[Purzel H. (hacky)]

>#pragma vector=USART0RX_VECTOR
__interrupt void Usart0_rx (void)
{
  while (!(IFG1 & UTXIFG0));
  recive = RXBUF0;
};

Es ist aber schon klar, dass weiter auf diesem controller nichts mehr 
laeuft...

[stefanus (Gast)]

Zeige uns den Rest des Programms. Wie wurde die Schnittstelle 
initialisiert und wie ist die Variable deklariert? Sie muss volatile 
sein!

Die Schnittstelle kan viele Bytes nacheinander empfangen, für jedes Byte 
wir die Interruptroutine aufgerufen. Üblicherweise sammelt man empfange 
Daten nicht in einer byte-Variable (weil da ja nur ein Byte rein passt), 
sondern in einem byte- oder char-array.

Das Stichwort dazu lautet: Ringpuffer.

[Steffen (Gast)]

volatile buffer[500] = {0};
int buffercounter = 0;

void main(void)
{
  volatile unsigned int i;
  P3SEL |= 0x30;                            
  WDTCTL = WDTPW + WDTHOLD;                 

  DCOCTL = 0xE0;       
  
  BCSCTL1 &= ~XT2OFF;                      

  do
  {
  IFG1 &= ~OFIFG;                          
  for (i = 0xFF; i > 0; i--);               
  }
  while ((IFG1 & OFIFG));                  

  BCSCTL2 |= SELM_2 + SELS;                

  ME1 |= UTXE0 + URXE0;                     
  UCTL0 |= CHAR;                           
  UTCTL0 |= SSEL1;                          // UCLK = SMCLK
  UBR00 = 0x71;                             // 6Mhz/9600 
  UBR10 = 0x02;                             //
  UMCTL0 = 0x00;                            
  UCTL0 &= ~SWRST;                          
  IE1 |= URXIE0;                            

  while(1)
 {
   // führe darstellung durch 

 }


}


#pragma vector=USART0RX_VECTOR
__interrupt void Usart0_rx (void)
{
  buffer[buffercounter++] = RXBUF0;
  IFG1 &= ~URXIFG0;
}

stefanus schrieb:
> Zeige uns den Rest des Programms. Wie wurde die Schnittstelle
> initialisiert und wie ist die Variable deklariert? Sie muss volatile
> sein!
>
> Die Schnittstelle kan viele Bytes nacheinander empfangen, für jedes Byte
> wir die Interruptroutine aufgerufen. Üblicherweise sammelt man empfange
> Daten nicht in einer byte-Variable (weil da ja nur ein Byte rein passt),
> sondern in einem byte- oder char-array.
>
> Das Stichwort dazu lautet: Ringpuffer.

Genau sowas suche ich bzw brauche da Hilfe weil ich jetzt so dauerhaft 
in der Routine festhänge. Es werden 21 Bytes gesendet und die muss ich 
auswerten. Also werte auslesen stimmt alles.