ATtiny13: UART Problem mit External-Interrupt

[binaer f. (binaerfreund)]

Hallo!

Das Thema war zwar schon sehr oft Inhalt, aber ich komme mit meinem 
Problem einfach nicht weiter. Da ich hier schon sehr viel hilfreiche 
Tipps sammeln konnte, hoffe ich, dass mir vielleicht jemand helfen kann.

Ich versuche gerade, mich ein Bisschen mit einem ATtiny13 zu 
beschäftigen und diesem die grundlegendsten Funktionen einer 
Software-UART zu programmieren, damit ich diesem zukünftig Befehle 
senden kann, um z.B. eine AD-Wandlung zu starten. Das Ergebnis kann dann 
am Rechner weiterverarbeitet werden.

Der u-Controller ist über den internen Oszillator auf 9,6 MHz, ohne 
Vorverteiler, getaktet.

Das Programm ist aktuell noch sehr simpel und soll auf PORTB-Pin 2 ein 
Byte empfangen und dieses auf PORTB-Pin 1 wieder ausgeben.
Einfach, um UART, den u-Controller und Interrupts kennenzulernen.

Das Zeichen zum Testen sende ich mit Putty.
Hier ist das "Lokale Echo", "Local Line Editing" und die Flusskontrolle 
abgeschaltet, damit wirklich nur das eingegebene Zeichen gesendet und 
das ankommende Zeichen ausgegeben wird (ohne Carriage Return und Line 
Feed).

Soweit funktioniert das auch. Allerdings scheint mir, als wird die 
Interrupt-Routine zweimal ausgeführt, da ich zwei Zeichen zurück 
bekomme.
Einmal das zum u-Controller gesendete Zeichen "a" und einmal 255_DEC, 
also LOW auf RX.

Neben dem Quellcode habe ich einen Screenshot vom "Messergebnis" mit dem 
OpenLogicSniffer angefügt.
Der Interrupt sollte, wenn ich mich im Datenblatt nicht verlesen habe, 
bei steigender Flanke an PORTB-Pin 2 ausgelöst werden und seine Routine 
abarbeiten....wie gesagt, passiert dies leider zweimal.
Auf PIN 2 gibt es nach dem Einlesen eines Bytes keine steigende Flanke 
mehr. Normalerweise sollte die Interruptroutine in diesem Beispiel kein 
zweites Mal aufgerufen werden.
Ich gehe davon aus, dass während die ISR abgearbeitet wird, kein 
weiteres Interrupt-Ereignis eingereiht wird. Um dies zu prüfen, habe ich 
die Funktionen cli() und sei() am Anfang und Ende von ISR() aufgerufen, 
was aber zum selben Ergebnis geführt hatte...

Hat vielleicht jemand von euch eine Idee, wo das Problem liegt? 
Vielleicht habe ich etwas übersehen, missverstanden oder einen Fehler im 
Code.


main.c

#include <avr/io.h
#include <avr/iotn13.h>
#include <avr/interrupt.h>
#include "uart.h"

unsigned char c;


ISR( PCINT0_vect );              // Interrupt Service Routine      External Interrupt Request



int main()
{
  DDRB |= ( 1 << PB1 );

  PCMSK |= (1<<PCINT2);          // PIN Change Mask Register        External Interrupt at PINB2
  MCUCR |= (1<<ISC01) | (1<<ISC00);    // MCU General Control Register      Rising Edge LOW to HIGH (RS232 Start-Bit)
  GIMSK |= (1<<PCIE);            // General Interrupt MaSK Register      External Interrupt
  sei();                  // Enable Interrupt


  while(1)                // Main Routine
  {
    // Singe ein Lied
  }

  return 0;
}


ISR( PCINT0_vect )
{
  c = _uart_receive_byte();
  _uart_send_byte( c );
}

uart.h

#ifndef _UART_H_
#define _UART_H_

#include <avr/io.h>
#include <avr/iotn13.h>
#include <util/delay.h>

// Prototypen:

int _uart_send_byte(unsigned char c);
unsigned char _uart_receive_byte();

#endif

uart.c

#include "uart.h"

//Funktionen:

int _uart_send_byte(unsigned char c )
{
  uint8_t i = 0;

  PORTB |= ( 1 << PB1 );         //START Bit  (Set PortPIN HIGH)
  _delay_us( 104 );

  for( i = 0; i < 8; i ++)      // Choose every bit from char LSB to MSB
  {
    if( ((c >> i ) & 0x01) )    // Check if Bit is 1
    {
      PORTB &= ~(1<<PB1);      // Bit is 1, Clear Bit (Set PortPIN LOW)
    }
    else
    {
      PORTB |= (1<<PB1);      // Bit is 0, Set Bit (Set PortPIN HIGH)
    }
    _delay_us( 104 );
  }

  PORTB &= ~(1<<PB1);          // STOP Bit (Set PortPIN LOW)
  _delay_us( 104 );

  return 0;
}

unsigned char _uart_receive_byte()
{
  unsigned char c=0x00;
  uint8_t i = 0;

  _delay_us( 156 );          // Wait 1,5 Bits after rising edge of START-Bit

  for( i = 0; i < 8; i++ )
  {
    if( ((PINB >> PINB2) & 1) )
    {
      c &= ~(1<<i);
    }
    else
    {
      c |= (1<<i);
    }
    _delay_us( 104 );
  }

  _delay_us( 104 );          // STOP Bit

  return c;
}

[Hannes L. (hannes)]

binaer freund schrieb:
> Ich gehe davon aus, dass während die ISR abgearbeitet wird, kein
> weiteres Interrupt-Ereignis eingereiht wird.

Das ist aber nicht (ganz) der Fall. Die nächste entsprechende Flanke 
setzt das Interrupt-Pending-Flag erneut, so dass nach Beenden der ISR 
diese erneut aufgerufen wird. Abhilfe schafft das Löschen des 
Interrupt-Pending-Flags vor Verlassen der ISR, also das Schreiben einer 
Eins in das entsprechende Bit des Registers GIFR.

...

[binaer f. (binaerfreund)]

Vielen Dank für die schnelle Hilfe!

Jetzt hat sich für mich der Sinn des GIF-Registers auch erschlossen.
Damit funktioniert es wunderbar und ich habe wieder etwas dazugelernt.

Danke!