Posts mit dem Label Entwicklung - Steuerung werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Entwicklung - Steuerung werden angezeigt. Alle Posts anzeigen

Mittwoch, 24. Juni 2020

RC Fahrtenregler für Lego Kettenfahrzeug



 

Auf dem Markt gibt es viele verschiedene Module an Motortreibern. Diesmal verwende ich einen recht einfachen, der zur Ansteuerung bis zu vier PWM Signale verwendet. Der Motorschield für den Arduino hingegen benötigt noch eine Steuerung eines Shiftregister 74HC595. Ich weiß, das geht auch ohne, aber ich beziehe mich diesmal auf fertige Module, die kompakt aufgebaut sind.

Aber nur ansteuern wäre diesmal zu langweilig und daher habe ich hier als Ziel, den Lego Technic Stunt-Racer damit zu betreiben. Wer das Modell kennt, weiß, dass dieser mit einer Infrarot Fernbedienung ausgeliefert wird und das eher nur in der Wohnung funktioniert.

 

Benötigt wird:

Modul MX1508 (DC Motor Treiber)

Arduino Mini Pro (5V Ausführung)

2x Servo Kabel

2x Lego Power Function Verlängerungskabel

Lego Technic Fahrzeug mit Power Function

Zwei Kanal Fernsteuerung und ein Empfänger mit PWM Signal Ausgängen.

 

Betrieb mit Funk-Fernsteuerung

Der Microcontroller soll zwei PWM Signale verarbeiten, so das damit zwei Motoren gesteuert werden können. Als Fernsteuerung soll links der Stick für die Geschwindigkeit sein und rechts der Stick für das Lenken. Also wie bei jedem anderen RC Auto.

 

Pin Belegung Power Function Kabel

Für die Umsetzung reicht es zu wissen, welche Leitung von den vier was ist. Bei der Suche war immer die Beschriftung 9V, 0V, C1 und C2 gegeben, weshalb ich das ebenfalls übernehme.

 

 

Für den nächsten Schritt müssen die beiden Power Function Kabel so abgeschnitten werden, dass die Verbindung für das eigene Projekt passen.

 

Motor Treiber MX1508

Den verwendeten Motor Treiber MX1508 findet man fälschlicherweise auch unter L298N. Der Motor Treiber L298N funktioniert ebenfalls für dieses Vorhaben, ist allerdings etwas übertrieben und ist auch eher was für größere Projekte geeignet.

 

Daten:

Betriebsspannung 2V bis 10V

Signal Spannung für IN1 bis IN4 1,8V bis 5V

Ausgangspannung für Motor-A und Motor-B 2V bis 10V

Betriebsstrom 1,5A

Maximaler Kurzstrom 2,5A

 

 

 

Aufbau der Schaltung

Der folgende Schaltplan zeigt, wie die Power Function Kabeln mit dem Motortreiber verbunden werden. Die Schaltung funktioniert auch mit einem Lipo Akku. Daher kommt neben dem Power Function Stecker noch ein JST Anschluss. Der Arduino Mini Pro wird über die Spannungsversorgung mitbetrieben und über den Pin RAW angeschlossen.

 

 

 

Der fertige Motortreiber

Anders als auf dem Bild zuvor habe ich noch einen weiteren Anschluss für die Spannungsversorgung angebracht. Das Ermöglicht auch zwei Zellen Lipo Akkus zu verwendend, anstatt der Lego Powerfunction Battery Box. Links auf dem Bild sind vier Leitungen mit Steckern, die für den Anschluss eines Empfängers da sind.

 



Programmcode einstellen

Diesmal beschreibe ich nicht den Aufbau des Programmcode, sondern gehe auf einen fertigen Motortreiber von mir ein. Für das Zielprojekt soll die Eingabe der Fernsteuerung links für die Geschwindigkeitsregelung sein und rechts das Lenken. Also ganz klassisch. Natürlich ginge auch eine Steuerung, wie sie bereits von Lego Power Function mit der Infrarot Fernbediendung vorgegeben wird.

 

Einstellung für den Lego Technic Stunt-Racer

 // Set this value true, for show all Value on Serial Monitor.  
 bool mSerialMonitor = false;        
 // 0 = Car, Input 1 for speed and input 2 for steer  
 //  - Alternate: Tracked vehicle, Input 1 for speed motor A and   
 //         Input 2 for speed motor B  
 // 1 = Tracked vehicle, Input 1 for speed and input 2 for steer  
 int mVehicleMode = 1;           
 // invert steering direction, only tracked vehicle   
 boolean mVehicleModeSteerInvert = false;  
 // Tolerance range in which no reaction should take   
 // place when sticks are in the middle position.  
 int mDeathbandPlusMinus = 10;       
 // change direction signal output for motor A  
 boolean mReverseA = true;  
 // middel state of the input signal. Example: stick on neutral position  
 int mInputMiddleA = 1500;  
 // minimum value of input signal. Example: stick is move complete down  
 int mInputMinA = 1000;  
 // minimum value of input signal. Example: stick is move complete up  
 int mInputMaxA = 2000;  
 // change direaction sinal output for motor B  
 boolean mReverseB = false;  
 // middel state of the input signal. Example: stick on neutral position  
 int mInputMiddleB = 1500;  
 // minimum value of input signal. Example: stick is move complete down  
 int mInputMinB = 1000;  
 // minimum value of input signal. Example: stick is move complete up  
 int mInputMaxB = 2000; 

 

 

Lego Technic Stunt-Racer Umbau

Damit der Empfänger und der Motor Treiber nicht einfach so rum hängen, sollte der Aufbau etwas geändert werden. Der Lego Technic Infrarot Empfänger wird entfernt. Wie nun der Umbau aussieht, ist zweitrangig, Hauptsache die Elektronik ist gut verstaut. Der folgende Umbau ist ein Beispiel.

 


   
 
   
   
   
   

 

Wort zum Schluss

Die Motoren lassen sich noch mit einer höheren Spannung betreiben. Allerdings steigt dann auch die Belastung der Lego Teile in Form von Verschleiß, wegen der fehlenden Kugellager.

Dann noch der hier verwendete Motor Treiber MX1508: Wegen einer falsch ausgewiesenen Information zu L298N, dachte ich zunächst, dass eine höhere Spannung möglich sei. Nach dem ich später für den Blog Eintrag mehr Informationen über den verwendete Komponente suchte, stieß ich auf die richtigen Werte. Zugegeben, ich hatte bereits mit der Fehlinformation den Aufbau mit einem 3S Akku betrieben. Allerdings nur kurz. Für den Betrieb mit einer hören Spannung würde dann der Motor Treiber L293D gehen, aber dann könnten Probleme mit dem maximalen Strom geben, wenn XL-Motoren verwendet werden.

 

Arduino Code - Motortreiber für MX1508

Github - Powerfunction-MotorDriver

 


Sonntag, 4. Januar 2015

Arduino Control (Teil 1) – LED ein und ausschalten

image

Diesmal gehen die folgenden Beispiele darauf ein, einen Arduino mit seinen Eigenschaften anzusteuern. Im Wesentlichen handelt dieser mehrteilige Blog Post davon, wie eine Eingabe vom PC zum Arduino kommt und auch wieder zurück.

Die Anforderung wird sein, dass mit der Enter Taste die rote LED auf dem Arduino ein oder ausgeschaltet wird. Für das erste Beispiel reicht daher ein Consolen Programm aus, um eine Eingabe aufzunehmen und einen Befehl entsprechend zu senden. Beide Programme müssen dieselbe Baudrate haben, die hier bei 115200 Baut liegt.

static void Main(string[] args)
{
    // Die Verwendete COM Verbindung
    // sollte der aus dem Arduino Programm entsprechen.
    SerialPort sp = new SerialPort("COM16", 115200);

    // Verbindung öffnen.
    // Wenn das Programm gestartet ist,
    // sollte der Arduino bereits mit dem PC verbunden sein.
    sp.Open();

    // Wird verwendet um den Zustand zu wechseln.
    bool changeState = true;

    // Der Eigentliche Steuerinhalt wird immer wieder ausgeführt.
    while (true)
    {
        // Programm hält an dieser Stelle,
        // bis die Enter Taste gedrückt wurde.

        Console.ReadLine();

        // Ist der Wechsel Status 'True'...
        if (changeState)
        {
            //... dann soll die LED eingeschaltet werden.
            sp.Write(new byte[] { 0x01 }, 0, 1);
        }
        else
        {
            //... dann soll die LED ausgeschaltet werden.
            sp.Write(new byte[] { 0x00 }, 0, 1);
        }

        // Wechselt den Zustand von True auf False oder umgekehrt.
        changeState = !changeState;
    }
}

