RN-Wissen.de - Benutzerbeiträge [de]

V-USB: Ein Firmware USB-Treiber für AVR

2013-09-25T16:36:26Z

Pit49:

Mit [http://www.obdev.at/products/vusb/index.html V-USB] von Objective Development ist es ohne weitere Hardware möglich, mit einem AVR Mikrocontroller ein USB-Gerät aufzubauen.

== Hardware Voraussetzungen des AVRs ==
=== Spannungspegel-Problem ===
Da der AVR mit anderen Spannungen als die des USB-Standards arbeitet, müssen diese Angepasst werden. Der Computer und der AVR-Mikrocontroller haben beide bestimmte Anforderungen an die Spannung für einen High- bzw. Low-Pegel. Da wir die Computerseite nicht verändern können, müssen die Anpassungen am AVR stattfinden. Vom PC wird ein Low-Pegel als 0V, ein High-Pegel als 3,3V übertragen. Jedoch ist dies das kleinere Problem, da die AVR-Mikrocontroller selbst bei 5V diesen Pegel sicher als High erkennen.
Die andere Richtung ist ein größeres Problem. Der Computer erwartet als Low-Pegel eine Spannung von 0V - 0,8V und 2V - 3,6V als High. Um diese Voraussetzungen zu erfüllen, muss entweder der AVR mit einer Spannung von 2V - 3,6V betreiben werden oder die Pegel müssen an D+ und D- des AVRs angepasst werden.

==== Lösung A: Verringern der Betriebspannung des AVRs ====
Für diese Lösung wird die Betriebsspannung des AVRs auf 3,3V - 3,6V herunter gesetzt.
Dies ist mit einem 3,3V-Spannungsregler (z.B. LE33CZ, LT1761ES5-3.3) möglich.
[[Bild:voltage-regulator.gif|thumb|Spannungsanpassung mit einem Spannungsregler]]

'''Vorteile'''
* Saubere Lösung. Schnelle Übergänge auf D+ und D-
* Gute Störfestigkeit am Signaleingang
* Stromverbrauch des µC ist bei 3,3 V geringer als bei 5 V

'''Nachteile'''
* 3,3V-Spannungsregler sind oft teuer und schwer zu beschaffen
* Viele ältere AVRs funktionieren bei 3,3 V nicht sicher beim geforderten Takt (12 MHz). Auch bei neueren sind bei 3.3 V kaum mehr als 13 MHz garantiert.
* Ruhestrom für den Spannungsregler (Forderung nach sparsamem Regler)

Ebenso ist es möglich, die Spannung mit Gleichrichterdioden zu reduzieren.
Hierfür werden einfach zwei oder drei Gleichrichterdioden in Reihe vor VCC des AVRs geschaltet.
[[Bild:voltage-reduction-with-diodes.gif|thumb|Pegelanpassung mit Dioden]]

'''Zusätzliche Vorteile'''
* Niedrige Kosten / Bauteile sind leicht zu bekommen.
* Kein Ruhestrom --> USB-Konformer Standby-Modus

'''Zusätzliche Nachteile'''
* Keine Spannungsregelung --> Spannung schwankt, das Geschwindigkeitsprobelm wird dadurch noch größer. Eventuell zu viel Spannung im Leerlauf.
* Die unregulierte Spannung ist problematisch für Analoge Schaltungen (ADC,...)

 

==== Lösung B: Anpassen der Spannung an D+ und D- ====
Ebenso kann man die Spannung an den Datenleitungen (D+ und D-) mit Zenerdioden verringern. Es werden 3,6V Low-Power Zenerdioden (wie 1N4148, 500mW oder weniger) empfohlen, da diese eine geringe Kapazität haben und somit weniger Störungen auf den Datenleitungen verursachen.
[[Bild:level-conversion-with-zener.gif|thumb|Pegelanpassung mit Zenerdioden]]

Wenn diese Lösung verwendet wird, stellen sie vor Benutzung sicher, dass die Spannungspegel mit den geforderten Pegeln(LOW:0V-0,8V HIGH:2V-3,6V) übereinstimmen.

'''Vorteile'''
* Niedrige Kosten
* Leicht zu bekommen
* Ganze Schaltung kann mit 5V betrieben werden --> Hohe Taktraten möglich
* zusätzlicher Schutz vor Überspannungen / ESD

'''Nachteile'''
* Keine saubere Lösung: Es muss ein Kompromiss zwischen allen Möglichkeiten gefunden werden.
* Zener-Dioden kommen mit einem breiten Spektrum an Merkmalen. Deshalb könnten die Ergebnisse nicht reproduzierbar sein.
* Hohe Ströme beim Senden von High-Leveln
* Nicht viel Reserve beim Empfangen

=== Allgemeine Anmerkungen zur Hardware ===
Es wird bei jeder der oben genannten Schaltungen ein PullUp-Widerstand (1,5k - 10k) von D- nach Vcc benötigt. Ebenso muss zwischen AVR und Die Datenleitungen ein Widerstand von je 68 Ohm.

=== Welche Taktraten können verwendet werden? ===
Momentan unterstützt V-USB Taktraten von 12 MHz, 12.8 MHz, 15 MHz, 16 MHz, 16.5 MHz, 18 MHz und 20 MHz. Diese Taktraten sind präzise, dies bedeutet, dass ein Quarz mit 11.9 MHz nicht funktionieren würde. Nur bei den 16.5 und 12.8 MHz Varianten ist eine Toleranz von 1%.16.5 MHz kann z.B. mit dem internen RC Oszillator von AVRs wie dem ATTiny25/45/85 oder dem ATTiny26 erreicht werden.
'''Entscheidungshilfe'''
* Möchten sie den internen RC Oszillator benutzen? Dann nehmen sie die 16.5MHz-Variante.
* Ist sehr wenig Speicher vorhanden? Verwenden sie am besten die 16MHz oder 20Mhz Variante.
* Wird der AVR mit einer niedrigen Spannung betrieben? Dann verwenden sie die 12MHz-Variante.
* Wollen sie CRC-Prüfsummen verwenden? Benutzen sie die 18Mhz-Variante.

=== Anschluss an den AVR ===
Die Datenleitung D+ muss über den 68 Ohm-Widerstand mit dem Port INT0 des AVRs verbunden werden. D- kann an einen beliebigen Port. Diese Ports müssen dann in der "usbconfig.h" angepasst werden.

== Software des AVR: Die Firmware ==
Als erstes muss man sich die neueste Version von V-USB von folgender Seite herunterladen: [http://www.obdev.at/products/vusb/download.html]
Nachdem sie das Archiv heruntergeladen haben, entpacken sie es und kopieren sie den Ordner "usbdrv" in ihr Projektverzeichnis. Kopieren bzw. erstellen sie das Makefile und passen darin die Taktrate und den verwendeten Controller an. Ebenso wird eine "usbconfig.h" benötigt, diese kann z.B. aus dem tests-Ordner kopiert werden. In dieser müssen nun die Punkte USB_CFG_IOPORTNAME, USB_CFG_DMINUS_BIT und USB_CFG_DPLUS_BIT angepasst werden.

In der main.c müssen immer als erstes folgende Dateien importiert werden:
<pre>
#include <avr/io.h> //IO-Zugriff: Braucht man immer
#include <avr/interrupt.h> // V-USB braucht interrupts
#include <avr/pgmspace.h>
#include <avr/wdt.h> //Watchdog: Sollte immer aktiv sein.

#include "usbdrv.h" //Der USB-Treiber
#include <util/delay.h> //Wird später für Timing etc. benötigt
</pre>

=== Gerät mit selbst geschriebenem PC-Treiber (kein HID) ===
Der Code für ein eigenes Gerät wird hier am Beispiel eines Gerätes veranschaulicht, bei dem sich über USB der PWM-Kanal steuern lässt. Damit kann man zum Beispiel eine LED dimmen.

Nach den Includes komm nun die Funktion zum Verarbeiten eingehender Daten.
Das erste Empfangene Byte, also der Befehl wird mit rq->bRequest abgefragt. In diesem Fall ist dieser entweder 0 oder 1. 0 bedeutet den PWM-Wert zu setzen, 1 bedeutet den Status (PWM-Wert) zurückzusenden.
Die einzelnen Parameter des Aufrufs können mit rq->wValue.bytes[id] abgefragt werden. Bei Befehl 0 wird in rq->wValue.bytes[0] der neue PWM-Wert übertragen. bytes[1] ist das 2. byte von wValue, welches beim Senden von Zahlen > 8bit entsteht. Ebenso gibt es noch rq->wIndex[id], welches gleich funktioniert.
Durch setzen von replyBuf kann festgelegt werden, welche Daten zurückgesendet werden sollen. Dabei muss immer replyBuf[id] verwendet werden. Bei Befehl 1 wird mit replyBuf[0] = OCR1A der aktuelle PWM-Wert zurückgesendet.
Mit return 2 wird dann noch mitgeteilt, dass überhaupt was zurückgesendet werden soll (2 Bytes). Mit return 0 wird nichts zurückgesendet. Das ist in diesem Fall der Fall, wenn ein ungültiger Befehl übermittelt wurde.

<pre>
USB_PUBLIC uchar usbFunctionSetup(uchar data[8])
{
usbRequest_t *rq = (void *)data;
static uchar replyBuf[2];

usbMsgPtr = replyBuf;
if(rq->bRequest == 0){
replyBuf[0] = rq->wValue.bytes[0];
replyBuf[1] = 0x0;

OCR1A=rq->wValue.bytes[0];
eeprom_write_byte(0,OCR1A);
return 2;
}
else if (rq->bRequest == 1) {
replyBuf[0] = OCR1A;
replyBuf[1] = 0x0;
return 2;
}
return 0;
}
</pre>

Als nächstes komm void main:
Hier schalten wir als erstes den Watchdog-Timer ein. Danach setzen wir alle Ports und DDR so wie wir sie brauchen. Es ist nur darauf zu achten, dass INT0 ein Eingang ist. Bei einem Atmega8 ist dies PORTD.2. Für unser Beispiel setzen wir TCCR1A als 8_bit PWM-Timer. Danach laden wir den letzten PWM-Wert aus dem EEPROM (Wird immer beim Ändern gespeichert). Nun trennen wir die Verbindung für > 500ms, dies wird benötigt, um nach einen Neustart des Mikrocontrollers (z.B. durch Watchdog) dem PC mitzuteilen, dass er neugestartet ist. Danach Verbinden wir uns wieder mit usbDeviceConnect(). Nun muss die Verbindung mit usbInit() initialisiert werden ud die Interrupts mit sei() eingeschaltet werden. Nun muss nur noch im Mainloop der Watchdog zurückgesetzt werden und usbPoll() aufgerufen werden.

<pre>
int main(void)
{
uchar i;

wdt_enable(WDTO_1S);
DDRD = ~(1 << 2); /* all outputs except PD2 = INT0 */
DDRB = 0xff; /* output pins setzen */
PORTD = 0; /* USB-Verbindung */
PORTB = 0; /* output pins aus*/

TCCR1A = (1<<WGM10)|(1<<COM1A1); // PWM, phase correct, 8 bit.
TCCR1B = (1<<CS11) |(1<<CS10); // set clock/prescaler 1/64 -> enable counter
OCR1A=eeprom_read_byte(0);

/* We fake an USB disconnect by pulling D+ and D- to 0 during reset. This is
* necessary if we had a watchdog reset or brownout reset to notify the host
* that it should re-enumerate the device. Otherwise the host's and device's
* concept of the device-ID would be out of sync.
*/

usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */
i = 0;
while(--i){ /* fake USB disconnect for > 500 ms */
wdt_reset();
_delay_ms(2);
}
usbDeviceConnect();
usbInit();
sei();
for(;;){ /* main event loop */
wdt_reset();
usbPoll();
}
return 0;
}
</pre>

Damit ist die Firmware fertig. Hier noch ein Makefile für avr-gcc: (Chip: Mega8, Clock: 12MHz, Programmer: Ponyser)
<pre>
# Name: Makefile
# Project: edited PowerSwitch
# Author:
# Creation Date:
# Tabsize: 4
# Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
# License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
# This Revision: $Id: Makefile 277 2007-03-20 10:53:33Z cs $

DEVICE = atmega8
AVRDUDE = avrdude -c ponyser -P /dev/ttyS0 -p $(DEVICE)
# Choose your favorite programmer and interface above.

COMPILE = avr-gcc -Wall -Os -Iusbdrv -I. -mmcu=$(DEVICE) #-DDEBUG_LEVEL=2
# NEVER compile the final product with debugging! Any debug output will
# distort timing so that the specs can't be met.

OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o main.o

# symbolic targets:
all: main.hex

.c.o:
$(COMPILE) -c $< -o $@

.S.o:
$(COMPILE) -x assembler-with-cpp -c $< -o $@
# "-x assembler-with-cpp" should not be necessary since this is the default
# file type for the .S (with capital S) extension. However, upper case
# characters are not always preserved on Windows. To ensure WinAVR
# compatibility define the file type manually.

.c.s:
$(COMPILE) -S $< -o $@

flash: all
$(AVRDUDE) -U flash:w:main.hex:i

# Fuse low byte:
# 0xef = 1 1 1 0 1 1 1 1
# ^ ^ \+/ \--+--/
# | | | +------- CKSEL 3..0 (clock selection -> crystal @ 12 MHz)
# | | +--------------- SUT 1..0 (BOD enabled, fast rising power)
# | +------------------ CKOUT (clock output on CKOUT pin -> disabled)
# +-------------------- CKDIV8 (divide clock by 8 -> don't divide)
#
# Fuse high byte:
# 0xdb = 1 1 0 1 1 0 1 1
# ^ ^ ^ ^ \-+-/ ^
# | | | | | +---- RSTDISBL (disable external reset -> enabled)
# | | | | +-------- BODLEVEL 2..0 (brownout trigger level -> 2.7V)
# | | | +-------------- WDTON (watchdog timer always on -> disable)
# | | +---------------- SPIEN (enable serial programming -> enabled)
# | +------------------ EESAVE (preserve EEPROM on Chip Erase -> not preserved)
# +-------------------- DWEN (debug wire enable)
#fuse_tiny2313: # only needed for attiny2313
# $(AVRDUDE) -U hfuse:w:0xdb:m -U lfuse:w:0xef:m

clean:
rm -f main.hex main.lst main.obj main.cof main.list main.map main.eep.hex main.bin *.o usbdrv/*.o main.s usbdrv/oddebug.s usbdrv/usbdrv.s

# file targets:
main.bin: $(OBJECTS)
$(COMPILE) -o main.bin $(OBJECTS)

main.hex: main.bin
rm -f main.hex main.eep.hex
avr-objcopy -j .text -j .data -O ihex main.bin main.hex
./checksize main.bin
# do the checksize script as our last action to allow successful compilation
# on Windows with WinAVR where the Unix commands will fail.

disasm: main.bin
avr-objdump -d main.bin

cpp:
$(COMPILE) -E main.c
</pre>

D+ ist in diesem Beispiel mit PD2 verbunden, D- mit PD0. Die LED hängt an PB1. (Schaltplan noch in Arbeit.)
[http://www.rn-wissen.de/index.php/V-USB:_Ein_Firmware_USB-Treiber_f%C3%BCr_AVR#PC-Software_bei_nicht_HID-Projekten_.28Treiber.29 Hier gehts zur PC-Seitigen Programmierung dieses Projekts]

=== HID-Gerät (Tastatur/Maus/...) ===
[noch in Arbeit]

== PC-Software bei nicht HID-Projekten (Treiber) ==
'''WARNUNG: Dieser Absatz ist veraltet und funktioniert NICHT mit der aktuellen libusb!'''
Ein etwas aktuelleres Tutorial, welches leider auch veraltet ist sei dennoch mal genannt: [http://www.dreamincode.net/forums/topic/148707-introduction-to-using-libusb-10/ dreamincode.net]

Wenn man nun ein Gerät mit einer Firmware hat, muss man als nächstes den Treiber für den PC schreiben. Dies werde ich nun am obigen Beispiel erläutern.

Als erstes sollte man sich überlegen, was die Software können muss. In unserem Beispiel wären das:
* Den PWM-Wert setzen
* Befehl ein/aus
* aktuellen Wert auslesen
Die Befehle ein bzw. aus müssen dabei keine eigenen Befehle werden, da man dafür den Wert 255(an) bzw. 0(aus) senden kann.

Um nun überhaupt einen USB-Treiber schreiben zu können, muss man sich als erstes "libusb" für c bzw. "libusb++" für c++ herunterladen. Unter Linux kann dies über den Paketmanager (Synaptic/Aptitude) geschehen. Unter Windows muss man sich die Bibliothek von folgender Seite herunterladen: [http://www.libusb.org/ http://www.libusb.org/]/[http://libusb.sourceforge.net/ http://libusb.sourceforge.net/]. Stellen sie sicher, dass wenn sie unter Windows arbeiten, die Win32-Version herunterladen.

Als erstes muss man auch wieder einige Header importieren:
<pre>
#include <stdio.h> /* Brauchen wir für Ein-/ bzw. Ausgabe */
#include <string.h> /* Brauchen wir für die Auswertung von Parametern */
#include <usb.h> /* Die Bibliothek - Liegt diese im Projektverzeichnis so muss #include "usb.h" verwendet werden*/
</pre>

Als nächstes müssen die VendorID und PID definiert werden. Diese können aus der Datei "USBID-License.txt" entnommen werden. WICHTIG: Zuerst ganz durchlesen um die Richtige auszuwählen.
Diese definiert man dann mit:
<pre>
#define USBDEV_SHARED_VENDOR 0x16C0 /* VOTI */
#define USBDEV_SHARED_PRODUCT 0x05DC /* Obdev's free shared PID */
</pre>
In diesem Beispiel wurde die VendorID/PID so gewählt, dass es keine Klasse hat, also ein eigenes Gerät ist.

Danach sollte man der Übersichtlichkeit halber, die einzelnen Befehle (welche einzelne Bytes sind) definieren. Für unser Beispiel heißt das:
<pre>
#define CMD_SETPWM 0
#define CMD_GETSTATUS 1
</pre>

Da dieses Projekt eine Konsolen-basierte Anwendung ist, ist es immer wichtig eine Hilfe mit den befehlen einzubauen. Nennen wir diese Funktion einfach usage: (Es kann selbstverständlich auch auf stdout ausgegeben werden.)
<pre>
static void usage(char *name)
{
fprintf(stderr, "usage:\n");
fprintf(stderr, " %s on\n", name);
fprintf(stderr, " %s off\n", name);
fprintf(stderr, " %s pwm [0-255]\n", name);
fprintf(stderr, " %s status\n", name);
}
</pre>

Als nächstes brauchen wir Funktionen zum Öffnen und Kommunizieren mit dem Gerät. Diese wurden aus dem Beispiel "PowerSwitch" von obdev kopiert:
<pre>
static int usbGetStringAscii(usb_dev_handle *dev, int index, int langid, char *buf, int buflen)
{
char buffer[256];
int rval, i;

if((rval = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index, langid, buffer, sizeof(buffer), 1000)) < 0)
return rval;
if(buffer[1] != USB_DT_STRING)
return 0;
if((unsigned char)buffer[0] < rval)
rval = (unsigned char)buffer[0];
rval /= 2;
/* lossy conversion to ISO Latin1 */
for(i=1;i<rval;i++){
if(i > buflen) /* destination buffer overflow */
break;
buf[i-1] = buffer[2 * i];
if(buffer[2 * i + 1] != 0) /* outside of ISO Latin1 range */
buf[i-1] = '?';
}
buf[i-1] = 0;
return i-1;
}

#define USB_ERROR_NOTFOUND 1
#define USB_ERROR_ACCESS 2
#define USB_ERROR_IO 3

static int usbOpenDevice(usb_dev_handle **device, int vendor, char *vendorName, int product, char *productName)
{
struct usb_bus *bus;
struct usb_device *dev;
usb_dev_handle *handle = NULL;
int errorCode = USB_ERROR_NOTFOUND;
static int didUsbInit = 0;

if(!didUsbInit){
didUsbInit = 1;
usb_init();
}
usb_find_busses();
usb_find_devices();
for(bus=usb_get_busses(); bus; bus=bus->next){
for(dev=bus->devices; dev; dev=dev->next){
if(dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product){
char string[256];
int len;
handle = usb_open(dev); /* we need to open the device in order to query strings */
if(!handle){
errorCode = USB_ERROR_ACCESS;
fprintf(stderr, "Warning: cannot open USB device: %s\n", usb_strerror());
continue;
}
if(vendorName == NULL && productName == NULL){ /* name does not matter */
break;
}
/* now check whether the names match: */
len = usbGetStringAscii(handle, dev->descriptor.iManufacturer, 0x0409, string, sizeof(string));
if(len < 0){
errorCode = USB_ERROR_IO;
fprintf(stderr, "Warning: cannot query manufacturer for device: %s\n", usb_strerror());
}else{
errorCode = USB_ERROR_NOTFOUND;
/* fprintf(stderr, "seen device from vendor ->%s<-\n", string); */
if(strcmp(string, vendorName) == 0){
len = usbGetStringAscii(handle, dev->descriptor.iProduct, 0x0409, string, sizeof(string));
if(len < 0){
errorCode = USB_ERROR_IO;
fprintf(stderr, "Warning: cannot query product for device: %s\n", usb_strerror());
}else{
errorCode = USB_ERROR_NOTFOUND;
/* fprintf(stderr, "seen product ->%s<-\n", string); */
if(strcmp(string, productName) == 0)
break;
}
}
}
usb_close(handle);
handle = NULL;
}
}
if(handle)
break;
}
if(handle != NULL){
errorCode = 0;
*device = handle;
}
return errorCode;
}
</pre>

Als letztes kommt nun void main. In main muss als erstes ein Handle für das USB-Gerät definiert werden. Danach brauchen wir noch einen Buffer für Dinge, die vom Gerät kommen und dann noch einen Zähler für empfangene Bytes.
Danach prüfen wir, ob der Programmaufruf korrekt ist. (Parameterzahl):
<pre>
int main(int argc, char **argv)
{
usb_dev_handle *handle = NULL;
unsigned char buffer[8];
int nBytes;

if(argc < 2){
usage(argv[0]);
exit(1);
}
</pre>
Danach muss libusb initialisiert werden dann das Gerät mit der obigen Funktion geöffnet werden. Dabei musst du natürlich Email/Homepage durch deine Homepage bzw. E-Mail ersetzen. Ebenso muss der Name, in diesem Fall PWMControl angepasst werden. Die beiden Werte wurden vorher in der Datei "usbconfig.h" festgelegt. Lesen sie dazu jedoch die Datei "USBID-License.txt". Diese Werte können natürlich auch als Defines gesetzt werden.
<pre>
usb_init();
if(usbOpenDevice(&handle, USBDEV_SHARED_VENDOR, "EMail/Homepage", USBDEV_SHARED_PRODUCT, "PWMControl") != 0){
fprintf(stderr, "Could not find USB device \"PWMControl\" with vid=0x%x pid=0x%x\n", USBDEV_SHARED_VENDOR, USBDEV_SHARED_PRODUCT);
exit(1);
}
</pre>
Als nächstes kommt unser eigentlicher Programmcode. In diesem wird zuerst überprüft ob on/off/pwm oder status übergeben wurde. Bei PWM wird zusätzlich geprüft, ob noch der PWM-Wert mit angegeben wurde. Mit dem befehl '' nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, [Befehl], [Param1], [Param2], (char *)buffer, sizeof(buffer), 5000);'' kann man nun Daten an das Gerät schicken. Sendet das Gerät Daten zurück, so sind diese in buffer abrufbar. Ebenfalls wird noch überprüft, ob ein fehler auftrat. Dies erfolgt mit ''if(nBytes < 0)''.
<pre>
if(strcmp(argv[1], "pwm") == 0){
if(argc < 3){
usage(argv[0]);
exit(1);
}
nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_SETPWM, atoi(argv[2]), 0, (char *)buffer, sizeof(buffer), 5000);
}else if(strcmp(argv[1], "off") == 0){
nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_SETPWM, 0, 255, (char *)buffer, sizeof(buffer), 5000);
}else if(strcmp(argv[1], "on") == 0){
nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_SETPWM, 255, 255, (char *)buffer, sizeof(buffer), 5000);
}else if(strcmp(argv[1], "status") == 0){
nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_GETSTATUS, 0, 0, (char *)buffer, sizeof(buffer), 5000);

