Beleuchtung mit dem ATtiny 45 (Ausbessern)

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.

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.

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.

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.

Zusammengelötet und fast fertig auf der Platine.

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.

Tippe die Lampe an

Letztes Jahr habe ich zu dem Sensor BMA020 bereits ein Code Beispiel für den Arduino gepostet. Nun dachte ich, da der so rum liegt, kann man den vielleicht auch mal für etwas verwenden. Also kam mir die Idee eine Lampe einzuschalten, in dem man gegen sie tippt oder leicht schlägt.

Im späteren Verlauf stellte ich fest, dass einige Widerstände zu groß berechnet wurden. Die Abweichungen kommen durch die LED, die eigentlich für 12V ausgelegt sind und ich sie aber mit 9V betreibe. (Für den ATMega fehlt auf dem Bild der Quarz, PIN9 und PIN10)

Zunächst skizzierte ich mir meine Schaltung und berechnete anhand des Schaltbildes die Widerstände. Dann sammelte ich meine benötigten Komponenten zusammen und steckte sie auf meinem Breadboard, um zu sehen ob meine Überlegung richtig ist.

Versuchsaufbau der Schaltung

Natürlich funktioniert die Schaltung nicht ohne einen Programmcode und daher musste ich mir zunächst etwas überlegen. Zum Beispiel wie ich aus den drei Achsen einen Wert berechne und wie hoch die Abweichung sein muss, um eine Bewegung als Tippen wahrzunehmen. Die Formel für den Gravitationsvektor half nicht sonderlich weiter. Am Ende kam ich auf ein simples Zusammenrechnen, wie es im Programmcode zu sehen ist.

gravitySum = axisX / 3 + axisY / 3 + axisZ / 3;

Dies habe ich mir auf den Serial Monitor ausgeben lassen und tippte solange gegen meinen Arduino mit dem Sensor, bis ich einen passenden Wert ermittelt hatte.

Nach dem gegentippen bekam ich einen Wert von mehr als 9000 (echt )

Dann übernahm ich den Wert in die Bedingung für das Einschalten oder Ausschalten. Nun musste das Ganze noch auf eine Platine gelötet werden und das möglichst im kleinsten Raum und mit den LEDs, die ich dafür verwenden möchte. Als Hülle habe ich einen Teil von einer Plastikflasche verwendet.

Die LED Fläche zerlegt. Diese LED Lampe kommt aus einem IKEA Lampen Set.

Hier schneide ich den Flaschenhals auseinander. Mit einer Halterung brachte ich den Teil des Flaschenhalses in Rotation und bekam durch diese Methode einen sauberen Schnitt mit dem Cutter Messer.

Anschließend noch in einer stylischen Farbe lackieren…

Die fertige Schaltung einsetzen und die LED Flächen ankleben.

Am Ende noch den fertigen Programmcode auf den ATMega326 bringen.

