Otra de led´s.

[Azicuetano]

OOHHH QUE MARAVILLA!!! ENHORABUENA!!! Video!! Video!!

jejee...

PD: Ponte un guante o algo en la mano antes de empezar a darle vueltas o te dejarás el dedo hecho un churro

Video!! Video!! 


Un saludo desde Alicante

[togarha]

Wenas,

Tremendo, ya sirve hasta para ligar el asunto xD , si al final a las mujeres tb les gustarán los pics


Para J1M, ya sabes como transmiten los de thermaltake la alimentación a la parte movil???

Un saludo,

[Veguepic]

Soy un desastre como camarografo!! 

http://www.mytempdir.com/2029088

Es el mejor de los videos que he podido hacer, un poco porque los leds no son de buen brillo y use la camara de fotos para grabar el video.

Espero mañana recibir ayuda para hacer un video decente.

Saludos

[J1M]

togarha, sí, juraría que puse las fotos!!... fallo mío.

La parte superior del ventilador (el plástico transparente) hace de estator, y la plaquita electrónica de rotor, puesto que dispone de un bobinado. Con lo anterior se obtiene una dinamo que proporciona la energía a la placa electrónica a partir del movimiento propio del ventilador.

un saludo!

[civerpic]

muchachos me gosto su proyecto me gustaria hacerme uno me podrian explicar el funcionamiento basico de este panel que conponentes utilizaron para que capte lkas vueltas o como funcione por faaaaaaaaaaaaaaaa...

[Azicuetano]

Hola civerpic!

He puesto en el google las palabras 'leds giratorios' y me ha aparecido esto:

http://www.hardcore-modding.com/modules.php?name=Forums&file=viewtopic&t=24825&highlight=propeller

Ahí explican la dinámica de como funciona.

Si te queda alguna duda exponla y te lo explico lo mejor que pueda.


Un saludo desde Alicante.

[togarha]

A mi lo que no me queda claro todavía es la parte de transmitir la alimentación a la parte móvil.

J1M, puedes poner alguna foto del thermaltake? Es que no entiendo exactamente como lo hace...

Salu2

PS: Estoy deseando ponerme con un monstruo de estos, pero la parte mecánica no me deja, soy totalmente inútil en ello...

[RedPic]

PS: Estoy deseando ponerme con un monstruo de estos, pero la parte mecánica no me deja, soy totalmente inútil en ello...

Bienvenido al Club de los Inútiles (como yo) Ja, ja, ja 

[Marttyn]

que facilidad teneis para crearme necesidades... como si no tuviera nada que hacer, ahora quiero uno de estos!
pues nada, tendre que hacerlo para que no me señalen en el foro con un mensaje de que no tengo uno de estos... 
pronto os contare que tal quedo...
y por favor dejen de publicar proyectos sin sentido... que yo me engancho a todo 
salu2

[Marttyn]

Hola Azicuetano, me he permitido una pequeña licencia para "compactar" el código y reducir el número de líneas:

Código: C