Hinweis: Hier im Beispiel verwende ich COM16, der wahrscheinlich angepasst werden muss. Das könnte dann ggf. über dem Arduino Programm gesichtet werden.

image

Nun muss der Arduino die Sendung vom Programm verstehen. Momentan wird erwartet das Hex 0x01 oder Hex 0x00 empfangen wird.

void setup()
{
  
// Baudrate wie bei dem C# Programm
  Serial.begin(115200);

  // Pin 13 für die Rote LED
  pinMode(13, OUTPUT);
}

void loop()
{
  // Wenn neue Daten verfügbar sind.
  if(Serial.available() > 0)
  {
    // Wird am Serial 0x01 gelesen, wird an die
    // Methode digitalWrite ‘true’ übergeben.

    digitalWrite(13, Serial.read() == 0x01);
  }
}

Das war im Grunde schon alles. Wenn nun das C# Programm gestartet wird und der Arduino bereits angeschlossen ist, so kann dann mit der Enter Taste die Rote LED ein und ausgeschaltet werden.

Quellcode zum Downloaden

Dienstag, 14. Oktober 2014

Intervallaufnahme mit der Kamera ohne Interne Funktion

IntervallAufnahme01

Die Funktion für eine Intervallaufnahme ist simpel, daher ist es für mich unverständlich, warum nicht zumindest die Systemkameras von der Nikon 1 Serie in ihren Modellen diese Option anbieten. Nun gut, dies war kein Kaufkriterium, wäre aber schön gewesen. Ich selbst verwende die Nikon 1 J3 (die J1 hat die Intervallaufnahme), allerdings sollte mein Beispiel auch für andere Kameras funktionieren. Grundsätzlich geht es darum einen Servo auf den Auslöser zu drücken. Für diesen Zweck habe ich aus Aluminium Eckschienen eine Vorrichtung gebaut.

image

Wie schon am Bild zu erkennen ist, sollten zum Schutz die Alu Eckschienen nach der Verarbeitung abgerundet und ggf. mit Filzaufklebern beklebt werden.

Die Materialliste:

  • Alu Eckschienen ca. 20cm
  • Filzaufkleber
  • ein paar 3mm Schrauben und entsprechende Muttern
  • Mini Servo mit ca. 10 Ncm
  • Eine passende Schraube zur Kamera dass mit dem Stativ auch verschraubt werden kann. (siehe folgendes Bild)
image

Zum Ansteuern wird der Netduino mit einem passenden Shield zur Ansteuerung für einen Servo verwendet. Die geringe Belastung kann das Board verkraften. Bei Normalen und größeren Servos wird eine Externe Stromversorgung notwendig.

image

Der Aufwand des Programmcodes gestaltet sich übersichtlich. Zusehen ist, dass noch ein Analoger Wert eingelesen wird, worauf ich im nächsten Absatz zu sprechen komme.

public class Program
{
    // Für die Einstellung des Druckpunktes.
    private static SecretLabs.NETMF.Hardware.AnalogInput _Input;

    // Ansteuerung des Servos für den Auslöser.
    private static PWM _Servo;

    // Led Status wiedergeben.
    private static OutputPort _Status;

   // Einen Zähler.
    private static int _IntervallCounter = 0;

   // Nach wie viel Sekunden soll ausgelöst werden.
   private static int _IntervallEnd = 15;//30;

    public static void Main()
    {
        _Input = new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A0);
        _Servo = new PWM(Pins.GPIO_PIN_D5);
        _Status = new OutputPort(Pins.ONBOARD_LED, false);
           
        // 20ms für den Analog Servo.
        uint periode = 20000;

        // Mittelstellung bei 1,5ms
        _Servo.SetPulse(periode, 1500);

