Ich habe diese POV-Geräte (Persistence of Vision) auf anderen Instructables gesehen und dachte, ich würde gerne eines herstellen, und ich wollte immer mein eigenes "APPLAUSE" -Zeichen. Die nächste Verbesserung wird darin bestehen, es fortzusetzen, wenn ich den Raum betrete.:) Vielleicht soll es heißen: "Und hier ist Charlie!" Aber das ist eine andere Zeit.

Also habe ich einen Fan bei einem Flohmarkt bekommen, etwas gelesen, Code gefunden und unten ist ein Video von meiner Maschine in Aktion.

Ich begann mit nettem Code aus einem Instructable von Scott Mitchell - "Arduino Bike POV", aber am Ende war sein Code stark pariert. Ich konnte es zunächst nicht zum Laufen bringen und ändere den Code ständig. Es stellte sich heraus, dass mein Problem nichts mit dem Code zu tun hatte. Also gehe ich zurück zu seinem Code und versuche es noch einmal, da er viel allgemeiner ist und leichter mit verschiedenen Phrasen arbeiten würde. Aber das gilt auch für später.

Das Video unten zeigt den POV in Aktion. Es scheint im wirklichen Leben nicht so kaputt oder unzusammenhängend zu sein wie im Video.

Zubehör:

Schritt 1: Holen Sie sich Sachen

In diesem Projekt verwendete Elemente:

kleiner Ventilator - Flohmarkt - 2.00

Sonstiges Holz - mein Keller - 0,00

eine Länge von Kunststoff 15 x 2,5 Zoll - mein Keller - 0,00

ein Arduino - ich benutze einen Ardweeny von SolarBotics - gegen 10.00

7 rote LEDs - hatten bereits - 1,00

7 - 330 Ohm Widerstände - 3,00

Hallensensor - Ich habe von Adafruit - US5881LUA - 2.00

1 10k Widerstand für den Halls Sensor - 1.00

2 Magnete aus dem örtlichen Hobbyfachhandel - 1.00

Außerdem werden benötigt: Kabel, 9 V Batterie, Schrauben, Loctite 5 min Epoxy, kleine Platine von Radio Shack

Schritt 2: Beginnen Sie mit der Montage

1. Schneiden Sie ein kleines Stück Sperrholz (3 x 5 Zoll) und kleben Sie es auf die Lüfternabe. Derzeit ist das Epoxidharz das einzige, das die LED-Baugruppe am Lüfter hält. Vielleicht wären einige Kabelbinder zur Sicherheit gut. Ich denke, ich werde sie später hinzufügen.

2. Ich schneide ein 15 mal 2,5 Zoll großes Stück Plastik aus einem Vorrat, den ich hatte. Plastikfolien sind im Home Depot erhältlich. Ich habe nur die Größe erraten und es stellte sich als ziemlich gut heraus.

3. Bohren Sie 7 Löcher in einem Abstand von ca. 3 mm für die LEDs. Ich habe eine Bohrgröße gefunden, mit der die LEDs recht fest in die Löcher gedrückt werden können. Wenn sie nicht gut gepasst hätten, hätte ich einen Tupfer Heißkleber verwendet, um sie an Ort und Stelle zu halten.

4. Setzen Sie die 7 LEDs in die Löcher ein.

5. Befestigen Sie den Kunststoff mit kleinen Holzschrauben am 3 x 5-Sperrholz.

Schritt 3: Beenden Sie den Lüfterhalter

Dies hängt vom verwendeten Lüfter ab. Ich habe eine Kerbe aus einem Stück von 1 mal 6 herausgeschnitten und konnte die Rückseite des Lüfters in die Kerbe einführen und dann den Lüfter mit einem Kabelbinder an der Platine befestigen. Ich musste die gesamte Einheit anheben, sodass ich den Lüfter mit ein paar Schritten von 1 x 3 s an die Stelle brachte, an der er die Grundplatine nicht berühren würde. Ich habe der Rückseite ein Stück Sperrholz hinzugefügt, damit der Effekt besser sichtbar wird. Ich habe dann alles schwarz gestrichen.

Schritt 4: Ardweeny & LEDs

Der Ardweeny von Solarbotics wird als Bausatz geliefert. Das Zusammenlöten der Teile dauert ca. 30 Minuten. Es ist für die Verwendung auf einem Steckbrett vorgesehen. Nachdem ich den Schaltkreis mit Brot bestückt habe, löte ich es auf ein kleines Stück Leiterplatte, das ich wiederum auf dem Sperrholz befestigen kann. Der Ardweeny dreht sich zusammen mit den LEDs.

