Problema utilizzo ADC su PIC18 Pierin

[Luca1995]

Ciao a tutti :)
Ho un problema con l'utilizzo del convertitore analogico digitale integrato nel PIC18 Pierin.
Ho in mio possesso un MMA7361, che è una specie di giroscopio, in quanto ha 3 piedini di uscita chiamati x, y e z che mandano tensioni diverse in base all'inclinazione dell'oggetto (su x e y) e all'accelerazione verso il basso o verso l'alto su z. Su di un piano (sulla mia scrivania) si può leggere 1.5V su x e 1.7V su y. La z non la utilizzo.
Quindi ho collegato queste uscite analogiche ai piedini RE2 (AN7) e RE1 (AN6) del PIC per poter acquisire i valori analogici emanati dal dispositivo.
Ho creato quindi due funzioni per acquisire 10 campioni e fare la media su ogni canale.
Una legge 10 volte da RE2 (x) e l'altra 10 volte da RE1 (y). Ci sono poi 2 display 7 segmenti collegati ai PORTB e PORTD per mostrare i valori letti sui piedini analogici (moltiplicati per 10 per non avere la virgola) e dei motori comandati da 4 piedini del PORTC.
Il problema è il seguente: se le due funzioni le utilizzo separatamente, cioè una funziona e l'altra la metto come commento per intenderci, i valori vengono letti giustamente e mostrati sui display moltiplicati per 10. Inoltre le funzioni if per i motori fanno il loro dovere. Nel momento che le metto tutte e due nel programma e devono quindi leggere i valori prima da un canale e poi dal successivo succede un po di casino tra le variabili. In poche parole sulla y si legge sempre lo stesso valore mentre sulla x si può leggere 33 come valore base, mentre normalmente è 15. Siccome 15+17 (che sono i valori di x e y prelevati separatamente) è uguale a 32 sembrerebbe che esso faccia la somma e poi contando le virgole si arriva a 33. Inoltre i due dati sono memorizzati in variabili diverse. Cosa potrebbe essere per voi??
(le funzioni alla fine sono quelle per scrivere sui display a 7 segmenti e funzionano, garantito al limone)

Codice: Seleziona tutto

// File di definizione dei registri del micro.
#include "p18f47j53.h"

#include <delays.h>
#include <stdio.h>
#include <math.h>

// Header del main
#include "main.h"

// File di configurazione dei fuses
#include "configurazione.h"   

// Mappatura delle interrupt
#include "mappa_int.h"

// Definizioni hardware
#include "hardware_def.h"




//------------------------------------------------------------------------------
// Variabili globali
//------------------------------------------------------------------------------
#pragma udata
volatile long int timer_delay;    // Timer software
volatile long int sincronismo;

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt ad ALTA priorità
//------------------------------------------------------------------------------
#pragma code
#pragma interrupt highPriorityInterrupt
void highPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
}

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt a BASSA priorità
//------------------------------------------------------------------------------
#pragma interruptlow lowPriorityInterrupt
void lowPriorityInterrupt()
{
   // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
  // Gestione dell' interrupt del timer 2
  if(PIR1bits.TMR2IF)
  {
    // gestione del flag di sincronismo
    if (sincronismo) sincronismo = 0;
   
    // gestione del timer software. Il timer software deve decrementarsi
    // fino ad arrivare a 0. Una volta arrivato a 0 resta fermo a 0.
    if (timer_delay) timer_delay--;
      
    // Resetta il flag che ha generato l' interrupt
    PIR1bits.TMR2IF = 0;
  }
}

//------------------------------------------------------------------------------
// Prototipi delle funzioni
//------------------------------------------------------------------------------
#pragma code
void scrivi_numero(int);
void scrivi_dnumero(int);
void scrivi_doppione(int);
void ritardo(int);
void adc_deInit(void);
double valore_x1(void);
double valore_y1(void);
double valore_z1(void);

//------------------------------------------------------------------------------
// Funzioni
//------------------------------------------------------------------------------
#pragma code



