Autor Tema: mil vueltas... en una sencilla comunicación serie entre pic  (Leído 8585 veces)

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

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #30 en: 02 de Junio de 2011, 18:46:51 »
Como los pines seleccionados no corresponden al modulo, se considera que es por software, así que no seria necesario  ;-)


Saludos!
No contesto mensajes privados, las consultas en el foro

Desconectado daltonico82

  • PIC12
  • **
  • Mensajes: 89
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #31 en: 02 de Junio de 2011, 18:52:08 »
Bien, entendido el "FORCE_SW" fuerza a trabajar a la UART, a sus pines asociados, por software y no salta  la rutina de atención a la interrupción sino que en el main pregunaríamos por :

 if(kbhit())
      {
       }...

Lo de las distintas velocidades es factible y funcionará????

Mañana me pongo pilas e intento lograr un program.

Gracias Suky!!!!! Gracias Foro!!!!

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #32 en: 02 de Junio de 2011, 19:15:17 »
Si, o sea, por hardware (utilizando el módulo) y dependiendo del cristal externo podes obtener grandes velocidades. Ahora cuando se utiliza por software lo mejor es una velocidad no muy alta, pero 9600 es adecuada.

El tema de kbhit() es distinto según se utilice por hardware o por software. Por hardware indica cuando a legado un byte, por software cuando se recibe el bit start.


Saludos!
No contesto mensajes privados, las consultas en el foro

Desconectado rivale

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1707
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #33 en: 02 de Junio de 2011, 19:23:24 »
si, puedes poner las velocidades que quieras, solo era un ejemplo lo que te envie, en hardaware puedes ponerle 115200 si quieres.


el kbhit no lo necesitas para la interrupcion por recepcion de datos. para saber si hay datos por el otro modulo(el de soft) ahi si tendrias que checar cuando recibes datos.

tambien puedes usar la interrupcion externa para checar si recibes datos por el puerto de software, en cuanto recibas el dato te genera una interrupcion, puedes apagar la interrupcion despues de recibir el bit de inicio y hasta que acabes de recibir los datos la vuelves a prender para que no te genere una interrupcion cada pulso del dato recibido
"Nada es imposible, no si puedes imaginarlo"

Desconectado daltonico82

  • PIC12
  • **
  • Mensajes: 89
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #34 en: 03 de Junio de 2011, 13:42:01 »
Hello WORLD!!!

He confeccionado como inicio un programa que recoge los datos del controlador (PIC1), los gestiona y envía al PIC2 un dato (un número en hexadecimal). En el PIC2 se recibe este dato y cambia el estado del puerto D. No lo he probado todabía, sólo dispongo de un PIC y hasta mañana no tengo el otro. Si veis algo raro, espero sugerencias

Saludos!!!

PIC1

Código: [Seleccionar]
#include <16f877.h> //PROGRAM PIC1
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT
#use delay(clock=20000000)
#use RS232 (baud=38400, bits=8, parity=N, xmit=PIN_C6, rcv=PIN_C7,STREAM=P1)
#use RS232 (baud=9600, xmit=PIN_B1, rcv=PIN_B0,STREAM=P2 )

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)                   
#use fast_io(D)                   
#use fast_io(E)                   

#byte PORTA = 0X05
#byte PORTB = 0X06
#byte PORTC = 0X07                     
#byte PORTD = 0X08
#byte PORTE = 0X09

#bit D0=PORTD.0
#bit D1=PORTD.1
#bit D2=PORTD.2

#PRIORITY RDA, EXT


const int SX1=0X2B;//coordenadas max y min: X
const int SX2=0X61;

const int S0Y1=0X26;//coordenadas max y min: Y_TECLA S0
const int S0Y2=0x3C;

const int S1Y1=0X40;//coordenadas max y min: Y_TECLA S1
const int S1Y2=0x59;

const int S2Y1=0X5B;//coordenadas max y min: Y_TECLA S2
const int S2Y2=0x73;

int1 Xok=0;
int lectura=0;
int valor[4];
int i=0;
int1 flag=0;

#int_RDA // recepción datos del controlador

void RDA_isr()
{
           
        lectura=getc();
        valor[i]=lectura;
        i++;
         if(i==4)
         {
              flag=1;
              i=0;
         }
     
}


