Sonntag, 6. November 2016

TFT Module und die richtige Bibliothek

Die Tage werden wieder kälter und ich sitze wieder länger Zuhause. Was gibt es besseres zu tun um einige Dinge heraus zu finden.

Bei meinen Versuchen mit dem TFT Modul traten Schwierigkeiten auf, wo ich oft nur wenig im Internet an „Lösungen“ (nicht) fand und zudem die Einträge schon relativ alt waren.

Was brauche wir für das Beispiel:
  • 1 x Arduino UNO
  • 6 x Kabel
  • 1 x Experimentierboard
  • 1 x 1.8“ TFT Modul, SPI 128x160


Bevor der erste Code geschrieben werden kann und auf den Arduino geladen wird, muss zunächst die Bibliothek eingebunden werden. In der Entwicklungsumgebung von Arduino sind bereits viele Bibliotheken vorhanden, sowie auch für das Display.



Wenn ihr beim kompilieren mehrere Fehler erhält, dann ist vielleicht die vorhandene Bibliothek die alte Version. Zumindest in meinem Fall und das führte dazu dass, sich der Quellcode nicht Kompilierern lies. Dieser Fehler trat mit der Arduino Version 1.6.8 auf, allerdings sei angemerkt, hat dieser Fehler nichts mit der Versionsnummer zu tun.

Falls neben der Bibliothek “Adafruit ST7735 Library” eine “Adafruit ST7735” vorhanden ist, dann sollte diese deinstalliert werden. Das gleiche gilt auch mit „Adafruit GFX Library“ und „Adafruit GFX“. Nur die, die am Ende des Namen „Library“ haben, müssen bestehen bleiben.

Das kann dann über dem Verzeichnis „../Dokumente/Arduino/libraries/ gelöscht werden. Sobald die aktuellere Bibliothek installiert ist, sollte der folgende „Hello World!“ Quellcode kompilierbar sein.

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>

// Verkabelung / Pins
// SCLK     => D13
// MOSI/DIN => D11
// CS       => D10
// DC       => D9
// RST      => D8

// Instanz anlegen zu dem verwendeten Bildschirm.
Adafruit_ST7735 tft = Adafruit_ST7735(10, 9, 8);

void setup() {

  // Initialisiert den Bildschirm
  // und legt die Spalten Adressierung fest.
  tft.initR(INITR_BLACKTAB);

  // Zusätzlichen Pin Ausgang festlegen
  // für die Beleuchtung
  pinMode(5, OUTPUT);

  // Bildschirm Beleuchtung einschalten.
  analogWrite(5, 255);
}

void loop() {

  // bildschirm zurück setzen,
  // bzw. es werden alle Pixel auf Schwarz umgestellt.
  tft.fillScreen(ST7735_BLACK);

  // Textgröße einstellen
  // Text ist mit einem Wert 2 doppelt so groß.
  tft.setTextSize(1);
  // Start Postion festlegen, von wo aus
  // der Text begonnen wird zu schreiben
  // x von links nach rechts
  // y von oben nach unten
  tft.setCursor(5,5); //x, y

  // farbe des Textes
  tft.setTextColor(ST7735_WHITE);
  // Ausgabe Text.
  tft.println("Hello World!");

  // fünf Sekunden warten
  delay(5000);
}

Für gewöhnlich kann die Verkabelung vorgenommen werden, wie bereits im Quellcode beschrieben ist. Dennoch zur Vollständigkeit darf das Bild dazu nicht fehlen.


Wenn das kompilieren klappt, dann sollte auf eurem Display „Hello World!“ leuchten.


Im Grunde ist der erste Schritt zur Verwendung des Display sehr leicht, dennoch können nicht gleich erkennbare Fehler auftreten. Zum Beispiel traten mit sehr günstigen Arduino Nano Klone ein Fehler mit der der Beleuchtung des Displays auf. So funktionierte das Display nicht an 3,3V sondern an 5V.
Wenn ihr andere Fehler und vielleicht auch Lösungen habt, schreibt mir einen Kommentar zu diesem Thema.

Sonntag, 17. Januar 2016

Arduino Control (Teil 5) - PWM Signal einlesen


Das Einlesen und Ausgeben des PWM Signals ist mit dem Beispiel für "Analoges Signal einlesen" vergleichbar. Daher gehe ich nochmal auf das Signal selbst ein.

Im Modellbau werden oft Analog Servos verwendet und nutzen zur Ansteuerung das PWM Signal. Die eingesetzte Frequenz liegt bei 50Hz. Bei Digital Servos wird ebenfalls ein PWM Signal verwendet, allerdings können diese mit einer deutlichen höheren Frequenz umgehen. Das bedeutet natürlich am Ende, dass in jeder Sekunde die Position des Servoarms mehrmals eingestellt wird. Also je höher die Frequenz, desto öfter pro Sekunde wird die Position festgelegt. Der Vorteil liegt auf der Hand: mit dem Digital Servo kann man wesentlich genauer arbeiten, hat aber entsprechend mehr Verbrauch. Hier muss man abwägen, ob sich für den geplanten Einsatz ein Digital Servo lohnt.

Zunächst zu dem PWM selbst sollte klar sein, wie  eigentlich das Signal aussieht. Im folgenden Bild ist zu sehen, dass eine Periodendauer aus einem HIGH und einem LOW Pegel besteht.
Mit der Pulslänge von 1ms bis 2ms wird das Steuersignal für den Ziel Steuereinheit bestimmt. Zum Beispiel bei einem Servo wäre dann bei 1ms Pulslänge der Winkel bei 0 Grad, bei 1,5ms bei 60 Grad und bei 2ms wäre die Ausrichtung  dann 120 Grad.
Im Modellbau ist der HIGH Level für gewöhnlich zwischen 4,8V und 6V. Wer einen Mikrocontroller mit einer Betriebsspannung von 3,3V verwendet, benötigt einen Pegelwandler. Hier reicht ein Wandler von 3,3V auf 5V aus. Natürlich können einige Servos wiederum mit der niedrigen Signalspannung umgehen. Dazu gehören z.B. Micro Servos.
Das HIGH Signal beinhaltet den Steuerwert und kann generell im RC Modellbau eine Pulslänge von 1 bis 2 Millisekunden betragen. Der LOW Zustand stellt die restliche Zeit der gesamten Periode. Zeitlich gesehen wird nichts mehr weiteres unternommen bis die nächste Periode beginnt. Bei 50Hz liegt die Periodendauer bei 20 Millisekunden, was bedeutet, dass 18 bis 19 Millisekunden kein neuer Steuerwert zugewiesen wird. Bei Digital Servos kann der LOW-Level-Zeitraum verkürzt werden. Als Beispiel könnte dann eine Periodendauer von 5 Millisekunden geschaltet werden, so das der LOW Zustand nun zwischen drei bis vier Millisekunden andauert.
Kommen wir zum Arduino Code. Anstatt der Methode analogRead, wird pulseIn(pinNumber, HIGH) verwendet. Der Ausgabewert kommt als ganze Zahl und stellt die Microsekunden dar. Wenn ein Signal von einem einfachen Empfänger gelesen wird, dann sollte ein Wert zwischen 900 bis 2000 als Ergebnis kommen.

// Digitaler Pin Nummer 3
int pin = 3;

void setup() {
 
  Serial.begin(9600);
 
  // Pin Eingang festlegen
  pinMode(pin, INPUT);
}

void loop() {
 
  // Pin Eingang einelsen
  int result = pulseIn(pin, HIGH);
 
  // Nur Inhalt im If ausführen,
  // wenn der Status sich geändert hat.
  if(result != lastValue)
  {
   // Member Field überschreiben.
    lastValue = result;
  
   // Buffer vorbereiten und
   // den Wert in zwei bytes aufteilen.
    byte ba[2];
    ba[0] = (byte)((result >> 8) & 0xff);
    ba[1] = (byte)(result & 0xff);
   
    // Buffer Inhalt von zwei Bytes senden.
    Serial.write(ba, 2);
       
    // Ermöglicht das Erkennen vom 1. und 2. Byte
    // in dem zwischen den Sendungen eine Pause gesetzt wird.
    delay(100);
  }  

  delay(20);
}

