Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

15 Schritt:Schritt 1: Zunächst müssen Sie einen Arduino Schritt 2: Erstellen der Controller Schritt 3: Erste Schritte Schritt 4: Erstellen Verbindungen- Motoren, LEDs und Transistoren Schritt 5: Lassen Sie uns jetzt etwas Spaß zu haben! Schritt 6: Mit den Tasten Schritt 7: Hinzufügen eines Servo Schritt 8: Soundeffekte und Biegesensoren Schritt 9: Controlling Servos Schritt 10: Nunchuck Steuer Schritt 11: Predator Kanone Schritt 12: War Machine Kanone Schritt 13: Gehen mit drahtlosen XBee Schritt 14: Ressourcen Schritt 15: FAQs

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Hier ist, wie Licht, Ton und Aktion, um Ihre Lieblings-Halloween-Projekt mit dem Open-Source-Arduino Mikrocontroller hinzuzufügen. Arduino ist einfach zu lernen, zu benutzen, und es öffnet sich eine ganz neue Welt für Modebauer und Kreatur Schöpfer. Wenn Sie lernen, wie man Drähte, Servos, LEDs anschließen und Soundeffekte, dass etwas Besonderes zu Ihrem aktuellen Projekt hinzufügen möchten, dann ist dies für Sie.

p {} Ich werde Ihnen zeigen, wie man eine nette kleine kompakte Servoregler Arduino Board mit in Servo-Anschlüsse, die perfekt für Kostüme und Spukhaus Anwendungen gebaut werden. Es gibt mehrere Code-Beispiele, Schaltpläne, und ich werde Ihnen zeigen, wie Sensoren und schließen sogar, wie man zwei Controller mit Wireless-Geräte angeschlossen werden.

Hier ist eine kleine Filmsequenz von dem, was ist leicht möglich- ein animatronic Predator Kanone mit Laservisier, Kanonenschuss Sound und Head-Tracking-Bewegungssteuerung.



Hier ist ein Iron Man Hand Repulsor mit Servo um den Unterarm Raketenfach zu öffnen. Folgen Sie entlang und finden Sie heraus, wie Sie Ihren fantastischen Kostümen mehr awesome zu machen ...


Update: My instructable zu zeigen, wie man ein animatronic Stargate Helm ist hier-
http://www.instructables.com/id/Animatronic-Stargate-helmet/
Ich habe auch erstellt eine Animatronics-Forum , wo Menschen gehen, um Hilfe bei ihrem Kostüm und Requisite Projekte zu bekommen. Ich bekomme so viele Nachrichten für spezifische Projekt Hilfe von Menschen, die ich beschlossen, einen eigenen Forum, wo jeder Hilfe zu erhalten und Ideen zu schaffen!



Hinweis - Während diese instructable ist für Anfänger geschrieben, übernimmt dieses Tutorial Sie, wie man einen Lötkolben und verschiedene andere Tools wie Abisolierzange und Drahtschneider verwenden. Bitte achten Sie darauf, um eine ordnungsgemäße Sicherheitsvorkehrungen zu treffen, eine Schutzbrille bei der Verwendung von Schneidwerkzeugen und haben ausreichende Lüftung beim Löten. Wenn Sie noch nicht sind komfortabel Löten kleinen oberflächenmontierbaren Komponenten nicht FRET ich Links in der Referenz, die Ihnen helfen ein Löten Champion in kürzester Zeit zu werden gebucht.
Schritt 1: Zunächst müssen Sie einen Arduino



Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!


Arduino? Was genau ist Arduino?

Arduino ist eine Open Source Mikrocontroller- Wesentlichen ist es ein kleiner Computer mit einem einfach zu plattformübergreifende Programmiersprache. Es ermöglicht Ihnen, interaktive Objekte basierend auf sensorischen Input zu erstellen (Physical Computing). Sie können es verwenden, um etwas Einfaches zu tun wie ein LED-verblassen zu machen oder ein Servo bewegen, wenn Sie einen Knopf drücken oder haben sie etwas sehr Komplexes mag steuern einen Roboter durch die Verarbeitung von Sensoreingängen, senden Sie die Eingänge an einen Computer über ein drahtloses Netzwerk und senden Befehle zurück an den Roboter. Die Anwendungen sind eigentlich nur durch Ihre Fantasie begrenzt und es gibt Tausende von Beispielen für coole Projekte auf der ganzen Web. Es gibt mehrere Bücher über Arduino und seine Fähigkeiten, und ich habe ein paar in der Referenz aufgeführt.

Welche Arduino zu benutzen?

Es gibt mehrere Varianten des Arduino-Controller zur Verfügung, so die man verwenden Sie? Es hängt von Ihrer Anwendung. Einige haben mehr Eingangs-Pins sind als andere, wenn Sie eine Menge von Sensoreingänge benötigen. Für die Zwecke dieser instructable Sie wirklich verwenden Sie Arduino du als der präsentierten Informationen gilt für die meisten jede Version. Hier ist eine Tabelle, die die meisten der derzeitigen Schwankungen zeigt Available
https://spreadsheets.google.com/ccc?key=0AsCUiP6WbJIvcG8xalA3QVdmb3JVT0ptWE9VNC02WEE&hl=en#gid=0

Wenn Sie vorhaben, ein Arduino Uno oder Mega oder Arduino, die in USB gebaut hat verwenden, dann können Sie auf der Begleit-Abschnitt überspringen.

Der Aufbau einer Servopension

Da mein Fokus liegt vor allem auf Kostüm Gebäude Ich beschloss, die Sparkfun Arduino Pro Mini zu verwenden und dann eine kompakte Servoanwendungsplatine für die es, mehrere Servoausgänge, Analogeingänge und Digitalausgänge hat zu bauen. Ich habe auch eine Fassung für ein Adafruit Xbee Funkadapter sowie eine Ladeschaltung für eine einzelne Zelle LiPo-Akku, um die Steuerung zu betreiben.

Die Gründe, Ich mag den Pro Mini sind die sehr kleinen Formfaktor, niedrigen Kosten und niedrigem Stromverbrauch. Es arbeitet auf 3,3 V, was bedeutet, sie kann von einer einzigen Lipo-Zelle mit Strom versorgt werden und das macht es einfach, wenn Anschluss von Sensoren, die auf 3,3 V laufen.

Die neueste Version Servoplatine verfügt über acht Servoausgänge, vier digitale Ausgänge und sechs analoge Eingänge. Die Servoausgänge sind ebenfalls digital outputs- sie einfach konfiguriert sind, um es wirklich einfach, Hobby Servos anschließen. Die frühere Version auf den Fotos gesehen hat sechs Servoausgänge. Jeder Servoausgang hat drei Zentrierstifte- Boden, Leistungs- und Signal. Die analogen Eingänge sind so konfiguriert, denselben Weg-jeder Eingang hat drei Zentrierstifte- Boden, Leistungs- und Signal. Diese Konfiguration macht es super einfach zu einzelnen Sensoren zu verbinden. Das Board misst 1.75 "x 2.30" so ist es ziemlich klein.

Das Board verfügt über einen Schaltkreis zum Laden der LiPo-Zelle, die Befugnisse der Steuerung. Es gibt einen Mini-USB-Anschluss für 5V Eingangsleistung. Schließen Sie einfach die Batterie und dann in einem USB-Kabel und die Batterie wird automatisch aufgeladen. Es gibt eine Lade Blink- die LED leuchtet, wenn der Akku geladen wird und dann wird es automatisch ab, wenn der Akku vollständig geladen ist.

Der Mini-USB-Port auch Stromversorgung der Steuerung, auch ohne eine Batterie angeschlossen. Der Mini-USB-Anschluss wird nur als Energiequelle Stecker während des Ladevorgangs oder während der Zeiten, in denen ein LiPo-Akku ist nicht Available gibt es keine Datenübertragung mit dem Mini-USB-Anschluss und Sie werden von der Menge an Energie einen USB-Anschluss kann begrenzt.

Code wird an die Steuerung über ein USB-zu-Seriell-Adapter hochgeladen (dazu später mehr.) Dieser Adapter kann auch die Steuerung über USB Power, ohne die Notwendigkeit, um die Batterie zu verbinden. Dies kommt in wirklich praktisch, wenn Sie testen Code und Sie den Controller ohne den LiPo-Akku verbinden mit Strom versorgen möchten.

Ich bin die alle notwendigen EAGLE-Dateien, damit die Menschen können das Design, um ihre eigenen Bedürfnisse zu modifizieren.

EAGLE kann heruntergeladen werden hier- http://www.cadsoftusa.com/
Schritt 2: Erstellen der Controller



Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Alle 10 Artikel anzeigen

Werkzeuge und Materialien

Löten Eisen- Eine gute Qualität Lötkolben ist ein Muss. Ich vor ein paar Jahren erhalten eine Aoyue 2900 Lötstation für Weihnachten und es war großartig. Sie glauben nicht, den Unterschied, wenn Sie mit einem guten Lötkolben starten.
http://sra-solder.com/product.php/6363/22

Ich benutze auch ein kleines Trinkgeld für das Löten kleine Oberflächenmontage Komponenten-
http://sra-solder.com/product.php/6397/0

Drahtschneider / Draht Strippers- Kleine bündig Schneider sind die besten. Wenn Sie Abisolierzange oder Messer nicht haben, dann werden diese Arbeit gut
http://www.adafruit.com/index.php?main_page=product_info&cPath=8&products_id=152
http://www.adafruit.com/index.php?main_page=product_info&cPath=8&products_id=147

Tweezers- Holen Sie einige kleine Pinzette mit Oberflächenmontage-Komponenten arbeiten. Hier ist eine kostengünstige Einstellung http://sra-solder.com/product.php/6409/79

Magnifiers- In der Lage zu sehen, was Sie gerade arbeiten macht einen großen Unterschied.
http://www.adafruit.com/index.php?main_page=product_info&cPath=8&products_id=291

Multimeter- meisten jeder Multimeter funktioniert. Sie brauchen nicht zu groß $$ € zu verbringen. Ich persönlich besitze eine Wavetek Meterman 16XL und es ist toll. Wenn Sie nicht bereits ein Multimeter und sind wirklich in Hobby Elektronik dann meter wird wahrscheinlich alles, was Sie wollen-tun konnte,
http://www.adafruit.com/index.php?main_page=product_info&cPath=8&products_id=308

Servoplatine PCB-
http://batchpcb.com/index.php/Products/47581

Arduino Pro Mini http://www.sparkfun.com/products/9220

USB Mini-B Stecker- http://www.sparkfun.com/products/587

Kondensatoren- 2 ea 1210 Paket 1uF SMD-Keramik-Kondensatoren
http://us.element-14.com/kemet/c1210x105k5ractu/capacitor-ceramic-1uf-50v-x7r-1210/dp/94M5711

Widerstands- 1ea 1206 Paket 1K Ohm SMD-Widerstand
http://us.element-14.com/welwyn/wcr1206-1k0fi/resistor-thick-film-1kohm-250mw/dp/98K2656

LED- 1 Stück 1206-Gehäuse SMD LED
http://us.element-14.com/vcc-visual-communications-company/vaol-s12rp4/led-2x1-5mm-red-133mcd-624nm/dp/27R0088

JST Steckverbinder- 1 Stück
http://www.sparkfun.com/products/8612

MAX1555 IC- 1 Stück
http://www.sparkfun.com/products/674
http://us.element-14.com/maxim-integrated-products/max1555ezk-t/ic-battery-charger-li-ion-340ma/dp/59J2761?Ntt=MAX1555

Gerade brechen Kopfstifte - 2ea 40 polige Stiftleiste
Diese in wirklich praktisch, so ist es immer gut, um Extras zur Hand haben,
http://www.sparkfun.com/products/116

Female Pause weg Kopfstifte, 2 ea 40 Lochreihe
Diese sind auch super praktisch um sich zu haben
http://www.sparkfun.com/products/115

Einzelzelle LiPo batterie 1ea (Sie jede Kapazität Sie verwenden können.)
http://www.sparkfun.com/products/339

USB Mini-B Kabel- 1 Stück
Chancen sind Sie bereits eine haben, aber wenn Sie nicht hier sind Sie Go-
http://www.sparkfun.com/products/598

Montage der Servoplatine

Das erste, was zu tun ist, beim Aufbau der Ladeschaltung. Ich in der Regel beginnen mit den kleinsten Komponenten zuerst. Ich habe die einfachste Möglichkeit, SMD-Bauteile löten gefunden wird, um ein klein wenig Lot auf Ihrer Lötspitze zu bekommen, und berühren Sie es, um eine der Komponente Pads auf der Leiterplatte. Halten Sie dann die Komponente in Ort mit einer Pinzette und erwärmen das Pad und Komponenten-pin- dies ermöglicht es Ihnen, die an der Platte befestigt ist, so dass Sie seine Ausrichtung für den Rest der Pads überprüfen Teil zu bekommen. Dann einfach verlöten jede der verbleibenden Flächen. Es gibt eine große Reihe von SMD-Löten Tutorials hier- http://www.sparkfun.com/tutorials/36

Beginnen Sie mit dem Löten auf der IC MAX1555 (mit der Bezeichnung U1) -einem kann nur auf einem Weg zu gehen. Als nächstes kommt die LED- stellen Sie sicher, die Polarität zu überprüfen, wie es auf der Leiterplatte markiert (die LED-Kathode mit einem Ende der R1 verbunden ist.) Dann löten Widerstand R1 durch die Kondensatoren C1 und C2, gefolgt. Diese können entweder eingelötet werden. Als nächstes kommt die Mini-USB-Stecker- dieses ist ein bisschen schwierig, wie die Stifte knapp unterhalb des Verbinders positioniert. Löten Sie nun auf der JST-Stecker. Achten Sie darauf, überprüfen Sie Ihre Löten Arbeit für diese Anschlüsse, da sie ein gutes Stück von mechanischer Belastung zu erhalten.

Testen Sie nun Ihre Ladeschaltung. Schließen Sie ein USB-Kabel und prüfen Sie die Spannung an der Batterie JST-Stecker. Es sollte über 4.2-4.3V lesen. Verbinden Sie nun den LiPo-Akku. Wenn alles in Ordnung ist die kleine LED schaltet sich unter Angabe der Akku geladen wird. Die Batterie abklemmen.

Löten Sie nun auf die Stifte, um den Pro Mini Platte zu verbinden. Dies wird durch Löten auf die Pause entfernt geraden Kopfstifte getan. Legen Sie zuerst die langen Stiftenden in die Leiterplatte, über das Brett drehen und löten sie an ihrem Platz. Überprüfen Sie Ihre Lötstellen. Jetzt umdrehen das Brett und legen Sie den Pro Mini Verpflegung im Hause auf der Oberseite der freiliegenden Stifte und löten Sie die Stifte an Ort und Stelle. Weiter die restlichen Zylinderstifte Lot in der digitalen Out-Positionen und der 3,3 V-Anschluss an der Unterseite der Platine einrasten.

In den Vorstand Lot in Platz beenden alle Buchsenleisten. Der beste Weg, die ich gefunden habe, um die Buchsenleisten geschnitten ist, um einen Stift an der Sie einen Schneid möchten entfernen Sie einfach reißen den Stift aus der Unterseite mit einer Zange. Dann nehmen Sie Drahtschneider und schneiden durch die Öffnung durch den Stift nach links. Nun nehmen Sie eine Datei (oder Sandpapier) und glätten die Schnittkante.

Stellen Sie sicher, Ihr Board mit Strom versorgt wird durch Einstecken eines USB-Kabels in den Mini-USB-Anschluss auf der Controller-Platine. Die rote LED auf der Arduino Pro Mini sollte aufleuchten.

Das ist it- Ihr Controller ist bereit zu gehen!
Schritt 3: Erste Schritte



Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Um Code in Ihre Arduino Servoplatine laden benötigen Sie ein USB-Seriell-Adapter. Ich benutze den Sparkfun FTDI Basic-3.3V Ausbruch. Sie können auch den Adafruit FTDI Freund (stellen Sie sicher, um es auf 3,3 V eingestellt.) Entweder Adapter funktioniert super (Sie haben, einen Verbinder, um den Boden des Sparkfun löten Adapter- Sie kann entweder gerade oder 90 Grad-Stifte verwenden. )

Ich mag diese Boards, weil Sie sehen können, die LEDs leuchten, wenn sie die Übertragung sind. Sie müssen auch sicherstellen, dass Sie die neusten FTDI-Treiber auf Ihrem Computer installiert haben (Sie können die aktuellsten Treiber auf den Produkt Webseiten zu erhalten.)

Sparkfun FTDI grundlegender Ausbruch 3.3V
http://www.sparkfun.com/products/10009

Adafruit FTDI Freund
http://www.adafruit.com/index.php?main_page=product_info&cPath=18&products_id=284

Stecken Sie einfach den FTDI grundlegender Ausbruch in die Programmierbuchse auf der Anschaltbaugruppe und schließen Sie es an einen Computer über ein USB-Mini-B-Kabel. Achten Sie darauf, Line-Up der GRN und BLK-Indikatoren.

Wenn Sie einen Arduino sind mit in USB gebaut dann brauchen Sie nicht ein USB-Seriell-Adapter- es in die Arduino-Board gebaut. Schließen Sie ihn einfach an einen Computer über ein USB-Kabel, und Sie sind gut zu gehen.

Programmierumgebung

Jetzt müssen Sie die Arduino-Software, die sich hier befindet herunterladen: http://arduino.cc/en/Main/Software

Zum Zeitpunkt des Schreibens dieses Artikels Ich bin mit Arduino 0018. Wenn Sie verwenden die neueren Arduino Uno oder Mega2560 dann sollten Sie die neueste Version (0021 in dieser Zeit) als die Uno verwenden möchten und Mega2560 verwenden eine andere Art von USB auf serielle Verbindung dass nicht von früheren Versionen unterstützt.

Ich empfehle Ihnen außerdem das Lesen der Arduino-Umgebung Führungs hier: http://arduino.cc/en/Guide/Environment

Der Code Sie verwenden, hat mehrere Teile:

1. Programmbeschreibung / Kommentare-
Dies ist, wo Sie sagen, was das Programm macht

2. Variable Erklärung Abschnitt-
Hier können Sie Eingangs- / Ausgangsanschlüsse usw. zuweisen

3. Setup-Abschnitt-
Hier können Sie Pins als Ein- oder Ausgänge etc. eingestellt

4. Loop-Abschnitt-
Dies ist das Programm, das über die Bedingungen für die Variablen und Abschnitte der Basis-Setup ausgeführt wird.

Wenn Ihr Programm läuft es zuerst Ihre Variablen zu definieren, führen Sie das Setup-Abschnitt einmal und dann immer und immer führen Sie den Schleifenabschnitt.

Also, was Sie tun, ist offen das Arduino-Software, fügen Sie (oder schreiben) Code (eine so genannte Skizze), überprüfen Sie (kompilieren) Code, schließen Sie Ihr Arduino zu Ihrem Computer, wählen Sie die USB / serielle Verbindung, wählen Sie die Art des Arduino Sie bist dann mit Ihrem Code auf die Arduino hochladen.

Hier ist die Verarbeitung

1. Öffnen Sie Arduino Fenster und fügen Sie / Schreib-Code
Öffnen Sie einfach die Arduino-Programm und das Codebeispiel, die Sie in dem Fenster verwenden möchten und fügen Sie ihn (oder schreib Code.)

2. Verify-
Hit the überprüfen Schaltfläche, um den Code zu kompilieren. Es wird Sie informieren, ob es irgendwelche Fehler mit Ihrem Code.

3. Schließen Board-
Schließen Sie das Servobrett mit der USB-Seriell-Adapter- wenn Sie einen Arduino mit in USB gebaut dann einfach den Arduino direkt in Ihrem Computer auf Ihren Computer.

4. Wählen Sie Anschluss-
Dies teilt dem USB-Seriell-Adapter, der seriellen Schnittstelle Sie verwenden wollen. Die eine, um zu wählen beginnt /dev/tty.usbserial markiert, so aus dem Hauptmenü gehen Sie auf Extras> Serial Port> /dev/tty.usbserial- (Insert-Port-Name hier)

5. Wählen Sie Board-
Das sagt dem Programm, das Arduino Board-Version Sie verwenden. Aus dem Hauptmenü gehen Sie auf Extras> Board> Arduino Pro oder Pro Mini (3,3 V, 8 MHz) w / ATmega328, wenn Sie mit den Pro Mini Servopension oder wählen Sie das richtige Modell Arduino.

6. Upload Code
Schlagen Sie den Upload-Button, um den Code in Ihre Arduino senden.

Das ist es!

Schritt 4: Erstellen Verbindungen- Motoren, LEDs und Transistoren



Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Alle 8 Artikel anzeigen

Ein- und Ausgängen

Jetzt müssen wir ein paar Geräte, wie zB Servos, Sensoren und LEDs, um unsere Controller. Der Controller verfügt über Eingänge und Ausgänge. Dinge wie Sensoren und Schalter sind Eingabegeräte, während Servos, LEDs und Motoren sind Ausgabegeräte. Die Eingänge und Ausgänge sind sowohl analoge als auch digital-ein digitaler Eingang wie ein Schalter, so dass es entweder an oder aus. Analogeingänge werden variablen es ist eher wie ein Dimmer, der Ihnen einen Wertebereich.

Digitalausgänge werden ähnlich- wenn der Reglerausgang Pin HOCH gesetzt ist, dann ist es auf. Wenn es niedrig eingestellt ist, dann ist es aus. Das ist großartig, wenn Sie an einem Motor oder LED schalten möchten. Wenn Sie die Helligkeit einer LED einen Servomotor bewegen dann ändern oder wollen Sie, um die Reglerausgang Pin ein analoges Ausgangs möchten. Dies wird mit PWM getan (Pulsweitenmodulation). PWM ermöglicht einfach den Controller zu fälschen einen analogen Spannungsausgang, indem Sie den Ausgangspin HOCH und dann Einstellen des Ausgangs-Pin LOW innerhalb weniger Mikrosekunden oder Millisekunden voneinander. Wenn Sie den Stift HOCH für die gleiche Zeitdauer, Puls Sie pulsieren es LOW Sie eine durchschnittliche Spannung von der Hälfte der Gesamtspannung erhalten würden, so dass die Ausgangsstift würde Ihnen statt 3.3V 1.6V. Die Zeitspanne, die der Stift hoch bleibt heißt Impulsbreite. Das Verhältnis der Zeit für den Stift von LOW nach HIGH auf LOW gehen wird als Einschaltdauer. Wenn man die Menge an Zeit zu verkürzen der Stift hoch bleibt relativ zu der Menge an Zeit, bleibt LOW ist die Ausgangsstift Spannung effektiv zu senken. Es klingt wirklich komplizierter als es ist aber das wird wirklich praktisch, später kommen in auf, wenn Sie machen LEDs dimmen oder einen Servo verschieben möchten. Zum Glück die meisten dieser komplexen Zeug ist für Sie in den Arduino Code-Bibliotheken durchgeführt, aber es ist immer noch sehr gut zu wissen.

Sensoren

Es gibt alle Arten von Sensoren, Biegesensoren, Kraftempfindliche Widerstände, Beschleunigungssensoren, Potentiometer, Joysticks usw.

Diese analogen Sensoren ändern ihre Ausgangsspannung, je nachdem wie man sie benutzt. In den Beispielen werden wir Knopfschalter verwenden, um die Dinge ein-und ausschalten, und wir werden Joysticks (Potentiometer), Biegesensoren und Beschleunigungssensoren verwenden, um Servos bewegen.

Beim Entwurf eines Animatronic-System für Kostümierung ich versuche, den Sensortyp mit einem bestimmten Körperbewegung übereinstimmen. Überlegen Sie, wie die Person, die das Tragen der Tracht geht, es zu benutzen. Biegesensoren sind groß, wenn Sie eine LED-dim oder Servo Umzug durch Biegen Sie Ihre Finger machen wollen. Für noch mehr Kontrolle kann ich einen kleinen Joystick auf der Fingerspitze zu platzieren und verwenden Sie diese, um eine Servo-Zug zu machen. Für einen Kopf-Tracking-System, die Servos folgen Sie den Kopf Bewegung ich einen Beschleunigungsmesser (von Wii Nunchuck) und ich verwende den Fingerspitzen schaltet in den Sound-Effekte auslösen lässt. Sie werden, wie diese Arbeit in den Beispielen zu sehen.

Sparkfun hat eine gute Größe momentaner Druckknopf-Schalter, Steckbrett ist freundlich-
http://www.sparkfun.com/products/9190
Hier ist die kleinere Version-
http://www.sparkfun.com/products/97