#INT_EXT //recepción datos PIC2
ext_isr()
{
//POR HACER
}

void main()
{
   
   delay_ms(50);//incialización controlador
   SET_TRIS_A (0xFF);
   SET_TRIS_B (0x01);//b0->in, b1->out
   SET_TRIS_C (0x80);//c6->out, c7->in
   SET_TRIS_D (0X00);
 
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   setup_psp(PSP_DISABLED);
 
   PORTD=0X00;
   int dato=0x00;

   enable_interrupts(INT_RDA);//INTERRUPCIÓN USART
   enable_interrupts (INT_EXT);//INTERRUPCIÓN EXTERNA (EN RB0)
   ext_int_edge (H_TO_L);
   enable_interrupts(GLOBAL);
   
   
    while(true)
    {
         if(flag==1)
      {   
     
     delay_ms(50);
         flag=0;
         
         if((valor[2]<(SX2))&&(valor[2]>(SX1)))//las X; las 3 teclas en este caso están alineadas verticalmente==>mismas coordenadas X
         {
            Xok=1;
         }
         
         if ((Xok==1)&&(valor[0]<S0Y2)&&(valor[0]>S0Y1))
         {
         Xok=0;
         dato=0x01;
         putc(dato);
         }
         
         if ((Xok==1)&&(valor[0]<S1Y2)&&(valor[0]>S1Y1))
         {
         Xok=0;
         dato=0x02;
         putc(dato);
         }
   
         if ((Xok==1)&&(valor[0]<S2Y2)&&(valor[0]>S2Y1))
         {
         Xok=0;
         dato=0x04;
         putc(dato);
         }

         
   
      }//flag==1
     
   
}//while(1)
}//main()

PIC2:
Código: [Seleccionar]
#include <16f877.h> //PROGRAM PIC2
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT
#use delay(clock=8000000)
#use RS232 (baud=9600, bits=8, parity=N, xmit=PIN_C6, rcv=PIN_C7)

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)                   
#use fast_io(D)                   
#use fast_io(E)                   

#byte PORTA = 0X05
#byte PORTB = 0X06
#byte PORTC = 0X07                     
#byte PORTD = 0X08
#byte PORTE = 0X09

#bit D0=PORTD.0
#bit D1=PORTD.1
#bit D2=PORTD.2

int lectura=0X00;
int valor=0X00;
int1 flag=0;

#int_RDA // recepción datos del PIC1

void RDA_isr()
{
           
        lectura=getc();
        valor=lectura;
        flag=1;     
}

void main()
{
   
   delay_ms(50);//incialización controlador
   SET_TRIS_A (0xFF);
   SET_TRIS_B (0x00);
   SET_TRIS_C (0x80);//c6->out, c7->in
   SET_TRIS_D (0X00);
 
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   setup_psp(PSP_DISABLED);
 
   PORTD=0X00;
   
   enable_interrupts(INT_RDA);//INTERRUPCIÓN USART
   enable_interrupts(GLOBAL);
   
   
    while(true)
    {
         if(flag==1)
      {   
     
         delay_ms(50);
         flag=0;
         PORTD=lectura;

      }//flag==1
     
   
}//while(1)
}//main()

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #35 en: 03 de Junio de 2011, 13:49:17 »

tambien puedes usar la interrupcion externa para checar si recibes datos por el puerto de software, en cuanto recibas el dato te genera una interrupcion, puedes apagar la interrupcion despues de recibir el bit de inicio y hasta que acabes de recibir los datos la vuelves a prender para que no te genere una interrupcion cada pulso del dato recibido

En realidad no es necesario apagar la interrupción, ya que dentro de la ISR se trabaja con fgetc() la cual recibirá todo el dato y luego se saldrá de la interrupción borrando la bandera.

@daltonico82, en el microcontrolador que tienes 2 canales de comunicación serial, debes utilizar las funciones fputc y fgetc para indicar mediante el stream sobre cual trabajar.


Saludos!
No contesto mensajes privados, las consultas en el foro

Desconectado rivale

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1707
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #36 en: 03 de Junio de 2011, 13:58:01 »
fputc(0x00, p1); algo asi tienes que poner para escribir, primero pones el dato que vas a enviar, y luego pones por que puerto lo quieres enviar. usando los nombres que le pusiste

#use RS232 (baud=38400, bits=8, parity=N, xmit=PIN_C6, rcv=PIN_C7,STREAM=P1)
#use RS232 (baud=9600, xmit=PIN_B1, rcv=PIN_B0,STREAM=P2)



de igual manera para leer le pones

lectura = fgetc(STREAM)
"Nada es imposible, no si puedes imaginarlo"

Desconectado daltonico82

  • PIC12
  • **
  • Mensajes: 89
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #37 en: 09 de Junio de 2011, 17:54:50 »
Hola!!!!

Mucho trabajo esta semana :5] :5] :5], por fin hoy pude probar la comunicación. Os cuento:

Correcta la comuncación entre controlador y PIC1 (rececpción de datos  en PIC1 hard-rs232)
Correcta la comunicación entre PIC1 y PIC2 (envío de datos desde PIC1 a PIC2; PIC1 soft-rs232, PIC2 hard-rs232)


 :oops:No funciona comunicación entre PIC2 Y PIC1 (envío de datos desde PIC2 A PIC1).

Dejo código; yo ahora mismo sigo por aca probando!!!
Saludos :-/ :-/ :-/

Código: [Seleccionar]
#include <16f877.h> //PROGRAM PIC1
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT
#use delay(clock=20000000)
#use RS232 (baud=38400, bits=8, parity=N, xmit=PIN_C6, rcv=PIN_C7,STREAM=P1)
#use RS232 (baud=9600, xmit=PIN_B1, rcv=PIN_B0,STREAM=P2 )

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)                   
#use fast_io(D)                   
#use fast_io(E)                   

#byte PORTA = 0X05
#byte PORTB = 0X06
#byte PORTC = 0X07                     
#byte PORTD = 0X08
#byte PORTE = 0X09

#bit D0=PORTD.0
#bit D1=PORTD.1
#bit D2=PORTD.2
#bit D6=PORTD.6
#bit D7=PORTD.7

#PRIORITY RDA, EXT


const int SX1=0X2B;//coordenadas max y min: X
const int SX2=0X61;

const int S0Y1=0X26;//coordenadas max y min: Y_TECLA S0
const int S0Y2=0x3C;

const int S1Y1=0X40;//coordenadas max y min: Y_TECLA S1
const int S1Y2=0x59;

const int S2Y1=0X5B;//coordenadas max y min: Y_TECLA S2
const int S2Y2=0x73;

int1 Xok=0;
int lectura=0;
int signal=0;
int valor[4];
int i=0;
int1 flag=0;

#int_RDA // recepción datos del controlador

void RDA_isr()
{
           
        lectura=fgetc(P1);
        valor[i]=lectura;
        i++;
         if(i==4)
         {
              flag=1;
              i=0;
         }
     
}


#int_EXT //recepción datos PIC2
ext_isr()
{
      signal=fgetc(P2);

      if (signal==0)
      {
      output_toggle(pin_D6);
      }

      if (signal==1)
      {
      output_toggle(pin_D7);
      }
}


void main()
{
   
   delay_ms(50);//incialización controlador
   SET_TRIS_A (0xFF);
   SET_TRIS_B (0x01);//b0->in, b1->out
   SET_TRIS_C (0x80);//c6->out, c7->in
   SET_TRIS_D (0X00);
 
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   setup_psp(PSP_DISABLED);
 
   PORTD=0X00;
   int dato=0;

   enable_interrupts(INT_RDA);//INTERRUPCIÓN USART
   enable_interrupts (INT_EXT);//INTERRUPCIÓN EXTERNA (EN RB0)
   ext_int_edge (H_TO_L);
   enable_interrupts(GLOBAL);
   
   
    while(true)
    {
         if(flag==1)
      {   
     
     delay_ms(50);
         flag=0;
         
         if((valor[2]<(SX2))&&(valor[2]>(SX1)))//las X; las 3 teclas en este caso están alineadas verticalmente==>mismas coordenadas X
         {
            Xok=1;
         }
         
         if ((Xok==1)&&(valor[0]<S0Y2)&&(valor[0]>S0Y1))
         {
         Xok=0;
         output_toggle(pin_D0);
         //PORTD=0x01;
         dato=1;
         fputc(dato,P2);
         }
         
         if ((Xok==1)&&(valor[0]<S1Y2)&&(valor[0]>S1Y1))
         {
         Xok=0;
         output_toggle(pin_D1);
         //PORTD=0X02;
         dato=2;
         fputc(dato,P2);
         }
   
         if ((Xok==1)&&(valor[0]<S2Y2)&&(valor[0]>S2Y1))
         {
         Xok=0;
         output_toggle(pin_D2);
         //PORTD=0X04;
         dato=3;
         fputc(dato,P2);
         }

         
   
      }//flag==1
     
   
}//while(1)
}//main()