Für das Programm auf dem Desktop kann der selbe Code Schnipsel verwendet werden, wie aus meinem Blog Post "Arduino Control (Teil 4) - Potentiometer Wert am PC ausgeben". Zur Vollständigkeit steht dieser im folgenden Abschnitt.

static void Main(string[] args)
{
    
// Die Verwendete COM Verbindung
    // sollte der aus dem Arduino Programm entsprechen.
    
    SerialPort sp = new SerialPort("COM16", 115200);
    // Event zuweisen für den Empfang.    
    sp.DataReceived += sp_DataReceived;
    // Verbindung öffnen.
   
// Wenn das Programm gestartet ist, 
    // sollte der Arduino bereits mit dem PC verbunden sein.
    
    sp.Open();
    while (true)
    {
       
// Nur warten.        
       Thread.Sleep(1000);
    }
}

// Wird ausgeführt, wenn Daten im Empfangspuffer vorhanden sind.
static void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
    
// SerialPort aus 'sender' casten.    
    SerialPort sp = (SerialPort)sender;
    // Bytes einlesen vom Empfang und auf die Console wiedergeben.    
    byte[] buffer = new byte[2];
    
if (sp.Read(buffer, 0, 2) != 0)
    {
        
Console.Clear();
        
// Die zwei empfangenen Byte müssen wieder zusammengelegt werden, 
        // um den Eigentlichen Wert wiederzugeben.
        
        Console.WriteLine("Received: {0} micro secounds", (int)buffer[0] << 8 | buffer[1]);
    }
}

Sinnvollerweise kann dieses Beispiel mit einer Fernsteuerung und einem Empfänger verwendet werden.

Quellcode zum Download
·         Für den Arduino reicht der Code aus dem Post aus.


Donnerstag, 24. Dezember 2015

Neu Verkabeln


Eine Schaltung zu entwerfen ist schon eine tolle Sache und wenn das Ganze auch noch gut verlötet ist, dann macht das schon einen professionellen Eindruck. Obwohl ich für einen Freizeitelektroniker relativ viel Übung habe, erreiche ich nicht immer ein überzeugendes Ergebnis. Das liegt oft an den Kabeln selbst, die meistens sehr bunt sind. Klar dienen die Farben zur Orientierung und sagen etwas über ihre Zuständigkeit aus, aber wenn sie bereits verlegt sind, benötige ich diese Funktion nicht mehr.


Im Normalfall werden die zu langen Kabel zusammengerollt und mit Kabelbinder zusammengehalten. Das reicht grundsätzlich aus, besonders dann, wenn noch nicht klar ist, wie alles verlegt wird.


Meine letzte unzufriedene Verkabelung war an meinem Quadrocopter. Viele Kabel waren zu lang und aufgewickelt. Auch hier zeigen sich die Leitungen in verschiedenen Farben. Das ergab ein sehr unordentliches Bild. Deshalb entschied ich, alles auf eine brauchbare Länge zu kürzen. Leider fehlte mir dazu eine Kleinigkeit.
Zunächst suchte ich nach Kabeln, die wie eine Schnur aussehen, bis ich vor einigen Monaten die Gewebeschläuche gefunden habe. Auf Ebay finden sich die Artikel unter den Begriffen wie Gewebeschlauch oder Geflechtschlauch.

Für die Verarbeitung des Gewebeschlauches gibt’s eine Sache zu tun. Damit der Gewebeschlauch sich nicht ausfranst, sollten mit einem Feuerzeug die Enden angesengt werden, bis sich die einzelnen Fäden miteinander verschmelzen.


Um das Ganze noch abzurunden, kann ich empfehlen, ein kleines Stück Schrumpfschlauch über die angesengten Enden zu ziehen.


Mit meinem Beispiel in der Zeitrafferaufnahme zeigen sich die einzelnen Schritte, wie die Verkabelung und die Verwendung des Schrumpfschlauches eingesetzt werden kann.


Dienstag, 12. Mai 2015

Beleuchtung mit dem ATtiny 45 (Ausbessern)

Quadrocopter_10

In meinem vorigen Post habe ich bereits geschrieben, dass die vorhandenen LEDs für meine Beleuchtung nicht alle vollständig durchgesteuert werden können. Der Grund liegt an dem verwendeten Spannungsregler, der für den Betrieb ca. 100mA zur Verfügung stellt und kurzzeitig auch bis zu 150mA. Die Lichtausbeute war somit nur eingeschränkt möglich.

