TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: nuevo mundo en 14 de Marzo de 2016, 00:28:35

Título: lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 14 de Marzo de 2016, 00:28:35
hola compañeros estoy practicando con programas de leer pulsadores (en varios pin pero solo cambia es estado entre 0y1) y dar salidas en otros pines (0,1 con retardos y salidas fijas) y me gustaria que me comentaran como leer al mismo tiempo varios pines con (condiciones if, else o "case" o  "//" o "&&" )para darme idea de como realisar diferentes condiciones al mismo tiempo en espera de un cambi de un pulsador o barios
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: w3-sistemas en 14 de Marzo de 2016, 00:51:40
hola aca te paso unas tareas en "c" que le pase a un colega mexicano para una alarma, la tarea A sensa el interruptor encendiendo o apagando tanto la alarma como la tarea B
y la B es la tarea que sensa 7 interruptores y si alguno se activa se enciende el led correspondiente y hasta que no pulsas el interruptor 1 no se apaga la alarma, mas datos me consultas

saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 14 de Marzo de 2016, 01:34:13
nuevo mundo:

Solo corregirte que es || y no //, normalmente en un teclado español lo podes poner con el "Alt Gr" (el que se encuentra a la derecha ) y el 1.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 16 de Marzo de 2016, 02:31:45
gracias  w3-sistemas por tu ayuda la agradezco de corazón y veo que gracias a las personas como tu que ya an caminado más en el mundo del lenguaje de programación de los pic tienen la experiencia, el conocimiento de por de ayudar y que nuevas personas puedan crecer poco a poco en este mundo tan maravilloso del los pic un servidor se llama Raúl Pérez acosta soy de tabasco México y hace algún tiempo me di a la tarea de realizar una alarma para mi hogar porque a mis dos vecinos le vaciaron la casa y eso me dio mucho miedo de perder lo que por muchos años uno a podido tener y dije que los pic me ´podían dar una para que esto no me sucediera a mi
por eso estoy aquí tratando de realizar la alarma empecé con lo básico leí e investigue  y pedí ayuda en este foro me apoyo de gran manera KILLERJC en mis primeras preguntas pero vi que lo que yo quería lo plantie quizás de la manera más difícil de hacer puse un tema llamado insertar una condicion mientras se ejecuta un while esto me iso despertar mas mucho más las bondades del lenguaje c para pic y aun sigo en la lucha dia a dia en tratar de realizar la idea de la alarma pero e buscado en internet ejemplos de como leer pulsadores y que den salida en algún pin pero solo e encontrado el básico 1 pulsadr y un led pero no en donde se censen barios y que den salida en otro pin como el que me diste gracias lo analizare lo pondré en proteus para simularlo y luego adaptarlo gracias   
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 16 de Marzo de 2016, 02:59:45
Gracias KILLERJC por tu ayuda ya encontré la tecla te comente que me sentía frustrado por lo difícil que se me puso el querer programar un pic para una alarma pero tengo que tener paciencia y seguir luchando hasta lograrlo sigo investigando asta muy altas horas de la noche para lograrlo y e aumentado los conocimiento y por eso realice esta pregunta por qué vi que se podía hacer más fácil con otras sentencia que tenía el lenguaje c para pic y me gustaría que en el foro existieran ejemplos que con anterioridad otros compañeros hayan hecho y lo compartan con todos para aprender de lo que ya pasaron creo que el que pregunta algo aquí es porque no lo puede hacer sin la ayuda del foro y si lo logra ese programa debería de quedar aquí para ejemplo y enriquecer mas a todo pic veo la capacidad que tiene muchos a qui y es extraordinaria ya me imagino los logros que an obtenido muchas personas gracias asu ayuda   bueno esa es solo una opinión saludos y si existe algo a si me comentas saludos desde Comalcalco mexico tierra del chocolate jejejeje  :P
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: w3-sistemas en 17 de Marzo de 2016, 00:19:51
bueno nuevomundo comentame como te fue con lo que te mande, saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 17 de Marzo de 2016, 01:01:05
Solo decirte que lo que le pasaste esta un poco fuera de los alcances de nuevo mundo, el recien comienza con C y no conoce ni los operadores, ni siquiera usar if para preguntar por las entradas, y en tus ejemplos estas poniendo enum, struct, y defines que ni siquiera estan en el texto, switch / break. Lo cual me parece a mi que lo va a marear mas.

El simplemente necesita primero un tutorial de C, pero no hay de CCS, sino solo de XC8 en el foro, pero podria buscar por internet cualquier tutorial hasta aprender lo principal, que es el control de flujo, loops, tipos, funciones, etc.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 18:55:41
Hola  KILLERJC ya e leído mucho mi buen lo que pasa es que no hay muchos ejemplos palpables ya desarrollados solo sentencias básicas pero no en ejemplos saludos y si gustas apoyarme de antemano gracias por orientarme
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 19:00:54
Gracias mi buen w3-sistemas a raíz de lo que me mandate me dedique a leer más para entender por competo la lógica de las dos rutinas que me mandaste y copiare la primera y de hay le pondré a un costado lo que le entiendo para que me orientes ti estoy por buen camino para leer de manera correcta el código saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 20:55:43
Operaciones Matemáticas
 Se  tienen  la  suma,  resta  multiplicación  y división,  división  entera  más  las  operaciones  de  incremento  y decremento.

char i,j, k;
void main()
{
i=10;
j=20;

k=i+j; //suma de 2 enteros
k=i-j; // resta de 2 enteros
k=i*j;  // multiplicación de 2 enteros
k=i%j;// Division entera
(debe dar el resto)
k++;  // incremento k=k+1
k--;  // decremento k=k-1;
}
Operaciones Lógicas
Se  realizan  con  variables  enteras  y  afectan  directamente  al  bit  del  dato,  se  tienen  los  operadores  lógicos y los desplazamientos a la Izquierda y ala derecha.

char i,j, k;
void main()
{
k=i&j; // operación AND entre i y j bit a bit
k=i|j; // operación OR entre i y j bit a bit
k=~i;  // operación negación de i asignado a k
k=i<<1; // i desplazado en un bit a izquierda
k=i<<2; // i desplazado en 2 bit a izquierda
k=i>>1; // i desplazado en un bit a la derecha
k=i<<2; // i desplazado en 2 bit a la derecha
}

Sentencias de control

Permiten  definir  las  funciones a  ejecutar  dependiendo  de  ciertas  condiciones  que  se  deben  evaluar.  Estas condiciones  pueden  ser  tipo lógicas, tipo mayor, menor o igual o ambas .  Por  lo  general  se  agrupan  entre paréntesis para definir la prioridad de la evaluación de la condición.
Tabla 3.
Operador de condición                 Descripción

          ==                                         Igual
          !=                                         Distinto
          > <                                       Mayor, menor
          >=  =<                                  Mayo o igual, Menor o igual
          &&                                        Operador Y
           ||                                         Operador O

Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 21:11:58
La condición verdadera puede ser también de la siguiente forma: Si se quiere preguntar por una variable que es  mayor  que  cero  solo  se  coloca  la  variable  si  se quiere  preguntar  si  es falsa  entonces se  niega,  usando el operador !.
Sentencia if-else Puede  usarse el if solo  o el if-else. Si  la  condición  es  verdadera  entonces  se  ejecuta  una instrucción o un grupo de instrucciones en caso contrario se ejecuta la que sigue

char i,j,k,h;
void main()
{

i=10;
j=20;

if(i==j) k=1; // si i=j entonces k=1 sino k=2
else k=2;
// si=10 entonces k=20,j=10 sino k=40,j=20,h=60
if(i==10) {
                  k=20;
                  j=10;
}
else
        {
                  k=40;
                  j=20;
                  h=k+j;
         }
// Si i=10 y j=20 entonces...
if((i==10) && (j==20)) {
                                       k=20;
                                       j=10;
                                     }
if(i) k=20; // si i es mayor que cero
if(!i) k=20; // si i es cero
}
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 21:36:32
Sentencia while
Esta  evalúa  la  condición  al  inicio,  si  ésta  es  verdadera,  entonces  se  ejecuta  el bloque  que  viene acontinuación en caso contrario lo salta.

El formato es el siguiente:

while(condición) instrucción;                                                                   while(condición) {
                                                                                                                                             instrucción_1;
                                                                                                                                             ...
                                                                                                                                             instrucción_n;
                                                                                                                                             }
En el siguiente código fuente se muestra que el ciclo while se realiza ya que i siempre sea mayor que 0. Sin embargo en algún momento i será menor que 0, dado que k se va decrementando y se hace igual a i dentro del ciclo. 

char i,j,k,h;
void main()
{
   i=1;   k=40;   j=10;
   while(i>0) // Solo mientras i>0 hace lo que viene a cont.
   {
      h=k+j;
      k--i=k;
    }
}
En el ejemplo sólo se evalúa la condición verdadera, pero nunca sele del ciclo.
char i,j,k,h;

void main()
{
   i=1;
   // Solo mientras i mayor que cero hace lo que viene a cont.
   while(i)   // Puede usarse while(1)
    {
       k=40;
       j=20;
       h=k+j;
     }
}
Para  salir  de  un  ciclo  donde  no  existe  posibilidad  de  que  la  condición  sea alterada,  se  puede  usar  la sentencia break.

char i,j,k,h;

void main()
{
   i=0;
   while(1)   
    {
       i++;
       if(i==5)break; // Sale cuando i=5
     }
}
La  sentencia do while se  evalúa  la  condición  al  final,  por  ejemplo  “ Hágalo  mientras  se  cumpla  la condición”.

void main()
{
  char i;
  i=10;
  do
  {
  i--;
  }while(i!=5);// Sale cuando i=5
}
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 21:45:09
Sentencia switch -case
Esta instrucción se  usa  cuando  se  deben  seleccionar  entre  varias  opciones  tipo  numéricas.Es  básicamente un selector.

char c;
void main()
{
   // se le debe asignar el valor a la var. c
   switch(c)
  {
    case 1: // debe saltar a función
    break;
    case 2: // debe saltar a función
    break;
    case
    3: // debe saltar a función
    break;
   }
}
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 22 de Marzo de 2016, 21:49:23
Todo eso lo podes encontrar en cualquier tutorial de C, me refiero a que corresponde al lenguaje de programacion C. Y no algo referente al micro. Por eso mismo:

El simplemente necesita primero un tutorial de C, pero no hay de CCS, sino solo de XC8 en el foro, pero podria buscar por internet cualquier tutorial hasta aprender lo principal, que es el control de flujo, loops, tipos, funciones, etc.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 22:13:32
KILLERJC no entiendo que me quieres decir pero esto que puse lo estoy utilizando para entender el programa que me facilito el compañero w3-sistema para así entenderlo y poder aplicarlo a mi problema de rateros que me acechan la verdad que si requiero de su ayuda porque sin esa ayuda creo que cuando logre realizar la alarma será tarde la verdad que le estoy echando todos las ganas para asi poder aplicar esto a una aplicación que sea funcional y que me ayude contra la amenaza que me asecha por favor si ya me entendiste lo que quiero realizar y conoces la manera más sencilla de hacerla coméntame le doy duro ala investigación y al desarrollo de lo que me comentes y ojala que lo que puse le sirva a otros compañeros saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 22:26:36
KILLERJC aaaaaaaaaa ya te entendí que lo que puse es orientado a el lenguaje de programación en c pero no orientado a pic verdad y si es asi eso es lo mismo que me e encontrado que no e encontrado ejemplos de la aplicación de la alarma pero orientado en lenguaje c para pic por eso voy a trabajar con lo que me digan puesto tienen mucha experimenta. supongo que ya se an encontrado con este tipo de aplicaciones por lo pronto creo creo lo digo bien creo porque los que saben más de esto son los que llevan más tiempo programando tengo que entender al 100% las dos rutinas la A y la B que me mando w3-sistemas y colocarle al código lo que le falta como son los fusibles, la velocidad del cristal el pic que debe de ser uno que tiene 3 puertos veo y hay poco a poco hacerlo 
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Marzo de 2016, 22:44:01
 mi buen w3-sistemas
lo que no aprece en el codigo que lo pones como #include "main.h" lo puedo sustituir por esto

#include <18f2550.h>

#fuses HSPLL, PUT, BROWNOUT, NOWDT, NOPROTECT, NOLVP
#fuses NODEBUG, USBDIV, PLL5, CPUDIV1, VREGEN, CCP2B3// VIT DE CONFIGURACION

#USE delay(clock=48000000)

#org 0x0000, 0x0FFF{}

#use standard_io(A)
#use standard_io(B)
#use standard_io(C)

comentamen si me falta declarar alguna constante global o variable goblal o alguna interrucin o que mas para ir poco a poco entendiendolo y completandolo