Código: [Seleccionar]
#include <16f877.h> //PROGRAM PIC2
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT
#use delay(clock=8000000)
#use RS232 (baud=9600, bits=8, parity=N, xmit=PIN_C6, rcv=PIN_C7,STREAM=P2)

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)                   
#use fast_io(D)                   
#use fast_io(E)                   

#byte PORTA = 0X05
#byte PORTB = 0X06
#byte PORTC = 0X07                     
#byte PORTD = 0X08
#byte PORTE = 0X09

#bit D0=PORTD.0
#bit D1=PORTD.1
#bit D2=PORTD.2
#bit A0=PORTA.0
#bit A1=PORTA.1

int lectura=0X00;
int valor=0X00;
int1 flag=0;

#int_RDA // recepción datos del PIC1

void RDA_isr()
{
           
        lectura=fgetc(P2);
        valor=lectura;
        flag=1;     
}

void main()
{
   
   delay_ms(50);//incialización controlador
   SET_TRIS_A (0xFF);
   SET_TRIS_B (0x00);
   SET_TRIS_C (0x80);//c6->out, c7->in
   SET_TRIS_D (0X00);
 
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   setup_psp(PSP_DISABLED);
   int signal=0;
   PORTD=0X00;
   
   enable_interrupts(INT_RDA);//INTERRUPCIÓN USART
   enable_interrupts(GLOBAL);
   
   
    while(true)
    {
         if(flag==1)
      {   
     
         delay_ms(50);
         flag=0;
         
         switch(lectura)
         {
         case 1:
         
         output_toggle(pin_D0);
         break;
         
         case 2:
         output_toggle(pin_D1);
         break;
         
         case 3:
         output_toggle(pin_D2);
         break;
         }
     
      if(pin_A0==0)
      {
      signal=0;
      fputc(signal,P2);
      }
     
      if(pin_A1==0)
      {
      signal=1;
      fputc(signal,P2);
      }

      }//flag==1
     
   
}//while(1)
}//main()

Desconectado rivale

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1707
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #38 en: 11 de Junio de 2011, 19:26:28 »
Hola, si en el pic2 solo tienes definido un puerto rs232 no necesitas ponerle el stream
"Nada es imposible, no si puedes imaginarlo"

Desconectado daltonico82

  • PIC12
  • **
  • Mensajes: 89
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #39 en: 13 de Junio de 2011, 11:39:27 »
Hola rivale!!!
Gracias por seguir el hilo. Suprimo el STREAM en el PIC2, pero siguo sin envíar del PIC2 a PIC1. ¿Detectas algo raro en el envío o en la recepción por parte del PIC1??? las prioridades en las interrupciones creo están bien...


Desconectado rivale

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1707
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #40 en: 13 de Junio de 2011, 18:05:47 »
Hola, en tu recepcion del pic1 estas intentando leer un dato cuando tienes una interrupcion externa, pero vas a entrar a esa interrupcion cada que tengas un cambio de flanco, no necesariamente cuando tengas un dato. primero checa si tienes un dato usando "kbit" y luego lees
"Nada es imposible, no si puedes imaginarlo"

Desconectado daltonico82

  • PIC12
  • **
  • Mensajes: 89
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #41 en: 14 de Junio de 2011, 13:13:58 »
hola!

Ocurre lo siguiente: Si en la rutina de atención a la interrupción por flanco de bajada en RB0 coloco el if(kbhit()) entonces no ejecuta lo que tengo dentro de dicha rutina. Si no lo coloco, es decir, si no pregunto si ha llegado bit start entonces sí ejecuta el código  pero deja de funcionarme la interrupción de la USART (y no hace caso a lo que llega desde el controlador) que lo tengo como prioritario:
#PRIORITY RDA, EXT

