Istruzioni.c

Go to the documentation of this file.

 
 
#include "tutti_gli_header.h"
 
/// \file
 
/*!
 
\page Istruzioni
\brief Instruction set is at \ref Instruction_set
 
*/
 
int valore_target_per_offset[]={0,0};  //Target offset to adjust
 
// INIZIO CROSS
 
/*!  \brief This is the pointer array to the instructions set: the byte #istruzione_codice of the CAN message
is the address used for the array
 
The input parameter is the global byte #istruzione_codice of the CAN messsage
*\return The returned parameters is the global 8-byte array to be sent with the CAN.
*/
void (*ptr_istruzioni[The_total_number_of_instrucions]) (void);
 
 
 
/*! \brief The pointer to the instruction functions is constructed here.
 
*\snippetlineno Istruzioni.c fun_Setting_of_the_pointer_for_command_parser
*/
//! <!-- [fun_Setting_of_the_pointer_for_command_parser] -->
void  Setting_of_the_pointer_for_command_parser ( void){
//! \brief base instrucions
    ptr_istruzioni[instr_NO_operation] =instr_NO_operation_function;                    //!< Nop instruction it replais the fw version
    ptr_istruzioni[instr_Shut_Down_ON_OFF]=instr_Shut_Down_ON_OFF_function;  //!< micro Pwd ON/OFF
    ptr_istruzioni[instr_inizializza_tutto_da_zero] =instr_inizializza_tutto_da_zero_function;   //!< Board reset   
    //! \brief Detector instructions    
    ptr_istruzioni[instr_detector_Vbias_we_want_to_set]=instr_detector_Vbias_we_want_to_set_function;   
    ptr_istruzioni[instr_Vbias_to_be_set]= instr_Vbias_to_be_set_function;
    ptr_istruzioni[instr_Relays_driver_set_reset_channel]=instr_Relays_driver_set_reset_channel_function;   
    ptr_istruzioni[instr_detector_scrittura_lettura_trimmer_bias] = instr_detector_scrittura_lettura_trimmer_bias_function;
    //! \brief Preamplifier instructions
    ptr_istruzioni[instr_preamplifier_gain_low_high_set]=instr_preamplifier_gain_low_high_set_function;
    ptr_istruzioni[instr_preamplifier_memory]=  instr_preamplifier_memory_function;
    ptr_istruzioni[instr_preamplifier_temperature_meas]= instr_preamplifier_temperature_meas_function;
    ptr_istruzioni[instr_ouput_offset_we_want_to_set] = instr_ouput_offset_we_want_to_set_function;
    ptr_istruzioni[instr_output_offset_to_be_set] = instr_output_offset_to_be_set_function;
    ptr_istruzioni[instr_preamplifier_scrittura_lettura_trimmer_offset] = instr_preamplifier_scrittura_lettura_trimmer_offset_function;
  //! \brief PGA managing
  ptr_istruzioni[instr_PGA_gain_set]=instr_PGA_gain_set_function;
    ptr_istruzioni[instr_PGA_set_reset_pre_PGA_gain]=instr_PGA_set_reset_pre_PGA_gain_function;
    ptr_istruzioni[instr_PGA_DAC_GAIN_CROSS]=instr_PGA_DAC_GAIN_CROSS_function;
    //! \brief Errors
    ptr_istruzioni[instr_ERROR_inspection]=instr_ERROR_inspection_function;
    ptr_istruzioni[instr_ERROR_echo_on_off]=instr_ERROR_echo_on_off_function;
  //! \brief Common use     
    ptr_istruzioni[instr_ADC_LETTURA]= instr_ADC_LETTURA_function; //Variable Readback
    ptr_istruzioni[instr_readback_variables]= instr_readback_variables_function; //Variable Readback
    ptr_istruzioni[instr_readback_node_voltages]=instr_readback_node_voltages_function;  //Readback node volatges 
//  ptr_istruzioni[instr_Vbias_set]=instruction_Detector_bias;  
  //! \brief Experts use
    ptr_istruzioni[instr_offset_trimmer_calibration]= instr_offset_trimmer_calibration_function;
    ptr_istruzioni[instr_DetBias_trimmer_calibration]= instr_DetBias_trimmer_calibration_function;  
  ptr_istruzioni[instr_EPROM_read_write]= instr_EPROM_read_write_function;
    ptr_istruzioni[instr_connect_disconnect_mux_node]= instr_connect_disconnect_mux_node_function;
    ptr_istruzioni[instr_LED_ON_OFF]= instr_LED_ON_OFF_function;    
    ptr_istruzioni[instr_periferal_reset]= instr_periferal_reset_function;
    
 
 
//! \brief ADC instructions 
//  ptr_istruzioni[instr_ADC_LETTURA] =instruction_lettura_ADC;         //!<
//! \brief preamplifier instrucions 
//  ptr_istruzioni[instr_pre_PGA_gain]= instruction_Detector_PGA_Rele;
//  ptr_istruzioni[instr_PGA_GAIN]=instruction_for_PGA_GAIN_set;
//  ptr_istruzioni[instr_preamplifier_temperature_meas]=instruction_Misura_della_temperatura;
//  ptr_istruzioni[instr_Power_supply_ON_OFF]=instruction_Power_supply_control;
//  ptr_istruzioni[instr_OFFSET_ADJ]=instruction_Offset_compensation;   
 
//  ptr_istruzioni[instr_preamplifier_memory]=instruction_preamplifier_memory;
//  ptr_istruzioni[instr_measure_pre_bias_coefficients]=instruction_measure_pre_bias_coefficients;
//  ptr_istruzioni[instr_Some_parameters_to_set] =instruction_Some_parameters_to_set;
    
//  ptr_istruzioni[instr_ricalibrazione_scheda] =instruction_ricalibrazione_scheda;
}
//! <!-- [fun_Setting_of_the_pointer_for_command_parser] -->
 
//In the following there are the instruction functions: every function is an instruction
 
 /*! \brief The NOP sends backs the fw version.
 
There is no input parameter for this function.
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_NO_operation_function
*/
//! <!-- [fun_instr_NO_operation_function] -->
void instr_NO_operation_function(void){
 
    *(unsigned int *) &tx_data[byte_istr_dati_0] =FW_version; // FW_version is copied in the first 4 bytes of tx_data
    __NOP();
}
//! <!-- [fun_instr_NO_operation_function] -->
 
 /*****************************************************************************
    Controllo modalit\'a Power down
 ******************************************************************************/
/*!  \brief &mu;-controller power down ON/OFF
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_Shut_Down_ON_OFF_function
*/
//! <!-- [fun_instr_Shut_Down_ON_OFF_function] -->
void instr_Shut_Down_ON_OFF_function(void){
    //If  vettore_istruzioni[istruzione_byte_4_e_scelta_canale]>1 the state is returned only.
    uint8_t dati_da_scrivere[]={0,0,0,0};
    if( vettore_istruzioni[istruzione_byte_4_e_scelta_canale]==1 ){
        //Power down attivo
        flag_power_down = true;
        POWER_DOWN_MAX_ATTESA= vettore_istruzioni[0];
        if ( (vettore_istruzioni[0]==0) || (vettore_istruzioni[0]>60) )POWER_DOWN_MAX_ATTESA=5;
        dati_da_scrivere[0]=  POWER_DOWN_MAX_ATTESA & 0xFF;
        EPROM_scrittura_M24C32_64( 0,  I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_micro_PD_wait_time_in_sec << 2  , dati_da_scrivere);
        EPROM_scrittura_M24C32_64( 1,  I2C_postmainboard, Canale_EPROM_postmainboard_up, Memory_postmainboard_micro_PD_wait_time_in_sec << 2  , dati_da_scrivere);  
        POWER_DOWN_MAX_ATTESA=POWER_DOWN_MAX_ATTESA*1000;       
    }else if ( vettore_istruzioni[istruzione_byte_4_e_scelta_canale]==0 ){
        //Power down non attivo, micro sempre acceso
        flag_power_down = false;
    }
        
    dati_da_scrivere[0]= flag_power_down;
    EPROM_scrittura_M24C32_64( 0,  I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_micro_powdown_active_1_alwaysON_0 << 2  , dati_da_scrivere);
    EPROM_scrittura_M24C32_64( 1,  I2C_postmainboard, Canale_EPROM_postmainboard_up, Memory_postmainboard_micro_powdown_active_1_alwaysON_0 << 2  , dati_da_scrivere);  
    tx_data[istruzione_byte_4_e_scelta_canale]= flag_power_down;
//  flag_power_down = false;   //<-------------------- Cancellare questa riga
 
    if( vettore_istruzioni[5]==0 ){
        //ADC in standby quando non usati, res dummy attive, power non cambia
        ADC_sleep_off = 0;
        ADC_sleep_ON_OFF( 0 , 0);
        ADC_sleep_ON_OFF( 1 , 0);
    }else if (vettore_istruzioni[5]==2 ){
        //ADC sempre accesi
        ADC_sleep_off = 2;
        ADC_sleep_ON_OFF( 0 , 2);
        ADC_sleep_ON_OFF( 1 , 2);
    }   else if (vettore_istruzioni[5]==1 ){
        //ADC in standby quando non usati, res dummy non attive, power si riduce
        ADC_sleep_off = 1;
        ADC_sleep_ON_OFF( 0 , 1);
        ADC_sleep_ON_OFF( 1 , 1);       
    }
    dati_da_scrivere[0]=ADC_sleep_off;
    EPROM_scrittura_M24C32_64( 0,  I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_ADCs_always_ON_0_powerdown_1 << 2  , dati_da_scrivere);
    EPROM_scrittura_M24C32_64( 1,  I2C_postmainboard, Canale_EPROM_postmainboard_up, Memory_postmainboard_ADCs_always_ON_0_powerdown_1 << 2  , dati_da_scrivere);
    if (ADC_sleep_off ==0) {
        tx_data[5]= 1; //spenti con dummy resistor
    }
    else if (ADC_sleep_off==1){
        tx_data[5]= 11; //spenti senza dummy resistor
    }else if (ADC_sleep_off>=2){
        tx_data[5]= 2; //sempre accesi
    }
    
    EPROM_lettura_M24C32_64(0, I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_micro_PD_wait_time_in_sec << 2,dati_da_scrivere);
    tx_data[0]= dati_da_scrivere[0];
}   
//! <!-- [fun_instr_Shut_Down_ON_OFF_function] -->
 
