Uart Zeichen auslesen

sorry unter main muss noch eine Schleife habe ich vergessen.

1

while (1)

2

{

3

4

5

}

Irgenwie passt "Zeichenkette" und "kann man dann das gespeicherte Byte 
auf PORTB des MC ausgeben" nicht zusammen??
Die Ausgabe fehlt ja völlig, darum kann man ja auch nicht sehen, was du 
genau willst.

Und vielleicht nochmal in die Grundlagen von C reingucken, wie das mit 
den Funktionen und der Variablenübergabe geht, da stimmt so einiges 
nicht. Es wird nix gespeichert. Zusammenkopieren alleine löst deine 
Aufgabenstellung nicht.

Ja aber was will man machen wenn man keine Ahnung hat, ich muss das 
fertig machen und habe keine Zeit mir noch mal alle c Grunglagen durch 
zulesen.

1

void initusart ();

habe ich schon in:

1

initusart ();

geändert und jetzt geht es.

1

void uart_gets( char* Buffer, uint8_t MaxLen );

hir bin ich mir noch nicht sicher wie ich das ändern muss

1

int main(void)

2

{

3

  initusart ();

4

  uint8_t uart_getc(void);

5

  void uart_gets( char* Buffer, uint8_t MaxLen );

6

}

7

8

//Zeichen sammeln und zum String zusammen setzen

9

void uart_gets( char* Buffer, uint8_t MaxLen )

10

{

11

  uint8_t NextChar;

12

  uint8_t StringLen = 0;

13

14

  NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen

15

                                  // Sammle solange Zeichen, bis:

16

                                  // * entweder das String Ende Zeichen kam

17

                                  // * oder das aufnehmende Array voll ist

18

19

20

  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {

21

    *Buffer++ = NextChar;

22

    StringLen++;

23

    NextChar = uart_getc();

24

  }

25

}

kann mir jemand sagen wie ich
void uart_gets( char* Buffer, uint8_t MaxLen );
in main ändern muss damit ich die Funktion die dahinter steckt aufrufen 
kann.

z.B.  00010011 dann 00101001 dann 0011010

insgesamt werden 10 Byte in den Uart geladen

>Dem kann man nur recht geben
Ja ihr habe ja recht aber ich kann mir das auch nicht an 1 Tag alles bei 
bringen.

Man kann dir nicht helfen, da man nicht weiß was du willst!!
Da steht einerseits irgendwas mit Zeichenkette und gleichzeitig das 
gespeicherte Byte ausgeben. Ja aber eine Zeichenkette besteht aus vielen 
Bytes, so ist es sehr schwer zu erahnen welches du den gern hättest!!!

Ja sorry wenn ich euch durch einnander gebracht habe.
Ich möchte die eingelesenen Byte z.B.00010011 00101001 0011010 auf den 
Ausgang PORTB ausgeben. Wenn die z.B. 00010011 eingelesen wurde soll auf 
PORTB 0=0 erscheinen und wenn das nächste Byter kommt soll
PORTB 1=0
PORTB 2=0
PORTB 3=1
PORTB 4=0
PORTB 5=0
PORTB 6=1
PORTB 7=1

auf PORTB halt das nöchste Byte angszeigt werden.

Hallo ich habe noch ein wenig an mein Quelltext verändert und das 
Initalisieren geht jetzt aber die zweite Funktion unter main wird immer 
noch nicht aufgerufen. Kann mir denn nicht jemand den Quelltext anpassen 
so das ich 8 Byte + 1 Stoppbite empfangen kann.


[c] #include <stdlib.h>
#include <avr/io.h>
#include <util/delay.h>
#include <inttypes.h>
#define F_CPU 4000000L
#define BAUD 4800L
#define ubrr_value (  ( F_CPU / (16*BAUD) ) - 1  )

uint8_t uart_getc(void);
void initusart ();
void uart_gets( char* Buffer, uint8_t MaxLen );

//*************************  main   ***************************

int main(void)
{

DDRB = 0xff;

  while (1)
  {
    initusart ();
    void uart_gets( char* Buffer, uint8_t MaxLen );
  }
}


/********************* Zeichen empfangen ************************/
uint8_t uart_getc(void)
{
    while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar
    return UDR;                   // Zeichen aus UDR an Aufrufer 
zurueckgeben
}


//***********************Zeichen sammeln und zum String zusammen 
setzen******
void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;

  NextChar = uart_getc();     // Warte auf und empfange das nächste 
Zeichen
                              // Sammle solange Zeichen, bis:
                              // * entweder das String Ende Zeichen kam
                              // * oder das aufnehmende Array voll ist


  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
}




//******************UART Initialisieren**********************
void initusart ()
{

    UBRRH = ubrr_value >> 8;
    UBRRL = ubrr_value & 0xFF;

  UCSRB |= (1<<RXEN)|(1<<RXCIE);              // UART RX einschalten
   UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);// Asynchron 8 
Bite

}

So jetzt kann ich alle funktinen aufrufen.

1

  #include <stdlib.h>

2

#include <avr/io.h>  

3

#include <util/delay.h>

4

#include <inttypes.h>

5

#define F_CPU 4000000L

6

#define BAUD 4800L

7

#define ubrr_value (  ( F_CPU / (16*BAUD) ) - 1  )

8

9

// Prototypen

10

uint8_t uart_getc(void);

11

void initusart ();

12

void uart_gets( char* Buffer, uint8_t MaxLen );

13

14

//********************  main   *********************

15

16

int main(void)

17

{

18

19

  // Variablen

20

21

  char strBuffer[256];

22

23

  DDRB = 0xff;

24

  initusart ();   

25

26

27

  while (1)

28

  {

29

30

31

    //DDRA = 0xff;

32

33

    // void uart_gets( char* Buffer, uint8_t MaxLen )

34

    uart_gets( &strBuffer[0], 255 );  //void

35

  }

36

}

37

38

39

/************************ Zeichen empfangen *************************/

40

uint8_t uart_getc(void)

41

{

42

    while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar    

43

    return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben

44

}

45

46

47

//********Zeichen sammeln und zum String zusammen setzen******

48

void uart_gets( char* Buffer, uint8_t MaxLen )

49

{

50

  uint8_t NextChar;

51

  uint8_t StringLen = 0;

52

53

  NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen

54

                                  // Sammle solange Zeichen, bis:

55

                                  // * entweder das String Ende Zeichen kam

56

                                  // * oder das aufnehmende Array voll ist

57

58

59

  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {

60

    *Buffer++ = NextChar;

61

    StringLen++;

62

    NextChar = uart_getc();

63

  }

64

}

65

66

67

68

69

//***************UART Initialisieren********************

70

void initusart ()

71

{

72

73

    UBRRH = ubrr_value >> 8;

74

    UBRRL = ubrr_value & 0xFF;

75

76

  UCSRB |= (1<<RXEN)|(1<<RXCIE);              // UART RX einschalten   

77

   UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);// Asynchron 8 Bite 

78

79

}

So mit dem Quelltext kann ich Daten empfangen und wenn man UDR (unter 
uint8_t uart_getc(void))  auf einen Ausgang gibt kann man auch die Bits 
sehen die empfangen wurden.