ElectroYou

Salve qualche settimana fa ho acquistato un tx - rx a 315 MHz http://www.ebay.it/itm/261086921764?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1497.l2649. Scrivendo il programma per gestire il tutto con il PIC, noto le seguenti cose:
Attraverso un oscilloscopio, si vede che anche quando non si sta trasmettendo niente, il ricevitore rileva una serie di impulsi (potrebbero essere necessari per la sincronizzazione); Attraverso un PIC, trasmetto 3 Byte preceduti da un impulso di start, notando però che in ricezione questo messaggio arriva totalmente sballato. Se però invece confronto i 3 byte trasmessi la seconda volta (dato che quando si preme il pulsante lo stesso messaggio viene mandato più volte) il risultato è ottimo; Ho anche notato che se tengo premuto il pulsante non viene mandato lo stesso messaggio ma più codici diversi: in particolare tenendo premuto il pulsante il led, che dovrebbe accendersi ogni qual volta riceve il messaggio corretto, si accende e si spegne con la stessa cadenza. Sembra quasi che il codice giusto venga mandato dopo un certo numero di codici sbagliati.
Vi chiedo di darmi una mano, se qualcuno di voi ha già utilizzato questi tx-rx.

Non intendendomene propongo una serie di possibili problemi: pulsanti di comando non derimbalzati, disturbi sulle alimentazioni, interferenze di vari tipi, connessioni non corrette, qualche errorino o bug nei codici.

kristian ha scritto:Scrivendo il programma per gestire il tutto con il PIC, noto le seguenti cose

Neanche io me ne intendo tanto di programmazione (di PIC praticamente nulla), però sei sicuro non sia un problema software? Forse è meglio postare anche quello.

No non è un problema software, utilizzando un oscilloscopio e collegando sul canale a il sengnale che il PIC fornisce al trasmettitore e sul canale b il segnale che il ricevitore invia al PIC, si nota che a volte un impulso viene allungato o accorciato "a caso", perfino lo start bit. Su suggerimento del mio insegnante, invece di confrontare il messaggio ricevuto la prima volta, utilizzo il secondo messaggio, che sembrerebbe essere meno affetto da questi strani fenomeni dato che funziona abbastanza bene. Però volendo fare un'applicazione, dove tenendo il pulsante premuto per un certo tot di tempo veniva eseguito un'operazione, ho notato che i 3 byte, cui il messaggio è composto, non sono sempre gli stessi ma si ripetono con la stessa frequenza. Allego un'immagine dell'oscilloscopio che dimostra quanto detto: il segnale in alto rappresenta il codice inviato dal PIC al tx, quello in basso il codice che il rx trasmette ad un alto PIC.

Allego il codice scritto usando Mikro C:

Codice TX( PIC 16f628A):

Codice: Seleziona tutto

sbit TX at RB0_BIT;
sbit PULSANTE1 at RB1_BIT;
sbit PULSANTE1_DIR at TRISB1_BIT;


unsigned short int byte1_canale1= 0b10101010;
unsigned short int byte2_canale1= 0b10101010;
unsigned short int byte3_canale1= 0b00000010;

void SEND_BIT(char value);
void SEND_BYTE(unsigned short int num);

void settings()
{
   CMCON=7;  // tutti i pin sono digitali
   PORTB=PORTA=TRISB=TRISA=0;
   PULSANTE1_DIR=1;
}



void main()
  {
     settings();
     while(1)
      {
         if(PULSANTE1)
           {
              SEND_BIT(0);    // bit di start corrispondente a uno 0
              SEND_BYTE(byte1_canale1);
              SEND_BYTE(byte2_canale1);
              SEND_BYTE(byte3_canale1);
              Delay_ms(15);          // se tengo premuto il pulsante, introdurrò un ritardo di 15 ms tra un messaggio e l'altro


           }



      }



  }
 
 
 
 
 
 
  unsigned int tmrvalue;
 
void SEND_BIT(char value)
   {
      if(value)    // se value è un 1
        {
          TX=1;
         
          tmrvalue=65536-1500;   // impulso alto di 1.5 ms
          TMR1L=tmrvalue;
          TMR1H=tmrvalue>>8;
          TMR1ON_BIT=1;
          while(!TMR1IF_BIT);
          TMR1IF_BIT=0;
          TMR1ON_BIT=0;
         
          TX=0;
         
          tmrvalue=65536-400;   // impulso basso di 400 us
          TMR1L=tmrvalue;
          TMR1H=tmrvalue>>8;
          TMR1ON_BIT=1;
          while(!TMR1IF_BIT);
          TMR1IF_BIT=0;
          TMR1ON_BIT=0;

        }
   
       else
        {
           TX=1;

          tmrvalue=65536-400;   // impulso alto di 400 us
          TMR1L=tmrvalue;
          TMR1H=tmrvalue>>8;
          TMR1ON_BIT=1;
          while(!TMR1IF_BIT);
          TMR1IF_BIT=0;
          TMR1ON_BIT=0;

          TX=0;

          tmrvalue=65536-1500;   // impulso basso di 1.5 ms
          TMR1L=tmrvalue;
          TMR1H=tmrvalue>>8;
          TMR1ON_BIT=1;
          while(!TMR1IF_BIT);
          TMR1IF_BIT=0;
          TMR1ON_BIT=0;

        }

   }
   
   
   
   
   
  char valore,i;