/*!  \brief readback of some parameters
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_readback_variables_function
*/
//! <!-- [fun_instr_readback_variables_function] -->
void instr_readback_variables_function(void){
uint8_t canale, offset_board=0;
int32_t variabile_in_mV;
    if ((vettore_istruzioni[istruzione_byte_4_e_scelta_canale] >>7) & 1){
        offset_board=6;
    }
    
    switch ( vettore_istruzioni[istruzione_byte_3] ){
        case instr_detector_bias_variable :
            //Detectoe biasing setting, a short
            for( canale=0; canale<6;canale++){
                if ((vettore_istruzioni[istruzione_byte_4_e_scelta_canale] >> canale) & 1) {
                    variabile_in_mV = Detector_bias_target[canale + offset_board] / 1000 ;
                    tx_data[byte_istr_dati_0]=  variabile_in_mV & 0xFF ;
                    tx_data[byte_istr_dati_1]= (variabile_in_mV >>8) & 0xFF;
                    break;
                }
            }   
            break;
        case instr_offset_voltage_variable:
            //Offset voltage value, a short
            for( canale=0; canale<6;canale++){
                if ((vettore_istruzioni[istruzione_byte_4_e_scelta_canale] >> canale) & 1) {
                    variabile_in_mV = preamplifier_Output_offset_target[canale + offset_board] / 1000;
                    tx_data[byte_istr_dati_0]=  variabile_in_mV & 0xFF ;
                    tx_data[byte_istr_dati_1]= (variabile_in_mV >>8) & 0xFF;
                    break;
                }
            }       
            break;
        case instr_PGA_gain_variable:
            //Pga Gain, an uint8
            for( canale=0; canale<6;canale++){
                if ((vettore_istruzioni[istruzione_byte_4_e_scelta_canale] >> canale) & 1) {
                    tx_data[byte_istr_dati_0]=  PGA_settled_gain[canale + offset_board]  ;
                    break;
                }
            }           
            break;
    }
 
 
    }
//! <!-- [fun_instr_readback_variables_function] -->
 
 
/*!  \brief readback of some node voltages from external ADC
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_readback_node_voltages_function
*/
//! <!-- [fun_instr_readback_node_voltages_function] -->    
void instr_readback_node_voltages_function(void){
    
    ADC_external_measurement = ( *(int32_t *)&vettore_istruzioni[0] ); //The input value is in microV
    ADC_external_measured_node = vettore_istruzioni[istruzione_byte_3];
 
}   
//! <!-- [fun_instr_readback_node_voltages_function] -->    
 
 
/*!  \brief preamplifier temperature read
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_readback_variables_function
*/
//! <!-- [fun_instr_readback_variables_function] -->    
void instr_preamplifier_temperature_meas_function(void){
    uint8_t canale_, canale= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    uint8_t scheda_su_scheda_giu = (canale >> 7) & 1;
    uint32_t temperatura_in_microK_;
    ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
    for( canale_=0;canale_<6;canale_++){
        if ( (canale >> canale_) & 1){
                termometro_lettura(  scheda_su_scheda_giu,   canale_ ,  &temperatura_in_microK_ );
                tx_data[0]= temperatura_in_microK_ & 0xFF;
                tx_data[1]= (temperatura_in_microK_ >> 8) & 0xFF;
              tx_data[2]= (temperatura_in_microK_ >> 16) & 0xFF;
              tx_data[3]= (temperatura_in_microK_ >> 24) & 0xFF;
            break;
        }
    }
    Error_imposta_la_istruzione();
}
//! <!-- [fun_instr_readback_variables_function] -->    
 
 
/*!  \brief preamplifier memory read/write
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_preamplifier_memory_function
*/
//! <!-- [fun_instr_preamplifier_memory_function] -->
void instr_preamplifier_memory_function(void){
    uint8_t canale_, canale= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    uint8_t scheda_su_scheda_giu = (canale & board_up) >0 ;// >> 7   ;
    short indirizzo_memoria= (vettore_istruzioni[4] & 0xFF) +  ( ( vettore_istruzioni[5]<<8) & 0xFF00) ;
    canale_ = canale & 0x3f; //Primi 6 bit sono il canale da considerare
    ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori 
    for (canale_=0; canale_<6;canale_++){
        if( (canale >> canale_) &1){
            break;
        }
    }
    if ( canale & write_trimmer){
        EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard, canale_,  indirizzo_memoria , (uint8_t *) rx_data);
//      EPROM_scrittura_M24C08_16(scheda_su_scheda_giu,canale_,indirizzo_memoria,(uint8_t *) rx_data);
    }else{
        EPROM_lettura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard,  canale_, indirizzo_memoria , tx_data);
//      EPROM_lettura_M24C08_16(scheda_su_scheda_giu, canale_, indirizzo_memoria,tx_data);
    }
    Error_imposta_la_istruzione();
}
//! <!-- [fun_instr_preamplifier_memory_function] -->
 
/*!  \brief preamplifier gain set large or small
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_preamplifier_gain_low_high_set_function
*/
//! <!-- [fun_instr_preamplifier_gain_low_high_set_function] -->
void instr_preamplifier_gain_low_high_set_function(void){
    uint8_t canale_, canale= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    uint8_t gain_small_large= vettore_istruzioni[istruzione_byte_3];
    uint8_t scheda_su_scheda_giu= (canale >> 7) & 1;
    ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
                if (gain_small_large){
                        gain_small_large=preamplifier_Gain_alto;
                }else{
                        gain_small_large=preamplifier_Gain_basso;
                }       
    for(canale_=0; canale_<6;canale_++){
        if( (canale >> canale_) &1){
            preamplifier_set_reset_pre_gain (scheda_su_scheda_giu,  canale_,  gain_small_large  );
        }
    }
    Error_imposta_la_istruzione();
}
//! <!-- [fun_instr_preamplifier_gain_low_high_set_function] -->
 
/*!  \brief PGA gain set 
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_PGA_gain_set_function
*/
//! <!-- [fun_instr_PGA_gain_set_function] -->
void instr_PGA_gain_set_function(void){
    #define PGA_mantieni_loffset   1
    
    uint8_t canale_, preamplifier_canali_da_regolare= (vettore_istruzioni[6] & 0x3F),iii,istruzione_old[8];
    uint8_t PGA_gain_to_set= vettore_istruzioni[byte_istr_dati_0];
    uint8_t scheda_su_scheda_giu= ((vettore_istruzioni[6] >> 7) & 1)*6; 
    uint8_t offset_maintained= vettore_istruzioni[istruzione_byte_3];
    uint8_t preamplifier_externalADC_1_onboardADC_0=0;
    
    if (vettore_istruzioni[5] & PGA_mantieni_loffset){
    //ATTENZIONE: se offset_maintained allora bisogna:
        for (iii =0; iii < 7;iii++){//conserviamo l'sitruzione
            istruzione_old[iii] = vettore_istruzioni[iii];
        }       
        //   -leggere l'offset prima di cambiare: questo sar\'a il target
        for ( canale_ =0; canale_<6; canale_++){
                preamplifier_Output_offset_target[scheda_su_scheda_giu + canale_] = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,preamplifier_externalADC_1_onboardADC_0,canale_,1);
        }           
        //Impostiamo ilo futuro valore del guadagno nel vettore, poi il guadagno verr\'a messo ad 1 nella funzione di regolazione per evitare saturazioni
        for ( canale_ =0; canale_<6; canale_++){
                if( (preamplifier_canali_da_regolare >> canale_) & 1){  
                    PGA_settled_gain[canale_ + scheda_su_scheda_giu]=PGA_gain_to_set;       
                        }
            }
          preamplifier_attesa_tra_le_misure = vettore_istruzioni[3];
            if( preamplifier_attesa_tra_le_misure==0) preamplifier_attesa_tra_le_misure=500;
            preamplifier_canali_da_regolare_old  = preamplifier_canali_da_regolare ; //serve per la funzione sotto
    //   -determinare i nuovi parametri di offset
            
            vettore_istruzioni[0]=0;vettore_istruzioni[1]=0;
            vettore_istruzioni[2]=istruzione_old[2];vettore_istruzioni[3]=0;
            if(vettore_istruzioni[2] ==0) vettore_istruzioni[2]=istruzione_old[2];
            if(vettore_istruzioni[2]==0) vettore_istruzioni[2]=10;
            vettore_istruzioni[4]=istruzione_old[3];
            if(vettore_istruzioni[4]==0) vettore_istruzioni[4]=10;
            vettore_istruzioni[5]=istruzione_old[4];
            if(vettore_istruzioni[5]==0) vettore_istruzioni[5] =50;
            vettore_istruzioni[6]=istruzione_old[6];
            vettore_istruzioni[7]= instr_output_offset_to_be_set;
            instr_output_offset_to_be_set_function();  //Lanciamo la funzione di aggiustamento offset, che alla fine imposter\'a i guadagni corretti finali
            for (iii =0; iii < 7;iii++){//Ritorniamo all'istruzione originaria
                    vettore_istruzioni[iii] = istruzione_old[iii];
            }
 
    }else{
                ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
        //Cambiamo il guadagno al nuovo valore, caso in cui non ci preoccupiamo dell'offset
        for(canale_=0; canale_<6;canale_++){
            if( ( preamplifier_canali_da_regolare >> canale_) &1 ){
            //   -cambiare il guadagno
                PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale_,  PGA_gain_to_set  ) ;
            }
        }
}
 
    Error_imposta_la_istruzione();
}
//! <!-- [fun_instr_PGA_gain_set_function] -->
 
