Raspberry-Pi-Projekte: Real Time Clock

Prof. Jürgen Plate, Jonas Goll, Tobias Müller, Xiao Wang

Raspberry Pi: Real Time Clock

Allgemeines

Wenn der Raspberry Pi mit dem Netzwerk verbunden ist, muss man sich um das Stellen der Uhr keine Gedanken machen, denn von Haus aus läuft der Network Time Daemon (ntp), der für das Abrufen der korrekten Uhrzeit und das Stellen der internen Uhr sorgt. Nur, wenn der RasPi keine Verbindung nach außen hat, muss man sich um die korrekte Uhrzeit kümmern.

Der Raspberry Pi besitzt keine integrierte Real Time Clock (RTC) wie ein PC. Damit er über die aktuelle Uhrzeit verfügt, muss er entweder die Uhrzeit über eine Netzwerkverbindung einlesen oder er benötigt eine lokale Uhr. Dieses Projekt versorgt den Rechner mit einer autonomen Uhr. Nach jedem Systemstart wird die Uhrzeit aus der RTC ausgelesen und als Systemzeit verwendet. Die RTC befindet sich auf einer eigenen Platine und wird per I2C integriert.

Real Time Clock DS1307 (RTC)

Dieser Baustein ist eine Echtzeituhr, die man über die I2C-Schnittstelle ansprechen kann und die batteriegepuffert weiterläuft, wenn der RasPi abgeschaltet ist. Die Genauigkeit ist nicht so überragend, Abweichungen von 1-2 Sekunden in 24 Stunden sind möglich (abhängig von Temperatur und Quarz). Bei großen Temperaturschwankungen sind die Abweichungen noch um einiges größer. An die RTC wird vom Raspberry Pi eine möglichst exakte Zeit übertragen. Diese Uhzreit wird nun von der RTC mit Hilfe des des internen Quarzoszillators aktualisiert. Bei Bedarf ( z. B. beim Hochfahren des RasPi) wird die Zeit abgefragt und als Systemzeit gespeichert - so wie das beim PC schon seit Jahrzehnten der Fall ist. Die Batterie soll nach Datenblatt bis zu 10 Jahre lang halten. In den Registern der RTC stehen die Uhrzeit, der Wochentag und das Datum. Die einzelnen BCD-Werte können über die folgende Adressen ausgelesen werden.

AdresseInhaltBeschreibung
0x00Sekunden und CH-BitBits 0 - 6: Sekunden (0..59)
Bit 8: Uhr ein- und ausschalten
0x01MinutenBits 0 - 6: Minuten (0..59)
0x02StundenBits 0 - 6: Stunden; 12/24h umschaltbar
0x03WochentagBits 0 - 2: Wochentag (1..7, So=1)
0x04TagBits 0 - 5: Tag (0..31)
0x05MonatBits 0 - 4: Monat (0..12)
0x06JahrBits 0 - 7: Jahr (0..99)
0x07EinstellungenSQW-Output einstellen
0x08 – 0x3F RAM56 x 8 Bit

Bem Sekundenregister ist darauf zu achten, dass das MSB (CH Bit) zum Ein- und Ausschalten der Uhr dient. Ist CH = 1, Stoppt der DS1307. Dieses Bit sollte beim Schreiben einer neuen Uhrzeit stets auf 1 gesetzt sein. Nachdem alle Werte gespeichert wurden, wird es zusammen mit der Sekundenangabe wieder auf 0 gesetzen und somit die RTC wieder eingeschaltet. Beim Auslesen der Sekunde muss das MSB natürlich ignoriert werden. Die Stunden werden im Register 2 gespeichert. Ist das Bit 6 des Registers gesetzt, werden die Stunden im 12h-Format angegeben, das Bit 5 gibt dabei AM(low)/PM(high) an. Ist das Bit dagegen gelöscht, werden die Stunden im 24h-Format ausgegegeben. Register 3 enthält den aktuellen Wochentag,wobei der Wert 1 dem Sonntag entspricht, 2 dem Montag usw. Register 7 dient zur Konfiguration des Rechtecksignal-Generators. Die restlichen Register können als batteriegepuffertes RAM verwendet und frei beschrieben werden.

