| 
23.02.2010
 | 
14:07

USB-Gerät per libftdi in C und Python ansprechen (Debian/Ubuntu)

Der FTDI-Chip ist bei einfachen USB-Geräten relativ weit verbreitet. Er simuliert eine serielle Schnittstelle am USB-Port. Wer selbst einfache Geräte programmieren will, kann FTDI unter Linux mit der offenen Bibliothek libftdi nutzen. Im folgenden Tutorial wird ein einfaches Beispiel zum Ansprechen des Chips mit Hilfe dieser Bibliothek gezeigt.

Das Beispiel ist recht einfach gestaltet: Eine Leuchtdiode (LED) wird mittels USB an einem Rechner angeschlossen und soll bei bestimmten Ereignissen leuchten. Anwendungsfälle lassen sich eine ganze Reihe ausdenken:

  • Die Diode soll leuchten, wenn neue E-Mail-Nachrichten vorliegen.
  • Die LED soll leuchten, wenn Netzwerkpakete empfangen und/oder abgeschickt werden.
  • Die Diode blinkt im Takt zur Musik, die auf dem Rechner gespielt wird.
  • Eine Infrarot-Diode kann als Fernbedienung benutzt werden. Der Computer kann damit den Fernseher oder DVD-Spieler steuern.

Diese Fälle übersteigen die Ansprüche dieses Tutorials und sollten als Anregung verstanden werden. Der erste Fall wird in einem neuen Artikel behandelt werden, dann jedoch mittels Perl und der Bibliothek D2XX. Das folgende Tutorial behandelt die von Intra2Net entwickelte Bibliothek libftdi.

Hardware

Neben dem Rechner werden einige Elektronikteile benötigt: Eine einfache Leuchtdiode (LED) ist das zentrale Bauteil. Diese wird an ein FTDI-Breakout-Board angeschlossen. Günstige Boards gibt es von SparkFun (Abb. 1). In Deutschland kann man diese Boards leicht bei Watterott beziehen. Es genügt das Board „FTDI Basic Breakout - 3.3V oder 5V” oder ein „FT232R Breakout” mit 3,3V, wie sie in Abbildung 1 zu sehen sind. Alternativ kann auch USB-zu RS232R-Kabel verwendet werden, was ebenfalls günstig ist. Bei den meisten Anschlüssen ist es sinnvoll das LED mit einem 220 Ω-Widerstand (rot-rot-braun-gold) abzusichern.

FTDI-Breakout-Boards von Sparkfun
Abbildung 1: Links das 3,3V FT232R-Breakout-Board, das alle 8 RS232-Ausgänge besitzt, rechts das Basic Board (hier 5V) mit vier Ausgängen.

Elektronikkomponeten
Abbildung 2: FTDI-Breakout-Board mit USB-Kabel, LED (difus, 5mm), 220 Ω-Widerstand.

Der Kostenpunkt der gesamten Hardware samt USB-Kabel liegt in etwa zwischen 15 und 20 EUR. Für ein paar Euro mehr kann man z.B. bei Conrad Electronic schöne Gehäuse erstehen, in die die LED-Anzeige eingebaut werden kann.

FDTI-Treiber installieren

Aktuelle Linux-Kernels erkennen den FTDI-Chip zumeist ohne Probleme, sofern das Kernel-Modul ftdi_sio vorhanden ist. Prüfen kann man dies, indem man ein Breakout-Board an einen freien USB-Port anschließt und auf der Kommandozeile lsmod | grep ftdi eingibt. Das Modul ftdi_sio sollte als geladen in der Liste erscheinen. Falls das nicht der Fall ist, kann man die Module per Hand nachladen: sudo modprobe ftdi_sio. Sollte das zu Fehlermeldungen führen, ist das Modul entweder nicht im Kernel, oder es liegen andere Probleme vor. dmesg mag in diesem Fall Aufschluss über mögliche Fehler geben.