#include <Wire.h> // I²C Adresse vom Beschleunigungssensor #define AccelerometerAddress 0x38 // Byte Array in dem die Ergebnisse gespeichert werden byte data[6]; // Ruft die XYZ Achsen Beschleunigung ab oder legt sie fest. int axisX; int axisY; int axisZ; // Beim Einschalten muss der Sensor Kalibriert werden. // Der Sensor sollte sich in dem Moment nicht bewegen. int axisX_offset; int axisY_offset; int axisZ_offset; // Wird nach dem Kalibrieren auf False gesetzt. boolean isFirstTime = true; // Die Beschleunigung wird zusammengerechnet, // durch 3 geteilt und dieser Variable gespeichert. double gravitySum; // Zeigt den maximalen berechneten Wert aus 'gravitySum' int maxValue = 0; // Ruft ab, ob die Lampen eingeschaltet // oder ausgeschaltet werden. boolean isHitting = false; // An welchem Pin soll die LED // ein oder ausgeschaltet werden. int ledPin = 12; void setup() {   // Die serielle Verbindung wird nur zum Ermitteln   // des 'gravitySum' benötigt.   Serial.begin(57600);   // LED Pin zuweisen   pinMode(ledPin, OUTPUT);   // I²C Verbindung starten   Wire.begin();   // LED Pin zunächst ausschalten.   digitalWrite(ledPin, LOW); } void loop() {   // Liest die Sensor Beschleunigungsdaten ein.   readAcceleration();     // per Byte Shifting den 10Bit Wert zusammenfügen   axisX = (data[0] >> 1) | data[1] << 8;   axisY = (data[2] >> 1) | data[3] << 8;   axisZ = (data[4] >> 1) | data[5] << 8;     // Wenn dies der erste Durchlauf ist   // dann wird das Offset gesetzt.   if(isFirstTime)   {     axisX_offset = axisX;     axisY_offset = axisY;     axisZ_offset = axisZ;     isFirstTime = false;   }   else   {     // Abweichung runterrechnen     axisX = axisX - axisX_offset;     axisY = axisY - axisY_offset;     axisZ = axisZ - axisZ_offset;   }     // Keine Gravitationsberechnung, nur einfaches   // Zusammenrechnen, um einen Wert später zu erhalten   // der nur bei Bewegung gemessen wurde.   if(axisX < 0){ axisX = axisX * -1; }   if(axisY < 0){ axisY = axisY * -1; }   if(axisZ < 0){ axisZ = axisZ * -1; }   gravitySum = axisX / 3 + axisY / 3 + axisZ / 3;     // Ergebnisse ausgeben   Serial.print("Axis X: ");   Serial.print(axisX, DEC);   Serial.print("\tAxis Y: ");   Serial.print(axisY, DEC);   Serial.print("\tAxis Z: ");   Serial.print(axisZ, DEC);     Serial.print("\tGravity: ");   Serial.print((int)gravitySum, DEC);     // Der 'maxValue' zeigt den höchsten   // berechneten Wert aus 'gravitySum'   if(gravitySum > maxValue)   {     maxValue = gravitySum;   }     // Maximalen Wert wiedergeben,   // der später als Schwellwert verwendet werden kann   Serial.print("\tMax Value: ");   Serial.println(maxValue, DEC);     // Wenn der maxValue ermittelt wurde   // kann der Wert zum Vergleich eingesetzt werden.   // So soll erst ein Schaltvorgang gesetzt werden,   // wenn der Schwellwert (hier 9000) erreicht wurde.   if(gravitySum > 9000)   {     // Zustand ändern     isHitting = !isHitting;        // Einschalten, wenn die Lampe aus ist     if(isHitting)     {       digitalWrite(ledPin, HIGH);       Serial.println("AN");     }     else     {       digitalWrite(ledPin, LOW);       Serial.println("AUS");     }         // Verzögerung zum Ausschwingen,     // damit nicht gleich die Lampe     // wieder ausgeschaltet wird.     delay(1500);   }     delay(100); } // Liest den Beschleunigungssensor ein und schreibt das Ergebnis in ein Byte Array. void readAcceleration() {   Wire.beginTransmission(AccelerometerAddress);   Wire.write(0x02);   Wire.endTransmission();   Wire.requestFrom(AccelerometerAddress, 6);   for(int i = 0; i < 6; i++)   {     data[i] = Wire.read();   } }

Mit einem 9V Block Akku lässt sich dies leider nicht lange betreiben, da die LEDs zusammen 1W Leistung verbrauchen. Ein 9V Block ist spätestens nach einer halben Stunde leer. Besser eignet sich hier ein Netzteil (oder eine Batterie mit mehr Kapazität). Hier noch ein kurzer Zusammenschnitt als Video.

Was vielleicht von Interesse sein könnte, sind die verwendeten Bauteile. Alternativ kann nach Bedarf das Aussehen bestimmt werden.

Materialliste:

• 1 x Arduino Duemilanove (Geht auch mit anderen)
• 1 x Beschleunigungssensor BMA020
• 1 x Spannungsregler LM317
• 1 x Quarz 16Mhz
• Widerstände: 1 x 47 Ohm, 1 x 4,7kOhm, 1 x 10Ohm, 2 x 2,2kOhm
• Transistoren: 1 x BC177A (PNP), 3 x BC547B (NPN)
• 1x Potentiometer 500Ohm
• 1x Streifenplatine
• 1 x DIODER (Name des IKEA Produktes mit den LED Flächen)
• 1 x Breadboard
• 1 x Platine
• 1 x 9V Block
• eine Menge Kabel
• 1 x Kunststoff Flasche

Netduino Sensor & Controller Shield für den Quadrocopter

Servo Test am neuen Neduino Shield

Irgendwann kommt die Zeit, dass man sich von Altem trennen muss. Besonders dann, wenn man einen Prototypen Shield hat, der aus zusammengesteckten Leiterbahnen besteht und dadurch viele Fehlerquellen haben kann. Zudem musste ich über eine weitere Schaltung das PWM Signal verstärken. So baumelte noch bis vor kurzem eine weitere Platine mit 4 Pegelwandlern am Shield. Eine wackelige Angelegenheit kann ich euch nur sagen...

Prototypen Shield mit zusätzlichen Pegelwandler

Am letzten Donnerstag kamen endlich die bestellten Arduino/Netduino Platinen aus China. Die Verarbeitung ist vernünftig und das Geld wert. Ich habe hier 4€ pro Stück bezahlt, zusätzlich Porto und Versand. Hier ist es sinnvoll gleich ein paar mehr zu bestellen. Den richtigen Pegelwandler habe ich erst aussuchen müssen. Ich habe zwei verschiedene bestellt, zum probieren. Entschieden habe ich mich für den 74HCT125N. Der Pegelwandler soll später das Pulssignal bzw. PWM von 3,3V auf 5V anheben. Zwar geht es auch mit 3,3V, aber ich habe öfters keine Reaktion beim Steuern der Servos oder Regler gehabt. Erst mit dem selbstgebastelten Pegelwandler war das Signal stabil.

Links ist der 74HCT125N und rechts der 74HCT245N

Ich überlegte zunächst, wie ich meine Sensoren anordne und wo ich später den Pegelwandler mit den Anschlüssen positioniere. Hinzu kam noch ein Anschluss für den Lithium Polymer Akkumulator, der den Mikrocontroller mit Strom versorgt. Später soll auch die Kapazität gemessen werden, sobald ich damit ein paar Versuche durchgeführt habe. Am Ende habe ich dann für mein Netduino folgende Bauteile verwendet:

- Arduino Platine - Buchsenleisten - Stiftleisten - einen Pegelwandler (74HCT125N) - Buchse für einen 3S LiPo Akku - Gelbe 3mm LED mit 20mcd Leuchtkraft - 150Ohm Widerstand - Druckknopf.

Zusätzlich kamen natürlich auch Kabel und Überbrückungstücke hinzu, um den richtigen Schaltkreis herzustellen. Nachdem ich mit dem Löten fertig war, musste ich noch das Lötfett entfernen. Das ging am besten mit heiß Wasser und Seife (mit anschließendem ausreichenden Trocknen, versteht sich).

Mein fertiges Netduino Shield, (oder fast fertig)

Das was nicht so schön ist habe ich auf der Unterseite verlötet.

Gelb sind die Signalleitungen. Rot für anliegende Spannung, wie z.B. +5V.

Nun kurz zur Erklärung der Funktionsweise des Shields:

• Die LED soll später die Aktivität des Controllers wiedergeben.
• Auf den Buchsen wird der Beschleunigungssensor gesteckt, um die Lage des Quadrocopter zu stabilisieren.
• Auf die vier 3-Pin Anschlüsse kommen jeweils die Regler für die Brushless Motoren. Das PWM Signal wird zuvor mit dem Pegelwandler von 3,3V auf 5V angehoben.
• Die weisse Buchse ist der Anschluss für einen 3S LiPo Akku, um den Netduino mit Strom zu versorgen.