1. //************************************************************
2. //
3. //                 LED´S GIRATORIOS MAREADOS ;)
4. //                  Azicuetano (foro Todopic)
5. //
6. //************************************************************
7.  
8. #include <18F2550.h>
9.  
10. #fuses XTPLL,PROTECT,NOLVP,PLL1,CPUDIV3,PUT,NOBROWNOUT,NOMCLR
11. #use delay(clock=12000000)
12.  
13. #define delay_led 5
14. #define enciende(leds_a_encender) {output_b(leds_a_encender); delay_ms(delay_led);}
15.  
16. #define TODOPIC
17.  
18. //#use fast_io(C)
19. //#use fast_io(B)
20.  
21. //void enciende(int);
22. void letra_I(void);
23. void letra_V(void);
24. void letra_A(void);
25. void letra_N(void);
26.  
27. /*
28. void enciende(int leds_a_encender)
29. {
30.    output_b(leds_a_encender);
31. }
32. */
33.  
34. void letra_I(void)
35. {
36.    enciende(0b00000000);
37.    enciende(0b00000000);
38.    enciende(0b10000001);
39.    enciende(0b10000001);
40.    enciende(0b11111111);
41.    enciende(0b10000001);
42.    enciende(0b10000001);
43.    enciende(0b00000000);
44. }
45.  
46. void letra_V(void)
47. {
48.    enciende(0b00000000);
49.    enciende(0b0000001);
50.    enciende(0b0001111);
51.    enciende(0b1110001);
52.    enciende(0b1000000);
53.    enciende(0b0111001);
54.    enciende(0b0000111);
55.    enciende(0b0000001);
56. }
57.  
58. void letra_A(void)
59. {
60.    enciende(0b00000000);
61.    enciende(0b10000000);
62.    enciende(0b11000000);
63.    enciende(0b10111101);
64.    enciende(0b00100011);
65.    enciende(0b10111100);
66.    enciende(0b11000000);
67.    enciende(0b10000000);
68. }
69.  
70. void letra_N(void)
71. {
72.    enciende(0b00000000);
73.    enciende(0b10000001);
74.    enciende(0b11111111);
75.    enciende(0b10000111);
76.    enciende(0b00011000);
77.    enciende(0b11100001);
78.    enciende(0b11111111);
79.    enciende(0b00000001);
80. }
81.  
82. void letra_T(void)
83. {
84.    enciende(0b00000000);
85.    enciende(0b11000000);
86.    enciende(0b10000000);
87.    enciende(0b10000001);
88.    enciende(0b11111111);
89.    enciende(0b10000001);
90.    enciende(0b10000000);
91.    enciende(0b11000000);
92. }
93.  
94. void letra_O(void)
95. {
96.    enciende(0b00000000);
97.    enciende(0b00000000);
98.    enciende(0b01111110);
99.    enciende(0b10000001);
100.    enciende(0b10000001);
101.    enciende(0b10000001);
102.    enciende(0b10000001);
103.    enciende(0b01111110);
104. }
105.  
106. void letra_D(void)
107. {
108.    enciende(0b00000000);
109.    enciende(0b10000001);
110.    enciende(0b11111111);
111.    enciende(0b10000001);
112.    enciende(0b10000001);
113.    enciende(0b10000001);
114.    enciende(0b01111110);
115.    enciende(0b00000000);
116. }
117.  
118. void letra_P(void)
119. {
120.    enciende(0b00000000);
121.    enciende(0b10000001);
122.    enciende(0b11111111);
123.    enciende(0b10010001);
124.    enciende(0b00010001);
125.    enciende(0b00010001);
126.    enciende(0b00001110);
127.    enciende(0b00000000);
128. }
129.  
130. void letra_C(void)
131. {
132.    enciende(0b00000000);
133.    enciende(0b00000000);
134.    enciende(0b01111110);
135.    enciende(0b10000001);
136.    enciende(0b10000001);
137.    enciende(0b10000001);
138.    enciende(0b01000010);
139.    enciende(0b00000000);
140. }
141.  
142. void main(void)
143. {
144.    set_tris_b(0b00000000);
145.    set_tris_c(0b00000000);
146.    set_tris_a(0b00000000);
147.  
148.    port_b_pullups(FALSE);
149.  
150.    output_high(PIN_B0);
151.    output_high(PIN_C7);
152.    delay_ms(500);
153.  
154. //************************************************************
155. //
156. //    EXPLICACION
157. //
158. //    Cada letra ocupa un tiempo de 40ms.
159. //    En 200ms. haciendo girar el llavero a una velocidad
160. //    normal, se repetir&#225; 2 veces la palabra que pongamos.
161. //
162. //
163. //************************************************************
164.  
165.    while(1)
166.    {
167.  
168. #ifdef TODOPIC
169.       letra_T();
170.       letra_D();
171.       letra_P();
172.       letra_I();
173.       letra_C();
174. #else      
175.       letra_I();
176.       letra_V();
177.       letra_A();
178.       letra_N();
179. #endif
180.  
181.       output_low(PIN_B0);
182.       output_low(PIN_B1);
183.       output_low(PIN_B2);
184.       output_low(PIN_B3);
185.       output_low(PIN_B4);
186.       output_low(PIN_B5);
187.       output_low(PIN_B6);
188.       output_low(PIN_B7);
189.       output_low(PIN_C7);
190.  
191.       delay_ms(40);             // retardo necesario para completar los 200ms.
192.                                 // 40ms*4 letras + 40 ms = 200 ms.
193.  
194.    }
195. }

Un saludo

mmm 
no estoy seguro, pero creo que lo que haces realmente es reducir el numero de lineas escritas, pero al compilar el programa ocupara mas... ya que un "define" simplemente reemplaza todos los "enciende(leds_a_encender)" por "output_b(leds_a_encender); delay_ms(delay_led);" al compilarse... en cambio una llamada a una funcion, como puede ser "enciende(leds_a_encender)" solo se grabara una vez en la memoria rom del pic y se accedera a ella cada vez que se requiera.
desde mi punto de vista, la modificacion que se podria hacer es esta:

