RX Complete Interrupt wird nicht ausgelöst

Gast #996938
Lesenswert?

Kann mir bitte jemand sagen, warum der USART- RX Complete Interrupt 
nicht ausgelöst wird?
Ich teste das ganze am STK500. Ich schalte in der ISR eine LED (zum 
Test). Die leuchtet jedoch nicht....
Die Routinen stammen von Ulrich Radig.
Danke!

UartTest.c:
1
#include <stdlib.h>
2
#include <avr/io.h>
3
#include <avr/interrupt.h>
4

5
#include "usart.h"
6

7
//----------------------------------------------------------------------------
8

9

10

11

12
int main(void)
13
{ 
14
  DDRC=0xFF;
15
  PORTC=0xFF;
16

17
  usart_init(9600);
18

19
  usart_write("Test");
20
  PORTC &= ~ (1<<PC0);
21

22
  sei();
23

24
}

Usart.c:
1
/*----------------------------------------------------------------------------
2
 Copyright:      Radig Ulrich  mailto: mail@ulrichradig.de
3
 Author:         Radig Ulrich
4
 Remarks:        
5
 known Problems: none
6
 Version:        14.06.2007
7
 Description:    RS232 Routinen
8
----------------------------------------------------------------------------*/
9

10
#include "usart.h"
11

12
volatile unsigned char buffercounter = 0;
13
char usart_rx_buffer[BUFFER_SIZE];
14

15
//----------------------------------------------------------------------------
16
//Init serielle Schnittstelle
17
void usart_init(unsigned int baudrate) 
18
{ 
19
    //Enable TXEN im Register UCR TX-Data Enable
20
  UCR =(1 << TXEN | 1 << RXEN | 1<< RXCIE);
21
  //Teiler wird gesetzt 
22
  UBRR=(SYSCLK / (baudrate * 16L) - 1);
23
}
24

25
//----------------------------------------------------------------------------
26
//Routine für die Serielle Ausgabe eines Zeichens
27
void usart_write_char(char c)
28
{
29
  if (c == '\n')
30
    usart_write_char('\r');
31
  //Warten solange bis Zeichen gesendet wurde
32
  while(!(USR & (1<<UDRE)));
33
  //Ausgabe des Zeichens
34
  UDR = c;
35
  return;
36
}
37

38
//------------------------------------------------------------------------------
39
void usart_write_P (const char *Buffer,...)
40
{
41
  va_list ap;
42
  va_start (ap, Buffer);  
43
  
44
  int format_flag;
45
  char str_buffer[10];
46
  char str_null_buffer[10];
47
  char move = 0;
48
  char Base = 0;
49
  int tmp = 0;
50
  char by;
51
  char *ptr;
52
    
53
  //Ausgabe der Zeichen
54
    for(;;)
55
  {
56
    by = pgm_read_byte(Buffer++);
57
    if(by==0) break; // end of format string
58
            
59
    if (by == '%')
60
    {
61
            by = pgm_read_byte(Buffer++);
62
      if (isdigit(by)>0)
63
        {
64
                                 
65
         str_null_buffer[0] = by;
66
        str_null_buffer[1] = '\0';
67
        move = atoi(str_null_buffer);
68
                by = pgm_read_byte(Buffer++);
69
        }
70

71
      switch (by)
72
        {
73
                case 's':
74
                    ptr = va_arg(ap,char *);
75
                    while(*ptr) { usart_write_char(*ptr++); }
76
                    break;
77
        case 'b':
78
          Base = 2;
79
          goto ConversionLoop;
80
        case 'c':
81
          //Int to char
82
          format_flag = va_arg(ap,int);
83
          usart_write_char (format_flag++);
84
          break;
85
        case 'i':
86
          Base = 10;
87
          goto ConversionLoop;
88
        case 'o':
89
          Base = 8;
90
          goto ConversionLoop;
91
        case 'x':
92
          Base = 16;
93
          //****************************
94
          ConversionLoop:
95
          //****************************
96
          itoa(va_arg(ap,int),str_buffer,Base);
97
          int b=0;
98
          while (str_buffer[b++] != 0){};
99
          b--;
100
          if (b<move)
101
            {
102
            move -=b;
103
            for (tmp = 0;tmp<move;tmp++)
104
              {
105
              str_null_buffer[tmp] = '0';
106
              }
107
            //tmp ++;
108
            str_null_buffer[tmp] = '\0';
109
            strcat(str_null_buffer,str_buffer);
110
            strcpy(str_buffer,str_null_buffer);
111
            }
112
          usart_write_str (str_buffer);
113
          move =0;
114
          break;
115
        }
116
      
117
      }  
118
    else
119
    {
120
      usart_write_char ( by );  
121
    }
122
  }
123
  va_end(ap);
124
}
125