Es gibt diverse Break-Out-Boards mit dem DS1307 im Handel, wobei die meisten die I2C-Anschlüsse direkt zum Raspberry Pi führen. Die Pull-Up-Widerstände auf dem RasPI-Board sorgen für die korrekte High-Spannung von 3,3 V. Manche der angebotenen Module, wie beispielsweise ein unter dem Namen "Tiny RTC I2C Module" angebotenes, sind für den Arduino gedacht und liefern 5 V auf den I2C-Leitungen. Bei diesem Modulen muss man die Pullup-Widerstände für SCL und SDA auslöten (siehe Bild).

Manche der angegebenen Boards versuchen, die Pufferbatterie zu laden, wenn die Stromversorgung vom Rechner aus erfolgt. Bei solchen Modulen darf keine 3,6-V-Lithium-Knopfzelle (z. B. CR2032) verwendet werden, sondern es muss eine entsprechende Akku-Knopfzelle (z. B. LIR2032) eingesetzt werden. Leider haben diese Bords eine etwas sehr rudimentäre Ladeschaltung. Wie im folgenden Bild links zu sehen ist, besteht sie nur aus einem Widerstand von 200 Ohm (R5) und einer Diode (Auszug aus der Schaltung des "Tiny RTC I2C Module"). Für die wiederaufladbare Batterie LIR2032 gilt nach Datenblatt: Nominalspannung: 3,7 V, Kapazität: 35 mAh, maximale Ladespannung: 4,2 V, maximaler Ladestrom: 35 mA. Aus der Schaltung aus R5 und D1 ergibt sich aber eine Ladespannung von 4,5 - 4,7 V, also viel zuviel für die Knopfzelle, deren Lebensdauer so massiv verkürzt wird (wenn sich die Zelle nicht auch noch aufbläht). Eine zumindest akzeptable Abhilfe würde das Einlöten einer zweiten Diode schaffen, mit der die Ladespannung unter 4,2 V bleibt (rechte Schaltung im Bild unten). Auf der oben abgebildeten Platine befindet sich D1 ganz oben rechts. Man könnte D1 auslöten und durch zwei entsprechende Dioden ersetzen, die auf einer Seite miteinander verlötet und mit den jeweils anderen Polen wieder mit den ursprünglichen Lötpads verbunden werden.

Wird anstelle der wiederaufladbaren Zelle eine "normale" Batterie LR2032 verwendet, sollten D1 und R4 entfernt und R6 überbrückt werden (Drahtbrücke über R6).

Ansonsten ist das Modul recht interessant, denn es befindet sich noch ein I2C-EEPROM auf dem Board und man kann optional noch einen DS18B20-Onewire-Temperatursensor auflöten (Schaltplan siehe bei den Links unten).

Um sicher zu sein, dass der RasPi keinen Schaden nimmt, wurde eine eigene Schaltung mit Board entwickelt, welche aktive Pegelwandler enthält:

Die entsprechenden Eagle-Dateien stehen zur Verfügung (siehe Links weiter unten). Der Anschluss der Platine erfolgt am Raspberry Pi an +5 V (Pin 2), +3,3 V (Pin 1), GND (Pin 6), SDA (Pin 3) und SCL (Pin 5). Siehe auch I2C-Konfiguration. Im folgenden wird davon ausgegangen, dass die Module i2c_bcm2708 und i2c_dev laden geladen sind. Ein erster Test kann mit den I2C-Tools mit Root-Rechten (sudo su) erfolgen:

i2cdetect -l
i2cdetect -y 1
Die RTC muss auf Adresse 0x68 sichtbar sein. Nun können Sie versuchen, einige Register auszulesen, z. B.:
i2cget -y 1 0x68 0 # Sekunde
i2cget -y 1 0x68 1 # Minute
i2cget -y 1 0x68 2 # Stunde
Wenn das geklappt hat, ist schon mal alles in Butter.

Jetzt kann man schon per Programm auf die Uhr zugreifen, wie das folgende Beispiel in C zeigt. Es genügen dabei die normalen Dateioperationen, die der I2C-Treiber bereitstellt. Compiliert wird das Programm mit dem Kommando gcc -Wall -o ds1307 ds1307.c.
#include <stdio.h>
#include <stdlib.h>
#include <linux/i2c.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

/* Puffer fuer die RTC-Daten */
#define BUFSIZE 7

/* Verwende I2C 1 */
#define I2CADDR "/dev/i2c-1"

/* defined in <linux/i2c-dev.h> */
#define I2C_SLAVE 0x703