Das sind noch nicht alle Funktionen, die ich für dieses Shield geplant habe. Wenn ich mit den Tests soweit durch bin, kann ich sicher ohne weiteres die Platine mit den erforderlichen Bauteilen ergänzen.
Geplant sind noch:

• Magnetsensor
• Gyroskop
• Akkukapazitätsmessung
• Anschluss für ein Display

Fehlersuche auf meinem Shield

Fast nicht zu erkennen. Unterbrechung an der Leiterbahn.

Irgendwann musste es ja so kommen. Hin und wieder reagierten die Regler nicht oder in einem Test sogar der Digital Servo. Mit einem einfachen Messgerät konnte ich die Unterbrechung feststellen. Da ich ja immer noch unterwegs bin, habe ich keine Lötstation dabei. Deshalb habe ich die Stelle vorrübergehend überbrückt.
Naja. Leider ist die Lötarbeit von mir miserabel, weil mein Lötkolben keine richtige Spitze bildet. So langsam brauche ich eine neue Lötstation mit einem Lötkolben, bei dem ich leichter Ersatzteile finde.

Pegelwandler für den Regler

Microcontroller und Regler mit Pegelwandler

Nach dem ich einen Pegelwandler über dem Breadboard ausprobiert habe, dachte ich "löte doch mal das gleich auf die Platine!". Damit ich auch die richtigen Widerstände verwende, habe ich kurzerhand die Schaltung für meine Bedürfnisse berechnet. Im Grunde reicht die Grundformel R=U/I. Zunächst suchte ich in meinen Kisten nach den passenden Transistoren, und fand schließlich auch die PNP Varianten. Zuvor habe ich nur NPN verwendet, wodurch ich noch ein Inverter benötigt habe, um das richtige Ausgangssignal zu erhalten.

Leider bin ich etwas gestolpert, als ich meinen Kaffee an meinen Tisch brachte.

Was hier allerdings auffallen dürfte ist, dass ich nicht die Werte genommen habe, die ich eigentlich berechnet habe, sondern Widerstände mit einem geringeren Wert. Da ich meistens mit 1 Milliampere rechne, ist es nicht weiter tragisch, wenn die Belastung auf 2mA oder 3mA ansteigt und für meine Anwendungen absolut ausreichend. Abgesehen davon, hätte ich sonst eine Platine voller Widerstände, und das wäre dann schon eine Verschwendung.

Widerstände 8x2,2kOhm und 4x1,5kOhm, 4xPNP BC177A und 4xNPN BC547A Transistoren, 1 Platine und Steckstifte zum anschließen.

Zugegeben passt auf der Platine noch mehr, dennoch sollte es erst einmal reichen. Vielleicht fällt mir später noch etwas ein, dass ich als Schaltung gebrauchen könnte.

Die fertigen 4 Pegelwandler. Von Links kommt das Signal vom Microcontroller und links vom schwarzen Transistor wird der Regler angeschlossen.

Kurz warum ich hier Pegelwandler brauche. Normalerweise würden die Servos, oder zumindest die kleinen, mit einem Spannungsimpuls von 3,3V auskommen. Schließt man hier einen normalen an, so kann es vorkommen, dass der Spannungsabfall zu groß ist und das Signal nicht ausreichend für den Regler zu lesen ist. In meinem Fall sind es die Regler für die Brushless Motoren, die keine ausreichende Entkopplung zum Stromkreis haben.

Neu Verkabeln

Kabel und Stecker

Zugegeben war ich unzufrieden, wie die Verkabelung auf meinem Quadrocopter aussah. Der Missbrauch  Steckersysteme zu verwenden, die Normalerweise im PC selbst zu finden sind, sah nicht schön aus. Daher besorgte ich im Conrad Shop entsprechendes Kabel und passende Stecker, die für den Modellbau geeignet sind.

 Stecker anlöten