Quadrocopter_12

Neu ist eine hintere LED Leiste mit fünf blauen und vier weißen LEDs. Dieser benötigt alleine bereits bis zu 200mA und da würde schon der einfache Spannungsregler nicht lange funktionieren. Nun mit dem etwas größer dimensionierten Spannungsregler sind solche Schwierigkeiten obsolet und am Programm muss nichts extra verändert werden, um Einsparungen für den Stromverbrauch vorzunehmen. Zudem können alle 16 LED RGBs (WS2812b) vollständig durchgeschaltet werden, ohne das die Spannung einbricht.

Quadrocopter_08

Kommen wir zu den Änderungen. Wie bereits erwähnt verwende ich einen anderen Spannungsregler von STMicroelectronics. Die Bezeichnung lautet L7805CV und fällt schon durch ein größeres Gehäuse auf, das der TO-220 Norm entspricht. Mit dem neuen kommen auch ungepolte Kondensatoren mit einer deutlichen kleineren Kapazität.

image

Die Schaltung ist dem Vorgänger sehr ähnlich und zeigt im Unterschied die neuen Anschlüsse für die hintere LED Leiste. Ebenfalls habe ich das Zusammenlöten der Komponenten so eingeplant, dass alles auf einer Platine Platz findet.

ATtiny45QuadrocopterLicht

Zusammengelötet und fast fertig auf der Platine.

Quadrocopter_09

Am Quellcode kann nun das Ansteuern des Pin 1 ergänzt werden. Damit wird später die hintere Lichtleiste ein- und ausgeschaltet.

// NeoPixel Bibliothek hinzufügen für die Ansteuerung der WS2812B LED Streifen
#include <Adafruit_NeoPixel.h>

// Instanz initialisieren
// Parameter Angaben:
// 1. Anzahl für verwendeter RGB LEDs
// 2. Auf welchen Pin soll verwendet werden.
// 3. Auswahl zwischen RGB, GRB oder BRG und verwendeter Takt 400KHz oder 800KHz

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(4, 2, NEO_GRB + NEO_KHZ800);

// Helligkeit einstellen. Kann von 0 bis Maximal 255 festgelegt werden.
// Bei Maximaler Ausleuchtung ist zu prüfen, ob die Maximale Stromabnahme erreicht wird.

int brightness = 100;

// Helligkeit bei verwendung der WS2812b, wenn sie weis auf blitzen sollen.
// Bei 210 wird die Maximale Stromabnahme überschritten.
// Darf nur kurz verwendet werden, ansonsten brennt der Spannungsregler durch.

int brightnessWhite = 210;

// Wird zum festlegen des Licht Einstellung verwendet.
// Damit die Einstellung funktioniert,
// muss an der Fernsteuerung einmal hin und her Geschaltet oder gedreht werden,
// um die längste Pulslänge zu ermitteln.

unsigned long maxPwmIn = 2;

void setup() {
  // Signal von der Fernsteuerung aufnehmen.
  pinMode(3, INPUT);
  // Positionslichter schalten
  pinMode(0, OUTPUT);
  // Neu. Um die LED Leiste ein- und auszuschalten.
 
pinMode(1, OUTPUT);
  // RGB LEDs Stribes starten
  pixels.begin();
  pixels.show();
}