/* Adresse des RTC-Chips */
#define RTC 0x68

int main()
  {
  int Device;          /* Device-Handle */
  char Date[BUFSIZE];  /* Datenpuffer   */
  int i;

  /* I2C aktivieren  */
  if ((Device = open(I2CADDR, O_RDWR)) < 0)
    {
    printf("I2C-Modul kann nicht geladen werden!\n");
    return -1;
    }

  /*  Port und Adresse setzen */
  if (ioctl(Device, I2C_SLAVE, RTC) < 0)
    {
    printf("RTC-Deviceadresse wurde nicht gefunden!\n");
    exit(1);
    }

  /* Pointer auf Adresse 0 (Startadresse) setzen */
  Date[0] = 0x00;
  if(write(Device, Date, 1) != 1)
    {
    printf("Fehler beim Schreiben der Daten!\n");
    return -1;
    }

  /* Uhrzeit einlesen */
  if (read(Device, Date, BUFSIZE) != BUFSIZE)
    {
    printf("Fehler beim Lesen der Daten!\n");
    return -1;
    }
  else
    {
    /* Werte von BCD in Dezimal umwandeln */
    for(i = 0; i < BUFSIZE; i++)
      {
      Date[i] = (Date[i] & 0x0f) + 10 * (Date[i] >> 4);
      }

    /* Ausgabe von Uhrzeit und Datum */
    printf("\n");
    printf("Uhrzeit: %02d:%02d:%02d\n", Date[2],Date[1],Date[0]);
    printf("Datum:   %02d.%02d.%04d\n", Date[4],Date[5],Date[6] + 2000);
    switch(Date[3])
      {
      case 1: printf("Sonntag");  break;
      case 2: printf("Montag");   break;
      case 3: printf("Dienstag"); break;
      case 4: printf("Mittwoch"); break;
      case 5: printf("Donnerstag"); break;
      case 6: printf("Freitag");  break;
      case 7: printf("Samstag");  break;
      }
    printf("\n");
    }

  close(Device);
  return 0;
  }
Die Ausgabe des Programm erscheint nach einem Aufruf des Programms dann auf dem Bildschirm:
Uhrzeit: 13:03:05
Datum:   05.02.2015
Donnerstag
Damit hätten Sie schon das nötige Rüstzeug. Durch Modifikation des Programms könnte man auch gleich das date-Kommando zum Setzen der internen Uhr aufrufen, indem man aus Datum und Uhrzeit einen String zusammensetzt der date als Parameter mitgegeben wird (Format: MMDDhhmmssYYYY):
char buffer[30];
sprintf(buffer, "sudo date %02d%02d%02d%02d%02d%04d",
    Date[5],Date[4],Date[2],Date[1],Date[0],Date[6] + 2000);
system(buffer);
Die C-Bibliothek (siehe auch Links unten) umfasst alle für den Zugriff auf den Chip notwendigen Funktionen:

Im Anhang (Linkliste) finden Sie auch noch eine umfangreiche Python-Bibliothek für den Zugriff auf den Uhrenchip und das Setzen der internen Uhr mit folgenden Methoden:

Die Echtzeituhr wird aber auch von Betriebssystem unterstützt. Manchmal möchte man aber nur die nötigsten Einstellungen des Raspbian-Betriebssystems vornehmen. In diesem Fall bleibt man bei dem C- oder Python-Programm ohne die im folgenden beschriebenen Modifikationen.

Raspbian für die RTC konfigurieren

Raspbian hat neben anderen Treibern auch einen für den DS1307 integriert. Man brauch also nichts zu installieren, sondern kann den Treiber gleich laden. Von Hand (zum Ausprobieren) macht man das mittels:

modprobe rtc-ds1307
Jetzt muss noch eine virtuelle Datei für die Uhr angelegt werden. Dabei muss man den richtigen I2C-Bus Nummer 1 verwenden, also i2c-1:
echo "ds1307 0x68" > /sys/class/i2c-adapter/i2c-1/new_device
Nun können die Systemprogramme über diese Adresse auf die RTC zugreifen. Dagegen läuft das Programm von oben nicht mehr, das der RTC-Treiber sich das Device gekrallt hat. Mit dem folgenden System-Befehl können Sie nun (als Root) die Uhrzeit ausgeben:
hwclock -r
Beim ersten Abruf wird eventuell noch der 1. Januar 2000 angezeigt. Sonst zeigt uns der Aufruf die aktuelle Zeit, z. B.:
Do 05 Feb 2015 13:45:57 CET  -0.073826 seconds
Mit dem date-Kommando kann die Systemuhrzeit gestellt werden, wenn keine Möglichkeit besteht, die Uhrzeit aus dem Netz zu holen. Dann kann man die gültige Zeit in die RTC übertragen:
hwclock --systohc -D --noadjfile --utc
Das Kommando ist etwas länger als nur hwclock -w. Die Parameter haben folgende Bedeutung: Zum Testen ist die Option --debug nützlich. Man erhält dann Informationen über das, was hwclock gerade anstellt, zum Beispiel:
 sudo hwclock --debug -r
hwclock from util-linux 2.20.1
Using /dev interface to clock.
Last drift adjustment done at 1423140131 seconds after 1969
Last calibration done at 1423140131 seconds after 1969
Hardware clock is on UTC time
Assuming hardware clock is kept in UTC time.
Waiting for clock tick...
/dev/rtc0 does not have interrupt functions. Waiting in loop for time from /dev/rtc0 to change
...got clock tick
Time read from Hardware Clock: 2015/02/05 12:45:57
Hw clock time : 2015/02/05 12:45:57 = 1423140357 seconds since 1969
Do 05 Feb 2015 13:45:57 CET  -0.073826 seconds

Mit dem so installierten Treiber ergibt sich noch ein kleiner Vorteil. Man kann Datum und Uhrzeit direkt über das Sys-Dateisystem auslesen:

cat /sys/class/rtc/rtc0/date
cat /sys/class/rtc/rtc0/time

Wenn soweit alles klappt, muss noch dafür gesorgt werden, dass nach einem Neustart auch alles wieder aktiviert werden muss. Deshalb wird das Ganze jetzt automatisiert. Vorausgesetzt wird, dass in der Datei /etc/modules die beiden Module i2c-bcm2708 und i2c-dev eingetragen sind und auch in /etc/modprobe.d/raspi-blacklist.conf die Zeile "i2c-bcm2708" auskommentiert wurde. Alle anderen Einstellungen nehmen Sie in der Startdatei /etc/rc.local vor (immer noch als Root). Tragen Sie vor der exit-Zeile die folgenden drei Zeilen ein (die ersten beiden sind genau diejenigen, die Sie oben auf der Kommandozeile eingetippt haben):

modprobe rtc-ds1307
echo "ds1307 0x68" > /sys/class/i2c-adapter/i2c-1/new_device
hwclock --hctosys
Das dritte Kommando setzt die Systemuhr mit der RTC-Uhrzeit. Testen können Sie das, indem Sie den Raspberry Pi für einige Minuten ausschalten und dann ohne Netzwerkanbindung starten. Hat er nun die aktuelle Zeit, haben Sie es geschafft!

Alternativ können Sie auch die erste Zeile ("modprobe rtc-ds1307") weglassen und dafür die folgende Zeile in der Datei /etc/modules eintragen:

rtc-ds1307

Ab Kernelversion 3.18 wird für das Einsetzen der Module der sogenannte Device Tree verwendet. Ab dann wird die One-Wire-Schnittstelle in der Datei /boot/config.txt aktiviert, indem dort eine Zeile eingetragen werden:

dtoverlay=i2c-rtc,ds1307=on
Es kann statt des Chips ds1307 auch einer der Chips ds3231, pcf2127, pcf8523 oder pcf8563 angegeben werden. Siehe auch das Device Tree Kapitel.

Jetzt kann man die RTC zwar mit dem Kommando sudo hwclock -r auslesen, aber die Uhrzeit wird beim Booten des RasPi nicht übernommen. Grund dafür ist eine an sich schlaue Einrichtung im Raspbian-Betriebssystem. Es implementiert eine sogenannte Fake-hwclock, bei der beim Shutdown die aktuelle Systemzeit gespeichert wird. Beim Booten wird diese Zeit verwendet, um die Uhr zu stellen. Der RasPi fängt so nicht immer beim 1.1.1970 an, sondern die Zeit läuft monoton steigend weiter, nur hat eben nichts mit der realen Zeit zu tun. Man muss also die Fake-hwclock entfernen, damit die RTC vom System übernommen wird. Dazu geben Sie (als root-User) folgende Kommandos in der Konsole ein:

update-rc.d ntp disable
update-rc.d -f fake-hwclock disable
update-rc.d -f fake-hwclock remove
apt-get remove fake-hwclock
Die erste Zeile deaktiviert den NTP-Server, die beiden folgenden das Start/Stopp-Skript für die Fake-Hardwareclock, die letzte Zeile entfernt schlißlich deren Software (kann man später mit apt-get install fake-hwclock wieder reaktivieren). Ab da startet das Betriebssystem immer mit dem 1.1.1970. Dieses Datum wird auch beim Shutdown in die Uhr kopiert, die dann immer eine ungültige Zeit hat, weil sie die Zeit erst ab dem 1.1.2000 richtig bestimmt.

Nun muss noch das Start/Stopp-Script für die RTC angepasst werden. Dazu wird (als root-User) die Datei /etc/init.d/hwclock.sh mit dem Editor bearbeitet. Zunächst tragen Sie am Anfang des Scripts die Default-Wert ein bzw. überprüfen diese:

# These defaults are user-overridable in /etc/default/hwclock
BADYEAR=no
HWCLOCKACCESS=yes
HWCLOCKPARS=' --noadjfile --utc'
HCTOSYS_DEVICE=rtc0
Nach der Zeile 'case "$1" in start)' werden die folgenden drei Zeilen auskommentieren ('#' davorsetzen):
  #if [ -d /run/udev ] || [ -d /dev/.udev ]; then
  #   return 0
  #fi
Nun die Datei speichern und den Editor verlassen.

Zu guter Letzt wird nun das Start/Stopp-Script aktiviert. Geben Sie dazu (als root-User) in Konsole ein:

update-rc.d hwclock.sh enable
Damit wird beim Booten das Script hwclock.sh ausgeführt und die Zeit der Echtzeituhr geladen. Beim Herunterfahren speichert das Script die Systemzeit in der RTC - Sie können die Uhr also ganz normal mittels date (oder sonstwie) stellen.

Anmerkung: Bei älteren Versionen des Raspbian-Betriebssystems fehlte die Gerätedatei /dev/rtc bzw. /dev/rtc0. Diese läßt sich mit dem Kommando

mknod /dev/rtc c 254 0
nachträglich einrichten. Gegebenenfalls kann dan noch ein Symlink erzeugt werden:
ln -s /dev/rtc /dev/rtc0

Real Time Clock DS3231 (RTC)

Wer nicht basteln will, kann ohne Änderungen ein Fertigmodul verwenden, das auch noch genauer ist. Es wurde ein Modul mit dem DS3231-RTC-Chip ausprobiert. Das getestet Modul wird von SunFounder (www.sunfounder.com produziert und ist bei Ebay oder Amazon für einige Euro zu bekommen. Es lässt sich direkt auf die erste Pinreihe des GPIO aufstecken. Die Chips des DS3231 verwenden die gleichen I2C-Befehle wie der DS1307, so dass alles funktioniert wie oben beschrieben. Der DS3231 ist nicht nur als Uhr genauer als der DS1307, sondern hat auch noch den Quarz integriert, so dass nur noch der übliche Blockkondensator nötig ist. Er ist zudem auch mit 3,3 V Versorgungsspannung zufrieden.

Das Bild zeigt das aufgesteckte Modul. Auf der Platinenoberseite sitzt der DS3231, auf der Unterseite ist die Puffer-Knopfzelle angebracht. Es gibt jedoch zwei Nachteile: Erstens blockiert das Modul den I2C-Anschluß für weitere Komponenten und zweitens ist die Batterie fest eingelötet, was einen Wechsel kompliziert. Durch den internen Quarz wird die Beschaltung noch einfacher.

Da der DS3231 nur 3,3 V benötigt, entfallen auch die beiden Pegelwandler-MOSFETs. Es gibt jedoch auch Module, die nicht aufgesteckt, sondern verdrahtet werden und mit einer auswechselbaren Knopfzelle bestückt sind. Ein Beispiel dafür zeigt das folgende Bild des Moduls ZS-042 von AZ-Delivery. Auf der Platine sitzt nicht nur ein DS3231, sondern zusätzlich ein EEPROM 24C32.

Die Schaltung des ZS-042 entspricht der oben gezeigten. Neben dem zusätzlichen EEPROM ist auch noch eine LED als Betriebsanzeige sowie die oben schon beschriebene Ladeschaltung aus 220-Ohm-Widerstand und Diode implementiert, die man ggf. deaktivieren kann. Da dieses Modul mit 3,3 V läuft, ist die Schaltung in diesem Fall aber unkritisch.

Die System-Konfiguration ändert sich nur insofern, als Sie statt "DS1307" überall "DS3231" eintragen. Meist funktioniert es sogar mit dem Eintrag "DS1307".

Das EEPROM 24C32

Wie man auf dem Bild der käuflichen Boards oben erkennen kann, befinden sich dort zwei ICs. Das ist bei vielen der angebotenen Uhrenboard ein nettes Zusatzfeature, nämlich ein EEPROM 24C32, das in der Lage ist, dauerhaft 4096 Bytes zu speichern - es benötigt auch keine Pufferbatterie wie das RAM im RTC-Baustein. Das EEPROM (Electrically Erasable Programmable Read Only Memory) wird ebenfalls über den I2C-Bus angesprochen. Es liegt per Default auf der Deviceadresse 0x50, weshalb i2cdetect dann auch neben der RTC-Adresse 0x68 diese Adresse anzeigt. Abhängig von der Jumperstellung auf dem jeweiligen Board (oder entsprechenden Lötbrücken) kann das EEPROM auf den Adressen 0x50 bis 0x57 liegen. Zum Schreiben und Lesen genügen wenige Programmzeilen. Im folgenden Listing sind drei Funktionen definiert:

Als Test werden im Hauptprogramm (wenig sinnvoll) die Adressen 0 .. 255 mit den Werten 0 .. 255) beschrieben und anschließend wieder gelesen.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <fcntl.h>