//------------------------------------------------------------------------------
// De-inizializza l' ADC
void adc_deInit(void)
{
  ADCON0 = 0;
  ADCON1 = 0;
  IPR1bits.ADIP = 0;  // Bit di priorità interrupt ADC
  PIE1bits.ADIE = 0;  // Interrupt disabilitta
  PIR1bits.ADIF = 0;  // Flag interrupt azzerato
}

//------------------------------------------------------------------------------
// De-inizializza il timer 2 e lo porta nello stato in cui si trovava
// subito dopo il RESET
void timer2_deInit(void)
{
  T2CON = 0;            // Resetta il timer 2 control register
  TMR2 = 0;             // Azzera il contatore interno
  PR2 = 0;              // Azzera il registro comparatore
  PIE1bits.TMR2IE = 0;  // Disabilita l' interrupt
  IPR1bits.TMR2IP = 0;  // Resetta il bit di priorità dell' interrupt
  PIR1bits.TMR2IF = 0;  // Azzera il flag di interrupt
}

//------------------------------------------------------------------------------
// MAIN FUNCTION
//------------------------------------------------------------------------------
void main(void)
{
 
  // Fa partire il PLL.
  // Anche se viene selezionato tramite i bit di configurazione
  // il suo funzionamento non è automatico. Ha bisogno di un comando.
  OSCTUNEbits.PLLEN = 1;
  // Attende abbastanza tempo per far stabilizzare il PLL
  Delay1KTCYx(100);
 
 
  // -------- Inizializzazione delle periferiche --------
 
  // De-inizializza il timer2. Non sarebbe necessario perché il micro esce
  // allo stato di RESET ma è comunque buona pratica de-inizializzare sempre
  // le periferiche per non tralasciare nessun bit.
  timer2_deInit();
  // Inizializza il timer 2 per interrupt ogni millisecondo.
  // prescaler divide per 16
  T2CONbits.T2CKPS = 2;
  // Postscaler divide per 5
  T2CONbits.T2OUTPS = 4;
  // Imposta il valore comparatore a 150
  PR2 = 150;
  // Imposta l' interrupt del Timer 2 a priorita' bassa
  IPR1bits.TMR2IP = 0;
  // abilita interrupt del timer
  PIE1bits.TMR2IE = 1;
 
 
  // Inizializza tutti i pin come digitali
  ANCON0 = 0xFF;
  ANCON1 = 0x1F;
  // Inizializza il pin AN7 (RE2). AN6,AN5  come ingresso analogico
  ANCON0bits.PCFG7 = 0; // 12/08/2013 corretto BUG segnalato da c1b8
ANCON0bits.PCFG6 = 0;
ANCON0bits.PCFG5 = 0; 


  // De-inizializza l' ADC
  adc_deInit();
  // Seleziona Vref positiva Vdd
  ADCON0bits.VCFG0 = 0;
  // Seleziona Vref negativa Vss
  ADCON0bits.VCFG1 = 0;
  // Seleziona il tempo di conversione 20TAD
  ADCON1bits.ACQT = 7;
  // Clock di conversione FOSC/64
  ADCON1bits.ADCS = 6;
  // Formato del risultato allineato a destra
  ADCON1bits.ADFM = 1;

 
  // -------- Selezione ed abilitazione delle interrupt --------
  // Ora che si sono inizializzate tutte le periferiche si possono abilitare
  // Oppurtunamente le interrupt
  // abilita le interrupt a bassa priorita'
  RCONbits.IPEN = 1;
  // abilta tutte le interrupt a priorità bassa
  INTCONbits.GIEL = 1;
  // Abilita tutte le interrupt in generale
  INTCONbits.GIEH = 1;
 
  // -------- Attivazione delle periferiche --------
  // Accensione del timer
  T2CONbits.TMR2ON = 1;
  // Accensione ADC
  ADCON0bits.ADON = 1;

 
  //Dichiaro i pin digitali con Input/Output
TRISB = 0x00;
TRISD = 0x00;

TRISC = 0x00;

//Inizializzo i piedini digitali del MCU
LATB = 0xFF;
LATD = 0xFF;
LATC = 0x00;
 
  // -------- Ciclo infinito di funzionamento --------
  for(;;)
  {   
   
   double y, x;
   //acquisisco i valori!!!!!!!
        //scrivi_doppione(int) mostra il valore sui due display a 7 segmenti. Moltiplico per 10
        //per liberarmi della virgola. Per leggere la x scrivo la x e ricarico il programma......
   y = valore_y1()*3.27/1024.00;
   x = valore_x1()*3.27/1024.00;

   scrivi_doppione(10.00*y);
      
   
   
   //funzioni per decidere quale motore attivare ed in quale senso farlo girare
   if((10.00*y)>19){LATCbits.LATC0 = 0; LATCbits.LATC1 = 1;}   
   if((10.00*y)<15){LATCbits.LATC0 = 1; LATCbits.LATC1 = 0;}
   if(((10.00*y)<=19)&&((10.00*y)>=15)){LATCbits.LATC0 = 0; LATCbits.LATC1 = 0;}
   
   if((10.00*x)>17){LATCbits.LATC2 = 1; LATCbits.LATC6 = 0;}   
   if((10.00*x)<13){LATCbits.LATC2 = 0; LATCbits.LATC6 = 1;}
   if(((10.00*x)<=17)&&((10.00*x)>=13)){LATCbits.LATC2 = 0; LATCbits.LATC6 = 0;}
   
   

   
    }//Chiudo il for(;;)
 
  }