Ist das Modul installiert und wird der FTDI-Chip richtig erkannt, ist alles gut! dmesg gibt auch im Erfolgsfall entsprechende Informationen, sobald ein USB-Kabel mit FTDI-Chip angesteckt wird. Zur Überwachung kann man den Befehl tail -f /var/log/messages eingeben (ggf. mit vorangestelltem sudo) und den Chip danach einstecken. Nachrichten wie "Detected FT232RL" oder "FTDI USB Serial Device converter now attached to ttyUSB" sollten im Message-Log erscheinen.

Unter Debian und Ubuntu liegt die Bibliothek von Intra2net in zwei Paketvarianten vor: Einmal als libftdi1 und einmal als libftdipp1. Letztere ist die C++-Version, während es sich bei der ersten um jene in C handelt. Im Tutorial benutzen wir nur die C-Variante.

Für das unten gezeigte Beispiel wird neben einem C-Compiler (gcc und am besten auch noch libc6-dev) das Paket libftdi-dev benötigt. Die C++-Variante des Entwicklungspaket heißt demzufolge libftdipp-dev.

Hilfe, ich will nicht root sein!

Debian, zumindest Lenny, scheint die Berechtigungen für den Zugriff auf FTDI richtig zu setzen. Beim Einstecken eines FTDI-Geräts sollte im Verzeichnis /dev/ ein Eintrag ttyUSBx erscheinen, wobei x für die Ziffer 0 oder höher steht (je nachdem, wie viele Geräte angeschlossen sind). Die Berechtigungen sollten idealerweise auf 660 für den Benutzer root und die Gruppe dialout gesetzt sein.

Unter Ubuntu funktioniert das Ganze nicht out-of-the-box. Hier darf nur root auf das Gerät zugreifen, was beim Einsatz des Geräts sicher nicht im Sinne des Erfinders ist. Schuld daran sind fehlende Einstellungen im udev-Subsystem (In Debian sind diese vorhanden). Man kann dies sehr einfach erreichen, indem man als root eine Datei /etc/udev/rules.d/40-permissions.rules mit folgendem Inhalt anlegt:

# USB-Serial Converter FTDI
ATTR{idVendor}=="0403", ATTR{idProduct}=="6001", MODE="660", GROUP="dialout"

Anmerkung: ATTR wird von neueren udev-Versionen benutzt. Bei älteren wird stattdessen SYSFS verwendet.

ID von Vendor und Produkt sind die des FTDI-Chips. Mit lsusb kann überprüft werden, ob die Nummern auch die des eingesteckten Geräts sind. Es gibt möglicherweise FTDI-kompatible Chips mit anderen Nummern, soweit ich das im Internet erkennen konnte. Falls die Nummern nicht übereinstimmen sollten, kann man die obige Zeile einfach entsprechend abändern. Nach dem Eintragen sollte man das udev-System neu starten: sudo /etc/init.d/udev restart. Unter Karmic oder einem anderen Upstart-System genügt: sudo restart udev.

Der aktuelle Benutzer (also der, der auf das Gerät zugreifen will) muss Mitglied der Gruppe dialout sein! Prüfen lässt sich das mit groups. Falls man noch nicht Mitglied der Gruppe ist, hilft ein sudo usermod -a -G dialout <user>. <user> muss natürlich mit dem eigentlichen Benutzernamen ersetzt werden. Danach muss man ggf. seine Sitzung (oder den Terminal) neu starten, um als Mitglied der Gruppe geführt zu werden. Nun kann man das Gerät auch ohne root-Rechte ansprechen!

FTDI/RS232-Basics

FTDI-Einführungen gibt es einige, deshalb will ich mich hier kurz fassen: Die serielle Standardschnittstelle RS232 haben viele Rechner heute nicht mehr. Sie wird mit einer Spannung von bis zu ±12 V betrieben und besitzt bis zu 8 Anschlüsse. USB unterscheidet sich stark davon: Sie Spannung beträgt maximal 5V (zumindest bei Standardanschlüssen) und es existieren nur 2 Anschlüsse. Darüber hinaus ist das USB-Protokoll relativ komplex und verlangt beispielsweise eine Gerätedetektion u.ä. Details des Datenaustauschs werden von libftdi übernommen und sind in diesem Tutorial daher nicht von Belang.

