Autor Tema: Duda Pulse  (Leído 2903 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado midq21

  • PIC10
  • *
  • Mensajes: 9
Duda Pulse
« en: 03 de Febrero de 2018, 22:33:20 »
Buen día/tarde/noche grupo. Soy nuevo en el foro y en el mundo de los PIC espero poder en un tiempo estar al nivel adecuado, por mientras a aprender  :-/
 Tengo una pequeña duda en este código,  la idea principal es realizar una suma y arrojarla en una matriz 8x8, pero esta suma se hace paso por paso cuando se presiona un Pulsador. Este mismo esta conectado al pin A6 del pic18f4550. Mi pensamiento fue el siguiente: Con la ayuda de un contador cada vez que este pin entrada/leyera un "0"  el mismo se incrementaría, dando así paso al llamado de las distintas funciones que realicen una acción correspondiente. Mi problema es que no logro de ninguna manera que el puerto lea el " 0 lógico" , Creo que porque el pulsador es demasiado rápido y no se alcanza a leer, decidi cambiarlo por un SW solo para probar pero en el mismo no importa si su estado es 0 o 1, simplemente la matriz se enciende y no  hace, ni me permite hacer mas nada. Si porfavor me pueden dar algunas indicaciones o tips sobre lecturas en un determinado puerto con pulsador. Les dejo el código que he hecho.  Gracias de ante mano.
Hay misterios en el universo que no nos corresponde resolver. Pero quienes somos y por qué estamos aquí no figuran entre ellos

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:Duda Pulse
« Respuesta #1 en: 04 de Febrero de 2018, 00:18:57 »
Que FUSES estas usando ? Ese PIN unicamente se vuelve RA6 en caso de estar usando cualquiera de estos 3 tipos de oscilador: ECIO, ECPIO and INTIO. El cual INTIO seria el oscilador interno

Por otro lado no entiendo a que te referis con "paso a paso", ¿Podrias hacer una explicacion mas detallada? Por ejemplo:

Los numeros los tomas desde el puerto B en formato binario, al presionar A6 tomas ese dato, y luego cuando presionas de vuelta A6 tenes el otro dato. Algo asi... que se explique el paso a paso.

Desconectado midq21

  • PIC10
  • *
  • Mensajes: 9
Re:Duda Pulse
« Respuesta #2 en: 04 de Febrero de 2018, 10:34:09 »
Que FUSES estas usando ? Ese PIN unicamente se vuelve RA6 en caso de estar usando cualquiera de estos 3 tipos de oscilador: ECIO, ECPIO and INTIO. El cual INTIO seria el oscilador interno

Por otro lado no entiendo a que te referis con "paso a paso", ¿Podrias hacer una explicacion mas detallada? Por ejemplo:

Los numeros los tomas desde el puerto B en formato binario, al presionar A6 tomas ese dato, y luego cuando presionas de vuelta A6 tenes el otro dato. Algo asi... que se explique el paso a paso.

Buen dia amigo, no estoy usando ningún fuse, investigue un poco sobre esto y no vi la necesidad de llamarlos.
Por otro lado el programa hace lo siguiente : Arrancando el programa se mantiene apagado//Se hace una pulsación y se lee y muestra el dato que esta en un Dsw2//se hace otra pulsación y muestra el signo de suma//Se hace otra pulsación y se lee y muestra el dato que esta en un Dsw1// se hace otra pulsación y muestra el signo de igualdad// se hace otra pulsación y muestra el resultado de la suma en hexadecimal//si se presiona una 6ta vez el pulsador regresa a su estado original. En total son 5 pulsaciones,  Este pulsador esta en el puerto RA6 y se activa cuando ve un "0 lógico" y manda hacer cada instrucción, por eso mi idea fue hace un contador global y cada vez que por el puerto RA6 se viera ese "0" mandara a incrementar el contador y segun lleve su cuenta sea "1, 2 ,.."  llame a alguna función determinada.
Hay misterios en el universo que no nos corresponde resolver. Pero quienes somos y por qué estamos aquí no figuran entre ellos

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:Duda Pulse
« Respuesta #3 en: 04 de Febrero de 2018, 11:48:16 »
Perfecto. Respecto al pulsador, seguramente tengas algo mal, Ejemplo FAST_IO se usan los puertos y no los nombres de los pines, ademas tenes siempre la OBLIGACION de setear los FUSES correctos, vos pusiste que tenes un clock de 10Mhz, pero si posees un clock de 10Mhz significa que tenes un cristal puesto. Un cristal te estaria usando el pin de RA6 ya que comparte el mismo pin que para los cristales, por eso mismo si uno quiere usar RA6 debe seleccionar el oscilador interno INTIO, y la frecuencia seguramente sea de 8Mhz.


Te voy a corregir un poco la forma de realizar el programa, para que no exista tanto codigo repetido y se vuelva mas facil de realizarlo/leerlo.

Primero... vamos al Main, estamos intentando resumir todo.. El main propuesto es este:

Código: C
  1. void main(void)
  2. {
  3.         int1 verif;
  4.         int1 valoranteriorverif = 1;
  5.         int8 estado = 0;
  6.         int8 valorAmostrar = APAGADO;
  7.  
  8.         setup_adc_ports(NO_ANALOGS);
  9.         set_tris_a(0xFF);
  10.         set_tris_b(0x00);
  11.         set_tris_d(0x00);
  12.  
  13.         while(true)
  14.         {
  15.                 verif=input(PIN_A6);
  16.                 if(verif != valoranteriorverif)  // Distinto de la ultima ves que paso, y tiene que ser igual a 0
  17.                 {
  18.                         if(verif == 0)
  19.                         {
  20.                                 switch(estado)
  21.                                 {
  22.                                 case 0:
  23.                                         dsw2=input_A()&0b00000111;
  24.                                         valorAmostrar = dsw2;
  25.                                         estado++;
  26.                                         break;
  27.                                 case 1:
  28.                                         valorAmostrar = SUMA;
  29.                                         estado++;
  30.                                         break;
  31.                                 case 2:
  32.                                         dsw1 = (input_a()&0b00111000) >> 3;
  33.                                         valorAmostrar = dsw1;
  34.                                         estado++;
  35.                                         break;
  36.                                 case 3:
  37.                                         valorAmostrar = IGUAL;
  38.                                         estado++;
  39.                                         break;
  40.                                 case 4:
  41.                                         valorAmostrar = dsw1+dsw2;
  42.                                         estado++;
  43.                                         break;
  44.                                 case 5:
  45.                                         valorAmostrar = APAGADO;
  46.                                         estado = 0;
  47.                                         break;
  48.                                 }
  49.                         }
  50.                         valoranteriorverif = verif;     // Proteccion para que no entre 2 veces
  51.                 }
  52.                 Mostrar(valorAmostrar);
  53.         }
  54. }

Observaras que esto reduce MUCHO la complejidad del codigo, tanto dsw1 como dsw2 van a ser numeros de 0x0 a 0x7, ya que le hicimos una rotacion, y siempre le pasamos el valor que queremos mostrar a la funcion "Mostrar"

Ahora.. ¿como es que seleccionamos de esa funcion cual es nuestro valor?, bueno aca necesitamos de declarar mejor el array, no tenerlos en array independientes. Voy a hacerlo de esta forma:

Código: C
  1. #DEFINE         MATMOV  16
  2. #DEFINE         SUMA    17
  3. #DEFINE         IGUAL   18
  4. #DEFINE         APAGADO 19
  5.  
  6.  
  7. const int NumerosMatriz[20][8]=
  8.                         {
  9.                                 {0b00000000,0b00111100,0b01111110,0b11000011,0b11000011,0b01111110,0b00111100,0b00000000},      // Numero 0
  10.                                 {0b00000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11001110,0b11001000,0b00000000},      // Numero 1
  11.                                 {0b00000000,0b00000000,0b11111110,0b11111110,0b11110110,0b11110110,0b00000000,0b00000000},      // Numero 2
  12.                                 {0b00000000,0b11111111,0b11111111,0b11011011,0b11011011,0b11011011,0b11011011,0b00000000},      // Numero 3
  13.                                 {},                                                                                             // Numero 4
  14.                                 {},                                                                                             // Numero 5
  15.                                 {},                                                                                             // Numero 6
  16.                                 {},                                                                                             // Numero 7
  17.                                 {},                                                                                             // Numero 8
  18.                                 {},                                                                                             // Numero 9
  19.                                 {},                                                                                             // Numero A
  20.                                 {},                                                                                             // Numero B
  21.                                 {},                                                                                             // Numero C
  22.                                 {},                                                                                             // Numero D
  23.                                 {},                                                                                             // Numero E
  24.                                 {},                                                                                             // Numero F
  25.                                 {0b00000001,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b10000000},      // Matriz Movimiento
  26.                                 {0b00011000,0b00011000,0b00011000,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000},      // Signo Suma
  27.                                 {0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110},      // Signo igual
  28.                                 {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000}       // APAGADO
  29.                         };

Observaras que si yo le paso un 0 para mostrar, deberia utilizar el array NumerosMatriz[0][8], si le paso una 0xA, deberia usar: NumerosMatriz[0xA][8], el problema esta tambien en los signos.
Puede que CCS te de error el "identado" que propuse, pero deberia esta bien el array. No puse los valores de los demas numeros, eso te lo dejo a vos... Observa que arriba use unos DEFINE con el numero de indice de cada signo especial. Mientras que cualquier numero que se pase, va a ser el indice correcto. Ahora la funcion va a ser MUCHO mas simple que antes:

Código: C
  1. void Mostrar(int8 valor)                    
  2. {
  3.         for(k=0;k<8;k++)
  4.         {
  5.                 output_B(NumeroMatriz[valor][k]);
  6.                 output_D(NumeroMatriz[MATMOV][k]);
  7.                 delay_ms(5);
  8.         }
  9.         set_tris_D(0);
  10. }

Solo modifique tu funcion, asi que puede tener sus defectos. Personalmente lo haria con un Timer/interrupción para actualizar el estado. Y entonces tu programa solo se preocupa en actualizar un solo valor. Es decir la interrupcion que ocurra cada 5ms por ejemplo, y que active un comun, y ponga el dato que corresponde solo. Eso va a estar marchando automaticamente y siempre. Nosotros unicamente vamos a actualizar el valor a mostrar y luego la interrupcion se va a encargar de todo lo demas.

En fin... Ese es todo tu programa... falta agregarle los FUSES correctos, como te decia necesitas  ponerlo como INTIO para usar RA6.

Código: C
  1. #include <C:\Program Files\PICC\Devices\18F4550.h>
  2. #use delay (clock=1000000)
  3. #use fast_io(A)
  4. #use fast_io(B)
  5. #use fast_io(D)
  6.  
  7. int dsw2=0,dsw1=0, resulta;     // j es el contador global, k es la variable que controlara el movimiento de las matriz
  8.  
  9. //------------------------------------------------------------------------------------------
  10. // combinacion de numeros y letras de matriz
  11.  
  12. #DEFINE         MATMOV  16
  13. #DEFINE         SUMA    17
  14. #DEFINE         IGUAL   18
  15. #DEFINE         APAGADO 19
  16.  
  17.  
  18. const int NumerosMatriz[20][8]=
  19.                         {
  20.                                 {0b00000000,0b00111100,0b01111110,0b11000011,0b11000011,0b01111110,0b00111100,0b00000000},      // Numero 0
  21.                                 {0b00000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11001110,0b11001000,0b00000000},      // Numero 1
  22.                                 {0b00000000,0b00000000,0b11111110,0b11111110,0b11110110,0b11110110,0b00000000,0b00000000},      // Numero 2
  23.                                 {0b00000000,0b11111111,0b11111111,0b11011011,0b11011011,0b11011011,0b11011011,0b00000000},      // Numero 3
  24.                                 {},                                                                                             // Numero 4
  25.                                 {},                                                                                             // Numero 5
  26.                                 {},                                                                                             // Numero 6
  27.                                 {},                                                                                             // Numero 7
  28.                                 {},                                                                                             // Numero 8
  29.                                 {},                                                                                             // Numero 9
  30.                                 {},                                                                                             // Numero A
  31.                                 {},                                                                                             // Numero B
  32.                                 {},                                                                                             // Numero C
  33.                                 {},                                                                                             // Numero D
  34.                                 {},                                                                                             // Numero E
  35.                                 {},                                                                                             // Numero F
  36.                                 {0b00000001,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b10000000},      // Matriz Movimiento
  37.                                 {0b00011000,0b00011000,0b00011000,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000},      // Signo Suma
  38.                                 {0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110},      // Signo igual
  39.                                 {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000}       // APAGADO
  40.                         };
  41.  
  42.  
  43. void Mostrar(int8 valor)                    
  44. {
  45.         for(k=0;k<8;k++)
  46.         {
  47.                 output_B(NumeroMatriz[valor][k]);
  48.                 output_D(NumeroMatriz[MATMOV][k]);
  49.                 delay_ms(5);
  50.         }
  51.         set_tris_D(0);
  52. }
  53.  
  54.  
  55. void main(void)
  56. {
  57.         int1 verif;
  58.         int1 valoranteriorverif = 1;
  59.         int8 estado = 0;
  60.         int8 valorAmostrar = APAGADO;
  61.  
  62.         setup_adc_ports(NO_ANALOGS);
  63.         set_tris_a(0xFF);
  64.         set_tris_b(0x00);
  65.         set_tris_d(0x00);
  66.  
  67.         while(true)
  68.         {
  69.                 verif=input(PIN_A6);
  70.                 if(verif != valoranteriorverif)  // Distinto de la ultima ves que paso, y tiene que ser igual a 0
  71.                 {
  72.                         if(verif == 0)
  73.                         {
  74.                                 switch(estado)
  75.                                 {
  76.                                 case 0:
  77.                                         dsw2=input_A()&0b00000111;
  78.                                         valorAmostrar = dsw2;
  79.                                         estado++;
  80.                                         break;
  81.                                 case 1:
  82.                                         valorAmostrar = SUMA;
  83.                                         estado++;
  84.                                         break;
  85.                                 case 2:
  86.                                         dsw1 = (input_a()&0b00111000) >> 3;
  87.                                         valorAmostrar = dsw1;
  88.                                         estado++;
  89.                                         break;
  90.                                 case 3:
  91.                                         valorAmostrar = IGUAL;
  92.                                         estado++;
  93.                                         break;
  94.                                 case 4:
  95.                                         valorAmostrar = dsw1+dsw2;
  96.                                         estado++;
  97.                                         break;
  98.                                 case 5:
  99.                                         valorAmostrar = APAGADO;
  100.                                         estado = 0;
  101.                                         break;
  102.                                 }
  103.                         }
  104.                         valoranteriorverif = verif;     // Proteccion para que no entre 2 veces
  105.                 }
  106.                 Mostrar(valorAmostrar);
  107.         }
  108. }

PD: los delays estan fuera de escala por eso quite bastante. Especialmente cuando mostrabas, ya que eran 2 segundos!!! 50 * 8 * 5ms, en que tu programa NO respondia a nada, debido a que estaba mostrando en el display
« Última modificación: 04 de Febrero de 2018, 12:03:07 por KILLERJC »

Desconectado midq21

  • PIC10
  • *
  • Mensajes: 9
Re:Duda Pulse
« Respuesta #4 en: 05 de Febrero de 2018, 11:10:01 »
Perfecto. Respecto al pulsador, seguramente tengas algo mal, Ejemplo FAST_IO se usan los puertos y no los nombres de los pines, ademas tenes siempre la OBLIGACION de setear los FUSES correctos, vos pusiste que tenes un clock de 10Mhz, pero si posees un clock de 10Mhz significa que tenes un cristal puesto. Un cristal te estaria usando el pin de RA6 ya que comparte el mismo pin que para los cristales, por eso mismo si uno quiere usar RA6 debe seleccionar el oscilador interno INTIO, y la frecuencia seguramente sea de 8Mhz.


Te voy a corregir un poco la forma de realizar el programa, para que no exista tanto codigo repetido y se vuelva mas facil de realizarlo/leerlo.

Primero... vamos al Main, estamos intentando resumir todo.. El main propuesto es este:

Código: C
  1. void main(void)
  2. {
  3.         int1 verif;
  4.         int1 valoranteriorverif = 1;
  5.         int8 estado = 0;
  6.         int8 valorAmostrar = APAGADO;
  7.  
  8.         setup_adc_ports(NO_ANALOGS);
  9.         set_tris_a(0xFF);
  10.         set_tris_b(0x00);
  11.         set_tris_d(0x00);
  12.  
  13.         while(true)
  14.         {
  15.                 verif=input(PIN_A6);
  16.                 if(verif != valoranteriorverif)  // Distinto de la ultima ves que paso, y tiene que ser igual a 0
  17.                 {
  18.                         if(verif == 0)
  19.                         {
  20.                                 switch(estado)
  21.                                 {
  22.                                 case 0:
  23.                                         dsw2=input_A()&0b00000111;
  24.                                         valorAmostrar = dsw2;
  25.                                         estado++;
  26.                                         break;
  27.                                 case 1:
  28.                                         valorAmostrar = SUMA;
  29.                                         estado++;
  30.                                         break;
  31.                                 case 2:
  32.                                         dsw1 = (input_a()&0b00111000) >> 3;
  33.                                         valorAmostrar = dsw1;
  34.                                         estado++;
  35.                                         break;
  36.                                 case 3:
  37.                                         valorAmostrar = IGUAL;
  38.                                         estado++;
  39.                                         break;
  40.                                 case 4:
  41.                                         valorAmostrar = dsw1+dsw2;
  42.                                         estado++;
  43.                                         break;
  44.                                 case 5:
  45.                                         valorAmostrar = APAGADO;
  46.                                         estado = 0;
  47.                                         break;
  48.                                 }
  49.                         }
  50.                         valoranteriorverif = verif;     // Proteccion para que no entre 2 veces
  51.                 }
  52.                 Mostrar(valorAmostrar);
  53.         }
  54. }

Observaras que esto reduce MUCHO la complejidad del codigo, tanto dsw1 como dsw2 van a ser numeros de 0x0 a 0x7, ya que le hicimos una rotacion, y siempre le pasamos el valor que queremos mostrar a la funcion "Mostrar"

Ahora.. ¿como es que seleccionamos de esa funcion cual es nuestro valor?, bueno aca necesitamos de declarar mejor el array, no tenerlos en array independientes. Voy a hacerlo de esta forma:

Código: C
  1. #DEFINE         MATMOV  16
  2. #DEFINE         SUMA    17
  3. #DEFINE         IGUAL   18
  4. #DEFINE         APAGADO 19
  5.  
  6.  
  7. const int NumerosMatriz[20][8]=
  8.                         {
  9.                                 {0b00000000,0b00111100,0b01111110,0b11000011,0b11000011,0b01111110,0b00111100,0b00000000},      // Numero 0
  10.                                 {0b00000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11001110,0b11001000,0b00000000},      // Numero 1
  11.                                 {0b00000000,0b00000000,0b11111110,0b11111110,0b11110110,0b11110110,0b00000000,0b00000000},      // Numero 2
  12.                                 {0b00000000,0b11111111,0b11111111,0b11011011,0b11011011,0b11011011,0b11011011,0b00000000},      // Numero 3
  13.                                 {},                                                                                             // Numero 4
  14.                                 {},                                                                                             // Numero 5
  15.                                 {},                                                                                             // Numero 6
  16.                                 {},                                                                                             // Numero 7
  17.                                 {},                                                                                             // Numero 8
  18.                                 {},                                                                                             // Numero 9
  19.                                 {},                                                                                             // Numero A
  20.                                 {},                                                                                             // Numero B
  21.                                 {},                                                                                             // Numero C
  22.                                 {},                                                                                             // Numero D
  23.                                 {},                                                                                             // Numero E
  24.                                 {},                                                                                             // Numero F
  25.                                 {0b00000001,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b10000000},      // Matriz Movimiento
  26.                                 {0b00011000,0b00011000,0b00011000,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000},      // Signo Suma
  27.                                 {0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110},      // Signo igual
  28.                                 {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000}       // APAGADO
  29.                         };

Observaras que si yo le paso un 0 para mostrar, deberia utilizar el array NumerosMatriz[0][8], si le paso una 0xA, deberia usar: NumerosMatriz[0xA][8], el problema esta tambien en los signos.
Puede que CCS te de error el "identado" que propuse, pero deberia esta bien el array. No puse los valores de los demas numeros, eso te lo dejo a vos... Observa que arriba use unos DEFINE con el numero de indice de cada signo especial. Mientras que cualquier numero que se pase, va a ser el indice correcto. Ahora la funcion va a ser MUCHO mas simple que antes:

Código: C
  1. void Mostrar(int8 valor)                    
  2. {
  3.         for(k=0;k<8;k++)
  4.         {
  5.                 output_B(NumeroMatriz[valor][k]);
  6.                 output_D(NumeroMatriz[MATMOV][k]);
  7.                 delay_ms(5);
  8.         }
  9.         set_tris_D(0);
  10. }

Solo modifique tu funcion, asi que puede tener sus defectos. Personalmente lo haria con un Timer/interrupción para actualizar el estado. Y entonces tu programa solo se preocupa en actualizar un solo valor. Es decir la interrupcion que ocurra cada 5ms por ejemplo, y que active un comun, y ponga el dato que corresponde solo. Eso va a estar marchando automaticamente y siempre. Nosotros unicamente vamos a actualizar el valor a mostrar y luego la interrupcion se va a encargar de todo lo demas.

En fin... Ese es todo tu programa... falta agregarle los FUSES correctos, como te decia necesitas  ponerlo como INTIO para usar RA6.

Código: C
  1. #include <C:\Program Files\PICC\Devices\18F4550.h>
  2. #use delay (clock=1000000)
  3. #use fast_io(A)
  4. #use fast_io(B)
  5. #use fast_io(D)
  6.  
  7. int dsw2=0,dsw1=0, resulta;     // j es el contador global, k es la variable que controlara el movimiento de las matriz
  8.  
  9. //------------------------------------------------------------------------------------------
  10. // combinacion de numeros y letras de matriz
  11.  
  12. #DEFINE         MATMOV  16
  13. #DEFINE         SUMA    17
  14. #DEFINE         IGUAL   18
  15. #DEFINE         APAGADO 19
  16.  
  17.  
  18. const int NumerosMatriz[20][8]=
  19.                         {
  20.                                 {0b00000000,0b00111100,0b01111110,0b11000011,0b11000011,0b01111110,0b00111100,0b00000000},      // Numero 0
  21.                                 {0b00000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11001110,0b11001000,0b00000000},      // Numero 1
  22.                                 {0b00000000,0b00000000,0b11111110,0b11111110,0b11110110,0b11110110,0b00000000,0b00000000},      // Numero 2
  23.                                 {0b00000000,0b11111111,0b11111111,0b11011011,0b11011011,0b11011011,0b11011011,0b00000000},      // Numero 3
  24.                                 {},                                                                                             // Numero 4
  25.                                 {},                                                                                             // Numero 5
  26.                                 {},                                                                                             // Numero 6
  27.                                 {},                                                                                             // Numero 7
  28.                                 {},                                                                                             // Numero 8
  29.                                 {},                                                                                             // Numero 9
  30.                                 {},                                                                                             // Numero A
  31.                                 {},                                                                                             // Numero B
  32.                                 {},                                                                                             // Numero C
  33.                                 {},                                                                                             // Numero D
  34.                                 {},                                                                                             // Numero E
  35.                                 {},                                                                                             // Numero F
  36.                                 {0b00000001,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b10000000},      // Matriz Movimiento
  37.                                 {0b00011000,0b00011000,0b00011000,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000},      // Signo Suma
  38.                                 {0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110,0b01100110},      // Signo igual
  39.                                 {0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000}       // APAGADO
  40.                         };
  41.  
  42.  
  43. void Mostrar(int8 valor)                    
  44. {
  45.         for(k=0;k<8;k++)
  46.         {
  47.                 output_B(NumeroMatriz[valor][k]);
  48.                 output_D(NumeroMatriz[MATMOV][k]);
  49.                 delay_ms(5);
  50.         }
  51.         set_tris_D(0);
  52. }
  53.  
  54.  
  55. void main(void)
  56. {
  57.         int1 verif;
  58.         int1 valoranteriorverif = 1;
  59.         int8 estado = 0;
  60.         int8 valorAmostrar = APAGADO;
  61.  
  62.         setup_adc_ports(NO_ANALOGS);
  63.         set_tris_a(0xFF);
  64.         set_tris_b(0x00);
  65.         set_tris_d(0x00);
  66.  
  67.         while(true)
  68.         {
  69.                 verif=input(PIN_A6);
  70.                 if(verif != valoranteriorverif)  // Distinto de la ultima ves que paso, y tiene que ser igual a 0
  71.                 {
  72.                         if(verif == 0)
  73.                         {
  74.                                 switch(estado)
  75.                                 {
  76.                                 case 0:
  77.                                         dsw2=input_A()&0b00000111;
  78.                                         valorAmostrar = dsw2;
  79.                                         estado++;
  80.                                         break;
  81.                                 case 1:
  82.                                         valorAmostrar = SUMA;
  83.                                         estado++;
  84.                                         break;
  85.                                 case 2:
  86.                                         dsw1 = (input_a()&0b00111000) >> 3;
  87.                                         valorAmostrar = dsw1;
  88.                                         estado++;
  89.                                         break;
  90.                                 case 3:
  91.                                         valorAmostrar = IGUAL;
  92.                                         estado++;
  93.                                         break;
  94.                                 case 4:
  95.                                         valorAmostrar = dsw1+dsw2;
  96.                                         estado++;
  97.                                         break;
  98.                                 case 5:
  99.                                         valorAmostrar = APAGADO;
  100.                                         estado = 0;
  101.                                         break;
  102.                                 }
  103.                         }
  104.                         valoranteriorverif = verif;     // Proteccion para que no entre 2 veces
  105.                 }
  106.                 Mostrar(valorAmostrar);
  107.         }
  108. }

PD: los delays estan fuera de escala por eso quite bastante. Especialmente cuando mostrabas, ya que eran 2 segundos!!! 50 * 8 * 5ms, en que tu programa NO respondia a nada, debido a que estaba mostrando en el display

Muchísimas gracias amigo, ayer estudie al detalle tu codigo, mi error general creo que era el que comentabas al principio. Estaba usando el puerto RA6 para un cristal, lo cual no era así, de la misma forma me faltaba llamar el fuse para trabajar con el oscilador interno el cual es: #fuse INTRC_IO   y asi mismo declare  #use delay(internal=8M), con estos datos y usando las funciones  "set_tris_X" Se puede leer perfectamente la pulsación y asi lograr los cambios correspondientes. A pesar de que optimizaste al máximo el código tome solo estos detalles y los otros los guardare para posibles ideas, ya que, se nota que mi nivel de programación es algo(por no decir muy muy :oops: ) bajo y se que para ser el primer proyecto en pic, se tengas errores de esta clase. Siempre tener en cuenta la optimizacion del código eso si. Tengo una duda en esta lectura input_A()&0b00111000) >> 3;  No entiendo muy bien el porque ">>3" Se debe a la posición de la lectura ya que los puertos van del RA0 al RA6, y como estoy entrando un dato binario y usando mascara para leer justamente eso el dato no se lee bien, es como por decir una corrección de la lectura, pero hasta hay se.Otra duda es saber si existe un forma de hacer que el delay sea el exacto para poder visualizar el numero/letra, ya que, si los quito me la muestra apresuradamente y colocando un delay(500...100....2..1) no logro sino en los 2 ultimo ver parte del numero/letra mas no completo.  Muchas Gracias. 
« Última modificación: 05 de Febrero de 2018, 11:56:44 por midq21 »
Hay misterios en el universo que no nos corresponde resolver. Pero quienes somos y por qué estamos aquí no figuran entre ellos

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:Duda Pulse
« Respuesta #5 en: 05 de Febrero de 2018, 13:51:16 »
Citar
A pesar de que optimizaste al máximo el código tome solo estos detalles y los otros los guardare para posibles ideas, ya que, se nota que mi nivel de programación es algo(por no decir muy muy :oops: ) bajo y se que para ser el primer proyecto en pic, se tengas errores de esta clase.

Nadie nacio sabiendo, todo se gana con la practica, si ves que en tu codigo tenes muchas veces repetido un mismo pedazo de codigo (la misma forma) pero distintas variables, quiere decir que existe alguna forma de mejorarlo.

Una cosa que no nombre es que al array con los numeros, le agregue el "const" en su definicion, esto es para que el compilador sepa que como es constante y no se va a modificar, lo ponga en la FLASH, sino debe ponerlo en la RAM, y para eso necesita tener los valores en la FLASH para luego pasarlos a la RAM, en resumen, terminas ocupando RAM y sin querer espacio de FLASH, con el "const" le digo que lo ponga en la FLASH y que tome de alli los valores.

Citar
Tengo una duda en esta lectura input_A()&0b00111000) >> 3;  No entiendo muy bien el porque ">>3" Se debe a la posición de la lectura ya que los puertos van del RA0 al RA6, y como estoy entrando un dato binario y usando mascara para leer justamente eso el dato no se lee bien, es como por decir una corrección de la lectura, pero hasta hay se.

