inizializzazione.c

Go to the documentation of this file.

 
/// \file
 
#include "tutti_gli_header.h"
 
 
/// \file system_LPC17xx.c
/// \file core_cm3.h
/*!
\page Inizializzazione_ 
*\brief  <span style="color:red;"> <b> System start-up </b> </span>
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref microcontroller
*\arg \ref System_Startup
*\arg \ref Clock_setup
*\arg \ref CAN_speed
*\arg \ref STARTUP_OVER_THE_CAN
 
*\section microcontroller Adopted &micro;-controller 
<hr width="75%" size="10" align="left">
\n The &micro;-controller adopted to manage the board sis a \b LPC1768 from NXP (here its user manual: <a href="./File_pdf/LPC1768_UM10360.pdf" target=_blank><b>LPC1768 UM</b></a>). 
The \b LPC1768 is a 32-bit ARM Cortex-M3.
 
*\section System_Startup System start-up
<hr width="75%" size="10" align="left">
\n At power-up it is very important that the system start properly and we have  
\n the function instr_inizializza_tutto_da_zero_function(). 
This function can be called from remote in order to apply for a system reset.
\n The list of the action done at start-up is evolving; here the actual list: 
- clock setup (SystemCoreClockUpdate());
- fw code determination (#__INT_DATE__) (more on this at \ref date_construction), the fw versione can be determined via CAN bus by the instruction
#instr_NO_operation;
- generation of the pointer to the instruction functions (Setting_of_the_pointer_for_command_parser());
- CAN initialization (CAN_Inizialize());
- SPI initialization (SPI_Inizialize());
- I2C0 and I2C1 initialization (I2C_0_Initialize(), I2C_1_Initialize());
- configure the I2C_mux (Configure_Reset_I2C_mux());
- configure to idle the relay driver of the first stage of the PGA (PGA_set_reset_pre_PGA_gain());
- configure to idle the relay driver of the preamplifier gain; <------------- da fare
- set to off all the chip select pins (I2C_to_Parallel_ini_PCA9554());
- set the PGA gain to 1 V/V (PGA_GAIN_CROSS());
- set the preamplifier gain to high;   <------------------------------------- da fare
- reset all the relay drivers (use of I2C_to_Parallel_set_PCA9554_outputs_values());
- disconnect the detector (use of Relays_driver_set_reset_channel());
- set the detector bias to 0 V (trimmer at half scale, 128) (detector_scrittura_lettura_trimmer_bias());
- set all the preamplifier trimmers at half scale (128) (preamplifier_scrittura_lettura_trimmer()).
 
 
*\section Clock_setup Clock setup
<hr width="75%" size="10" align="left">
The easier way to configure theCPU clock is by the "configuration wizard" that can be managed opening the "system_LPC17xx.c" file. 
The parameters to select is the clock source that, in our case, is suggested to be "Main Oscillator", tyhat is, our \b 12 \b Mz crystal.
Then, 3 parameters are necessary to select. 
\n In case the PLL is used PLL0 must be selected together  with \b MSEL and \n NSEL and \b CCLKSEL according to the following formula:
 
\f$ f_{cpu} = Main Osc \frac {2 MSEL}{NSEL \; CCLKSEL} \f$
 
Note that the frequency at the PLL output, i.e. after \b MSEL and \b NSEL must be between \b 275 \b MHz and \b 550 \b MHz. 
\n As an example: MainOsc = 12 MHz, MSEL=100, NSEL=6 and CCLKSEL=4 gives: 100 MHz.
\n In case PLL is not used it must be unselected and:
 
\f$ f_{cpu} = \frac {Main Osc }{CCLKSEL} \f$ .
 
\note System clock frequency is at #SystemCoreClock
 
 
*\section CAN_speed CAN speed
<hr width="75%" size="10" align="left">
 
\n Can speed is selectable in 2 different locations. Within the "configuration wizard" of the "system_LPC17xx.c" the CAN clock
is configurable as a function of the CPU clock. It seems that the CAN does not operates correctely if this parameter if different than \b 4.
So, unless the reason for this is not clear, it is suggested to leave this parameter to \b 4.
The bit rate, or CAN frequency, is as it follows:
 
\f$ bit \; rate = \frac {CAN Clk}{P \; N} \f$ 
 
where \b P is the prescaler that is determined by the compiler and \b N:
 
\f$ N = 1 + PROP\_SEG + PHASE\_SEG1 + PHASE\_SEG2 \f$ 
 
and these parameters are withn the function CANdrv->SetBitrate() (CAN1_SetBitrate()) located in CAN_LPC17xx.c. 
\n Note that the parameter \b P must results an integer and an error happens and the CAN does not work if this does not result. 
It is suggested to adjust N in such a way \b P results an integer.
\n As an example if the CPU clock is 100 MHz and CAN bit rate must be 125 KHz, from CAN clock = 25 MHz and N=8 (=1+5+1+1) we get P=25. 
If the CPU clock is 12 MHz (no PLL used), and N=8 (=1+5+1+1) it results P=12.
 
*\section STARTUP_OVER_THE_CAN Startup over the CAN bus
<hr width="75%" size="10" align="left">
\n The initialization function, or rest, can be called via CAN bus by the
<a href="file:///D:/ownCloud/Laboratorio/FW_CROSS/FW_CROSS_POSTFRONTEND/html/_instruction_set.html#instr_inizializza_tutto_da_zero_option">instr_inizializza_tutto_da_zero</a>.
\n Take care that the boards respond on a common address at \b 0xAAAAAAA with the own address. 
\n There are 2 way to set the CAN address depending on the value of the postfrontend memory content at address #Memory_postmainboard_CAN_from_hw_switch_1_from_EPROM_0 of the postfronend board. 
If the content of this memory location is read &ge;1 at startup the address is read from the switches \b SW3 on board (only the first 6 switches are active and the address
can be set from 0 to 0x3f (63)). Switch high corresponds to \b 1.
\n if the content of #Memory_postmainboard_CAN_from_hw_switch_1_from_EPROM_0 is 0 the address is read from the memory location #Memory_postmainboard_address_CAN_own_filter of the postfrontend board.
Changing the content of #Memory_postmainboard_CAN_from_hw_switch_1_from_EPROM_0, by <a href=_instruction_set.html#instr_EPROM_read_write_option>instr_EPROM_read_write</a> instrucion, allows to change the address from one modality to the other. This need to re-initialize the board, by the 
<a href=_instruction_set.html#instr_Shut_Down_ON_OFF_option>instr_Shut_Down_ON_OFF</a> instruction.
 
\sa <a href=_instruction_set.html#instr_EPROM_read_write_option>instr_EPROM_read_write</a> and <a href=_instruction_set.html#instr_Shut_Down_ON_OFF_option>instr_Shut_Down_ON_OFF</a> instrucions.
 
*/
/*!  <!-- Commenti per le CMSIS -->
\fn SystemCoreClockUpdate (void) 
\return no parameters
\brief Configuring the clock, frequency, PLL, etc
 
\var SystemCoreClock
\brief The clock frequency
*/
//INIZIO CROSS
 
        int32_t mio_SCS_Val ;
        int32_t mio_CCLKCFG_Val;
        int32_t mio_PCLKSEL0_Val;
        int32_t mio_PCLKSEL1_Val;
        int32_t mio_CLKSRCSEL_Val;
        int32_t mio_PLL0CFG_Val;
        int32_t mio_PLL0_SETUP;
 
 
/*! \brief Start-up function
 
*\return No Parameters
\showrefby
\showrefs
*\snippet{lineno} inizializzazione.c fun_startup
 */
//! <!-- [fun_startup] -->
void instr_inizializza_tutto_da_zero_function(void){
        uint8_t canale_, trimmer_,dati_letti[4];
 
 
    // Configurazione del LED   
    //  Configure_Led_rosso();                                                          // Viene configurato il Led rosso
    //  Configure_Led_verde();                                                          // Viene configurato il Led verde                                                   
    //  Accendi_led_verde();                                                                // Viene acceso il Led verde
 
 
    // Configurazione del Timer
        SystemCoreClockUpdate();                                        // Viene aggiornato il system core clock         
        SysTick_Config(SystemCoreClock/1000);                       // Viene generato l'interrupt ogni 1 ms  
    
//      TIMER0_setup();
//      TIMER1_setup();
        LED_remote_control=false;  //LEDs controlled by micro
    
        if(rx_data[6]) NVIC_SystemReset();
 
 
        FW_version =  __INT_DATE__;
        scheda_su_scheda_giu=0;    //.........................................Bisogner\'a specificare per la eprom del solo per il postfrontend, poi
 
        //Definizione puntatore sitruzioni
        Setting_of_the_pointer_for_command_parser ( );
        LPC_SC->PCONP |= 1 <<15 ; //Accensione GPIO     
      LED_pin_configuration();
        LED_accendi_spegni( LED_RED, accendi);
      LED_accendi_spegni( LED_GREEN, spegni);
 
    // Configurazione delle Periferiche 
    //  Configure_Bit_Address_for_CAN();
 
        I2C_1_Initialize();                                                                 // Viene inizializzata la periferica I2C_A
        I2C_0_Initialize();                                                                 // Viene inizializzata la periferica I2C_B
        
        Configure_Reset_I2C_mux();  //< configuration of reset pin of the I2C_mux, reset it an turn into in idle state, waiting to operate
//      ADC_noding_map();       
 
        Configure_Reset_selection_port_analog_mux_ResIn_ADC_buffer(); //< configuration of reset pin of the 8 analog mux, reset it an turn into in idle state, waiting to operate
        ADC_pin_configurations();
 
        
        Configure_Bit_Address_for_CAN();
        CAN_Inizialize();                                                                       // Viene inizializzata la periferica CAN
        SPI_Inizialize();                                                                       // Viene inizializzata la periferica SPI
        EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard, Canale_Eprom_mainboard,  Memory_mainboard_address_fw << 2 , (uint8_t *) &FW_version);   
        
 
        ADC_Wakeup(I2C_mux_Scheda_giu);
        ADC_Wakeup(I2C_mux_Scheda_su);
        
        //Risoluzione max, lentezza maggiore
        ADC_scrittura_registro(0 /*0=ADC0, 1=ADC1*/, 0, ADC_channel_conversion_time_FW_ch0_register, ADC_max_resolution);  
        ADC_scrittura_registro(1 /*0=ADC0, 1=ADC1*/, 0, ADC_channel_conversion_time_FW_ch0_register, ADC_max_resolution);
        ADC_scrittura_registro(0 /*0=ADC0, 1=ADC1*/, 1, ADC_channel_conversion_time_FW_ch0_register, ADC_max_resolution);
        ADC_scrittura_registro(1 /*0=ADC0, 1=ADC1*/, 1, ADC_channel_conversion_time_FW_ch0_register, ADC_max_resolution);       
                        
        
        ADC_selfcal_zero_scale(I2C_mux_Scheda_giu);
        ADC_selfcal_zero_scale(I2C_mux_Scheda_su); //selfcal manda in sleep
                    
        ADC_sleep_ON_OFF(0 , 2); //Acendiamo gli ADC
        ADC_sleep_ON_OFF(1 , 2);        
        EPROM_lettura_M24C32_64(0,  I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_ADCs_always_ON_0_powerdown_1 << 2  , dati_letti); 
        ADC_sleep_off =dati_letti[0];       
        ADC_sleep_ON_OFF(0 , 0 + ADC_sleep_off); //Spegnamo gli ADC se non vanno tenuti sempre ON
        ADC_sleep_ON_OFF(1 , 0 + ADC_sleep_off);
 
 
