Matriz de led con pic 16f886

#1
Buenos días a todos :apreton: quisiera saber si este código esta funcionando ya que en la simulación si funciona pero a la hora de implementarlo en protoboard no funciona:confused:.
Código:
#include <16F883.h>
#fuses NOWDT         //Deshabilita Watchdog
#fuses RC                //Oscilador RC (Resistencia Capacitor Externos)
#fuses HS                //Modo Full Power de alta Velocidad, hasta 10MHZ, más depende el micro
#fuses LP                //Modo Bajo Consumo hasta 200KHZ
#fuses INTRC         //Cristal Interno RC
#use delay(int=4000000)
#define LARGO 28                      //Longitud de la tabla
int const tabla[LARGO+8]={
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio  
                          0b11111111, //Dato de tabla H
                          0b00010000,
                          0b00010000,
                          0b11111111,
                          0b00000000, //Espacio
                          0b01111110, //Dato de tabla O
                          0b10000001,
                          0b10000001,
                          0b01111110, 
                          0b00000000, //Espacio
                          0b11111111, //Dato de tabla L
                          0b10000000, 
                          0b10000000, 
                          0b00000000, //Espacio
                          0b11111110, //Dato de tabla A
                          0b00010001, 
                          0b00010001, 
                          0b11111110, 
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          };
void main(){
   byte const bitMask[8]={1,2,4,8,16,32,64,128}; //Mascara
   int i,j,k;                         //Variables contadores
   while(TRUE){                       //Ciclo infinito
      for(i=0;i<LARGO+8;i++){         //Recorrido de tabla
         for(k=0;k<20;k++){           //Refresco de matriz
            for(j=0;j<8;j++){         //Barrido de columnas
               output_a(~bitMask[j]); //Columnas ponderadas
               output_b(tabla[j+i]);  //Desplazamiento de tabla
               delay_ms(1);           //Demora de multiplexado
            }   
         }
      }
   }   
}
 
Última edición por un moderador:
#2
todo esto esta mal
#include <16F883.h>
#fuses NOWDT //Deshabilita Watchdog
#fuses RC //Oscilador RC (Resistencia Capacitor Externos)
#fuses HS //Modo Full Power de alta Velocidad, hasta 10MHZ, más depende el micro
#fuses LP //Modo Bajo Consumo hasta 200KHZ
#fuses INTRC //Cristal Interno RC
#use delay(int=4000000)

si es para el 886 deberia ser asi con oscilador interno

#include <16F886.h>

#fuses INTRC_IO //donde aqui marcamos que es interno el reloj

#use delay(clock=8M) //por la hoja de datos nos dice que el reloj interno solo llega a 8 Mhz


mas cuidado con los copy paste muchos autores ponen errores apropocito para que la gente estudie el codigo y no hagan la ley del minomo esfuerzo
 
#4
aca te dejo un videito de un demo con un pic18f4550

para hacer el barrido use un cd4017 "para ahorrar pines" y dibuje usando el puerto B


en realidad hacer eso es muy simple solo debes jugar con el puerto b y dar un clock para dibujar la siguiente fila
 
#7
see mas especifico en la pregunta son un switch es facil
solo lees lo que entra por un pin el que sea

digamos

en codigo:

char secuencia;

while(1)
{
secuencia=input_a();

switch(secuencia)
{
case1:
...
break;

case2:
...
break;

case3:
...
break;


default:
...
break;
}
}


y ya!
 
#8
Digamos que tengo dos secuencias de led una que es parecido al auto fantástico y otro alazar mi duda era como le hago para utilizar solo una secuencia y a la hora de presionar el switch cambie a la otra y siga repitiendo hasta que vuelva a presionar el switch muchas gracias por ayudarme te lo agadezco mucho :apreton: :aplauso:
 
#9
es que como usas el bucle switch preguntas si hiso un cambio o con un if

digamos que tenemos una secuencia 1 y una secuencia 2 con 1 solo boton cambiamos la secuencia

el codigo debemos poner
1 broche que pregunte en que secuencia esta
leer el boton
un bucle infinito while(1)

un if que pregunten en que secuencia e incrementarla si se pasa regresar a la primer secuencia o a ninguna secuencia

un switch que contenga las secuencias


codigo mas o menos asi

char broche=0;