Mas que una correccion, lo que busco obtener yo es un numero de 0 a 7 de esos 3 bits. El problema que se encuentran desde el bit 3 al 5, Cuando hago la AND siguen quedando en esas posiciones. es decir:

PORTA = xxaa axxx   (x los valores que quiero quitar, y a los valores que me interesan)
Hago la AND con 0011 1000
El resultado es: 00aa a000
Haciendo un desplazamiento a la derecha 3 veces " >> 3 " hago que esos bits queden asi: 0000 0aaa

Ahora si ambos valores son numeros de 0 a 7, y sumarlos es viable y facilmente como podes ver.

Citar
Otra duda es saber si existe un forma de hacer que el delay sea el exacto para poder visualizar el numero/letra, ya que, si los quito me la muestra apresuradamente y colocando un delay(500...100....2..1) no logro sino en los 2 ultimo ver parte del numero/letra mas no completo.  Muchas Gracias.

Los delays son un gran problema, la idea siempre es minimizar su uso, asi como esta realizado el programa, implica que cualquier cosa que pongas en tu loop principal va a afectar en el tiempo que se muestra. Antes vos lo tenias para que muestre por 2 segundos en los cuales mientras muestra NO se puede ejecutar nada, terminado eso lee los botones y se encierra nuevamente al mostrar y eso es un problema. Que pasaria si en tu codigo de los botones tenes un delay de 1s, eso significa que tendrias 2s mostrandose y 1s sin mostrar, y vuelve a repetirse, se ve ahora el problema?