y tambien si me explicas esta parte if(SWbits.fSw1) segun yo
if            significa si
SWbit     definicion que no veo de swich asignado a un bits
.fSw1      el . es una asignacion a una direccion de memoria y
fsw1 el nombre que se le dio a la direccion de memoria
comentame por fa como voy gracias
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 22 de Marzo de 2016, 23:43:03
Por eso mismo decia que era muy avanzado e incompleto.

Citar
, y en tus ejemplos estas poniendo enum, struct, y defines que ni siquiera estan en el texto, switch / break. Lo cual me parece a mi que lo va a marear mas.

Por ahora me extiendo un poco y luego voy a tu pregunta.

el . es para acceder a los elementos de una estructura o una union, personalmente no creo que sea correcto por ahora ir por ese camino, pero si te interesa como usarlo o como funciona te dejo una idea. Supongamos que tenes una estructura (struct) de 3 elementos, 2 int8 y uno int16

Código: C
  1. // Definicion de la estructura, es decir como esta conformada la misma
  2.  
  3. struct MyStructTag {
  4.         int8    variable1;
  5.         int8    variable2;
  6.         int16   variable3;
  7. }
  8.  
  9. // Creacion de una estructura
  10.  
  11. struct MyStuctTag MyStruct1;
  12. struct MyStuctTag MyStruct2;
  13.  
  14. // Para acceder a los elementos de la estructura haces:
  15.  
  16. MyStruct1.variable1 = 0 ;               // Pongo a 0 variable 1, de MyStruct1
  17. MyStruct1.variable3 = 1024;             // Pongo a 1024 la variable 3 de MyStruct1
  18. MyStruct2.variable3 = 100;              // Pongo a 100 la variable 3 de MyStruct2

Como ves hay variables pero de 8 bits.. por ahi quisieras variables de 1 bit. Y tambien poder acceder a todo como si fuera una de 8 bits, algo asi como los puertos.
En las estructuras tenes lo que se conoce como bit field. Es decir declaras la cantidad de bits que ocupan.

Código: C
  1. struct BitStuctTag {
  2.         unsigned Bit0                    :1;
  3.         unsigned Bit1                    :1;
  4.         unsigned Bit2                    :1;
  5.         unsigned Bit3                    :1;
  6.         unsigned Bit4                    :1;
  7.         unsigned Bit5                    :1;
  8.         unsigned Bit6                    :1;
  9.         unsigned Bit7                    :1;
  10. };

Y ahora podes acceder a cada uno de los bits de eso.. es decir si declaramos una estructura con el nombre "bitStruct" podria acceder a bitStruct.Bit0 y lo que me devolveria es 0 o 1 ya que es de 1 bit. Esto seria bastante parecido a hacer algo asi:

Código: C
  1. #define BIT0 0b00000001
  2. #define BIT1 0b00000010
  3. #define BIT2 0b00000100
  4. #define BIT3 0b00001000
  5. // Aca lso demas
  6.  
  7. int8 myvar;
  8.  
  9. if ((myvar & BIT0) == 0)                // Pregunto por si el Bit 0 esta en 0
  10. myvar |= BIT0;                          // Pongo a 1 el bit 0 de myvar
  11. myvar &= ~BIT0;                         // Pongo a 0 el bit 0 de myvar

Pero segun el compilador la implementacion puede ser muy mala. Hacer lo que hice antes puede que el compilador efectivametne necesite hacer una OR, etc, y no usar una instruccion que simplemente ponga a 1 el bit, todo depende del grado de optimizacion que posee el compilador.

Ahora si tu pregunta

Código: C
  1. if(SWbits.fSw1)

Es un condicional, es decir si lo que esta dentro de los parentesis es TRUE, va a ejecutar el codigo dentro de las llaves { }, Para que algo sea considerado TRUE debe ser distinto de 0. En el caso ese si fSw1 perteneciente a la estructura SWbits es 1, va a entrar y ejecutar el if.

Citar
// VIT DE CONFIGURACION

Es Bits o palabras.

Consejo no uses las directivas ORG en C, al menos no por ahora, y son casos especiales en los que deberias usarlo, me refiero a esto:

Citar
#org 0x0000, 0x0FFF{}

Citar
colocarle al código lo que le falta como son los fusibles, la velocidad del cristal el pic que debe de ser uno que tiene 3 puertos veo y hay poco a poco hacerlo
El codigo que te paso w3-sistemas para mi va a hacer que tengas mas problemas que si te manejas con simples if() , pero es bueno que veas un codigo, preguntes e intentes entenderle.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 24 de Marzo de 2016, 02:18:47
Hola mi buen KILLERJC asu  mecha ya casi me estoy quedando siego jejejej buscando y leyendo lo que hay en el foro pero es descomunal la información pero aun seguiré buscando como ir avanzando veo que si sabes un buen de esto por las repuestas que das eres de otro nivel: mrgreen:

por otro lado gracias por la explicación que me diste de las estructuras y en lo que el leído ese tipo de cosas  las utilizan en las matrices verdad por que leen datos de varios bits y si es correcto tengo que estudiar mas y mas para ir entendiendo más gracias

y me hago la pregunta me continuarías ayudando para ir desarrollando la famosa alarma que quiero realizar con leer entradas y salidas del pic te acuerdas a el condigo que me ayudaste con los if - else al simularlo no función me puedes decir que paso ósea no da erro al compilarlo solo que al simularlo no hace nada de nada

#include <16f84a.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
                            // PORTB direccion es 06h y el TRISB la direccion es 86h


    void main(void){


            set_tris_b(0b0110101);  // RB0 y RB2,RB3,RB4,RB5 entradas Y RB1,RB3,RB7 salidas (10001010)
            output_low(PIN_B0);

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

                    if(input(PIN_B1)==1)
                    {
                            if(input(PIN_B2)==1)
                            {
                                    output_high(PIN_B3);          // Cambio el valor del pin
                            }
                            else
                            {
                                    output_low(PIN_B3);
                            }
                    }
                    else
                    {
                            output_low(PIN_B3);
                    }
            }
    }



Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 24 de Marzo de 2016, 05:16:47
Es que le quitaste el

#use FAST_IO(B)

Es una trampa de CCS para la gente nueva.. A mi no me gusta.. pero es para que lo tengas en cuenta.
De forma normal el compilador esta en STANDART_IO

Entonces cuando hay funciones asi:
input(PIN_B0)==0

Lo que hace es hacer el pin una entrada, y si encuentra un output_low(PIN_Bx) lo transforma en salida.
Y por ahi eso NO es lo que uno quiere , tal ves uno quiere que siga como salida siempre y poder leer el estado que tiene el pin pero como salida.
Entonces al decirle FAST_IO, le decimos al compilador que no agrege codigo para pasarlo a entrada o salida.

Lo que nos queda es ahora definir cual pin va a ser entrada y cual salida. Para eso esta:

set_tris_b(0b0110101);

donde el bit 0 es decir el de la derecha pertenece a B0, un 1 significa entrada, un 0 salida.

Es por eso que no te funciona como vos queres, pero si te fijas en el antiguo post que preguntaste sobre eso y te di el codigo, tenia escrito el #use fast_io si no mal recuerdo.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 24 de Marzo de 2016, 17:27:40
asuuuuuuu KILLERJC si funciono ya   :-/ . hasta hay fíjate que yo le había  colocado #use standard_io(b) y me marcaba error pero no se me cerro el mundo cuando lo puse
 pero gracias le coloque #use FAST_IO(B)  y ya funciona en la simulación ahora voy a pensarle en donde lo anexo otras dos entradas y otras dos salidas con el if saludos  :mrgreen:
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 25 de Marzo de 2016, 16:59:45
hola intente colocar la siguiente condicion pero me marca herror   if(input(PIN_B2)==1) || (input(pin_b4==1))

lo que me dise como erroe es

 A numeric expression must appear here    lo traduje y dise  Una expresión numérica debe aparecer aquí    por que marca error me pueden ayudar


todo completo es asi

#include <16f84a.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)             // PORTB direccion es 06h y el TRISB la direccion es 86h


    void main(void){


            set_tris_b(0b0110101);  // RB0 y RB2,RB3,RB4,RB5 entradas Y RB1,RB3,RB7 salidas (10001010)
            output_low(PIN_B0);

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

                    if(input(PIN_B1)==1)
                    {
                            if(input(PIN_B2)==1) || (input(pin_b4==1))

                            {
                                    output_high(PIN_B3);          // Cambio el valor del pin
                            }
                            else
                            {
                                    output_low(PIN_B3);
                            }
                    }
                    else
                    {
                            output_low(PIN_B3);
                    }
            }
    }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 25 de Marzo de 2016, 17:52:27
lo puse asi y no marca error pero  no realiza la condicion si algunos de los dos pines b2 o b4=1 dar salida en 1 a pin 3

 if(input(PIN_B2)==1 || input(pin_b4==1))

me pueden explicar por que en las dos formas no son correctas
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 25 de Marzo de 2016, 18:22:50
Tu Error:

Observa los parentesis y trata e ir paso por paso

if( input(PIN_B2)==1) || (input(pin_b4==1) )

en ese caso existe un parentesis de menos antes del input(PIN_B2), ademas observa que es input(PIN_XX) y vos metiste el == dentro. Ahora lo voy a escribir bien y vamos a desmenuzarlo

if( (input(PIN_B2)==1) || (input(pin_b4)==1) )

Ahora si. los parentesis de afuera recubren todo lo de adentro , Adentro hay 2 elementos por una OR.

(input(PIN_B2)==1)              ||              (input(pin_b4)==1)

Como en una OR logica deberia hacer OR entre TRUE/FALSE me refiero a TRUE || FALSE, TRUE || TRUE , FALSE || FALSE, etc

Cada uno de esos elementos es una comparacion:

input(PIN_B2) == 1

input() es una funcion, que va a devolver un numero 1 o 0, segun el pin que posea el argumento. Si es 1 lo devuelto por esta funcion, esa condicion quedaria  1 == 1 , es decir 1 igual a 1 ? TRUE ( Verdadero ), sino puede que devuelva un 0 y quedar 0 == 1, 0 igual a 1?, FALSE ( Falso )

Entonces pensalo paso a paso. Suponete que B2 es igual a 0, y B4 igual a 1. el if quedaria asi:

if( (input(PIN_B2)==1) || (input(pin_b4)==1) )

if( ( 0 == 1 ) || ( 1 == 1 ) )
if( FALSE || TRUE )
if( TRUE )

Con lo que entraria al if por ser la condicion Verdadera.

Ahora vamos con el error y por que uno te funciono y otro no.

- El primer caso fue que le erraste en la cantidad de parentesis, como decia el if deberia encerrar TODO pero en el primer caso:

if(input(PIN_B2)==1) || (input(pin_b4==1))

Se cierra luego del primer ==1, lo cual esta mal el if() quedando algo asi:

if(input(PIN_B2)==1)                ||             (input(pin_b4==1))

Como si ese OR y lo demas fuera aparte. y no es asi.

- Tu segundo codigo en cambio no tiene problemas de parentesis, observaras que los parentesis del input() abren y cierran 1 ves, en cada caso y el parentesis del if abre y cierra en todo.

if(       input(PIN_B2)==1 || input(pin_b4==1)       )

El problema aca es el segundo input(), me refiero a :

input(   pin_b4 == 1      )

Como observas no le estoy pasando el valor PIN_B4 a input, sino que le estoy pasando el valor PIN_B4 == 1, es decir un TRUE o un FALSE. A pesar que uno pienso que ese PIN_B4 sea el pin exacto, para el programa PIN_B4 no es mas que un numero, que luego dentro de input, segun el numero ingresado leera la entrada que se desee. Tal ves ahi estabas leyendo A0 o A1, o tal ves un mal valor por que le estabas pasando un 0 o un 1. Distinto es como tenias antes:

input(PIN_B2) == 1

Y que como analizamos primero se resuelve la funcion, esta devuelve un valor (0 o 1 en este caso) que se compara con 1.
Espero que veas donde te estas equivocando. Son cosas muy basicas, pero muy basicas.
Pero segui que pronto va a ser todo mas facil.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 25 de Marzo de 2016, 22:32:37
ok enterado lo voy a colocar de esa forma y lo simulare asta horita no e encontrado en red de ejemplos de múltiples condiciones con un if o de algún otra forma metodo que se pueda realizar si tienes algún enlace o en realidad con tus habilidades creo que tienes unos cuantos en la mente jejejeje  :mrgreen: en serio se que hay voy poco a poco nadien nace sabiendo
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 25 de Marzo de 2016, 22:36:51
Es que con el ejemplo que te di ya deberias tener suficiente. Lo que realmente importa es que sepas que hace el if, como funciona, y Donde poner la condicion.

