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

0 Usuarios y 3 Visitantes están viendo este tema.

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #30 en: 29 de Marzo de 2016, 02:40:05 »
E realizado la lista de sensores y la condición de los pines del pic también investigue y el 16f84aAes algo antiguo y verifique el costo y cuesta lo mismo que un 16f877A que tiene más pines digo por si me hacen falta pines si me sorprende lo que me dijiste de meter todo por 1 o dos pines supongo que es comunicación serial, creo que mejor pin por entrada y salidas por que así podre manejar el cableado de cada uno individualmente que serán un buen
Asi que si me faltan pines este me sobraran jejeje
Ya investigue los sensores de movimientos dan salida en un piezzo electronique incluido cuando detectan un movimiento este es el que tomaría para la entrada del pic (ósea están N/A)
Los sensores magnéticos son N/S y según pondré un láser en la parte de atrás y otro adelante estarán N/S
La nomenclatura es la siguiente (creo que serían variables de 1 bit para que se entienda mejor el programa)  empesare con los cambios para que quede mejor estructurado desde un comienso

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #31 en: 30 de Marzo de 2016, 00:12:02 »
e cambiado el pic y declare las bariables que utilisare pueden desirme si voy bien  y tengo dudas si puedo desde aqui asignar a cada uno de los pines correspondiente de los pines digo antes de desirlo en el tris correspondiente

#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 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

int1 E-ON-OF=0      //declaro la variable (E-ON-OF) a O Y Significa                                                 (Entrada Ensendido Apagado)
int1 S-MOV-D=0      //declaro la variable (S-MOV-D) Y le asigno que empiece en O Y Significa        (sensor de Movomiento Delantero)
int1 S-MOV-T=0      //declaro la variable (S-MOV-T) Y le asigno que empiece en O Y Significa         (sensor de Movomiento Trasero)
int1 L-D=1              //declaro la variable (L-D) Y le asigno que empiece en 1 Y Significa                 (Laser Delantero)
int1 L-T=1              //declaro la variable (L-T) Y le asigno que empiece en 1 Y Significa                  (Laser Trasero)
int1 S-MAG-D=1      //declaro la variable (S-MAG-D) Y le asigno que empiece en 1 Y Significa         (Sensor Magnetico Delantero)
int1 S-MAG-T=1      //declaro la variable (S-MAG-T) Y le asigno que empiece en 1 Y Significa          (Sensor Magnetico Tracero)
int1 LUZ-PD=0        //declaro la variable (L-PD)  Y le asigno que empiece en O Y Significa              (Luz Patio Delantero)
int1 LUZ-PT=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)

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #32 en: 30 de Marzo de 2016, 00:45:09 »
Como quieras hacerlo , me parece demasiado pero bueno cada uno con sus gustos.

Les falta el punto y coma a todas.

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #33 en: 30 de Marzo de 2016, 01:24:57 »
jejeje ok es que meda miedito que me falte algún pin yo tengo dos pic 16f84a pero no sé si será suficiente vamos a continuar con este que ya ice hasta el circuito para simularlo y tengo dudas de como después de asigna una variable de 1 bay un nombre como después esa variable la puede identificar el pic que esta corresponde a un pin del pic le falta algo más verdad

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #34 en: 30 de Marzo de 2016, 01:31:30 »
aqui continuo ya mas adelante asta la parte que funciona el on-of como lo ves voy bien o ya voy muy mal y ya le puse los punto y coma
que opinas

#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 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

