USART mit dem Attiny2313 / 4313 geht nicht

[Michael (c0d3z3r0)]

Hallo!

Ich habe folgendes Problem mit dem Attiny2313 / 4313.

Ich habe den tiny über einen MAX232N an die Serielle Schnittstelle 
gepackt. An einem Port (PD6) hängt ne LED, die sich per Taster 
ein-/ausschalten lässt.

Die Ausgabe an den PC per uart_puts() funktioniert ohne Probleme.

void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
    }
}

Aber sobald ich am PC auch nur ein Zeichen eingebe, leuchtet plötzlich 
die zuvor ausgeschaltete LED auf und es geht gar nichts mehr. Den 
Empfang habe ich nach einem Tutorial per Interrupt gelöst:

ISR(USART_RXC_vect)
{
  uart_puts("test");
}

Initialisiert wird USART wie folgt:

void uart_init()
{
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
  UCSRB |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);  // UART RX, TX und RX Interrupt einschalten
  /* Set frame format: 8data, 2stop bit */
  UCSRC = ( 1 << USBS ) | ( 3 << UCSZ0 );
}

Wieso leuchtet plötzlich die LED auf / hängt sich der tiny auf? Und 
warum mag er meine Eingaben nicht verarbeiten? :(  Ich hoffe ihr könnt 
mir helfen!


Danke schonmal!

[Stefan E. (sternst)]

Michael Niewöhner schrieb:
> Ich habe folgendes Problem mit dem Attiny2313 / 4313.

ISR(USART_RXC_vect)

Und wo hast du diesen Namen her?
Merke: Den Vektornamen errät man nicht und man kopiert ihn auch nicht 
einfach von einem anderen Code der für einen anderen µC geschrieben 
wurde. Stattdessen informiert man sich, wie dieser Name für genau deinen 
µC lautet.

PS: Und außerdem ignoriert man die diesbezügliche Compiler-Warnung 
nicht.

[Michael (c0d3z3r0)]

Dank für die flotte Antwort!

Naja, erraten hab ich den Namen sicher nicht... und der compiler spricht 
folgendes:

uart.h:23:1: warning: type defaults to 'int' in declaration of 'ISR'
uart.c:40:1: warning: type of 'UART0RX_vect' defaults to 'int'

Das Datenblatt hat gesprochen... "USART0_RXC" ist wohl richtig... Geht 
aber auch nicht, gleiches Problem :(

[KeyMusic (Gast)]

Hallo Michael,

was macht denn die Funktion uart_puts?!
Puffert sie die zu sendenden Zeichen oder blockiert sie? Im zweiten Fall 
wäre es sehr "gefährlich" sie aus einer InterruptServiceRoutine 
aufzurufen...

Gruß
KeyMusic

[Michael (c0d3z3r0)]

Blockieren?  Sie puffert den zu sendenden String und arbeiten diesen 
zeichenweise mit putz ab.

Auch wenn ich statt der Ausgabe die LED toggle, hängt sich der µC auf..

ISR(USART0_RXC)
{
  //uart_puts("do");
  PORTD ^= (1<<PD6);
}

[Stefan E. (sternst)]

Michael Niewöhner schrieb:
> und der compiler spricht
> folgendes:

Dann hast du außerdem auch noch ein

#include <avr/interrupt.h>

vergessen.

Michael Niewöhner schrieb:
> Das Datenblatt hat gesprochen... "USART0_RXC" ist wohl richtig...

Irgendwelche Namen in irgendwelchen Assembler-Beispiel-Codes sind 
irrelevant.

http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

[Michael (c0d3z3r0)]

Stefan Ernst schrieb:
> Dann hast du außerdem auch noch ein#include <avr/interrupt.h>vergessen.

Nein, ist bereits drin.

[Stefan E. (sternst)]

Michael Niewöhner schrieb:
>> Dann hast du außerdem auch noch ein#include <avr/interrupt.h>vergessen.
>
> Nein, ist bereits drin.

Aber garantiert nicht an der Stelle der ersten Fehlermeldung.

uart.h:23:1: warning: type defaults to 'int' in declaration of 'ISR'

Was hat das "ISR" überhaupt in einer deiner Header-Dateien zu suchen?

[Michael (c0d3z3r0)]

Okay, der Name ist laut Liste "USART_RX_vect". Geht auch nicht.

Stefan Ernst schrieb:
> uart.h:23:1: warning: type defaults to 'int' in declaration of 'ISR'Was hat das 
"ISR" überhaupt in einer deiner Header-Dateien zu suchen?

Gute Frage.... hab ich rausgenommen. Keine Änderung...

[Stefan E. (sternst)]

Michael Niewöhner schrieb:
> Keine Änderung...

Dann poste den kompletten aktuellen Code, und alle Compiler-Meldungen 
dazu.

[Michael (c0d3z3r0)]

Danke für eure Hilfe!  Bitte nicht gleich schlagen :S indeckunggeh


main.c

#include <avr/io.h>
#include "functions.h"
#include <util/delay.h>
#include "uart.h"
#include <avr/interrupt.h> 

void init(void)
{  
  // Eingänge
  DDRB &= ~( (1<<DDB0) ); // Taster 1
  PORTB |= (1 << PB0); // Pull-Up ein
  
  //Ausgänge
  DDRD  |= (1<<DDD6); // LED

  //UART initialisieren
  uart_init();

  //LED EIN
  PORTD |= (1<<PD6);
  
  //Interrupts ein
  sei();
  uart_puts("INIT\n\r");
}

int main()
{
  init();
  uint16_t i;
  char s[10];
  while(1)
  {
    // Taster 1
    if (debounce(&PINB, PB0))
    {
      PORTD ^= (1<<PD6);
      uart_puts("TEST\n\r");
    }
  }
  
  return 0;
}

functions.c

#include <avr/io.h>
#include "functions.h"
#include <util/delay.h>
  
uint8_t debounce(volatile uint8_t *port, uint8_t pin)
{
    if  (!(*port & (1 << pin)))
    {
        _delay_ms(30);
        if (  (*port & (1 << pin)) )
    {
      _delay_ms(30);
      return 1;
    }
    }
    return 0; 
}

functions.h

#ifndef F_CPU
  #define F_CPU 8000000UL
#endif

uint8_t debounce(volatile uint8_t *port, uint8_t pin);

uart.c

#include <avr/io.h>
#include "uart.h"
#include <avr/interrupt.h>
 
volatile uint8_t uart_str_complete = 0;
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";

void uart_init()
{
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
  UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);  // UART RX, TX und RX Interrupt einschalten
  UCSRC = ( 1 << USBS ) | ( 3 << UCSZ0 );
  //UCSRC = (1<<UCSZ1)|(1<<UCSZ0);
  
}

int uart_putc(unsigned char c)
{
    while (!(UCSRA & (1<<UDRE)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR = c;                      /* sende Zeichen */
    return 0;
}
 
void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
    }
}


ISR(USART_RX_vect)
{
  PORTD ^= (1<<PD6);
}

uart.h

#ifndef F_CPU
  #define F_CPU 8000000UL
#endif

#define BAUD 9600UL      // Baudrate
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
 
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif

#define UART_MAXSTRLEN 10

int uart_putc(unsigned char c);
void uart_puts (char *s);
void uart_init();
unsigned char USART_Receive( void );

extern volatile uint8_t uart_str_complete;
extern volatile uint8_t uart_str_count;
extern volatile char uart_string[UART_MAXSTRLEN + 1];

[Michael (c0d3z3r0)]

Compiler:

avr-gcc (GCC) 4.5.1
Copyright (C) 2010 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.


Compiling: main.c
avr-gcc -c -mmcu=attiny4313 -I. -gdwarf-2   -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=main.lst  -std=gnu99 -DF_OSC= -funsigned-char -funsigned-bitfields -MD -MP -MF .dep/main.o.d main.c -o main.o 
In file included from main.c:4:0:
uart.h:20:1: warning: function declaration isn't a prototype
main.c:27:5: warning: function declaration isn't a prototype
main.c: In function 'main':
main.c:50:4: warning: "/*" within comment
main.c:31:7: warning: unused variable 's'
main.c:30:11: warning: unused variable 'i'

Compiling: functions.c
avr-gcc -c -mmcu=attiny4313 -I. -gdwarf-2   -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=functions.lst  -std=gnu99 -DF_OSC= -funsigned-char -funsigned-bitfields -MD -MP -MF .dep/functions.o.d functions.c -o functions.o 

Compiling: uart.c
avr-gcc -c -mmcu=attiny4313 -I. -gdwarf-2   -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=uart.lst  -std=gnu99 -DF_OSC= -funsigned-char -funsigned-bitfields -MD -MP -MF .dep/uart.o.d uart.c -o uart.o 
In file included from uart.c:2:0:
uart.h:20:1: warning: function declaration isn't a prototype
uart.c:9:6: warning: function declaration isn't a prototype

Linking: main.elf
avr-gcc -mmcu=attiny4313 -I. -gdwarf-2   -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=main.o  -std=gnu99 -DF_OSC= -funsigned-char -funsigned-bitfields -MD -MP -MF .dep/main.elf.d main.o functions.o uart.o   --output main.elf -Wl,-Map=main.map,--cref    -lm

Creating load file for Flash: main.hex
avr-objcopy -O ihex -R .eeprom main.elf main.hex

Creating load file for EEPROM: main.eep
avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" \
  --change-section-lma .eeprom=0 -O ihex main.elf main.eep
avr-objcopy: --change-section-lma .eeprom=0x00000000 never used

Creating Extended Listing: main.lss
avr-objdump -h -S main.elf > main.lss

Creating Symbol Table: main.sym
avr-nm -n main.elf > main.sym

Size after:
AVR Memory Usage
----------------
Device: attiny4313

Program:     346 bytes (8.4% Full)
(.text + .data + .bootloader)

Data:         28 bytes (10.9% Full)
(.data + .bss + .noinit)



Errors: none
-------- end --------

[MWS (Gast)]

Du musst UDR auslesen, sonst hört der Interrupt nicht auf zu triggern.

[Stefan E. (sternst)]

  PORTD ^= (1<<PD6);

Ändere das wieder in das ursprüngliche, und du wirst merken, dass der 
Interrupt vermutlich sehr wohl geht (nur nicht ganz so, wie von dir 
erwartet).

Als nächstes liest du dir dann im Datenblatt die Beschreibung des 
RXC-Flags nochmal durch, und überlegst, was wohl die Ursache dieses "nur 
nicht ganz so, wie von dir erwartet" ist.

Edit:
@MWS
Spielverderber ;-)

[MWS (Gast)]

Den Lerneffekt wird der TE auch so haben ;D

[Michael (c0d3z3r0)]

MWS schrieb:
> Du musst UDR auslesen, sonst hört der Interrupt nicht auf zu triggern.

Ja, jetzt klappts :D  Vielen Dank euch!

[Michael (c0d3z3r0)]

MWS schrieb:
> Den Lerneffekt wird der TE auch so haben ;D

Jep :)