Lo demas es pura logica. if(x=0)..else    es lo mismo que: si (x=0) hacer ... si no lo es hacer

Si ya no entendes esa simple logica por mas cantidad de ejemplos que uno pueda poner es imposible que lo entiendas.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 26 de Marzo de 2016, 01:52:25
ok si comprendi segun yo pero para estar seguro partiendo con que En una compuerta OR,  la salida será “1″,cuando en cualquiera de sus entradas haya un “1″. 
segun mi logica (input(PIN_B2)==1) es una entra de la or y la otra (input(pin_b4)==1) y colocandole entre paretesis quedan dentro del if que si una de las dos lecturas de los pines es =1 el if es verdadero y hara o que sigue que es ensender el pin rb3 asi lo entiendo es correcto ?????
por que segun lo que quiero es que si RB2 O RB4 estan en un estado alto cuando lea la condicion se encienda RB3
y con todo esto que e visto para que se entienda mejor deberia de asignar variables a los led que son salidas y a los swich que son entrada para una mejor comprencion pero creo que primero que aga esto verdad 

oyes soy el peor alumno que as tenido verdad jajajaja es un chascarrilo para salir un momentito ala risa


Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 26 de Marzo de 2016, 03:49:01
ya loo coloque de manera correcta segun pero no lo ejecuta de manera correcto  :5] uuuf

if((input(PIN_B2)==1) || (input(pin_B4==1)))
 al accionar el interuptor que esta en RB4 =1 no ensiende RB3 solo  cuando se acciona RB2
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 26 de Marzo de 2016, 04:59:37
Citar
segun mi logica (input(PIN_B2)==1) es una entra de la or y la otra (input(pin_b4)==1) y colocandole entre paretesis quedan dentro del if que si una de las dos lecturas de los pines es =1 el if es verdadero y hara o que sigue que es ensender el pin rb3 asi lo entiendo es correcto ?????
por que segun lo que quiero es que si RB2 O RB4 estan en un estado alto cuando lea la condicion se encienda RB3

En parte es correcto, esa OR en realidad dice que cuando una de las 2 condiciones que nombras es verdadera entraria al if. Sea lo que sea que tengas analizando como verdadero o falso. En tu caso justamente estas analizando las entradas y una condicion es si esta en 1 B2, y la otra si esta en 1 B4.

ya loo coloque de manera correcta segun pero no lo ejecuta de manera correcto  :5] uuuf

if((input(PIN_B2)==1) || (input(pin_B4==1)))
 al accionar el interuptor que esta en RB4 =1 no ensiende RB3 solo  cuando se acciona RB2

Mostra el programa completo, ademas ese if, vuelve a tener un problema, mira el == del pin_b4 donde esta
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 27 de Marzo de 2016, 03:35:42
si es correcto solo al colocarle el paréntesis que faltaba funciono la condición   :mrgreen: y creo que es la primera vez que veo un ejemplo de dos condiciones dentro de un if  para manejo de pines.
se siente bien ir poco a poco avanzando pero realmente sin tu ayuda aun no tuviera avance gracias
 creo que tendre que ponerme lentes jejejejej
aora segire abansando colocare 2 mas aver que pasa jejejeje
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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)
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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




Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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:
 
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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)
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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);
                    }
            }
    }















Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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  :(
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 03 de Abril de 2016, 04:18:20
pasa el codigo, no el .hex generado.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Abril de 2016, 04:23:03
jejee si verdad
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Abril de 2016, 04:45:27
veo que poco a poco me acerco a la máquina de estado  en la cual cada opción hará una parte del programa dependiendo del sensor que se active
ya voy entendiendo para que es  :shock:
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 03 de Abril de 2016, 05:10:59
Donde lo estas probando ? el codigo parece correcto, lo unico que no veo correctamente son los FUSES
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Abril de 2016, 13:04:57
es que no se como subir el archivo aqui ya lo intente dos veses y dise que no lo puedo haser por que no es la extencion te mande un correo te llego
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 05 de Abril de 2016, 19:04:52
cual fuse ves que no esta bien killerjc
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 05 de Abril de 2016, 19:55:16
Estoy parado sin ayuda en estos momentos no avanzó mucho pero si estoy en chinga aunque no lo pueda destrabar fíjate que imagine hacer tres programas de control de led cada uno con una acción de la alarma
la #1 seria encender un led que simula  (LUZ-PAD PIN) cuando se acciona  (S-MOV-PAD ) pero que esto lo aga por 20 min
la #2 seria encender dos led que simula LUZ-PAD PIN y SIRENA cuando se accione ( S-MOV-PUD PIN)
la #3 seria cuando se acciona (S_MAG_PUD) lo anterior mas llamar y colgar
Según yo  jejeje luego se podría mandar a llamar como función aunque serian tres mas pero iguales solo se cambiaría todo pero para la parte trasera  la verdad que si quiero terminar esto estoy en la lucha saludos
Esta que estoy trabado seria la #2

Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 05 de Abril de 2016, 20:18:21
es es el codigo que tengo pero aun no jala no sensa los sensores por que era
#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_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

//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)


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

            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)                  //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
                            }
                            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
                    }
            }
    }


Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 05 de Abril de 2016, 21:05:58
cual fuse ves que no esta bien killerjc

No veo que esten los fuses del oscilador y faltan varios mas.

Citar
es es el codigo que tengo pero aun no jala no sensa los sensores por que era

Si podes pasar una imagen del circuito como lo estas probando mejor.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 05 de Abril de 2016, 21:59:06
Apagar luz patio trasero  quisiera subir el archivo de proteus pero no e podido una porque la extensión no la acepta y la otra porque lo compacto pero en win rad y tampoco acepta ese archivo lo subiré como imagen pero creo que solo se podrá ver no simular nada
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 05 de Abril de 2016, 22:13:49
te mandare el archivo para ver si lo puedes suvir tu por por aya
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 05 de Abril de 2016, 23:35:08
Por la forma de tu circuito, se queda estancado aca:

Código: C
  1. while(input(E_ON_OF)==0);

cambialo la condicion del if y el while a 1, es decir

Código: C
  1. if(input(E_ON_OF)==1);
  2. {
  3.        //Aca delay
  4.        while(input(E_ON_OF)==1);
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 06 de Abril de 2016, 01:16:58
es cierto funciono  ((:-)) pero vi que al pulsar el botón correspondiente  (S_MAG_PAD) o (S_MAG_PUD) pero al soltarlo se apaga  (LUZ_PAD  y SIRENA)  de hay le puse un delay pero no funciono mi idea porque hay se quedaba realizando el delay Y mientras que estaba en el delay pulsaba el botón ON_OF no lo respeta supongo que es porque hasta que salga del delay continua realizando el programa que es apagar (LUZ_PAD) Y (SIRENA)  y asi es
Deduzco que debe de ver algún truco de programación o algún método para corregir esto me puede decir que es para que estudie sobre eso y poder anexarlo para que cuando este en el delay si acciono el botón ON_OF se apague la alarma
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 06 de Abril de 2016, 02:25:33
Intenta explicar como queres que funcione.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 06 de Abril de 2016, 03:12:53
ok lo que quiero es que según sensor magnético se dispara con solo dispararse se debe tomar acción esto es que la luz parpadee en forma de flas por lo menos unos 20 minutos hasta que alguien apague la alarma y la sirena encendida continuamente por 20 minutos pero si yo vengo con mi control y aun solo paso 5 min de activada la alarma pues se apague si pulso el ON-OF
nota si es difícil lo de parpadear un led lo dejamos fijo el mismo tiempo que la sirena y el parpadeo lo tendré que hacer con electrónica aunque me quisiera ahorrar la electrónica que utilizare para parpadear la luz con programar esa parte pero si es complicado ni modo tendré que compra la electrónica para que parpadee
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 06 de Abril de 2016, 04:24:15
Todo se puede hacer pero para no complicarla demasiado, mejor aprender a usar el timer, asi que create un programa simple ( si uno nuevo por ahora ) que encienda un led cada 0.5s (o 1segundo mejor) aproximadamente, el programa te quedaria algo asi:

Código: C
  1. void main(void)
  2. {
  3.          Configura salidas/entradas
  4.          Configura el Timer.
  5.          Activa las interrupciones
  6.  
  7.          while(1) {};
  8. }
  9.  
  10. #INT_TIMER1
  11. void  TIMER1_isr(void)
  12. {
  13.           set_timer1(0x0000);        //Cargar el timer 1 con el valor correspondiente
  14.           output_toggle(PIN_D0)
  15. }

De seguro que hay ejemplos realizados por internet, Pero primero hace eso y luego se lo incorporamos a lo que tenes.

Y si no sabes como calcular el tiempo del timer, hay herramientas que te permiten mover el tiempo, preescaler, frecuencia del oscilador para que sepas que frecuencia y tiempo conseguis:

http://eng-serve.com/pic/pic_timer.html

Procura usar el timer1 que es el de 16bits

EDIT:

Algo de lectura:
http://www.aquihayapuntes.com/indice-practicas-pic-en-c/uso-del-tmr1-como-temporizador.html
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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)
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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 )
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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.     }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
                    }
            }
    }



Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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. }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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:
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC 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.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo 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
         
       
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 10 de Abril de 2016, 04:26:29
Bueno continuamos primero explico la lógica que quiero que haga esta alarma lo he pensado que sea de 3 etapas la forma de persuadir al rata al activar (S_MOV_P AD) alarma es luminosa que es hasta donde esta ahorita pero si continua dentro del patio y se para cerca de (S_MOV_PUD) que lo trate de persuadir ahora con la SIRENA  y la última etapa es si la LUZ  y la SINERA  no es suficiente y abre la puerta que es (S_MAG_PUD) pues que realice la llama como ves me paso verdad jejejej lo complico mucho
1.Si (S_MOV_PAD) =1 encender (LUZ_PAD) parpadean hasta que (LED_ON_OF)=0 esto está hecho
2.Si (S_MOV_PAD)=1 + (S_MOV_PUD)=1 dar salida a 1 (LUZ_PAD) pero parpadeando mas (SIRENA)=1
3.Si (S_MOV_PAD)=1 + (S_MOV_PUD)=1+(S_MAG_PUD)=1 dar salida (LUZ_PAD) pero parpadeando+(SIRENA)+(LLAMAR) y luego colgar

Para la segunda opción  sería así verdad

 if((input(S_MOV_PAD)==1) && (input(S_MOV_PUD)==1))
output_high (SIRENA);

output_high (LUZ_PAD);//se que estos mal por que ya lo hase aora ya parpadea y a esto le falta un delay para que parpadee jejeje

Bueno la duda es como tener una segunda opción de condición en mi mente lo veo que tiene que ser independiente??????
cuál sería la variable que checaría su estado (SalidaActiva) o (S_MOV_PAD) para sumarle una segunda condición

Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 10 de Abril de 2016, 04:32:32
fijate que encontre esto la verdad que es muy tarde son las 2:30am pero sirve de aporte al fora la encontre como libreia de control de pines la verdad no la revise toda ni la analise por que ya tengo sueño pero la ponder aqui


Módulo IO y manipulación de pines

Muestra las funciones para poder trabajar con los pines del PIC.

   #include <pinio.h>
      

output_high_slow

Establece un PIN a un estado alto de voltaje. Verifica el estado del tris.

   void output_high_slow(   BYTE puerto,
            BYTE pin);
   ejemplo:
   output_high_slow(PIN_B0);

      

output_high_fast

Establece un PIN a un estado alto de voltaje. No verifica el estado del tris.

   void output_high_fast(   BYTE puerto,
            BYTE pin);
   ejemplo:
   output_high_fast(PIN_B0);

      

output_high

Establece un PIN a un estado alto de voltaje. La verificación del estado del tris depende de habilitar el macro SLOW_IO como TRUE o FALSE.

Por defecto, si no se escribe #define SLOW_IO TRUE , SLOW_IO tiene el valor de TRUE.

   #define SLOW_IO TRUE

   void output_high(   BYTE puerto,
            BYTE pin);
   ejemplo:
   output_high(PIN_B0);

      

output_low_slow

Establece un PIN a un estado bajo de voltaje. Verifica el estado del tris.

   void output_low_slow(   BYTE puerto,
            BYTE pin);
   ejemplo:
   output_low_slow(PIN_B0);

      

output_low_fast

Establece un PIN a un estado bajo de voltaje. No verifica el estado del tris.

   void output_low_fast(   BYTE puerto,
            BYTE pin);
   ejemplo:
   output_low_fast(PIN_B0);

      

output_low

Establece un PIN a un estado bajo de voltaje. La verificación del estado del tris depende de habilitar el macro SLOW_IO como TRUE o FALSE.

Por defecto, si no se escribe #define SLOW_IO TRUE , SLOW_IO tiene el valor de TRUE.

   #define SLOW_IO TRUE

   void output_low(   BYTE puerto,
            BYTE pin);
   ejemplo:
   output_low(PIN_B0);

      

