Mit Naegeln und Intel® Galileo einen Erdfeuchtigkeitssensor bauen

Ob Sie es glauben oder nicht, ich habe in gerade einmal  in zwei Stunden  ein aus Hardware und Software bestehendes Projekt fertiggestellt. Wovon ich spreche? Intel® Galileo – das erste Intel® Mainboard, das mit der Arduino*-API kompatibel ist und einige neue, coole Features bietet.

Bevor ich die Herstellung eines äußerst erschwinglichen Feuchtigkeitssensorsystems erkläre, möchte ich Intel Galileo vorstellen.

Intel® Galileo-Mainboard – Hardware 
Das Intel Galileo-Mainboard basiert auf einem neuen 32-bit-Einkern-Single-Thread-Prozessor mit x86-Architektur, dem Intel® Quark SoC X1000, und bietet volle ACPI-Kompatibilität und RTC-Unterstützung. Erinnern Sie sich noch an den Pentium? Ganz genau: mit Chipsatz-Befehlen kompatibel, aber kleiner, erschwinglich, ACPI-fähig und äußerst einfach zu verwenden. 
Zur Mainboard-Ausstattung gehören außerdem:

  • Ethernet-Anschluss
  • PCIe-Bus (Mini-PCI)
  • Steckplatz für SD-Karte (bis zu 32 GB)
  • Arduino-Uno-Standardpins für digitale und analoge Eingabe/Ausgabe und ein IO-Expander, mit dem sich 8 PWM-Kanäle erzeugen lassen
  • 1 USB-Port als Host (2.0) für bis zu 128 Geräte
  • 1 USB-Port für die Programmierung (2.0)
  • 512 MB Flash-Speicher und 216 MB RAM
  • Reset-Knopf für den Prozessor, Reset-Knopf für die Sketches
  • 10-poliger JTAG-Anschluss
  • Unterstützung für 5-V- und 3,5-V-Betrieb des Mainboards (über Jumper konfigurierbar)
  • 11-kbit-EEPROM verfügbar (dafür gibt es auch eine API... und zwar hier)

Den Schaltplan finden Sie hier.

Intel® Galileo-Mainboard – Software 
Intel Galileo verwendet Linux* als Betriebssystem, und der Systemstart kann von der Flash-SD-Karte erfolgen. Besonders interessant ist, dass auf diesem Mainboard die Arduino-APIs zur Verfügung stehen, also die IDE für Linux, Windows* und Mac* im 32- und 64-bit-Format. 
Nur die Arduino-APIs? Keineswegs! Das Mainboard kommt mit zusätzlichen Erweiterungen... und da es nun neue Komponenten gibt, wurden neue APIs erstellt, etwa RTC, EEPROM, Web-Client usw. Und es gibt noch ein weiteres Detail: Die Servo-API ist eine neue Methode, die hinzugefügt wurde, um Flügelmotoren mit 188 Hz (für erhöhte Präzision) oder 50 Hz zu betreiben. 
Unter Linux werden gemeinsam mit der IDE-Installation auch alle Crosscompiler installiert (Toolchain). Daher können Sie in nativem C/C++-ANSI entwickeln und die Linux-Bibliotheken verwenden. Die Arduino-IDE ist in diesem Fall optional, da Sie Ihren Code nativ entwickeln und zum Beispiel mit FTP übertragen können.

Wann wird Intel Galileo erhältlich sein? Wie viel wird das Mainboard kosten? Und... ist es die Investition wert? 
Das Mainboard gibt es bereits seit Ende 2013. Die Kosten liegen bei etwa [70 – 75 €].Intel Galileo hat einen Ethernet-Anschluss und einen PCIe-Bus. Wenn Sie mit Arduino ein Projekt entwickeln wollen, das eine Internetverbindung braucht, müssen Sie zusätzlich ein teures WiFi/Ethernet-Shield kaufen, das mit etwa 65 US-Dollar (in Europa leider deutlich mehr) zu Buche schlägt. Wenn Sie Galileo verwenden, können Sie den integrierten Ethernet-Anschluss verwenden oder ein einfaches WiFi- und Bluetooth-Modul mit PCIe-Kompatibilität kaufen. Dasselbe gilt, wenn Sie eine Grafikkarte benötigen! 
Ein weiteres Plus ist die Echtzeituhr (RTC)... Ein weiterer Shield ist hierfür nicht nötig... Dasselbe gilt für die SD-Karte: Für die Datenprotokollierung brauchen Sie keinen weiteren Shield, da Sie die APIs verwenden und bis zu 32 GB auf der SD-Karte, für die bereits ein Steckplatz vorgesehen ist, speichern können. 
Mit diesem Ansatz sparen Sie jede Menge Geld und haben für Ihr Projekt ein leistungsstarkes Mainboard zur Verfügung.

Womit fange ich an?
Wenn Sie ein Arduino-Entwickler sind, werden Sie feststellen, dass die IDE größtenteils identisch ist, mit Ausnahme der neu hinzugefügten APIs und der Option, die Mainboard-Firmware zu aktualisieren. 
Lesen Sie den Einsteigerleitfaden und laden Sie die IDE herunter. Bei der IDE haben Sie die Wahl zwischen Windows, Linux und Mac. 
Die IDE bietet eine spezielle Funktion, mit der sich das Linux-Betriebssystem auf Ihrem Mainboard (Flash-Speicher oder SD-Karte) aktualisieren lässt. Im Einsteigerleitfaden finden hierzu Sie weitere Informationen.

Erdfeuchtigkeitssystem mit Nägeln
Nach dieser Einführung in das Intel Galileo-Mainboard ist es an der Zeit, dass wir uns ein sehr einfaches Projekt anschauen. Ich habe es in zwei Stunden angefertigt und auf der Maker Fair in Rom präsentiert.

Auf den ersten Blick war den Messebesuchern nicht ganz klar, was zwei mit Erde gefüllte und verdrahtete Becher auf einer Elektronikmesse zu suchen haben, aber sobald sie die Details verstanden hatten, waren sie begeistert (sogar Intels CEO Brian Krzanich).

Das System basiert auf zwei Sensoren. Für jeden Sensor kommen galvanisierte Nägel zum Einsatz, die mit einem analogen Port verbunden sind und eine Widerstandsperre zu einem anderen Widerstand bilden. Die Sensoren sind so konstruiert, dass die Nägel stets 3,8 cm voneinander entfernt sind, was ich mit einem Stück Schaumstoff erreiche, das ich im Abfall gefunden habe. Das System, das für die Überwachung der Erdfeuchtigkeit einfache Nägel verwendet, ist simpel und günstig. Der Grund, warum ich mich für galvanisierte Nägel entschieden habe, ist naheliegend... Ich wollte vermeiden, dass die Nägel innerhalb kürzester Zeit zu rosten beginnen.

 

 

Mit dem System kann ich überprüfen, ob die Pflanzenerde ausreichend mit Wasser versorgt ist. Und da ich das Projekt auf einer Elektronikmesse ausstellte, baute ich eine LED-Matrix, die ein glückliches oder trauriges Gesicht zeigt. Das Gesicht hat eine Drucktaste.

Wenn „ein Auge“ leuchtet, entspricht das Sensor Nummer EINS. „Zwei Augen“ bedeutet Sensor Nummer ZWEI. Die Sensorauswahl erfolgt über die Drucktaste. Auf diese Weise können die Benutzer „ein“ oder „zwei“ Augen einschalten. Auf der Messe verwendete ich zwei Becher, von denen einer nur eine geringe Wassermenge enthielt. Jeder Becher war mit einem Sensor verbunden.

 

Anschließend wurde jeder Sensor mit einem entsprechenden analogen Port (A0 – Sensor 1 und A1 – Sensor 2) verbunden. Der über die Drucktaste ausgewählte Sensor und die „Augen“ wurden periodisch kontrolliert. Wenn das Wasser unter einer bestimmten Menge lag (siehe Code), war die Erde trocken und die Pflanzen benötigten mehr Wasser. Folglich stellte die LED-Matrix ein trauriges Gesicht dar. War die Feuchtigkeit hingegen ausreichend, zeigte die LED-Matrix ein glückliches Gesicht.