//x1 collegato ad RE2
//y2 collegato ad RE1
//z1 collegato ad RE0

double valore_x1(void){
int i;
int accumulatore;
for(i=0;i<10;i++)
{
     sincronismo = 1;
      while(sincronismo);
   
    // Calibrazione ADC
    ADCON1bits.ADCAL = 1;
    ADCON0bits.GO = 1;
    while(ADCON0bits.GO);
    ADCON1bits.ADCAL = 0;
   
    // Seleziona l' ingresso da misurare
    ADCON0bits.CHS = 7;
   
      // Fa partire la conversione 45 us.
      ADCON0bits.GO = 1;
      // Aspetta la fine della conversione
      while(ADCON0bits.GO);
      // Legge il valore convertito
      accumulatore += ADRES;
   
}
   ADRES = 0;
   return (accumulatore/10);
}


double valore_y1(void){
int i;
int accumulatore;
for(i=0;i<10;i++)
{
     sincronismo = 1;
      while(sincronismo);
   
    // Calibrazione ADC
    ADCON1bits.ADCAL = 1;
    ADCON0bits.GO = 1;
    while(ADCON0bits.GO);
    ADCON1bits.ADCAL = 0;
   
    // Seleziona l' ingresso da misurare
    ADCON0bits.CHS = 6;
   
      // Fa partire la conversione 45 us.
      ADCON0bits.GO = 1;
      // Aspetta la fine della conversione
      while(ADCON0bits.GO);
      // Legge il valore convertito
      accumulatore += ADRES;
}
   ADRES = 0;
   return (accumulatore/10);
}


double valore_z1(void){
int i;
int accumulatore;
for(i=0;i<10;i++)
{
     sincronismo = 1;
      while(sincronismo);
   
    // Calibrazione ADC
    ADCON1bits.ADCAL = 1;
    ADCON0bits.GO = 1;
    while(ADCON0bits.GO);
    ADCON1bits.ADCAL = 0;
   
    // Seleziona l' ingresso da misurare
    ADCON0bits.CHS = 5;
   
      // Fa partire la conversione 45 us.
      ADCON0bits.GO = 1;
      // Aspetta la fine della conversione
      while(ADCON0bits.GO);
      // Legge il valore convertito
      accumulatore += ADRES;
}
   return (accumulatore/10);
}





void ritardo(int a)
   {
   timer_delay = a;
   while(timer_delay);
   }

void clear(void)
{
LATB = 0xFF;
LATD = 0xFF;
}