//      int risultato;
//      risultato= ADC_lettura_24bit(0, I2C_mux_Scheda_su,1);
//      risultato= ADC_lettura_24bit(1, I2C_mux_Scheda_giu,1);
//      risultato= ADC_lettura_24bit(0, I2C_mux_Scheda_su,3);
//      risultato= ADC_lettura_24bit(1, I2C_mux_Scheda_giu,3);
//      risultato= ADC_lettura_24bit(0, I2C_mux_Scheda_giu,2);  
//      risultato= ADC_lettura_24bit(1, I2C_mux_Scheda_su,2);
//      
//      uint8_t ii;
//      for (ii=32; ii<32+8;ii++){
//          Analog_mux_line_to_select_deselect_for_postmainboard ( 1,  ii, 1 );
//          Analog_mux_line_to_select_deselect_for_postmainboard ( 1,  ii, 0 );     
//      }
//      for (ii=40; ii<41+8;ii++){
//          Analog_mux_line_to_select_deselect_for_postmainboard ( 1,  ii, 1 );
//          Analog_mux_line_to_select_deselect_for_postmainboard ( 1,  ii, 0 );     
//      }
//preamplifier_determina_trimmer_therma_comp( 1, 1, 180,  0);
//preamplifier_determina_trimmer_therma_comp( 1, 0, 180,  0);
 
    // The ouputs of the I2C to parallel, the chip selects, mainly, are all set high     
         I2C_to_Parallel_ini_PCA9554(  0,    I2C_to_Parallel_name_1);
         I2C_to_Parallel_ini_PCA9554(  0,  I2C_to_Parallel_name_2 ); //< swithces are active High
         I2C_to_Parallel_ini_PCA9554(  0,  I2C_to_Parallel_name_3 ); //< swithces are active High 
         I2C_to_Parallel_ini_PCA9554(  1,    I2C_to_Parallel_name_1);
         I2C_to_Parallel_ini_PCA9554(  1,  I2C_to_Parallel_name_2 ); //< swithces are active High
         I2C_to_Parallel_ini_PCA9554(  1,  I2C_to_Parallel_name_3 ); //< swithces are active High        
         
         Aspetta_tanti_ms(500);
         
    // Set the PGA gain at its minimum (pga input stage at gain 1, DAC pre at gain 1)
    for( canale_=0; canale_ <6; canale_ ++ ){
//      PGA_set_reset_pre_PGA_gain ( 0,  canale_,  PGA_set_pre_pga_low_gain  )   ;
//      PGA_DAC_GAIN_CROSS( 0,  canale_ ,  1,1);
        PGA_GAIN_CROSS( 0,  canale_,  1  );
        PGA_GAIN_CROSS( 1,  canale_,  1  );
    }    
 
         
    //Detector Relays Drivers reset  
    I2C_to_Parallel_set_PCA9554_outputs_values(  0,      detector_reset_all_relays_driver.I2C_to_parallel_chip_num, \
                detector_reset_all_relays_driver.I2C_to_parallel_chip__pin_num);    // one pin connect all the 6 driver reset inputs and is fired now
                                        //to switch off all the ouputs.
    Aspetta_tanti_ms(10);    //wait_for_ADC_setting for stability
    I2C_to_Parallel_set_PCA9554_outputs_values(  1,      detector_reset_all_relays_driver.I2C_to_parallel_chip_num, \
                                                                                        I2C_to_Parallel_ini_set[detector_reset_all_relays_driver.I2C_to_parallel_chip_num]);    //Te reset pin is put inactive       
 
    //Dis-Connect the detector
    for( canale_=0; canale_ <6; canale_ ++ ){
        Relays_driver_set_reset_channel(0, canale_ ,  Detector_prea_to_GND );
        Relays_driver_set_reset_channel(1, canale_ ,  Detector_prea_to_GND );
    }
    //Detector bias at zero
    for( canale_=0; canale_ <6; canale_ ++ ){
        for(trimmer_=0; trimmer_<4;trimmer_++){
        detector_scrittura_lettura_trimmer_bias( 0,  canale_,  trimmer_,  128,  1); 
        detector_scrittura_lettura_trimmer_bias( 1,  canale_,  trimmer_,  128,  1);                     
        }   
    }