if(nBytes < 2){
if(nBytes < 0)
fprintf(stderr, "USB error: %s\n", usb_strerror());
fprintf(stderr, "only %d bytes status received\n", nBytes);
exit(1);
}
printf("%i\n", buffer[0]);

}else{
nBytes = 0;
usage(argv[0]);
exit(1);
}
if(nBytes < 0)
fprintf(stderr, "USB error: %s\n", usb_strerror());
</pre>
Letztendlich muss man das USB-gerät nur noch schließen und den void main beenden.
<pre>
usb_close(handle); //USB-Gerät schließen
return 0;
}
</pre>

== Quellen ==
* [http://www.obdev.at/products/vusb/index.html V-USB Homepage by Objective Development]
* [http://vusb.wikidot.com/ V-USB Wiki]
* Alle drei Schaltpläne wurden aus der Wiki von V-USB entnommen.
[[Kategorie:Microcontroller]]
{{Ausbauwunsch|Das Thema HID-Geräte fehlt noch komplett.}}
[[Kategorie:Software]]
[[Kategorie:Quellcode C]]

Fototransistor

2013-09-25T15:28:47Z

Pit49:

[[Bild:Fototransistor-Foto.JPG|thumb|Verschiedene Bauarten von Fototransistoren]]
Fototransistoren sind eine Art von [[Transistor | Transistoren]], die auf einfallendes Licht reagieren. Der Basis-Anschluss ist bei Fototransistoren optisch zugänglich.
 
== Aufbau und Funktion ==
[[Bild:Fototransistor-Struktur.jpg|thumb|Innerer Aufbau eines Fototransistors]]
[[Bild:Fototransistor-Schaltbild.jpg|left]]''Schaltzeichen eines Fototransistors'' 
Wie die [[Fotodiode]] arbeitet auch der Fototransistor mit einer Halbleiterstrecke, die bei Lichteinfall ihre Eigenschaften ändert. Es handelt sich dabei um die Basis-Kollektor-Strecke, die als Fotodiode fungiert und den Basisstrom für den Fototransistor erzeugt. Der Fototransistor wird somit nur über das einfallende Licht gesteuert. Fällt Licht auf einen Fototransistor, dann erhöht sich der Strom, der zwischen Kollektor und Emitter fließt. Bei manchen Fototransistoren ist zudem der Basisanschluss herausgeführt. Dadurch ist eine Arbeitspunktstabilisierung oder eine Manipulation des Schaltverhaltens möglich.

Die spektrale Empfindlichkeit von Fototransistoren ist mit der von Fotodioden vergleichbar, d.h. Fototransistoren aus Silizium haben ihr Maximum bei etwa 800 nm, solche aus Germanium bei etwa 1500 nm. Beide Wellenlängen liegen somit im Infrarotbereich.

Fototransistoren haben ein lichtdurchlässiges Gehäuse, bei dem das Licht auf die Basis-Kollektor-Sperrschicht fallen kann. Die Empfindlichkeit ist jedoch auch vom verwendeten Material des Transistorgehäuses abhängig, ein transparentes Gehäuse hat eine breitere Empfindlichkeitskurve als ein schwarzes Epoxy-Gehäuse (IR-Filter).

Der Vorteil des Fototransistors gegenüber der Fotodiode ist die wesentlich höhere Empfindlichkeit, denn der Fotostrom wird wie bei einem normalen bipolaren Transistor um etwa den Faktor 200 verstärkt.
Allerdings ist die Trägheit von Fototransistoren höher als die von Fotodioden: Die Grenzfrequenz eines Fototransistors liegt mit etwa 250 kHz wesentlich niedriger, bei Foto-Darlington-Transistoren liegt diese sogar nur bei ca. 30 kHz. Bei der typischen eher hochohmigen Beschaltung liegt die Grenzfrequenz sogar noch deutlich niedriger.

== Anwendungsbeispiele ==

[[Bild:Fototransistor-analog.GIF|thumb|Fototransistor als Lichtstärkesensor]]
Häufig werden Fototransistoren als Lichtstärkesensor (z.B. in einem Roboter, der einer Linie folgt) verwendet und werden analog ausgewertet. Hierfür wird der Fototransistor zusammen mit einem Arbeitswiderstand von z.B. 10kOhm als Spannungsteiler geschaltet. Die Spannung am Widerstand ist dann näherungsweise proportional zur Helligkeit und kann direkt mit einem Analog-Digital-Wandler (wie er in den meisten Mikrocontrollern vorhanden ist) gemessen werden.

Der Fototransistor wird üblicherweise gegen VCC geschaltet und der Arbeitswiderstand gegen GND.

Die Linearität ist besser als bei einem [[LDR]], aber schlechter als bei einer [[Fotodiode]].

[[Bild:Optokoppler-Aufbau.GIF|thumb|Interner Aufbau eines Optokopplers]]Die Empfängerseite der meisten [[Optokoppler]] ist ein Fototransistor.
[[Bild:Fototransistor-Lichtschranke.GIF|thumb|Schaltplan einer Lichtschranke]]
Im Schaltplan rechts ist die einfachste Variante einer schnellen Lichtschranke zu sehen. RV dient der Strombegrenzung durch die [[Leuchtdiode]], mit dem Widerstand R wird die Schaltschwelle eingestellt. Die Last muss keine Lampe, sondern kann jeder beliebige Verbraucher sein, vom [[Relais]] bis zum μController-Eingang.
 

== Vergleich bekannter Fototransistoren==
{| {{Blauetabelle}}
|-
| Name||Bauform||max. Empf.||Bereich der Empf. 10%||Empf. Fläche||Halbwinkel||Fotostrom typ.||Schaltzeit||Bemerkung
|-
|BP103B||5mm, klar||850nm||420...1300nm||0,12 mm²||+-25°||0,63-1,6 mA (3,4-8,6 mA)||7,5-10µs||
|-
|BP103BF||5mm, dunkel||900nm||730...1120nm||0,045 mm²||+-12°||0,63-1,6 mA (3,4-8,6 mA)||7,5-10µs||
|-
|BPW16N||3,3x2,4mm bedrahtet, klar||825nm||620...960nm||?||+-40°||0,07-0,14 mA||5µs||
|-
|BPW17N||3,3x2,4mm bedrahtet, klar||825nm||620...960nm||?||+-12°||0,5-1 mA||5µs||
|-
|BPW39||ähnlich TO-92, seitl. empf.||780nm||520...950nm||?||+-65°||0,5-1,6 mA||3,4µs||
|-
|BPW40||5mm||780nm||520...950nm(50%)||?||+-20°||0,1-0,5 mA||3µs||
|-
|BPW42||3mm||830nm||560...980nm(50%)||?||+-180°!?||0,9-1,9mA||3µs||
|-
|BPX38||5mm Metall, hermetisch dicht TO-18||880nm||450-1120nm||0,675mm²||+-40°||0,2-3,6mA||9-18µs||Basis extra
|-
|BPX43||5mm Metall, hermetisch dicht TO-18||880nm||450...1100nm||0,675mm²||+-15°||0,8-15mA||9-18µs||Basis extra
|-
|BPX81||"einstellige Zeilenbauform" <3mm||850nm||440...1070nm||0,17mm²||+-18°||0,25-3,4mA||5,5-8µs||
|-
|BPY62||5mm Metall, hermetisch dicht||850nm||420...1130nm||0,12 mm²||+-8°||0,5-11,4mA||5-12µs||Basis extra
|-
|K153P (S472P)|| 5x5x2,7mm bedrahtet, dunkel||920nm||850...980nm(50%)||?||+-35°||1,7-5,5mA||4-15µs||
|-
|LPT80A||flach, 4,6x5,6x1,5mm; seitl. empf.||850nm||430...1070nm||0,30 mm²||+-35°||0,25-3,2mA||10µs||
|-
|PT15-21B/TR8||SMD 1206||940nm||730...1100nm||?||?||0,3 mA||15 µs||
|-
|PT331C||5mm, klar||940nm||400...1100nm||?||?||0,7-2,5 mA||15 µs||
|-
|SDP8406||.||ca. 870nm||ca.400...1100nm||?||ca.+-25°||bis 8 mA||ca.2-10µs||
|-
|SDP8436||.||ca. 900nm||ca.750...1000nm||?||ca.+-10°||?||ca.2-10µs||
|-
|SFH300||5mm, klar||850nm||420...1130nm||0,12 mm²||+-25°||0,63-1,6 mA (3,4-8,6 mA)||7,5-10µs||
|-
|SFH300FA||5mm, dunkel||870nm||730...1120nm||0,12 mm²||+-25°||0,63-1,6 mA (3,4-8,6 mA)||7,5-10µs||
|-
|SFH305||"Mini-Bauform"||850nm||460...1060nm||0,17 mm²||+-16°||0,25-2,2 mA||5,5-6 µs||
|-
|SFH309||3mm, klar||860nm||380...1150nm||0,038 mm²||+-12°||0,4-5 mA (1,5-11,2 mA)||5-9µs||
|-
|SFH309FA||3mm, dunkel||900nm||730...1120nm||0,038 mm²||+-12°||0,4-5 mA (1,5-11,2 mA)||5-9µs||
|-
|SFH313||5mm, klar||850nm||460...1080nm||0,55mm²||+-10°||2,5-12,5mA||8-14µs||
|-
|SFH313FA||5mm, dunkel||870nm||740...1080nm||0,55mm²||+-10°||2,5-12,5mA||8-14µs||
|-
|SFH320||SMD, PLCC-2||980nm||450...1150nm||0,038mm²||+-60°||0,42-1mA||6-8µs||
|-
|SFH320FA||SMD, PLCC-2||980nm||750...1120nm||0,038mm²||+-60°||0,42-1mA||6-8µs||
|-
|SFH3100F||3mm, rechteckig, seitl. empf.||920nm||840...1080nm||1 mm²||+-14°||0,25mA||7-9µs||
|-
|SFH3310||3mm, klar||570nm||350...970nm||0,29 mm²||+-75°||2,5-8µA (290-460 µA)||?||
|-
|SFH3500||Surface Mount Radial||830nm||450...1060nm||0,55 mm²||+-13°||4-20 mA||17-24µs||
|-
|TEKT5400S||ähnlich TO-92, seitl. empf.||920nm||850...980nm(50%)||?||+-37°||4mA||5-6µs||
|-
|}

Keine Garantie auf Vollständigkeit und Richtigkeit. Stand der Angaben: 12.Feb 2012 (BMS)

== Anmerkungen ==
''Der Autor möchte hier weder die an anderen Stellen zu findenden Formelsammlungen wiedergeben, noch mit diesem Artikel ein Fachbuch ersetzten. Einzig die Grundlagen, die (aus eigener Erfahrung) für einen Hobby-Bastler von Interesse sind, sollen hier dargestellt werden.''
 
== Siehe auch ==
* [[Fotodiode]]
* [[Fotowiderstand]]
* [[Sensorarten]]

== Weblinks ==
* [http://de.wikipedia.org Wikipedia] 
* [http://www.elektronik-kompendium.de/sites/bau/0207012.htm Das ELektronik-KOmpendium - Fototransistor] 
 

== Autor ==
--[[Benutzer:Williwilli|Williwilli]] 20:26, 17. Okt 2008 (CEST)

--[[Benutzer:BMS|BMS]] 20:50, 17. Mar 2011 (Tabelle)
[[Kategorie:Grundlagen]]
[[Kategorie:Elektronik]]
[[Kategorie:Sensoren]]

Bascom und Kompass CMPS03

2013-09-25T15:23:20Z

Pit49:

[[Bild:kompass.jpeg|thumb|Wo gehts lang?]]Damit sich ein Roboter orientieren kann, gibt es die unterschiedlichsten Verfahren. Bei den meisten Verfahren wäre es hilfreich, wenn man wüsste, in welche Himmelsrichtung sich der Bot gerade bewegt. Wo ist Norden oder Süden? Genau für diesen Zweck wurde das Modul CMPS03 von Devantech entwickelt. Dieses Modul ist in der Handhabung äußerst einfach, es gibt über den I2C-Bus den genauen Winkel in Abstufungen von 0,1 Grad zum Nordpol aus, also 0 bis 360 Grad. Obwohl die Anwendung äußerst einfach ist, gibt es kaum Bascom-Beispiele.
Dem soll hier abgeholfen werden. Das nachfolgende Programm demonstriert die Anwendung mit dem bekannten Board RN-Control. Natürlich lassen sich die Funktionen auch einfach auf andere RN- oder AVR-Boards übertragen.

==Die Pinbelegung des Modules==

[[Bild:cmps3pin.jpg|center]]

==Einfacher Anschluss an den I2C-Bus==
Da [[RN-Control]] den Standard-I2C-Stecker (nach [[RN-Definitionen]]) benutzt, reicht ein Kabel für das Modul aus, die notwendige Betriebsspannung kann nämlich auch gleich über das I2C-Kabel erfolgen.

Das Ganze sieht dann angeschlossen so aus:

[[Bild:kompassmodul_an_rncontrol.jpg|center]]

Man benötigt nicht alle 10 Drähte des 10-pol. Kabels. Daher bastelt man sich einfach einen entsprechenden Stecker an das Kabel und schneidet die nicht benötigten Drähte ab. Da CMPS03 bereits über eine Stiftleiste verfügt, kann der Stecker dann bequem aufgesteckt werden.

Das sieht dann beispielsweise so aus:

[[Bild:kompasskabel.gif|center]]

==Das Beispielprogramm in Bascom Basic==
Hier das vollständig dokumentierte Beispielprogramm für RN-Control. Das Programm kann unverändert übernommen und kompiliert werden. Es gibt über die RS232-Schnittstelle, also ein Terminalprogramm, die Firmwareversion und den Winkel zum Nordpol aus.

<pre>
'###################################################
'cmps03_an_rncontrol.bas.bas
'für
'RoboterNetz Board RN-CONTROL (ab Version 1.1)
'und das Kompassmodul CMPS03 für Erkennung der Himmelsrichtung
'Datenblatt zu CMPS03 siehe Downloadbereich:
'http://www.roboternetz.de

'Aufgabe:
' Gibt die Himmelsrichtung in Bezug auf Norden aus

' Die Unterfunktionen können gerne in eigenen Programmen
' genutzt werden.

' Autor: Frank (Roboternetz)
' Modul: CMPS03 Devantech/robotikhardware.de neueste Firmware
' Getestet mit CMPS Firmware 11
'#######################################################

Declare Function Rn_cmps_himmelsrichtung() As Word
Declare Function Rn_cmps_firmware() As Byte

' ---------- Das RN-Control übliche --------------
$regfile = "m32def.dat"
$framesize = 42
$swstack = 32
$hwstack = 32

$crystal = 16000000 'Quarzfrequenz
$baud = 9600
Config Scl = Portc.0 'Ports fuer IIC-Bus
Config Sda = Portc.1
' ------------------------------------------------

Dim Himmelsrichtung As Word
Dim Grad As Single
Dim V As Byte

Wait 3 'Warte 3 Sekunde
I2cinit
Print "RN-Control CMPS03 Kompass Testprogramm "
Print "CMPS03 Kompass Firmware Version:" ; Rn_cmps_firmware()

V = 1
Do
Himmelsrichtung = Rn_cmps_himmelsrichtung()
Print "Himmelsrichtung in 0,1 Grad Schritten: " ; Himmelsrichtung
Grad = Himmelsrichtung / 10
Print "Himmelsrichtung genau in Grad: " ; Grad

V = V + 3
Wait 1
Loop

End

Function Rn_cmps_himmelsrichtung() As Word
Local Lob As Byte
Local Hib As Byte
Local Cmps_slaveid As Byte
Local Cmps_slaveid_read As Byte

Cmps_slaveid = &HC0
Cmps_slaveid_read = Cmps_slaveid + 1

'Register auswählen
I2cstart
I2cwbyte Cmps_slaveid
I2cwbyte 2
I2cstop

I2cstart
I2cwbyte Cmps_slaveid_read
I2crbyte Hib , Ack
I2crbyte Lob , Nack
I2cstop

Rn_cmps_himmelsrichtung = Makeint(lob , Hib)
End Function

Function Rn_cmps_firmware() As Byte
Local Firmware As Byte
Local Cmps_slaveid As Byte
Local Cmps_slaveid_read As Byte

Cmps_slaveid = &HC0
Cmps_slaveid_read = Cmps_slaveid + 1

I2cstart
I2cwbyte Cmps_slaveid
I2cwbyte 0 'Leseregister festlegen
I2cstop

I2cstart
I2cwbyte Cmps_slaveid_read
I2crbyte Firmware , Nack
I2cstop

Rn_cmps_firmware = Firmware
End Function
</pre>

==Siehe auch==
* [[RN-Control]]
* [[Sensorarten]]
* [[Bascom]]
* [[Avr]]

==Weblinks==
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=333 CMPS03 Deutsche als auch englische Anleitung/Datenblatt]

[[Kategorie:Quellcode Bascom]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Sensoren]]

Beispiel Drehzahlmessung mit RN-Control

2013-01-04T17:40:20Z

Pit49:

Wie einfach man mit einem Drehgeber die Drehzahl messen kann zeigt diese Schaltung /dieser Quelltext. Für dieses Beispiel wurde ein Drehgeber GP1A030 mit Codescheibe verwendet. Es könnte aber genauso ein GP1A038 oder ein ähnlicher Sensor sein. In diesem Demo wird nicht die Drehrichtung ausgewertet, obwohl es mit diesem Sensor ebenfalls möglich wäre.

[[Bild:drehgeber_an_rncontrol.gif|center|framed|Beispielschaltung, wenn man lediglich die Drehzahl ohne Drehrichtung auswerten möchte. Als Widerstand hat sich 330 Ohm als gut erwiesen.]]

<pre>

'###################################################
'rncontrol_drehzahl.BAS
'für
'RoboterNetz Board RN-CONTROL ab Version 1.1
'Das neue preiswerte Controllerboard zum Experimentieren

' Achtung:
' Diese Demo ist mit Bascom Compiler 1.11.7.8 getestet

'
'Aufgabe:
' Dieses Testprogramm demonstriert wie man mit Drehgebern
' die Umdrehungszahl von Motoren anzeigen kann
' Als Drehgeber wird ein Sharp GP1A030 mit Codescheibe
' verwendet (siehe http://www.robotikhardware.de Rubrik Sensoren)
' In diesem Demo wird nicht die Drehrichtung ausgewertet, daher
' wird nur ein Interrupt Port (INT0) an den Sensorausgang (VOA)
' angeschlossen. Zudem noch +5V, GND und +5V über 330 Ohm
' Widerstand an Anode des Sensors. Also einfachste Beschaltung.

' Wenn man das Programm startet wird jede Sekunde die Drehzahl
' ermittelt und alle 3 Sekunden über RS232 auf einem
' Terminalprogramm (oder KN-KeyLCD) ausgegeben.

' Das Programm eignet sich somit zum Messen von Drehzahlen als
' auch zur Überprüfung der Drehgeberfunktion. Es läßt sich
' sehr einfach zu Wegstrecken-Auswertung ausbauen. Statt
' an einem Interrupt könnte man den Sensor auch an einen Timereingang
' anschließen, jedoch wird dies hier im Programm nicht berücksichtigt.

'Autor: Frank
'Weitere Beispiele und Beschreibung der Hardware
'unter http://www.Roboternetz.de oder robotikhardware.de
'#######################################################

$regfile = "m32def.dat"
' bei Mega 16 $regfile = "m16def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32

$crystal = 16000000 'Quarzfrequenz
$baud = 9600

Config Int0 = Falling

Config Timer1 = Timer, Prescale = 256
Const Timervorgabe = 3036
Const Markierungenproscheibe = 120

Dim Zaehlerirq0 As Long
Dim Impulseprosekunde As Long
Dim Impulseprominute As Long
Dim Umdrehungenprominute As Integer

Print
Print "* RN-CONTROL 1.4 *"
Print "Drehzahl Messung"; ""

Zaehlerirq0 = 0
On Int0 Irq0
Enable Int0

On Timer1 Timer_irq
Enable Timer1

Enable Interrupts

Do
Print
Print "Impulse Sek: "; Impulseprosekunde
Impulseprominute = Impulseprosekunde * 60
Umdrehungenprominute = Impulseprominute / Markierungenproscheibe
Print "Umdreh. Min: "; Umdrehungenprominute
Wait 3
Loop

End

'Pro Impuls (Markierung auf Scheibe) ein Aufruf
Irq0:
Incr Zaehlerirq0
Return

'Pro Sekunde ein Aufruf
Timer_irq:
Timer1 = Timervorgabe
Impulseprosekunde = Zaehlerirq0
Zaehlerirq0 = 0
Return

</pre>

==Siehe auch==
* [[RN-Control]]
* [[Avr]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Quellcode Bascom]]

Bascom und USI-Kommunikation

2006-12-23T20:44:30Z

Pit49:

In diesem Artikel folgen einige Programmbeispiele, um das [[USI (Avr)|USI]]-Hardwaremodul der [[AVR]]s zu verwenden. Mit dem [[USI (Avr)|USI]]-Modul können die Schnittstellen [[I2C]] ([[TWI]]) und [[SPI]] nachgebildet werden. Näheres zu [[USI (Avr)|USI]], [[I2C]] und [[SPI]] finden sich in den entsprechenden Artikeln. Die Beispiele sind zwar in [[Bascom]] Basic verfasst, aber so ausgeführt, dass es möglich sein sollte das Prinzip mit jeder anderen Sprache nachvollziehen zu können.

== USI-I2C-Master ==
[[Bild:USI-I2C_PCF8574_RN-Control_Tiny2313.JPG|thumb|Beispielumgebung mit PCF8574]]
Ist der AVR Master, bestimmt er was und wie schnell es auf dem [[I2C|I2C]]-Bus zugeht. (Ausnahme: [[Clock_Stretching]] )

Zur Generierung der gewünschten Busgeschwindigkeit ist die Software zuständig, die Länge der Pausen zwischen den Takten muss errechnet werden, im Beispielprogramm für ca. 100 kHz bei 16 MHz CPU-Frequenz.
Der Takt kann auch mithilfe eines [[Timer/Counter (Avr)|Timer]]s erzeugt werden, dies wird erst zu einem späteren Zeitpunkt mit einem Beispiel gezeigt.

In den Beispielen wird als Master das Board [[RN-Control]] mit einem [[ATtiny2313|Tiny2313]], und als Slave ein [[I2C_Chip-Übersicht#I.2FO_expanders:|PCF8574]] verwendet, da sich dieser leicht ansteuern lässt. 

----

=== Transmitter ===

;Nur Senden

Der Master sendet einem Slave ein (oder mehrere) Byte, und schließt die Übertragung anschließend ab.

Das Gegenstück wäre ''Slave Receiver''.

Beispielprogramm sendet ein Byte zum Slave mit Adresse 64 (0x40 bzw. &H40):

{{vbcomment|USI-I2C Testprogramm}}
{{vbcomment|mit PCF8574 @ &H40}}
{{vbcomment|}}
{{vbcomment|ohne Interrupt und ohne Timer}}
{{vbcomment|ein Byte senden}}
$regfile = "attiny2313.dat"
$crystal = 16000000
$baud = 9600

{{vbcomment|Unterprogramme für die USI-Kommunikation}}
Declare Sub Usi_twi_master_initialise()
Declare Sub Usi_twi_start_transceiver()
Declare Sub Usi_twi_master_stop()
Declare Sub Usi_twi_master_transfer()

{{vbcomment|einige Aliases anlegen}}
Pout_usi_scl Alias Portb.7
Pin_usi_scl Alias Pinb.7
Ddr_usi_scl Alias Ddrb.7
Pout_usi_sda Alias Portb.5
Pin_usi_sda Alias Pinb.5
Ddr_usi_sda Alias Ddrb.5

Dim Usi_twi_errorstate As Byte {{vbcomment|eigener Fehlerstatus}}
{{vbcomment|Array der Daten die übertragen werden}}
Dim Messagebuf(4) As Byte
Dim Temp_usisr As Byte {{vbcomment|Tempvariable für Unterprogramm}}
Dim Anzahlbuf As Byte {{vbcomment|Anzahl Zeichen die gesendet werden sollen }}
Dim Cnt As Byte {{vbcomment|Zähler}}
Dim B As Byte {{vbcomment|Zeichen von UART oder Testzeichen zum senden über USI}}

{{vbcomment|Prepare register value to: Clear flags, and set USI to shift 8 bits i.e. count 16 clock edges.}}
Const Temp_usisr_8bit = &HF0
{{vbcomment|Prepare register value to: Clear flags, and set USI to shift 1 bit i.e. count 2 clock edges.}}
Const Temp_usisr_1bit = &HFE

B = 0
Anzahlbuf = 2 {{vbcomment|in diesem Beispiel immer nur 2 Zeichen}}

Waitms 300 {{vbcomment|Sicherheitspause nach Reset}}

Call Usi_twi_master_initialise

Print
Print "Tiny2313 USI-TWI-Test"

Messagebuf(1) = &H40 {{vbcomment|Adresse von 8574}}

Do
{{vbcomment|warten bis etwas über UART kommt}}
Input B
{{vbcomment|oder automatisch zählen lassen}}
{{vbcomment|Incr B}}

{{vbcomment|Den Wert zum Slave senden}}
Messagebuf(2) = Not B {{vbcomment|Not, weil LEDs gegen GND schalten}}
Call Usi_twi_start_transceiver
Call Usi_twi_master_stop

{{vbcomment|Ausgabe, damit wir sehen was geschehen ist}}
Print B ;
Print " "
Print Hex(usi_twi_errorstate);
Print " " ;
Print Hex(temp_usisr)

Call Usi_twi_master_initialise {{vbcomment|nochmal initialisieren falls ein Fehler aufgetreten ist}}

{{vbcomment|Waitms 700 ' Wenn automatisch gezählt werden soll, eine kleine Pause, damit man auch was sehen kann}}
Loop

End

==== Unterprogramm nur Senden ====

Die restlichen Subroutinen sind im nächsten Abschnitt zu finden.

Diese Funktion ist nur zum Versenden geeignet !

Statt dieser kann auch die Routine von unten genommen werden, die aber etwas mehr Speicherplatz benötigt.

{{vbcomment|USI Transmit Funktion.}}
Sub Usi_twi_start_transceiver()

Usi_twi_errorstate = 0

{{vbcomment|Test if any unexpected conditions have arrived prior to this execution.}}
{{vbcomment|Ist eine Startbedingung aufgetreten ?}}
If Usisr.7 = 1 Then {{vbcomment|USISIF}}
Usi_twi_errorstate = &H02 {{vbcomment|Usi_twi_ue_start_con}}
Exit Sub
End If

{{vbcomment|Ist eine Stopbedingung aufgetreten ?}}
If Usisr.5 = 1 Then {{vbcomment|USIPF}}
Usi_twi_errorstate = &H03 {{vbcomment|Usi_twi_ue_stop_con}}
Exit Sub
End If

{{vbcomment|Ist eine Datenkollision aufgetreten ?}}
If Usisr.4 = 1 Then {{vbcomment|USIDC}}
Usi_twi_errorstate = &H04 {{vbcomment|Usi_twi_ue_data_col}}
Exit Sub
End If

{{vbcomment|Release SCL to ensure that (repeated) Start can be performed}}
Pout_usi_scl = 1
Waitus 5

{{vbcomment|Startbedingung ausgeben}}
Pout_usi_sda = 0 {{vbcomment|Force SDA LOW.}}
Waitus 4
Pout_usi_scl = 0 {{vbcomment|Pull SCL LOW.}}
Pout_usi_sda = 1 {{vbcomment|Release SDA.}}

{{vbcomment|prüfen ob die Startbedingung vom eigenen USI erkannt wurde}}
If Usisr.7 = 0 Then {{vbcomment|USISIF}}
Usi_twi_errorstate = &H07
Exit Sub
End If

{{vbcomment|Slaveadresse und Daten ausgeben}}
For Cnt = 1 To Anzahlbuf
{{vbcomment|Ein Byte ausgeben}}
Pout_usi_scl = 0 {{vbcomment|Pull SCL LOW.}}
Usidr = Messagebuf(cnt)
Temp_usisr = Temp_usisr_8bit {{vbcomment|8Bit ausgeben}}
Call Usi_twi_master_transfer

{{vbcomment|(N)ACK vom Slave lesen}}
Ddr_usi_sda = 0 {{vbcomment|Enable SDA as input.}}
Temp_usisr = Temp_usisr_1bit {{vbcomment|1Bit einlesen}}
Call Usi_twi_master_transfer

{{vbcomment|kein ACK gekommen, Slave meldet sich nicht}}
If Temp_usisr.0 = 1 Then
Usi_twi_errorstate = &H05 {{vbcomment|Slave hat mit NACK quittiert}}
If Cnt = 1 Then
Usi_twi_errorstate = &H06 {{vbcomment|Es hat sich kein Slave gemeldet}}
End If
Exit For {{vbcomment|hier wird die Schleife bei einem NACK verlasssen}}
End If

Next Cnt

End Sub

----

=== Transmitter und Receiver mit DS1621 als Slave ===
[[Bild:USI-I2C_DS1621_RN-Control_Tiny2313.JPG|thumb|Beispielumgebung mit DS1621]]

;Senden und Empfangen (Repeated Start)
Im Beispiel wird ein DS1621 Temperatursensor mit I2C-Schnittstelle verwendet. 
Der Master sendet dem Slave ein Kommando, stellt um auf Empfang und holt den Temperaturwert, schließt die Übertragung anschließend ab.

Der Temperaturwert wird über [[UART]] ([[RS232]]) im Klartext ausgegeben.

Die Subroutinen sind die gleichen wie für ''Master Transmitter''. Da der DS1621 aber mit 400 kHz kommunizieren kann, wurden die ''Waitus'' zwischen den Pegelwechseln weggelassen, da die Befehle hier sowieso nicht schnell genug sind und ein Wait unnötig machen. Sie sind aber als Kommentar eingefügt, damit zu sehen ist an welchen Stellen ansonsten gewartet werden sollte (zB bei 100kHz).

Beispielprogramm holt Temperaturwert vom Slave mit Adresse 144 (0x90 bzw. &H90): 
(Das Beispiel belegt 1418 Byte im Flash, das sind ca. 69% eines Tiny2313 !)

{{vbcomment|USI-I2C Testprogramm}}
{{vbcomment|mit DS1621 @ &H90}}
{{vbcomment|}}
{{vbcomment|ohne Interrupt und ohne Timer}}
{{vbcomment|Temperatur von DS1621 lesen, und über UART ausgeben}}
$regfile = "attiny2313.dat"
$crystal = 16000000
$baud = 9600

{{vbcomment|Unterprogramme für die USI-Kommunikation}}
Declare Sub Usi_twi_master_initialise()
Declare Sub Usi_twi_start_transceiver()
Declare Sub Usi_twi_master_stop()
Declare Sub Usi_twi_master_transfer()

{{vbcomment|einige Aliases anlegen}}
Pout_usi_scl Alias Portb.7
Pin_usi_scl Alias Pinb.7
Ddr_usi_scl Alias Ddrb.7
Pout_usi_sda Alias Portb.5
Pin_usi_sda Alias Pinb.5
Ddr_usi_sda Alias Ddrb.5

Dim Usi_twi_errorstate As Byte {{vbcomment|eigener Fehlerstatus}}
{{vbcomment|Array der Daten die übertragen werden}}
Dim Messagebuf(4) As Byte
Dim Temp_usisr As Byte {{vbcomment|Tempvariable für Unterprogramm}}
Dim Anzahlbuf As Byte {{vbcomment|Anzahl Zeichen die gesendet werden sollen}}
Dim Cnt As Byte {{vbcomment|Zähler}}
Dim Rw As Bit {{vbcomment|Read/Write Flag}}

{{vbcomment|Prepare register value to: Clear flags, and set USI to shift 8 bits i.e. count 16 clock edges.}}
Const Temp_usisr_8bit = &HF0
{{vbcomment|Prepare register value to: Clear flags, and set USI to shift 1 bit i.e. count 2 clock edges.}}
Const Temp_usisr_1bit = &HFE

Waitms 500 {{vbcomment|Sicherheitspause nach Reset}}

Call Usi_twi_master_initialise

Dim Device As Byte
Dim Deviceread As Byte
Dim Lowtemp As Byte
Dim Hightemp As Byte

Device = &H90
Deviceread = &H91

Sound Portd.5 , 300 , 450 {{vbcomment|BEEP}}

Print
Print "DS1621-USI Temperatur"

{{vbcomment|Hauptprogramm}}
Do

Messagebuf(1) = Device {{vbcomment|Adresse von DS1621}}
Messagebuf(2) = &HEE {{vbcomment|Temperaturmessung anstoßen}}
Anzahlbuf = 2 {{vbcomment|2 Byte ausgeben}}
Call Usi_twi_start_transceiver
{{vbcomment|Print Hex(usi_twi_errorstate)}}

If Usi_twi_errorstate = 0 Then {{vbcomment|kein Fehler aufgetreten}}

Call Usi_twi_master_stop
{{vbcomment|Print Hex(usi_twi_errorstate)}}

{{vbcomment|Waitms 1}}
Messagebuf(1) = Device {{vbcomment|Adresse von DS1621}}
Messagebuf(2) = &HAA {{vbcomment|Temperaturmessung Lesekommando}}
Anzahlbuf = 2 {{vbcomment|2 Byte ausgeben}}
Call Usi_twi_start_transceiver
{{vbcomment|Print Hex(usi_twi_errorstate)}}
{{vbcomment|kein STOP an dieser Stelle !}}
{{vbcomment|es folgt ein Repeated START !}}

If Usi_twi_errorstate = 0 Then {{vbcomment|kein Fehler aufgetreten}}
{{vbcomment|Temperatur lesen}}
Messagebuf(1) = Deviceread {{vbcomment|Adresse von DS1621}}
Messagebuf(2) = 0
Messagebuf(3) = 0
Anzahlbuf = 3 {{vbcomment|3 Byte ausgeben, bzw. einlesen}}
Call Usi_twi_start_transceiver
{{vbcomment|Print Hex(usi_twi_errorstate)}}

If Usi_twi_errorstate = 0 Then {{vbcomment|kein Fehler aufgetreten}}

Call Usi_twi_master_stop
{{vbcomment|Print Hex(usi_twi_errorstate)}}

{{vbcomment|Gelesenen Bytes stehen ab Position 2 im Array}}
Lowtemp = Messagebuf(2)
Hightemp = Messagebuf(3)

{{vbcomment|Negativer Wert ?}}
If Lowtemp.7 = 1 Then
Lowtemp = Not Lowtemp
{{vbcomment|.5 ?}}
If &H80 > Hightemp Then
Incr Lowtemp
End If
Print "-" ;
Else
Print " " ;
End If

Print Lowtemp ; "," ;

If Hightemp = &H80 Then
Print "5"
Else
Print "0"
End If

End If
End If
End If

If Usi_twi_errorstate <> 0 Then {{vbcomment|bei einem Fehler den Fehlercode ausgeben}}
Print "Error " ; Hex(usi_twi_errorstate)
End If

{{vbcomment|nochmal initialisieren falls ein Fehler aufgetreten ist}}
Call Usi_twi_master_initialise

Waitms 2000
Loop

End

=== Unterprogramme für USI-Kommunikation ===

Hier folgen die Unterprogramme für die USI-I2C-Master Kommunikation

==== Initialisierung ====

USI-I2C Pins Initialisieren, und USI-Register setzen für I2C-Master.

{{vbcomment|USI TWI single master initialization function}}
Sub Usi_twi_master_initialise()
{{vbcomment|Direction Out}}
Ddr_usi_scl = 1
Ddr_usi_sda = 1
{{vbcomment|Release SCL & SDA}}
Pout_usi_scl = 1
Pout_usi_sda = 1

{{vbcomment|Preload dataregister with "released level" data.}}
Usidr = &HFF

{{vbcomment|Disable USI Interrupts.}}
{{vbcomment|Set USI in Two-wire mode.}}
{{vbcomment|Software stobe as counter clock source}}
Usicr = &B00101010

{{vbcomment|Statusflags löschen, und Counter auf 0 zurücksetzen.}}
Usisr = &B11110000

End Sub

==== Senden/Empfangen ====

Startbedingung ausgeben, 
versenden der Anzahl der angegebenen Bytes, 
und einen Status zurückgeben, ob die Daten angenommen (ACK) wurden.

{{vbcomment|USI Transmit und Receive Funktion.}}
Sub Usi_twi_start_transceiver()

Usi_twi_errorstate = 0

{{vbcomment|Test if any unexpected conditions have arrived prior to this execution.}}
{{vbcomment|Ist eine Startbedingung aufgetreten ?}}
If Usisr.7 = 1 Then {{vbcomment|USISIF}}
Usi_twi_errorstate = &H02 {{vbcomment|Usi_twi_ue_start_con}}
Exit Sub
End If

{{vbcomment|Ist eine Stopbedingung aufgetreten ?}}
If Usisr.5 = 1 Then {{vbcomment|USIPF}}
Usi_twi_errorstate = &H03 {{vbcomment|Usi_twi_ue_stop_con}}
Exit Sub
End If

{{vbcomment|Ist eine Datenkollision aufgetreten ?}}
If Usisr.4 = 1 Then {{vbcomment|USIDC}}
Usi_twi_errorstate = &H04 {{vbcomment|Usi_twi_ue_data_col}}
Exit Sub
End If

{{vbcomment|Release SCL to ensure that (repeated) Start can be performed}}
Pout_usi_scl = 1
Waitus 1 {{vbcomment|5}}

{{vbcomment|Generate Start Condition}}
Pout_usi_sda = 0 {{vbcomment|Force SDA LOW.}}
{{vbcomment|Waitus 4}}
Pout_usi_scl = 0 {{vbcomment|Pull SCL LOW.}}
Pout_usi_sda = 1 {{vbcomment|Release SDA.}}

{{vbcomment|prüfen ob die Startsequenz vom eigenen USI erkannt wurde}}
If Usisr.7 = 0 Then {{vbcomment|USISIF}}
Usi_twi_errorstate = &H07
Exit Sub
End If

{{vbcomment|RW-Bit : Messagebuf(1).0}}
Rw = Messagebuf(1).0

{{vbcomment|Write address and Read/Write data}}
For Cnt = 1 To Anzahlbuf
{{vbcomment|SlaveAdresse immer Write, sonst auf R/W prüfen}}
If Cnt = 1 Or Rw = 0 Then
{{vbcomment|Write a byte}}
Pout_usi_scl = 0 {{vbcomment|Pull SCL LOW.}}
Usidr = Messagebuf(cnt)
Temp_usisr = Temp_usisr_8bit
Call Usi_twi_master_transfer

{{vbcomment|Clock and verify (N)ACK from slave}}
Ddr_usi_sda = 0 {{vbcomment|Enable SDA as input.}}
Temp_usisr = Temp_usisr_1bit
Call Usi_twi_master_transfer

{{vbcomment|kein ACK gekommen}}
If Temp_usisr.0 = 1 Then
Usi_twi_errorstate = &H05 {{vbcomment|Der Slave hat die Daten mit NACK quittiert}}
If Cnt = 1 Then
Usi_twi_errorstate = &H06 {{vbcomment|Es hat sich kein Slave gemeldet}}
End If
Exit For {{vbcomment|die Schleife bei einem Fehler verlasssen}}
End If
Else
{{vbcomment|Read a Byte}}
Ddr_usi_sda = 0 {{vbcomment|Enable SDA as input.}}
Temp_usisr = Temp_usisr_8bit
Call Usi_twi_master_transfer

Messagebuf(cnt) = Temp_usisr {{vbcomment|Empfangenes Byte ins Array}}

{{vbcomment|Prepare to generate ACK (or NACK in case of End Of Transmission)}}
If Cnt = Anzahlbuf Then
Usidr = &HFF {{vbcomment|Load NACK to confirm End Of Transmission.}}
Else
Usidr = &H00 {{vbcomment|Load ACK. Set data register bit 7 (output for SDA) low.}}
End If

Temp_usisr = Temp_usisr_1bit
Call Usi_twi_master_transfer {{vbcomment|ACK oder NACK senden}}

End If
Next Cnt

End Sub

==== Ein Byte ausgeben/einlesen ====

Diese Routine gibt die Anzahl Bit aus, wie anhand der Variablen ''Temp_usisr'' eingestellt wurde, bzw. es wird damit die Anzahl Takte angegeben, die der Counter des USI-Moduls zählt bevor er überläuft, und das Flag ''USIOIF'' im Status-Register ''USISR'' gesetzt wird.

Getaktet wird hier per Software, pro Bit zwei Takte. Bei jedem Takt ändert sich der Zustand (High/Low) von SCL.

Die Daten, die ausgegeben werden sollen, müssen vor dem Aufruf dieser Routine in das Datenregister ''USIDR'' geschrieben werden.

Ob ein Bit ausgegeben oder gelesen wird, wird vor dem Aufruf im Datenrichtungsregister der Datenleitung SDA eingestellt. Im Beispiel mit dem Alias ''Ddr_usi_sda''.

Das gelesene Byte von ''USIDR'' wird in die Variable ''Temp_usisr'' geschrieben, und kann vom Hauptprogramm weiterverarbeitet werden.

Sub Usi_twi_master_transfer()
Usisr = Temp_usisr

Temp_usisr = &B00101011 {{vbcomment|for Toggle Clock Port.}}

Do
{{vbcomment|Waitus 5}}
Usicr = Temp_usisr {{vbcomment|SCL takten}}
{{vbcomment|Wait for SCL to go high.}}
While Pin_usi_scl = 0
Wend

{{vbcomment|Waitus 4}}
Usicr = Temp_usisr {{vbcomment|SCL takten}}

Loop Until Usisr.6 = 1 {{vbcomment|USIOIF, Wenn der Zähler überläuft, sind alle Bits versendet.}}

{{vbcomment|Waitus 5}}
Temp_usisr = Usidr {{vbcomment|Daten aus USI-Datenregister lesen.}}
Usidr = &HFF {{vbcomment|Release SDA.}}

Ddr_usi_sda = 1 {{vbcomment|Enable SDA as output.}}

End Sub

==== STOP-Bedingung ausgeben ====

STOP-Bedingung ausgeben, und prüfen ob dies vom eigenen Modul erkannt wurde. 
Status zurückgeben, ob die STOP-Bedingung erfolgreich ausgegeben wurde.

{{vbcomment|Function for generating a TWI Stop Condition. Used to release the TWI bus.}}
Sub Usi_twi_master_stop()

Pout_usi_sda = 0 {{vbcomment|Pull SDA LOW.}}
Pout_usi_scl = 1 {{vbcomment|Release SCL.}}

{{vbcomment|Wait for SCL to go high.}}
While Pin_usi_scl = 0
Wend
{{vbcomment|Waitus 4}}
Pout_usi_sda = 1 {{vbcomment|Release SDA.}}
Waitus 1 {{vbcomment|5}}

{{vbcomment|prüfen ob die Stopsequenz vom eigenen USI erkannt wurde}}
If Usisr.5 = 0 Then {{vbcomment|USIPF}}
Usi_twi_errorstate = &H08
{{vbcomment| Exit Sub ' Exit nicht nötig, da schon das Ende erreicht}}
End If

Usisr.5 = 1 {{vbcomment|USIPF zurücksetzen}}
End Sub

----

=== Fehlercodes aus den Beispielen ===

Wenn ein unerwartetes Ereignis auftreten sollte, wird eine Zahl ausgegeben, hier ist deren Bedeutung dazu.
Die Fehlercodes wurden aus den Beispielen von Atmel übernommen. (siehe Weblinks)

<div align="center">
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Code || Kurzbezeichnung || Fehlerbeschreibung
|-
|align="center"|02
| USI_TWI_UE_START_CON || Unerwartete Start Bedingung aufgetreten
|-
|align="center"|03
| USI_TWI_UE_STOP_CON || Unerwartete Stop Bedingung aufgetreten
|-
|align="center"|04
| USI_TWI_UE_DATA_COL || Unerwartete Data Collision (arbitration)
|-
|align="center"|05
| USI_TWI_NO_ACK_ON_DATA || Der Slave hat die Daten nicht per ACK quittiert
|-
|align="center"|06
| USI_TWI_NO_ACK_ON_ADDRESS || Es hat sich kein Slave per ACK gemeldet
|-
|align="center"|07
| USI_TWI_MISSING_START_CON || Erzeugte Start Bedingung nicht erkannt
|-
|align="center"|08
| USI_TWI_MISSING_STOP_CON || Erzeugte Stop Bedingung nicht erkannt
|}
</div>

== USI-I2C-Slave ==

Da der I2C-Master den Takt vorgibt, sind die [[TWI#Anmerkung_zur_CPU-Frequenz|Anmerkungen zur CPU-Frequenz]] zu beachten.

In den Beispielen wird als Master das Board [[RN-Mega8]] mit einem [[ATMega8|Mega8]], und als Slave das [[RN-Control]] Board, mit dem Adapter auf dem der [[ATtiny2313|Tiny2313]] sitzt, verwendet. Da nur diese beiden Boards am Bus hängen, wurde ebenfalls als Slaveadresse 64 (0x40 bzw. &H40) verwendet, damit man die vorhergehenden Beispiele gleich weiterverwenden kann.

----

=== Transmitter ===

;auf Abruf Senden

Der Slave wird von einem Master über eine festgelegte Adresse angesprochen, ein (oder mehrere) Byte werden zum Master übertragen und anschließend die Übertragung beendet.

Das Gegenstück wäre ''Master Receiver''.

Das Beispielprogramm gibt Bytewerte zurück, die sich bei jeder Abfrage um eins erhöhen. Verwendet man beim Master das Beispiel von ''Master Receiver'', wird der Wert nach jeder Eingabe von Enter angezeigt.
{{vbcomment|USI-I2C-Slave test}}
{{vbcomment|zum simulieren eines PCF8574}}

Do
Loop

End

----

=== Receiver ===

;Nur Empfangen

Der Slave wird von einem Master über eine festgelegte Adresse angesprochen, ein (oder mehrere) Byte werden zum Slave übertragen und anschließend die Übertragung beendet.

Das Gegenstück wäre ''Master Transmitter''.

Das Beispielprogramm gibt die Bytewerte an PortC aus (aber nur die oberen 6 bit, da die beiden unteren für I2C verwendet werden), an dem beim RN-Control eine LED-Reihe angeschlossen ist. Verwendet man beim Master das Beispiel von ''Master Transmitter'', wird der Wert, den man dort eingibt, am Slave Binär angezeigt.
{{vbcomment|TWI-slave test}}
{{vbcomment|zum Simulieren eines PCF8574}}

Do
Loop

End

----

== Siehe auch ==

* [[Avr]] - Infos zu AVR allgemein
* [[I2C|I2C]] - Details zu I2C
* [[TWI]] - Two-wire Serial Interface
* [[SPI]] - Serial Peripheral Interface
* [[TWI Praxis]] - Bascom-Beispiele für Hardware TWI
* [[TWI Praxis Multimaster]] - Bascom-Beispiele für Hardware TWI

==WebLinks==
* [http://www.roboternetz.de/phpBB2/viewtopic.php?t=25058] - Thread im Forum der zu diesem hier geführt hat
* [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=71&products_id=107] - DS1621 bei Robotikhardware
* [http://www.atmel.com/dyn/resources/prod_documents/doc2561.pdf Atmel_AVR310] - Using the USI module as a I2C master
* [http://www.atmel.com/dyn/resources/prod_documents/doc2560.pdf Atmel_AVR312] - Using the USI module as a I2C slave

= Baustelle =
{{Baustelle|Linux_80}}

--[[Benutzer:Linux 80|Linux 80]] 02:11, 26. Nov 2006 (CET)

[[Kategorie:Abkürzung]]
[[Kategorie:Grundlagen]]
[[Kategorie:Kommunikation]]
[[Kategorie:Microcontroller]]
[[Kategorie:Elektronik]]
[[Kategorie:Praxis]]
[[Kategorie:Software]]
[[Kategorie:Quellcode Bascom]]

AT90S2313

2006-12-23T20:34:42Z

Pit49:

'''Versorgungspannung:'''
::AT90S2313-4: 2.7V - 6V
::AT90S2313-10: 4V - 6V
::ATTiny2313-20: 1.8V - 5.5V
'''Flash-Programm-Speicher:''' 2kByte 
'''EEPROM-Datenspeicher:''' 128Byte 
'''SRAM-Datenspeicher:''' 128 Byte 
'''Taktfrequenz:'''
::AT90S2313-4: bis 4MHz
::AT90S2313-10: bis 10MHz
::ATTiny2313-20: bis 20MHz
'''Features:'''
* Full Duplex UART
* ein 8-bit Timer
* ein 16-bit Timer mit PWM, InputCapture, external Clock
* Analog-Comparator
* 15 digitale I/O-Ports
* programmierbarer Watchdog-Timer
'''weitere Features beim Tiny2313:'''
* 4 PWM Kanäle beim Tiny2313
* 18 digitale I/O-Ports wenn kein externer Quarz und kein Reset benutzt werden
* [[USI (Avr)|Universelle serielle Schnittstelle (USI)]], damit kann [[TWI]] oder [[SPI]] nachgebildet werden
* Pin Change Interrupts an PortB
* Debug-wire
* Interner RC-Oszillator bis 8 MHz
* erweiterte USART, mit Parity-Bit usw.

Der AT90S2313 ist heute veraltet. Der Hersteller empfiehlt, für neue Designs den [[ATtiny2313]] zu verwenden.

[[Bild:at90s2313tiny.png|center]]

==Siehe auch==
* [[Atmel]]
* [[AVR]]
* [[HEX Beispiel-Dateien für AVR]]

== Packages==
* PDIP 20
* SOIC 20

==Weblinks==
* [http://www.atmel.com/dyn/resources/prod_documents/DOC0839.PDF Datenblatt des AT90S2313 (englisches PDF, 92 Seiten, 1.6 MByte)]
* [http://www.atmel.com/dyn/resources/prod_documents/doc4298.pdf AVR091: Replacing AT90S2313 by ATtiny2313 (englisches PDF, 11 Seiten, 118 kByte)]
* [http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf Datenblatt des ATTiny2313 (englisches PDF, 231 Seiten, 2MB)]

[[Kategorie:Microcontroller]]
[[Kategorie:Grundlagen]]
[[Kategorie:Elektronik]]