int1 E-ON-OF=0;    //declaro la variable (E-ON-OF) a O Y Significa                               (Entrada Ensendido Apagado)
int1 S-MOV-D=0;    //declaro la variable (S-MOV-D) Y le asigno que empiece en O Y Significa      (sensor de Movomiento Delantero)
int1 S-MOV-T=0;    //declaro la variable (S-MOV-T) Y le asigno que empiece en O Y Significa      (sensor de Movomiento Trasero)
int1 L-D=1;        //declaro la variable (L-D) Y le asigno que empiece en 1 Y Significa          (Laser Delantero)
int1 L-T=1;        //declaro la variable (L-T) Y le asigno que empiece en 1 Y Significa          (Laser Trasero)
int1 S-MAG-D=1;    //declaro la variable (S-MAG-D) Y le asigno que empiece en 1 Y Significa      (Sensor Magnetico Delantero)
int1 S-MAG-T=1;    //declaro la variable (S-MAG-T) Y le asigno que empiece en 1 Y Significa      (Sensor Magnetico Tracero)
int1 LUZ-PD=0;     //declaro la variable (L-PD)  Y le asigno que empiece en O Y Significa        (Luz Patio Delantero)
int1 LUZ-PT=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)


 void main(void){

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

            while(1)
            {
                    if(input(E-ON-OF)==0)                    // 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)==0);        // Espero que suelte el boton, observa el ; al final, es decir un while(){}
                            output_toggle(LED_ON_OF);          // Cambio el valor del pin





Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #35 en: 30 de Marzo de 2016, 02:06:44 »
que opinas que me propones  KILLERJC es que asi pin por pin voy entendiendo la logica del programa y con la variables se comprede mas luego que quede y si me apoyas se podra  optimizar el codigo con algunas tecnicas que existan segun yo jejeje :mrgreen:

                                                corregi este comentario estaban cambiados la B por la D pero ya lo puse bien

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

como ves continuamos con la idea del on-of que tiene ya hecho el codigo o hay otra forma de hacerlo mejor ??? saludos tamos pendientazoooo a tu respuesta ya voy a dormir  :sleepy:
 

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #36 en: 30 de Marzo de 2016, 06:38:41 »
Tenes un problema

E-ON-OF es una variable de 1 bit, pero no significa que sea el PIN_B0,

Asi que esto:
output_low(E-ON_OF);

No deberia funcionar como vos queres y mucho menos esto:

 if(input(E-ON-OF)==0)

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #37 en: 01 de Abril de 2016, 02:06:16 »
 por eso tengo esa dudas de como después de asigna una variable de 1 bay un nombre y asignarle un valor (1,0) como después esa variable la puede identificar el pic que esta corresponde a un pin del pic le falta algo más verdad yo lo puse asi

int1 E-ON-OF=0;    //declaro la variable (E-ON-OF) a O Y Significa 
o es asi
int1 E-ON-OF=PIN Rb0=1;
int1 E-ON-OF=RBO
int1 E-ON-OF=RBO=1; 
osea segun se le dise al programa con int1 que es una variable de 1 bay de hay le asigno un nombre y luego le doy un valor inicial de 0 pero me falta desirle al pic a caul pin corresponde no se como se hace

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #38 en: 01 de Abril de 2016, 06:13:08 »
Pienso que lo que vos queres hacer es:

#define E-ON-OF PIN_B0

De esa forma hacemos que E-ON-OF tenga el mismo valor que PIN_B0,  cuando escribamos nuestro programa lo haces asi:

output_low(E-ON_OF);

Pero el compilador lo interpretaria asi:

output_low(PIN_B0);

Casi como una sustitucion ANTES de compilar el archivo.

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #39 en: 02 de Abril de 2016, 05:22:50 »
ok enterado ahora aora algunos pines deben inisirlizar en 0 y otros en 1 eso como lo ago
ok enterado ahora algunos pines deben inicializar en 0 y otros en 1 eso como lo hago 

ya tengo cai el programa para dejarlo exactamente asta donde estábamos pero me falta inicializar los pines que usare de manera correcta para garantizar que comienzan bien al iniciar el programa y para que en proteus no tenga errores por que ya vi que si no lo hace uno el programa puede dar salida a un pin por que no le dijimos por programa como deberían de arrancar

y otra cosa me marca error en   if(input(E-ON-OF)==0)  por que
 

#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 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-PD 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-PT 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-PD PIN_B5     //se define que S-MAG-PD es el PIN_B5   y  (S-MAG-PD) significa sensor magnetico puerta delantera)
#define S-MAG-PD 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

//int1 E-OF-ON =0;        //declaro la variable (E-ON-OF) a O Y Significa                               (Entrada Ensendido Apagado)
//int1 S-MOV-D =0;        //declaro la variable (S-MOV-D) Y le asigno que empiece en O Y Significa       (sensor de Movomiento Delantero)
//int1 S-MOV-T =0;        //declaro la variable (S-MOV-T) Y le asigno que empiece en O Y Significa       (sensor de Movomiento Trasero)
//int1 s-MOV-PAD=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-D=1;         //declaro la variable (S-MAG-D) Y le asigno que empiece en 1 Y Significa       (Sensor Magnetico Delantero)
//int1 S-MAG=1;           //declaro la variable (S-MAG-T) Y le asigno que empiece en 1 Y Significa       (Sensor Magnetico Tracero)
//int1 LUZ-PD=0;          //declaro la variable (L-PD)  Y le asigno que empiece en O Y Significa         (Luz Patio Delantero)
//int1 LUZ-PT=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)


 void main(void){

            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)==0)                    // 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)==0);        // 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)
                    {
                            if((input(S-MOV-D)==1) || (input(S-MOV-T)==1))

                            {
                                    output_high(LUZ-PD);          // Cambio el valor del pin
                            }
                            else
                            {
                                    output_low(LUZ-PD);
                            }
                    }
                    else
                    {
                            output_low(LUZ-PD);
                    }
            }
    }
















Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #40 en: 02 de Abril de 2016, 06:03:13 »
Yo no soy el adecuado para guiarte como configurar los pines con CCS por que no uso CCS, uso XC8. Y tiene formas distintas de configurar las entradas/salidas.

