Mikrocontroller.net - Benutzerbeiträge [de]

Ports benutzen (GCC)

2008-04-13T15:23:30Z

User-s: /* I2C Treiber installieren (Kernel 2.6) */

[[Category:Linux]]
[[Category:PC-Programmierung]]

==Einleitung==

Über die Ansteuerung der Schnittstellen unter Linux findet man im Internet überall etwas anderes. Die einen sagen, man soll die Schnittstellen über ihre I/O-Adresse (0x3F8,0x2F8,0x378,...) ansteuern, allerdings ist das nicht portabel und funktioniert nur mit Root-Rechten.

Die hier vorgestellte Methode ermöglicht folgendes:
* Zugriff auf Schnittstellen '''ohne''' Root-Berechtigung
* Zugriff auf '''alle''' parallelen oder seriellen Schnittstellen, egal ob USB oder nicht
* einfaches Portieren des Codes auf MacOSX, FreeBSD, ...

Für den weiteren Artikel werden C/C++ Kenntnisse vorausgesetzt, denn die meisten Funktionen werden mit C-Code erklärt.

==Allgemein==

===Zugriffsrechte===
Damit man auf die Schnittstellen zugreifen kann braucht man die passende Berechtigung. Auf meinem Debian-System sehen die Zugriffsrechte so aus: 

<pre>
noway:/# ll /dev/ttyUSB? /dev/ttyS? /dev/parport?
crw-rw---- 1 root lp 99, 0 Feb 28 16:00 /dev/parport0
crw-rw---- 1 root lp 99, 1 Feb 28 16:00 /dev/parport1
crw-rw---- 1 root lp 99, 2 Feb 28 16:00 /dev/parport2
crw-rw---- 1 root lp 99, 3 Feb 28 16:00 /dev/parport3
crw-rw---- 1 root dialout 4, 64 Jan 22 01:11 /dev/ttyS0
crw-rw---- 1 root dialout 4, 65 Jan 22 01:11 /dev/ttyS1
crw-rw---- 1 root dialout 4, 66 Jan 22 01:11 /dev/ttyS2
crw-rw---- 1 root dialout 4, 67 Jan 22 01:11 /dev/ttyS3
crw-rw---- 1 root dialout 188, 0 Jan 22 01:11 /dev/ttyUSB0
crw-rw---- 1 root dialout 188, 1 Jan 22 01:11 /dev/ttyUSB1
crw-rw---- 1 root dialout 188, 2 Jan 22 01:11 /dev/ttyUSB2
crw-rw---- 1 root dialout 188, 3 Jan 22 01:11 /dev/ttyUSB3
</pre>

Damit der User auf die Schnittstellen zugreifen kann, muss er in die Gruppen "lp" und "dialout" eingetragen werden. Wie das funktioniert kann man hier nachlesen: http://www.tuxhausen.de/kurs_user.html

==Schnittstellen öffnen und schliessen==
===Schnittstelle mit open(2) öffnen===
Bevor man auf eine Schnittstelle zugreifen kann muss man diese mit open(2) öffnen:

<pre>
int port;
port = open("/dev/ttyS0", O_RDWR);
if ( port == -1 )
{
// FEHLER: Port konnte nicht geöffnet werden!
}
</pre>

Wenn das Programm beendet wird sollte man diese auch wieder schliessen:

<pre>
close( port );
</pre>

===Schnittstelle mit fopen(3) öffnen===

Öffnen:

<pre>
#include <stdio.h>
...
FILE* port;
port = fopen("/dev/ttyS0", "rw");
if ( port == NULL )
{
// ein FEHLER ist aufgetreten
}
</pre>

Schliessen:

<pre>
fclose (port);
</pre>

===Warum open(2) und nicht fopen(3)?===

Der Zugriff mittels open(2) ist vorzuziehen, da hierbei deutlich flexiblere IO-Möglichkeiten (z.B. select, poll) zur Verfügung stehen, die sonst nur mittels Umweg über fileno(3) zu erreichen sind. Ferner kann die libc Schreibzugriffe mit fputs o.ä. Puffern, so dass man, um sicher zu stellen, dass die Daten auch tatsächlich übertragen wurden, fsync(3) aufrufen muss.

Natürlich funktionieren beide Methoden.

===Die Namen der Schnittstellen===

Die Schnittstellen die man benutzen kann sind unter anderem:

{| border=1 cellpadding=5
| ''die RS-232 Schnittstellen''
| /dev/ttyS0
| /dev/ttyS1
| /dev/ttySx
|-
| ''die USB-RS232 Schnittstellen''
| /dev/ttyUSB0
| /dev/ttyUSB1
| /dev/ttyUSBx
|-
| ''die parallelen Schnittstellen''
| /dev/parport0
| /dev/parport1
| /dev/parportx
|-
| ''die USB-parallelen Schnittstellen''
| /dev/?
| /dev/?
| /dev/?
|-
| ''der I2C-/SM-Bus''
| /dev/i2c-0
| /dev/i2c-1
| /dev/i2c-x
|}

==Serielle Schnittstelle==

Die Serielle Schnittstelle besitzt 3 Ausgangspins (TX,RTS,DTR) und 5 Eingangspins (RX,DCD,DSR,CTS,RI).

Der Zugriff auf die serielle Schnittstelle erfolgt entweder:
* auf Protokollebene, oder
* auf Pinebene (Pin1 -> an, Pin2 -> aus, ...)

===Die Pinebene===

Die Pins der Seriellen Schnittstelle können '''ohne vorherige Konfiguration''' gelesen/gesetzt werden. Der Zugriff auf die Pins erfolgt über ioctl(2). Dabei muss beachtet werden dass dieser Zugriff '''ohne Interrupts''' und '''ohne FIFO''' erfolgt, daher ist es eine polling-only Lösung, aber für die Programmierung eines Chip's über ISP oder die Ansteuerung eines Schieberegisters reicht es allemal.

====Die Pins DCD,DSR,CTS,RI lesen====
Die Eingangspins werden mit ioctl(2) gelesen:

<pre>
int i;
ioctl( port, TIOCMGET, &i );

// Jetzt kann abgefragt werden welche Pins gesetzt sind:

if ( (i & TIOCM_CD )==TIOCM_CD ) // Pin DCD
{
// am Pin liegt Spannung an (3 bis 12V)
}
else
{
// am Pin liegt keine Spannung an (0 bis -12V)
}

if ( (i & TIOCM_DSR)==TIOCM_DSR ) // Pin DSR
...
if ( (i & TIOCM_CTS)==TIOCM_CTS ) // Pin CTS
...
if ( (i & TIOCM_RI )==TIOCM_RI ) // Pin RI
...
</pre>

====Die Pins RTS,DTR setzen/löschen====
Aktiviert wird RTS,DTR so:

<pre>
int i = 0;
if (...) i |= TIOCM_RTS; // Pin RTS wird aktiviert (12V)
if (...) i |= TIOCM_DTR; // Pin DTR wird aktiviert (12V)
ioctl( port, TIOCMBIS, &i );
</pre>

Und deaktiviert so:

<pre>
int i = 0;
if (...) i |= TIOCM_RTS; // Pin RTS wird deaktiviert (-12V)
if (...) i |= TIOCM_DTR; // Pin DTR wird deaktiviert (-12V)
ioctl( port, TIOCMBIC, &i );
</pre>

====Den Pin TX setzen/löschen====
Aktiviert wird TX so:

<pre>
ioctl( port, TIOCSBRK, NULL );
</pre>

Und deaktiviert so:

<pre>
ioctl( port, TIOCCBRK, NULL );
</pre>

===Die Protokollebene===
Üblicherweise steuert man die serielle Schnittstelle nicht auf der Pinebene an, sondern auf der Protokollebene. Dabei übernimmt die Hardware die Aufgabe, die Pins zu steuern. Um die Schnittstelle auf der Protokollebene zu benutzen, muss man:

* die Schnittstelle öffnen
* die Schnittstelle konfigurieren
* die Daten mit read(2) lesen und mit write(2) schreiben
* die Schnittstelle schließen

====Konfigurieren====
Vor der Benutzung muss die RS232-Schnittstelle erstmal konfiguriert werden. Dazu verwendet man tcsetattr(3). Vorher allerdings nicht vergessen, die alten Einstellungen mit tcgetattr(3) zu sichern, um sie bei Beendigung des Programmes wiederherzustellen. Dies sollte zwar eigentlich nicht nötig sein, aber es gibt fehlerhafte Programme, die nicht mehr funktionieren, wenn man exotische Einstellungen getätigt hat und den Zustand der seriellen Schnittstelle nicht wiederhergestellt hat.

=====Konfiguration lesen=====
<pre>
struct termios config;
// int tcgetattr ( int fd, struct termios *termios_p );
if ( tcgetattr( port, &config ) == -1 )
{
// error
}
</pre>

=====Konfiguration schreiben=====
<pre>
struct termios config;
// int tcsetattr ( int fd, int optional_actions, struct termios *termios_p );
if ( tcsetattr( port, TCSANOW, &config ) == -1 )
{
// error
}
</pre>

=====Eigene Konfiguration erstellen=====
Auszug aus <bits/termios.h>:

<pre>
struct termios
{
tcflag_t c_iflag; /* input mode flags */
tcflag_t c_oflag; /* output mode flags */
tcflag_t c_cflag; /* control mode flags */
tcflag_t c_lflag; /* local mode flags */
cc_t c_line; /* line discipline */
cc_t c_cc[NCCS]; /* control characters */
speed_t c_ispeed; /* input speed */
speed_t c_ospeed; /* output speed */
};
</pre>

<pre>
struct termios config; // struct erstellen
bzero( &config, sizeof(config) ); // struct nullen

config.c_iflag = ; // flags setzen
config.c_oflag = ;
config.c_cflag = ;
config.c_lflag = ;
config.c_cc[x] = ;

cfsetospeed( &config, B9600 ); // baudrate setzen

// jetzt kann die konfiguration der schnittstelle zugewiesen werden
if ( tcsetattr( port, TCSANOW, &config ) == -1 )
{
// error
}
</pre>