Nachdem der Ardweeny aufgebaut ist, ist es Zeit, die LEDs zu verdrahten. Ich habe einen blanken Kupferdraht als gemeinsamen Erdungsdraht verwendet. Jeder der kurzen Drähte von den LEDs wird mit dem Kupferdraht verlötet, und dann wird der Kupferdraht mit einer Masse am Ardweeny verbunden. Schließen Sie vom längeren positiven Zweig der LED einen Draht an den Ardweeny an und schließen Sie einen 330-Ohm-Widerstand in die Schaltung ein.

Ich habe die LEDs mit den Pins 1,2,3,4,5,6,7 verbunden, wobei die äußerste LED mit Pin 1 verbunden ist.

Nachdem alle Verbindungen hergestellt wurden, befestigen Sie den Ardweeny am Sperrholz. Ich habe eine kleine Schraube durch die Platine geschraubt.

Schritt 5: Hallensensor & Batterie

Hallsensor:

Befestigen Sie den Hallsensor am Ende des Kunststoffs. Ich habe den Sensor zuerst auf ein kleines Stück Platine gelötet und dann die Platine mit einer kleinen Schraube am Kunststoff befestigt.

Für den Anschluss des Sensors habe ich die folgenden Informationen verwendet, die ich bei Adafruit erhalten habe: "Läuft mit 3,5 V bis 24 V. Um die Spannung an Pin 1 (ganz links) anzuschließen, verbinden Sie Pin 2 (Mitte) mit Masse und dann Pin 3 mit einem 10-K-Pull-up-Widerstand. Hören Sie dann auf Pin 3 Befindet sich der Südpol eines Magneten in der Nähe der Vorderseite des Sensors, wird Pin 3 auf 0 V abgesenkt, andernfalls verbleibt er an der Stelle, an der der Pullup-Widerstand angeschlossen ist. Wenn sich der Nordpol eines Magneten in der Nähe befindet (unipolar), geschieht nichts. "

Magnet für den Sensor:

Ich befestigte einen kleinen Magneten am Ende eines Dübels und befestigte den Dübel an der Lüfterhalterung. Ich habe das auf beiden Seiten des Fans gemacht. Es ist wichtig, dass einer der Magnete mit der Südseite nach außen zeigt und der andere Magnet mit der Nordseite nach außen zeigt.

Idee: Bei diesem Sensor handelt es sich um einen Latch-Typ, also entweder um eine 1 oder eine 0. Wenn der Spin beginnt, schaltet der erste Magnet die LEDs ein und wenn er zum anderen Magnet gelangt, schaltet er sie aus. Das stimmt natürlich mit der Software überein.

Der lila Draht geht an den analogen Pin 0, schwarz an Masse und rot an den Pin A + (5-Volt-Ausgang).

Batterie:

Die 9-V-Batterie sollte dort platziert werden, wo sie als Gegengewicht für den sich drehenden Kunststoff dient. Wenn der Kunststoff nicht gut ausbalanciert ist, wird der gesamte Lüfter geschüttelt, wenn die Drehzahl erreicht ist. Ich habe eine Kombination aus Gummiband und Kabelbindern verwendet, um es in Position zu halten, kann es aber trotzdem herausholen, wenn es ausgetauscht werden muss

Verdrahten Sie die positiven und negativen Kabel von der Batterie zu den entsprechenden Stiften. Ich habe einen Schalter eingebaut, mit dem ich den Ardweeny ausschalten kann. Der Schalter ist mit doppeltem Klebeband am Sperrholz befestigt.

Schritt 6: Der Code

Bei der Suche nach POV-Projekten wurde Code für ein POV-Bike-Projekt gefunden.

Unten ist, was ich verwendet habe, aber es ist weit vom Original entfernt. Das Original ist viel umfassender und ausgefeilter, aber ich habe mit seinem Code begonnen und sollte ihn würdigen.

Die Skizze enthält auch eine font.h-Datei, die ich nach dem Durchsuchen des Internets gefunden habe. Ich bin nicht sicher, ob es die Schriftart war. H, die ein Teil des Originals war. Ich habe meine unten aufgenommen..

// Code für das Arduino Bike POV-Projekt

// Arduino Bike POV

//

// von Scott Mitchell

// www.openobject.org

// Open Source Urbanismus