void scrivi_doppione(int x)
{
if (x == 0){scrivi_numero(0);scrivi_dnumero(0);}
if (x == 1){scrivi_numero(1);scrivi_dnumero(0);}
if (x == 2){scrivi_numero(2);scrivi_dnumero(0);}
if (x == 3){scrivi_numero(3);scrivi_dnumero(0);}
if (x == 4){scrivi_numero(4);scrivi_dnumero(0);}
if (x == 5){scrivi_numero(5);scrivi_dnumero(0);}
if (x == 6){scrivi_numero(6);scrivi_dnumero(0);}
if (x == 7){scrivi_numero(7);scrivi_dnumero(0);}
if (x == 8){scrivi_numero(8);scrivi_dnumero(0);}
if (x == 9){scrivi_numero(9);scrivi_dnumero(0);}
if (x == 10){scrivi_numero(0);scrivi_dnumero(1);}
if (x == 11){scrivi_numero(1);scrivi_dnumero(1);}
if (x == 12){scrivi_numero(2);scrivi_dnumero(1);}
if (x == 13){scrivi_numero(3);scrivi_dnumero(1);}
if (x == 14){scrivi_numero(4);scrivi_dnumero(1);}
if (x == 15){scrivi_numero(5);scrivi_dnumero(1);}
if (x == 16){scrivi_numero(6);scrivi_dnumero(1);}
if (x == 17){scrivi_numero(7);scrivi_dnumero(1);}
if (x == 18){scrivi_numero(8);scrivi_dnumero(1);}
if (x == 19){scrivi_numero(9);scrivi_dnumero(1);}
if (x == 20){scrivi_numero(0);scrivi_dnumero(2);}
if (x == 21){scrivi_numero(1);scrivi_dnumero(2);}
if (x == 22){scrivi_numero(2);scrivi_dnumero(2);}
if (x == 23){scrivi_numero(3);scrivi_dnumero(2);}
if (x == 24){scrivi_numero(4);scrivi_dnumero(2);}
if (x == 25){scrivi_numero(5);scrivi_dnumero(2);}
if (x == 26){scrivi_numero(6);scrivi_dnumero(2);}
if (x == 27){scrivi_numero(7);scrivi_dnumero(2);}
if (x == 28){scrivi_numero(8);scrivi_dnumero(2);}
if (x == 29){scrivi_numero(9);scrivi_dnumero(2);}
if (x == 30){scrivi_numero(0);scrivi_dnumero(3);}
if (x == 31){scrivi_numero(1);scrivi_dnumero(3);}
if (x == 32){scrivi_numero(2);scrivi_dnumero(3);}
if (x == 33){scrivi_numero(3);scrivi_dnumero(3);}
if (x == 34){scrivi_numero(4);scrivi_dnumero(3);}
if (x == 35){scrivi_numero(5);scrivi_dnumero(3);}
if (x == 36){scrivi_numero(6);scrivi_dnumero(3);}
if (x == 37){scrivi_numero(7);scrivi_dnumero(3);}
if (x == 38){scrivi_numero(8);scrivi_dnumero(3);}
if (x == 39){scrivi_numero(9);scrivi_dnumero(3);}
if (x == 40){scrivi_numero(0);scrivi_dnumero(4);}
if (x == 41){scrivi_numero(1);scrivi_dnumero(4);}
if (x == 42){scrivi_numero(2);scrivi_dnumero(4);}
if (x == 43){scrivi_numero(3);scrivi_dnumero(4);}
if (x == 44){scrivi_numero(4);scrivi_dnumero(4);}
if (x == 45){scrivi_numero(5);scrivi_dnumero(4);}
if (x == 46){scrivi_numero(6);scrivi_dnumero(4);}
if (x == 47){scrivi_numero(7);scrivi_dnumero(4);}
if (x == 48){scrivi_numero(8);scrivi_dnumero(4);}
if (x == 49){scrivi_numero(9);scrivi_dnumero(4);}
if (x == 50){scrivi_numero(0);scrivi_dnumero(5);}
if (x == 51){scrivi_numero(1);scrivi_dnumero(5);}
if (x == 52){scrivi_numero(2);scrivi_dnumero(5);}
if (x == 53){scrivi_numero(3);scrivi_dnumero(5);}
if (x == 54){scrivi_numero(4);scrivi_dnumero(5);}
if (x == 55){scrivi_numero(5);scrivi_dnumero(5);}
if (x == 56){scrivi_numero(6);scrivi_dnumero(5);}
if (x == 57){scrivi_numero(7);scrivi_dnumero(5);}
if (x == 58){scrivi_numero(8);scrivi_dnumero(5);}
if (x == 59){scrivi_numero(9);scrivi_dnumero(5);}
if (x == 60){scrivi_numero(0);scrivi_dnumero(6);}
if (x == 61){scrivi_numero(1);scrivi_dnumero(6);}
if (x == 62){scrivi_numero(2);scrivi_dnumero(6);}
if (x == 63){scrivi_numero(3);scrivi_dnumero(6);}
if (x == 64){scrivi_numero(4);scrivi_dnumero(6);}
if (x == 65){scrivi_numero(5);scrivi_dnumero(6);}
if (x == 66){scrivi_numero(6);scrivi_dnumero(6);}
if (x == 67){scrivi_numero(7);scrivi_dnumero(6);}
if (x == 68){scrivi_numero(8);scrivi_dnumero(6);}
if (x == 69){scrivi_numero(9);scrivi_dnumero(6);}
if (x == 70){scrivi_numero(0);scrivi_dnumero(7);}
if (x == 71){scrivi_numero(1);scrivi_dnumero(7);}
if (x == 72){scrivi_numero(2);scrivi_dnumero(7);}
if (x == 73){scrivi_numero(3);scrivi_dnumero(7);}
if (x == 74){scrivi_numero(4);scrivi_dnumero(7);}
if (x == 75){scrivi_numero(5);scrivi_dnumero(7);}
if (x == 76){scrivi_numero(6);scrivi_dnumero(7);}
if (x == 77){scrivi_numero(7);scrivi_dnumero(7);}
if (x == 78){scrivi_numero(8);scrivi_dnumero(7);}
if (x == 79){scrivi_numero(9);scrivi_dnumero(7);}
if (x == 80){scrivi_numero(0);scrivi_dnumero(8);}
if (x == 81){scrivi_numero(1);scrivi_dnumero(8);}
if (x == 82){scrivi_numero(2);scrivi_dnumero(8);}
if (x == 83){scrivi_numero(3);scrivi_dnumero(8);}
if (x == 84){scrivi_numero(4);scrivi_dnumero(8);}
if (x == 85){scrivi_numero(5);scrivi_dnumero(8);}
if (x == 86){scrivi_numero(6);scrivi_dnumero(8);}
if (x == 87){scrivi_numero(7);scrivi_dnumero(8);}
if (x == 88){scrivi_numero(8);scrivi_dnumero(8);}
if (x == 89){scrivi_numero(9);scrivi_dnumero(8);}
if (x == 90){scrivi_numero(0);scrivi_dnumero(9);}
if (x == 91){scrivi_numero(1);scrivi_dnumero(9);}
if (x == 92){scrivi_numero(2);scrivi_dnumero(9);}
if (x == 93){scrivi_numero(3);scrivi_dnumero(9);}
if (x == 94){scrivi_numero(4);scrivi_dnumero(9);}
if (x == 95){scrivi_numero(5);scrivi_dnumero(9);}
if (x == 96){scrivi_numero(6);scrivi_dnumero(9);}
if (x == 97){scrivi_numero(7);scrivi_dnumero(9);}
if (x == 98){scrivi_numero(8);scrivi_dnumero(9);}
if (x == 99){scrivi_numero(9);scrivi_dnumero(9);}
}

