Beleuchtung mit dem ATtiny 45

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.

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.

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.

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.

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.

• Aktuell funktioniert die Arduino Software 1.6.3 mit der ATTiny Erweiterung
• Die ATtiny Erweiterung kann von GitHub.com/damellis/attiny herunter geladen werden. Anschließend entpackt ihr die ZIP File, kopiert den Ordner attiny in Hardware (z.B. ../Arduino/hardware/attiny).
• Wenn die Software gestartet ist, stehen unter Werkzeug weitere Optionen zur Verfügung.
• Der aktuelle Arduino wird nun mit dem Arduino ISP Programm beschrieben.
• Anschließend kann unter Werkzeug > Programmer > Arduino as ISP umgestellt werden.
• Für dieses Beispiel verwende ich einen ATTiny45 mit internen 8MHz.
  • Werkzeug > Platine > ATtiny
  • Werkzeug > Prozessor > ATtiny45
  • Werkzeug > Clock > 8MHz (internal)
  • Werkzeug > Port > {sollte dem aktuell angeschlossen Arduino eingestellt sein}

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

• high-low tech (Programming an ATtiny Arduino)
• high-low tech (Arduino board as ATtiny programmer)
• Arduino Software
• ATtiny für Arduino
• Adafruit NeoPixel

Feuchtigkeitssensor HTU21D mit dem Netduino (Teil 1)

Zuvor habe ich für meinem Weather Shield einen Feuchtigkeitssensor DHT11 verwendet. Wer diesen kennt, weiss sicherlich wie ungenau die Messwerte sind. Ich möchte den Sensor nicht schlecht reden, denn immerhin ist er sehr günstig. Möchte man allerdings für eine Anwendung mehr Genauigkeit und eine schnelle Abtastung der aktuellen Feuchtigkeit und Temperatur, bieten andere Sensoren deutlich bessere Ergebnisse.

Ein paar interessante Daten zum Sensor:

• Schnittstelle I²C
• Betriebsspannung: 3,3V (max. 3,6V)
• Stromaufnahme: ca. 10mA
• Temperaturmessung ca. 50ms bei 14Bit (7ms bei 11Bit) (-40°C bis 125°C)
• Feuchtigkeitmessung ca. 16ms bei 12bit (3ms bei 8Bit)
• Kostet ab 6,50€ bei Ebay über einem chinesischen Händler

Weitere Daten findet ihr im Datenblatt.

Ansprechen lässt sich der Sensor über den I²C Bus und kann mit dem .NET Micro Framework mit geringen Aufwand programmiert werden. Das Einstiegsverhalten lässt sich mit dem Luftdruck Sensors BMP085 vergleichen, über den ich bereits geschrieben habe.

Erstellen wir eine neue Klasse mit dem Namen des Sensors, um zunächst die Verbindung herzustellen und die Rohdaten zu erhalten.