Alle Sensoren werden wir verwenden, sind an den Arduino Eingangspins verbunden ist. Ein Potentiometer ist eine Vorrichtung, die üblicherweise in einer Anwendung verwendet werden, wie ein Stereo-Volumen noppen- es ist eine Art von variablen Widerstand. Wenn Sie liefern das Potentiometer mit 3,3 V, wenn Sie den Regler drehen die Ausgangsspannung von 0 bis 3,3 V liegen. Ein Joystick einfach zwei Potentiometer in einem gemeinsamen Gehäuse- eine für die X-Achse und eine für die Y-Achse.

Sparkfun hat ein 10K Potentiometertafel
http://www.sparkfun.com/products/9939

Sie haben auch ein paar kleine joysticks-
http://www.sparkfun.com/products/9032
http://www.sparkfun.com/products/9426

Biegesensor ist ein Widerstand, dessen Widerstandswert ändert sich entsprechend, wie viel Sie es zu biegen. Durch Hinzufügen eines weiteren Widerstandes und die Schaffung eines Spannungsteilers, können wir die Ausgangsspannung der Biegesensor ändern, den Grad der Biegung entspricht. Der einzige wirkliche Nachteil zu Sensoren zu biegen ist, dass sie nicht über die große Auswahl, dass ein Potentiometer hat.

Sparkfun verkauft ein Biegesensor hier-
http://www.sparkfun.com/products/8606

Beschleunigungsmesser arbeiten durch Erfassen einer Änderung der Beschleunigung und dann ihre Leistung in Bezug auf die Änderung der Beschleunigung zu verändern. Wenn Sie einen Beschleunigungsmesser kippen misst Beschleunigung aufgrund der je mehr Sie es desto größer ist die Änderung der Ausgangs kippen Sie Schwerkraft. Beschleunigungssensoren werden häufig in Video-Game-Controller und Handys verwendet.

Eine Wii Nunchuck hat einen 3-Achsen-Beschleunigungsmesser, Joystick und zwei Drucktasten für 20 €.

Motors

Servos

Hobby Servos-Kleingetriebemotoren, die eine Leiterplatte und Potentiometer, um ihre Drehung zu kontrollieren. Dies ermöglicht ihnen, in der Lage, auf eine exakte Position in Bezug auf Ihre Eingabe Sensorsignal zu bewegen. Die meisten Servos können fast 180 Grad bewegen, und einige können sogar mehrere Umdrehungen sowie kontinuierliche Drehung. Servos haben drei wires- Boden, Leistungs- und Signal. Der Signaldraht (in der Regel gelb oder weiß) mit dem Arduino Ausgangsstift verbunden ist. Die Leistungs- und Erdungsdrähte an eine separate Stromquelle angeschlossen ist, in der Regel im Bereich irgendwo von 4,8 V bis 6V. Der Grund für den Anschluss von Servos an eine eigene Stromversorgung ist, dass Motoren erzeugen ein gutes Stück von elektrischen Störungen, die Störungen oder ein Stottereffekt in ihrer Bewegung führen kann.

Wenn Sie eine Eingabesensor, der eine Eingangsspannung von 0-3.3V erzeugt haben das Arduino Ball analoge Spannung und weist sie einen Wert von 0 bis 1023 mit Hilfe eines Analog-Digital-Wandler (ADC). Der Code auf dem Arduino erzählt dann die Servo wie weit von der umgerechnete Wert auf der Basis zu bewegen. Also, wenn Ihr Sensor-Ausgangssignale 1.65V dann einen Messwert von 511 erhalten würde und Ihren Servo würde die Hälfte der Drehung zu bewegen. Viele Arduino Platten arbeiten auf 5V so der gleiche Sensor an derselben Position würde 2,5 V gelesen, und die Servo würde immer noch drehen halbem Weg. Eine kontinuierliche Drehservo würde in eine Richtung zu drehen, zu stoppen, wie der Sensor hat ein 1.65V Lesen und dann wechseln Sie die Richtung, wie Sie auf den Sensor, um die Eingangsspannung zu erhöhen verursacht.

Steuerung eines Servo durch PWM getan. Sie senden einen Impuls ein Sende an den Servo auf der Servosignalleitung alle 20 Millisekunden. Die Pulsbreite erzählt die Servo welche Position zu bewegen. Die meisten Servos arbeiten in einem 1 bis 2 Millisekunden-Pulsbereich so ein 1 ms Puls erzählt die Servo an die 0-Grad-Position zu bewegen, und eine 2-Millisekunden-Puls erzählt die Servo an die 180-Grad-Position zu bewegen. Jeder Puls zwischen 1 und 2 Millisekunden erzählt die Servo in eine Position, die in einem angemessenen Verhältnis zwischen 0 und 180 Grad bewegen.

Ich bekomme alle meine Servos hier-
http://www.servocity.com

Gleichstrommotoren

Anders als die meisten Servomotoren Gleichstrommotoren werden am besten verwendet, wenn Sie eine kontinuierliche Drehung brauchen, vor allem, wenn Sie hohe Drehzahlen soll. Da DC-Motoren kann eine ganze Menge Energie verbraucht sie sind verbunden mit dem Arduino Ausgangsstift mit einem Transistor oder ein PWM-Drehzahlregler.

Pololu verkauft eine Vielzahl von kleinen DC Motoren-
http://www.pololu.com/catalog/category/22

Schrittmotoren

Ich nicht normalerweise verwenden Schrittmotoren in meiner Animatronic-Projekte (zumindest noch nicht!), Aber ich fühlte sie erwähnenswert sind. Schrittmotoren erlauben eine genaue Positionierung sowie eine kontinuierliche Drehung und Drehzahlregelung. Der Nachteil davon ist, dass sie ein gutes Stück von elektrischer Energie und sie sind in der Regel deutlich größer und schwerer als ein Servo gleicher Nenndrehmoment. Kleine Schrittmotoren können aus alten Drucker und Scanner geborgen werden. Im Gegensatz zu Gleichstrommotoren Schrittmotoren haben mehrere Einzelspulen im Inneren, die müssen in der richtigen Reihenfolge, um zu bekommen, dass der Motor bewegen aktiviert werden. Das Arduino-Controller ist in der Lage, Schrittmotoren mit einem speziellen Treiber-Chip oder Transistor-Array, das in der Lage ist Erregen jedes einzelne Spule in dem Motor zu fahren. Für weitere Informationen über Stepper einen Blick im Referenzteil.

LEDs

Kleine LEDs sind ziemlich einfach, um zum Arduino- verbinden nur nicht vergessen, einen Widerstand zwischen dem Arduino Ausgangsstift und dem Widerstand Kathode zu verwenden, um den Stromfluss zu begrenzen. Sie können einen Widerstand auf entweder der Anode oder Kathode des LED- oder so funktionieren wird gestellt. Die meisten der kleinen 3,3 V LEDs wird ein Durchlassstrom von ca. 20 mA so einen Widerstand Wert haben rund 100 Ohms funktioniert ziemlich gut. Für eine genaue Widerstandswert-Berechnungen einen Blick hier-
http://led.linear1.org/1led.wiz

Für meine Iron Man Repulsor machte ich einen kleinen Durchmesser von 2 "LED-Platine, die 24 PLCC-2 LEDs hat. Sie können die nackten PCB hier- erhalten
http://www.batchpcb.com/index.php/Products/41872

Das Board verwendet 24 1206-Gehäuse SMD 100 Ohm resistors-
http://us.element-14.com/vishay-dale/crcw1206100rjnea/resistor-thick-film-100ohm-250mw/dp/59M6948

Ich häufig kaufen PLCC-2 superhellen LEDs auf eBay zu guten Preise-
http://stores.ebay.com/bestshop2008hk

Hohe Leistung Luxeon LEDs haben eine viel höhere Strombelastbarkeit und wird am besten mit irgendeiner Art von Konstantstromquelle, sie zu vertreiben arbeiten (es gibt mehrere instructables zu diesem Thema.) A 1 Watt Luxeon-LED ein Durchlassstrom von 350 mA, so dass Sie nicht schließen Sie es direkt an ein Arduino Ausgangspin. Ähnlich wie ein Gleichstrommotor müssen Sie es mit dem Ausgangsstift unter Verwendung eines Transistors zu verbinden.

Sparkfun verkauft Luxeon-LEDs und einen konstanten Strom Fahrer-
http://www.sparkfun.com/search/results?term=Luxeon&what=products
http://www.sparkfun.com/products/9642

Transistoren

Ein Transistor ist im Grunde nur ein elektronischer Schalter. Jedes Arduino Ausgangspin ist auf 40 mA Ausgangsstrom, so dass wir eine bestimmte Art von Transistor als NPN-Darlington-Transistor bekannt werde verwenden, um auf Hochstromeinrichtungen wenden. Diese Transistoren haben drei Zentrierstifte- den Kollektor, Emitter und der Basis. Die Basisstift mit dem Arduino Ausgangsstift mit einem 1K-Ohm Widerstand. Der Kollektorstift ist mit der Hochleistungsvorrichtung angebracht ist und der Emitter Stift ist mit Masse verbunden. Wenn der Arduino Ausgangspin HIGH gesetzt wird der Transistor eingeschaltet und ermöglicht Strom, um einen Stromkreis zu schließen.

Für Anwendungen, die keine Leistungsanforderungen über 1 Amp Ich entwarf einen kleinen Transistor Brett, das auf digitale Anschlussstifte 10-13 mit Flachbandkabel und zwei acht pin IDC-Steckverbinder verbindet. Dieser arbeitet mit vier SOT-23-Gehäuse SMD-Transistoren und vier 1206-Gehäuse 1k Ohm SMD-Widerstände. Das Board ist wirklich einfach zu löten.

Transistor Bord PCB-
http://batchpcb.com/index.php/Products/41936

SOT-23 NPN Darlington-Transistoren 4 EA-
http://us.element-14.com/fairchild-semiconductor/mmbt6427/bipolar-transistor-npn-40v/dp/58K1891

1206 SMD 1K Ohm Widerstände 4 EA-
http://us.element-14.com/yageo/rc1206jr-071kl/resistor-thick-film-1kohm-250mw/dp/68R0298

2x4 pin IDC connector 2ea-
http://www.surplusgizmos.com/8-Pin-2x4-IDC-Ribbon-Cable-COnnector_p_1879.html

Für Lasten bis zu 5A verwende ich eine Spitze 120-Transistors in der TO-220-Gehäuse. Diese sind für kleine Gleichstrommotoren und Servos. Verwenden Sie einen 1K-Ohm-Widerstand, um die Transistorbasis Pin an die Arduino Ausgangs-Pin zu verbinden.

Gewöhnlich kaufe ich TIP 120 Transistoren von meinem lokalen Radio Shack. Sie sind sehr leicht, auch online zu bekommen.

Energieversorgung

Um das Arduino Board und den Servos Servo Sie zwei getrennte Strom sources- einer einzigen Zelle LiPo-Akku für den Controller und eine kleine 4.8V- 6V Akkupack muss Power (4AA Batterien gut funktionieren) an die Macht Servos. Die Servoplatine verfügt über eine zusätzliche Buchse, die Energie liefert von der LiPo Zelle auf Niederspannungsgeräte wie LEDs anzutreiben.
Schritt 5: Lassen Sie uns jetzt etwas Spaß zu haben!



Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Beispiel 1- LEDs

Das ist wirklich einfach-wir gehen, um zwei LEDs blinken und eine andere LED-verblassen. Der Code wird immer und immer wieder, sobald Sie Leistung gelten laufen.

Es ist wirklich einfach zu Strecken wie dies einzurichten mit einem Steckbrett. Bei jedem Beispiel werde ich zeigen, wie man alles verkabeln entweder mit dem Servopension oder Arduino.

Kopieren und fügen Sie diese Skizze in Ihr Arduino Fenster

/ *
* Beispiel 1
* LED-Steuerung
* In diesem Beispiel werden zwei LEDs blinken und dann verblassen ein weiteres LED-
* Honus 2010
* Fading Code erstellt 1. November 2008 von David A. Mellis, geändert 17. Juni 2009 von Tom Igoe
* /

int ledPin1 = 13; // Steuerstift für LED
int ledPin2 = 12;
int ledPin3 = 11;