Wie wird FTDI nun angesprochen? Je nach Breakout-Board kann man maximal 8 Ausgänge für den Ein- und Ausgang von Signalen benutzen. Zusätzlich existiert noch ein serieller Datentransfer, wie er bei seriellen Geräten zum Einsatz kommt. Beispiele dafür sind Modems. Solche Geräte können per Terminalemulator angesprochen werden – unter Linux sei hier auf kermit, minicom, picocom und gtkterm verwiesen, wobei libftdi diesen Modus auch beherrscht. Im Terminalmodus empfängt das Endgerät einzelne Zeichen vom Rechner über die TX-Leitung und schickt ggf. Daten über RX zurück. Dazu wird eine Baudrate gesetzt.

In den anderen Modi werden die Signale direkt, d.h. die Leitungen unter Strom gesetzt bzw. Signaleingänge abgefragt. Es gibt zwei Modi: einen „Standard”- oder „einfachen” Modus und den sog. „Bitbang”-Modus. Im einfachen Modus ist festgelegt, welche Leitungen zum Empfangen von Daten und welche zum Abschicken dieser fungieren. Im Bitbang-Modus können die Leitungen über ein Bitmaske beliebig für den Ein- und Ausgang definiert werden. Folgende Tabelle gibt eine Übersicht über die Leitungen:

Leitung

Name

Bitbang-Bit

Ein-/Ausgang

TX

Transmit Data

0

A

RX

Receive Data

1

E

RTS

Request to Send

2

A

CTS

Clear to Send

3

E

DTR

Data Terminal Ready

4

A

DSR

Dataset Ready

5

E

DCD

Data Carrier Detect

6

E

RI

Ring Indicator

7

E

Im Gegensatz zu der Bibliothek FTD2XX bietet libftdi weniger Möglichkeiten, um Pins direkt im einfachen Modus anzusprechen (nicht, dass das viele wären). Deshalb ist die Verwendung des Bitbang-Modus fast immer sinnvoll, außer man muss lediglich ein oder zwei Ausgänge ansprechen.

Versuchsaufbau

Zum Testen bauen wir einen kleinen Versuchsaufbau auf einer Steckplatine (Breadboad) auf: Zum Einsatz kommt das 5V-FTDI-Breakout und drei LEDs. Mit anderen Worten: Es wird eine einfache Ampel simuliert. Abb. 3 zeigt die verwendeten Komponenten: 3 LEDs, 3 Widerstände (wie oben), ein Kabel und eine kurze Steckleiste. Dazu kommt eine Steckplatine. Der Versuchsaufbau wird so gebaut, wie in Abb. 4 gezeigt. Das braune Kabel wird dabei mit dem 5V-Anschluss verbunden, die Widerstände und die LEDs werden jeweils paarweise hintereinandergeschaltet und mit DTR, RX und TX verbunden. Es ist darauf zu achten, dass die Anode (der längere Fuß) der LEDs in Richtung 5V gelegt wird.

Kompontenten des Versuchsaufbaus
Abbildung 3: Kompontenten des Versuchsaufbaus.

Versuchsaufbau
Abbildung 4: Versuchsaufbau

Nun ist das Ganze bereit!

Programmieren mit libftdi: Beispiel in C

Die Bibliothek libftdi ist in C geschrieben und logischerweise am einfachsten von C aus anzusprechen. Im Folgenden findet sich ein Listing, das eine einfache deutsche Ampelschaltung simuliert. Das Beispiel ist von einem Listing auf Hack-A-Day und der libftdi-API inspiriert worden.

