comunicazione com blocca il pic

[sharky]

ciao a tutti!

ho il seguente codice che viene usato per leggere i dati inviati dal pc. (valori rgb.)

sono pacchetti da 4 byte. il primo byte é una @ che indica l inizio di un pacchetto, poi seguono RGB.

il mio problema é che se invio tanti dati uno dopo l altro il pic si blocca. e devo togliere e rimettere l alimentazione per farlo riprisitnare. succede solo inviando tanti dati di fretta. non succede se li invio a distanza di qualche secodno. per veloce intendo 1 pacchetto ogni 10 ms. (che in teoria dovrebbe essere lentissimo come tempo.. ) questo probelma me lo fa solo da poco.

cosa puo essere? vedete un errore di fondo nel mio programma? dato che non fa nient altro non ho usato interrupt...

il pic é un 18f4431. vi posto soltanto il loop principale perche il resto funziona tutto correttamente.

  while (1) {
  
  while(!DataRdyUSART());
  data = ReadUSART();
  if (data == 0x40)
   {
  PORTCbits.RC1 = 0;
  while(!DataRdyUSART());
  datar = ReadUSART();
  while(!DataRdyUSART());
  datag = ReadUSART();
  while(!DataRdyUSART());
  datab = ReadUSART();
  duty_cycle2 = datar;
  duty_cycle = duty_cycle2;
  outH =  duty_cycle >> 8; ////questa riga serve a fare lo shifting se modifico i valori pwm.
  outL = duty_cycle & 0b11111111;
  PDC0H = outH;
  PDC0L = outL;
  duty_cycle2 = datag;
  duty_cycle = duty_cycle2;
  outH =  duty_cycle >> 8;
  outL = duty_cycle & 0b11111111;
  PDC1H = outH;
  PDC1L = outL;
  duty_cycle2 = datab;
  duty_cycle = duty_cycle2;
  outH =  duty_cycle >> 8;
  outL = duty_cycle & 0b11111111;
  PDC3H = outH;
  PDC3L = outL;
  PORTCbits.RC1 = 1;
   }

  if (RCSTAbits.OERR == 1)  
  {
  RCSTAbits.CREN = 0;
  RCSTAbits.CREN = 1;
  }
  
  }

[sergio_camici]

La comunicazione seriale è una brutta bestia che molti tendono a sottovalutare

Per come hai gestito la cosa (con i while di attesa) se la seriale va in errore il programma si blocca.

Non aver paura degli interrupt, ricevi il carattere e mettilo in un buffer poi alzi una flag quando hai ricevuto un pacchetto e nel main loop lo analizzi.
Nell'int potrai anche gestire gli errori ci comunicazione ed eventualmente resettare qualche registro per sbloccare le situazioni "rognose".

[sharky]

grazie...

allora provo a riscriverlo e vediamo che combino..

[gyppe]

Devi controllare e azzerare i flag di errore altrimenti ti si blocca tutto quanto al 100%, io ci persi un mese. Aggiungi due righe dove controlli e gli azzeri se settati, fallo prima della ricezione vera e propria e vai a colpo sicuro
Ovvio poi se non vuoi perdere nessun dato devi aggiungere altri controlli, magari una comunicazione bidirezionale con conferma di dato ricevuto.

[Fu Mauro]

...pero' quando azzeri cerca di capire cosa azzeri e la causa dell'errore o natura del flag settato...!

...so che sarai critico nel farlo!

Ciao,

Mauro

[sharky]

ciao ragazzzzuoli!

ho appena visto ora le altre risposte, dunque ancora non é implementato in questo codice... counque, il codice che vi riporto qui é cio che ho al momento e ho il problema che il valore che nell interrupt viene salvato in "data2" non corrisponde al valore che il pc ha inviato. (controllato con un port monitor e con l oscilloscopio).

il codice é una conversione da quello precedente e é ancora molto sporco e contiene giri di variabili che si pososno eliminare. per favore non fate caso a cio dato che non é ancora finito. ora come ora ho il problema che "ciclo" é SEMPRE settato a 0... dunque il valore data2 non corrisponde mai a 0x40 che é il primo pacchetto che invio..

grazie

ciao

