Trimmer.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 Trimmer_page Trimmer
\brief <span style="color:red;"> <b> Trimmer managing </b> </span>
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref introduction_to_trimmer
*\arg \ref a_bit_inside
*\arg \ref Preamplifier_Slope_measure
*\arg \ref Conclusion
 
 
*\section introduction_to_trimmer Trimmer usage
<hr width="90%" size="10" align="left">
 
\n Trimmers are used for setting the detector bias, the preamplifier offset and the preamplifier thermal drift 
and the gain of the trimmer based PGA. The trimmer used is the 
<a href="./File_pdf/AD5263.pdf"  target=_blank><b>AD5263 datasheet</b></a>, a quad trimmer whose schematic diagram is in figure \ref Figure_Trimmer_AD5263_trimmer.
To manage the stuffs we have 3 main functions, quite similar: 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  ),
 detector_scrittura_lettura_trimmer_bias(uint8_t scheda_su_scheda_giu, uint8_t canale, uint8_t trimmer, uint8_t valore, uint8_t scrivi_1_leggi_0)
 and trimmer_based_PGA(). 
We have a sort of tree: it needs to identify the board, the channel, the trimmer and the value to write, if we need to write, otherwise we read the content; reading writing is established 
with the boolean \b scrivi_1_leggi_0. 
\n For detector and preamplifier the 4 trimmers of the chip have different functions. For what concern the preamplifier we have that 
(the bullet number is the addresss inside the chip):
 
<ol start="0">
  <li> #trimmer_CMRR_compensation;
    <li> #trimmer_fine_offset;
  <li> #trimmer_thermal_compensation;
    <li> #trimmer_coarse_offset.
    </li>
</ol>
 
Whereas for detector trimmer:
 
<ol start="0">
  <li> #Detector_trimmer_coarse_bias_pos
    <li> #Detector_trimmer_coarse_bias_neg
    <li> #Detector_trimmer_fine_bias_pos
    <li> #Detector_trimmer_fine_bias_neg
    </li>
</ol>
 
\n The content of every trimmer is stored in matrixes: #contenuto_trimmer_detector, 
#contenuto_trimmer_preamplifier and #contenuto_trimmer_PGA_a_trimmer. 
They are listed here with their default values:
 
*\snippet Trimmer.c matrix_contenuto_trimmer_detector
 
*\snippet Trimmer.c matrix_contenuto_trimmer_preamplifier
 
For the caseof the trimmer based PGA the number of trimmers used for the 12 channles is 6, one every 2 channels:
 
*\snippet Trimmer.c matrix_contenuto_trimmer_PGA_a_trimmer
 
*\anchor Figure_Trimmer_AD5263_trimmer
*\image html Trimmer_AD5263.png "FigureTrimmer_AD5263: simplified" width=30%
*\image latex Trimmer_AD5263.png "FigureTrimmer_AD5263: simplified" width=30%
 
\n Although not necessary for its direct usage, let's give a bit of further details. Every trimmer chip is selectd by mean of a constant struct with which it is possible to select
both the I2C and its I2C address:
 
*\snippet Trimmer.h fun_address_detector_bias_trimmer_type
 
First of all the I2C, the I2C mux and which of the 4 I2C mux output channels must be selcted with 
I2C_mux_select_ch( uint8_t scheda_su_scheda_giu, uint8_t mainboard_postmainboard , uint8_t  canale_da_abilitare)
 
*\section a_bit_inside A few details about the functions 
<hr width="90%" size="10" align="left">
 
\n We have the 2 constant structures for trimmer selection #address_detector_bias_trimmer and #address_preamplifier_trimmer. 
The structures are used within the functions 
preamplifier_scrittura_lettura_trimmer() and detector_scrittura_lettura_trimmer_bias(). Here an example:
*\snippet Trimmer.c fun_detector_scrittura_lettura_trimmer_bias
 
\anchor pre_trim_slope
*\section Preamplifier_Slope_measure Preamplifier Slope measurement
<hr width="90%" size="10" align="left">
 
\n Offset regulation of preamplifier is based on 2 trimmers, a coarse and fine trimmer. The adjustment can be done
by SAR tecnique or by setting the propoer value of the trimmers, if it is known their effects. The in-between 
solution is to set the value of the trimmers at a guess value, then use the SAR for a few bits.
The function is quite long and reported here instr_offset_trimmer_calibration_function().
 
 
\n Once that the slope has been measured it is stored in the preamplifier EPROM. The 2 slopes are stored at 2 
locations preceded by a location that says if the slopes have been characterized (the complete list is 
at \ref preamplifier_memory_location_list "Preamplifier EPROM location list"):
 
<ol start="1">
    <li> #Memory_preamplifier_slope_calibration_ON_0_OFF_ff;
  <li> #Memory_preamplifier_address_fine_trimmer_slope_offset;
    <li> #Memory_preamplifier_address_coarse_trimmer_slope_offset;
  </li>
</ol>
 
 
\n Namely if #Memory_preamplifier_slope_calibration_ON_0_OFF_ff is 0xFF, the initial default, the following 2 locations are not usable 
because not set. If #Memory_preamplifier_slope_calibration_ON_0_OFF_ff is 0, then the 2 following location have been 
characterized and are usable. In this latter case the slopes stored could be either the actual value measured or 
the nominal value if, during characterizatin, the measured values resulted outside &plusmn;  20\% of tolerance 
with respect to the nominla value.
 
*\section Conclusion Conclusion
<hr width="90%" size="10" align="left">
 
\n Refer to \ref Detector_Bias "Detector Bias" and \ref Preamplifier_Offset_Drift_Correcttion_page "Preamplifier Offset Drift Correcttion" for trimmer usage.
 
 The code for mamnaging the trimmers is at: 
 - \ref  Trimmer.c
 - \ref  Trimmer.h
*/
 
//static ARM_DRIVER_I2C * I2CBdrv ;                         // Viene inizializzata in I2C_B
 
//INIZIO CROSS
const struct address_detector_bias_trimmer_type /*{
//  uint8_t quale_I2C;  
//  uint8_t indirizzo_I2C
}*/ address_detector_bias_trimmer[6]={I2C_mux_abilita_0, I2C_address_ch_dispari, 
                                                                            I2C_mux_abilita_0, I2C_address_ch_pari, 
                                                                            I2C_mux_abilita_1,I2C_address_ch_dispari ,
                                                                            I2C_mux_abilita_1,I2C_address_ch_pari,   
                                                                            I2C_mux_abilita_2, I2C_address_ch_dispari,
                                                                            I2C_mux_abilita_2,I2C_address_ch_pari}; ///< Detector trimmer addresses
 
const struct address_detector_bias_trimmer_type /*{
//  uint8_t quale_I2C;  
//  uint8_t indirizzo_I2C   
}*/ address_preamplifier_trimmer[6]={I2C_mux_abilita_0, I2C_address_ch_dispari-2, 
                                                                        I2C_mux_abilita_0, I2C_address_ch_pari-2, 
                                                                        I2C_mux_abilita_1,I2C_address_ch_dispari-2,
                                                                        I2C_mux_abilita_1, I2C_address_ch_pari-2,   /*I2C_address_ch_pari-2*/
                                                                        I2C_mux_abilita_2, I2C_address_ch_dispari-2, 
                                                                        I2C_mux_abilita_2,I2C_address_ch_pari-2};       ///< Preamplifier trimmer addresses 
 
const struct address_detector_bias_trimmer_type /*{
//  uint8_t quale_I2C;  
//  uint8_t indirizzo_I2C   
}*/ address_PGA_a_trimmer[6]={I2C_mux_abilita_0, I2C_addres_trimmer_PGA, 
                                                            I2C_mux_abilita_0, I2C_addres_trimmer_PGA, 
                                                            I2C_mux_abilita_1,I2C_addres_trimmer_PGA,
                                                            I2C_mux_abilita_1, I2C_addres_trimmer_PGA,   /*I2C_address_ch_pari-2*/
                                                            I2C_mux_abilita_2, I2C_addres_trimmer_PGA, 
                                                            I2C_mux_abilita_2,I2C_addres_trimmer_PGA};      ///< Preamplifier trimmer addresses                                                                         
 
//! \brief Content of the trimmer for detector bias system
/*
*\snippet{lineno} Trimmer.c matrix_contenuto_trimmer_detector
 */
 //! <!-- [matrix_contenuto_trimmer_detector] -->
uint8_t   contenuto_trimmer_detector[12][4]={ 128, 128, 128, 128, //!< Scheda gi\'u 
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,  ///< Scheda su
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128};///< Detetctor bias trimmer content. Default value is half scale
//! <!-- [matrix_contenuto_trimmer_detector] -->
                                                                                        
/*
*\snippet{lineno} Trimmer.c matrix_contenuto_trimmer_preamplifier
 */
 //! <!-- [matrix_contenuto_trimmer_preamplifier] -->                                                                                       
uint8_t volatile contenuto_trimmer_preamplifier[12][4]={ 128, 128, 128, 128, //Scheda gi\'u
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128, 
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,  //Scheda su
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128,
                                                                                        128, 128, 128, 128}; ///< Preamplifier trimmers contents
 //! <!-- [matrix_contenuto_trimmer_preamplifier] -->
                                                                                        
                                                                                        
//!< Trimmer are in default set at almost 1 gain
//uint8_t volatile contenuto_trimmer_PGA_a_trimmer[6][4]={ 128, 128, 128, 128, //Scheda gi\'u
//                                                                                      128, 128, 128, 128, 
//                                                                                      128, 128, 128, 128, 
//                                                                                      128, 128, 128, 128, //Scheda su
//                                                                                      128, 128, 128, 128,
//                                                                                      128, 128, 128, 128}; ///< PGA  a trimmer trimmers contents                                                                                          
                                                                                        
/*
*\snippet{lineno} Trimmer.c matrix_contenuto_trimmer_PGA_a_trimmer
 */
 //! <!-- [matrix_contenuto_trimmer_PGA_a_trimmer] -->                                                                                      
uint8_t volatile contenuto_trimmer_PGA_a_trimmer[6][4]={ 245, 245, 245, 245, //Scheda gi\'u
                                                                                        245, 245, 245, 245, 
                                                                                        245, 245, 245, 245, 
                                                                                        245, 245, 245, 245, //Scheda su
                                                                                        245, 245, 245, 245, 
                                                                                        245, 245, 245, 245}; ///< PGA  a trimmer trimmers contents      
 //! <!-- [matrix_contenuto_trimmer_PGA_a_trimmer] -->
                                                                                        
                                                                                        
//!< State od attenuators at the PGA trimmer based inputs
//!< A vlaue o 3 means attenuator ON, a value of 0 means attenuator OFF
uint8_t volatile attenuatori_PGA_a_trimmer[12]={ 3,3,3,3, //Scheda gi\'u
                                                                                        3,3,3,3, 
                                                                                        3,3,3,3}; ///< PGA  a trimmer trimmers contents
//uint8_t volatile attenuatori_PGA_a_trimmer[12]={ 0,0,0,0, //Scheda gi\'u
//                                                                                      0,0,0,0, 
//                                                                                      0,0,0,0}; ///< PGA  a trimmer trimmers contents
 
 
 /*! \brief Setting the value of any trimmer for detector biasing, the contents of the trimmers are stored 
                                                                                        in the matrix #contenuto_trimmer_detector[canale][trimmer]  
 
 *\param[in] scheda_su_scheda_giu one of the 2 boards that the postfrontend manages
 *\param[in] canale the channel for which we need to manage the trimmer
 *\param[in] trimmer the trimmer to select in  the chip, from 0 to 3            
 *\param[in] valore     the value to be written to.         
 *\param[in] scrivi_1_leggi_0    if 1 we write and read, if 0 we read only and the contenis in the global contenuto_trimmer_detector[canale][trimmer]                                                               
 *\return No Parameters
 
 *\snippet{lineno} Trimmer.c fun_detector_scrittura_lettura_trimmer_bias
 */
 //! <!-- [fun_detector_scrittura_lettura_trimmer_bias] -->
void detector_scrittura_lettura_trimmer_bias(uint8_t scheda_su_scheda_giu, uint8_t canale, uint8_t trimmer, uint8_t valore, uint8_t scrivi_1_leggi_0  ){
    
    //Attenzione: canale deve essere < 6
    
        uint8_t spedizione[2]={ ( (trimmer << 5) & maschera_solo_bit_di_scrittura_trimmer), valore};  //The trimmer and what to write
        
        if( scheda_su_scheda_giu) scheda_su_scheda_giu =6;
 
        
        I2C_mux_select_ch(  scheda_su_scheda_giu,  I2C_mainboard, address_detector_bias_trimmer[canale].quale_I2C);  //Select the I2C to be used
        
        if (scrivi_1_leggi_0){
        
        I2C_mux->MasterTransmit( (uint8_t) address_detector_bias_trimmer[canale].indirizzo_I2C , spedizione, 2,false); //Write to the selected trimmer of the selcted channel
            
        }else{
            
            I2C_mux->MasterTransmit( (uint8_t) address_detector_bias_trimmer[canale].indirizzo_I2C , spedizione, 1,false); //set the channel to read only
        }
        
        while( I2C_mux->GetStatus().busy){};  // Write transmission complete
            if( Error_bad_operation) ERROR_codifica_errore( scheda_su_scheda_giu, error_address_I2C1_B  , I2C_error_trimmer_bias_0  + canale,1);
        
        I2C_mux->MasterReceive( address_detector_bias_trimmer[canale].indirizzo_I2C, &tappo, 1,false);  //Read back, the trimmer value
        
        while( I2C_mux->GetStatus().busy){};
        
                contenuto_trimmer_detector[canale + scheda_su_scheda_giu][trimmer]  = tappo;  //Tappo is global
}   
 //! <!-- [fun_detector_scrittura_lettura_trimmer_bias] -->
 
 
 /*! \brief Setting the value of any trimmer for preamplifier trimmer, the contents of the trimmers are stored 
                                                                                        in the matrix contenuto_trimmer_preamplifier[canale][trimmer]   
 
 *\param[in] scheda_su_scheda_giu one of the 2 boards that the postfrontend manages
 *\param[in] canale the channel for which we need to manage the trimmer
 *\param[in] trimmer the trimmer to select in  the chip, from 0 to 3            
 *\param[in] valore     the value to be written to.         
 *\param[in] scrivi_1_leggi_0    if 1 we write and read, if 0 we read only and the contenis in the global contenuto_trimmer_detector[canale][trimmer]                                                               
 *\return No Parameters
 
 *\snippetlineno Trimmer.c  fun_preamplifier_scrittura_lettura_trimmer
 */
 //! <!-- [fun_preamplifier_scrittura_lettura_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;
}   
 //! <!-- [fun_preamplifier_scrittura_lettura_trimmer] -->
 
 
 /*! \brief The fine and coarse trimmers for offset adjustment are calibrated here  
 
 *\return No Parameters
 
 *\snippetlineno Trimmer.c  fun_instr_offset_trimmer_calibration_function
 */
 //! <!-- [fun_instr_offset_trimmer_calibration_function] -->
void instr_offset_trimmer_calibration_function(void){
    uint8_t canale,internalADC_0_externalADC_1=(tx_data[4] & 1), canale_selezionato=10;
    uint8_t trimmer_old[4], PGA_Gain_old[12], trimmer_fine_test, trimmer_coarse_test;
    uint8_t *dati_da_scrivere,dati_da_leggere[]={0,0,0,0};
    //convertiamo i valori di riferimento
    int32_t pendenza_fine=0,pendenza_coarse=0,trimmer_riferimento_fine = (*(uint16_t *)&tx_data[0]);//fine trimmer in microV
    int32_t ADC_misura_fatta_first,ADC_misura_fatta_last,trimmer_riferimento_coarse=  (*(uint16_t *)&tx_data[2] ) *10;//Coarse trimmer in unit\'a di 10^5
                    ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
    //Detrminare il canale da calibrare
    scheda_su_scheda_giu = ((tx_data[6] >> 7) & 1)*6;
    ADC_medie_per_misura = tx_data[4] >>1;
    for(canale=0;canale<6;canale++){
        if((tx_data[6]>>canale)&1){
            canale_selezionato=canale;
            break;
        }
    }
    //Memorizzare il valore dei trimmer, da poterer poi ristabilire
    for(canale=0;canale<4;canale++){
        trimmer_old[canale]=contenuto_trimmer_preamplifier[canale_selezionato+scheda_su_scheda_giu][canale];
    }
    //Impostare il gain a 1
    for(canale=0;canale<6;canale++){
        PGA_Gain_old[canale]=PGA_settled_gain[canale + scheda_su_scheda_giu];
        PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale,  1  );
    }
    //Verificre che l'offset sia in una scala opportuna
//  if(internalADC_0_externalADC_1){
//      //lettura con ADC exsterno
//      ADC_misura_fatta_first = preamplifier_ADC_external_measured_node_function(scheda_su_scheda_giu ,node_voltage_PGA_ch_0 + \
//              canale_selezionato+scheda_su_scheda_giu);
//                                  ERROR_codifica_errore(scheda_su_scheda_giu, error_address_reg_ADC0 , ADC_external_fails , 1);       
//  }else{
//      //lettura con adc interno
//      ADC_misura_fatta_first = ADC_lettura(scheda_su_scheda_giu, node_voltage_PGA_ch_0 + \
//      canale_selezionato+scheda_su_scheda_giu, 1);
//                                  ERROR_codifica_errore(scheda_su_scheda_giu, error_address_reg_ADC0 , ADC_internal_General_fails , 1);       
//  }
        ADC_misura_fatta_first = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,internalADC_0_externalADC_1,node_voltage_PGA_ch_0 + canale_selezionato, 1);
    //se l'offset non \'e in scala non viene fatto nessun calcolo.
    if( (ADC_misura_fatta_first > trimmer_max_voltage_per_trimmer_calibration) || \
        (ADC_misura_fatta_first <-trimmer_max_voltage_per_trimmer_calibration)){
        //Offset troppo grande
            tx_data[5]=4;
    }else{
        //facciamo i conti
    //loop per la calibrazione dei 2 trimmer
                if(tx_data[5] & 1){//Calibrazione trimmer fine
            // cambiare il trimmer fine di un po'
                    if(trimmer_old[trimmer_fine_offset] >128){
                        trimmer_fine_test= 0;
                    }else{
                        trimmer_fine_test =255;
                    }
                    preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale_selezionato, \
                        trimmer_fine_offset, trimmer_fine_test, preamplifier_scrivi_il_trimmer  );
                    Aspetta_tanti_ms( 500);
//              if(internalADC_0_externalADC_1){
//                          ADC_misura_fatta_last = preamplifier_ADC_external_measured_node_function(scheda_su_scheda_giu, node_voltage_PGA_ch_0 + \
//              canale_selezionato+scheda_su_scheda_giu);
//              }else{
//                  ADC_misura_fatta_last = ADC_lettura(scheda_su_scheda_giu, node_voltage_PGA_ch_0 + canale_selezionato+scheda_su_scheda_giu, 1);
//              }
                    ADC_misura_fatta_last = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,internalADC_0_externalADC_1,node_voltage_PGA_ch_0 + canale_selezionato, 1);
                    
                pendenza_fine = (ADC_misura_fatta_first - ADC_misura_fatta_last) \
                        /(trimmer_old[trimmer_fine_offset] - trimmer_fine_test);
                if( (pendenza_fine > ((trimmer_riferimento_fine *12)/10)) \
                        || (pendenza_fine <((trimmer_riferimento_fine *10)/12) )){ 
                            //Misura anadata a male, prendiamo il default
                            pendenza_fine = trimmer_riferimento_fine;
                            tx_data[5] -= 1; //Togliamo perch\'e non \'e andato bene
                        }
                    //memorizzare il valore nella eprom se \'e in tolleranza
                    dati_da_scrivere= (uint8_t *)&pendenza_fine;
                    EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard,  canale_selezionato,  (Memory_preamplifier_address_fine_trimmer_slope_offset << 2) ,  dati_da_scrivere);
                        ADC_misura_fatta_first = ADC_misura_fatta_last; //Se si misura anche il coarse questa \'e l'ultima misura valida
                    EPROM_lettura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard,  canale_selezionato,  (Memory_preamplifier_slope_calibration_ON_0_OFF_ff << 2) ,  dati_da_leggere);
                    if(dati_da_leggere[0]>3){ //If it the first time it is read the content of the register is 0xff
                        dati_da_leggere[0]=1;  //1 means that the fine slope is stored
                    }else{
                        dati_da_leggere[0] |=1; //It maybe that the coars was already measured. Here we add the information about this slope, the 1
                    }   
                    dati_da_leggere[1]=0;dati_da_leggere[2]=0;dati_da_leggere[3]=0;
                        EPROM_scrittura_M24C32_64( scheda_su_scheda_giu,   I2C_mainboard, canale_selezionato,  (Memory_preamplifier_slope_calibration_ON_0_OFF_ff << 2) ,  dati_da_leggere);
            }
            if( tx_data[5] & 2){
            // cambiare il trimmer coarse di 4 passi e misurare di nuovo, se si vuole calcolare questa
                    if(trimmer_old[trimmer_coarse_offset] >128){
                        trimmer_coarse_test= trimmer_old[trimmer_coarse_offset]  -4;
                    }else{
                        trimmer_coarse_test =trimmer_old[trimmer_coarse_offset] +4;
                    }
                    preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale_selezionato, \
                        trimmer_coarse_offset, trimmer_coarse_test, preamplifier_scrivi_il_trimmer  );
                    Aspetta_tanti_ms( 500);
//              if(internalADC_0_externalADC_1){
//                          ADC_misura_fatta_last = preamplifier_ADC_external_measured_node_function(scheda_su_scheda_giu, node_voltage_PGA_ch_0 + \
//              canale_selezionato+scheda_su_scheda_giu);
//              }else{
//                  ADC_misura_fatta_last = ADC_lettura(scheda_su_scheda_giu, node_voltage_PGA_ch_0 + canale_selezionato+scheda_su_scheda_giu , 1);
//              }
                    ADC_misura_fatta_last = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,internalADC_0_externalADC_1,node_voltage_PGA_ch_0 + canale_selezionato, 1);
                    
                pendenza_coarse = (ADC_misura_fatta_first - ADC_misura_fatta_last) \
                        /(trimmer_old[trimmer_coarse_offset] - trimmer_coarse_test);
                if( (pendenza_coarse > ((trimmer_riferimento_coarse *12)/10)) \
                        || (pendenza_coarse <((trimmer_riferimento_coarse *10)/12) )){ 
                            //Misura anadata a male, prendiamo il default
                            pendenza_coarse = trimmer_riferimento_coarse;
                            tx_data[5] -= 2; //Togliamo perch\'e non \'e andato bene
                        }
                    //memorizzare il valore nella eprom se \'e in tolleranza
                    dati_da_scrivere= (uint8_t *)&pendenza_coarse;
                    EPROM_scrittura_M24C32_64( scheda_su_scheda_giu,  I2C_mainboard, canale_selezionato,  (Memory_preamplifier_address_coarse_trimmer_slope_offset <<2) ,  dati_da_scrivere);                       
 
                    EPROM_lettura_M24C32_64( scheda_su_scheda_giu,I2C_mainboard,   canale_selezionato,  (Memory_preamplifier_slope_calibration_ON_0_OFF_ff << 2) ,  dati_da_leggere);
                    if(dati_da_leggere[0]>3){ //If it the first time it is read the content of the register is 0xff
                        dati_da_leggere[0]=2;  //2 means that the fine slope is stored
                    }else{
                        dati_da_leggere[0] |=2; //It maybe that the coars was already measured. Here we add the information about this slope, the 2
                    }           
                    dati_da_leggere[1]=0;dati_da_leggere[2]=0;dati_da_leggere[3]=0;
                        EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard,  canale_selezionato,  (Memory_preamplifier_slope_calibration_ON_0_OFF_ff << 2) ,  dati_da_leggere);                     
                }                       
            }
                    EPROM_lettura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard,  canale_selezionato,  (Memory_preamplifier_slope_calibration_ON_0_OFF_ff << 2) ,  dati_da_leggere);
                    if(dati_da_leggere[0]==3){
                        dati_da_leggere[0]=0;
                        dati_da_leggere[1]=0;dati_da_leggere[2]=0;dati_da_leggere[3]=0;
                        EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard,  canale_selezionato,  (Memory_preamplifier_slope_calibration_ON_0_OFF_ff << 2) ,  dati_da_leggere);                     
                    }
    // ritornare il valore misurato nella istruzione can
        pendenza_fine = pendenza_fine;
        tx_data[0]= pendenza_fine & 0xff;
        tx_data[1] =(pendenza_fine >> 8) & 0xff;
        pendenza_coarse = pendenza_coarse /10 ; 
        tx_data[2]= pendenza_coarse & 0xff;
        tx_data[3]= ( pendenza_coarse >> 8) & 0xff;
    //ristabilire i trimmer.
        for(canale=0;canale<4;canale++){
        preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale_selezionato, \
            canale, trimmer_old[canale],    preamplifier_scrivi_il_trimmer  );
    }
    //Ristabilire il guadagno
        for(canale=0;canale<6;canale++){
        PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale,  PGA_Gain_old[canale]  );
    }
        Error_imposta_la_istruzione();
}
 //! <!-- [fun_instr_offset_trimmer_calibration_function] -->
 
 
 /*! \brief The fine and coarse trimmers for Detector bias  adjustment are calibrated here  
 
 *\return No Parameters
 
 *\snippetlineno Trimmer.c  fun_instr_DetBias_trimmer_calibration_function
 */
 //! <!-- [fun_instr_DetBias_trimmer_calibration_function] -->
void instr_DetBias_trimmer_calibration_function(void){
        uint8_t canale,internalADC_0_externalADC_1=(tx_data[4] & 1), canale_selezionato=10;
    uint8_t trimmer_old[4], PGA_Gain_old[12], trimmer_fine_test, trimmer_coarse_test;
    uint8_t *dati_da_scrivere,dati_per_switch[]={0,0,0,0}, delta_trimmer, divisore;
    int32_t target_slope = *(int32_t *)tx_data, tampone;
    //convertiamo i valori di riferimento
    int32_t pendenza[]={0,0,0,0,},trimmer_riferimento_fine = (*(uint16_t *)&tx_data[0]);//fine trimmer in microV
    int32_t ADC_misura_fatta_first[]={0,0,0,0},ADC_misura_fatta_last[]={0,0,0,0},  risul_vof;//Coarse trimmer in unit\'a di 10^5
    ADC_medie_per_misura = tx_data[4] >>1;
        //Detrminare il canale da calibrare
    scheda_su_scheda_giu = ((tx_data[6] >> 7) & 1)*6;
    for(canale=0;canale<6;canale++){
        if((tx_data[6]>>canale)&1){
            canale_selezionato=canale;
            break;
        }
    }
    
    //Vettori corrispondenze
    typedef struct {
        uint8_t trimmer;  //Il trimmer da modificare
        uint16_t memoria_trimmer; //la cella di memoria dove star\'a la pendenza
        uint16_t memoria_switch_trimmer; //la cella di memoria che certifa la presenza della calibrazione
        int32_t     segno_uscita; //Coefficiente per la variazione del segnale di uscita
        uint8_t      nodo_lettura; //il nodo di tensione da leggere
    }trimmer_da_lavorare_;
    
    trimmer_da_lavorare_ trimmer_da_lavorare[]={Detector_trimmer_coarse_bias_pos,Memory_detector_positive_address_coarse_trimmer_slope_bias,Memory_detector_coarse_slope_calibration_ON_0_OFF_ff,-1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset ,
        Detector_trimmer_coarse_bias_neg,Memory_detector_negative_address_coarse_trimmer_slope_bias,Memory_detector_coarse_slope_calibration_ON_0_OFF_ff,1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset+1,
        Detector_trimmer_fine_bias_pos,Memory_detector_positive_address_fine_trimmer_slope_bias,Memory_detector_fine_slope_calibration_ON_0_OFF_ff,1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset,
        Detector_trimmer_fine_bias_neg,Memory_detector_negative_address_fine_trimmer_slope_bias,Memory_detector_fine_slope_calibration_ON_0_OFF_ff,-1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset+1};
 
//Preamplifier memory contents regarding detector trimmer slopes are copied in the mainboard memory or restored.
//This is a patch: the storing of these data in the preamplifier memoery is unnecessary, but it was done. 
//So now the content of the preamplifier memory is done also in the mainboard memory at the time of the slopes measurements. 
//These data are restored in the preamplifier memory at startup so that if the preamplifier is changed the slopes are not lost. 
    trimmer_da_lavorare_    trimmer_da_lavorare_mainboard_CH0[]={
        0, Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch0, Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch0, 0,0,
        0, Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch0, Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch0,0,0,
        0,Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch0, Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch0,0,0,
        0,Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch0,Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch0,0,0 };
            
    uint8_t ii, trimmer_coarse_o_fine=10; //inizializzazione ad un valore abnorme
                
        
//L'offset da considerare in trimmer_da_lavorare per selezionare la coppia di trimmer giusti, i 2 coarse o i 2 fine.
    if( tx_data[5]==1){
        trimmer_coarse_o_fine=2;
        delta_trimmer=100;
        divisore=1;
    }else if (tx_data[5]==2){
        trimmer_coarse_o_fine=0;
        delta_trimmer=10;
        divisore=10;
    }
        
 
//Condizioni iniziale da ristabilire    
    //Memorizzare il valore dei trimmer, da poterer poi ristabilire ed impostiamo la met\'a scala
    for(canale=0;canale<4;canale++){
        trimmer_old[canale]=contenuto_trimmer_detector[canale_selezionato+scheda_su_scheda_giu][canale];
        detector_scrittura_lettura_trimmer_bias(scheda_su_scheda_giu, canale_selezionato, canale, 128, 1);
    }
    //Impostare il gain a 1
    for(canale=0;canale<6;canale++){
        PGA_Gain_old[canale]=PGA_settled_gain[canale + scheda_su_scheda_giu];
        PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale,  1  );
    }
    
    //Qui calibriamo    
    //Misuriamo a met\'a scala
    Aspetta_tanti_ms(500);
        for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
            ADC_misura_fatta_first[ii] = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,internalADC_0_externalADC_1,trimmer_da_lavorare[ii].nodo_lettura,0);
 
    detector_scrittura_lettura_trimmer_bias(scheda_su_scheda_giu, canale_selezionato, trimmer_da_lavorare[ii].trimmer, \
    128+trimmer_da_lavorare[ii].segno_uscita*delta_trimmer, 1);
    }
    Aspetta_tanti_ms(500);
    for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
        ADC_misura_fatta_last[ii] = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,internalADC_0_externalADC_1,trimmer_da_lavorare[ii].nodo_lettura,0);
    }
    for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
        pendenza[ii]=( (ADC_misura_fatta_last[ii] - ADC_misura_fatta_first[ii]) * (trimmer_da_lavorare[ii].segno_uscita ) )/ ( (int)delta_trimmer)  ; 
        tampone = ((int)100*pendenza[ii]) / target_slope;
        if (target_slope){ //If target_slope is passed 0 there is no comparison 
        if ( (tampone >130) || (tampone<70)){
            //valore non in tolleranza
            pendenza[ii]=target_slope;
            tx_data[5]=3 + ii -trimmer_coarse_o_fine;
        }
    }
    }
                //memorizzare il valore nella eprom se \'e in tolleranza
        for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
                    dati_da_scrivere= (uint8_t *)&pendenza[ii];
                    EPROM_scrittura_M24C32_64( scheda_su_scheda_giu,I2C_mainboard,   canale_selezionato,  (trimmer_da_lavorare[ii].memoria_trimmer <<2) ,  dati_da_scrivere);   
                    //We store also in the mainboard EPROM, to be restored in the preamplifier memory at startup
                    EPROM_scrittura_M24C32_64(scheda_su_scheda_giu,I2C_mainboard, Canale_Eprom_mainboard,\
                                                    ((trimmer_da_lavorare_mainboard_CH0[ii].memoria_trimmer+6*canale_selezionato) <<2), dati_da_scrivere);
                    dati_per_switch[0]=0;
                    if( tx_data[5] >2){
                       dati_per_switch[0]=0xFF;   
                    }
                    EPROM_scrittura_M24C32_64( scheda_su_scheda_giu,  I2C_mainboard, canale_selezionato,  (trimmer_da_lavorare[ii].memoria_switch_trimmer << 2) ,  dati_per_switch);
                    //We store also in the mainboard EPROM, to be restored in the preamplifier memory at startup
                    EPROM_scrittura_M24C32_64(scheda_su_scheda_giu,I2C_mainboard, Canale_Eprom_mainboard,\
                                ((trimmer_da_lavorare_mainboard_CH0[ii].memoria_switch_trimmer+6*canale_selezionato) <<2), dati_per_switch);
                }
        pendenza[ trimmer_coarse_o_fine]  = (pendenza[ trimmer_coarse_o_fine] / divisore );
        tx_data[0]= (pendenza[ trimmer_coarse_o_fine]  )& 0xff;
        tx_data[1] =(( pendenza[ trimmer_coarse_o_fine] )>>8)& 0xff;
        pendenza[ trimmer_coarse_o_fine+1]= (pendenza[ trimmer_coarse_o_fine+1] / divisore );
        tx_data[2]= (pendenza[ trimmer_coarse_o_fine+1]  )& 0xff;
        tx_data[3]=( ( pendenza[ trimmer_coarse_o_fine+1])>>8)& 0xff;
        tx_data[4]= divisore;
//E qui riportiamo tutto come prima 
    //ristabilire i trimmer.
        for(canale=0;canale<4;canale++){
        detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu,  canale_selezionato, \
            canale, trimmer_old[canale],    Detector_scrivi_il_trimmer  );
    }
    //Ristabilire il guadagno
        for(canale=0;canale<6;canale++){
            PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale,  PGA_Gain_old[canale]  );
    }
    
}
 //! <!-- [fun_instr_DetBias_trimmer_calibration_function] -->
 
//Fine CROSS
 
/******************************************************************************
Variabili 
*******************************************************************************/
struct trimmer_type /*{
//  signed short fine_thermal;
    signed short JFET_Offset;   
    signed short fine_offset;
    signed short coarse_thermal;
    signed short coarse_offset;
}*/ Trimmer_offset_preampli[]={0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80};
 
struct trimmer_CMRR_JFET_COLD_type /* {
    signed short JFET_COLD[2];  
    signed short CMRR[2];
}       */ Trimmer_CMRR_JFET_COLD={0x80,0x80,0x80,0x80};
 
 
int      coarse_Trimmer_offset_step_actual[]={coarse_Trimmer_offset_step,coarse_Trimmer_offset_step};
int      fine_Trimmer_offset_step_actual[]={fine_Trimmer_offset_step,fine_Trimmer_offset_step};
int      fine_Trimmer_thermal_step_actual[]={fine_Trimmer_thermal_step,fine_Trimmer_thermal_step};
int      coarse_Trimmer_thermal_step_actual[]={coarse_Trimmer_thermal_step,coarse_Trimmer_thermal_step};
int    reference_thermal_drift_actual=reference_thermal_drift;
char        numero_offset_per_impostazione_deriva[]= {17,17};  //Numero di impostazioni dell'offset per la deriva nella EPROM. Il default \'e 17
char        numero_temperature_impostazione_deriva[]= {9,9};
unsigned char       coefficiente_termico_trimmer_deriva[]= {200,200};
signed char valori_offset_per_impostazione_deriva[2][20];
unsigned char valori_temperature_impostazione_deriva[2][12];
char temperatura_di_lavoro[2];
char offset_di_lavoro[2];
 
/******************************************************************************
    Imposta_wiper_a_meta_scala_canale_0_I2CA
*******************************************************************************/
void Imposta_wiper_a_meta_scala_canale_0_I2CA( void )
{
    uint8_t addr = 0x2D;                                                                                    // 0101101 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    uint8_t dati_scrittura[2];
    dati_scrittura[0] = 0<<5;                                                                           // Viene impostato il trimmer 0
    dati_scrittura[1] = 0x80;                                                                           // Viene mandato il dato 128 che \'e met\'a scala
 
  I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
 
    dati_scrittura[0] = 1<<5;                                                                           // Viene impostato il trimmer 1
  I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
 
    dati_scrittura[0] = 2<<5;                                                                           // Viene impostato il trimmer 2
    I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
 
    dati_scrittura[0] = 3<<5;                                                                           // Viene impostato il trimmer 3
    I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
}
 
 
/******************************************************************************
    Imposta_wiper_a_meta_scala_canale_1_I2CA
*******************************************************************************/
void Imposta_wiper_a_meta_scala_canale_1_I2CA( void )
{
    uint8_t addr = 0x2F;                                                                                    // 0101111 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    uint8_t dati_scrittura[2];
    dati_scrittura[0] = 0<<5;                                                                           // Viene impostato il trimmer 0
    dati_scrittura[1] = 0x80;                                                                           // Viene mandato il dato 128 che \'e met\'a scala
 
  I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
 
    dati_scrittura[0] = 1<<5;                                                                           // Viene impostato il trimmer 1
  I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
 
    dati_scrittura[0] = 2<<5;                                                                           // Viene impostato il trimmer 2
    I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
 
    dati_scrittura[0] = 3<<5;                                                                           // Viene impostato il trimmer 3
    I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
}
 
 
/******************************************************************************
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA
*******************************************************************************/
void Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA  (uint8_t numero_canale, uint8_t numero_trimmer, uint8_t valore_dato)
{
    uint8_t addr;
    uint8_t dati_scrittura[2];
 
    if(numero_canale == 0)                                                                              // 0101101 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    {
        addr = I2C_addres_trimmer_pre_ch0;
    }
    if(numero_canale == 1)
    {
        addr = I2C_addres_trimmer_pre_ch1;                                                                                              // 0101111 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    }   
    
    dati_scrittura[0] = numero_trimmer<<5;                                              // Viene usato il trimmer specificato
    dati_scrittura[1] = valore_dato;                                                            // Viene mandato il dato 
 
  I2CAdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CAdrv->GetStatus().busy);
}
 
 
void Imposta_trimmer_common_mode_I2CB  ( uint8_t numero_trimmer, uint8_t valore_dato)
{
    uint8_t addr;
    uint8_t dati_scrittura[2];
 
 
        addr = I2C_addres_trimmer_common_mode_cold ;
 
    
    dati_scrittura[0] = numero_trimmer<<5;                                              // Viene usato il trimmer specificato
    dati_scrittura[1] = valore_dato;                                                            // Viene mandato il dato 
 
  I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
}
 
/******************************************************************************
    Imposta_wiper_a_meta_scala_canale_0_I2CB
*******************************************************************************/
void Imposta_wiper_a_meta_scala_canale_0_I2CB( void )
{
    uint8_t addr = 0x2D;                                                                                    // 0101101 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    uint8_t dati_scrittura[2];
    dati_scrittura[0] = 0<<5;                                                                           // Viene impostato il canale del trimmer 0
    dati_scrittura[1] = 0x80;                                                                           // Viene mandato il dato 128 che \'e met\'a scala
 
  I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
 
    dati_scrittura[0] = 1<<5;                                                                           // Viene impostato il canale del trimmer 1
  I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
 
    dati_scrittura[0] = 2<<5;                                                                           // Viene impostato il canale del trimmer 2
    I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
 
    dati_scrittura[0] = 3<<5;                                                                           // Viene impostato il canale del trimmer 3
    I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
}
 
 
/******************************************************************************
    Imposta_wiper_a_meta_scala_canale_1_I2CB
*******************************************************************************/
void Imposta_wiper_a_meta_scala_canale_1_I2CB( void )
{
    uint8_t addr = 0x2C;                                                                                    // 0101100 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    uint8_t dati_scrittura[2];
    dati_scrittura[0] = 0<<5;                                                                           // Viene impostato il trimmer 0
    dati_scrittura[1] = 0x80;                                                                           // Viene mandato il dato 128 che \'e met\'a scala
 
  I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
 
    dati_scrittura[0] = 1<<5;                                                                           // Viene impostato il trimmer 1
  I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
 
    dati_scrittura[0] = 2<<5;                                                                           // Viene impostato il trimmer 2
    I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
 
    dati_scrittura[0] = 3<<5;                                                                           // Viene impostato il trimmer 3
    I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
}
 
 
/******************************************************************************
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB
*******************************************************************************/
void Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB  (uint8_t numero_canale, uint8_t numero_trimmer, uint8_t valore_dato)
{
    uint8_t addr;
    uint8_t dati_scrittura[2];
 
    if(numero_canale == 0)                                                                              // 0101101 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    {
        addr = I2C_addres_trimmer_bias_ch0;
    }
    if(numero_canale == 1)
    {
        addr = I2C_addres_trimmer_bias_ch1;                                                                                             // 0101100 indirizzo a 7 bit (il bit di lettura e scrittura viene messo in automatico)
    }   
    
    dati_scrittura[0] = numero_trimmer<<5;                                              // Viene usato il trimmer specificato
    dati_scrittura[1] = valore_dato;                                                            // Viene mandato il dato 
 
  I2CBdrv->MasterTransmit (addr, dati_scrittura, 2, false);
  while (I2CBdrv->GetStatus().busy);
}
 
 
 /*****************************************************************************
  Arrotonda
 ******************************************************************************/
long int Arrotonda(float temp)
{
    long int valore_finale;
 
    if(temp>0)
    {       
        if(temp - (long int) temp >=0.5)
        {
            valore_finale = (long int) temp + 1;
        }
        else
        {   
            valore_finale = (long int) temp;
        }
    }
    else
    {
        if(-(temp - (long int) temp )>=0.5)
        {
            valore_finale = (long int) temp - 1;
        }
        else
        {   
            valore_finale = (long int) temp;
        }   
    }
return valore_finale;
}
 
 
 /****************************************************************************************
  Trova_valori_trimmer_per_la_Vbias_del_rivelatore_per_la_tensione_in_uscita_uguale_a_vout
 *****************************************************************************************/
//void Trova_valori_trimmer_per_la_Vbias_del_rivelatore_per_la_tensione_in_uscita_uguale_a_vout (long int vout_, int16_t *Valori_per_i_trimmer, long int offset)
//{
//  vout_ = vout_ - offset;
////    float temp = -vout*128/1.03/5000;
//  float temp = -(float)vout_ / trimmer_bias_coarse_step;
//  long int x = Arrotonda(temp);   
//  
//  int16_t Tr0, Tr1;
//  Tr0 = x + 128;
 
////    summed because x is negated above.
//  temp = (  vout_ + x*trimmer_bias_coarse_step) / trimmer_bias_fine_step ;
//  Tr1 = Arrotonda(temp);
//  Tr1 = Tr1 + 128;
 
////    long int tensione_out[1];
////    tensione_out[0] = ( (Tr0-128) *(-1.03) + (Tr1-128)*(0.0117) )*5000/128;
//  
//  Valori_per_i_trimmer[0]= Tr0;
//  Valori_per_i_trimmer[1]= Tr1;
//  return;
//}
 
 
 /****************************************************************************************
  Trova_valori_trimmer_per_offset_preamplificatore
 *****************************************************************************************/
void Trova_valori_trimmer_per_offset_preamplificatore (long int offset, struct trimmer_type *Valori_per_i_trimmer, int coarse_trimmer_step, int fine_trimmer_step)
{
//  offset=offset;
    int16_t Tr0, Tr1;
    
    float temp = offset / coarse_trimmer_step;
     Tr0 = Arrotonda(temp); 
    
 
    long int tensione_rimasta[1];
    tensione_rimasta[0] = offset - coarse_Trimmer_offset_step * Tr0;    
 
    temp = tensione_rimasta[0] / fine_trimmer_step;
    Tr1 = Arrotonda(temp);      
 
    Valori_per_i_trimmer->coarse_offset += Tr0;
    if (Valori_per_i_trimmer->coarse_offset > 0xFF) Valori_per_i_trimmer->coarse_offset=0xFF;
    if( Valori_per_i_trimmer->coarse_offset <0) Valori_per_i_trimmer->coarse_offset=0;
    Valori_per_i_trimmer->fine_offset  += Tr1;
    if (Valori_per_i_trimmer->fine_offset > 0xFF) Valori_per_i_trimmer->fine_offset=0x80;
    if(Valori_per_i_trimmer->fine_offset <0) Valori_per_i_trimmer->fine_offset=0x80;
 
}
    
    
 
 
 /****************************************************************************************
  Trova_valori_trimmer_per_deriva_termica_preamplificatore
 *****************************************************************************************/
void Trova_valori_trimmer_per_deriva_termica_preamplificatore (long int deriva, int16_t *Valori_per_i_trimmer)
{
    
    float temp = deriva*2.7*256/5.1/2560*2;
    long int x = Arrotonda(temp);   
    
    int16_t Tr0, Tr1;
    Tr0 = x + 128;  
    
    long int tensione_rimasta[1];
    tensione_rimasta[0] = deriva - 5.1*2560/2*x/2.7/256;    
 
    temp = tensione_rimasta[0]*470*256/5.1/2560*2;
    x = Arrotonda(temp);        
    
    Tr1 = x;
    Valori_per_i_trimmer[0] = Tr0;
    Valori_per_i_trimmer[1]= Tr1+128;
 
return;
}