void loop() {
  // Signal von der Fernsteuerung einlesen.
  // Für die Verwendung sollte ein Schalter genutzt werden.

  unsigned long pwmIn =  pulseIn(3, HIGH);
  // Wird zum Anlernen verwendet. Durch festlegen der maximalen Pulslänge
  // können zwei Zustände verwendet werden.

  if(pwmIn > maxPwmIn) { maxPwmIn = pwmIn; }
 
  // Wenn das Signal kürzer ist als der Maximalen Pulslänge.
  if(pwmIn < maxPwmIn - 100){
    // Positionslichter einschalten
    // (Bei verwendung von NPN Transisitor, kann die '255 -' weg)

    analogWrite(0, 255 - brightness); delay(100);
    // Ausschalten (Bei NPN, den Wert auf 0 setzen.)
    analogWrite(0, 255); delay(100);
    // Die LED Leiste einschalten
   
analogWrite(1, 255);
    // RGB LED Streifen ansteuern.
    // Rot und Grün

    allRGB_LED_Off();
    pixels.setPixelColor(0, pixels.Color(brightness, 0, 0));
    pixels.setPixelColor(1, pixels.Color(0, brightness, 0));
    pixels.show();
    delay(100);
    allRGB_LED_Off();
    pixels.setPixelColor(2, pixels.Color(brightness, 0, 0));
    pixels.setPixelColor(3, pixels.Color(0, brightness, 0));
    pixels.show();
   delay(100);
  }
  else
  {
    // Positionslichter ausschalten
    // (Bei verwendung von NPN Transisitor, ist zum Ausschalten der Wert 0)

    analogWrite(0, 255);
    // Die LED Leiste ausschalten.
   
analogWrite(1, 255);
   // RGB LED Streifen ansteuern.
    for(int i = 0; i < 4; i++)
    {
      // Alle aus.
      allRGB_LED_Off();
     // Mit der Aktuellen Iteration als Index verwenden,
      // um den entsprechende RGB LED zu überschreiben.

      pixels.setPixelColor(i, pixels.Color(brightnessWhite, brightnessWhite, brightnessWhite));
      pixels.show();
      delay(100);
    }
  }
}
// Stellt alle Werte zurück.
void allRGB_LED_Off()
{
  for(int i = 0; i < 4; i++)
  {
    pixels.setPixelColor(i, pixels.Color(0, 0, 0));
  }
}

Zuletzt dürfen zur Demo die Videos nicht fehlen.

Sonntag, 19. April 2015

Beleuchtung mit dem ATtiny 45

image

Zuerst habe ich darüber nachgedacht, was ich alles an Beleuchtung am Quadrocopter anschließen möchte und kam zu dem Entschluss Positionslichter anzubringen. Das macht dann besonders Sinn, wenn der Quadrocopter bereits 40 Meter entfernt ist. Für diesen Zweck eignen sich ultrahelle LEDs ab einer Lichtstärke von über 5000mcd. Für das Bunte sah ich die WS2812B auf Streifen für die Unterbodenbeleuchtung. Diese RGB LEDs sind nicht nur leuchtstark, sondern können über eine Leitung angesteuert werden.

image

Normalweise würde ich einen ATMega328 oder 168 verwenden, doch die bessere Wahl ist ein ATtiny. Der ATTiny45/85 z.B. hat insgesamt acht Pins. Zwei für die Stromversorgung, einen für Reset und der Rest kann frei programmiert werden.

image

Für das Vorhaben werden folgende Teile benötigt:

  • 1x ATTiny45
  • 2x Ultrahelle LEDs Grün (3mm, 6000mcd)
  • 2x Ultrahelle LEDs Rot (3mm, 5000mcd)
  • RGB LEDs WS2812B
  • 2x PNP Transistoren (es gehen auch 2x NPN, muss nur im Code umgedreht werden)
  • 2x 22µF Kondensatoren (63V, darf auch niedriger sein)
  • 1x 5V Spannungsregler (UTC LP2950G 5.0 QC4, 160mA)
  • 2x 75 Ohm Widerstand (100Ohm kamen in meiner Schaltung)
  • 2x 2,2kOhm Wiederstände
  • 1x Rasterplatine
  • ausreichend Schrumpfschläuche
  • und natürlich dürfen die Kabel nicht fehlen

[Bild von den Teilen]

Bevor das Ganze zusammengelötet wird, empfiehlt sich ein Test der Schaltung auf dem Breadboard. In meinem Fall war dies auch notwendig, da die Anzahl der angeschlossen LEDs mehr Strom benötigt hat. Der vorgegebene Spannungsregler kann bis zu 160mA durchlassen und reicht für die grünen und roten LEDs auch aus. Kommen nun die RGB LEDs hinzu, dann wird es knapp. Selbst wenn jetzt die vier LEDs ca. 120mA verbrauchen, bleiben nur 40mA übrig. Das reicht gerade mal für zwei weitere LEDs, in einer RGB LED sind aber drei. Abgesehen davon, dass der ATtiny für die Ansteuerung der WS2812B verwendet wird, kann dieser auch die Ansteuerung der Helligkeit regulieren und somit den Stromverbrauch reduzieren. Hierbei werden die einzelnen LEDs mit einem PWM Signal angesteuert. Kommen wir zur Grundschaltung.

