Preamplifier_Offset_Drift_Correcttion.c

Go to the documentation of this file.

#include "tutti_gli_header.h"
 
 
/*****DOCUMENTAZIONE DOXYGEN             (premi il - a sinistra per ridurla a icona) il manuale html \'e nella cartella************/
/// \file
 
/*!  \page Preamplifier_Offset_Drift_Correcttion_page  The preamplifier Offset Drift Correcttion
\brief <span style="color:red;"> <b> Preamplifier Offset Drift Correcttion </b> </span>
*\tableofcontents
 
 \b SUMMARY: 
<ul>
<li> \ref introduction_to_preamplifier_corrections </li>
<li> \ref Effects_of_trimmers_on_preamplifier </li>
<li> \ref Preamplifier_PGA_offset_setting
        <ul>
            <li> \ref SAR_procedure </li>
            <li> \ref FAST_SAR_procedure </li>
        </ul>
</li>
<li> \ref Node_measurements_with_internal_external_ADC</li>
<li> \ref sw_detail_pre </li>
</ul>
 
*\section introduction_to_preamplifier_corrections Trimmer usage with preamplifier
<hr width="90%" size="10" align="left">
 
\n The preamplifier has a quad trimmer <a href="./File_pdf/AD5263.pdf"  target=_blank><b>AD5263</b></a>.
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:
 
<ol start="0">
  <li> #trimmer_CMRR_compensation
    <li> #trimmer_fine_offset
    <li> #trimmer_thermal_compensation
    <li> #trimmer_coarse_offset
    </li>
</ol>   
\n 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:
- \b scheda_su_scheda_giu is the board where the trimmer is;
- \b canale is the preamplifier channel (0 to 5);
- \b trimmer is one of the 4 trimmers to write or to read (0 to 3 of the list above);
- \b valore is the value to write, a unsigned int8 (0 to 255);
- \b scrivi_1_leggi_0 is boolean: when true a write of \b 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] .
 
\n An example of writing of the value 158 in the trimmer for coarse offset compensation of the second channel is:
<span style="color:orange;"> <I>
\code {.c}
preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,  canale1, trimmer_coarse_offset, 158, preamplifier_scrivi_il_trimmer  );
\endcode
</I> </span>
 
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 
 
*\section Effects_of_trimmers_on_preamplifier Effects of trimmers on preamplifier
<hr width="90%" size="10" align="left">
\n The effects of the trimmers on the output or input of the preamplifier are summarized in 
\ref Table_trimmer_Effects "Table" below:
 
\n 
<center>
\anchor Table_trimmer_Effects  \b Table \b 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 &micro;V           |
#trimmer_coarse_offset          |  121,3 mV              | xxx &micro;V           |
#trimmer_thermal_compensation   |  x mV/&deg;C           | y &micro;V/&deg;C      |
</center>
 
\section Preamplifier_PGA_offset_setting Preamplifier/PGA offset setting
<hr width="90%" size="10" align="left">
 
\n 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.
\n 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.
\n 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.
\n 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 &micro;-controller asks from the CAN bus the measurement. 
This is done in a way similar to the 
<a href="_instruction_set.html#instr_ouput_offset_we_want_to_set_option">instr_output_offset_to_be_set</a>.
\n The modalities for doing an adjustment can be set with the 
<a href="_instruction_set.html#instr_readback_node_voltages_option">instr_preamplifier_scrittura_lettura_trimmer_offset</a>
\n The main function to adjust the offset is instr_Vbias_to_be_set_function():
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_instr_Vbias_to_be_set_function
 
\n 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:
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_normalize_gain_offset_error
 
\n At this point if the standard SAR procedure is chosen we go to \ref 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 
\ref 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.
 
\subsection SAR_procedure SAR_procedure
\n 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():
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_aggiusta_offset_SAR
 
\n 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.
 
\subsection FAST_SAR_procedure FAST_SAR_procedure
 
\n The Fats SAR procedure tries to reduce the numeber of SAR steps from 16 to between 4 and 6. 
\n 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. 
\n 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.
\n The Fast SAR function  preamplifier_aggiusta_offset_FastSAR() is this:
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_aggiusta_offset_FastSAR.
 
\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.
 
\section Node_measurements_with_internal_external_ADC Node measurements with internal or external ADC
<hr width="90%" size="10" align="left">
\n 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():
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_ADC_external_measured_node_function
 
\n The function invokes the reading from an external ADC from the CAN.
\n In case the internal ADC is used, the function to call is the XXXXXXXX():
 
\section sw_detail_pre Sw details
<hr width="90%" size="10" align="left">
\n Let's see the function preamplifier_scrittura_lettura_trimmer() for writing, reading the trimmer:
 *\snippetlineno Trimmer.c  fun_preamplifier_scrittura_lettura_trimmer
 
\n The identification of the trimmers is done with the structure #address_preamplifier_trimmer[6]:
\snippet Memoria_pre_M24CXX.h fun_EPROM_I2C
 
\n 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
 
\n The codes for mamnaging the trimmer are: 
 - \ref  Preamplifier_Offset_Drift_Correcttion.c
 - \ref  Preamplifier_Offset_Drift_Correcttion.h
 
*/
 
 
// CROSS INIZIO
 