Código: C

1. //************************************************************
2. //
3. //                 LED&#180;S GIRATORIOS MAREADOS ;)
4. //                  Azicuetano (foro Todopic)
5. //
6. //************************************************************
7.  
8. #include <18F2550.h>
9.  
10. #fuses XTPLL,PROTECT,NOLVP,PLL1,CPUDIV3,PUT,NOBROWNOUT,NOMCLR
11. #use delay(clock=12000000)
12.  
13. #define delay_led 5
14.  
15. #define TODOPIC
16.  
17. //#use fast_io(C)
18. //#use fast_io(B)
19.  
20. void enciende(int);
21. void letra_I(void);
22. void letra_V(void);
23. void letra_A(void);
24. void letra_N(void);
25.  
26. void enciende(int leds_a_encender)
27. {
28.    output_b(leds_a_encender);
29.    delay_ms(delay_led);
30. }
31.  
32. void letra_I(void)
33. {
34.    enciende(0b00000000);
35.    enciende(0b00000000);
36.    enciende(0b10000001);
37.    enciende(0b10000001);
38.    enciende(0b11111111);
39.    enciende(0b10000001);
40.    enciende(0b10000001);
41.    enciende(0b00000000);
42. }
43.  
44. void letra_V(void)
45. {
46.    enciende(0b00000000);
47.    enciende(0b0000001);
48.    enciende(0b0001111);
49.    enciende(0b1110001);
50.    enciende(0b1000000);
51.    enciende(0b0111001);
52.    enciende(0b0000111);
53.    enciende(0b0000001);
54. }
55.  
56. void letra_A(void)
57. {
58.    enciende(0b00000000);
59.    enciende(0b10000000);
60.    enciende(0b11000000);
61.    enciende(0b10111101);
62.    enciende(0b00100011);
63.    enciende(0b10111100);
64.    enciende(0b11000000);
65.    enciende(0b10000000);
66. }
67.  
68. void letra_N(void)
69. {
70.    enciende(0b00000000);
71.    enciende(0b10000001);
72.    enciende(0b11111111);
73.    enciende(0b10000111);
74.    enciende(0b00011000);
75.    enciende(0b11100001);
76.    enciende(0b11111111);
77.    enciende(0b00000001);
78. }
79.  
80. void letra_T(void)
81. {
82.    enciende(0b00000000);
83.    enciende(0b11000000);
84.    enciende(0b10000000);
85.    enciende(0b10000001);
86.    enciende(0b11111111);
87.    enciende(0b10000001);
88.    enciende(0b10000000);
89.    enciende(0b11000000);
90. }
91.  
92. void letra_O(void)
93. {
94.    enciende(0b00000000);
95.    enciende(0b00000000);
96.    enciende(0b01111110);
97.    enciende(0b10000001);
98.    enciende(0b10000001);
99.    enciende(0b10000001);
100.    enciende(0b10000001);
101.    enciende(0b01111110);
102. }
103.  
104. void letra_D(void)
105. {
106.    enciende(0b00000000);
107.    enciende(0b10000001);
108.    enciende(0b11111111);
109.    enciende(0b10000001);
110.    enciende(0b10000001);
111.    enciende(0b10000001);
112.    enciende(0b01111110);
113.    enciende(0b00000000);
114. }
115.  
116. void letra_P(void)
117. {
118.    enciende(0b00000000);
119.    enciende(0b10000001);
120.    enciende(0b11111111);
121.    enciende(0b10010001);
122.    enciende(0b00010001);
123.    enciende(0b00010001);
124.    enciende(0b00001110);
125.    enciende(0b00000000);
126. }
127.  
128. void letra_C(void)
129. {
130.    enciende(0b00000000);
131.    enciende(0b00000000);
132.    enciende(0b01111110);
133.    enciende(0b10000001);
134.    enciende(0b10000001);
135.    enciende(0b10000001);
136.    enciende(0b01000010);
137.    enciende(0b00000000);
138. }
139.  
140. void main(void)
141. {
142.    set_tris_b(0b00000000);
143.    set_tris_c(0b00000000);
144.    set_tris_a(0b00000000);
145.  
146.    port_b_pullups(FALSE);
147.  
148.    output_high(PIN_B0);
149.    output_high(PIN_C7);
150.    delay_ms(500);
151.  
152. //************************************************************
153. //
154. //    EXPLICACION
155. //
156. //    Cada letra ocupa un tiempo de 40ms.
157. //    En 200ms. haciendo girar el llavero a una velocidad
158. //    normal, se repetir&#225; 2 veces la palabra que pongamos.
159. //
160. //
161. //************************************************************
162.  
163.    while(1)
164.    {
165.  
166. #ifdef TODOPIC
167.       letra_T();
168.       letra_D();
169.       letra_P();
170.       letra_I();
171.       letra_C();
172. #else      
173.       letra_I();
174.       letra_V();
175.       letra_A();
176.       letra_N();
177. #endif
178.  
179.       output_low(PIN_B0);
180.       output_low(PIN_B1);
181.       output_low(PIN_B2);
182.       output_low(PIN_B3);
183.       output_low(PIN_B4);
184.       output_low(PIN_B5);
185.       output_low(PIN_B6);
186.       output_low(PIN_B7);
187.       output_low(PIN_C7);
188.  
189.       delay_ms(40);             // retardo necesario para completar los 200ms.
190.                                 // 40ms*4 letras + 40 ms = 200 ms.
191.  
192.    }
193. }

