Das ultimative Teamwork-Projekt: Wie Sie mit Arduino zwei Boards und zwei Sensoren für nur einen Servo nutzen

Willkommen, angehende Tüftler und Elektronik-Enthusiasten! Haben Sie sich jemals gefragt, ob Sie die Rechenleistung von zwei Arduinos kombinieren können, um ein einzelnes Gerät zu steuern? Dieses Projekt ist Ihre Antwort. Wir werden uns auf ein faszinierendes Unterfangen begeben, bei dem zwei Arduino-Boards, jeweils mit einem Sensor ausgestattet, zusammenarbeiten, um die Position eines einzigen Servos zu steuern. Und das Beste daran? Es ist relativ kostengünstig und ein hervorragendes Lernfeld für fortgeschrittene Arduino-Techniken.

Warum dieses Projekt?

Vielleicht fragen Sie sich, warum man überhaupt zwei Arduinos für eine Aufgabe benötigt, die scheinbar von einem einzigen Board erledigt werden kann. Hier sind ein paar überzeugende Gründe:

• Komplexitätsverteilung: Verteilt die Rechenlast. Wenn Ihre Sensoren intensive Berechnungen erfordern oder Ihre Anwendung komplex ist (z. B. eine gleichzeitige Datenprotokollierung und Regelung), kann die Verteilung der Aufgaben auf zwei Boards die Gesamtleistung verbessern.
• Isolation: Sensoren können unterschiedliche Spannungen oder Anforderungen haben. Die Verwendung separater Boards kann eine elektrische Isolation bieten und potenzielle Störungen oder Schäden verhindern.
• Modulare Bauweise: Ermöglicht einen modularen Ansatz. Stellen Sie sich vor, Sie entwickeln ein komplexes System. Die Aufteilung in kleinere, unabhängige Module macht das Debuggen und die Erweiterung einfacher.
• Lernen: Bietet eine hervorragende Gelegenheit, die Kommunikation zwischen Arduinos, die Sensorintegration und die Servosteuerung zu meistern.

Was Sie brauchen

Bevor wir loslegen, stellen Sie sicher, dass Sie die folgenden Komponenten zur Hand haben:

• Zwei Arduino Uno (oder kompatible) Boards
• Ein Servo (z.B. SG90)
• Zwei Sensoren (wir empfehlen einen Lichtsensor (LDR) und einen Temperatursensor (z.B. DHT11), aber Sie können beliebige kompatible Sensoren verwenden)
• Jumperkabel
• Ein Potentiometer (optional, zur manuellen Servosteuerung während des Testens)
• Ein Breadboard
• Widerstände (passend zu Ihren Sensoren)

Das Schaltungsschema

Das Schaltungsschema ist der Schlüssel zum Verständnis, wie alles zusammenpasst. Hier ist eine Schritt-für-Schritt-Anleitung:

1. Arduino 1 (Sensor 1 – z.B. LDR):
   • Verbinden Sie den LDR mit einem analogen Eingang (z. B. A0). Denken Sie daran, einen Widerstand (typischerweise 10k Ohm) als Spannungsteiler zu verwenden.
   • Verbinden Sie den digitalen Pin 12 mit einem digitalen Pin an Arduino 2 (für die serielle Kommunikation).
   • Versorgen Sie das Arduino-Board mit Strom über USB oder eine externe Stromquelle.
2. Arduino 2 (Sensor 2 – z.B. DHT11):
   • Verbinden Sie den DHT11-Sensor mit einem digitalen Pin (z. B. D2). Achten Sie darauf, den entsprechenden Pull-Up-Widerstand zu verwenden (normalerweise im Lieferumfang des DHT11 enthalten oder separat erhältlich).
   • Verbinden Sie den digitalen Pin 11 mit dem digitalen Pin 12 von Arduino 1 (für die serielle Kommunikation).
   • Verbinden Sie den Signalpin des Servos mit einem PWM-fähigen digitalen Pin (z. B. D9).
   • Versorgen Sie das Arduino-Board mit Strom über USB oder eine externe Stromquelle.
   • *Hinweis:* Das Servo benötigt möglicherweise eine separate Stromversorgung (5V), da es zu viel Strom für das Arduino-Board ziehen könnte. Verbinden Sie in diesem Fall das GND der separaten Stromversorgung mit dem GND des Arduino.