//Detectro large resistors
    for( canale_=0; canale_ <6; canale_ ++ ){
        Relays_driver_set_reset_channel(0, canale_ ,  Detector_large_RLOAD );
        Relays_driver_set_reset_channel(1, canale_ ,  Detector_large_RLOAD );
    }   
//Bias diretto e non invertito
    for( canale_=0; canale_ <6; canale_ ++ ){
        Relays_driver_set_reset_channel(0, canale_ ,  Detector_bias_diretto );
        Relays_driver_set_reset_channel(1, canale_ ,  Detector_bias_diretto );      
    }
    
//Trimmer preamplif a met\'a scala
     for( canale_=0; canale_ <6; canale_ ++ ){
         for( trimmer_=0; trimmer_ <4; trimmer_ ++ ){
//void preamplifier_scrittura_lettura_trimmer(uint8_t scheda_su_scheda_giu, uint8_t canale, uint8_t trimmer, uint8_t valore, uint8_t scrivi_leggi_1_leggi_0  )
        preamplifier_scrittura_lettura_trimmer( 0,  canale_, trimmer_, 128, preamplifier_scrivi_il_trimmer  );
        preamplifier_scrittura_lettura_trimmer( 1,  canale_, trimmer_, 128, preamplifier_scrivi_il_trimmer  );       
     }
}   
    
     
//Trimmer based PGA at attenuator 0.5 and gain almost 1
    for( canale_=0; canale_ <6; canale_ ++ ){
            PGA_trimmer_gain (scheda_su, canale_); //Done for the first 6 channels
            PGA_trimmer_gain (scheda_giu, canale_); //Done for the second  6 channels
     }
     