es decir, mantener la funcion original, y agregarle el dalay a la misma, permitiendo eliminar todos los delay intermedios.

por cierto... es necesario que el pic trabaje a 12mhz? pensaba hacerlo con un 16f88, con su oscilador interno de 8mhz asi me ahorraba componentes en la placa. ademas tiene menos pines, ya que 28 me parecen demasiados...
me estoy planteando AUMENTAR este proyecto... mi ultimo proyecto utilizaba la libreria para displays de 7-seg de vszener, y nocturno le agrego un printf para sacar mensajes...
tal vez, si a esto le agregamos una memoria I2C con los caracteres ascii que nos interesen guardados (si cada caracter ocupa 64bits en una memoria de 16k podemos meter toda la tabla ascii) para no tener que recurrir a una funcion por cada letra...
y otra memoria en la que podamos tener guardados algunos mensajes seleccionables con un dipswitch...
se le implementa el printf... no se si captais por dodne van los tiros
quedaria REDONDO... nunca mejor dicho 
pues... son las 4:40 de la madrugada, y deberia irme a dormir... pero me estoy entusiasmando con esto y creo que hoy voy a trasnochar... 
espero obtener resultados pronto... salu2

[jfh900]

Hola Azicuetano, me he permitido una pequeña licencia para "compactar" el código y reducir el número de líneas:

mmm 
no estoy seguro, pero creo que lo que haces realmente es reducir el numero de lineas escritas, pero al compilar el programa ocupara mas... ya que un "define" simplemente reemplaza todos los "enciende(leds_a_encender)" por "output_b(leds_a_encender); delay_ms(delay_led);" al compilarse... en cambio una llamada a una funcion, como puede ser "enciende(leds_a_encender)" solo se grabara una vez en la memoria rom del pic y se accedera a ella cada vez que se requiera.

Totalmente de acuerdo. Cuando me refiero a compactar el código, es el código fuente, el propio programa en "C", reduciendo el número de líneas y haciendole más facil de seguir.

Efectiamente con una subrutina se reduce el código generado y el escrito al mismo tiempo, pero como todo tiene un precio, y es que se hace una llamada más a una función, con lo que el tiempo de ejecución aumenta, creo que este no es el caso, en el que el tiempo de proceso es muy critico, pero en un programa con los tiempos muy justos esta perdida de velocidad de ejecución puede ser crítica.

Un saludo

[stk500]

Hola amigos me dejais colaborar
Aqui os dejo una pagina muy buenas de codigo para LED
http://www.hobby-elec.org/e_pic6.htm
http://www.hobby-elec.org/e_menu.htm aqui esta el menu
o este http://tobe.nimio.info/led_mood_lamp.php en RGB son geniales
 
Un saludo
tengo un projecto en la web de una matrix de 512 LED
 
si usted se animan hacer algo avisen
estoy para ayudar

[JJcorps]

Una manera ingeniosa de sacar tension de alimentacion a un pic con un ventilador de PC

Lo sabia desde hace tiempo pero es interesante para este proposito

Un saludo

[neo]

Hola a todos, se que este post es antiguo, pero me ha molado jeje   pero no entiendo esta parte, la de los numeros,alguien me podria explicar el tema de las letras como vá,  ejemplo:

void letra_A(void)
{
   enciende(0b00000000);
   enciende(0b10000000);
   enciende(0b11000000);
   enciende(0b10111101);
   enciende(0b00100011);
   enciende(0b10111100);
   enciende(0b11000000);
   enciende(0b10000000);
}