image
Schaltbild vom Versuchs- und Testaufbau.

Kommen wir nun zu dem ATtiny. Um diesen zu beschreiben verwende ich einfach einen Arduino und einen eigenen, selbst gelöteten Shield. Alternativ kann dies auch auf einem Breadboard zusammengesteckt werden.

image

Ich empfehle, die Arduino Entwicklungsumgebung zu verwenden; dies erspart weitere Kosten für ein neues Board. Das setzt natürlich voraus, dass man bereits einen Arduino besitzt.

Nachteil ist, dass für die Verwendung eine weitere Komponente installiert werden muss.

Die Seite high-low tech erklärt, wie der Arduino als ISP Programmer für den ATtiny verwendet werden kann. Daher fasse ich kurz zusammen, was für die Installation wichtig ist.

Nun fehlt noch eine Sache. Für die Verwendung der WS2812B RGB LEDs wäre eine wenig mehr Code notwendig. Ich greife deshalb auf eine fertige Library zurück. Diese wird von Adafruit bereit gestellt auf GitHub.com/adafruit/Adafruit_NeoPixel. Die fertige Bibliothek kommt diesmal in den Ordner ../Arduino/libraries/Adafruit_Neopixel.

Jetzt kann der eigentliche Spaß losgehen. Der folgende Beispiel Code ist extra kurz gehalten und geht mehr auf die verwendete Inhalte ein.

// NeoPixel Bibliothek hinzufügen für die Ansteuerung der WS2812B LED Streifen
#include <Adafruit_NeoPixel.h>

// Instanz initialisieren
// Parameter Angaben:
// 1. Anzahl für verwendeter RGB LEDs
// 2. Auf welchen Pin soll verwendet werden.
// 3. Auswahl zwischen RGB, GRB oder BRG und verwendeter Takt 400KHz oder 800KHz

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(4, 2, NEO_GRB + NEO_KHZ800);

// Helligkeit einstellen. Kann von 0 bis Maximal 255 festgelegt werden.
// Bei Maximaler Ausleuchtung ist zu prüfen, ob die Maximale Stromabnahme erreicht wird.

int brightness = 100;

// Helligkeit bei verwendung der WS2812b, wenn sie weis auf blitzen sollen.
// Bei 210 wird die Maximale Stromabnahme überschritten.
// Darf nur kurz verwendet werden, ansonsten brennt der Spannungsregler durch.

int brightnessWhite = 210;

// Wird zum festlegen des Licht Einstellung verwendet.
// Damit die Einstellung funktioniert,
// muss an der Fernsteuerung einmal hin und her Geschaltet oder gedreht werden,
// um die längste Pulslänge zu ermitteln.

unsigned long maxPwmIn = 2;

void setup() {
  // Signal von der Fernsteuerung aufnehmen.
  pinMode(3, INPUT);
  // Positionslichter schalten
  pinMode(0, OUTPUT);
 
  // RGB LEDs Stribes starten
  pixels.begin();
  pixels.show();
}