input_slow

Devuelve el estado de un pin. puede ser 1 o 0. Verifica el estado del tris.

   BYTE input_slow(   BYTE puerto,
            BYTE pin);
   ejemplo:
   input_slow(PIN_B1);

      

input_fast

Devuelve el estado de un pin. puede ser 1 o 0. No verifica el estado del tris.

   BYTE input_fast(   BYTE puerto,
            BYTE pin);
   ejemplo:
   input_fast(PIN_B1);

      

input

Devuelve el estado de un pin. puede ser 1 o 0. La verificación del estado del tris depende de habilitar el macro SLOW_IO como TRUE o FALSE.

Por defecto, si no se escribe #define SLOW_IO TRUE , SLOW_IO tiene el valor de TRUE.

   #define SLOW_IO TRUE

   BYTE input(   BYTE puerto,
         BYTE pin);
   ejemplo:
   input(PIN_B1);

      

set_pin_to_slow

Establece el estado de un pin a 1 o 0. Verifica el estado del tris.

   void set_pin_to_slow(   BYTE puerto,
            BYTE pin,
            BYTE X);

   ejemplo:
   set_pin_to_slow(PIN_C1,1);//el pin C1 ahora tiene un estado alto
   set_pin_to_slow(PIN_C1,0);//el pin C1 ahora tiene un estado bajo
      

set_pin_to_fast

Establece el estado de un pin a 1 o 0. No verifica el estado del tris.

   void set_pin_to_fast(   BYTE puerto,
            BYTE pin,
            BYTE X);

   ejemplo:
   set_pin_to_fast(PIN_C1,1);//el pin C1 ahora tiene un estado alto
   set_pin_to_fast(PIN_C1,0);//el pin C1 ahora tiene un estado bajo
      

set_pin_to

Establece el estado de un pin a 1 o 0.

La verificación del estado del tris depende de habilitar el macro SLOW_IO como TRUE o FALSE.

Por defecto, si no se escribe #define SLOW_IO TRUE , SLOW_IO tiene el valor de TRUE.

   #define SLOW_IO TRUE

   void set_pin_to(   BYTE puerto,
            BYTE pin,
            BYTE X);

   ejemplo:
   set_pin_to(PIN_C1,1);//el pin C1 ahora tiene un estado alto
   set_pin_to(PIN_C1,0);//el pin C1 ahora tiene un estado bajo
      

set_pin_tris_to

Establece el TRIS de un pin a 1 o 0.

   void set_pin_tris_to(   BYTE puerto,
            BYTE pin,
            BYTE X);

   ejemplo:
   set_pin_tris_to(PIN_C1,1);//el TRIS C1 ahora tiene un estado alto
   set_pin_tris_to(PIN_C1,0);//el TRIS C1 ahora tiene un estado bajo
      

set_porta_as_digital

Establece el puerto A como DIGITAL.

   #define set_porta_as_digital() ADCON1=0x06

   ejemplo:
   set_porta_as_digital();
      

set_pullup_portb

Habilita o deshabilita las resistencias de pull-up del puerto B.

Para habilitar las resistencias de pull-up X= 1 o TRUE.

Para deshabilitar las resistencias de pull-up X= 0 o FALSE.

   void set_pullup_portb(BYTE X);
      

Ejemplo de PinIO

Para compilar necesitas los siguientes comandos.

Ejemplo de compilacion : ./compila.sh ej_pinio 16f877a
      

ej_pinio.c

#include <pic/p16f877a.h>

#define FOSC_HZ 20000000

#include <pinio.h>
#include <delayms.h>

int main (void)
{
   delayms(100);

   while(TRUE)
   {
      delayms(50);
      output_high(PIN_C2);
      delayms(50);
      output_low(PIN_C2);

      if(input(PIN_A4)==1) output_high(PIN_B7);
      else                 output_low (PIN_B7);
   }
   return 0;
}
      
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 10 de Abril de 2016, 05:52:57
Respecto a la libreria pinio.h pienso que es agregar mas problema a lo que ya existe, con las funciones que trae de base CCS se puede hacer tranquilamente. Y lo unico que tenes que optar es por poner FAST_IO o no al comienzo.

Respecto al programa entiendo lo que queres hacer. Pone el programa como lo tenes realizado y de ahi vemos.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 10 de Abril de 2016, 12:40:49
asta aqui va el progrma 

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==8)
  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.  
  48.             // Aca el setup de pines/modulos/etc
  49.  
  50.             set_tris_B(0b11111111);         //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
  51.             set_tris_D(0b00000000);         // asigno todo el puerto D como salidas
  52.             output_D(0b00000000);
  53.  
  54.  
  55.             setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  56.             set_timer1 (3036);
  57.             enable_interrupts(int_timer1);
  58.             enable_interrupts(global);
  59.  
  60.             // Comienzo del programa principal
  61.  
  62.             while(true)
  63.             {
  64.                     if(input(E_ON_OF)==1)                   // Pregunto si la entrada del pin B0 es igual a 0
  65.                     {
  66.                             delay_ms(10);                   // Espero 10ms por si la llave esta rebotando (variando entre 1 y 0 )
  67.                             while(input(E_ON_OF)==1);       // Espero que suelte el boton, observa el ; al final, es decir un while(){}
  68.                             output_toggle(LED_ON_OF);       // Cambio el valor del pin
  69.  
  70.                     }
  71.  
  72.                     if(input(LED_ON_OF)==1)                  //pregunto si (LED_ON_OF)==1 si es verdad pasa a la siguiente linea
  73.                     {
  74.                             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
  75.                             {
  76.                                     SalidaActiva=1;
  77.                             }
  78.                     }
  79.                     else
  80.                     {
  81.                             SalidaActiva=0;
  82.                     }
  83.             }
  84.     }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 10 de Abril de 2016, 14:04:06
Para la segunda opción  sería así verdad

Código: C
  1. if((input(S_MOV_PAD)==1) && (input(S_MOV_PUD)==1))
  2. output_high (SIRENA);

Código: C
  1. output_high (LUZ_PAD);//se que estos mal por que ya lo hase aora ya parpadea y a esto le falta un delay para que parpadee jejeje

Bueno la duda es como tener una segunda opción de condición en mi mente lo veo que tiene que ser independiente??????
cuál sería la variable que checaría su estado (SalidaActiva) o (S_MOV_PAD) para sumarle una segunda condición
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 10 de Abril de 2016, 14:18:10
1.Si (S_MOV_PAD) =1 encender (LUZ_PAD) parpadean hasta que (LED_ON_OF)=0 esto está hecho
2.Si (S_MOV_PAD)=1 + (S_MOV_PUD)=1 dar salida a 1 (LUZ_PAD) pero parpadeando mas (SIRENA)=1
3.Si (S_MOV_PAD)=1 + (S_MOV_PUD)=1+(S_MAG_PUD)=1 dar salida (LUZ_PAD) pero parpadeando+(SIRENA)+(LLAMAR) y luego colgar

Vamos por parte... La primera esta realizada.
La 2da mi pregunta es... necesitas que la sirena se active y desactive cada cierto tiempo (Algo asi como la luz) o simplemente necesitas que este en 1 siempre hasta que obviamente se desactive la alarma.

La 3era la pregunta es la misma. Sirena + LLamar y luego colgar, deben respetar algun tiempo ? Por ejemplo llamar debe estar activo por 10segundos y luego colgar activo 2 segundos mas.

Defini exactamente como es que queres que funcione, con tiempos, que ocurriria si por ejemplo se desactiva una de las entradas, esto para cada caso, pensa en todos los posibles opciones que puede ocurrir. Luego vemos si es necesario agregar otras cosas al timer, Ya que siguiendo tu logica con 3 ifs bastaria, en ves de lo ya realizado.
Imaginate que pasaria si el primer sensor ( S_MOV_PAD ) no detecta nada y los demas si ?

Código: C
  1. if(S_MOV_PAD==1)
  2. {
  3.  
  4.         //Caso de S_MOV_PAD solo
  5.  
  6.         if(S_MOV_PUD==1)
  7.         {
  8.  
  9.                 //Caso de S_MOV_PAD + S_MOV_PUD
  10.  
  11.                 if(S_MAG_PUD==1)
  12.                 {
  13.  
  14.                         //Caso de S_MOV_PAD + S_MOV_PUD + S_MAG_PUD
  15.  
  16.                 }
  17.         }
  18. }

Aunque falta que nombres todas las condiciones posibles.

EDIT: Me olvide decirte el codigo es de referencia. No va a funcionar un copy & paste.

Citar
Bueno la duda es como tener una segunda opción de condición en mi mente lo veo que tiene que ser independiente??????
cuál sería la variable que checaría su estado (SalidaActiva) o (S_MOV_PAD) para sumarle una segunda condición

No entendi que querias hacer, si lo podes explicar con simples palabras como es que queres que funcione seria mas facil.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 10 de Abril de 2016, 22:12:07
Bueno continuamos primero explico la lógica que quiero que haga esta alarma lo he pensado que sea de 3 etapas la forma de persuadir al rata al activar (S_MOV_P AD) alarma es luminosa esta puede estar parpadeando asta que se apague la alarma eso no hace ruido que es hasta donde esta
ahorita pero si continua dentro del patio y se para cerca de (S_MOV_PUD) que lo trate de persuadir con LUZ y SIRENA y la última etapa es si la LUZ  y la SINERA  no es suficiente y abre la puerta que es (S_MAG_PUD)=1 pues que realice la llama como ves me paso verdad jejejej lo complico mucho

1.Si (S_MOV_PAD) =1 encender (LUZ_PAD) parpadean hasta que (LED_ON_OF)=0  o hasta un reseteado total de 30 minutos que se pondrá todo de nuevo en estado de alerta.

2.Si (S_MOV_PAD)=1 + (S_MOV_PUD)=1 dar salida a 1 (LUZ_PAD) pero parpadeando mas (SIRENA)=1 hasta que           (LED_ON_OF)=0  o hasta un reseteado total de 30 minutos que se pondrá todo de nuevo en estado de alerta.

3.Si (S_MOV_PAD)=1 + (S_MOV_PUD)=1+(S_MAG_PUD)=1 dar salida (LUZ_PAD) pero parpadeando+(SIRENA)+(LLAMAR) y luego (COLGAR)

Condición de llamar y colgar  if (((S_MOV_PAD)=1) && ((S_MOV_PUD)=1)&&((S_MAG_PUD)=1)) //espero que este bien ya ya aquí practico lo que me enseñaste de los paréntesis de hay dar salida en (LUZ_PAD) parpadeante y (SIRENA)=1 y (LLAMAR)=1 por un tiempo de 30 ms de hay (LLAMAR)=0 esperar 5 segundos y dar salida en (COLGAR)=1 por 30 ms de hay esperar 5 segundos e iniciar nuevamente esto por 4 veces para que llame 4 veces solo llamara 4 veces o antes si  (LED_ON_OF)=0  claro estará (LUZ_PAD) y sirena activas por 30 minuto hasta que se resetee todo y se coloque en esto de alerta otra ves
Nota como ves todas las condiciones estarán sujetas a apagarse si (LED_ON_OF)=0 y tendrá un reset general a los 30 minutos y se pondrá en estado de alerta otra ves

Veo con todo esto 2 condiciones que no se tome encuenta creo que hay que colocarse si por algún motivo (S_MOV_PAD) no detectara el intruso y llegara a la puerta donde tengo(S_MOV_PUD) no haría nada la alarma aunque este último lo detecte por como está condicionado a que tiene que estar en 1 el (S_MOV_PAD)=1 no hará nada por esta razón debe de tener 2 condiciones mas 1 en donde  si se activa solo (S_MOV_PUD) y la otra si (S_MAG_PUD)=1

4.-(S_MOV_PUD)=1  dar salida en (LUZ_PAD)=1 parpadeante y (SIRENA)=1 esto por 30 min o antes si (LED_ON_OF)=0  esto estará (LUZ_PAD) y sirena activas por 30 minuto hasta que se resetee todo y se coloque en esto de alerta otra vez

5.- .-(S_MAG_PUD)=1  dar salida en (LUZ_PAD) parpadeante y (SIRENA)=1 y [ (LLAMAR)=1 por un tiempo de 30 ms de hay (LLAMAR)=0 esperar 5 segundos y dar salida en (COLGAR)=1 por 30 ms de hay esperar 5 segundos e iniciar nuevamente esto por 4 veces para que llame 4 veces loso llamara 4 veces o antes si  (LED_ON_OF)=0  claro estará (LUZ_PAD)y sirena activas por 30 minuto hasta que se resetee todo y se coloque en esto de alerta otra ves] es la misma salida que la 3

