Hardware Handshake mit AVR

[Handshaker (Gast)]

Hallo Leute!

Ich habe vor einen Hardware Handshake mit einer UART Schnittstelle eines 
AVR zu realisieren.
Als Handshake-Leitungen nehm ich CTS und RTS.
Hardware existiert schon alles.
Falls Computer zum Empfang bereit ist setzt er RTS und falls AVR bereit 
ist setzt er CTS.
Falls nun beim AVR der Eingangsbuffer voll ist soll CTS abfallen.

Als Ansteuerprogramm der UART-Schnittstelle verwende ich folgendes 
Programm:

http://www.rn-wissen.de/index.php/UART_mit_avr-gcc

und davon die Interrupt-Variante.
Ich hätte nun die Abfrage der RTS-Leitung in diese

ISR (USART_UDRE_vect)

Routine und in dieser

ISR (USART_RXC_vect)

würde ich nun den Füllstand des Eingangsbuffers abfragen.

Aber wo soll ich nun den Ausgang für CTS setzen?
In einer ISR soll man ja sowas nicht.
Oder wie würdet ihr sowas am besten lösen?

Schonmal Danke im Vorraus!

[Handshaker (Gast)]

Habs nun so wie beschrieben programmiert.
geht so.
Es bleibt nur das Problem mit dem setzen von CTS (Ausgangspin) in der 
ISR.
Ich hab auch schon überlegt es mit Flags zu lösen.
Aber dann bräuchte ich ja auch wieder eine Funktion die das Flag pollt.

Weiß denn keiner wie man sowas am besten löst?

Hier noch das Programm:

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

#define RTS_PORT PORTD
#define RTS_DDR DDRD
#define RTS_PIN PIND
#define RTS_P PD2

#define CTS_PORT PORTD
#define CTS_DDR DDRD
#define CTS_P PD4

#define UART_BAUD_RATE 19200L
#define UART_BAUD_CALC(UART_BAUD_RATE,F_CPU) ((F_CPU)/((UART_BAUD_RATE)*16L)-1)

#define BUFSIZE_IN 0x40         // Pufferlänge für Empfang
static uint8_t inbuf[BUFSIZE_IN];
static fifo_t infifo;

#define BUFSIZE_OUT 0x40        // Pufferlänge für Senden
static uint8_t outbuf[BUFSIZE_OUT];
static fifo_t outfifo;

// UART initialisieren
void uart_init (void) {
    
  RTS_DDR &= ~(1<<RTS_P);       // RTS ist Eingang
  CTS_DDR |= (1<<CTS_P);        // CTS ist Ausgang
  
  // TX (senden), RX (empfangen) und Interruptauslösung für eingehende Daten einschalten
  UCSRB |= (1<<TXEN) | (1<<RXEN) | (1<<RXCIE);
  
  // Asynchron, 8N1
  UCSRC |= (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1);
  
  uint8_t sreg = SREG;
  cli();
  
  // Baudrate auswählen
  UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_CPU)>>8);
  UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_CPU);
  
  // enfernen evtl. vorhandener ungültiger Werte
  do {
      UDR;
  } while(UCSRA & (1<<RXC));
  
  // Rücksetzen von Receive und Transmit Complete-Flags
  UCSRA = (1<<RXC) | (1<<TXC);
  
  SREG = sreg;
  
  // FIFOs für Ein- und Ausgabe initialisieren
  fifo_init (&infifo, inbuf, BUFSIZE_IN);
  fifo_init (&outfifo, outbuf, BUFSIZE_OUT);
}

// Empfangene Zeichen werden in Eingabe-FIFO gespeichert und warten dort
ISR (USART_RXC_vect) {

    fifo_put (&infifo, UDR);
  if(infifo.count >= BUFSIZE_IN) {
      CTS_PORT |= (1<<CTS_P);
  }
}

// Ein Zeichen aus Ausgabe-FIFO lesen und ausgeben
// Ist das Zeichen fertig ausgegeben, wird ein neuer IRQ getriggert
// Ist der FIFO leer, deaktiviert die ISR ihren eigenen IRQ
ISR (USART_UDRE_vect) {

    if((outfifo.count > 0) && (!(RTS_PIN & (1<<RTS_P))))
      UDR = fifo_get_nowait (&outfifo);
  else
      UCSRB &= ~(1<<UDRIE);
}

// Senden eines Zeichens
int uart_putc (const uint8_t c) {
    
    int ret = fifo_put (&outfifo, c);
  UCSRB |= (1<<UDRIE);
  return ret;
}

// Senden eines Strings
void uart_puts (const char *s) {

    while (*s) {             // so lange *s != NULL
        uart_putc(*s);
        s++;
    }
}

// liest ein Zeichen aus dem FIFO ohne zu warten
// gibt 0 zurück falls FIFO leer ist
uint8_t uart_getc_nowait (void) {
    
  uint8_t data = (uint8_t) fifo_get_nowait (&infifo);
  CTS_PORT &= ~(1<<CTS_P);
  return data;
}

// liest ein Zeichen aus dem FIFO
// wartet falls FIFO leer ist
uint8_t uart_getc_wait (void) {

    uint8_t data = (uint8_t) fifo_get_wait (&infifo);
  CTS_PORT &= ~(1<<CTS_P);
  return data;
}

[Benjamin U. (utzus)]

Hi,

warum hast du Bedenken ein Bit in der ISR zu setzen? Mir fallen grad 
keine Gründe dagegen ein. Geht schnell, blockiert nicht.

Grüße

[Handshaker (Gast)]

Oh da hast du natürlich recht.
Macht ja erst evtl. Probleme wenn mehr Bits gesetzt werden.

[Benjamin U. (utzus)]

Hmm, das ist vermutlich Ansichtssache. Die ISR soll halt so kurz wie 
möglich sein und so lang wie nötig. Was muss das muss :D
Aber so die ein oder andere LED kann man in einer ISR schon mal togglen.

Schönen Abend,

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Die Kürze ist eher darauf bezogen, dass dort keine Warteschleifen, waits 
und größere Berechnungen stattfinden sollten (Stringoperationen, 
division, floats).
Bissel Bitwackeln ist kein Problem.
Kannst sogar alle Ports umschalten und das juckt nicht weiter.

[Handshaker (Gast)]

Ein Problem ist mir bei obigem Code aufgefallen.
Falls RTS vom Computer deaktiviert wird und nach einer Zeit wieder 
aktiviert wird werden die ganzen Daten aus dem Ausgangsbuffer erst 
gesendet, wenn ein weiteres Zeichen gesendet wird (es muss erst ein 
neuer ISR (USART_UDRE_vect) getriggert werden).

Weiß da jemand wie man sowas am besten löst?
Besten Dank schonmal!

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Neuere AVR haben nen PinChange IRQ (PCINT) an jedem Pin ;)
Ansonsten musste den RTS Pin periodisch pollen oder an den INTx 
anschließen.

[Karl H. (kbuchegg)]

Noch was

  if(infifo.count >= BUFSIZE_IN) {

das könnte unter Umständen ein bischen zu spät sein. Du musst damit 
rechnen, dass nach dem Setzen von CTS noch ein bischen was reinkommen 
kann, je nachdem wie auf der Gegenstelle die konkrete Situation ist. 
Dein AVR hat ja zb auch einen 1 Byte Hardware-Buffer, wenn du ein 
Zeichen wegschickst. D.h. selbst wenn du vor jedem Raussenden immer das 
RTS überprüfst, kann es sein, dass die Gegenstelle nach dem Setzen der 
Leitung noch 1 Zeichen bekommt. An deiner Empfangsseite ist es nicht 
anders. Wenn du deine CTS auf 'Halt' ziehst, kann es passieren, dass 
noch was reinkommt. Das solltest du berücksichtigen und CTS nicht erst 
dann auf 'Halt' stellen, wenn deine FIFO schon auf Knirsch voll ist.

[Handshaker (Gast)]

Ok
Dann werd ichs wohl mit nem externen INT machen.
Der ATmega32 besitzt ja soweit ich laut Datenblatt seh (noch) keinen 
PinChange IRQ.

[Handshaker (Gast)]

Karl Heinz Buchegger schrieb:
> Noch was
>
>   if(infifo.count >= BUFSIZE_IN) {
>
> das könnte unter Umständen ein bischen zu spät sein. Du musst damit
> rechnen, dass nach dem Setzen von CTS noch ein bischen was reinkommen
> kann, je nachdem wie auf der Gegenstelle die konkrete Situation ist.
> Dein AVR hat ja zb auch einen 1 Byte Hardware-Buffer, wenn du ein
> Zeichen wegschickst. D.h. selbst wenn du vor jedem Raussenden immer das
> RTS überprüfst, kann es sein, dass die Gegenstelle nach dem Setzen der
> Leitung noch 1 Zeichen bekommt. An deiner Empfangsseite ist es nicht
> anders. Wenn du deine CTS auf 'Halt' ziehst, kann es passieren, dass
> noch was reinkommt. Das solltest du berücksichtigen und CTS nicht erst
> dann auf 'Halt' stellen, wenn deine FIFO schon auf Knirsch voll ist.

Ok werde ich berücksichtigen!

Danke für den Tipp