Quelltext:  Alles auswählen  |  Zeilennummerierung an/aus
  1. /* ampel.c
  2.  
  3.    Einfache Ampel-Simulation für libftdi
  4.    (c) 2010 Maximilian Kalus
  5. */
  6.  
  7. /* Konstanten für die Schalter im Bitbang-Modus */
  8. #define PIN_TX  0x01
  9. #define PIN_RX  0x02
  10. #define PIN_RTS 0x04
  11. #define PIN_CTS 0x08
  12. #define PIN_DTR 0x10
  13. #define PIN_DSR 0x20
  14. #define PIN_DCD 0x40
  15. #define PIN_RI  0x80
  16.  
  17. /* Includes */
  18. #include <stdio.h>
  19. #include <ftdi.h>
  20.  
  21. /* Ampelphasen */
  22. void rot(struct ftdi_context *ftdic) {
  23.     unsigned char c = 255 - PIN_DTR;
  24.     printf("Rot: Alles anhalten!\n");
  25.     ftdi_write_data(ftdic, &c, 1);
  26. }
  27.  
  28. void gelb(struct ftdi_context *ftdic) {
  29.     unsigned char c = 255 - PIN_RX;
  30.     printf("Gelb: Jetzt noch schnell rueber!\n");
  31.     ftdi_write_data(ftdic, &c, 1);
  32. }
  33.  
  34. void rotgelb(struct ftdi_context *ftdic) {
  35.     unsigned char c = 255 - PIN_RX - PIN_DTR;
  36.     printf("Rot-Gelb: Bereit?\n");
  37.     ftdi_write_data(ftdic, &c, 1);
  38. }
  39.  
  40. void gruen(struct ftdi_context *ftdic) {
  41.     unsigned char c = 255 - PIN_TX;
  42.     printf("Gruen: Los! Los!\n");
  43.     ftdi_write_data(ftdic, &c, 1);
  44. }
  45.  
  46. /* Hauptprogramm */
  47. int main() {
  48.     int ret; /* für Rückgabewerte */
  49.     struct ftdi_context ftdic; /* FTDI-Kontext - enthält Datenstruktur */
  50.     unsigned char c = 255; /* für Pinbelegung */
  51.  
  52.     /* Kontext initialisieren */
  53.     if (ftdi_init(&ftdic) < 0) {
  54.         fprintf(stderr, "ftdi_init fehlgeschlagen\n");
  55.         return EXIT_FAILURE;
  56.     }
  57.    
  58.     /* Öffne FTDI-Chip FT232R - evt. andere Nummern eintragen! */
  59.     if ((ret = ftdi_usb_open(&ftdic, 0x0403, 0x6001)) < 0) {
  60.         fprintf(stderr, "Konnte Geraet nicht oeffnen: %d (%s)\n",
  61.             ret, ftdi_get_error_string(&ftdic));
  62.         return EXIT_FAILURE;
  63.     }
  64.    
  65.     /* Chip-Id vom Typ R auslesen (individuelle ID) */
  66.     if (ftdic.type == TYPE_R) {
  67.         unsigned int chipid;
  68.         ftdi_read_chipid(&ftdic, &chipid);
  69.         printf("Oeffnete Geraet-Id: %X\n", chipid);
  70.     }
  71.  
  72.     /* Bitbag mit DTR, RX und TX beginnen */
  73.     ftdi_enable_bitbang(&ftdic, PIN_DTR | PIN_RX | PIN_TX);
  74.    
  75.     /* Am Anfang ausschalten */
  76.     ftdi_write_data(&ftdic, &c, 1);
  77.    
  78.     /* Ampelschaltung dreimal durchlaufen */
  79.     int i;
  80.     for (i = 0; i < 3; i++) {
  81.         gruen(&ftdic);
  82.         sleep(5); /* 5 sec grün */
  83.         gelb(&ftdic);
  84.         sleep(2); /* 2 sec gelb */
  85.         rot(&ftdic);
  86.         sleep(5); /* 5 sec rot */
  87.         rotgelb(&ftdic);
  88.         sleep(1); /* 1 sec gelb-rot */
  89.     }
  90.  
  91.     /* Am Ende ausschalten */
  92.     ftdi_write_data(&ftdic, &c, 1);
  93.  
  94.     /* Schließe Gerät */
  95.     if ((ret = ftdi_usb_close(&ftdic)) < 0) {
  96.         fprintf(stderr, "Konnte Geraet nicht schliessen: %d (%s)\n",
  97.             ret, ftdi_get_error_string(&ftdic));
  98.         return EXIT_FAILURE;
  99.     }
  100.  
  101.     /* De-Initialiserung */
  102.     ftdi_disable_bitbang(&ftdic);
  103.     ftdi_deinit(&ftdic);
  104.    
  105.     return EXIT_SUCCESS; /* alles gut */
  106. }

