Learning Cube für Arduino

Der Learning Cube für Arduino ermöglicht Ihnen einen einfachen Einstieg in die vielseitige Arduino-Welt.
Der Cube ist in Zusammenarbeit des Hackerspace Bremen e.V. und der Funduino GmbH entstanden.

In den nachfolgenden Segmenten widmen wir uns Schritt für Schritt der Installation und Inbetriebnahme des Cubes.


Schritt 1: Der Zusammenbau des Learning Cube für Arduino

Der Cube wird in Einzelkomponenten ausgeliefert. Im Lieferumfang enthalten sind :

 

1x NANO kompatibler Mikrocontroller mit CH340 Chip
2x Pinheader (Buchse)
1x USB-Kabel für den NANO Mikrocontroller
1x Leiterplatine (engl. PCB) und 4x Montageschrauben
1x Gehäuse für die Leiterplatine
1x 0,96″ OLED Display im 128*64 Format mit I²C Schnittstelle
1x Gehäuse für das OLED Display
1x DHT11 Temperatur und Feuchtigkeitssensor
1x Lautsprecher
1x WS2812B LED Modul mit acht Pixeln
1x TL1838 Infrarotempfänger
1x Funduino Infrarot Fernbedienung
1x Fotowiderstand (engl. LDR)
1x Potentiometer
1x Kappe für Potentiometer
1x Taster
1x RGB LED
1x LED Rot
1x LED Gelb
1x LED Grün
5x Widerstand 220 Ohm
1x Widerstand 820 Ohm
1x Widerstand 1,2K Ohm
1x Widerstand 47K Ohm
2x Widerstand 4,7K Ohm
2x 100 nF Kondensator
1x 220 uF 25v Kondensator
2x Pinheader 1*3
1x Pinheader 1*4
1x Pinheader 90°


Die Bauteile werden nach folgendem Schema auf die Leiterplatine (engl. PCB) verlötet. 

Der Cube wird anschließend mit Hilfe der vier Montageschrauben mit dem Gehäuse verbunden.

Der Learning Cube für Arduino und dessen Komponenten greifen dabei auf die folgende Pinbelegungen zurück. 

A0   = DHT11
A1   = Neopixel Platine mit acht Pixeln
A2   = Infrarot Empfänger TLK1838
A3   = nicht verwendet
A4   = SDA
A5   = SCL
A6   = Potentiomter
A7   = Fotowiderstand (LDR)
D2   = Taster
D3   = LED3 (LED Grün)
D4   = LED2 (LED Gelb)
D5   = LED 1 (LED Rot)
D6   = RGB LED (Rot)
D7   = RGB LED (Grün)
D8   = RGB LED (Blau)
D9   = Lautsprecher
D10 = Servo
D11 = nicht verbunden
D12 = nicht verbunden
D13 = interne LED des Funduino NANO R3

 



Wichtiger Hinweis!

Es existieren zwei unterschiedliche Versionen der RGB-LED.

Version A  :
„Common cathode“ – Das längste Beinchen der LED ist „-“ und die drei kürzeren Beinchen werden über „+“ (Spannung) angesteuert.
Version B :
„Common anode“ – Das längste Beinchen der LED ist „+“ und die drei kürzeren Beinchen werden über „-“ (GND) angesteuert.

Je nach Version müssen variierende und zusätzliche Lötarbeiten vorgenommen werden.

In unserem Set finden Sie hauptsächlich die Version A – Typ „Common cathode“. Das bedeutet, wir setzen eine zusätzliche Lötverbindung zwischen den Pins „K“ und „C“, welche Sie links der RGB finden.
Sollten Sie eine RGB LED der Version B – Typ „Common anode“ verwenden wollen, setzen Sie eine zusätzliche Lötverbindung zwischen den Pins „A“ und „C“.
Bitte prüfen Sie vorab welche Version der RGB-LED Ihnen vorliegt.  

 

 

Zudem existieren zwei unterschiedliche Versionen des OLED Displays, welche sich lediglich in der Größe des Displays unterscheiden. Wir differenzieren hier zwischen der 0,96″ und der 1,3″ Version. 

Innerhalb dieser Versionen gibt es Unterschiede in der Reihenfolge und Bezeichnung der Pins. 
Bitte wählen Sie die unten stehende Kombination für Ihr vorliegendes OLED aus.

Je nach Version müssen die Lötverbindungen folgendermaßen gesetzt werden.

Version  0,96″ OLED – Pinreihenfolge :  VCC // GND // SCL // SDA
Verbinden Sie die Lötpunkte „VCC“ und „X“. Verbinden Sie die Lötpunkte „GND“ und „Y“.

Version  0,96″ OLED –  Pinreihenfolge : GND // VDD // SCK // SDA
Verbinden Sie die Lötpunkte „GND“ und „X“. Verbinden Sie die Lötpunkte „VDD“ und „Y“.

Version    1,3″ OLED  Pinreihenfolge :  VCC // GND // SCL // SDA
Verbinden Sie die Lötpunkte „VCC“ und „X“. Verbinden Sie die Lötpunkte „GND“ und „Y“.

Version    1,3″ OLED – Pinreihenfolge : GND // VDD // SCK // SDA
Verbinden Sie die Lötpunkte „GND“ und „X“. Verbinden Sie die Lötpunkte „VCC“ und „Y“.


                                                   Schritt 2 :  Die Installation des FTDI Treibers

Damit der NANO Mikrocontroller mit CH340 Chip von Ihrem Betriebssystem erkannt werden kann, benötigen Sie einen speziellen Treiber.
Dieser wird kostenfrei auf einer Vielzahl von Plattformen zur Verfügung gestellt, zum Beispiel von GitHub.

 

Die heruntergeladene Datei muss anschließend in einem Dateipfad Ihrer Wahl entpackt werden. 
Anschließend führen wir die Datei „SETUP.exe“ aus und installieren den Treiber durch einen Linksklick des „INSTALL“ Buttons. Nach dem erfolgreichen Abschluss der Installation erhalten Sie eine Rückmeldung.

 

 


Schritt 3 : Installation der Arduino IDE und Auswahl des Mikrocontrollers. 

Teilschritt 1) Zuerst downloaden wir die Arduino IDE, also die Software zum Ansteuern des Cubes, von der Website  www.arduino.cc und installieren diese in einem Wunschverzeichnis unseres Computers.
Im Anschluss öffnen wir den Softwareordner und starten das Programm mit dem Dateiname „arduino.exe“.

Teilschritt 2) Wir wählen anschließend durch den Klick auf den Reiter „Werkzeuge“ das „Arduino NANO“ Board aus.

 

 

Teilschritt 3) Die Arduino IDE „weiß“ nun, welcher Mikrocontroller mit unserem Sketch bespielt werden soll.
Damit die Kommunikation zwischen Arduino IDE und Mikrocontroller jedoch stattfinden kann, müssen wir zuerst den korrekten Prozessor (auch Bootloader genannt) auswählen.

Teilschritt 4) Daran anschließend stellen wir eine Verbindung zwischen dem Controller und der Software her, in dem wir den Port vergeben. In unserem Fall ist dies der Port „COM20“ (variabel). Der Mikrocontroller kann nun mit unserem Testsketch bespielt werden. 

 


   Schritt 4 : Einbindung von Bibliotheken in die Arduino IDE

Eine Bibliothek (auch Library genannt) ist für einige Projekte sinnvoll, da diese die Programmierung vereinfachen kann. Durch Libraries kann im Code auf Funktionen der jeweiligen Bibliothek zurückgegriffen werden, sodass diese nicht komplett im Code ausgeschrieben werden müssen. Die notwendigen Libraries hängen davon ab, welchen Sketch man verwendet und was man gerade programmieren möchte.

Für den Fall, dass unser Testsketch verwendet werden soll, benötigen wir folgende Libraries:

<Servo.h>  für einen Servomotor (nicht im Lieferumfang enthalten)

<Wire.h>  für die I²C Schnittstellen

<Adafruit_Neopixel.h> für die LED-Platine mit acht Pixeln

<DHT.h> für den DHT11 Sensor

Zusätzlich muss die allgemeine Sensor Library von Adafruit installiert sein. Diese lässt sich nicht automatisch einbinden, sondern ist bei GitHub zu finden:

https://github.com/adafruit/Adafruit_Sensor

Die oben genannten Libraries müssen in der Arduino Software hinzugefügt werden. Dazu gibt es verschiedene Möglichkeiten.

Die einfachste Möglichkeit bietet sich durch die Funktion „Bibliotheken verwalten…“.
Die Funktion befindet sich in der Software unter „Sketch > Bibliothek einbinden > Bibliotheken verwalten…“.
Dort kann über das Suchfeld die gewünschte Library gesucht und direkt installiert werden.

Nach der erfolgreichen Installation kann die Bibliothek direkt verwendet werden.

Alternativ können extern heruntergeladene Bibliotheken direkt in das Arduino Verzeichnis kopiert und somit installiert werden. Ein Möglicher Pfad könnte so aussehen : 

C:\Program Files (x86)\Arduino\libraries

 


Schritt 5 : Der Testsketch

Nun ist es fast geschafft : Wir haben den Learning Cube für Arduino zusammengebaut, die Arduino IDE mit den zugehörigen Bibliotheken installiert und sind nun bereit, den Cube in Betrieb zu nehmen. 

Damit wir testen können, ob alle Komponenten ordnungsgemäß auf dem Board verlötet wurden, spielen wir den nachfolgenden Sketch auf. Dieser spricht nacheinander alle Bauteile des Cubes an.
So sollten nun zum Beispiel die LEDs blinken, der Lautsprecher ertönen und ein Beispieltext auf dem OLED erscheinen. Ein Teil der verbauten Bauteile erfasst jedoch Werte, welche zunächst im Seriellen Monitor ausgelesen werden können.


Der Sketch : 

 

//Vorab Libraries laden:
// DHT, NEOPIXEL, OLED ASCII, IRremote (shirriff),

//Intro Lichtsensor
int LichtWert = 0; //Variable für den Sensorwert mit 0 als Startwert

// Intro RGB-LED
int RGBLEDrot=6; // Farbe rot an Pin 6
int RGBLEDgruen=7; // Farbe gruen an Pin 7
int RGBLEDblau=8; // Farbe blau an Pin 8
int p=500; // p ist eine Pause mit 1000ms also 1 Sekunde
int brightness1a = 0; // Zahlenwert zwischen 0 und 255 – gibt die Leuchtstärke der einzelnen Farbe an
int brightness1b = 0; // Zahlenwert zwischen 0 und 255 – gibt die Leuchtstärke der einzelnen Farbe an
int brightness1c = 0; // Zahlenwert zwischen 0 und 255 – gibt die Leuchtstärke der einzelnen Farbe an
int dunkel = 255; // Zahlenwert 0 bedeutet Spannung 0V – also LED aus.

//Intro Fernbedienung
//#include <IRremote.h>   // Das Programm greift an dieser Stelle auf eine „Library“ zurück. Das erleichtert einem viel Arbeit. Denn das Infrarotlicht wird mit einem Code verschlüsselt gesendet. Um diesen Code selber auszulesen und in passende Werte umzuwandeln, wären sehr viele Zeilen Code erforderlich.
//int RECV_PIN = A6;  //  Der Kontakt der am Infrarotsensor die Daten ausgibt, wird mit Pin 11 des Arduinoboards verbunden.
//IRrecv irrecv(RECV_PIN);   // An dieser Stelle wird ein Objekt definiert, dass den Infrarotsensor an Pin 11 ausliest.
//decode_results results;  // Dieser Befehl sorgt dafür, dass die Daten, die per Infrarot eingelesen werden unter „results“ abgespeichert werden.


//Intro Servo
#include <Servo.h> //Die Servobibliothek wird aufgerufen. Sie wird benötigt, damit die Ansteuerung des Servos vereinfacht wird.
Servo servoblau; //Erstellt für das Programm ein Servo mit dem Namen „servoblau“

// Intro OLED
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
SSD1306AsciiWire oled; 

// Intro Neopixel
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN 11 // Hier wird angegeben, an welchem digitalen Pin die WS2812 LEDs bzw. NeoPixel angeschlossen sind
#define NUMPIXELS 8 // Hier wird die Anzahl der angeschlossenen WS2812 LEDs bzw. NeoPixel angegeben
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
int pause=70; // 100 Millisekunden Pause bis zur Ansteuerung der nächsten LED.

// Intro DHT11
#include "DHT.h" //DHT Bibliothek laden
#define DHTPIN 12 //Der Sensor wird an PIN 2 angeschlossen    
#define DHTTYPE DHT11    // Es handelt sich um den DHT11 Sensor
DHT dht(DHTPIN, DHTTYPE); //Der Sensor wird ab jetzt mit „dth“ angesprochen


void setup() 
{
//Serieller Monitor - Dient zum Anzeigen von Daten am seriellen Monitor
Serial.begin(9600);    //Im Setup wird die Serielle Verbindung gestartet, damit man sich die Empfangenen Daten der Fernbedienung per seriellen Monitor ansehen kann.
  
// Setup Taster
pinMode(2, INPUT_PULLUP);

// Setup Ampel
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);  
 
//Setup RGB-LED
pinMode(RGBLEDblau, OUTPUT);
pinMode(RGBLEDgruen, OUTPUT);
pinMode(RGBLEDrot, OUTPUT);

// OLED Setup
Wire.begin();

// Neopixel Setup
pixels.begin(); // Initialisierung der NeoPixel

//Setup Servo
servoblau.attach(10); //Das Setup enthält die Information, dass das Servo an der Steuerleitung (gelb) mit Pin 8 verbunden wird. Hier ist natürlich auch ein anderer Pin möglich.

//Setup DHT
dht.begin();

//Fernbedienung
//irrecv.enableIRIn();   //Dieser Befehl initialisiert den Infrarotempfänger.

  
}


void loop() 
{

//Potentiometer
int sensorwert =analogRead(A6);

if (sensorwert>=400)
 {
  //Aktion abhängig vom Wert des Potentiometers
 }

//Taster
int tasterstatus = digitalRead(2); //Taster an Pin 2 auslesen
if (tasterstatus==LOW)
 {
  //Aktion abhängig vom Wert des Tasters
 }
  
// OLED
oled.begin(&Adafruit128x64, 0x3C);
  oled.setFont(Arial_bold_14);
  oled.clear();
  oled.println("MJAM MJAM");
  oled.println("Rene hamm hamm");
  oled.println("IDEENEXPO");
  oled.println("2019 Mach doch!");
  delay(500);
  
//Ampel
  digitalWrite(3, HIGH);
  delay(500);    
  digitalWrite(3, LOW);       
  digitalWrite(4, HIGH);
  delay(500);    
  digitalWrite(4, LOW);    
  digitalWrite(5, HIGH);
  delay(500);    
  digitalWrite(5, LOW);    

// RGB LED
analogWrite(RGBLEDblau, brightness1a); // blau einschalten
delay(p); // pause
analogWrite(RGBLEDblau, dunkel); // blau ausschalten
analogWrite(RGBLEDrot, brightness1b); // rot einschalten
delay(p); // pause
analogWrite(RGBLEDrot, dunkel); // rotausschalten
analogWrite(RGBLEDgruen, brightness1c); // gruen einschalten
delay(p); // pause
analogWrite(RGBLEDgruen, dunkel); // gruenausschalten

// Neopixel

//Rot
for (int i = 1; i <= 8; i++) 
{
pixels.setPixelColor(i, pixels.Color(255,0,0));
pixels.show(); // Durchführen der Pixel-Ansteuerung
delay (pause); // Pause, in dieser Zeit wird nichts verändert.;
}
//Gelb
for (int i = 1; i <= 8; i++) 
{
pixels.setPixelColor(i, pixels.Color(255,255,0));
pixels.show(); // Durchführen der Pixel-Ansteuerung
delay (pause); // Pause, in dieser Zeit wird nichts verändert.;
}
//Grün
for (int i = 1; i <= 8; i++) 
{
pixels.setPixelColor(i, pixels.Color(0,255,0));
pixels.show(); // Durchführen der Pixel-Ansteuerung
delay (pause); // Pause, in dieser Zeit wird nichts verändert.;
}
//Türkis
for (int i = 1; i <= 8; i++) 
{
pixels.setPixelColor(i, pixels.Color(0,255,255));
pixels.show(); // Durchführen der Pixel-Ansteuerung
delay (pause); // Pause, in dieser Zeit wird nichts verändert.;
}
//Blau
for (int i = 1; i <= 8; i++) 
{
pixels.setPixelColor(i, pixels.Color(0,0,255));
pixels.show(); // Durchführen der Pixel-Ansteuerung
delay (pause); // Pause, in dieser Zeit wird nichts verändert.;
}
for (int i = 8; i >= 1; i--) 
{
pixels.setPixelColor(i, pixels.Color(0,0,0)); 
pixels.show(); // Durchführen der Pixel-Ansteuerung
delay (pause); // Pause, die LEDs bleiben in dieser Zeit aus
}

// Lautsprecher
tone(9, 300); // Im Hauptteil wird nun mit dem Befehl "tone ( PIN , TONHOEHE )" ein Ton abgegeben.
delay(100); // mit einer Dauer von 1 Sekunde
noTone(9); // Der Ton wird abgeschaltet
delay(100); // mit einer Dauer von 1 Sekunde

// DHT11 Temperatur und Luftfeuchtigkeit
float Luftfeuchtigkeit = dht.readHumidity(); //die Luftfeuchtigkeit auslesen und unter „Luftfeutchtigkeit“ speichern
float Temperatur = dht.readTemperature();//die Temperatur auslesen und unter „Temperatur“ speichern

  oled.setFont(Arial_bold_14);
  oled.clear();
  oled.println("Temperatur");
  oled.println(Temperatur);
  oled.println("Luftfeuchte");
  oled.println(Luftfeuchtigkeit);
  delay(2000);

//Servo
servoblau.write(90); //Position 1 ansteuern mit dem Winkel 90°
delay(1000); //Das Programm stoppt für eine Sekunde
servoblau.write(0); //Position 2 ansteuern mit dem Winkel 0°
delay(1000); //Das Programm stoppt für eine Sekunde

//Fernbedienung
//if (irrecv.decode(&results)) 
//{    //Wenn Daten empfangen wurden,
//Serial.println(results.value, DEC); //werden sie als Dezimalzahl (DEC) an den Serial-Monitor ausgegeben.
//irrecv.resume();  //Der nächste Wert soll vom IR-Empfänger eingelesen werden
//}

// Lagesensor
int x=analogRead(A1); // Auslesen des Sensorwertes der x-Achse
int y=analogRead(A2); // Auslesen des Sensorwertes der y-Achse
int z=analogRead(A3); // Auslesen des Sensorwertes der z-Achse
Serial.print (x); // Ausgabe des Sensorwertes der x-Achse an den serial monitor
Serial.print ("    "); // Ausgabe von vier Leerzeichen
Serial.print (y); // Ausgabe des Sensorwertes der y-Achse an den serial monitor
Serial.print ("    "); // Ausgabe von vier Leerzeichen
Serial.println (z); // Ausgabe des Sensorwertes der z-Achse an den serial monitor und Zeilenumsprung durch den Befehl "Serial.println"
delay(100); // Wartezeit zwischen den einzelnen Ausgaben der Sensorwerte

//Lichtmessung
{
LichtWert =analogRead(A7); //Die Spannung an dem Fotowiderstand auslesen und unter der Variable „sensorWert“ abspeichern.
if (LichtWert > 512 ) //Wenn der Sensorwert über 512 beträgt….
{
digitalWrite(3, HIGH); //…soll die rote LED leuchten…
}

else //andernfalls…
{
digitalWrite(3, LOW); //….soll die rote LED nicht leuchten.
}
delay (50); //Eine kurze Pause, in der die LED an oder aus ist
}
               
}