// Adresse des EEPROMS
#define ADDR24C32 0x50

int init_24c32(unsigned char device_address)
  /* Verbindung zum EEPROM 24c32 oeffenen
   * device_address: I2C-Deviceadresse (default: 0x50)
   */
  {
  int device;

  if ((device = open("/dev/i2c-1", O_RDWR)) < 0)
    {
    perror("Can not open I2C Bus");
    exit (1);
    }
 if (ioctl(device, I2C_SLAVE, device_address) < 0)
   {
   perror("Can not connect to Device");
   exit (1);
   }
  return device;
  }

void write_24c32(int device, unsigned int address, unsigned char data)
  /*
   * Schreiben auf EEPROM 24C32
   * device: I2C-Device (geoeffnet mit init_24c32()
   * address: Speicheradresse (12 Bit, 0 .. 0xff (4095))
   * data: zu speicherndes Byte
   */
  {
  unsigned char buf[3];
  buf[0] = (unsigned char)(address >> 8) & 0x0f; // High Byte Address
  buf[1] = (unsigned char)address & 0xff;              // Low Byte Address
  buf[2] = data;                                           // Daten
  write(device,buf,3);                                     // Puffer schreiben
  usleep(5000);
  }

unsigned char read_24c32(int device, unsigned int address)
  /* Lesen vom EEPROM 24C32
   * device: I2C-Device (geoeffnet mit init_24c32()
   * address: Speicheradresse (12 Bit, 0 .. 0xff (4095))
   * Rueckgabewert: gelesenes Byte
   */
  {
  unsigned char buf[3];
  buf[0] = (unsigned char)(address >> 8) & 0x0f; // High Byte Address
  buf[1] = (unsigned char)address & 0xff;              // Low Byte Address
  write(device,buf,2);                                     // Adresse schreiben
  read(device,buf,1);                                      // Daten lesen
  return buf[0];
  }

/* Testprogramm */
int main (void)
  {
  int dev;
  int i, j;

  dev = init_24c32(ADDR24C32);

  for (i = 0; i < 256; i++)
    {
    printf("Write: %d %d\n",i, i);
    write_24c32(dev, i, i);
    }
  for (i = 0; i < 256; i++)
    {
    j = read_24c32(dev, i);
    printf ("Read: %d %d\n", i, j);
    }

  close(dev);
  return 0;
  }
Unter den folgenden Links ist auch eine Klassen-Bibliothek für Python zu finden:

Links


Copyright © Hochschule München, FK 04, Prof. Jürgen Plate und die Autoren
Letzte Aktualisierung: