Respecto al pic te recomiendo un PIC18F442 o PIC18F452 que es una familia muy usada comunmente y con bastante memoria y seguro que no tendrás ningún problema.
cerebro, que problemas tiene el pickit 2 con los J y K?
#include <18F4450.h>
#fuses XT,NOWDT
#use delay( clock = 4000000 ) // Reloj de 4 MHz
#BYTE TRISB = 0x01 // TRISB en todos los puertos menos en el primero???
#BYTE PORTB = 0x06 // PORTB en 06h.
#BYTE OPTION_REG = 0x81 //OPTION_REG en 81h.
void main()
{
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF|ADC_TAD_MUL_0);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
//Setup_Oscillator parameter not selected from Intr Oscillotar Config tab
// TODO: USER CODE!!
bit_clear(OPTION_REG,7); // Habilitación Pull-up
bit_set(TRISB,0); //B0 como entrada
bit_clear(TRISB,1); // B1 como salida
bit_clear(PORTB,1); // apaga LED
while (1) {
if (bit_test(PORTB,0) == 1 ) //Si RB0 es 1 apaga el LED
bit_clear(PORTB,1);
else{
bit_set(PORTB,1); //Si RB0=0 enciende el LED
delay_ms(1000);
bit_set(PORTB,3);
delay_ms(1000);
bit_set(PORTB,7);
delay_ms(1000);
bit_set(PORTB,15);
}
}
}
#include <18F4450.h>
#fuses HS,NOWDT
#use delay( clock = 12000000 ) // Reloj de 12 MHz
#define boton PIN_B0
#define led1 PIN_B1
#define led2 PIN_B2
#define led3 PIN_B3
#define led4 PIN_B4
#define led5 PIN_B5
#define led6 PIN_B6
#define led7 PIN_B7
#define ON output_high
#define OFF output_low
void main(){
while (1) {
if ( boton == 0 ){
OFF(led1);
delay_ms(1000);
OFF(led2);
delay_ms(1000);
OFF(led3);
delay_ms(1000);
OFF(led4);
delay_ms(1000);
OFF(led5);
delay_ms(1000);
OFF(led6);
delay_ms(1000);
OFF(led7);
}else{
ON(led1);
delay_ms(1000);
ON(led2);
delay_ms(1000);
ON(led3);
delay_ms(1000);
ON(led4);
delay_ms(1000);
ON(led5);
delay_ms(1000);
ON(led6);
delay_ms(1000);
ON(led7);
}
}
}
#include <18F4450.h>
#fuses HS,NOWDT
#use delay( clock = 24000000 ) // Reloj de 24 MHz
#define boton1 PIN_B0
#define boton2 PIN_C0
#define led1 PIN_B1
#define led2 PIN_B2
#define led3 PIN_B3
#define led4 PIN_B4
#define led5 PIN_B5
#define led6 PIN_B6
#define led7 PIN_B7
#define ON output_high
#define OFF output_low
void main(){
int presionado1, presionado2;
int anterior = 0;
while (1) {
presionado1 = input_state(boton1);
presionado2 = input_state(boton2);
if ( presionado2 == 1 ){
OFF(led1);
delay_ms(100);
OFF(led2);
delay_ms(100);
OFF(led3);
delay_ms(100);
OFF(led4);
delay_ms(100);
OFF(led5);
delay_ms(100);
OFF(led6);
delay_ms(100);
OFF(led7);
anterior = 0;
}
if (presionado1 == 1){
anterior = 1;
ON(led1);
delay_ms(100);
ON(led2);
delay_ms(100);
ON(led3);
delay_ms(100);
ON(led4);
delay_ms(100);
ON(led5);
delay_ms(100);
ON(led6);
delay_ms(100);
ON(led7);
}
}
}
#include <18F4450.h>
#fuses HS,NOWDT
#use delay( clock = 24000000 ) // Reloj de 24 MHz
#define botonAbajo PIN_B0
#define botonArriba PIN_C0
#define led1 PIN_B1
#define led2 PIN_B2
#define led3 PIN_B3
#define led4 PIN_B4
#define led5 PIN_B5
#define led6 PIN_B6
#define led7 PIN_B7
#define ON output_high
#define OFF output_low
void main(){
int abajo, arriba;
int inicioAbajo = 0;
int inicioArriba = 0;
while (1) {
abajo = input_state(botonAbajo);
arriba = input_state(botonArriba);
if ( arriba == 1 ){
if (inicioAbajo == 0){
inicioArriba = 1;
ON(led7);
delay_ms(100);
ON(led6);
delay_ms(100);
ON(led5);
delay_ms(100);
ON(led4);
delay_ms(100);
ON(led3);
delay_ms(100);
ON(led2);
delay_ms(100);
ON(led1);
}else{
OFF(led1);
delay_ms(100);
OFF(led2);
delay_ms(100);
OFF(led3);
delay_ms(100);
OFF(led4);
delay_ms(100);
OFF(led5);
delay_ms(100);
OFF(led6);
delay_ms(100);
OFF(led7);
inicioAbajo = 0;
}
}
if (abajo == 1){
if (inicioArriba == 1){
OFF(led7);
delay_ms(100);
OFF(led6);
delay_ms(100);
OFF(led5);
delay_ms(100);
OFF(led4);
delay_ms(100);
OFF(led3);
delay_ms(100);
OFF(led2);
delay_ms(100);
OFF(led1);
inicioArriba = 0;
}else{
inicioAbajo = 1;
ON(led1);
delay_ms(100);
ON(led2);
delay_ms(100);
ON(led3);
delay_ms(100);
ON(led4);
delay_ms(100);
ON(led5);
delay_ms(100);
ON(led6);
delay_ms(100);
ON(led7);
}
}
}
}
Disculpad, pero para conseguir un efecto de encendido o apagado progresivo de los leds no se hace con condensadores, sino mediante la modificación del % duty del PWM.
Para el PWM tendrás que multiplexarlo por SW, es decir usar los timers para PWM, sigue este enlace del compañero RedPIC, no es exactamente lo que tienes que hacer pero van por ahí los tiros.
Control Servo Timer PWM
Respecto a lo de Proteus...es debido a que tu máquina no es lo suficientemente potente para mover las simulaciones en tiempo real, eso no significa que no funcione, simplemente que no lo hace en tiempo real.
Lo veo más óptimo y más barato, hacer esto del PWM con el PIC, incluso de esta forma con el PWM el pic va a estar muy ocioso, ya que lo único que hará es comparar variables auxiliares cada vez que se desbordan los temporizadores. Pero si es cierto que para alguien que no sabe programar muy bien en PICs le es más fácil lo otro...
#include <18F4450.h>
#fuses HS,NOWDT
#use delay( clock = 4000000 ) // Reloj de 4 MHz
#define botonAbajo PIN_C0
#define botonArriba PIN_C1
#define led1 PIN_B0
#define led2 PIN_B1
#define led3 PIN_B2
#define led4 PIN_B3
#define led5 PIN_B4
#define led6 PIN_B5
#define led7 PIN_B6
#define led8 PIN_B7
#define ON output_high
#define OFF output_low
void main(){
int abajo, arriba;
int inicioAbajo = 0;
int inicioArriba = 0;
for (;;) {
abajo = input_state(botonAbajo);
arriba = input_state(botonArriba);
if ( arriba == 1 ){
if (inicioAbajo == 0){
inicioArriba = 1;
ON(led8);
delay_ms(200);
ON(led7);
delay_ms(200);
ON(led6);
delay_ms(200);
ON(led5);
delay_ms(200);
ON(led4);
delay_ms(200);
ON(led3);
delay_ms(200);
ON(led2);
delay_ms(200);
ON(led1);
}else{
OFF(led1);
delay_ms(200);
OFF(led2);
delay_ms(200);
OFF(led3);
delay_ms(200);
OFF(led4);
delay_ms(200);
OFF(led5);
delay_ms(200);
OFF(led6);
delay_ms(200);
OFF(led7);
delay_ms(200);
OFF(led8);
inicioAbajo = 0;
}
}
if (abajo == 1){
if (inicioArriba == 1){
OFF(led8);
delay_ms(200);
OFF(led7);
delay_ms(200);
OFF(led6);
delay_ms(200);
OFF(led5);
delay_ms(200);
OFF(led4);
delay_ms(200);
OFF(led3);
delay_ms(200);
OFF(led2);
delay_ms(200);
OFF(led1);
inicioArriba = 0;
}else{
inicioAbajo = 1;
ON(led1);
delay_ms(200);
ON(led2);
delay_ms(200);
ON(led3);
delay_ms(200);
ON(led4);
delay_ms(200);
ON(led5);
delay_ms(200);
ON(led6);
delay_ms(200);
ON(led7);
delay_ms(200);
ON(led8);
}
}
}
}
You will receive 100 pcs 5mm White LEDs.
Free to provide 100 pcs resistors for 5V DC and 25 pcs resistors for 12V DC.
This is highly intensive, super bright White LED. It's so bright that you can't miss it!
Ideal for small fog light, interior illumination, signal indicator.
Several beautiful colors available: Red, Blue, Green, White etc. PLZ contact us
with email or message for all colors we provide. They are fully waterproof and completely shatterproof,and have been tested for performance and durability in extreme heat, vibration.
Product Number LE-DS150 Product Name 100 pcs 5mm White LED17000mcd & Free Resistor Emitted Color White/td] Size (mm) 5mm/td] Lens Color Water Clear Peak Wave Length (nm) N/A Static Sense Yes Forward Voltage (V) 3.0 - 3.2 View Angle 5 - 25° Luminous Intensity (mcd) 15000 - 17000 Maximum Curren 20mA Continuous, 50mA peak for 10% Pulse Width Item Net Weight 75g / 2.7oz
View Angle 5 - 25°
TIP= Es conveniente siempre usar varios cables finos (multifilar, cable litz, etc) que un solo cable gordito sobretodo si vas a mandar una señal de frecuencia relativamente alta por él por el tema del efecto pelicular que aumenta la Resistencia efectiva o desde otro punto de vista, reduce la sección equivalente del conductor.
De cualquier modo, salvo que sea la escalera más larga del mundo (http://www.francescjosep.net/la-escalera-mas-larga-del-mundo/) :) no vas a tener ningún problema, medí la R del cable y multiplicala por la máxima I que vaya a pasar por él y verás la caida de V (seguro resultará despreciable)
TIP= Es conveniente siempre usar varios cables finos (multifilar, cable litz, etc) que un solo cable gordito sobretodo si vas a mandar una señal de frecuencia relativamente alta por él por el tema del efecto pelicular que aumenta la Resistencia efectiva o desde otro punto de vista, reduce la sección equivalente del conductor.
De cualquier modo, salvo que sea la escalera más larga del mundo (http://www.francescjosep.net/la-escalera-mas-larga-del-mundo/) :) no vas a tener ningún problema, medí la R del cable y multiplicala por la máxima I que vaya a pasar por él y verás la caida de V (seguro resultará despreciable)
Efecto skin, cierto? :P
//++++++++++++++++++++++++++++++++++++++++++++++++++++++//
#include <16F628a.h>
#FUSES INTRC_IO,NOWDT,PUT,NOMCLR,BROWNOUT,PROTECT,CPD
#use delay(clock=4000000)
//#use rs232(baud=19200,rcv=PIN_A3,BITS=8,sample_early)
#zero_ram
//+++++++++++++++++++++++++++++++++++++++++//
#define LED1 PIN_A0
#define LED2 PIN_A1
#define SW1 PIN_A4
#define SW2 PIN_A5
#define PUS_PC PIN_B0
#define PUS_PD PIN_B1
#define IN_SEN PIN_B2
//+++++++++++++++++++++++++++++++++++++++++//
#define CMD_ON 0x01
#define CMD_OFF 0x02
#define CMD_FADER_FAST 0x03
#define CMD_FADER_SLOW 0x04
#define CMD_INC_FAST 0x05
#define CMD_INC_SLOW 0x06
#define CMD_DEC_FAST 0x07
#define CMD_DEC_SLOW 0x08
//+++++++++++++++++++++++++++++++++++++++++
//
//
// Protocolo Unidireccional Serie (PUS) ;-)
//
// Dos Lineas:
// PD : Dato
// PC : Reloj
//
// Dato se lee en flanco de subida PD y debe permanecer
// hasta siguiente flanco de bajada, si no Error o START.
//
// Condicion START:
// PD = 0 en flanco de subida de PC.
// PD = 1 en siguiente flanco de bajada de PC.
//
// ____ ____ ____ ____
// __| |____| |____| |____| |____ PC
//
// ____ _______ _______
// ____| |_| |_| |___________| PD
//
// ^
// START
// 1 1 0
// Formato paquete
// A3 A2 A1 A0 C3 C2 C1 C0
//
// A : Direccion ( 15 posibles, 0 reservado)
// C : Comando ( 15 posibles, 0 reservado)
//
////+++++++++++++++++++++++++++++++++++++++++
//
void PUS_write(int8 add,int8 cmd);
////+++++++++++++++++++++++++++++++++++++++++
////+++++++++++++++++++++++++++++++++++++++++
void main(){
setup_comparator(NC_NC_NC_NC); //Comparador deshabilitado
output_A(0x00); //Latch
set_tris_A(0B0110000); //Input A4 y A5
output_B(0x00); //Latch
set_tris_B(0B0000100); //Input B2
//--------- PROGRAMA PRINCIPAL -----------------------------\\\\
// Prueba de envio ON/OFFF
while (1) {
PUS_write (0x01,CMD_ON);
PUS_write (0x02,CMD_OFF);
delay_ms(1000);
PUS_write (0x01,CMD_OFF);
PUS_write (0x02,CMD_ON);
delay_ms(1000);
}//end while
}//end main
////+++++++++++++++++++++++++++++++++++++++++
#define PERIODO_BIT_US 500
void PUS_write(int8 add,int8 cmd)
{
int8 dato, nbits, mask;
dato = (add << 4) & 0xF0;
dato |= (cmd & 0x0F);
output_low(PUS_PD);
output_low(PUS_PC);
// Condicion START
delay_us (2 * PERIODO_BIT_US);
output_high(PUS_PC);
delay_us (PERIODO_BIT_US / 2);
output_high(PUS_PD);
delay_us (PERIODO_BIT_US / 2);
output_low(PUS_PC);
// Envio de los bits
mask = 0x80;
for (nbits = 0; nbits < 8; nbits++)
{
delay_us (PERIODO_BIT_US / 2);
if ((dato & mask) > 0)
output_high(PUS_PD);
else
output_low(PUS_PD);
delay_us (PERIODO_BIT_US / 2);
output_high(PUS_PC);
delay_us (PERIODO_BIT_US);
output_low(PUS_PC);
mask = mask >> 1;
}
delay_us (PERIODO_BIT_US);
output_low(PUS_PD);
delay_us (PERIODO_BIT_US);
// TODO : Envio de paridad
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++//
#include <12F629.h>
#FUSES INTRC_IO,NOWDT,PUT,NOMCLR,BROWNOUT,PROTECT,CPD
#use delay(clock=4M)
#use fast_io(A)
#zero_ram
//+++++++++++++++++++++++++++++++++++++++++//
#define LED PIN_A0
#define PUS_PC PIN_A3
#define PUS_PD PIN_A4
//+++++++++++++++++++++++++++++++++++++++++//
#define MAX_LED 100
#define CMD_ON 0x01
#define CMD_OFF 0x02
#define CMD_FADER_FAST 0x03
#define CMD_FADER_SLOW 0x04
#define CMD_INC_FAST 0x05
#define CMD_INC_SLOW 0x06
#define CMD_DEC_FAST 0x07
#define CMD_DEC_SLOW 0x08
char dato_rx = 0;
volatile int8 pwm_act_led = 0;
int8 pwm_led = 0;
// Variable control seceuncia de inicio
//
#define SEQ_INIT_START 0
#define SEQ_INIT_F1 1
#define SEQ_INIT_F2 2
#define SEQ_INIT_F3 3
#define SEQ_INIT_END 4
int16 cont_seq_inicio = 0;
int8 seq_inicio = SEQ_INIT_START;
int8 comando,address;
int8 fader(int8 speed,int1 inicio );
//+++++++++++++++++++++++++++++++++++++++++
//
//
// Protocolo Unidireccional Serie (PUS) ;-)
//
// Dos Lineas:
// PD : Dato
// PC : Reloj
//
// Dato se lee en flanco de subida PD y debe permanecer
// hasta siguiente flanco de bajada, si no Error o START.
//
// Condicion START:
// PD = 0 en flanco de subida de PC.
// PD = 1 en siguiente flanco de bajada de PC.
//
// ____ ____ ____ ____
// __| |____| |____| |____| |____ PC
//
// ____ _______ _______
// ____| |_| |_| |___________| PD
//
// ^
// START
// 1 1 0
// Formato paquete
// A3 A2 A1 A0 C3 C2 C1 C0
//
// A : Direccion ( 15 posibles, 0 reservado)
// C : Comando ( 15 posibles, 0 reservado)
//
////+++++++++++++++++++++++++++++++++++++++++
//
int8 PUS_dato = 0;
#define PUS_ADDR 0x01
////+++++++++++++++++++++++++++++++++++++++++
////+++++++++++++++++++++++++++++++++++++++++
void main(){
setup_comparator(NC_NC_NC_NC); //Comparador deshabilitado
output_A(0x00); //Latch
set_tris_A(0B011000); //MCLR=A3= RX input Int_RA3 on Change
enable_interrupts(GLOBAL); //Interrupciones Habilitadas
enable_interrupts(INT_TIMER1); //Habilitamos interrupcion desborde TMR1
// Timer1 para conseguir un tick cada 100us @ 4Mhz
set_timer1(65436); // 65536-(.000100/(4/4000000))
setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);
enable_interrupts(INT_RA3); //Habilitamos interrupcion por cambio de estado
//en pin RA3
//--------- PROGRAMA PRINCIPAL -----------------------------\\\\
//while (fader(100,1)) delay_ms(200);
while (1) {
//
// Estamos en sequencia de inicio
//
if (seq_inicio != SEQ_INIT_END)
{
switch (seq_inicio)
{
case SEQ_INIT_START : pwm_led = MAX_LED; break;
case SEQ_INIT_F1 : pwm_led = MAX_LED/2; break;
case SEQ_INIT_F2 : pwm_led = MAX_LED/4; break;
case SEQ_INIT_F3 : pwm_led = 0; break;
}
if (cont_seq_inicio++ > 10000)
{
cont_seq_inicio = 0;
seq_inicio++;
}
}
else
//
// Ejecucion normal : chequeamos dato recibido por PUS
//
dato_rx = PUS_dato;
PUS_dato = 0;
if (dato_rx != 0)
{
comando = dato_rx & 0x0F;
address = (dato_rx >> 4) & 0x0F;
if (address == PUS_ADDR)
{
switch (comando)
{
case CMD_OFF : pwm_led = 0; break;
case CMD_ON : pwm_led = MAX_LED; break;
}
}
dato_rx = 0;
}//if rx
}//end while
}//end main
// ++++++++++++++++++++++++++++++++++++++++++++++++
#define MAX_LED_FADER 8
const int8 led_valor[MAX_LED_FADER] = {0,10,20,30,50,70,80,100};
#define FADER_STOP 0
#define FADER_UP 1
#define FADER_DOWN 2
int8 fase_fader = FADER_STOP;
int8 idx_valor;
int8 speed_fader;
//
// fader
//
// speed : velocidad de la secuencia "fader"
// inicio : flag arranque secuencia
//
// devuelve 0 al finalizar el ciclode "fader", 1 en caso contrario.
//
int8 fader(int8 speed,int1 inicio )
{
if ((fase_fader == FADER_STOP) && (inicio))
{
pwm_led = 0;
speed_fader= speed;
fase_fader = FADER_UP;
idx_valor = 0;
}
if (fase_fader == FADER_UP )
{
pwm_led = led_valor[idx_valor++];
if (idx_valor > MAX_LED_FADER)
{
fase_fader = FADER_DOWN;
idx_valor = MAX_LED_FADER-1;
}
}
if (fase_fader == FADER_DOWN)
{
if (idx_valor == 0)
{
fase_fader = FADER_STOP;
}
else
{
pwm_led = led_valor[idx_valor--];
}
}
return (fase_fader != FADER_STOP);
}
//+++++++++++++++ INTERRUPCIONES +++++++++++++++++++//
#INT_TIMER1
void desborde_TMR1(){ //Interrupcion por desborde de timer cada 100 us
//
// Control PWM del LED
//
pwm_act_led++;
if (pwm_act_led > pwm_led)
output_low(LED);
else
output_high(LED);
// El ciclo se repite cada 100 * 100us = 10ms. (100Hz)
if (pwm_act_led > MAX_LED) pwm_act_led = 0;
set_timer1(65436); // 65536-(.000100/(4/4000000))
} // interrupcion TMR1
//
// Gestion del protocolo PUS por interrupcion
//
#define PUS_IDLE 0
#define PUS_START 1
#define PUS_RX 2
int8 PUS_temp = 0;
int8 PUS_nbit = 0;
int8 PUS_status = PUS_IDLE;
int1 PUS_bit = 0;
int8 PUS_error_data = 0;
int8 PUS_error_start = 0;
#INT_RA
void PUS_recepcion(){ //Interrupcion por cambio de estado en pines
if (input_state(PUS_PC) == 1) // Flanco subida PC
{
switch(PUS_status)
{
case PUS_IDLE :
// Chequeo inicio de condicion de START
if (input_state(PUS_PD) == 0)
{
PUS_status = PUS_START;
}
break;
case PUS_START : break;
case PUS_RX :
// detectamos inicio de bit.
PUS_bit = input_state(PUS_PD);
break;
}
}
else // Flando bajada PC
{
switch(PUS_status)
{
case PUS_IDLE : break;
case PUS_START :
// Chequeo de condicion de START completa
if (input_state(PUS_PD) == 1)
{
PUS_status = PUS_RX;
PUS_temp = 0;
}
else // ERROR, reinicio
{
PUS_status = PUS_IDLE;
PUS_error_start++;
}
break;
case PUS_RX:
// Condicion de START ya detectada
// Bit en PD se ha mantenido, guardamos
if (PUS_bit == input_state(PUS_PD))
{
PUS_temp <<= 1;
if (PUS_bit)
PUS_temp |= 0x01;
else
PUS_temp &= 0xFE;
PUS_nbit++;
// Dato completo recibido ?
if (PUS_nbit > 7)
{
PUS_nbit = 0;
PUS_status= PUS_IDLE;
PUS_dato = PUS_temp;
PUS_temp = 0;
}
}
else // ERROR, reinicio dato
{
PUS_dato = 0;
PUS_nbit = 0;
PUS_status= PUS_IDLE;
PUS_error_data++;
}
break;
}
}
} //int_ra3
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++//
Disculpad, pero para conseguir un efecto de encendido o apagado progresivo de los leds no se hace con condensadores, sino mediante la modificación del % duty del PWM.Nocturno, y, generalmente, a que frecuencia debe estar el PWM? O cual es lo mas recomendable?
(http://galaxi0.files.wordpress.com/2009/06/pwm1.png?w=320&h=350)
Pues dependerá del tiempo de respuesta del led, la verdad es que no sé responderte a esa pregunta con un argumento sólido. Yo siempre pongo varios KHz pero es probable que exista una frecuencia idónea que venga dada por el tipo de led.La(s) frecuencia(s) que usas generalmente? Solo por tener una idea.
Bueno, mirando el primer video, noto que al encender lo hace instantáneamente y cuando se apaga da la sensación que lo hace por PWM, la verdad si se quiere hacer igual, y solo para esta aplicación no habría necesidad de un PIC..echando un poco de cabeza recordando viejos tiempos, creo que eso se puede hacer con un CD4011 conectado como un circuito de reloj controlado, y varios Flip-flop tipo D conectados en cascada hasta que tengan las salidas que necesitemos; y a las salidas de los transistores le pondremos un condensador que mantenga el Led encendido y este valla descargándolo dando la sensación de apagado suave..no se que piensan al respecto?..
O si quieren PIC pues usar un 12F509, conectarle Shif Registrer(cd4094) en cascada y el mismo sistema de condensador por salida..no se así me ahorraría tanto componente para un efecto que de por si es muy llamativo sin importar si se enciende suave o no.
Saludos
Hola... al empezar a leer este tema pensé lo mismo, es decir, usar capacitores. El circuito que se me ocurrió es el que presento a continuación
(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=30294.0;attach=11840)
Adjunto también una simulación en proteus 7.2 SP6. con su .hex
Notar que sólo hice uso de un puerto del pic, pero se pueden usar todos los pines del mismo que tengamos disponibles de igual manera.
Los pulsadores simulan los sensores infrarrojos en los extremos de la escalera.
Al hacer este circuito me di cuenta de 2 cosas:
- El circuito se amplía bastante al realizar el efecto de retardo de los led mediante hardware.
- El valor de los capacitores es relativamente grande y depende del tipo de leds que usemos, a mayor consumo se necesita un capacitor mayor para mantener el mismo retardo.
Todo esto quizas pueda ser subsanado en parte por otra configurración de hardware, pero ésta es la mejor que se me ocurrió a mí.
Después de esta conclusión, si yo tuviese que realizar este proyecto, y no se mejora el hardware que aquí propongo, lo encararía por el lado del software con pwm. Pero también vale aclarar que se me dificultará bastante hacer el código y me llevaría bastante más tiempo también. Por eso, con todo respeto, para alguien que no tenga experiencia en programación se le va a complicar y mucho.
Saludos y éxitos para los que encaren este proyecto.
edito:
ya vi mi error en ponerle 2 snensores de cada lado, ya que prenderian pero se apagarian seguidamente, jajajaja tendre que seguir pensando como hacerle, gracias
Hola a todos!
Yo tambien me emocione con este proyecto y empece por mi lado con lo poco que se a ver que me salia, mas o menos tiene color, lo hice en el PSI y lo simule en proteus, coloque pulsadores para subir y bajar, pero se pone un par de infrarrojos y solucionamos ese tema.
El asunto de hacerlo modular no es nada complicado, habia pensado en hacerlo con 5 cables por modulo, 2 de alimentacion, uno de entrada y dos de salida.
Serian dos de salida por que hay que controlar cuando se sube o se baja la escalera, pero es posible reducirlo a un solo cablecito
Les dejo la simulacion por si alguien lo quiere probar, el codigo si quieren lo subo, pero es asquerosamente horrible, tengo que probar un poco mas con shifleft y shiftright, y si me sale lo que tengo en mente me ahorro una banda de codigo.
Saludos!
Martin
inicio:
if porta.0 = 1 then goto baja 'Pulsador para encender las luces al bajar la escalera
if porta.1 = 1 then goto sube 'Pulsador para endender las luces al subir las escaleras
goto inicio
:baja 'secuencia para bajar escaleras
portb = 00000001
waitms 300
portb = 00000011
waitms 300
portb = 00000111
waitms 300
portb = 00001111
waitms 300
portb = 00011111
waitms 300
portb = 00111111
waitms 300
portb = 01111111
waitms 300
portb = 11111111
waitms 5000 'espera 5 segundos para comenzar secuencia de apagado
portb = 11111110 'comienza secuencia de apagado con delay de 1seg entre cada led
waitms 1000
portb = 11111100
waitms 1000
portb = 11111000
waitms 1000
portb = 11110000
waitms 1000
portb = 11100000
waitms 1000
portb = 11000000
waitms 1000
portb = 10000000
waitms 1000
portb = 0
goto inicio
sube: 'Secuencia para subir las escaleras1
portb = 10000000
waitms 300
portb = 11000000
waitms 300
portb = 11100000
waitms 300
portb = 11110000
waitms 300
portb = 11111000
waitms 300
portb = 11111100
waitms 300
portb = 11111110
waitms 300
portb = 11111111
waitms 5000
portb = 01111111
waitms 1000
portb = 00111111
waitms 1000
portb = 00011111
waitms 1000
portb = 00001111
waitms 1000
portb = 00000111
waitms 1000
portb = 00000011
waitms 1000
portb = 00000001
waitms 1000
portb = 0
goto inicio
end
Y sobre que PIC podríamos implementar esto????Pues en la simulación que adjunte puedes hacerte una idea.
Hola JeremylfAsí es. Parecen LEDs de 1W no? Bueno, estoy intentando encontrar algo que se asemeje a ese marco.. Sabrían de algún lugar?
Si te fijas en el primer video que está publicado, puedes ver como ilumina sobre la pared de enfrente, se puede notar o que no es un solo led o tiene alguna lente, si miras con detenimiento en una parte del video hacen una toma desde arriba y se ve el aplique del led, tiene como un marco de acero inoxidable (por lo menos es el color), pero me juego con que tiene alguna lente en el aplique que utilizaron.-
saludos y muy bueno el proyecto
Hola, antes de nada quería presentarme. Hace unos días vi un video en la página de hacknmod una persona que iluminaba los escalones de su casa mediante leds, el tema es que me gustaría hacer lo mismo. Un buen amigo me comentó que eso se debería de hacer con un PIC, yo creo que el sistema no es muy complicado de hacer, lo que pasa que soy practicamente un noob en el tema de la electrónica. Aprendí algo (a montar circuitos y a medir con el osciloscopio) en la universidad.
Me gustaría saber si alguno del foro podría ayudarme un poco. Tendría que adquirir todo desde el pic necesario, los leds, tambien me comentó mi amigo el uso de algún transistor para alimentar a los led con la potencia suficiente, así como el programador, aunque me recomendó el pic Kit 2, no he visto que programe pics de la familia 18Fxxxx que es la que me recomendó.
Adjunto el video de esta persona y espero sus respuestas.
Gracias, un saludo
darkbytes, puedes usar mejor un ULN2803 para no usar tanto transistor. Tb te falta sus respectivas resistencias de los LEDs. Por otro lado, esa alternativa, almenos yo ya la descarte, pues es mucho el cableado que se tiene que hacer en la escalera.
De todas formas, gracias por el aporte! Exitos!
Bueno, por mi parte, creo que no es esa la mejor solucion. Pero estaria bien ver como te está quedando. Exitos.
darkbytes, puedes usar mejor un ULN2803 para no usar tanto transistor. Tb te falta sus respectivas resistencias de los LEDs. Por otro lado, esa alternativa, almenos yo ya la descarte, pues es mucho el cableado que se tiene que hacer en la escalera.
De todas formas, gracias por el aporte! Exitos!
Bueno, por mi parte, creo que no es esa la mejor solucion. Pero estaria bien ver como te está quedando. Exitos.
“I am illuminating the stairs using 30 independently controlled RGB leds. Control of the LEDs is done using an ATmega328 processor (Arduino) and 6 TLC5940 LED driver ICs. Pressure sensors detect someone going on the staircase and is calibrated to ignore my dog.”