void loop() {
 
  // Signal von der Fernsteuerung einlesen.
  // Für die Verwendung sollte ein Schalter genutzt werden.

  unsigned long pwmIn =  pulseIn(3, HIGH);
  // Wird zum Anlernen verwendet. Durch festlegen der maximalen Pulslänge
  // können zwei Zustände verwendet werden.

  if(pwmIn > maxPwmIn) { maxPwmIn = pwmIn; }
 
  // Wenn das Signal kürzer ist als der Maximalen Pulslänge.
  if(pwmIn < maxPwmIn - 100){
    // Positionslichter einschalten
    // (Bei verwendung von NPN Transisitor, kann die '255 -' weg)

    analogWrite(0, 255 - brightness); delay(100);
   // Ausschalten (Bei NPN, den Wert auf 0 setzen.)
   analogWrite(0, 255); delay(100);
   
    // RGB LED Streifen ansteuern.
    // Rot und Grün

    allRGB_LED_Off();
    pixels.setPixelColor(0, pixels.Color(brightness, 0, 0));
    pixels.setPixelColor(1, pixels.Color(0, brightness, 0));
    pixels.show();
    delay(100);
    allRGB_LED_Off();
    pixels.setPixelColor(2, pixels.Color(brightness, 0, 0));
    pixels.setPixelColor(3, pixels.Color(0, brightness, 0));
    pixels.show();
   delay(100);
  }
  else
  {
    // Positionslichter ausschalten
    // (Bei verwendung von NPN Transisitor, ist zum Ausschalten der Wert 0)

    analogWrite(0, 255);
   
   // RGB LED Streifen ansteuern.
    for(int i = 0; i < 4; i++)
    {
      // Alle aus.
      allRGB_LED_Off();
     
     // Mit der Aktuellen Iteration als Index verwenden,
      // um den entsprechende RGB LED zu überschreiben.

      pixels.setPixelColor(i, pixels.Color(brightnessWhite, brightnessWhite, brightnessWhite));
      pixels.show();
      delay(100);
    }
  }
}

// Stellt alle Werte zurück.
void allRGB_LED_Off()
{
  for(int i = 0; i < 4; i++)
  {
    pixels.setPixelColor(i, pixels.Color(0, 0, 0));
  }
}

Im folgendem Video wird gezeigt, wie dieses Code Beispiel aussieht. Daneben ist noch ein Netduino der ein PWM Signal abgibt und alle drei Sekunden wechselt zwischen 900 und 1100 Mikrosekunden Pulslänge, um das Umschalten zu simulieren.

Bei dem ATtiny45 wird man schnell feststellen, dass der Speicher sehr knapp ist. Wer mehr Lichtanimationen einsetzen möchte, sollte auf einen ATtiny85 wechseln. Und wer mehr Licht einsetzen und nicht unbedingt an Strom sparen will, wird einen größeren Spannungsregler benötigen.

 Referenzen

Sonntag, 22. März 2015

Stereoskopie mit Windows Phone und MonoGame

StereoscopicTest03

Inzwischen findet sich immer mehr Zubehör für das Smartphone, um etwas Ähnliches zu schaffen wie die Oculus Rift. Zum Thema habe ich vor ein einigen Tagen im AppStore fürs Windows Phone nach solchen Apps mit Stereoskopie Ausgabe erfolglos gesucht. Die Verbreitung ist offenbar Android und iOS vorbehalten. Kommen wir aber zu der Frage: wie schwer ist die Umsetzung einer Stereoskopie Wiedergabe?

Das Prinzip ist simpel. Der gezeigte Inhalt wird für das linke und das rechte Auge gerendert. Um den 3d Effekt zu erzielen, müssen, wie in der realen Welt, zwei Kameras eingesetzt werden, die zueinander leicht versetzt sind. Doch wie sieht das im Programmcode aus?

Tatsächlich wird das für dieses Beispiel mit wenigen Ergänzungen im Programmcode erreicht. Und am Ende werden Sie sich fragen, wieso das noch keiner für Windows Phone gemacht hat.

Bevor Sie starten, sollten Sie neben Visual Studio 2013 noch MonoGame installiert haben und dann können Sie mit einem neuen Projekt für Windows Phone 8.1 starten.

image

Mit dem neuen Projekt wird in der Vorlage bereits eine fertige Szene mit einem 3d Würfel vorgegeben. Daher gehe ich im Beispiel nur auf das Wesentliche ein, nämlich, welche Ergänzungen notwendig sind.

Öffnen Sie die Game1.cs und legen sie oben zusätzliche Member Variable an.

// Ausgabebereich
Viewport viewportDefault;
Viewport viewportLeft;
Viewport viewportRight;

// Renderbereich
Matrix matrixProjection;
Matrix matrixProjectionHalf;

// Kamera Position und Ausrichtung
Matrix matrixViewLeft;
Matrix matrixViewRight;

In der Methode ‘Initialize()’ wird die Kameraposition und Ausrichtung festgelegt. Zusätzlich wird der ViewPort zusammengestaucht und der Platz für zwei Bilder hergerichtet. Mit den zwei Variablen für die Projektion wird noch der Renderbereich festgelegt.

