Autor Tema: lecturas y salidas (digitales y analogicas) en lengua c para pic  (Leído 13059 veces)

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

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #60 en: 06 de Abril de 2016, 13:42:08 »
ok enterado oyes una pregunta cual seria la ventaja de usar el timer como temporizador y el dalay ya vi un ejemplo alrato que regrese pongo el codigo

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #61 en: 06 de Abril de 2016, 22:36:47 »
Un delay() lo que hace en realidad es crear codigo que se la pasa saltando y ejecutando instrucciones sin sentido para que se cumple el tiempo. Por lo cual es imposible salir del mismo a no ser que exista una interrupcion que lo saque.

Por otro lado tenemos el timer, el timer va a contar siempre por mas que estes en donde sea el programa, cuando ocurre que se produce el overflow es decir el timer pasa de 0xFF a 0x00 para 8 bits o de 0xFFFF a 0x0000 para 16 bits, se activa el flag de interrupcion, que si esta activa la misma va a entrar a la funcion de interrupcion, ejecutar el codigo de alli y volver..

Código: C
  1. int8 contador;
  2.  
  3. void main(void)
  4. {
  5.          Configura salidas/entradas
  6.          Configura el Timer.
  7.          Activa las interrupciones
  8.  
  9.          while(1)
  10.          {
  11.              delay_ms(500);
  12.              output_toggle(PIN_D1);
  13.          }
  14. }
  15.  
  16. #INT_TIMER1
  17. void  TIMER1_isr(void)
  18. {
  19.           set_timer1(0x0000);        //Cargar el timer 1 con el valor correspondiente
  20.           if ( contador == 2)
  21.           {
  22.                  output_toggle(PIN_D0);
  23.                  contador = 0;
  24.           }
  25. }

Supongamos ese codigo. Vos cargaste tu timer para que la interrupcion se produzca cada 250ms ( 0.25s ), yo utilize la variable contador para que cuando se cumplan 2 veces la interrupcion recien ahi cambie el estado del pin D0. A su ves en el main en el while hay un delay de 500ms. La interrupcion funciona de la siguiente forma.
Vamos a suponer nuevmante que el programa se esta ejecutando y esta ejecutando el delay de 500ms, pero todavia van 100ms, y ocurrio el overflow del timer. El microcontrolador guarda donde estaba, entra a la interrupcion, ejecuta el codigo, sale y vuelve para hacer los restantes 400ms.

Si lo pensas es como si las cosas se estuvieran ejecutando en paralelo, la idea es que con la interrupcion se atienda rapidamente las cosas y se salga.
Ademas te da otra ventaja, si haces por ejemplo un timer de 0.5s, entonces podes llevar multiples tiempos con fracciones de 0.5s, como la luz o la sirena.
Como podes aplicar esto a lo tuyo ?

En tu main, en ves de activar las salidas, podes directamente decir que la alarma esta disparada y que tenes la luz encendida. Luego en el timer con contadores de cantidad de veces que entra a la interrupcion y con ifs podes actuar.

Código: C
  1. if ( SirenaActiva == 1)
  2. {
  3.         if ( contadorSirena == 60 )                 // 60 * 0.5s = 30s
  4.         {
  5.                  contadorSirena = 0;
  6.                  output_toggle(sirena);
  7.         }
  8. }
  9. else
  10. {
  11.         Sirena = 0;
  12. }
  13.  
  14. if ( LuzActiva == 1)
  15. {
  16.         if ( contadorLuz == 40 )                 // 40 * 0.5s = 20s
  17.         {
  18.                  contadorLuz = 0;
  19.                  output_toggle(Luz);
  20.         }
  21. }
  22. else
  23. {
  24.         Luz = 0;
  25. }

