Funduino-Cube programmieren #1: LEDs – Teil 1

In diesem ersten Beitrag möchte ich dir zeigen, wie du die LEDs am Funduino-Cube programmieren kannst.

Ich habe dir bereits gezeigt wie du LEDs am Arduino programmierst, der Funduino-Cube verfügt über einen Arduino Nano V3 und daher würde dieses nichts Neues werden. Aber dieses Board verfügt über ein paar Aktoren, welche wir nutzen wollen.

Im ersten Teil möchte ich dir zeigen, wie du LEDs mit dem Fotowiderstand (LDR) und dem 3 Achsen Lagesensor steuern kannst.

Ein großer Vorteil des Funduino-Cube ist, dass eine aufwändige und ggf. fehleranfällige Schaltung entfällt, wir können also quasi mit der Programmierung direkt beginnen.

Fotowiderstand & LEDs

Der Fotowiderstand ist am Pin analogen Pin A7 angeschlossen und liefert je nach Helligkeit einen Wert zwischen 0 (für dunkel) und 1023 (für maximale Helligkeit).

Mit diesem Fotowiderstand oder auch LDR genannt können wir nun die drei, farbigen, 8 mm LEDs steuern.

//Fotowiderstand / LDR am analogen Pin A7 angeschlossen
#define ldr A7

//LED rot am digitalen Pin D5 angeschlossen
#define ledRot 5
//LED gelb am digitalen Pin D4 angeschlossen
#define ledGelb 4
//LED gruen am digitalen Pin D3 angeschlossen
#define ledGruen 3

//Array mit den Pins der LEDs
int leds[] = { ledRot, ledGelb, ledGruen };

//Feld zum speichern der zuletzt aktivierten LED
int lastActiveLed = -1;

void setup() {
  //definieren das die Pins der LEDs als Ausgang dienen
  pinMode(ledRot, OUTPUT);
  pinMode(ledGelb, OUTPUT);
  pinMode(ledGruen, OUTPUT);
}

/** 
Zurucksetzen / deaktivieren der LEDs
*/
void reset() {
  digitalWrite(ledRot, LOW);
  digitalWrite(ledGelb, LOW);
  digitalWrite(ledGruen, LOW);
}

void loop() {
  //lesen des aktuellen Wertes des analogen Fotowiderstandes
  int value = analogRead(ldr);
  //mappen des analogen Wertes auf die Anzahl der LEDs
  //ein Array beginnt mit dem Index 0!
  int activeLed = map(value, 0, 1023, 0, 2);
  //Wenn der ermittelte Wert ungleich der zuletzt aktivierten LED ist, dann...
  if (lastActiveLed != activeLed) {
    //ueberschreiben des Wertes
    lastActiveLed = activeLed;
    //deaktivieren aller LEDs
    reset();
    //aktivieren der neuen LED
    digitalWrite(leds[activeLed], HIGH);
  }
}

Wenn wir diesen Code aufspielen, dann können wir mit einer Taschenlampe den Fotowiderstand beleuchten und somit die rote LED zum Leuchten bringen. Wenn wir diesen jedoch abdunkeln, dann leuchtet die grüne LED.

Analoger 3 Achsen Lagesensor & NeoPixel Bar

Den 3 Achsen Lagesensor können wir über die 3 nachfolgenden analogen Pins auslesen.

3 Achsen Lagesensor	Anschluss am Arduino Nano
X	A1
Y	A2
Z	A3

Die 8fach NeoPixel Bar ist am digitalen Pin D8 angeschlossen.

Für den NeoPixel benötigen wir zum Programmieren noch eine Bibliothek, hier verwende ich ich die Adafruit NeoPixel Bibliothek welche du entweder vom GitHub Repository adafruit / Adafruit_NeoPixel als ZIP-Datei herunterladen oder ganz bequem über den Bibliotheksverwalter der Arduino IDE.

Der Weg über den Bibliotheksverwalter der Arduino IDE ist deutlich einfacher, denn dort braucht man nur nach “Adafruit NeoPixel” suchen und an dem entsprechenden Eintrag die Schaltfläche “INSTALL” klicken.

Programmieren

Nachfolgend möchte ich dir zeigen, wie du die Lage Y auslesen kannst und je nach Lage der Platine eine LED aktivierst.

#include <Adafruit_NeoPixel.h>

//Der Pin der Y-Achse des 3 Achsen Lagesensors
//ist am analogen Pin A2 angeschlossen
#define yAchse A2

//NeoPixel Bar am digitalen Pin D11 angeschlossen
#define neoPixel 11

//Anzahl der NeoPixel
const int NUM_PIXEL = 8;

Adafruit_NeoPixel bar = Adafruit_NeoPixel(NUM_PIXEL, neoPixel, NEO_GRB + NEO_KHZ800);

//Positionen des Lagesensors, diese können variieren und sollten vorher geprüft werden
const int ZERO_POS = 326;
const int MAX_POS = 400;
const int MIN_POS = 262;

//Wert für die Farbe rot
uint32_t red = bar.Color(255, 0, 0);
//RGB Wert für die Farbe schwarz
uint32_t black = bar.Color(0, 0, 0);

void setup() {
  //beginn der kommunikation mit der RGB NeoPixel Bar
  bar.begin();
  //die Helligkeit setzen 0 dunkel -> 255 ganz hell
  bar.setBrightness(100);
  //anzeigen der Pixelfarben
  bar.show();
}

void loop() {
  // lesen des aktuellen Wertes der Y-Achse
  int yAxisValue = analogRead(yAchse);
  //Feld zum speichern des Wertes für die zu aktivierende LED
  int activeLED = 0;
  //Wenn der Wert kleiner als 326 ist, dann..
  if (yAxisValue < 326) {
    //mappen des Wert von 326 bis zum niedrigsten von 262 auf die ersten 4 LEDs
    activeLED = map(yAxisValue, 326, 262, 4, 0);
  } else {
    //mappen des Wert von 326 bis zu den höchsten von 400 auf die letzten 4 LEDs
    activeLED = map(yAxisValue, 326, 400, 4, 8);
  }

  //Schleife über alle LEDs
  for (int i = 0; i < NUM_PIXEL; i++) {
    //Feld für die Farbe
    uint32_t color;
    //Wenn der aktuelle Zähler gleich der zu aktivierenden LED ist,dann...
    if (i == activeLED) {
      //Farbe rot zuweisen
      color = red;
    } else {
      //ansonsten, Farbe schwarz zuweisen
      color = black;
    }
    //setzen der Farbe an der LED mit dem Index i
    bar.setPixelColor(i, color);
  }
  //anzeigen aller LEDs
  bar.show();
  //kleine Pause von 25 ms.
  delay(125);
}

Wenn wir diesen Code auf den Funduino-Cube bzw. dem verbauten Arduino Nano überspielen, dann können wir mit dem Bewegen der Platine über die y-Achse die LEDs auf der NeoPixel Bar aktivieren bzw. bewegen.