126
//----------------------------------------------------------------------------
127
//Ausgabe eines Strings
128
void usart_write_str(char *str)
129
{
130
  while (*str)
131
  {
132
    usart_write_char(*str++);
133
  }
134
}
135

136
//Empfang eines Zeichens
137
ISR(USART_RXC_vect)
138
{  
139
    PORTC &= ~ (1<<PC1);         // Zur überprüfung ob ISR überhaupt aufgerufen wird
140
/*  unsigned char receive_char;
141
  receive_char = (UDR);
142

143
  if (usart_status.usart_ready)
144
  {
145
    usart_status.usart_rx_ovl = 1;
146
    return; 
147
  }
148

149
  if (receive_char == 13 && (!(usart_rx_buffer[buffercounter-1] == '\\')))
150
  {
151
      
152
    usart_rx_buffer[buffercounter] = 0;
153
    buffercounter = 0;
154
    usart_status.usart_ready = 1;
155
    return;    
156
  }
157

158
  if (buffercounter < BUFFER_SIZE - 1)
159
  {
160
    usart_rx_buffer[buffercounter++] = receive_char;    
161
  }
162
return; */
163
}

usart.h
1
/*----------------------------------------------------------------------------
2
 Copyright:      Radig Ulrich  mailto: mail@ulrichradig.de
3
 Author:         Radig Ulrich
4
 Remarks:        
5
 known Problems: none
6
 Version:        14.06.2007
7
 Description:    RS232 Routinen
8
----------------------------------------------------------------------------*/
9

10
#ifndef _UART_H
11
  #define _UART_H
12

13
#define BUFFER_SIZE  100
14

15
volatile unsigned char buffercounter;
16
char usart_rx_buffer[BUFFER_SIZE];
17

18
struct {
19
    volatile unsigned char usart_ready:1;
20
    volatile unsigned char usart_rx_ovl:1;
21
    }usart_status ;
22
    
23
//----------------------------------------------------------------------------
24
  
25
  #include <avr/interrupt.h>
26
  #include <avr/pgmspace.h>
27
  #include <stdlib.h>
28
  #include <stdarg.h>
29
  #include <ctype.h>
30
  #include <string.h>
31
  #include <avr/io.h>
32

33
//----------------------------------------------------------------------------
34

35
//Der Quarz auf dem Experimentierboard
36
#ifndef SYSCLK
37
    //#define SYSCLK  8000000  //Quarz Frequenz in Hz
38
    //#define SYSCLK  14318180  //Quarz Frequenz in Hz
39
    #define SYSCLK 4000000UL
40
#endif //SYSCLK  
41

42
//Anpassen der seriellen Schnittstellen Register wenn ein ATMega128 benutzt wird
43
#if defined (__AVR_ATmega128__)
44
#  define USR UCSR0A
45
#  define UCR UCSR0B
46
#  define UDR UDR0
47
#  define UBRR UBRR0L
48
#  define EICR EICRB
49
#endif
50

51
#if defined (__AVR_ATmega32__)
52
#  define USR UCSRA
53
#  define UCR UCSRB
54
#  define UBRR UBRRL
55
#  define EICR EICRB
56
#endif
57

58
#if defined (__AVR_ATmega8__)
59
#  define USR UCSRA
60
#  define UCR UCSRB
61
#  define UBRR UBRRL
62
#endif
63

64
#if defined (__AVR_ATmega8515__)  // by hubert
65
#  define USR UCSRA
66
#  define UCR UCSRB
67
#  define UBRR UBRRL
68
#endif
69

70
#if defined (__AVR_ATmega88__)
71
#  define USR UCSR0A
72
#  define UCR UCSR0B
73
#  define UBRR UBRR0L
74
#  define TXEN TXEN0
75
#  define UDR UDR0
76
#  define UDRE UDRE0
77
#endif
78

79
//----------------------------------------------------------------------------
80
  
81
void usart_init(unsigned int baudrate); 
82
void usart_write_char(char c);
83
void usart_write_str(char *str);
84
  
85
void usart_write_P (const char *Buffer,...);
86
#define usart_write(format, args...)   usart_write_P(PSTR(format) , ## args)
87
  
88
//----------------------------------------------------------------------------
89

90
#endif //_UART_H
Gast #996954
Lesenswert?

Beim Überfliegen würd ich spontan sagen "Da!".

UCR =(1 << TXEN | 1 << RXEN | 1<< RXCIE);

ich meine | hat ne höher Priorität als <<, d.h die Zeile ergibt unfug.

Versuchs mal so:
UCR =(1 << TXEN) | (1 << RXEN) | (1<< RXCIE);

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