public class HTU21D : I2CDevice {     // Konstruktor mit vererbten Konstruktor aus der I2CDevice Klasse     // 0x40 = Adresse des Sensors     //  100 = Takt in kHz     public HTU21D()         : base(new Configuration(0x40, 100))     {     }     // Luftfeuchtigkeit Messen und Rohwert zurückgeben     public int Read()     {         // Befehl senden.         if (this.Write(new byte[] { 0xf5 }) == 0)         {             throw new SystemException("Fehler beim Senden!");         }         // Warten bis der Sensor mit dem Lesevorgang fertig ist.         Thread.Sleep(50);         byte[] data = new byte[3];        // Messergebnis abrufen         if (this.Read(data) == data.Length)         {            // Es werden für dieses Beispiel zwei Bytes verwendet             int raw = (data[0] << 8) | data[1];             raw &= 0xFFFC;             return raw;         }         Debug.Print("Sensor konnte nicht gelesen werden!");         return 0;     }     // Sendet den Inhalt des Byte Arrays     private int Write(byte[] buffer)     {         I2CTransaction[] trans = new I2CTransaction[]         {             CreateWriteTransaction(buffer)         };         return Execute(trans, 1000);     }     // Liest den zu empfangene Byte Array     private int Read(byte[] buffer)     {        I2CTransaction[] trans = new I2CTransaction[]         {             CreateReadTransaction(buffer)         };         return Execute(trans, 1000);     } }

Die Rohdaten können nun über die Program.cs Klasse aufgerufen und über die Ausgabe in Visual Studio ausgegeben werden.

public class Program {     public static void Main()     {         HTU21D sensor = new HTU21D();         while (true)         {             Debug.Print("Humidity RAW Value: " + sensor.Read().ToString());             Thread.Sleep(1000);         }     } }

Im nächsten Schritt wird das Modul mit dem Feuchtigkeitsensor mit dem Netduino verbunden. Je nach Ausführung des Sensor, werden eventuell zwei Widerstände mit 2,2kOhm benötigt. In der Variante die ich erhalten habe, sind diese aufgelötet, aber mit der 3,3V Zuleitung nicht verbunden. Das Modul habe ich zunächst so belassen und habe für den Testlauf zwei Pull Up Widerstände hinzu gesteckt.

Ansonsten hält sich die Schaltung mit den Netduino und dem Feuchtigkeitssensor sehr Übersichtlich.

Wie bereits aus den Technischen Grunddaten hervorgeht, gibt es auch einen Temperatursensor zum Messen. Dafür muss nur in der Methode “Read()”, das zu sendende Byte von 0xf5 auf 0xf3 umgeschrieben werden. Damit erhält man den Rohwert der gemessenen Temperatur.

• Beispiel Programm zum herunterladen
• Datenblatt HTU21D

Luftdrucksensor BMP085 mit dem Netduino - Luftdruck (Teil 1)

Für das Erfassen von Wetterdaten eignet sich der Sensor BMP085. In erster Linie misst dieser den Luftdruck, kann jedoch auch die Temperatur messen. Dennoch bleiben wir zunächst bei einem kurzen Testprogramm für den Netduino.

public class BMP085 : I2CDevice {    // Bestimmt wie lange gewartet wird in Millisekunden     private int _Timeout = 1000;    // Standard Mode     private int _Mode = 1;     // Empfangspuffer     private byte[] _Receive = new byte[3];     // Konstruktor mit vererbten Konstruktor von der I2CDevice Klasse     public BMP085() : base(new Configuration(0x77, 40))     {     }     // Sensor lesen     public int ReadSensorData()     {         // Status Abfrage senden         if (Write(new byte[] { 0xF4, (byte)(0x34 + (_Mode << 6)) }) == 0)         {             Debug.Print("Status abfrage konnte nicht ausgeführt werden.");             return 0;         }         // Kurz abwarten         Thread.Sleep(8);         // Sensor Ergebnis abfragen         if (Write(new byte[] { 0xF6 }) == 0)         {             Debug.Print("Ergebnis konnte nicht abgefragt werden.");             return 0;         }         // Ergebnis einlesen         if (Read(_Receive) == 0)         {             Debug.Print("Es konnte das Ergebnis vom Sensor nicht gelesen werden.");             return 0;         }         // Ergebnis per Byteshifting        return ((_Receive[0] << 16) | (_Receive[1] << 8) | (_Receive[2])) >> (8 - _Mode);     }     // Sendet den Inhalt des Byte Arrays    private int Write(byte[] buffer)     {         I2CTransaction[] trans = new I2CTransaction[]         {             CreateWriteTransaction(buffer)         };         return Execute(trans, _Timeout);     }     // Liest den zu empfangene Byte Array     private int Read(byte[] buffer)     {         I2CTransaction[] trans = new I2CTransaction[]         {             CreateReadTransaction(buffer)         };         return Execute(trans, _Timeout);     } }

Der Programmcode ermöglicht den Messwert im Sensor auszulesen. Nun muss im Program.cs die Klasse initialisiert werden und in der Schleife der Sensor immer wieder gelesen werden.

public class Program {     private static BMP085 _Airpressur;     public static void Main()     {         _Airpressur = new BMP085();        while (true)         {             Debug.Print("Pressure Value: " + _Airpressur.ReadSensorData().ToString());             // halbe Sekunde warten             Thread.Sleep(500);         }     } }

Wie nun die Kalibrierung funktioniert, erkläre ich in einem späteren Post. Nun zu der Verkabelung. Leider war der Sensor in der Fritzing Software in einer anderen Version. Diesmal sollten diese Fotos ausreichen, um zu zeigen, wie dieser Sensor verkabelt wird.

Verkabelung bei einem Netduino Plus 1

Mit dem Netduino 2 und dem Netduino Plus 2 sind die Anschlüsse für den I²C auf die andere Seite gewandert.

Verkabelung bei einem Netduino Plus 2

Wenn alles soweit klappt, dürfte nun im Visual Studio – Ausgabe Fenster der Messwert angezeigt werden.

Wie sich zeigt, bildet das kleine Programm eine einfache Möglichkeit den Sensor in Betrieb zu nehmen. Im nächsten Blog Post wird auf den Temperatur Sensor eingegangen, der hier ebenfalls auf dem Sensor Modul enthalten ist.

Beispiel Programm zum herunterladen.

Datenblatt BMP085

LED 8x8 Matrix (Rot/Grün) Schaltung

Die LED 8x8 Matrix an meiner Schaltung.

So einige wie ich haben seltsamerweise kein Dokument zu der LED Matrix im Internet gefunden. Letzten Endes habe ich dann selbst durch einiges Prüfen herausgefunden, welcher Pin nun für welche Funktion ist. Anschließend konnte ich dann einen Versuchsaufbau starten, der allerdings aufwendiger wurde. Auf den ersten Blick sieht meine Schaltung mit den vielen Kabeln ziemlich unüberschaubar aus. Dennoch habe ich den Aufbau mal wieder aus dem Kopf heraus zusammengesteckt, woran man sieht, dass diese Schaltung nicht sonderlich kompliziert sein kann.

Die Verwendeten ICs. Shiftregister, 2x Demultiplexer und 2x Inverter

Für die Schaltung habe ich Folgendes verwendet:

• LED 8x8 Matrix (Rot/Grün)
• Shiftregister (74hc595)
• 2x Demultiplexer (74HC154)
• 2x Inverter (74F04)
• 8x Widerstände (150 Ohm)
• 2x kurze Breadboards
• 1x langer Breadboard
• und viel Kabel zum Verbinden

Der Netduino wird hier als Steuereinheit verwendet, auf dem später meine Library “Game of Life” läuft.

Der Shiftregister ist entscheidend für die Darstellung an der LED-Matrix, da diese Einheit den Zustand der Demultiplexer schaltet, wenn alle 8 Bits gesetzt wurden. Im meinem ersten Versuch habe ich die zwei Demultiplexer direkt am Netduino angeschlossen. Hierbei wurden mehrere LEDs als gesetzt geschaltet. Der Fehler ließ sich jedoch nachvollziehen. In einer Methode habe ich die 8 Ausgänge geschaltet, die sehr zeitnah nacheinander ausgeführt werden. Leider war dieser Vorgang nicht schnell genug, so dass sich während dieser Zeit auch andere Schaltzustände ergaben. Zwar leuchten die nicht gesetzten LEDs nicht hell, aber dennoch stört dieser Zustand.

Schaltbild von der LED Matrix.

An der LED Matrix sind insgesamt 24 Pins und deswegen sind es zum Anschließen an einen einzelnen Netduino oder Arduino zu viel. Abhilfe schafft hier der Demultiplexer, der mit seinen 4 Eingängen bis zu 16 Zustände annehmen kann. Da einer nicht reicht, kommt ein zweiter hinzu, und wenn man diese in eine Matrix einbindet, dann können bis zu 256 Zustände erreicht werden. Den ersten Demultiplexer verwende ich für die 8 Reihen Rot und 8 Reihen Grün. Der zweite ist für die 8 Zeilen, die vorher durch einen Inverter geschaltet werden. Grund hierfür sind die Signale an den Demultiplexerausgängen, die negiert sind. Die Widerstände teilen die Spannung auf und trimmen die Stromaufnahme bei 20mA. Jedoch hier der Hinweis, dass ich die Spannung der LEDs auf 2.0V schätze. Also ergibt sich aus meiner Rechnung, dass am Widerstand 3V anliegen sollten. Mit der Grundformel R=U/I erhält man den benötigten Widerstandswert von 150Ohm. Im folgenden habe ich mir aus meinem Beispiel ein Schaltbild in Eagle erstellt. Was hier allerdings nicht so schön ist,ist dass die Last von den LEDs direkt an den ICs liegt. Also ist diese Schaltung aus diesem Grunde nur experimentell und nicht für den Dauerbetrieb geeignet. 

Gesamtes Schaltbild, ohne Netduino.

Nun ein bisschen Quellcode zum Ende, den ich jedoch von Netduino.com abgeschrieben und etwas abgeändert habe. Ich empfehle auf der Seite nachzuschauen, falls die Verbindungen mit Shiftregister und Netduino unklar sein sollten.

private static OutputPort _Data = new OutputPort(Pins.GPIO_PIN_D0, false); private static OutputPort _Clock = new OutputPort(Pins.GPIO_PIN_D1, false); private static OutputPort _Latch = new OutputPort(Pins.GPIO_PIN_D2, false); /// Code von der Seite Netduino /// Der Besipeil code und ein Schaltbild private static void UpdateLEDs(int value) {     _Latch.Write(false);     for (int i = 0; i < 8; i++)     {         int bit = value & 0x80;         value = value << 1;         if (bit == 128)         {             _Data.Write(true);         }         else         {             _Data.Write(false);         }         _Clock.Write(true);         //Thread.Sleep(1);         SleepWhile(5);         _Clock.Write(false);     }     _Latch.Write(true); } /// Dient als Ersatz zu Thread.Sleep private static void SleepWhile(int count) {     for (int i = 0; i < count; i++){ } }

Members und die Methode für das ansteuern des Shiftregister.

Wird nun an der Methode ein Wert zwischen 0 und 255 übergeben, wird die entsprechende Bit Einstellung am Shiftregister gesetzt. Dieser steuert die zwei Demultiplexer, die wiederum mit der LED Matrix verbunden sind und die entsprechende LED leuchtet.

Normalerweise würde man hier einen LED Matrix Treiber verwenden, um sich die umfangreiche Verkabelung zu sparen. Jedoch möchte ich zeigen, dass es auch andere Lösungen gibt und hoffe, dass dieses Bespiel dem einen oder anderen weiterhilft.

Mein Beispiel mit “Game of Life” und einem Gleiter.