//

// Copyright (C) 2008 Scott Mitchell 12-10-2008

//

// Dieses Programm ist freie Software: Sie können es weitergeben und / oder modifizieren

// es unter den Bedingungen der GNU General Public License, wie von veröffentlicht

// die Free Software Foundation, entweder Version 3 der Lizenz, oder

// (nach Ihrer Wahl) jede spätere Version.

//

//============================================================

// 6/2011 stark modifiziert von c. Dubois für mein POV-Projekt

// Der Hallsensor ist ein Schalter, deshalb habe ich dafür einen anderen Code verwendet

// habe auch eine font.h benutzt, die ich gefunden habe

// ------------------------------------------------------------

// Definiere das Alphabet

#include "font.h"

// Definiere die verwendeten Arduino LED Pins

const int LEDpins = {

1,2,3,4,5,6,7};

// Anzahl der LEDs

const int charHeight = sizeof (LEDpins);

const int charWidth = 5;

// Sensoreinrichtung

const int sensorPIN = 0; // Definiere den Arduino Sensor Pin

// Boolescher SensorFlag = false; // Speichert den Sensorstatus

int sensVal; // Variable zum Speichern des vom Sensor kommenden Wertes

const char textString = "APPLAUSE";

void setup ()

{

PinMode (13, OUTPUT);

pinMode (1, OUTPUT);

PinMode (2, OUTPUT);

PinMode (3, OUTPUT);

PinMode (4, OUTPUT);

pinMode (5, OUTPUT);

pinMode (6, OUTPUT);

PinMode (7, OUTPUT);

// Serial.begin (9600);

}

leere Schleife ()

{

// Led für einen Kreis in der Mitte einschalten und beweisen, dass Arduino mit Strom versorgt wird

digitalWrite (13, HIGH); // LED einschalten

sensVal = analogRead (sensorPIN); // Lesen Sie den Hall-Effekt-Sensor

// Serial.println (sensVal);

// delay (500);

Ich hatte hier Schwierigkeiten

// Da es sich um einen Schalter handelt, sollte der Hall-Schalter wahrscheinlich nur digital gelesen werden

if (sensVal! = 1023) {

// drucke jeden Buchstaben des textStrings

für (int k = 0; k

printLetter (textString k);

}

}

}

void printLetter (char ch)

{

// Stellen Sie sicher, dass sich das Zeichen innerhalb der Alphabetgrenzen befindet (definiert durch die Datei font.h)

// Wenn dies nicht der Fall ist, machen Sie es zu einem leeren Zeichen

if (ch <32 || ch> 126) {

ch = 32;

}

// das Leerzeichen subtrahieren (konvertiert die ASCII-Nummer in die Indexnummer der Schriftart)

ch - = 32;

// schrittweise durch jedes Byte des Zeichenarrays

für (int i = 0; i

Byte b = Schriftart ch i;

// Bitverschiebung durch das Byte und Ausgabe an den Pin

für (int j = 0; j

digitalWrite (LEDpins j, !! (b & (1 << j)));

}

// Abstand zwischen den Spalten

delayMicroseconds (900);

}

// lösche die LEDs

digitalWrite (1, LOW); // LED einschalten

digitalWrite (2, LOW); // LED einschalten

digitalWrite (3, LOW); // LED einschalten

digitalWrite (4, LOW); // LED einschalten

digitalWrite (5, LOW); // LED einschalten

digitalWrite (6, LOW); // LED einschalten

digitalWrite (7, LOW); // LED einschalten

// Leerzeichen zwischen Buchstaben

delayMicroseconds (2500);

}

--------------------------------------

----------------------------------------

///============================================================

// Arduino Bike POV

// font.h

//

// von Scott Mitchell

// www.openobject.org

// Open Source Urbanismus

//

// Copyright (C) 2008 Scott Mitchell 12-10-2008

//

// Dieses Programm ist freie Software: Sie können es weitergeben und / oder modifizieren

// es unter den Bedingungen der GNU General Public License, wie von veröffentlicht

// die Free Software Foundation, entweder Version 3 der Lizenz, oder

// (nach Ihrer Wahl) jede spätere Version.

//

// Dieses Programm wird in der Hoffnung verbreitet, dass es nützlich sein wird, // aber OHNE GARANTIE; ohne auch nur die implizite garantie von

// MARKTGÄNGIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK. Siehe die

// GNU General Public License für weitere Details.

//

// Eine Kopie der GNU General Public License