//Termometri in shut down
    for( canale_=0; canale_ <6; canale_ ++ ){
        termometro_sht_down( 0,     canale_ );      
        termometro_sht_down( 1,     canale_ );      
    }    
     
    //Inizializzazione parametri pendenza offset, se impostati
    uint8_t  scheda_su_scheda_giu_; 
    for(scheda_su_scheda_giu_=0;scheda_su_scheda_giu_ <2;scheda_su_scheda_giu_++){
    for (canale_=0; canale_<6;canale_++){
        EPROM_lettura_M24C32_64(scheda_su_scheda_giu_ ,I2C_mainboard, canale_, (Memory_preamplifier_slope_calibration_ON_0_OFF_ff <<2), dati_letti);
        if( *(uint32_t *)dati_letti == 0){//Solo se questa cella ha tutti zeri la calibrazione \'e stata fatta
            EPROM_lettura_M24C32_64(scheda_su_scheda_giu_ ,I2C_mainboard, canale_, (Memory_preamplifier_address_fine_trimmer_slope_offset <<2), dati_letti);
            preamplifier_fine_step_trimmer[canale_ + scheda_su_scheda_giu_ *6] = *(int32_t *)dati_letti;
            EPROM_lettura_M24C32_64(scheda_su_scheda_giu_ ,I2C_mainboard, canale_, (Memory_preamplifier_address_coarse_trimmer_slope_offset <<2), dati_letti);
            preamplifier_coarse_step_trimmer[canale_ + scheda_su_scheda_giu_ *6] = *(int32_t *)dati_letti; 
        }
        
    }
    }
 
    //Restoring of the detector slopes into the preamplifiers EPROM
    for( canale_=0; canale_ <6; canale_ ++ ){
            EPROM_restore_detector_slopes_in_pream( I2C_mux_Scheda_su ,  canale_ );
            EPROM_restore_detector_slopes_in_pream( I2C_mux_Scheda_giu ,  canale_ );
    }
    
    //Punto di lavoro iniziale, eventuale 
    EPROM_store_recover_state_M24C32_64(0,0x3F,1,1);
    EPROM_store_recover_state_M24C32_64(1,0x3F,1,1);
 
//  GPIO_PinWrite(LED_Red.porta_num, LED_Red.pin_num, 0);      //!< now the red LED is switched ON  at startup
//  GPIO_PinWrite(LED_Green.porta_num, LED_Green.pin_num, 1);      //!< now the red LED is switched ON  at startup
    
    //Questi serviranno solo per la re-imnizializzazione, dopo powerdown--powerup
         mio_SCS_Val = LPC_SC->SCS;
         mio_CCLKCFG_Val= LPC_SC->CCLKCFG;
         mio_PCLKSEL0_Val=LPC_SC->PCLKSEL0;
         mio_PCLKSEL1_Val=LPC_SC->PCLKSEL1;
         mio_CLKSRCSEL_Val=LPC_SC->CLKSRCSEL;
         mio_PLL0CFG_Val=LPC_SC->PLL0CFG;
         mio_PLL0_SETUP=LPC_SC->PLL0CON;
    
    //Powerwon da attivare o no
        EPROM_lettura_M24C32_64(0,  I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_micro_powdown_active_1_alwaysON_0 << 2  , dati_letti);
        flag_power_down=dati_letti[0];
        //Lettura wait time per reset micro
        EPROM_lettura_M24C32_64(0,  I2C_postmainboard, Canale_EPROM_postmainboard_down, Memory_postmainboard_micro_PD_wait_time_in_sec << 2  , dati_letti); 
        if (  (dati_letti[0]>0) || (dati_letti[0]<=60)) POWER_DOWN_MAX_ATTESA = dati_letti[0]*1000;  //Il default \'e 5000
//      flag_power_down=0;  
}
//! <!-- [fun_startup] -->
 
/*! \brief I2C, SPI and CAN can be rest
 
*\return No Parameters
\showrefby
\showrefs 
\snippet{lineno} inizializzazione.c fun_instr_periferal_reset_function
 */
//! <!-- [fun_instr_periferal_reset_function] -->
void instr_periferal_reset_function(void){
    uint8_t chi_resettare=vettore_istruzioni[6];
    
    if( chi_resettare & 1) CAN_Inizialize();
    if( chi_resettare & 2){
        I2C_1_Initialize();                                                                 // Viene inizializzata la periferica I2C_A
        I2C_0_Initialize();
    }
    if( chi_resettare & 4) SPI_Inizialize();
        
}
//! <!-- [fun_instr_periferal_reset_function] -->
 
//fine CROSS
 