Schauen Sie sich die Bilder unten an. Im ersten Bild ist Sensor Nummer 2 (zwei Augen) aktiv: Die Pflanze ist glücklich, da sich im ersten mit Erde gefüllten Becher ausreichend Wasser befindet. Im zweiten Bild (ein Auge) ist Sensor Nummer 1 aktiv: Die Pflanze ist unglücklich, da sie dringend Wasser benötigt.

 

Vorstellbar wäre, dass Sie das unglückliche Gesicht anschließend durch Geräusche dazu auffordert, der Pflanze Wasser zu geben. Da ich das Projekt auf einer Messe vorstellte, schloss ich kein elektrisches Wasserventil an, denn Wasserpfützen wären sicher nicht gut angekommen und außerdem hätte ich ständig die Erde wechseln müssen. Wenn Sie das System zu Hause nachbauen, benötigen Sie keine LED-Matrix, um eine Blume mit glücklichem oder unglücklichem Gesicht darzustellen. Sie müssen lediglich die Nägel mit den analogen Ports verbinden und dann die Entscheidung, ob zum Beispiel ein Bewässerungssystem eingeschaltet werden soll, Ihrer Software überlassen.

Der Code:

Im folgenden Abschnitt finden Sie den Code, mit dem die Sensoren ausgelesen werden und die LED-Matrix nach Betätigung der Drucktaste verändert wird. Zu einem späteren Zeitpunkt werde ich einen weiteren Beitrag posten, in dem ich zeige, wie ich das System mit dem Ethernet-Anschluss oder WiFi-PCIe-Modul zum Kommunizieren bringe.

</pre>
// Autor: Manoel Carlos Ramon
 
#define DEBUG 0
 
/* Pins, die definieren, ob das System eingeschaltet ist */
#define PIN_LEFT_EYE 10
#define PIN_RIGHT_EYE 11
 
/* Sensorwechselschalter */
#define PIN_SWITCH_SYSTEM 13
int sensor_value = 0;
 
/* Feuchtigkeitssensor – analoger Input */
#define ANALOG_MOISTURE_SENSOR_1 A0
#define ANALOG_MOISTURE_SENSOR_2 A1
 
/* Analog ermittelter Grenzwert, der angibt, dass die Erdfeuchtigkeit ausreichend ist */
#define SOIL_IS_GOOD 350
 
/* Einige Prototypen */
void clear();
int current_system = 0;
int button_state = 0;
int last_button_state = 0;
 
int array_happy_face[2][4] = {{1, 0, 0, 1}, /* Zeile 1 */
 {0, 1, 1, 0}}; /* Zeile 0 */
 
int array_sad_face[2][4] = {{0, 1, 1, 0}, /* Zeile 1 */
 {1, 0, 0, 1}}; /* Zeile 0 */
 
/*
 _____________ LED 0 – Pin 6
 | __________ LED 1 = Pin 7
 | | _______ LED 2 = Pin 8
 | | | ______ LED 3 = Pin 9
 | | | |
*/
 
int array_serious_face[2][4] = {{1, 1, 1, 1}, /* Zeile 1 */
 {1, 1, 1, 1}}; /* Zeile 0 */
 
/*
 ^ ^ ^ ^
 | | | |__ LED 3 = Pin 5
 | | |______ LED 2 = Pin 4
 | |________ LED 1 = Pin 3
 |____________ LED 0 = Pin 2
*/
 
/* LED */
/*
 Funktionsweise der Pins
Pin 0 – Wählt den gemeinsamen Pluspol Zeile 0.
Pin 1 – Wählt den gemeinsamen Pluspol Zeile 1.
*/
int lastButtonState = LOW; // Der zuvor aus der Input-Pin ausgelesene Wert
long lastDebounceTime = 0; // Der letzte Zeitpunkt, zu dem der Output-Pin umgeschaltet wurde
long debounceDelay = 50; // Die Entprellzeit; erhöhen, wenn die Ausgabe flackert
 
void setup() {
 
 if (DEBUG) Serial.begin(9600);
 // An dieser Stelle sorgt der Setup-Code dafür, dass Folgendes einmal ausgeführt wird:
 int pin = 0;
 for (pin = 0; pin < 12; pin++)
 {
 pinMode(pin, OUTPUT);
 delay(10);
 }
 
 // Drucktaste
 pinMode(PIN_SWITCH_SYSTEM, INPUT);
 
// Löschen – clear()
 
}
 
