Vi estos dispositivos POV (Persistencia de la visión) en otros Instructables y pensé que me gustaría hacer uno y siempre he querido mi propia señal de "APLAUSOS". La siguiente mejora será hacer que se encienda cada vez que entro en la sala.:) Tal vez haga que diga: "¡Y aquí está Charlie!" Pero eso es para otro momento.

Así que conseguí un fanático en una venta de garaje, hice algunas lecturas, encontré algo de código y debajo hay un video de mi máquina en acción.

Comencé con un buen código de un Instructable de Scott Mitchell - "Arduino Bike POV", pero lo que terminé con su código fue muy reducido. Al principio no pude hacer que funcionara y por eso sigo cambiando el código. Resultó que mi problema no tenía nada que ver con el código. Así que volveré a su código e intentaré nuevamente ya que el suyo es mucho más genérico y funcionaría más fácilmente con diferentes frases. Pero eso es para más tarde también.

El siguiente video muestra el punto de vista en acción. No parece tan roto o desconectado en la vida real como lo hace en el video.

Suministros:

Paso 1: Obtener cosas

Artículos utilizados en este proyecto:

Ventilador pequeño - Venta de garaje - 2.00.

varios madera - mi sótano - 0.00

una longitud de plástico de 15 por 2,5 pulgadas - mi sótano - 0.00

un Arduino - uso un Ardweeny de SolarBotics - alrededor de las 10.00

7 LEDs rojos - ya tenían - 1.00

7 - resistencias de 330 ohmios - 3.00

Sensor Halls - Conseguí de Adafruit - US5881LUA - 2.00

1 resistencia de 10k para usar con el sensor Halls - 1.00

2 imanes de tienda local de hobby - 1.00

También necesitará: cable, batería de 9 V, tornillos, Loctite 5 min epoxi, PCB pequeño de Radio Shack

Paso 2: Comience la Asamblea

1. Corte un pedazo pequeño de 3 por 5 piezas de madera contrachapada de 1/4 de pulgada y epóxico al cubo del ventilador. En este momento, el epoxi es lo único que sujeta el ensamblaje de LED al ventilador. Quizás algunas bridas de alambre para la seguridad serían buenas. Creo que los añadiré más tarde.

2. Corté una pieza de plástico de 15 por 2,5 pulgadas de algunas acciones que tenía. Se pueden tener láminas de plástico en Home Depot. Acabo de adivinar el tamaño y resultó ser bastante bueno.

3. Perfore 7 orificios en un extremo a una distancia de aproximadamente 3/4 de pulgada para los LED. Encontré un tamaño de broca que permite que los LED se presionen en los agujeros con mucha fuerza. Si no hubieran encajado bien, habría usado un poco de pegamento caliente para mantenerlo en su lugar.

4. Inserte los 7 LEDs en los agujeros.

5. Fije el plástico a la madera contrachapada de 3 por 5 con pequeños tornillos para madera.

Paso 3: Termina el soporte del ventilador

Esto dependerá del ventilador que uses. Corté una muesca de una pieza de 1 por 6 y pude insertar la parte posterior del ventilador en la muesca y luego usé una atadura de cables para asegurar el ventilador a la placa. Necesitaba levantar toda la unidad, así que utilicé un par de 1 por 3 s para llevar el ventilador hasta donde no golpeara el tablero base. Agregué un pedazo de madera contrachapada en la parte posterior para poder ver mejor el efecto. Luego pinté todo de negro.

Paso 4: Ardweeny y LEDS

El Ardweeny de Solarbotics viene en un kit y requiere unos 30 minutos para soldar las piezas. Está diseñado para ser utilizado en una placa de pruebas y, después de haber empuñado el circuito, lo sueldo a una pequeña pieza de placa de PCB que, a su vez, puedo unir al contrachapado. El Ardweeny girará junto con los LEDs.

Una vez que se haya construido el Ardweeny, es hora de conectar los LED. Usé un cable de cobre desnudo como un cable de tierra común. Cada uno de los cables cortos de los LED se suelda al cable de cobre y luego el cable de cobre se conecta a una toma de tierra en el Ardweeny. Desde la pata positiva más larga del LED, conecte un cable al Ardweeny e incluya una resistencia de 330 ohmios en el circuito.

Conecté los LED a los pines 1,2,3,4,5,6,7 con el LED más exterior conectado al pin 1.

Una vez que se hayan realizado todas las conexiones, coloque el Ardweeny en el contrachapado. Usé un tornillo pequeño a través de la PCB.

Paso 5: Sensor de Pasillo y Batería

Sensor de pasillo:

Acople el sensor Halls al extremo del plástico. Primero soldé el sensor a una pequeña pieza de PCB y luego conecté la PCB al plástico con un tornillo pequeño.

Para conectar el sensor utilicé la siguiente información que obtuve en Adafruit: "Funciona a 3.5V hasta 24V. Para usar la alimentación, conecte el pin 1 (completamente a la izquierda), conecte a tierra el pin 2 (centro) y luego una resistencia de 10K desde el pin 3 al poder. Luego escuche el pin 3, cuando el polo sur de un imán está cerca de la parte frontal del sensor, el pin 3 bajará a 0 V. De lo contrario, permanecerá en cualquier cosa a la que esté conectada la resistencia pullup. No ocurre nada si el polo norte de un imán está cerca (unipolar). "

Imán para el sensor:

Coloqué un pequeño imán en el extremo de una clavija y conecté la clavija al soporte del ventilador. Hice esto en ambos lados del abanico. Es importante que uno de los imanes tenga su lado sur mirando hacia afuera y el otro imán tenga su lado norte hacia afuera.

idea: este sensor es de tipo pestillo, por lo que es 1 o 0. Cuando comienza el giro, el primer imán encenderá los LEDS y cuando llegue al otro imán, los apagará. Por supuesto esto está en concierto con el software.

El cable púrpura va al pin analógico 0, negro a tierra y rojo al pin A + (salida de 5 voltios).

Batería:

La batería de 9V debe colocarse donde actúe como un contrapeso para el plástico en rotación. Si el plástico no está bien equilibrado, agitará todo el ventilador cuando alcance la velocidad. Utilicé una combinación de goma y abrazaderas de alambre para mantenerla en su lugar, pero aún así puedo sacarla si necesita reemplazo.

Conecte los cables positivo y negativo de la batería a los pines apropiados. Incluí un interruptor para poder apagar el Ardweeny. El interruptor está unido a la madera contrachapada con cinta de doble respaldo.

Paso 6: El Código

Una búsqueda de proyectos POV encontró el código para un proyecto POV Bike.

A continuación es lo que usé, pero está muy lejos del original. El original es mucho más completo y pulido, pero comencé con su código y debería darle crédito.

También el boceto incluye un archivo font.h que encontré después de buscar en Internet. No estoy seguro de que fuera la fuente que formara parte del original. He incluido el mío a continuación.

// Código para el proyecto Arduino Bike POV.

// Arduino Bike POV

//

// por Scott Mitchell

// www.openobject.org

// Urbanismo de código abierto

//

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

//

// Este programa es software libre: puedes redistribuirlo y / o modificarlo

// bajo los términos de la Licencia Pública General de GNU tal como fue publicada por

// Free Software Foundation, ya sea la versión 3 de la Licencia, o

// (a su elección) cualquier versión posterior.

//

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

// 6/2011 fuertemente modificado por c. Dubois para mi proyecto POV

// El sensor Hall es un interruptor, así que usé un código diferente para él

// También usé un font.h que encontré

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

// definiendo el alfabeto

#include "font.h"

// define los pines LED Arduino en uso

const int LEDpins = {

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

// número de LEDs

const int charHeight = sizeof (LEDpins);

const int charWidth = 5;

// configuración del sensor

const int sensorPIN = 0; // define el pin del sensor Arduino

// boolean sensorFlag = false; // almacena el estado del sensor

int sensVal; // variable para almacenar el valor proveniente del sensor

const char textString = "APPLAUSE";

configuración del vacío ()

{

pinMode (13, SALIDA);

pinMode (1, SALIDA);

pinMode (2, SALIDA);

modo de pin (3, SALIDA);

pinMode (4, SALIDA);

pinMode (5, SALIDA);

modo de pin (6, SALIDA);

pinMode (7, SALIDA);

// Serial.begin (9600);

}

bucle de vacío ()

{

// enciende el LED para un círculo en el medio y prueba de que arduino está encendido

escritura digital (13, ALTA); // enciende el LED

sensVal = analogRead (sensorPIN); // lee el sensor de efecto Hall

// Serial.println (sensVal);

// retraso (500);

// tuvo dificultades aquí

// ya que es un interruptor de la sala del interruptor, probablemente debería hacer una lectura digital

si (sensVal! = 1023) {

// imprimiendo cada letra de la cadena de texto

para (int k = 0; k

printLetter (textString k);

}

}

}

void printLetter (char ch)

{

// asegúrese de que el carácter esté dentro de los límites del alfabeto (definidos por el archivo font.h)

// si no lo es, hazlo un caracter en blanco

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

ch = 32;

}

// restar el carácter de espacio (convierte el número ASCII al número de índice de fuente)

ch - = 32;

// paso a través de cada byte de la matriz de caracteres

para (int i = 0; i

byte b = fuente ch i;

// cambio de bit a través del byte y salida al pin

para (int j = 0; j

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

}

// espacio entre columnas

delayMicroseconds (900);

}

// borrar los LEDs

escritura digital (1, BAJA); // enciende el LED

escritura digital (2, BAJA); // enciende el LED

escritura digital (3, BAJA); // enciende el LED

escritura digital (4, BAJA); // enciende el LED

escritura digital (5, BAJA); // enciende el LED

escritura digital (6, BAJA); // enciende el LED

escritura digital (7, BAJA); // enciende el LED

// espacio entre letras

delayMicroseconds (2500);

}

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

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

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

// Arduino Bike POV

// fuente.h

//

// por Scott Mitchell

// www.openobject.org

// Urbanismo de código abierto

//

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

//

// Este programa es software libre: puedes redistribuirlo y / o modificarlo

// bajo los términos de la Licencia Pública General de GNU tal como fue publicada por

// Free Software Foundation, ya sea la versión 3 de la Licencia, o

// (a su elección) cualquier versión posterior.

//

// Este programa se distribuye con la esperanza de que sea útil, // pero SIN NINGUNA GARANTÍA; sin ni siquiera la garantía implícita de

// COMERCIABILIDAD o APTITUD PARA UN PROPÓSITO PARTICULAR. Ver el

// GNU General Public License para más detalles.

//

// Una copia de la Licencia Pública General de GNU

// se puede encontrar en .

//

// B4.1

// Última modificación: 13 de octubre de 2008

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

// definiendo el alfabeto

// caracteres de alimentación lateral ascii 7x5 para módulos led

// addapted from

// fuente byte const 5 = {

Fuente de caracteres sin signo de const 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 Attribution-Noncommercial-Share Alike 2.5 Australia License

Esta página fue modificada por última vez el 14:41 del 11 de enero de 2009. Esta página ha sido visitada 1.477 veces.

El contenido está disponible bajo Creative Commons Attribution-Noncommercial-Share Alike 2.5 Australia License.

Sobre el urbanismo de código abierto

Renuncias

Desarrollado por MediaWiki

*/

Finalista en el

Concurso de LED