//void instruction_measure_pre_bias_coefficients(void) {
//  #define solo_lettura 0x80
//  #define restore_coefficients 0x40
//  char vettore_istruzioni_byte_3=vettore_istruzioni[istruzione_byte_3];
//  struct canale_ADC_type{
//      unsigned char att_pos;
//      unsigned char att_neg;
//  }canale_ADC[]={ADC_Misura_bias_10_att_ch0_p,ADC_Misura_bias_10_att_ch0_n,ADC_Misura_bias_10_att_ch1_p,ADC_Misura_bias_10_att_ch1_n} ;   
//  char chi_misuro= vettore_istruzioni[istruzione_byte_4_e_scelta_canale],canale,ii,PGA_Gain_V_su_V_old,fine_offset,coarse_offset;
//  int coefficiente_in_mV,offset_ini,offset_fin, fine_offset_da_dividere;
//  int attesa= vettore_istruzioni[istruzione_byte_2]*100;
//  if (attesa <1000) attesa=1000;
//  char 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}; 
//  for( ii=0; ii<2;ii++){
//      if ( (chi_misuro >> ii) & 1){
//          canale=ii;
//      }   
//  }
//  chi_misuro=chi_misuro & 0xFE ;
//if(       ((chi_misuro & solo_lettura) ==0 ) && ((chi_misuro & restore_coefficients) ==0 ) ){ //Se 0x8x si chiede solo la stampa, se 0x4x il restoring
//      if( vettore_istruzioni_byte_3 ==1){
//          //Detector bias coefficients
//          //fine
//          Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_pos, 0);
//          Aspetta_tanti_ms(attesa);
////            offset_ini = lettura_ADC( canale_ADC[canale].att_pos); // Viene misurato l'offset per uscita neg e valutato il nuovo valore dei trimmer
//          offset_ini = correzione_misura_ADC(indice_Vbias, offset_ini);           
//          Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_pos, 0xFF);
//          Aspetta_tanti_ms(attesa);
////            offset_fin = lettura_ADC( canale_ADC[canale].att_pos); // Viene misurato l'offset per uscita neg e valutato il nuovo valore dei trimmer
//          offset_fin = correzione_misura_ADC(indice_Vbias, offset_fin);
//          trimmer_bias_fine_step_actual[canale] = abs( offset_fin - offset_ini ) / 0xFF;
////            scrivi_mem_EPROM( Memory_address_fine_trimmer_slope_bias, trimmer_bias_fine_step_actual[canale], canale);
//          
//          //coarse
//          Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_pos,0x80);
//          Aspetta_tanti_ms(attesa);
////            offset_ini = lettura_ADC( canale_ADC[canale].att_pos); // Viene misurato l'offset per uscita neg e valutato il nuovo valore dei trimmer
//          offset_ini = correzione_misura_ADC(indice_Vbias, offset_ini);           
//          Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_pos, 0x85);
//          Aspetta_tanti_ms(attesa);
////            offset_fin = lettura_ADC( canale_ADC[canale].att_pos); // Viene misurato l'offset per uscita neg e valutato il nuovo valore dei trimmer
//          offset_fin = correzione_misura_ADC(indice_Vbias, offset_fin);
//          trimmer_bias_coarse_step_actual[canale] = abs( offset_fin - offset_ini ) / 5 ;  
////            scrivi_mem_EPROM( Memory_address_coarse_trimmer_slope_bias, trimmer_bias_coarse_step_actual[canale],canale);
//          
//      }else{
//              PGA_Gain_V_su_V_old = PGA_Gain_V_su_V[canale];
//              PGA_GAIN_set( canale,   1);
//              Aspetta_tanti_ms(attesa);
////                offset_ini=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
//              offset_ini=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset_ini);
//          
//              if (vettore_istruzioni_byte_3 ==0){
//                  
//                          //Preamplifier coefficients
//                  if( (offset_ini < saturazione_positiva ) && (offset_ini > saturazione_negativa) ){
//                      //Facciamo la misura
//                      if (offset_ini >0){//Cerchiamo di andare dalla parte opposta per non avere probemi di dinamica
//              //          fine_offset= Trimmer_offset_preampli[canale].fine_offset +=  (1<<4 );
//                          fine_offset= 0xff;
//                          coarse_offset=Trimmer_offset_preampli[canale].coarse_offset += 1 << 1 ;
//                      }else{
//              //          fine_offset=Trimmer_offset_preampli[canale].fine_offset -=  (1<<4 );
//                          fine_offset=0;
//                          coarse_offset=Trimmer_offset_preampli[canale].coarse_offset -= 1 << 1 ; 
//                      }
//                      //Facciamo prima il test con fine offset
//                  if ( Trimmer_offset_preampli[canale].fine_offset > 0x80){
//                      fine_offset_da_dividere=  Trimmer_offset_preampli[canale].fine_offset * guadagno_minimo_PGA;  // <<2 perch\'e la misura \'e fatta all'uscita del pga, 
//                                                                                                                              //che ha guadagno 4, ovvero 2^2
//                      fine_offset=0;
//                  }else{
//                      fine_offset_da_dividere=( 0xff - Trimmer_offset_preampli[canale].fine_offset) *guadagno_minimo_PGA;  // <<2 perch\'e la misura \'e fatta all'uscita del pga, 
//                                                                                                                              //che ha guadagno 4, ovvero 2^2
//                      fine_offset= 0xFF;
//                  }
//                      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, fine_offset);
//                      Aspetta_tanti_ms(attesa);
////                        offset_fin=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
//                      offset_fin=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset_fin);
//                      if ( (offset_fin < saturazione_positiva ) && (offset_fin >saturazione_negativa)){
//                      fine_Trimmer_offset_step_actual[canale]  = abs( offset_fin - offset_ini ) / fine_offset_da_dividere;        //diviso 2^4 e diviso per 4 perch\'e all'uscita del pga
//                      //Scrittura in memoria
////                        scrivi_mem_EPROM( Memory_preamplifier_address_fine_trimmer_slope_offset, fine_Trimmer_offset_step_actual[canale], canale);
//                  }else{
//                      tx_data[istruzione_byte_4_e_scelta_canale]=0xFF;
//                  }
 
