I2C-RTC-Uhr mit DS1307 auf Velxio

Einleitung

Schon einmal eine Echtzeituhr zu deinem Arduino-Projekt hinzufügen wollen, aber die Hardware nicht zur Hand gehabt? Mit Velxio kannst du einen I2C-RTC (DS1307) direkt in deinem Browser simulieren. In diesem Tutorial bauen wir einen einfachen I2C-Leser, der die aktuelle Uhrzeit und das Datum von einem virtuellen DS1307 abruft und auf dem seriellen Monitor ausgibt. Keine externen Bibliotheken nötig – nur die integrierte Wire-Bibliothek.

Schaltplan-Durchlauf

Dieses Beispiel ist bemerkenswert einfach, da der DS1307 bereits in das virtuelle Arduino-Uno-Board integriert ist. Es müssen keine externen Komponenten oder Drähte hinzugefügt werden. Der I2C-Bus (SDA auf A4, SCL auf A5) ist intern mit dem DS1307 unter der Adresse 0x68 verbunden. Die einzige Komponente ist der Arduino Uno selbst.

Öffne zunächst den Velxio-Editor und wähle einen Arduino Uno aus der Komponentenauswahl. Der DS1307 ist in die Simulationsumgebung integriert, du musst ihn also nicht separat hinzufügen. Die Schaltung ist einsatzbereit.

Code-Durchlauf

Lass uns den Code Schritt für Schritt aufschlüsseln.

Einbinden und Definieren

#include <Wire.h>

#define DS1307_ADDR 0x68

Wir binden die Wire-Bibliothek für die I2C-Kommunikation ein und definieren die I2C-Adresse des DS1307 als 0x68.

BCD-zu-Dezimal-Umwandlung

byte bcdToDec(byte val) {
  return ((val >> 4) * 10) + (val & 0x0F);
}

Der DS1307 speichert Zeitwerte im Binär codierten Dezimalformat (BCD). Diese Hilfsfunktion wandelt ein BCD-Byte in eine normale Dezimalzahl um.

Setup

void setup() {
  Wire.begin();
  Serial.begin(9600);

  Serial.println("===========================");
  Serial.println("  DS1307 RTC Reader (I2C)");
  Serial.println("===========================");
  Serial.println();
}

Wir initialisieren den I2C-Bus und die serielle Kommunikation mit 9600 Baud. Dann geben wir eine Kopfzeile aus.

Loop

void loop() {
  // Set register pointer to 0 (seconds)
  Wire.beginTransmission(DS1307_ADDR);
  Wire.write(0x00);
  Wire.endTransmission();

  // Request 7 bytes: sec, min, hr, dow, date, month, year
  Wire.requestFrom(DS1307_ADDR, 7);

  if (Wire.available() >= 7) {
    byte sec   = bcdToDec(Wire.read() & 0x7F);
    byte min   = bcdToDec(Wire.read());
    byte hr    = bcdToDec(Wire.read() & 0x3F);
    byte dow   = bcdToDec(Wire.read());
    byte date  = bcdToDec(Wire.read());
    byte month = bcdToDec(Wire.read());
    byte year  = bcdToDec(Wire.read());

    // Print formatted time
    Serial.print("Time: ");
    if (hr < 10) Serial.print("0");
    Serial.print(hr);
    Serial.print(":");
    if (min < 10) Serial.print("0");
    Serial.print(min);
    Serial.print(":");
    if (sec < 10) Serial.print("0");
    Serial.print(sec);

    Serial.print("  Date: ");
    if (date < 10) Serial.print("0");
    Serial.print(date);
    Serial.print("/");
    if (month < 10) Serial.print("0");
    Serial.print(month);
    Serial.print("/20");
    if (year < 10) Serial.print("0");
    Serial.println(year);
  } else {
    Serial.println("Error: Could not read RTC");
  }

  delay(1000);
}

In der Schleife setzen wir zunächst den Registerzeiger des DS1307 auf 0 (Sekundenregister), indem wir ein einzelnes Byte 0x00 senden. Dann fordern wir 7 Bytes vom RTC an. Der DS1307 gibt Sekunden, Minuten, Stunden, Wochentag, Datum, Monat und Jahr im BCD-Format zurück. Wir maskieren das oberste Bit der Sekunden (Bit 7 ist das Clock-Halt-Flag) und die oberen zwei Bits der Stunden (Bits 6-7 sind Modus/AM-PM). Nach der Umwandlung geben wir die Uhrzeit und das Datum mit führenden Nullen aus. Wenn weniger als 7 Bytes verfügbar sind, geben wir einen Fehler aus. Schließlich warten wir 1 Sekunde.

Schlüsselkonzepte

• I2C-Kommunikation: Die Wire-Bibliothek übernimmt das I2C-Protokoll. beginTransmission() startet einen Schreibvorgang, write() stellt Daten in die Warteschlange, endTransmission() sendet sie. requestFrom() liest Bytes von einem Slave.
• BCD-Format: Der DS1307 speichert die Zeit im BCD-Format, bei dem jedes Halbbyte eine Dezimalziffer darstellt. Die Funktion bcdToDec() wandelt es um.
• Registeradressierung: Auf die internen Register des DS1307 wird zugegriffen, indem zuerst die Registeradresse geschrieben und dann Daten gelesen oder geschrieben werden.
• Bitmaskierung: Das oberste Bit des Sekundenregisters (CH) zeigt den Clock-Halt an; wir maskieren es mit & 0x7F. Die oberen Bits des Stundenregisters zeigen den 12/24-Stunden-Modus an; wir maskieren sie mit & 0x3F.

Häufige Fallstricke und Debugging-Tipps

• Falsche I2C-Adresse: Stelle sicher, dass die Adresse 0x68 (7-Bit) ist. Wenn du eine 8-Bit-Adresse verwendest, verschiebe sie um 1 nach links.
• Fehlende Pull-up-Widerstände: Bei echter Hardware benötigen I2C-Leitungen Pull-ups. In Velxio werden sie intern simuliert.
• Serieller Monitor wird nicht angezeigt: Stelle sicher, dass die Baudrate übereinstimmt (9600). Klicke auf das Symbol des seriellen Monitors in der Editor-Symbolleiste.

• Kompilierungsfehler: Überprüfe, ob du Wire.h eingebunden hast. Der Code verwendet keine externen Bibliotheken.
• RTC antwortet nicht: Wenn du “Error: Could not read RTC” siehst, ist die I2C-Kommunikation möglicherweise fehlgeschlagen. Überprüfe die Adresse und die Verkabelung.

Vorgeschlagene Erweiterungen

• Zeit einstellen: Füge Code hinzu, um die Zeit des DS1307 über die serielle Eingabe einzustellen.
• Auf LCD anzeigen: Verwende ein I2C-LCD, um die Zeit anzuzeigen.
• Alarmfunktion: Implementiere einen Alarm mithilfe der Alarmregister des DS1307.
• Datenprotokollierung: Protokolliere Zeitstempel auf EEPROM oder einer SD-Karte.

Probier es selbst aus

Bereit, es in Aktion zu sehen? Öffne das Live-Beispiel auf Velxio und klicke auf die Schaltfläche “Run”. Du wirst sehen, wie die Zeit jede Sekunde auf dem seriellen Monitor aktualisiert wird.

Starte den I2C-RTC-Leser auf Velxio

Viel Spaß beim Simulieren!