Mit meinem anschlagenden Lötstation war das kein leichtes, alle Kabel so vernünftig wie möglich anzulöten. Schwierig waren die Stellen, wo zwei Kabel aneinander gelötet werden.

Schrumpfschlauch herum, nur nicht zu lange mit dem Feuerzeug behandeln

Ich hatte fast immer die passenden Schrumpfschläuche da. Ein wenig bunt wirkt es jedoch schon, da ich nicht immer die entsprechende Farbe wählen konnte.

Fertig ist der Verteiler

Das löten erwies sich als sehr langwierig, dafür ist es nun ordentlicher geworden. Jedoch stellte ich fest, dass mir meine Kabelbinder ausgegangen sind. Dies ist zwar nicht kritisch, da es gerade noch reichte die Regler festzuspannen, dennoch könnten es doch ein paar mehr sein. Wie dem auch sei...

Stat mit dem "wie das andere hieß", sind die Regler mit Kabelbinder festgezogen

Wo schon bereits der Rumpf, die Verkabelung und Elektronik bereits platz gefunden haben, fehlt es immer noch am Programmcode. Es zieht sich hin, das auf Grund verschiedener Einwirkungen mich daran hindern damit zügig fertig zu werden.
Bei einigen Sachen wie zum Beispiel mit dem Stabilisieren könnte ich sicherlich etwas fertiges im Internet finden, aber dann wäre dies nur halb so herausfordernd.

Brushless Motoren montieren

Brushless Motor und entsprechende Teile
Motor mit Propeller und Fahrtenregler

Nach über einem Monat habe ich endlich die Motoren zu meinem Projekt “Quadrocopter” erhalten. Ärgerlich war, dass das Paket beim Zollamt abgeholt werden musste, weil die entsprechende Rechnung am Paket nicht vorhanden war. Somit hat sich die Montage um eine Woche verzögert.

Motor am Rumpf montiert und verkabelt

Nachdem ich wieder die Stellen markiert, gekörnt, angebohrt und gebohrt habe, konnte ich die Motoren montieren. Anschließend kam die Verkabelung dran. Da mir die entsprechenden Y-Verbindungen für die Fahrtenregler fehlten, lötete ich einige Stecker zusammen. Folgend kam die Verkabelung und die Verbindungen auf dem Rumpf. Leider finde ich die Verkabelung noch nicht ganz gelungen, und ich denke, das mache ich am nächsten Wochenende nochmal.

Mit dem Arduino Nano 3.0 wurde durch geprüft

Nachdem ich alles mehr oder wenig provisorisch verkabelt hatte, schrieb ich für den Arduino ein kleines Programm zum regulieren des PWM Signals. Mit einem Potentiometer konnte ich die Ansteuerung des Fahrtenreglers vornehmen. Zuerst habe ich ein kleines Netzteil verwendet, das sich aber nach dem Anschluss des zweiten Fahrtenreglers als zu schwach herausstellte, und nahm daher den Akku. Mit Vorsicht drehte ich langsam am Potentiometer und staunte, dass ich bereits bei ca. 20% erst einmal anhalten musste, da mir sonst auf dem Tisch weggeflogen wäre. Gemessen an einem Rotor, könnte man schon meinen, dass einer  reichen würde, den ganzen Rumpf hochzuziehen. Später habe ich dann auf dem Boden im Wohnzimmer weiter getestet und drehte auf ca. 50%. Es flatterten schon die Gardinen und meiner Freundin wurde kalt, durch den starken Wind von den Rotoren.

Passt gerade so auf dem Schreibtisch

Inzwischen hat mein Projekt eine gewisse Größe erreicht. Auf dem Bild zu sehen: mein Quadrocopter auf meinem Schreibtisch.
Nun bleibt noch die Programmierung der Steuerung übrig.