//                      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);
//                          //Adesso facciamo col coarse offset
//                      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, coarse_offset);
//                      Aspetta_tanti_ms(attesa);
////                        offset_fin=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
//                      offset_fin=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset_fin);
//                      if ( (offset_fin < saturazione_positiva ) && (offset_fin >saturazione_negativa)){
//                      coarse_Trimmer_offset_step_actual[canale]  = abs( offset_fin - offset_ini ) /2/guadagno_minimo_PGA; //diviso 2 e diviso per 4 perch\'e all'uscita del pga   
//                      //Scrittura in memoria  
////                        scrivi_mem_EPROM( Memory_preamplifier_address_coarse_trimmer_slope_offset, coarse_Trimmer_offset_step_actual[canale],canale);
//                      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);
//                  }else{
//                      tx_data[istruzione_byte_4_e_scelta_canale]=0xFF;
//                  }
 
//                  }else{
//                      //La misura non si pu\'o fare perch\'e in saturazione e lo segnaliamo
//                      tx_data[istruzione_byte_4_e_scelta_canale]=0xFF;
//      }
//      }else if(vettore_istruzioni_byte_3 ==2){
//              //trimmer termico
//          unsigned short trimmer_variato= Trimmer_offset_preampli[canale].coarse_thermal +4;
//          if (trimmer_variato > 0xFF){
//              trimmer_variato = Trimmer_offset_preampli[canale].coarse_thermal - 4;
//          }
//          if( (offset_ini < saturazione_positiva ) && (offset_ini > saturazione_negativa) ){
//                      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_coarse_thermal_trimmer, trimmer_variato);
//                      Aspetta_tanti_ms(attesa);
////                        offset_fin=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
//                      offset_fin=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset_fin);
//                      if ( (offset_fin < saturazione_positiva ) && (offset_fin >saturazione_negativa)){
//                      coarse_Trimmer_thermal_step_actual[canale]  = abs( offset_fin - offset_ini ) /4/guadagno_minimo_PGA;        //diviso 4, che \'e la variazione,
//                                                                          // e diviso per 4 perch\'e all'uscita del pga
//                      //Scrittura in memoria
////                        scrivi_mem_EPROM( Memory_address_coarse_trimmer_temp_slope_compensation, coarse_Trimmer_thermal_step_actual[canale],canale);
//                      Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_coarse_thermal_trimmer, Trimmer_offset_preampli[canale].coarse_thermal);
//                  }else{
//                      tx_data[istruzione_byte_4_e_scelta_canale]=0xFF;
//                  }               
//          }else{
//              tx_data[istruzione_byte_4_e_scelta_canale]=0xFF;
//          }
//      }
//  PGA_GAIN_set( canale,   PGA_Gain_V_su_V_old);  //Ristabiliamo il guadagno+
//  Aspetta_tanti_ms(attesa);
//      } 
//  }   
 
//if(       (chi_misuro & restore_coefficients)  ){
//      if( vettore_istruzioni_byte_3 ==1){
//      //restore dei parametri del dettector bias
//      trimmer_bias_fine_step_actual[canale]= trimmer_bias_fine_step;
////        scrivi_mem_EPROM( Memory_address_fine_trimmer_slope_bias, trimmer_bias_fine_step_actual[canale],canale);
//      trimmer_bias_coarse_step_actual[canale]=trimmer_bias_coarse_step;
////        scrivi_mem_EPROM( Memory_address_coarse_trimmer_slope_bias, trimmer_bias_coarse_step_actual[canale],canale);
//  }else if (vettore_istruzioni_byte_3 ==0){   
//      //restore dei parametri per l'offset
//      fine_Trimmer_offset_step_actual[canale] =fine_Trimmer_offset_step;
////        scrivi_mem_EPROM( Memory_preamplifier_address_fine_trimmer_slope_offset, fine_Trimmer_offset_step_actual[canale],canale);
//      coarse_Trimmer_offset_step_actual[canale]  = coarse_Trimmer_offset_step;
////        scrivi_mem_EPROM( Memory_preamplifier_address_coarse_trimmer_slope_offset, coarse_Trimmer_offset_step_actual[canale],canale);
//  }else if (vettore_istruzioni_byte_3 == 2){
//      //restore dei parametri per la deriva termica
//      fine_Trimmer_thermal_step_actual[canale]= fine_Trimmer_thermal_step;
////        scrivi_mem_EPROM( Memory_address_fine_trimmer_temp_slope_compensation, fine_Trimmer_thermal_step_actual[canale],canale);
//      coarse_Trimmer_thermal_step_actual[canale]=coarse_Trimmer_thermal_step;
////        scrivi_mem_EPROM( Memory_address_coarse_trimmer_temp_slope_compensation, coarse_Trimmer_thermal_step_actual[canale],canale);
//  }
//}
 
 
//      //Stampa coefficineti in uso
//      if( vettore_istruzioni_byte_3 ==1){
//          //Detector bias coefficients
//          coefficiente_in_mV =trimmer_bias_coarse_step_actual[canale] / 1000;
//          tx_data[0] = coefficiente_in_mV & 0xFF;
//          tx_data[1] = (coefficiente_in_mV >> 8) & 0xFF;
//          coefficiente_in_mV =trimmer_bias_fine_step_actual[canale] ;
//          tx_data[2] = coefficiente_in_mV & 0xFF;
//          tx_data[3] = (coefficiente_in_mV >> 8) & 0xFF;          
//      }else if (vettore_istruzioni_byte_3 ==0 ){
//          //Preamplifier coefficients
//          coefficiente_in_mV =coarse_Trimmer_offset_step_actual[canale] / 1000;
//          tx_data[0] = coefficiente_in_mV & 0xFF;
//          tx_data[1] = (coefficiente_in_mV >> 8) & 0xFF;
//          coefficiente_in_mV =fine_Trimmer_offset_step_actual[canale] ;
//          tx_data[2] = coefficiente_in_mV & 0xFF;
//          tx_data[3] = (coefficiente_in_mV >> 8) & 0xFF;          
//      } else if (vettore_istruzioni_byte_3 ==2){
//          coefficiente_in_mV =coarse_Trimmer_thermal_step_actual[canale] / 1000;
//          tx_data[0] = coefficiente_in_mV & 0xFF;
//          tx_data[1] = (coefficiente_in_mV >> 8) & 0xFF;
//          coefficiente_in_mV =fine_Trimmer_thermal_step_actual[canale] ;
//          tx_data[2] = coefficiente_in_mV & 0xFF;
//          tx_data[3] = (coefficiente_in_mV >> 8) & 0xFF;          
//      }
//}
 
 
///*! \brief Calibration of some parameters of the ADC mainly
 
//*\return No Parameters
//\showrefby
//\showrefs 
//\snippet{lineno} inizializzazione.c fun_instruction_ricalibrazione_scheda
// */
//! <!-- [fun_instruction_ricalibrazione_scheda] -->
//void instruction_ricalibrazione_scheda(void){
 
//  calibrazione_Resistenze_sterne_ADC();
//  
//}
//! <!-- [fun_instruction_ricalibrazione_scheda] -->