¿Cual es la mejor solucion para esto?
Independizar los tiempos. Usar un Timer, este Timer lo configuras para que cada 5ms por ejemplo llame a una funcion (que es la de interrupcion) entonces, cuando es el momento de actualizar el display lo hace por mas que estaba ejecutando cualquier cosa dentro del loop infinito. En realidad deja en pausa el loop infinito y atiende la interrupcion. Pero como la rutina de interrupcion es rapida parece como si estuviera ejecutandose simultaneamente.

El codigo quedaria algo asi:

Código: C
  1. #INT_TMR1
  2. void interrupcion_tmr1(void)
  3. {
  4.         set_timer_1(0);                         // Valor a determinar, por ahora ponemos 0
  5.         output_B(NumeroMatriz[valorAmostrar][k]);
  6.         output_D(NumeroMatriz[MATMOV][k]);
  7.         k++;
  8.         if(k==8) { k=0;}                        // Si se paso que vuelva a comenzar
  9. }

Y en tu main, unicamente le tendrias que dar inicio al Timer y luego nada mas, la funcion "mostrar" estaria ahi en la interrupcion. Entonces...
Ese codigo se ejecuta cada 5ms (si es que configuramos el Timer para 5ms), por lo tanto no necesitas ningun delay, de querer cambiar el valor a mostrar, en tu loop principal le asignas el valor a la variable "valorAmostrar", obviamente a esa variable hay que hacerla global (declararla fuera del main) y ponerle el volatile (asi obligamos al compilador que siempre lo lea, usalo cuando tengas variables que se usan tanto en la interrupcion como en el main).