Das Listing besitzt einige Ampel-Funktionen und die obligatorische Hauptfunktion am Ende. In der Hauptfunktion wird zuerst der FTDI-Kontext definiert (Z. 49). Dabei handelt es sich um eine Datenstruktur, welche alle relevanten Daten für das Gerät enthält. Danach wird der Kontext initialisert (Z. 53–56) und das Gerät geöffnet (Z. 59–63). Im Anschluss wird noch die Id des Geräts ausgelesen, was allerdings nicht bei allen Geräten funktioniert (Z. 66–70).

Nun kommt der eigentlich spannende Teil: Die Ampelschaltung an sich. Dazu wird das Gerät in den Bitbang-Modus versetzt (Z. 73) und die drei Pins DTR, RX und TX als schreibende Ausgänge gesetzt. Die Ampel muss zunächst ausgeschaltet werden (Z. 76). Grund dafür ist, dass die Belegung in unserem Fall gewissermaßen invertiert ist: Da die LEDs am +5V-Pol angeschlossen sind, leuchten sie nach Aktivierung des Bitbang-Modus. Im Gegensatz zum Beispiel von Hack-A-Day habe ich die LEDs an diesen Pol angeschlossen, da zumindest beim Sparkfun-Gerät ein Anschluss an Ground den LEDs nur ein sehr schwaches Glimmen entlocken konnte. Nun ja…

Die Ampelschaltung wird dreimal durchlaufen (Z. 79–89): Am Anfang soll die Ampel fünf Sekunden lang grün zeigen, dann 2 Sekunden lang auf gelb stehen, bevor weitere 5 Sekunden lang der Verkehr gestoppt wird. Dann wird kurz gelb-rot gezeigt, bevor man wieder losfahren kann. Zum Umschalten werden die Funktionen aufgerufen (Z. 22–44). Da die Schaltung, wie gesagt, invertiert ist, werden die Zahlenwerte der Leitungen von 255 abgezogen. Dadurch wird das relevante Bit auf 0 gesetzt und die LED leuchtet. Schön ist dies bei der gelb-rot-Schaltung sichtbar, da hier ja zwei LEDs gleichzeitig leuchten.

Am Ende des Programms werden alle Leitungen ausgeschaltet und das Gerät de-initialisert (Z. 92–103). So einfach geht's!

Kompiliert wird das Programm mit dem Aufruf cc -lftdi -o ampel ampel.c. Wichtig ist, dass libftdi-dev und ein C-Kompiler installiert sind (s.o.). Aufgerufen wird das Programm dann einfach mit ./ampel.

Programmieren mit libftdi: Beispiel in Python

Das zweite Listing zeigt die Ampelschaltung in Python. Die Bindings sind dabei automatisch mit Hilfe von swig für Python erstellt worden. Python ruft demnach tatsächlich die C-Funktionen der Bibliothek auf.

Unter Debian und Ubuntu kann man die Python-Verbindung zu libftdi mit sudo apt-get install python-ftdi installieren. Damit kann man in Python das Modul ftdi importieren und die Funktionen wie in C aufrufen. Probleme hatte ich allerdings mit ftdi_read_chipid. Hier verlangte der Python-Wrapper eine unsigned int, die ich jedoch nicht liefern konnte, selbst als ich das libc-Modul importiert hatte. Die Python-Bindings sind ansonsten sehr schlecht dokumentiert. Falls jemand einen Tipp hat, bin ich dafür sehr dankbar!

Das Python-Programm funktioniert genau wie das C-Programm und kann mit python ampel.py aufgerufen werden.