       while (true)
        {
           if (_IntervallCounter >= _IntervallEnd)
            {
                for (int i = 0; i < 3; i++)
                {
                    _Status.Write(true);
                    Thread.Sleep(100);
                    _Status.Write(false);
                    Thread.Sleep(100);
                }

                // Hinweis: bei Netduino 1 wird ein Wert gelesen von 0 bis 1023.
                //          Der Netduino 2 hingegen liest bis 4095.
                //uint duration = 1000 + (uint)_Input.Read();         // Ein kommentieren um den Servo
                //Debug.Print("Duration: " + duration.ToString());  // einzustellen am Pin A1.

                _Servo.SetPulse(periode, 1710); // 1710 ist eine Einstellung, an meiner Kamera
                Thread.Sleep(400);

               // Zähler Zurücksetzten.
                _IntervallCounter = 0;
            }
            else
            {
                // Aktivität zeigen
                _Status.Write(true);
                Thread.Sleep(100);
                _Status.Write(false);
               Thread.Sleep(900);

                _IntervallCounter++;
            }

           // Zurückstellen.
            _Servo.SetPulse(periode, 1500);
        }
    }
}

Das gleiche nochmal für den Arduino.

#include <Servo.h>
// Servo Kontrolle anlegen
Servo controlServo;
// Einstellung wie weit sich der Servo drehen darf
int pinAnalogIn = A0;
// Servo ansteuern
int pinServo = 5;
// LED Status
int pinLed = 13;
// Intervall Zähler
int intervall = 0;
// IntervallLänge in Sekunden
int intervallLength = 15; // 30;

void setup(){

  // Dient zu Einstellgunszwecke
  Serial.begin(9600);
  // Pins zuweisen
  pinMode(pinAnalogIn, INPUT);
  controlServo.attach(pinServo);
  pinMode(pinLed, OUTPUT);
}

void loop()
{
  if(intervall >= intervallLength)
  {
    for(int i = 0; i < 3; i++)
    {
      digitalWrite(pinLed, HIGH);
      delay(100);
      digitalWrite(pinLed, LOW);
      delay(100);
    }
   
   // Einkommentieren um die Reichweite des Servos einzustellen,
    // mit einem Potitometer am Pin A1.

    int result = 500; //analogRead(pinAnalogIn);
   
    controlServo.write(map(result, 0, 1023, 0, 179));
    delay(400);
   
    // Zähler zurück setzen
    intervall = 0;
  }
  else
  {
   digitalWrite(pinLed, HIGH);
   delay(100);
    digitalWrite(pinLed, LOW);
    delay(900);
    intervall++;
  }
 
  // Zurück stellen.
  controlServo.write(90);
}

Jetzt fehlt noch ein fester Wert für den Druckpunkt. Der Potentiometer wird an Pin A1 angeschlossen, die Spannungsversorgung muss beim Netduino mit 3,3V angelegt werden. Das Auslesen des Stellwertes erfolgt beim Netduino über Debug.Print() und wird über die Ausgabe angezeigt. Beim Arduino wird der Stellwert über dem Serial Monitor wiedergegeben. Je nach Belastung kann die Versorgung über USB instabil werden. Das zeigt sich dann, wenn der Servo beim Drücken des Auslösers leicht zittert. Später, mit einem 9V Akku oder Netzteil, sollten diese Schwierigkeiten nicht mehr auftauchen. Ansonsten muss der Servo einen eigenen Stromkreis erhalten, um zu verhindern, dass die Versorgung des Mikrocontrollers zu sehr schwankt und so zu einem Neustart des Programms führt.

image image
image image

Zu den Einstellungen der Kamera. Um ein schnelles Auslösen der Kamera zu ermöglichen, sollte auf den Kreativ Modus gewechselt werden. Die Blende, die Verschlusszeit und der Fokus sind am besten manuell festzulegen. Spätestens bei Nachtaufnahmen kommt man an diesen Einstellungen nicht vorbei. Achja, das Dateiformat JPG ist für die Ausgabe zu empfehlen. Mit dem NEF bzw. RAW ist das Bearbeiten im Video Schnittprogramm kaum machbar.

BeiNachtMitSternenhimmel_06

Tipp zur Nachtaufnahme: acht bis fünfzehn Sekunden für die Verschlusszeit bei maximal offener Blende reichen aus. Zu lange Belichtung führt dazu, dass die Sterne Streifen bilden, also praktisch gesehen wird die Erdrotation sichtbar. Die idealen Nächte mit Sternenhimmel sind in der Zeit um Neumond. Die besten Bedingungen sind Orte, die so dunkel sind, dass beim Hinabsehen die eigenen Füße nicht mehr zu sehen sind. Zwinkerndes Smiley

