Hexadezimale Zeichen über UART einlesen

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

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.

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.

1

volatile buffer[500] = {0};

2

int buffercounter = 0;

3

4

void main(void)

5

{

6

  volatile unsigned int i;

7

  P3SEL |= 0x30;                            

8

  WDTCTL = WDTPW + WDTHOLD;                 

9

10

  DCOCTL = 0xE0;       

11

12

  BCSCTL1 &= ~XT2OFF;                      

13

14

  do

15

  {

16

  IFG1 &= ~OFIFG;                          

17

  for (i = 0xFF; i > 0; i--);               

18

  }

19

  while ((IFG1 & OFIFG));                  

20

21

  BCSCTL2 |= SELM_2 + SELS;                

22

23

  ME1 |= UTXE0 + URXE0;                     

24

  UCTL0 |= CHAR;                           

25

  UTCTL0 |= SSEL1;                          // UCLK = SMCLK

26

  UBR00 = 0x71;                             // 6Mhz/9600 

27

  UBR10 = 0x02;                             //

28

  UMCTL0 = 0x00;                            

29

  UCTL0 &= ~SWRST;                          

30

  IE1 |= URXIE0;                            

31

32

  while(1)

33

 {

34

   // führe darstellung durch 

35

36

 }

37

38

39

}

40

41

42

#pragma vector=USART0RX_VECTOR

43

__interrupt void Usart0_rx (void)

44

{

45

  buffer[buffercounter++] = RXBUF0;

46

  IFG1 &= ~URXIFG0;

47

}

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.