Leere setup () {
pinMode (ledPin1, OUTPUT); // Setzt die LED-Pin als Ausgang
pinMode (ledPin2, OUTPUT);
digital (ledPin1, LOW); // Setzt die LED Pin LOW (schaltet ihn aus)
digital (ledPin2, LOW);
}

Leere Schleife ()
{

digital (ledPin1, HIGH); // Setzt die LED-Pin HIGH (schaltet ihn ein)
Verzögerung (500); // Wartet 500 Millisekunden
digital (ledPin2, HIGH);
Verzögerung (500);
digital (ledPin1, LOW); // Setzt die LED Pin LOW (schaltet ihn aus)
Verzögerung (500);
digital (ledPin2, LOW);
Verzögerung (500);

// Von min verblassen in max in Schritten von 5 Punkten:
for (int fadeValue = 0; fadeValue <= 255; fadeValue + = 5) {
// Setzt den Wert (im Bereich von 0 bis 255):
analogWrite (ledPin3, fadeValue);
// 30 Millisekunden warten, um den Dimm-Effekt zu sehen
Verzögerung (40);
}

// Von max ausblenden, um in Schritten von 5 Punkten min:
for (int fadeValue = 255; fadeValue> = 0; fadeValue - = 5) {
// Setzt den Wert (im Bereich von 0 bis 255):
analogWrite (ledPin3, fadeValue);
// 30 Millisekunden warten, um den Dimm-Effekt zu sehen
Verzögerung (40);
}
Verzögerung (2000); // Zwei Sekunden warten
}

Schritt 6: Mit den Tasten



Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Beispiel 2- Mit einem Knopfeingabe

Das ist wie im vorherigen Beispiel, aber jetzt der Code nach Knopfdruck fährt nur einmal. Die Drucktaste wird ein Pull-Down-Widerstand so, wenn die Taste gedrückt wird der Eingangspin liest HOCH, sonst heißt es immer niedrig.

Kopieren und fügen Sie diese Skizze in Ihr Arduino Fenster

/ *
* Beispiel 2
* LED-Steuerung mit der Taste Eingang
* In diesem Beispiel werden zwei LEDs blinken und verblassen andere LED, wenn eine Taste gedrückt und wieder losgelassen
* Honus 2010
* Von Adafruit Wechselschalter Code, http://www.adafruit.com Geändert
* /

int ledPin1 = 13; // Steuerstift für LED
int ledPin2 = 12;
int ledPin3 = 11;

int buttonPin = 14; // Button ist mit 14 (analog in pin 0) pin
int val; // Variable zum Lesen des Stiftstatus
int Button; // Variable auf den letzten Knopf Zustand zu halten

Leere setup () {
pinMode (buttonPin, INPUT); // Die Schaltfläche Pin als Eingang eingestellt

Serial.begin (9600); // Der seriellen Kommunikation auf 9600 bps eingestellt
Button = digitalRead (buttonPin); // Den Ausgangszustand zu lesen

pinMode (ledPin1, OUTPUT); // Setzt die LED-Pin als Ausgang
pinMode (ledPin2, OUTPUT);

}

Leere Schleife () {
val = digitalRead (buttonPin); // Eingangswert lesen und speichern sie in val

if (val! = Button) {// die Taste Zustand hat sich geändert!
if (val == LOW) {// überprüfen, ob die Taste gedrückt wird
Serial.println ("gedrückt");

digital (ledPin1, HIGH); // Setzt die LED-Pin HIGH (schaltet ihn ein)
Verzögerung (500); // Wartet 500 Millisekunden
digital (ledPin2, HIGH);
Verzögerung (500);
digital (ledPin1, LOW); // Setzt die LED Pin LOW (schaltet ihn aus)
Verzögerung (500);
digital (ledPin2, LOW);
Verzögerung (500);

// Von min verblassen in max in Schritten von 5 Punkten:
for (int fadeValue = 0; fadeValue <= 255; fadeValue + = 5) {
// Setzt den Wert (im Bereich von 0 bis 255):
analogWrite (ledPin3, fadeValue);
// 30 Millisekunden warten, um den Dimm-Effekt zu sehen
Verzögerung (40);
}

// Von max ausblenden, um in Schritten von 5 Punkten min:
for (int fadeValue = 255; fadeValue> = 0; fadeValue - = 5) {
// Setzt den Wert (im Bereich von 0 bis 255):
analogWrite(ledPin3, fadeValue);
// wait for 30 milliseconds to see the dimming effect
Verzögerung (40);
}
} else { // the button is -not- pressed...
Serial.println("button released");
digitalWrite(ledPin1, LOW); // turn the LED off
digitalWrite(ledPin2, LOW);
}
}

buttonState = val; // save the new state in our variable
}
Step 7: Adding a servo

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Example 3- Adding a servo controlled by another button

Building on the previous example now we'll add a servo that is tied to a second push button. This uses the Arduino Servo library to control the servo position. By changing the value in parentheses after the servo1.write code you can control how far the servo moves.

Copy and paste this sketch into your Arduino window-

/ *
* Example 3
* This example will blink two LEDs and then fade another LED when button1 is pressed and released
* and a servo will move after button2 is pressed and released
* Honus 2010
* Modified from Adafruit alternating switch code, http://www.adafruit.com
* /

#include "Servo.h" // include the servo library

Servo servo1; // creates an instance of the servo object to control a servo

int servoPin1 = 9; // control pin for servo
int ledPin1 = 8; // control pin for LED
int ledPin2 = 7;
int ledPin3 = 11;

int buttonPin1 = 14; // button is connected to pin 14 (analog 0 pin)
int buttonPin2 = 15; // button is connected to pin 15 (analog 1 pin)
int val1; // variable for reading the pin status
int val2;
int buttonState1; // variable to hold the last button state
int buttonState2;

Leere setup () {

servo1.attach(servoPin1); // attaches the servo on pin 9 to the servo object
pinMode(buttonPin1, INPUT); // set the button pin as input
pinMode(buttonPin2, INPUT);

buttonState1 = digitalRead(buttonPin1); // read the initial state
buttonState2 = digitalRead(buttonPin2); // read the initial state

pinMode(ledPin1, OUTPUT); // sets the LED pin as output
pinMode(ledPin2, OUTPUT);

}

Leere Schleife () {
servo1.write(20);
val1 = digitalRead(buttonPin1); // read input value and store it in val

if (val1 != buttonState1) { // the button state has changed!
if (val1 == LOW) { // check if the button is pressed
Serial.println("button just pressed");

digitalWrite(ledPin1, HIGH); // sets the LED pin HIGH (turns it on)
delay(500); // wait 500 milliseconds
digitalWrite(ledPin2, HIGH);
delay(500);
digitalWrite(ledPin1, LOW); // sets the LED pin LOW (turns it off)
delay(500);
digitalWrite(ledPin2, LOW);
delay(500);

// fade in from min to max in increments of 5 points:
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
// sets the value (range from 0 to 255):
analogWrite(ledPin3, fadeValue);
// wait for 30 milliseconds to see the dimming effect
Verzögerung (40);
}

// fade out from max to min in increments of 5 points:
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
// sets the value (range from 0 to 255):
analogWrite(ledPin3, fadeValue);
// wait for 30 milliseconds to see the dimming effect
Verzögerung (40);
}
} else { // the button is -not- pressed...

digitalWrite(ledPin1, LOW); // turn off the LED
digitalWrite(ledPin2, LOW);
}
}

val2 = digitalRead(buttonPin2); // read input value and store it in val 2

if (val2 != buttonState2) { // the button state has changed!
if (val2 == LOW) { // check if the button is pressed

servo1.write(160); // rotate the servo to 160 degrees
delay(3000); // wait 3 seconds
servo1.write(20); // rotate to 20 degrees

} else { // the button is -not- pressed...

servo1.write(20);
}
}

buttonState1 = val1; // save the new state in our variable
buttonState2 = val2;
}
Step 8: Sound effects and bend sensors

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Example 4- adding sound and using a bend sensor to make an Iron Man hand repulsor

The bend sensor in this example is used as a trigger- once its output value reaches a certain level it causes the Arduino to run the specified code. You can change the threshold value to alter the point at which the sensor acts as a trigger. If you open the Arduino serial monitor window while the servo board is connected to your computer you can see when the bend sensor triggers. The bend sensor is set up using a voltage divider to provide an analog input value on input pin 1.

This example uses the Adafruit Wave Shield to provide sound effects. The instructions for building and setting up the Wave Shield can be found on the Wave Shield web page at http://www.ladyada.net/make/waveshield/

There are several code examples on the Wave Shield page for playing back audio files. The example I used is the play6_hc.pde example located at http://www.ladyada.net/make/waveshield/libraryhcplay6.html

Just download the sound file to a SD memory card and place it in your Wave Shield and you're good to go.

For the wiring schematic I did it two ways. The first version uses a small surface mount transistor board to activate the LED board and the Wave Shield. The second version uses two TIP 120 transistors instead- they are functionally identical. The big difference is the TIP 120 transistors can handle much larger current loads than the small surface mount transistors- but the TIP 120s take up a lot more space.

The transistors are needed because the Wave Shield needs a switch to tell it when to play the audio file (the transistor grounds the Wave Shield input pin when activated) and multiple LEDs use far more current than a single Arduino output pin can provide.

When the bend sensor is bent far enough the LEDs will fade, the sound file will play and then a servo will move. The servo would be used to open a forearm missile compartment.

[youtube]WfPqdOLakdA[/youtube]
For more Iron Man costuming fun check out the SIWDAT site-
http://www.siwdat.com/index.html

Copy and paste this sketch into your Arduino window-

/ *
* Example 4
* Bend Sensor/Wave shield
* This example uses a bend sensor as a trigger to fade a LED with sound effect
* using a Wave shield and then activate a servo
* Honus 2010
* Modified from Knock Sensor code created 25 Mar 2007 by David Cuartielles
* and modified 4 Sep 2010 by Tom Igoe
* /

#include "Servo.h" // include the servo library

Servo servo1; // creates an instance of the servo object to control a servo

// these constants won't change:
const int servoPin1 = 9; // control pin for servo
const int triggerSensor = 1; // the sensor is connected to analog pin 1
const int threshold = 400; // threshold value to decide when the sensor input triggers
const int ledPin = 11;
int soundPin1 = 10; // control pin for sound board

// these variables will change:
int sensorReading = 0; // variable to store the value read from the sensor pin
int ledState = LOW; // variable used to store the last LED status, to toggle the light

Leere setup () {
Serial.begin (9600); // use the serial port
servo1.attach(servoPin1); // attaches the servo on pin 9 to the servo object
pinMode(soundPin1, OUTPUT); // sets the sound pin as output
digitalWrite(soundPin1, LOW);

}

void loop() {
servo1.write(20); // move the servo to 20 degree position

// read the sensor and store it in the variable sensorReading:
sensorReading = analogRead(triggerSensor);

// if the sensor reading is greater than the threshold:
if (sensorReading >= threshold) {

digitalWrite(soundPin1, HIGH); // turn the sound on
delay(10); // wait ten milliseconds
digitalWrite(soundPin1, LOW); // turn the sound off

// fade in from min to max in increments of 5 points:
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
// sets the value (range from 0 to 255):
analogWrite(ledPin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
Verzögerung (40);
}

// fade out from max to min in increments of 5 points:
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
// sets the value (range from 0 to 255):
analogWrite(ledPin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
Verzögerung (40);
// send the string "trigger!" back to the computer, followed by newline
Serial.println("trigger!");
}

servo1.write(160); // move the servo to 160 degree position
delay(3000); // wait 3 seconds
servo1.write(20); // move the servo to 20 degree position
}

delay (3000); // three second delay to avoid overloading the serial port buffer
}

Step 9: Controlling servos

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!


Example 5- controlling a servo using analog input

These two examples show how easy it is to control servos using an analog input. You can use any analog input device you want- I'll use a 10k Ohm potentiometer for the example wiring diagram. As you turn the pot (and change its value) the servo moves proportionally.

The second code example simply extends the first example to control six servos from six inputs. This kind of control comes in really handy if you want to control several servos using bend sensors attached to a glove. This would work really well for controlling an animatronic mask.

/ *
* Example 5
* Servo Control
* This example uses a servos and analog input to move the servo according to the sensor input value
* Honus 2010
* /

#include "Servo.h" // include the servo library

Servo servo1; // creates an instance of the servo object to control a servo

int analogPin = 0; // the analog pin that the sensor is on
int analogValue = 0; // the value returned from the analog sensor

