Muy buenas las aplicaciones que se le pueden dar a un simple led, ya estoy apartando LEDs para la matriz.
Al momento de "sensar" uno de los LEDs, deberia haber algun(os) otro(s) encendidos, que proporcionen la luz necesaria en caso de que se este usando en un lugar "a oscuras", no?
Hay un efecto que no se como se llama por el cual, un led conduce cuando se le excita con una luz de longitud de onda igual a la frecuencia en que este emite...por esto debe iluminar los leds de la columna aledaña a la que va a sensar.
Habria que resolver el tema del "driver" que permita exitar los (maximo) 8 LEDS a la vez que permite su lectura....Exacto, ya no se puede utilizar el ULN... en este caso.
Los pines del PIC son tri-estado: salida 0, salida 1 y entrada.
Los pines del PIC son tri-estado: salida 0, salida 1 y entrada.
creo que a lo que se refiere Ariel es que el driver deberia ser tri estado para no cargar directamente la matriz al PIC, mas alla de que este sea tri-estado como bien decis.
Enredado, pero muy interesante el desafio! :)
Hasta se podria hacer una especie de SUPER-SIMON con eso!!!!!!! :)
The LED is a photodiode that is sensitive to light at and above the wavelength
at which it emits (barring any filtering effects of a colored plastic package).
Yo entendí que Mario se refería a la radiación infrarroja que emiten los cuerpos vivos.
Aparentemente, TODOS los LEDs, en mayor o menor medida, reaccionan a la radiacion termica, independientemente de que sean o no infrarrojos....¿Es asi, Mario?
Si, creo que a lo que se refiere Mario es a la radiación térmica que emitiría el dedo, el tema es, que si ponemos LED's infrarrojos no podemos hacer efectos de iluminación con la matriz, seria solo para detección. O estoy errado?
4. Empiezo a sospechar que la matriz que se ve en el vídeo original no es una matriz comercial, sino una matriz fabricada ad-hoc para este uso, pues no veo la forma de hacer funcionar el sistema mediante multiplexión... aunque sigo dándole vueltas.
¡Qué chulada, tío!Lo mismo me pregunte yo...Ademas, deben durar bien poco: multiplexados y todo, son 36 leds por cara...
¿Por dónde se meterán las pilas?
y actualmente está podrido en el dinero, jajajaja
Aunque no está directamente relacionado con el tema:Hace unos meses estuve en unas charlas en el Esade de Barcelona y los auriculares de traducción simultánea recibían la información mediante leds infrarrojos. Había unos focos en el techo llenos de estos leds, de hecho sólo se veían iluminados con la cámara del móvil, y cuando ponías la mano entre los auriculares y los focos dejabas de oir el audio.
En este documento (http://www.jstage.jst.go.jp/article/jlve/31/2/65/_pdf) explican que cada vez más se tiende a utilizar LEDs para iluminación en entornos domésticos, y que con estos LEDs es posible transmitir información musical sin que se perciba el parpadeo (adiós a los cables, adiós a las interferencias, ...)
¿Cómo narices puedo saber qué longitudes de onda no atraviesan el cristal?
Mi proyecto/sueño sería crear varias matrices de 10x10 independientes, como en el tiletoy (publiqué información en http://www.todopic.com.ar/foros/index.php?topic=21690.0) que sirvieran, por ejemplo, para plantear juegos aritméticos a niños. Por ejemplo, con 5 matrices podría implementarse un juego en el que se propusiesen operaciones (como 2+5=) y el chaval tuviera que escribir el resultado en la última matriz con su dedo. Entra aquí en juego el reconocimiento óptico de caracteres...
1. Un led actúa, hasta cierto punto, como un fotodiodo, de modo que si incide luz sobre él generará una tensión incluso de varios voltios. Compruébalo simplemente conectando las dos patillas de un led al polímetro (en modo voltímetro) y acercándolo a una bombilla. Por este motivo baja la tensión en tu último experimento.
Si no entendi mal, el proceso q explicas arriba en la figura, consiste en encender un led, y rapidamente poner el puerto como entrada y medir la tension en sus patas. Lo q digo yo, es mantener el led encendido todo el tiempo con algun puerto del pic, y aparte, medir la variacion de la tension en los leds con el ADC.
Lo que quedaria muy vistoso que no he visto en ningun lado es cambiar el color del led que estamos utilizando a medida que acercamos el dedo......se complicara mucho? digo por el tema de la reflexion de la luz con el dedo que no es igual para todas las frecuencias.
Juanfe que opinas?
estimado amigo, espero te encuentres bien y bueno la razon de mi mensaje es que tengo problemas con la aplicacion del led sensor, programo en ccs con un pic 12f675, en el cual lo que hago es esto.
#include "D:\program ccs\led sensor 12f.h"
#byte TRISIO = 0x85
void main()
{
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
SETUP_ADC(ADC_CLOCK_INTERNAL);
while(true)
{
TRISIO = 0b00010000; //Configuracion del puerto. '0' salida. '1' entrada.
output_high(PIN_A1);
output_low(PIN_A2);
delay_ms(1);
output_high(PIN_A2);
output_low(PIN_A1);
delay_ms(1);
set_adc_channel(2); // selecciono canal 2
if(input(PIN_A2)<= 10){ //este valor de 10 es arbitrario solo para ajustar
output_high(PIN_A0);
delay_ms(100);// retardo para ver que esta detectando
}
setup_adc( ADC_OFF );
output_low(PIN_A0);
TRISIO=0b00010000; //Configuracion del puerto. '0' salida. '1' entrada.
}//fin de while infinito
}//fin de programa
lo unico que deseo es que cuando el led detecte me mande un led de encendido, claro despues hare mas aplicaciones, pero por ahora no detecto nada, espero me puedas ayudar gracias por tu atencion y hasta pronto
La duración de la demora es el valor que tendrás que determinar experimentalmente, no el valor 10 que actualmente utilizas en la comparación if(input(PIN_A2)<= 10){
#byte TRISIO = 0x85
void main()
{
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
while(true)
{
TRISIO = 0b00010000; //Configuracion del puerto. '0' salida. '1' entrada.
output_high(PIN_A1); //polarizando en directa
output_low(PIN_A2);
delay_ms(10); //tiempo de carga
output_low(PIN_A1);//polarizando en inverza
output_high(PIN_A2);
delay_ms(1); //tiempo de descarga
TRISIO = 0b000100; //cambio de estado a entrada
delay_ms(20); //tiempo del cambio de estado
if(!input(PIN_A2)){
while(input(PIN_A2)){}
output_high(PIN_A0);
}
else {output_low(PIN_A0);}//accion en respuesta de deteccion
delay_ms(1);
}//fin de while infinito
}Excelente trabajo gomdryyy!! espero ansioso el video :D
pero tengo una duda... para q configuras el timer si nunca lo usas?
saludos!
#include <10F202.h>
#FUSES NOWDT //No Watch Dog Timer
#FUSES MCLR //Master Clear pin used for I/O
#FUSES NOPROTECT //Code not protected from reading
#byte TRISIO = 0x85
#use delay(clock=4000000)
long int ints_t0 = 0;
int suma = 0;
#int_RTCC
void timer_isr(void)
{
ints_t0 = ints_t0 + 1;
if(ints_t0 <= 5000)
{output_high(PIN_B0);}
else if((ints_t0 > 5000)||(ints_t0 <= 10000))
{output_low(PIN_B0); }
if(ints_t0 >= 10001){ints_t0 = 0;suma = suma + 1;}
}//FIN DE TIMER 0
void main()
{
enable_interrupts(int_RTCC);
enable_interrupts(GLOBAL);
while(true)
{
TRISIO = 0b000000; //Configuracion del puerto. '0' salida. '1' entrada.
output_high(PIN_B1); //polarizando en directa
output_low(PIN_B2);
delay_ms(15); //tiempo de carga
output_low(PIN_B1);//polarizando en inverza
output_high(PIN_B2);
delay_ms(1); //tiempo de descarga
TRISIO = 0b000100; //cambio de estado a entrada
delay_ms(30); //tiempo del cambio de estado
if(!input(PIN_B2)){
while(input(PIN_B2)){}
}
else {//output_low(PIN_A0);
suma = 150;}//accion en respuesta de deteccion
delay_ms(1);
if (suma >= 130)
{
output_low(PIN_B0);
output_low(PIN_B1);
output_low(PIN_B2);
delay_cycles(1);//nop
sleep();
delay_cycles(1);//nop
}
}//fin de while
}//fin de programa
Hola gente tengo otra idea....
¿se podrían utilizar los leds bicolores? y dentro del mismo led ¿utilizar un color como emisor y otro como emisor?
esto creo tendría que hacerce con una fuentecita partida o un divisor resistivo...
Suerte ekud... yo llegúe a la conclusión de que para medir cambios significativos era necesario que sobre el led incidiese luz de su misma longitud de onda, de modo que cuando uses un led como sensor, deberás tener otro igual en los alrededores iluminado.
Si quieres hacer una matriz en la que cada led pueda actuar como sensor, lo anterior significa que tendrás que poder polarizarlos en directa para que se iluminen y, además, de algún modo, poder leer la tensión entre sus terminales. Me interes saber cómo vas a hacer esto último (leer tensión entre terminales).
Hola Ekud, si te he entendido bien, quieres controlar cada led bicolor de forma independiente, sin unir los cátodos/ánodos de todos los que conforman una misma fila/columna ¿es así?
Pero entonces... para una matriz de, por ejemplo, 20 leds necesitarás 20 entradas analógicas y no sé si hay algún PIC con esas capacidades.
These analog multiplexers/demultiplexers control analog
voltages that may vary across the voltage supply range (i.e.
VCC to VEE). They are bidirectional switches thus allowing
any analog input to be used as an output and visa-versa.
program LED_SENSOR
'Simbolos para los anodos del led receptor
Symbol ANODO_ROJO = PORTA.0
Symbol ANODO_VERDE = PORTA.1
'Variables necesarias
Dim t as word
Dim texto as char [5]
main:
'Configuro el puerto A
trisa = %00000001
'Configuro la conversion AD
adcon1 = %10001110
'le indico al micro como esta conectado el lcd
Lcd_Init(PORTB)
'limpio el lcd
Lcd_cmd(lcd_clear)
PRINCIPAL:
'Obtengo el valor de la conversion AD
t = adc_read(0)
'hago la conversion a string para poder mostrar en el display
WordToStrWithZeros(t, texto)
'muestro el dato por el display
Lcd_out(1,1,texto)
'retardo de 1 segundo para poder ver bien el dato
'delay_ms(1000)
'Obtengo el valor de la conversion AD
t = adc_read(0)
'Mientras que la lectura del anodo rojo (pin 0 del AD) sea mayor que 286
while t>=260
'Enciendo el color verde del led bicolor
ANODO_VERDE = 1
'hago la conversion a string para poder mostrar en el display
WordToStrWithZeros(t, texto)
'muestro el dato por el display
Lcd_out(2,1,texto)
'lo dejo encendido un tiempo
DELAY_MS(1000)
'salgo del ciclo ps tener el led en este estado me puede generar
'falsos positivos
GOTO SALIDA
wend
SALIDA:
'Apago el color de indicacion de deteccion
ANODO_VERDE = 0
GOTO PRINCIPAL
end.
Buenas amigos!!! Disculpen q me retrotraiga tanto, es q recien tengo tiempo a ponerme a armar esto y me pasaron un par de cosas algo
extrañas. Arme el ejemplo q dio gomdryyy una pagina antes.
La primera cosa rara q paso es q el ejemplo no anduvo usando el puerto B del pic16f84a, pero cuando use el puerto A si anduvo. Lo segundo es q la sensibilidad del "sensor" aumenta notablemente cuando el circuito esta conectado al programador. Y por ultimo... sin querer quite el led q hace de sensor, y el circuito seguia funcionando!!! Cuando le acerco el dedo a la resistencia q va en serie con el led, en circuito sensa. Debe ser q hay un ruido barbaro, y entre capacidades y todo eso...
En fin, es muy raro, aunq no es el comportamiento q me gustaria q tenga. Sugerencias?
Gracias!!!
program LED_SENSOR
'Simbolos para los anodos del led receptor
Symbol ANODO_ROJO = PORTA.0
Symbol ANODO_VERDE = PORTA.1
Dim t as word
Dim j as byte
Dim promedio as word
Dim i as byte
Dim texto as char [5]
main:
'Configuro el puerto A
trisa = %00000001
'Configuro la conversion AD
adcon1 = %10001110
'le indico al micro como esta conectado el lcd
Lcd_Init(PORTB)
'limpio el lcd
Lcd_cmd(lcd_clear)
'retardo de un segundo para estabilizar
delay_ms(1000)
'muestro un mensaje ke avisa que esta promediando la luz ambiente
Lcd_Out(1,1,"Estabilizando...")
'hago un retardo para estabilizar el circuito
delay_ms(100)
'me aseguro de tener apagado el led
PORTA = 0
'Inicializo la variable de preomdio
promedio = 0
'Itero para obtener los datos del promedio
for j = 1 to 100
for i = 1 to 200
promedio = promedio + Adc_read(0)
next i
promedio = promedio / 200
next j
'muestro el dato en el lcd
Lcd_cmd(lcd_clear)
Lcd_out(1,1,"Prome:")
'hago la conversion a string para poder mostrar en el display
WordToStrWithZeros(promedio, texto)
'muestro el dato por el display
Lcd_out(1,7,texto)
Lcd_out(2,1,"Detec:")
PRINCIPAL:
'reinicio la variable de deteccion
t = 0
'recojo datos de deteccion para hacer promedio
for i = 1 to 200
'Obtengo el valor de la conversion AD
t = adc_read(0) + t
next i
'hago el promedio
t = t / 200
'Mientras que la lectura del anodo rojo (pin 0 del AD) sea mayor que
'el valor del promedio... (ese numero 10 es como para superar un nivel
'de ruido y hace que el sistema sea mas confiable, se obtiene experimentalmente
'y entre mas grande sea mas luz tiene que incidir sobre el led receptor para
'disparar una deteccion y asi mismo entre mas grande sea este numero el
'sistema sera menos sensible al ruido lo k significa poder usarlo en cualkier condicion
'de luz
while t >= (promedio + 10)
'Enciendo el color verde del led bicolor
ANODO_VERDE = 1
'hago la conversion a string para poder mostrar en el display
WordToStrWithZeros(t, texto)
'muestro el dato por el display
Lcd_out(2,7,texto)
'lo dejo encendido un tiempo
Delay_ms(200)
'salgo del ciclo ps tener el led en este estado me puede generar
'falsos positivos
goto SALIDA
wend
SALIDA:
'Apago el color de indicacion de deteccion
ANODO_VERDE = 0
goto PRINCIPAL
end.
La distancia de detección es extraordinaria, no me imaginaba que se alcanzase tanto.
¿Cómo se gestiona que las condiciones de luminosidad cambien?, ¿qué pasa si alguien enciende o apaga la luz de la habitación?
Por cierto, buenísimo lo del giro de cámara :D
Exacto: cada pin deberia manejar 8 leds, por lo que la corriente suministrada por el pic es insuficiente. Por eso me referia a un driver externo, tipo el ULN2803 pero que tenga la posibilidad de ser puesto en un tercer estado (DISABLED) para que no "moleste" a la hora de leer los LEDs.
Buenas amigos!!! Disculpen q me retrotraiga tanto, es q recien tengo tiempo a ponerme a armar esto y me pasaron un par de cosas algo[/glow]
extrañas. Arme el ejemplo q dio gomdryyy una pagina antes.
La primera cosa rara q paso es q el ejemplo no anduvo usando el puerto B del pic16f84a, pero cuando use el puerto A si anduvo. Lo segundo es q la sensibilidad del "sensor" aumenta notablemente cuando el circuito esta conectado al programador. Y por ultimo... sin querer quite el led q hace de sensor, y el circuito seguia funcionando!!! Cuando le acerco el dedo a la resistencia q va en serie con el led, en circuito sensa. Debe ser q hay un ruido barbaro, y entre capacidades y todo eso...
En fin, es muy raro, aunq no es el comportamiento q me gustaria q tenga. Sugerencias?
Gracias!!!
#include <12F675.h>
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES INTRC_IO //Resistor/Capacitor Osc with CLKOUT
#FUSES NOCPD //No EE protection
#FUSES NOPROTECT //Code not protected from reading
#FUSES MCLR //Master Clear pin enabled
#FUSES NOPUT //No Power Up Timer
#FUSES BROWNOUT //Reset when brownout detected
#use delay(clock=4000000,RESTART_WDT)
#use rs232(baud=9600,xmit=pin_A4)
#byte TRISIO = 0x85
#bit sali = 05.5
int i,j,t,promedio;
int contador = 0;
byte flag=0,var1=3; //variables para menu configurar
///LLAMADA FUNCION INTERRUPCION
#INT_TIMER1
void interrupcion()
{
if(flag>var1){ //¿ya es 130ms aprox?
var1--; //SI -> decremento var...
if(var1==0)
var1=2; //...ajuste fino de 130ms aprox
flag=0; //reset flag para contar 130ms aprox
sali=!sali;
contador = contador +1;
}
set_timer1(0); //reset TMR0
flag++; //incremento variable flag
}
void main()
{
setup_port_a(AN1_ANALOG);
SETUP_ADC(ADC_CLOCK_DIV_16);
set_adc_channel(1);
enable_interrupts(INT_TIMER1); //interrupcion TIMER0 activada
setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
set_timer1(0); //carga TMR0
enable_interrupts(GLOBAL); //activadas interrupciones
// TODO: USER CODE!!
output_low(PIN_A5);
output_high(PIN_A2);
printf("\fEstabilizando...");
delay_ms(1000);
promedio = j = 0;
for (i=1;i<=10;++i){
promedio = promedio+read_adc();
Delay_ms(20);
}
promedio = promedio / 10;
Delay_ms(50);
while(true)
{
t = i = 0;
for (i=1;i<=10;++i){
t = t+read_adc();
Delay_ms(20);
}
t = t/10;
Delay_ms(10);
printf("\fPROMEDIO= %d Detectado= %d",promedio,t);
if (t >= (promedio + 7)){ ///Respues a deteccion en el dia
output_high(PIN_A0);
output_low(PIN_A1);
output_low(PIN_A2);
output_low(PIN_A4);
output_low(PIN_A5);
delay_cycles(1);//nop
sleep();
delay_cycles(1);//nop
}
else if (t <= (promedio - 7)){ ///Respuesta a deteccion en oscuridad
output_high(PIN_A0);
output_low(PIN_A1);
output_low(PIN_A2);
output_low(PIN_A4);
output_low(PIN_A5);
delay_cycles(1);//nop
sleep();
delay_cycles(1);//nop
}
else {output_low(PIN_A0);}
if (contador == 150){// Fin de la alarmaaaaaaaaaaaa
output_high(PIN_A0);
output_low(PIN_A1);
output_low(PIN_A2);
output_low(PIN_A4);
output_low(PIN_A5);
delay_cycles(1);//nop
sleep();
delay_cycles(1);//nop
}
t =0;
Delay_ms(5);
}//fin infinito
}//fin de main
//// ledSensor.c ////
//// ////
//// Autor: jfmateos2 ////
//// Contacto: jfmateos@lycos.es ////
//// Madrid, febrero 2008 ////
//// ////
/////////////////////////////////////////////////////////////////////////
#include <18F4550.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN, CCP2C1
#device ADC=10
#use delay(clock=48000000)
#include ".\include\usb_cdc.h"
#define catodo0 PIN_A0
#define catodo1 PIN_A1
#define catodo2 PIN_A2
#define catodo3 PIN_A3
#define catodo4 PIN_A4
#define anodo0 PIN_B4
#define anodo1 PIN_B3
#define anodo2 PIN_B2
#define anodo3 PIN_B1
#define anodo4 PIN_B0
int1 conversorOcupado=0;
#INT_AD
void ad_handler(){
conversorOcupado=0;
}
//ADC
void main(){
int i,maximo,intervalo,umbral,cuantizado;
int32 lecturas, minimo, media;
int32 valor, lectura[20];
usb_cdc_init();
usb_init();
while(!usb_cdc_connected()) {}
setup_adc(ADC_CLOCK_DIV_64 );
set_adc_channel(0);
setup_adc_ports(AN0);
enable_interrupts(INT_AD);
clear_interrupt(INT_AD);
output_bit(catodo0,1);
output_bit(anodo0,0);
output_bit(anodo1,0);
output_bit(anodo2,0);
output_bit(anodo3,0);
output_bit(anodo4,0);
umbral=120;
intervalo=19;
do{
set_tris_b(27);
set_tris_a(1);
minimo=1024;
media=0;
//maximo=0;
for(i=0;i<15;i++){
conversorOcupado=1;
read_adc(ADC_START_ONLY);
while(conversorOcupado){
}
valor = read_adc(ADC_READ_ONLY);
if(valor<minimo){
minimo=valor;
}
}
cuantizado=0;
for(i=1;i<=18;i++){
if(minimo>((int32)((int32)intervalo*(int32)i))){
cuantizado=i;
}
}
output_bit(catodo0,0);
output_bit(anodo0,1);
output_bit(anodo1,1);
output_bit(anodo2,1);
output_bit(anodo3,1);
output_bit(anodo4,1);
usb_task();
if (usb_enumerated()) {
//printf(usb_cdc_putc, "%u %Lu", cuantizado, minimo);
printf(usb_cdc_putc, " %c",cuantizado);
//printf(usb_cdc_putc, "\n\r");
}
delay_ms(20);
output_bit(catodo0,1);
output_bit(anodo0,0);
output_bit(anodo1,0);
output_bit(anodo2,0);
output_bit(anodo3,0);
output_bit(anodo4,0);
}while(true);
}
/*
//Contabilizar estado alto
void main(){
int32 lecturas;
usb_cdc_init();
usb_init();
while(!usb_cdc_connected()) {}
output_bit(catodo0,1);
output_bit(catodo1,1);
output_bit(catodo2,1);
output_bit(catodo3,1);
output_bit(catodo4,1);
output_bit(anodo0,0);
output_bit(anodo1,0);
output_bit(anodo2,0);
output_bit(anodo3,0);
output_bit(anodo4,0);
do{
lecturas=0;
set_tris_b(27);
set_tris_a(31);
while (input(catodo2)){
lecturas++;
}
usb_task();
if (usb_enumerated()) {
printf(usb_cdc_putc, "Lecturas= %Lu ", lecturas);
printf(usb_cdc_putc, "\n\r");
}
output_bit(catodo0,1);
output_bit(catodo1,1);
output_bit(catodo2,1);
output_bit(catodo3,1);
output_bit(catodo4,1);
output_bit(anodo0,0);
output_bit(anodo1,0);
output_bit(anodo2,0);
output_bit(anodo3,0);
output_bit(anodo4,0);
delay_ms(100);
} while(true);
}*/
Es fantastico lo que vienen haciendo estos años con este tema!
Una cosa no me queda muy en clara....estoy viendo como hacer mi aplicacion, la cual va a contar con 5 o 6 botones,,,los cuales no habria problema en usar unos simples switches pero la idea es ver de usar otro tipo de "switch". Encontre la tecnologia mTouch de microchip y ahora me encuentro con esto.....Seria posible usar un led por cada "boton"? El panel seria para controlar un menu de un lcd; fundamentalmente para manejarlo al aire libre.
Es fantastico lo que vienen haciendo estos años con este tema!
Una cosa no me queda muy en clara....estoy viendo como hacer mi aplicacion, la cual va a contar con 5 o 6 botones,,,los cuales no habria problema en usar unos simples switches pero la idea es ver de usar otro tipo de "switch". Encontre la tecnologia mTouch de microchip y ahora me encuentro con esto.....Seria posible usar un led por cada "boton"? El panel seria para controlar un menu de un lcd; fundamentalmente para manejarlo al aire libre.
puedes usar los sensores capacitivos de mtouch, mira este ejemplo:
http://www.todopic.com.ar/foros/index.php?topic=28727.0 (http://www.todopic.com.ar/foros/index.php?topic=28727.0)
o podrias usar los leds como botones, como en este post.
en ambos casos los puedes usar como "switches" usandolos al aire libre, siempre y cuando los calibres bien.
Si la duda es elegir entre leds o mtouch, yo me quedaría con lo segundo. Es más preciso, te permite encapsular el circuito y protegerlo de inclemencias externas y encima es más barato.