igor

 
#include <p18f4431.h>
#include <pwm.h>
#include <usart.h>
#include <timers.h>
#pragma config OSC = HS
#pragma config WDTEN = OFF
#pragma config LVP = OFF
#pragma config PWM4MX = RD5 
#pragma config CPB = OFF
#pragma config CPD = OFF 
#pragma config WRTC = OFF 
#pragma config WRTB = OFF 
#pragma config EBTRB = OFF 
  int ciclo = 0;
  int aggiorna = 0;
  unsigned char datar;
  unsigned char datag;
  unsigned char datab;
//#pragma config PBADEN = OFF
//OSC = HS Impostato per lavorare ad alta frequenza
//WDT = OFF Disabilito il watchdog timer
//LVP = OFF Disabilito programmazione LVP
//PBADEN = OFF Disabilito gli ingressi analogici
//*********************************
// gestione interrupt
//*********************************

//prototipo di funzione
void High_Int_Event (void);
#pragma code high_vector=0x08
void high_interrupt(void) {
  //imposta il salto per la gestione dell interrupt
  _asm GOTO High_Int_Event _endasm
}
#pragma code
#pragma interrupt High_Int_Event
void High_Int_Event (void) {
  //variabile che conterrá i dati ricevuti
  unsigned char data2;

  //controllo che l interrupt sia stato generato dall usart
  if (PIR1bits.RCIF == 1) {
  data2 = 0;
  data2 = ReadUSART();

  if ((ciclo == 0) && (data2 == 0x40)){ 
       ciclo ++; 
       }
  if (ciclo == 1) { 
        ciclo ++;
       datar = data2;
      }
  if (ciclo == 2) { 
        ciclo ++;
       datag = data2;
      }
  if (ciclo == 3) { 
       ciclo = 0; 
       datab = data2;
       aggiorna = 1;
      }

  }
  PIR1bits.RCIF = 0;
   
}

void main (void){

  // Variabile usata per creare un conteggio fittizio di pausa
  unsigned int i;
  // Periodo del segnale PWM
  unsigned char period;
  unsigned char data;
  // Duty Cycle
  unsigned int duty_cycle = 0;
  unsigned int duty_cycle2 = 0;
  unsigned char outH = 0;
  unsigned char outL = 0;
  // Imposto PORTA tutti ingressi
  LATA = 0x00;
  TRISA = 0xFF;
  // Imposto PORTB tutti ingressi
  LATB = 0x00;
  TRISB = 0x00;
  // Imposto PORTC tutti ingressi ed RC1 come uscita
  LATC = 0x00;
  TRISC = 0b11111101;
  // Imposto PORTD tutti ingressi
  LATD = 0x00;
  TRISD = 0b00011111;
  // Imposto PORTE tutti ingressi
  LATE = 0x00;
  TRISE = 0xFF;
  
  // configura l usart
  //8 bit
  //19200 bits/s
  //1bit stop
  //0 bit paritá
  RCSTAbits.SPEN = 1;
  OpenUSART ( USART_TX_INT_OFF &
  USART_RX_INT_ON &
  USART_ASYNCH_MODE &
  USART_EIGHT_BIT &
  USART_CONT_RX &
  USART_BRGH_HIGH, 64);
  
  //configuro PTCON0: PWM TIMER CONTROL REGISTER 0
  //postscale 1:1 0000
  //prescale 1:1 00
  //free running mode 00
  PTCON0 = 0b00000000;
  
  //configuro PTCON1: PWM TIMER CONTROL REGISTER 1
  //timebase on 1
  //timebase counts up 0
  //unimplemented 000000
  PTCON1 = 0b10000000;
  
  //configuro PWMCON0: PWM CONTROL REGISTER 0
  //unimplemented 0
  //pwm odd pins --> 111
  //all indipendent 1111
  PWMCON0 = 0b01111111;
  
  //configuro PWMCON1: PWM CONTROL REGISTER 1
  //postscale 1:1 0000 
  //special event downwards 1
  //unimplemented 0
  //PWM update disable bit 0
  //output sync 1
  PWMCON1 = 0b00001001;

  //configuro FLTCONFIG: FAULT CONFIGURATION REGISTER
  //disable fault 0
  FLTCONFIG = 0b00000000;
 
  //configuro OVDCOND: OUTPUT OVERRIDE CONTROL REGISTER
  // tutto a 1. provare...
  OVDCOND = 0b11111111;
  //conficuro OVDCONS: OUTPUT STATE REGISTER
  // tutto a 0. provare...
  OVDCONS = 0b00000000;
    DTCON = 0;   

  //PTPERL = 249;
  PTPERL = 63;
  
  PTPERH = 0;
  PDC0H = 0xff;
  PDC0L = 0xff;
  
 PORTCbits.RC1 = 1; 
  //abilito l interrupt globale
  INTCONbits.GIE = 1;
  
  //Abilito interrupt per periferiche
  INTCONbits.PEIE = 1;
  PIR1bits.RCIF = 0;
  PDC0H = 0;
  PDC0L = 10;
  PDC1H = 0;
  PDC1L = 10;
  PDC3H = 0;
  PDC3L = 10;

 // Ciclo infinito
  while (1) {
  
  if (aggiorna == 1)
  {
  duty_cycle2 = datar;
  duty_cycle = duty_cycle2;
  outH =  duty_cycle >> 8;
  outL = duty_cycle & 0b11111111;
  PDC0H = outH;
  PDC0L = outL;
  duty_cycle2 = datag;
  duty_cycle = duty_cycle2;
  outH =  duty_cycle >> 8;
  outL = duty_cycle & 0b11111111;
  PDC1H = outH;
  PDC1L = outL;
  duty_cycle2 = datab;
  duty_cycle = duty_cycle2;
  outH =  duty_cycle >> 8;
  outL = duty_cycle & 0b11111111;
  PDC3H = outH;
  PDC3L = outL;
  aggiorna = 0;
  }

  if (RCSTAbits.OERR == 1)  
  {
  RCSTAbits.CREN = 0;
  RCSTAbits.CREN = 1;
  }
  
  }
}