Y listo, ahora en tu main no tenes mas la funcion "mostrar", podes poner delays y siempre se va a ver correctamente. Lo unico "complejo" que tiene esto es que tenes que configurar el Timer al comienzo del main ( despues de los set_tris por ejemplo ).
« Última modificación: 05 de Febrero de 2018, 13:54:41 por KILLERJC »

Desconectado midq21

  • PIC10
  • *
  • Mensajes: 9
Re:Duda Pulse
« Respuesta #6 en: 06 de Febrero de 2018, 18:56:18 »
Citar
A pesar de que optimizaste al máximo el código tome solo estos detalles y los otros los guardare para posibles ideas, ya que, se nota que mi nivel de programación es algo(por no decir muy muy :oops: ) bajo y se que para ser el primer proyecto en pic, se tengas errores de esta clase.

Nadie nacio sabiendo, todo se gana con la practica, si ves que en tu codigo tenes muchas veces repetido un mismo pedazo de codigo (la misma forma) pero distintas variables, quiere decir que existe alguna forma de mejorarlo.

Una cosa que no nombre es que al array con los numeros, le agregue el "const" en su definicion, esto es para que el compilador sepa que como es constante y no se va a modificar, lo ponga en la FLASH, sino debe ponerlo en la RAM, y para eso necesita tener los valores en la FLASH para luego pasarlos a la RAM, en resumen, terminas ocupando RAM y sin querer espacio de FLASH, con el "const" le digo que lo ponga en la FLASH y que tome de alli los valores.