void SEND_BYTE(unsigned short int num)
{
    for(i=0; i<8; i++)
      {
        valore = (num >> (7-i)) & 1;
        SEND_BIT(valore);
      }
}

codice rx(18f2550):

Codice: Seleziona tutto

        // LCD module connections
sbit LCD_RS at RC7_bit;
sbit LCD_EN at RC6_bit;
sbit LCD_D4 at RC2_bit;
sbit LCD_D5 at RC1_bit;
sbit LCD_D6 at RC0_bit;
sbit LCD_D7 at RA4_bit;

sbit LCD_RS_Direction at TRISC7_bit;
sbit LCD_EN_Direction at TRISC6_bit;
sbit LCD_D4_Direction at TRISC2_bit;
sbit LCD_D5_Direction at TRISC1_bit;
sbit LCD_D6_Direction at TRISC0_bit;
sbit LCD_D7_Direction at TRISA4_bit;
// End LCD module connections



sbit DATA at Ra5_bit;
sbit DataDir at TRISa5_bit;
char onetime=0;

char message1[]="B1:000";
char message2[]="B2:000";
char message3[]="B3:000";

unsigned short int found=0, startbit_trovato=0;
unsigned int tempo;
unsigned short int byte1, byte2, byte3;

unsigned short int byte1_canale1 = 0b10101010;
unsigned short int byte2_canale1 = 0b10101010;
unsigned short int byte3_canale1 = 0b00000010;


unsigned short int ReadByte();



void setting()
{
ADCON1=0x0F;
PORTC=PORTA=TRISB=TRISC=TRISA=0;
PORTB=0XFF;
DataDir=1;
T1CKPS1_bit = T3CKPS1_bit = 1;       //PRESCALER TIMER 1 E TIMER3 A 4
GIE_BIT=PEIE_BIT=TMR3IE_BIT=1;
TMR1H=TMR1L=TMR3L=TMR3H=0;
LCD_INIT();
LCD_CMD(_LCD_CLEAR);
LCD_CMD(_LCD_CURSOR_OFF);
}




unsigned short int SEARCH_START_BIT()
{
    TMR1ON_BIT=1;                // cronometriamo l'impulso di start
                                  //  __
    while(DATA);                //   |  |

    TMR1ON_BIT=0;

    tempo = ( TMR1L + (TMR1H<<8) );
    TMR1H = TMR1L = 0;


    /*  L'impulso di start è cosituito da un impulso a livello alto della durata di 400 us e di un impulso a
      livello basso della durata di 1.36 ms  */

    /* il livello basso dell'impulso di start viene delimitato da 300 a 500 us, quindi
       N°incrementi del timer = tempo / 0.8 us  --------->   dove 0.8 è dato da 1 /( 20/(4*4) )  */


    if (tempo>475 && tempo<625)          // 475 equivale a 380 us, 625 equivale a 550 us
         {

             TMR1ON_BIT=1;
             while(!DATA);            //   |___
             TMR1ON_BIT=0;

             tempo=( TMR1L + (TMR1H<<8) );
             TMR1H = TMR1L = 0;

             if(tempo>1500 && tempo<2500)       // 1500 incrementi equivalgono a 1.2 ms, 2500 a 2 ms
                   found=1;         // impulso di start trovato

         }
    return found;
}








void main()
{
  setting();

  while(1)
  {

    if(DATA)
     {
        STARTBIT_TROVATO=SEARCH_START_BIT();

        if(STARTBIT_TROVATO)          // verifica se si tratta del search bit altrimenti rieffettua il controllo
           {
              found=STARTBIT_TROVATO=0;
              if(!onetime)       // nel momento in cui premo il pulsante solo quella volta andrò a vedere l'impulso successivo
                 {
                      Delay_ms(56);            //ricevuto il primo bit di start lascio perdere il primo messaggio

                      while(!STARTBIT_TROVATO)         //esce dal ciclo quando finalmente trova il bit di start
                        {
                            while(!Data);
                            STARTBIT_TROVATO=SEARCH_START_BIT();
                        }

                      found=STARTBIT_TROVATO=0;
                 }



              TMR3H=TMR3L=TMR3ON_BIT=0;

              byte1=ReadByte();
              byte2=ReadByte();
              byte3=ReadByte();



                    message1[3]=byte1/100 + '0';
                    message1[4]=(byte1%100)/10  +'0';
                    message1[5]=(byte1%100)%10 + '0';
                    LCD_OUT(1,1,message1);

                    message2[3]=byte2/100 + '0';
                    message2[4]=(byte2%100)/10  +'0';
                    message2[5]=(byte2%100)%10 + '0';
                    LCD_OUT(1,11,message2);

                    message3[3]=byte3/100 + '0';
                    message3[4]=(byte3%100)/10  +'0';
                    message3[5]=(byte3%100)%10 + '0';
                    LCD_OUT(2,1,message3);
                   
                 if(onetime==0)
                 {
                    RB0_BIT^=1;
                    onetime=1;
                   if(byte1==byte1_canale1 && byte2==byte2_canale1 && byte3==byte3_canale1)            // && byte3==byte3_canale1           && (byte2==byte2_canale1)
                    {  RA3_BIT = RA3_bIT^1;    }
                 }

              if(onetime==1)
                {
                    tempo=65536-15000;           // esegue 25000 incrementi * 0.8 us = 20 ms
                    TMR3L=tempo;
                    TMR3H=tempo>>8;
                    TMR3ON_BIT=1;
                }
           }
       }
    }
}