while(1)
{

// debemos leer el boton
if((!input(pin_a3))
{
broche++;
if(broche>=2)
broche=0;
}

switch(broche)
{

case 0:
//ninguna secuencia
break;

case 1:
//secuencia 1
break;


case 2:
//secuencia 2
break;
}

}
 
#10
Excelente explicacion :aplauso: pero tengo una duda y para implementarla en este código como le arria :confused: son mas o menos 9 secuencias diferentes
#include<16f84a.h>
#fuses XT
#fuses NOWDT
#fuses NOPUT
#fuses PUT
#fuses NOPROTECT
#use delay (clock= 4000000)
#use fast_io(B)
int i=0;
Void main()
{
Set_tris_B(0x00); //Configura en o, osea
//se configura como salida
Output_B(0b00000000); //coloca en estado cero el pin,0

While(1)
{
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(300);
output_b(0b10000000);
delay_ms(100);
output_b(0b01000000);
delay_ms(100);
output_b(0b00100000);
delay_ms(100);
output_b(0b00010000);
delay_ms(100);
output_b(0b00001000);
delay_ms(100);
output_b(0b00000100);
delay_ms(100);
output_b(0b00000010);
delay_ms(100);
output_b(0b00000001);
delay_ms(100);
output_b(0b00000000);
delay_ms(200);
output_b(0b00000001);
delay_ms(100);
output_b(0b00000010);
delay_ms(100);
output_b(0b00000100);
delay_ms(100);
output_b(0b00001000);
delay_ms(100);
output_b(0b00010000);
delay_ms(100);
output_b(0b00100000);
delay_ms(100);
output_b(0b01000000);
delay_ms(100);
output_b(0b10000000);
delay_ms(100);
}
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(300);
output_b(0b10000001);
delay_ms(150);
output_b(0b11000011);
delay_ms(150);
output_b(0b11100111);
delay_ms(150);
output_b(0b01111110);
delay_ms(150);
output_b(0b00111100);
delay_ms(150);
output_b(0b00011000);
delay_ms(150);
output_b(0b00000000);
delay_ms(300);
output_b(0b00011000);
delay_ms(150);
output_b(0b00111100);
delay_ms(150);
output_b(0b01111110);
delay_ms(150);
output_b(0b11100111);
delay_ms(150);
output_b(0b11000011);
delay_ms(150);
output_b(0b10000001);
delay_ms(150);
}
for(i=0;i<=9;i++){
output_b(0b00001111);
delay_ms(300);
output_b(0b11110000);
delay_ms(250);
output_b(0b00001111);
delay_ms(250);
output_b(0b11110000);
delay_ms(250);
}
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(200);
output_b(0b01010101);
delay_ms(250);
output_b(0b10101010);
delay_ms(250);
output_b(0b01010101);
delay_ms(250);
output_b(0b10101010);
delay_ms(250);
}
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(400);
output_b(0b00111100);
delay_ms(300);
output_b(0b11000011);
delay_ms(300);
output_b(0b00111100);
delay_ms(300);
}
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(400);
output_b(0b11111111);
delay_ms(400);
}
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(600);
output_b(0b11110000);
delay_ms(500);
}
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(600);
output_b(0b00001111);
delay_ms(500);
}
for(i=0;i<=9;i++){
output_b(0b00000000);
delay_ms(250);
output_b(0b10000000);
delay_ms(200);
output_b(0b01000000);
delay_ms(200);
output_b(0b10100000);
delay_ms(200);
output_b(0b01010000);
delay_ms(200);
output_b(0b10101000);
delay_ms(200);
output_b(0b01010100);
delay_ms(200);
output_b(0b10101010);
delay_ms(200);
output_b(0b01010101);
delay_ms(200);
output_b(0b00101010);
delay_ms(200);
output_b(0b00010101);
delay_ms(200);
output_b(0b00001010);
delay_ms(200);
output_b(0b00000101);
delay_ms(200);
output_b(0b00000010);
delay_ms(200);
output_b(0b00000001);
delay_ms(200);
output_b(0b00000000);
delay_ms(200);
output_b(0b00000001);
delay_ms(200);
output_b(0b00000010);
delay_ms(200);
output_b(0b00000101);
delay_ms(200);
output_b(0b00001010);
delay_ms(200);
output_b(0b00010101);
delay_ms(200);
output_b(0b00101010);
delay_ms(200);
output_b(0b01010101);
delay_ms(200);
output_b(0b10101010);
delay_ms(200);
output_b(0b01010100);
delay_ms(200);
output_b(0b10101000);
delay_ms(200);
output_b(0b01010000);
delay_ms(200);
output_b(0b10100000);
delay_ms(200);
output_b(0b01000000);
delay_ms(200);
output_b(0b10000000);
delay_ms(200);
}
}
}
 
#11
tus secuencias deben ir dentro de los cases

y dios mio cuantos delay!!!

nimodo eso debe corregirse pues los delay no permiten leer los botones en tiempo real
 
#12
Disculpa pero a la hora de compilar me tira varios errores entre ellos estan a numeric expression, must appear here, undefined identifier broche, expecting a close paren si me pudieras explicar por que me da estos errores te agradecería mucho
 
#17
no pues todo esta mal


case (1):{
//secuencia 1
break;
output_b(0b00000000);
delay_ms(600);
output_b(0b00001111);
delay_ms(500);
}

eso esta mal

en un case

va asi

case 1:

//tu codigo

break;

sin corchetes
 
#19
lo revisare con tiempo no te preocupes cualquier error lo corrijo



ya esta correjido que pesimo para mi gusto pero es una ayudadita

en realidad esta mal meter tanto delay pues el micro se atonta y se atora hasta que termina el delay es decir no podra leer el boton hasta que la secuencia acabe, falta antirrebote y es un pic16f84a
yo usaria el pic16f716 o el 16f88, pero en gustos se rompen generos. :unsure:


terminado y pulido ;) en el proteus usa las ledbar para no poner tanto led, usa resistencias pues no va a simular correctamente y yo te aconsejo que el cuando pongas push usa los toggle que se encuentran en la parte de DEBUG tools.
 

Adjuntos

Última edición:
Arriba