Citar
Tengo una duda en esta lectura input_A()&0b00111000) >> 3;  No entiendo muy bien el porque ">>3" Se debe a la posición de la lectura ya que los puertos van del RA0 al RA6, y como estoy entrando un dato binario y usando mascara para leer justamente eso el dato no se lee bien, es como por decir una corrección de la lectura, pero hasta hay se.

Mas que una correccion, lo que busco obtener yo es un numero de 0 a 7 de esos 3 bits. El problema que se encuentran desde el bit 3 al 5, Cuando hago la AND siguen quedando en esas posiciones. es decir:

PORTA = xxaa axxx   (x los valores que quiero quitar, y a los valores que me interesan)
Hago la AND con 0011 1000
El resultado es: 00aa a000
Haciendo un desplazamiento a la derecha 3 veces " >> 3 " hago que esos bits queden asi: 0000 0aaa

Ahora si ambos valores son numeros de 0 a 7, y sumarlos es viable y facilmente como podes ver.

Citar
Otra duda es saber si existe un forma de hacer que el delay sea el exacto para poder visualizar el numero/letra, ya que, si los quito me la muestra apresuradamente y colocando un delay(500...100....2..1) no logro sino en los 2 ultimo ver parte del numero/letra mas no completo.  Muchas Gracias.