int servoPin = 4; // Control pin for servo motor
Leere setup () {
servo1.attach(servoPin); // attaches the servo on pin 9 to the servo object
}

Leere Schleife ()
{
analogValue = analogRead(analogPin); // read the analog input (value between 0 and 1023)
analogValue = map(analogValue, 0, 1023, 0, 179); // map the analog value (0 - 1023) to the angle of the servo (0 - 179)
servo1.write(analogValue); // write the new mapped analog value to set the position of the servo
delay(15); // waits for the servo to get there
}

Example 5a- Controlling 6 servos using multiple inputs

/ *
* Example 5a
* Servo Control6
* This example uses 6 servos and analog inputs to move the servos according to the sensor input values
* Honus 2010
* /

#include // include the servo library

Servo servoMotor1; // creates an instance of the servo object to control a servo
Servo servoMotor2;
Servo servoMotor3;
Servo servoMotor4;
Servo servoMotor5;
Servo servoMotor6;

int analogPin1 = 0; // the analog pin that the sensor is on
int analogPin2 = 1;
int analogPin3 = 2;
int analogPin4 = 3;
int analogPin5 = 4;
int analogPin6 = 5;

int analogValue1 = 0; // the value returned from the analog sensor
int analogValue2 = 0;
int analogValue3 = 0;
int analogValue4 = 0;
int analogValue5 = 0;
int analogValue6 = 0;

int servoPin1 = 4; // Control pin for servo motor
int servoPin2 = 5;
int servoPin3 = 6;
int servoPin4 = 7;
int servoPin5 = 8;
int servoPin6 = 9;

Leere setup () {
servoMotor1.attach(servoPin1); // attaches the servo on pin 4 to the servo object
servoMotor2.attach(servoPin2); // attaches the servo on pin 5 to the servo object
servoMotor3.attach(servoPin3); // attaches the servo on pin 6 to the servo object
servoMotor4.attach(servoPin4); // attaches the servo on pin 7 to the servo object
servoMotor5.attach(servoPin5); // attaches the servo on pin 8 to the servo object
servoMotor6.attach(servoPin6); // attaches the servo on pin 9 to the servo object
}

Leere Schleife ()
{
analogValue1 = analogRead(analogPin1); // read the analog input (value between 0 and 1023)
analogValue1 = map(analogValue1, 0, 1023, 0, 179); // map the analog value (0 - 1023) to the angle of the servo (0 - 179)
servoMotor1.write(analogValue1); // write the new mapped analog value to set the position of the servo

analogValue2 = analogRead(analogPin2);
analogValue2 = map(analogValue2, 0, 1023, 0, 179);
servoMotor2.write(analogValue2);

analogValue3 = analogRead(analogPin3);
analogValue3 = map(analogValue3, 0, 1023, 0, 179);
servoMotor3.write(analogValue3);

analogValue4 = analogRead(analogPin4);
analogValue4 = map(analogValue4, 0, 1023, 0, 179);
servoMotor4.write(analogValue4);

analogValue5 = analogRead(analogPin5);
analogValue5 = map(analogValue5, 0, 1023, 0, 179);
servoMotor5.write(analogValue5);

analogValue6 = analogRead(analogPin6);
analogValue6 = map(analogValue6, 0, 1023, 0, 179);
servoMotor6.write(analogValue6);

delay(15); // waits for the servo to get there
}

Step 10: Nunchuck control

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Example 6- Using a Wii nunchuck as an input device

I wrote this bit of code back in 2007 to use a Wii nunchuck as an input device for an animatronic Predator cannon (see example 7.) The Wii nunchuck communicates to an Arduino over four wires (power, ground, data and clock) using an I²C interface (Inter-Integrated Circuit aka two-wire interface or TWI.)

The Wii nunchuck has a three axis accelerometer, joystick and two push buttons- for € 20 it's an awesome input device for Arduino projects. The code presented here is a further modification of the code by Tod Kurt that was presented in his Bionic Arduino class- I simply extended it to control everything but the accelerometer Z axis, which I found I rarely used.

Using this code you can control four servos using the accelerometer and joystick functions and use the two push buttons to turn on LEDs (or transistors or even run a bit of code.)

/ *
* Example 6
* Nunchuck control for four servos and two button inputs
* Honus 2007
* This allows the use of a Wii nunchuck as an input device and is modified/extended from the original code
* by Tod E. Kurt and Windmeadow Labs
*2007 Tod E. Kurt, http://todbot.com/blog/
*The Wii Nunchuck reading code is taken from Windmeadow Labs, http://www.windmeadow.com/node/42
* /

#include "Wire.h"

int ledPin1 = 13; // Control pin for LED 1
int ledPin2 = 12; // Control pin for LED 2
int servoPin1 = 9; // Control pin for servo motor
int servoPin2 = 8; // Control pin for servo motor
int servoPin3 = 7; // Control pin for servo motor
int servoPin4 = 6; // Control pin for servo motor

int pulseWidth1 = 0; // Amount to pulse the servo 1
int pulseWidth2 = 0; // Amount to pulse the servo 2
int pulseWidth3 = 0; // Amount to pulse the servo 3
int pulseWidth4 = 0; // Amount to pulse the servo 4

int refreshTime = 20; // the time in millisecs needed in between pulses

long lastPulse1;
long lastPulse2;
long lastPulse3;
long lastPulse4;

int minPulse = 700; // minimum pulse width
int loop_cnt=0;

Leere setup ()
{
Serial.begin(19200);
pinMode(servoPin1, OUTPUT); // Set servo pin as an output pin
pinMode(servoPin2, OUTPUT); // Set servo pin as an output pin
pinMode(servoPin3, OUTPUT); // Set servo pin as an output pin
pinMode(servoPin4, OUTPUT); // Set servo pin as an output pin

pulseWidth1 = minPulse; // Set the motor position to the minimum
pulseWidth2 = minPulse; // Set the motor position to the minimum
pulseWidth3 = minPulse; // Set the motor position to the minimum
pulseWidth4 = minPulse; // Set the motor position to the minimum

nunchuck_init(); // send the initilization handshake
Serial.print("NunchuckServo ready\n");
}

Leere Schleife ()
{
checkNunchuck1();
updateServo1(); // update servo 1 position
checkNunchuck2();
updateServo2(); // update servo 2 position
checkNunchuck3();
updateServo3(); // update servo 3 position
checkNunchuck4();
updateServo4(); // update servo 4 position

if( nunchuck_zbutton() ) // light the LED if z button is pressed
digitalWrite(ledPin1, HIGH);
else
digitalWrite(ledPin1,LOW);

if( nunchuck_cbutton() ) // light the LED if c button is pressed
digitalWrite(ledPin2, HIGH);
else
digitalWrite(ledPin2,LOW);

delay(1); // this is here to give a known time per loop
}

void checkNunchuck1()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_accelx(); // x-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth1 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo1()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse1 >= refreshTime) {
digitalWrite(servoPin1, HIGH); // Turn the motor on
delayMicroseconds(pulseWidth1); // Length of the pulse sets the motor position
digitalWrite(servoPin1, LOW); // Turn the motor off
lastPulse1 = millis(); // save the time of the last pulse
}
}

void checkNunchuck2()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_accely(); // y-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth2 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo2()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse2 >= refreshTime) {
digitalWrite(servoPin2, HIGH); // Turn the motor on
delayMicroseconds(pulseWidth2); // Length of the pulse sets the motor position
digitalWrite(servoPin2, LOW); // Turn the motor off
lastPulse2 = millis(); // save the time of the last pulse
}
}

void checkNunchuck3()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_joyx(); // x-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth3 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo3()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse3 >= refreshTime) {
digitalWrite(servoPin3, HIGH); // Turn the motor on
delayMicroseconds(pulseWidth3); // Length of the pulse sets the motor position
digitalWrite(servoPin3, LOW); // Turn the motor off
lastPulse3 = millis(); // save the time of the last pulse
}
}

void checkNunchuck4()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_joyy(); // y-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth4 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo4()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse4 >= refreshTime) {
digitalWrite(servoPin4, HIGH); // Turn the motor on
delayMicroseconds(pulseWidth4); // Length of the pulse sets the motor position
digitalWrite(servoPin4, LOW); // Turn the motor off
lastPulse4 = millis(); // save the time of the last pulse
}
}

//
// Nunchuck functions
//

static uint8_t nunchuck_buf[6]; // array to store nunchuck data,

// initialize the I2C system, join the I2C bus,
// and tell the nunchuck we're talking to it
void nunchuck_init()
{
Wire.begin(); // join i2c bus as master
Wire.beginTransmission(0x52); // transmit to device 0x52
Wire.send(0x40); // sends memory address
Wire.send(0x00); // sends sent a zero.
Wire.endTransmission(); // stop transmitting
}

// Send a request for data to the nunchuck
// was "send_zero()"
void nunchuck_send_request()
{
Wire.beginTransmission(0x52); // transmit to device 0x52
Wire.send(0x00); // sends one byte
Wire.endTransmission(); // stop transmitting
}

// Receive data back from the nunchuck,
// returns 1 on successful read. returns 0 on failure
int nunchuck_get_data()
{
int cnt=0;
Wire.requestFrom (0x52, 6); // request data from nunchuck
while (Wire.available ()) {
// receive byte as an integer
nunchuck_buf[cnt] = nunchuk_decode_byte(Wire.receive());
cnt++;
}
nunchuck_send_request(); // send request for next data payload
// If we recieved the 6 bytes, then go print them
if (cnt >= 5) {
return 1; // success
}
return 0; //failure
}

// Print the input data we have recieved
// accel data is 10 bits long
// so we read 8 bits, then we have to add
// on the last 2 bits. That is why I
// multiply them by 2 * 2
void nunchuck_print_data()
{
static int i=0;
int joy_x_axis = nunchuck_buf[0];
int joy_y_axis = nunchuck_buf[1];
int accel_x_axis = nunchuck_buf[2]; // * 2 * 2;
int accel_y_axis = nunchuck_buf[3]; // * 2 * 2;
int accel_z_axis = nunchuck_buf[4]; // * 2 * 2;

int z_button = 0;
int c_button = 0;

// byte nunchuck_buf[5] contains bits for z and c buttons
// it also contains the least significant bits for the accelerometer data
// so we have to check each bit of byte outbuf[5]
if ((nunchuck_buf[5] >> 0) & 1)
z_button = 1;
if ((nunchuck_buf[5] >> 1) & 1)
c_button = 1;

if ((nunchuck_buf[5] >> 2) & 1)
accel_x_axis += 2;
if ((nunchuck_buf[5] >> 3) & 1)
accel_x_axis += 1;

if ((nunchuck_buf[5] >> 4) & 1)
accel_y_axis += 2;
if ((nunchuck_buf[5] >> 5) & 1)
accel_y_axis += 1;

if ((nunchuck_buf[5] >> 6) & 1)
accel_z_axis += 2;
if ((nunchuck_buf[5] >> 7) & 1)
accel_z_axis += 1;

Serial.print(i,DEC);
Serial.print("\t");

Serial.print("joy:");
Serial.print(joy_x_axis,DEC);
Serial.print(",");
Serial.print(joy_y_axis, DEC);
Serial.print(" \t");

Serial.print("acc:");
Serial.print(accel_x_axis, DEC);
Serial.print(",");
Serial.print(accel_y_axis, DEC);
Serial.print(",");
Serial.print(accel_z_axis, DEC);
Serial.print("\t");

Serial.print("but:");
Serial.print(z_button, DEC);
Serial.print(",");
Serial.print(c_button, DEC);

Serial.print("\r\n"); // newline
i++;
}

// Encode data to format that most wiimote drivers except
// only needed if you use one of the regular wiimote drivers
char nunchuk_decode_byte (char x)
{
x = (x ^ 0x17) + 0x17;
return x;
}

// returns zbutton state: 1=pressed, 0=notpressed
int nunchuck_zbutton()
{
return ((nunchuck_buf[5] >> 0) & 1) ? 0 : 1; // voodoo
}

// returns zbutton state: 1=pressed, 0=notpressed
int nunchuck_cbutton()
{
return ((nunchuck_buf[5] >> 1) & 1) ? 0 : 1; // voodoo
}

// returns value of x-axis joystick
int nunchuck_joyx()
{
return nunchuck_buf[0];
}

// returns value of y-axis joystick
int nunchuck_joyy()
{
return nunchuck_buf[1];
}