Lo que te puedo decir es que vas mejor encaminado. Y solo me voy a limitar a hablar del programa, es decir lo que esta dentro del while(1).
Para comenzar deberias de realizar una simulacion al menos con pulsadores, en el que algunas entradas esten a 1 y otras a 0 sin presionar el pulsador, algo simple de hacer.

Ahora vamos a suponer que al detectarse algo procede a activar la alarma. Para esto voy a hacer un "programa" como para que lo entiendas, obviamente no vas a poder copiar y pegarlo. Es basicamente lo que tenes vos y estas haciendo, pero te dejo ademas algo mas claro

Código: C
  1. while(1)
  2.             {
  3.                     if( ¿ Boton encendido presionado ? )               // Este boton va a cambiar el estado de la alarma
  4.                     {                                                   // El estado de la alarma pueden ser 2: Activado y Desactivado
  5.                             delay_ms(10);
  6.                             while(input(E_ON_OF)==0);
  7.                             output_toggle(Estado de alarma);          // Led que indica el estado de la alarma, uso esta salida tambien para saber cuando esta activa o no
  8.  
  9.                     }
  10.  
  11.                     if(Estado Alarma == Activado )
  12.                     {
  13.                             if(Sensor1 == 1 o Sensor2 == 1 o Sensor3 == 0 o Sensor4 == 0)
  14.                             {                                   // Si se detecta algun cambio en los sensores de los valores
  15.                                     output_high(Sirena);        // por defecto, que active la alarma
  16.                             }                                   // Sensor1 tendria por defecto un 0, y cuando recibe datos del sensor pasa a 1
  17.                     }                                           // Sensor3 podrias pensarlo como una llave que es Normal cerrado a 5V por lo que tiene un 1 siempre y cuando
  18.                     else                                        // alguien abre la puerta se pone a 0. Si se detecta algun cambio en los sensores que active la sirena
  19.                     {
  20.                             output_low(Sirena);         // En caso que se desactive la alarma desactivamos la sirena tambien.
  21.                     }
  22.             }

Si vos tenes activada la alarma y se detecta algo que se active la Sirena, pero no significa que cuando el sensor vuelva a su estado "normal" se corte la sirena, pensalo como si abris la puerta comienza a sonar la sirena, la cerras y se para. No tiene sentido como alarma. Entonces la unica forma de desactivarla es que se presione el mismo boton que lo activo.

Por supuesto esto es MUY simple y hay muchos mas cosas a agregar, por ejemplo cuando la activas deseas que pase un tiempo hasta que la alarma se "arme" de esa forma tenes tiempo de salir de la casa. Y esto es podria ser algo simple de realizar haciendo esto:

Código: C
  1. while(1)
  2.             {
  3.                     if( ¿ Boton encendido presionado ? )               // Este boton va a cambiar el estado de la alarma
  4.                     {                                                   // El estado de la alarma pueden ser 2: Activado y Desactivado
  5.                             delay_ms(10);
  6.                             while(input(E_ON_OF)==0);
  7.                             if(Estado Alarma == Desactivado )
  8.                             {
  9.                                 delay_ms(5000);
  10.                             }
  11.                             output_toggle(Estado de alarma);
  12.  
  13.                     }
  14.  
  15.                     if(Estado Alarma == Activado )
  16.                     {
  17.                             if(Sensor1 == 1 o Sensor2 == 1 o Sensor3 == 0 o Sensor4 == 0)
  18.                             {                                   // Si se detecta algun cambio en los sensores de los valores
  19.                                     output_high(Sirena);        // por defecto, que active la alarma
  20.                             }                                   // Sensor1 tendria por defecto un 0, y cuando recibe datos del sensor pasa a 1
  21.                     }                                           // Sensor3 podrias pensarlo como una llave que es Normal cerrado a 5V y cuando
  22.                     else                                        // alguien abre la puerta se pone a 0
  23.                     {
  24.                             output_low(Sirena);        
  25.                     }
  26.             }

Ahora le estoy diciendo que si cuando presiono el boton de "activar/desactivar" y justamente pasa a activarse la alarma, espere 5 segundos antes de comienze a tomar los sensores ( que entre al otro if que pregunta por los sensores)

