DFRobot verstehen: Gravity-Stecker, Boards & Bibliotheken für schnelle Projekte

DFRobot bietet ein breites Ökosystem aus Mikrocontroller-Boards, Sensoren/Modulen und Lernmaterial. Besonders bekannt ist das Gravity-Stecksystem mit 3-Pin (Analog/Digital) und 4-Pin (I²C) JST-PH-Buchsen, das Verdrahtung unkompliziert und verpolsicher macht.

Ökosystem auf einen Blick

• Gravity-Module: Analog/Digital/I²C/UART-Sensoren mit 3-/4-Pin-Kabeln (JST-PH). Viele laufen an 3,3–5 V – Datenblatt prüfen.
• Boards: FireBeetle (z. B. ESP32-basierte IoT-Boards), Beetle (sehr kompakt), Romeo (Robotik-Controller mit Motor-Treibern).
• Bibliotheken & Beispiele: Arduino-Libs und Wiki-Guides beschleunigen den Einstieg.

Stecker & Verdrahtung

Hinweis: Gravity (JST-PH 2,0 mm) ist mechanisch größer als Qwiic/STEMMA QT (JST-SH 1,0 mm) – nicht direkt kompatibel ohne Adapter.

Spannungen & Pegel

• Viele Module sind 3,3–5 V-tolerant; dennoch kann ein falscher Pegel ICs beschädigen – Datenblatt/Wiki checken.
• Bei UART/I²C zwischen 3,3-V-MCU und 5-V-Modul ggf. Level-Shifter nutzen.

Mini-Beispiel 1: Arduino – Gravity Analog-Sensor lesen (A0)

Universelles Grundgerüst für analoge Gravity-Module. Die Spannung hilft beim Kalibrieren; die Umrechnung in Messgröße hängt vom konkreten Sensor ab.

const int PIN_SIG = A0;
const float VREF = 5.0;   // bei 3,3-V-Boards anpassen
const int N = 10;      // gleitender Mittelwert

int buf[N]; int idx=0; long sum=0;

void setup() {
  Serial.begin(115200);
  for(int i=0; i<N; ++i) { buf[i]=0; }
}

void loop() {
  sum -= buf[idx];
  buf[idx] = analogRead(PIN_SIG);
  sum += buf[idx];
  idx = (idx+1) % N;

  float avg = (float)sum/N;
  float voltage = avg * (VREF/1023.0); // 10-bit ADC

  Serial.print("ADC="); Serial.print(avg, 1);
  Serial.print("  U="); Serial.print(voltage, 3); Serial.println(" V");
  delay(200);
}
    

Mini-Beispiel 2: Arduino – I²C-Scan & Register lesen (Gravity I²C)

Schnelles Prüfen, ob ein I²C-Gravity-Modul korrekt erkannt wird. Die Registeradresse ist exemplarisch.

#include <Wire.h>

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Serial.println("I2C-Scan...");
  for (uint8_t addr=1; addr<127; ++addr) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0) {
      Serial.print("Gefunden: 0x"); Serial.println(addr, HEX);
    }
  }
}

void loop() {
  const uint8_t ADDR=0x40;  // Beispieladresse
  Wire.beginTransmission(ADDR);
  Wire.write(0x00);               // z. B. Statusregister
  Wire.endTransmission(false);
  Wire.requestFrom(ADDR, (uint8_t)2);
  if (Wire.available() == 2) {
    uint16_t val = (Wire.read() << 8) | Wire.read();
    Serial.print("Reg0x00="); Serial.println(val);
  }
  delay(500);
}
    

Python-Beispiel (Raspberry Pi): I²C-Werte lesen

Mit smbus2 lässt sich ein I²C-Gravity-Sensor am Pi schnell ansprechen. Adresse/Register dem konkreten Modul anpassen.

from smbus2 import SMBus
import time

ADDR = 0x40   # Beispiel
REG  = 0x00

with SMBus(1) as bus:
    while True:
        bus.write_byte(ADDR, REG)
        data = bus.read_i2c_block_data(ADDR, REG, 2)
        val = (data[0]<<8) | data[1]
        print("val=", val)
        time.sleep(0.5)
    

Typische Fehler & schnelle Checks

1. Falscher Stecker/Port → 3-Pin (Analog/Digital) ≠ 4-Pin (I²C). Immer Pinout prüfen.
2. Keine gemeinsame Masse → instabile Messungen/Kommunikation.
3. Pegel/Versorgung → 3,3 V-MCU an 5 V-Modul? Datenblatt checken, ggf. Level-Shifter.
4. I²C-Adresse falsch → I²C-Scanner nutzen, Adress-Jumper/SDO beachten.
5. Kalibrierung ignoriert → viele Analog-Sensoren brauchen Offset/Skalierung.

Checkliste

• Modultyp & Port (3-Pin/4-Pin/UART) identifiziert
• Versorgung & Pegel passend (3,3/5 V)
• I²C-Adresse per Scan bestätigt
• Beispielcode aus Bibliothek/Wiki getestet
• Kalibrierung dokumentiert & im Code umgesetzt

Fazit

Mit Gravity-Steckern, kompakten Boards und guten Beispielcodes ermöglicht DFRobot einen schnellen Weg vom Sensor zum lauffähigen Prototypen. Achte auf korrekte Ports, Pegel und Adressen – dann steht stabilen Messungen und robusten Projekten nichts im Weg.

Tipp: Für IoT-Projekte ist ein FireBeetle ESP32 + Gravity-I²C-Sensoren eine stabile Basis; für kompakte USB-Geräte eignet sich das kleine Beetle.