// returns value of x-axis accelerometer
int nunchuck_accelx()
{
return nunchuck_buf[2]; // FIXME: this leaves out 2-bits of the data
}

// returns value of y-axis accelerometer
int nunchuck_accely()
{
return nunchuck_buf[3]; // FIXME: this leaves out 2-bits of the data
}

// returns value of z-axis accelerometer
int nunchuck_accelz()
{
return nunchuck_buf[4]; // FIXME: this leaves out 2-bits of the data
}

Step 11: Predator cannon

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Alle 19 Artikel anzeigen
Example 7- Predator cannon

Using a modified Wii nunchuck board we can make a "head tracking" system to control an animatronic Predator cannon. This system was designed to look like the cannon mechanism in the first Predator movie.

The nunchuck board is removed from its case, the joystick is removed and the board is placed level in the top of the Predator Bio helmet. The wires are extended for the buttons so they can be used as fingertip buttons to activate the cannon and trigger the firing sequence.

To remove the circuit board from the Wii nunchuck case you'll need a tri-wing screwdriver-
http://www.play-asia.com/paOS-13-71-1e-49-en-70-1fe.html

The sound effect is handled just like the Iron Man repulsor in example 4 using the Adafruit Wave Shield. Since the Wave Shield code used can support six individual sounds you can add five other Predator sounds and activate them using fingertip switches- neat!

There is one servo that is geared 4:1 that raises the cannon arm- in the code you can see this as the servo rotating 180 degrees, thereby raising the cannon arm 45 degrees. The other two servos aim the cannon using the accelerometer inputs. There are transistors that turn on the aiming servos and laser sight when one button is pressed. If the aiming servos were always on then the cannon would rotate even when it was in the lowered position, so they need a way of being turned off when the cannon is lowered.

So push one one button and the cannon raises up, the aiming servos turn on and the laser sight turns on. Push the second button and the cannon fires- two transistors turn on the cannon LED and activate the firing sound. Three red LEDs can be used in place of the laser sight. The cannon LED can be anything from several small LEDs to a high power Luxeon LED. When using a high power Luxeon LED be sure to use a constant current driver to power it.

Servos can draw a fair bit of power so I use a TIP 120 transistor to turn on the aiming servos.

The prototype cannon mechanism was built using Delrin plastic scraps and timing belts and gears from old desktop printers and photocopiers I found in the trash. When I build the final version for the Predator costume it will probably be entirely gear driven to make it more compact and cleaner.

For Predator costuming info check out http://www.thehunterslair.com

Those individuals interested in obtaining a resin cannon casting should contact my friend Carl here- http://www.accurizedhunterparts.com/

Carl's work is absolutely brilliant- check out the photos below of the Predator backpack clay sculpt that he created for this project. That's a lot of clay! When contacting Carl please be patient as he's extremely busy and he has a large backlog of work.

Here's the code-

/ *
* Example 7
* Predator Cannon
* This uses a modified Wii nunchuck as a head tracking input device to control an animatronic Predator cannon
* Adafruit Wave shield is used for sound effects
* Honus 2007, updated 2010
* Wii nunchuck reading code modified/extended from nunchuck code by Tod E. Kurt and Windmeadow Labs
* 2007 Tod E. Kurt, http://todbot.com/blog/
* The Wii Nunchuck reading code is taken from Windmeadow Labs, http://www.windmeadow.com/node/42
* /

#include "Wire.h" // include the Wire library
#include "Servo.h" // include the servo library

Servo servo3; // creates an instance of the servo object to control a servo

int controlPin1 = 6; // Control pin for sound effects board using z button
int transistorPin1 = 13; // Control pin for LED using z button
int transistorPin2 = 12; // Control pin for laser sight using c button
int transistorPin3 = 11; // Control pin for servo 1 using c button
int transistorPin4 = 10; // Control pin for servo 2 using c button
int servoPin1 = 7; // Control pin for servo 1 using accelerometer x axis
int servoPin2 = 8; // Control pin for servo 2 using accelerometer y axis
int servoPin3 = 9; // control pin for arm servo

int pulseWidth1 = 0; // Amount to pulse the servo 1
int pulseWidth2 = 0; // Amount to pulse the servo 2

int refreshTime = 20; // the time in millisecs needed in between servo pulses
long lastPulse1;
long lastPulse2;

int minPulse = 700; // minimum servo pulse width
int loop_cnt=0;

boolean button_down = false;
unsigned long start;

Leere setup ()
{
Serial.begin(19200);

servo3.attach(servoPin3); // attaches the servo on pin 9 to the servo object

pinMode(controlPin1, OUTPUT); // Set control pin 1 as output
pinMode(transistorPin1, OUTPUT); // Set transistor pin 1 as output
pinMode(transistorPin2, OUTPUT); // Set transistor pin 2 as output
pinMode(transistorPin3, OUTPUT); // Set transistor pin 3 as output
pinMode(transistorPin4, OUTPUT); // Set transistor pin 4 as output
pinMode(servoPin1, OUTPUT); // Set servo pin 1 as output
pinMode(servoPin2, OUTPUT); // Set servo pin 2 as output

pulseWidth1 = minPulse; // Set the servo position to the minimum
pulseWidth2 = minPulse; // Set the servo position to the minimum

nunchuck_init(); // send the initilization handshake
Serial.print("NunchuckServo ready\n");
}

Leere Schleife ()
{
checkNunchuck1();
updateServo1(); // update servo 1 position
checkNunchuck2();
updateServo2(); // update servo 2 position

if( nunchuck_cbutton() ) {
digitalWrite(transistorPin2, HIGH); // turn on transistor pin 2 if c button is pressed
digitalWrite(transistorPin3, HIGH); // turn on transistor pin 3 if c button is pressed
digitalWrite(transistorPin4, HIGH); // turn on transistor pin 4 if c button is pressed

servo3.write(180);
}
else {
digitalWrite(transistorPin2, LOW);
digitalWrite(transistorPin3, LOW);
digitalWrite(transistorPin4, LOW);
servo3.write(0);
}

if ( nunchuck_zbutton() )
{
if (!button_down) // if button was just pressed do this
{
digitalWrite(controlPin1, HIGH);
button_down = true;
start = millis();
}
else if (millis() - start > 1200) // if timer has elapsed do this
{
digitalWrite(transistorPin1, HIGH);
}
}
else // if button is up do this
{
button_down = false;
digitalWrite(controlPin1, LOW);
digitalWrite(transistorPin1, LOW);
}

delay(1); // this is here to give a known time per loop
}

void checkNunchuck1()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_accelx(); // x-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth1 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo1()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse1 >= refreshTime) {
digitalWrite(servoPin1, HIGH); // Turn the servo on
delayMicroseconds(pulseWidth1); // Length of the pulse sets the servo position
digitalWrite(servoPin1, LOW); // Turn the servo off
lastPulse1 = millis(); // save the time of the last pulse
}
}

void checkNunchuck2()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_accely(); // y-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth2 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo2()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse2 >= refreshTime) {
digitalWrite(servoPin2, HIGH); // Turn the servo on
delayMicroseconds(pulseWidth2); // Length of the pulse sets the servo position
digitalWrite(servoPin2, LOW); // Turn the servo off
lastPulse2 = millis(); // save the time of the last pulse
}
}

//
// Nunchuck functions
//

static uint8_t nunchuck_buf[6]; // array to store nunchuck data,

// initialize the I2C system, join the I2C bus,
// and tell the nunchuck we're talking to it
void nunchuck_init()
{
Wire.begin(); // join i2c bus as master
Wire.beginTransmission(0x52); // transmit to device 0x52
Wire.send(0x40); // sends memory address
Wire.send(0x00); // sends sent a zero.
Wire.endTransmission(); // stop transmitting
}

// Send a request for data to the nunchuck
// was "send_zero()"
void nunchuck_send_request()
{
Wire.beginTransmission(0x52); // transmit to device 0x52
Wire.send(0x00); // sends one byte
Wire.endTransmission(); // stop transmitting
}

// Receive data back from the nunchuck,
// returns 1 on successful read. returns 0 on failure
int nunchuck_get_data()
{
int cnt=0;
Wire.requestFrom (0x52, 6); // request data from nunchuck
while (Wire.available ()) {
// receive byte as an integer
nunchuck_buf[cnt] = nunchuk_decode_byte(Wire.receive());
cnt++;
}
nunchuck_send_request(); // send request for next data payload
// If we recieved the 6 bytes, then go print them
if (cnt >= 5) {
return 1; // success
}
return 0; //failure
}

// Print the input data we have recieved
// accel data is 10 bits long
// so we read 8 bits, then we have to add
// on the last 2 bits. That is why I
// multiply them by 2 * 2
void nunchuck_print_data()
{
static int i=0;
int joy_x_axis = nunchuck_buf[0];
int joy_y_axis = nunchuck_buf[1];
int accel_x_axis = nunchuck_buf[2]; // * 2 * 2;
int accel_y_axis = nunchuck_buf[3]; // * 2 * 2;
int accel_z_axis = nunchuck_buf[4]; // * 2 * 2;

int z_button = 0;
int c_button = 0;

// byte nunchuck_buf[5] contains bits for z and c buttons
// it also contains the least significant bits for the accelerometer data
// so we have to check each bit of byte outbuf[5]
if ((nunchuck_buf[5] >> 0) & 1)
z_button = 1;
if ((nunchuck_buf[5] >> 1) & 1)
c_button = 1;

if ((nunchuck_buf[5] >> 2) & 1)
accel_x_axis += 2;
if ((nunchuck_buf[5] >> 3) & 1)
accel_x_axis += 1;

if ((nunchuck_buf[5] >> 4) & 1)
accel_y_axis += 2;
if ((nunchuck_buf[5] >> 5) & 1)
accel_y_axis += 1;

if ((nunchuck_buf[5] >> 6) & 1)
accel_z_axis += 2;
if ((nunchuck_buf[5] >> 7) & 1)
accel_z_axis += 1;

Serial.print(i,DEC);
Serial.print("\t");

Serial.print("joy:");
Serial.print(joy_x_axis,DEC);
Serial.print(",");
Serial.print(joy_y_axis, DEC);
Serial.print(" \t");

Serial.print("acc:");
Serial.print(accel_x_axis, DEC);
Serial.print(",");
Serial.print(accel_y_axis, DEC);
Serial.print(",");
Serial.print(accel_z_axis, DEC);
Serial.print("\t");

Serial.print("but:");
Serial.print(z_button, DEC);
Serial.print(",");
Serial.print(c_button, DEC);

Serial.print("\r\n"); // newline
i++;
}

// Encode data to format that most wiimote drivers except
// only needed if you use one of the regular wiimote drivers
char nunchuk_decode_byte (char x)
{
x = (x ^ 0x17) + 0x17;
return x;
}

// returns zbutton state: 1=pressed, 0=notpressed
int nunchuck_zbutton()
{
return ((nunchuck_buf[5] >> 0) & 1) ? 0 : 1; // voodoo
}

// returns zbutton state: 1=pressed, 0=notpressed
int nunchuck_cbutton()
{
return ((nunchuck_buf[5] >> 1) & 1) ? 0 : 1; // voodoo
}

// returns value of x-axis joystick
int nunchuck_joyx()
{
return nunchuck_buf[0];
}

// returns value of y-axis joystick
int nunchuck_joyy()
{
return nunchuck_buf[1];
}

// returns value of x-axis accelerometer
int nunchuck_accelx()
{
return nunchuck_buf[2]; // FIXME: this leaves out 2-bits of the data
}

// returns value of y-axis accelerometer
int nunchuck_accely()
{
return nunchuck_buf[3]; // FIXME: this leaves out 2-bits of the data
}

// returns value of z-axis accelerometer
int nunchuck_accelz()
{
return nunchuck_buf[4]; // FIXME: this leaves out 2-bits of the data
}
Step 12: War Machine cannon

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!
Example 8- War Machine cannon

You want to be the War Machine? This example is based on the Predator cannon but uses a motor connected to a transistor to spin the cannon barrels. When you push the fire button the motor turns on. There is a 1N4004 diode to prevent back voltage from the motor damaging the controller output pin.

A War Machine cannon is substantially larger than a Predator cannon and would require larger, more powerful servos so I have individual TIP 120 transistors shown on the wiring diagram.

For mounting the cannon Servocity sells pan/tilt mechanisms that would be perfect for this application-
http://www.servocity.com/html/spt200_pan___tilt_system.html