this.matrixViewLeft = Matrix.CreateLookAt(new Vector3(.3f, 1f, -4f), new Vector3(0, 0, 0), Vector3.Up);
this.matrixViewRight = Matrix.CreateLookAt(new Vector3(-0.3f, 1f, -4f), new Vector3(0, 0, 0), Vector3.Up);

this.viewportDefault = this.GraphicsDevice.Viewport;
this.viewportLeft = viewportDefault;
this.viewportRight = viewportDefault;
this.viewportLeft.Width = viewportLeft.Width / 2;
this.viewportRight.Width = viewportRight.Width / 2;
this.viewportRight.X = viewportLeft.Width;

this.matrixProjection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 4.0f / 3.0f, 1, 10000);
this.matrixProjectionHalf = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 2.0f / 3.0f, 1, 10000);

Zuletzt wird eine Änderung an der ‘Draw()’ Methode vorgenommen. Der zu rendernde Inhalt wird nun als eigene Methode mit dem Namen ‘DrawScene’ ausgelagert.

image

Damit dürfte Anschließend Ihre Methode so aussehen.

private void DrawScene(ref Matrix View, ref Matrix Projection, ref Matrix World)
{
    vertexBuffer.SetData(cube, 0, 8, SetDataOptions.Discard);
    indexBuffer.SetData(cubeIndices, 0, 36, SetDataOptions.Discard);

    GraphicsDevice device = basicEffect.GraphicsDevice;
    device.SetVertexBuffer(vertexBuffer);
    device.Indices = indexBuffer;

    basicEffect.View = View;
    basicEffect.Projection = Projection;
    basicEffect.World = World;
    foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
    {
        pass.Apply();
        device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 8, 0, 36);
    }
}

Die Matrix Variable für ‘View’ und ‘Projection’ werden ersetzt. Im folgenden Code werden Sie erkennen, wie nun das Splitting erreicht wird.

// Linke Seite
this.GraphicsDevice.Viewport = this.viewportLeft;
this.DrawScene(ref this.matrixViewLeft, ref this.matrixProjectionHalf, ref World);

// Rechte Seite
this.GraphicsDevice.Viewport = this.viewportRight;
this.DrawScene(ref this.matrixViewRight, ref this.matrixProjectionHalf, ref World);

Und schon ist das Beispiel fertig. Nach Drücken auf die F5 Taste und hochladen auf das Smartphone dürfte nun, wie im Bild zu sehen, dieses Ergebnis erscheinen:

Stereoscopic_01

Fehlt noch der Aufsatz, um die Stereoskopie zu erleben. Für wenig Geld bekommen Sie bei Online Händlern z.B. ein aus Pappe hergestelltes Gestell mit den entsprechenden Linsen. Achten Sie in diesem Fall darauf, welche Größe Ihr Smartphone hat.

DIY Google Karton_01 DIY Google Karton_02
DIY Google Karton_03

Was eigentlich noch fehlt, um die Sache im wahrsten Sinne des Wortes abzurunden, ist die fehlende Krümmung. Der 3D-Effekt wirkt ein wenig nach innen gezogen. Wer bereits die Oculus Rift oder Bilder davon gesehen hat, wird feststellen, dass die Renderbilder einen leichten Fischaugeneffekt haben. Was den Komfort angeht, naja, zum Experimentieren reicht die Lösung aus.

Quellen:

Suchbegriffe:

  • Virtual Reality
  • VR Handy 3d
  • Google Cardboard

Beispiel Solution: ExampleMonoGameStereoscopic (VS2013, MonoGame)

Donnerstag, 12. Februar 2015

Wetterstation mit dem Netduino

Diesmal steht mein eigentlicher Inhalt nicht hier als Blog Post, weil der Umfang einen ganzen Artikel umfasst und wurde Inzwischen in der Windows Developer Ausgabe 2.2015 veröffentlicht mit dem Hauptthema “Internet of Things”.

Mein Artikel beschreibt wie mit C# und .NET Micro Framework, zwei Sensor Module mit verschiedenen Einstellungen abgefragt werden.

zu Windows Developer und dem Artikel "Blauer Himmel mit C#"