Todo esto es para hacerlo lo ,as apegado a la realidad espero me haya explicado creo que con esto sería una alarma real 
Dejo un enlace para que veas lo del celular
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 10 de Abril de 2016, 23:43:47
nohtml5=False
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 11 de Abril de 2016, 04:52:54
Entiendo lo que queres hacer pero...

Citar
Todo esto es para hacerlo lo mas apegado a la realidad espero me haya explicado creo que con esto sería una alarma real 

Pero ahi te estas equivocando, lo mas cercano a la realidad es que si se detecta algo Si o Si se dispare la alarma que no depende de la luz por si es que debe disparar la alarma. Una ves disparada la alarma se procede a llamar, los sensores de movimiento que pueden disparar la alarma van dentro de la casa asi como los magneticos, si tenes uno afuera tal ves sea para la luz nomas, pero este no deberia influir en nada al funcionamiento de la alarma. Estas intentando crear algo complicado cuando es tan simple.

Entonces tenes que distinguir:

Sensores para la alarma y sensores para las luces.
Para la alarma van a ser sensores magneticos en puertas y ventanas + sensores de movimiento en todas las habitaciones.

Para las luces, van a ser sensores de movimiento solo para esas luces.

Otra de las cosas, encender y apagar la luz acortaria la vida de la luz rapidamente, especialmente ahora que casi todo posee lamparas bajo consumo fluorescentes ( LFC ), y hacer lo que pensas lo destruiria, mejor que este activo un tiempo y luego se corte, como toda luz exterior.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 11 de Abril de 2016, 14:37:49
Si es correcto lo que dices lo que pasa es que yo quería evitar una forma de persuadir a un intruso antes que cause un daño en la propiedad por eso los sensores afuera y en la puerta es que aquí los ratas le dan duro a las puertas o sea de golpes y a mi parecer asta podrian romperían los sensores magnéticos puesto en puertas o ventanas ok entera lo voy a analizar dame chance  saludos

tu me dises algo como esto pero mejorado jejejeje verdad 

Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 11 de Abril de 2016, 20:24:11
Si es correcto lo que dices lo que pasa es que yo quería evitar una forma de persuadir a un intruso antes que cause un daño en la propiedad por eso los sensores afuera y en la puerta es que aquí los ratas le dan duro a las puertas o sea de golpes y a mi parecer asta podrian romperían los sensores magnéticos puesto en puertas o ventanas ok entera lo voy a analizar dame chance  saludos

Ese video es un insulto a una alarma. Pero si. mejorado.

Con respecto a la forma de persuadir al intruso ...

- No podes guiarte por sensores de movimiento en el patio, ya que puede moverse cualquier cosa y tal ves disparar la alarma. Pero una luz no lastima a nadie.
- Si te rompen el sensor magnetico el cual primero deberian abrir si o si la puerta para hacerlo ya que suelen estar agregados al marco. Se dispararia antes la alarma.
- Si rompen la ventana pero no la abren, se usa el sensor de movimiento de adentro de la habitacion.

El tema es que vos estas pensando poner sensores de movimiento en espacios abiertos. Y no solo 1 , sino 2 o mas, y nada dentro de la casa.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 13 de Abril de 2016, 00:13:15
OK si e sierto ninguno jejeje parese que doy por hecho que no fallaran los de afuera verdad jejeje por lo menos dos dentro deverian de estar
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 14 de Abril de 2016, 12:40:20
Continuamos con el programa killer jc ojala que pronto ya pueda pasar a la etapa de pruebas físicas  :mrgreen: veo que voy a tardar en terminar jejeje y segun yo que queria practicar con una criansa para pesese o para pollos cuando terminara jejejeje seguire practicando voy a buscar como se puede ver un progrma paso a paso en ccs para ver donde se queda el progrma exactamente y atacar esa parte saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 17 de Abril de 2016, 01:14:34
no alcanso a leer esto
Código: C
  1. if((input_b() & 0b01111000) != 0)
si la entrada del puesto b pero tengo duda por el paréntesis vacío y luego dice y las terminales del puerto b que estén en entradas y salidas luego un signo que significa complemento es igual a cero no lo comprendo

Código: C
  1. unsigned int8   ContadorLuz = 0;         //asigno una variable de tipo entero de 8 bay con el nombre de ContadorLuz y la inicializo en cero

y todo esto se lee asi como los comentarios que le puse a los comentarios

Código: C
  1. // Contador que maneja el Timer de la luz
  2.  
  3.         if(LuzActiva == 1)                     //si LuzActiva es igual a 1              
  4.         {
  5.                 ContadorLuz++;                      //aumenta variable ContadorLuz en 1
  6.                 if(ContadorLuz == 60)                                   // 30 seg = 60 entradas
  7.                 {
  8.                         output_low(LUZ_PAD);             //dar una salida baja en el pin D0 que esta asignado como LUZ_PAD          
  9.                         ContadorLuz = 0;                 //asigno un cero       ContadorLuz
  10.                         LuzActiva = 0;                   //asigno un cero     LuzActiva
  11.                 }
  12.         }

Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 17 de Abril de 2016, 05:46:45
no alcanso a leer esto
Código: C
  1. if((input_b() & 0b01111000) != 0)
si la entrada del puesto b pero tengo duda por el paréntesis vacío y luego dice y las terminales del puerto b que estén en entradas y salidas luego un signo que significa complemento es igual a cero no lo comprendo

input_b() es una funcion, que no necesita ningun argumento, output_low(PIN_xx) es una funcion que necesita un argumento, esta funcion ( input_x() ) devuelve el valor de TODO el puerto y no solo de 1 pin, es decir si es input_c() me va a devolver 8 bits, los cuales cada uno corresponde a PIN_C0 , PIN_C1, etc.. Lo mismo ocurre con input_b() nomas que ahora pido que esa funcion me devuelta 8 bits ( 1 byte )

Respecto a las funciones, Por ejemplo cuando creas una funcion

Código: C
  1. void RevisarDatos(void)
  2. {
  3.        //Aca instrucciones
  4. }

Esta funcion al no recibir ningun argumento ( por eso el void dentro de los parentesis ) ni devolver ningun dato ( por eso el void del comienzo ) se debe llamar asi:

Código: C
  1. RevisarDatos();   //Correcto
  2. RevisarDatos(0x10);   //Incorrecto por que no recibe argumentos
  3. RevisarDatos() & 10;   //Incorrecto por que no devuelve nada
  4. Datos = RevisarDatos();   //Incorrecto por que no devuelve nada

Tambien podes tener alguna que devuelva un dato, y que ademas reciba un dato. Pero ejemplo recibir un numero de 16 bits ( 2 bytes ), y que devuelta solo los 8bit de menor peso ( es decir el byte de la derecha ).

Código: C
  1. int8 DevolverNumero( int16 Numero)
  2. {
  3.       return (int8)Numero;
  4. }

Entonces si tenes:

Código: C
  1. int8 dato;
  2. dato = DevolverNumero(0x1250);

Dato va a tener el valor 0x50.

Lo demas es una AND binaria &, lo cual corresponde que si el bit de la misma posicion es 0, la salida va a ser 0, y si ambos son 1, la salida es 1, esto me permite filtrar algunas entradas. Suponete ahora que por el puerto B tenes algo asi 10101010, y le hago una AND con 01111000, el resultado eso:

10101010
01111000
---------------
00101000

Es decir si te fijas donde estaban los 1 eso quedo como estaba. Y lo demas lo puse en 0 por que no me interesa, supuestamente si no tenes NINGUNA entrada activa todas deberian estar en 0, si es asi el resultado de esa AND va a ser 0, y cuando se compare va a dar falso.

!= no es complemento, es una operacion logica y quiere decir NO ES IGUAL A

SI (  (PuertoB AND 0b01111000) NO ES IGUAL A 0)

O con una mayor traduccion

SI (  (PuertoB pin de 3 a 6 ) NO ES IGUAL A 0)

Código: C
  1. unsigned int8   ContadorLuz = 0;         //asigno una variable de tipo entero de 8 bay con el nombre de ContadorLuz y la inicializo en cero

Eso se entiende como un entero ( int ) de 8 bits (por eso el 8, esto es unico de CCS OJO! ) y sin signo ( unsigned ) llamado ContadorLuz, y que al momento del arranque del micro, debe comenzar con un valor de 0.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 17 de Abril de 2016, 15:48:45
Asu mecha veo las cosas que se pueden colocar con código me refiero a esto (  if((input_b() & 0b01111000) != 0)) la verdad es la primera ves que me topo con algo asi claro es verdad jejejeje me refiero a primera ves porque estoy aprendiendo 
Ahora bien e analizado esto y tengo los siguientes conjeturas primero  leo los estados presente de todo el puerto B y los comparo con el siguiente valor binario 0b01111000 y si no es igual a cero que haga lo que sigue del código es asi verdad

Bueno la conjetura es que debo de cambiar este 0b01111000 por 01111110  y mejor dicho lo cambie y mejoro un poco el programa porque ahora si censa todas las entradas a como estaba fíjate que solo censaba una entrada y así ya censa todas

Bueno ahora buscare porque solo es que cuando se activa algún sensor el programa solo da una salida la de llamar y ni la luz ni la sirena nada asta y se queda. SI  Censa cambio en el puerto B  y si da salida pero solo una que es llamar de hay nada de nada 
Otra pregunta necesito entender el flujo de las funciones para que pueda comprender y detectar en que parte del código se queda el programa osea a lo que me refiero es que necesito entender por ejemplo
Código: C
  1. // Contador que maneja el Timer de la luz
  2.  
  3.         if(LuzActiva == 1)
  4.         {
  5.                 ContadorLuz++;
  6.                 if(ContadorLuz == 60)                                   // 30 seg = 60 entradas
  7.                 {
  8.                         output_low(LUZ_PAD);
  9.                         ContadorLuz = 0;
  10.                         LuzActiva = 0;
  11.                 }
  12.         }
  13.         else
  14.         {
  15.                 output_low(LUZ_PAD);
  16.                 ContadorLuz = 0;
  17.         }