void clear()
{
 int pin = 0;
 for (pin = 0; pin < 12; pin++)
 {
 digitalWrite(pin, LOW);
 }
 
}
void drawMatrix(int array[2][4])
{
 int line = 0;
 int pin = 2;
 int c = 0;
 int level = LOW;
 
 while (line < 2)
 {
 digitalWrite(line, LOW);
 
 while (c <= 3)
 {
 
 level = array[line]1;
 if (DEBUG)
 {
 Serial.print(line);
 Serial.print(",");
 Serial.print(c);
 Serial.print(":");
 Serial.print(pin);
 Serial.print("(");
 Serial.print(level);
 Serial.print("}");
 }
 
 digitalWrite(pin, level);
 c++;pin++;
 }
 c=0;
 /* if (DEBUG)
 {
 Serial.println("ok");
 Serial.println();
 }*/
 line++;
 delay(10);
 }
 
 digitalWrite(PIN_LEFT_EYE, HIGH);
 
 if (current_system != 0) digitalWrite(PIN_RIGHT_EYE, HIGH);
 
}
 
int checkButtonState()
{
 
 // Status der Taste in eine lokale Variable lesen
 int reading = digitalRead(PIN_SWITCH_SYSTEM);
 
// Überprüfen, ob die Taste gedrückt wurde
 // (d. h. ob die Eingabe zwischen LOW und HIGH gewechselt hat) und ob Sie
 // seit dem Drücken lange genug gewartet haben, um Störungen zu vermeiden:
 
// Wenn sich die Tastenstellung durch eine Störung oder durch Drücken geändert hat,
 if (reading != lastButtonState) {
 // wird der Timer für die Entprellzeit zurückgesetzt.
 lastDebounceTime = millis();
 }
 
 if ((millis() - lastDebounceTime) > debounceDelay) {
 // Unabhängig vom Status des ausgelesen Werts existiert er bereits länger
 // als die Entprellverzögerung. Daher können Sie ihn als aktuellen Status verwenden:
 
// Wenn sich der Tastenstatus geändert hat:
 if (reading != button_state) {
 button_state = reading;
 
}
 }
 
return button_state;
}
void loop() {
 
digitalWrite(0, LOW);
 
digitalWrite(1, LOW);
 // Sensor auslesen
 switch (current_system)
 {
 case 0:
 sensor_value = analogRead(ANALOG_MOISTURE_SENSOR_1);
 break;
 
 case 1:
 sensor_value = analogRead(ANALOG_MOISTURE_SENSOR_2);
 break;
 }
 
 if (DEBUG)
 {
 Serial.print("current_system:");
 Serial.println(current_system);
 
 Serial.print(" sensor_value:");
 Serial.println(sensor_value);
 }
 
 if (sensor_value >= SOIL_IS_GOOD)
 {
 drawMatrix(array_happy_face);
 }
 else
 {
 drawMatrix(array_sad_face);
 }
 
 // Tastenstatus auslesen
 button_state = digitalRead(PIN_SWITCH_SYSTEM);
 
 checkButtonState();
 if( button_state == HIGH)
 {
 // Taste ist gedrückt
 current_system++;
 if (current_system > 1) current_system = 0;
 }
 
 if (current_system == 0)
 digitalWrite(PIN_RIGHT_EYE, LOW);
 
 delay(100);
 
}
<pre>

Download

Da das Format oben nicht besonders benutzerfreundlich ist, steht der Code hier für Sie zum Download bereit.

Im nächsten Teil werde ich zeigen, wie Sie die Pflanzen zum Kommunizieren bringen, damit sie Ihnen mitteilen können, wann sie Wasser benötigen.

Über Rom und Italien

Einer der schönsten Orte, den ich je besucht habe... ich liebe diese Stadt, die Menschen und das Essen!

Dieser Beitrag ist eine Übersetzung des Artikels Creating a soil moisture sensors using nails and Intel Galileo, der zuerst auf der privaten Webseite des Intel Mitarbeiters Manoel  Ramon veröffentlicht wurde:

http://bytesthink.com/blog/?p=242

Para obter informações mais completas sobre otimizações do compilador, consulte nosso aviso de otimização.