• Home »
  • Controller »

    12 Schritt:Schritt 1: Main Board Schritt 2: TempLedPotButton Foren Schritt 3: Touch-Direkttaste Foren Schritt 4: LCDSerial Schritt 5: Video Keyboard Foren Schritt 6: Code Schritt 7: Ethernet - die beggining Schritt 8: Ethernet - Mitte Schritt 9: Ethernet - Das Ende? Schritt 10: Video Schritt 11: Touch and USB Schritt 12: Abschließende Worte

    Dies ist ein Entwicklungs-Board für den PIC24F Reihe von Mikrochips, mit: USB (schließen Sie es an jeden Computer) Ethernet (schließen Sie es an das Internet) SD-Karte (zu speichern und alle Daten, die Sie benötigen, zu lesen) ich diese Sache entwickelt als Lernplattform, es hat funktioniert (immer noch). Also, wenn Sie wollen immer noch einen Schritt weiter in Mikrocontrollern gehen, wie ich will, es ist ein schöner Weg, es zu tun. Das Problem, das ich hatte, ist, dass Mikrochips Beispiele sind für ihre Entwicklung Bord, die ich haben keinen Zugang. So entwickelte ich meine ein Brett und Beispiele, und ich gerettet alle Schritte so, es wäre einfacher, jemanden zu started.Going von einer einfachen ping auf eine Webseite mit Ajax zu bekommen. Ein Video zeigt das Projekt: (Obs: Die Seite ist nicht mehr verfügbar ist, benötigt er eine gewisse Macht und einen Port auf meinem Router.) Nur um einen Vorsprung einige der Dinge, die ich bisher mit diesem Board getan zu sehen: Ein Touch-Tastatur, verwendbar als ein Standard-USB-Tastatur. A Video Game (Tennis und Schlange Spiele), mit TV-Ausgang und Anschluss an einen PC-Tastatur (die alte PS / 2) für die Steuerung. Bilderrahmen liest Bilder bilden die SD-Karte und ihnen zeigen, auf dem TV. Steuern Sie ein 5-Volt-LCD und ein paar LEDs, mit nur 3 Drähten (die MCU ist 3.3V) Web-Server , in dem Sie einige Status der Platine, wie Temperatur, die Position eines Pot und eine Taste sehen können, die Kontrolle über einige LEDs und das LCD- (alles aus dem Internet) Und die Dinge, die ich wissen, bevor ich anfing, (nur eine Checkliste): die rechte Seite von einem Lötkolben Programm in c (nur die Grundlagen) Programmierung PICs in Assembler (Ich habe hier für eine lange Zeit stecken, aber es ist nicht erforderlich) zur Verfügung, wie man ein PCB machen ein bisschen Elektronik Debugging Es begann alles, als ich dieses Projekt sah: Web-Server-on-a-Business-Card-Teil-2 (danke hackaday) Die Idee der Steuerung etwas trought das Internet war wirklich schön, also kaufte ich den Chip. Aber als ich geboren hatte Klassen gestartet. Ein Jahr später begann ich, ein vielversprechendes Buch lesen: Programmierung 16-Bit-PIC-Mikrocontroller in C: Lernen, um den PIC 24 Fly Ich war der 24F, begann ich sofort. Brotschneidebrett, Draht-Durcheinander, und die ersten Programme laufen. Aber als ich in dem Buch voran Ich hatte das Bedürfnis für eine Leiterplatte. Hackaday Projekt war meine Basis, aber ich wollte ich etwas mehr. Ein USB-Anschluss, und ein paar Stifte Vordergrund expansions.The WEBSD Bord war geboren. Nachdem ich entwickelte zusätzliche Bretter zu stecken. Wenn ich eine neue Sache mit dem Board zu tun, nur das Design eines einfachen Erweiterungskarte. Befolgen Sie die nächsten Seiten, um mehr über das Projekt zu sehen. Projektdateien sind auf dieser Seite beigefügt. Arthur Benemann 2011 BrasilStep 1: Main Board Alle 7 Artikel anzeigen Wechseln Sie dies, wenn Sie kein Interesse an der Gestaltung Teil des Projekts haben. Die Hauptplatine auf dem hackaday Projekt basiert. Seinen Namen von den beiden Hauptsache darauf kommen: WEB - Internetanschluss SD - Die Speicherkarte ich eine meiner ersten Projekte mit einem PIC24F war, und die Kraft dieser Chips und C kombiniert machte mir Angst. Layout war wegen der PPS (Peripheral Pin Select) Merkmal dieser Familie einfach. I kann der I / O der digitalen Peripherie, fast jede Stifte zugeordnet werden. Aber ich war tief auf der Pin-Anzahl, aber drückte 4 Pins aus ihm für Erweiterungen. Die Stromversorgung erfolgt durch eine kleine Stromversorgung bewertet für 5V 500mA (a standart 7805 PS) durchgeführt. Ich glaube nicht, wählte USB Power aufgrund der Stromaufnahme durch den Ethernet-Chip. Um alle Anschlüsse auf einer Seite zu setzen und eine kleine Größe zu halten, wurde eine Doppelschichtplatte benötigt. Ich habe von SMD-Bauteilen süchtig, sie schneller zu löten sein kann, und es gibt keine Notwendigkeit, so viele Löcher in der Platine zu bohren. Leider habe ich nicht gekauft haben, haben die SMD-Version des ENC28j60 so ist es eine DIP Teil. Die MCU Wahl war einfach, ich wollte lernen, die Familie 24F verwenden, USB war ein nettes Feature, um zu erkunden, SOIC-Gehäuse (QFN-Gehäusen mir Angst immer noch). So nehme ich nur das eine mit der größten Programmspeicher. Die ICSP Programmierung Anschluss wird mit der pickit2 Fußabdruck, i wird auch als eine serielle RS232-Schnittstelle verwendet. Sie können die Kommunikation mit dem Terminal mit dem pickit2 oder mit einem externen seriellen Schnittstelle bereitgestellt (sorgt für mehr Geschwindigkeit) Part-Liste (mit Mouser Referenz): Qty Wert Gerät Teile 3 rot LEDCHIPLED_0805 LED1, LED2, LED3 8 0.1uF C-EUC0805 C2, C4, C6, C7, C9, C10, C11, C12 2 1uF C-EUC0805 C5, C8 1 2K32 R-EU_R0805 R12 2 10k R-EU_R0805 R1, R5 1 10uF CPOL-EU153CLV-0405 C3 1 25 MHz CRYSTALHC49UP Q2 2 22pF C-EUC0805 C15, C16 4 49R9 1% R-EU_R0805 R8, R9, R10, R11 1 60ohms I_0805 L1 1 330R R-EU_R0805 R4 2 330R R-EU_R0805 R2, R3 1 AP1117E33 V_REG_LM1117SOT223 IC1 1 ENC28J60-DIL ENC28J60-DIL IC2 1 J1006LONG Ethernet Connector RJ1 1 PIC24FJXXGB002 PIC24FJXXGB002 U 1 € 1 SD SD U 2 € 1 USB-MB USB-MB U 4 € 1 Stromanschluss JACK-PLUG1 J2 Schritt 2: TempLedPotButton Foren Wechseln Sie dies, wenn Sie kein Interesse an der Gestaltung Teil des Projekts haben. Die erste Erweiterungskarte i entwickelt, so einfach, wie es sein kann. I hat genau das, was der Name schon sagt: Temp - Temperatursensor, einem LM35 Strom aus der 5V-Versorgung, die 10 mV / ° C gibt. Led - kein Geheimnis hier, ein führte ein ein Widerstand Pot - Potentiometer als Spannungsteiler verbunden ist, die nur darauf warten von der ADC-Knopf zu lesen - eine Drucktaste auf den Boden, werden keine Klimmzüge verwendet wie die PIC hat sie bereits. Ich hier in Brasilien habe ich Probleme, ist es schwer, Teile zu bekommen. Ich muss aus den USA kaufen (zahlen eine Menge Steuern, bis zu 200%), nur um ein paar "bekommen Buchsenleisten ". Damit ich weiß, dass die Anschlüsse i verwendet werden für Kabel hergestellt. Nizza Header wäre viel besser (wie die in der Arduino). Ich war mit meiner Plattenhersteller Fähigkeiten zu experimentieren, so fielen frei, um die Größe dieser Tracks zu erhöhen (8mil Tracks sind schwer mit der Toner-Transfer-Methode). Schritt 3: Touch-Direkttaste Foren Wechseln Sie dies, wenn Sie kein Interesse an der Gestaltung Teil des Projekts haben. Ich hatte schon eine Routine zur Berührungsmessung in Assembler für die PIC16 geschrieben, aber die 24 fps hat weiteres nettes Feature der Ladezeit Measurement Unit (CTMU). Wenn Sie sie als Stromquelle ist es viel einfach zu Kapazität zu messen. So eine einfache Erklärung für die Touch-Sensoren: Wenn Sie Ihren Finger in der Nähe des großen Platz auf dem Brett Sie die parasitäre Kapazität des Titels zu erhöhen. Die Mikro die Linie für Änderungen auf der Linie Erkennen eines Tastendruck kontinuierlich zu überwachen. Keine großen Dinge auf diesem Board, nur ein Stück Acryl auf der Oberseite, um die Frontplatte etwas zu simulieren (i brach eine Ecke, als ich schneiden). Ich habe einen einfachen Siebdruck auf dem Brett, um die Tasten zu identifizieren. Für eine bessere Performance müssen die Tracks so nah wie möglich an den Finger, aber ich habe sie auf der Unterseite der Platine, weil, wenn ich kann, damit es funktioniert wie diese, es wird gut funktionieren, wenn verwendet normally.Step 4: LCDSerial Wechseln Sie dies, wenn Sie kein Interesse an der Gestaltung Teil des Projekts haben. Kein Entwicklungsboard wäre komplett ohne eine LCD.But gibt es ein großes Problem hier in der Tat zwei: Die Kraft für diese PIC ist 3,3 V, und alle alphanumerischen LCD habe ich bei der Hand sind nur 5V. Es besteht die Möglichkeit zum Anschluss von 5V-Eingänge, einige der Stifte auf der Mikro-, aber ich hatte zu verwenden alle von ihnen. (Wenn Sie den USB-Stifte nehmen es nicht genug Stifte links) Auch wenn es sich um eine 5V Teil hatte ich nur links 4 Expansionsstifte, die lcd muss mindestens 6 (flink, nur Schreibmodus) So sah ich mich um, bis Ich finde die Lösung auf einem piclist Post, ich etwas mehr und ich fand diese . Eine 74HCT 595 Chip würde die Aufgabe des Pegelumsetzung zu tun. Ich denke, es wäre besser, von "gefährlichen Prototypen" erklärt werden, so werfen Sie einen Blick dort. Aber warum stoppen auf einem LCD, wenn Sie ein Schieberegister sind? Lets auf dieses Ding setzen einige Leds. Eine weitere '595 in Reihe, und wir sind gut zu gehen. Die versteckte Lage der Kontrast Potentiometer ist erwähnenswert. i projiziert mit einem lcd, sondern gelötet anderen so blieb es in der falschen Position. Part-Liste (mit Mouser Referenz): Qty Wert Gerät Teile 8 LEDCHIP-LED0805 LED1, LED2, LED3, LED4, LED5, LED6, LED7, LED8 1 TAC_SWITCH S1 1 0.1uF C-EUC0805 C1 1 1K R-EU_0204 / 5 R2 1 10K TRIM_EU-LI10 R1 2 74HC595N 74HC595N IC1, IC2 8 330R 0805 R-EU_R0805 R3, R4, R5, R6, R7, R8, R9, R10 1 HD44780-LCD HD44780-LCD LCD1 Schritt 5: Video Keyboard Foren Wechseln Sie dies, wenn Sie kein Interesse an der Gestaltung Teil des Projekts haben. Dieses Board wurde entwickelt, um auf eine PC-Tastatur angeschlossen werden. Es ist die alte PS / 2-Tastatur. Es funktioniert bei 5V also müssen wir einen kleinen Trick hier gelten, gibt es einige Widerstände, die auf den Klemmdioden aus dem PIC angewiesen, um die Spannung auf 3,3 V zu senken. Der Verbinder ich nahm aus einer alten ATX-Motherboard. Ein einfacher DAC von zwei Widerständen verwendet wird, um das Video signal.I hatte keine Leiterplattenmontage RCA-Anschluss zu erzeugen, als früher einen Molex-Stecker an einen RCA Stecker verdrahtet. Das Molex-Cinch-Adapter ist einfach, GND der Platine muss auf dem Schild des RCA, VideoOut vom Spielfeld auf den Mittelstift des RCA verbinden. Schritt 6: Code Es dauerte ein paar Monate Zeit, um zu lernen, wie man alles, was das Board hat jetzt zu codieren, so dass ich den Code in einigen Teilen aufteilen: Ethernet-Anschluss Serielle LCD-Video So auf die Seite, die Sie interessiert zu gelangen. Der gesamte Code wurde mit C30 Lite-Version von Microchip (kostenlos) zusammengestellt. Unter dessen eine Tabelle, was notwendig ist, um jedes Beispiel auszuführen. Tafel Hardware TempLED PotButton LcdSerial Video Tastatur Touch-Direkttaste SD-Karte (Mikro) Tastatur (PS / 2) SDTest - - - - X - Klingeln - - - - - - HTTP - - - - - - HTTP2 - - - - - - Dynamische Variable X - - - - - BEKOMMEN X - - - - - Autentication X - - - - - AJAX X - - - - - Ethernet LCD - X - - - - TCPIP-Demo X - - - - - LCDSerial - X - - - - Berühren Sie LIB - - - X - - USB Touch- - - - X - - Video - - X - - - SDPicture - - X - X - Spiele - - X - - X Schritt 7: Ethernet - die beggining So können beginnen. Die Hauptplatine ist bereit, was wir tun? -------------------------------------------- Einschalten ---- ----------------------------------- Macht es einfach auf und prüfen Sie, ob nichts raucht, muss die Power-LED an ist. Versuchen Sie nun, eine Ethernet-Kabel von Ihrem Router oder PC zu verbinden. Eine der LEDs in der Nähe der ENC28J60 sollte leuchten anzeigt Link bestätigt wird, und die andere blinken bedeutet, dass es RX-Aktivitäten (der Router versucht, in den Vorstand zu verbinden). ----------------------------------------------- SDtest - -------------------------------------------- Wenn du hier Great! Bedeutet, dass das Ethernet-Teil Ihrer Bord funktioniert. jetzt können Sie die MCU und SD-Karte, indem Sie das Demo-SDTest testen. Brennen, schalten Sie das Board mit einem auf den Sockel eingeführt SD-Karte. Eine Textdatei wird auf der Karte erstellt werden, wenn alles gut läuft. Das bedeutet, dass jetzt können Sie spielen mit Mikrochip-Dateisystem-Bibliothek beginnen:). ---------------------------------------------- Ping Test - ------------------------------------------ Jetzt wird alles interessant, lassen Sie verbinden Sie es mit einem Netzwerkadministrator kann dies durch 2 Arten tun, die Verbindung mit einem Crossover-Kabel direkt an einen PC. Oder (dieses ist am besten) verbinden Sie es mit einem inländischen Router mit aktiviertem DHCP (i verwenden Sie einen di-524). Statische IP ist nicht schwer, aber die Demos für DHCP programmiert. Programmieren Sie das Board mit dem Ping-Demo. Nur ping das Board zu sehen, ob TCPIP-Stack funktioniert. Zu tun, ein Ping-Test öffnen Sie eine Eingabeaufforderung und geben Sie "ping websd", sollte es die IP-Adressen des Vorstandes und der Zeit, die, um eine Antwort zu bekommen zurückzukehren. Wenn es nicht funktioniert, können Sie versuchen, direkt auf die IP-Adresse der Platine ping können Sie finden, dass dieses Add Dazu suchen Sie in Router-Seite, oder mit Hilfe eines Werkzeuges durch Mikrochip "Ethernet Discoverer" vorgesehen (dies ist der einfachste Weg, ). Es gibt einige Sachen, die Debugging-i senden Trog RS232 (nicht bei allen Demos). Stecken Sie es ein wenig mehr Spaß zu haben. -------------------------------------------------- - HTTP ----------------------------------------------- Herzlichen Glückwunsch, die TCPIP-Stack ist, wenn man hier Betriebs! Lassen Sie uns nun einen HTTP-Server. Demo-Nummer 3 - "HTTP", ist ein Mini-HTTP-Server. Ich verwendet den alten Server aus Mikrochip mit MPFS, um Webseiten im Programmspeicher zu speichern. Das muss im Programmspeicher abgelegt, weil sie nicht eine externe Speicher chip.To die Webseiten vorbereiten müssen Sie einen kleinen Mikrochip-Programm namens MPFS verwenden werden. WebPages.bat seine eine Batch-Datei zu erstellen, dass ich können die Web-Seiten für die MPFS zu verarbeiten, kann es in MPLAB als Pre-Build-Option enthalten sein, so dass, wenn die Erstellung der Web-Seiten werden automatisch aktualisiert. Um dieses Beispiel zu sehen, arbeiten, müssen Sie: Kompilieren, zu verbrennen. Versuchen Sie nun, um das Brett zu pingen, öffnen Sie die Seite trought ein browser.It können in einem Browser geöffnet werden, indem openein die url: "teste /" oder "IPADD", wo IPADD es ist die Netzwerkadresse der Karte. Wenn sucesseful eine Webseite mit einem Hallo-Welt-Nachricht wird geöffnet, ein Lächeln auf Ihr Gesicht. -------------------------------------------------- - HTTP2 ----------------------------------------------- Es ist das gleiche Zeug, wie die "HTTP" Demo nutzt bu Mikrochip HTTP2 Modul und MPFS2. Diese haben viel mehr Funktionalität wird in den nächsten Beispielen untersucht werden. Nur zusammenstellen, brennen, Kugelschreiber in einem Web-Browser. Jetzt aber beachten Sie, dass TCPIP Versions- und Build-dat, ändert acordling, wann es gebaut wurde. Diese beiden sind dynamische variables.Step 8: Ethernet - Mitte Ok Sie haben einen Web-Server, hat es Links, Texte, Bilder. Aber es scheint immer noch etwas fehlen, wir sind nicht in den 90er Jahren nicht mehr. Was wir brauchen, ist eine Art der Interaktion mit der Welt so: ------------------------------------------- Dynamische Variablen ----- ---------------------------------------- Jetzt nur nicht vergessen, die TempPotLedButton Board stecken. Dynamische Variablen ist die Art, Mikrochip beschlossen, diese Interaktion zu implementieren. Sie stellen so etwas wie "Temp ~ ~" in Ihre Webseite Code, dann, wenn das MPFS liest sie geändert wird, um zu einem Unterprogramm in der Programmdauer Routine aufgerufen nennen ist "HTTPPrint_temp" auf die Datei "CustomHTTPApp.c". Dort können Sie jede stric zurück zu Show in der Web-Seite mit dem Befehl "TCPPutROMString ()" sein. Alle Anrufe an die Druckunterprogramme sind in der Datei "HTTP_print.h", die von MSFS automatisch generiert wird. Die in dieser Demo umgesetzt Größen sind Status der Schaltfläche, die Temperatur der Platine, Stellung des Potentiometers. Die Werte werden erfasst, wenn die Web-Seiten geladen wird, so dass ein F5 zu betätigen, um die Seite mit neuen Werten zu aktualisieren. Ich habe ein "ipconfig" -Seite, um die Konfiguration der Karte TCPIP-Protokoll zeigen. -------------------------------------------------- - GET Form ---------------------------------------------- ---------- Bis jetzt haben wir einen http-Server, der realen Welt Variablen wie Temperatur, Status einer Schaltfläche angezeigt werden kann ... Jetzt ist es Zeit zu beginnen Controlling Dinge aus dem web.To tun, werden wir eine html form.There verwenden gibt zwei Methoden der Verarbeitung Daten für HTML-Formulare: GET oder POST. GET es simples hat jedoch eine Grenze für die Größe der Daten. POST hat keine Grenze, ist aber ein wenig schwieriger. Um nur geführt get-Methode umschalten ausreichend. Holen Sie wird von einer Form auf der Webseite durchgeführt, es einige Daten anzuhängen, um die URL der Webseite, wie: "Index.htm? Geführt = on", wo Led ist die Variable, und ist der Staat. Microchip HTTP2 Server rufen Sie eine Routine aufgerufen: "HTTPExecuteGet", wenn ein get Formular muss diese Routine müssen wir prüfen, ob es die richtige Webseite processed.In werden, suchen für die Variable in der URL, überprüfen Sie es Staat, und tun Sie etwas mit ihm wie Makeln die LED. Es ist nur notwendig, um zu brennen, und öffnen Sie den Browser, um diese Funktion zu sehen. ------------------------------------------------- Authentication ------------------------------------------------ Die Seite ipconfig hat einige Informationen über das lokale Netzwerk, vielleicht ist es besser, diese Informationen zu schützen. y Glücklichermicrochip hat fast die ganze Arbeit für uns (nice) getan. Müssen nur die Authentifizierungsmodul an den HTTP-Server hinzuzufügen. Eine Routine in customHTTPApp.ca Routine prüft, ob die Webseite offen Bedürfnisse Authentifizierung und andere Routinekontrollen des Passwortes. Einfach, wie es sein könnte. Brennen Sie die Demo, und versuchen Sie ipconfig Seite zu öffnen, ist standardmäßig config: user: "Arthur" übergeben: "admin" Schritt 9: Ethernet - Das Ende? Ist dies das Ende der Ethernet-Demos? Wahrscheinlich nicht, ich glaube, dass dies nur die Welt der Dinge, die mit Vorstand wie folgt durchgeführt werden können zerkratzt. Jetzt, da wir die Grundlagen abgedeckt werden wir sehen, einige der neuesten Codes ich getan habe. -------------------------------------------------- -------------- AJAX ----------------------------------- ----------------------- Dest Demos gezeigt, wie man die LED blinkt und lesen Sie ein paar Sachen aus dem Vorstand. Aber jedesmal, wenn Sie die LED blinkt oder eine neue Lesung aus dem Vorstand ein Refresh muss getan werden, Neuladen der gesamten Seite erneut. Die Lösung, die Mikrochips und viele othes verabschieden ist die Verwendung von Ajax . Es wurde entwickelt, um etwas von der Last auf dem Client-Rechner nehmen, laut Wikipedia: "Web-Anwendungen können Daten von dem Server asynchron im Hintergrund, ohne die Anzeige und das Verhalten der vorhandenen Seite abrufen". Es gibt ein Skript auf der Webseite, die nur die dynamische Variablen, um den Server in einer zeitlich abgestimmten fashion.This Weise die Serverbelastung verringert, auch die Kalibrierung der Temperaturfühler und Bereich Skalierung der Potentiometer können in der Webseite durchgeführt werden abgefragt, Bewegen der Gleitkomma-Operationen mit dem PC und nicht auf die PIC. Dinge auf dem PIC Seite nicht zu viel ändern, nur die Anrufe an die Temperatur und Topfgrößen nicht auf die Skalierung der Werte zu tun. JavaScript auf der Webseite ändern auch die Größe und die Farbe einer Tabelle als eine Möglichkeit, die Visualisierung des Potentiometer-Wert (Farbwechsel zu) verbessern. Brennen, schließen Sie das TempPotLedButton Bord, und Spaß haben. Der Code für das Autoreload ajax Skript Form des Mikrochips "TCPIP Demo App" übernommen. -------------------------------------------------- ------ Ethernet LCD ------------------------------------------ ------------ Um zu verstehen, diese besser lesen Sie die Seite, wo ich erklären, die LCD-Routinen ersten. Lesevariablen aus dem Vorstand und mit Updates in Echtzeit, es ist eine nützliche Funktion. Aber eine andere nette Geschichte ist meiner Meinung nach Kontrolle Dinge aus dem Internet. Ich weiß, dass die GET Beispiel schon gemacht, aber mit ajax Dinge sind viel mehr Spaß. Wenn jemand klickt blinkt eine LED, während Sie in der Seite sind, werden Sie auch sehen, es Statuswechsel. Putting-Nachrichten auf einem LCD über das Internet seine schön. So entwickelte ich dieses Board und Demo für diese Funktion Demo-Ausgänge, eine Nachricht kann auf der LCD Trog senden werden die Webseite und der Status der LEDs kann auch geändert werden. Als i whanted diese Demo zu halten Online seit einiger Zeit ein hits counter wäre schön. Deshalb habe ich eine Variable, die jedes Mal, wenn die "print_builddate" Routine wird (auf Seite Lasten) genannt wird erhöht. Sein Wert ist selbst von der Ajax-Skript aktualisiert. Es ist ein 32-Bit-Ganzzahl ohne Vorzeichen, wird es nicht überlaufen (hehe 2 ^ 32 = 4.294.967.296 hits). Wenn alles gut geht (mein ISP mir nicht blockieren), sollten Sie in der Lage, meine WEBSD Brett auf der Adresse (es kann langsam sein, da ich nicht eine gute Internetverbindung haben) zu öffnen: http://websd.no-ip.org/ Setzen Sie dieses Online war ein wenig schwer. Ich habe einen Inlands ADSL-Verbindung, was bedeutet, keine statische IP-Adresse, und die Dinge Schlimmste meiner IPS Blöcke Port 80 und 8080 (gemeinsame Ports für HTTP-Server) zu bekommen. Die Lösung war, No-IP-Umleitung von Port 80, dynamische IP (No-IP und meinem Router) und die Umleitung wieder auf die 80-Anschluss an der IP-add des Boards in meinem lokalen Netzwerk zu nutzen. Port 80 in mein internes Netzwerk, so kann ich es direkt. -------------------------------------------------- TCPIP Demo App ----------------------------------------------- -------- Mit ein paar Änderungen TCPIPdemo von Microchip exemples kann auf diesem Board mit internen Flash ausgeführt werden. Aber wegen der Programmgröße beschränkt Maximun otimizations verwendet werden. Einige Features, wo geschnitten, weil der Programmgröße constrains.Button Anzeige funktioniert und die LED an Bord wird von der zweiten LED (links nach rechts) auf der Webseite gesteuert. Schritt 10: Video Wie ich am Anfang sagte, begann ich dieses Projekt, weil ich das Buch las: Programmierung 16-Bit-PIC-Mikrocontroller in C: Lernen, um den PIC 24 Fly In einem Kapitel zeigt es, wie ein zusammengesetztes Videosignal (ein PAL NTSC) mit dem SPI-Modul des Bild zu erzeugen. Also hier sind die Ergebnisse, dass das Spielen mit. -------------------------------------------------- --------- Video ---------------------------------------- ---------------------- Dieses Projekt ist es eine der folgenden Seite Bücher von Seite. Der beste Weg, um tiefer zu verstehen, was los ist, das Buch zu lesen. Also dafür werde ich nur den Code ohne Erklärung (außer für die Kommentare im Code) links. Fügen Sie eine der folowings im Projekt in MPLAB souce: CleanScreen.c - Blank NTSC Rahmen TestPatern1.c - Testmuster zu sehen, ob Videopuffer i CornerBox.c - 4 Boxen an den Ecken, um zu sehen, ob alle Bildpunkte angezeigt werden, RandomPatern.c - Test der plotPixel Funktion LineTest1.c - versucht, eine Linie zu zeichnen LineTest2.c - Bresenham-Algorithmus für Linien graph1.c - 2D-Diagramm, von dem pic berechnet graph2.c - 3D-Diagramm, wie zuvor, aber schöner mandelbrot.c - der Mandelbrot-Menge zu ziehen on the fly (Ich schlage vor, dass Sie die zu folgen, um zu sehen, wie, was entwickelt werden) Dann kompilieren, und das Bild, um es zu sehen, arbeiten zu verbrennen. -------------------------------------------------- - SDPicture ------------------------------------------------ ---------------- Dank hackaday für die Inspiration und Erläuterung der ein paar Sachen von diesem Projekt. Wikipedia half auch eine Menge. Dieses Projekt lesen Sie einfach die SD-Karte auf der Suche nach monocromatic, (Bildschirmauflösung) 256x192, BMP-Dateien auf der Karte. Als es dekodiert sie und das Bild in den Videopuffer, ihnen zu zeigen, auf dem TV-Bildschirm. : Es wurde bei diesem Projekt von hackaday basierte digitale Bild fram e Wikipedia war äußerst hilfsbereit, um mich die Bitmap-Dateien zu verstehen: BITMAP -------------------------------------------------- ------ Spiele ------------------------------------------- ------------------- Ein Hinweis in der Schlusskapitel des Buches angeregt mich. Double-Buffering verwendet werden, um flüssige Bewegung auf dem Bildschirm für Dinge wie Spiele machen werden. Doppelpuffer ist eine Methode von jedem Grafikkarte, um Grafiken zu erzeugen. Ein Puffer ist zu zeigen auf dem Bildschirm, während der andere als Unentschieden. Wenn die Zeichnung gemacht Puffer getauscht. Das war es, ich brauchte, um ein Video-Spiel zu bauen. Aber, wie man einige Kontrollen auf diesem Board anschließen, 4-polig wäre nicht genug für eine direkte Verbindung sein. Ein weiterer PIC über eine serielle Schnittstelle verbunden wäre OK. Aber aus einer früheren Kapitel des Buches habe ich machte einige Routinen a eine Tastatur PS / 2. Nur zwei Stifte benötigt, nur der Widerstand Trick, um das Niveau Form 5V bis 3,3 V zu ändern (die Tastatur 5 V) an. 2 Pins für die Tastatur + 2pins für den Video-Ausgang, Video wurde Keyboard Board getan. Jetzt brauchen Sie nur wählen Sie ein Spiel, erste Wahl Schlange. Der Code wurde in einem Top-Down-Mode geschrieben. Eine Struktur, die Schlange Variablen halten, Routinen, um die Schlange zu zeichnen, ziehen Sie den Block des Körpers ... Ist schön, den Code dieses eine zu überprüfen. Es war ein schönes Spiel, aber Multi-Player ist besser. Warum nicht berufen einer der Klassiker: PONG. Das war schnell, um Code, aber muss noch brauchen polieren. Ich hoffe, dass ein Video von dieser Video games.Step 11 Beitrag: Berühren und USB Ich arbeite an einem Projekt, das einen USB-Touch-Tastatur muss arbeiten. Die WEBSD Bord war perfekt für die Entwicklung einer schnellen Prototypen. Aber ich konnte nicht der Mikrochip berührungsempfindlichen Bibliothek zu work.But Ich hatte schon einige Touch-Routinen für die PIC16F in Assembler geschrieben. Dann habe ich meine eigene Routinen. -------------------------------------------------- ---- Touch-LIB -------------------------------------------- ----------------- Meine eigene berührungsempfindliche Routinen. Nehmen Sie einige der Kommentare auf dem Code, um eine Menge von Daten über RS232 senden. Es ist schön, die Variablen in einem Diagramm mit einem Endgerät wie Laufen sehen Tinybld . Ich werde nicht erklären, viel hier, Mikrochip hat eine Menge Material über berührungsempfindliche, so schauen Sie hier für weitere Informationen. Dieses Programm ist nur ein Test des Touch LIB, es hält das Senden der Status jeder Taste auf dem Board über die serielle (gedrückt oder nicht). -------------------------------------------------- ---- USB-Touch--------------------------------------------- ------ Es ist ein Touch-USB-Tastatur, die pc erkennt es als standart USB-Tastatur, eine Menge, wie einer meiner früheren Projekten IRUSB. Aber isntead von Tasten hat Touch-Sensoren. Der Code ist eine Fusion des Touch Lib oben entwickelt und die USB-Tastatur-Demo von Microchip. Schritt 12: Abschließende Worte Nur ein paar abschließende Worte. Ich hoffe, dieses Projekt weiter, mit Dingen wie Google Leistungsmesser und others.Comments sind immer willkommen. Ich möchte Mikrochip zu danken, und all diese Jungs, die Anwendungshinweise und Beispielcode zu schreiben. Hackaday für Ihre Projekte gut erklärt. Fiel frei, um meinen Code zu verwenden, es einfach verwenden, nicht im Handel. Arthur Benemann 2011 Brasil.$(function() {$("a.lightbox").lightBox();});

      9 Schritt:Schritt 1: Teile, die Sie benötigen Schritt 2: SSR Foren Schritt 3: Fügen Sie die Arduino Schritt 4: Konstruieren Sie die WaveShield Schritt 5: Schließen Sie an die Halbleiterrelais Schritt 6: hochladen Sketch und alles testen Schritt 7: Setzen Sie alle in einer Box Schritt 8: Hook Up Christmas Lights Schritt 9: Ideen für Veränderungen

      Meine Frau und ich haben wollten unsere eigenen Lichter-set-to-Musik-Show für die letzten Ferienzeit zu erstellen. Inspiriert von den beiden Instructables unten, entschieden wir uns schließlich in diesem Jahr beginnen und schmücken unsere RV. Wir wollten eine all-in-one-Controller (Licht und Musik), aber nicht brauchen, um über das Internet steuerbar sein, so dass es ein wenig anders als die anderen beiden Instructables. Video zu kommen! Sources ich verwendet habe: Instructables: Arduino Weihnachtslichtregler weihnachten-Box: Arduino / ioBridge Internet gesteuert Christas Lichter und Musik-Show Sonstiges: Halbleiterrelais (SSR) Mit TRIACs: Schritt 1: Teile, die Sie benötigen SSR Supplies (7 €): MOC3031 Optokoppler (8) Z0103 TRIAC (8) Lichtregler Supplies (61 €): Arduino Duemilanove WaveShield FM Transmitter - ich eines aus (auf den Fotos unten), aber jeder wird funktionieren (€ 15 +) Radioshack B & M (€ 14): Draht-Terminals (3 Pakete, 12 Anschlüsse) 276-1388 Printed Circuit Board 276-147 (könnten kleiner verwenden) 330Ohm Widerstände (2x 5-Packs) 150 Ohm Widerstände (2x 5-Packs) Home Depot B & M (25 €): 50 ft Landschaft / Sprinkler Draht (18ga, 7 Leiter) 079407238170 6 'Power Cords (x8 Minimum, um die weibliche 120v Anschlüsse verwenden) -Sie können mehr als 8 benötigen, abhängig von den Standorten Ihrer Lichter; Ich habe 11 Klar, Kunststoff-Box (meine Dollar Tree war aus, aber HD hatte diese für 0,87 €) Sonstiges: Lötkolben (Ich benutze einen Butan-angetriebene BernzOmatic von Home Depot; dient auch als Heißluftpistole) Solder (sehr empfehlenswert: Lotpaste ) Schraubendreher (philips für WaveShield, Standard für Drahtanschlüsse) Draht (für WaveShield und den Anschluss an die Halbleiterrelais, benutzte ich zusätzliche Steckbrett Schaltdrähte ich hatte) Seitenschneider Abisoliergeräte SD Card (jeglicher Größe, habe ich 64 MB) Isolierband Stromquelle für Arduino (Ich habe einen zusätzlichen USB-Hub ich hatte) Heißklebepistole Kabelverbinder (optional) Schritt 2: SSR Foren Solid State Relais-Board Wenn Sie möchten, können Sie auch in voller Größe zu sehen meine Kopien und . Ich begann, indem Sie alle Komponenten auf der Platine. Als ich mit, wie sie angelegt zufrieden war, begann ich durch Löten Sie alle Einzelteile an der Platte, die nicht brauchen zusätzliches Kabel (im Grunde alles, aber den Boden aus dem Arduino und der 120-V-Hotline). Ich habe dann verlötet die Gemeinsamkeiten / Heißdrähte. Wie Sie aus der Unterseite der Platine sehen können, sieht es ziemlich chaotisch. Wenn Sie fertig sind, testete ich jeden SSR getrennt durch Anschließen des 120v Macht und Messen über den neutralen und jeder schaltet Heiß ausgegeben, während ich einen 5V-Quelle über die Arduino Seite des Brettes. Schritt 3: Fügen Sie die Arduino Ich habe eine Heißklebepistole, um das Arduino-Board an den SSR PCB zu sichern. Wenn Sie sich entscheiden, einen UKW-Sender direkt auf die Leiterplatte zu löten, können Sie es in dem zusätzlichen Platz in der unteren linken Ecke des unten zu Fotos hinzufügen. Sie können aber auch in die Anschlüsse in jeder generische FM-Transmitter. Schritt 4: Konstruieren Sie die WaveShield Folgen Sie den ausgezeichneten Richtungen Lady Ada , die WaveShield Kit zu bauen. Früher habe ich die Standard-Steueranschlüsse (2 - LCS, 3 - CLK, 4 - DI, 5 - LAT, 10 - LCS). Ich habe auch Pin A0 an die 1.5k Widerstand bei R7 angeschlossen (siehe Foto unten). Wenn Sie fertig sind, folgen Sie den Anweisungen hier , um Songs vorzubereiten und sie auf der SD-Karte. Legen Sie die Karte in der WaveShield wenn Sie fertig sind. Schritt 5: Schließen Sie an die Halbleiterrelais Früher habe ich die zusätzlichen Steckbrett Schaltdrähte musste ich schließen Sie das folgende: WaveShield (diese können geändert werden, aber ich habe die Standardeinstellungen) D2 - LCS D3 - CLK D4 - DI D5 - LAT Erste 3 SSR Channels D6 - Kanal 1 D7 - Kanal 2 D8 - Channel 3 WaveShield D10 -> LCS WaveShield - SD-Karte (kann nicht geändert werden) D11 D12 D13 Leistung Gnd [0] - SSR Boden VU-Meter A0 - bis R7 (1,5 K Widerstand) auf der WaveShield Verbinden von Verstärkerausgang zu messen. Restlichen 5 SSR Channels A1 = D15 - Channel 4 A2 = D16 - Channel 5 A3 = D17 - Kanal 6 A4 = D18 - Channel 7 A5 = D19 - Kanal 8 Schritt 6: hochladen Sketch und alles testen Ich habe ein kurzes Stück der Landschaft Draht, um das Setup zu testen. Ich habe das schwarze Kabel an den Neutralleiter-Terminal, und jeder der anderen sechs Leiter, um den ersten sechs SSR Heißdrahtanschlüsse. Am anderen Ende der Landschaft Draht, verbunden ich alle Neutralen an die schwarze Leiter und jeder der anderen sechs Leiter an den heißen Draht von jedem der sechs weiblichen Steckdosen (siehe Foto unten). Um Energie zu liefern, eine der sechs männlichen Fuß Netzkabel über von der Ernte der Buchsen in die 120-V-Eingangskabelanschlüsse (siehe Foto unten) links verbunden I Ich habe xmas_box.pde von hier und set debug auf true beim Testen alles. Ich habe vor, die Bearbeitung der Code, sobald ich alles außerhalb einzurichten, aber jetzt funktioniert es ohne Modifikation. Aktualisieren 2010-06-22: Ich habe einen 7-zip-Datei Code könnte ich verwendet haben, die (neben dem Original-Code von oben) angebracht ist. Ich werde neue Code später in diesem Jahr laden, wenn ich den Controller wieder zusammen und implementieren einige der Ideen, die ich für eine zukünftige Expansion hatte. Aktualisieren 2010-12-11: Ich habe neu geschrieben das Programm über die daphc Beispiel aus dem WaveHC Bibliothek und der Vumeter Code aus dem xmas_box Instructable oben verlinkten. Es wird nun jeden Song auf der WaveShield SD-Karte findet spielen in einer Endlosschleife. Das Programm wird unter Christmas_Lights_2010.pde. Ich habe auch Christmas_Lights_2010_Channel_Test.pde die gerade durchläuft alle 8 Kanäle, so dass Sie wissen, dass sie work.Step 7: Setzen Sie alle in einer Box Ich begann durch Heißkleben der Leiterplatte in die klare Kunststoffwanne. Ich hatte einen zusätzlichen USB-Hub herumliegen, so habe ich beschlossen, dass verwenden, um den Arduino anzutreiben. Ich heiße verklebt das Netzteil für die Nabe einrastet und verstopft die 11. 6 'Verlängerungskabel (das einzige nicht zerschneiden) hinein. Ich klebte auch die Nabe in Position. In die gegenüberliegende Seite des Verlängerungskabels, angeschlossen ich in 120v Stecker der Leiterplatte ist. Das USB-Kabel geht an den Arduino von der Nabe ist eine 1 € zu verlängern-Lage Kabel von Dollar Tree aber jede USB-Kabel funktionieren würde. Um die Kabel durch die Seite der Wanne laufen, habe ich meinen Lötkolben mit der Spitze entfernt (effektiv ein Mini-Heißluftpistole) zu schmelzen den Kunststoff. Ich habe dann verwendet Heißkleber, um die Kabel zu befestigen. Ich tat dies mit den Lichtern 'Netzkabel (oben im Bild unten) und das Netzkabel für das Board (unten). Ich beendete es mit Hilfe Draht Nüsse, die Macht ausgehen, um alle Lichter zu den Testdrähten ich schon oben angespannt (Hinzufügen einer zusätzlichen zwei für den 7. und 8. Kanäle) zu verbinden. Fügen Sie den Deckel und du bist fertig. Sollte wasserdicht-genug für mich sein, und es ist von der Eingangstreppe meiner RV geschützt. Schritt 8: Hook Up Christmas Lights Führen Sie die Landschaft Kabel an alle Lichter und Draht die weiblichen 120v Anschlüsse. Jeder Verbinder ist sowohl mit der schwarzen Draht und einer der sechs Farben (eine für jeden Kanal in der Leitung) verbunden ist. Ich landete laufen zwei Kabellängen (alle 8 Kanäle zu decken). Sie müssen möglicherweise mehr als eine weibliche 120v Stecker pro Kanal. Ich habe zwei pro Kanal für meine beiden Miniatur-Bäume und meine Rentiere (es gibt eine auf jeder Seite eines zentralen Weihnachtsbaum). Schritt 9: Ideen für Veränderungen Expansion: Es gibt 3 zusätzliche Pins auf der Arduino zur Verfügung, um zusätzliche Kanäle hinzuzufügen. Wahrscheinlich werde ich diese drei im nächsten Jahr hinzuzufügen (oder gehen Sie mit den beiden folgenden zwei Optionen). Verwenden höherer Leistung TRIACs, wie die 4A Z0405 -wie lange, wie Sie mit LED-Leuchten sind, sollten 1A VIEL sein Verwenden Sie ein Schieberegister, so dass Sie mehr als 11 Kanäle haben.

        9 Schritt:Schritt 1: Teileliste Schritt 2: Hauptstromkreis Schritt 3: Extras Schritt 4: Testen Schritt 5: Layout Schritt 6: Löten Schritt 7: Motoren Schritt 8: Batterie Schritt 9: Genießen

        Alle 8 Artikel anzeigen Ich liebe Roboter. Normalerweise die, die ich bauen sind recht groß und würde nicht in die Hosentasche passen, aber für einen Wechsel der Gangart Ich beschloss, etwas kleiner und Spaß versuchen! Dieser Roboter ist genau das, und in der Tat passt in einer altoids tin. Sie ist billig, vielseitig (so viele verschiedene Sensoren können verwendet werden) und extrem unterhaltsam. Check it out in action unten! (Leider habe ich mit mir gespielt, so viel, bevor ich jedes Video hatte ich meine Knopfzellenbatterien verwendet, und ein Motor gestartet haben Probleme, so fahre ich es mit einer 9V im Video) Das Projekt dauert einige Zeit, aber lehrt viel über Motorsteuerungen, die ATMega Chip und Löten. Die meisten Spaß, was war, die verschiedenen Sensoren und Schreiben von Programmen sammeln, um es zu reagieren (nur zwei meiner vier sind in dem Video zu sehen), wie Sie die Roboter viel "Persönlichkeit", dass Art und Weise geben kann. Nie langweilig, wenn Sie diesen Kerl in der Tasche haben! Schritt 1: Teileliste Da dieses Projekt ist eine, die viele verschiedene Möglichkeiten hat Ich werde vor allem diskutieren die wesentlichen Teile. Grundlagen: 1 x Arduino (vorzugsweise UNO) 1 x ATmega328 Chip (andere Versionen funktionieren auch, dazu später mehr. Sie werden wahrscheinlich wollen eine mit einem vorinstallierten Bootloader) 1 x 28 pin DIP-Sockel (hält den ATMega, nicht unbedingt erforderlich, aber Sie sollten wirklich es haben) 1 x 5V-Regler (L7805) 2 x 10 uf Capacitors 1 x 16 MHz Keramik-Resonator (a 16 MHz Kristall funktioniert auch, aber Sie werden zusätzliche Kondensatoren, die Platz nehmen müssen. 1 x Platine (bekam ein kleines, die in einem Altoid Zinn passen von Radioshack für ein paar Dollar) 1 x Steckbrett (um den Stromkreis zu testen) 2 x Motoren (I verwendet Pager Motoren mit Planetengetriebe von robotshop.com) 2 x Räder (auch bekam diese von robotshop.com, aber Sie verwenden können, was auch immer funktioniert) 1 x L293D (Motortreiber-Chip, der, wenn Sie werden mit Motoren erforderlich ist) 1 x Taster (mein Code drehte sich um diese Sache, auf jeden Fall sinnvoll) Kabel! Müssen eine Menge zu Steckbrett und löten. Knopfzellen (diese halten die Größe klein genug, um in der Altoids Zinn passen) Fun Extras: 2 x Fotowiderstände (viel Spaß Programme, die Sie für diese schreiben kann) 2 x RGB-LEDs (gibt es die Persönlichkeit!) 1 x Mikrofon Element (lässt sie zu hören und zu klingen zu reagieren) Alles, was Sie denken, wäre cool! Ich wollte Sound hinzufügen, aber leider nicht genug Platz für einen kleinen Piezo-Lautsprecher hast. Werkzeuge: Klipper, Lötkolben, vielleicht ein Freund zu helfen, halten wiresStep 2: Hauptstromkreis Es gibt zwei Hauptstromkreise: eine für die Motorsteuerung (L293D) und dem ATmega328 Chip. Sie können eine Anschlussbeschreibung des ATmega328 mit freundlicher Genehmigung von instructables finden Sie HIER. Grundsätzlich treffen Sie die einfachste arduino Schaltung möglich (ich weiß nicht einmal gehört ein Reset-Taste, aber Sie, wenn Sie möchten können). Jetzt sind die einzigen Dinge, die Sie müssen, um den ATmega Haken ist 5V (geregelt durch die L7805) an den Pins 7 und 20, Boden, um Pins 8 und 22 (i zog in Stift 21 als leer, weil sie nicht brauchen, um verbunden werden nichts), und die Keramik-Resonator (oder Kristalloszillator) an den Pins 9 und 10 Sehen Sie die Bilder, wie man die Kondensatoren mit dem Spannungsregler verwenden und sicher sein, um den mittleren Pin des Keramik-Resonator zu erden. Wenn Sie mit einem Quarzoszillator sind Sie zusätzliche Kondensatoren benötigen, um zu sehen, wie das zu tun oder als eine andere Referenz für jeden Teil dieser Schaltung prüfen 'ible HIER. Das Anschlussdiagramm für den L293D Motorsteuerung gefunden werden kann HIER . Ich habe keine Bilder von diesem haben, weil es ist ziemlich einfach Pins 1, 8, 9, und 16 erhalten 5V; Pins 2, 7, 10, 15 und gehen Sie zu dem Arduino digitale Stifte (Ich habe diejenigen mit pwm zu Motordrehzahlen zu steuern); Stifte 3, 6, 11 und 14 sind bis zu den Motoren eingehakt (die Motoren laufen von 3 V, aber der Abfall durch den Chip genügt, daß keine Diode erforderlich sind); und Pins 4, 5, 12 und 13 sind mit Masse setzen. Schritt 3: Extras Dies sind wirklich an Ihnen, ich werde ein paar einfache Schaltungen für die Dinge, die ich hinzugefügt zeigen Ihnen aber seien Sie kreativ! Dies ist es, was der Roboter seine "Persönlichkeit" und macht es interessant. Schritt 4: Testen Dies ist ein wichtiger Schritt. Sie benötigen, um Ihre gesamte Schaltungslayout Steckbrett. Vorerst nur verdrahten alle Sensoren und Motoren bis zu einer tatsächlichen Arduino, weil immer wieder Herausnehmen der Chip in dem Steckbrett kleben würde ganz schön nervig sein. Sobald Sie das getan und Ihr Code geschrieben haben (als Referenz und Spaß, kann mein Programm finden Sie hier ) können Sie die ATMega328 Chip aus dem Arduino zu entfernen und legen Sie sie in Ihrem Steckbrett. Seien Sie äußerst vorsichtig, wenn Sie diese, wie es erfordert viel Kraft und ist einfach zu des Chips führt zu biegen. Sobald es an Ort und Stelle in dem Steckbrett, dem Anschluss des Spannungsreglers mit Kondensatoren und der Keramik-Resonator mit dem Chip (lesen die Schaltpläne sprachen über früher) und stellen Sie sicher, dass die Spannung an den Chip werde bei 5 V und das Programm läuft, wie es sollte vom Brett zu befreien. Jetzt Cookin 'sind! Schritt 5: Layout Seit Größe ist so ein Problem, müssen Sie eine Minute Zeit nehmen und zu entwickeln, wie Sie sie alle in Ihrem Raum zur Verfügung gestellt stopfen. Ich habe die Platine als meine Referenz und zu einer Zeit, wo ich möchte, dass sie sein legte Teile ein und skizziert sie ein gutes Gefühl für, wo alles würde am Ende zu bekommen. Stellen Sie außerdem sicher, um zu testen, dass Ihre Batteriehalter in der Lage, irgendwann mit Komponenten zu befestigen und in die Dose passen. Vergessen Sie nicht, Sie zu einem bestimmten Zeitpunkt zu montieren Motoren Schritt 6: Löten Dies wird einfach der schwierigste Schritt wie die Größe und Dichte der Drähte macht es schwierig. Mein Rat an Sie, ist sicherzustellen, dass Sie den Spannungsregler, Keramik-Resonator, ATMega Chip und Motortreiberchip erste Lot und sicherzustellen, dass sie vollständig, bevor Sie mit allen Extras hakt (Ich war so aufgeregt über die LEDs und Motoren, es machte immer Strom und Masse an den Chip schwieriger als nötig!). Ich empfehle auch, indem man lange blanken Draht auf der linken und rechten Seite und einem Haken an die Macht und die andere auf Masse, so wird es leichter sein, um all die Extras, um sie später anzuschließen. Hier können Sie das verrückte Wald von Drähten zu sehen, wie es proceeded.Step 7: Motoren Hoffentlich haben Sie etwas Platz gespeichert, um Ihre Motoren montieren! Der einfachste Weg, ich fand, war zu bohren, eine offene Loch in der Leiterplatte und verwenden Sie einen Kabelbinder um die Vorderseite (siehe Bilder). Für die Räder von robotshop, bohrte ich gerade sie ein bisschen und sie direkt an geknallt! Um die auf die Platine Ich habe eine ziptie, die ich durch eine Leiterplattenbohrung setzen feste Motoren halten (benötigt, um ein wenig aufgebohrt werden) und dann um die Vorderseite (Bilder zeigen das besser als ich erklären kann). Jetzt können Sie 'Bewegen' sind. hah ... Das einzige andere Problem war, dass die Drähte unter dem Bauch des Roboters waren so dick, dass die kleinen Räder nicht einmal den Boden berühren. Um dies zu lösen, fügte ich eine Büroklammer auf der Rückseite, die ich gebogen in zwei Dreiecke und verwendet zwei Perlen als Räder eine glattere Fahrt (Bilder sind viel klarer, was das sieht aus wie) .Schritt 8 zu ermöglichen: Batterie Mit einer Energiequelle, die in der Altoid Zinn mit Ihrem Roboter Sie müssen einige Knopfzellen erhalten passend zu bekommen. Diese können an den meisten großen Geschäfte (Lebensmittel, Ziel, etc.) gefunden werden. Sie wollen die kombinierte Spannung der Zellen auf über 5 V sein, in meinem Fall habe ich zwei 3V Einsen und stapelte sie in Serie. um eine einfache Halter Ich zog einige Draht machen, setzen eine auf jeder Seite, und klebte die ganze Sache zusammen. Dies hielt die Dinge einfach für mich, es mit dem Roboter verbinden. Du bist fertig! Gehen Sie zu beeindrucken einige people.Step 9: Genießen Jetzt, wo du es gebaut haben, ist es Zeit, dass Sie einen Namen geben und präsentieren es auf Ihre Familie und Lieben. Es ist ziemlich cool aber, und ist sehr beeindruckend, wenn man nur ziehen einen Altoid Zinn aus der Tasche und haben eine nette und brillante Roboter wartet, um ihre Sache zu tun. Fügen Sie etwas Klang, machen es zu tanzen, und lassen Sie mich wissen, welche tollen Sachen Sie zu machen! Würde gerne viele kleine Roboter sehen domin- ich meine ...

          38 Schritt:Schritt 1: Schematische und Übersicht Schritt 2: Solder LEDs zu Sparkfun PCB Schritt 3: Solder Diodes zu Sparkfun PCB Schritt 4: Flachbandkabel Schritt 5: Clamp-Buchse Schritt 6: Multiplexing mit Arduino und 74HC595 Schritt 7: Header Pins Schritt 8: Strombegrenzungswiderstände Schritt 9: 74HC595 Buchse Schritt 10: Anschlüsse an LEDs Schritt 11: In Second 74HC595: Part 1 Schritt 12: In Second 74HC595: Part 2 Schritt 13: In Second 74HC595: Teil 3 Schritt 14: In Second 74HC595: Teil 4 Schritt 15: In Second 74HC595: Teil 4 Schritt 16: Header Pins Schritt 17: Schließen Sie 74HC595, um Arduino Schritt 18: Test LEDs Schritt 19: Multiplexing mit Arduino und 74HC165 Schritt 20: 74HC165: Teil 1 Schritt 21: 74HC165: Part 2 Pull-Down-Widerstände Schritt 22: 74HC165: Part 3 Schritt 23: 74HC165: Teil 4 Schritt 24: Testknöpfe Schritt 25: Serielle Kommunikation Schritt 26: Batterie Schritt 27: Midi Out Schritt 28: Accerometer / Gyro Schritt 29: Töpfe Schritt 30: Gehäuse Schritt 31: Schluss Firmware Schritt 32: Zukunft der Arbeit Schritt 33: Anhang: Schneiden PCB für Steuertasten Schritt 34: Anhang: Steuertasten Verdrahtung Teil 1: PCB Schritt 35: Anhang: Steuertasten Verdrahtung Teil 2: Socket Schritt 36: Anhang: Steuertasten Verdrahtung Teil 3: Header Pins Schritt 37: Anhang: Steuertasten Wiring Teil 4: Anschlüsse an LEDs Schritt 38: Anhang: Steuertasten Wiring Teil 5: Anschlüsse an Buttons

          Dieses Projekt ist ein tragbares, Arduino-betrieben, Grid-basierten MIDI-Controller, der in eine Vielzahl von Anwendungen startet, um viele Dinge, mit Ton zu tun. Es verfügt über 16 beleuchtete Tasten, da beide Ein- und Ausgänge verwendet werden, um das Steuergerät eine visuelle Rückmeldung zu geben. 2 Potentiometer geben analoge Steuer, abhängig von der App die Töpfe an Tempo, MIDI-Velocity, Tonhöhe zugewiesen und das Scrollen (Herstellung der avaible Rasterabstand größer als 4x4). Ein x / y-Beschleunigungsmesser und ein x / y-Gyroskop fügen Sie etwas verspielt, gestische Steuerung an das Gerät; die meisten der Anwendungen implementieren eine "Shake zu löschen" Steuerung und mehrere reagieren auf verschiedene Weise zu kippen. Er startet in 7 apps (wie unten beschrieben), auch wenn sie das Potenzial, in insgesamt 16 hochfahren hat. Dieses Gerät ist in erster Linie ein MIDI-Controller, aber ich habe auch eine App, die Sie auf die Schaltfläche und Analogdaten in ziehen können geschrieben MaxMSP und Audio-Steuerung . Dieser Controller wurde sowohl von der inspiriert monome und TENORI-ON . Als ich im College war, baute ich einen großen Touchscreen-Display, auf der Grundlage der Arduinome monome-Arduino Klon Schaltpläne und Code, die mit allen Open-Source-Anwendungen in monome MaxMSP geschrieben gearbeitet. Es gibt eine Tonne von Menschen, den Aufbau ihrer eigenen monome-type-Geräte mit diesen Tasten von Sparkfun und Arduinome Code sowie einige Variationen über das Thema . Mit diesem Projekt, war ich daran interessiert, ein Gerät, das ein wenig mehr in sich geschlossene und relativ billig zu machen (viele Tasten = viel $) war. In dem Konzept des TENORI-ON halten mehr, dieser Controller nicht alle seine App Verarbeitung selbst, es nicht auf einen Computer angewiesen, um Tastendrücke / Analog-Kontrollen in MIDI zu bearbeiten. Das bedeutet, Sie können es direkt in einen Synthesizer oder ein anderes Gerät, das MIDI versteht stecken und Sie sind gut zu gehen, kein Computer erforderlich. Es läuft eine bullige LiPo Akku, der es hält läuft seit Tagen auf eine Ladung, also ist es ziemlich portable als auch. Im Einklang mit der monome Seite der Dinge, es ist völlig Open Source und kann auf Ihre speziellen Audio-Setup / Bedürfnisse angepasst werden. All das Arduino-Code ist auf Github (klicken Sie auf die Cloud-förmige Taste zum Download), zusammen mit einem MaxMSP Patch, der Daten aus der Steuerung in etwas Brauchbares in Max decodiert. Eine Übersicht über die apps, die ich bisher geschrieben: Pixel Tilt - Ein Pixel bewegt sich über eine 2D-Tastatur mit Neigungs auslöst MIDI wie es sich bewegt. Steuergeschwindigkeit und Basisnote mit Töpfen. Flin - Music Box app basierend auf monome . Drehzahl und Geschwindigkeit der Notizen, die von y Neigungs gesteuert. Paging über 16 "Bahnen" mit Topf. Schütteln, um zu löschen. Serielle Kommunikation mit MaxMSP - Ziehen von Daten aus Tasten und analoge Steuerungen in MaxMSP und verwenden Sie, um LED-Zustände Max senden. Unterstützt 5-Bit-Analog-Bedienelemente für x / y-Beschleunigungsmesser und 2 Töpfen. Das ist großartig, wenn Sie die Audioverarbeitung mit dem Controller ausgeführt werden soll. Laden Sie SerialDemo app ( SerialDemo.maxpat , mit den Arduino-Dateien enthalten, klicken Sie auf die Cloud-förmige Taste hier ), um Daten in Max analysieren. Beat Slicer (siehe oben) App ist im Preis inbegriffen mit der Arduino-Dateien sowie. Arpeggiator - Spielt eine zwei, drei, oder vier note Arpeggio, ähnlich wie diese App ich für monome schrieb. Ein Topf steuert die Geschwindigkeit des Arpeggios, anderen Steuerungen Geschwindigkeit. Hinweise im Arpeggio kann nach oben oder unten um einen Halbton über Tastensteuerung verschoben werden. Das gesamte Arpeggio wird über x Neige umgesetzt. Drücken Sie die Note ganz links in der Arpeggio die Noten in aufsteigender Reihenfolge zu spielen, drücken Sie die ganz rechts Note im Arpeggio die Noten in absteigender Reihenfolge zu spielen, und drücken Sie eine Herznote in der Arpeggio die Noten in zufälliger Reihenfolge abzuspielen. Schütteln, um zu löschen. Boiing - Bouncing Pixel, die Polyrhythmen zu erzeugen, basierend auf diesem TENORI-ON-App . Bounce Richtung basierend auf y Neigung. Geschwindigkeit und MIDI-Velocity (Lautstärke) von Töpfen gesteuert. Schütteln, um zu löschen. Step Sequencer - Vier note 16 Step-Sequenzer. Pots steuern Tempo und Paging in Folge. Schütteln, um zu löschen. MIDI Keyboard - Einfache MIDI-Tastatur. Steuergeschwindigkeit und Basisnote mit Töpfen, Pitchbend mit x kippen. Liste der Einzelteile: Sparkfun: (1x) Button-Pad 4x4 - LED Kompatibel Sparkfun COM-07835 (1x) Button-Pad 4x4 - Breakout PCB Sparkfun COM-08033 (1x) Arduino Uno Sparkfun DEV-11021 (1x) Accelerometer / Gyro 5 Freiheitsgraden Sparkfun SEN-11072 Ich habe einen 3-Achsen-Beschleunigungssensor und 2 Achsen-Gyroskop in diesem Controller es einige gestische Kontrolle zu geben, aber bisher habe ich noch nicht wirklich in allen apps verwendet werden, den Kreisel, und ich habe nur die x- und y-Achse des Beschleunigungsmessers bekam verdrahtet. Das bedeutet, dass Sie in einer einfacheren / billiger Teil wie sub könnte dies . DIGIKEY: (16x) Weiß 5mm LED (3mm ist auch in Ordnung) Digikey C513A-WSN-CV0Y0151-ND (2x) 74HC595 Schieberegister Digikey 296-1600-5-ND (1x) 74HC165 Schieberegister Digikey 296-8251-5-ND (3x) 16 pin IC-Sockel Digikey A100206-ND (16x) 1N4148 Diode Digikey 1N4148FS-ND (4x) Strombegrenzungswiderstände (Wert wird auf LEDs ab, die in Schritt 5 enthalten Beispielrechnung) (4x) 10 kOhm 1 / 4watt Widerstände Digikey CF14JT10K0CT-ND (1x) 220Ohm 1 / 4watt Widerstand Digikey CF14JT220RCT-ND (1x) 5-Pin MIDI Jack Digikey CP-2350-ND (optional - in Schritt 27 beschrieben) (1x) USB Typ B Buchse; Digikey 732-2734-ND (optional - in Schritt 27 beschrieben) (2x) 10kOhm lineare Verjüngung Potentiometer Digikey 987-1308-ND Jameco: (1x) 16 Leiterbandkabel Jameco 28RC16-10VP (1x) 16 pin Winkelkupplung Jameco 746285-3 (6x) Stiftleiste Stifte Jameco 103.393 Radioshack: (1x) Midikabel Radioshack 42-2149 (optional - in Schritt 27 beschrieben) (1x) Größe N LED-Einbau Coaxial Netzteilbuchse mit Schalter Radioshack 274-1576 (1x) Größe N Coaxial DC Power Plug Radioshack 274-1573 (1x) SPST Kippschalter Radioshack 275-634 AMAZON: (1x) Li-Ion 7.4V Tenergy 2200mAh Akku-Modul mit PCB Amazon (1x) Tenergy Universal Smart-Ladegerät für Li-Ion / Polymer-Akku (3,7 V-14.8V 1-4 Zellen) Amazon (1x) MIDI zum USB-Kabel Amazon (optional - in Schritt 27 beschrieben) NEWARK: (2x) Aluminum Knöpfe Newark 74M6717 Weitere Materialien: 22-Gauge-Kabel, verschiedene Farben Jameco # 9313-0-R Isolierband Radioshack 64-2373 Kabelschneider Abisolierzange Lot Holz / Acryl / Projekt Gehäuse (Ich habe diese 6 "x6" x2 "Bambus-Box The Container Store ) Kleber / Epoxy Doppelklebeband Amazon Schritt 1: Schematische und Übersicht Alle 7 Artikel anzeigen Alle Schaltpläne für dieses Projekt sind oben gezeigt. Detaillierte Übersichten über den 74HC595, 74HC165, und Stromanschlüsse werden später in diesem Instructable gegeben. Alle Arduino Pin-Anschlüsse sind nachfolgend aufgeführt: Analog 0 - Gyroskop Y (Y4.5) 1 - Potentiometer 1 2 - Gyroskop X (X4.5) 3 - Beschleunigungsmesser Y (yacc) 4 - Beschleunigungsmesser X (XAcc) 5 - Potentiometer 2 Digital 0 - Serien in - das muss frei bleiben 1 - Serien out - das ist bis zu den MIDI-Ausgang angeschlossen 2 - 74HC165 Datenstift (Q7) 3 - 74HC165 Taktpin (CP) 4 - 74HC165 Raststift (PL) 5 - 74HC595 Taktpin (SH_CP) 6 - 74HC595 Raststift (ST_CP) 7 - 74HC595 Datenstift (DS) keine Verbindungen zu digitalen Stifte 8-13Step 2: Solder LEDs zu Sparkfun PCB Alle 7 Artikel anzeigen Führen Sie die Leitungen der 16 LEDs (5 mm oder 3 mm sind in Ordnung, habe ich 5 mm) durch LED-Löcher in der Sparkfun PCB. Diese Platten sind mit 4-Kanal-RGB-LEDs kompatibel, so gibt es vier verfügbaren Löcher auf jeder Taste Pad. Sie können die beiden mittleren Löcher für einfarbige LEDs (siehe Abbildung 3) zu verwenden. Achten Sie darauf, dass die flache Kante des LED (die Kathode) einer Linie mit dem Flach Markierung auf der Leiterplatte. Löten Sie die LED-Leads und schneiden Sie das überschüssige wire.Step 3: Solder Diodes zu Sparkfun PCB Alle 7 Artikel anzeigen Löten Sie 16 Dioden Sparkfun PCB. Achten Sie darauf, die Linie bis schwarze Markierung auf Diode (Kathode) mit dem Streifen auf der PCB.Step 4: Flachbandkabel Schneiden Sie etwa 1 ft von 16 Leiterbandkabel. Separate und isolieren Sie die Enden alle 16 Drähte auf der einen Seite und Lot Sparkfun PCB. Die folgende Liste gibt alle farbigen Leitern, um mit dem Namen der Leiterplattenbohrung sollten verlötet, wenn Sie tun dies richtig keiner der Drähte sollten überqueren werden. Beachten Sie, dass da ich nur mit einer einzigen Farbe LED, werde ich verdrahten nur die "blue" Anode. Anschlüsse: einer Seite des Bandkabel Brown SWT-GND1 Rote LED-GND1 Orange SWT-GND2 Gelbe LED-GND2 Grün SWT-GND3 Blaue LED-GND3 Lila SWT-GND4 Grau LED-GND4 Weiß blue4 Schwarz Switch4 Brown Blue3 Red Switch3 Orange BLUE2 Yellow SWITCH2 Grün BLUE1 Blau SWITCH1 anderen Seite der Band cableStep 5: Clamp-Buchse Verwenden Sie einen Schraubstock, um den 16 poligen Buchse an der Flachbandkabel klemmen. Wenn Sie nicht über einen Schraubstock keine Zange dies tun, werden Sie die Buchse an der Seite und mess up die Verbindungen zu klemmen. Du bist besser dran mit einem Hammer, um die Klemme geschlossen tippen, so stellen Sie sicher, dass Sie immer die Anwendung den Druck gleichmäßig über die Steckdose. Achten Sie darauf, die Klemme die Buchse an der Flachbandkabel in der gleichen Orientierung in den Bildern angezeigt above.Step 6: Multiplexing mit Arduino und 74HC595 Zwei 74HC595s (parallel geschaltet) fahren wird alle LEDs im Projekt sowie die Bereitstellung von Energie, um alle Tasten. Die 74HC595 ist ein 8-Bit-Serien parallel Schieberegister. Ich habe ein ausführliches Tutorial über Multiplexing mit dem 74HC595 geschrieben, und Sie mehr Informationen über dieses auf dem Chip können Datenblatt . Bitte beachten Sie, dass die 74HC595 in der schematischen gezogen ist kein Pin-Diagramm, habe ich die Reihenfolge der Stifte der Schaltplan klarer zu machen neu geordnet. Die Pin-Diagramm für den Chip ist in Figur 4 dargestellt ist. Die 74HC595 hat folgende Stifte (der technische Name kann eine von mehreren Dinge je nachdem, welche Datenblatt Sie lesen sein): Position Common Name Technischer Name 1 Parallel-Ausgang 2 QB oder Q1 2 parallele Ausgabe 3 QC oder Q2 3 Parallelausgang 4 QD oder Q3 4 parallele Ausgabe 5 QE oder Q4 5 parallelen Ausgang QF 6 oder Q5 6 parallele Ausgabe 7 QG oder Q6 7 parallel Ausgang 8 QH oder Q7 8 Masse GND 9 seriellen Datenausgang QH 'oder Q7' oder Q7s 10 Master-Reset (active low) MR (mit einer Linie an der Spitze) oder SRCLR (mit einer Linie auf der Oberseite) 11 Uhr Stift SH_CP oder SRCLK 12 Raststift ST_CP oder RCLK 13 Ausgangsfreigabe (active low) OE (mit einer Linie auf der Oberseite) 14 Datenstift DS oder SER 15 Parallelausgang 1 QA oder Q0 16 5 Volt Versorgung VCC Die Verbindungen zwischen dem 74HC595 und Sparkfun Platte sind in der schematischen gezeigt und unten wiederholt: 74HC595 Sparkfun Breakout Board Q0 BLUE 4 und Schalter 4 Q1 BLUE 3 und SWITCH 3 Q2 BLUE 2 und SWITCH 2 Q3 BLUE 1 und SWITCH 1 Q4 (über Strombegrenzungswiderstand) LED GND 4 Q5 (über Strombegrenzungswiderstand) LED GND 3 Q6 (über Strombegrenzungswiderstand) LED GND 2 Q7 (über Strombegrenzungswiderstand) LED GND 1 Die restlichen Stifte haben die folgenden Verbindungen zu dem Arduino (auch in schematischer dargestellt): 74HC595 Arduino Vcc 5 V GND GND DS Digitale Pin 7 OE (Linie oben) GND ST_CP Digitale Pin 6 SH_CP Digitale Pin 5 MR (Linie oben) 5V Q7 'kein connectionStep 7: Header Pins Löten Sie zwei Reihen von acht Kopfstifte an die protoboard. Dies ist, wo das Flachbandkabel-Buchse wird auf die board.Step 8 befestigen: Strombegrenzungswiderstände Werden die 74HC595 werden Ansteuerung der LEDs in der Sparkfun Bord. Doch dieser Chip nur Ausgänge 0 oder 5 V und es ausgeben kann so viel wie 70 mA. Das bedeutet, wir müssen Strombegrenzungswiderstände verwenden Beschädigung der LEDs zu verhindern. Aus den Angaben der LEDs I verwendet: max Vorwärtsstrom: 30mA Vorwärtsspannung: 3.2V Berechnen Sie die benötigt wird, um diese max Bewertungen V = IR erreichen Widerstand: Widerstand = (5V-3,2V) / (0,03 A) = 60 Ohm Ich habe 68 Ohm-Widerstände, so dass ich war nicht auf das absolute Maximum Laufen, sondern auch um sicherzustellen, dass ich zu viel Helligkeit nicht zu verlieren. (Ich habe einen Fehler ein packte die 100KOhm Widerstände, wenn ich dieses Projekt gemacht, ich regelte es später, aber die Streifen von 100Ohm Widerstände sollte blau, grau, schwarz, gold, ignorieren Sie die Farben in den Bildern). Dies sind die Beispielrechnungen für die einzelnen LEDs I verwendet, Sie tun Sie Berechnungen auf der Grundlage der Spezifikationen Ihres LEDs besitzen müssen. Wenn Sie unsicher sind, was zu tun haben, nutzen 220ohm oder höher Widerstände; zu viel Widerstand machen die LEDs weniger hell, aber sie werden nicht beschädigt. Löten Sie vier Widerstände auf die protoboard, wie in den Bildern gezeigt. Schließen Sie die Leitungen der Widerstände mit ihren benachbarten Kopfstifte mit Lot (Abbildung 2) .Schritt 9: 74HC595 Buchse Löten Sie einen 8-poligen Buchse auf der Lochrasterplatinen, wie gezeigt in die Bilder above.Step 10: Anschlüsse an LEDs Wie in 6 gezeigt, sind die Ausgangspins (Q0-Q7) auf den Pins 1-7 und 15. Dieses Bild wurde von der genommen befindet Datenblatt des 74HC595. Schließen Sie die Widerstände auf die Stifte 4-7 mit Drahtbrücken wie in den Abbildungen 1 und 2 Connect Stifte 1-3 und 15, um den Kopfstiften gezeigt nach dem Schema (beachten Sie die Verkabelung in das Bild nicht korrekt ist, aber die schematische korrekt ist) . Die Stifte Verbindungen zum 74HC595 sollte wie folgt sein: Pin 15 - Blue 4 Pin 1 - Blue 3 Pin 2 - Blue 2 Pin 3 - Blue 1 Pin 4 - LED GND 4 Pin 5 - LED GND 3 Pin 6 - LED GND 2 Pin 7 - LED GND 1 Führen Sie die Stiftverbindungen erhalten Richtigkeit dieser Teil langsam tun und verweisen auf die schematische oft. Stellen Sie sicher, alle diese Verbindungen mit Lot elektrisch verbinden auf der Unterseite der Platine (2 und 4) Schritt 11: In Second 74HC595: Part 1 Jedes 74HC595 nur kann Quelle 70mA zu einer Zeit, für alle seine Stifte. Mit der 100-Ohm Strombegrenzungswiderstände, wenn alle 4 LEDs in einer Reihe stehen auf zur gleichen Zeit (mit Multiplex das ist die maximale Anzahl der LEDs, die möglicherweise auf zur gleichen Zeit sein kann), werden sie jeder Ziehung über 18mA, welche das setzt Stromanforderungen leicht über dem 70mA maximale Bewertung. Ich werde Zeichnung zusätzlicher Strom von den Stiften Q0-Q7, um die Tasten zu multiplexen (in späteren Schritten). Eine einfache Lösung für dieses Problem ist, eine andere 74HC595, um die Schaltung hinzuzufügen, wird es parallel zur Strom 74HC595 verdrahtet werden (siehe Schema). Dies wird uns zusätzliche 70mA aus auf alle 8 Pins zu ziehen. Fügen Sie ein weiteres 16-poligen Buchse auf der Lochrasterplatinen, wie in der 12 gezeigt images.Step: In Second 74HC595: Part 2 Drahtstifte 1-7 und 15 der Buchsen untereinander (siehe Hinweis auf schematisch). Diese Stifte entsprechen allen acht Ausgängen des 74HC595s.Step 13: In Second 74HC595: Teil 3 Verbinden Sie Pin 8 (Masse) und Pin 16 (5 V) der Buchsen zusammen (siehe Bild Anmerkung über schematisch) .Schritt 14: In Second 74HC595: Teil 4 Verbindung der Stifte 11, 12 und 14 der Buchsen zueinander. Diese entsprechen den Taktgeber, verriegeln und Daten-Pins des 74HC595s.Step 15: In Second 74HC595: Part 4 Drahtstift 10 auf 5 V (Pin 16) und Pin 13 auf Masse (Pin 8). Header-Pins: Pin 10 (MR) sollte hoch und Pin 13 (OE) sollte, um Daten an die Ausgangsstifte (Q0-Q7) .Schritt 16 senden niedrig sein Solder Kopfstifte an den perfboard so dass ein Arduino Uno kann passen auf sie einrasten. Achten Sie auf die ungeraden Pin Abstand zwischen digitalen Stiften 7 und 8, habe ich dieses Projekt so konzipiert, dass eine Verbindung zu Pin 8-13 ist nicht notwendig, ist es wahrscheinlich am besten, für Arduino Pins Kopfstiften 0-13 weglassen, so dass die Dinge zusammenschnappen einfacher (siehe Bild Hinweis) .Schritt 17: Schließen Sie 74HC595, um Arduino Schließen Sie drei 74HC595 Datenpins, digitale Stifte 5, 6 und 7. Verbinden Sie Masse und 5V Arduino Arduino zu entsprechenden Leistungs Pins. Steckerbelegung: 74HC595 Arduino Datenstift (Pin 14) Digitalstift 7 Raststift (Pin 12) Digitalstift 6 Uhr (Pin 11) Digitalstift 5Step 18: Test LEDs Laden Sie den Code unten auf die Arduino und testen, ob LEDs korrekt verdrahtet. Legen Sie zwei 74HC595s in die leeren Sockel, schließen Sie das Button PCB in die Fassung, und schließen Sie das Arduino auf die protoboard (Bild 1). Sie sollten jedes LED-Licht bis ein zu einer Zeit zu sehen, diese Schleife weiterhin zu wiederholen immer (siehe Video unten). Wenn dies nicht funktioniert, überprüfen Sie die Anschlüsse in den vorherigen Schritten und lassen Sie Ihre Verbindungen nach Kontinuität. Nicht auf den nächsten Schritten fortfahren, bis Sie die LEDs zum Laufen zu bringen. Weitere Informationen zu den 74HC595 und shiftOut, siehe Abb 2, das Datenblatt und die Arduino Referenzseite . // LED TEST w / 74HC595 // Von Amanda Ghassaei 2012 / * * Dieses Programm ist freie Software; es darf weitergegeben und / oder zu modifizieren * Es unter den Bedingungen der GNU General Public License, wie von veröffentlicht * Die Free Software Foundation; entweder Version 2 der Lizenz oder * (Nach Ihrer Option) jeder späteren Version. * * / // Diese Firmware leuchtet die jeweils von einem LED ein // Stiftverbindungen int Verriegelungsstift = 6; int clockPin = 5; int dataPin = 7; // Schleife Variablen Byte-i; Byte-j; // Speichervariable Byte dataToSend; Leere setup () { pinMode (Verriegelungsstift, OUTPUT); pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); } Leere Schleife () { for (i = 0; i <4; i ++) { for (j = 0; j <4; j ++) { dataToSend = (1 << (i + 4)) | (15 & ~ (1 << j)); // preprare Byte bis zu 74HC595 senden // Setlatch Pin niedrig, so dass die LEDs nicht beim Versenden in Bits ändern digital (Verriegelungsstift, LOW); // Am dataToSend verschieben sich die Bits shiftOut (dataPin, clockPin, LSBFIRST, dataToSend); // Setze Raststift hoch, so dass die LEDs leuchten digital (Verriegelungsstift, HIGH); Verzögerung (500); // warten } } } Schritt 19: Multiplexing mit Arduino und 74HC165 Die 74HC595 kann nur tun, parallel ausgegeben, so habe ich ein 74HC165, um den Zustand der Tasten über 4 Strombegrenzungswiderstände messen und senden diese Information an den Arduino. Mehr Infos über den Chip kann für sich finden Datenblatt . Beachten Sie in Figur 2, dass die 595 Chips aus den vorherigen Schritten wird Energie an den Tasten (wie sie es tun für die LEDs). Die 74HC165 hat folgende Stifte (der technische Name können etwas unterschiedlich je nachdem, welche Datenblatt Sie gerade lesen): Position / Common Name / Technischer Name 1 Raststift (active low) PL (mit einer Linie auf der Oberseite) 2 Taktpin CP 3 parallelen Eingang 4 D4 4 parallele Eingangs 5 ​​D5 5 parallelen Eingangs 6 D6 6 parallele Eingangs 7 D7 7 inverse seriellen Ausgang Q7 (mit einer Linie auf der Oberseite) 8 Masse GND 9 seriellen Ausgang (Datenanschluss) Q7 10 seriellen Eingang DS 11 parallele Eingangs 0 D0 12 parallele Eingangs 1 D1 13 parallele Eingangs 2 D2 14 parallele Eingangs 3 D3 15 Taktfreigabeeingang (active low) CE (mit einer Linie auf der Oberseite) 16 5 Volt Versorgung VCC Die Verbindungen zwischen dem 74HC165 und Sparkfun Platte sind in der schematischen gezeigt und unten wiederholt: 74HC165 -> Sparkfun Breakout Board D0 SWITCH GND 4 D1 SWITCH GND 3 D2 SWITCH GND 2 D3 SWITCH GND 1 (Beachten Sie, dass die 165 Pins sollten auch eine Verbindung über einen Widerstand an Masse haben - siehe Schema) Die restlichen Stifte haben die folgenden Verbindungen zu dem Arduino (auch in schematischer dargestellt): 74HC165 -> Arduino Vcc 5 V GND GND CE (Linie oben) GND DS GND Q7 Digitale Pin 2 Q7 (Linie oben) keine Verbindung PL (Linie oben) Digitale Pin 4 CP Digitale Pin 3Schritt 20: 74HC165: Part 1 Löten Sie ein drittes 16-poligen Buchse auf der Lochrasterplatinen, wird diese für den 74HC165 sein. Schließen Sie 5V an Pin 16 und Masse zu 8.Step 21-polig: 74HC165: Part 2 Pull Down Widerstände Früher habe ich die Widerstände in Reihe mit den Tasten D0-D3 des 165-Chip nach unten ziehen, um Boden, während die Tasten nicht gedrückt werden - dies ist ein "Pull-Down-Widerstand" bezeichnet. Löten Sie vier 10kOhm Widerstände zu den Pins neben den Kopfstiften (siehe Bild 1). Verbinden vier Drähte von den 74HC165 Eingänge D0-3 (Pins 11-14) in den Raum zwischen der männlichen Kopfstiften und den 10k Widerstände wie in Figur 3 und in der schematischen angedeutet (siehe auch gelbe Drähte in Figur 2). Drag Lot zwischen den Kopfstiften, die Drähte an die 165-Chip, und die Widerstände um sie zu verbinden (siehe Bild 3). Schließen Sie die andere Seite der vier Widerstände zueinander und zur Erde Arduino (siehe wieder FIG 3 und die schematisch). Wir werden die Versorgung der Tasten mit dem gleichen Versorgung, die Stromversorgung ist der LEDs - die 595 Chips. Drag Lot zwischen den Kopfstiften, die an die LED-BLUE (1-4) auf der Sparkfun Bord der Kopfstiften, die auf dem Board Sparkfun Schalter (1-4) anschließen anschließen (siehe Hinweis auf Figur 3 und 5) .Schritt 22: 74HC165: Teil 3 Schließen Sie die Datenstifte des 74HC165 in die Arduino (braunes Kabel) Pin-Anschlüsse (ebenfalls in schematischer dargestellt): 74HC165 Arduino PL (Linie oben) (Pin 1) Digitalstift D4 CP (Pin 2) Digitalstift D3 Q7 (Pin 9) Digitalstift D2Step 23: 74HC165: Teil 4 Verbinden Sie die Masse an Pin 15 (CE mit der Linie auf der Oberseite) und 10 (DS) des 74HC165.Step 24: Test Buttons Laden Sie den folgenden Code auf das Arduino. Wenn alles richtig verkabelt wird jede Taste leuchtet, während gedrückt. Wenn Sie bemerken, dass einige Tasten sind nicht so reagieren, reinigen Sie die leitenden Ringe und die Spuren auf der Leiterplatte mit Wasser und Trocknen gründlich, diese zu lösen einige Probleme Antwort für mich. // TASTE TEST w / 74HC595 und 74HC165 // Von Amanda Ghassaei 2012 / * * Dieses Programm ist freie Software; es darf weitergegeben und / oder zu modifizieren * Es unter den Bedingungen der GNU General Public License, wie von veröffentlicht * Die Free Software Foundation; entweder Version 2 der Lizenz oder * (Nach Ihrer Option) jeder späteren Version. * * / // Diese Firmware verursacht die Tasten zu leuchten kurzzeitig während sie gedrückt werden. // Stiftverbindungen int ledLatchPin = 6; int ledClockPin = 5; int ledDataPin = 7; int buttonLatchPin = 4; int buttonClockPin = 3; int buttonDataPin = 2; // Schleife Variablen Byte-i; Byte-j; Byte k; // Speicher für LED-Zustände, 4 Byte Byte ledData [] = {0, 0, 0, 0}; // Speicher für Tasten, 4 Byte Byte buttonCurrent [] = {0,0,0,0}; Byte buttonLast [] = {0,0,0,0}; Byte Button [] = {0,0,0,0}; Byte Button [] = {0,0,0,0}; // Button debounce Gegen 16 Bytes Byte buttonDebounceCounter [4] [4]; Leere setup () { DDRD = 0xFA; // Satz Stifte D7-D4 als Ausgabe, D2 als Eingangs } // ButtonCheck - überprüft den Zustand einer bestimmten Taste. // Dies buttoncheck Funktion weitgehend aus dem monome 40h Firmware von Brian Crabtree und joe See kopiert Leere buttonCheck (byte Reihe, Byte-Index) { if (((buttonCurrent [row] ^ buttonLast [Reihe]) & (1 << index)) && // wenn die aktuelle physische Taste Zustand, die von der ist ((ButtonCurrent [row] ^ Button [Reihe]) & (1 << index))) {// letzten physischen Schaltzustand und der aktuelle Zustand entprellt if (buttonCurrent [Zeile] & (1 << index)) {// wenn die aktuelle körperliche Zustand Taste gedrückt wird Button [row] = 1 << index; // Sofort Warteschlange eine neue Schaltfläche Ereignis Button [Zeile] | = (1 << index); // Und den entprellt Zustand nach unten. } else { buttonDebounceCounter [Zeile] [index] = 12; } // Andernfalls die Taste zuvor gedrückt und jetzt // Freigegeben wurde, so wir unsere Entprellzähler. } else if (((buttonCurrent [row] ^ buttonLast [Reihe]) & (1 << index)) == 0 && // wenn die aktuelle physische Taste Zustand ist die gleiche wie (ButtonCurrent [row] ^ Button [Reihe]) & (1 << index)) {// die letzte physische Taste Staat, sondern der aktuelle physikalische // Button Zustand, die von der aktuellen debounce ist // Stand ... if (buttonDebounceCounter [row] [Index]> 0 && --buttonDebounceCounter [row] [Index] == 0) {// wenn das die Entprellzähler hat // Auf 0 heruntergezählt worden ist (was bedeutet, die // Die Taste hat für gewesen // KButtonUpDefaultDebounceCount // Iterationen /// Button [row] = 1 << index; // Schlange eine Schaltfläche Zustandsänderungsereignis if (buttonCurrent [Zeile] & (1 << index)) {// und drücken Sie die Tasten debounce Zustand. Button [Zeile] | = (1 << index); } else { Button [row] und = ~ (1 << index); } } } } Leere shift () { for (i = 0; i <4; i ++) { buttonLast [i] = buttonCurrent [i]; Byte dataToSend = (1 << (i + 4)) | (15 & ~ ledData [i]); // Setze Raststift niedrig, so dass die LEDs nicht beim Versenden in Bits ändern digital (ledLatchPin, LOW); // Verschieben sich die Bits dataToSend shiftOut (ledDataPin, ledClockPin, LSBFIRST, dataToSend); // Setze Raststift hoch, so dass die LEDs werden neue Daten zu empfangen digital (ledLatchPin, HIGH); // Einmal eine Zeile wurde hoch eingestellt ist, empfangen Daten von Tasten // Setze Raststift hoch digital (buttonLatchPin, HIGH); // Verschiebung der Daten buttonCurrent [i] = Shiftin (buttonDataPin, buttonClockPin, LSBFIRST) >> 3; // Verriegelungsstift niedrig digital (buttonLatchPin, LOW); for (k = 0; k <4; k ++) { buttonCheck (i, k); } } } Leere updateLEDs () {// Die LEDs zu aktualisieren, um hte Zustand der Tasten zu reflektieren for (j = 0; j <4; j ++) { ledData [j] = Button [j]; } } Leere Schleife () { verschieben (); updateLEDs (); } Schritt 25: Serielle Kommunikation An dieser Stelle in das Projekt habe ich ein wenig ungeduldig und wollte beginnen, einige Klänge, so dass ich noch ein paar Dinge, auf die Firmware, um die Arduino Senden und Empfangen von Daten seriell. Ich habe den Code unten geschrieben. Ich habe eine Timer-Interrupt, um den Arduino, die auf eingehenden seriellen Nachrichten halten, können Sie ein wenig mehr darüber, wie das hier funktioniert lesen. (Wenn Sie vorhaben, diesen Code zu testen, verwenden Sie die App angebracht ist, ist die neuere Version des Beat-Slicer-App auf Github ein wenig anders). // TASTE TEST w / 74HC595 und 74HC165 und serielle Kommunikation // Von Amanda Ghassaei // Juni 2012 / * * Dieses Programm ist freie Software; es darf weitergegeben und / oder zu modifizieren * Es unter den Bedingungen der GNU General Public License, wie von veröffentlicht * Die Free Software Foundation; entweder Version 2 der Lizenz oder * (Nach Ihrer Option) jeder späteren Version. * * / // Diese Firmware wird Daten hin und her mit dem MaxMSP Patch senden "Beat Slicer" // Stiftverbindungen int ledLatchPin = 6; int ledClockPin = 5; int ledDataPin = 7; int buttonLatchPin = 4; int buttonClockPin = 3; int buttonDataPin = 2; // Schleife Variablen Byte-i; Byte-j; Byte k; Byte ledByte; // Speicher für LED-Zustände, 4 Byte Byte ledData [] = {0, 0, 0, 0}; // Speicher für Tasten, 4 Byte Byte buttonCurrent [] = {0,0,0,0}; Byte buttonLast [] = {0,0,0,0}; Byte Button [] = {0,0,0,0}; Byte Button [] = {0,0,0,0}; // Button debounce Gegen 16 Bytes Byte buttonDebounceCounter [4] [4]; Leere setup () { DDRD = 0xFA; // Satz Stifte D7-D4 als Ausgabe, D2 als Eingangs Serial.begin (57600); cli (); // Stop-Interrupts // Setze timer2 alle 128us zu unterbrechen TCCR2A = 0; // gesetzt gesamten TCCR2A Register auf 0 TCCR2B = 0; // gleiche für TCCR2B TCNT2 = 0; // initialisieren Zählerwert auf 0 // Set vergleichen Einstimmungsregister für 7.8khz Schritten OCR2A = 255; // = (16 * 10 ^ 6) / (7812,5 * 8) - 1 (muss <256) // Auf CTC-Modus schalten TCCR2A | = (1 << WGM21); // Set CS11-Bit für 8 Vorteiler TCCR2B | = (1 << CS11); // Timer aktivieren vergleichen zu unterbrechen TIMSK2 | = (1 << OCIE2A); sei (); // ermöglichen Interrupts } // ButtonCheck - überprüft den Zustand einer bestimmten Taste. // Dies buttoncheck Funktion weitgehend aus dem monome 40h Firmware von Brian Crabtree und joe See kopiert Leere buttonCheck (byte Reihe, Byte-Index) { if (((buttonCurrent [row] ^ buttonLast [Reihe]) & (1 << index)) && // wenn die aktuelle physische Taste Zustand, die von der ist ((ButtonCurrent [row] ^ Button [Reihe]) & (1 << index))) {// letzten physischen Schaltzustand und der aktuelle Zustand entprellt if (buttonCurrent [Zeile] & (1 << index)) {// wenn die aktuelle körperliche Zustand Taste gedrückt wird Button [row] = 1 << index; // Sofort Warteschlange eine neue Schaltfläche Ereignis Button [Zeile] | = (1 << index); // Und den entprellt Zustand nach unten. } else { buttonDebounceCounter [Zeile] [index] = 12; } // Andernfalls die Taste zuvor gedrückt und jetzt // Freigegeben wurde, so wir unsere Entprellzähler. } else if (((buttonCurrent [row] ^ buttonLast [Reihe]) & (1 << index)) == 0 && // wenn die aktuelle physische Taste Zustand ist die gleiche wie (ButtonCurrent [row] ^ Button [Reihe]) & (1 << index)) {// die letzte physische Taste Staat, sondern der aktuelle physikalische // Button Zustand, die von der aktuellen debounce ist // Stand ... if (buttonDebounceCounter [row] [Index]> 0 && --buttonDebounceCounter [row] [Index] == 0) {// wenn das die Entprellzähler hat // Auf 0 heruntergezählt worden ist (was bedeutet, die // Die Taste hat für gewesen // KButtonUpDefaultDebounceCount // Iterationen /// Button [row] = 1 << index; // Schlange eine Schaltfläche Zustandsänderungsereignis if (buttonCurrent [Zeile] & (1 << index)) {// und drücken Sie die Tasten debounce Zustand. Button [Zeile] | = (1 << index); } else { Button [row] und = ~ (1 << index); } } } } Leere shift () { for (i = 0; i <4; i ++) { buttonLast [i] = buttonCurrent [i]; Byte dataToSend = (1 << (i + 4)) | (15 & ~ ledData [i]); // Setze Raststift niedrig, so dass die LEDs nicht beim Versenden in Bits ändern digital (ledLatchPin, LOW); // Verschieben sich die Bits dataToSend shiftOut (ledDataPin, ledClockPin, LSBFIRST, dataToSend); // Setze Raststift hoch, so dass die LEDs werden neue Daten zu empfangen digital (ledLatchPin, HIGH); // Einmal eine Zeile wurde hoch eingestellt ist, empfangen Daten von Tasten // Setze Raststift hoch digital (buttonLatchPin, HIGH); // Verschiebung der Daten buttonCurrent [i] = Shiftin (buttonDataPin, buttonClockPin, LSBFIRST) >> 3; // Verriegelungsstift niedrig digital (buttonLatchPin, LOW); for (k = 0; k <4; k ++) { buttonCheck (i, k); if (Button [i] <> 1) und 3; Byte LEDx = (ledByte >> 3) & 3; if (LED-Status) { ledData [ledy] | = 8 >> LEDx; } else { ledData [ledy] & = ~ (8 >> LEDx); } } // End if Serien verfügbar } // End tun while (Serial.available ()> 8); } Leere Schleife () { shift();//updates leds and receives data from buttons } I sent this serial data to an audio processing application I wrote in MaxMSP. You can download this application below (called beat slicer) and open it with MaxMSP or MaxRuntime (free version) here . I'm running Max 5, I assume it will work on Max 6 as well. It will prompt you to select an audio file (wav, mp3, aiff). Then you can manipulate this audio file using the button grid as shown in the video below: Step 26: Battery Alle 10 Artikel anzeigen One of my main objectives for this project was to make something portable, so the next step is to add portable power. I used a rechargeable Li-Po battery to minimize waste and provide enough power for hours of use. Additionally, I wanted a Li-Po battery that only had two leads coming out of it so that I could charge it using a regular barrel plug. Here are the parts for the power setup, taken from the parts list on the first page: Li-Ion 7.4V Tenergy 2200mAh Rechargeable Battery module with PCB Amazon Tenergy Universal Smart Charger for Li-Ion/Polymer battery Pack (3.7V-14.8V 1-4 cells) Amazon Size N Panel-Mount Coaxial DC Power Jack Radioshack 274-1576 Size N Coaxial DC Power Plug Radioshack 274-1573 SPST Toggle Switch Radioshack 275-634 Cut and strip the two leads from the battery (do not let them short out). Make connections between the battery, plug, switch and Arduino according to the schematic above. I like to always attach ground to the outside part of the coaxial jack, but you can wire it however you like (just make sure your wiring of the charger is consistent!). Cut and strip the two leads from the charger. Solder the n type barrel plug to these leads as shown in the image above. Make sure that the polarity of your charger's barrel plug matches the polarity of the jack. Again, I've chosen to connect ground to the outside part of the coaxial jack/plug in the images above. Now the switch acts as an on/off switch to the Arduino and the battery can be charged via the barrel plug. Charging Li-Po batteries is a somewhat complicated procedure that involves balancing the cells of the battery, I'm not sure if hooking up the Arduino in parallel with the battery during charging will interfere with this process. Just to be safe, I'm always sure to switch the power switch off during charging, thereby removing the Arduino from the circuit. Note- be careful when using Li-Po batteries, improper use can result in fire. Be careful not to short circuit the battery and always use the proper charger.Step 27: Midi Out Show All 13 Items This instrument is primarily a MIDI device, so we need to build a MIDI out. There are two ways to do this (and over the course of this project I did one and then switched to the other): output MIDI via a 5 pin DIN connector (see fig 1) output MIDI via USB (this is what I eventually settled on) Either of these options is fine, I chose USB because I didn't want to have to carry a special MIDI to USB cable all the time. If you have a lot of synthesizers that receive a 5 pin MIDI input, it might be more convenient for you to use the 5 pin jack (it's also a little easier). I'll go through both processes below: 5 pin connection: Solder a 220ohm resistor to pin 4 of the MIDI jack and connect to Arduino 5V. Solder a wire between MIDI pin 2 and ground. Solder a wire between MIDI pin 5 and digital pin 1 (TX). MIDI over USB: MIDI over USB is a little tricky. Ideally we'd be able to send MIDI out the USB port already connected to the Arduino, but this turns out to be more trouble than it's worth in my opinion. You can read a little bit about various solutions here . Instead, I found a really great tutorial that explains how you can take apart a cheap MIDI to USB cable , solder new connections to it, and tuck it inside your project enclosure with your Arduino, to create a secondary MIDI-USB output. The process is explained really well on the Shiftmore blog, but the MIDI to USB cable I received from amazon was a little different, so I'll describe the process again here. Remove the plastic casing from the MIDI to USB cable and unsolder the connections to the cables on either end (fig 8). The USB connections are shown here , make the following connections: 5V + DP D+ DM D- VSS - As you can see in figs 9 and 10, I used a pieced of perf board to make the connections to the USB jack. On the other side of the MIDI to USB board, make the following connections to the Ardunio: IN- Digital Pin 1 (TX) GND Arduino Ground Testing it out: Load the firmware below onto the Arduino (also in attached file), it will turn the keypad into a simple MIDI device: pressing each of the buttons will cause the button to light up and trigger a MIDI note. Disconnect the Arduino's serial connection and connect the MIDI output to a MIDI instrument or your computer to hear the MIDI notes. You should also see the yellow MIDI IN light on the MIDI to USB board turn on with each note. More info about programming the Arduino to send MIDI can be found here. //basic midi test //by Amanda Ghassaei 2012 / * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * / //this firmware will cause the buttons to light up momentarily while they are pressed. //pin connections int ledLatchPin = 6; int ledClockPin = 5; int ledDataPin = 7; int buttonLatchPin = 4; int buttonClockPin = 3; int buttonDataPin = 2; //looping variables byte i; byte j; byte k; //storage for led states, 4 bytes byte ledData[] = {0, 0, 0, 0}; //storage for buttons, 4 bytes byte buttonCurrent[] = {0,0,0,0}; byte buttonLast[] = {0,0,0,0}; byte buttonEvent[] = {0,0,0,0}; byte buttonState[] = {0,0,0,0}; //button debounce counter- 16 bytes byte buttonDebounceCounter[4][4]; //MIDI variables int velocity = 100; int noteON = 144; int MIDIoffset = 60; void setup() { DDRD = 0xFA;//set pins D7-D4 as output, D2 as input Serial.begin(31250);//set midi baud rate } // buttonCheck - checks the state of a given button. //this buttoncheck function is largely copied from the monome 40h firmware by brian crabtree and joe lake void buttonCheck(byte row, byte index) { if (((buttonCurrent[row] ^ buttonLast[row]) & (1 << index)) && // if the current physical button state is different from the ((buttonCurrent[row] ^ buttonState[row]) & (1 << index))) { // last physical button state AND the current debounced state if (buttonCurrent[row] & (1 << index)) { // if the current physical button state is depressed buttonEvent[row] = 1 << index; // queue up a new button event immediately buttonState[row] |= (1 << index); // and set the debounced state to down. } else{ buttonDebounceCounter[row][index] = 12; } // otherwise the button was previously depressed and now // has been released so we set our debounce counter. } else if (((buttonCurrent[row] ^ buttonLast[row]) & (1 << index)) == 0 && // if the current physical button state is the same as (buttonCurrent[row] ^ buttonState[row]) & (1 << index)) { // the last physical button state but the current physical // button state is different from the current debounce // state... if (buttonDebounceCounter[row][index] > 0 && --buttonDebounceCounter[row][index] == 0) { // if the the debounce counter has // been decremented to 0 (meaning the // the button has been up for // kButtonUpDefaultDebounceCount // iterations/// buttonEvent[row] = 1 << index; // queue up a button state change event if (buttonCurrent[row] & (1 << index)){ // and toggle the buttons debounce state. buttonState[row] |= (1 << index); } else{ buttonState[row] &= ~(1 << index); } } } } void shift(){ for (i=0;i<4;i++){ buttonLast[i] = buttonCurrent[i]; byte dataToSend = (1 << (i+4)) | (15 & ~ledData[i]); // set latch pin low so the LEDs don't change while sending in bits digitalWrite(ledLatchPin, LOW); // shift out the bits of dataToSend shiftOut(ledDataPin, ledClockPin, LSBFIRST, dataToSend); //set latch pin high so the LEDs will receive new data digitalWrite(ledLatchPin, HIGH); //once one row has been set high, receive data from buttons //set latch pin high digitalWrite(buttonLatchPin, HIGH); //shift in data buttonCurrent[i] = shiftIn(buttonDataPin, buttonClockPin, LSBFIRST) >> 3; //latchpin low digitalWrite(buttonLatchPin, LOW); for (k=0;k<4;k++){ buttonCheck(i,k); } } } void updateLEDs(){ //update the leds to reflect hte state of the buttons for (j=0;j<4;j++){ ledData[j] = buttonState[j]; } } void MIDImessage(int command, int MIDInote, int MIDIvelocity) {//send sa MIDI message Serial.write(command);//send note on or note off command Serial.write(MIDInote);//send pitch data Serial.write(MIDIvelocity);//send velocity data } void sendMIDI(){ for (byte a=0;a<4;a++){ for (byte b=0;b<4;b++){ if (buttonEvent[a]&(1<<b)){ buttonEvent[a]&=~(1<<b);//zero button event if (buttonState[a]&(1<<b)){ MIDImessage(noteON,(MIDIoffset+a*5+b),100); } else{ MIDImessage(noteON,(MIDIoffset+a*5+b),0); } } } } } Leere Schleife () { shift(); updateLEDs(); sendMIDI(); } Step 28: Accerometer/Gyro Alle 9 Artikel anzeigen I attached a 2 axis gyroscope and 3 axis accelerometer onto this project so that I could add some interesting control to the device. The 5 degrees of freedom board from Sparkfun outputs data from its gyroscope and accelerometer as analog voltages. I sent these to analog pin 0-4. You may notice that the Gyro has four outputs- I chose to use the X/Y4.5 out instead of the X/YRate out because the 4.5 has higher resolution. I wrote more about this board and explained some of the code I used to get it up and running here. Solder header pins on the gyro/accelerometer board. Solder on the perfboard, making sure to leave room for the Arduino to fit on top. Make the following pin connections: RAW - Arduino 5V GND- Arduino ground X4.5- A2 Y4.5- A0 XAcc- A4 YAcc- A3 ZAcc- A1 (I ended up disconnecting this later to free up an analog input for a second potentiometer) Upload the following code and check the serial monitor to make sure accelerometer/gyro is functioning properly. When the board is lying still and parallel to the ground the values of xGyro, yGyro, xAcc, and yAcc should all hover around 0. zAcc should output a value around -66 (see fig 8). Move the board around and see how the values change. In figure 9 you can see how rotation about the x axis changes xGyro and y and zAcc, but not yGyro or xAcc. //Analog Accerometer w Serial //by Amanda Ghassaei //instructables.com/amandaghassaei //August 2012 / * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * / //setup acceleration variables int xAcc; int yAcc; int zAcc; //setup gyre variables int xGyro; int yGyro; int zero = 282;//this was the zero point value for my accelerometer, your board may be slightly different. void setup(){ Serial.begin(9600);//set up serial } void loop(){ //read values xGyro = analogRead(A2); yGyro = analogRead(A0); xAcc = analogRead(A4); yAcc = analogRead(A3); zAcc = analogRead(A1); //print values Serial.print("xGyro "); Serial.println(317-xGyro); Serial.print("yGyro "); Serial.println(183-yGyro); Serial.print("xAcc "); Serial.println(zero-xAcc); Serial.print("yAcc "); Serial.println(zero-yAcc); Serial.print("zAcc "); Serial.println(zero-zAcc); Serial.println(" "); delay(500);//wait } The following pieces of firmware combine the hardware that I've set up in the preview steps with the accelerometer and gyroscope. Each of the programs functions are summarized in the video below: The code below lets you light up one pixel of the button pad and move the pixel around the 4x4 grid by tilting it in different directions. As the pixel moves across the grid it also triggers MIDI notes. //accelerometer test //by Amanda Ghassaei 2012 / * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * / //this firmware will cause the buttons to light up momentarily while they are pressed. //pin connections int ledLatchPin = 6; int ledClockPin = 5; int ledDataPin = 7; int buttonLatchPin = 4; int buttonClockPin = 3; int buttonDataPin = 2; //setup varibles for Gyroscope/Accelerometer int xGyroRAW; int yGyroRAW; int xAccRAW; int yAccRAW; int zAccRAW; byte xGyro; byte yGyro; byte xAcc; byte yAcc; byte zAcc; //looping variables byte i; byte j; byte k; //storage for led states, 4 bytes byte ledData[] = {0, 0, 0, 0}; //storage for buttons, 4 bytes byte buttonCurrent[] = {0,0,0,0}; byte buttonLast[] = {0,0,0,0}; byte buttonEvent[] = {0,0,0,0}; byte buttonState[] = {0,0,0,0}; //button debounce counter- 16 bytes byte buttonDebounceCounter[4][4]; //variables for accelerometer pixel movement boolean firstPress = 1; byte movingPixel[] = {0, 0, 0, 0}; byte yPosition; byte xPosition; int timeX = 0; int timeY = 0; boolean dirX = 0; boolean dirY = 0; byte lastX = 4; byte lastY = 4; //MIDI variables int velocity = 100; int noteON = 144; int MIDIoffset = 60; byte currentX; void setup() { DDRD = 0xFA;//set pins D7-D4 as output, D2 as input Serial.begin(31250);//MIDI baud rate // Serial.begin(9600); cli();//stop interrupts //set timer1 interrupt at 1kHz TCCR1A = 0;// set entire TCCR1A register to 0 TCCR1B = 0;// same for TCCR1B TCNT1 = 0;//initialize counter value to 0; // set timer count for 1khz increments OCR1A = 1999;// = (16*10^6) / (1000*8) - 1 // turn on CTC mode TCCR1B |= (1 << WGM12); // Set CS11 bit for 8 prescaler TCCR1B |= (1 << CS11); // enable timer compare interrupt TIMSK1 |= (1 << OCIE1A); sei();//allow interrupts } ISR(TIMER1_COMPA_vect) {//Interrupt at freq of 1kHz timeX++;//increment timeX timeY++;//increment timeY } // buttonCheck - checks the state of a given button. //this buttoncheck function is largely copied from the monome 40h firmware by brian crabtree and joe lake void buttonCheck(byte row, byte index) { if (((buttonCurrent[row] ^ buttonLast[row]) & (1 << index)) && // if the current physical button state is different from the ((buttonCurrent[row] ^ buttonState[row]) & (1 << index))) { // last physical button state AND the current debounced state if (buttonCurrent[row] & (1 << index)) { // if the current physical button state is depressed buttonEvent[row] = 1 << index; // queue up a new button event immediately buttonState[row] |= (1 << index); // and set the debounced state to down. } else{ buttonDebounceCounter[row][index] = 12; } // otherwise the button was previously depressed and now // has been released so we set our debounce counter. } else if (((buttonCurrent[row] ^ buttonLast[row]) & (1 << index)) == 0 && // if the current physical button state is the same as (buttonCurrent[row] ^ buttonState[row]) & (1 << index)) { // the last physical button state but the current physical // button state is different from the current debounce // state... if (buttonDebounceCounter[row][index] > 0 && --buttonDebounceCounter[row][index] == 0) { // if the the debounce counter has // been decremented to 0 (meaning the // the button has been up for // kButtonUpDefaultDebounceCount // iterations/// buttonEvent[row] = 1 << index; // queue up a button state change event if (buttonCurrent[row] & (1 << index)){ // and toggle the buttons debounce state. buttonState[row] |= (1 << index); } else{ buttonState[row] &= ~(1 << index); } } } } void shift(){ for (i=0;i<4;i++){ buttonLast[i] = buttonCurrent[i]; byte dataToSend = (1 << (i+4)) | (15 & ~ledData[i]); // set latch pin low so the LEDs don't change while sending in bits digitalWrite(ledLatchPin, LOW); // shift out the bits of dataToSend shiftOut(ledDataPin, ledClockPin, LSBFIRST, dataToSend); //set latch pin high so the LEDs will receive new data digitalWrite(ledLatchPin, HIGH); //once one row has been set high, receive data from buttons //set latch pin high digitalWrite(buttonLatchPin, HIGH); //shift in data buttonCurrent[i] = shiftIn(buttonDataPin, buttonClockPin, LSBFIRST) >> 3; //latchpin low digitalWrite(buttonLatchPin, LOW); for (k=0;k<4;k++){ buttonCheck(i,k); } } } void checkFirstButton(){ for (byte a=0;a<4;a++){ if (buttonEvent[a]){ for (byte b=0;b<4;b++){ if (buttonState[a]&(1<=-10){ return 5; } else if (RAW<-10){ if (RAW<-50){ return 0; } else if (RAW<-40){ return 1; } else if (RAW<-30){ return 2; } else if (RAW<-20){ return 3; } else{ return 4; } } else if (RAW>10){ if (RAW>50){ return 10; } else if (RAW>40){ return 9; } else if (RAW>30){ return 8; } else if (RAW>20){ return 7; } else{ return 6; } } } void checkAccelerometer(){ //read values xGyroRAW = analogRead(A1); yGyroRAW = analogRead(A0); xAccRAW = analogRead(A4); yAccRAW = analogRead(A3); zAccRAW = analogRead(A2); //offset data xGyroRAW = 317-xGyroRAW; yGyroRAW = 183-yGyroRAW; xAccRAW = 282-xAccRAW; yAccRAW = 282-yAccRAW; zAccRAW = 282-zAccRAW; if (xAccRAW>0){ dirX = 1; } else{ dirX = 0; } if (yAccRAW>0){ dirY = 1; } else{ dirY = 0; } //convert to 0-10 xAcc = scaleAcc(xAccRAW); yAcc = scaleAcc(yAccRAW); } int getTime(byte acceleration){ switch (acceleration){ case 0://max - acceleration return 25; Unterbrechung; case 1: return 25; Unterbrechung; case 2: return 50; Unterbrechung; case 3: return 100; Unterbrechung; case 4: return 150; Unterbrechung; case 5://lying flat return 0; Unterbrechung; case 6: return 150; Unterbrechung; case 7: return 100; Unterbrechung; case 8: return 50; Unterbrechung; case 9: return 25; Unterbrechung; case 10://max + acceleration return 25; Unterbrechung; } } void moveXPixel(int timeComp){ if (timeComp==0){ } else{ if (timeX>timeComp){ timeX = 0; if (dirX){ if (xPosition==8){ } else{ xPosition = xPosition<<1; } } else{ if (xPosition==1){ } else{ xPosition = xPosition>>1; } } } } } void moveYPixel(int timeComp){ if (timeComp==0){ } else{ if (timeY>timeComp){ timeY = 0; if (dirY){ if (yPosition==3){ } else{ yPosition = yPosition+=1; } } else{ if (yPosition==0){ } else{ yPosition = yPosition-=1; } } } } } void checkMIDI(){ //convert xPosition to decimal switch (xPosition){ case 1: currentX = 0; Unterbrechung; case 2: currentX = 1; Unterbrechung; case 4: currentX = 2; Unterbrechung; case 8: currentX = 3; Unterbrechung; } //if pixel has moved send midi if (lastX != currentX || lastY != yPosition){ MIDImessage(noteON,(lastX+5*lastY+MIDIoffset),0);//turn off last note MIDImessage(noteON,(currentX+5*yPosition+MIDIoffset),velocity);//turn on next note } lastX = currentX; lastY = yPosition; } void MIDImessage(int command, int MIDInote, int MIDIvelocity) {//send sa MIDI message Serial.write(command);//send note on or note off command Serial.write(MIDInote);//send pitch data Serial.write(MIDIvelocity);//send velocity data } Leere Schleife () { shift(); if (firstPress){ checkFirstButton(); } else{ for (byte pixel=0;pixel<4;pixel++){ if (pixel==yPosition){ ledData[pixel]=xPosition; } else{ ledData[pixel] = 0; } } checkAccelerometer(); moveXPixel(getTime(xAcc)); moveYPixel(getTime(yAcc)); checkMIDI(); } } The code below lets you light up one pixel in each column. As you tilt the gyroscope, the pixels bounce against the edge of the grid and trigger a MIDI note. //accelerometer test //by Amanda Ghassaei 2012 / * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * / //this firmware will cause the buttons to light up momentarily while they are pressed. //pin connections //#define ledLatchPin 6 //#define ledClockPin 5 //#define ledDataPin 7 //#define buttonLatchPin 4 //#define buttonClockPin 3 //#define buttonDataPin 2 //setup varibles for Gyroscope/Accelerometer int xGyroRAW; int yGyroRAW; int xAccRAW; int yAccRAW; int zAccRAW; byte xGyro; byte yGyro; byte xAcc; byte yAcc; byte zAcc; //looping variables byte i; byte j; byte k; //storage for led states, 4 bytes byte ledData[] = {0, 0, 0, 0}; //storage for buttons, 4 bytes byte buttonCurrent[] = {0,0,0,0}; byte buttonLast[] = {0,0,0,0}; byte buttonEvent[] = {0,0,0,0}; byte buttonState[] = {0,0,0,0}; //button debounce counter- 16 bytes byte buttonDebounceCounter[4][4]; //variables for accelerometer pixel movement boolean firstPress[] = {0, 0, 0, 0}; byte movingPixel[] = {0, 0, 0, 0}; byte xPosition[4]; int timeX[] = {0, 0, 0, 0}; boolean dirX; boolean dirY; boolean prevDirX = 0; boolean bounceDirection[]= {0, 0, 0, 0}; boolean toggle[] = {1, 1, 1, 1}; byte peakHeight[4]; byte lastX = 4; byte lastY = 4; //MIDI variables int velocity = 100; int noteON = 144; int MIDIoffset = 60; byte currentX; byte note[] = {60, 64, 67, 72}; void setup() { DDRD = 0xFA;//set pins D7-D4 as output, D2 as input Serial.begin(31250);//MIDI baud rate cli();//stop interrupts //set timer1 interrupt at 1kHz TCCR1A = 0;// set entire TCCR1A register to 0 TCCR1B = 0;// same for TCCR1B TCNT1 = 0;//initialize counter value to 0; // set timer count for 1khz increments OCR1A = 1999;// = (16*10^6) / (1000*8) - 1 // turn on CTC mode TCCR1B |= (1 << WGM12); // Set CS11 bit for 8 prescaler TCCR1B |= (1 << CS11); // enable timer compare interrupt TIMSK1 |= (1 << OCIE1A); sei();//allow interrupts } ISR(TIMER1_COMPA_vect) {//Interrupt at freq of 1kHz for (byte a=0;a<4;a++){ timeX[a]++;//increment each element of timeX } shift(); } // buttonCheck - checks the state of a given button. //this buttoncheck function is largely copied from the monome 40h firmware by brian crabtree and joe lake void buttonCheck(byte row, byte index) { if (((buttonCurrent[row] ^ buttonLast[row]) & (1 << index)) && // if the current physical button state is different from the ((buttonCurrent[row] ^ buttonState[row]) & (1 << index))) { // last physical button state AND the current debounced state if (buttonCurrent[row] & (1 << index)) { // if the current physical button state is depressed buttonEvent[row] = 1 << index; // queue up a new button event immediately buttonState[row] |= (1 << index); // and set the debounced state to down. } else{ buttonDebounceCounter[row][index] = 12; } // otherwise the button was previously depressed and now // has been released so we set our debounce counter. } else if (((buttonCurrent[row] ^ buttonLast[row]) & (1 << index)) == 0 && // if the current physical button state is the same as (buttonCurrent[row] ^ buttonState[row]) & (1 << index)) { // the last physical button state but the current physical // button state is different from the current debounce // state... if (buttonDebounceCounter[row][index] > 0 && --buttonDebounceCounter[row][index] == 0) { // if the the debounce counter has // been decremented to 0 (meaning the // the button has been up for // kButtonUpDefaultDebounceCount // iterations/// buttonEvent[row] = 1 << index; // queue up a button state change event if (buttonCurrent[row] & (1 << index)){ // and toggle the buttons debounce state. buttonState[row] |= (1 << index); } else{ buttonState[row] &= ~(1 << index); } } } } void shift(){ for (i=0;i<4;i++){ buttonLast[i] = buttonCurrent[i]; byte dataToSend = (1 << (i+4)) | (15 & ~ledData[i]); // set latch pin low so the LEDs don't change while sending in bits PORTD&=B10111111;//digitalWrite(ledLatchPin, LOW); // shift out the bits of dataToSend //shiftOut(ledDataPin, ledClockPin, LSBFIRST, dataToSend); for (j=0;j<8;j++){ PORTD&=B11011111;//digitalWrite(ledClockPin,LOW); //digitalWrite(ledDataPin,((dataToSend>>j)&1)); if ((dataToSend>>j)&1){ PORTD|=B10000000; } else{ PORTD&=B01111111; } PORTD|=B00100000;//digitalWrite(ledClockPin,HIGH); } //set latch pin high so the LEDs will receive new data PORTD|=B01000000;//digitalWrite(ledLatchPin, HIGH); // SlowDown is put in here to waste a little time while we wait for the state of the output // pins to settle. Without this time wasting loop, a single button press would show up as // two presses (the button and its neighbour) volatile int SlowDown = 0; while (SlowDown < 15) { SlowDown++; } //once one row has been set high, receive data from buttons //set latch pin high PORTD|=B00010000;//digitalWrite(buttonLatchPin, HIGH); //shift in data //buttonCurrent[i] = shiftIn(buttonDataPin, buttonClockPin, LSBFIRST) >> 3; for (j=0;j<4;j++){ PORTD&=B11110111;//digitalWrite(buttonClockPin,LOW); PORTD|=B00001000;//digitalWrite(buttonClockPin,HIGH); } for (j=0;j<4;j++){ PORTD&=B11110111;//digitalWrite(buttonClockPin,LOW); if ((PIND>>2)&1){//digitalRead(buttonDataPin) buttonCurrent[i]|=1< Step 29: Pots Connect a black wire to the left lead of a 10K linear taper potentiometer. Connect a green wire to the middle lead. Connect a red wire to the remaining lead. Repeat this for the other potentiometer. Connect the other end of the red wires to 5V, the black wires to ground, and the green wires to Analog in Use pliers to remove the pin on the side of the pots, so that you can mount it more easily in your project enclosure.Step 30: Enclosure I borrowed an idea from former Artist in Residence Mads Hobye for my enclosure. Mads founds these sleek boxes at the container store and used them to make project enclosures for the various musical instruments he built during his stay. These boxes are particularly convenient because they have a bevel around the top that allows you to easily mount a 5mm acrylic front panel. I used a laser cutter to cut out two USB ports (one for the Arduino and one for MIDI out) in the bottom of the enclosure. Then I used a drill to make holes for two pots, a power switch, and a charging jack. The vector files are attached. I laser cut a front panel from translucent white 5mm acrylic so that it would snap fit into the wood box. the eps file for the front panel is attached below.Step 31: Final Firmware For the final firmware, I've extracted all the code that controls the buttons and leds into a library to make it more tidy, all of this is in a class called SugarCube . I was inspired by the work I've been doing on the Instructables iOS app, and wrote the event handling pieces of the code so that they work in a similar way that an iPhone deals with touch and other gestural events. Basically I created a set of methods that each app can subscribe to, things like "deviceWasShaken" or "buttonPressed". When the SugarCube class detects one of these events, it tells the current app to execute the corresponding method. If you're interested in seeing an example of this structure in action, check out SimpleMIDIKeyboard.cpp , it shows how few lines of code are needed to wire up all the button and analog controls to MIDI outputs. I hope to eventually write out a little more complete documentation for how to write your own apps based on this framework, please let me know if there is interest. This is by far my biggest piece of C++ code, and I am by no means an expert in C++, I'd love to hear an expert's thoughts on how I did! Step for running the code: Download the zip file from github unzip rename the folder to "SugarCubeLibraryFiles" open the file SugarCubeLibraryFiles.ino in Arduino connect your Arduino and uploadStep 32: Future Work This project has the potential to be expanded upon quite a bit. Unfortunately, I just don't have the time to invest in exploring all the possibilities, but here's some ideas I had for things to look into: More apps: The current implementation of this device allows you to boot into 16 different applications, but I've only written seven so far. There's a ton of great ideas over on the monome website for grid based controllers, it'd be great to see some of that translated into Arduino. Gyro Control: As I mentioned earlier, I threw an x/y gyroscope in the controller, but I've yet to write an app that actually uses it. I'd love to hear if someone has an idea for how this could work with MIDI. Wireless : When I started this project, my major design objectives were portability and plug and play ease of use. I wanted to try to break away from the model of the electronic controller that necessitates a computer to run, in an effort to bring electronic music out of the traditional studio environment. In keeping with that idea, I'd like to eventually get this controller to wirelessly send MIDI to my phone to make it totally portable. I have one of these bluetooth boards from Red Bear Labs , and I think there might be some way to send the data to my phone, translate it into CoreMIDI and run it though a MIDI synth, but I just haven't explored the idea enough yet. If anyone has any insight, I'd love to hear your thoughts.Step 33: Appendix: Cut PCB for Control Buttons Originally, I planned to have four extra "control" buttons on the side of the controller that I was going to use in various applications. I started wiring it up, but eventually scrapped it. I haven't written any code for these buttons, and they are in no way integrated into the apps I've written, but I figured I'd still include the images that I took during that process in this Instructable in case it's useful to anyone. Cut the 2x2 sparkfun pcb as shown in the pictures above. Solder white LEDs and diodes on the pcb as in steps 2 and 3.Step 34: Appendix: Control Buttons Wiring Part 1: PCB Alle 8 Artikel anzeigen Cut a piece of ribbon cable and solder 8 wires to the sparkfun PCB holes labelled "switch gnd" and "led gnd". Solder four more wires to the holes labelled "switch" and "blue." See the images for more info. On one half of the PCB (the one labelled "green" and "blue") you will have to rewire some of the traces that were broken when the PCB was cut. Both connections to the positive switch rail will need to be connected to each other and then connected to the "green" led trace as shown in fig 4. I did this by removing one strand of a piece of stranded wire and poking it through the vias on the PCB. Use a dab of solder to secure the electrical connection between the copper strand and the PCB (fig 7). You will also have to solder a wire between the two "blue" positive rails (also shown in fig 4). Once this is done, test for continuity and cover the exposed copper with electrical tape to prevent short circuits (fig 6). On the other half of the PCB, use a jumper wire to connect the "red" and "blue" sockets of one of the LEDs together (see fig 7). This will connect the anode of your white LEDs to the ribbon cable.Step 35: Appendix: Control Buttons Wiring Part 2: Socket Clamp a 16 pin socket onto the ribbon cable as shown in fig 1. Solder two rows of male header pins to the protoboard so that the control buttons fit onto the board as shown in fig 3. Trim any excess ribbon cable.Step 36: Appendix: Control Buttons Wiring Part 3: Header Pins Solder 3 more male header pins to snap to digital pins 11-13. Since the spacing between Arduino digital pins 0-7 and pin 8-13, I had to drill holes in my perfboard and scrape off some of the copper traces. See the images above for more information.Step 37: Appendix: Control Buttons Wiring Part 4: Connections to LEDs Solder four 68ohm resistors to the pins which connect to the LED cathodes. Connect the other end of these resistors to pins 4-7 of the 74HC595 with jumper wires (yellow). We'll be using pin 11 of the Arduino to supply positive voltage to the LEDs, but one Arduino pin cannot source enough current to drive the LEDs by itself. I used a 222 NPN transistor in an emitter-follower configuration to boost the power of pin 11's signal. Connect pin 11 to the base (middle pin) of the transistor. Connect the collector to the Arduino's 5V supply and the emitter to the header pins which connect to the LED anodes (fig 5).Step 38: Appendix: Control Buttons Wiring Part 5: Connections to Buttons Solder a jumper wire between pin 13 of the Arduino and the header pins which attach to the button anodes. On the reverse side of the perfboard I soldered four jumper wires from the button cathode pins to 10k resistors connected to ground (fig 4). I did this to save space on my PCB so that it would fit in an enclosure better. I also soldered four jumper wires from the non grounded side of the 10k resistors to 165 pins 3-6.

            26 Schritt:Schritt 1: LLP (Laser Light Plane) Schritt 2: Schematische Schritt 3: Gehäuse Schritt 4: Laser Schritt 5: Laserjustierungen Schritt 6: Projektionswand (Diffuser) Schritt 7: Glass Schritt 8: Sicheres Glass Schritt 9: Draht Laser Schritt 10: Align Laser Schritt 11: Frontplatten Schritt 12: Band Vorderseite Edges Schritt 13: Mount Frontplatten Schritt 14: Lichtdichte Schritt 15: USB / Power-Zugang Schritt 16: Aluminium-Trennwände Schritt 17: Installieren von Partitionen Schritt 18: LED / Fototransistor-Array Schritt 19: Draht up Array Schritt 20: Installieren LED / Sensor Array Schritt 21: Rückseite Schritt 22: Firmware Schritt 23: Flash neue Seriennummer auf Arduino Schritt 24: Arduinome Serien Schritt 25: MaxMSP Schritt 26: Fehlersuche

            Dieses Projekt ist ein Arduino betriebenen Infrarot-Touchscreen / Kaffeetisch-Schnittstelle, die ich benutze, um zu steuern verschiedene Musik- und Grafikanwendungen auf meinem Computer. Dies ist ein altes Projekt, das ich vor kurzem Zeit, um zurück zu gehen und Dokument / in Ordnung bringen musste; Dieses Projekt ist ein wenig mehr zu mir als die meisten besondere, denn es war mein erster Arduino / Elektronik-Projekt, und während ich forschen dafür Ich landete auf Instructables für das erste Mal. Ich habe mit diesem Regler in erster Linie um Musik und Grafikanwendungen in MaxMSP laufen zu fahren. Hier eine kurze Demo: Der Touchscreen nutzt Infrarot (IR) Erkundung in Finger und andere Objekte auf dem Bildschirm zu erkennen. Ein IR-Laser an jeder Ecke strahlt IR-Licht über die Oberfläche des Bildschirms. Wenn ein Finger oder ein anderes Objekt die Oberfläche berührt, verursacht er die IR-Licht in viele Richtungen gestreut. Ein Teil dieses Lichts wird durch die in den Bildschirm gerichtet ist, hin zu einer Reihe von 64 Infrarot-Sensoren. Durch das Scannen durch die Sensoren, können Sie die X- und Y-Position des Touch-Event (s) zu bestimmen, und nutzen diese, um eine Vielzahl von Anwendungen zu steuern. Eine Reihe von 64 LEDs unterhalb des Displays bietet visuelles Feedback für die Schnittstelle, über die Rückprojektion . Die LED-Anordnung arbeitet völlig unabhängig von der Sensoranordnung - das bedeutet, die LEDs können in mehrfacher Hinsicht, die nur die Anzeige der aktuellen Note Positionen eingesetzt werden. Diese Schnittstelle ist ein Controller, spielt es keine Anwendungen, die im Speicher gespeichert sind, laufen (wenn das möglich ist). Stattdessen verbindet es mit einem Computer über den USB und sendet eine Reihe von Berührungs Nachrichten zur Steuerung von Anwendungen auf dem Computer ausgeführt werden (ähnlich wie eine Computertastatur sendet Tastenanschläge an einem Computer). Der Computer verarbeitet die Eingangsdaten und bestimmt die Konfiguration der Ausgangsanzeige, dann eine Reihe von LED-Nachrichten zurück an die Schnittstelle (ähnlich wie der Computer steuert eine LCD-Anzeige) sendet. Auf diese Weise ist die Steuerung sehr einfach und muss nicht irgendeine Verarbeitung außerhalb der grundlegenden Aufgaben des Erhaltens der Zustände seiner Eingänge (IR-Sensoren) und Einstellen der Zustände der Ausgänge (LEDs) zu behandeln; der Computer tut all die schwere Arbeit in diesem Szenario. Wie ich schon sagte, setzt das Gerät auf die IR-Abfrage als Eingangsinformation, aus fand ich durch Zufall, dass es funktioniert ein paar coole Sachen, wenn Sie es draußen, während die Intensität der Sonneneinstrahlung ändert sich schnell (Sonnenaufgang / Sonnenuntergang). Ich hatte etwas Spaß zu versuchen, interessante Möglichkeiten der Umwandlung scheinbar zufällige Rauschen aus den Eingaben in Ton / Lichter zu finden: Obwohl das Projekt vor einiger Zeit getan, ich habe es vor kurzem auseinandergenommen, um das Holz Reparaturlackierung und zu beheben, ein paar Dinge, die mich nervt wurden. Ich habe immer geschrieben dieses Instructable als würde ich es von Grund auf neu bauen, aber es wird manchmal offensichtlich, dass dies in der Tat ein fertiges Projekt. Mein Tipp: die schematische und Firmware in diesem Projekt ist eine modifizierte Version des Arduinome Projekt , das eine modifizierte Version des ist Monome Projekt . Wenn Sie während jeder Phase des Projekts auf Probleme stoßen, können Sie finden, was Sie suchen in einem dieser Foren. Sicherheitshinweis: Dieses Projekt verwendet Laserdioden stark genug, um die Augen (oder die Augen der Menschen in Ihrer Umgebung) dauerhaft beschädigt werden, verwenden Sie keine Laser, wenn Sie nicht wissen, wie man sie richtig zu behandeln. LISTE DER EINZELTEILE: Verschiedene Quellen (X4) 25 Milliwatt 780nm Laserdioden mit 89-Grad-Linie Linse Aixis AIX-780-25-8 - wirklich wichtiger Hinweis hier, auch wenn diese Laser sind mit "3.2V", sie sind tatsächlich 5V, dies hat mich eine wirklich lange Zeit herausfinden. (X1) rosco schwarze Leinwand (a ~ 2 '2' Stück mindestens) Rose Marke (X1) Arduino Uno (Ich habe ein Duemilanova, sondern eine Uno sollte auch funktionieren) Sparkfun DEV-11021 (X1) 20 "x20" Phenolfolie (für die Installation von LEDs und IR-Sensoren) (X1) Holz 2x4 (für Gehäuse- ich etwas Redwood, die Verlegung wurde um (X1) 1 mm Aluminiumblech (für lichtdichte Trennwände unterhalb Bildschirme) genug, um 14 20 "x 2.5" Stücke zu machen - ich schwarz eloxiertem Aluminium, aber regelmäßige un-eloxiertem Aluminium sollten auch funktionieren. (X1) 20 "x20" x¼ "Glasscheibe Digikey (X64) 800nm ​​IR Fototransistoren Digikey 511-1357-ND (X64) weiß Weitwinkel LEDs Digikey C535A-WJN-CS0V0231-ND - ich fand, dass die Qualitätskontrolle für diese LEDs nicht so groß, und sie jeder stellte sich heraus, etwas andere Schattierungen von Weiß sein. Ich dachte, der Effekt tatsächlich sah ziemlich cool, aber wenn das nicht das, was Sie in sind, würde ich versuchen, einige andere Weitwinkel-LEDs finden. (X1) MAX7219 LED-Treiber Digikey MAX7219CNG -ND (X1) 24 polige Buchse Digikey 3M5466-ND (X1) 10uF Kondensator Digikey P828-ND (X1) 0.1uf Kondensator Digikey 490-5401-ND (X1) 74HC595 Schieberegister Digikey 296-1600-5-ND (X1) 16 polige Buchse Digikey A100206-ND (X10) 10kOhm 1/4 Watt-Widerständen Digikey CF14JT10K0CT-ND (X1) 1/4 Watt 7219 Widerstand (Wert bestimmt hier je nach Ihren LEDs) Amazonas (X2) USB-Kabel Stecker Typ A auf Stecker Typ B Amazon (X1) USB-Adapter weiblichen Typ A auf Buchse Typ B Amazon (X1) mit Kupfer perfboard Amazon (X1) polycrylic Klarlack Amazon (X1) Silikonkleber Amazon (X1) schwarzem Isolierband Amazon Jameco (X1) 16 polige Flachbandkabel Jameco 643.532 (X1) 16 Stift Crimp Buchse Jameco 1.578.111 (habe ich nicht wirklich nutzen, aber ich wünschte, ich hätte) (X5) Stiftleiste Stifte Jameco 103.393 (X1) 22 Gauge feste Kerndraht Jameco 36792 Werkzeuge: Schraubendreher Heißklebepistole Bohrer Tischsäge Holzmühle / Router Aluminiumwerk Aluminium-Querschneider Bandsäge Lötkolben Infrarot / Nachtsicht-Kamera (optional, aber nützlich) Schritt 1: LLP (Laser Light Plane) Infrarot (IR) Multitouch ist eine kostengünstige Alternative zu dem kapazitiven Multitouch in Smartphones und Tablets gefunden. Es gibt ein paar beliebte Techniken für den Aufbau eines IR-Multitouch-System, die alle sehr schön an der skizzierten nuigroup Wiki . Früher habe ich eine Technik namens Laser Light Flugzeug (LLP) für meine Touchscreen; Das Diagramm gibt einen Überblick über, wie es funktioniert. Mehrere Laser auf der Oberseite des Bildschirms positioniert schaffen eine sehr dünne Schicht oder Infrarot (IR) Licht, das die Bildschirmoberfläche vollständig bedeckt. Wenn ein Finger den Bildschirm berührt, bricht es diese Ebene von Licht und streut ein Teil des IR-Licht in den Bildschirm. Ich partitioniert die Unterseite des Bildschirms mit Stücken von Aluminiumblech gelegt und eine IR-Sensor in jeder Partition. Durch Messen jeder der Sensoren können die x- und y-Koordinaten des Berührungsereignisses zu bestimmen. Ich habe auch eine weiße LED zu jeder Partition, so dass der Bildschirm kann als Projektionsoberfläche verwendet werden. Das Diffusormaterial an der Unterseite des Bildschirms (hellgrau) hilft die LED besser verteilen Licht über die Oberfläche des Bildschirms. Dies ist, was LLP sieht aus wie mit dem roten Laser, IR wird die gleiche Arbeit, aber es ist nicht sichtbar für das menschliche Auge: Hier ist, was es sieht aus wie eine Kamera, die so modifiziert ist, um IR sehen: Dies ist, was meine letzte Projekt sieht aus wie mit Nachtsicht: Ich will nicht (wieder, überprüfen Sie in die Besonderheiten der einzelnen IR-Multitouch-Technik hier nuigroup für diese info), aber ich werde ein paar Dinge über, warum ich sagen, LLP: Nullkraft - kein Druck nach unten auf dem Bildschirm ist notwendig, um einen Hauch zu registrieren. Glas - Ich wollte Glas als meine Bildschirmoberfläche verwenden (sieht / fühlt sich schöner, weniger kratzanfällig als Acryl), aber einige IR Multitouch-Methoden (Totalreflexion) erfordern Acryl. dünn - viele IR-Multitouch-Techniken uns eine Kamera, um den Finger Tracking zu tun, bedeutet dies, dass die Kamera muss so positioniert werden, dass sie einen freien Blick auf den gesamten Bildschirm. In der Regel bedeutet dies, dass das Gehäuse des Multitouch-Oberfläche sehr tief, so dass sich die Kamera ausreichend weit entfernt. Dagegen kann mein Verfahren zur Verwendung eines Arrays mit LLP auf Dicken von weniger als einem Zoll skaliert. skalierbar - die Einheit Stück dieser Touchscreen - die Zelle, die eine LED und ein IR-Sensor - kann viele Male wiederholt werden, um größere oder dichteren Arrays machen. Einige Nachteile zu LLP: - Alles, was die Oberfläche des Bildschirms bricht werden die Sensoren auslösen - Ärmel, Ellbogen ... manchmal ist das ärgerlich. Es könnte eine gute Sache, wenn auch sein, können Sie regelmäßige Objekte verwenden, um die Touch auslösen. - Der Untergang aller IR-Touchscreens ist, dass sie empfindlich auf Infrarotlicht sind. Dieser Bildschirm funktioniert nur in der Nacht oder in einem Raum ohne Fenster, und das Licht im Raum kann nur fluoreszierend sein - keine Glühbirnen. Eine andere gute Quelle für LLP Informationen finden Sie unter dem nuigroup LLP Seite . Bildquelle: Teile des obigen Bild stammen aus nuigroup Schritt 2: Schematische Meine schema ist eine modifizierte Version des Arduinome schema gefunden hier . Ein wenig Informationen über, warum ich auf der Grundlage dieses weg Arduinome ... Als ich das erste Online-Recherchen für Ideen, die ich wusste, ich wollte eine Art von LED-Array / Kaffeetisch / Bedienoberfläche machen. Ich fand einige Sachen wie diese, die ich auf youtube gefallen: Auf der Suche nach mehr Arduino / grid-Controller, fand ich monome und Arduinome. Es war (und ist) die beste Lösung für diese Art von Projekt, denn sobald Sie die Schnittstelle zu bauen, haben Sie Zugriff auf alle MaxMSP Anwendungen , die Menschen zu schreiben auf der monome Ort - und es gibt einige wirklich kreative und erstaunliche Apps gibt - so dass Sie bist immer eine Menge von Wert aus der Arbeit, die Sie in. Da diese Anwendungen werden in MaxMSP geschrieben, sie sind Open Source, so dass, wenn Sie wollen, können Sie sie bearbeiten, und erfahren Sie mehr darüber, wie sie funktionieren. Uuund wenn Sie immer am Ende das Schreiben eigener Anwendungen, können Sie sie zu schreiben und sehen, was andere Leute tun mit ihnen, was immer ganz lustig ist. Die bemerkenswerteste Änderung habe ich die ursprüngliche Form Arduinome schema gemacht ist, dass ich alle Tasten und ihre entsprechenden Dioden, mit IR-Phototransistoren ersetzt (da die Transistoren eine inhärente Polarität, sind Dioden nicht erforderlich). Ich habe auch die Stelle des 74HC164 mit einem 74HC595 . Auf Papier diese Chips nicht zu unterschiedlich sind, aber ich festgestellt, dass einer der Stifte an der 164 in einen Spannungsabfall leicht in Arduinome schema . Dies ist keine große Sache, wenn Sie die Steuerung sind Knöpfe, weil sie 2-State-Geräte, aber es verursachte eine Reihe von meinen Sensoren deutlich weniger empfindlich als die anderen zu sein. Ich habe versucht, dieses zu überprüfen und konnte nicht einen Weg finden, so dass ich ersetzte sie mit dem 595 und hatte viel bessere Ergebnisse. I vereinfacht auch den Stromkreis durch Entfernen des 74HC165 und mit 8 Pins auf der Arduino statt. Ich musste die Arduinome Firmware ändern, um diese Änderungen zu berücksichtigen, werden Sie, dass in einem späteren step.Step 3 zu finden: Gehäuse Alle 8 Artikel anzeigen Dies ist eine grundlegende mockup des Gehäuses. Das Hauptstrukturkomponente ist eine quadratische Holzrahmen mit einem 1/4 "Aussparung ausschneiden von oben (2). I geschnitten 1-2mm dicken Aluminiumfolie in Streifen verwendet Kerbausschnitten, die Streifen miteinander zu verbinden, um eine 8x8-Gitter-Partition, die innerhalb des Gehäuses (Figur 3 und 4 zu bilden, ein 16x16 Raster ist in dem Diagramm gezeigt, dies wurde während der Herstellung verändert, beachten Sie auch, dass die in diesem Mockup angegebenen Abmessungen sind nicht ganz richtig). Dieses Raster passt genau in den Holzrahmen (Bild 5). Unterhalb des Gitters ist ein großes Stück von phenolischen, wo alle der LEDs und Fototransistoren angeordnet sind. Oberhalb des Gitters ist die Rückprojektionsfläche (der Diffusor) und 1/4 "Glasscheibe (6), diese passen innerhalb der oberen Ausnehmung des Holzrahmens Oberhalb der Glas vier Holzplatten, die einen Rahmen bilden;. Diese Rahmen hält / versteckt die 4-Laser an jeder Ecken und verhindert, dass Laserlicht von dem Verlassen des Gehäuses (Bild 7) Ein Panel auf der Rückseite schließt das Gehäuse und bietet einen Ort, um die verbleibende Schaltung montieren - Arduino und andere elektronische components.Step. 4: Laser Ich legte einen 89-Grad-Linie Linse jedem meiner Laser. Diese Linsen drehen einen Punkt / Lichtstrahl in einem 89 Grad-Fan / ebene Form. Auf diese Weise vier Laser (eine an jeder Ecke des Bildschirms) wird eine hervorragende Abdeckung der Oberfläche des Bildschirms zu erhalten. An dieser Stelle werden Sie wollen, um den Laser zu fokussieren. Ich denke, der beste Weg, dies zu tun ist, um den Laser einzuschalten und schalten Sie das Licht aus. Glanz der Laser auf eine weiße Wand - Sie sollten sehen, eine schwache rote Linie erscheinen. Drehen Sie das Objektiv, bis Sie den Laserfokus zu sehen, sollten Sie die Zeile so scharf wie möglich zu sein. Es ist eine gute Idee, die Laser in Isolierband umwickeln, um sie von uns aus der focus.Step 5 gestoßen zu verhindern: Laser-Halterungen I bearbeitet vier Laserhalterungen aus Aluminium. Jedes verfügt über eine Stellschraube zum Halten der Laser in Kraft und eine weitere große Loch an der Basis zur Befestigung an der Holzgehäuse (und Einstellen vertikale Position). Denn jetzt habe ich locker positioniert den Laser (ohne Verlust Fokus) in den Halterungen, werde ich über Ausrichten dieser Laser im Detail in einem weiteren Schritt zu sprechen. Beachten Sie, wie ich Heißkleber, um die Drähte aus dem Laser kommen zu stabilisieren; Ich habe gelernt, auf die harte Tour, dass die Verbindungen zwischen den Drähten und der Laser pcb sind sehr schwach und kann leicht brechen, wenn Sie versehentlich ziehen Sie an den Leitungen zu bekommen. Es ist eine gute Idee, Heißkleber als Puffer zwischen den Lasern und jeder zieht, dass vielleicht durch Zufall auf der anderen Seite des enclosure.Step 6 passieren verwenden: Projektionswand (Diffuser) Ich streckte eine 17.5x17.5 "Stück des rosco schwarze Leinwand am oberen Rand des Holzgehäuse und befestigt es mit einigen kleinen Nägeln. Seien Sie vorsichtig, um die Spannung gleichmäßig über den Bildschirm zu verteilen, so dass Sie am Ende nicht mit Falten. Schritt 7: Glass Unter Verwendung der durch Ritzen und Brechen -Methode, meinen Teller Glas schnitt ich auf die richtige Größe (17.5 "x17.5") und schneiden Sie kleine Dreiecke an jeder der Ecken, um Platz für den Laser zu machen. Dieses Stück Glas sollte innerhalb der Vertiefung der Holzrahmen passen und bündig mit der Oberkante des wood.Step 8: Sicheres Glass Ich sicherte das Glas an die Holzgehäuse mit Silikonkleber entlang der äußeren perimeter.Step 9: Draht Laser Ursprünglich habe ich eine externe 5V-Versorgung, um den Laser anzutreiben, aber ich habe vor kurzem begonnen Versorgung sie mit dem Arduino 5V-Versorgung. die Verdrahtungsanweisungen sind die gleichen für beide Fälle: Draht bis 5 V von der Strombuchse (oder Arduino) am rechten Stift des der Netzschalter, dann verbinden Sie den Netzschalter Mittelstift, um alle vier Laser "red führt. Verdrahten Sie die 0 V von der Strombuchse (oder Arduino) zum verbleibenden Stift des Netzschalters und die schwarzen Leitungen aller vier Lasern. Auf diese Weise wird der Schalter Stromversorgung der Laser parallel steuern. Schritt 10: Align Laser Die IR-Laser sind etwas schwierig, mit menschlichen Augen sehen, können Sie feststellen, dass dieser Schritt leichter mit der Verwendung einer Nachtsichtkamera oder einem modifizierten Webcam erreicht. Wenn Sie nicht über eine dieser, tun Sie diesen Schritt in einem dunklen Raum, damit Sie die IR sehen können. Decken drei der IR-Laser mit schwarzem Isolierband, um sie zu blockieren. Halten Sie ein Stück weißen Karton vertikal auf dem Glas vor dem un-blockierten Laserdiode. Ihr sollten sehen, eine Linie auf der Karte erscheinen, ist dies der Strahl des Lasers. Wenn Sie nicht bereits haben, konzentrieren den Strahl durch Anziehen und Lösen der Objektivaufsatz auf dem Laser. Sie möchten die Position, dass die Linie auf dem Karton erscheinen so dünn wie möglich macht. Dies ist viel einfacher zu tun, wenn der Karton ist weiter weg gehalten, können Sie sogar versuchen leuchtenden den Laser auf eine weiße Wand ein paar Meter entfernt. Sobald der Laser im Schwerpunkt mit einem Stück Klebeband, um die Position der Linse zu befestigen. Lösen Sie nun die Laserhalterung und stellen Sie den Laser und die Halterung, bis das Laserlicht parallel strahlt auf die Oberfläche des Glases, etwa 1 mm über der Oberfläche. Sie müssen, um den Laser in der Halterung drehen und passen Sie die vertikale Position der Halterung, um es in Position zu bringen. One man die optimale Position gefunden haben, Ihre Set Schrauben festziehen, damit die Halterungen bleiben kannst. Wiederholen Sie diesen Vorgang für die verbleibenden Lasern. Hier ist ein Video, das zeigt, wie das aussieht: Schritt 11: Frontplatten Die Frontplatten sind im Detail in den oben genannten Bildern dargestellt. I verwendet einen Router, um Material entlang ihrer Länge und in jeder der Ecken zu entfernen. Die Ecke Material wurde entfernt, um Platz für den Laser und Laser Halterungen an jeder Ecke des Gehäuses bilden. Der Raum sich entlang der Länge so zugegeben wurde, dass, wenn das IR-Licht aus dem Laser trifft auf die Frontplatten und streut, wird es nicht Licht in Richtung auf den Fototransistoren in den Randzellen der Anzeige. Stattdessen wird das Licht unter der Frontplatte zu reisen, ungefähr ein Zoll über den Rand des sichtbaren Teils des Bildschirms. Jedes Licht, das von dort nach unten springt mit Isolierband blockiert werden, ohne dass der Auftritt des display.Step 12: Band Vorderseite Edges Ich fand, dass einige schwarzem Isolierband entlang der Kanten der Vorderseite Stück dazu beigetragen, um unerwünschte IR-Licht durch Streuung in die Randzellen der display.Step 13 zu verhindern: Mount Frontplatten Sobald Sie mit der Position der Laser glücklich, und haben sie mit Klebeband / Kleber befestigt ist, montieren Sie die Schutzfrontplatten. Ich habe einige kleine Nägel, um die Platten an der Vorderseite des Gehäuses zu befestigen meinen, man könnte auch Holzleim verwenden. Schritt 14: Lichtdichte Ich benutzte Isolierband, um die Unterseite der Laserhalterungen fest leuchten - Sie wollen nicht jede verstreut IR-Licht auf den Fototransistor in den Ecken des Displays zu schlagen. I ausgekleidet auch die Ränder des Gehäuses mit Isolierband. Achten Sie darauf, dass keine dieser blockiert Teile von der Vorderseite des Gehäuses sichtbar sind, wenn die Frontplatten auf. Schalten Sie den Laser auf und verwenden Sie Ihre Nachtsicht-Kamera, um sicherzustellen, dass kein Fremdlicht wird durch die screen.Step 15 vorbei: USB / Power-Zugang Ich habe einen Router, um ein paar Löcher für meine USB und Stromanschlüsse (extra Stromanschluss ist optional), und mein Netzschalter geschnitten. I diese Komponenten in mit Silikonkleber und Epoxid verklebt. Später, als ich die Rückwand installiert waren diese Komponenten bündig dagegen. Schritt 16: Aluminium-Trennwände Cut 14 Aluminium Partitionen von 1 mm Aluminiumblech. Schneiden Sie die Streifen, so dass sie eng in den eckigen Holzgehäuse passen. Ich habe die Bandsäge zu sieben Kerben auf halbem Weg durch jedes der Stücke geschnitten, so dass sie zusammenpassen könnte, wie in den Bildern gezeigt above.Step 17: Installieren von Partitionen Legen Sie das Aluminium-Partitionen in den hinteren Öffnung des Gehäuses, so dass es gegen den Diffusor und Glas pane.Step 18 drückt: LED / Fototransistor Array Schneiden Sie ein Stück 17 "x17" Phenol, so dass es in der Rückseite des Gehäuses genau passt. Die Mittelpunkte jeder Zelle des phenolischen und Bohrer vier kleine Löcher, um das mit einem LED und einem Phototransistor montieren. Dies ist der langweiligste Teil - Draht bis 64 weiße LEDs in und 8x8-Array und 64 Fototransistoren in einem 8x8-Array, wie in der schematischen gezeigt. Achten Sie darauf, den Überblick über die Anoden und Kathoden der LEDs und Transistoren zu halten, so dass Sie wissen, dass sie richtig angeschlossen sind. Schritt 19: Draht up Array Verdrahten Sie die 595 und 7219 wie in den obigen Schemata gezeigt. Nehmen Sie alle erforderlichen Verbindungen zu den LED und Fototransistor-Arrays und dem Arduino. Der Phototransistor als Dioden in der schema oben dargestellt, da sie nur zwei Leitungen. Sie müssen einen Wert für RSet des MAX7219 Schaltung auf der Grundlage der specificaltions Ihrer LEDs aus. Hier finden Sie Informationen dazu, wie Sie das tun Sie hier . Sie müssen auch auf Widerstände für die Zeilen der Phototransistorfeld wählen. Sie können die Empfindlichkeit der Anordnung durch die Erhöhung der Widerstandsfähigkeit dieser Widerstände zu erhöhen. Ich habe 10kOhm Widerstände, das ist wahrscheinlich ein guter Ort, um zu starten. Schritt 20: Installieren LED / Sensor Array Klappen Sie den phenolischen Bord über, so dass die LEDs und Fototransistoren werden nach unten und das Board zu installieren in dem Gehäuse. Verwenden Sie Schrauben, um das Brett in place.Step 21 zu sichern: Rückseite Ich brauchte ein wenig mehr Tiefe, um die gesamte Elektronik in meinem Projekt passen, so schneide ich ein 3/4 "Stück Lage mit einem 10" x10 "x0.5" geroutet-out Tasche als Rückwand für das Gehäuse verwenden. Die Shopping-Suchmaschine Dateien für den Teil befestigt sind. Ich malte die Lagen schwarz, so dass es sah ein wenig schöner, mit dem Redwood. Schritt 22: Firmware Laden Sie die folgende Firmware in den Vorstand: / * * "ArduinomeFirmware" - Arduino Based Monome Clone von Owen Vallis & Jordan Hochenbaum 2008.06.16 * Revised 2008.06.26 * Revised 2008.07.20 von Ben Southall * Revised 2009.03.21 Ben Southall * Revised 2012.01.21 Jordan Hochenbaum v3.3 Rev.A * Überarbeitete 06/2012 für 74HC595 von Amanda Ghassaei * ------------------------------------------------- ------------------------- * Dieses Programm ist freie Software; es darf weitergegeben und / oder zu modifizieren * Es unter den Bedingungen der GNU General Public License, wie von veröffentlicht * Die Free Software Foundation; entweder Version 2 der Lizenz oder * (Nach Ihrer Option) jeder späteren Version. * * Dieses Programm wird in der Hoffnung, daß es Ihnen von Nutzen sein, * Aber OHNE IRGENDEINE GARANTIE, sogar ohne die implizite Garantie der * Marktfähigkeit oder Eignung für einen bestimmten Zweck. Siehe * GNU General Public License für weitere Details. * ------------------------------------------------- ------------------------- * * Dieser Code ist größtenteils eine direkte Übersetzung des 40h-Protokoll von Brian Crabtree ausgelegt * & Joe See, und von Joe See codiert. Wir möchten unser Bestes Dank, dass zum Ausdruck * Die monome & seine innere Funktionsweise verfügbar und Open Source. Wir helfen aber auch gerne verlängern * Unser Dank an alle, die uns geholfen haben so weit kommen bei der erfolgreichen Herstellung eines arduino- * Basierend monome Klon, aber nicht ausschließlich Brad Hill für seine ehrfürchtige Arduino Schild begrenzt, * Melka und zu zeigen, wie zum Packen und Entpacken der seriellen Daten. * * Zusätzliche Kommentar und Zuschreibung 2008.07.20: * Die Änderungen am 2008.07.20 wurden in einem Teil inspiriert und mindestens unmittelbar * Von der "Octinct 'Code von Jonathan M Guberman (upwardnotnorthward.com) geschrieben kopiert. * Insbesondere der Einsatz von Zeitgeber 2, um eine Interrupt-Routine zu fahren, um zu lesen die serielle Schnittstelle war * Aus dem Octinct Projekt aufgenommen wird, und auch, die Baudrate auf 57600 zu sein schien, * Entscheidend für immer alles, um zuverlässig zu arbeiten. Mein Dank an Jonathan für den Austausch sein * Software, und um herauszufinden, wie man die seriellen Puffer in Schach zu halten. * * Änderungen 2009.03.21 * * Added ADC Unterstützung für arduino ADCs 0 - 3. Dank Josh Lory für den ersten Schnitt des Codes für * Dies. Hinzugefügt Handhabung des ADC aktivieren / Serien Nachrichten zu deaktivieren, und änderte Joshs checkADC Code * Schleife durch den 4 ADCs nicht lesen jedes einzeln. Außerdem räumte eine Reihe von * Unbenutzte Variablen, und zog alle PORT / pin-Definitionen in der Anfang der Datei; dies sollte es machen * Einfacher für Menschen nicht mit dem unsped Schild, um die Hardware-Verbindungen zu ändern. * * Bitte beachten Sie, Email Wünschen monome bei technischen Fragen und / oder Hilfe zu diesem Code oder Klon. * Sie sind in keiner Weise verantwortlich oder mit diesem Projekt nicht erkennbar ist unsere Inspiration waren assoziiert * Und wir haben viele ihrer Methoden und zog aus ihrem Code. * * Darüber hinaus, während wir sind availble und bereit sind, so viel wie möglich zu helfen, auch wir nicht gehalten werden kann * Für alles, was Sie mit diesem Code zu tun verantwortlich. Bitte zögern Sie nicht alle Bugs, Anregungen mitteilen * Oder Verbesserungen an uns, da sie alle willkommen. Auch hier können wir nicht für etwaige Schäden haftbar gemacht werden * Oder Schäden, die durch den Gebrauch oder Missbrauch dieses Codes oder unseren Anweisungen verursacht. Danke für dein Verständnis. * * * * * Ändert 2012.01.21 & 3.3a * Arduino 1.0+ Verträglichkeit (verwendet .ino Erweiterung und nicht mehr gibt BYTE-Typ in Serial.write) * ------------------------------------------------- ------------------------- * * Links: * www.monome.org - Unsere Website - Klicken Sie "Work / Arduinome" im Navigationsmenü auf der Oberseite. * www.monome.org - das "Original" monome und unsere Inspiration * www.monome.org * www.monome.org * * / // PIN und Portzuweisungen // Wenn Sie Hardware mit Ausnahme des unsped Schild bist, hast du wollen durch diesen Teil des Codes zu gehen, // Und ändern Sie die Pin-Nummern und ATmega 168 Ports, die Sie verwenden. Wir verwenden pin / Portzuweisungen hier, // NICHT der Pin-Nummer Schema aus den Arduino-Board-Ausgänge (zB Arduino digitale Stift 8 = PORTB Pin 1) // Doch in den Kommentaren unten, ich geben die Äquivalente zwischen Arduino digitale Pin-Nummern und die // ATmega168 die PORT / Bit-Nummerierung. // WICHTIG - Sie brauchen, um sicherzustellen, dass Sie die Daten folgenden zwei Richtungsregister Variablen entsprechen festgelegt werden Ihre // Pin-Belegungen. Byte PORTD_Data_Direction = 0x02; // alle Eingänge außer Pin 1 (TX) Byte PORTB_Data_Direction = 0xFF; // alle Ausgänge Byte PORTC_Data_Direction = 0xFC; // A2-A5 sind Ausgänge, A0, A1 Eingänge // Verbindungen zu 595-Schieberegister // DataPin = A4 = PORTC, Bit 4 // ClockPin = A2 = PORTC, Bit 2 // Verriegelungsstift = A3 = PORTC, Bit 3 #define DATA_PORT_595 (PORTC) Byte dataPin595 = 4; Byte dataPin595MaskHigh = 1 << dataPin595; Byte dataPin595MaskLow = ~ dataPin595MaskHigh; #define CLOCK_PORT_595 (PORTC) Byte clockPin595 = 2; Byte clockPin595MaskHigh = 1 << clockPin595; Byte clockPin595MaskLow = ~ clockPin595MaskHigh; #define LATCH_PORT_595 (PORTC) Byte latchPin595 = 3; Byte latchPin595MaskHigh = 1 << latchPin595; Byte latchPin595MaskLow = ~ latchPin595MaskHigh; // Verbindungen zu den MAX7219 (Antriebe LEDS) // DATAIN = Arduino Pin A5 = PORTC, Bit 5 // Load = Arduino Pin 11 = PORTB Bit 4 // Clock = Arduino Pin 12 = PORTB, Bit 5 #define LED_DATA_PORT (PORTC) Byte MaxDataPin = 5; Byte DataMaskHigh = 1 << MaxDataPin; Byte DataMaskLow = ~ DataMaskHigh; #define LED_CLOCK_PORT (PORTB) Byte MaxClockPin = 5; Byte ClockMaskHigh = 1 << MaxClockPin; Byte ClockMaskLow = ~ ClockMaskHigh; #define LED_LOAD_PORT (PORTB) Byte MaxLoadPin = 4; Byte LoadMaskHigh = 1 << MaxLoadPin; Byte LoadMaskLow = ~ LoadMaskHigh; // End Verbindungen zum 165-Schieberegister // Verwenden, dies zu beheben Spiegelung boolean mirrorXLEDs = true; boolean mirrorYLEDs = false; boolean mirrorXButtons = false; boolean mirrorYButtons = false; // END Stift und Portzuweisungen // ---------------------------- // Globale Variablen Byte Byte0, byte1; // Speicher für eingehende serielle Daten Byte WaitingForAddress = 1; // 1, wenn wir erwarten, dass die nächsten seriellen Byte auf ein Adressenwert, 0 sonst sein Byte-Adresse = 0x00; // Müll Byte-Adresse des Funktions halten Byte-state = 0x00; // Müll Byte Zustandswert halten Byte x = 0x00; // Müll Byte x Position zu halten byte y = 0x00; // Müll Byte y Position zu halten Byte z = 0x00; // Müll Byte über Tasten durchlaufen // Die folgenden Variablen werden zum Speichern von Flags, die anzeigen, ob wir eine bestimmte Nachricht empfangen verwendet, // Der Wert der Daten in dieser Nachricht. zB IntensityChange = 0 == keine Intensitätsänderung Nachricht empfangen, // IntensityChange = 1 == eine Intensitätsänderung Nachricht empfangen worden ist, und es ist Wert in IntensityVal sein // Der Code, der schließlich wirkt auf die eingehende Nachricht wird die Variable 'Change' auf 0 zurückgesetzt, sobald die // Nachricht wurde abgewickelt. Byte IntensityChange = 0; Byte IntensityVal = 0; Byte DisplayTestChange = 0; Byte DisplayTestVal = 0; Byte ShutdownModeChange = 0; Byte ShutdownModeVal = 0; // Diese Variablen werden verwendet, um die ADC-Nachrichten und Speicher, welche Ports derzeit aktiviert Griff, // Und welche nicht. Byte ADCnum; Byte ADCSTATE; Byte ADCEnableState [4]; Byte ledmem [8]; // Speicher für die LED-Zustände - 64 Bit. Byte j = 0; // Temporäre Variable für die Schaltfläche looping int i = 0; // Temporäre Variable zum Durchschleifen usw. int id = 0; // Zwischenspeicher für eingehende Nachricht ID Byte FirstRun = 1; // 1, wenn wir noch ein LED-Befehl, 0 nach, dass zu erhalten. // Verwendet werden, um sicherzustellen, dass unsere LED-State-Speicher richtig initialisiert wird, wenn wir die erste LED Meldung int kButtonUpDefaultDebounceCount = 12; // Wird in Taste Entprellung int kButtonNewEvent = 1; // Wird benutzt, um zu speichern, ob der Zustand einer Schaltfläche geändert hat oder nicht. Byte t = 0; // Temporäre Variable in Taste Verarbeitung verwendet / * BUTTON Array-Variablen Für 1/0 Tastenzustände, verwenden 8 Byte (64 Bit) Für Schaltfläche Entprellzähler Verwenden 8x8-Array * / Byte button_current [8]; Byte button_last [8]; Byte button_state [8]; Byte button_debounce_count [8] [8]; Byte button_event [8]; / * ENDE DER BUTTON Array-Variablen * / / * MAX 7219 Befehlsadressen * / Byte max7219_reg_noop = 0x00; // Definieren MAX7219 Register (lesen Sie die Tech-doc für Erläuterungen) Byte max7219_reg_digit0 = 0x01; Byte max7219_reg_digit1 = 0x02; Byte max7219_reg_digit2 = 0x03; Byte max7219_reg_digit3 = 0x04; Byte max7219_reg_digit4 = 0x05; Byte max7219_reg_digit5 = 0x06; Byte max7219_reg_digit6 = 0x07; Byte max7219_reg_digit7 = 0x08; Byte max7219_reg_decodeMode = 0x09; Byte max7219_reg_intensity = 0x0a; Byte max7219_reg_scanLimit = 0x0b; Byte max7219_reg_shutdown = 0x0C; Byte max7219_reg_displayTest = 0x0F; / * ENDE DER MAX 7219 Befehlsadressen * / // PutByte - Hilfsfunktion, die ein einzelnes Byte in den MAX-Chip sendet nichtig putByte (Byte-Daten) { byte i = 8; Byte-Maske; while (i> 0) { mask = 0x01 << (i - 1); // Erhalten Bitmaske if (Daten & mask) // lesen und senden Sie Wert dieses Bits { LED_DATA_PORT | = DataMaskHigh; } sonst { LED_DATA_PORT & = DataMaskLow; } // Puls des MAX Uhr LED_CLOCK_PORT & = ClockMaskLow; // Digital (Uhr, LOW); // "Tick" prepeare für Bit-Eingang LED_CLOCK_PORT | = ClockMaskHigh; // digital (Uhr, HIGH); // "Tock" Eingangsbit --ich; // Zu geringeren Bit verschieben } } // MaxSingle ist die "easy" Funktion, um für eine einzelne MAX7219 verwenden // Dig ist die Zeilenaufruf und seg ist die Spalte Aufruf dig und seg beziehen sich auf Namen aus tech doc Stift nichtig maxSingle (byte dig, Byte seg) { LED_LOAD_PORT & = LoadMaskLow; // Digital (Last, LOW); // Start putByte (dig); // Angeben registrieren putByte (seg); // ((Daten & 0x01) * 256) + Daten >> 1); // Stellen Daten LED_LOAD_PORT | = LoadMaskHigh; // Digital (Last, HIGH); } // ButtonInit - Hilfsfunktion, die die Tastenzustände auf Null nichtig buttonInit (void) { Byte-i; for (i = 0; i <8; i ++) { button_current[i] = 0x00; button_last[i] = 0x00; button_state[i] = 0x00; button_event[i] = 0x00; } } // buttonCheck - checks the state of a given button. void buttonCheck(byte row, byte index) { if (((button_current[row] ^ button_last[row]) & (1 << index)) && // if the current physical button state is different from the ((button_current[row] ^ button_state[row]) & (1 << index))) { // last physical button state AND the current debounced state if (button_current[row] & (1 << index)) { // if the current physical button state is depressed button_event[row] = kButtonNewEvent << index; // queue up a new button event immediately button_state[row] |= (1 << index); // and set the debounced state to down. } else{ button_debounce_count[row][index] = kButtonUpDefaultDebounceCount; } // otherwise the button was previously depressed and now // has been released so we set our debounce counter. } else if (((button_current[row] ^ button_last[row]) & (1 << index)) == 0 && // if the current physical button state is the same as (button_current[row] ^ button_state[row]) & (1 << index)) { // the last physical button state but the current physical // button state is different from the current debounce // state... if (button_debounce_count[row][index] > 0 && --button_debounce_count[row][index] == 0) { // if the the debounce counter has // been decremented to 0 (meaning the // the button has been up for // kButtonUpDefaultDebounceCount // iterations/// button_event[row] = kButtonNewEvent << index; // queue up a button state change event if (button_current[row] & (1 << index)){ // and toggle the buttons debounce state. button_state[row] |= (1 << index); } else{ button_state[row] &= ~(1 << index); } } } } void buttonpress () { for(i = 0; i < 8; i++){ LATCH_PORT_595 &= latchPin595MaskLow;// set latch pin low so the outputs don't change while sending in bits for (j=0;j<8;j++){ CLOCK_PORT_595 &= clockPin595MaskLow;//digitalWrite(clockPin,LOW); if (j==i){//if index equal current i value, set low DATA_PORT_595 &= dataPin595MaskLow;//digitalWrite(A4,LOW); } else{//set the rest of the pins high DATA_PORT_595 |= dataPin595MaskHigh;//digitalWrite(A4,HIGH); } CLOCK_PORT_595 |= clockPin595MaskHigh;//digitalWrite(clockPin,HIGH); } //set latch pin high- this sends data to outputs LATCH_PORT_595 |= latchPin595MaskHigh;//digitalWrite(latchPin, HIGH); // SlowDown is put in here to waste a little time while we wait for the state of the output // pins to settle. Without this time wasting loop, a single button press would show up as // two presses (the button and its neighbour) volatile int SlowDown = 0; while (SlowDown < 15) { SlowDown++; } button_last [i] = button_current [i]; for(id = 0; id < 8; id++) { switch (id){ case 0: t = digitalRead(A0); Unterbrechung; case 1: t = digitalRead(A1); Unterbrechung; case 2: t = digitalRead(2); Unterbrechung; case 3: t = digitalRead(3); Unterbrechung; case 4: t = digitalRead(4); Unterbrechung; case 5: t = digitalRead(5); Unterbrechung; case 6: t = digitalRead(6); Unterbrechung; case 7: t = digitalRead(7); Unterbrechung; } t = (t == 0);//invert t if(t){ button_current [i] |= (1 << id); } else{ button_current [i] &= ~(1 << id); } buttonCheck(i, id); if (button_event[i] & (1 << id)) { button_event[i] &= ~(1 << id);//zero button event if(button_state[i] & (1 << id)){ Serial.write(1); } else{ Serial.write(byte(0)); } if (mirrorXButtons){ id=7-id; } if (mirrorYButtons){ i=7-i; } Serial.write(((id) << 4) | (i)); } } } //set all pins of 595 high LATCH_PORT_595 &= latchPin595MaskLow;// set latch pin low so the outputs don't change while sending in bits for (j=0;j<8;j++){ CLOCK_PORT_595 &= clockPin595MaskLow;//digitalWrite(clockPin,LOW); DATA_PORT_595 |= dataPin595MaskHigh;//digitalWrite(A4,HIGH); CLOCK_PORT_595 |= clockPin595MaskHigh;//digitalWrite(clockPin,HIGH); } //set latch pin high- this sends data to outputs LATCH_PORT_595 |= latchPin595MaskHigh;//digitalWrite(latchPin, HIGH); } ISR(TIMER2_COMPA_vect) { machen { if (Serial.available()) { if (WaitingForAddress == 1) { byte0 = Serial.read(); address = byte0 >> 4; WaitingForAddress = 0; } // end if (WaitingForAddress == 1); if (Serial.available()) { WaitingForAddress = 1; byte1 = Serial.read(); switch(address) { case 2: state = byte0 & 15; x = byte1 >> 4; y = byte1 & 15; if (state == 0){ ledmem[7-y] &= ~( 1 << x); } else { ledmem[7-y] |= ( 1 << x); } Unterbrechung; case 3: IntensityChange = 1; IntensityVal = byte1 & 15; Unterbrechung; case 4: DisplayTestChange = 1; DisplayTestVal = byte1 & 15; Unterbrechung; case 5: state = byte1 & 0x0F; ADCEnableState[(byte1 >> 4)&0x03] = state; Unterbrechung; case 6: ShutdownModeChange = 1; ShutdownModeVal= byte1 & 15; Unterbrechung; case 7: if (firstRun == 1) { for (x = 0; x < 8; x++) { ledmem[x] = 0; } firstRun = 0; } x = ((byte0 & 15) & 0x7); // mask this value so we don't write to an invalid address. y = byte1; if (mirrorYLEDs){ y=7-y; } if (mirrorXLEDs){ x=flipByte(x); } ledmem[x] = y; Unterbrechung; case 8: if (firstRun == 1) { for (x = 0; x < 8; x++) { ledmem[x] = 0; } firstRun = 0; } x = ((byte0 & 15) & 0x7); y = byte1; if (mirrorYLEDs){ x=7-x; } if (mirrorXLEDs){ y=flipByte(y); } for (z = 0; z < 8; z++) { if (y & (1 << z)) { ledmem[z] |= 1 << x; } else { ledmem[z] &= ~(1 << x); } } Unterbrechung; } // end switch(address) } // end if (Serial.available() } // end if (Serial.available(); } // end do while (Serial.available() > 16); } void whoosh(void) { // reactivate overflow interrupt for // timer 1 - it's needed by delay(...) TIMSK0 |= (1 << TOIE0); for (int j = 0; j < 9; j++) { for (int i = 0; i < 8; i++) { maxSingle(i+1,1<<j); } delay(125); } // and switch the interrupt off. TIMSK0 &= ~(1 << TOIE0); } void setup () { DDRD = PORTD_Data_Direction; DDRB = PORTB_Data_Direction; DDRC = PORTC_Data_Direction; Serial.begin(57600); buttonInit(); //initiation of the max 7219 maxSingle(max7219_reg_scanLimit, 0x07); maxSingle(max7219_reg_intensity,0x0F); maxSingle(max7219_reg_shutdown, 0x01); // not in shutdown mode maxSingle(max7219_reg_displayTest, 0x00); // empty registers, turn all LEDs off h for (i=1; i<=8; i++){ maxSingle(i,0); ledmem[i-1]=0; } cli();//stop interrupts //set timer2 interrupt every 128us TCCR2A = 0;// set entire TCCR2A register to 0 TCCR2B = 0;// same for TCCR2B TCNT2 = 0;//initialize counter value to 0 // set compare match register for 7.8khz increments OCR2A = 255;// = (16*10^6) / (7812.5*8) - 1 (must be <256) // turn on CTC mode TCCR2A |= (1 << WGM21); // Set CS11 bit for 8 prescaler TCCR2B |= (1 << CS11); // enable timer compare interrupt TIMSK2 |= (1 << OCIE2A); sei();//allow interrupts // // Set up 8-bit counter 2, output compare switched off, // // normal waveform generation (whatever that might mean) // TCCR2A = 0; // // set counter to be clocked at 16Mhz/8 = 2Mhz // TCCR2B = 1<<CS21; // // // set the interrupt mask so that we get an interrupt // // on timer 2 overflow, ie after 256 clock cycles. // // The timer 2 interrupt routine will execute every // // 128 uS. // TIMSK2 = 1<<TOIE2; // // // NOTE: In my efforts to try to get this // // code to work reliably at 115200 baud // // I went about disabling unused timers that // // are set up by the Arduino framework. // // The framework sets up both timer 2 and // // timer 1. We use timer 2 to drive the // // serial reading interrupt, so we can only // // disable timer1 and its interrupt. // // // REALLY IMPORTANT NOTE - IF YOU WANT TO USE // // ANALOGWRITE // // // Disabling timer 1 will switch off the timer // // used for PWM, which underlies analogWrite. // // If you want to use analogWrite, remove // // the lines below. // // // DISABLE PWM COUNTER // TIMSK0 &= ~(1 << TOIE0); // // TCCR1B &= ~(1 << CS12); // TCCR1B &= ~(1 << CS11); // TCCR1B &= ~(1 << CS10); // // END DISABLE PWM COUNTER // // // Also, disable the interrupts on timer 0 // // REALLY IMPORTANT NOTE IF YOU WANT TO USE // // DELAY // // remove this line, and also look at // // 'whoosh', which enables and then disables // // the intterupt on timer 0. You'll want // // to get rid of those lines too. // TIMSK0 &= ~(1 << TOIE0); // pretty pattern to assure me that the firmware's // uploaded properly. whoosh(); // make sure to turn off the lights. for (int i = 0; i < 8; i++) { maxSingle(i+1,0); } } //void sendADC(int port, int value) { // Serial.write((1 << 4) | ((port << 2) & 0x0C) | ((value >> 8) & 0x03)); // Serial.write(value & 0xFF); //} // //int current[4]; //int previous[4]; //int tolerance = 7; //void checkADCs() { // // for (int adcCounter = 0; adcCounter < 4; adcCounter++) // { // // if (ADCEnableState[adcCounter] != 0) // { // current[adcCounter] = analogRead(adcCounter); // // if (abs(previous[adcCounter]-current[adcCounter]) > tolerance) // { // previous[adcCounter] = current[adcCounter]; // sendADC(adcCounter,current[adcCounter]); // } // // } // // } //} byte flipByte(byte numToFlip){ byte mirror = 0; for (int j=0;j<8;j++){ byte copy = numToFlip; mirror |= (copy>>j)&1; if (j<7){ mirror = mirror << 1; } } return mirror; } void loop () { // send the LED states to the LED matrix. for (int i = 0; i < 8; i++) { byte ledmemMirror = 0; if (mirrorXLEDs){ ledmemMirror=flipByte(ledmem[i]); } else { ledmemMirror = ledmem[i]; } int y; if (mirrorYLEDs){ y =(7-i)+1; } else { y = i+1; } maxSingle(y,ledmemMirror); } if (IntensityChange == 1) { IntensityChange = 0; maxSingle(max7219_reg_intensity, IntensityVal & 15); } if (DisplayTestChange == 1) { DisplayTestChange = 0; maxSingle(max7219_reg_displayTest, DisplayTestVal & 15); } if (ShutdownModeChange == 1) { ShutdownModeChange = 0; maxSingle(max7219_reg_shutdown, ShutdownModeVal & 15); } // check for button presses buttonpress(); // // check the state of the ADCs // checkADCs(); } You should see your leds light up one column at a time and scroll across the display when the firmware is finished uploading: If your leds are not wired up correctly, fixed them now before moving on to the next step. Step 23: Flash new serial number on Arduino This is the trickiest step. First you need to give your Arduino a new identity, you can follow these instructions with an Arduino Uno (Mac only). Disconnect your Arduino from your circuit while you do this. Be sure you read through the directions carefully and understand all the steps before you attempt this. If done incorrectly, you can potentially render your Arduino useless - though I'm not exactly sure how - I've just read a lot of warnings about it. In case this is useful, these are the instructions (Windows only) I followed to flash my duemilanova 4 years ago (taken from Julien Bayle's site ): 1. Download an install the D2XX drivers and the MProg application (in that order) 2. Connect your arduino to the PC and run MProg. 3. Select Device => Scan from the Menu. You should get a message like the following in the box bellow: Number Of Blank Devices = 0 Number Of Programmed Devices = 1 4. Select from the menu "Tools" => "Read and Parse". 5. At this point I saved the configuration I did "File" => "save as". This is not really needed, but I did it just in case I happen to screw up later on, to be able to recover the original configuration. 6. Check the “use fixed serial number” box and change the serial number value. Your board should have a serial with this shape: a40h-xxx (I'm using : a40h-001) 7. Save the configuration ("File" => "save as") 8. Once saved, program the FTDI by clicking on the flash icon (or doing "device" => "program"). 9. Unplug / plug back your board from the usb port. 10. Download and install Arduinome serial. 11. Run Arduinomeserial, you should see a device with the name you gave your arduinoe in step 6. I can't remember if it is necessary to upload the firmware on the Arduino again after this step. If so, you can select your board using its new name and upload like normal using the Arduino IDE. If the Arduino doesn't show up, try unplugging it and plugging it back in. Step 24: Arduinome Serial Arduinome Serial is an application that packages the messages coming from your touchscreen into OSC , so that can be sent into MaxMSP. It also receives messages from MaxMSP and packages them for Arduino. Download Arduinome Serial and plug in your Arduino. You should see Arduinome Serial recognize your Arduino with the new name you've given it. If it doesn't connect right away, make sure you have the Arduino Software closed, this can interfere with the connection. Step 25: MaxMSP MaxMSP is a graphical programming environment for running and writing interactive audio/video/graphics applications; it's what you'll be using to run apps on your touchscreen. Max is really fun and easy to use, I wrote a series of Instructables about how to write your own MIDI and audio applications in Max here, I even have a special section about how to write applications for monome here. Download MaxMSP (or at least MaxMSP Runtime) and grab some monome patches (applications in Max are called "patches") that seem interesting. Start with the "monome_test" patch from monome base to make sure everything is wired up correctly. If it is, try out boiingg (because it's easy to get started with) and then go from there. In all the Max patches for monome, you'll find a grey button that says "sys/prefix /XXXX" (where XXXX is the name of the patch), be sure to click that button so that it sets the correct prefix in the "Address Pattern Prefix" field in Arduinome Serial. This lets Arduinome Serial know the correct prefix to put on all the button press events it's receiving from your touchscreen before it sends them into Max, each monome patch only responds to messages with the corresponding prefix. This seems inconvenient, but it lets you have many patches open on your comp at once, while having control over which one is receiving messages at a time. Step 26: Troubleshooting You can rotate the orientation of your touchscreen in Arduinome Serial by selecting from the various options in the "cable orientation" dropdown. One of the most common mistakes with projects like this is to wire your array backwards. If the touchscreen is working with the "monome_test" patch in monome base, but the position of the buttons/leds is flipped from what shows up in Max, make the edits below to your firmware and re-upload it on the Arduino. Remember - You will need to disconnect from Arduinome Serial (by quitting the application) each time you connect to the Arduino through the Arduino IDE. And then you will need to quit Arduino to connect to Arduinome Serial again. you may also have to disconnect the Arduino from your computer and plug it in again to reinitialize the connection. This is a pain, but once you get the firmware right, you won't have to do it again. Firmware Edits - Find the following lines in the firmware and change all/none/some of these to true until everything is connected right: boolean mirrorXLEDs = false; boolean mirrorYLEDs = false; boolean mirrorXButtons = false; boolean mirrorYButtons = false;

              9 Schritt:Schritt 1: Einrichten der Umgebung Schritt 2: Lassen Sie uns Get Started Schritt 3: Hallo Welt Beispiel Schritt 4: Konvertieren von Zahlensystemen Schritt 5: Boolesche Operationen mit Python - bitweiser AND-Operator Schritt 6: Bitweise ODER-Operationen Schritt 7: Bitweise XOR-Operationen Schritt 8: Bitweises NOT und Shift-Operatoren Schritt 9: Bit Banging Beispiel

              Überblick Wenn ich etwas hämmern oder Programmierung Mikrocontroller, manchmal ich möchte wirklich, was die Bitmuster aussehen zu konzentrieren, wirklich zu visualisieren, was die Nullen und Einsen tun. Aber dass die Mathematik in vielen Fällen tun lenkt meine Aufmerksamkeit von der Aufgabe. Mit einem Taschenrechner ist langsam und schwerfällig, und lenkt mich auch aus den binären Operationen. Wir Menschen arbeiten und denken in dezimal. Bit-Muster sind in binär. Um die Konvertierung ein bisschen einfacher wir konvertieren hexadezimal zu machen. Mit, um diese Umwandlung zu tun, sei es mental, mit Papier und Stift oder Taschenrechner, zumindest für mich, stiehlt zu viel Aufmerksamkeit von was ich wirklich versucht, zu visualisieren. Ich habe über das Schreiben ein kleines Programm, das mich in meiner Visualisierung helfen werden gedacht, aber das dauert zu Zeit und nimmt mich weg aus der Beobachtung die Bitmuster. So nach grübeln dieses Dilemma für eine Weile, kam ich auf eine schnelle und einfache Lösung, die mir beispielsweise binäre Darstellung zu geben, ohne Knirschen Zahlen, ohne manuelle Konvertierung zwischen Zahlensystemen und ist sofort und einfach. Ich normalerweise Programm in C oder C ++, so würde Ich mag, um binäre Daten unter Verwendung von Befehlen, die gleich oder ähnlich zu C Booleschen Operatoren sind zu verarbeiten. Die Antwort ist Python. Für diejenigen unter Ihnen, die nicht wissen, ist Python eine interpretierte Sprache, die eine interaktive Shell (Befehlszeilenschnittstelle) genannt Idle hat. Python Idle Ich kann schnell konvertieren zwischen Zahlensystemen und führen alle Boolesche Operationen mit den gleichen Betreiber, die ich in C oder C ++. Wenn Sie neu in Boolesche Operationen sind oder wollen, um sich frisch zu Ihren Fähigkeiten finden Sie im folgenden Artikel verweisen, lassen Sie sich nicht die Tatsache, dass der Artikel in der Arduino Playground veröffentlicht abschrecken. Der Artikel ist leicht zu lesen, klar geschrieben und deckt das Thema von binären und Boolesche Operationen ganz gut. http://playground.arduino.cc/Code/BitMath Wenn Sie neu in binären und Boolesche Operationen sind zögern Sie nicht, meine "No Math" Konzept für die Lektüre dieses Artikels zu verwenden. Auch Sie können dann konzentrieren sich auf das Verständnis, wie Boolesche Operationen, ohne die Mathematik durchzuführen. In meiner "No Math Ansatz werde ich auf diesen Artikel Bezug werden von Zeit zu Zeit. Schritt 1: Einrichten der Umgebung Einrichten der Umgebung Python ist Open Source und seinem freien, Python läuft auf Windows, Linux und Apple OS X. So richten Sie Ihre Umgebung, den Kopf über die folgenden Links: http://python.org/ Wenn Sie Hilfe bei der Installation von Python oder das Lernen über Python zu nehmen müssen Sie einen Blick auf den Link unten: http://wiki.python.org/moin/BeginnersGuide Schritt 2: Lassen Sie uns Get Started Ich werde die Annahme, dass Sie wissen sehr wenig über python machen, Bit hämmern und Boolesche Operationen. Falls Sie erweiterte in Ihrem Bildungsniveau sind, zögern Sie nicht, um zu überspringen. Wenn Sie neu in die Programmierung, binäre Operationen und bit banging, zögern Sie nicht, Google jedes Thema Sie das Gefühl, Sie weitere Informationen zu benötigen. Lesen Sie dieses Material, um ein besseres Verständnis zu erlangen, bevor Sie fortfahren. Die Version von Python Ich verwende ist Version 3.2, wenn Sie diese Version oder neuere Versionen sollten in Ordnung sein. Wenn Sie mit einem 2.x-Version von Python sind, installieren Sie bitte die aktuelle Version 3.x. Sie können immer noch halten Sie Ihre 2.x Version von Python installiert. Wenn Sie eine Auffrischung auf Binär, dezimal und hexadezimal Zahlensysteme wie finden Sie in der unten stehenden Link: http://www.myhome.org/pg/numbers.html Laden Sie den Python Idle Anwendung auf Ihrem Desktop. Ich arbeite mit Apple OS X, so dass mein Desktop Bilder etwas anders als bei Ihnen aussehen. Aber die Vorgänge sind die gleichen. Sobald Idle Lasten sollten Sie folgendes Fenster: Schritt 3: Hallo Welt Beispiel Die >>> Prompt ist die interaktive Eingabeaufforderung, wo Sie Ihre Ausdrücke eingeben. Die Antwort auf Ihre Frage wird in der folgenden Zeile folgen: Bitte geben Sie die folgende Zeile nach der >>> Aufforderung, und drücken Sie die Eingabetaste: >>> Print ('Hallo Welt') Sie sollten die folgende sehen: Hallo Welt >>> Das ist Ihre nächste >>> Aufforderung; Sie sind bereit für weitere Befehle und Funktionen. Herzlichen Glückwunsch, Ihr erfolgreich geschrieben Ihre erste Linie der python code.Step 4: Konvertieren von Zahlensystemen Lassen Sie uns einige Zahlen konvertiert zwischen Zahlensystemen: Geben Sie folgende an der Eingabeaufforderung >>> und drücken Sie die Return-Taste: >>> Bin (100) '0b1100100' >>> Wir bitten, Python 100 dezimal binär konvertieren: Wir als Antwort empfangen wird, 1100100, feststellen, dass ein 0b Notation wird zu Beginn des 1100100 platziert ist dies Python Notation angibt, daß die Antwort ist binär. So haben wir 100 Dezimalstelle auf 1.100.100 in binäre umgewandelt. Geben Sie den folgenden: >>> Hex (100) '0x64' >>> Unsere Antwort ist 64 hex, ist die 0x python-Notation, die unsere Antwort ist hexadezimal. Wir haben 100 dezimal bis 64 hex umgewandelt. Lassen Sie uns versuchen, den anderen Weg nun in der folgenden an der Eingabeaufforderung >>> gehen ein: >>> Int ("0x64 ', 16) 100 >>> Beachten Sie, es gibt kein Dezember () -Funktion, müssen wir die int () Funktion verwenden. Beachten Sie auch, Wir mussten die '0x64' in einfache Anführungszeichen setzen. Die Funktion int () nimmt einen String als Wert. Wir müssen auch eine geben, (Komma), und geben Sie einen Wert von 16. Die 16 erzählt die int () Funktion, die 0x64 ist eine Hexadezimalzahl. Die Funktion int () wandelt String-Werte zu Dezimalwerten. Jetzt können Geben Sie folgende an der Eingabeaufforderung >>>: >>> Int ("1100100", 2) 100 >>> Verwenden des int () -Funktion können wir auch wandeln ein Binär-String-Wert in eine Dezimalzahl. Die, 2 erzählt die int () Funktion, die wir versuchen, eine binäre Zeichenfolge in eine Dezimalzahl umzuwandeln. Durch die Verwendung dieser drei Funktionen, bin (), hex, und int () können wir leicht zwischen allen Zahlensystemen umwandeln verwendet in der Programmierung. Schritt 5: Boolesche Operationen mit Python - bitweiser AND-Operator Für diesen Abschnitt werden wir auf die Arduino Spielplatz Artikel, BitMath Tutorial beziehen: http://playground.arduino.cc/Code/BitMath Bitweise UND-Operationen Lesen Sie den Abschnitt auf bitweiser AND-Operator. Geben Sie in den folgenden Ausdrücken: >>> 0 & 0 0 >>> 0 & 1 0 >>> 1 & 0 0 >>> 1 & 1 1 >>> Beachten Sie, wir haben die gleichen Antworten erhalten, wie in der Bitweises AND Beispiel angezeigt. Was wir geschaffen haben, nennt man eine Wahrheitstabelle für die bitweise UND-Verknüpfung. Wir haben jede mögliche Antwort, die wir erhalten können angezeigt werden, die Durchführung der bitweiser AND-Operator. Lassen Sie uns weiter mit dem Bitweises AND Beispiele: Geben Sie folgende an der Eingabeaufforderung >>>: >>> A = 92 >>> B = 101 >>> Bin (a) '0b1011100' >>> Bin (b) '0b1100101' >>> A & b 68 >>> Bin (a & b) '0b1000100' >>> Hier haben wir einen Wert von 92 bis Variablen a und einen Wert von 101 bis Variable b zugeordnet. Dann konvertiert die Werte von a und b, um binäre, einfach die Ergebnisse der bitweisen UND-Operation sehen. Dann führte die bitweise UND-Verknüpfung, indem Sie a & b, führte dies zu einem Wert von 68. Aber wir, die Antwort in binären visualisieren möchten, so dass wir in den Papierkorb (a & b) Funktion eingegeben. Wir können jetzt einfach die bitweise UND-Verknüpfung zu visualisieren, ohne dass unsere Aufmerksamkeit vom Blick auf die binären Muster von 92 und 101, um die Mathematik zu tun zu entfernen. Lassen Sie uns auch weiterhin die mit dem bitweisen AND Beispiele: Was halten Sie das bitweise AND-Operator in der Programmierung oder etwas hämmern benutzen? Eine der Anwendungen ist es, eine der Bit-Werte von einem Byte zu extrahieren. (Acht Bits) Können sagen, wir um den Wert des niedrigstwertigen Bits der binären Zahl 101 extrahieren möchten, das Recht höchstens 1 ist die niederwertigste Bit. Geben Sie folgende an der Eingabeaufforderung >>>: X = 5 >>> Bin (x) '0b101' >>> Y = x & 1 >>> Bin (y) '0b1' Wollte man das zweite niedrigstwertige Bit von dem Wert von 101 zu extrahieren, würde das zweite niedrigstwertige Bit 101 die 0 sein. Geben Sie folgende an der Eingabeaufforderung >>>: >>> Y = x & 2 >>> Bin (y) '0b0' >>> Achten Sie darauf, verschiedene Prozessoren definieren niederwertigsten Bitpositionen unterschiedlich. Einige Prozessoren verwenden die am weitesten links liegenden Bit als das niedrigstwertige Bit Position und einige Prozessoren verwenden die am weitesten rechts liegenden Bit-Position wie das niedrigstwertige Bit position.Step 6: bitweises ODER-Operationen Siehe Abschnitt bitweisen OR-Operator in der Arduino Spielplatz Artikel. Ich werde euch die bitweise ODER-Wahrheitstabelle mit den Beispielen in dem Artikel zu bauen. Wir werden uns auf das, was können Sie den bitweisen OR-Operator für die Anwendung zu konzentrieren. Wir verwenden den bitweisen OR-Operator, um Bits in einem Byte (Binärzahl) eingestellt. Lassen Sie sagen, dass wir, um die am wenigsten signifikante Bit in dem Wert von 0b100 festlegen möchten. Geben Sie folgende an der Eingabeaufforderung >>>: >>> X = 4 >>> Bin (x) '0b100' >>> Y = x | 1 >>> Bin (y) '0b101' >>> Lassen Sie uns jetzt stellen Sie die zweite Bit auf einen Wert von 1, dh: 111 Geben Sie folgende an der Eingabeaufforderung >>>: >>> Y = y | 2 >>> Bin (y) '0b111'Step 7: Bitweise XOR-Operationen Siehe Abschnitt bitweiser XOR-Operator in der Arduino Spielplatz Artikel. Ich werde euch die bitweise XOR-Wahrheitstabelle bauen am Beispiel in dem Artikel. Wir werden uns auf das, was können Sie die bitweiser XOR-Operator für die Anwendung zu konzentrieren. Wir nutzen die bitweiser XOR-Operator zu kippen oder umzuschalten Bits in einer Zahl (binäre Zahl). Lassen Sie sagen, dass wir, um die am wenigsten signifikante Bit in dem Wert von 0b110 Flip möchten. Geben Sie folgende an der Eingabeaufforderung >>>: >>> X = 6 >>> Bin (x) '0b110' >>> Y = x ^ 1 >>> Bin (y) '0b111' >>> Lassen Sie uns jetzt drehen Sie die zweite Bit in dem Wert 0b111 Geben Sie folgende an der Eingabeaufforderung >>>: >>> Y = y ^ 2 >>> Bin (y) '0b101' >>> Das ist sehr cool. Wir können jetzt steuern Einstellung und schnell sehen Bit-Werte und Muster und easily.Step 8: Bitweises NOT und Shift-Operatoren Bitweises NOT Operationen Siehe Abschnitt bitweiser NOT-Operator in der Arduino Spielplatz Artikel. Fühlen Sie sich frei zu spielen, um mit dem Operator NOT. Aber studieren diesen Operator sorgfältig wie Null und negative Zahlen werden anders dargestellt als Sie vielleicht denken. Werfen Sie einen Blick auf, was ein Vorzeichenbit und den Artikel auf Zweier-Komplement zu lesen. Der Hauptbetrieb der bitweiser NOT-Operator ist, Flip 0 auf 1 und 1 auf 0. Auch dieser Operator arbeitet auf eine Zahl anstelle von zwei Zahlen. Bit Shift-Operatoren Beziehen sich auf die bitweise Verschiebung Bedieneinheit in der Arduino Spielplatz Artikel. Fühlen Sie sich frei zu spielen, um mit den beiden links zu verschieben und mit der rechten Shift-Operatoren. Verwenden Sie das bin () -Funktion, um die binären Werte zu überprüfen, wie wir mit den anderen Bit-Operatoren durchgeführt. Echt Einsatz von links zu verschieben und mit der rechten Maus Betreiber sind, abziehen entweder das niederwertigste oder höchstwertige Bit von einer Reihe ein Bit zu einer Zeit. Rest des Artikels Jetzt haben Sie genügend Informationen, um den Rest des Artikels auf eigene Faust zu lesen und sich an die "No Math" Python-Ansatz. Kommen wir nun zu einem echten bit hämmern example.Step 9 aussehen: Bit Banging Beispiel Programmierung Mikrocontroller oder versuchen, Reverse Engineering, was ein Mikrocontroller Programm macht die Verarbeitung beinhaltet eine Menge von binären Informationen. Zum Beispiel ist eine Möglichkeit, wie Microcontrollern mit anderen Geräten kommunizieren, um eine einfache Zweidraht-Schnittstelle genannt I2C ausgeprägte I quadriert C. Verwendung I2C beinhaltet, um eine Adresse eines Geräts, das für die Anforderungen von dem Mikrocontroller abhört, (Mastergerät) Wenn eine Anforderung von der Vorrichtung empfangen wird, (Slave), sendet das Gerät entweder ein oder mehrere Bytes von Daten Binärdaten zurück zu der Mikrocontroller. Lernen, wie man die Kommunikation auf I2C-Geräte zu programmieren oder zu versuchen, Reverse Engineering Daten aus I2C-Geräte müssen Sie die Daten anschauen, es ist in binärer Form. Ich werde Ihnen eine einfache Beispiel zeigt, wie diese mit den Sie gerade gelernt haben Verfahren zu tun. In Lern ​​I2C ist es oft ratsam, studieren anderen Programmen Programmierer geschrieben haben, so können Sie lehnen Sie, wie Daten zwischen Mikrocontroller und Geräten übergeben. So zum Beispiel werden wir an einem Programm-Snippet von einigen RobotC Code, um etwas geschrieben Knall einen I2C-Gerät zu suchen. Ich habe eine Probe bisschen knallte C-Programm in RobotC von Xander geschrieben, die einen Roboter Blog namens hält wurde: http://botbench.com/blog/2011/02/20/bit-banged-i2c-master-on-robotc-for-arduino/#comment-2674 In diesem Blog-Artikel er etwas hämmern eine I2C-Programm, um mit einem LED-Array, um LED-Leuchten in einer Sequenz blinken zu kommunizieren. Wir werden Reverse Engineering der for-Schleife benutzt er, um eine Reihe von Bits, die dem LED-Array zu senden. Wenn Sie noch nie programmiert haben, google bitte Variablen, for-Schleife, Funktionen und While-Schleifen. Hier ist der Code-Schnipsel werden wir uns bei: while (true) { for (int i = 0; i <8; i ++) { PCF8574write (~ (1 << i)); wait1Msec (50); } } Normalerweise würde ich ein kleines Python-Programm zur Schleife drucken Sie sich die Werte der zu schreiben. Aber da ich gehe davon aus, jeder ist neu in die Programmierung und Boolesche Logik ich manuell eingeben aus jeder Iteration der for-Schleife. Besonderer Hinweis: Python unterstützt kein Byte-Datentyp, so in unserem bit hämmern Beispiel werden wir den Modulo-Operator verwenden, um eine ganze Zahl als Byte ohne Vorzeichen angezeigt werden sollen. Bitte Google inf Sie Hilfe benötigen, Zum Beispiel: Wenn wir das folgende Beispiel auszuführen: >>> ~ (1 << 0), in Python wir -2, Wenn wir dann >>> bin (-2), so erhalten wir '-0b10'. Um das Problem zu beheben und zeigen eine volle 8 Bits geben Sie den folgenden: >>> Bin (-2% 256) '0b11111110' Um richtig zu sehen, was los ist mit Bits müssen wir die vollen 8 Bit zu sehen. Das ist zwar immer Looping, ignorieren Sie diese jetzt. Die for-Schleife Schleifen, wo die Variable i gleich 0-7 ist. PCF8574write () ist eine benutzerdefinierte Funktion, die wir im Rahmen dieses Artikel wird diskutiert. Sie können auf den Code verweisen, um zu sehen, was diese Funktion hat auf eigene Faust. Was uns interessiert, ist der Wert von i und welche Binärzahl wir zum PCF8574write () Funktion übergeben. Lets übersetzen jeder Iteration der for-Schleife: Lets geben Sie jede Iteration der Schleife in Python: Die Variable i beginnt als 0 und endet bei einem Wert von 7: >>> ~ (1 << 0) -2 Lets ziehen diesen Ausdruck auseinander. Wir führen eine bitweise NOT auf den folgenden Wert. Wir Linksverschiebung den Wert 1, i-mal. Das heißt wir 1 << 0. Wir drängen Bits von rechts nach links, .In der ersten Schleife wir Linksverschiebung 1, 0 mal, oder wir das höchstwertige Bit. Also, wenn wir uns den binären Wert von -2 erhalten wir: >>> Bin (~ (1 << 0)) "0b10 ' Lets fortfahren, werden Sie bald sehen, das Muster. >>> ~ (1 << 0) -2 >>> Bin (-2% 256) '-0b11111110' >>> ~ (1 << 1) -3 >>> Bin (-3% 256) '-0b11111101' >>> ~ (1 << 2) -5 >>> Bin (-5% 256) '-0b11111011' >>> ~ (1 << 3) -9 >>> Bin (-9% 256) '-0b11110111' >>> ~ (1 << 4) -17 >>> Bin (-17% 256) '-0b11101111' >>> ~ (1 << 5) -33 >>> Bin (-33% 256) '-0b11011111' >>> ~ (1 << 6) -65 >>> Bin (-65% 256) '0b10111111' >>> ~ (1 << 7) -129 >>> Bin (-129% 256) '-0b1111111' Die führende 0 in diesem Fall weggelassen. Es sollte lesen "-0b01111111 ' Nun, wenn Sie nicht bereits getan haben, gehen Sie auf die Webseite und das Video: http://botbench.com/blog/2011/02/20/bit-banged-i2c-master-on-robotc-for-arduino/#comment-2674 Nun ein Blick auf den Bitmuster sehr eng. Beachten Sie, dass, wie die for-Schleife erhöht, dass die 0-Bit hält auf Bewegung nach links. Ich werde versuchen Sie nicht, dass Sie zu viel verwirren gerade jetzt, (es gibt eine andere bitweise AND und eine Linksverschiebung Betrieb im i2c_write () Funktion) ist die Priorität, Boolesche Operationen zu verstehen und zu wissen, wie man Python verwenden, um Sie in das Verständnis dieser Boolean unterstützen Operationen. Wenn Sie es fühlen, Reverse Engineering i2c_write (), um zu sehen, wie die Bitmuster weiterverarbeitet werden, bevor sie an dem LED-Array gesendet. In der Arbeit mit Microcontrollern, wenn ein Bit hoch ist, mit einem Wert 1, wird in der Regel ein Gerät eingeschaltet ist. Wenn ein wenig niedrig ist, mit einem Wert 0 ein Gerät ausgeschaltet ist. Beachten Sie, dass wir es mit 8 Bit arbeitet und unsere LED-Array verfügt über 8 LEDs. Ja das ist korrekt. Jedesmal, wenn wir setzen ein bisschen auf, mit einem Wert von 1, wenden wir uns an der LED. Wenn wir den Bit-Wert auf 0 oder den etwas abseits, wenden wir uns von der LED. Jetzt wieder das Video. Jetzt Bild, das sowohl für Loops, eine in der Hauptfunktion und die for-Schleife in der i2c_write Funktion laufen so schnell oder schneller als die LEDs blinken. Die Logik in der i2c_write () ist die Durchführung ein wenig komplexer Logik, Verwendung python zu visualisieren, wie das High oder Low-Bit-Zustände ändern sich auch die 8 Bits werden durch in der for-Schleife trat. Bitte halten auf das Lernen über Mikrocontroller und Boolesche Operationen, wie das sind die Bausteine, um die Programmierung Mikrocontroller.

                10 Schritt:Schritt 1: Definieren Sie die Projekt Schritt 2: Prototyp der Schaltung Schritt 3: Schreiben Sie den Code Schritt 4: TEST TEST TEST TEST Schritt 5: Elektronische Schematischer Aufbau Schritt 6: PCB Layout Schritt 7: Schneiden Sie die Leiterplatte Schritt 8: Setzen Sie die Projekt Schritt 9: Installieren Sie den Leiterplatten- Schritt 10: Fertig

                Ich hatte eine Ampel, dass ich die Reparaturlackierung. Das einzige, was noch zu tun war, um die Steuerung für Signalmuster des Lichts zu bauen. Um es eine Wendung zu geben I integriert eine Fernbedienung. Dies war auch die perfekte Gelegenheit für mich zu versuchen, ein Arduino. Ich wollte die Verwendung der Arduino becuase war es leicht, auf Mac und Windows.

                  6 Schritt:Schritt 1: The Eagle Schematic Schritt 2: Controlling 2 DC Bürstenmotoren Schritt 3: Steuern von 2 Servos Schritt 4: Der Aufbau einer Steckbrett Roboter mit GOduino III Schritt 5: GOduino III Objekt Vermeidung Roboter Schritt 6: Dank

                  UPDATES 16. November 2012 auf DangerousPrototypes.com Beliebte http://goo.gl/N4DIC 3. Oktober 2012: Ich habe eine PCB-Adapter an Position IR & Ultraschall-Sensoren helfen, 90 Grad, in Steckbrett zu GOduino III Roboter Projekte zu unterstützen 1. September 2012 entworfen : Added EAGLE Board-Layout EINFÜHRUNG Die GOduino III ist eine kostengünstige Arduino kompatible Open-Source-Hardware Robotersteuerung. Es ist eine einfache und kostengünstige Robotersteuerung (appx. 25 €). Ich baute diesen Controller für meine Robotik-Workshops als auch für meine persönliche Projekte. Die GOduino III kann in ein Steckbrett für einfache Prototyping eingefügt werden. Ich habe auch eine Software-Bibliothek (Goduino.h) zu motorischen Funktionen unterstützt entwickelt. Es ist eine Erweiterung von Adafruit die Boarduino . HINWEIS: Dies ist meine erste PCB-Projekt so mit Ihrem Feedback am meisten geschätzt wird. Ich bin auch sicher, dass diese Anleitung enthält viele Tippfehler. So in den nächsten Tagen werde ich Korrekturen und das Hinzufügen von mehr Details basierend auf dem Feedback der Leser. Vielen Dank im Voraus für Ihre Unterstützung. HINTERGRUND Dies ist eine 3. Generation GOduino. Die eine war die vor prefboard GOduino II und der erste war ein Steckbrett GOduino. 1) GOduino II (prefboard) http://www.instructables.com/id/GOduino-II-Arduino-L293D-Variable-Speed-Motor-/ 2) GOduino I (Steckbrett) http://www.instructables.com/id/GOduino-The-Arduino-Uno-Motor-Driver-clone/ ÜBERSICHT Die GOduino III basiert auf dem ATMEGA328P Mikrocontroller und dem L293D Dual H-Brücken-basierte. Es ist mit DIP ICs und Durchgangsbohrung Komponenten für eine einfache Montage und Reparatur gebaut. Diese Robotersteuerung kann 2 kleine Servos handhaben und 2 DC Bürstenmotoren (max 1,2 A für jeden Motor mit 2 X L293D). Die GOduino III kann mit einem Standard-Arduino IDE über einen FTDI USB / UART-Programmierer oder über die ICSP-Header mit Programmierern wie AVR-ISP, STK500 oder parallel Programmierer programmiert werden. TECHNISCHE DATEN Auf der Grundlage der ATMEGA328P Mikrocontroller @ 16 MHz (im Herzen der Arduino Uno DIP-Modell) Größe: 5 cm X 2,5 cm. Stecker in eine Steckbrett mit Hilfe von 0,1 "(2,54 mm) Stiftleisten oder Sie können Buchsenleisten löten Arduino-Standard digital, analog, und Spezialstifte ausgesetzt Digital I / O Pins:.. 14 (davon 6 ausgegebenes PWM liefern) - Analog Input Pins: 6 2 X LED: eine für Power und eine andere für Stift 13. Reset-Taste 2 X 3-poligen 0,1 "(2,54 mm) Kopfzeilen (5 V) für kleine Servos.. 2 x 2-polige 0,1 "(2,54mm) Header für bürstenbehaftete Gleichstrommotoren. 6-poligen 0,1" (2,54 mm) ICSP Stiftleiste. 6-pin 0,1 "(2,54 mm) Stiftleiste, um FTDI USB-Programmierer zubringen Flash-Speicher:. 32 KB von denen 0,5 KB SRAM durch Bootloader verwendet: 2 KB EEPROM: 1 KB PROGRAMMIER Die GOduino III kann mit dem Arduino IDE über einen FTDI USB Programmierer Es kann auch über die ICSP Header mit Programmierer wie AVR-ISP, STK500 oder parallel Programmierer programmiert werden programmiert werden. Die FTDI "FT232RL USB to Serial Adapter" für weniger als 10 € von Ebay erworben werden. Außerdem können Sie einen Arduino Uno DIP verwenden, um die GOduino III ATmega328 Mikrocontroller programmieren setzen Sie sie wieder in die GOduino III. Auto-Reset-Funktion für FTDI-Programmierer über den DTR-Pin. POWER- Logikspannung: 5V vom T7805CV Regler zugeführt. Eingangsspannung (empfohlen): 7-12V. (Grenzen): 6-20V Motor Spannung: Während der L293D Motortreiber-IC ist für 4,5V bis 36V gelesen werden wir von den empfohlenen / Grenzspannung Bewertungen des Leistungsregler gebunden. 1N7001 Diode schützt vor Gegenspannung von der externen Stromquelle. Die L7805CV Regler bietet 1,5 A, die genug an die Macht der GOduino III und 2 kleine Servos ist. Sie können die 7805 mit Pin-kompatibel Low-Drop-out-Spannungsregler mit höherer Strom wie der LM1084-5V die 5A mit einer maximalen Dropout-Spannung von 1,5 V Quelle kann zu tauschen. Die 5V-Regler auch Kräfte der Servos nicht aber die Motoren. Für die Motoren, bekommt der L293D H-Brücke seine Energie aus dem DC-Steckfassung oder der VIN Pin direkt. Sie können wählen, um die GOduino III von USB oder externes Netz mit einem Stift-Jumper Strom zu versorgen. Bitte beachten Sie, dass USB-Energie nicht ausreichen, um Servos und Motoren zu betreiben. Der L293D H-Brücke kann unterstützt 2 DC-Motoren @ 600mA Dauerstrom je. Sie können zwei L293D huckepack um den Strom auf 1,2 A pro Strommotors zu verdoppeln. PARTS Kondensatorkeramik 0.1uF X 5 10uF / 25V 100uF / 16V 100uF / 6V X 2 Diode 1N4007 LED Red 3MM LED Grün 3MM ATMEGA168P Mikrocontroller 7805 5V-Regler L293D Dual h-Brücke DC Jack Buchse 1X2-3.5MM 40-polige Stiftleiste (0,1 " 2,54 mm) DIP-Sockel 28-Pin-Taste DIP-Sockel 16-Pin-Resistor 10K Ohm Resistor 1.0 K Ohms X 2 Reset 16.00MHz Ceramic Resonator 3-pin Ich überlege, Ersetzen des 3,5-mm-DC-Buchse mit einem Anschlussblock für den nächsten Patch von GOduino PCBs. Sie können die EAGLE Schaltpläne für die Leiterplatte von Github zusammen mit der Bibliothek zu erhalten. Die Board-Layout wird geändert, aber ich werde es bald Github veröffentlicht, sobald ich fertig bin. Software Library Es gibt 4 motorischen Funktionen im Goduino Bibliothek. Sie werden im Abschnitt über die Steuerung von Motoren erläutert. Motorgeschwindigkeit (mot1speed, mot2speed) Setzt Geschwindigkeit für beide Motoren. Motorstop (motorNum) Stoppt ein Motor. motorForward (motorNum) spinnt ein Motor in eine Richtung. motorBack (motorNum) spinnt ein Motor in der umgekehrten Richtung. Die GOduino III Motor Bibliothek und andere Support-Dateien können von Github zum Download bereit: https://github.com/techbitar/goduino VIDEO

                    1 Schritt:

                    Alle 8 Artikel anzeigen Fortsetzung folgt ... Sonnenkollektor-Controller, Thermostat mit Arduino Pro Mini-Prozessor, LCD-1602 und 3 Temperaturfühler DS18B20, enternet Stecker, 5-Taste der Tastatur. Komponenten: Pro Mini ATmega328 5V 16M Arduino Compatible, 1602 16x2 HD44780 Character LCD Display-Modul, 3 Temperaturfühler DS18B20, 5V 2 - die Temperatur um den Kollektor und die Wasserheizung Tank (Kessel gemessen - wird Kanal Relaismodul Der Kollektor sehr einfach gesteuert ). Wenn die Wassertemperatur im Solarkollektor ist höher als Kessel dreht Steuerung der Pumpe und der Wärmeübergang vom Kollektor zum Warmwasserspeicher beginnt. Wenn die Temperaturdifferenz abnimmt, wird die Umwälzpumpe abgeschaltet. Controller hier beschriebenen funktioniert wie folgt: 1. Wenn die Temperaturdifferenz zwischen Solarkollektor und dem Tank mehr als 5 Grad, wird der Schalter eingeschaltet ist. Temperture gemessen wird und auf dem Bildschirm ständig angezeigt wird, aber der Unterschied ist alle 15 Sekunden kontrolliert. 2.when die Temperaturdifferenz zwischen Solarkollektor und dem Tank geringer ist als 2 Grad wird das Relais ausgeschaltet. Differenz überprüft alle 15 Sekunden. 3.Potentiometer kann eine beliebige Anzahl von 0 auf 100 zu stellen, rodomasekrane es. Wenn die 3-ber Sensortemperatur erreicht der Endschalter 2. Relais. Unterschreiten der Grenzschalter ausschaltet. 4.Instead der beiden Sensoren (löten Sie die beiden Widerstände oder schneiden Sie die Spur in der PCB) kann eine weitere 2-Kanal-Relaismodul und die erforderlichen Sensoren parallel über ein einziges Kabel verbunden zu verbinden. Für die Steuerung an die Arbeit nach solchen Änderungen benötigen nur minimale Verbesserungen des Programms. 5.DS18B20 Sensoren angeschlossen werden 2 oder 3 Drähte. 6. Die Anzeige zeigt die Kesseltemperatur, Kollektortemperatur, Temperaturdifferenz, dritte Sensortemperatur mit Potentiometer voreingestellte Temperatur, Relaisstatus (Ein / Aus).

                      8 Schritt:Schritt 1: Nehmen Sie neben der Controller- Schritt 2: Sculpt Schritt 3: Anbringen des Lehm- Schritt 4: untere Hälfte des Controllers Schritt 5: Malen Schritt 6: Clear Coat Schritt 7: Tasten, Trigger und Bumpers Schritt 8: Legen Sie es zusammen

                      Ich beobachtete David Cronenbergs Film eXistenZ den anderen Tag und bekam die Krätze, eine Xbox-Controller inspiriert durch das Spiel pod in den Film zu machen. Wenn Sie es nicht gesehen haben, es ist ein Ende der 90-er Film über immersive Videospielen mit viel fab fleischigen Technologie. Es ist alles klebrig, bio Grobheit in dieser köstliche Art und Weise. Mein erster Versuch war ein völliger Misserfolg im Formenbau, die ich hier dokumentiert. Ich landete unter den ursprünglichen Polymer Clay, dass ich im Begriff war, gegossen und nur gebacken, um sie an die Steuerung anschließen. Es ist schwerer, clunkier, und bei weitem nicht so raffiniert wie ich gehofft hatte, aber zumindest habe ich ein fertiges Produkt und es tatsächlich funktioniert. Die Wirbelsäule auf dem D-Pad ist ein wenig umständlich beim Spielen, aber es ist wirklich eher ein Gesprächsstoff, als eine alltägliche Steuerung. Materialliste: Xbox-Controller Polymer-Ton Farbe Füller und Klarlack Sekundenkleber Schraubendreher

                        9 Schritt:Schritt 1: Schritt 1 Materialien und Werkzeuge benutzt Schritt 2: Kennzeichnung Out Schritt 3: Ziehen Sie Controller-Apart vorsichtig Schritt 4: Start Drilling! Schritt 5: Suchen Sie im Internet nach einem 20mm Lüfter Schritt 6: Installieren der Fans Schritt 7: Bauen Sie den Controller Schritt 8: In 9V-Batterie und Holster Schritt 9: Komplette, indem Sie das 9-V-Stecker

                        Hallo, Mein Name ist Jimi und Ich mag die Dinge mit meinen Händen, meine Hobbys sind kleine und große Motor Mechanik, Software und Hardware von Computern, Holzarbeiten, Metallarbeiten und ich plantschen in Kunststoffarbeiten. Diese Idee kam mir, einem heißen Tag während Putting eine Xbox 360-Controller wieder zusammen nach der Fixierung auf einen Knopf. Es ist eine ziemlich einfache Idee der Platzierung Fans an der Stelle der Vibrationsmotoren, die Kühlung der Benutzer die Hände nach unten. Ich danke Ihnen allen, und vergessen Sie nicht, für mich zu stimmen, Beifall. (ACHTUNG: Wenn Sie gerade Ihren Controller / Xbox 360 gebracht haben, können Sie nicht wollen, um dieses Instructable tun, denn es kann keine Gewährleistung aufheben Sie haben können) (Bild gezeigt, der es zu vollenden, ohne Farbe, noch die Entscheidung über Mattschwarz oder Käse-Farbe)

                          7 Schritt:Schritt 1: Öffnen Sie den Controller Schritt 2: Nehmen Sie sie auseinander, aber nicht die Stücke zu verlieren! Schritt 3: Machen Sie Ihre Verbindungen Schritt 4: Tragen Sie Ihre neue Schaltfläche! Schritt 5: Führen Sie Ihre Drähte Schritt 6: Setzen Sie Ihre Controller wieder zusammen Schritt 7: Viel Spaß!

                          Beim Spielen Call of Duty auf xbox live, bemerkte ich einige Leute, meine Kugeln Ausweichen aus der Nähe von hockend und gehen neigen während des Schießens und halten ihr Ziel auf mich. Wenn Sie mit den Steuerelementen für Call of Duty vertraut sind, würde dies bedeuten, ihren rechten Daumen wurde die Taste B Halten und Bewegen des rechten Daumen-Stick während des Schießens. Ich bin sicher, es gibt eine Art von Finger Yoga Sie tun können, um dies zu erreichen, aber das ist schwierig und führt wahrscheinlich zu Arthritis. :) Es wäre viel besser, wenn es eine weitere Taste auf der Rückseite des Controllers, wo Ihre Mittel- oder Ringfinger hängen nichts zu tun, Ihr Spiel zu verbessern, während der Rest der Finger am Werk sind. Diese instructable ist generisch und ist auch gut für Battlefield Spieler, die zurück zu Ort, ohne dabei die Finger drücken wollen. Hinweis: Sie müssen für diesen mod löten!

                            7 Schritt:Schritt 1: Materialien Schritt 2: Öffnen Sie den Controller Schritt 3: Lötdrähte Schritt 4: A Little Surgery Schritt 5: Der Button Schritt 6: Verdrahtung Schritt 7: Programmierung

                            Ich wollte nicht, um eine modded Controller-Chip aus zwei Gründen zu kaufen, den sie nur die eine Sache, und zwei werden sie heraus Stichtag schnell macht sie nutzlos für neue Spiele zu tun. Also das arduino ich abgeholt schien perfekt, es ist programmierbar Sinne, dass, wenn es ein Update und es aufgehört zu arbeiten, ich könnte einfach den Code ändern, und es würde wieder arbeiten und die Arduino ist sinnvoll, in einem in der Nähe infinate Menge von Projekten. Auch, weil ich diese Mod für Splitscreen und private Begegnungen absolute Perfektion wollte nur nicht nötig war. Also, wenn Sie für den besten Schnellfeuer suchen gibt, gehen Sie kaufen einen Chip. Aber wenn Ihr nicht ein Perfektionist, und Sie wollen, dass die Dragunov in die AK drehen, dass es wirklich oder schießen das Barrett wie ein p90, dann ist dies für Sie. Zunächst einmal sollten Sie wissen, dass wie alle anderen Xbox-Controller Mods gibt es einige Risiken. Dem ersten Öffnen der Steuerung erlischt die Garantie ( ich hebe Garantien ), Wenn Sie das Löten falsch machen könnten Sie beschädigen Sie Controller sind dauerhaft, und wenn Sie es auf den Live-Einsatz Ich denke, es ist ein Trinkbarkeit Sie verboten werden könnte (ich gespielt habe ein paar Spiele auf Live-so ist es nicht instant). Ich übernehme keine Verantwortung für die Auswirkungen des Projekts. Dort gehen Sie gewarnt habe. Update: Zwei zusätzliche peices sind für eine bessere Leistung erforderlich ist, ein Widerstand (Gold, schwarz, rot, gold) und eine Diode (Ich denke, jeder tun wird). Befestigen Sie die Diode an den Draht von der Schaltfläche, die Vin geht, sicherzustellen, dass das schwarze Ende in den Vin Stift und dem Silber geht (-) Ende geht auf die Tasten Draht. Befestigen Sie den Widerstand auf den anderen Draht von der Taste, die in Pin 4 geht (es spielt keine Rolle, welchen Weg Widerstände haben keine Polarität). Fiel frei, um mit anderen Widerstand Diode Combos zu experimentieren, wenn Sie eines, das gut funktioniert bitte einen Kommentar hinterlassen zu haben. Ich habe auch eine crumby Video für Ihr Sehvergnügen (oder deren Fehlen)

                              23 Schritt:Schritt 1: Kennen Sie Ihre Teile Schritt 2: Vorbereiten des Controllers Schritt 3: Entfernen Sie die Schraube unterhalb des Akkus Schritt 4: Entfernen Sie die restlichen 6 Schrauben auf der Rückseite des Controllers Schritt 5: Entfernen Sie die Rückseite der Schale Schritt 6: Legen Sie den Controller Schritt 7: Entfernen Sie die Vibrationsmechanismen Schritt 8: Entfernen Sie den Mikrochip und zugehörige Komponenten Schritt 9: Entfernen Sie Gummiabdeckungen Schritt 10: Nehmen Sie die A, B, X, Y, "Zurück", "Start" und Xbox Energie buttons Schritt 11: die Rückseite des D-Pad herausdrehen Schritt 12: Entfernen Sie die oberen und unteren Ende der D-Pad Schritt 13: Entfernen Sie die Auto-Panel Schritt 14: Entfernen Endkappe des Controllers Schritt 15: Sie haben nun erfolgreich neben dem Controller genommen Schritt 16: Legen Sie A, B, X, Y, "Zurück", "Start" und Xbox Netzschalter in der neuen Shell Schritt 17: Setzen Sie die D-Pad Schritt 18: Installieren Gummiabdeckungen, Top Stoßfänger und Controller-Endkappe Schritt 19: Setzen Sie den Mikrochip und zugehörige Komponenten Schritt 20: Legen Sie die Vibrationsmechanismen in dort neue Wohnungen Schritt 21: Legen Sie die Rückseite des neuen Shell anstelle Schritt 22: Bringen Sie die Schrauben in entsprechende Löcher Schritt 23: Genießen Sie Ihre scheinbar neue (und viel cooler) Controller!

                              Willst du etwas spannender dann Ihren alten stumpf matt schwarz oder weiß? Risse oder Beschädigungen Ihrer alten Frontplatte? Dann werden diese Anweisungen sind für Sie da! In dieser Anleitung erfahren Sie, wie Sie auf einer Xbox 360 Wireless Controller verändern sich die Schale. WARNUNG: Die folgenden Anweisungen können Sie Ihre Xbox 360-Controller Garantie!

                                6 Schritt:Schritt 1: Sammeln Sie die Materialien Schritt 2: Demontage der Steuerung Schritt 3: Entfernen Sie den Joystick Schritt 4: Anbringen der New Joystick Schritt 5: Zusammenbau des Controllers Schritt 6: Fazit

                                Haben Sie jemals eine der Joysticks hatte auf dem Controller Pause, die den Controller völlig nutzlos? Es ist dein Glückstag, weil diese Instuctable wird Ihnen zeigen, wie Sie Ihre Steuerung durch den Austausch des Joystick gegen einen neuen zu reparieren. Diese Reparatur ist groß, weil für einen Bruchteil der Kosten eines neuen Controller, können Sie Ihre alte zu reparieren. Wenn Sie bereits über das Gerät, wird dieses Reparaturkosten nicht mehr als € 5, viel besser als der Kauf eines neuen € 50 Controller. Mit einigen grundlegenden elektronische Reparatur-Fähigkeiten und Ausrüstung, können Sie Ihre Steuerung in kürzester Zeit repariert. Der Zeitaufwand ist minimal und kann 30-90 min je nach Spielstärke zu nehmen. Ich hoffe, dies wird instructable von Nutzen sein und Ihnen helfen, wieder zu gaming!

                                  9 Schritt:Schritt 1: Wo gibt es die Supplies Schritt 2: Demontage des Controllers Schritt 3: Bohren der Buttons Schritt 4: Anbringen der LED Schritt 5: Fräsen aus dem Gehäuse Schritt 6: Verdrahtung der LEDs Schritt 7: Der Widerstand Schritt 8: The Jewel (Optional) Schritt 9: Cleanup

                                  Diese instructable legt zu leuchten die vier A, B, X, Y Tasten und Juwel einer ursprünglichen Xbox-Controller-S. Um dieses Projekt zu vollenden, ist komfortabel mit einem Lötkolben wird empfohlen. Auch wenn Sie nicht in Löten erlebt, aber möchte lernen, lesen Sie auf diesen Führungen und fühlen sich frei, diese Mod zu tun. Wie zu löten Wie LEDs Verdrahten Dieses Handbuch lehrt mit Worten als auch Bilder, von denen fast alle Kommentare zur Klärung, was los ist bei der Installation haben. Dies kann ein langwieriger installieren, da Toleranzen innerhalb eines Xbox-Controller sind relativ eng, klein sind die Stücke, und erwarten, dass jeder Controller überall von 2-3 Stunden je nachdem, wie gut Sie sind zu nehmen. In dieser Anleitung verwende ich langsam verblassen RGB (Rot, Grün, Blau) LEDs, obwohl jede Kombination von Farben für Ihre Wahl Beleuchtung verwendet werden. Ich hoffe, Sie genießen diese instructable, und sind in der Lage, Ihre Xbox-Controller ändern zu leuchten viele Nächte von Gaming. *** Ich bin nicht verantwortlich für persönliche Schäden oder Verletzungen, die sich aus folgenden dieses Tutorial auftritt. Sie werden mit Strom (sehr niedriger Spannung) und heißen Werkzeugen (Lötkolben & Heißklebepistole) zu arbeiten. Wenn Sie Ihren Regler zerstören Sie müssen nur 10 € auf ein neues verbringen ***

                                    4 Schritt:Schritt 1: Bereiten Sie die Kabel μUSB Schritt 2: Entfernen Sie das vorhandene Kabel Schritt 3: Schließen Sie das neue Kabel Schritt 4: Wiedereinbau des Controllers

                                    Ich ein paar Jahren eine nicht-funktionale Xbox 360-Controller erfasst und nach der schnellen Identifizierung des Kabels als das fehlerhafte Teil, begann, es Streifen auseinander, um die Pause zu finden. Der größte Verschleiß ist wahrscheinlich, am Ausgang des Reglers auf, so musste ich schnitt den Gummi gromit, um das Kabel zu lösen. Stellt sich heraus, die Pause war am Ende des USB-Stecker, so landete ich Entlöten es von der Leiterplatte und macht doppelt so viele Schnitte wie nötig. 2 Jahre später, es funktioniert immer noch in Ordnung, aber die Wieder geklebt gromit wird wieder auseinander kommt, und die Kabelisolierung ist durchgescheuert, so ist es Zeit für eine weitere Reparatur. Als ich es auf einem Computer statt einer Xbox, ist die riesige Kabel ein Durcheinander zu entwirren. Ich dachte, es wäre eine gute Idee, um ein abnehmbares Kabel, die viel kürzer ist zu verwenden; da mein Handy und Tablet verwenden beide Micro USB, was eine bessere Anpassung an als die verwenden !? Alle, die für dieses Projekt benötigt wurde, war: - Eine günstige Micro-USB-Extender - Kleinen Kreuzschlitzschraubendreher - Abisolierzangen - Lötkolben + Solder - Klebepistole (Optional)

                                      2 Schritt:Schritt 1: Schneiden Sie die Paddle Pop Schritt 2:

                                      Dafür benötigen Sie: 2x AA Batterie ist 1x Paddle Pop-Stock- Stück Folie Tape (any tun wird) Schere

                                        3 Schritt:Schritt 1: Holen Sie sich einige Sugru. Schritt 2: Folgen Sie den Anweisungen zum Gebrauch Sugru. Schritt 3: Mould

                                        Ich habe Sugru um besseren Halt zu meiner Xbox360 Controller hinzuzufügen. Normalerweise werden diese würden Sie nach oben, um eine Packung 20,00 € kosten, und ihren Griff ist immer noch nicht so toll. Einige Leute gehen sogar so weit, mit denen, die aus dem PlayStation-Controller ersetzen Sie die Analog-Sticks. Mit Sugru hat meinen Griff nie besser. Auf jeden Fall mehr als die anderen Alternativen Griff empfohlen.

                                          2 Schritt:Schritt 1: Öffnen Sie den Controller Schritt 2: Die Spots zu bedienen

                                          Es gibt eine Menge von Tutorials, wie man ein modded Controller machen, aber, um Platz für die Chips und Knöpfe machen Sie gezwungen sind, einen Motor, oder zwei zu entfernen. In diesem instructable Ich zeige Ihnen ein paar andere Orte, wo man Ihre mods setzen, so dass Sie Ihre Motoren halten können genau dort, wo sie sind

                                          Seiten: « Zurück 1 2 3 Nächster »