bueno te explicare como lo entiendo y asi podrar ver a que me refiero con el flujo de la funcion
bueno primero tenemos
  if(LuzActiva == 1) y yo lo leo como si LuzActiva es 1 continua la siguiente linea del codigo que es el {
 { osea abrimos un corchete en el cual se anidan un congunto de intrucciones de hay sigue
ContadorLuz++; osea el valor de ContadorLuz incrementamos en 1 valía 0 por que lo inicializamos al comienzo del programa sea 0   que ahora vale 1 de hay sigue la siguiente línea del código
if(ContadorLuz == 60)   donde se pregunta si contador vale 60 como no vale 60 como vale 60 de hay que hace sigue la siguiente línea de codigo si es asi seguiría
{ se abre otro corchete uunnm no se por que donde meteremos otro grupo de instrucciones bueno aqui cabe preguntar si no e serrado el primero este segundo seria como una opción secundaria del primero del primer corchete o es alrebes primero se cumple las instrucciones de este segundo corchete y ya terminado continua ejecutando las primeras instrucciones por eso es toy perdido no comprendo uno las prioridades de los corchetes {} y dos si el código tiene 14 lineas primero hase por ejemplo las primeras 4 de hay regresa ala línea 1 y como no se a cumplido el aumento del contados hay se queda asta que se cumpla el contador =60
si se cumple pasa a la siguiente línea que es output_low(LUZ_PAD); que es apagar LUZ_PAD si es asi cuando se ensenderia LUZ_PAD aver si me explique en la comprensión del flujo del código que te puse arriba

Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 19 de Abril de 2016, 01:18:49
hola alguien me ayuda por favor nesecito ayuda para entender un programa y asi ver si lo puedo componer saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 19 de Abril de 2016, 05:53:50
Citar
Bueno la conjetura es que debo de cambiar este 0b01111000 por 01111110  y mejor dicho lo cambie y mejoro un poco el programa porque ahora si censa todas las entradas a como estaba fíjate que solo censaba una entrada y así ya censa todas

Eso fue por que yo solo queria que se activara la sirena con las entradas de adentro nomas y no la externas, que las externas solo encendieran la luz.

Citar
Otra pregunta necesito entender el flujo de las funciones para que pueda comprender y detectar en que parte del código se queda el programa

Te lo estoy escribiendo bastante simple, el espacio al frente de las intrucciones no estan sin sentido, estan para ayudar a la lectura.

Código: C
  1. if(LuzActiva == 1)
  2.         {
  3.                 ContadorLuz++;
  4.                 if(ContadorLuz == 60)                                   // 30 seg = 60 entradas
  5.                 {
  6.                         output_low(LUZ_PAD);
  7.                         ContadorLuz = 0;
  8.                         LuzActiva = 0;
  9.                 }
  10.         }
  11.         else
  12.         {
  13.                 output_low(LUZ_PAD);
  14.                 ContadorLuz = 0;
  15.         }

Si te fijas en la misma linea vertical del if, yo puse el else, para que te dieras cuenta rapidamente que ese else pertenece a ese if, es decir que si se cumple la condicion del if, va a ejecutar todo el bloque que encierra sus llaves ( que si te fijas tiene un espacio mas para que sepas lo que conforma TODO el bloque ) de no producirse la condicion es ejecuta el else.

Supongamos que LuzActiva es igual 1. Ahora se debe ejecutar esto:

Código: C
  1. ContadorLuz++;
  2.                 if(ContadorLuz == 60)                                   // 30 seg = 60 entradas
  3.                 {
  4.                         output_low(LUZ_PAD);
  5.                         ContadorLuz = 0;
  6.                         LuzActiva = 0;
  7.                 }

Sumo 1 a ContadorLuz, y se va a ir acumulando cada ves que entre. Mientras no sea igual a 60 solamente se va a producir el incremento de ContadorLuz y se sale del if del LuzActiva.
Cuando se cumple la condicion de que ContadorLuz era 59, entro, se incremento en 1, ahora es 60, se pregunta en el if y cumple la condicion, entonces recien ahi ejecuta lo de adentro del if, es decir:

Código: C
  1. output_low(LUZ_PAD);
  2.                         ContadorLuz = 0;
  3.                         LuzActiva = 0;

Apagando la luz, poniendo el contador a 0 para que comienze de nuevo, Y apagando el tema de LuzActiva. asi ya no vuelve a entrar hasta que el sensor nuevamente detecte algo y ponga el mismo a LuzActiva en 1, para comenzar todo de nuevo.


Citar
si se cumple pasa a la siguiente línea que es output_low(LUZ_PAD); que es apagar LUZ_PAD si es asi cuando se ensenderia LUZ_PAD aver si me explique en la comprensión del flujo del código que te puse arriba

LUZ_PAD se encenderia al momento en que el sensor detecte algo, en la rutina principal
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 20 de Abril de 2016, 01:05:13
Tienes razón killer jc si veo que eres bueno al escribir e código con orden y respetando la buena imagen lo veré de nuevo con esta nueva perspectiva que me dijiste haber si veo por qué no enciende la LUZ_PAD o la SIRENA ni realiza la rutina de llamar voy a abrir bien los ojos y pediré a los guru de la programación que me den entendimiento jejejeje saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 20 de Abril de 2016, 19:32:29
pregunta??? ¿la forma de activar cada una de las funciones? según yo esto se hace en el programa principal verdad???? ósea que en el programa principal se llama a la función o se activa la función como se dice 


Código: C
  1. void main(void)
  2. {
  3.  
  4.         // Aca el setup de pines/modulos/etc
  5.  
  6.         set_tris_B(0b11111111);         //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
  7.         set_tris_D(0b00000000);         // asigno todo el puerto D como salidas
  8.         output_D(0b00000000);
  9.  
  10.  
  11.         setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  12.         set_timer1 (3036);
  13.         enable_interrupts(int_timer1);
  14.         enable_interrupts(global);
  15.  
  16.         // Comienzo del programa principal
  17.  
  18.         while(true)
  19.         {
  20.                 if(input(E_ON_OF)==1)                   // Pregunto si la entrada del pin B0 es igual a 0
  21.                 {
  22.                         delay_ms(10);                   // Espero 10ms por si la llave esta rebotando (variando entre 1 y 0 )
  23.                         while(input(E_ON_OF)==1);       // Espero que suelte el boton, observa el ; al final, es decir un while(){}
  24.                         output_toggle(LED_ON_OF);       // Cambio el valor del pin
  25.  
  26.                 }
  27.  
  28.                 if(input(LED_ON_OF)==1)
  29.                 {
  30.                         if((input(S_MOV_PAD)==1))
  31.                         {
  32.                                 LuzActiva = 1;//[color=blue] aqui se activa o se llama a que se ejecute la funcion LuzActiva verdad[/color]
  33.                         }
  34.                         if((input_b() & 0b01111000) != 0)       // Es decir se activo algun sensor interno, entonces active la sirena y la llamada.
  35.                         {
  36.                                 SirenaActiva = 1;   // [color=blue]aqui se activa o se llama a que se ejecute la funcion SirenaActiva verdad[/color]
  37.                                 LLamadaActiva = 1;// [color=blue]aqui se activa o se llama a que se ejecute la funcion SirenaActiva verdad[/color]
  38.                         }
  39.                 }
  40.                 else
  41.                 {
  42.                         LuzActiva=0;
  43.                         SirenaActiva = 0;
  44.                         LLamadaActiva = 0;
  45.                         ContadorParaReset = 0;
  46.                 }
  47.         }
  48. }

lo que marque de axul es donde se llam o se actiba las funciones verdad estoy mal
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 20 de Abril de 2016, 19:47:38
Lo que pones en code, no toma ningun formato :P

Pero ahi veo, si, lo que hago es simplemente poner a 1 una variable, para que cuando entre al timer actue. Nada mas. Ahora me doy cuenta que le faltaba algo a la funcion de interrupcion:


Código: C
  1. if(LuzActiva == 1)
  2.         {
  3.                 output_high(LUZ_PAD);                          // Esto le faltaba, asi se enciende la luz.
  4.                 ContadorLuz++;
  5.                 if(ContadorLuz == 60)
  6.                 {
  7.                         output_low(LUZ_PAD);
  8.                         ContadorLuz = 0;
  9.                         LuzActiva = 0;
  10.                 }
  11.         }
  12.         else
  13.         {
  14.                 output_low(LUZ_PAD);
  15.                 ContadorLuz = 0;
  16.         }

Ahi comente la instruccion, tal ves a la de la sirena tambien le falte lo mismo.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 21 de Abril de 2016, 00:40:48
ok si lo colocare y simulare a ver qué tal  gracias ya lo había visto pero aquí en México se dice
¡¡el que no sabe es como el que no ve!! jejejeje  :D :D
te imaginas e visto el programa unas 80 de veces queriéndole  hacerle un conjuro haaablaaaameee haaablameee  programa y nada que me habla  jejejeje
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 21 de Abril de 2016, 02:49:04
hasta casi la1 am le di al conjuro del programa pero como no funciono mejor le puse unas 2 líneas de lo que me has enseñado y ya mejoro un poco hay ba ya aunque a la mitad uuuffff a sido un buen camino falta a  ahora la llamada si llama pero hasta ay queda no cuelga ni vuelve a llamar voy a mirar con lupa a ver que veo
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Abril de 2016, 19:47:49
hola killer jc una pregunta e visto que la funcion LUZ_PAD Y SIRENA estan resetenado en diferentes tiempo y e visto que es por ue una lo hace con un retardo y el otro con retardo
Código: C
  1. if(LuzActiva == 1)
  2.         {
  3.       output_high(LUZ_PAD);  //esto le puse yo
  4.         ContadorLuz++;
  5.                 if(ContadorLuz == 60)
y el otro asi
Código: C
  1. if( SirenaActiva == 1 )
  2.         {
  3.       output_high(SIRENA);          //OJO OJO esto le puse yo nota le quise poner    output_high(SirenaActiva); pero me marco errooor
  4.         ContadorParaReset++;
  5.                 if ( ContadorParaReset >= 240 )         // 30 Minutos = 1800 segundos = 3600 entradas de 0.5s  OJO OJO cambia  3600  por 240 para 2 min y pueda ver si recetea
  6.                 {
claro que no es lo mismo pero al simular funcionan los dos y si respetan  el ON_OF que me dises hase lo mismo de diferente forma verdad
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 22 de Abril de 2016, 20:02:48
Como te decia, la luz al menos como se hizo el codigo es para que funcione solo, cuando el sensor de afuera detecta algo que active la luz, este tiene un "temporizador" propio, como puede encenderse la luz pero no la sirena ( que en caso de la sirena es cuando ya se activa un sensor del interior ) tiene que estar separados, si los pusiera juntos deberian activarse ambos al mismo tiempo.
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Abril de 2016, 20:16:08
aora seguire con lo de la llamada

Código: C
  1. // Contador que maneja el timer de las llamadas
  2.  
  3.         if(LLamadaActiva == 1)
  4.         {
  5.                 if(ContadorLLamada < 26 )
  6.                 {
  7.                         ContadorLLamada++;
  8.                         if( (ContadorLLamada == 0) || (ContadorLLamada == 2) )                  // Primera entrada presiona LLAMAR por 0.5s
  9.                         {                                                                       // Espera 0.5s y presiona LLAMAR de nuevo por 0.5s
  10.                                 output_high(LLAMAR);
  11.                         }
  12.                         else if ( ContadorLLamada == 22 )                                       // Pasan 10 segundos desde que se llamo y se corta
  13.                         {
  14.                                 output_high(COLGAR);
  15.                         }
pienso que se queda aqui
Código: C
  1. if( (ContadorLLamada == 0) || (ContadorLLamada == 2)
por que solo llama por .5s y ya no hace nada no espera el tiempo que es para espera de llamar y menos da salida para colgar que opinas saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Abril de 2016, 20:20:52
ok enterado osea que es el funcionamiento adecuado entiendo gracias ya viste ya empecé a moverle un poco al programa como mover el tiempo de media hora para ver si reseteaba jejeje un poquito osea que poco a poco voy aprendiendo algo
aora seguire de pregunton por lo de la llamada como ya abras visto  :mrgreen:
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 22 de Abril de 2016, 20:21:39
Ten envie el codigo con eso corregido.... Hay un error ahi.. deberian ser:

Código: C
  1. if( (ContadorLLamada == 1) || (ContadorLLamada == 3) )
  2.  else if ( ContadorLLamada == 23 )

Por que apenas entra pasa a 1 antes del primer if, entonces la condicion de ContadorLLamada == 0 nunca se va a lograr. Al aumentarle 1, si se logra.

O... se podria mover ContadorLLamada++; al final de todo esos else de dentro de LLamadaActiva.

Código: C
  1. if(ContadorLLamada < 26 )
  2.                 {
  3.  
  4.                         if( (ContadorLLamada == 0) || (ContadorLLamada == 2) )                  // Primera entrada presiona LLAMAR por 0.5s
  5.                         {                                                                       // Espera 0.5s y presiona LLAMAR de nuevo por 0.5s
  6.                                 xxxx
  7.                         }
  8.                         else if ( ContadorLLamada == 22 )                                       // Pasan 10 segundos desde que se llamo y se corta
  9.                         {
  10.                                xxxx
  11.                         }
  12.                         else
  13.                         {
  14.                                xxxxx
  15.                         }
  16.                         ContadorLLamada++;
  17.                 }
  18.                 else {......}
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 22 de Abril de 2016, 20:34:06
ok enterado gracias lo checo lo sustitullo y lo simulo ya te comento gracias
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 23 de Abril de 2016, 03:11:10
hola simule y no hace mucho con relacion a llamar y detecte que es lo que pasa solo llama una ves pero de hay nada

lo que vi es que deveria de llamar por lo menos 3 veses y tambien 3 veses colgar y entiendo que deveria de ser mas o menos asi aver si me explico o si esta bien la logica
 
output_high(LLAMAR);   //mandamos un 1 como si fuera la primera llamada de hay
delay_ms(10);               //esperamos 10 ms 
output_low(LLAMAR);    //y apagamos la salida de llamada de hay
delay_ms(100);             // esperamos que el cel solito da unas 3  timbradas al numero que ya esta predeterminado por eso este retardo
                                      // de hay que paso este tiempo
output_high(COLGAR);  // damos una salida de 1 a colgar de hay
delay_ms(10);              //esperamos 10 ms y
output_low(COLGAR);   //apagamos colgar

esto seria 3 veses para que llame 3 veses y cuelge 3 veses y el el timer de llamada activa solo me parese que yama una ves y cuelga una ves  no se si me explique ya me voy a dormir ojala que alrato me comentes
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 23 de Abril de 2016, 08:08:57
Entonces hay que reacomodar lo de llamar para que lo haga 3 veces. Yo lo hice para que lo realize una sola ves.

Fijate como esta realizado lo de la llamada, intenta entenderle, fijate que entra cada 0.5s dentro de la interrupcion a aumentar 1 a ContadorLLamada, es decir cada ves que incremente 1 pasaron 0.5s, intenta modificarlo y pegarlo aca y luego vemos como vas y arreglamos las cosas.

PD: En las interrupciones NO podes poner delays!
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 24 de Abril de 2016, 01:12:18
ok una pregunta mas que necesito entender cada vez que sale de un siclo la salida que es LLAMADA se apaga automáticamente ???? cuando termina el siclo o uno también la apaga

por eso ice esto según yo destroce el programa la verdad pero la intención es por ejemplo dar salida a llamada de ahí apagar la salida  de ahí que haya dado las timbradas del cel dar salida a colgar y luego apagar la salida de colgar por eso pregunto lo de arria
Código: C
  1. // Contador que maneja el timer de las llamadas
  2.  
  3. if(LLamadaActiva == 1)
  4.         {
  5.         if(ContadorLLamada < 26 )    //lo cambia de 26 a 27
  6.         {
  7.                 //ContadorLLamada++;
  8.                 if( (ContadorLLamada <= 1) || (ContadorLLamada == 9) || (ContadorLLamada == 18) )// Primera entrada presiona LLAMAR por 0.5s de 3 le puse 9
  9.         {                                                                       // Espera 0.5s y presiona LLAMAR de nuevo por 0.5s
  10.                         output_high(LLAMAR);
  11.         if ((ContadorLLamada ==2) || (ContadorLLamada == 10) || (ContadorLLamada == 19))
  12.          output_low(LLAMAR);
  13.          }
  14.         else if (( ContadorLLamada == 23 ) || (ContadorLLamada == 17) || (ContadorLLamada == 26))       // Pasan 10     segundos  desde que se llamo y se corta tenia 23
  15.                         {
  16.                                 output_high(COLGAR);
  17.             if ((ContadorLLamada ==24) || (ContadorLLamada == 18) || (ContadorLLamada == 27))
  18.             output_low(LLAMAR);
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 24 de Abril de 2016, 07:18:30
Espero que se entienda mejor con esta imagen que es lo que hago:

 - Tienes que ingresar para ver archivos adjuntos -


Arriba puse lo que es "contador LLamada" y con las flechas para arriba cuando es que suma. Por eso comienza de 1.
Si observas mi idea es que cuando esta en 1 y en 3 se de un pulso en LLAMADA, esto por que el primer pulso es para entrar a los telefonos que se llamaron ultimos, y el otro pulso es para realizar la llamada. Luego espera 20 interrupciones mas ( hasta llegar al 23 - 10 segundos ) y procede a dar un pulso de cortar.

Quedan 2 formas de agregar mas llamadas. La primera es agregar mas condiciones. Como ves puede que complique un poco las cosas.

Código: C
  1. if(ContadorLLamada < 255 )
  2.                 {
  3.  
  4.                         if( (ContadorLLamada == 1) || (ContadorLLamada == 3) || (ACA_AGREGAR_RESTANTES))
  5.                         {          
  6.                                 xxxx
  7.                         }
  8.                         else if ( (ContadorLLamada == 23) || (ACA_AGREGAR_RESTANTES) )
  9.                         {
  10.                                xxxx
  11.                         }
  12.                         else
  13.                         {
  14.                                xxxxx
  15.                         }
  16.                         ContadorLLamada++;
  17.                 }
  18.                 else {......}

Suponiendo que quisiera 3 llamadas, separadas por 10 segundos cada una ( 20 ContadorLLamada )
La primera termina a los 23 entrada de la interrupcion. la segunda deberia comenzar a los 43 el primer pulso y 45 el segundo, y cortar a los 65. La tercera comenzar a los 85, el segundo pulso a los 87 y cortar a los 107.
Esto te dejaria el if de activar llamada asi:

Código: C
  1. if( (ContadorLLamada == 1) || (ContadorLLamada == 3) || (ContadorLLamada == 43) || (ContadorLLamada == 45) || (ContadorLLamada == 85) || (ContadorLLamada == 87))
Y el else if asi:
Código: C
  1. else if ( (ContadorLLamada == 23) || (ContadorLLamada == 65) || (ContadorLLamada == 107))

Ademas deberias cambiar el primer if:

Código: C
  1. if(ContadorLLamada < 110 )

Ese if esta para que no cuente hasta 255 y pase a 0, llamando de nuevo. A partir de 110 no entra mas hasta que alguien pone a 0 a LlamadaActiva.

¿Un poquito largos los if verdad? ¿Y que tal si quiero 4/5 o 6 ? Seria un if gigante! y malo. Hay mejor solucion, o tal ves mas practica. Creemos un ContadorVecesLlamada.

Código: C
  1. if(ContadorLLamada < 44 )
  2.                 {
  3.  
  4.                         if( (ContadorLLamada == 1) || (ContadorLLamada == 3) )                  // Primera entrada presiona LLAMAR por 0.5s
  5.                         {                                                                       // Espera 0.5s y presiona LLAMAR de nuevo por 0.5s
  6.                                 xxxx
  7.                         }
  8.                         else if ( ContadorLLamada == 23 )                                       // Pasan 10 segundos desde que se llamo y se corta
  9.                         {
  10.                                xxxx
  11.                         }
  12.                         else if ( ContadorLLamada == 43 )
  13.                         {
  14.                                 if(ContadorVecesLLamada < 3)
  15.                                 {
  16.                                         ContadorLLamada = 0;
  17.                                 }
  18.                                 ContadorVecesLLamada++;
  19.                         }
  20.                         else
  21.                         {
  22.                                xxxxx
  23.                         }
  24.                         ContadorLLamada++;
  25.                 }
  26.                 else {......}

Obviamente con esto hay que modificar otras partes del programa, para que cuando LLamadaActiva se ponga a 0, tambien lo haga el ContadorVecesLLamada. En resumen en la parte del if que se ejecuta cuando LLamadaActiva es 0, ponele un ContadorVecesLLamada = 0; y ya estaria funcionando ( Exactamente dentro del if de ContadorLLamada !=0 )

Cambie 2 cosas del codigo, primero aumente el rango en que ContadorLLamada va a contar, ahora llega hasta 43 ( Ultimo corte + 10 segundos mas ), Cuando llega a 43 entra al nuevo else if, y pregunta cuantas llamadas se hicieron, ahi con solo modificar 1 numero cambias cuantas veces queres que te llame. Observa que no cambie nada mas de lo otro. Solo deberia agregar la linea que dije antes, pero es para cuando se desactiva LLamadaActiva.

Intenta hacerlo ahora con eso en mente y vemos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 24 de Abril de 2016, 22:37:55
antes que nada de verdad muchas gracias por la ayuda y quiero que sepas que estoy muy agradecido por toda la ayuda  veo que eres una persona talentosa mi buen killerjc la y que conoces mucho de esto veo que me diste una catedra de cómo darle tiempos a los delay se que en el lenguaje de programador es claro un servidor poco a poco voy pensando como programador y en el grado que baya pensado como tal se que voy entendiendo cosas básicas, reglas, métodos, forma de escritura y lectura y hasta trucos que existe en este mundo tan basto de la programación gracias por compartir tus conocimientos 

y pasando al programa voy a leeer detenidamente lo que me dises e intentare hacerlo  :idea: :rayito:
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 27 de Abril de 2016, 15:10:36
ya regrese se me rompio el cargador de la pc y pos hoy la compre continuare con el progra saludos  :mrgreen:
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 28 de Abril de 2016, 21:57:33
Ya hice todas las modificaciones pero fíjate que madamas una vez se enciende LLAMAR Y no hace madamas as mecha cuando daré una buena   :5] no se por qué no funciona los diez segundos y que vuelva a llamar si logre compilarlo sin errores coloque la varible  los cambios pero no enciende ninguna ves colgar
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Mayo de 2016, 01:58:18
estoy vivo le estoy moviendo al programa pero asta hoy nada saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 03 de Mayo de 2016, 07:32:36
Dale, yo ultimamente no entre a linux donde abro mi correo, estuve con otras cosas y no dispongo demasiado tiempo. Pero si me enviaste algo luego lo veo. Sino lo pones aca y es mas facil xD
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Mayo de 2016, 22:08:01
esta parte no entra niuna ves como ves

Código: C
  1. else if ( ContadorLLamada == 23)                                        // Pasan 10 segundos desde que se llamo y se corta  estaba en 43
  2.                         {
  3.                 output_high(COLGAR);
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 03 de Mayo de 2016, 22:19:26
Codigo completo :P
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Mayo de 2016, 22:36:26
no se por qué no hace ni una ves el colgar y al querer meter un else if mas me marca error solo da salida el llamar ya las 3 veces de hay nada mas
Código: C
  1. if(LLamadaActiva == 1)
  2.         {
  3.                 if(ContadorLLamada < 44 )
  4.                 {
  5.                         ContadorLLamada++;
  6.                         if( (ContadorLLamada <= 1) || (ContadorLLamada == 3) || (ContadorLLamada == 23) ||(ContadorLLamada == 43) )                     // Primera entrada presiona LLAMAR por 0.5s
  7.                         {                                                                       // Espera 0.5s y presiona LLAMAR de nuevo por 0.5s
  8.                                 output_high(LLAMAR);
  9.                         }
  10.                           else if ( ContadorLLamada == 23)                                      // Pasan 10 segundos desde que se llamo y se corta  estaba en 43
  11.                         {
  12.                 output_high(COLGAR);
  13.          
  14.             if(ContadorVecesLLamada < 3)
  15.             {
  16.              ContadorLLamada = 0;
  17.             }
  18.              ContadorVecesLLamada++;
  19.          }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Mayo de 2016, 22:38:19
asi o mas jejeje  :mrgreen: te mando un pribado para que veas compilado ya jejeje pero claro en proceso
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Mayo de 2016, 22:43:23
ya lo mande me dises si lo puedes ver sino pues sigo poniendo codigo aqui
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Mayo de 2016, 23:14:07
este es todo lo de la llamada

Código: C
  1. if(LLamadaActiva == 1)
  2.         {
  3.                 if(ContadorLLamada < 44 )
  4.                 {
  5.                         ContadorLLamada++;
  6.                         if( (ContadorLLamada <= 1) || (ContadorLLamada == 3) || (ContadorLLamada == 23) ||(ContadorLLamada == 43) )                     // Primera entrada presiona LLAMAR por 0.5s
  7.                         {                                                                       // Espera 0.5s y presiona LLAMAR de nuevo por 0.5s
  8.                                 output_high(LLAMAR);
  9.                         }
  10.                           else if ( ContadorLLamada == 23)                                      // Pasan 10 segundos desde que se llamo y se corta  estaba en 43
  11.                         {
  12.                 output_high(COLGAR);
  13.          
  14.             if(ContadorVecesLLamada < 3)
  15.             {
  16.              ContadorLLamada = 0;
  17.             }
  18.              ContadorVecesLLamada++;
  19.          }
  20.                         else                                                                    // En cualqier otro momento de tiempo que esten en 0 las salidas
  21.                         {
  22.                                 output_low(COLGAR);
  23.                                 output_low(LLAMAR);
  24.                         }
  25.           //  ContadorLLamada++;
  26.       }
  27.         }
  28.         else
  29.         {
  30.                 if(ContadorLLamada != 0)
  31.  
  32.       {
  33.                         // Si por alguna casualidad se desactiva la alarma mientras esta llamando esto va a colgar el celular aunque sea 1 ves
  34.                         output_low(LLAMAR);
  35.                         output_high(COLGAR);
  36.                         ContadorLLamada = 0;
  37.          ContadorVecesLLamada = 0;
  38.       }
  39.                 else
  40.                 {
  41.                         // Caso que no se presione nada, entonces me aseguro que ambos esten en 0
  42.                         output_low(LLAMAR);
  43.                         output_low(COLGAR);
  44.                 }
  45.         }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 03 de Mayo de 2016, 23:15:41
solo llama las tres beses de hay nada ya vi que no te puedo enviar nada esta desactivado jejeje me lo mande yo mismo por error saludos
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 05 de Mayo de 2016, 12:36:57
creo que no as podido er el progrma

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_B6    //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.  
  24. unsigned int8   ContadorLuz = 0;
  25. unsigned int8   ContadorLlamada = 0;
  26. unsigned int16  ContadorParaReset = 0;
  27. volatile int1   LuzActiva = 0;
  28. volatile int1   LLamadaActiva = 0;
  29. volatile int1   SirenaActiva = 0;
  30. volatile int1  ContadorVecesLLamada = 0;
  31.  
  32. #int_timer1
  33. void time_1(void)
  34. {
  35.         set_timer1(3036);
  36.  
  37.  
  38.         // Contador que maneja el Timer de la luz
  39.  
  40.         if(LuzActiva == 1)
  41.         {
  42.                 output_high(LUZ_PAD);
  43.                 ContadorLuz++;
  44.                 if(ContadorLuz == 60)                                   // 30 seg = 60 entradas
  45.                 {
  46.                         output_low(LUZ_PAD);                            // Corregi aca
  47.                         ContadorLuz = 0;
  48.                         LuzActiva = 0;
  49.                 }
  50.         }
  51.         else
  52.         {
  53.                 output_low(LUZ_PAD);
  54.                 ContadorLuz = 0;
  55.         }
  56.  
  57.  
  58.         // Contador que maneja el timer de las llamadas
  59.  
  60.         if(LLamadaActiva == 1)
  61.         {
  62.                 if(ContadorLLamada < 44 )
  63.                 {
  64.                         ContadorLLamada++;
  65.                         if( (ContadorLLamada <= 1) || (ContadorLLamada == 3) || (ContadorLLamada == 23) ||(ContadorLLamada == 43) )                     // Primera entrada presiona LLAMAR por 0.5s
  66.                         {                                                                       // Espera 0.5s y presiona LLAMAR de nuevo por 0.5s
  67.                                 output_high(LLAMAR);
  68.                         }
  69.                           else if ( ContadorLLamada == 23)                                      // Pasan 10 segundos desde que se llamo y se corta  estaba en 43
  70.                         {
  71.                 output_high(COLGAR);
  72.  
  73.             if(ContadorVecesLLamada < 3)
  74.             {
  75.              ContadorLLamada = 0;
  76.             }
  77.              ContadorVecesLLamada++;
  78.          }
  79.                         else                                                                    // En cualqier otro momento de tiempo que esten en 0 las salidas
  80.                         {
  81.                                 output_low(COLGAR);
  82.                                 output_low(LLAMAR);
  83.                         }
  84.           //  ContadorLLamada++;
  85.       }
  86.         }
  87.         else
  88.         {
  89.                 if(ContadorLLamada != 0)
  90.  
  91.       {
  92.                         // Si por alguna casualidad se desactiva la alarma mientras esta llamando esto va a colgar el celular aunque sea 1 ves
  93.                         output_low(LLAMAR);
  94.                         output_high(COLGAR);
  95.                         ContadorLLamada = 0;
  96.          ContadorVecesLLamada = 0;
  97.       }
  98.                 else
  99.                 {
  100.                         // Caso que no se presione nada, entonces me aseguro que ambos esten en 0
  101.                         output_low(LLAMAR);
  102.                         output_low(COLGAR);
  103.                 }
  104.         }
  105.  
  106.  
  107.         // Contador que maneja el timer de la sirena y su reset a los 30minutos
  108.  
  109.         if( SirenaActiva == 1 )
  110.         {
  111.                 output_high(SIRENA);
  112.                 ContadorParaReset++;
  113.                 if ( ContadorParaReset >= 240 )         // 30 Minutos = 1800 segundos = 3600 entradas de 0.5s  OJO OJO cambia  3600  por 240 para 2 min y pueda ver si recetea
  114.                 {
  115.                         output_low(SIRENA);
  116.                         SirenaActiva = 0;
  117.                         LLamadaActiva = 0;
  118.                         ContadorParaReset = 0;
  119.                 }
  120.         }
  121.         else
  122.         {
  123.                 output_low(SIRENA);
  124.                 ContadorParaReset = 0;     // OJO OJO esto lo puse yo segun yo vi que le asia falta
  125.         }
  126. }
  127.  
  128. void main(void)
  129. {
  130.  
  131.         // Aca el setup de pines/modulos/etc
  132.  
  133.         set_tris_B(0b11111111);         //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
  134.         set_tris_D(0b00000000);         // asigno todo el puerto D como salidas
  135.         output_D(0b00000000);
  136.  
  137.  
  138.         setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  139.         set_timer1 (3036);
  140.         enable_interrupts(int_timer1);
  141.         enable_interrupts(global);
  142.  
  143.         // Comienzo del programa principal
  144.  
  145.         while(true)
  146.         {
  147.                 if(input(E_ON_OF)==1)                   // Pregunto si la entrada del pin B0 es igual a 0
  148.                 {
  149.                         delay_ms(10);                   // Espero 10ms por si la llave esta rebotando (variando entre 1 y 0 )
  150.                         while(input(E_ON_OF)==1);       // Espero que suelte el boton, observa el ; al final, es decir un while(){}
  151.                         output_toggle(LED_ON_OF);       // Cambio el valor del pin
  152.  
  153.                 }
  154.  
  155.                 if(input(LED_ON_OF)==1)
  156.                 {
  157.                         if((input(S_MOV_PAD)==1)||(input(S_MOV_PUD)==1)||(input(S_MAG_PUD)==1))      //OJO OJO lo puse yo estaba asi if((input(S_MOV_PAD)==1))
  158.                         {
  159.                                 LuzActiva = 1;
  160.                                 ContadorLuz = 0;                //Asi no se apaga
  161.                         }
  162.                         if((input_b() & 0b01111110) != 0) // Es decir se activo algun sensor interno, entonces active la sirena y la llamada. OJO OJO tenia 0b01111000)
  163.                         {
  164.  
  165.                                 SirenaActiva = 1;
  166.                                 LLamadaActiva = 1;
  167.             ContadorVecesLLamada =1;
  168.                         }
  169.                 }
  170.                 else
  171.                 {
  172.                         LuzActiva=0;
  173.                         SirenaActiva = 0;
  174.                         LLamadaActiva = 0;
  175.                         ContadorParaReset = 0;
  176.          ContadorVecesLLamada =0;
  177.         }
  178.         }
  179. }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 05 de Mayo de 2016, 12:39:53
esto no lo lee no entra a esta parte

Código: C
  1. else if ( ContadorLLamada == 23)  // Pasan 10 segundos desde que se llamo y se corta  estaba en 43
  2.            {
  3.      output_high(COLGAR);
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 05 de Mayo de 2016, 17:48:28
Acabo de verlo, hiciste una mezcla de las 2 opciones que te di. Luego escribo el programa, edito esta respuesta y lo probas, ahora no poseo tiempo, no hace falta que respondas al mensaje este, yo voy a editarlo y lo vas a tener

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_B6    //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.  
  24. unsigned int8   ContadorLuz = 0;
  25. unsigned int8   ContadorLlamada = 0;
  26. unsigned int16  ContadorParaReset = 0;
  27. volatile int8   ContadorVecesLLamada = 0;
  28. volatile int1   LuzActiva = 0;
  29. volatile int1   LLamadaActiva = 0;
  30. volatile int1   SirenaActiva = 0;
  31.  
  32. #int_timer1
  33. void time_1(void)
  34. {
  35.         set_timer1(3036);
  36.  
  37.  
  38.         // Contador que maneja el Timer de la luz
  39.  
  40.         if(LuzActiva == 1)
  41.         {
  42.                 output_high(LUZ_PAD);
  43.                 ContadorLuz++;
  44.                 if(ContadorLuz == 60)                                   // 30 seg = 60 entradas
  45.                 {
  46.                         output_low(LUZ_PAD);                            // Corregi aca
  47.                         ContadorLuz = 0;
  48.                         LuzActiva = 0;
  49.                 }
  50.         }
  51.         else
  52.         {
  53.                 output_low(LUZ_PAD);
  54.                 ContadorLuz = 0;
  55.         }
  56.  
  57.  
  58.         // Contador que maneja el timer de las llamadas
  59.  
  60.         if(LLamadaActiva == 1)
  61.         {
  62.                 if(ContadorLLamada < 44 )
  63.                 {
  64.                         ContadorLLamada++;
  65.                         output_low(COLGAR);
  66.                         output_low(LLAMAR);
  67.                         switch(ContadorLLamada)
  68.                         {
  69.                         case 1:
  70.                         case 3:
  71.                                 output_high(LLAMAR);
  72.                                 break;
  73.                         case 23:
  74.                                 output_high(COLGAR);
  75.                                 break;
  76.                         case 43:
  77.                                 if(ContadorVecesLLamada < 3)
  78.                                 {
  79.                                         ContadorLLamada = 0;
  80.                                 }
  81.                                 break;
  82.                         default:                               
  83.                                 break;
  84.                         }
  85.                 }
  86.         }
  87.         else
  88.         {
  89.                 output_low(LLAMAR);
  90.                 ContadorVecesLLamada = 0;
  91.                 if(ContadorLLamada != 0)
  92.                 {
  93.                         // Si por alguna casualidad se desactiva la alarma mientras esta llamando esto va a colgar el celular aunque sea 1 ves
  94.                         output_high(COLGAR);
  95.                         ContadorLLamada = 0;
  96.                 }
  97.                 else
  98.                 {
  99.                         // Caso que no se presione nada, entonces me aseguro que ambos esten en 0
  100.                         output_low(COLGAR);
  101.                 }
  102.         }
  103.  
  104.  
  105.         // Contador que maneja el timer de la sirena y su reset a los 30minutos
  106.  
  107.         if( SirenaActiva == 1 )
  108.         {
  109.                 output_high(SIRENA);
  110.                 ContadorParaReset++;
  111.                 if ( ContadorParaReset >= 240 )         // 30 Minutos = 1800 segundos = 3600 entradas de 0.5s  OJO OJO cambia  3600  por 240 para 2 min y pueda ver si recetea
  112.                 {
  113.                         output_low(SIRENA);
  114.                         SirenaActiva = 0;
  115.                         LLamadaActiva = 0;
  116.                         ContadorParaReset = 0;
  117.                 }
  118.         }
  119.         else
  120.         {
  121.                 output_low(SIRENA);
  122.                 ContadorParaReset = 0;     // OJO OJO esto lo puse yo segun yo vi que le asia falta
  123.         }
  124. }
  125.  
  126. void main(void)
  127. {
  128.  
  129.         // Aca el setup de pines/modulos/etc
  130.  
  131.         set_tris_B(0b11111111);         //asigno todo el puerto B como entradas y lo puse en binario para que lo tenga presente
  132.         set_tris_D(0b00000000);         // asigno todo el puerto D como salidas
  133.         output_D(0b00000000);
  134.  
  135.  
  136.         setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  137.         set_timer1 (3036);
  138.         enable_interrupts(int_timer1);
  139.         enable_interrupts(global);
  140.  
  141.         // Comienzo del programa principal
  142.  
  143.         while(true)
  144.         {
  145.                 if(input(E_ON_OF)==1)                   // Pregunto si la entrada del pin B0 es igual a 0
  146.                 {
  147.                         delay_ms(10);                   // Espero 10ms por si la llave esta rebotando (variando entre 1 y 0 )
  148.                         while(input(E_ON_OF)==1);       // Espero que suelte el boton, observa el ; al final, es decir un while(){}
  149.                         output_toggle(LED_ON_OF);       // Cambio el valor del pin
  150.                 }
  151.  
  152.                 if(input(LED_ON_OF)==1)
  153.                 {
  154.                         if((input(S_MOV_PAD)==1)||(input(S_MOV_PUD)==1)||(input(S_MAG_PUD)==1))      //OJO OJO lo puse yo estaba asi if((input(S_MOV_PAD)==1))
  155.                         {
  156.                                 LuzActiva = 1;
  157.                                 ContadorLuz = 0;                //Asi no se apaga
  158.                         }
  159.                         if((input_b() & 0b01111110) != 0) // Es decir se activo algun sensor interno, entonces active la sirena y la llamada. OJO OJO tenia 0b01111000)
  160.                         {
  161.  
  162.                                 SirenaActiva = 1;
  163.                                 LLamadaActiva = 1;
  164.                         }
  165.                 }
  166.                 else
  167.                 {
  168.                         LuzActiva = 0;
  169.                         SirenaActiva = 0;
  170.                         LLamadaActiva = 0;
  171.                         ContadorParaReset = 0;
  172.                         ContadorVecesLLamada = 0;
  173.                 }
  174.         }
  175. }
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 08 de Mayo de 2016, 23:53:41
ok enterado saludos le hago  la lucha jejeje es mi primer intento de hacer un programa  :mrgreen:
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 12 de Mayo de 2016, 19:24:55
Hola mi buen killer jc me podrías decir por favor que debo de leer primero para intentar hacer un programa para un control remoto infrarrojo lo requiero para anexárselo a este programa recuerdas que tiene un on/of y me gustaria que fuera mas seguro y que reacciones de acuerdo a la entrada necesito leer para saber cómo empezar saludos gracias abriré un nuevo tema para cuando lea del tema y tengo idea de cómo se hace para leer la entrada de unos pulsos con pic  :mrgreen:

Pos data e investigado algunas tecnologías que me gustaría compartir contigo te las mandare saludos   
Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: KILLERJC en 12 de Mayo de 2016, 20:35:22
Apartir de aca estas solo, pero yo buscaria algo mas como RF, mas que infrarrojo. Ya que no se si los controles siguen usando los mismos protocolos como NEC y RC-5, Ademas es algo comun a todos los controles asi que seguridad ahi no tendrias para nada.

Título: Re:lecturas y salidas (digitales y analogicas) en lengua c para pic
Publicado por: nuevo mundo en 12 de Mayo de 2016, 22:34:14
ok enterado gracias por el apoyo ya investigo muy amable  :-/  entonses este tema queda resuelto  ((:-))