Nun noch ein paar Aufnahmen, die ich mit meiner Apparatur erstellt habe.

Zu guter Letzt auch noch der Quellcode zum Herunterladen.

Montag, 10. September 2012

Immer wieder neue Erkenntnisse

image
Netduino mit meinem aktuellen Shield
Zugegeben, habe ich mich vielleicht etwas übernommen, als ich geglaubt habe, dass ich das in wenigen Monaten schaffe würde, eine brauchbare Lösung zu programmieren, ohne an die praktischen Schwierigkeiten zu denken.
Wer kennt es nicht, dass der PC mehr Arbeitsspeicher braucht für mehrere oder besonders speicherlastige Programme. Nun, mein Programmcode für den Controller zur Steuerung über Netzwerk und das Auswerten der Sensoren erfordert mehr Speicher als das, was im Netduino Plus steckt. Mit den 42KB Arbeitsspeicher scheine ich wohl derzeitig nicht auszukommen und so muss ich wohl einen anderen Weg finden, etwas kompakter zu programmieren.
image
Die Nummer 16 hinter Hauptroutine, bedeutet, dass der Thread angehalten ist. Der Thread wird gebraucht, um die Regler anzusteuern.
Wie wirkt es sich derzeitig aus? Sobald das Ende des Arbeitsspeichers erreicht ist, kommt es zu einem Ausnahmefehler in der Methode. Da ich jeden Thread mit einer eigenen Fehlerbehandlung bearbeitet habe, steigt nur der eine oder andere Thread aus, oder wird nicht gestartet. Also da ist noch einiges zu tun, jedoch muss ich leider mein Projekt zum Teil einschränken, da ich mit meiner Freundin kurz vor einem Umzug stehe. Also dann…

Freitag, 20. Juli 2012

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.

Defekter Brushless Motor

Brushless Motor, Regler und der Arduino zum programmieren des Reglers

Ärgerlich. Jetzt bin ich mit dem größten Teil der Programmierung durch, ist mir beim justieren ein Motor im wahrsten Sinne abgeraucht. Nach dieser neuesten Erfahrung musste ich feststellen, dass der Regler für Brushless Motor in einem schädlichen Bereich steuern kann. Vielleicht kann ich erst einmal einen Tricopter konfigurieren, um meine Tests fortzuführen und gegebenenfalls auch mal zu fliegen.

Mittwoch, 18. Juli 2012

Provisorischer Pegelwandler von 3,3V auf 5V

PWM Signal über den Pegelwandler und Inverter

Heute morgen habe ich meine Bestellung von ein paar Pegelwandlern abgesendet. Obwohl ich mir sicher bin, dass es dann mit der Ansteuerung der Regler funktioniert, habe ich testweise einen Pegelwandler aus zwei Transistoren, 3 Widerständen und einem Inverter zusammengesteckt.
Es funktioniert! Zuvor ging es mit dem großen Servo nur teilweise und eigentlich wackelte der Arm nur ein wenig hin und her. Das gleiche dürfte auch bei den Reglern der Fall gewesen sein, so dass sich die Motoren nur ungenau und fast nur auf Vollgas drehten.

Der provisorische Pegelwandler wandelt den Impuls von 3,3V auf 5V. Zumindest sollte das so sein. Es kamen hier jedoch nur 3,8V an, reichte allerdings, dass der Servo nun mit dem PWM Signal etwas anfangen konnte. Besser wäre es, wenn ich das vorher ausgerechnet hätte, dann wäre ich näher an der gewünschten Signalstärke.
Wenn meine bestellten Teile ankommen, dann kann ich erst mal einen neuen Netduino Shield löten.

Montag, 16. Juli 2012

Schwierigkeiten mit dem Steuerimpuls

Messen mit dem Oszilloskop

Nachdem ich gestern etwas am Verzweifeln war, stellte ich heute etwas neues fest. Die Spannung, die als Signal Impuls ankommt, hat nur 3,3V und scheint bei Belastung zu weit abzufallen. Das führt nun dazu, dass die Regler nicht richtig durchgesteuert werden und die Motoren nur ein wenig hin und her wackeln.

Dem Fehler auf der Spur. Spannung vom Signal zu gering.

Erst heute fand ich zufällig bei meiner Suche die richtigen Einstellungen für die PWM Klasse im  .NET Micro Framework. Jedoch stellte ich fest, dass meine verwendeten Werte alle richtig sind, und ich nun darauf kam, mal das Signal etwas näher zu betrachten. Ach ja, bei meiner Suche im Internet fand ich einen Blog, der mir den entscheidenden Hinweis gab, und zwar die Spannung.
Also schloss ich mein Oszilloskop an und legte den Messstift an den Microcontroller und siehe da, es stimmt. Die Spannung ist wie beschrieben bei 3,3V, und nicht wie immer angenommen bei 5V. Zwar sollte auch die Spannung von 3,3V reichen, aber bei mehreren Reglern fällt die Spannung zu weit runter, so dass ein vernünftiges Durchsteuern nicht mehr möglich ist

Dienstag, 10. Juli 2012

Fernsteuerung Entwickeln für Windows Phone 7

Windows Phone 7 und in Expression Blend entwickelte Controls.

Fast 2 Wochen habe ich keinen Blogeintrag getätigt, was allerdings nicht bedeutet, dass ich nicht weiter am Quadrocopter arbeite. Es ist vielleicht spannend, wie ich viele Tests durchführe, um die richtigen Einstellungen für die Rotorsteuerung herauszufinden. Jedoch habe ich dies ausgelassen und behalte das solange, bis ich fertig bin. Am Ende werde ich vielleicht auch eine kleine Dokumentation auf meinem Blog veröffentlichen in einer weiteren Kategorie.

Vorläufige Steuercontroller. Schubwerte (die 4 Kreise links), Gleichgewichtsanzeige (sieht aus wie ein Radar), Verzögerungsanzeige (Netzwerkverbindungverzögerung), Batterieanzeige. Zudem Anzeigen welche Bereiche Betriebsbereit sind.

Für die Programmierentwicklung reicht nicht nur die Entwicklung auf dem Microcontroller, sondern auch die Entwicklung für die Fernbedienung. Zudem war es für mich notwendig mich mit Expression Blend 4 auseinander zusetzen, dass ich nun in Zukunft immer verwenden werde, um meine Controls zu gestalten. Zuvor habe ich dies immer per Hand im Designer eingegeben, was ein gewissen Zeitaufwand benötigte.

Erste Version der Controllerseite.

Momentan sind erst mal die Seiten fertig, auf dem später die Steuerung des Quadrocopter vorgenommen werden kann. Zwar habe ich schon vor einen Monat bereits an der App programmiert, jedoch gefiel mir die Optik noch nicht. Jetzt komme ich schon der Sache näher und ich bekomme nun mit der Version wesentlich mehr auf eine Seite als zuvor. In der ersten Variante sah es recht klobig aus.

Einfacher Aufbau für die Netzwerkverbindung.

Nachdem ich meine erste Version für den Controller fertig entwickelt habe in einer Simulierten Programm, kompilierte ich den Code auf den Netduino und schloss es an die Regler für die Rotoren an. Leider war ich mit der Begrenzung der Schubkontrolle etwas zu großzügig, so das ich Schwierigkeiten hatte, die Stromversorgung für die Motoren abzutrennen, ohne das mir mein Quadrocopter aus der Handreißt. Für die nächsten Test ist nun der Rumpf am Tisch festgebunden.

Am Tisch gebunden. Einfach so ist die Gefahr zu groß für Beschädigungen.

Bevor ich also da weiter testen kann, muss die Software für das Windows Phone fertig werden. Und vielleicht ist ein Not aus für die Tests auch nicht verkehrt.

Sonntag, 17. Juni 2012

Brushless Motoren montieren

WP_000208 WP_000211
Brushless Motor und entsprechende Teile
WP_000210
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.
Quadrocopter_08 Quadrocopter_10
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.
Quadrocopter_09
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.
Quadrocopter_11
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.

Gehäuseentwurf für Signalleuchten (Part 1)

RGB LEDs und LIPO Akkus sind bestellt. Weil ich bereits die Abmessungen habe, kann ich schon mal mit dem Gehäuseentwurf in Blender anfangen....