Continuaré hasta lograrlo, estamos cerca pero ó una cosa o la otra.... :5]

Desconectado rivale

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1707
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #42 en: 14 de Junio de 2011, 13:31:58 »
Hola de nuevo, si estas usando el kbhit() puede que te de un true cuando tenga un dato por cualquiera de tus puertos, si quieres especificarle en que puerto quieres checar si hay dato usa:

kbhit(stream);   donde stream es el nombre de tu puerto a checar


tambien puedes hacer la prueba poniendo el kbhit dentro de tu main, solo para ver si esta recibiendo bien los datos del otro pic, si no, tal vez sea que el otro no envia bien los datos
"Nada es imposible, no si puedes imaginarlo"

Desconectado daltonico82

  • PIC12
  • **
  • Mensajes: 89
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #43 en: 17 de Junio de 2011, 15:06:22 »
Hola PICamigos!!!!

Conseguí enviar y recibir tal y como queria con mis dos 16F877. Adjunto los programas tal y cómo los tengo funcionando; sólo una duda: fijaros en el programa del PIC2. Tal y cómo está anda; sin embargo si coloco el envío correspondiente al estado de los pines A0 y A1 dentro del switch, envía pero deja de comunicar correctamente el controlador con el PIC1. Si pongo dicho envío de los dos pines A0 y A1 fuera del switch lo mismo....Tal y cómo está, uno dentro y otro fuera funciona. Raro, raro, raro...

Saludos

Código: [Seleccionar]
#include <16f877.h> //PROGRAM PIC1
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT
#use delay(clock=20000000)

#use RS232 (baud=38400, bits=8, parity=N, xmit=PIN_C6, rcv=PIN_C7,STREAM=P1)
#use RS232 (baud=9600, xmit=PIN_B1, rcv=PIN_B0,STREAM=P2 )

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)                   
#use fast_io(D)                   
#use fast_io(E)                   

#byte PORTA = 0X05
#byte PORTB = 0X06
#byte PORTC = 0X07                     
#byte PORTD = 0X08
#byte PORTE = 0X09

#bit D0=PORTD.0
#bit D1=PORTD.1
#bit D2=PORTD.2
#bit D6=PORTD.6
#bit D7=PORTD.7

#PRIORITY RDA, EXT


const int SX1=0X2B;//coordenadas max y min: X
const int SX2=0X61;

const int S0Y1=0X26;//coordenadas max y min: Y_TECLA S0
const int S0Y2=0x3C;

const int S1Y1=0X40;//coordenadas max y min: Y_TECLA S1
const int S1Y2=0x59;

const int S2Y1=0X5B;//coordenadas max y min: Y_TECLA S2
const int S2Y2=0x73;

int1 Xok=0;
int lectura=0;
int signal=0;
int valor[4];
int i=0;
int1 flag=0;

#int_RDA // recepción datos del controlador

void RDA_isr()
{
         
        lectura=fgetc(P1);
        valor[i]=lectura;
        i++;
         if(i==4)
         {
              flag=1;
              i=0;
         }
     
}


#int_EXT //recepción datos PIC2
ext_isr()
{
if (kbhit(P2))
{
      signal=fgetc(P2);
 
     switch (signal)
     {
     case 1:
     output_high(pin_D6);
     break;
     
     case 2:
     output_low(pin_D6);
     break;
     
     case 3:
     output_high(pin_D7);
     break;
     
     case 4:
     output_low(pin_D7);
     break;
     }   
}
}