Si comparten tiempo podes juntarlos, y en tu main solo te preocupas por poner a 1 o a 0 esas variables de 1 bit que serian LuzActiva, SirenaActiva.
Y como ves con un solo timer no introduzco ningun delay en medio del main, haciendo que la lectura de los sensores sean mucho mas rapidas. Y que tampoco queden atrapadas en delays.

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #62 en: 06 de Abril de 2016, 23:38:47 »
Excelente poco a poco voy aprendiendo algo mas. Entiendo que los TYME se están ejecutando como de manera independiente y así si sucede algo en algún sensor puede atender  esto jejejeje  y el pic16f877A  veo que tiene 3 TYMES el (0,1,2) jejejeje  que bueno  en estos momentos estoy escribiendo el programa porque lo vi en un video y hay que ver lentamente el video para transcribir el programa en cuanto lo trascriba lo pongo aquí para que lo veas según es un retarde de ½ segundo y le ponen algo que no entendí mucho desbordamiento para que se pueda hacer mas tiempo como 2 min estoy en eso al ratito lo subo lo ves y me le das una explicadita para que me quede mas claro

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #63 en: 07 de Abril de 2016, 01:13:26 »
ya tengo dos programas de TYMER 1 para este pic jejejeje uno de 30 segundos y el otro con desbordamiento para llegar a 2 minutos como ves ahora esto lo tengo que usar en el programa jejejeje como lo meto  :( :shock:  voy analizar lo que me pusiste a ver si lo meto

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #64 en: 07 de Abril de 2016, 01:18:05 »
este es le de 30 segundos es diferente al otro por que este no tiene desbordamiento 
los dos no lo e simulado pero no marcan error voy a simularlo por si las mosca no sea que no aga lo que deve de hacer

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #65 en: 07 de Abril de 2016, 07:26:13 »
A 4 Mhz, cargando 3036 y con preescaler 1:8 , la interrupcion ocurriria cada 0.5s.

El segundo codigo que me pasaste, no es de 30 segundos, es de 0.5s, y el primero que me pasaste son 4 veces 0.5s, es decir 2s y no 2 minutos.

- Para 30 segundos deberia ser 30 / 0.5s = 60 entradas a la interrupcion, con una variable de 8bit podes llevar el contador por que tenes hasta un maximo de 255
- Para 2 minutos = 120 segundos es 120 / 0.5s = 240 entradas a la interrupcion,

Si necesitas mas tiempo entonces vas a necesitar un contador de 16 bits. Ya que como dije antes el maximo de una variable de 8bits es 255

Es ese error que tenes nomas. Otra de las cosas, intenta SIEMPRE cuando trabajes con el timer, poner el seteo del timer primero, es decir:

Código: C
  1. #int_timer1
  2. void time_1(void)
  3. {
  4.   set_timer1(3036);                        //Lo primero!!!
  5.   cont++;
  6.   if(cont==4)
  7.   {
  8.      output_toggle(pin_b0);
  9.      cont=0;
  10.   }
  11. }

Ahora como incorporarlo al programa que tenias es bastante parecido, si lees lo que te dije antes deberias darte cuenta. sino este es un ejemplo:

Código: C
  1. //este programa es para realizar un retardo de 1 segundo mediante timer1, habilitado por un switch
  2. #include<16f877a.h>
  3. #fuses xt,nowdt
  4. #use delay(clock=4000000)
  5.  
  6. int cont = 0;
  7. volatile int1 SalidaActiva = 0;         // Siempre cuando una variable se use en la interrupcion y en el main
  8.                                         // ponela como volatile, esa variable es de 1 bit, 0 o 1.
  9. #int_timer1
  10. void time_1(void)
  11. {
  12.         set_timer1(3036);
  13.         if(SalidaActiva==1)
  14.         {
  15.                 cont++;
  16.                 if(cont==2)
  17.                 {
  18.                         output_toggle(pin_b0);
  19.                         cont=0;
  20.                 }
  21.         }
  22.         else
  23.         {
  24.                 output_low(pin_b0);
  25.         }
  26. }
  27.  
  28. void main(void)
  29. {
  30.         set_tris_b(0b0);                //<- Esto no sirve de nada si no usas FAST_IO(B) !!!
  31.         output_b(0b0);
  32.         setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  33.         set_timer1 (3036);
  34.         enable_interrupts(int_timer1);
  35.         enable_interrupts(global);
  36.         while(true)
  37.         {
  38.                 if(input(PIN_D0))
  39.                 {
  40.                         delay_ms(10);
  41.                         while(input(PIN_D0));
  42.                         SalidaActiva = ~SalidaActiva;           // El negado de SalidaActiva
  43.                 }
  44.         }
  45. }

Algunas cosas que cambie, observa donde inicializo las variables.
Ahora solo queda en vos aplicarlo a tu programa. Una ves que tengas el programa realizado, lo copias y pegas aca. No hace falta que subas el archivo, Para que aparesca en colores en donde tenes las caritas hay un menu despegable que dice "Código", presionas ahi, elegis C, y luego copias el codigo dentro del tag de code ( lo pongo en parentesis pero son corchetes )

Código: [Seleccionar]
(code=c)  Aca tu codigo  (/code)
« Última modificación: 07 de Abril de 2016, 07:29:40 por KILLERJC »

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #66 en: 08 de Abril de 2016, 01:20:55 »
ni idea de cómo meter el código dentro del otro la verdad   :shock: :roll:  :?: :!: :idea:

Apenas cuando me dijiste de los timer los vi y le encontré sentido entonces voy a copiar el código que me diste de ejemplo de hay le pondré a un lado los comentarios esto para que veas que tanto entiendo del código y si es correcto como lo estoy viendo yo el ejemplo de activar un led con un timer necesito entender ese código para ver si así ya lo puedo usar dentro de lo otro por ahora ni idea
« Última modificación: 08 de Abril de 2016, 02:34:55 por nuevo mundo »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #67 en: 08 de Abril de 2016, 09:18:55 »
EL codigo es linea a linea... segui la logica, la interrupcion solo ocurre cuando el timer llega a 0.
Asi que podes pensar como si fueran 2 programas separados, y lo unico que los une es una variable "SalidaActiva".
Me refiero a que con lo unico que se comunican es con esa variable de 1 bit ( normalmente se le llama "flag" o bandera en español )

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #68 en: 08 de Abril de 2016, 15:48:53 »
Código: C
  1. hise asi y nada no iso nada ase solo lo mismo se queda en el delay y no responde a el on of
  2.  
  3. #include <16f877A.h>         //el pic a utilizar es por que solo requiero de pocos recursos para la alarma
  4. #use delay(clock=4000000)   //tiempo del cristal 4 MG
  5. #fuses xt                   //utiliza cristal
  6. #fuses NOWDT                //proteccion perro guardian of
  7. #fuses PUT                  //proteccion para esperar que se estabilise la alimentacion del pic
  8. #use FAST_IO(B)             //utilizo el puerto B
  9. #use FAST_IO(D)             //utilizo el puerto D
  10.  
  11. #define E_ON_OF PIN_B0      //se define que E-ON-OF es el PIN_B0    y  (E-ON-OF) significa Entrada Ensendido Apagad)
  12. #define S_MOV_PAD PIN_B1    //se define que S-MOV-PAD es el PIN_B1  y  (S-MOV-PAD) significa sensor de movimiento patio delantero)
  13. #define S_MOV_PAT PIN_B2    //se define que S-MOV-PAT es el PIN_B2  y  (S-MOV-PAT) significa sensor de movimiento patio trasero)
  14. #define S_MOV_PUD PIN_B3    //se define que S-MOV-PUD es el PIN_B3  y  (S-MOV-PUD) significa sensor de movimiento puerta delantera)
  15. #define S_MOV_PUT PIN_B4    //se define que S-MOV-PUT es el PIN_B4  y  (S-MOV-PUT) significa sensor de movimiento puerta trasera)
  16. #define S_MAG_PUD PIN_B5    //se define que S-MAG-PD es el PIN_B5   y  (S-MAG-PD) significa sensor magnetico puerta delantera)
  17. #define S_MAG_PUT PIN_B5    //se define que S-MAG-PT es el PIN_B6   y  (S-MAG-PT) significa sensor magnetico puerta trasera)
  18. #define LUZ_PAD PIN_D0      //se define que LUZ-PAD es el PIN_D0    y  (LUZ-PAD) significa luz patio delantero
  19. #define LUZ_PAT PIN_D1      //se define que LUZ-PAT es el PIN_D1    y  (LUZ-PAD) significa luz patio trasero
  20. #define SIRENA PIN_D2       //se define que SIRENA es el pin_D2     y  (SIRENA) es la bocina la bulla
  21. #define LLAMAR PIN_D3       //se define que LLAMAR es el pin_D3     y  (LLAMAR) es una salida para realisar una llamada a un cel
  22. #define COLGAR PIN_D4       //se define que COLGAN es el pin_D4     y  (COLGAR) es una salida para colgar la llamada
  23. #define LED_ON_OF PIN_D5    //se define que LED-ON-OF PIN_D5        y  (LED-ON-OF)significa led ensendido apagado
  24.  
  25.  
  26. int cont = 0;
  27. volatile int1 LED_ON_OF = 0;         // Siempre cuando una variable se use en la interrupcion y en el main
  28.  
  29. //int1 E-OF-ON=0;        //declaro la variable (E-ON-OF) a O Y Significa                                (Entrada Ensendido Apagado)
  30. //int1 S_MOV_PAD=0;      //declaro la variable (S-MOV-D) Y le asigno que empiece en O Y Significa       (sensor de Movomiento Delantero)
  31. //int1 S_MOV_PAT=0;      //declaro la variable (S-MOV-T) Y le asigno que empiece en O Y Significa       (sensor de Movomiento Trasero)
  32. //int1 S_MOV_PUD=0;      //declaro la variable (L-D) Y le asigno que empiece en 1 Y Significa           (Laser Delantero)
  33. //int1 S_MOV_PAT=0;      //declaro la variable (L-T) Y le asigno que empiece en 1 Y Significa           (Laser Trasero)
  34. //int1 S_MAG_PUD=1;      //declaro la variable (S-MAG-D) Y le asigno que empiece en 1 Y Significa       (Sensor Magnetico Delantero)
  35. //int1 S_MAG_PUT=1;      //declaro la variable (S-MAG-T) Y le asigno que empiece en 1 Y Significa       (Sensor Magnetico Tracero)
  36. //int1 LUZ_PUD=0;        //declaro la variable (L-PD)  Y le asigno que empiece en O Y Significa         (Luz Patio Delantero)
  37. //int1 LUZ_PUT=0;        //declaro la variable (L-PT)  Y le asigno que empiece en O Y Significa         (Luz Patio Trasero)
  38. //int1 SIRENA=0;         //declaro la variable (SIRENA)  Y le asigno que empiece en O Y Significa       (SIRENA)
  39. //int1 LLAMAR=0;         //declaro la variable (LLAMAR)  Y le asigno que empiece en O Y Significa       (LLAMAR)
  40. //int1 COLGAR=0;         //declaro la variable (COLGAR)  Y le asigno que empiece en O Y Significa       (COLGAR)
  41. //int1 LED_ON_OF=0;      //declaro la variable (LED-ON-OF)  Y le asigno que empiece en O Y Significa    (SIRENA)
  42. #int_timer1
  43. void time_1(void)
  44. {
  45.         set_timer1(3036);
  46.         if(LED_ON_OF==1)
  47.         {
  48.                 cont++;
  49.                 if(cont==2)
  50.                 {
  51.                         output_toggle(LED_ON_OF);
  52.                         cont=0;
  53.                 }
  54.         }
  55.         else
  56.         {
  57.                 output_low(LED_ON_OF);
  58.         }
  59. }
  60.  
  61. void main(void)
  62. {
  63.         set_tris_D(0b0);                //<- Esto no sirve de nada si no usas FAST_IO(B) !!!
  64.         output_D(0b0);
  65.         setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  66.         set_timer1 (3036);
  67.         enable_interrupts(int_timer1);
  68.         enable_interrupts(global);
  69.         while(true)
  70.         {
  71.  
  72.  void main(void){
  73.   output_low(S_MOV_PAD);  //esto lo puse por al simular seme ensendian los pines
  74.   output_low(S_MOV_PUD);  //esto lo puse por al simular seme ensendian los pines
  75.   output_low(LUZ_PAD);    //esto lo puse por al simular seme ensendian los pines
  76.  
  77.             set_tris_B(0b11111111);   //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
  78.             set_tris_D(0b00000000);  // asigno todo el puerto D como salidas
  79.             output_low(E_ON_OF);    //coloco eel pin B0 a cero
  80.  
  81.             while(1)
  82.             {
  83.                     if(input(E_ON_OF)==1)                   // Pregunto si la entrada del pin B0 es igual a 0
  84.                     {
  85.                             delay_ms(10);                   // Espero 10ms por si la llave esta rebotando (variando entre 1 y 0 )
  86.                             while(input(E_ON_OF)==1);       // Espero que suelte el boton, observa el ; al final, es decir un while(){}
  87.                             output_toggle(LED_ON_OF);       // Cambio el valor del pin
  88.  
  89.                     }
  90.  
  91.                     if(input(LED_ON_OF)==1)                  //pregunto si (LED_ON_OF)==1 si es verdad pasa a la siguiente linea
  92.                     {
  93.                             if((input(S_MOV_PAD)==1) || (input(S_MOV_PUD)==1)) //pregunto si el valor del pin (S_MOV_PAD)==1) o (S_MOV_PUD)==1
  94.  
  95.                             {
  96.  
  97.                                     output_high(LUZ_PAD); //ensiendo luz patio trasero
  98.                                     output_high(SIRENA);  //enciende sirena
  99.                                     delay_ms(18000);
  100.                             }
  101.                             else
  102.                             {
  103.                                     output_low(LUZ_PAD); //de lo contrario apaga luz patio trasero
  104.                                     output_low(SIRENA);  //de lo contrario apaga sirena
  105.                             }
  106.                     }
  107.                     else
  108.                     {
  109.                             output_low(LUZ_PAD);  //apagando luz patio delantero
  110.                             output_low(SIRENA);   //apagando sirena
  111.                     }
  112.             }
  113.     }
« Última modificación: 08 de Abril de 2016, 17:25:33 por nuevo mundo »

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #69 en: 08 de Abril de 2016, 17:59:10 »
//lo puse asi menos marca error

#include <16f877A.h>         //el pic a utilizar es por que solo requiero de pocos recursos para la alarma
#use delay(clock=4000000)   //tiempo del cristal 4 MG
#fuses xt                   //utiliza cristal
#fuses NOWDT                //proteccion perro guardian of
#fuses PUT                  //proteccion para esperar que se estabilise la alimentacion del pic
#use FAST_IO(B)             //utilizo el puerto B
#use FAST_IO(D)             //utilizo el puerto D

#define E_ON_OF PIN_B0      //se define que E-ON-OF es el PIN_B0    y  (E-ON-OF) significa Entrada Ensendido Apagad)
#define S_MOV_PAD PIN_B1    //se define que S-MOV-PAD es el PIN_B1  y  (S-MOV-PAD) significa sensor de movimiento patio delantero)
#define S_MOV_PAT PIN_B2    //se define que S-MOV-PAT es el PIN_B2  y  (S-MOV-PAT) significa sensor de movimiento patio trasero)
#define S_MOV_PUD PIN_B3    //se define que S-MOV-PUD es el PIN_B3  y  (S-MOV-PUD) significa sensor de movimiento puerta delantera)
#define S_MOV_PUT PIN_B4    //se define que S-MOV-PUT es el PIN_B4  y  (S-MOV-PUT) significa sensor de movimiento puerta trasera)
#define S_MAG_PUD PIN_B5    //se define que S-MAG-PD es el PIN_B5   y  (S-MAG-PD) significa sensor magnetico puerta delantera)
#define S_MAG_PUT PIN_B5    //se define que S-MAG-PT es el PIN_B6   y  (S-MAG-PT) significa sensor magnetico puerta trasera)
#define LUZ_PAD PIN_D0      //se define que LUZ-PAD es el PIN_D0    y  (LUZ-PAD) significa luz patio delantero
#define LUZ_PAT PIN_D1      //se define que LUZ-PAT es el PIN_D1    y  (LUZ-PAD) significa luz patio trasero
#define SIRENA PIN_D2       //se define que SIRENA es el pin_D2     y  (SIRENA) es la bocina la bulla
#define LLAMAR PIN_D3       //se define que LLAMAR es el pin_D3     y  (LLAMAR) es una salida para realisar una llamada a un cel
#define COLGAR PIN_D4       //se define que COLGAN es el pin_D4     y  (COLGAR) es una salida para colgar la llamada
#define LED_ON_OF PIN_D5    //se define que LED-ON-OF PIN_D5        y  (LED-ON-OF)significa led ensendido apagado

int cont = 0;
volatile int1 SalidaActiva = 0;         // Siempre cuando una variable se use en la interrupcion y en el main       // Siempre cuando una variable se use en la interrupcion y en el main

//int1 E-OF-ON=0;        //declaro la variable (E-ON-OF) a O Y Significa                                (Entrada Ensendido Apagado)
//int1 S_MOV_PAD=0;      //declaro la variable (S-MOV-D) Y le asigno que empiece en O Y Significa       (sensor de Movomiento Delantero)
//int1 S_MOV_PAT=0;      //declaro la variable (S-MOV-T) Y le asigno que empiece en O Y Significa       (sensor de Movomiento Trasero)
//int1 S_MOV_PUD=0;      //declaro la variable (L-D) Y le asigno que empiece en 1 Y Significa           (Laser Delantero)
//int1 S_MOV_PAT=0;      //declaro la variable (L-T) Y le asigno que empiece en 1 Y Significa           (Laser Trasero)
//int1 S_MAG_PUD=1;      //declaro la variable (S-MAG-D) Y le asigno que empiece en 1 Y Significa       (Sensor Magnetico Delantero)
//int1 S_MAG_PUT=1;      //declaro la variable (S-MAG-T) Y le asigno que empiece en 1 Y Significa       (Sensor Magnetico Tracero)
//int1 LUZ_PUD=0;        //declaro la variable (L-PD)  Y le asigno que empiece en O Y Significa         (Luz Patio Delantero)
//int1 LUZ_PUT=0;        //declaro la variable (L-PT)  Y le asigno que empiece en O Y Significa         (Luz Patio Trasero)
//int1 SIRENA=0;         //declaro la variable (SIRENA)  Y le asigno que empiece en O Y Significa       (SIRENA)
//int1 LLAMAR=0;         //declaro la variable (LLAMAR)  Y le asigno que empiece en O Y Significa       (LLAMAR)
//int1 COLGAR=0;         //declaro la variable (COLGAR)  Y le asigno que empiece en O Y Significa       (COLGAR)
//int1 LED_ON_OF=0;      //declaro la variable (LED-ON-OF)  Y le asigno que empiece en O Y Significa    (SIRENA)
main
#int_timer1
void time_1(void)
{
        set_timer1(3036);
        if(SalidaActiva==1)
        {
                cont++;
                if(cont==2)
                {
                        output_toggle(pin_b0);
                        cont=0;
                }
        }
        else
        {
                output_low(pin_b0);
        }
}
 
void main(void)
{
        set_tris_b(0b0);                //<- Esto no sirve de nada si no usas FAST_IO(B) !!!
        output_b(0b0);
        setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
        set_timer1 (3036);
        enable_interrupts(int_timer1);
        enable_interrupts(global);
        while(true)
        {
                if(input(PIN_D0))
                {
                        delay_ms(10);
                        while(input(PIN_D0));
                        SalidaActiva = ~SalidaActiva;           // El negado de SalidaActiva
                }
        }
}

 void main(void){
  output_low(S_MOV_PAD);  //esto lo puse por al simular seme ensendian los pines
  output_low(S_MOV_PUD);  //esto lo puse por al simular seme ensendian los pines
  output_low(LUZ_PAD);    //esto lo puse por al simular seme ensendian los pines

            set_tris_B(0b11111111);   //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
            set_tris_D(0b00000000);  // asigno todo el puerto D como salidas
            output_low(E_ON_OF);    //coloco eel pin B0 a cero

            while(1)
            {
                    if(input(E_ON_OF)==1)                   // Pregunto si la entrada del pin B0 es igual a 0
                    {
                            delay_ms(10);                   // Espero 10ms por si la llave esta rebotando (variando entre 1 y 0 )
                            while(input(E_ON_OF)==1);       // Espero que suelte el boton, observa el ; al final, es decir un while(){}
                            output_toggle(LED_ON_OF);       // Cambio el valor del pin

                    }

                    if(input(LED_ON_OF)==1)                  //pregunto si (LED_ON_OF)==1 si es verdad pasa a la siguiente linea
                    {
                            if((input(S_MOV_PAD)==1) || (input(S_MOV_PUD)==1)) //pregunto si el valor del pin (S_MOV_PAD)==1) o (S_MOV_PUD)==1

                            {

                                    output_high(LUZ_PAD); //ensiendo luz patio trasero
                                    output_high(SIRENA);  //enciende sirena
                                    delay_ms(18000);
                            }
                            else
                            {
                                    output_low(LUZ_PAD); //de lo contrario apaga luz patio trasero
                                    output_low(SIRENA);  //de lo contrario apaga sirena
                            }
                    }
                    else
                    {
                            output_low(LUZ_PAD);  //apagando luz patio delantero
                            output_low(SIRENA);   //apagando sirena
                    }
            }
    }




Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #70 en: 08 de Abril de 2016, 18:16:28 »
Sigamos con esta cosa bueno primero
Tengo dudas se puede hacer dos programas completos una primero y después el otro
De hay en la primera código cambie  volatile int1 SalidaActiva = 0;  por  volatile int1 LED_ON_OF = 0;
De hay cambie todo para delante lo que decía SalidaActiva  por LED_ON_OF dentro del programa del timer  y nada

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #71 en: 08 de Abril de 2016, 23:26:30 »
Te diste cuenta que tenes una funcion dentro de otra funcion, y encima con el mismo nombre con lo cual nunca va a compilar?

Te diste cuenta que estas usando LED_ON_OFF tanto para el define como para el nombre de la variable ? Y eso va a provocar problemas?

Mira el codigo ahora y estudialo:

Código: C
  1. #include <16f877A.h>         //el pic a utilizar es por que solo requiero de pocos recursos para la alarma
  2. #use delay(clock=4000000)   //tiempo del cristal 4 MG
  3. #fuses xt                   //utiliza cristal
  4. #fuses NOWDT                //proteccion perro guardian of
  5. #fuses PUT                  //proteccion para esperar que se estabilise la alimentacion del pic
  6. #use FAST_IO(B)             //utilizo el puerto B
  7. #use FAST_IO(D)             //utilizo el puerto D
  8.  
  9. #define E_ON_OF PIN_B0      //se define que E-ON-OF es el PIN_B0    y  (E-ON-OF) significa Entrada Ensendido Apagad)
  10. #define S_MOV_PAD PIN_B1    //se define que S-MOV-PAD es el PIN_B1  y  (S-MOV-PAD) significa sensor de movimiento patio delantero)
  11. #define S_MOV_PAT PIN_B2    //se define que S-MOV-PAT es el PIN_B2  y  (S-MOV-PAT) significa sensor de movimiento patio trasero)
  12. #define S_MOV_PUD PIN_B3    //se define que S-MOV-PUD es el PIN_B3  y  (S-MOV-PUD) significa sensor de movimiento puerta delantera)
  13. #define S_MOV_PUT PIN_B4    //se define que S-MOV-PUT es el PIN_B4  y  (S-MOV-PUT) significa sensor de movimiento puerta trasera)
  14. #define S_MAG_PUD PIN_B5    //se define que S-MAG-PD es el PIN_B5   y  (S-MAG-PD) significa sensor magnetico puerta delantera)
  15. #define S_MAG_PUT PIN_B5    //se define que S-MAG-PT es el PIN_B6   y  (S-MAG-PT) significa sensor magnetico puerta trasera)
  16. #define LUZ_PAD PIN_D0      //se define que LUZ-PAD es el PIN_D0    y  (LUZ-PAD) significa luz patio delantero
  17. #define LUZ_PAT PIN_D1      //se define que LUZ-PAT es el PIN_D1    y  (LUZ-PAD) significa luz patio trasero
  18. #define SIRENA PIN_D2       //se define que SIRENA es el pin_D2     y  (SIRENA) es la bocina la bulla
  19. #define LLAMAR PIN_D3       //se define que LLAMAR es el pin_D3     y  (LLAMAR) es una salida para realisar una llamada a un cel
  20. #define COLGAR PIN_D4       //se define que COLGAN es el pin_D4     y  (COLGAR) es una salida para colgar la llamada
  21. #define LED_ON_OF PIN_D5    //se define que LED-ON-OF PIN_D5        y  (LED-ON-OF)significa led ensendido apagado
  22.  
  23. int cont = 0;
  24. volatile int1 SalidaActiva = 0;
  25.  
  26. #int_timer1
  27. void time_1(void)
  28. {
  29.         set_timer1(3036);
  30.         if(SalidaActiva==1)
  31.         {
  32.                 cont++;
  33.                 if(cont==2)
  34.                 {
  35.                         output_toggle(LUZ_PAD);
  36.                         cont=0;
  37.                 }
  38.         }
  39.         else
  40.         {
  41.                 output_low(LUZ_PAD);
  42.         }
  43. }
  44.  
  45. void main(void)
  46. {
  47.         // Aca el setup de pines/modulos/etc
  48.  
  49.         set_tris_B(0b11111111);         //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
  50.         set_tris_D(0b00000000);         // asigno todo el puerto D como salidas
  51.         output_low(E_ON_OF);            //coloco eel pin B0 a cero        
  52.         output_low(LUZ_PAD);            //esto lo puse por al simular seme ensendian los pines
  53.         setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  54.         set_timer1 (3036);
  55.         enable_interrupts(int_timer1);
  56.         enable_interrupts(global);
  57.  
  58.         // Comienzo del programa principal
  59.  
  60.         while(true)
  61.         {
  62.                 if(input(E_ON_OF)==1)                   // Pregunto si la entrada del pin B0 es igual a 0
  63.                 {
  64.                         delay_ms(10);                   // Espero 10ms por si la llave esta rebotando (variando entre 1 y 0 )
  65.                         while(input(E_ON_OF)==1);       // Espero que suelte el boton, observa el ; al final, es decir un while(){}
  66.                         output_toggle(LED_ON_OF);       // Cambio el valor del pin
  67.  
  68.                 }
  69.  
  70.                 if(input(LED_ON_OF)==1)                  //pregunto si (LED_ON_OF)==1 si es verdad pasa a la siguiente linea
  71.                 {
  72.                         if((input(S_MOV_PAD)==1) || (input(S_MOV_PUD)==1)) //pregunto si el valor del pin (S_MOV_PAD)==1) o (S_MOV_PUD)==1
  73.                         {
  74.                                 SalidaActiva=1;
  75.                         }
  76.                 }
  77.                 else
  78.                 {
  79.                         SalidaActiva=0;
  80.                 }
  81.         }
  82. }

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #72 en: 09 de Abril de 2016, 14:26:22 »
ok gracias ya simule y hace algunas cosas que no los voy a poner a cero para ver que pasa
la salida(llamar, sirena y led on_of empiesan en cero) led-on_of se apaga al precionas el suich e_on_of y llmar y sirena todo el tiempo están encendidas voy a ponerlas en bajo al comienzo a ver si asi se corriji.
oyes por otro lado se siente bien que poco a poco el primer programa en c que intente valla saliendo supongo que te as de acordar cuando pasaste por lo mismo verdad pero a de ver sido más difícil :mrgreen: si no existía todopic para que ´personas como tu te ayudaran jejejej saludos
falta  mucho para celebrar verda  :mrgreen:

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #73 en: 09 de Abril de 2016, 15:04:07 »
ok gracias ya simule y hace algunas cosas que no los voy a poner a cero para ver que pasa
la salida(llamar, sirena y led on_of empiesan en cero) led-on_of se apaga al precionas el suich e_on_of y llmar y sirena todo el tiempo están encendidas voy a ponerlas en bajo al comienzo a ver si asi se corriji.
oyes por otro lado se siente bien que poco a poco el primer programa en c que intente valla saliendo supongo que te as de acordar cuando pasaste por lo mismo verdad pero a de ver sido más difícil :mrgreen: si no existía todopic para que ´personas como tu te ayudaran jejejej saludos
falta  mucho para celebrar verda  :mrgreen:

Cualquier problema que tengas lo vemos.
Respecto al primer programa para PIC mio fue en ASM, a pesar que uno estudia ingles en esos momentos 14/15 años resulta complicado conocer todas las palabras. Pero te acostumbras rapidamente y por ahi tenes 1 sola palabra molestandote. En fin ASM fue lo primero que toque, hice la universidad y recien en 5to año de la misma decidi dar el paso de ir por C. Fui muy necio en quedarme unicamente con ASM, aunque el trabajar tan cerca del micro te hace pensar miles de formas para hacer algo que puede requerir mucho en C si lo haces normalmente. Claro ejemplo seria una formula.

Multiplicar por 5 en C lo haces:

var = var * 5;

Pero dependiendo del compilador si tiene o no optimizaciones puede que eso ocupe cientos de ciclos del procesador. En cambio podes lograr lo mismo con:

var = ( var << 2 ) + var;

Que requiere girar el valor 2 veces y sumar, y puede llevar 4 ciclos en ASM. Estos problemas mas que nada por compiladores sin optimizacion, algo que se sufre a no ser que pagues por la version PRO en el caso de XC de Microchip, desconozco la optimizacion de CCS.

En fin, lo interesante es ver que tu proyecto funcione. Nunca vas a ir y te va a funcionar a la primera, si no te funciona primero rompete la cabeza pensando por que no lo hace. Segui la logica del programa, cuando es que ocurre eso. Proba poner salidas para ver si es que entra a un if o no. Eso te lleva a aprender realmente, por ahora solo estamos incorporando nuevas cosas, ahora que ya introducimos lo del timer e interrupciones, es momento de arreglar los problemas de los if que tenes, pero no que esten mal escritos sino sobre como funciona el programa. Y es en lo que me voy a centrar ahora cuando traigas tu problema, la idea es que aprendas, no que termines llevandote algo que no sabes como es que se hizo.

Como decis falta mucho, pero eso depende de vos exclusivamente, no vas a aprender todo en 2 semanas o menos. Pero te puede servir una base para que vos comienzes a jugar. Si tenes dudas sobre como funcionan los loops o funciones siempre tenes Google para buscar tus dudas, que seguro alguien ya las respondio y con ejemplos.

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #74 en: 10 de Abril de 2016, 02:18:10 »
//si claro lo se pero créeme que hay voy de cero voy avanzando poco a poco jejejeje es el primero de muchos asta que sea un as en la //programación en c o aprenda cx8 bueno a darla duro al programa

//bueno borre
             output_low(E_ON_OF);            //coloco eel pin B0 a cero
            output_low(LUZ_PAD);            //esto lo puse por al simular seme ensendian los pines


// y coloque

 output_D(0b00000000);
//despues de la configuracion de los tris

//quedando asi

void main(void)
    {
Código: C
  1.  

            // Aca el setup de pines/modulos/etc

            set_tris_B(0b11111111);         //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
            set_tris_D(0b00000000);         // asigno todo el puerto D como salidas
            output_D(0b00000000);


//y se corrigió el problema de que cuando comienza la simulación se activan algunas salidas
         
       
« Última modificación: 10 de Abril de 2016, 03:09:53 por nuevo mundo »