instruction_Offset_compensation()

void instruction_Offset_compensation

(

void

)

Output offset voltage compensation.

Returns

No Parameters, the actual result is sent to the CAN bus output throught tx_data.

 void instruction_Offset_compensation(void){
    #define offset_PGA_1_or_pre_0_out 7  /* This is at byte istruzione_byte_1 */
    #define offset_different_between_ch 6  /* This is at byte istruzione_byte_1 */   
    #define offset_drift_adjusted_on_offset 5  /* This is at byte istruzione_byte_1 */  
     #define attivazione_CMRR  2   /*if 1 the CMRR is inactive at half scale, if 0 the CMRR is loaded from EPROM and set in the trimmer*/
    #define JFET_offset_used_0_not_used_1  1  /* If 1 the JFET offset from EPROM is not used as default*/
    #define JFET_offset_measured_and_stored_in_EPROM 0 /* If 1 the JFET offset is measured and store in EPROM*/
    
     
     
    //Definizioni delle varibaili di stato
    #define stato_esci_dalla_misura (int)(-1 )
    #define stato_compensazione_termica_su_zero_offset 0
    #define stato_compensazione_in_temperatura_sull_0ffset_secondo_passo 1 
    #define stato_compensazione_in_temperatura_sull_0ffset 2 
    #define stato_senza_compensazione_in_temperatura 3 
    #define  stato_misurare_parametro_per_EPROM_terzo_passo 4
    #define stato_misurare_parametro_per_EPROM_secondo_passo 5
    #define stato_misurare_parametro_per_EPROM 6
//struct trimmer_type /*{
//  unsigned char fine_thermal;
//  unsigned char fine_offset;
//  unsigned char coarse_thermal;  
//  unsigned char coarse_offset;
//}*/   Trimmer_offset_preampli[2];
//  int16_t Valori_per_i_trimmer[2];                    // Qui verranno inseriti i valori per i trimmer
    char canale;
     signed char stato_della_misura;
     unsigned char dati_letti[4],buffer_vettore_istruzioni_istruzione_byte_0=vettore_istruzioni[istruzione_byte_0];
    unsigned short errore, errore_temperatura, indirizzo_da_usare;
    char gain_da_moltiplicare;
    long int offset, discrepanza[2];
    int tolleranza=vettore_istruzioni[istruzione_byte_3]*1000; //in microV
    int attesa, misura_finale[2];
//  char nodo_di_misura_1[]={ADC_ADC_PGA_neg_in_ch0, ADC_ADC_PGA_neg_in_ch1};
//  char nodo_di_misura_2[]={ADC_ADC_PGA_pos_in_ch0, ADC_ADC_PGA_pos_in_ch1};
    char ii, nodo_di_misura_1[]={ADC_ADC_PGA_neg_out_ch0, ADC_ADC_PGA_neg_out_ch1};
    char nodo_di_misura_2[]={ADC_ADC_PGA_pos_out_ch0, ADC_ADC_PGA_pos_out_ch1};
    char chi_aggiustiamo = vettore_istruzioni[istruzione_byte_4_e_scelta_canale] & 0x3;
//  bool errore_canale[]={false,false}, errore_totale=false, saturazione_canale[]={false,false};
    bool saturazione_canale[]={false,false};
    int temperatura[2];
    int coarse_trimmer_step[] = {coarse_Trimmer_offset_step_actual[0] * guadagno_minimo_PGA, coarse_Trimmer_offset_step_actual[1] * guadagno_minimo_PGA} ; //********************************************* coarse_Trimmer_offset_step_actual
    int fine_trimmer_step[] ={ fine_Trimmer_offset_step_actual[0] * guadagno_minimo_PGA,fine_Trimmer_offset_step_actual[1] * guadagno_minimo_PGA} ;     //*********************************************
//   char nodo_di_misura[]={ADC_ADC_PGA_pos_out_ch0, ADC_ADC_PGA_pos_out_ch1};
    
    //Impostiamo il trimmer del CMRR
    if( (vettore_istruzioni[istruzione_byte_1]  >> attivazione_CMRR ) & 1 ){
            attiva_il_CMRR(  chi_aggiustiamo /*1 per canale 0, 2 per canale 1, 3 per entrambi i canali*/,0);
    }else{
            attiva_il_CMRR(  chi_aggiustiamo /*1 per canale 0, 2 per canale 1, 3 per entrambi i canali*/,1);
    }
 
    if ( (tolleranza << 1)  < (fine_trimmer_step[0]+fine_trimmer_step[1])) tolleranza = (fine_trimmer_step[0]+fine_trimmer_step[1]) >> 1;
//  int valore_target_per_ch[canale] =1000*(signed short)( vettore_istruzioni[byte_istr_dati_0] & 0xFF + ( (signed char)(0xFF & vettore_istruzioni[byte_istr_dati_1])*(1<<8) ));
    
        if( (vettore_istruzioni[istruzione_byte_1] >> offset_PGA_1_or_pre_0_out) &1){
        //Offset at Pre output
        nodo_di_misura_1[0]=ADC_ADC_PGA_neg_in_ch0;
        nodo_di_misura_1[1]= ADC_ADC_PGA_neg_in_ch1;
        nodo_di_misura_2[0]=ADC_ADC_PGA_pos_in_ch0;
        nodo_di_misura_2[1]=ADC_ADC_PGA_pos_in_ch1;
      coarse_trimmer_step[0] = coarse_Trimmer_offset_step_actual[0]  ;
      fine_trimmer_step[1] = coarse_Trimmer_offset_step_actual[1] ;     
         gain_da_moltiplicare= 1;
    }else{
         gain_da_moltiplicare= guadagno_minimo_PGA;
    }
    
if( (vettore_istruzioni[istruzione_byte_1] >> offset_drift_adjusted_on_offset) & 1){
    stato_della_misura=stato_compensazione_in_temperatura_sull_0ffset;  //Si fanno 2 giri perch\'e si vuole aggiustare la deriva con l'offset
    }else{
    stato_della_misura=stato_compensazione_termica_su_zero_offset; //Si fa un solo giro perch\'e si aggiusta la deriva ad offset zero.
}
if ( buffer_vettore_istruzioni_istruzione_byte_0 == 0xff) stato_della_misura=stato_senza_compensazione_in_temperatura;
 
if( (vettore_istruzioni[istruzione_byte_1] >> JFET_offset_measured_and_stored_in_EPROM) & 1) stato_della_misura=stato_misurare_parametro_per_EPROM;
 
for( canale=0;canale<2;canale++){
    if( (chi_aggiustiamo >> canale) & 1){
            if( (vettore_istruzioni[istruzione_byte_1] >> JFET_offset_used_0_not_used_1) & 1) {//Non si usa la EPROM per l'offset del JFET, quindi trimmer a met\'a scala
                        Trimmer_offset_preampli[canale].JFET_Offset=0x80;
            }else{//Usiamo la EPROM             
//                      lettura_EPROM(canale,  Memory_address_JFET_trimmer_offset , dati_letti);
                        Trimmer_offset_preampli[canale].JFET_Offset=dati_letti[0];
                        Trimmer_offset_preampli[canale].coarse_offset=dati_letti[1];
                        Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);
            }
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer, Trimmer_offset_preampli[canale].JFET_Offset); 
        }
}
    
    while (stato_della_misura >=0){
//***********************************************************************************************************   
        //Vediamo che temperatura eventualmente usare e che range adottare
        //Lo facciamo per entrambi i canali anche se poi magari agiremo solo su uno
            if ( buffer_vettore_istruzioni_istruzione_byte_0 <0xff){
                    //Impostaiamo il trimmer per la deriva alla temperatura data o la misuriamo
                            if ( buffer_vettore_istruzioni_istruzione_byte_0==0){
                            Misura_della_temperatura(temperatura);
                            for (ii=0;ii<2;ii++){
                                temperatura[ii]= temperatura[ii]*3;
                                temperatura[ii]= temperatura[ii]/1000; //Normalizziamo a quello memorizzato
                            }}else{
                                temperatura[0]=buffer_vettore_istruzioni_istruzione_byte_0*3;
                                temperatura[1]=temperatura[0];
                            }
                        //Cerchiamo la temperatura pi\'u prossima per l'impostazione del trimer
                        for (canale=0; canale<2;canale++){
                            errore=0xff;
                            for (ii=0; ii< numero_temperature_impostazione_deriva[canale]; ii++){       
                                errore_temperatura= abs( valori_temperature_impostazione_deriva[canale][ii] - temperatura[canale]);
                                if (errore_temperatura < errore){
                                    errore=errore_temperatura;
                                    temperatura_di_lavoro[canale]= ii;
                                }
                            }       
                        }
            }
        //Imposttiamo il trimmer alla deriva a media temperatura
        for (canale=0; canale<2;canale++){
            
            if( stato_della_misura ==0){// Consideriamo l'offset a zero
                if (canale) stato_della_misura=stato_esci_dalla_misura;
                if( (chi_aggiustiamo >> canale) & 1){
                    offset_di_lavoro[canale]= (numero_offset_per_impostazione_deriva[canale] +1 ) >>1 ; //Prendo l'offset a met\'a scala, approssimando all'intero maggiore
//                          indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
//                                              Memory_address_lookup_table_start ;         
//                          lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
                            Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];                    
                }
            }  // fine stato_della_misura=0
            
            if( stato_della_misura ==stato_compensazione_in_temperatura_sull_0ffset_secondo_passo){ //Aggiustiamo con la temperatura accordata anche sulloffset. Veniamo dallo stato 2
                if (canale) stato_della_misura=stato_esci_dalla_misura;
                        if( (chi_aggiustiamo >> canale) & 1){   
                    errore=0xff;
//                  lettura_EPROM( canale,  Memory_address_JFET_trimmer_offset ,  dati_letti);
                    for (ii=0; ii< numero_offset_per_impostazione_deriva[canale]; ii++){        
                        errore_temperatura= abs( valori_offset_per_impostazione_deriva[canale][ii] - (signed char)(Trimmer_offset_preampli[canale].coarse_offset - dati_letti[1] ) ) ;
                        if (errore_temperatura < errore){
                            errore=errore_temperatura;
                            offset_di_lavoro[canale]= ii;
                        }
                    }               
//                                      indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
//                                                          Memory_address_lookup_table_start ;         
//                                      lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
                                        Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
                        }
            } //fine stato_della_misura =stato_compensazione_in_temperatura_sull_0ffset_secondo_passo
            
            if( stato_della_misura ==stato_compensazione_in_temperatura_sull_0ffset){//Vogliamo aggiustare la temperatura sull'offset: primo passaggio , troviamo l'offset
                if (canale) stato_della_misura=stato_compensazione_in_temperatura_sull_0ffset_secondo_passo;
                        if( (chi_aggiustiamo >> canale) & 1){   
                                offset_di_lavoro[canale]= (numero_offset_per_impostazione_deriva[canale] +1 ) >>1 ; //Prendo l'offset a met\'a scala, approssimando all'intero maggiore
                    //Se stato_della_misura =2 devo valutare quale offset abbiamo , prima di impostare la temperatura. Per cui metto il trimmer a met\'a scala
                    Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;                           
                        }
            } //fine stato_della_misura =stato_compensazione_in_temperatura_sull_0ffset
            
        if( stato_della_misura ==stato_senza_compensazione_in_temperatura){//Aggiustiamo senza compensazione in temperatura
                if (canale) stato_della_misura=stato_esci_dalla_misura;
                        if( (chi_aggiustiamo >> canale) & 1){   
                    Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;                           
                        }
            } //fine stato_della_misura =stato_senza_compensazione_in_temperatura
        
        
            if( stato_della_misura ==stato_misurare_parametro_per_EPROM_secondo_passo){//Secondo passo per offset in EPROM: metto il dato eprom in trimmer e l'offset in eprom
                if (canale) stato_della_misura=stato_misurare_parametro_per_EPROM_terzo_passo; //Lo stato 4 \'ein fondo perch\'e serve solo per memorizzare l'offset nella eprom
                        if( (chi_aggiustiamo >> canale) & 1){   
                            Trimmer_offset_preampli[canale].JFET_Offset=0x80 +\
                            (( (128 - Trimmer_offset_preampli[canale].coarse_offset) * JFET_offset_conversione) >> 7) ;
                            Trimmer_offset_preampli[canale].coarse_offset=0x80;
                            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer, Trimmer_offset_preampli[canale].JFET_Offset); 
                        }
            } //fine stato_della_misura =stato_misurare_parametro_per_EPROM_secondo_passo
    
            if( stato_della_misura ==stato_misurare_parametro_per_EPROM){//Primo passo per offset in EPROM: misuro a offset 0 con ERPOM a met\'a scala
                if (canale) stato_della_misura=stato_misurare_parametro_per_EPROM_secondo_passo;
                    if( (chi_aggiustiamo >> canale) & 1){
                        Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;   
                        Trimmer_offset_preampli[canale].JFET_Offset=0x80;       
                        Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer, Trimmer_offset_preampli[canale].JFET_Offset); 
                        vettore_istruzioni[byte_istr_dati_0]=0;
                        vettore_istruzioni[byte_istr_dati_1]=0;
                        }
            } //fine stato_della_misura =stato_misurare_parametro_per_EPROM
            
//      if ( buffer_vettore_istruzioni_istruzione_byte_0 <0xff){
//          if ( (stato_della_misura ==0) || (stato_della_misura==2) ){
//              //Se stato della misura =0 vogliamo stare a met\'a con l'offset;
//              //se stato della misura =2 misuriamo a met\'a scala per la temperatura
//              offset_di_lavoro[canale]= (numero_offset_per_impostazione_deriva[canale] +1 ) >>1 ; //Prendo l'offset a met\'a scala, approssimando all'intero maggiore
//              
//              if(stato_della_misura==2){
//                  //Se stato_della_misura =2 devo valutare quale offset abbiamo , prima di impostare la temperatura. Per cui metto il trimmer a met\'a scala
//                  Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;
//              }else{
//                  //Se stato_della_misura \'e zero estraggo dalla memoria il valore da mettere nel trimmer della temperatura
////                            indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
////                                                Memory_address_lookup_table_start ;         
////                            lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
////                            Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
//              }
//              
//              if (canale) stato_della_misura--;
//          }else{//Troviamo la polarizzazione pi\'u vicina
//              
//          errore=0xff;
//          for (ii=0; ii< numero_offset_per_impostazione_deriva[canale]; ii++){        
//              errore_temperatura= abs( valori_offset_per_impostazione_deriva[canale][ii] - Trimmer_offset_preampli[canale].coarse_offset) ;
//              if (errore_temperatura < errore){
//                  errore=errore_temperatura;
//                  offset_di_lavoro[canale]= ii;
//              }
//          }               
//                              indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
//                                                  Memory_address_lookup_table_start ;         
//                              lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
//                              Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
//              if (canale) stato_della_misura = -1;
//          }
////            indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
////                                                Memory_address_lookup_table_start ;         
////            lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
////            Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
//      }else{
//          Trimmer_offset_preampli[canale].coarse_thermal=0x80;
//          if (canale) stato_della_misura = -1;
//      }
        if( (chi_aggiustiamo >> canale) & 1){
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_coarse_thermal_trimmer, Trimmer_offset_preampli[canale].coarse_thermal );
//          Trimmer_offset_preampli[canale].fine_thermal=0x80;
//          Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_thermal_trimmer, Trimmer_offset_preampli[canale].fine_thermal);           
            //Ora compensiamo l'offset per il contributo impostato dal trimmer
            Trimmer_offset_preampli[canale].coarse_offset = ((Trimmer_offset_preampli[canale].coarse_offset + Trimmer_offset_preampli[canale].coarse_thermal - 128)*coarse_Trimmer_drift_offset_ratio_by_2e7) >> 7  ;
            if( Trimmer_offset_preampli[canale].coarse_offset > 255) Trimmer_offset_preampli[canale].coarse_offset=255;
            if( Trimmer_offset_preampli[canale].coarse_offset <0) Trimmer_offset_preampli[canale].coarse_offset=0;
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);      
        }
        }
 
        
//***********************************************************************************************************       
    
    if(  ((vettore_istruzioni[istruzione_byte_1] >> offset_different_between_ch) &1)==0 ) {
        //Offset is get from the first 2 bytes of the isntruction, otherwise is already given elsewhere
        vettore_istruzioni[byte_istr_dati_2]=0;
        vettore_istruzioni[byte_istr_dati_3]=0;
        valore_target_per_offset[0] = 1000*( *(signed short *) &vettore_istruzioni[byte_istr_dati_0]);
        valore_target_per_offset[1]=valore_target_per_offset[0];
    }
    int valore_target_per_ch[]={(valore_target_per_offset[0] *(int)gain_da_moltiplicare )/ (int)PGA_Gain_V_su_V[0], (valore_target_per_offset[1] *(int)gain_da_moltiplicare)/ (int)PGA_Gain_V_su_V[1]};
    attesa= vettore_istruzioni[istruzione_byte_2]*100;
    if (attesa == 0) attesa=1000;   
    if( attesa > 10000) attesa =10000;
    
    //Set the PGA Gain to 1 and retain the actual
    char PGA_Gain_V_su_V_old[]={PGA_Gain_V_su_V[0], PGA_Gain_V_su_V[1]};  //*********************************************
    PGA_GAIN_set(3, 1);
    
    Aspetta_tanti_ms(attesa);
     
    for( canale=0;canale<2;canale++){
        if( (chi_aggiustiamo >> canale) & 1){
//  offset=lettura_ADC( nodo_di_misura_1[canale]) ; //Il <<1 \'e per renderlo differenziale
    risultato=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
    if ( (risultato >= saturazione_positiva) || (risultato <= saturazione_negativa) ){
        //Dobbiamo iniziare con SAR
        saturazione_canale[canale]=true;
                }
            }
        }
    
aggiustamento_SAR(saturazione_canale, attesa, nodo_di_misura_1); // Effettivo solo se saturazione_canale \'e true
 
//  Aspetta_tanti_ms(attesa);
//LEGGO L'USCITA Neg
    for( canale=0;canale<2;canale++){
        if( (chi_aggiustiamo >> canale) & 1){
//  offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
    offset=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
    discrepanza[canale] = offset - valore_target_per_ch[canale] ;
 
//HO L'OFFSET       
            
    Trova_valori_trimmer_per_offset_preamplificatore(discrepanza[canale], &Trimmer_offset_preampli[canale], coarse_trimmer_step[canale], fine_trimmer_step[canale]);        
    
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);                                      
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);                                     
        }
    }
    Aspetta_tanti_ms(attesa);           
    
 
// offset_Adjust_core( chi_aggiustiamo, valore_target_per_ch, nodo_di_misura_1, nodo_di_misura_2, \
//                                                                   tolleranza,  coarse_trimmer_step,  fine_trimmer_step,   attesa, misura_finale);    
 
//  Abbassa_chip_selector_multiplexer();
    
    PGA_Gain_V_su_V[0]=PGA_Gain_V_su_V_old[0];  //*********************************************
    PGA_Gain_V_su_V[1]=PGA_Gain_V_su_V_old[1];
    PGA_GAIN_set(1, PGA_Gain_V_su_V[0]);
    PGA_GAIN_set(2, PGA_Gain_V_su_V[1]);
    
        for( canale=0;canale<2;canale++){
        if( (chi_aggiustiamo >> canale) & 1){   
//          int offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
            offset=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset) * (int)guadagno_minimo_PGA / (int)PGA_Gain_V_su_V[canale] ;
            int correzione =  (  misura_finale[canale]  - offset )  / (( (fine_trimmer_step[0]+fine_trimmer_step[1])>>1) ) ; 
            Trimmer_offset_preampli[canale].fine_offset= Trimmer_offset_preampli[canale].fine_offset - correzione;
            if (Trimmer_offset_preampli[canale].fine_offset >255) Trimmer_offset_preampli[canale].fine_offset=255;
            if( Trimmer_offset_preampli[canale].fine_offset <0 ) Trimmer_offset_preampli[canale].fine_offset=0;
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);     
        }
    }   
    
    
    Aspetta_tanti_ms(attesa);
    
for(canale=0;canale<2;canale++){    
//      offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
        misura_finale[canale]=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
}
    
misura_finale[0] =(misura_finale[0] / 1000);
tx_data[byte_istr_dati_0] =  (unsigned int)(misura_finale[0]) & 0xFF ;
tx_data[byte_istr_dati_1] =  (( (unsigned int)(misura_finale[0]) ) >> 8 ) & 0xFF ;
misura_finale[1] =(misura_finale[1] / 1000);
tx_data[byte_istr_dati_2] =  (unsigned int)(misura_finale[1]) & 0xFF ;
tx_data[byte_istr_dati_3] =  (( (unsigned int)(misura_finale[1]) ) >> 8 ) & 0xFF ;
        //Set the PGA Gain to 1 and retain the actual
    //PGA gain is restablished
                    if( stato_della_misura ==stato_misurare_parametro_per_EPROM_terzo_passo){////Terzo e ultimo passo per offset in EPROM: metto offset in eprom in trimmer e l'offset in eprom
                        stato_della_misura=stato_esci_dalla_misura;
                        for(canale=0;canale<2;canale++){
                            if( (chi_aggiustiamo >> canale) & 1){   
//                              int dato_da_scrivere=   Trimmer_offset_preampli[canale].JFET_Offset + \
//                                  (Trimmer_offset_preampli[canale].coarse_offset <<8);
//                              scrivi_mem_EPROM(   Memory_address_JFET_trimmer_offset ,  dato_da_scrivere,canale);
                        }
                    }
            } //fine stato_della_misura =4
}
}

Definition at line 902 of file Istruzioni.c.