/ *
* Example 8
* Iron Man War Machine Cannon
* This uses a modified Wii nunchuck as a head tracking input device to control an animatronic Iron Man War Machine cannon
* Adafruit Wave shield is used for sound effects
* Honus 2010
* Wii nunchuck reading code modified/extended from nunchuck code by Tod E. Kurt and Windmeadow Labs
* 2007 Tod E. Kurt, http://todbot.com/blog/
* The Wii Nunchuck reading code is taken from Windmeadow Labs, http://www.windmeadow.com/node/42
* /

#include "Wire.h" // include the Wire library

int controlPin1 = 7; // Control pin for sound effects board using z button
int transistorPin1 = 13; // Control pin for cannon LED using z button
int transistorPin2 = 12; // Control pin for servo 1 using c button
int transistorPin3 = 11; // Control pin for servo 2 using c button
int transistorPin4 = 10; // Control pin for cannon motor using z button
int servoPin1 = 9; // Control pin for servo 1 using accelerometer x axis
int servoPin2 = 8; // Control pin for servo 2 using accelerometer y axis

int pulseWidth1 = 0; // Amount to pulse the servo 1
int pulseWidth2 = 0; // Amount to pulse the servo 2

int refreshTime = 20; // the time in millisecs needed in between servo pulses
long lastPulse1;
long lastPulse2;

int minPulse = 700; // minimum servo pulse width
int loop_cnt=0;

boolean button_down = false;
unsigned long start;

Leere setup ()
{
Serial.begin(19200);

pinMode(controlPin1, OUTPUT); // Set control pin 1 as output
pinMode(transistorPin1, OUTPUT); // Set transistor pin 1 as output
pinMode(transistorPin2, OUTPUT); // Set transistor pin 2 as output
pinMode(transistorPin3, OUTPUT); // Set transistor pin 3 as output
pinMode(transistorPin4, OUTPUT); // Set transistor pin 4 as output
pinMode(servoPin1, OUTPUT); // Set servo pin 1 as output
pinMode(servoPin2, OUTPUT); // Set servo pin 2 as output

pulseWidth1 = minPulse; // Set the servo position to the minimum
pulseWidth2 = minPulse; // Set the servo position to the minimum

nunchuck_init(); // send the initilization handshake
Serial.print("NunchuckServo ready\n");
}

Leere Schleife ()
{
checkNunchuck1();
updateServo1(); // update servo 1 position
checkNunchuck2();
updateServo2(); // update servo 2 position

if( nunchuck_cbutton() ) {
digitalWrite(transistorPin2, HIGH); // turn on transistor pin 2 if c button is pressed
digitalWrite(transistorPin3, HIGH); // turn on transistor pin 3 if c button is pressed
}
else {
digitalWrite(transistorPin2, LOW); // turn off transistor pin 2
digitalWrite(transistorPin3, LOW);
}

if ( nunchuck_zbutton() )
{
if (!button_down) // if button was just pressed do this
{
digitalWrite(controlPin1, HIGH); // turn on sound effect
button_down = true;
start = millis();
}
else if (millis() - start > 1200) // if timer has elapsed do this
{
digitalWrite(transistorPin1, HIGH); // turn on cannon LED
digitalWrite(transistorPin4, HIGH); // turn on cannon motor
}
}
else // if button is up do this
{
button_down = false;
digitalWrite(controlPin1, LOW); // turn off sound effect
digitalWrite(transistorPin1, LOW); // turn off cannon LED
digitalWrite(transistorPin4, LOW); // turn off cannon motor
}

delay(1); // this is here to give a known time per loop
}

void checkNunchuck1()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_accelx(); // x-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth1 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo1()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse1 >= refreshTime) {
digitalWrite(servoPin1, HIGH); // Turn the servo on
delayMicroseconds(pulseWidth1); // Length of the pulse sets the servo position
digitalWrite(servoPin1, LOW); // Turn the servo off
lastPulse1 = millis(); // save the time of the last pulse
}
}

void checkNunchuck2()
{
if( loop_cnt > 100 ) { // loop()s is every 1msec, this is every 100msec

nunchuck_get_data();
nunchuck_print_data();

float tilt = nunchuck_accely(); // y-axis, in this case ranges from ~70 - ~185
tilt = (tilt - 70) * 1.5; // convert to angle in degrees, roughly
pulseWidth2 = (tilt * 9) + minPulse; // convert angle to microseconds

loop_cnt = 0; // reset for
}
loop_cnt++;

}

// called every loop().
// uses global variables servoPin, pulsewidth, lastPulse, & refreshTime
void updateServo2()
{
// pulse the servo again if rhe refresh time (20 ms) have passed:
if (millis() - lastPulse2 >= refreshTime) {
digitalWrite(servoPin2, HIGH); // Turn the servo on
delayMicroseconds(pulseWidth2); // Length of the pulse sets the servo position
digitalWrite(servoPin2, LOW); // Turn the servo off
lastPulse2 = millis(); // save the time of the last pulse
}
}

//
// Nunchuck functions
//

static uint8_t nunchuck_buf[6]; // array to store nunchuck data,

// initialize the I2C system, join the I2C bus,
// and tell the nunchuck we're talking to it
void nunchuck_init()
{
Wire.begin(); // join i2c bus as master
Wire.beginTransmission(0x52); // transmit to device 0x52
Wire.send(0x40); // sends memory address
Wire.send(0x00); // sends sent a zero.
Wire.endTransmission(); // stop transmitting
}

// Send a request for data to the nunchuck
// was "send_zero()"
void nunchuck_send_request()
{
Wire.beginTransmission(0x52); // transmit to device 0x52
Wire.send(0x00); // sends one byte
Wire.endTransmission(); // stop transmitting
}

// Receive data back from the nunchuck,
// returns 1 on successful read. returns 0 on failure
int nunchuck_get_data()
{
int cnt=0;
Wire.requestFrom (0x52, 6); // request data from nunchuck
while (Wire.available ()) {
// receive byte as an integer
nunchuck_buf[cnt] = nunchuk_decode_byte(Wire.receive());
cnt++;
}
nunchuck_send_request(); // send request for next data payload
// If we recieved the 6 bytes, then go print them
if (cnt >= 5) {
return 1; // success
}
return 0; //failure
}

// Print the input data we have recieved
// accel data is 10 bits long
// so we read 8 bits, then we have to add
// on the last 2 bits. That is why I
// multiply them by 2 * 2
void nunchuck_print_data()
{
static int i=0;
int joy_x_axis = nunchuck_buf[0];
int joy_y_axis = nunchuck_buf[1];
int accel_x_axis = nunchuck_buf[2]; // * 2 * 2;
int accel_y_axis = nunchuck_buf[3]; // * 2 * 2;
int accel_z_axis = nunchuck_buf[4]; // * 2 * 2;

int z_button = 0;
int c_button = 0;

// byte nunchuck_buf[5] contains bits for z and c buttons
// it also contains the least significant bits for the accelerometer data
// so we have to check each bit of byte outbuf[5]
if ((nunchuck_buf[5] >> 0) & 1)
z_button = 1;
if ((nunchuck_buf[5] >> 1) & 1)
c_button = 1;

if ((nunchuck_buf[5] >> 2) & 1)
accel_x_axis += 2;
if ((nunchuck_buf[5] >> 3) & 1)
accel_x_axis += 1;

if ((nunchuck_buf[5] >> 4) & 1)
accel_y_axis += 2;
if ((nunchuck_buf[5] >> 5) & 1)
accel_y_axis += 1;

if ((nunchuck_buf[5] >> 6) & 1)
accel_z_axis += 2;
if ((nunchuck_buf[5] >> 7) & 1)
accel_z_axis += 1;

Serial.print(i,DEC);
Serial.print("\t");

Serial.print("joy:");
Serial.print(joy_x_axis,DEC);
Serial.print(",");
Serial.print(joy_y_axis, DEC);
Serial.print(" \t");

Serial.print("acc:");
Serial.print(accel_x_axis, DEC);
Serial.print(",");
Serial.print(accel_y_axis, DEC);
Serial.print(",");
Serial.print(accel_z_axis, DEC);
Serial.print("\t");

Serial.print("but:");
Serial.print(z_button, DEC);
Serial.print(",");
Serial.print(c_button, DEC);

Serial.print("\r\n"); // newline
i++;
}

// Encode data to format that most wiimote drivers except
// only needed if you use one of the regular wiimote drivers
char nunchuk_decode_byte (char x)
{
x = (x ^ 0x17) + 0x17;
return x;
}

// returns zbutton state: 1=pressed, 0=notpressed
int nunchuck_zbutton()
{
return ((nunchuck_buf[5] >> 0) & 1) ? 0 : 1; // voodoo
}

// returns zbutton state: 1=pressed, 0=notpressed
int nunchuck_cbutton()
{
return ((nunchuck_buf[5] >> 1) & 1) ? 0 : 1; // voodoo
}

// returns value of x-axis joystick
int nunchuck_joyx()
{
return nunchuck_buf[0];
}

// returns value of y-axis joystick
int nunchuck_joyy()
{
return nunchuck_buf[1];
}

// returns value of x-axis accelerometer
int nunchuck_accelx()
{
return nunchuck_buf[2]; // FIXME: this leaves out 2-bits of the data
}

// returns value of y-axis accelerometer
int nunchuck_accely()
{
return nunchuck_buf[3]; // FIXME: this leaves out 2-bits of the data
}

// returns value of z-axis accelerometer
int nunchuck_accelz()
{
return nunchuck_buf[4]; // FIXME: this leaves out 2-bits of the data
}
Step 13: Going wireless with XBee

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!

Arduino animatronics- machen Ihren fantastischen Kostümen mehr awesome!


Example 9- Wireless XBee radios

This allows you to use the Nunchuck control but does it by setting up one controller as a transmitter and another controller as the receiver. I use the Adafruit XBee wireless adapter because it's super easy to use and can work on both 3V and 5V so it's great for most any Arduino wireless project. The servo board is set up for point to point communication and the XBee adapter plugs directly into a socket at the top of the board. This setup would really well for controlling haunted house attractions.

You can get the XBee adapter and radios here-
http://www.adafruit.com/index.php?main_page=product_info&cPath=29&products_id=126

There is a complete XBee tutorial for building the XBee adapter and configuring it here-
http://www.ladyada.net/make/xbee/

Unlike the previous nuchuck control code, this code uses a new nunchuck library that cleans up the code considerably. It is called nunchuck_funcs.h
You can get it here-
http://todbot.com/blog/2008/02/18/wiichuck-wii-nunchuck-adapter-available/comment-page-3/

Simply place the nunchuck_funcs.h library into your Arduino libraries folder and you're good to go.

The wiring for this is exactly like the wiring for example 6 except the nunchuck is connected to the transmitter and the servos and LEDs are connected to the receiver.

Note- you cannot connect the USB to serial adapter while the XBee adapter is plugged into its socket as they use the same data transmission lines. You must program the controller first and then plug in the XBee adapter. If you need to be able to monitor the serial port while using the XBee you can use a couple of wires to connect the XBee RX and TX to digital out pins 2 and 3 as shown in the Adafruit point-to-point tutorial.

Here's the code for the transmitter-

/ *
* Example 9a
* Nunchuck XBee transmitter
* This code uses the nunchuck functions library and an XBee radio (w/ Adafruit XBee adapter)
* to make a Wii nunchuck a wireless input device
* Honus 2010
* Nunchuck functions library from Tod E. Kurt, http://todbot.com/blog
* /

#include "Wire.h" // include the Wire library
#include "nunchuck_funcs.h" // include the nunchuck functions library

int loop_cnt=0;

byte accx,accy,zbut,cbut,joyy,joyx;
int ledPin = 13;

Leere setup ()
{
Serial.begin (9600);
nunchuck_setpowerpins();
nunchuck_init(); // send the initilization handshake
pinMode(ledPin, OUTPUT);
}