[sharky]

sono ancora al punto di ieri.. nulla da fare..

il pc invia 0x40 e nel RCREG cé 0xA0.

cio che non mi quadra é che senza interrupt gli arriva il carattere giusto...

[sergio_camici]

Questa la mia inizializzazione

 // 19200 N81
 OpenUSART( USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH,	25 );

Questo il mio interrupt

#pragma code highVector=0x008                        
void atInterrupthigh(void)
{
_asm GOTO MyInterrupt _endasm                
}
#pragma code // retour à la zone de code

#pragma interrupt MyInterrupt
void MyInterrupt(void)
{
  // Interrupt su seriale
  if (PIR1bits.RCIF){
    data = ReadUSART();
	WriteUSART(data);
	
    PIR1bits.RCIF = 0;

 	if ((sts_buff == IDLE) && (data == START_PROTOCOL)){	// Se START prendo un puntatore al buffer
		sts_buff = GET_DATA;
		cmd_process = IDLE;
		idx_wbuff = 0;
	}

 	if ((sts_buff == GET_DATA) && (data == STOP_PROTOCOL)){
		sts_buff = IDLE;
		cmd_process = PROCESS;		
	}

 	if (sts_buff == GET_DATA){
		CMDbuff[idx_wbuff++] = data;
	}
  } 
}

Non è bello dirlo, ma a me funziona.
Magari è colpa del selettore di velocità (io 25 tu 64)... io vado a 32Mhz

[sharky]

ciao sergio!

Grazie dell aiuto..

io viaggio con un 20 mhz e con SPBRG=64 ottengo una rate di 19231 con un margine di errore del 0,16%.


ho ricontrollato tramite oscilloscopio e il valore che esce dal max232 é corretto. cioé costantemente su +5, un bit basso di start, e poi il bite che voglio inviare e infine un bit alto di stop.

cio che non mi quadra é che cio che viene salvato nel pic non é cio che viene inviato. cio che rende il tutto ancora piu strano é che se io invio 0x01 il pic salva un valore differente, ma inviando 0x01 salva sempre lo STESSO valore. cioé non é un valore random. inviando 0x02 salva un altro valore ma comunque sempre quello per il 0x02... boh...

[Fu Mauro]

Ciao,

non ho letto tutte le impostazioni, ma ti consiglio di fare un loop-back. Quello che invii deve essere quello che ricevi.
Non sono certo se stai ricevendo gia' in loop-back.

P.S.
Poi prova anche altri baud rate.
...l'esempio del libro lo hai fatto?
...sicuro che non invii anche caratteri strai come carriage return?


Ciao,

Mauro