atmega1284p sendet immer die gleichen Daten

Gast #2826353
Lesenswert?

Hallo Leute,

Ich versuche jetzt schon einen Tag lang Daten über den usart0 des 
atmega1284 zu senden. Es wird zum einen ein String und danach ein 
Zeichen über den Usart0 gesendet.

RealTerm gibt mir aber immer die gleichen Daten zurück. RealTerm ist 
richtig eingestellt.

Als ob sich der Wert im Datenregister des usart0 nie geändert wird.
Ich sende mit 9600 Baud, 8n1, 8 MHz Prozessortakt.

Ich würde mich sehr freuen, wenn ihr mal drüber schauen würdet.
Ich bin für jeden Tip dankbar.

Grüße Kermit

Haupt Programm:
1
#include <avr/io.h>
2
#include "m1284usart.h"
3

4

5

6

7
int main(void)
8
{  uint8_t hello[] = "Hallo\n\r";    //Variable für Ausgabetext
9
  uint8_t helloWorld[] = "HalloWelt\n\r";  
10
  uint8_t bitPattern0 = 0b11111111;
11

12

13
  const unsigned long baudRateUsart0AndUsart1 = 9600;
14
  const unsigned long fCpuInHertz = 8000000;
15

16

17

18
    m1284usart *rs232 = new m1284usart(baudRateUsart0AndUsart1, fCpuInHertz);
19

20

21
  while(1)
22
  {  
23
    rs232->usart0Flush();
24
    rs232->usart0SendString(helloWorld);
25
    rs232->usart0SendByte(bitPattern0);
26
  }
27
  return 0;
28
}


cpp File usart Klasse:
1
#include "util.h"
2

3
#include "m1284usart.h"
4

5
void m1284usart::usart0SendByte(uint8_t byte)
6
{
7
  while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
8
  {
9

10
  }
11

12
  UDR0 = byte;
13
}
14

15

16
void m1284usart::usart1SendByte(uint8_t byte)
17
{
18
  while (!(UCSR1A & (1<<UDRE1)))  /* warten bis Senden moeglich */
19
  {
20

21
  }
22

23
  UDR1 = byte;
24
}
25

26

27
void m1284usart::usart0SendString(uint8_t *string)
28
{
29
  while (*string)
30
  {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
31
    usart0SendByte(*string);
32
    string++;
33
  }
34
}
35

36

37

38
void m1284usart::usart1SendString(uint8_t *string)
39
{
40
  while (*string)
41
  {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
42
    usart1SendByte(*string);
43
    string++;
44
  }
45
}
46

47

48

49

50

51

52
m1284usart::m1284usart(unsigned long baudRate, unsigned long fCpu)
53
{
54
  unsigned long myBaudRate = fCpu/16/baudRate;
55

56
  UBRR1H = (uint8_t)(myBaudRate>>8); //set baudRate usart1
57
  UBRR1L = (uint8_t)myBaudRate;
58

59
  UBRR0H = (uint8_t)(myBaudRate>>8); //set baudRate usart0
60
  UBRR0L = (uint8_t)myBaudRate;
61

62

63
  UCSR1B |= (1<<TXEN1);            //enable usart1 transmitter
64

65
  UCSR0B |= (1<<TXEN0);            //enable usart1 transmitter
66

67
  UCSR0B |= (1<<RXEN0);            //enable usart0 reciver
68

69
  UCSR1B |= (1<<RXEN1);           //enable usart1 reciver
70
}
71

72

73
m1284usart::~m1284usart(void)
74
{
75
  UCSR1B &= ~(1<<TXEN1);            //enable usart1 transmitter
76

77
  UCSR0B &= ~(1<<TXEN0);            //enable usart1 transmitter
78

79
  UCSR0B &= ~(1<<RXEN0);            //enable usart0 reciver
80

81
  UCSR1B &= ~(1<<RXEN1);           //enable usart1 reciver
82
}
83

84

85
void m1284usart::usart0Flush( void )
86
{
87
  unsigned char dummy;
88
  while ( UCSR0A & (1<<RXC0) ) dummy = UDR0;
89
}
90

91

92
void m1284usart::usart1Flush( void )
93
{
94
  unsigned char dummy;
95
  while ( UCSR1A & (1<<RXC1) ) dummy = UDR1;
96
}



Header File usart Klasse:
1
#include <avr/io.h>
2

3
class m1284usart
4
{
5
  private:
6
  //#define usartDataBuffer (*(volatile struct st_io    *)0x32)
7
    uint8_t buffer;
8
    #define F_CPU 8000000
9
    #define BAUD 9600
10
    #define MYUBRR F_CPU/16/BAUD-1
11

12
  public:
13
    void usart0SendByte(uint8_t byte);
14
    void usart1SendByte(uint8_t byte);
15
    void usart0SendString(uint8_t *string);
16
    void usart1SendString(uint8_t *string);
17
    void usart0Flush(void);
18
    void usart1Flush(void);
19

20

21
  m1284usart(unsigned long baudRate, unsigned long fCpu);
22
  ~m1284usart(void);
23
};

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren