Software-UART mit avr-gcc - Versionsgeschichte

Phaiax am 13. August 2009 um 20:36 Uhr

2009-08-13T20:36:52Z

Phaiax am 13. August 2009 um 20:36 Uhr

2009-08-13T20:36:29Z

Phaiax am 13. August 2009 um 20:36 Uhr

2009-08-13T20:36:03Z

SprinterSB_alt: /* Transmitter */

2007-02-12T09:55:25Z

‎Transmitter

SprinterSB_alt: /* Initialisierung */

2007-02-12T09:53:30Z

‎Initialisierung

SprinterSB_alt: /* Dateikopf */

2007-02-12T09:47:54Z

‎Dateikopf

SprinterSB_alt: /* Dateikopf */ infifo

2006-06-05T20:24:50Z

‎Dateikopf: infifo

SprinterSB_alt: /* Dateikopf */

2006-03-03T10:56:49Z

‎Dateikopf

SprinterSB_alt: /* Einführung */

2006-02-22T09:42:58Z

‎Einführung

SprinterSB_alt: /* Siehe auch */

2006-02-13T17:18:50Z

‎Siehe auch

@@ Zeile 113: / Zeile 113: @@
       SREG = sreg;
-−
   #ifdef _FIFO_H_
      fifo_init (&infifo,   inbuf, INBUF_SIZE);
   #endif // _FIFO_H_
-−
+  }

@@ Zeile 114: / Zeile 114: @@
       SREG = sreg;
-#ifdef _FIFO_H_
+ #ifdef _FIFO_H_
      fifo_init (&infifo,   inbuf, INBUF_SIZE);
-#endif // _FIFO_H_
+ #endif // _FIFO_H_
+  }

← Nächstältere Version		Version vom 13. August 2009, 20:36 Uhr
Zeile 113:		Zeile 113:

	SREG = sreg;		SREG = sreg;
		+
		+	#ifdef _FIFO_H_
		+	fifo_init (&infifo, inbuf, INBUF_SIZE);
		+	#endif // _FIFO_H_
		+
	}		}

@@ Zeile 117: / Zeile 117: @@
 === Transmitter ===
 Das Senden ist am einfachsten: Zuerst wird gewartet, bis eine evtl. laufende Sendung abgeschlossen ist. Dann wird der Ausgabe-Frame zusammengebaut (1&nbsp;Startbit, 8&nbsp;Datenbits, 1&nbsp;Stopbit und 1&nbsp;Bit als interne Endekennung). Dann wird OutputCompare1A-Interrupt aktiviert das entsprechende Interrupt-Flag zurückgesetzt, damit das erste Bit nicht zu kurz wird (wenn das Flag gesetzt wäre, würde direkt nach dem <tt>sei()</tt> ein Interrupt auftreten. Ein Transmit ist fertig, wenn <tt>outframe</tt> gleich 0 ist. Das Auslesen von <tt>outframe</tt> muss unter Interrupt-Deaktivierung geschehen. <tt>uart_putc</tt> geht davon aus, daß Interrupts global aktiviert sind (ansonsten hängt es sich auf bzw. es wird nicht ausgegeben).
-<pre>
+ #ifdef SUART_TXD
-#ifdef SUART_TXD
+ void uart_putc (const char c)
 void uart_putc (const char c)
+     do
-    do
+         sei(); nop(); cli(); {{ccomment|yield(); }}
-        sei(); nop(); cli(); // yield();
+     } while (outframe);
-    } while (outframe);
+     {{ccomment|frame &#61; *.P.7.6.5.4.3.2.1.0.S   S&#61;Start(0), P&#61;Stop(1), *&#61;Endemarke(1) }}
-    // frame = *.P.7.6.5.4.3.2.1.0.S   S=Start(0), P=Stop(1), *=Endemarke(1)
+     outframe = (3 &lt;&lt; 9) | (((uint8_t) c) &lt;&lt; 1);
-    outframe = (3 << 9) | (((uint8_t) c) << 1);
+     TIMSK |= (1 &lt;&lt; OCIE1A);
-    TIMSK |= (1 << OCIE1A);
+     TIFR   = (1 &lt;&lt; OCF1A);
-    TIFR   = (1 << OCF1A);
+     sei();
-    sei();
+ #endif {{ccomment|SUART_TXD }}
-#endif // SUART_TXD
-</pre>
 Danach kommt es zu OC1A-Interrupts. Für jeden [[IRQ]] wird ein Bit ausgegeben. Im letzten Interrupt wird das Senden eingestellt und die [[ISR]] deaktiviert ihren eigenen IRQ.

@@ Zeile 74: / Zeile 74: @@
 Hier wird der Software-UART initialisiert. Die Initialisierung ist gegen Interrupts gesperrt. Das Modus- und OCR1A-Register von Timer1 werden so initialisiert, daß eine Zeitbasis für den UART entsteht.
-    // PoutputCompare für gewünschte Timer1 Frequenz
+ {{ccomment|Initialisierung für einen ATmega8 }}
-    OCR1A = (uint16_t) ((uint32_t) F_CPU/BAUDRATE);
+ {{ccomment|Für andere AVR-Derivate sieht dies vermutlich anders aus: }}
+ {{ccomment|Registernamen ändern sich (zB TIMSK0 anstatt TIMSK, etc). }}
-#ifdef SUART_RXD
+ void uart_init()
-    SUART_RXD_DDR  &= ~(1 << SUART_RXD_BIT);
-    SUART_RXD_PORT |=  (1 << SUART_RXD_BIT);
+     uint8_t tifr = 0;
-    TIMSK |= (1 << TICIE1);
+     uint8_t sreg = SREG;
-    tifr |= (1 << ICF1) | (1 << OCF1B);
+     cli();
-#else
-    TIMSK &= ~(1 << TICIE1);
+     {{ccomment|Mode #4 für Timer1 }}
-#endif // SUART_RXD
+     {{ccomment|und volle MCU clock }}
+     {{ccomment|IC Noise Cancel }}
-#ifdef SUART_TXD
+     {{ccomment|IC on Falling Edge }}
-    tifr |= (1 << OCF1A);
+     TCCR1A = 0;
-    SUART_TXD_PORT |= (1 << SUART_TXD_BIT);
+     TCCR1B = (1 &lt;&lt; WGM12) | (1 &lt;&lt; CS10) | (0 &lt;&lt; ICES1) | (1 &lt;&lt; ICNC1);
-    SUART_TXD_DDR  |= (1 << SUART_TXD_BIT);
-    outframe = 0;
+     {{ccomment|OutputCompare für gewünschte Timer1 Frequenz }}
-#endif // SUART_TXD
+     OCR1A = (uint16_t) ((uint32_t) F_CPU/BAUDRATE);
-−
-    TIFR = tifr;
+ #ifdef SUART_RXD
+     SUART_RXD_DDR  &= ~(1 &lt;&lt; SUART_RXD_BIT);
-    SREG = sreg;
+     SUART_RXD_PORT |=  (1 &lt;&lt; SUART_RXD_BIT);
+     TIMSK |= (1 &lt;&lt; TICIE1);
-</pre>
+     tifr  |= (1 &lt;&lt; ICF1) | (1 &lt;&lt; OCF1B);
 === Transmitter ===

@@ Zeile 30: / Zeile 30: @@
 ;FIFO aktivieren: Um die FIFO zu aktivieren, wird einfach der Header <tt>fifo.h</tt> includet und dadurch die entsprechende Codeerzeugung veranlasst.
 :;<tt>#define INBUF_SIZE ...</tt>: Die Größe des Eingabe-Puffers für die Receiver-FIFO
-// Einfach einkommentieren, falls FIFO verwendet werden soll
+ #include &lt;avr/io.h>
-// #include "fifo.h"
+ #include &lt;avr/interrupt.h>
-−
-#define BAUDRATE 38400
+ #ifndef SIGNAL
+ #include &lt;avr/signal.h>
-#define nop() __asm volatile ("nop")
+ #endif {{ccomment|SIGNAL }}
-−
-#ifdef SUART_TXD
+ #include "uart.h"
-    #define SUART_TXD_PORT PORTB
-    #define SUART_TXD_DDR  DDRB
+ {{ccomment|Folgende Zeile einkommentieren, falls FIFO verwendet werden soll }}
-    #define SUART_TXD_BIT  PB1
+ {{ccomment|#include "fifo.h" }}
-    static volatile uint16_t outframe;
-#endif // SUART_TXD
+ #define BAUDRATE 38400
-−
-#ifdef SUART_RXD
+ #define nop() __asm volatile ("nop")
-    #define SUART_RXD_PORT PORTB
-    #define SUART_RXD_PIN  PINB
+ #ifdef SUART_TXD
-    #define SUART_RXD_DDR  DDRB
+     #define SUART_TXD_PORT PORTB
-    #define SUART_RXD_BIT  PB0
+     #define SUART_TXD_DDR  DDRB
-    static volatile uint16_t inframe;
+     #define SUART_TXD_BIT  PB1
-    static volatile uint8_t inbits, received;
+     static volatile uint16_t outframe;
+ #endif {{ccomment|SUART_TXD }}
-#   ifdef _FIFO_H_
-    #define INBUF_SIZE 4
+ #ifdef SUART_RXD
-    static uint8_t inbuf[INBUF_SIZE];
+     #define SUART_RXD_PORT PORTB
-    fifo_t infifo;
+     #define SUART_RXD_PIN  PINB
-#   else // _FIFO_H_
+     #define SUART_RXD_DDR  DDRB
-    static volatile uint8_t indata;
+     #define SUART_RXD_BIT  PB0
-#   endif // _FIFO_H_
+     static volatile uint16_t inframe;
+     static volatile uint8_t inbits, received;
-#endif // SUART_RXD
-</pre>
+     #ifdef _FIFO_H_
 === Initialisierung ===

@@ Zeile 61: / Zeile 61: @@
      #define INBUF_SIZE 4
      static uint8_t inbuf[INBUF_SIZE];
-     fifo_t infifo =
+     fifo_t infifo;
-−
-        .count = 0,
-        .pwrite = inbuf,
-        .pread  = inbuf,
-        .read2end  = INBUF_SIZE,
-        .write2end = INBUF_SIZE,
-        .size      = INBUF_SIZE
-    };
 #   else // _FIFO_H_
      static volatile uint8_t indata;

@@ Zeile 8: / Zeile 8: @@
 Jeder diese Herangehensweisen hat ihre Vor- und Nachteile. Welcher Weg der bessere ist, kann nur im Gesamtzusammenhang des Programmes entschieden werden.
-Wie auch immer; Ziel der Software ist es, UART-Datenframes senden und empfangen zu können. Bei Inaktivität (idle) ist die Signalleitung auf 1 (High). Jeder Frame beginnt mit einem Startbit (S), das 0 ist. Danach folgen die 8 Datenbits und schliesslich ein Stop-Bit (P), das 1 ist. Danach ist die Leitung wieder inaktiv oder es folgen weitere Frames.
+Wie auch immer; Ziel der Software ist es, UART-Datenframes senden und empfangen zu können. Bei Inaktivität (idle) ist die Signalleitung auf 1 (High). Jeder Frame beginnt mit einem Startbit (S), das 0 ist. Danach folgen die 8 Datenbits und schliesslich ein Stop-Bit (P), das immer 1 ist. Danach ist die Leitung wieder inaktiv oder es folgen weitere Frames.
 <center>
 [[Bild:UART-Frame.png|UART-Frame]]
@@ Zeile 15: / Zeile 15: @@
 Läuft der AVR mit einer Taktrate von <tt>F_CPU</tt> und die Übertragung mit der Baudrate BAUDRATE, dann dauert ein Bit
 :<math>Z_\mathrm{bit} = \frac\mathrm{F_{CPU}}\mathrm{BAUDRATE}</math>
-Zyklen. Bei 16MHZ und 38400 Baud dauert ein Bit also rund 417 Zyklen, bei 1MHz und 9600 hat man nur rund 104 Zyklen Zeit.
+Zyklen. Bei 16MHz und 38400 Baud dauert ein Bit also rund 417 Zyklen, bei 1MHz und 9600 hat man nur rund 104 Zyklen Zeit.
 == Mit Verwendung von Timer1 ==

@@ Zeile 294: / Zeile 294: @@
 *[[UART]]
 *[[RS232]]
 *[[UART mit avr-gcc]]
 *[[avr-gcc]]