Quelltext:  Alles auswählen  |  Zeilennummerierung an/aus
  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3. #ampel.py
  4. #Einfache Ampel-Simulation für libftdi
  5. #(c) 2010 Maximilian Kalus
  6.  
  7. #Konstanten für die Schalter im Bitbang-Modus
  8. PIN_TX  = 0x01
  9. PIN_RX  = 0x02
  10. PIN_RTS = 0x04
  11. PIN_CTS = 0x08
  12. PIN_DTR = 0x10
  13. PIN_DSR = 0x20
  14. PIN_DCD = 0x40
  15. PIN_RI  = 0x80
  16.  
  17. #FTDI importieren
  18. import ftdi
  19. import time
  20.  
  21. #Ampelphasen
  22. def rot(ftdic):
  23.     c = chr(255 - PIN_DTR)
  24.     print "Rot: Alles anhalten!"
  25.     ftdi.ftdi_write_data(ftdic, c, 1)
  26.  
  27. def gelb(ftdic):
  28.     c = chr(255 - PIN_RX)
  29.     print "Gelb: Jetzt noch schnell rueber!"
  30.     ftdi.ftdi_write_data(ftdic, c, 1)
  31.  
  32. def rotgelb(ftdic):
  33.     c = chr(255 - PIN_RX - PIN_DTR)
  34.     print "Rot-Gelb: Bereit?"
  35.     ftdi.ftdi_write_data(ftdic, c, 1)
  36.  
  37. def gruen(ftdic):
  38.     c = chr(255 - PIN_TX)
  39.     print "Grün: Los! Los!"
  40.     ftdi.ftdi_write_data(ftdic, c, 1)
  41.  
  42. #Kontext definieren
  43. ftdic = ftdi.ftdi_context()
  44.  
  45. #Kontext initialisieren
  46. if ftdi.ftdi_init(ftdic) < 0:
  47.     print "ftdi_init fehlgeschlagen"
  48.     exit(-1)
  49.  
  50. #Öffne FTDI-Chip FT232R - evt. andere Nummern eintragen!
  51. ret = ftdi.ftdi_usb_open(ftdic, 0x0403, 0x6001)
  52. if (ret) < 0:
  53.     print "Konnte Gerät nicht öffnen:" + ret + "(" + \
  54.         ftdi.ftdi_get_error_string(ftdic) + ")"
  55.     exit(-1)
  56.  
  57. #Chip-Id vom Typ R auslesen - ausgelassen
  58.  
  59. #Bitbag mit DTR, RX und TX beginnen
  60. ftdi.ftdi_enable_bitbang(ftdic, PIN_DTR | PIN_RX | PIN_TX)
  61.  
  62. #Am Anfang ausschalten
  63. ftdi.ftdi_write_data(ftdic, chr(255), 1)
  64.  
  65. for i in range(0, 3):
  66.     gruen(ftdic);
  67.     time.sleep(5); #5 sec grün
  68.     gelb(ftdic);
  69.     time.sleep(2); #2 sec gelb
  70.     rot(ftdic);
  71.     time.sleep(5); #5 sec rot
  72.     rotgelb(ftdic);
  73.     time.sleep(1); #1 sec gelb-rot
  74.  
  75.  
  76. #Am Ende ausschalten
  77. ftdi.ftdi_write_data(ftdic, chr(255), 1)
  78.  
  79. #Schließe Gerät
  80. ret = ftdi.ftdi_usb_close(ftdic)
  81. if ret < 0:
  82.     print "Konnte Gerät nicht schließen:" + ret + "(" + \
  83.         ftdi.ftdi_get_error_string(ftdic) + ")"
  84.     exit(-1)
  85.  
  86. #De-Initialiserung
  87. ftdi.ftdi_disable_bitbang(ftdic);
  88. ftdi.ftdi_deinit(ftdic);
  89. del ftdic
  90.  
  91. exit(0)

So, ich hoffe, das Tutorial hilft dem einen oder anderen. Zu Abschluss noch ein kleines Video zur Präsentation der Ampelschaltung. Viel Spaß!

  •  
  • 11 Kommentare
  •  
Gravatar: E333E333
13.10.2010
20:43

schöner Artikel

Bis jetzt zwar nur überflogen, aber auf den Ersten Blick ein Sehr schöner Artikel. Schön, dass es zu solch spezielleren Themen noch deutsche Artikel gibt :)