Y genial ahora tenemos nuestra demora. Pero... sigue simple y se agregan muchas mas complicaciones en el proceso. Si quisieras desactivar la alarma cuando la activaste y estas en esos 5 segundos de espera, no lo vas a poder hacer!, vamos a analizarlo paso a paso, la presion de un boton supongamos como maximo es de 0.5s diria mas 0.1 a 0.25s.

Siguiendo la linea del programa presionas primero el boton de "activar/desactivar", eso va a hacer que entre al primer if, cuando lo sueltes va a entrar a delay de 5s, paso 1 segundo y te diste cuenta que te olvidaste algo asi que tenes que desactivarla, si presionas de nuevo no es que va a entrar de nuevo en el if, sino que todavia esta atrapado dentro del delay y faltan 4 segundos para que salga, entonces te quedan 2 opciones, o tenes presionado el boton por 4 segundos mas y seguro que se va a disparar la alarma por que va a detectar los sensores y hasta que no sueltes no se va a apagar o simplemente esperas que se dispare y luego presionas el boton.

De esta forma tenes que realizar algo para que esto no ocurra. Los delays son muy lindos pero tienen ese problema, perdes la respuesta antes cambios, Asi que deberias diseñar algo para que te permita hacer eso. Ahora en mi ejemplo tome en cuenta como si lo activaras desde adentro, dije 5 segundos , pero 5 segundos es poco. Y normalmente serian algo asi de 30segundos. No creo que sea nada lindo esperar 30 segundos que se dispare la alarma o tener presionado el boton los 30 segundos. Por eso es que debe responder el PIC. Lo mejor para esto es en ves de usar un delay, es usar un timer. Y esto no es unicamente para eso sino tambien para los sensores en el que por ahi quisieras que no detecte un pequeño pulso que puede llegar por un error del sensor sino que esperas por ejemplo que este 1segundo activo el mismo. Otros momentos que necesitas del timer es que espere un tiempo para disparar la alarma, asi podes entrar y "desactivarla" sin que suene, tambien si pensas hacer lo de las luces vas a necesitar contar el tiempo.

Si esto lo haces con delays va a ser un desastre como alarma.

Como el timer es todo un tema aparte, lo mejor que se me ocurre es que realizes un programa aparte y nuevo con un ejemplo de un timer + un led, que el timer sea el encargado de encender el led.

Una cosa mas.
Si leiste estuve hablando de pulsadores conectados al PIC, y las salidas pueden ser simples leds para poder probarlo y simularlo. De esa forma tenes que el programa es correcto y podes probarlo incluso en un protoboard, me refiero a que esos pulsadores van a simular ser los sensores, y los leds las cargas como leds/sirenas/luces/etc. Luego una ves que tengas el programa mas avanzado podemos ir complicandolo un poco mas, por ejemplo que la forma de activacion pueda ser tanto por IR / RF  o desde adentro con un boton.