Leere Schleife ()
{
digitalWrite(ledPin, HIGH); // set the LED on

if( loop_cnt > 100 ) { // every 100 msecs get new data
loop_cnt = 0;

nunchuck_get_data();

accx = nunchuck_accelx(); // ranges from approx 70 - 182
accy = nunchuck_accely(); // ranges from approx 65 - 173
zbut = nunchuck_zbutton();
cbut = nunchuck_cbutton();
joyx = nunchuck_joyx();
joyy = nunchuck_joyy();

Serial.print("joyx:");
Serial.print((byte)joyx,DEC);
Serial.print("joyy:");
Serial.print((byte)joyy,DEC);
Serial.print("accx:");
Serial.print((byte)accx,DEC);
Serial.print("accy:");
Serial.print((byte)accy,DEC);
Serial.print("\tzbut:");
Serial.print((byte)zbut,DEC);
Serial.print("\tcbut:");
Serial.println((byte)cbut,DEC);
}
loop_cnt++;
delay(1);
}

Here's the code for the receiver-

/ *
* Example 9b
* Nunchuck XBee receiver
* This code receives input from a Wii nunchuck using an XBee radio (w/ Adafruit XBee adapter)
* and controls four servos and two digital pins to turn on LEDs
* Honus 2010
* /

#include "Servo.h" // include the Servo library

int joyx,joyy = 135;
int accx,accy = 135;
int zbut,cbut = 0;
int ledPin1 = 13;
int ledPin2 = 12;
int lightvalue1 = 255;
int lightvalue2 = 255;
char nunchuckData;
int val = 0;
int tempval = 0;
int servo1Pos;
int servo2Pos;
int servo3Pos;
int servo4Pos;
int buttonState1 = 0;
int buttonState2 = 0;
int lightMode1 = 0;
int lightMode2 = 0;

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;

int servoPin1 = 9;
int servoPin2 = 8;
int servoPin3 = 7;
int servoPin4 = 6;

Leere setup ()
{
// Serial.begin(9600);
// Serial.print("Nunchuck ready\n");
Serial.begin (9600);

servo1.attach(servoPin1);
servo2.attach(servoPin2);
servo3.attach(servoPin3);
servo4.attach(servoPin4);
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}

Leere Schleife () {

if (accy > 125) {
servo1Pos = 90-(accy-125);
if (servo2Pos < 45)
servo1Pos = 45;
servo1.write(servo1Pos);
}
if (accy < 125) {
servo1Pos = 90+(125-accy);
if (servo1Pos > 135)
servo1Pos = 135;
servo1.write(servo1Pos);
}

if (accx > 125) {
servo2Pos = 90-(accx-125);
if (servo2Pos < 45)
servo2Pos = 45;
servo2.write(servo2Pos);
}
if (accx < 125) {
servo2Pos = 90+(125-accx);
if (servo2Pos > 135)
servo2Pos = 135;
servo2.write(servo2Pos);
}

if (joyy > 125) {
servo3Pos = 90-(joyy-125);
if (servo3Pos < 45)
servo3Pos = 45;
servo3.write(servo3Pos);
}
if (joyy < 125) {
servo3Pos = 90+(125-joyy);
if (servo3Pos > 135)
servo3Pos = 135;
servo3.write(servo3Pos);
}

if (joyx > 125) {
servo4Pos = 90-(joyx-125);
if (servo4Pos < 45)
servo4Pos = 45;
servo4.write(servo4Pos);
}
if (joyx < 125) {
servo4Pos = 90+(125-joyx);
if (servo4Pos > 135)
servo4Pos = 135;
servo4.write(servo4Pos);
}

if (cbut != buttonState1) { // the button state has changed!
if (cbut == 1) { // check if the button is pressed
if (lightMode1 == 0) { // light is off
lightMode1 = 1; // light is on!
digitalWrite(ledPin1, HIGH);
} else {
lightMode1 = 0; // light is on!
digitalWrite(ledPin1, LOW);
}
}
}

if (zbut != buttonState2) { // the button state has changed!
if (zbut == 1) { // check if the button is pressed
if (lightMode2 == 0) { // light is off
lightMode2 = 1; // light is on!
digitalWrite(ledPin2, HIGH);
} else {
lightMode2 = 0; // light is on!
digitalWrite(ledPin2, LOW);
}
}
}
buttonState1 = cbut; // save the new state in our variable
buttonState2 = zbut; // save the new state in our variable

while(Serial.available()) {
tempval = Serial.read();
if (tempval=='x') {
nunchuckData='x';
val=0;
}
else if (tempval=='y') {
nunchuckData='y';
val=0;
}
else if (tempval=='X') {
nunchuckData='X';
val=0;
}
else if (tempval=='Y') {
nunchuckData='Y';
val=0;
}
else if (tempval=='Z') {
nunchuckData='Z';
val=0;
}
else if (tempval=='C') {
nunchuckData='C';
val=0;
}
else if (tempval >='0' && tempval <= '9') {
val=val * 10;
val=val + (tempval - '0');

if (nunchuckData=='x'){
joyx=val;
}
else if (nunchuckData=='y'){
joyy=val;
}
else if (nunchuckData=='X'){
accx=val;
}
else if (nunchuckData=='Y'){
accy=val;
}
else if (nunchuckData=='Z'){
zbut=val;
}
else if (nunchuckData=='C'){
cbut=val;
}
}
} //end of input in serial buffer
}

Step 14: Resources


So that's it for now- I'll be adding more code examples and mechanisms as time goes on.
Here's some additional material to check out:
Animatronics-
Here's an awesome show reel that displays the capabilities of animatronics-
http://www.johnnolanfilms.com/animatronics/showreel-flash-2010.php
Electronics classes-
Once you're comfortable with Arduino and you want to move into a greater understanding of electronics and circuits have a look at Contextual Electronics . Chris Gammell (of the Amp Hour podcast ) created Contextual Electronics as a site dedicated to teaching electronics in an easy-to-understand way with lots of hands-on interaction. Sehr empfehlenswert!
http://www.contextualelectronics.com
Soldering tutorials-
This is the first in a great series of SMD soldering tutorials-
http://www.sparkfun.com/tutorials/36
Basic soldering skills-
http://www.sparkfun.com/tutorials/106
Arduino tutorials-
http://www.ladyada.net/learn/arduino/index.html
http://www.arduino.cc/playground/
Using Eagle to make PCBs-
http://www.sparkfun.com/tutorials/108
Books-
MAKE: Electronics- If you're just getting into electronics or need a refresher this is a great book
http://www.Amazon.de/MAKE-Electronics-Learning-Through-Discovery/dp/0596153740/ref=sr_1_1?s=books&ie=UTF8&qid=1291095250&sr=1-1
Making Things Talk- everything you ever wanted to know about Arduino and communication techniques
http://www.Amazon.de/Making-Things-Talk-Practical-Connecting/dp/0596510519/ref=sr_1_1?ie=UTF8&s=books&qid=1291014224&sr=1-1
Practical Arduino- A great book with awesome Arduino projects
http://www.Amazon.de/Practical-Arduino-Projects-Hardware-Technology/dp/1430224770/ref=sr_1_2?ie=UTF8&s=books&qid=1250109738&sr=8-2
Physical Computing- It's not Arduino specific as it predates it but it's THE book to have regarding physical computing; everything from servos and stepper motors to LEDs and sensors- it's all in there
http://www.Amazon.de/Physical-Computing-Sensing-Controlling-Computers/dp/159200346X/ref=sr_1_1?s=books&ie=UTF8&qid=1291014345&sr=1-1
Making Things Move- Looks like a great book for learning how to design all kinds of mechanisms.
http://www.makingthingsmove.com/
http://www.Amazon.de/dp/0071741674?tag=makingthingsm-20&camp=14573&creative=327641&linkCode=as1&creativeASIN=0071741674&adid=1RG5X8SW1YZDQ0MMAXDR&
No Strings Attached- A great book about the Jim Henson Creature shop
http://www.Amazon.de/No-Strings-Attached-Hensons-Creature/dp/185227669X/ref=sr_1_2?s=books&ie=UTF8&qid=1291014513&sr=1-2
The Winston Effect- Amazing photos and information about all kinds of animatronic creations
http://www.Amazon.de/Winston-Effect-History-Stan-Studio/dp/1845761502/ref=sr_1_1?ie=UTF8&s=books&qid=1291014636&sr=1-1 Step 15: FAQs


Frequently asked questions-

Do you offer a servo board kit?
Nope- at least not yet. I might be coaxed into making a fully assembled board though...just message me if you want one.

Will you do custom work?
On occasion- message me to discuss your project.

I need help with my own code/project- is there a forum for help?
The Arduino forum is the place to go-
http://arduino.cc/cgi-bin/yabb2/YaBB.pl

The Predator setup isn't really a true head tracking system- why?
When I first started looking at this I had just envisioned a simple system that was controlled using bend sensors on your fingers and it wouldn't be able to look up and down. That really was a bit cumbersome to operate and wasn't very natural.

Next I looked at keeping the bend sensor that would raise the cannon, but I figured out a system that had a cable mounted under the mask that turned a pulley/spring loaded potentiometer (mounted under the cannon mechanism) that would allow the cannon to follow your head rotation. It still wasn't able to look up/down. Now I got a natural (and smooth) rotation but fixing/routing the cable was difficult and cumbersome. Mask removal could also be a real problem.

Then I started looking at different kinds of sensors. Gyroscopic, compass and accelerometers. Combo boards, IMUs (inertial measurement units), etc. I have a friend that is a data acquisition engineer as well as a friend that is a programmer and I spoke to several electrical engineers for help. Compasses are affected by tilt, so you have to compensate for that and then they don't work when you rotate your whole body vs. just your head, so dual compasses would be necessary and you would have to write code to differentiate between the two.

The problem with gyros is that you need two of them, preferably with an accelerometer to account for drift as well as front/rear tilt (pitch). One gyro really won't work well because it will respond to whole body rotation as well as just head rotation, so you would need one IMU at the head and another at the cannon base and then you have to write some code to differentiate between the two. Gyros really only sense change in angular velocity so its output only changes with respect to movement and it will reset itself once you stop rotating your body- the cannon will quickly become out of sync with your movements. That's why to really do it right you need a multiple DOF (degree of freedom) IMU and you need two of them for true head tracking. Most of the systems I've seen that people post online as a head tracking system for R/C or video control that use these types of sensors have pretty poor yaw control and I think this is why. And they don't even have to deal with the body vs. head rotation issue as they can sit in a chair- not an option for costuming.

There are IMUs and digital compasses available now that have on board processing and are programmed to account for drift and tilt so some of the hard work is done for you but you would still have to factor in the difference output of two of them and then generate your necessary servo movement values from that. It can be done but it's pretty darn expensive.

Most of the solutions I found were pretty complex in terms of programming requiring sophisticated algorithms and/or extremely expensive on the hardware side. There are also pretty severe space restrictions for fitting sensors inside the Predator Bio helmet as some of the IMUs available are pretty large physically.

Then I found that I could modify the sensor board out of a Wii nunchuck controller and interface it with a microcontroller over its I²C bus. This provided me with an inexpensive and reliable multi axis accelerometer and two finger pushbuttons with an easy to use interface. I ended up writing code that would allow me to access all of the nunchuck's functions- the accelerometer outputs, the joystick and the two pushbuttons.

When it was all said and done the rotation was still a bit of a problem as the accelerometer only really gives you a stable output with respect to gravity so you have to tilt it to get the rotation. What I found was that if I mounted it as level as possible in Predator helmet it really didn't need much tilt at all to get a stable rotation. The beauty of this system is that there are only only two finger buttons to control everything- it's also pretty easy for me to modify the code. I haven't yet taken apart a Wii Motion Plus to combine it with a nunchuck to create an inexpensive IMU but I'll post the results when I do.

What I did was to basically fake it by strictly using the accelerometer inputs- when looking sideways you just need to tilt your head to the side like a bird for yaw (rotation) control. The accelerometer reads the tilt and moves everything accordingly- the pitch function is normal. It does take a bit of getting used to but after a while it becomes more natural and it's very convincing.

For costuming all you need to do is provide the illusion. When I started the project with a friend three years ago (he's sculpting the Pedator backpack) we wanted something that anyone could build from readily available building blocks to add some cool animatronics to their Predator costume without spending a ton of cash.

Whew...

I want to power my project and I only want to use one battery to supply different voltages- what do I do?
I would use a switching step down voltage regulator like this one-
http://www.pololu.com/catalog/product/2110
It's far more efficient than using a traditional voltage regulator, especially if you need to use something like a 12V battery and drop it down to 5V for servo power. If you need to drop 5V to 3.3V then a traditional voltage regulator is fine. Just don't plug it into the JST connector on the controller board and then plug in a USB cable into the USB mini-B port for the charging circuit- that would be bad.