volatile uint16_t preamplifier_attesa_tra_le_misure = 10;       //attesa tra le misure per aggiustamento offset
        
int32_t     preamplifier_error_voltage= 10000; //errore tollerato in microV
 
uint8_t preamplifier_canali_da_regolare= 0;         //i canali da agiustare
 
uint8_t     preamplifier_externalADC_1_onboardADC_0 ; //ADC selection for offset adjustment
//uint8_t       preamplifier_SAR_1_no_SAR_0; //SAR / no SAR in offset adjustment.
//uint8_t preamplifier_fastSAR_1_no_fastSAR_0; //fast SAR in offset adjustment
volatile int32_t        preamplifier_Output_offset_target_at_the_moment[12] ;
volatile uint8_t  termalizzazione_fatta[12];
 
 
int32_t     preamplifier_error_voltage_at_the_moment[12];
int32_t   preamplifier_error_voltage_at_PGA_gain[12];
int32_t ADC_misura_fatta_old[12]={0,0,0,0,0,0,0,0,0,0,0,0};
 
int32_t preamplifier_coarse_step_trimmer[]={preamplifier_coarse_step_trimmer_default,preamplifier_coarse_step_trimmer_default,preamplifier_coarse_step_trimmer_default, \
    preamplifier_coarse_step_trimmer_default, preamplifier_coarse_step_trimmer_default,preamplifier_coarse_step_trimmer_default, \
    preamplifier_coarse_step_trimmer_default,preamplifier_coarse_step_trimmer_default, preamplifier_coarse_step_trimmer_default,
    preamplifier_coarse_step_trimmer_default,preamplifier_coarse_step_trimmer_default,preamplifier_coarse_step_trimmer_default,};  //Value in microV
int32_t preamplifier_fine_step_trimmer[]={preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default, \
        preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default, \
        preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default, \
        preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default,preamplifier_fine_step_trimmer_default,};  //Value in microV
 
struct preamplifier_SAR_ini_type /*{
    uint8_t starting_value;
    uint8_t starting_exp_value;
}*/ preamplifier_SAR_ini[12];
 
uint8_t PGA_settled_gain_old[12]    , preamplifier_canali_da_regolare_old;
 
/*! \brief Offset target values
*\snippet Preamplifier_Offset_Drift_Correcttion.c vec_preamplifier_Output_offset_target
*/
//! <!-- [vec_preamplifier_Output_offset_target] -->
int32_t preamplifier_Output_offset_target[12]={0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0};  //in microV
//! <!-- [vec_preamplifier_Output_offset_target] -->
 
/*!  \brief The preamplifier offset will be set at the value passed from the CAN with this function if,
after this setting, it is launched instr_Vbias_to_be_set_function().
 
The first 2 bytes of the CAN bus message are the voltage setting in mV. Byte_6 is for which channel the voltage is to be set. 
The same voltage can be the same for several channels. The voltage is applied if the corresponding bit of Byte_6 is 1, ie if bit_2
is 1, than the voltage is applied to channel 1, if bit_1 and bit_5 are 1 then the same voltage is applied for both channles 1 and 5.
Run the command several times if the targety is different among the channles.
These values are stored in the vector #Detector_bias_target[12].
Only positive values are accepted and the voltage is considered the total bias voltage, namely Voltage==Vbias_pos - Vbias_neg, symmetric.
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c instr_ouput_offset_we_want_to_set_function
*/
//! <!-- [instr_ouput_offset_we_want_to_set_function] -->
void instr_ouput_offset_we_want_to_set_function(void){
uint8_t canali_ , canali_input=vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    uint8_t scheda_su_giu = (canali_input >> 7) & 1;
    uint8_t offset_scheda=0;
    if (scheda_su_giu){
        offset_scheda=6;
    }
    for( canali_=0; canali_ <6; canali_ ++){
        if( (canali_input >> canali_) & 1){
            preamplifier_Output_offset_target[offset_scheda + canali_]= ( ( *(int16_t *)vettore_istruzioni  ) *1000);
        }       
    }
    tx_data[istruzione_byte_4_e_scelta_canale]= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
}
//! <!-- [instr_ouput_offset_we_want_to_set_function] -->
 
/*!  \brief Content of the preamplifier trimmers can be read/write.
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_instr_preamplifier_scrittura_lettura_trimmer_offset_function
*/
//! <!-- [fun_instr_preamplifier_scrittura_lettura_trimmer_offset_function] -->
void instr_preamplifier_scrittura_lettura_trimmer_offset_function(void){
    uint8_t canale_, canale= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    uint8_t contenuto_trimmer= vettore_istruzioni[byte_istr_dati_0];
    uint8_t trimmer_da_scrivere= vettore_istruzioni[istruzione_byte_3];
    uint8_t scrivere_leggere= (canale >> 6) & 1;
    uint8_t scheda_su_giu= ((canale >> 7) & 1)*6;
        ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
    for ( canale_=0; canale_ <6; canale_++){
        if ( (canale >> canale_) &  1){
            preamplifier_scrittura_lettura_trimmer( scheda_su_giu,  canale_,  trimmer_da_scrivere, \
            contenuto_trimmer,  scrivere_leggere  );
            tx_data[byte_istr_dati_0]= contenuto_trimmer_preamplifier[canale_ + scheda_su_giu][trimmer_da_scrivere] ; 
            break ;
        }
    }   
    Error_imposta_la_istruzione();
}   
//! <!-- [fun_instr_preamplifier_scrittura_lettura_trimmer_offset_function] -->
 
/*!  \brief The detector bias will be set at the value set with the function instr_detector_Vbias_we_want_to_set_function()
with which the target values are stored in the vector #Detector_bias_target[].
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_instr_Vbias_to_be_set_function
*/
//! <!-- [fun_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();
}   
//! <!-- [fun_instr_Vbias_to_be_set_function] -->       
 
 
/*!  \brief The ouput offset will be set at the value that was given with the #instr_ouput_offset_we_want_to_set instruction.
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_trova_il_guess
*/
//! <!-- [fun_preamplifier_trova_il_guess] -->
void preamplifier_trova_il_guess(uint8_t trimmer_da_usare){
    #define numero_ripetizioni 3
    uint8_t canale, indice , ripetizioni, preamplifier_canali_da_regolare_locale=preamplifier_canali_da_regolare_old,trimmer_per_ini;
    uint8_t scheda_su_scheda_giu = ((vettore_istruzioni[6]>>7 &1)*6);
    uint16_t iii,media_prov; //medie=20;
    int16_t delta;
    int32_t ADC_misura_fatta_prov,ADC_misura_fatta_prov_vet[200],ADC_misura_fatta_[12], *pendenza_trimmer;
    
    if( trimmer_da_usare == trimmer_coarse_offset){
        pendenza_trimmer = preamplifier_coarse_step_trimmer;
        trimmer_per_ini = 0;
      }else if (trimmer_da_usare == trimmer_fine_offset){
        pendenza_trimmer = preamplifier_fine_step_trimmer;
            trimmer_per_ini=1;
    }
    
    if(scheda_su_scheda_giu==1) scheda_su_scheda_giu=6;
    
        //le condizioni di lavoro devono essere gi\'a impostate
        //ripetiamo qualche volta
 for(ripetizioni= 0; ripetizioni < numero_ripetizioni ;ripetizioni++){
        //prima di tutto leggere tutte le uscite
                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_canali_da_regolare_locale >> canale) & 1){//Selezionaiamo solo i canali indicati 
                        
//                      ADC_misura_fatta_[indice]= ADC_misura_differenziale_con_media_at_PGA(scheda_su_scheda_giu,  preamplifier_externalADC_1_onboardADC_0,  canale,  preamplifier_error_voltage_at_the_moment);
                        ADC_misura_fatta_[indice]=ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,preamplifier_externalADC_1_onboardADC_0,canale,1);
                    //Attenzione che le uscite non siano sature
                    }//chiusura canali da considerare
                }//chiusura Canali
            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_canali_da_regolare_locale >> canale) & 1){//Selezionaiamo solo i canali indicati 
                        if( (ADC_misura_fatta_[indice]<preamplifier_positive_saturation) &&  (ADC_misura_fatta_[indice]> preamplifier_negative_saturation)){
 
                            delta = ( preamplifier_Output_offset_target_at_the_moment[indice] - ADC_misura_fatta_[indice] ) / pendenza_trimmer[indice] ;
                            delta += (( preamplifier_Output_offset_target_at_the_moment[indice] - ADC_misura_fatta_[indice] ) % pendenza_trimmer[indice] ) / (pendenza_trimmer[indice]>>1); //mezzo bit recuperato
                            
                            if( (delta + contenuto_trimmer_preamplifier[indice][trimmer_da_usare])<0){
                                contenuto_trimmer_preamplifier[indice][trimmer_da_usare] =0;
                            }else if( (delta +contenuto_trimmer_preamplifier[indice][trimmer_da_usare]) >0xff) {
                                contenuto_trimmer_preamplifier[indice][trimmer_da_usare] =0xff;     
                            }else{
                                contenuto_trimmer_preamplifier[indice][trimmer_da_usare] += delta;
                            }   
                    //Aggiungiamoci il valore della correzione della temperatura aggiustato al valore del trimmer dell'offset
                            if (  (trimmer_da_usare ==trimmer_coarse_offset)){
                                    termalizzazione_fatta[indice]=1;
                                    preamplifier_determina_trimmer_therma_comp( scheda_su_scheda_giu, canale, contenuto_trimmer_preamplifier[indice][trimmer_da_usare],  0);
                            }
                            
                            preamplifier_scrittura_lettura_trimmer(scheda_su_scheda_giu, canale, trimmer_da_usare, contenuto_trimmer_preamplifier[indice][trimmer_da_usare],1);
                            if ( (delta<3) && (delta>-3)){// siamo giusti, con errore contenuto
                                    preamplifier_canali_da_regolare_locale -= 1<<canale ; 
//                                  preamplifier_SAR_ini[indice].starting_value = ( contenuto_trimmer_preamplifier[indice][trimmer_da_usare] ) & 0xFC;
                                }                         
                                    if (delta<0)delta=-delta;
                                    if( contenuto_trimmer_preamplifier[indice][trimmer_da_usare]  >= delta){
                                        preamplifier_SAR_ini[indice].starting_value = contenuto_trimmer_preamplifier[indice][trimmer_da_usare] -delta ;
                                    }else{
                                        preamplifier_SAR_ini[indice].starting_value=0;
                                    }
                                    if (delta<=1){
                                        preamplifier_SAR_ini[indice].starting_exp_value[ trimmer_per_ini]= 1;
                                    }else if (delta <= 3) {
                                        preamplifier_SAR_ini[indice].starting_exp_value[ trimmer_per_ini]= 2;
                                    }else if (delta <= 10){
                                        preamplifier_SAR_ini[indice].starting_exp_value[ trimmer_per_ini]= 3;
                                    }else if  (delta > 10){
                                        preamplifier_SAR_ini[indice].starting_exp_value[ trimmer_per_ini]= 5;
                                    }
 
                        }/* chiusura saturazione rispettata */ else{
                                preamplifier_canali_da_regolare_locale -= 1<<canale ; //rimane il default
                                preamplifier_SAR_ini[indice].starting_value=0;
                        }//chiusura saturazione non rispettata
                    }//chiusura canali da considerare
                }//chiusura Canali
                }//chiusura ripetiamo qualche volta
        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_canali_da_regolare_locale >> canale) & 1){
            contenuto_trimmer_preamplifier[indice][trimmer_da_usare]= preamplifier_SAR_ini[indice].starting_value;
        }
            }
}
//! <!-- [fun_preamplifier_trova_il_guess] -->
 
 
 
/*!  \brief The ouput offset will be set at the value that was given with the #instr_ouput_offset_we_want_to_set instruction.
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_aggiusta_offset
*/
//! <!-- [fun_preamplifier_normalize_gain_offset_error] -->
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; 
}
//! <!-- [fun_preamplifier_normalize_gain_offset_error] -->
 
 
 
/*!  \brief This function provide the output offset with the standard SAR method.
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_aggiusta_offset_SAR
*/
//! <!-- [fun_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 ;
                        }
                    }
                }
            }
        }   
    }
        
    }
}
//! <!-- [fun_preamplifier_aggiusta_offset_SAR] -->
 
 
 
/*!  \brief This function sets the original gain when a few LSb have to be determined. The umber of bits
is bit_to_go.
 
*\param[in]  indice_trimmer  the offset trimmer under usage
*\param[in] scalata The value 1<<(7-scalata) is the SAR test weigth
*\param[in] target_raggiunto_1_non_raggiunto_0 vector for target offset got or not got 
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_ritorno_al_gain_originale
*/
//! <!-- [fun_preamplifier_ritorno_al_gain_originale] -->
void preamplifier_ritorno_al_gain_originale(uint8_t scalata, uint8_t indice_trimmer, uint8_t * target_raggiunto_1_non_raggiunto_0){
#define bit_to_go 3
uint8_t canale, indice;
    if( scheda_su_scheda_giu >=1) scheda_su_scheda_giu=6;
    //***************Questo solo al secondo giro per impostare il secondo trimmer inizio**************************************************
        if( (indice_trimmer == 1) && ((7-scalata)==bit_to_go)  ){ 
                preamplifier_canali_da_regolare_old = preamplifier_canali_da_regolare;
            
            //Ritorno al guadagno originale per tutti i canali inizio
                for(canale=0; canale< 6; canale++){
                    indice = canale + scheda_su_scheda_giu;
                    if( (preamplifier_SAR_ini[indice].starting_exp_value[1]<2) && (PGA_settled_gain_old[indice] > 1) ){
                        //Siamo un po' pessimisti e aggiungiamo bit di test a guadagni grandi
                        preamplifier_SAR_ini[indice].starting_exp_value[1]=2;
                        contenuto_trimmer_preamplifier[indice][trimmer_fine_offset] &= 0xf8;
                        preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale, trimmer_fine_offset, \
                        contenuto_trimmer_preamplifier[indice][trimmer_fine_offset],    preamplifier_scrivi_il_trimmer  );                      
                    }
                    PGA_GAIN_CROSS( scheda_su_scheda_giu , canale , PGA_settled_gain_old[indice] );
                    if ( (PGA_settled_gain_old[indice] ==1) && (((preamplifier_canali_da_regolare >> canale)&1)==0)){
                        preamplifier_canali_da_regolare_old &= ~(1 << canale); //In this case nothing changes
                    }
                    //Recuperiamo errore e target iniziale
                    preamplifier_Output_offset_target_at_the_moment[indice] = preamplifier_Output_offset_target[indice];
                    preamplifier_error_voltage_at_the_moment[indice] = preamplifier_error_voltage_at_PGA_gain[indice];
                }
            //Ritorno al guadagno originale per tutti i fine
                preamplifier_canali_da_regolare =preamplifier_canali_da_regolare_old;
                Aspetta_tanti_ms( preamplifier_attesa_tra_le_misure );  //Measure with the new values
    }           
}
//! <!-- [fun_preamplifier_ritorno_al_gain_originale] -->
 
/*!  \brief This function provide node reading from an external ADC.
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_ADC_external_measured_node_function
*/
//! <!-- [fun_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
}
//! <!-- [fun_preamplifier_ADC_external_measured_node_function] -->
 
 
/*!  \brief This function determines and set the thermal compensation trimmer
 
\param[in] scheda_su_scheda_giu                     :    which board
\param[in] canale                                                       :    which channel
\param[in] valore_previsto_trimmer_offset   :    the possible value to set in the offset trimmer
\param[in] solo_recupero_default_comp_se_1  :    only if the offset trimmer is recovered
 
*\return   No Parameters, the preamplfier trimmer is set within the function.
 
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_determina_trimmer_therma_comp
*/
//! <!-- [fun_preamplifier_determina_trimmer_therma_comp] -->
void preamplifier_determina_trimmer_therma_comp(uint8_t scheda_su_scheda_giu,uint8_t canale,  \
                    uint8_t valore_previsto_trimmer_offset, uint8_t solo_recupero_default_comp_se_1){
    
    uint8_t dati_da_leggere_o_scrivere[]={0,0,0,0},trimmer_comp_di_default;
    int32_t differenza_trimmer_offset, variazione_trimmer_termico, pendenza_deriva_trimmer_offset,pendenza_deriva_trimmer_compensazione;
    
    if (scheda_su_scheda_giu) scheda_su_scheda_giu=6;
    
    // Verifico dalla emoria se ci sono calibrazioni
            EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                        Memory_preamplifier_drift_ON_0_OFF_ff <<2  , dati_da_leggere_o_scrivere);
        if(*(uint32_t *)dati_da_leggere_o_scrivere ==0){            
        //se ci sono calibrazioni le leggo. Si tratta di:
        //          leggere il trimmer offset di base e leggere il trimmer termico di base:
        //                  questi 2 fanno parte della stessa locazione di memoria.
        //          leggere la pendenza del trimmer offset
        //      leggere la pendenza del trimmer compensazione           
    //POssiamo valutare il nuovo valore del trimmer termico
            EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                        Memory_preamplifier_trimmers_for_drift <<2  , dati_da_leggere_o_scrivere);  
                    // A questo punto serve la differenza tra il trimmer target e quello di base, entrambi offset
                        trimmer_comp_di_default= dati_da_leggere_o_scrivere[trimmer_thermal_compensation];
        if (solo_recupero_default_comp_se_1){
            //Se vogliamo solo impostare il solo trimmer compensazione offset di default lo facciamo qui
                dati_da_leggere_o_scrivere[0] =trimmer_comp_di_default;
        }else{
            differenza_trimmer_offset = valore_previsto_trimmer_offset - dati_da_leggere_o_scrivere[trimmer_coarse_offset];
 
    // questa differenza moltipllicata per la pendenza offset e diviso per la pendenda termica 
        // con segno cambiato ci fornisce la variazione che deve subire il trimmer termico.
                EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                        Memory_preamplifier_offset_slope_trimmer_with_temp <<2  , dati_da_leggere_o_scrivere);
            pendenza_deriva_trimmer_offset =*(int32_t *)dati_da_leggere_o_scrivere;
                EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                        Memory_preamplifier_compensation_slope_trimmer_with_temp <<2  , dati_da_leggere_o_scrivere);            
            pendenza_deriva_trimmer_compensazione=-(*(int32_t *)dati_da_leggere_o_scrivere); //Segno "-" perch\'e la variazione deve essere opposta.
            variazione_trimmer_termico = (differenza_trimmer_offset * pendenza_deriva_trimmer_offset) / pendenza_deriva_trimmer_compensazione  ;
            variazione_trimmer_termico += (((differenza_trimmer_offset * pendenza_deriva_trimmer_offset) % pendenza_deriva_trimmer_compensazione )*2 )/(pendenza_deriva_trimmer_compensazione)\
                        + trimmer_comp_di_default ; //Vediamo anche il mezzo bit
        }
    // Il nuov valore del trimmer termico sar\'a il risultato precedente sommato a quello di base.
            if ( variazione_trimmer_termico >0xff){
                dati_da_leggere_o_scrivere[0] =0xff;
            }else if ( variazione_trimmer_termico <0 ){
                dati_da_leggere_o_scrivere[0] =0;
            }else{
                dati_da_leggere_o_scrivere[0] = variazione_trimmer_termico & 0xff;
            }
        }else{
            //se non ci sono ccalibrazioni imposto il trimmer termico a 128
            //Impostiamo il trimmer termico a 128
            dati_da_leggere_o_scrivere[0]=128;
        }
    
    // Questo nuovo valore viene scritto nel trimmer
        preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,  canale,  trimmer_thermal_compensation, \
                                        dati_da_leggere_o_scrivere[0], preamplifier_scrivi_il_trimmer  );
}
//! <!-- [fun_preamplifier_determina_trimmer_therma_comp] -->
 
// CROSS FINE