3. Erdung:
   • Verbinden Sie die Masse (GND) beider Arduino-Boards miteinander. Dies ist entscheidend für die korrekte serielle Kommunikation.

Der Code – Arduino 1 (LDR-Sensor)

Dieser Code liest den Wert des LDR-Sensors und sendet ihn seriell an Arduino 2.

„`arduino
const int ldrPin = A0;
const int sendPin = 12; // Pin für die serielle Kommunikation mit Arduino 2

void setup() {
Serial.begin(9600); // Zum Debuggen über den seriellen Monitor
pinMode(sendPin, OUTPUT);
}

void loop() {
int ldrValue = analogRead(ldrPin);
Serial.print(„LDR Value: „);
Serial.println(ldrValue);

// Senden des LDR-Wertes an Arduino 2
digitalWrite(sendPin, HIGH); // Signal für Arduino 2, dass Daten bereit sind
delayMicroseconds(10); // Kurze Verzögerung, damit Arduino 2 das Signal erkennt
Serial.print(ldrValue); // Senden des Datenwertes
digitalWrite(sendPin, LOW); // Signal für Arduino 2, dass die Datenübertragung abgeschlossen ist
delay(50);
}
„`

Der Code – Arduino 2 (DHT11 & Servo)

Dieser Code empfängt den LDR-Wert von Arduino 1, liest den Temperaturwert vom DHT11-Sensor und steuert die Position des Servos basierend auf einer Kombination dieser Werte.

„`arduino
#include
#include

#define DHTPIN 2 // Digital pin verbunden mit dem DHT11-Sensor
#define DHTTYPE DHT11 // DHT 11

Servo myservo; // Servo-Objekt erstellen, um den Servo zu steuern
DHT dht(DHTPIN, DHTTYPE);

const int servoPin = 9;
const int receivePin = 11; // Pin für die serielle Kommunikation mit Arduino 1

int ldrValue = 0;
float temperature = 0.0;

void setup() {
Serial.begin(9600);
myservo.attach(servoPin); // Verbindet das Servo mit dem angegebenen Pin
dht.begin();
pinMode(receivePin, INPUT);
}

void loop() {
// Empfangen des LDR-Wertes von Arduino 1
if (digitalRead(receivePin) == HIGH) {
ldrValue = Serial.parseInt();
Serial.print(„Empfangener LDR-Wert: „);
Serial.println(ldrValue);
}

// Lesen des Temperaturwertes vom DHT11-Sensor
float h = dht.readHumidity();
float t = dht.readTemperature();

if (isnan(h) || isnan(t)) {
Serial.println(F(„Fehler beim Lesen des DHT-Sensors!”));
} else {
temperature = t;
Serial.print(F(„Temperatur: „));
Serial.print(temperature);
Serial.println(F(” *C”));
}

// Berechnen der Servo-Position basierend auf LDR- und Temperaturwerten
// Dies ist nur ein Beispiel. Passen Sie die Formel an Ihre Bedürfnisse an.
int servoAngle = map(ldrValue + (int)(temperature * 10), 0, 1500, 0, 180); // Kombinieren Sie LDR- und Temperaturwerte für die Servo-Steuerung
servoAngle = constrain(servoAngle, 0, 180); // Stellen Sie sicher, dass sich der Winkel innerhalb des gültigen Bereichs befindet

myservo.write(servoAngle); // Servoposition einstellen
Serial.print(„Servo-Winkel: „);
Serial.println(servoAngle);

delay(50); // Warten Sie eine kurze Zeit
}
„`

Erklärung des Codes

Lassen Sie uns den Code aufschlüsseln, um sicherzustellen, dass Sie jedes Detail verstehen:

1. Arduino 1 (LDR):
   • `analogRead(ldrPin)`: Liest den analogen Wert vom LDR-Sensor.
   • `Serial.print(ldrValue)`: Sendet den LDR-Wert über die serielle Schnittstelle.
   • `digitalWrite(sendPin, HIGH)` und `digitalWrite(sendPin, LOW)`: Diese Zeilen simulieren eine einfache serielle Kommunikation, wobei `sendPin` als Signal verwendet wird, um Arduino 2 mitzuteilen, dass ein neuer Datenwert gesendet wird.