void scrivi_numero(int a){
   if(a==0){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 0;
   LATBbits.LATB3 = 1;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 0;
   LATBbits.LATB7 = 0;
   }

   if(a==1){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 1;
   LATBbits.LATB2 = 1;
   LATBbits.LATB3 =    1;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 1;
   LATBbits.LATB7 = 1;
   }

   if(a==2){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 1;
   LATBbits.LATB3 = 0;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 1;
   LATBbits.LATB6 = 0;
   LATBbits.LATB7 = 0;
   }

   if(a==3){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 1;
   LATBbits.LATB3 = 0;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 0;
   LATBbits.LATB7 = 1;
   }

   if(a==4){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 1;
   LATBbits.LATB2 = 0;
   LATBbits.LATB3 = 0;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 1;
   LATBbits.LATB7 = 1;
   }

   if(a==5){
   LATBbits.LATB0 = 1;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 0;
   LATBbits.LATB3 = 0;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 0;
   LATBbits.LATB7 = 1;
   }

   if(a==6){
   LATBbits.LATB0 = 1;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 0;
   LATBbits.LATB3 = 0;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 0;
   LATBbits.LATB7 = 0;
   }

   if(a==7){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 1;
   LATBbits.LATB3 = 1;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 1;
   LATBbits.LATB7 = 1;
   }

   if(a==8){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 0;
   LATBbits.LATB3 = 0;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 0;
   LATBbits.LATB7 = 0;
   }

   if(a==9){
   LATBbits.LATB0 = 0;
   LATBbits.LATB1 = 0;
   LATBbits.LATB2 = 0;
   LATBbits.LATB3 = 0;
   LATBbits.LATB4 = 1;
   LATBbits.LATB5 = 0;
   LATBbits.LATB6 = 0;
   LATBbits.LATB7 = 1;
   }

}