PD: Hasta ahora no usamos mas que if y un while, nada mas. Y con lo que hay para hacer no se necesita mas que ifs en su mayoria
« Última modificación: 02 de Abril de 2016, 07:13:58 por KILLERJC »

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #41 en: 02 de Abril de 2016, 13:10:58 »
ok enterado oyes si es cierto no tome en cuenta nunca que aser cuando se actiba la alarma los retardos que quiero que tenga uuunnnnmmm ok oyes ¿es más fácil el programar en CX8 ? que en ccs

 aaaay otra pregunta por qué marca error en esta línea  output_low(E-ON-OF)   dice que identifique E supongo que el compilador no a identificado E-ON-OF como un todo sino que de forma separada E......ON......OF parece que no es correcto usar el guion arriba como puedo hacer para que este me tome E-ON-OF como una sola palabra es que si no se compone esta parte no puedo usar ningún nombre que le puse a los sensores  :(

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #42 en: 02 de Abril de 2016, 13:37:51 »
ok enterado oyes si es cierto no tome en cuenta nunca que aser cuando se actiba la alarma los retardos que quiero que tenga uuunnnnmmm ok oyes ¿es más fácil el programar en CX8 ? que en ccs

 aaaay otra pregunta por qué marca error en esta línea  output_low(E-ON-OF)   dice que identifique E supongo que el compilador no a identificado E-ON-OF como un todo sino que de forma separada E......ON......OF parece que no es correcto usar el guion arriba como puedo hacer para que este me tome E-ON-OF como una sola palabra es que si no se compone esta parte no puedo usar ningún nombre que le puse a los sensores  :(

Por que el - significa menos, 12 - 5 eso es igual a 7. En textos no podes hacerlo. Podes usar el guion bajo E_ON_OFF.

Respecto a los compiladores ambos son en C, es decir que muchas cosas no van a cambiar. Pero XC8 se basa mas en el datasheet del micro, ya que terminas modificando registros directamente.
Por ejemplo al hacer:

Código: C
  1. output_low(PIN_B0);
  2. output_a(0x20);
  3. var = input(PIN_B7);

Lo que estas haciendo es poner un 0 en el bit 0 del registro PORTB, luego poniendo 0x20 en el registro PORTA, y finalmente tomando el valor del pin B7. Por lo cual el equivalente en XC8 seria:

Código: C
  1. PORTBbits.RB0  = 0;
  2. PORTA = 0x20;
  3. var = PORTBbits.RB7;

Igual los timers por ejemplo en CCS tenes una funcion que se llama

Código: C
  1. setup_timer_1(ACA_OPCIONES);

En XC8 podes hacerlo de 2 formas. Una es usando las librerias de Microchip, o directamente modificando los registros:

Código: C
  1. OpenTimer1(ACA_OPCIONES);

o que es lo mismo que hacer:

Código: C
  1. T1CON = 0x20;                // Configuro timer
  2. TMR1 = 0x1050;               // Le doy un valor inicial
  3. PIRbits.T1IF = 0;              // Borro bandera
  4. PIE1bits.T1IE = 1;            // Activo interrupcion del timer 1
  5.  
  6. T1CONbits.TMR1ON = 1;  // Activo el timer

Pensaras que tenes que acordarte de TODOS los registros, pero si abris el datasheet siempre al final de la explicacion de cada modulo te aparecen todos lso registros y bits que afectan a cada uno. Ademas los nombres como TMR1ON corresponden exactamente al nombre que tiene el datasheet el bit ese. Al igual que los registros.

T1CONbits.TMR1ON  ----- Registro T1CON , el bit TMR1ON, observaras que tiene un "bits" agregado para cuando se quiere acceder a los mismos, y sin los bits podes cargar los 8 bits directo, tal cual hice con T1CON = 0x20;

Eso mas algunas diferencias hacen a estos 2 compiladores. La mas notable es que podes abrir el archivo que contiene el codigo de OpenTimer1 y ver que hace exactamente alli dentro. Cosa que no podes en CCS con ninguna funcion. Pero CCS te abstrae mas, y por ahi eso significa poder hacer cosas de forma mas facil sin entender demasiado. El ejemplo mas claro es el de RS232 ( UART ), en CCS es facilisimo su configuracion, en XC8 es un poco mas rebuscado aunque el datasheet te suele dar paso a paso como configurarlo, ejemplo la recepcion asincrona:

Citar
When setting up an Asynchronous Reception, follow these steps:
1. Initialize the SPBRG register for the appropriate baud rate. If a high-speed baud rate is desired, set bit BRGH (Section 10.1 “USART Baud Rate Generator (BRG)”).
2. Enable the asynchronous serial port by clearing bit SYNC and setting bit SPEN.
3. If interrupts are desired, then set enable bit RCIE.
4. If 9-bit reception is desired, then set bit RX9.
5. Enable the reception by setting bit CREN.
6. Flag bit RCIF will be set when reception is complete and an interrupt will be generated if enable bit RCIE is set.
7. Read the RCSTA register to get the ninth bit (if enabled) and determine if any error occurred during reception.
8. Read the 8-bit received data by reading the RCREG register.
9. If any error occurred, clear the error by clearing enable bit CREN.
10. If using interrupts, ensure that GIE and PEIE (bits 7 and 6) of the INTCON register are set.

Seguis esos pasos y tenes creado el codigo (O podes usar nuevamente la libreria y usar OpenUSART(OPCIONES) ). Es cuestion de gusto y de cada uno. Lo unico que cambia es eso, todo lo demas sigue siendo C, y es identico en uno como en otro. Es decir el funcionamiento de los if/while/&&/etc no va a cambiar.
« Última modificación: 02 de Abril de 2016, 13:40:34 por KILLERJC »

Desconectado nuevo mundo

  • PIC16
  • ***
  • Mensajes: 108
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #43 en: 03 de Abril de 2016, 04:15:20 »
ok ya compile el programa chécalo pero no me lee la condición no se por qué si solo se sustituyó los nombres de los pines pero no enciende el led correspondiente  es que quiero dejarlo exactamente hasta donde estaba antes de cambiar el nombre de los pines por algo más entendible

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
« Respuesta #44 en: 03 de Abril de 2016, 04:18:20 »
pasa el codigo, no el .hex generado.