Gravatar: MaxMax
13.10.2010
20:46

Re: schöner Artikel

Danke für das Lob!



Ich freue mich über das Feedback - zeigt mir, dass es Sinn macht, auch deutsche Artikel zu solchen Themen zu schreiben :-)



Max.

Gravatar: E333E333
26.10.2010
19:36

Steckleiste

Schonwieder ich ;)

Bin gerade beim Bestellen der nötigen Teile. Wie sieht es denn aus mit den Steckverbindern ? Ich finde nirgendwo eine Referenz, wie Breit die denn sein sollten, damit sie in das Breakoutboard passen. Wäre für eine Antwort dankbar.



MfG, E333

Gravatar: MaxMax
27.10.2010
10:17

Re: Steckleiste

Hallo E333,



die obigen Boards benötigen einen USB-Stecker vom Typ B-Mini (bzw. Mini-B). Am anderen Ende sitzt dann ein A-Stecker, der in den Rechner passt :-)



Viel Spaß,

Max.

Gravatar: E333E333
28.10.2010
20:59

MiniB?

Kann das Wirklich sein, dass das Board einen Mini-B-Stecker braucht ? Auf der Abbildung ist ja klar ein Rechteckiges Profil des Anschlusses zu sehen, mit 4 Pins. Allerdings sieht ein MiniB-Stecker komplett anderst aus. (Vgl. http://de.wikipedia.org/w/index.php?title=Datei:USB-Steckerformen.jpg&filetimestamp=20051220110437 3. von Links !

Gravatar: MaxMax
29.10.2010
19:07

Re: MiniB?

Hallo!



Doch, es ist ein Mini-B :-) Flach und klein.



Max.

Gravatar: LutzLutz
07.12.2010
15:32

Blockschaltbild

Hallo Max,



diese Seite gefällt mir sehr. Kompliment!



Gibt es zu der Ampelsteuerung auch ein Blockschaltbild?



Mfg Lutz

Gravatar: MaxMax
07.12.2010
15:45

Re: Blockschaltbild

Hallo Lutz,



leider nein - die Schaltung ist eigentlich so einfach, dass ich keines malen wollte :-)



Max.

Gravatar: KathrinKathrin
13.12.2010
13:21

Zahlenwerte der Leitungen von 255 abgezogen ?

Hallo,



ein sehr schöner Artikel. Eine Frage hätte ich aber. Wo sehe ich, dass die Schaltung invertiert ist? Ich habe im Datenblatt gesucht aber leider kann ich dort nicht erkennen wo die Belegung inverteirt ist.

Und was ist genau mit dem Satz gemeint? '' Da die LEDs am +5V-Pol angeschlossen sind, leuchten sie nach Aktivierung des Bitbang-Modus '' . Ich bin leider noch etwas unerfahren in Elektronik.



Ich würde mich sehr freuen, wenn mir jemand helfen könnte.



Kathrin :-)

Gravatar: MaxMax
14.12.2010
19:26

Re: Zahlenwerte der Leitungen von 255 abgezogen ?

Hallo Kathrin,



ist schon eine Weile her, seitdem ich das gebastelt habe.Die Schaltung war nicht invertiert, aber ich meine mich daran zu erinnern, dass der Bitbang-Modus die PINs standardmäßig belegt. Es ist also quasi "Strom drauf", so dass die LEDs direkt nach dem Einschalten des Bitbangs leuchten. Um die Ampel zu schalten muss man also die Belegen gewissermaßen "umdrehen", deshalb werden die Werte von 255 abgezogen.



Viele Grüße,

Max.

Gravatar: MartinMartin
20.08.2011
21:45

Martin

Ein sehr schöner Artikel. Ich habe allerdings in Problem :-( Ich arbeite mit Ubuntu 11.04, wenn ich 40-permissions.rules erstelle (IDs sind die gleichen) kann ich leider nicht als normal Benutzer die Datei nicht senden nur als root. Bin auch in der Gruppe dialout:-(

Mein Kommentar
Ich möchte über jeden weiteren Kommentar benachrichtigt werden.

Zurück