void scrivi_dnumero(int a){
   if(a==0){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 0;
   LATDbits.LATD3 = 1;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 0;
   LATDbits.LATD7 = 0;
   }

   if(a==1){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 1;
   LATDbits.LATD2 = 1;
   LATDbits.LATD3 = 1;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 1;
   LATDbits.LATD7 = 1;
   }

   if(a==2){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 1;
   LATDbits.LATD3 = 0;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 1;
   LATDbits.LATD6 = 0;
   LATDbits.LATD7 = 0;
   }

   if(a==3){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 1;
   LATDbits.LATD3 = 0;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 0;
   LATDbits.LATD7 = 1;
   }

   if(a==4){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 1;
   LATDbits.LATD2 = 0;
   LATDbits.LATD3 = 0;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 1;
   LATDbits.LATD7 = 1;
   }

   if(a==5){
   LATDbits.LATD0 = 1;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 0;
   LATDbits.LATD3 = 0;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 0;
   LATDbits.LATD7 = 1;
   }

   if(a==6){
   LATDbits.LATD0 = 1;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 0;
   LATDbits.LATD3 = 0;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 0;
   LATDbits.LATD7 = 0;
   }

   if(a==7){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 1;
   LATDbits.LATD3 = 1;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 1;
   LATDbits.LATD7 = 1;
   }

   if(a==8){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 0;
   LATDbits.LATD3 = 0;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 0;
   LATDbits.LATD7 = 0;
   }

   if(a==9){
   LATDbits.LATD0 = 0;
   LATDbits.LATD1 = 0;
   LATDbits.LATD2 = 0;
   LATDbits.LATD3 = 0;
   LATDbits.LATD4 = 1;
   LATDbits.LATD5 = 0;
   LATDbits.LATD6 = 0;
   LATDbits.LATD7 = 1;
   }

}

[c1b8]

All'interno di valore_x1() e valore_y1() utilizzi accumulatore per accumulare le letture effettuate, non sono del tutto convinto che dichiarare la variabile ma non inizializzarla prima del ciclo for di lettura sia corretto.
Se il tuo compilatore non si incarica di inizializzare quella variabile a 0, pur essendo una variabile locale potrebbe tornare risultati non corretti. Se poi il compilatore utilizza sempre la stessa lacazione di memoria potrebbe tornare valori pari alla somma letture di tutti i canali.

Intanto prova questa modifica, io continua a guardare il codice...

[Luca1995]

Per il momento ho risolto mettendo le due funzioni nell'interrupt di 1 millisecondo derivante dal timer2 e dichiarando le due variabili come globali in modo che siano continuamente aggiornate sul valore del giroscopio.
Adesso proverò a chiamarle in 2 modi diversi e di inizializzarle a 0 perché non penso che sia buono far andare l'ADC per sempre. Grazie tante intanto :)