unsigned short int ReadByte()
{

unsigned short int val, i;
val=0;

for(i=0; i<8; i++)
{
    TMR1ON_bit=1;
    while(DATA);
    TMR1ON_bit=0;

    tempo = ( TMR1L + (TMR1H<<8) );
    TMR1L=TMR1H=0;

    if(tempo > 1500)            //TEMPO MAGGIORE DI 1500 * 0.8 = 1.2 ms : livello logico 1
          val = val |( 1<<(7-i) );

    while(!DATA);
}
    return val;
}













void interrupt()
{


   if(TMR3IF_BIT)
   {
     onetime=0;
     TMR3L=TMR3H=tmr3on_bit=0;

     tmr3if_bit=0;
   }

}

In questo caso, una volta riconosciuto il bit di start del primo messaggio, aspetto che questo passi utilizzando il delay_ms; dopo ricerco il bit di start e comincio a prendere i valori dei 3 byte; sul display LCD viene visualizzato il valore dei 3 byte. Su ra3 è collegato il led che si accende quando il codice viene riconosciuto; su RB0 il led che segnala la ricezione di un codice, anche se non è quello trasmesso.

Probabilmente succede che il rumore che hai all'uscita del ricevitore quando non hai segnale in ingresso viene (giustamente) interpretato dalla UART nel PIC ricevitore come start-bit e dati a a seguire.

Quindi quando inizia la trasmissione vera e la FSM dell'UART è probabile che non si trovi nello stato "attendo start-bit" ma in altro stato random. A questo punto la risincronizzazione è difficoltosa, a meno che i byte non siano distanziati ben più del minino (10 volte Tbit) uno dei bit trasmessi viene interpretato come start-bit e il tutto rimane "fuori fase"....

Direi che, dato che mi sembra di capire che i modulini siano AM con modulazione OOK, una soluzione potrebbe essere un lead-in-delay, cioè accendi la portante, trasmetti 1, radiofrequenza accesa, chiamala un po' come vuoi.

Accendi la portante dicevo e poi attendi almeno il tempo che serve a trasmettere un byte (tipicamente 10Tbit) così lasci il tempo all'UART di arrivare allo stato "attendo start-bit" e naturalmente scarti quelllo che trovi nel registro dati ricevuti.

Poi dopo questo flushing inizi la trasmissione "normale" avendo cura che lo stato space (stato di riposo della linea) sia quello con portante accesa.

Finito di trasmettere il pacchetto spegni tutto.

Edit: vedo ora il codice.... non l'ho controllato ma quello lo controlli facilmente, togli i moduli TX/RX e colleghi i due PIC con due fili

carloc ha scritto:Probabilmente succede che il rumore che hai all'uscita del ricevitore quando non hai segnale in ingresso viene (giustamente) interpretato dalla UART nel PIC ricevitore come start-bit e dati a a seguire.

Per risolvere questo problema ho già introdotto la funzione SEARCH_START_BIT, che va a ricercare il bit di start che riporta quelle caratteristiche(tempo basso di un certo tot e tempo alto di un certo tot).
Quando dici accendi/spegni la portante, intendi interrompi l'alimentazione al modulo?

mmm pensavo tu usassi lo standard RS232....

comunque come fai ad essere sicuro che il rumore in uscita al ricevitore quando non hai trasmissione non possa essere "scambiato" per uno start?

Per accendere la portante intendo avere avere il trasmettitore che trasmette "a riposo", come stato space della linea, come fare lo sai tu che hai il datasheet del TX o alimenti o ha un pin enable separato...


se non hai il TX acceso hai rumore in uscita al ricevitore che potrebbe essere scambiato per start bit

allora quando decidi che devi trasmettere accendi il TX e aspetti fino a quando è sicuramente terminata la ricezione di un eventuale falso byte.

dopo inizi a trasmettere normalmente...

Questo è un po' quello che ho già fatto, il primo messaggio, dato che presentava sempre errori, viene lasciato perdere e viene considerato il secondo messaggio. Continuo a non capire cosa intendi per accendere la portante: significa tramettere uno 0? Il modulo possiede due piedini di alimentazione e due per i dati, anche se poi questi due piedini sono cortocircuitati tra loro.

Un'altra cosa come si spiega che il segnalericevuto dal rx, mostrato nell'immagine, risulti essere così storpiato?
è colpa del rumore? Se così fosse come faccio ad essere sicuro e che tutti gli altri bit non siano affetti da rumore?