The preamplifier Offset Drift Correcttion

Table of Contents

• Trimmer usage with preamplifier
• Effects of trimmers on preamplifier
• Preamplifier/PGA offset setting
  • SAR_procedure
  • FAST_SAR_procedure
• Node measurements with internal or external ADC
• Sw details

Preamplifier Offset Drift Correcttion

SUMMARY:

• Trimmer usage with preamplifier
• Effects of trimmers on preamplifier
• Preamplifier/PGA offset setting
  • SAR_procedure
  • FAST_SAR_procedure
• Node measurements with internal or external ADC
• Sw details

Trimmer usage with preamplifier

---

The preamplifier has a quad trimmer AD5263. Two of the 4 trimmers are exploited to adjust the output offset voltage, coarse ancd fine. The third trimmer is for drift compensation while the last trimmer is for CMRR mitigation. The 4 trimmers are defined this way:

0. trimmer_CMRR_compensation
1. trimmer_fine_offset
2. trimmer_thermal_compensation
3. trimmer_coarse_offset

To write or read any trimmer we use only one function: preamplifier_scrittura_lettura_trimmer(uint8_t scheda_su_scheda_giu, uint8_t canale, uint8_t trimmer,uint8_t valore, uint8_t scrivi_1_leggi_0 ) where:

• scheda_su_scheda_giu is the board where the trimmer is;
• canale is the preamplifier channel (0 to 5);
• trimmer is one of the 4 trimmers to write or to read (0 to 3 of the list above);
• valore is the value to write, a unsigned int8 (0 to 255);
• scrivi_1_leggi_0 is boolean: when true a write of valore is done, if 0 a reading of the content is done. For both cases the values of the trimmers are in the global matrix contenuto_trimmer_preamplifier[6][4] .

An example of writing of the value 158 in the trimmer for coarse offset compensation of the second channel is:

preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,  canale1, trimmer_coarse_offset, 158, preamplifier_scrivi_il_trimmer  );

In the example above:

• preamplifier_scrivi_il_trimmer is defined as 1 for trimmer writing
• preamplifier_leggi_il_trimmer is defined as 0 for trimmer reading

Effects of trimmers on preamplifier

---

The effects of the trimmers on the output or input of the preamplifier are summarized in Table below:

Table 1: Effects of the trimmers on preamplifier

Trimmer	Output Change per step	Input Change per step
trimmer_CMRR_compensation	Not Applicable	Not Applicable
trimmer_fine_offset	0.985 mV	xxx µV
trimmer_coarse_offset	121,3 mV	xxx µV
trimmer_thermal_compensation	x mV/°C	y µV/°C

Preamplifier/PGA offset setting

---

Amplifer offset can be set with an accuracy of sligtly less than 16 bits via the 2 trimmers trimmer_coarse_offset and trimmer_fine_offset. Offset is implemented with 2 different modalities with the aim of speed up the process of correction and details are given below.
There are some common initial settings. We use 2 trimmers that are initialized. A few steps are adopted in order to minimize disturbances. First the PGA gains of all the channles of the board are set to 1 V/V. Then the offsets, for those channles that must be adjusted, being set at PGA gain of 1 V/V, are scaled by the gain factor. The same is done for the expected final error. This is done channel by channel. As an example if we need an output offset of 0.5 V at a PGA gain of 10, then, the PGA gain is set to 1 V/V and the offset adjusted at 0.05 V. Since some error can be introduced when the gain is returned at its value, the gain of every channel is not recovered at the end of the process, but a few bits before, 2 or 3 depending on the difference between the target value and the acyual value. This way possible errors are compensated.
The offset is adjusted in pseudo-paralalel way. Pseudo-parallel is intended for the fact the the ADC measurement is the only action that is made channel after channel, since only one ADC is present.
The ADC to perform the measurement can be that on the post-board or can be external. In the latter case every time the measurement is needed the µ-controller asks from the CAN bus the measurement. This is done in a way similar to the instr_output_offset_to_be_set.
The modalities for doing an adjustment can be set with the instr_preamplifier_scrittura_lettura_trimmer_offset
The main function to adjust the offset is instr_Vbias_to_be_set_function():

void instr_output_offset_to_be_set_function(void){
uint8_t iii,canale, indice; 
uint8_t volatile    tx_data_buffer[8],fai_fai=1;
int8_t variazione;
    LED_rosso_fondo_scala=LED_lungo;
    
        ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
        for(iii=0;iii < 8;iii++){// Potrebbe essere richiesto qualcosa sul can, 
            //bufferizziamo l'istruzione
        tx_data_buffer[iii]= tx_data[iii];
    }
 
    //La funzione va sviluppata per ora si ritrona il fw 
    //verificare le modalit\'a di misura:
        ADC_medie_per_misura = (uint8_t) vettore_istruzioni[2];
        if (ADC_medie_per_misura==0) ADC_medie_per_misura=1;
        if( ADC_medie_per_misura >200) ADC_medie_per_misura=200;
        //attesa tra le misure
        preamplifier_attesa_tra_le_misure = vettore_istruzioni[4] *100;
        if ( preamplifier_attesa_tra_le_misure <100) preamplifier_attesa_tra_le_misure=100;
        if (preamplifier_attesa_tra_le_misure > 10000) preamplifier_attesa_tra_le_misure=10000;
        //errore tollerato
        preamplifier_error_voltage= vettore_istruzioni[5] *1000;
        //i canali da agiustare
        preamplifier_canali_da_regolare= vettore_istruzioni[6] & 0x7F;
        preamplifier_canali_da_regolare_old=preamplifier_canali_da_regolare;
        scheda_su_scheda_giu = ((vettore_istruzioni[6] >> 7) & 1)*6;
        //l'adc da usare, interno o esterno
        preamplifier_externalADC_1_onboardADC_0 = vettore_istruzioni[3] & 1;
//      preamplifier_SAR_1_no_SAR_0 = ( vettore_istruzioni[3] >> 1 ) & 1;
//      preamplifier_fastSAR_1_no_fastSAR_0 = ( vettore_istruzioni[3] >> 2 ) & 1;
    
    if ( vettore_istruzioni[3] & detector_bit_store_state_in_user_as_it_is ){
        vettore_istruzioni[3] =0;  //Non si fa altro
        fai_fai=0;
        EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu, vettore_istruzioni[6],0,0);
    }
    
    if ( vettore_istruzioni[3] & detector_bit_recall_startup){
        //Offset recalled from startup
        EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu,preamplifier_canali_da_regolare,1,1);
        fai_fai=0;
    }
        if ( vettore_istruzioni[3] & detector_bit_recall_user_defined){
        //Offset recalled from user location
        EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu,preamplifier_canali_da_regolare,1,0);      
        fai_fai=0;
        }
        
        //Leggiamo le pendenze
        uint8_t dati_scambio[4] , scheda=scheda_su_scheda_giu;
    for( canale=0;canale<6;canale++){   
//          if(canale==6) scheda =1;
            EPROM_lettura_M24C32_64(scheda, I2C_mainboard, canale, Memory_preamplifier_slope_calibration_ON_0_OFF_ff <<2,dati_scambio);
            if(dati_scambio[0] ==0){//solo se la misura \'e stata fatta si aggiornano le pendenze, altrimenti vale il fedault
                    EPROM_lettura_M24C32_64(scheda, I2C_mainboard, canale, Memory_preamplifier_address_coarse_trimmer_slope_offset <<2,dati_scambio);
                    preamplifier_coarse_step_trimmer[canale+scheda]=*(int32_t *)dati_scambio;
                    EPROM_lettura_M24C32_64(scheda, I2C_mainboard, canale, Memory_preamplifier_address_fine_trimmer_slope_offset <<2,dati_scambio);
                    preamplifier_fine_step_trimmer[canale+scheda]=  *(int32_t *)dati_scambio;
            }
            preamplifier_error_voltage_at_the_moment[canale+scheda]= preamplifier_coarse_step_trimmer[canale+scheda] >>1;  //mezzo bit di errore sul coarse all'inizio
    }
 
    if(fai_fai){
//Initialization for default SAR
        if ( vettore_istruzioni[3] & detector_offset_from_half_scale){
                for( canale=0;canale<12;canale++){  
                    preamplifier_SAR_ini[canale].starting_value =128;
                    preamplifier_SAR_ini[canale].starting_exp_value[0]=7;
                    preamplifier_SAR_ini[canale].starting_exp_value[1]=7;
                }
        }
            for( canale=0;canale<6;canale++){ //a met\'a scala i trimmer fine che ci interssano
                if((preamplifier_canali_da_regolare >> canale) & 1){
                    preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale,\
                        trimmer_fine_offset, 128,   preamplifier_scrivi_il_trimmer  );//Trimmer fine inizializzato met\'a scala
                }   
            }
            
//Ora impostiamo ad 1 tutti i guadagni, normalizziamo gli errori ed i target            
preamplifier_normalize_gain_offset_error(scheda_su_scheda_giu)  ;   
            
//FINE: Initialization for default SAR, changes are applied in fastSAR, eventually
            
            for( canale=0;canale<6;canale++){ //impostiamo la compensazione termica di default, se \'e stata fatta.
                if((preamplifier_canali_da_regolare >> canale) & 1){            
                     preamplifier_determina_trimmer_therma_comp( scheda_su_scheda_giu, canale, 0,  1);
                    termalizzazione_fatta[canale + scheda_su_scheda_giu]=0;
                }
            }
            
            
   preamplifier_trova_il_guess(trimmer_coarse_offset);      
     preamplifier_aggiusta_offset_SAR();
            
    //Ora aggiustiamo il controllo termico per quei canali che inizialmente erano saturi
    uint8_t     ri_misuriamo=0;preamplifier_canali_da_regolare_old=preamplifier_canali_da_regolare;
        for( canale=0;canale<6;canale++){ //impostiamo la compensazione termica di default, se \'e stata fatta.
                if((preamplifier_canali_da_regolare_old >> canale) & 1){
                        if (termalizzazione_fatta[canale + scheda_su_scheda_giu]==0){
                            preamplifier_canali_da_regolare=1 <<canale;
                            ri_misuriamo=1;
                        }
                }
            }
        //Se c'erano canali inizalmente saturi riaggiustiamo
            if(ri_misuriamo){
                    preamplifier_trova_il_guess(trimmer_coarse_offset);     
                    preamplifier_aggiusta_offset_SAR();     
            }
 
        
//Ora vediamo qualche setting       
        if(vettore_istruzioni[3] & detector_bit_per_storing_startup){
            //Offset to be stored at memory location for sturtup
            EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu,vettore_istruzioni[6],0,1);            
        }
        if(vettore_istruzioni[3] & detector_bit_per_storing_user_state){
            //Offset to be stored at user memory location for sturtup
            EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu, vettore_istruzioni[6],0,0);
        }
    }
        for(iii=0;iii < 8 ;iii++){
        tx_data[iii]= tx_data_buffer[iii];
    }
        tx_data[6] = preamplifier_canali_da_regolare; //i canali non in tolleranza hanno un 1 in corrispondenza 
    int32_t somma=0;
    for( iii=0;iii<6;iii++){
        somma += preamplifier_error_voltage_at_PGA_gain[iii+scheda_su_scheda_giu];
    }
    somma = somma / 6000;
    if( somma >255) somma=255;
        tx_data[5] = somma;
    Error_imposta_la_istruzione();
}   

From it, after setting some variables, we go to preamplifier_normalize_gain_offset_error(), where the gain of all the channels are set to 1 V/V, the target offsets and the final target errors are normalized to 1 V/V, too:

static void preamplifier_normalize_gain_offset_error(uint8_t scheda_su_scheda_giu_){
    //First of all we set the PGA gain to minimum
    //Then the offset is normalized to PGA at unity gain
//  uint8_t limitatore;
    int32_t max_error=0;
    uint8_t canale=0, indice;
    if(scheda_su_scheda_giu_>=1) scheda_su_scheda_giu_=6;
//  int16_t pre_variazione;
//  int32_t variazione ;
//  int32_t variazione_1;
    preamplifier_canali_da_regolare_old = preamplifier_canali_da_regolare;
    //The PGA gain of all channells of the board are set to 1 V/V
    for(canale=0; canale< 6; canale++){
        indice= canale + scheda_su_scheda_giu_;
        PGA_settled_gain_old[indice]= PGA_settled_gain[indice];
        preamplifier_Output_offset_target_at_the_moment[indice] =  preamplifier_Output_offset_target[indice] / PGA_settled_gain[indice];
        if ( preamplifier_error_voltage < ((PGA_settled_gain[indice] * preamplifier_fine_step_trimmer[indice] *3 )/2) ){
            //risoluzione minima di 1.5 bit LSb (*3/2)
            preamplifier_error_voltage_at_PGA_gain[indice] =(3 * PGA_settled_gain[indice] * preamplifier_fine_step_trimmer[indice] )/2;
        }else{
            preamplifier_error_voltage_at_PGA_gain[indice] = preamplifier_error_voltage;
        }
        if( preamplifier_error_voltage_at_PGA_gain[indice] > max_error) max_error = preamplifier_error_voltage_at_PGA_gain[indice];
//      preamplifier_error_voltage_at_the_moment[indice]= (preamplifier_error_voltage_at_PGA_gain[indice])  / PGA_settled_gain[indice];
        
        PGA_GAIN_CROSS( scheda_su_scheda_giu_ , canale , guadagno_minimo_PGA );
    }
    vettore_istruzioni[5] = max_error / 1000; 
}

At this point if the standard SAR procedure is chosen we go to SAR_procedure, while if the Fast SAR procedure is adopted, a first measurement of the outputs is done from which a guess for the coarse trimmers is determined. Then, we go to FAST_SAR_procedure.

Note

Both SAR and Fast SAR procedures work rigtly if the calibration of the steps effects determined by the fine and coarse trimmers are known and stored in the preamplifier EPROM. This must be done during preampleifers initial test and the 2 instructions XXXXXXX and YYYYYY are dedicated to this.

SAR_procedure

SAR is implemented in standard way and both fine and coarse trimmers are initialized to 0. The function called by instr_Vbias_to_be_set_function() is preamplifier_aggiusta_offset_SAR():

void preamplifier_aggiusta_offset_SAR(void){
    uint8_t canale;
    uint8_t indice;
    uint8_t i_2_trimmer[]={trimmer_coarse_offset , trimmer_fine_offset}, indice_trimmer,scalata,confronto;
    uint8_t target_raggiunto_1_non_raggiunto_0[]={0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0};  // si misura fino a che non diventa 1
    int32_t ADC_misura_fatta_prov,ADC_misura_fatta_prov_vet[200];
    uint16_t iii, media_prov; //medie=10;
    
    if( scheda_su_scheda_giu>=1) scheda_su_scheda_giu=6;
 
//Inizializzazione dei trimmer che servono alla regolazione
//for(canale=0; canale<6;canale++){ 
//  if( (preamplifier_canali_da_regolare >> canale) & 1){
//          preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale, trimmer_coarse_offset, \
//                  preamplifier_SAR_ini[canale + scheda_su_scheda_giu].starting_value, preamplifier_scrivi_il_trimmer  );//Trimmer inizializzato a zero
//          preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale, trimmer_fine_offset, 128,   preamplifier_scrivi_il_trimmer  );//Trimmer inizializzato a zero
//  }
//}
//FINE Inizializzazione dei trimmer che servono alla regolazione
 
// Esploriamo i 2 trimmer, a partie dal+ significativo, cio\'e il SAR veroe e proprio   
    preamplifier_canali_da_regolare_old= preamplifier_canali_da_regolare;
    for(indice_trimmer=0; indice_trimmer<2;indice_trimmer++){//Facciamo 2 giri, uno per ogni trimmer
 
        if( indice_trimmer) {
            preamplifier_canali_da_regolare = preamplifier_canali_da_regolare_old;
            for(canale=0; canale<6;canale++){
                indice= canale + scheda_su_scheda_giu;
                preamplifier_error_voltage_at_the_moment[indice]= preamplifier_error_voltage_at_PGA_gain[indice] / PGA_settled_gain_old[indice];  //Ripristiniamo l'errore
                target_raggiunto_1_non_raggiunto_0[indice]=0;
        }
           preamplifier_trova_il_guess( i_2_trimmer[indice_trimmer]);
    }
 
        for(scalata=0; scalata<8; scalata++){
            //SAR a guadagno 1 fino agli ultimi bit, per non creare sconquasso
            preamplifier_ritorno_al_gain_originale(scalata , indice_trimmer,  target_raggiunto_1_non_raggiunto_0);
 
                confronto= 1 << (7-scalata); //Impostiamo il valore di prova da aggiungere al trimmer
                        for(canale=0; canale<6;canale++){ // Scansoniamo tutti i possibili canali sulla scheda selezionata
                            indice= canale + scheda_su_scheda_giu; //Solito 2 schede possibili, la prima schede ha indirizzi da 0 a 5, la seconda da 6 a 11         
                                if( (preamplifier_SAR_ini[indice].starting_exp_value[indice_trimmer] >= (7-scalata))){ //Job starts just with the minimal cheks, always for the lower 8 bits
                                    if( (preamplifier_canali_da_regolare >> canale) & 1){//Selezionaiamo solo i canali indicati
                                    contenuto_trimmer_preamplifier[indice][i_2_trimmer[indice_trimmer]] += confronto;
                                    preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale, i_2_trimmer[indice_trimmer], \
                                    contenuto_trimmer_preamplifier[indice][i_2_trimmer[indice_trimmer]],    preamplifier_scrivi_il_trimmer  );                              
                                    }
                            }
                        }
            Aspetta_tanti_ms( preamplifier_attesa_tra_le_misure );      
                        
                for(canale=0; canale<6;canale++){ // Scansoniamo tutti i possibili canali sulla scheda selezionata
                    indice= canale + scheda_su_scheda_giu; //Solito 2 schede possibili, la prima schede ha indirizzi da 0 a 5, la seconda da 6 a 11     
                    if( (preamplifier_SAR_ini[indice].starting_exp_value[indice_trimmer] >= (7-scalata)) ){     //Job is done just with the minimal cheks
                    if( (preamplifier_canali_da_regolare >> canale) & 1){//Selezionaiamo solo i canali indicati 
                        if( target_raggiunto_1_non_raggiunto_0[indice]==0){//Se non abbiamo ancora raggiunto la tolleranza continuamo, per i canali fuori target
                            ADC_misura_fatta =ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,preamplifier_externalADC_1_onboardADC_0,canale,1);
                            
                            if( ( ADC_misura_fatta - preamplifier_Output_offset_target_at_the_moment[indice] ) <    \
                                ( - preamplifier_error_voltage_at_the_moment[indice]) ){
                                    //siamo fuori tolleranza
                                target_raggiunto_1_non_raggiunto_0[indice]=0;
                                ADC_misura_fatta_old[indice]= ADC_misura_fatta; //
                                }else if ( ( ADC_misura_fatta - preamplifier_Output_offset_target_at_the_moment[indice] ) < \
                                (0 ) ){
                                  //Siamo in tolleranza e dobbiamo fermarci
                                    target_raggiunto_1_non_raggiunto_0[indice]=1;
                                    preamplifier_canali_da_regolare -= 1 << canale ;
                                    ADC_misura_fatta_old[indice]= ADC_misura_fatta; //
                            }else if ( ( ADC_misura_fatta - preamplifier_Output_offset_target_at_the_moment[indice] ) >\
                                ( preamplifier_error_voltage_at_the_moment[indice])){
                                    //siamo fuori tolleranza
                                target_raggiunto_1_non_raggiunto_0[indice]=0;
                                    
                                contenuto_trimmer_preamplifier[indice][ i_2_trimmer[indice_trimmer]] -= confronto;
                            preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale, i_2_trimmer[indice_trimmer], \
                                    contenuto_trimmer_preamplifier[indice][i_2_trimmer[indice_trimmer]],    preamplifier_scrivi_il_trimmer  );
                            }else if ( ( ADC_misura_fatta - preamplifier_Output_offset_target_at_the_moment[indice] ) >\
                                (0 ) ){
                                    //siamo in tolleranza
                                    target_raggiunto_1_non_raggiunto_0[indice]=1;
                                    ADC_misura_fatta_old[indice]= ADC_misura_fatta; //
                                    preamplifier_canali_da_regolare -= 1 << canale ;
                        }
                    }
                }
            }
        }   
    }
        
    }
}

Note that the function preamplifier_ritorno_al_gain_originale() is called to verify if it is the time to come back to the original gain. Normally this is done when 2 or 3 bits of the fine trimmer are those remaining to test and set, for compensanting any possible small error introducd by the gain change.

FAST_SAR_procedure

The Fats SAR procedure tries to reduce the numeber of SAR steps from 16 to between 4 and 6.
When the gains are set to 1 V/V the PGA output voltages are read and a tentative calculation of the 8 MSB for target offset is done (in instr_Vbias_to_be_set_function()). Then, depending on how far is the new measured offset from the target, the 2 or 3 LSb of the MSB, or coarse trimmer, are set to 0 and the SAR is applied from here to the end of the MSB. At this point, the final adjustment part is left to the LSB, or fine trimmer, that was set to 0.
The first step with the setting of the LSB is to recover to the original value the gains. Then, the target values for the LSB are calculated from the measured offset and, depending on how far the new offset is from the final value, the 2 or 3 LSb are set to 0 and the SAR is applied to them.
The Fast SAR function preamplifier_aggiusta_offset_FastSAR() is this:

Note

If, when the gain is set to 1 V/V, the output voltage of any channel is found outside the saturation levels (high and low), the procedure is set to standard SAR, for those channels.

Node measurements with internal or external ADC

---

Node reading can be made with the internal or external ADC. In case an external ADC is chosen, the function called is the preamplifier_ADC_external_measured_node_function():

int32_t preamplifier_ADC_external_measured_node_function(uint8_t scheda_su_scheda_giu,  uint8_t indice){
    //richiedere sul CAN la misura
    //In questo caso scheda su o gi\'u non ha importanza perch\'e l'ADC esterno sar\'a connesso direttamente ad una sola scheda
    uint8_t ii=0;
    int32_t valore_mis;
    evento_CAN=10;
    uint8_t buffer_istruzione[8],iii;
    for(iii=0;iii<8;iii++){
        buffer_istruzione[iii]=tx_data[iii];
    }
        if ( (indice >= node_voltage_Analog_Mux_0_offset ) ){
        //Misura su uno dei 2 nodi dei mux
        Analog_mux_line_to_select_deselect(scheda_su_scheda_giu, indice , 1);
    }
    tx_data[5]=  indice; //The node to be measured, the code includes also the selected board
    tx_data[6]= 1; //This must be "1" and says that the node voltage read must be returned here
    tx_data[7]=  instr_readback_node_voltages ;  //instr code
    tx_msg_info.id = ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda);
    CANdrv->MessageSend(tx_obj_idx, &tx_msg_info, tx_data, 8U);//msg to CAN back to the control room
    Aspetta_tanti_ms(100); //From here we wait the answer or generate an error
    //Aspettare che la misura sia fatta, o generare errore
    //! [CAN error marker] 
    //Before here a CAN message has been sent with success, we hope
    while(   (ii <50) && ( evento_CAN  != ARM_CAN_EVENT_RECEIVE ) ){
        Aspetta_tanti_ms(200);
        ii++;
    }   
    if(ii>=50)      ERROR_codifica_errore(  0, error_address_CAN, CAN_error_comunichiamo_qualche_dato_timeout_on_transmission,1);
    //! [CAN error marker]
    if( (indice >= node_voltage_Analog_Mux_0_offset ) ){
        //Reset di uno dei 2 mux usati per la misura
        Analog_mux_line_to_select_deselect(scheda_su_scheda_giu, indice , 0);
    }   
    
     valore_mis= ( ( ( *(int32_t *)rx_data  ) & 0xFFFFFFFF ) ) ;
        //Convertiamo in funzione del nodo dal leggere
     valore_mis = (valore_mis * ADC_coefficiente[indice / ADC_molteplicita_node_to_read].numeratore )\
                        / ADC_coefficiente[indice / ADC_molteplicita_node_to_read].denominatore ;
        for(iii=0;iii<8;iii++){
        tx_data[iii]=buffer_istruzione[iii];
    }
    return valore_mis; //The value returned is the voltage in microV
}

The function invokes the reading from an external ADC from the CAN.
In case the internal ADC is used, the function to call is the XXXXXXXX():

Sw details

---

Let's see the function preamplifier_scrittura_lettura_trimmer() for writing, reading the trimmer:

void preamplifier_scrittura_lettura_trimmer(uint8_t scheda_su_scheda_giu, uint8_t canale, uint8_t trimmer, \
                                        uint8_t valore, uint8_t scrivi_1_leggi_0  ){
                                            
        if( scheda_su_scheda_giu >=1) scheda_su_scheda_giu=6;
    
        uint8_t spedizione[2]={ ( (trimmer << 5) & maschera_solo_bit_di_scrittura_trimmer), valore};  //The trimmer and what to write
        
        I2C_mux_select_ch(  scheda_su_scheda_giu,  I2C_mainboard, address_preamplifier_trimmer[canale].quale_I2C);  //Select the I2C to be used
        
        if (scrivi_1_leggi_0){
        
            I2C_mux->MasterTransmit( (uint8_t) address_preamplifier_trimmer[canale].indirizzo_I2C , spedizione, 2,false); //Write to the selected trimmer of the selcted channel
            
        }else{
            
            I2C_mux->MasterTransmit( (uint8_t) address_preamplifier_trimmer[canale].indirizzo_I2C , spedizione, 1,false); //set the channel to read only
        }
        
        while( I2C_mux->GetStatus().busy){};  // Write transmission complete
        
            I2C_mux->MasterReceive( address_preamplifier_trimmer[canale].indirizzo_I2C, &tappo, 1,false);  //Read back, the trimmer value
        
        while( I2C_mux->GetStatus().busy){};
        if(Error_bad_operation) ERROR_codifica_errore( scheda_su_scheda_giu, error_address_I2C1_B  , I2C_error_termometro_0  +canale,1);
        
                contenuto_trimmer_preamplifier[canale + scheda_su_scheda_giu][trimmer]  = tappo;
}   

The identification of the trimmers is done with the structure address_preamplifier_trimmer[6]:

//struct address_detector_bias_trimmer_type {
//  uint8_t quale_I2C;  
//  uint8_t indirizzo_I2C;
//};

The I2C addresses are 2 less than those of the detector trimmer (remember that to communicate with the 6 trimmers we use 3 different I2C):

• I2C_address_ch_dispari -2
• I2C_address_ch_pari -2

The codes for mamnaging the trimmer are:

• Preamplifier_Offset_Drift_Correcttion.c
• Preamplifier_Offset_Drift_Correcttion.h