// finden Sie unter .

//

// B4.1

// Letzte Änderung: 13. Oktober 2008

//============================================================

// Definiere das Alphabet

// ASCII 7x5 Side-Feed-Zeichen für LED-Module

// Von http://www.sxlist.com/TECHREF/datafile/charset/8x6.htm hinzugefügt

// const byte font 5 = {

const unsigned char font 95 5 = {

{0x00,0x00,0x00,0x00,0x00}, // 0x20 32

{0x00,0x00,0x6f, 0x00,0x00}, //! 0x21 33

{0x00,0x07,0x00,0x07,0x00}, // "0x22 34

{0x14,0x7f, 0x14,0x7f, 0x14}, // # 0x23 35

{0x00,0x07,0x04,0x1e, 0x00}, // $ 0x24 36

{0x23,0x13,0x08,0x64,0x62}, //% 0x25 37

{0x36,0x49,0x56,0x20,0x50}, // & 0x26 38

{0x00,0x00,0x07,0x00,0x00}, // '0x27 39

{0x00,0x1c, 0x22,0x41,0x00}, // (0x28 40

{0x00,0x41,0x22,0x1c, 0x00}, //) 0x29 41

{0x14,0x08,0x3e, 0x08,0x14}, // * 0x2a 42

{0x08,0x08,0x3e, 0x08,0x08}, // + 0x2b 43

{0x00,0x50,0x30,0x00,0x00}, //, 0x2c 44

{0x08,0x08,0x08,0x08,0x08}, // - 0x2d 45

{0x00,0x60,0x60,0x00,0x00}, //. 0x2e 46

{0x20,0x10,0x08,0x04,0x02}, // / 0x2f 47

{0x3e, 0x51,0x49,0x45,0x3e}, // 0 0x30 48

{0x00,0x42,0x7f, 0x40,0x00}, // 1 0x31 49

{0x42,0x61,0x51,0x49,0x46}, // 2 0x32 50

{0x21,0x41,0x45,0x4b, 0x31}, // 3 0x33 51

{0x18,0x14,0x12,0x7f, 0x10}, // 4 0x34 52

{0x27,0x45,0x45,0x45,0x39}, // 5 0x35 53

{0x3c, 0x4a, 0x49,0x49,0x30}, // 6 0x36 54

{0x01,0x71,0x09,0x05,0x03}, // 7 0x37 55

{0x36,0x49,0x49,0x49,0x36}, // 8 0x38 56

{0x06,0x49,0x49,0x29,0x1e}, // 9 0x39 57

{0x00,0x36,0x36,0x00,0x00}, //: 0x3a 58

{0x00,0x56,0x36,0x00,0x00}, //; 0x3b 59

{0x08,0x14,0x22,0x41,0x00}, // <0x3c 60

{0x14,0x14,0x14,0x14,0x14}, // = 0x3d 61

{0x00,0x41,0x22,0x14,0x08}, //> 0x3e 62

{0x02,0x01,0x51,0x09,0x06}, //? 0x3f 63

{0x3e, 0x41,0x5d, 0x49,0x4e}, // @ 0x40 64

{0x7e, 0x09,0x09,0x09,0x7e}, // A 0x41 65

{0x7f, 0x49,0x49,0x49,0x36}, // B 0x42 66

{0x3e, 0x41,0x41,0x41,0x22}, // C 0x43 67

{0x7f, 0x41,0x41,0x41,0x3e}, // D 0x44 68

{0x7f, 0x49,0x49,0x49,0x41}, // E 0x45 69

{0x7f, 0x09,0x09,0x09,0x01}, // F 0x46 70

{0x3e, 0x41,0x49,0x49,0x7a}, // G 0x47 71

{0x7f, 0x08,0x08,0x08,0x7f}, // H 0x48 72

{0x00,0x41,0x7f, 0x41,0x00}, // I 0x49 73

{0x20,0x40,0x41,0x3f, 0x01}, // J 0x4a 74

{0x7f, 0x08,0x14,0x22,0x41}, // K 0x4b 75

{0x7f, 0x40,0x40,0x40,0x40}, // L 0x4c 76

{0x7f, 0x02,0x0c, 0x02,0x7f}, // M 0x4d 77

{0x7f, 0x04,0x08,0x10,0x7f}, // N 0x4e 78

{0x3e, 0x41,0x41,0x41,0x3e}, // O 0x4f 79

{0x7f, 0x09,0x09,0x09,0x06}, // P 0x50 80

{0x3e, 0x41,0x51,0x21,0x5e}, // Q 0x51 81

{0x7f, 0x09,0x19,0x29,0x46}, // R 0x52 82

{0x46,0x49,0x49,0x49,0x31}, // S 0x53 83

{0x01,0x01,0x7f, 0x01,0x01}, // T 0x54 84

{0x3f, 0x40,0x40,0x40,0x3f}, // U 0x55 85

{0x0f, 0x30,0x40,0x30,0x0f}, // V 0x56 86

{0x3f, 0x40,0x30,0x40,0x3f}, // W 0x57 87

{0x63,0x14,0x08,0x14,0x63}, // X 0x58 88

{0x07,0x08,0x70,0x08,0x07}, // Y 0x59 89

{0x61,0x51,0x49,0x45,0x43}, // Z 0x5a 90

{0x3c, 0x4a, 0x49,0x29,0x1e}, // 0x5b 91

{0x02,0x04,0x08,0x10,0x20}, // 0x5c 92

{0x00,0x41,0x7f, 0x00,0x00}, // 0x5d 93

{0x04,0x02,0x01,0x02,0x04}, // ^ 0x5e 94

{0x40,0x40,0x40,0x40,0x40}, // _ 0x5f 95

{0x00,0x00,0x03,0x04,0x00}, // `0x60 96

{0x20,0x54,0x54,0x54,0x78}, // a 0x61 97

{0x7f, 0x48,0x44,0x44,0x38}, // b 0x62 98

{0x38,0x44,0x44,0x44,0x20}, // c 0x63 99

{0x38,0x44,0x44,0x48,0x7f}, // d 0x64 100

{0x38,0x54,0x54,0x54,0x18}, // e 0x65 101

{0x08,0x7e, 0x09,0x01,0x02}, // f 0x66 102

{0x0c, 0x52,0x52,0x52,0x3e}, // g 0x67 103

{0x7f, 0x08,0x04,0x04,0x78}, // h 0x68 104

{0x00,0x44,0x7d, 0x40,0x00}, // i 0x69 105

{0x20,0x40,0x44,0x3d, 0x00}, // j 0x6a 106

{0x00,0x7f, 0x10,0x28,0x44}, // k 0x6b 107

{0x00,0x41,0x7f, 0x40,0x00}, // l 0x6c 108

{0x7c, 0x04,0x18,0x04,0x78}, // m 0x6d 109

{0x7c, 0x08,0x04,0x04,0x78}, // n 0x6e 110

{0x38,0x44,0x44,0x44,0x38}, // o 0x6f 111

{0x7c, 0x14,0x14,0x14,0x08}, // p 0x70 112

{0x08,0x14,0x14,0x18,0x7c}, // q 0x71 113

{0x7c, 0x08,0x04,0x04,0x08}, // r 0x72 114

{0x48,0x54,0x54,0x54,0x20}, // s 0x73 115

{0x04,0x3f, 0x44,0x40,0x20}, // t 0x74 116

{0x3c, 0x40,0x40,0x20,0x7c}, // u 0x75 117

{0x1c, 0x20,0x40,0x20,0x1c}, // v 0x76 118

{0x3c, 0x40,0x30,0x40,0x3c}, // w 0x77 119

{0x44,0x28,0x10,0x28,0x44}, // x 0x78 120

{0x0c, 0x50,0x50,0x50,0x3c}, // y 0x79 121

{0x44,0x64,0x54,0x4c, 0x44}, // z 0x7a 122

{0x00,0x08,0x36,0x41,0x41}, // {0x7b 123

{0x00,0x00,0x7f, 0x00,0x00}, // | 0x7c 124

{0x41,0x41,0x36,0x08,0x00}, //} 0x7d 125

{0x04,0x02,0x04,0x08,0x04}, // ~ 0x7e 126

};

/*

Creative Commons Namensnennung-Keine kommerzielle Nutzung-Weitergabe unter gleichen Bedingungen 2.5 Australia-Lizenz

Diese Seite wurde zuletzt am 11. Januar 2009 um 14:41 Uhr geändert. Diese Seite wurde bisher 1.477-mal abgerufen.

Inhalt ist verfügbar unter der Attribution-Noncommercial-Share Alike 2.5 Australia-Lizenz.

Über Open Source Urbanismus

Haftungsausschluss

Bereitgestellt von MediaWiki

*/

Finalist in der

LED-Wettbewerb