/*!  \brief PGA input stage gain set 
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_PGA_set_reset_pre_PGA_gain_function
*/
//! <!-- [fun_instr_PGA_set_reset_pre_PGA_gain_function] -->
void instr_PGA_set_reset_pre_PGA_gain_function(void){
    uint8_t canale_, canale= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    uint8_t scheda_su_scheda_giu= (canale >> 7) & 1;    
    uint8_t PGA_gain_da_impostare= vettore_istruzioni[istruzione_byte_2];
    uint8_t offset_maintained= vettore_istruzioni[istruzione_byte_3];
    //ATTENZIONE: se offset_maintained allora bisogna:
    //   -leggere l'offset prima di cambiare
    //   -determinare i nuovi parametri di offset
    //   -cambiare il guadagno 
            ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori 
    uint8_t set_2_reset_1_idle_0=1;
    if (PGA_gain_da_impostare){
        set_2_reset_1_idle_0=2;
    }
    for(canale_=0; canale_<6;canale_++){
        if ((canale>> canale_) & 1) {
            PGA_set_reset_pre_PGA_gain ( scheda_su_scheda_giu,  canale_,  set_2_reset_1_idle_0  );
        }
    }
        Error_imposta_la_istruzione();
}
//! <!-- [fun_instr_PGA_set_reset_pre_PGA_gain_function] -->
 
 
void instr_PGA_DAC_GAIN_CROSS_function(void){
    uint8_t canale_, canale= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    uint8_t scheda_su_scheda_giu= (canale >> 7) & 1;    
    uint8_t PGA_gain_da_impostare= vettore_istruzioni[istruzione_byte_2];
    uint8_t PGA_offset_maintained= vettore_istruzioni[istruzione_byte_3];
    //ATTENZIONE: se PGA_offset_maintained allora bisogna:
    //   -leggere l'offset prima di cambiare
    //   -determinare i nuovi parametri di offset
    //   -cambiare il guadagno
            ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori 
    for(canale_=0; canale_<6;canale_++){
        if ((canale>> canale_) & 1) {
            PGA_DAC_GAIN_CROSS( scheda_su_scheda_giu,   canale_,  PGA_gain_da_impostare,  PGA_set_pre_pga_low_gain);
        }
    }   
        Error_imposta_la_istruzione();  
}
 
 
/*!  \brief Routing of available node voltage to outout by means of the analog mux 
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instr_connect_disconnect_mux_node_function
*/
//! <!-- [fun_instr_connect_disconnect_mux_node_function] -->
void instr_connect_disconnect_mux_node_function(void){
    
                ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
Analog_mux_line_to_select_deselect ( vettore_istruzioni[4], vettore_istruzioni[5], vettore_istruzioni[6] );
 
if (vettore_istruzioni[6]==0){
        tx_data[5]=0;
   }    
        Error_imposta_la_istruzione();
}
//! <!-- [fun_instr_connect_disconnect_mux_node_function] -->
 
 
//FINE CROSS
 
 
 /*! \brief ADC instrunction implementation with node selection
 
This instruction needs to know which node to read. The node to read is 
at byte #istruzione_byte_4_e_scelta_canale of the CAN message.
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
 
*\snippetlineno Istruzioni.c fun_istruzione_lettura_ADC
*/
//! <!-- [fun_istruzione_lettura_ADC] -->
 void instruction_lettura_ADC(void){
    int misura;
     char sottoistruzione = vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
     //! <!-- [cod_parte_finale_ADC] -->    
 
//      misura = lettura_ADC(  sottoistruzione);
 
     *(unsigned int *) &tx_data[byte_istr_dati_0] =  correzione_misura_ADC(coeffcienti_misura_ADC_nodi[sottoistruzione], misura);
     //! <!-- [cod_parte_finale_ADC] -->    
 }
 //! <!-- [fun_istruzione_lettura_ADC] -->
 
 
  /*! \brief This is a sub-function of the ADC instrunction. It is useful as it cane be used in other 
 part of the program such as detector bias setting and offset adjustement.
 
*\param[in] sottoistruzione is the selctring node according to the list at \ref ADC_Mux_page
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
 
*\snippetlineno Istruzioni.c fun_lettura_ADC
*/
//! <!-- [fun_lettura_ADC] -->
// int lettura_ADC( char sottoistruzione){
//   char ii;
////     ATTIVA_CHIP_SELECTOR_MULTIPLEXER( (sottoistruzione >> 4) & 0x7); //the 4 MSb select the mux
////     Line_select_in_the_mux(  sottoistruzione & 0xF); //The 4 LSb select te mux line
//   Aspetta_tanti_ms(wait_for_ADC_setting); //Wait for nodes stabilization
//  risultato=0;
//   for( ii=0; ii <(1 <<  medie_ADC); ii++){    
//   risultato += ADC_lettura_24bit(0,0,2); //Measurement is taken
//   }
//   risultato=risultato>>medie_ADC;
 
////     Stampa_risultato_sul_CAN(risultato); //The result is composed in the CAN message, 4 MSB.
////     ATTIVA_CHIP_SELECTOR_MULTIPLEXER( 0);  //Disable all mux's
//   return risultato;   
// }
//! <!-- [fun_lettura_ADC] -->
 
 
  /*! \brief We manage the relais which take care of the deetector performances. The relay for the pre PGA 
gain x1 - x10 is managed here, too. 
 
This instruction needs to know the gain to set and the channel to apply the setting. These informztion is
at byte #istruzione_byte_4_e_scelta_canale of the CAN message.
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
 
*\snippetlineno Istruzioni.c fun_instruction_Detector_PGA_Rele
*/
//! <!-- [fun_instruction_Detector_PGA_Rele] -->
 void instruction_Detector_PGA_Rele(void){
     uint8_t canale_;
     for( canale_=0; canale_<6; canale_++){
     PGA_set_reset_pre_PGA_gain ( scheda_su_scheda_giu,  canale_,  PGA_set_pre_pga_low_gain  ) ;
     }
 }
 
 void Detector_PGA_Rele( char discriminazione){
         char chan=0, action=0;
     porta_pin_def PGA_pre_gain;
     if (discriminazione>=0x10) chan=1;
     action= discriminazione & 0x0F;
     if (action>=8){
         //Pga pre gain set to 1 V/V or to 10 V/V
         if (action ==8){
             //pga pre gain =1
             if (chan){
                 PGA_pre_gain=PGA_pre_gain_1_ch1;
             }else{
                 PGA_pre_gain=PGA_pre_gain_1_ch0;
             }
         }else{
             //pga pre gain =10
             if (chan){
                 PGA_pre_gain=PGA_pre_gain_10_ch1;
             }else{
                 PGA_pre_gain=PGA_pre_gain_10_ch0;
             }           
         }
            GPIO_PinWrite(PGA_pre_gain.porta_num, PGA_pre_gain.pin_num, 1);                     // Viene attivato il PGA_rele_cho_1
            Aspetta_tanti_ms(wait_time_for_rele_setting);
            GPIO_PinWrite(PGA_pre_gain.porta_num, PGA_pre_gain.pin_num, 0);                     // Viene disattivato il PGA_rele_cho_1 
            Aspetta_tanti_ms(wait_time_for_rele_setting);        
     }else {
         // Working with detector relays
         Funzione_per_attivare( chan, (1 << action));
     }
 }
//! <!-- [fun_instruction_Detector_PGA_Rele] -->
 
 
 
/*!  \brief Some usefull parematers can be set here.
 
The list of parameters is the enum ***DA AGGIUNGERE***
This instruction needs to know which parameter to set 
at byte #istruzione_byte_4_e_scelta_canale and the parameter value 
at bytes #byte_istr_dati_0 and #byte_istr_dati_1 of the CAN message.
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instruction_Some_parameters_to_set
*/
//! <!-- [fun_instruction_Some_parameters_to_set] -->
void instruction_Some_parameters_to_set(void){
    //The second byte from the CAN says which paremetr to set
    //The last byt from the CAN says which value to set
    char ii, canale;
enum R_W_Parameters {
 read_write_value_for_wait_for_ADC_setting                  ,       //!< NOP, in future release the fw version will be replayed     
 read_write_medie_ADC,  
 read_PGA_Gain_code,
 read_PGA_Gain_V_su_V,
 read_write_guadagno_minimo_PGA,
 read_write_massimo_guadagno_impostabile,
 read_write_Trimmer_offset_preampli,
 read_write_Trimmer_thermal_preampli,
 read_write_Trimmer_detector_bias_positive,
 read_write_Trimmer_detector_bias_negative,
 read_write_Trimmer_drift_in_micro_su_C,
 read_write_Trimmer_common_mode
}  ;    
    //Da aggiungere: 
 
    char sottoistruzione = vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    for(ii =0;ii<2;ii++){
        if( (sottoistruzione >> ii) && 1) canale=ii;
    }
 
    switch (vettore_istruzioni[istruzione_byte_2])
    {
        case read_write_value_for_wait_for_ADC_setting:
            {
                if( vettore_istruzioni[istruzione_byte_3]){
                wait_for_ADC_setting= (vettore_istruzioni[byte_istr_dati_1] <<8) + vettore_istruzioni[byte_istr_dati_0];
                //MAximu time is 10 sec: time from the mux and ADC setting and the measurement
                //Default is 100 ms
                if (wait_for_ADC_setting >10000) wait_for_ADC_setting=10000;
                }
                tx_data[0]= wait_for_ADC_setting &0xFF;
                tx_data[1]= (wait_for_ADC_setting >>8 ) & 0xFF;
                return;
            }
        case read_write_medie_ADC:
        {
                if( vettore_istruzioni[istruzione_byte_3]){
                medie_ADC=  vettore_istruzioni[byte_istr_dati_0];
                //Default is 2: take care the number of averages is (1 << medie_ADC), or 2^medie_ADC
                }
                tx_data[0]= medie_ADC &0xFF;            
            return;
        }
        case read_PGA_Gain_code:  //Read only
            {
                tx_data[0]= PGA_Gain_code[canale] & 0xFF;
                tx_data[1]= (PGA_Gain_code[canale] >>8 ) & 0xFF;    
                return;
            }
        case read_PGA_Gain_V_su_V:
        {
                tx_data[0]= PGA_Gain_V_su_V[canale] & 0xFF;     
        return;
        }
        case read_write_guadagno_minimo_PGA:
        {
                if( vettore_istruzioni[istruzione_byte_3]){
                guadagno_minimo_PGA=  vettore_istruzioni[byte_istr_dati_0];
                //Default is 4:
                }
                tx_data[0]= guadagno_minimo_PGA &0xFF;          
            return;         
        }
        case read_write_massimo_guadagno_impostabile:
        {
                if( vettore_istruzioni[istruzione_byte_3]){
                massimo_guadagno_impostabile=  vettore_istruzioni[byte_istr_dati_0];
                //Default is 100:
                }
                tx_data[0]= massimo_guadagno_impostabile &0xFF;         
            return;         
        }
        case read_write_Trimmer_offset_preampli:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                Trimmer_offset_preampli[canale].coarse_offset= vettore_istruzioni[byte_istr_dati_1];
                Trimmer_offset_preampli[canale].fine_offset = vettore_istruzioni[byte_istr_dati_0];
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);                                      
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);                 
            }
                tx_data[0]= Trimmer_offset_preampli[canale].fine_offset & 0xFF;
                tx_data[1]= Trimmer_offset_preampli[canale].coarse_offset & 0xFF;       
            return;
        }
        case read_write_Trimmer_thermal_preampli:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                Trimmer_offset_preampli[canale].coarse_thermal= vettore_istruzioni[byte_istr_dati_1];
                Trimmer_offset_preampli[canale].JFET_Offset = vettore_istruzioni[byte_istr_dati_0];
//              Trimmer_offset_preampli[canale].fine_thermal = vettore_istruzioni[byte_istr_dati_0];
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_coarse_thermal_trimmer , Trimmer_offset_preampli[canale].coarse_thermal);                                      
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer , Trimmer_offset_preampli[canale].JFET_Offset);
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_thermal_trimmer, Trimmer_offset_preampli[canale].fine_thermal);                   
            }
//              tx_data[0]= Trimmer_offset_preampli[canale].fine_thermal & 0xFF;
                tx_data[1]= Trimmer_offset_preampli[canale].coarse_thermal & 0xFF;  
                tx_data[0]= Trimmer_offset_preampli[canale].JFET_Offset & 0xFF;
            return;
        }   
        case read_write_Trimmer_detector_bias_positive:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                detector_Trimmer_bias[canale].fine_pos= vettore_istruzioni[byte_istr_dati_0];
                detector_Trimmer_bias[canale].coarse_pos = vettore_istruzioni[byte_istr_dati_1];
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_pos, detector_Trimmer_bias[canale].coarse_pos);                                     
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_pos, detector_Trimmer_bias[canale].fine_pos);                 
            }
                tx_data[0]= detector_Trimmer_bias[canale].fine_pos & 0xFF;
                tx_data[1]= detector_Trimmer_bias[canale].coarse_pos & 0xFF;            
            return;
        }
        case read_write_Trimmer_detector_bias_negative:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                detector_Trimmer_bias[canale].fine_neg= vettore_istruzioni[byte_istr_dati_0];
                detector_Trimmer_bias[canale].coarse_neg = vettore_istruzioni[byte_istr_dati_1];
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_neg, detector_Trimmer_bias[canale].coarse_neg);                                     
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_neg, detector_Trimmer_bias[canale].fine_neg);                 
            }
                tx_data[0]= detector_Trimmer_bias[canale].fine_neg & 0xFF;
                tx_data[1]= detector_Trimmer_bias[canale].coarse_neg & 0xFF;                
            return;
        }
        case read_write_Trimmer_drift_in_micro_su_C:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                reference_thermal_drift_actual= vettore_istruzioni[byte_istr_dati_0];           
            }
        case read_write_Trimmer_common_mode:
        {//Lettura/scrittura del trimmer per aggiustare il CMRR
            if( vettore_istruzioni[istruzione_byte_3]){
                Trimmer_CMRR_JFET_COLD.CMRR[canale]=vettore_istruzioni[byte_istr_dati_0];
                Imposta_trimmer_common_mode_I2CB  ( Trimmer_numero_offset + canale, Trimmer_CMRR_JFET_COLD.CMRR[canale]);                   
            }
                tx_data[0]= Trimmer_CMRR_JFET_COLD.CMRR[canale] & 0xFF;
                tx_data[1]= 0;              
            return;         
        }           
        }
    }
}
//! <!-- [fun_instruction_Some_parameters_to_set] -->
 
 
/*!  \brief The temperature from both preamplifier is read
 
The temperature ios read for both the preamplifiers and written
in the first 4 bytes, the first 2 for ch0 and the second pair for ch1
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instruction_Misura_della_temperatura
*/
//! <!-- [fun_instruction_Misura_della_temperatura] -->
void instruction_Misura_della_temperatura(void){
    //TERMOMETRO del canale 0
        int misura_temperatura_locale[2];
        int32_t risultato;  
        Misura_della_temperatura(misura_temperatura_locale);
//  uint8_t ii, addr[2] ={ 0x4A, 0x49};             // 100 1010     //L'INDIRIZZO????????   
//  uint8_t dati_scrittura[2], dati_scrittura_aa[]={4,0x60},dati_scrittura_bb[]={0};
//  int misura_temperatura_locale[2];
//  int32_t risultato;
//  for(ii=0;ii<2;ii++){
//      I2CAdrv ->MasterTransmit (addr[ii], dati_scrittura_aa, 2, false); //Massima risoluzione 14 bit
//      while (I2CAdrv->GetStatus().busy);
//      
//      I2CAdrv ->MasterTransmit (addr[ii], dati_scrittura_bb, 1, false); //Leggiamo T
//      while (I2CAdrv->GetStatus().busy);
//      
//      I2CAdrv->MasterReceive (addr[ii], dati_scrittura, 2, false);
//      while (I2CAdrv->GetStatus().busy);
 
//      misura_temperatura_locale[ii] =( (dati_scrittura[0]<<8) + (dati_scrittura[1]) )>>2; //14 bit di risoluzione
//      misura_temperatura_locale[ii] = ((misura_temperatura_locale[ii]*1000)) >> 5 ;//moltiplichiamo per 0.03135
//                                              // ovvero dividiamo per 32//we have 0.25 or 1/4 C/bit
//                                              //The temperature is im mK
//  }
    
    
    risultato= (misura_temperatura_locale[0] & 0xFFFF) + ((misura_temperatura_locale[1] & 0xFFFF)<<16);
//  misura_temperatura=misura_temperatura-1500;
    *(unsigned int *) &tx_data[byte_istr_dati_0] = risultato;
//  Stampa_risultato_sul_CAN(misura_temperatura);       
return;
}   
//! <!-- [fun_instruction_Misura_della_temperatura] -->
 
void Misura_della_temperatura(int *misura_temperatura_locale){  //Misura in mK
    uint8_t ii, addr[2] ={ 0x4A, 0x49};             // 100 1010     //L'INDIRIZZO????????   
    uint8_t dati_scrittura[2], dati_scrittura_aa[]={4,0x60},dati_scrittura_bb[]={0};
//  int misura_temperatura_locale[2];
//  int32_t risultato;
    for(ii=0;ii<2;ii++){
        I2CAdrv ->MasterTransmit (addr[ii], dati_scrittura_aa, 2, false); //Massima risoluzione 14 bit
        while (I2CAdrv->GetStatus().busy);
        
        I2CAdrv ->MasterTransmit (addr[ii], dati_scrittura_bb, 1, false); //Leggiamo T
        while (I2CAdrv->GetStatus().busy);
        
        I2CAdrv->MasterReceive (addr[ii], dati_scrittura, 2, false);
        while (I2CAdrv->GetStatus().busy);
 
        misura_temperatura_locale[ii] =( (dati_scrittura[0]<<8) + (dati_scrittura[1]) )>>2; //14 bit di risoluzione
        misura_temperatura_locale[ii] = ((misura_temperatura_locale[ii]*1000)) >> 5 ;//moltiplichiamo per 0.03135
                                                // ovvero dividiamo per 32//we have 0.25 or 1/4 C/bit
                                                //The temperature is im mK
    }
    
}
 
 /*****************************************************************************
    Controllo alimentazione
 ******************************************************************************/
//void instruction_Power_supply_control(void){
//  if( vettore_istruzioni[istruzione_byte_4_e_scelta_canale] ){
//      //Accensione
//      Accensione_delle_alimentazioni_analogiche();
//  }else{
//      //Spegnimento
//      Spegnimento_delle_alimentazioni_analogiche();
//  }
//  tx_data[istruzione_byte_4_e_scelta_canale]= vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
//}
 
//void Spegnimento_delle_alimentazioni_analogiche(void)
//{
//  Sleep_ADC();                                                        // Viene spenta l'ADC
//  
//  //Vengono spente Vref pos e Vref neg
//  GPIO_SetDir(1, Shut_Vrefp_Vrefn, GPIO_DIR_OUTPUT);
//  
//  //Vengono spente Vcc e Vee
//  GPIO_SetDir(1, Shut_Vcc_Vee, GPIO_DIR_OUTPUT);                  
//              
//  //Vengono abbassati altri due pin per non lasciare accese le alimentazioni
//  GPIO_PinWrite(2, DIG_5, 0);                 
//  GPIO_PinWrite(2, DIG_3_3, 0);   
 
//  //Vengono abbassati tutti i PIN
//  GPIO_PinWrite(0, Chip_Sel_Adc, 0);                                                  // Viene abbassato il Chip_Sel_Adc
//  GPIO_PinWrite(0, Chip_Sel_rele_0, 0);                                               // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Set_ch0, 0);                                                               // Impostando il set a 0 vengono abbassati tutti gli interruttori
//  GPIO_PinWrite(1, Reset_ch0 ,0);                                                         // Viene impostato il Reset a 0
////    GPIO_PinWrite(0, Chip_Sel_rele_1, 0);                                               // Viene abbassato il Chip Sel rele del canale 1
//  GPIO_PinWrite(1, Set_ch1, 0);                                                               // Impostando il set a 0 vengono abbassati tutti gli interruttori
//  GPIO_PinWrite(1, Reset_ch1 ,0);                                                         // Viene impostato il Reset a 0
//  GPIO_PinWrite(0, PGA_Chip_Sel_DAC_ch0, 0);                                  // Viene abbassato il Chip Sel del DAC del canale 0
//  GPIO_PinWrite(0, PGA_Chip_Sel_DAC_ch1, 0);                                  // Viene abbassato il Chip Sel del DAC del canale 1         
//  GPIO_PinWrite(1, PGA_rele_ch0_1, 0);                                                // Viene abbassato il Chip Sel rele del canale 1
//  GPIO_PinWrite(1, PGA_rele_ch0_2, 0);                                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, PGA_rele_ch1_1, 0);                                                // Viene abbassato il Chip Sel rele del canale 1
//  GPIO_PinWrite(1, PGA_rele_ch1_2, 0);                                                // Viene abbassato il Chip Sel rele del canale 0
////    GPIO_PinWrite(1, Chip_Sel_Multiplexer_4, 0);                                // Viene abbassato il Chip Sel rele del canale 0
////    GPIO_PinWrite(1, Chip_Sel_Multiplexer_3, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Chip_Sel_Multiplexer_2, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Chip_Sel_Multiplexer_1, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Sel_Par_Interruttori_3, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Sel_Par_Interruttori_2, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Sel_Par_Interruttori_1, 0);                                // Viene abbassato il Chip Sel rele del canale 0
 
//  SPIdrv->Uninitialize();                                                                         // Viene disinizializzata l'SPI
//  I2CAdrv->Uninitialize();                                                                        // Viene disinizializzata l'I2CA
//  I2CBdrv->Uninitialize();                                                                        // Viene disinizializzata l'I2CB
//  I2C_termometro_drv->Uninitialize();                                                 // Viene disinizializzata l'I2C_termometro  
//return;
//}     
 
//void Accensione_delle_alimentazioni_analogiche(void)
//{
//  ADC_Wakeup();
//  
//  //Vengono accese Vref pos e Vref neg
//  GPIO_SetDir(1, Shut_Vrefp_Vrefn, GPIO_DIR_INPUT);   
//  
//  //Vengono accese Vcc e Vee
//  GPIO_SetDir(1, Shut_Vcc_Vee, GPIO_DIR_INPUT);   
 
//  //Vengono alzati gli altri due pin per non lasciare spente le alimentazioni
//  GPIO_PinWrite(2, DIG_5, 1); 
//  GPIO_PinWrite(2, DIG_3_3, 1);       
//                  
//  //Vengono reimpostati tutti i PIN                   
//  GPIO_PinWrite(0, Chip_Sel_Adc, 1);                                                  // Viene abbassato il Chip_Sel_Adc
//  GPIO_PinWrite(0, Chip_Sel_rele_0, 1);                                               // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Set_ch0, 1);                                                               // Impostando il set a 0 vengono abbassati tutti gli interruttori
//  GPIO_PinWrite(1, Reset_ch0 ,1);                                                         // Viene impostato il Reset a 0
////    GPIO_PinWrite(0, Chip_Sel_rele_1, 1);                                               // Viene abbassato il Chip Sel rele del canale 1
//  GPIO_PinWrite(1, Set_ch1, 1);                                                               // Impostando il set a 0 vengono abbassati tutti gli interruttori
//  GPIO_PinWrite(1, Reset_ch1 ,1);                                                         // Viene impostato il Reset a 0
//  GPIO_PinWrite(0, PGA_Chip_Sel_DAC_ch0, 1);                                  // Viene abbassato il Chip Sel del DAC del canale 0
//  GPIO_PinWrite(0, PGA_Chip_Sel_DAC_ch1, 1);                                  // Viene abbassato il Chip Sel del DAC del canale 1         
//  GPIO_PinWrite(1, PGA_rele_ch0_1, 0);                                                // Viene abbassato il Chip Sel rele del canale 1
//  GPIO_PinWrite(1, PGA_rele_ch0_2, 0);                                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, PGA_rele_ch1_1, 0);                                                // Viene abbassato il Chip Sel rele del canale 1
//  GPIO_PinWrite(1, PGA_rele_ch1_2, 0);                                                // Viene abbassato il Chip Sel rele del canale 0
////    GPIO_PinWrite(1, Chip_Sel_Multiplexer_4, 0);                                // Viene abbassato il Chip Sel rele del canale 0
////    GPIO_PinWrite(1, Chip_Sel_Multiplexer_3, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Chip_Sel_Multiplexer_2, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Chip_Sel_Multiplexer_1, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Sel_Par_Interruttori_3, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Sel_Par_Interruttori_2, 0);                                // Viene abbassato il Chip Sel rele del canale 0
//  GPIO_PinWrite(1, Sel_Par_Interruttori_1, 0);                                // Viene abbassato il Chip Sel rele del canale 0        
 
 
//  SPI_Inizialize();                                                               // Vengono riinizializzate le Periferiche               
//  I2C_1_Initialize();             
//  I2C_0_Initialize();             
////    I2C_termometro_Initialize();            //Questa non serve???????????????????????????????????                       
//return;
//}     
 
 
 
/*!  \brief Output offset voltage compensation
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Istruzioni.c fun_instruction_Offset_compensation
*/
//! <!-- [fun_instruction_Offset_compensation] -->
 void instruction_Offset_compensation(void){
    #define offset_PGA_1_or_pre_0_out 7  /* This is at byte istruzione_byte_1 */
    #define offset_different_between_ch 6  /* This is at byte istruzione_byte_1 */   
    #define offset_drift_adjusted_on_offset 5  /* This is at byte istruzione_byte_1 */  
     #define attivazione_CMRR  2   /*if 1 the CMRR is inactive at half scale, if 0 the CMRR is loaded from EPROM and set in the trimmer*/
    #define JFET_offset_used_0_not_used_1  1  /* If 1 the JFET offset from EPROM is not used as default*/
    #define JFET_offset_measured_and_stored_in_EPROM 0 /* If 1 the JFET offset is measured and store in EPROM*/
    
     
     
    //Definizioni delle varibaili di stato
    #define stato_esci_dalla_misura (int)(-1 )
    #define stato_compensazione_termica_su_zero_offset 0
    #define stato_compensazione_in_temperatura_sull_0ffset_secondo_passo 1 
    #define stato_compensazione_in_temperatura_sull_0ffset 2 
    #define stato_senza_compensazione_in_temperatura 3 
    #define  stato_misurare_parametro_per_EPROM_terzo_passo 4
    #define stato_misurare_parametro_per_EPROM_secondo_passo 5
    #define stato_misurare_parametro_per_EPROM 6
//struct trimmer_type /*{
//  unsigned char fine_thermal;
//  unsigned char fine_offset;
//  unsigned char coarse_thermal;  
//  unsigned char coarse_offset;
//}*/   Trimmer_offset_preampli[2];
//  int16_t Valori_per_i_trimmer[2];                    // Qui verranno inseriti i valori per i trimmer
    char canale;
     signed char stato_della_misura;
     unsigned char dati_letti[4],buffer_vettore_istruzioni_istruzione_byte_0=vettore_istruzioni[istruzione_byte_0];
    unsigned short errore, errore_temperatura, indirizzo_da_usare;
    char gain_da_moltiplicare;
    long int offset, discrepanza[2];
    int tolleranza=vettore_istruzioni[istruzione_byte_3]*1000; //in microV
    int attesa, misura_finale[2];
//  char nodo_di_misura_1[]={ADC_ADC_PGA_neg_in_ch0, ADC_ADC_PGA_neg_in_ch1};
//  char nodo_di_misura_2[]={ADC_ADC_PGA_pos_in_ch0, ADC_ADC_PGA_pos_in_ch1};
    char ii, nodo_di_misura_1[]={ADC_ADC_PGA_neg_out_ch0, ADC_ADC_PGA_neg_out_ch1};
    char nodo_di_misura_2[]={ADC_ADC_PGA_pos_out_ch0, ADC_ADC_PGA_pos_out_ch1};
    char chi_aggiustiamo = vettore_istruzioni[istruzione_byte_4_e_scelta_canale] & 0x3;
//  bool errore_canale[]={false,false}, errore_totale=false, saturazione_canale[]={false,false};
    bool saturazione_canale[]={false,false};
    int temperatura[2];
    int coarse_trimmer_step[] = {coarse_Trimmer_offset_step_actual[0] * guadagno_minimo_PGA, coarse_Trimmer_offset_step_actual[1] * guadagno_minimo_PGA} ; //********************************************* coarse_Trimmer_offset_step_actual
    int fine_trimmer_step[] ={ fine_Trimmer_offset_step_actual[0] * guadagno_minimo_PGA,fine_Trimmer_offset_step_actual[1] * guadagno_minimo_PGA} ;     //*********************************************
//   char nodo_di_misura[]={ADC_ADC_PGA_pos_out_ch0, ADC_ADC_PGA_pos_out_ch1};
    
    //Impostiamo il trimmer del CMRR
    if( (vettore_istruzioni[istruzione_byte_1]  >> attivazione_CMRR ) & 1 ){
            attiva_il_CMRR(  chi_aggiustiamo /*1 per canale 0, 2 per canale 1, 3 per entrambi i canali*/,0);
    }else{
            attiva_il_CMRR(  chi_aggiustiamo /*1 per canale 0, 2 per canale 1, 3 per entrambi i canali*/,1);
    }
 
    if ( (tolleranza << 1)  < (fine_trimmer_step[0]+fine_trimmer_step[1])) tolleranza = (fine_trimmer_step[0]+fine_trimmer_step[1]) >> 1;
//  int valore_target_per_ch[canale] =1000*(signed short)( vettore_istruzioni[byte_istr_dati_0] & 0xFF + ( (signed char)(0xFF & vettore_istruzioni[byte_istr_dati_1])*(1<<8) ));
    
        if( (vettore_istruzioni[istruzione_byte_1] >> offset_PGA_1_or_pre_0_out) &1){
        //Offset at Pre output
        nodo_di_misura_1[0]=ADC_ADC_PGA_neg_in_ch0;
        nodo_di_misura_1[1]= ADC_ADC_PGA_neg_in_ch1;
        nodo_di_misura_2[0]=ADC_ADC_PGA_pos_in_ch0;
        nodo_di_misura_2[1]=ADC_ADC_PGA_pos_in_ch1;
      coarse_trimmer_step[0] = coarse_Trimmer_offset_step_actual[0]  ;
      fine_trimmer_step[1] = coarse_Trimmer_offset_step_actual[1] ;     
         gain_da_moltiplicare= 1;
    }else{
         gain_da_moltiplicare= guadagno_minimo_PGA;
    }
    
if( (vettore_istruzioni[istruzione_byte_1] >> offset_drift_adjusted_on_offset) & 1){
    stato_della_misura=stato_compensazione_in_temperatura_sull_0ffset;  //Si fanno 2 giri perch\'e si vuole aggiustare la deriva con l'offset
    }else{
    stato_della_misura=stato_compensazione_termica_su_zero_offset; //Si fa un solo giro perch\'e si aggiusta la deriva ad offset zero.
}
if ( buffer_vettore_istruzioni_istruzione_byte_0 == 0xff) stato_della_misura=stato_senza_compensazione_in_temperatura;
 
if( (vettore_istruzioni[istruzione_byte_1] >> JFET_offset_measured_and_stored_in_EPROM) & 1) stato_della_misura=stato_misurare_parametro_per_EPROM;
 
for( canale=0;canale<2;canale++){
    if( (chi_aggiustiamo >> canale) & 1){
            if( (vettore_istruzioni[istruzione_byte_1] >> JFET_offset_used_0_not_used_1) & 1) {//Non si usa la EPROM per l'offset del JFET, quindi trimmer a met\'a scala
                        Trimmer_offset_preampli[canale].JFET_Offset=0x80;
            }else{//Usiamo la EPROM             
//                      lettura_EPROM(canale,  Memory_address_JFET_trimmer_offset , dati_letti);
                        Trimmer_offset_preampli[canale].JFET_Offset=dati_letti[0];
                        Trimmer_offset_preampli[canale].coarse_offset=dati_letti[1];
                        Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);
            }
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer, Trimmer_offset_preampli[canale].JFET_Offset); 
        }
}
    
    while (stato_della_misura >=0){
//***********************************************************************************************************   
        //Vediamo che temperatura eventualmente usare e che range adottare
        //Lo facciamo per entrambi i canali anche se poi magari agiremo solo su uno
            if ( buffer_vettore_istruzioni_istruzione_byte_0 <0xff){
                    //Impostaiamo il trimmer per la deriva alla temperatura data o la misuriamo
                            if ( buffer_vettore_istruzioni_istruzione_byte_0==0){
                            Misura_della_temperatura(temperatura);
                            for (ii=0;ii<2;ii++){
                                temperatura[ii]= temperatura[ii]*3;
                                temperatura[ii]= temperatura[ii]/1000; //Normalizziamo a quello memorizzato
                            }}else{
                                temperatura[0]=buffer_vettore_istruzioni_istruzione_byte_0*3;
                                temperatura[1]=temperatura[0];
                            }
                        //Cerchiamo la temperatura pi\'u prossima per l'impostazione del trimer
                        for (canale=0; canale<2;canale++){
                            errore=0xff;
                            for (ii=0; ii< numero_temperature_impostazione_deriva[canale]; ii++){       
                                errore_temperatura= abs( valori_temperature_impostazione_deriva[canale][ii] - temperatura[canale]);
                                if (errore_temperatura < errore){
                                    errore=errore_temperatura;
                                    temperatura_di_lavoro[canale]= ii;
                                }
                            }       
                        }
            }
        //Imposttiamo il trimmer alla deriva a media temperatura
        for (canale=0; canale<2;canale++){
            
            if( stato_della_misura ==0){// Consideriamo l'offset a zero
                if (canale) stato_della_misura=stato_esci_dalla_misura;
                if( (chi_aggiustiamo >> canale) & 1){
                    offset_di_lavoro[canale]= (numero_offset_per_impostazione_deriva[canale] +1 ) >>1 ; //Prendo l'offset a met\'a scala, approssimando all'intero maggiore
//                          indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
//                                              Memory_address_lookup_table_start ;         
//                          lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
                            Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];                    
                }
            }  // fine stato_della_misura=0
            
            if( stato_della_misura ==stato_compensazione_in_temperatura_sull_0ffset_secondo_passo){ //Aggiustiamo con la temperatura accordata anche sulloffset. Veniamo dallo stato 2
                if (canale) stato_della_misura=stato_esci_dalla_misura;
                        if( (chi_aggiustiamo >> canale) & 1){   
                    errore=0xff;
//                  lettura_EPROM( canale,  Memory_address_JFET_trimmer_offset ,  dati_letti);
                    for (ii=0; ii< numero_offset_per_impostazione_deriva[canale]; ii++){        
                        errore_temperatura= abs( valori_offset_per_impostazione_deriva[canale][ii] - (signed char)(Trimmer_offset_preampli[canale].coarse_offset - dati_letti[1] ) ) ;
                        if (errore_temperatura < errore){
                            errore=errore_temperatura;
                            offset_di_lavoro[canale]= ii;
                        }
                    }               
//                                      indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
//                                                          Memory_address_lookup_table_start ;         
//                                      lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
                                        Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
                        }
            } //fine stato_della_misura =stato_compensazione_in_temperatura_sull_0ffset_secondo_passo
            
            if( stato_della_misura ==stato_compensazione_in_temperatura_sull_0ffset){//Vogliamo aggiustare la temperatura sull'offset: primo passaggio , troviamo l'offset
                if (canale) stato_della_misura=stato_compensazione_in_temperatura_sull_0ffset_secondo_passo;
                        if( (chi_aggiustiamo >> canale) & 1){   
                                offset_di_lavoro[canale]= (numero_offset_per_impostazione_deriva[canale] +1 ) >>1 ; //Prendo l'offset a met\'a scala, approssimando all'intero maggiore
                    //Se stato_della_misura =2 devo valutare quale offset abbiamo , prima di impostare la temperatura. Per cui metto il trimmer a met\'a scala
                    Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;                           
                        }
            } //fine stato_della_misura =stato_compensazione_in_temperatura_sull_0ffset
            
        if( stato_della_misura ==stato_senza_compensazione_in_temperatura){//Aggiustiamo senza compensazione in temperatura
                if (canale) stato_della_misura=stato_esci_dalla_misura;
                        if( (chi_aggiustiamo >> canale) & 1){   
                    Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;                           
                        }
            } //fine stato_della_misura =stato_senza_compensazione_in_temperatura
        
        
            if( stato_della_misura ==stato_misurare_parametro_per_EPROM_secondo_passo){//Secondo passo per offset in EPROM: metto il dato eprom in trimmer e l'offset in eprom
                if (canale) stato_della_misura=stato_misurare_parametro_per_EPROM_terzo_passo; //Lo stato 4 \'ein fondo perch\'e serve solo per memorizzare l'offset nella eprom
                        if( (chi_aggiustiamo >> canale) & 1){   
                            Trimmer_offset_preampli[canale].JFET_Offset=0x80 +\
                            (( (128 - Trimmer_offset_preampli[canale].coarse_offset) * JFET_offset_conversione) >> 7) ;
                            Trimmer_offset_preampli[canale].coarse_offset=0x80;
                            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer, Trimmer_offset_preampli[canale].JFET_Offset); 
                        }
            } //fine stato_della_misura =stato_misurare_parametro_per_EPROM_secondo_passo
    
            if( stato_della_misura ==stato_misurare_parametro_per_EPROM){//Primo passo per offset in EPROM: misuro a offset 0 con ERPOM a met\'a scala
                if (canale) stato_della_misura=stato_misurare_parametro_per_EPROM_secondo_passo;
                    if( (chi_aggiustiamo >> canale) & 1){
                        Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;   
                        Trimmer_offset_preampli[canale].JFET_Offset=0x80;       
                        Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer, Trimmer_offset_preampli[canale].JFET_Offset); 
                        vettore_istruzioni[byte_istr_dati_0]=0;
                        vettore_istruzioni[byte_istr_dati_1]=0;
                        }
            } //fine stato_della_misura =stato_misurare_parametro_per_EPROM
            
//      if ( buffer_vettore_istruzioni_istruzione_byte_0 <0xff){
//          if ( (stato_della_misura ==0) || (stato_della_misura==2) ){
//              //Se stato della misura =0 vogliamo stare a met\'a con l'offset;
//              //se stato della misura =2 misuriamo a met\'a scala per la temperatura
//              offset_di_lavoro[canale]= (numero_offset_per_impostazione_deriva[canale] +1 ) >>1 ; //Prendo l'offset a met\'a scala, approssimando all'intero maggiore
//              
//              if(stato_della_misura==2){
//                  //Se stato_della_misura =2 devo valutare quale offset abbiamo , prima di impostare la temperatura. Per cui metto il trimmer a met\'a scala
//                  Trimmer_offset_preampli[canale].coarse_thermal    = 0x80;
//              }else{
//                  //Se stato_della_misura \'e zero estraggo dalla memoria il valore da mettere nel trimmer della temperatura
////                            indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
////                                                Memory_address_lookup_table_start ;         
////                            lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
////                            Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
//              }
//              
//              if (canale) stato_della_misura--;
//          }else{//Troviamo la polarizzazione pi\'u vicina
//              
//          errore=0xff;
//          for (ii=0; ii< numero_offset_per_impostazione_deriva[canale]; ii++){        
//              errore_temperatura= abs( valori_offset_per_impostazione_deriva[canale][ii] - Trimmer_offset_preampli[canale].coarse_offset) ;
//              if (errore_temperatura < errore){
//                  errore=errore_temperatura;
//                  offset_di_lavoro[canale]= ii;
//              }
//          }               
//                              indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
//                                                  Memory_address_lookup_table_start ;         
//                              lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
//                              Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
//              if (canale) stato_della_misura = -1;
//          }
////            indirizzo_da_usare=   offset_di_lavoro[canale] * numero_temperature_impostazione_deriva[canale] + temperatura_di_lavoro[canale]+ \
////                                                Memory_address_lookup_table_start ;         
////            lettura_EPROM(canale,  indirizzo_da_usare , dati_letti);
////            Trimmer_offset_preampli[canale].coarse_thermal    = dati_letti[ indirizzo_da_usare & 3];
//      }else{
//          Trimmer_offset_preampli[canale].coarse_thermal=0x80;
//          if (canale) stato_della_misura = -1;
//      }
        if( (chi_aggiustiamo >> canale) & 1){
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_coarse_thermal_trimmer, Trimmer_offset_preampli[canale].coarse_thermal );
//          Trimmer_offset_preampli[canale].fine_thermal=0x80;
//          Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_thermal_trimmer, Trimmer_offset_preampli[canale].fine_thermal);           
            //Ora compensiamo l'offset per il contributo impostato dal trimmer
            Trimmer_offset_preampli[canale].coarse_offset = ((Trimmer_offset_preampli[canale].coarse_offset + Trimmer_offset_preampli[canale].coarse_thermal - 128)*coarse_Trimmer_drift_offset_ratio_by_2e7) >> 7  ;
            if( Trimmer_offset_preampli[canale].coarse_offset > 255) Trimmer_offset_preampli[canale].coarse_offset=255;
            if( Trimmer_offset_preampli[canale].coarse_offset <0) Trimmer_offset_preampli[canale].coarse_offset=0;
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);      
        }
        }
 
        
//***********************************************************************************************************       
    
    if(  ((vettore_istruzioni[istruzione_byte_1] >> offset_different_between_ch) &1)==0 ) {
        //Offset is get from the first 2 bytes of the isntruction, otherwise is already given elsewhere
        vettore_istruzioni[byte_istr_dati_2]=0;
        vettore_istruzioni[byte_istr_dati_3]=0;
        valore_target_per_offset[0] = 1000*( *(signed short *) &vettore_istruzioni[byte_istr_dati_0]);
        valore_target_per_offset[1]=valore_target_per_offset[0];
    }
    int valore_target_per_ch[]={(valore_target_per_offset[0] *(int)gain_da_moltiplicare )/ (int)PGA_Gain_V_su_V[0], (valore_target_per_offset[1] *(int)gain_da_moltiplicare)/ (int)PGA_Gain_V_su_V[1]};
    attesa= vettore_istruzioni[istruzione_byte_2]*100;
    if (attesa == 0) attesa=1000;   
    if( attesa > 10000) attesa =10000;
    
    //Set the PGA Gain to 1 and retain the actual
    char PGA_Gain_V_su_V_old[]={PGA_Gain_V_su_V[0], PGA_Gain_V_su_V[1]};  //*********************************************
    PGA_GAIN_set(3, 1);
    
    Aspetta_tanti_ms(attesa);
     
    for( canale=0;canale<2;canale++){
        if( (chi_aggiustiamo >> canale) & 1){
//  offset=lettura_ADC( nodo_di_misura_1[canale]) ; //Il <<1 \'e per renderlo differenziale
    risultato=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
    if ( (risultato >= saturazione_positiva) || (risultato <= saturazione_negativa) ){
        //Dobbiamo iniziare con SAR
        saturazione_canale[canale]=true;
                }
            }
        }
    
aggiustamento_SAR(saturazione_canale, attesa, nodo_di_misura_1); // Effettivo solo se saturazione_canale \'e true
 
//  Aspetta_tanti_ms(attesa);
//LEGGO L'USCITA Neg
    for( canale=0;canale<2;canale++){
        if( (chi_aggiustiamo >> canale) & 1){
//  offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
    offset=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
    discrepanza[canale] = offset - valore_target_per_ch[canale] ;
 
//HO L'OFFSET       
            
    Trova_valori_trimmer_per_offset_preamplificatore(discrepanza[canale], &Trimmer_offset_preampli[canale], coarse_trimmer_step[canale], fine_trimmer_step[canale]);        
    
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);                                      
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);                                     
        }
    }
    Aspetta_tanti_ms(attesa);           
    
 
// offset_Adjust_core( chi_aggiustiamo, valore_target_per_ch, nodo_di_misura_1, nodo_di_misura_2, \
//                                                                   tolleranza,  coarse_trimmer_step,  fine_trimmer_step,   attesa, misura_finale);    
 
//  Abbassa_chip_selector_multiplexer();
    
    PGA_Gain_V_su_V[0]=PGA_Gain_V_su_V_old[0];  //*********************************************
    PGA_Gain_V_su_V[1]=PGA_Gain_V_su_V_old[1];
    PGA_GAIN_set(1, PGA_Gain_V_su_V[0]);
    PGA_GAIN_set(2, PGA_Gain_V_su_V[1]);
    
        for( canale=0;canale<2;canale++){
        if( (chi_aggiustiamo >> canale) & 1){   
//          int offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
            offset=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset) * (int)guadagno_minimo_PGA / (int)PGA_Gain_V_su_V[canale] ;
            int correzione =  (  misura_finale[canale]  - offset )  / (( (fine_trimmer_step[0]+fine_trimmer_step[1])>>1) ) ; 
            Trimmer_offset_preampli[canale].fine_offset= Trimmer_offset_preampli[canale].fine_offset - correzione;
            if (Trimmer_offset_preampli[canale].fine_offset >255) Trimmer_offset_preampli[canale].fine_offset=255;
            if( Trimmer_offset_preampli[canale].fine_offset <0 ) Trimmer_offset_preampli[canale].fine_offset=0;
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);     
        }
    }   
    
    
    Aspetta_tanti_ms(attesa);
    
for(canale=0;canale<2;canale++){    
//      offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
        misura_finale[canale]=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
}
    
misura_finale[0] =(misura_finale[0] / 1000);
tx_data[byte_istr_dati_0] =  (unsigned int)(misura_finale[0]) & 0xFF ;
tx_data[byte_istr_dati_1] =  (( (unsigned int)(misura_finale[0]) ) >> 8 ) & 0xFF ;
misura_finale[1] =(misura_finale[1] / 1000);
tx_data[byte_istr_dati_2] =  (unsigned int)(misura_finale[1]) & 0xFF ;
tx_data[byte_istr_dati_3] =  (( (unsigned int)(misura_finale[1]) ) >> 8 ) & 0xFF ;
        //Set the PGA Gain to 1 and retain the actual
    //PGA gain is restablished
                    if( stato_della_misura ==stato_misurare_parametro_per_EPROM_terzo_passo){////Terzo e ultimo passo per offset in EPROM: metto offset in eprom in trimmer e l'offset in eprom
                        stato_della_misura=stato_esci_dalla_misura;
                        for(canale=0;canale<2;canale++){
                            if( (chi_aggiustiamo >> canale) & 1){   
//                              int dato_da_scrivere=   Trimmer_offset_preampli[canale].JFET_Offset + \
//                                  (Trimmer_offset_preampli[canale].coarse_offset <<8);
//                              scrivi_mem_EPROM(   Memory_address_JFET_trimmer_offset ,  dato_da_scrivere,canale);
                        }
                    }
            } //fine stato_della_misura =4
}
}
//! <!-- [fun_instruction_Offset_compensation] -->
 
/*!  \brief When the preamplifier output is saturated we start with the standard SAR 
 
 
*\param[in] saturazione_canale is boolean ans says which channel is saturated and should be worked
*\param[in] attesa is the waiting time between trimmer settings
*\param[in] nodo_di_misura_1 is the vector of the nodes to be measured with the ADC
*\return   No Parameters.
 
*\snippetlineno Istruzioni.c fun_aggiustamento_SAR
*/
//! <!-- [fun_aggiustamento_SAR] -->
void            aggiustamento_SAR(bool *saturazione_canale, int attesa, char *nodo_di_misura_1){
    char canale;
    for( canale=0;canale<2;canale++){
    if( saturazione_canale[canale]){
            Trimmer_offset_preampli[canale].fine_offset=0x80;
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, 0x80);
            Trimmer_offset_preampli[canale].coarse_offset =0;
            }
        }
    signed char posizione_bit_di_test;
    
    for( posizione_bit_di_test =7; posizione_bit_di_test>=0;posizione_bit_di_test--){
        for( canale=0;canale<2;canale++){
            if( saturazione_canale[canale]){
                    Trimmer_offset_preampli[canale].coarse_offset |=(1 << posizione_bit_di_test) & 0xFF;
                    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);
            }
    }
        if ( saturazione_canale[0] | saturazione_canale[1]){
                Aspetta_tanti_ms(attesa);
        }
            for( canale=0;canale<2;canale++){
            if( saturazione_canale[canale]){
//                  risultato=lettura_ADC( nodo_di_misura_1[canale]) ; //Il <<1 \'e per renderlo differenziale
                    risultato=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], risultato);
                    if ( (risultato >= saturazione_positiva) ){
                        //Ancora troppo poco
                        saturazione_canale[canale]=true;
                    }else{
                        //Vediamo se non sia troppo
                                if( (risultato <= saturazione_negativa) ){
                                    //abbiamo esagerato
                                    Trimmer_offset_preampli[canale].coarse_offset &= ~(1 << posizione_bit_di_test);
                                    saturazione_canale[canale]=true;
                                }else{
                                    //siamo ok
                                    saturazione_canale[canale]=false;
                                }
                    }
            }
        }
}
}
//! <!-- [fun_aggiustamento_SAR] -->
 
 
///*!  \brief This is the core of the adjusting offset. It tryes to get the target voltage knowing the trimmer steps 
 
 
//*\param[in] chi_aggiustiamo which channels to adjust
//*\param[in] valore_target_per_ch the final target voltage in &mu;V
//*\param[in] nodo_di_misura_1 is the vector of the positive output nodes to be measured with the ADC
//*\param[in] nodo_di_misura_2 is the vector of the negative output nodes to be measured with the ADC
//*\param[in] tolleranza is the admitted error in &mu;V
//*\param[in] coarse_trimmer_step is the coarse trimmer step voltage in &mu;V
//*\param[in] fine_trimmer_step is the fine trimmer step voltage in &mu;V
//*\param[in] attesa is the waiting time between trimmer settings in ms
//*\param[out] misura_finale is the vector with the final measurements
//*\return   No Parameters.
 
//*\snippetlineno Istruzioni.c fun_offset_Adjust_core */
//! <!-- [fun_offset_Adjust_core -->
//void offset_Adjust_core(char chi_aggiustiamo, int *valore_target_per_ch, char *nodo_di_misura_1, char *nodo_di_misura_2, \
//                                      int tolleranza, int *coarse_trimmer_step, int *fine_trimmer_step, unsigned int attesa, int *misura_finale){
//  char canale;
//  int offset, discrepanza[2];
//  signed short nn;
//  bool errore_canale[]={false,false}, errore_totale=false;
//  
//  for( canale=0;canale<2;canale++){
//      if( (chi_aggiustiamo >> canale) & 1){   
////            offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
//          risultato=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
//          misura_finale[canale]= risultato;
//          discrepanza[canale] =   risultato - valore_target_per_ch[canale] ;
//          errore_canale[canale]= discrepanza[canale] <= -tolleranza || discrepanza[canale] >= tolleranza;
//          errore_totale |=errore_canale[canale];
//      }
//  }
 
 
//  char massimo_numero_misure=0;
//  while( errore_totale && (massimo_numero_misure <10) )   // Se la |discrepanza[canale]| < tot, viene corretta la tensione con i trimmer
//  {                       
//      massimo_numero_misure++;
//      for( canale=0;canale<2;canale++){
//          if ( errore_canale[canale]){
//          if (abs( discrepanza[canale] ) > coarse_trimmer_step[canale])
//          {
//              nn = discrepanza[canale] / coarse_trimmer_step[canale];                                                                         // Passo trimmer grezzo, ogni passo sono 73 mV
//               Trimmer_offset_preampli[canale].coarse_offset=  Trimmer_offset_preampli[canale].coarse_offset+nn;
//              if ( Trimmer_offset_preampli[canale].coarse_offset >0xff)  Trimmer_offset_preampli[canale].coarse_offset=0xFF;
//              if ( Trimmer_offset_preampli[canale].coarse_offset <0)  Trimmer_offset_preampli[canale].coarse_offset=0;
//          }
//          else
//          {
//              nn = discrepanza[canale] / fine_trimmer_step[canale];                                                                       // Passo trimmer fine, ogni passo sono 0.1 mV
//              Trimmer_offset_preampli[canale].fine_offset= Trimmer_offset_preampli[canale].fine_offset+nn;        
//              if (Trimmer_offset_preampli[canale].fine_offset >0xff){
//                  Trimmer_offset_preampli[canale].fine_offset=0x80;
//                  Trimmer_offset_preampli[canale].coarse_offset ++;
//              }
//              if (Trimmer_offset_preampli[canale].fine_offset <0){
//                  Trimmer_offset_preampli[canale].fine_offset=0x80;
//                  Trimmer_offset_preampli[canale].coarse_offset --;
//              }
//          }
//          
//      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);                                     
//      
//      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);                                      
//                  }
//      }
//          
//      Aspetta_tanti_ms(attesa);       
//      
//      errore_totale=false;
//      for( canale=0;canale<2;canale++){
//          if ( errore_canale[canale]){            
////                    offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
//                  risultato=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);     
//                  misura_finale[canale]= risultato;
//                  discrepanza[canale] = risultato - valore_target_per_ch[canale] ;            // Si itera finch\'e |discrepanza| < tot
//                  errore_canale[canale]= discrepanza[canale] <= -tolleranza || discrepanza[canale] >= tolleranza;
//                  errore_totale |=errore_canale[canale];
//          }
//      }
//  }   
//  
//}
//! <!-- [fun_offset_Adjust_core -->
 
void attiva_il_CMRR( char chi_aggiustiamo /*1 per canale 0, 2 per canale 1, 3 per entrambi i canali*/, char attivare_si_no){
    unsigned char canale, dati_letti[4];
    for( canale=0;canale<2;canale++){
        if( (chi_aggiustiamo >> canale) & 1){   
            if( attivare_si_no) {
//          lettura_EPROM(canale,  Memory_address_CMRR_compensation , dati_letti);
            }else{
                dati_letti[0]=128;
            }
            Trimmer_CMRR_JFET_COLD.CMRR[canale]=dati_letti[0];
            Imposta_trimmer_common_mode_I2CB  ( Trimmer_numero_offset + canale, Trimmer_CMRR_JFET_COLD.CMRR[canale]);   
        }
}
}