====Daten lesen/schreiben====
Mit read(2) kann man nun Daten von der Schnittstelle lesen. Wenn keine Daten anliegen und man read(2) aufruft, blockiert der Aufruf den weiteren Programmablauf. Dies kann man durch benutzen von [http://www.pronix.de/pronix-66.html select(2)] verhindern.

<pre>
int bytes;
char buffer[ x ];
bytes = read( port, buffer, sizeof( buffer ) );
// read(2) gibt die Anzahl der gelesenen Bytes zurück
</pre>

Möchte man Daten über die Schnittstelle senden, muss man dafür write(2) verwenden. Dieser Aufruf blockt für gewöhnlich nicht.

<pre>
int bytes;
int size;
char buffer[ x ];
bytes = write( port, buffer, size );
// write(2) gibt die Anzahl der tatsächlich geschriebenen Bytes zurück
if ( bytes != size ) ... // Fehler
</pre>

==Parallele Schnittstelle==
Die parallele Schnittstelle besitzt 8 Datenleitungen, 9 Steuerleitungen und 8 Massepins. Die Datenleitungen können bidirektional verwendet werden (hängt allerdings von den Einstellungen im BIOS-Setup ab, Printer oder SPP reicht nicht; Bidirectional, ECP oder EPP ist erforderlich), die Steuerleitungen haben aber unabhängig von der BIOS-Einstellung eine festgelegte Richtung.

Die benötigte Include-Datei heisst: <linux/ppdev.h>

Der Parallelport kann, wie die serielle Schnittstelle auch, in verschiedenen Modi angesprochen werden, dazu gehören:
* Die Pinebene, nur bei sehr alter Hardware unidirektional, sonst immer bidirektional.
* Die Protokollebene, dazu gehören die Protokolle SPP, EPP und ECP.

===Die Pinebene===
Wer früher den Parallelport unter DOS programmiert hat, wird sicher noch die Register kennen. Unter Linux wird auf diese Register aber nicht mehr direkt zugegriffen. Weil der Kernel jetzt den direkten Zugriff auf die Register steuert, muss man ihm über ioctl() sagen, was er machen soll.

====Die Bits im Register und die dazugehörigen Pins====

{| border=1 cellpadding=5
| ''Registername''
| ''Bit im Register''
| ''Type''
| ''Pin Nummer''
| ''Name''
|-
| rowspan="8" | data
| 7
| rowspan="8" | I/O
| 9
| data bit 7
|-
| 6
| 8
| data bit 6
|-
| 5
| 7
| data bit 5
|-
| 4
| 6
| data bit 4
|-
| 3
| 5
| data bit 3
|-
| 2
| 4
| data bit 2
|-
| 1
| 3
| data bit 1
|-
| 0
| 2
| data bit 0

|-
| rowspan="8" | status
| 7
| rowspan="5" | I
| 11
| busy#
|-
| 6
| 10
| ack#
|-
| 5
| 12
| paper empty
|-
| 4
| 13
| printer is selected
|-
| 3
| 15
| error#
|-
| 2
| rowspan="3" | -
| rowspan="3" | -
| Interrupt has occurred
|-
| 1
| ?
|-
| 0
| ?

|-
| rowspan="8" | control
| 7
| rowspan="4" | -
| rowspan="4" | -
| ?
|-
| 6
| ?
|-
| 5
| ?
|-
| 4
| enable Interrupt
|-
| 3
| rowspan="4" | O
| 17
| select printer
|-
| 2
| 16
| initialize printer#
|-
| 1
| 14
| automatic line feed
|-
| 0
| 1
| strobe
|}

data:
<pre>
Pin 9, I/O, Bit 7 = data bit 7
Pin 8, I/O, Bit 6 = data bit 6
Pin 7, I/O, Bit 5 = data bit 5
Pin 6, I/O, Bit 4 = data bit 4
Pin 5, I/O, Bit 3 = data bit 3
Pin 4, I/O, Bit 2 = data bit 2
Pin 3, I/O, Bit 1 = data bit 1
Pin 2, I/O, Bit 0 = data bit 0
</pre>

status:
<pre>
Pin 11, I, Bit 7 = busy#
Pin 10, I, Bit 6 = ack#
Pin 12, I, Bit 5 = paper empty
Pin 13, I, Bit 4 = printer is selected
Pin 15, I, Bit 3 = error#
Bit 2 = Interrupt has occurred
Bit 1 = ?
Bit 0 = ?
</pre>

control:
<pre>
Bit 7 = ?
Bit 6 = ?
Bit 5 = ?
Bit 4 = enable Interrupt
Pin 17, O, Bit 3 = select printer
Pin 16, O, Bit 2 = initialize printer#
Pin 14, O, Bit 1 = automatic line feed
Pin 1, O, Bit 0 = strobe
</pre>

====Parallelport öffnen====
Das Öffnen der Parallelschnittstelle gestaltet sich ein wenig anders, als das Öffnen der seriellen Schnittstelle. Da an den Parallelport mehrere Geräte gleichzeitig angeschlossen werden können, und Linux das auch unterstüzt, braucht man eine Methode, mit der sich mehrere Programme die Schnittstelle teilen können. Dafür öffnet man die Schnittstelle, genau wie die serielle, erst mit open(2). Danach muss man ppdev sagen, dass man die Schnittstelle auch benutzen mag, das geschieht mit dem PPCLAIM ioctl-call.

<pre>
int port;
port = open( "/dev/parport0", O_RDWR );
ioctl( port, PPCLAIM, NULL );
</pre>

====Parallelport schliessen====
<pre>
ioctl( port, PPRELEASE, NULL );
close( port );
</pre>

====Parallelport lesen/schreiben====
Der Zugriff auf den Port erfolgt über seine Register, zu diesen gehören:
# Das "data" Register,
# "status" Register,
# "control" Register.

=====Register lesen=====
<pre>
unsigned char r;
ioctl( port, PPRCONTROL, &r ); // liest das "control" Register
ioctl( port, PPRSTATUS , &r ); // liest das "status" Register
ioctl( port, PPRDATA , &r ); // liest das "data" Register
</pre>

=====Register schreiben=====
<pre>
unsigned char r;
r = 0xXX;
ioctl( port, PPWCONTROL, &r ); // schreibt das "control" Register
ioctl( port, PPWDATA , &r ); // schreibt das "data" Register
</pre>

====="read modify write" umgehen=====
Wenn man nur ein paar Bits setzen/löschen möchte, könnte man erst den Registerinhalt lesen, die Bits ändern, und den Inhalt wieder schreiben.

Das geht aber besser, weil der Kernel dafür selbst eine Funktion anbietet:

<pre>
/*
struct ppdev_frob_struct {
unsigned char mask;
unsigned char val;
};
*/

ppdev_frob_struct frob;
frob.mask = 0xXX;
frob.val = 0xXX;
ioctl( port, PPFCONTROL, &frob ); // ändert Bits im "control" Register
// new_control = (old_control & ~mask) | val;

</pre>

Diese Funktion ist nur für das control Register verfügbar.

====Parallelport [[Ausgangsstufen_Logik-ICs#Tri-state|Tri-State]]-Modus aktivieren====
Bei deaktiviertem Tri-State-Modus treibt der Port die Datenleitungen. Dabei ist der Zustand vom data Register abhängig.

Wenn man nun den Tri-State-Modus aktiviert, treibt der Port die Datenleitungen nicht mehr. Nun kann man den Zustand der Datenleitungen über das data Register lesen.

<pre>
int i;
i = 0; // Tri-State '''aus''' (Der PC treibt die Data-Leitungen)
i = 1; // Tri-State '''an''' (Der PC treibt die Data-Leitungen '''nicht''')
ioctl( port, PPDATADIR, &i );
</pre>

===Die Protokollebene SPP===
(to do)

===Die Protokollebene EPP (IEEE 1284)===
(to do)

==Der I2C Bus & SMBus==
Für den Linuxkernel gibt es auch I2C und SMBus Treiber, in Kernelversion 2.5 und 2.6 sind diese schon drin. Für Version 2.4 muss man diese extra installieren.

Wer es nicht so genau wissen möchte, kann sich einfach merken, das der SMBus ein I2C-Bus ist. Wer den SMBus aber ansteuern möchte, muss sich mit den kleinen Unterschieden aueinandersetzen. Hierfür wird auf das AN476 von Maxim verwiesen: http://www.maxim-ic.com/appnotes.cfm/appnote_number/476

=== Software ===
==== I2C u. SMBus Treiber installieren (Kernel 2.4) ====
Auf meinem Debian läuft ein selbstkompilierter Kernel, deswegen musste ich die Pakete i2c-source und sensors-source installieren. Voraussetzung ist das die Kernelquellen installiert sind.

<pre>
apt-get install i2c-source lm-sensors-source
</pre>

Danach liegen in /usr/src/ zwei *.tar Dateien:

<pre>
noway:/usr/src# ll
-rw-r--r-- 1 root root 146976 Apr 15 2005 i2c.tar.gz
-rw-r--r-- 1 root root 924605 Sep 12 2005 lm-sensors.tar.gz
</pre>

Diese muss man nun auspacken, danach in das Verzeichniss modules/i2c wechseln, und make ausführen:

<pre>
noway:/usr/src# cd modules/i2c
noway:/usr/src/modules/i2c# make
noway:/usr/src/modules/i2c# make install
noway:/usr/src/modules/i2c# cd ../..
</pre>

Und das gleiche nochmal für das lm-sensors-source Paket.

<pre>
noway:/usr/src# cd modules/lm-sensors
noway:/usr/src/modules/lm-sensors# make
noway:/usr/src/modules/lm-sensors# make install
</pre>

Danach wird man um diese Programme reicher:

<pre>
i2cdetect
i2cdump
i2cset
isadump
isaset
sensors-detect
sensors
...
</pre>

Jetzt sollte man die /dev/ Einträge erstellen:

<pre>
noway:~# cd /dev
noway:/dev# ./MAKEDEV i2c
noway:/dev# l i2c-*
crw------- 1 root root 89, 0 Mar 17 21:00 i2c-0
crw------- 1 root root 89, 1 Mar 17 21:00 i2c-1
crw------- 1 root root 89, 2 Mar 17 21:00 i2c-2
crw------- 1 root root 89, 3 Mar 17 21:00 i2c-3
crw------- 1 root root 89, 4 Mar 17 21:00 i2c-4
crw------- 1 root root 89, 5 Mar 17 21:00 i2c-5
crw------- 1 root root 89, 6 Mar 17 21:00 i2c-6
crw------- 1 root root 89, 7 Mar 17 21:00 i2c-7
</pre>

Damit kann jetzt nur "root" etwas anfangen. Damit die normalen Benutzer den Bus benutzen können, muss man eine neue Gruppe erstellen und die Zugriffsrechte anpassen:

<pre>
noway:/dev# groupadd i2c
noway:/dev# chmod 660 i2c-*
noway:/dev# chgrp i2c i2c-*
</pre>

Danach sollte es so aussehen:

<pre>
noway:/dev# l i2c-*
crw-rw---- 1 root i2c 89, 0 Mar 17 21:00 i2c-0
crw-rw---- 1 root i2c 89, 1 Mar 17 21:00 i2c-1
crw-rw---- 1 root i2c 89, 2 Mar 17 21:00 i2c-2
crw-rw---- 1 root i2c 89, 3 Mar 17 21:00 i2c-3
crw-rw---- 1 root i2c 89, 4 Mar 17 21:00 i2c-4
crw-rw---- 1 root i2c 89, 5 Mar 17 21:00 i2c-5
crw-rw---- 1 root i2c 89, 6 Mar 17 21:00 i2c-6
crw-rw---- 1 root i2c 89, 7 Mar 17 21:00 i2c-7
</pre>

Jetzt muss man sensors-detect aufrufen. Danach sollte für den SMBus das richtige Modul geladen sein. Mit "modprobe i2c-pport" kann man das Parallelport-I2C-Modul laden.

Welche Busse nun verfügbar sind, kann man mit "cat /proc/bus/i2c" erfahren.

Mit i2cdetect kann man jetzt die verfügbaren Busse scannen:

<pre>
noway:~# i2cdetect -l
i2c-0 smbus SMBus Via Pro adapter at e800 Non-I2C SMBus adapter
i2c-1 i2c Primitive Parallel port adaptor Bit-shift algorithm
</pre>

<pre>
noway:~# i2cdetect -y 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: XX XX XX XX XX XX XX XX XX XX XX XX XX
10: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
20: XX XX XX XX XX XX XX XX XX XX XX XX XX UU XX XX
30: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
40: XX XX XX XX XX XX XX XX UU UU XX XX XX XX XX XX
50: 50 XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
60: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
70: XX XX XX XX XX XX XX XX
</pre>

<pre>
noway:~# i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: XX XX XX XX XX XX XX XX XX XX XX XX XX
10: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
20: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
30: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
40: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
50: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
60: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
70: XX XX XX XX XX XX XX XX
</pre>

==== I2C Treiber installieren (Kernel 2.6) ====
Hier [http://www.mikrocontroller.net/wikifiles/4/4d/I2c-pport-26.tar.gz] gibt es die angepassten Sourcen für das i2c-pport Modul, dieses muss man selbst kompilieren. Der Rest funktioniert wie oben für Kernel 2.4 beschrieben. 
Wichtig ist, dass man die Module lp und parport_pc auf die Blacklist setzt und den Parallelport im SPP-Modus betreibt (Bios-Einstellung). Dieser kleine Treiber benötigt keine weitere Hardware. (Quelle: [http://2z4gn8.blogspot.com/2008/04/saa1064-sieben-segment-anzeige-via-i2c.html])

==== I2C Bus öffnen/schliessen ====
Den Bus öffnet man nun genau wie die anderen Schnittstellen:

<pre>
int bus;
bus = open( "/dev/i2c-0", O_RDWR );
if ( bus == -1 )
{
// error
}
</pre>

<pre>
close( bus );
</pre>

Die include-Datei <linux/i2c-dev.h> wird benötigt, ggf. auch <linux/i2c.h>.

==== I2C Bus steuern (ioctl) ====
An einem I2C-Bus können viele Chips angeschlossen werden, damit der Kernel weiss, mit welchem er Kontakt aufnehmen muss, braucht man diesen ioctl-call:

<pre>
uint8_t slave_addr = 0xXX;
ioctl( bus, I2C_SLAVE, slave_addr );
</pre>

"slave_addr" ist in diesem Fall die I2C-Adresse von dem Chip, den man ansprechen möchte.

==== I2C Bus lesen/schreiben ====
Nachdem man eine Slave-Adresse zugewiesen hat, kann man den selektierten Chip mit read(2) und write(2) ansprechen:

<pre>
char buffer[256];
uint16_t bytes;
bytes = read( bus, buffer, sizeof(buffer) );
</pre>

==== SMBus Zugriffe ====

=== Hardware ===
==== Der interne SMBus ====
Hier gibt es eine Beschreibung, wie man den SMBus findet: http://secure.netroedge.com/~lm78/hardhack.html

==== Externe I2C Busse ====
===== Parallelport-Bitbang Dongle =====

Für Linux gibt es ein Kernelmodul namens "i2c-pport". Das ist ein I2C-Bus über den Parallelport. Dieser Bus ist erschreckend einfach aufgebaut: es werden bis auf zwei Stecker '''keine''' Bauteile benötigt. Die notwendigen Verbindungen sehen so aus:

{| border=1 cellpadding=5
| Parallelport
| I2C-Bus
|-
| 14
| SDA
|-
| 16
| SCL
|-
| 18-25
| GND
|}

Das funktioniert nur deswegen, weil der Parallelport [[Ausgangsstufen_Logik-ICs#Open-collector|Open-Collector]] Ausgänge mit Pullup-Widerständen besitzt, und mehr braucht man für einen I2C-Bus nicht. Der PC kann die Leitungen SDA und SCL übrigends auch lesen.

===== Parallelport I2C-Bus Adapter mit PCF8584 =====
(to do)

==Verweise auf man-pages==
Die manpages können online betrachtet werden unter http://www.rt.com/man/

===Dateien öffnen===
-> open(2)
http://www.rt.com/man/open.2.html

===Dateien schliessen===
-> close(2)
http://www.rt.com/man/close.2.html

===Dateien lesen===
-> read(2)
http://www.rt.com/man/read.2.html

===Dateien schreiben===
-> write(2)
http://www.rt.com/man/write.2.html

===Besonderer Dateizugriff===
-> ioctl(2)
http://www.rt.com/man/ioctl.2.html

===Abfragen ob Daten zum lesen bereit sind===
-> select(2)
http://www.rt.com/man/select.2.html

==Benötigte include Dateien==

===write(2) read(2) close(2)===
<pre>
#include <unistd.h>
</pre>

===open(2)===
<pre>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
</pre>

===ioctl(2)===
<pre>
#include <sys/ioctl.h>
</pre>

===select(2)===
<pre>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
</pre>

=== für I2C und SMBus ===
<pre>
#include <linux/i2c-dev.h>
#include <linux/i2c.h> //zumindest für 2.6.x
</pre>

== Siehe auch ==

* [[Ports benutzen (PHP)]]
* [[Ports benutzen (Windows)]]
* [http://www.mikrocontroller.net/topic/93089#803530 Forumsbeitrag]: Sourcecode RS232 bzw. V24 in C unter Linux

Ports benutzen (GCC)

2008-04-13T15:21:32Z

User-s: /* I2C Bus öffnen/schliessen */

[[Category:Linux]]
[[Category:PC-Programmierung]]

==Einleitung==

Über die Ansteuerung der Schnittstellen unter Linux findet man im Internet überall etwas anderes. Die einen sagen, man soll die Schnittstellen über ihre I/O-Adresse (0x3F8,0x2F8,0x378,...) ansteuern, allerdings ist das nicht portabel und funktioniert nur mit Root-Rechten.

Die hier vorgestellte Methode ermöglicht folgendes:
* Zugriff auf Schnittstellen '''ohne''' Root-Berechtigung
* Zugriff auf '''alle''' parallelen oder seriellen Schnittstellen, egal ob USB oder nicht
* einfaches Portieren des Codes auf MacOSX, FreeBSD, ...

Für den weiteren Artikel werden C/C++ Kenntnisse vorausgesetzt, denn die meisten Funktionen werden mit C-Code erklärt.

==Allgemein==

===Zugriffsrechte===
Damit man auf die Schnittstellen zugreifen kann braucht man die passende Berechtigung. Auf meinem Debian-System sehen die Zugriffsrechte so aus: 

<pre>
noway:/# ll /dev/ttyUSB? /dev/ttyS? /dev/parport?
crw-rw---- 1 root lp 99, 0 Feb 28 16:00 /dev/parport0
crw-rw---- 1 root lp 99, 1 Feb 28 16:00 /dev/parport1
crw-rw---- 1 root lp 99, 2 Feb 28 16:00 /dev/parport2
crw-rw---- 1 root lp 99, 3 Feb 28 16:00 /dev/parport3
crw-rw---- 1 root dialout 4, 64 Jan 22 01:11 /dev/ttyS0
crw-rw---- 1 root dialout 4, 65 Jan 22 01:11 /dev/ttyS1
crw-rw---- 1 root dialout 4, 66 Jan 22 01:11 /dev/ttyS2
crw-rw---- 1 root dialout 4, 67 Jan 22 01:11 /dev/ttyS3
crw-rw---- 1 root dialout 188, 0 Jan 22 01:11 /dev/ttyUSB0
crw-rw---- 1 root dialout 188, 1 Jan 22 01:11 /dev/ttyUSB1
crw-rw---- 1 root dialout 188, 2 Jan 22 01:11 /dev/ttyUSB2
crw-rw---- 1 root dialout 188, 3 Jan 22 01:11 /dev/ttyUSB3
</pre>

Damit der User auf die Schnittstellen zugreifen kann, muss er in die Gruppen "lp" und "dialout" eingetragen werden. Wie das funktioniert kann man hier nachlesen: http://www.tuxhausen.de/kurs_user.html

==Schnittstellen öffnen und schliessen==
===Schnittstelle mit open(2) öffnen===
Bevor man auf eine Schnittstelle zugreifen kann muss man diese mit open(2) öffnen:

<pre>
int port;
port = open("/dev/ttyS0", O_RDWR);
if ( port == -1 )
{
// FEHLER: Port konnte nicht geöffnet werden!
}
</pre>

Wenn das Programm beendet wird sollte man diese auch wieder schliessen:

<pre>
close( port );
</pre>

===Schnittstelle mit fopen(3) öffnen===

Öffnen:

<pre>
#include <stdio.h>
...
FILE* port;
port = fopen("/dev/ttyS0", "rw");
if ( port == NULL )
{
// ein FEHLER ist aufgetreten
}
</pre>

Schliessen:

<pre>
fclose (port);
</pre>

===Warum open(2) und nicht fopen(3)?===

Der Zugriff mittels open(2) ist vorzuziehen, da hierbei deutlich flexiblere IO-Möglichkeiten (z.B. select, poll) zur Verfügung stehen, die sonst nur mittels Umweg über fileno(3) zu erreichen sind. Ferner kann die libc Schreibzugriffe mit fputs o.ä. Puffern, so dass man, um sicher zu stellen, dass die Daten auch tatsächlich übertragen wurden, fsync(3) aufrufen muss.

Natürlich funktionieren beide Methoden.

===Die Namen der Schnittstellen===

Die Schnittstellen die man benutzen kann sind unter anderem:

{| border=1 cellpadding=5
| ''die RS-232 Schnittstellen''
| /dev/ttyS0
| /dev/ttyS1
| /dev/ttySx
|-
| ''die USB-RS232 Schnittstellen''
| /dev/ttyUSB0
| /dev/ttyUSB1
| /dev/ttyUSBx
|-
| ''die parallelen Schnittstellen''
| /dev/parport0
| /dev/parport1
| /dev/parportx
|-
| ''die USB-parallelen Schnittstellen''
| /dev/?
| /dev/?
| /dev/?
|-
| ''der I2C-/SM-Bus''
| /dev/i2c-0
| /dev/i2c-1
| /dev/i2c-x
|}

==Serielle Schnittstelle==

Die Serielle Schnittstelle besitzt 3 Ausgangspins (TX,RTS,DTR) und 5 Eingangspins (RX,DCD,DSR,CTS,RI).

Der Zugriff auf die serielle Schnittstelle erfolgt entweder:
* auf Protokollebene, oder
* auf Pinebene (Pin1 -> an, Pin2 -> aus, ...)

===Die Pinebene===

Die Pins der Seriellen Schnittstelle können '''ohne vorherige Konfiguration''' gelesen/gesetzt werden. Der Zugriff auf die Pins erfolgt über ioctl(2). Dabei muss beachtet werden dass dieser Zugriff '''ohne Interrupts''' und '''ohne FIFO''' erfolgt, daher ist es eine polling-only Lösung, aber für die Programmierung eines Chip's über ISP oder die Ansteuerung eines Schieberegisters reicht es allemal.

====Die Pins DCD,DSR,CTS,RI lesen====
Die Eingangspins werden mit ioctl(2) gelesen:

<pre>
int i;
ioctl( port, TIOCMGET, &i );

// Jetzt kann abgefragt werden welche Pins gesetzt sind:

if ( (i & TIOCM_CD )==TIOCM_CD ) // Pin DCD
{
// am Pin liegt Spannung an (3 bis 12V)
}
else
{
// am Pin liegt keine Spannung an (0 bis -12V)
}

if ( (i & TIOCM_DSR)==TIOCM_DSR ) // Pin DSR
...
if ( (i & TIOCM_CTS)==TIOCM_CTS ) // Pin CTS
...
if ( (i & TIOCM_RI )==TIOCM_RI ) // Pin RI
...
</pre>

====Die Pins RTS,DTR setzen/löschen====
Aktiviert wird RTS,DTR so:

<pre>
int i = 0;
if (...) i |= TIOCM_RTS; // Pin RTS wird aktiviert (12V)
if (...) i |= TIOCM_DTR; // Pin DTR wird aktiviert (12V)
ioctl( port, TIOCMBIS, &i );
</pre>

Und deaktiviert so:

<pre>
int i = 0;
if (...) i |= TIOCM_RTS; // Pin RTS wird deaktiviert (-12V)
if (...) i |= TIOCM_DTR; // Pin DTR wird deaktiviert (-12V)
ioctl( port, TIOCMBIC, &i );
</pre>

====Den Pin TX setzen/löschen====
Aktiviert wird TX so:

<pre>
ioctl( port, TIOCSBRK, NULL );
</pre>

Und deaktiviert so:

<pre>
ioctl( port, TIOCCBRK, NULL );
</pre>

===Die Protokollebene===
Üblicherweise steuert man die serielle Schnittstelle nicht auf der Pinebene an, sondern auf der Protokollebene. Dabei übernimmt die Hardware die Aufgabe, die Pins zu steuern. Um die Schnittstelle auf der Protokollebene zu benutzen, muss man:

* die Schnittstelle öffnen
* die Schnittstelle konfigurieren
* die Daten mit read(2) lesen und mit write(2) schreiben
* die Schnittstelle schließen

====Konfigurieren====
Vor der Benutzung muss die RS232-Schnittstelle erstmal konfiguriert werden. Dazu verwendet man tcsetattr(3). Vorher allerdings nicht vergessen, die alten Einstellungen mit tcgetattr(3) zu sichern, um sie bei Beendigung des Programmes wiederherzustellen. Dies sollte zwar eigentlich nicht nötig sein, aber es gibt fehlerhafte Programme, die nicht mehr funktionieren, wenn man exotische Einstellungen getätigt hat und den Zustand der seriellen Schnittstelle nicht wiederhergestellt hat.

=====Konfiguration lesen=====
<pre>
struct termios config;
// int tcgetattr ( int fd, struct termios *termios_p );
if ( tcgetattr( port, &config ) == -1 )
{
// error
}
</pre>

=====Konfiguration schreiben=====
<pre>
struct termios config;
// int tcsetattr ( int fd, int optional_actions, struct termios *termios_p );
if ( tcsetattr( port, TCSANOW, &config ) == -1 )
{
// error
}
</pre>

=====Eigene Konfiguration erstellen=====
Auszug aus <bits/termios.h>:

<pre>
struct termios
{
tcflag_t c_iflag; /* input mode flags */
tcflag_t c_oflag; /* output mode flags */
tcflag_t c_cflag; /* control mode flags */
tcflag_t c_lflag; /* local mode flags */
cc_t c_line; /* line discipline */
cc_t c_cc[NCCS]; /* control characters */
speed_t c_ispeed; /* input speed */
speed_t c_ospeed; /* output speed */
};
</pre>

<pre>
struct termios config; // struct erstellen
bzero( &config, sizeof(config) ); // struct nullen

config.c_iflag = ; // flags setzen
config.c_oflag = ;
config.c_cflag = ;
config.c_lflag = ;
config.c_cc[x] = ;

cfsetospeed( &config, B9600 ); // baudrate setzen

// jetzt kann die konfiguration der schnittstelle zugewiesen werden
if ( tcsetattr( port, TCSANOW, &config ) == -1 )
{
// error
}
</pre>

====Daten lesen/schreiben====
Mit read(2) kann man nun Daten von der Schnittstelle lesen. Wenn keine Daten anliegen und man read(2) aufruft, blockiert der Aufruf den weiteren Programmablauf. Dies kann man durch benutzen von [http://www.pronix.de/pronix-66.html select(2)] verhindern.

<pre>
int bytes;
char buffer[ x ];
bytes = read( port, buffer, sizeof( buffer ) );
// read(2) gibt die Anzahl der gelesenen Bytes zurück
</pre>

Möchte man Daten über die Schnittstelle senden, muss man dafür write(2) verwenden. Dieser Aufruf blockt für gewöhnlich nicht.

<pre>
int bytes;
int size;
char buffer[ x ];
bytes = write( port, buffer, size );
// write(2) gibt die Anzahl der tatsächlich geschriebenen Bytes zurück
if ( bytes != size ) ... // Fehler
</pre>

==Parallele Schnittstelle==
Die parallele Schnittstelle besitzt 8 Datenleitungen, 9 Steuerleitungen und 8 Massepins. Die Datenleitungen können bidirektional verwendet werden (hängt allerdings von den Einstellungen im BIOS-Setup ab, Printer oder SPP reicht nicht; Bidirectional, ECP oder EPP ist erforderlich), die Steuerleitungen haben aber unabhängig von der BIOS-Einstellung eine festgelegte Richtung.

Die benötigte Include-Datei heisst: <linux/ppdev.h>

Der Parallelport kann, wie die serielle Schnittstelle auch, in verschiedenen Modi angesprochen werden, dazu gehören:
* Die Pinebene, nur bei sehr alter Hardware unidirektional, sonst immer bidirektional.
* Die Protokollebene, dazu gehören die Protokolle SPP, EPP und ECP.

===Die Pinebene===
Wer früher den Parallelport unter DOS programmiert hat, wird sicher noch die Register kennen. Unter Linux wird auf diese Register aber nicht mehr direkt zugegriffen. Weil der Kernel jetzt den direkten Zugriff auf die Register steuert, muss man ihm über ioctl() sagen, was er machen soll.

====Die Bits im Register und die dazugehörigen Pins====

{| border=1 cellpadding=5
| ''Registername''
| ''Bit im Register''
| ''Type''
| ''Pin Nummer''
| ''Name''
|-
| rowspan="8" | data
| 7
| rowspan="8" | I/O
| 9
| data bit 7
|-
| 6
| 8
| data bit 6
|-
| 5
| 7
| data bit 5
|-
| 4
| 6
| data bit 4
|-
| 3
| 5
| data bit 3
|-
| 2
| 4
| data bit 2
|-
| 1
| 3
| data bit 1
|-
| 0
| 2
| data bit 0

|-
| rowspan="8" | status
| 7
| rowspan="5" | I
| 11
| busy#
|-
| 6
| 10
| ack#
|-
| 5
| 12
| paper empty
|-
| 4
| 13
| printer is selected
|-
| 3
| 15
| error#
|-
| 2
| rowspan="3" | -
| rowspan="3" | -
| Interrupt has occurred
|-
| 1
| ?
|-
| 0
| ?

|-
| rowspan="8" | control
| 7
| rowspan="4" | -
| rowspan="4" | -
| ?
|-
| 6
| ?
|-
| 5
| ?
|-
| 4
| enable Interrupt
|-
| 3
| rowspan="4" | O
| 17
| select printer
|-
| 2
| 16
| initialize printer#
|-
| 1
| 14
| automatic line feed
|-
| 0
| 1
| strobe
|}

data:
<pre>
Pin 9, I/O, Bit 7 = data bit 7
Pin 8, I/O, Bit 6 = data bit 6
Pin 7, I/O, Bit 5 = data bit 5
Pin 6, I/O, Bit 4 = data bit 4
Pin 5, I/O, Bit 3 = data bit 3
Pin 4, I/O, Bit 2 = data bit 2
Pin 3, I/O, Bit 1 = data bit 1
Pin 2, I/O, Bit 0 = data bit 0
</pre>

status:
<pre>
Pin 11, I, Bit 7 = busy#
Pin 10, I, Bit 6 = ack#
Pin 12, I, Bit 5 = paper empty
Pin 13, I, Bit 4 = printer is selected
Pin 15, I, Bit 3 = error#
Bit 2 = Interrupt has occurred
Bit 1 = ?
Bit 0 = ?
</pre>

control:
<pre>
Bit 7 = ?
Bit 6 = ?
Bit 5 = ?
Bit 4 = enable Interrupt
Pin 17, O, Bit 3 = select printer
Pin 16, O, Bit 2 = initialize printer#
Pin 14, O, Bit 1 = automatic line feed
Pin 1, O, Bit 0 = strobe
</pre>

====Parallelport öffnen====
Das Öffnen der Parallelschnittstelle gestaltet sich ein wenig anders, als das Öffnen der seriellen Schnittstelle. Da an den Parallelport mehrere Geräte gleichzeitig angeschlossen werden können, und Linux das auch unterstüzt, braucht man eine Methode, mit der sich mehrere Programme die Schnittstelle teilen können. Dafür öffnet man die Schnittstelle, genau wie die serielle, erst mit open(2). Danach muss man ppdev sagen, dass man die Schnittstelle auch benutzen mag, das geschieht mit dem PPCLAIM ioctl-call.

<pre>
int port;
port = open( "/dev/parport0", O_RDWR );
ioctl( port, PPCLAIM, NULL );
</pre>

====Parallelport schliessen====
<pre>
ioctl( port, PPRELEASE, NULL );
close( port );
</pre>

====Parallelport lesen/schreiben====
Der Zugriff auf den Port erfolgt über seine Register, zu diesen gehören:
# Das "data" Register,
# "status" Register,
# "control" Register.

=====Register lesen=====
<pre>
unsigned char r;
ioctl( port, PPRCONTROL, &r ); // liest das "control" Register
ioctl( port, PPRSTATUS , &r ); // liest das "status" Register
ioctl( port, PPRDATA , &r ); // liest das "data" Register
</pre>

=====Register schreiben=====
<pre>
unsigned char r;
r = 0xXX;
ioctl( port, PPWCONTROL, &r ); // schreibt das "control" Register
ioctl( port, PPWDATA , &r ); // schreibt das "data" Register
</pre>

====="read modify write" umgehen=====
Wenn man nur ein paar Bits setzen/löschen möchte, könnte man erst den Registerinhalt lesen, die Bits ändern, und den Inhalt wieder schreiben.

Das geht aber besser, weil der Kernel dafür selbst eine Funktion anbietet:

<pre>
/*
struct ppdev_frob_struct {
unsigned char mask;
unsigned char val;
};
*/

ppdev_frob_struct frob;
frob.mask = 0xXX;
frob.val = 0xXX;
ioctl( port, PPFCONTROL, &frob ); // ändert Bits im "control" Register
// new_control = (old_control & ~mask) | val;

</pre>

Diese Funktion ist nur für das control Register verfügbar.

====Parallelport [[Ausgangsstufen_Logik-ICs#Tri-state|Tri-State]]-Modus aktivieren====
Bei deaktiviertem Tri-State-Modus treibt der Port die Datenleitungen. Dabei ist der Zustand vom data Register abhängig.

Wenn man nun den Tri-State-Modus aktiviert, treibt der Port die Datenleitungen nicht mehr. Nun kann man den Zustand der Datenleitungen über das data Register lesen.

<pre>
int i;
i = 0; // Tri-State '''aus''' (Der PC treibt die Data-Leitungen)
i = 1; // Tri-State '''an''' (Der PC treibt die Data-Leitungen '''nicht''')
ioctl( port, PPDATADIR, &i );
</pre>

===Die Protokollebene SPP===
(to do)

===Die Protokollebene EPP (IEEE 1284)===
(to do)

==Der I2C Bus & SMBus==
Für den Linuxkernel gibt es auch I2C und SMBus Treiber, in Kernelversion 2.5 und 2.6 sind diese schon drin. Für Version 2.4 muss man diese extra installieren.

Wer es nicht so genau wissen möchte, kann sich einfach merken, das der SMBus ein I2C-Bus ist. Wer den SMBus aber ansteuern möchte, muss sich mit den kleinen Unterschieden aueinandersetzen. Hierfür wird auf das AN476 von Maxim verwiesen: http://www.maxim-ic.com/appnotes.cfm/appnote_number/476

=== Software ===
==== I2C u. SMBus Treiber installieren (Kernel 2.4) ====
Auf meinem Debian läuft ein selbstkompilierter Kernel, deswegen musste ich die Pakete i2c-source und sensors-source installieren. Voraussetzung ist das die Kernelquellen installiert sind.

<pre>
apt-get install i2c-source lm-sensors-source
</pre>

Danach liegen in /usr/src/ zwei *.tar Dateien:

<pre>
noway:/usr/src# ll
-rw-r--r-- 1 root root 146976 Apr 15 2005 i2c.tar.gz
-rw-r--r-- 1 root root 924605 Sep 12 2005 lm-sensors.tar.gz
</pre>

Diese muss man nun auspacken, danach in das Verzeichniss modules/i2c wechseln, und make ausführen:

<pre>
noway:/usr/src# cd modules/i2c
noway:/usr/src/modules/i2c# make
noway:/usr/src/modules/i2c# make install
noway:/usr/src/modules/i2c# cd ../..
</pre>

Und das gleiche nochmal für das lm-sensors-source Paket.

<pre>
noway:/usr/src# cd modules/lm-sensors
noway:/usr/src/modules/lm-sensors# make
noway:/usr/src/modules/lm-sensors# make install
</pre>

Danach wird man um diese Programme reicher:

<pre>
i2cdetect
i2cdump
i2cset
isadump
isaset
sensors-detect
sensors
...
</pre>

Jetzt sollte man die /dev/ Einträge erstellen:

<pre>
noway:~# cd /dev
noway:/dev# ./MAKEDEV i2c
noway:/dev# l i2c-*
crw------- 1 root root 89, 0 Mar 17 21:00 i2c-0
crw------- 1 root root 89, 1 Mar 17 21:00 i2c-1
crw------- 1 root root 89, 2 Mar 17 21:00 i2c-2
crw------- 1 root root 89, 3 Mar 17 21:00 i2c-3
crw------- 1 root root 89, 4 Mar 17 21:00 i2c-4
crw------- 1 root root 89, 5 Mar 17 21:00 i2c-5
crw------- 1 root root 89, 6 Mar 17 21:00 i2c-6
crw------- 1 root root 89, 7 Mar 17 21:00 i2c-7
</pre>

Damit kann jetzt nur "root" etwas anfangen. Damit die normalen Benutzer den Bus benutzen können, muss man eine neue Gruppe erstellen und die Zugriffsrechte anpassen:

<pre>
noway:/dev# groupadd i2c
noway:/dev# chmod 660 i2c-*
noway:/dev# chgrp i2c i2c-*
</pre>

Danach sollte es so aussehen:

<pre>
noway:/dev# l i2c-*
crw-rw---- 1 root i2c 89, 0 Mar 17 21:00 i2c-0
crw-rw---- 1 root i2c 89, 1 Mar 17 21:00 i2c-1
crw-rw---- 1 root i2c 89, 2 Mar 17 21:00 i2c-2
crw-rw---- 1 root i2c 89, 3 Mar 17 21:00 i2c-3
crw-rw---- 1 root i2c 89, 4 Mar 17 21:00 i2c-4
crw-rw---- 1 root i2c 89, 5 Mar 17 21:00 i2c-5
crw-rw---- 1 root i2c 89, 6 Mar 17 21:00 i2c-6
crw-rw---- 1 root i2c 89, 7 Mar 17 21:00 i2c-7
</pre>

Jetzt muss man sensors-detect aufrufen. Danach sollte für den SMBus das richtige Modul geladen sein. Mit "modprobe i2c-pport" kann man das Parallelport-I2C-Modul laden.

Welche Busse nun verfügbar sind, kann man mit "cat /proc/bus/i2c" erfahren.

Mit i2cdetect kann man jetzt die verfügbaren Busse scannen:

<pre>
noway:~# i2cdetect -l
i2c-0 smbus SMBus Via Pro adapter at e800 Non-I2C SMBus adapter
i2c-1 i2c Primitive Parallel port adaptor Bit-shift algorithm
</pre>

<pre>
noway:~# i2cdetect -y 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: XX XX XX XX XX XX XX XX XX XX XX XX XX
10: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
20: XX XX XX XX XX XX XX XX XX XX XX XX XX UU XX XX
30: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
40: XX XX XX XX XX XX XX XX UU UU XX XX XX XX XX XX
50: 50 XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
60: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
70: XX XX XX XX XX XX XX XX
</pre>

<pre>
noway:~# i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: XX XX XX XX XX XX XX XX XX XX XX XX XX
10: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
20: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
30: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
40: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
50: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
60: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
70: XX XX XX XX XX XX XX XX
</pre>

==== I2C Treiber installieren (Kernel 2.6) ====
Hier [http://www.mikrocontroller.net/wikifiles/4/4d/I2c-pport-26.tar.gz] gibt es die angepassten Sourcen für das i2c-pport Modul. Funktioniert wie oben für Kernel 2.4 beschrieben. 
Wichtig ist, dass man die Module lp und parport_pc auf die Blacklist setzt und den Parallelport im SPP-Modus betreibt (Bios-Einstellung). Dieser kleine Treiber benötigt keine weitere Hardware. (Quelle: [http://2z4gn8.blogspot.com/2008/04/saa1064-sieben-segment-anzeige-via-i2c.html])

==== I2C Bus öffnen/schliessen ====
Den Bus öffnet man nun genau wie die anderen Schnittstellen:

<pre>
int bus;
bus = open( "/dev/i2c-0", O_RDWR );
if ( bus == -1 )
{
// error
}
</pre>

<pre>
close( bus );
</pre>

Die include-Datei <linux/i2c-dev.h> wird benötigt, ggf. auch <linux/i2c.h>.

==== I2C Bus steuern (ioctl) ====
An einem I2C-Bus können viele Chips angeschlossen werden, damit der Kernel weiss, mit welchem er Kontakt aufnehmen muss, braucht man diesen ioctl-call:

<pre>
uint8_t slave_addr = 0xXX;
ioctl( bus, I2C_SLAVE, slave_addr );
</pre>

"slave_addr" ist in diesem Fall die I2C-Adresse von dem Chip, den man ansprechen möchte.

==== I2C Bus lesen/schreiben ====
Nachdem man eine Slave-Adresse zugewiesen hat, kann man den selektierten Chip mit read(2) und write(2) ansprechen:

<pre>
char buffer[256];
uint16_t bytes;
bytes = read( bus, buffer, sizeof(buffer) );
</pre>

==== SMBus Zugriffe ====

=== Hardware ===
==== Der interne SMBus ====
Hier gibt es eine Beschreibung, wie man den SMBus findet: http://secure.netroedge.com/~lm78/hardhack.html

==== Externe I2C Busse ====
===== Parallelport-Bitbang Dongle =====

Für Linux gibt es ein Kernelmodul namens "i2c-pport". Das ist ein I2C-Bus über den Parallelport. Dieser Bus ist erschreckend einfach aufgebaut: es werden bis auf zwei Stecker '''keine''' Bauteile benötigt. Die notwendigen Verbindungen sehen so aus:

{| border=1 cellpadding=5
| Parallelport
| I2C-Bus
|-
| 14
| SDA
|-
| 16
| SCL
|-
| 18-25
| GND
|}

Das funktioniert nur deswegen, weil der Parallelport [[Ausgangsstufen_Logik-ICs#Open-collector|Open-Collector]] Ausgänge mit Pullup-Widerständen besitzt, und mehr braucht man für einen I2C-Bus nicht. Der PC kann die Leitungen SDA und SCL übrigends auch lesen.

===== Parallelport I2C-Bus Adapter mit PCF8584 =====
(to do)

==Verweise auf man-pages==
Die manpages können online betrachtet werden unter http://www.rt.com/man/

===Dateien öffnen===
-> open(2)
http://www.rt.com/man/open.2.html

===Dateien schliessen===
-> close(2)
http://www.rt.com/man/close.2.html

===Dateien lesen===
-> read(2)
http://www.rt.com/man/read.2.html

===Dateien schreiben===
-> write(2)
http://www.rt.com/man/write.2.html

===Besonderer Dateizugriff===
-> ioctl(2)
http://www.rt.com/man/ioctl.2.html

===Abfragen ob Daten zum lesen bereit sind===
-> select(2)
http://www.rt.com/man/select.2.html

==Benötigte include Dateien==

===write(2) read(2) close(2)===
<pre>
#include <unistd.h>
</pre>

===open(2)===
<pre>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
</pre>

===ioctl(2)===
<pre>
#include <sys/ioctl.h>
</pre>

===select(2)===
<pre>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
</pre>

=== für I2C und SMBus ===
<pre>
#include <linux/i2c-dev.h>
#include <linux/i2c.h> //zumindest für 2.6.x
</pre>

== Siehe auch ==

* [[Ports benutzen (PHP)]]
* [[Ports benutzen (Windows)]]
* [http://www.mikrocontroller.net/topic/93089#803530 Forumsbeitrag]: Sourcecode RS232 bzw. V24 in C unter Linux

Ports benutzen (GCC)

2008-04-13T15:20:21Z

User-s: /* I2C u. SMBus Treiber installieren (Kernel 2.6) */

[[Category:Linux]]
[[Category:PC-Programmierung]]

==Einleitung==

Über die Ansteuerung der Schnittstellen unter Linux findet man im Internet überall etwas anderes. Die einen sagen, man soll die Schnittstellen über ihre I/O-Adresse (0x3F8,0x2F8,0x378,...) ansteuern, allerdings ist das nicht portabel und funktioniert nur mit Root-Rechten.

Die hier vorgestellte Methode ermöglicht folgendes:
* Zugriff auf Schnittstellen '''ohne''' Root-Berechtigung
* Zugriff auf '''alle''' parallelen oder seriellen Schnittstellen, egal ob USB oder nicht
* einfaches Portieren des Codes auf MacOSX, FreeBSD, ...

Für den weiteren Artikel werden C/C++ Kenntnisse vorausgesetzt, denn die meisten Funktionen werden mit C-Code erklärt.

==Allgemein==

===Zugriffsrechte===
Damit man auf die Schnittstellen zugreifen kann braucht man die passende Berechtigung. Auf meinem Debian-System sehen die Zugriffsrechte so aus: 

<pre>
noway:/# ll /dev/ttyUSB? /dev/ttyS? /dev/parport?
crw-rw---- 1 root lp 99, 0 Feb 28 16:00 /dev/parport0
crw-rw---- 1 root lp 99, 1 Feb 28 16:00 /dev/parport1
crw-rw---- 1 root lp 99, 2 Feb 28 16:00 /dev/parport2
crw-rw---- 1 root lp 99, 3 Feb 28 16:00 /dev/parport3
crw-rw---- 1 root dialout 4, 64 Jan 22 01:11 /dev/ttyS0
crw-rw---- 1 root dialout 4, 65 Jan 22 01:11 /dev/ttyS1
crw-rw---- 1 root dialout 4, 66 Jan 22 01:11 /dev/ttyS2
crw-rw---- 1 root dialout 4, 67 Jan 22 01:11 /dev/ttyS3
crw-rw---- 1 root dialout 188, 0 Jan 22 01:11 /dev/ttyUSB0
crw-rw---- 1 root dialout 188, 1 Jan 22 01:11 /dev/ttyUSB1
crw-rw---- 1 root dialout 188, 2 Jan 22 01:11 /dev/ttyUSB2
crw-rw---- 1 root dialout 188, 3 Jan 22 01:11 /dev/ttyUSB3
</pre>

Damit der User auf die Schnittstellen zugreifen kann, muss er in die Gruppen "lp" und "dialout" eingetragen werden. Wie das funktioniert kann man hier nachlesen: http://www.tuxhausen.de/kurs_user.html

==Schnittstellen öffnen und schliessen==
===Schnittstelle mit open(2) öffnen===
Bevor man auf eine Schnittstelle zugreifen kann muss man diese mit open(2) öffnen:

<pre>
int port;
port = open("/dev/ttyS0", O_RDWR);
if ( port == -1 )
{
// FEHLER: Port konnte nicht geöffnet werden!
}
</pre>

Wenn das Programm beendet wird sollte man diese auch wieder schliessen:

<pre>
close( port );
</pre>

===Schnittstelle mit fopen(3) öffnen===

Öffnen:

<pre>
#include <stdio.h>
...
FILE* port;
port = fopen("/dev/ttyS0", "rw");
if ( port == NULL )
{
// ein FEHLER ist aufgetreten
}
</pre>

Schliessen:

<pre>
fclose (port);
</pre>

===Warum open(2) und nicht fopen(3)?===

Der Zugriff mittels open(2) ist vorzuziehen, da hierbei deutlich flexiblere IO-Möglichkeiten (z.B. select, poll) zur Verfügung stehen, die sonst nur mittels Umweg über fileno(3) zu erreichen sind. Ferner kann die libc Schreibzugriffe mit fputs o.ä. Puffern, so dass man, um sicher zu stellen, dass die Daten auch tatsächlich übertragen wurden, fsync(3) aufrufen muss.

Natürlich funktionieren beide Methoden.

===Die Namen der Schnittstellen===

Die Schnittstellen die man benutzen kann sind unter anderem:

{| border=1 cellpadding=5
| ''die RS-232 Schnittstellen''
| /dev/ttyS0
| /dev/ttyS1
| /dev/ttySx
|-
| ''die USB-RS232 Schnittstellen''
| /dev/ttyUSB0
| /dev/ttyUSB1
| /dev/ttyUSBx
|-
| ''die parallelen Schnittstellen''
| /dev/parport0
| /dev/parport1
| /dev/parportx
|-
| ''die USB-parallelen Schnittstellen''
| /dev/?
| /dev/?
| /dev/?
|-
| ''der I2C-/SM-Bus''
| /dev/i2c-0
| /dev/i2c-1
| /dev/i2c-x
|}

==Serielle Schnittstelle==

Die Serielle Schnittstelle besitzt 3 Ausgangspins (TX,RTS,DTR) und 5 Eingangspins (RX,DCD,DSR,CTS,RI).

Der Zugriff auf die serielle Schnittstelle erfolgt entweder:
* auf Protokollebene, oder
* auf Pinebene (Pin1 -> an, Pin2 -> aus, ...)

===Die Pinebene===

Die Pins der Seriellen Schnittstelle können '''ohne vorherige Konfiguration''' gelesen/gesetzt werden. Der Zugriff auf die Pins erfolgt über ioctl(2). Dabei muss beachtet werden dass dieser Zugriff '''ohne Interrupts''' und '''ohne FIFO''' erfolgt, daher ist es eine polling-only Lösung, aber für die Programmierung eines Chip's über ISP oder die Ansteuerung eines Schieberegisters reicht es allemal.

====Die Pins DCD,DSR,CTS,RI lesen====
Die Eingangspins werden mit ioctl(2) gelesen:

<pre>
int i;
ioctl( port, TIOCMGET, &i );

// Jetzt kann abgefragt werden welche Pins gesetzt sind:

if ( (i & TIOCM_CD )==TIOCM_CD ) // Pin DCD
{
// am Pin liegt Spannung an (3 bis 12V)
}
else
{
// am Pin liegt keine Spannung an (0 bis -12V)
}

if ( (i & TIOCM_DSR)==TIOCM_DSR ) // Pin DSR
...
if ( (i & TIOCM_CTS)==TIOCM_CTS ) // Pin CTS
...
if ( (i & TIOCM_RI )==TIOCM_RI ) // Pin RI
...
</pre>

====Die Pins RTS,DTR setzen/löschen====
Aktiviert wird RTS,DTR so:

<pre>
int i = 0;
if (...) i |= TIOCM_RTS; // Pin RTS wird aktiviert (12V)
if (...) i |= TIOCM_DTR; // Pin DTR wird aktiviert (12V)
ioctl( port, TIOCMBIS, &i );
</pre>

Und deaktiviert so:

<pre>
int i = 0;
if (...) i |= TIOCM_RTS; // Pin RTS wird deaktiviert (-12V)
if (...) i |= TIOCM_DTR; // Pin DTR wird deaktiviert (-12V)
ioctl( port, TIOCMBIC, &i );
</pre>

====Den Pin TX setzen/löschen====
Aktiviert wird TX so:

<pre>
ioctl( port, TIOCSBRK, NULL );
</pre>

Und deaktiviert so:

<pre>
ioctl( port, TIOCCBRK, NULL );
</pre>

===Die Protokollebene===
Üblicherweise steuert man die serielle Schnittstelle nicht auf der Pinebene an, sondern auf der Protokollebene. Dabei übernimmt die Hardware die Aufgabe, die Pins zu steuern. Um die Schnittstelle auf der Protokollebene zu benutzen, muss man:

* die Schnittstelle öffnen
* die Schnittstelle konfigurieren
* die Daten mit read(2) lesen und mit write(2) schreiben
* die Schnittstelle schließen

====Konfigurieren====
Vor der Benutzung muss die RS232-Schnittstelle erstmal konfiguriert werden. Dazu verwendet man tcsetattr(3). Vorher allerdings nicht vergessen, die alten Einstellungen mit tcgetattr(3) zu sichern, um sie bei Beendigung des Programmes wiederherzustellen. Dies sollte zwar eigentlich nicht nötig sein, aber es gibt fehlerhafte Programme, die nicht mehr funktionieren, wenn man exotische Einstellungen getätigt hat und den Zustand der seriellen Schnittstelle nicht wiederhergestellt hat.

=====Konfiguration lesen=====
<pre>
struct termios config;
// int tcgetattr ( int fd, struct termios *termios_p );
if ( tcgetattr( port, &config ) == -1 )
{
// error
}
</pre>

=====Konfiguration schreiben=====
<pre>
struct termios config;
// int tcsetattr ( int fd, int optional_actions, struct termios *termios_p );
if ( tcsetattr( port, TCSANOW, &config ) == -1 )
{
// error
}
</pre>

=====Eigene Konfiguration erstellen=====
Auszug aus <bits/termios.h>:

<pre>
struct termios
{
tcflag_t c_iflag; /* input mode flags */
tcflag_t c_oflag; /* output mode flags */
tcflag_t c_cflag; /* control mode flags */
tcflag_t c_lflag; /* local mode flags */
cc_t c_line; /* line discipline */
cc_t c_cc[NCCS]; /* control characters */
speed_t c_ispeed; /* input speed */
speed_t c_ospeed; /* output speed */
};
</pre>

<pre>
struct termios config; // struct erstellen
bzero( &config, sizeof(config) ); // struct nullen

config.c_iflag = ; // flags setzen
config.c_oflag = ;
config.c_cflag = ;
config.c_lflag = ;
config.c_cc[x] = ;

cfsetospeed( &config, B9600 ); // baudrate setzen

// jetzt kann die konfiguration der schnittstelle zugewiesen werden
if ( tcsetattr( port, TCSANOW, &config ) == -1 )
{
// error
}
</pre>

====Daten lesen/schreiben====
Mit read(2) kann man nun Daten von der Schnittstelle lesen. Wenn keine Daten anliegen und man read(2) aufruft, blockiert der Aufruf den weiteren Programmablauf. Dies kann man durch benutzen von [http://www.pronix.de/pronix-66.html select(2)] verhindern.

<pre>
int bytes;
char buffer[ x ];
bytes = read( port, buffer, sizeof( buffer ) );
// read(2) gibt die Anzahl der gelesenen Bytes zurück
</pre>

Möchte man Daten über die Schnittstelle senden, muss man dafür write(2) verwenden. Dieser Aufruf blockt für gewöhnlich nicht.

<pre>
int bytes;
int size;
char buffer[ x ];
bytes = write( port, buffer, size );
// write(2) gibt die Anzahl der tatsächlich geschriebenen Bytes zurück
if ( bytes != size ) ... // Fehler
</pre>

==Parallele Schnittstelle==
Die parallele Schnittstelle besitzt 8 Datenleitungen, 9 Steuerleitungen und 8 Massepins. Die Datenleitungen können bidirektional verwendet werden (hängt allerdings von den Einstellungen im BIOS-Setup ab, Printer oder SPP reicht nicht; Bidirectional, ECP oder EPP ist erforderlich), die Steuerleitungen haben aber unabhängig von der BIOS-Einstellung eine festgelegte Richtung.

Die benötigte Include-Datei heisst: <linux/ppdev.h>

Der Parallelport kann, wie die serielle Schnittstelle auch, in verschiedenen Modi angesprochen werden, dazu gehören:
* Die Pinebene, nur bei sehr alter Hardware unidirektional, sonst immer bidirektional.
* Die Protokollebene, dazu gehören die Protokolle SPP, EPP und ECP.

===Die Pinebene===
Wer früher den Parallelport unter DOS programmiert hat, wird sicher noch die Register kennen. Unter Linux wird auf diese Register aber nicht mehr direkt zugegriffen. Weil der Kernel jetzt den direkten Zugriff auf die Register steuert, muss man ihm über ioctl() sagen, was er machen soll.

====Die Bits im Register und die dazugehörigen Pins====

{| border=1 cellpadding=5
| ''Registername''
| ''Bit im Register''
| ''Type''
| ''Pin Nummer''
| ''Name''
|-
| rowspan="8" | data
| 7
| rowspan="8" | I/O
| 9
| data bit 7
|-
| 6
| 8
| data bit 6
|-
| 5
| 7
| data bit 5
|-
| 4
| 6
| data bit 4
|-
| 3
| 5
| data bit 3
|-
| 2
| 4
| data bit 2
|-
| 1
| 3
| data bit 1
|-
| 0
| 2
| data bit 0

|-
| rowspan="8" | status
| 7
| rowspan="5" | I
| 11
| busy#
|-
| 6
| 10
| ack#
|-
| 5
| 12
| paper empty
|-
| 4
| 13
| printer is selected
|-
| 3
| 15
| error#
|-
| 2
| rowspan="3" | -
| rowspan="3" | -
| Interrupt has occurred
|-
| 1
| ?
|-
| 0
| ?

|-
| rowspan="8" | control
| 7
| rowspan="4" | -
| rowspan="4" | -
| ?
|-
| 6
| ?
|-
| 5
| ?
|-
| 4
| enable Interrupt
|-
| 3
| rowspan="4" | O
| 17
| select printer
|-
| 2
| 16
| initialize printer#
|-
| 1
| 14
| automatic line feed
|-
| 0
| 1
| strobe
|}

data:
<pre>
Pin 9, I/O, Bit 7 = data bit 7
Pin 8, I/O, Bit 6 = data bit 6
Pin 7, I/O, Bit 5 = data bit 5
Pin 6, I/O, Bit 4 = data bit 4
Pin 5, I/O, Bit 3 = data bit 3
Pin 4, I/O, Bit 2 = data bit 2
Pin 3, I/O, Bit 1 = data bit 1
Pin 2, I/O, Bit 0 = data bit 0
</pre>

status:
<pre>
Pin 11, I, Bit 7 = busy#
Pin 10, I, Bit 6 = ack#
Pin 12, I, Bit 5 = paper empty
Pin 13, I, Bit 4 = printer is selected
Pin 15, I, Bit 3 = error#
Bit 2 = Interrupt has occurred
Bit 1 = ?
Bit 0 = ?
</pre>

control:
<pre>
Bit 7 = ?
Bit 6 = ?
Bit 5 = ?
Bit 4 = enable Interrupt
Pin 17, O, Bit 3 = select printer
Pin 16, O, Bit 2 = initialize printer#
Pin 14, O, Bit 1 = automatic line feed
Pin 1, O, Bit 0 = strobe
</pre>

====Parallelport öffnen====
Das Öffnen der Parallelschnittstelle gestaltet sich ein wenig anders, als das Öffnen der seriellen Schnittstelle. Da an den Parallelport mehrere Geräte gleichzeitig angeschlossen werden können, und Linux das auch unterstüzt, braucht man eine Methode, mit der sich mehrere Programme die Schnittstelle teilen können. Dafür öffnet man die Schnittstelle, genau wie die serielle, erst mit open(2). Danach muss man ppdev sagen, dass man die Schnittstelle auch benutzen mag, das geschieht mit dem PPCLAIM ioctl-call.

<pre>
int port;
port = open( "/dev/parport0", O_RDWR );
ioctl( port, PPCLAIM, NULL );
</pre>

====Parallelport schliessen====
<pre>
ioctl( port, PPRELEASE, NULL );
close( port );
</pre>

====Parallelport lesen/schreiben====
Der Zugriff auf den Port erfolgt über seine Register, zu diesen gehören:
# Das "data" Register,
# "status" Register,
# "control" Register.

=====Register lesen=====
<pre>
unsigned char r;
ioctl( port, PPRCONTROL, &r ); // liest das "control" Register
ioctl( port, PPRSTATUS , &r ); // liest das "status" Register
ioctl( port, PPRDATA , &r ); // liest das "data" Register
</pre>

=====Register schreiben=====
<pre>
unsigned char r;
r = 0xXX;
ioctl( port, PPWCONTROL, &r ); // schreibt das "control" Register
ioctl( port, PPWDATA , &r ); // schreibt das "data" Register
</pre>

====="read modify write" umgehen=====
Wenn man nur ein paar Bits setzen/löschen möchte, könnte man erst den Registerinhalt lesen, die Bits ändern, und den Inhalt wieder schreiben.

Das geht aber besser, weil der Kernel dafür selbst eine Funktion anbietet:

<pre>
/*
struct ppdev_frob_struct {
unsigned char mask;
unsigned char val;
};
*/

ppdev_frob_struct frob;
frob.mask = 0xXX;
frob.val = 0xXX;
ioctl( port, PPFCONTROL, &frob ); // ändert Bits im "control" Register
// new_control = (old_control & ~mask) | val;

</pre>

Diese Funktion ist nur für das control Register verfügbar.

====Parallelport [[Ausgangsstufen_Logik-ICs#Tri-state|Tri-State]]-Modus aktivieren====
Bei deaktiviertem Tri-State-Modus treibt der Port die Datenleitungen. Dabei ist der Zustand vom data Register abhängig.

Wenn man nun den Tri-State-Modus aktiviert, treibt der Port die Datenleitungen nicht mehr. Nun kann man den Zustand der Datenleitungen über das data Register lesen.

<pre>
int i;
i = 0; // Tri-State '''aus''' (Der PC treibt die Data-Leitungen)
i = 1; // Tri-State '''an''' (Der PC treibt die Data-Leitungen '''nicht''')
ioctl( port, PPDATADIR, &i );
</pre>

===Die Protokollebene SPP===
(to do)

===Die Protokollebene EPP (IEEE 1284)===
(to do)

==Der I2C Bus & SMBus==
Für den Linuxkernel gibt es auch I2C und SMBus Treiber, in Kernelversion 2.5 und 2.6 sind diese schon drin. Für Version 2.4 muss man diese extra installieren.

Wer es nicht so genau wissen möchte, kann sich einfach merken, das der SMBus ein I2C-Bus ist. Wer den SMBus aber ansteuern möchte, muss sich mit den kleinen Unterschieden aueinandersetzen. Hierfür wird auf das AN476 von Maxim verwiesen: http://www.maxim-ic.com/appnotes.cfm/appnote_number/476

=== Software ===
==== I2C u. SMBus Treiber installieren (Kernel 2.4) ====
Auf meinem Debian läuft ein selbstkompilierter Kernel, deswegen musste ich die Pakete i2c-source und sensors-source installieren. Voraussetzung ist das die Kernelquellen installiert sind.

<pre>
apt-get install i2c-source lm-sensors-source
</pre>

Danach liegen in /usr/src/ zwei *.tar Dateien:

<pre>
noway:/usr/src# ll
-rw-r--r-- 1 root root 146976 Apr 15 2005 i2c.tar.gz
-rw-r--r-- 1 root root 924605 Sep 12 2005 lm-sensors.tar.gz
</pre>

Diese muss man nun auspacken, danach in das Verzeichniss modules/i2c wechseln, und make ausführen:

<pre>
noway:/usr/src# cd modules/i2c
noway:/usr/src/modules/i2c# make
noway:/usr/src/modules/i2c# make install
noway:/usr/src/modules/i2c# cd ../..
</pre>

Und das gleiche nochmal für das lm-sensors-source Paket.

<pre>
noway:/usr/src# cd modules/lm-sensors
noway:/usr/src/modules/lm-sensors# make
noway:/usr/src/modules/lm-sensors# make install
</pre>

Danach wird man um diese Programme reicher:

<pre>
i2cdetect
i2cdump
i2cset
isadump
isaset
sensors-detect
sensors
...
</pre>

Jetzt sollte man die /dev/ Einträge erstellen:

<pre>
noway:~# cd /dev
noway:/dev# ./MAKEDEV i2c
noway:/dev# l i2c-*
crw------- 1 root root 89, 0 Mar 17 21:00 i2c-0
crw------- 1 root root 89, 1 Mar 17 21:00 i2c-1
crw------- 1 root root 89, 2 Mar 17 21:00 i2c-2
crw------- 1 root root 89, 3 Mar 17 21:00 i2c-3
crw------- 1 root root 89, 4 Mar 17 21:00 i2c-4
crw------- 1 root root 89, 5 Mar 17 21:00 i2c-5
crw------- 1 root root 89, 6 Mar 17 21:00 i2c-6
crw------- 1 root root 89, 7 Mar 17 21:00 i2c-7
</pre>

Damit kann jetzt nur "root" etwas anfangen. Damit die normalen Benutzer den Bus benutzen können, muss man eine neue Gruppe erstellen und die Zugriffsrechte anpassen:

<pre>
noway:/dev# groupadd i2c
noway:/dev# chmod 660 i2c-*
noway:/dev# chgrp i2c i2c-*
</pre>

Danach sollte es so aussehen:

<pre>
noway:/dev# l i2c-*
crw-rw---- 1 root i2c 89, 0 Mar 17 21:00 i2c-0
crw-rw---- 1 root i2c 89, 1 Mar 17 21:00 i2c-1
crw-rw---- 1 root i2c 89, 2 Mar 17 21:00 i2c-2
crw-rw---- 1 root i2c 89, 3 Mar 17 21:00 i2c-3
crw-rw---- 1 root i2c 89, 4 Mar 17 21:00 i2c-4
crw-rw---- 1 root i2c 89, 5 Mar 17 21:00 i2c-5
crw-rw---- 1 root i2c 89, 6 Mar 17 21:00 i2c-6
crw-rw---- 1 root i2c 89, 7 Mar 17 21:00 i2c-7
</pre>

Jetzt muss man sensors-detect aufrufen. Danach sollte für den SMBus das richtige Modul geladen sein. Mit "modprobe i2c-pport" kann man das Parallelport-I2C-Modul laden.

Welche Busse nun verfügbar sind, kann man mit "cat /proc/bus/i2c" erfahren.

Mit i2cdetect kann man jetzt die verfügbaren Busse scannen:

<pre>
noway:~# i2cdetect -l
i2c-0 smbus SMBus Via Pro adapter at e800 Non-I2C SMBus adapter
i2c-1 i2c Primitive Parallel port adaptor Bit-shift algorithm
</pre>

<pre>
noway:~# i2cdetect -y 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: XX XX XX XX XX XX XX XX XX XX XX XX XX
10: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
20: XX XX XX XX XX XX XX XX XX XX XX XX XX UU XX XX
30: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
40: XX XX XX XX XX XX XX XX UU UU XX XX XX XX XX XX
50: 50 XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
60: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
70: XX XX XX XX XX XX XX XX
</pre>

<pre>
noway:~# i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: XX XX XX XX XX XX XX XX XX XX XX XX XX
10: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
20: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
30: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
40: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
50: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
60: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
70: XX XX XX XX XX XX XX XX
</pre>

==== I2C Treiber installieren (Kernel 2.6) ====
Hier [http://www.mikrocontroller.net/wikifiles/4/4d/I2c-pport-26.tar.gz] gibt es die angepassten Sourcen für das i2c-pport Modul. Funktioniert wie oben für Kernel 2.4 beschrieben. 
Wichtig ist, dass man die Module lp und parport_pc auf die Blacklist setzt und den Parallelport im SPP-Modus betreibt (Bios-Einstellung). Dieser kleine Treiber benötigt keine weitere Hardware. (Quelle: [http://2z4gn8.blogspot.com/2008/04/saa1064-sieben-segment-anzeige-via-i2c.html])

==== I2C Bus öffnen/schliessen ====
Den Bus öffnet man nun genau wie die anderen Schnittstellen:

<pre>
int bus;
bus = open( "/dev/i2c-0", O_RDWR );
if ( bus == -1 )
{
// error
}
</pre>

<pre>
close( bus );
</pre>

Die include-Datei <linux/i2c-dev.h> wird benötigt.

==== I2C Bus steuern (ioctl) ====
An einem I2C-Bus können viele Chips angeschlossen werden, damit der Kernel weiss, mit welchem er Kontakt aufnehmen muss, braucht man diesen ioctl-call:

<pre>
uint8_t slave_addr = 0xXX;
ioctl( bus, I2C_SLAVE, slave_addr );
</pre>

"slave_addr" ist in diesem Fall die I2C-Adresse von dem Chip, den man ansprechen möchte.

==== I2C Bus lesen/schreiben ====
Nachdem man eine Slave-Adresse zugewiesen hat, kann man den selektierten Chip mit read(2) und write(2) ansprechen:

<pre>
char buffer[256];
uint16_t bytes;
bytes = read( bus, buffer, sizeof(buffer) );
</pre>

==== SMBus Zugriffe ====

=== Hardware ===
==== Der interne SMBus ====
Hier gibt es eine Beschreibung, wie man den SMBus findet: http://secure.netroedge.com/~lm78/hardhack.html

==== Externe I2C Busse ====
===== Parallelport-Bitbang Dongle =====

Für Linux gibt es ein Kernelmodul namens "i2c-pport". Das ist ein I2C-Bus über den Parallelport. Dieser Bus ist erschreckend einfach aufgebaut: es werden bis auf zwei Stecker '''keine''' Bauteile benötigt. Die notwendigen Verbindungen sehen so aus:

{| border=1 cellpadding=5
| Parallelport
| I2C-Bus
|-
| 14
| SDA
|-
| 16
| SCL
|-
| 18-25
| GND
|}

Das funktioniert nur deswegen, weil der Parallelport [[Ausgangsstufen_Logik-ICs#Open-collector|Open-Collector]] Ausgänge mit Pullup-Widerständen besitzt, und mehr braucht man für einen I2C-Bus nicht. Der PC kann die Leitungen SDA und SCL übrigends auch lesen.

===== Parallelport I2C-Bus Adapter mit PCF8584 =====
(to do)

==Verweise auf man-pages==
Die manpages können online betrachtet werden unter http://www.rt.com/man/

===Dateien öffnen===
-> open(2)
http://www.rt.com/man/open.2.html

===Dateien schliessen===
-> close(2)
http://www.rt.com/man/close.2.html

===Dateien lesen===
-> read(2)
http://www.rt.com/man/read.2.html

===Dateien schreiben===
-> write(2)
http://www.rt.com/man/write.2.html

===Besonderer Dateizugriff===
-> ioctl(2)
http://www.rt.com/man/ioctl.2.html

===Abfragen ob Daten zum lesen bereit sind===
-> select(2)
http://www.rt.com/man/select.2.html

==Benötigte include Dateien==

===write(2) read(2) close(2)===
<pre>
#include <unistd.h>
</pre>

===open(2)===
<pre>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
</pre>

===ioctl(2)===
<pre>
#include <sys/ioctl.h>
</pre>

===select(2)===
<pre>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
</pre>

=== für I2C und SMBus ===
<pre>
#include <linux/i2c-dev.h>
#include <linux/i2c.h> //zumindest für 2.6.x
</pre>

== Siehe auch ==

* [[Ports benutzen (PHP)]]
* [[Ports benutzen (Windows)]]
* [http://www.mikrocontroller.net/topic/93089#803530 Forumsbeitrag]: Sourcecode RS232 bzw. V24 in C unter Linux

Datei:I2c-pport-26.tar.gz

2008-04-13T15:10:48Z

User-s: i2c-pport modul für kernel 2.6.x

i2c-pport modul für kernel 2.6.x