Los delays son un gran problema, la idea siempre es minimizar su uso, asi como esta realizado el programa, implica que cualquier cosa que pongas en tu loop principal va a afectar en el tiempo que se muestra. Antes vos lo tenias para que muestre por 2 segundos en los cuales mientras muestra NO se puede ejecutar nada, terminado eso lee los botones y se encierra nuevamente al mostrar y eso es un problema. Que pasaria si en tu codigo de los botones tenes un delay de 1s, eso significa que tendrias 2s mostrandose y 1s sin mostrar, y vuelve a repetirse, se ve ahora el problema?

¿Cual es la mejor solucion para esto?
Independizar los tiempos. Usar un Timer, este Timer lo configuras para que cada 5ms por ejemplo llame a una funcion (que es la de interrupcion) entonces, cuando es el momento de actualizar el display lo hace por mas que estaba ejecutando cualquier cosa dentro del loop infinito. En realidad deja en pausa el loop infinito y atiende la interrupcion. Pero como la rutina de interrupcion es rapida parece como si estuviera ejecutandose simultaneamente.

El codigo quedaria algo asi:

Código: C
  1. #INT_TMR1
  2. void interrupcion_tmr1(void)
  3. {
  4.         set_timer_1(0);                         // Valor a determinar, por ahora ponemos 0
  5.         output_B(NumeroMatriz[valorAmostrar][k]);
  6.         output_D(NumeroMatriz[MATMOV][k]);
  7.         k++;
  8.         if(k==8) { k=0;}                        // Si se paso que vuelva a comenzar
  9. }

Y en tu main, unicamente le tendrias que dar inicio al Timer y luego nada mas, la funcion "mostrar" estaria ahi en la interrupcion. Entonces...
Ese codigo se ejecuta cada 5ms (si es que configuramos el Timer para 5ms), por lo tanto no necesitas ningun delay, de querer cambiar el valor a mostrar, en tu loop principal le asignas el valor a la variable "valorAmostrar", obviamente a esa variable hay que hacerla global (declararla fuera del main) y ponerle el volatile (asi obligamos al compilador que siempre lo lea, usalo cuando tengas variables que se usan tanto en la interrupcion como en el main).

Y listo, ahora en tu main no tenes mas la funcion "mostrar", podes poner delays y siempre se va a ver correctamente. Lo unico "complejo" que tiene esto es que tenes que configurar el Timer al comienzo del main ( despues de los set_tris por ejemplo ).

Perfecto amigo, muchísimas gracias. Tendre todo esos datos presentes siempre.
Hay misterios en el universo que no nos corresponde resolver. Pero quienes somos y por qué estamos aquí no figuran entre ellos