2. Arduino 2 (DHT11 & Servo):
   • `#include ` und `#include `: Binden die erforderlichen Bibliotheken für die Servosteuerung und den DHT11-Sensor ein.
   • `myservo.attach(servoPin)`: Verbindet das Servo-Objekt mit dem Servopin.
   • `dht.readTemperature()`: Liest den Temperaturwert vom DHT11-Sensor.
   • `Serial.parseInt()`: Empfängt den LDR-Wert von Arduino 1. Es wartet auf verfügbare serielle Daten und wandelt diese in einen Integer um.
   • `map(ldrValue + (int)(temperature * 10), 0, 1500, 0, 180)`: Ordnet den kombinierten LDR- und Temperaturwert einem Winkelbereich von 0 bis 180 Grad zu. Dies ist der Kern der Entscheidung, wie das Servo gesteuert wird. Die Formel `ldrValue + (int)(temperature * 10)` kombiniert die Sensordaten. Der `map()` Funktion skaliert diesen kombinierten Wert auf einen Winkel zwischen 0 und 180.
   • `constrain(servoAngle, 0, 180)`: Stellt sicher, dass der berechnete Winkel innerhalb der Grenzen des Servos liegt.
   • `myservo.write(servoAngle)`: Bewegt das Servo auf den berechneten Winkel.

Fehlerbehebung

Wie bei jedem Elektronikprojekt können Probleme auftreten. Hier sind ein paar Tipps zur Fehlerbehebung:

• Keine serielle Kommunikation: Stellen Sie sicher, dass die GND-Anschlüsse beider Arduinos verbunden sind. Überprüfen Sie die Baudraten in beiden Codes. Sie müssen übereinstimmen. Stellen Sie sicher, dass die Verbindungspins (sendPin und receivePin) korrekt verdrahtet sind. Nutzen Sie den Seriellen Monitor zur Fehlersuche.
• Servo bewegt sich nicht: Stellen Sie sicher, dass das Servo korrekt mit Strom versorgt wird. Überprüfen Sie die Servoanschlüsse. Vergewissern Sie sich, dass der Servo-Pin ein PWM-Pin ist. Testen Sie das Servo mit einem einfachen Beispielcode, um zu bestätigen, dass es funktioniert.
• Falsche Sensorwerte: Überprüfen Sie die Sensoranschlüsse. Vergewissern Sie sich, dass Sie die richtigen Bibliotheken eingebunden haben. Verwenden Sie den seriellen Monitor, um die Rohdaten des Sensors zu überprüfen.

Erweiterungen und Erweiterungen

Dieses Projekt ist ein Sprungbrett. Hier sind einige Ideen, um es noch weiter zu führen:

• Mehr Sensoren: Integrieren Sie weitere Sensoren, um ein komplexeres System zu erstellen.
• Drahtlose Kommunikation: Verwenden Sie Module wie NRF24L01 oder ESP8266 für die drahtlose Kommunikation zwischen den Arduinos.
• Datenprotokollierung: Protokollieren Sie die Sensordaten auf einer SD-Karte oder in einer Cloud-Datenbank.
• GUI: Entwickeln Sie eine grafische Benutzeroberfläche (GUI) mit Processing oder einer anderen Programmiersprache, um die Sensordaten anzuzeigen und die Servoposition zu steuern.

Fazit

Dieses Projekt „Zwei Arduinos, zwei Sensoren, ein Servo“ ist ein faszinierendes und lehrreiches Unterfangen. Es bietet praktische Erfahrungen in der Kommunikation zwischen Arduinos, der Sensorintegration und der Servosteuerung. Indem Sie die Leistungsfähigkeit der Teamarbeit (im wahrsten Sinne des Wortes!) nutzen, können Sie ein System erstellen, das intelligenter, reaktionsfähiger und vielseitiger ist, als es ein einzelner Arduino allein könnte. Viel Spaß beim Tüfteln!