void main()
{
   
   delay_ms(50);//incialización controlador
   SET_TRIS_A (0xFF);
   SET_TRIS_B (0x01);//b0->in, b1->out
   SET_TRIS_C (0x80);//c6->out, c7->in
   SET_TRIS_D (0X00);
 
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   setup_psp(PSP_DISABLED);
 
   PORTD=0X00;
   int dato=0;

   enable_interrupts(INT_RDA);//INTERRUPCIÓN USART
   enable_interrupts (INT_EXT);//INTERRUPCIÓN EXTERNA (EN RB0)
   ext_int_edge (H_TO_L);
   enable_interrupts(GLOBAL);
   
   
    while(true)
    {
         if(flag==1)
      {   
     
     delay_ms(50);
         flag=0;
         
         if((valor[2]<(SX2))&&(valor[2]>(SX1)))//las X; las 3 teclas en este caso están alineadas verticalmente==>mismas coordenadas X
         {
            Xok=1;
         }
         
         if ((Xok==1)&&(valor[0]<S0Y2)&&(valor[0]>S0Y1))
         {
         Xok=0;
         output_toggle(pin_D0);
         dato=1;
         fputc(dato,P2);
         }
         
         if ((Xok==1)&&(valor[0]<S1Y2)&&(valor[0]>S1Y1))
         {
         Xok=0;
         output_toggle(pin_D1);
         dato=2;
         fputc(dato,P2);
         }
   
         if ((Xok==1)&&(valor[0]<S2Y2)&&(valor[0]>S2Y1))
         {
         Xok=0;
         output_toggle(pin_D2);
         dato=3;
         fputc(dato,P2);
         }
         
       }//flag==1
       
 
}//while(1)
}//main()

Código: [Seleccionar]
#include <16f877.h> //PROGRAM PIC2
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT
#use delay(clock=8000000)
#use RS232 (baud=9600, bits=8, parity=N, xmit=PIN_C6, rcv=PIN_C7)

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)                   
#use fast_io(D)                   
#use fast_io(E)                   

#byte PORTA = 0X05
#byte PORTB = 0X06
#byte PORTC = 0X07                     
#byte PORTD = 0X08
#byte PORTE = 0X09

#bit D0=PORTD.0
#bit D1=PORTD.1
#bit D2=PORTD.2
#bit A0=PORTA.0
#bit A1=PORTA.1


int lectura=0X00;
int valor=0;
int1 flag=0;

#int_RDA // recepción datos del PIC1

void RDA_isr()
{
           
        lectura=getc();
        valor=lectura;
        flag=1;     
}


void main()
{
   
   delay_ms(50);//incialización controlador
   SET_TRIS_A (0xFF);
   SET_TRIS_B (0xff);
   SET_TRIS_C (0x80);//c6->out, c7->in
   SET_TRIS_D (0X00);
 
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   setup_psp(PSP_DISABLED);
   int signal1=0;
   PORTD=0X00;
   
   enable_interrupts(INT_RDA);//INTERRUPCIÓN USART
   enable_interrupts(GLOBAL);
   
   
    while(true)
    {
   
      if(input(pin_A0)==0)
      {
      //signal1=1;
      //putc(signal1);
      valor=4;
      flag=1;
      }
      else
      {
      //signal1=2;
      //putc(signal1);
      valor=5;
      flag=1;
      }
     
      if(input(pin_A1)==0)
      {
      signal1=3;
      putc(signal1);
      //valor=6;
      //flag=1;
      }
      else
      {
      signal1=4;
      putc(signal1);
      //valor=7;
      //flag=1;
      }
   
    ///////////////////////////////////
      if(flag==1)
      {   
         delay_ms(50);
         flag=0;
         
         switch(valor)
         {
         case 1:
         output_toggle(pin_D0);
         break;
         
         case 2:
         output_toggle(pin_D1);
         break;
         
         case 3:
         output_toggle(pin_D2);
         break;
         
         case 4://d6 pic1 on
         signal1=1;
         putc(signal1);
         break;
         
         case 5:// d6 pic1 off
         signal1=2;
         putc(signal1);
         break;
         }
         /*
         
         case 6://d7 pic1 on
         signal1=3;
         putc(signal1);
         break;
         
         case 7://d7 pic1 off
         signal1=4;
         putc(signal1);
         break;
         }*/
       
       }//flag==1
   
       
}//while(1)
}//main()

Desconectado rivale

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1707
Re: mil vueltas... en una sencilla comunicación serie entre pic
« Respuesta #44 en: 17 de Junio de 2011, 18:07:56 »
que bueno que funciona :-/, aunque no tendria porque darte errores si pones los 2 dentro de un switch.

a que te refieres con que se deja de comunicar correctamente con el pic1, el pic2 se pierde, o se resetea o deja de enviar cualquier dato?
"Nada es imposible, no si puedes imaginarlo"