Adc.c

Go to the documentation of this file.

 
 
#include "tutti_gli_header.h"
//#include "math.h"
/*****DOCUMENTAZIONE DOXYGEN             (premi il - a sinistra per ridurla a icona) il manuale html \'e nella cartella************/
/// \file
 
/*!
\page ADC_page Adc
\brief <span style="color:red;"> <b> ADC managing </b> </span> \anchor ADC_managing
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref introduction_to_ADC
*\arg \ref ADC_settings
*\arg \ref ADC_operation
*\arg \ref OffBoard_ADC
*\arg \ref ADC_conclusion
 
 
*\section introduction_to_ADC On Board Adc usage
<hr width="90%" size="10" align="left">
 
\n The ADC on board is the 24 bits <a href="./File_pdf/AD7732BRU.pdf"  target=_blank><b>AD7732BRU datasheet</b></a>. It has some 
parameters that can be set with flags in its instruction. Its main function to be called is
ADC_lettura(), whose code is the following:
*\snippetlineno Adc.c fun_ADC_lettura
 
\n Reading result has to be multiplied by numeratore, then divided by denominatore. This to work with integer numbers: remember
that our voltages are in &micro;V. 
\n Each node to be read has its own identity; as an instance, the detector bias is read after a voltage attenuator. The reading nodes
are organized in groups of 6, there is a vector structure whose locations are retreived by node_number/6:
*\snippetlineno Adc.h struct_ADC_coefficiente_type
 
\n Here is the vector #ADC_coefficiente and here we see the coefficient values:
- #ADC_numeratore_PGA 
- #ADC_denominatore_PGA 
- #ADC_numeratore_PreOut 
- #ADC_denominatore_PreOut 
- #ADC_numeratore_PowerSupply 
- #ADC_denominatore_PowerSupply 
- #ADC_numeratore_Vreg
- #ADC_denominatore_Vreg
- #ADC_numeratore_Bias
- #ADC_denominatore_Bias 
- #ADC_numeratore_Res_fisse 
- #ADC_denominatore_Res_fisse 
- #ADC_numeratore_Bias_p 
- #ADC_denominatore_Bias_p
 
\n These number are exploited by the function ADC_compensazione_al_nodo()
that needs as input parameters the node that is being measured by  \b line_to_read. Then, from the ADc measured value, \b lettura_ADC and offset \b lettura_offset
the actual node voltage is obtained. The above coefficiennts take into account the attanuator factors at the buffer inputs according to the following figure:
 
*\anchor Figure_ADC_Buffer_attenuation_input
*\image html ADC_buffer_input.png "Figure_ADC_Buffeattenuation 1: ADC buffer in switchable resistor" width=50%
*\image latex ADC_buffer_input.png "Figure_ADC_Buffeattenuation 1: ADC buffer in switchable resistor" width=50%
 
\note During the developing phase the board can be connected to an external ADC rather than that of the postfrontend, or mainboard B. 
Dscrimination between internal and external ADC can be made at the instruction level.
 
*\section ADC_settings On Board ADC settings
<hr width="90%" size="10" align="left">
 
\n At startup, within instr_inizializza_tutto_da_zero_function(), both ADC's are initialized. The first action done on ADC is the settings of its configuration pins. This is done at startup by the function ADC_pin_configurations(void). 
Soon after that the SPI protool is set, SPI_Inizialize(), the ADC's zero scale calibration is done, with ADC_selfcal_zero_scale(uint8_t up_down) invoked 2 times, one for each ADC present, 
than, the ADC's are sent into powerdown state with the function ADC_Sleep_fun(uint8_t up_down), invoked 2 times, too.
 
*\section ADC_operation ADC Operation
<hr width="90%" size="10" align="left">
 
\n The ADC functions list is here:
 
- ADC_misura_differenziale_con_media_generico() with inpt parameters uint8_t scheda_su_scheda_giu_, uint8_t preamplifier_externalADC_1_onboardADC_0, 
uint8_t nodo_da_misurare, uint8_t differenziale1_single_0
- ADC_misura_differenziale_single_ended() with input parameters uint8_t scheda_su_scheda_giu , 
uint8_t nodo_da_leggere, uint8_t differenziale_1_single_0 
- ADC_pin_configurations(void)
- ADC_selfcal_zero_scale(uint8_t up_down)
- ADC_Sleep_fun(uint8_t up_down)
- ADC_Wakeup(uint8_t up_down)
- ADC_lettura_24bit(char ADC_0_o_1 , uint8_t up_down, uint8_t cosa_fare)
- ADC_lettura_registro(char ADC_0_o_1 , uint8_t up_down, uint8_t registro_ch0)
- ADC_lettura(uint8_t scheda_su_scheda_giu, uint8_t node_to_read, uint8_t cosa_fare)
- instr_ADC_LETTURA_function(void)
 
 
\n On the top of the above list there are the 2 functions that operate globally the ADC's to perform the measurement. 
\n The first one is
ADC_misura_differenziale_con_media_generico() that allows to set all the necessary parameters to perform the measurement.
The user could use only this function to operate the ADC.
\n There are 2 parameters that are not passed to the function but are global and need to be set at least once, or their default 
values are considered.
\n The variable #ADC_medie_per_misura is the first of the 2 variables that are not passed as a parameter but is a global. It can be set with the instruction via CAN,
<a href=#instr_ADC_LETTURA_option>instr_ADC_LETTURA</a>. 
It says to the function how many measurements of the node must be taken and averaged.
\n The other variable that is not passed, but is global is #ADC_non_leggi_lo_offset_se_true. If it is true the input offset
of the buffer which stands in front of the ADC is not read, \ref Figure_ADC_Buffer_attenuation_input. With the new OA used
the offset is very small and its measurement can be omitted. This shortens the reading time. This flag can be set ON or OFF from
the instruction, <a href=#instr_ADC_LETTURA_option>instr_ADC_LETTURA</a>.
\n The input parameters to the first function are: 
- \b scheda_su_scheda_giu_ is the board selection; 
- \b preamplifier_externalADC_1_onboardADC_0 indicates whether
the ADC's on board are used or an external ADC is the selcted to perform the measurement, usually this parameter is set to zero
since the external ADC is selected only for testing purpose; 
- \b nodo_da_misurare is the node whose voltage is to be measured, the node list can be found at \ref lista_nodi "lista nodi";
- \b differenziale1_single_0 determines whether the measurement is performed differential os single ended. As an example, the ouput of the 
PGA amplifier is differential and we can read it as <b> Vout_pos - Vout_neg </b>, or to read <b>Vout_pos </b> and <b>Vout_neg </b> 
indipendently.
 
\n The second function, ADC_misura_differenziale_single_ended(), is invoked from the previous function. Its parameters are similar
to the previous described above:
- \b scheda_su_scheda_giu is the board from which volateg nodes must be read;
- \b nodo_da_leggere is the node to be read according to \ref lista_nodi "lista nodi";
- \b differenziale_1_single_0 determines whether the measurement is performed differential os single ended.
 
\n The function ADC_pin_configurations() is invoked just one time, at the startup. Calibration is done at startup, too, and can be invoked from time to time from the CAN, too.
\n ADC_Wakeup() is called every time a reading must be taken, while ADC_Sleep_fun() is invoked at the end of the reading function.
\n ADC_lettura_24bit(char ADC_0_o_1 , uint8_t up_down, uint8_t cosa_fare) allows a single reading of the previously selected node. It needs to know 
which of the 2 ADC channels to use with \b ADC_0_o_1, and which ADC to consider with \b up_down. 
The last parameter \b cosa_fare allows to operate the 2 ADC in parallel, if needed.
It cover 3 values as it follows:
 
- <b>cosa_fare=1:</b> The measurement is only started. The measurement function is not blocking and this allows to launch the measurement with the other ADC in parallel. 
    The returned value is 0 in this case.
    Take care that the parallel operation is not possible with the 2 channels of the ADC because the ADC is multiplexed. If the parallel operation is anyway set for 
    the 2 channels of the same ADC one measurement will be lost.
- <b>cosa_fare=2:</b> In this case the measuremen is launched and the result is waited and returned. This is a situation for which parallel operation is not exploited.
This function is blocking.
- <b>cosa_fare=3:</b> In this case the result is waited of the measuremnt launched in a previous call with <b>cosa_fare=1</b>.
 
An example of parallel operation is here (<b>cosa_fare=1</b> combined with <b>cosa_fare=3</b>):
 
\code{.c}
        ADC_lettura_24bit(0, I2C_mux_Scheda_su,1);
        ADC_lettura_24bit(1, I2C_mux_Scheda_giu,1);
        //The 2 measurements have started in parallel and below here are read
        int risultato[2];
        risultato[0]= ADC_lettura_24bit(0, I2C_mux_Scheda_su,3);
        risultato[1]= ADC_lettura_24bit(1, I2C_mux_Scheda_giu,3);
\endcode
 
An example of non parallel operation is here (<b>cosa_fare=2</b>):
 
\code{.c}
        int risultato[2];
        risultato[0]= ADC_lettura_24bit(1, I2C_mux_Scheda_giu,2);   
        //Now the second measurement below will be done just after the measurement 
        //above is finisched since now the function is blocking
        risultato[1]= ADC_lettura_24bit(0, I2C_mux_Scheda_su,2);
\endcode
 
The inputs of the ADCs are buffered. The input resistor of the buffer is a switchable, in principle. This feature cannot be used since the switches are
MOS whos parasitic diode becomes forward bias when the input voltage goes negative. In this versione of the board the MOS are used for another fnctions and the resistirs is held 
to GND. Its value is not 10 K&Omega;, as in the picture below, but 82 K&Omega;; at the same time the resistor in series to the analog MUX's ouputs is now 8.2 K&Omega;. This
combination attenuates a little the value of the input node to measure and avoid to be too close to the rails, where the accuracy of the buffer lowers a little. 
 
*\anchor Figure_ADC_Buffer_in
*\image html ADC_buffer_in_resistor.png "Figure_ADC_Buffer_in 2: ADC buffer in switchable resistor" width=70%
*\image latex ADC_buffer_in_resistor.png "Figure_ADC_Buffer_in 2: ADC buffer in switchable resistor" width=70%
 
ADC_lettura_registro() allows to read a whatever ADC internal register of the selected ADC and ADC channel. 
Possible choices are (select the left number of the \b Addr column):
 
*\anchor Figure_ADC_Reg_list
*\image html ADC_register_list.png "Figure_ADC_reg 3: ADC register MAP. Select the register number from the \b Addr column. In case 2 numbers are available, choose the left one." width=40%
*\image latex ADC_register_list.png "Figure_ADC_reg 3: ADC register MAP. Select the register number from the \b Addr column. In case 2 numbers are available, choose the left one." width=40%
 
\n ADC_lettura(uint8_t scheda_su_scheda_giu, uint8_t node_to_read, uint8_t cosa_fare) sets the path, from the 
node to read, to the ADC input. First of all \b scheda_su_scheda_giu determines the region to operate and the ADC to select.
It needs to know the node(\b node_to_read) to set the path. 
Then \b cosa_fare is the parameter with which we can operate in parallel with the same sintax seen above.
 
\n Finally, instr_ADC_LETTURA_function(), is the function that is called when the CAN instruction is invoked, 
<a href=#instr_ADC_LETTURA_option>instr_ADC_LETTURA</a>.
 
*\section OffBoard_ADC Off Board ADC
<hr width="90%" size="10" align="left">
\n This option is anomalous becasue is the &micro;-controller that is asking back the requirement to read the node voltage. Through the CAN Bus and the 
\ref instr_readback_node_voltages_option_ "ReadBack Node Voltage instruction" any available node volatge can be read. The function that is able to perform this 
operation is:
*\snippetlineno .\Preamplifier_Offset_Drift_Correcttion.c fun_preamplifier_ADC_external_measured_node_function
 
*\section ADC_conclusion Conclusions
<hr width="90%" size="10" align="left">
 
\n This section must be expanded
 
 
<hr width="90%" size="10" align="left">
 The codes for mamnaging the ADC are: 
 - \ref  Adc.c
 - \ref  Adc.h
*/
 
 
 
// CROSS INIZIO
int32_t volatile  ADC_misura_fatta;
volatile bool  ADC_non_leggi_lo_offset_se_true=false; //!< if not necessary, the ADC input offset from buffer is not read
 
int32_t volatile ADC_external_measurement=0;
uint8_t volatile ADC_external_measured_node=0;
 
volatile uint8_t ADC_sleep_off=10; //!< if 0 ADC in sleep when not working, ADC>1 ADC never sleep
volatile uint16_t ADC_medie_per_misura=10;  //!< the number of ADC readings to average, the maximum is 400
 
 
//! Node normalizing coeficinets used in ADC_lettura_24bit()
const struct ADC_coefficiente_type ADC_coefficiente[]={ 
    /*PGA differential or positive from 0 to 5  (6 elements)*/
    ADC_numeratore_PGA ,  ADC_denominatore_PGA, ADC_numeratore_PGA, ADC_denominatore_PGA,
    ADC_numeratore_PGA ,  ADC_denominatore_PGA, ADC_numeratore_PGA, ADC_denominatore_PGA,
    ADC_numeratore_PGA ,  ADC_denominatore_PGA, ADC_numeratore_PGA, ADC_denominatore_PGA,
    /*PGA negative from 6 to 11 (6 elements)*/  
    ADC_numeratore_PGA ,  ADC_denominatore_PGA, ADC_numeratore_PGA, ADC_denominatore_PGA,
    ADC_numeratore_PGA ,  ADC_denominatore_PGA, ADC_numeratore_PGA, ADC_denominatore_PGA,
    ADC_numeratore_PGA ,  ADC_denominatore_PGA, ADC_numeratore_PGA, ADC_denominatore_PGA,
    /* Preamplifier differntial or positive from 12 to 17 (6 elements)*/    
    ADC_numeratore_PreOut, ADC_denominatore_PreOut , ADC_numeratore_PreOut, ADC_denominatore_PreOut,
    ADC_numeratore_PreOut, ADC_denominatore_PreOut , ADC_numeratore_PreOut, ADC_denominatore_PreOut,
    ADC_numeratore_PreOut, ADC_denominatore_PreOut , ADC_numeratore_PreOut, ADC_denominatore_PreOut,
    /* Preamplifier negative from 18 to 23 (6 elements)*/
    ADC_numeratore_PreOut, ADC_denominatore_PreOut , ADC_numeratore_PreOut, ADC_denominatore_PreOut,
    ADC_numeratore_PreOut, ADC_denominatore_PreOut , ADC_numeratore_PreOut, ADC_denominatore_PreOut,
    ADC_numeratore_PreOut, ADC_denominatore_PreOut , ADC_numeratore_PreOut, ADC_denominatore_PreOut,    
    /* Power supply Vcc Vee and Vdig from 24 to 26 (3 elements)*/
    ADC_numeratore_PowerSupply,  ADC_denominatore_PowerSupply,  
    ADC_numeratore_PowerSupply,  ADC_denominatore_PowerSupply,
    ADC_numeratore_PowerSupply,  ADC_denominatore_PowerSupply,
    /* Power supply Vreg_p Vreg_n e GND sense from 27 to 29 (3 elements)*/
    ADC_numeratore_Vreg, ADC_denominatore_Vreg,
    ADC_numeratore_Vreg, ADC_denominatore_Vreg,
    ADC_numeratore_Vreg, ADC_denominatore_Vreg,
    /* Dummy from 30 to 31 (2 elements)*/
    0,0,  0,0,
    /* Detector bias from 32 to 45 (14 elements)*/
    ADC_numeratore_Bias, ADC_denominatore_Bias , ADC_numeratore_Bias, ADC_denominatore_Bias ,
    ADC_numeratore_Bias, ADC_denominatore_Bias , ADC_numeratore_Bias, ADC_denominatore_Bias ,
    ADC_numeratore_Bias, ADC_denominatore_Bias , ADC_numeratore_Bias, ADC_denominatore_Bias ,
    ADC_numeratore_Bias, ADC_denominatore_Bias , ADC_numeratore_Bias, ADC_denominatore_Bias ,
    ADC_numeratore_Bias, ADC_denominatore_Bias , ADC_numeratore_Bias, ADC_denominatore_Bias ,
    ADC_numeratore_Bias, ADC_denominatore_Bias , ADC_numeratore_Bias, ADC_denominatore_Bias ,
    ADC_numeratore_Bias, ADC_denominatore_Bias , ADC_numeratore_Bias, ADC_denominatore_Bias ,
    /* Dummy from 46 to 47 (2 elements)*/
    0,0,    0,0,
    /* Analog mux none e 10 Kohm from 48 to 49 (2 elements)*/
    ADC_numeratore_Res_fisse,  ADC_denominatore_Res_fisse, ADC_numeratore_Res_fisse,  ADC_denominatore_Res_fisse,
    /* Detector bias attenuator  50 (1 elements)*/
    ADC_numeratore_Bias_p, ADC_denominatore_Bias_p};
 
    #define indice_attenuatore_BIAS sizeof(ADC_coefficiente ) / sizeof(ADC_coefficiente[1])-1
    
 
/*!  \brief ADC is sent to sleep mode
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Adc.c fun_ADC_Sleep_fun
*/
//! <!-- [fun_ADC_Sleep_fun] -->
void ADC_Sleep_fun(uint8_t up_down){
    const porta_pin_def  *ref_locale;
    if( up_down) up_down=1;
    if ( up_down == I2C_mux_Scheda_giu){
        ref_locale =&ADC_Chip_Sel_down;             // Viene abbassato il chip selector ADC per la lettura
    }else{
        ref_locale =&ADC_Chip_Sel_up;
    }
    
    if( up_down <2){
            GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 0);
            
            uint8_t valore_da_trasmettere[]={ ADC_mode_reg, ADC_power_down_com};
            
            SPIdrv->Send ( &valore_da_trasmettere ,2); 
            uint8_t troppa_attesa=0;
            while( (SPIdrv->GetStatus().busy) && (troppa_attesa <250) ){
                Aspetta_tanti_ms(1);
                troppa_attesa++;
            } //wait end of transmission     ;
            if((troppa_attesa>=250) || (Error_bad_operation)) ERROR_codifica_errore(up_down, error_address_SPI, SPI_error_EVENT_DATA_LOST,1);
            GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1);
}
}
//! <!-- [fun_ADC_Sleep_fun] --                                                                                                             
                                                                                                                                                                                                                
                                                                                                                
/*! \brief ADC self-calibration. ADC needs to be pre-selected.
 
*\return No return
 
*\snippetlineno ADC.c fun_selfcal_ADC
*/
//! <!-- [fun_selfcal_ADC] -->
void ADC_selfcal_zero_scale(uint8_t up_down){
    const porta_pin_def  *ref_locale,*ref_locale_ADCready;
    uint8_t limite=0;
    if ( up_down == I2C_mux_Scheda_giu){
        ref_locale =&ADC_Chip_Sel_down;     
        ref_locale_ADCready=&ADC_ready_down;
        ADC_Wakeup(I2C_mux_Scheda_giu);
    }else{
        ref_locale =&ADC_Chip_Sel_up;
        ref_locale_ADCready=&ADC_ready_up;
        ADC_Wakeup(I2C_mux_Scheda_su);
    }
    GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 0); // Viene abbassato il chip selector ADC per la lettura
 
    uint8_t valore_da_trasmettere[]={ ADC_mode_reg_ch0, ADC_ZeroScaleCalibration_com};  //Calibriamo il CH0
    SPIdrv->Send ( &valore_da_trasmettere ,2); 
//  while( (SPIdrv->GetStatus().busy)  ){
//      limite++;
//      Aspetta_tanti_ms(1);    
//  }
//  if( (limite>=10) || Error_bad_operation) ERROR_codifica_errore(up_down, error_address_SPI, Error_bad_operation, 1);     
    
                uint8_t troppa_attesa=0;
            while( (SPIdrv->GetStatus().busy) && (troppa_attesa <250) ){
                Aspetta_tanti_ms(1);
                troppa_attesa++;
            } //wait end of transmission     ;
            if((troppa_attesa>=250) || (Error_bad_operation)) ERROR_codifica_errore(up_down, error_address_SPI, SPI_error_EVENT_DATA_LOST,1);
        
    limite=0;
  while (( GPIO_PinRead(ref_locale_ADCready->porta_num,ref_locale_ADCready->pin_num) == 1  ) )
    {     // Si aspetta che il risultato sia pronto ( notRDY=0 )
            Aspetta_tanti_ms(1);
            limite++;           
        }
    if( (limite>=10) ) ERROR_codifica_errore(up_down, error_address_reg_ADC0, ADC_RDY_pin_fault, 1);        
            
    GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1);               // Viene alzato il chip selector ADC per la lettura
    ADC_Sleep_fun(up_down + ADC_sleep_off); 
}
//! <!-- [fun_selfcal_ADC] -->
 
 
 
/*! \brief ADC is set to sleep or awake
 
\param[in]  up_down                :ADC for board up or board down
\param[in]  ADC_ON_1_OFF_0_NOP_GT1 : 2 (ON)=ADC ON, dummy resistors OFF; 0(OFF): ADC sleep, dummy resitors ON; 1(OFF): ADC sleep, dummy resitors OFF; >2: NOP
 
*\return No return
 
*\snippetlineno ADC.c fun_ADC_sleep_ON_OFF
*/
//! <!-- [fun_ADC_sleep_ON_OFF] -->
void ADC_sleep_ON_OFF(uint8_t up_down , uint8_t ADC_ON_1_OFF_0_NOP_GT1){
    const porta_pin_def  *ref_locale,*ref_locale_ResBuffer,*ref_locale_ResBuffer_;
if(up_down)up_down=1;   
if (    ADC_ON_1_OFF_0_NOP_GT1 <= 2){
                if ( up_down == I2C_mux_Scheda_giu){    
                    ref_locale_ResBuffer = &ADC_ResIn_B_buffer_down;//switch for buffer resistor on/off
                    ref_locale_ResBuffer_ = &ADC_ResIn_A_buffer_down;//switch for buffer resistor on/off
                }else if(up_down>=I2C_mux_Scheda_su){
                    ref_locale_ResBuffer = &ADC_ResIn_B_buffer_up;//switch for buffer resistor on/off
                    ref_locale_ResBuffer_ = &ADC_ResIn_A_buffer_up;//switch for buffer resistor on/off  
                }
                if(ADC_ON_1_OFF_0_NOP_GT1==1){
                    //ADC OFF, dummy OFF
                     ADC_Sleep_fun(up_down );
                     GPIO_PinWrite(ref_locale_ResBuffer->porta_num, ref_locale_ResBuffer->pin_num, 0); // Togliamo il consumo che simula l'ADC
                     GPIO_PinWrite(ref_locale_ResBuffer_->porta_num, ref_locale_ResBuffer_->pin_num, 0); // Togliamo il consumo che simula l'ADC
                }else if (ADC_ON_1_OFF_0_NOP_GT1==0){
                    //ADC OFF, dummy ON
                     ADC_Sleep_fun(up_down );
                     GPIO_PinWrite(ref_locale_ResBuffer->porta_num, ref_locale_ResBuffer->pin_num, 1); // Aggiungiamo il consumo che simula l'ADC
                     GPIO_PinWrite(ref_locale_ResBuffer_->porta_num, ref_locale_ResBuffer_->pin_num, 1); // Aggiungiamo il consumo che simula l'ADC                 
                }else if (ADC_ON_1_OFF_0_NOP_GT1==2){
                    //ADC ON, dummy OFF
                     ADC_Wakeup(up_down);       
                     GPIO_PinWrite(ref_locale_ResBuffer->porta_num, ref_locale_ResBuffer->pin_num, 0); // Togliamo il consumo che simula l'ADC
                     GPIO_PinWrite(ref_locale_ResBuffer_->porta_num, ref_locale_ResBuffer_->pin_num, 0); // Togliamo il consumo che simula l'ADC                    
                }
        }
}
//! <!-- [fun_ADC_sleep_ON_OFF] -->
 
/*! \brief ADC Wakeup and 24 bits reading
 
*\return No return
 
*\snippetlineno ADC.c fun_ADC_Wakeup
*/
//! <!-- [fun_ADC_Wakeup] -->
void ADC_Wakeup(uint8_t up_down){
    uint8_t limite;
    const porta_pin_def  *ref_locale;
    if ( up_down == I2C_mux_Scheda_giu){
        ref_locale =&ADC_Chip_Sel_down;     
    }else{
        ref_locale =&ADC_Chip_Sel_up;
    }
    GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 0); // Viene abbassato il chip selector ADC per la lettura
    
    uint8_t valore_da_trasmettere[]={ ADC_mode_reg_ch0, ADC_idle_com};  //Idle, attesa misura
    SPIdrv->Send ( &valore_da_trasmettere ,2); 
    limite=0;
    while( (SPIdrv->GetStatus().busy) && (limite<10) )  {
        limite++;
        Aspetta_tanti_ms(1);    
    }
    if( (limite>=10) || Error_bad_operation) ERROR_codifica_errore(up_down, error_address_SPI, Error_bad_operation, 1);
 
  valore_da_trasmettere[0]= ADC_mode_reg_ch1; valore_da_trasmettere[1]= ADC_idle_com;  //Idle, attesa misura
    SPIdrv->Send ( &valore_da_trasmettere ,2); 
    limite=0;   
    while( (SPIdrv->GetStatus().busy) &&(limite<10) )   {
        limite++;
        Aspetta_tanti_ms(1);    
    }
    if( (limite>=10) || Error_bad_operation) ERROR_codifica_errore(up_down, error_address_SPI, Error_bad_operation, 1);     
    
//  SPItx(ADC_mode_reg);
//  SPItx(ADC_idle_com); //idle mode, 24 bit
    
    GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1);               // Viene alzato il chip selector ADC per la lettura
}
//! <!-- [fun_ADC_Wakeup] -->
 
/*! \brief ADC Wakeup and 24 bits reading
*\param[in] line_to_read_to_select_ADCch0_ADCch1  : which of the 2 channels within the ADC has to be considered, if =50 ADC ch0 if =51 ADC ch 1
*\param[in] up_down                                                       : which boards: up or down
*\param[in] cosa_fare                                                       : cosa_fare=1 measurement is launched, but the result is not waited; cosa_fare=2 measurement is launched end the result is waited,
                                                                                                        cosa_fare=3 only the result is waited
*\return risultato                                                            : the measurement result in microV
 
*\snippetlineno ADC.c fun_ADC_lettura_24bit
*/
//! <!-- [fun_ADC_lettura_24bit] -->
long  int ADC_lettura_24bit(char line_to_read_to_select_ADCch0_ADCch1 , uint8_t up_down, uint8_t cosa_fare){
    //cosa_fare=1 measurement is launched, but the result is not waited
    //cosa_fare=2 measurement is launched end the result is waited
    //cosa_fare=3 only the result is waited
    //Exploting cosa_fare the ADCs can be operated in parallel. The parallel operation is not posssible 
    //with the 2 ADC of the same chip. If the function is called with cosa_fare= 2/3 with the same value of
    //up_down the results will be unpredictable.
    uint8_t ADC_0_o_1;
    uint8_t limite;
    ARM_SPI_STATUS errorone;
    unsigned  int           risultato_= 0xffffffff;
//  unsigned  long int          registro_di_controllo;
    if (up_down>1) up_down=1;
    status = SPIdrv->Control(SPI_control_for_relay_driver,spi_clock_for_relais);
    Aspetta_tanti_ms(1);
    long int    risultato=0;
    if ( ADC_node_map[line_to_read_to_select_ADCch0_ADCch1] < 16) ADC_0_o_1=0; 
    if ( (ADC_node_map[line_to_read_to_select_ADCch0_ADCch1] >=16) ) ADC_0_o_1=1;
 
    uint8_t ii=0,scelta_ADC=ADC_mode_reg_ch0, valore_da_trasmettere[4]={0,0,0,0};
    uint8_t indirizzo_registro_lettura=read_from_CH0 ;
    uint8_t valore_da_ricevere[4];
    const porta_pin_def  *ref_locale, *ref_locale_ADCready, *ref_locale_ResBuffer, *ref_locale_ResBuffer_;
    
    if ( up_down == I2C_mux_Scheda_giu){
        ref_locale =&ADC_Chip_Sel_down; 
        ref_locale_ADCready=&ADC_ready_down;    //Ready pin of ADC down
        ref_locale_ResBuffer = &ADC_ResIn_B_buffer_down;//switch for buffer resistor on/off
        ref_locale_ResBuffer_ = &ADC_ResIn_A_buffer_down;//switch for buffer resistor on/off
//      if( ADC_0_o_1){
//          ref_locale_ResBuffer = &ADC_ResIn_B_buffer_down;//switch for buffer resistor on/off
//      }else{
//          ref_locale_ResBuffer = &ADC_ResIn_A_buffer_down;//switch for buffer resistor on/off
//      }
    }else{
        ref_locale =&ADC_Chip_Sel_up;
        ref_locale_ADCready=&ADC_ready_up;  //Ready pin of ADC up
        ref_locale_ResBuffer = &ADC_ResIn_B_buffer_up;//switch for buffer resistor on/off
        ref_locale_ResBuffer_ = &ADC_ResIn_A_buffer_up;//switch for buffer resistor on/off
//      if( ADC_0_o_1){
//          ref_locale_ResBuffer = &ADC_ResIn_B_buffer_up;//switch for buffer resistor on/off
//      }else{
//          ref_locale_ResBuffer = &ADC_ResIn_A_buffer_up;//switch for buffer resistor on/off
//      }       
    }
    if (ADC_0_o_1==1){
        scelta_ADC=ADC_mode_reg_ch1; //indirizzo registro start misura
        indirizzo_registro_lettura=read_from_CH1; //indirizzo lettura misura
    }
    if (cosa_fare <=2 ){// Si sceglie di fare partire a misura
        ADC_sleep_ON_OFF(scheda_su_scheda_giu , 2 + ADC_sleep_off );  //ADC on se serve
//      ADC_Wakeup(up_down);
        GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 0); // Viene abbassato il chip selector ADC per la lettura
//      if( ADC_sleep_off==0){
//          GPIO_PinWrite(ref_locale_ResBuffer->porta_num, ref_locale_ResBuffer->pin_num, 0); // Togliamo il consumo che simula l'ADC
//          GPIO_PinWrite(ref_locale_ResBuffer_->porta_num, ref_locale_ResBuffer_->pin_num, 0); // Togliamo il consumo che simula l'ADC
//  }
        Aspetta_tanti_ms(7);
        //SI lancia la misura dell'ADC selezionato
        valore_da_trasmettere[0]= scelta_ADC; valore_da_trasmettere[1]= ADC_mode_reg_set_single_24bit;  
        evento_SPI=0;
        SPIdrv->Send ( &valore_da_trasmettere ,2); 
        limite=0;
//      while( (SPIdrv->GetStatus().busy) && (limite<10) ){
        while( (evento_SPI==0) && (limite<10) ){            
         Aspetta_tanti_ms(1);
            limite++;
        }
        if( (limite>=10) || Error_bad_operation){
            errorone=SPIdrv->GetStatus();
            status = SPIdrv->Control(ARM_SPI_ABORT_TRANSFER,0);
            ERROR_codifica_errore(up_down, error_address_SPI, Error_bad_operation, 1);
        }
        GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1); // Viene alzto il chip selector ADC per la lettura
    }
    if(cosa_fare > 1){//Polling di fine misura solo nei casi selezionati
        uint8_t registro38= (ADC_lettura_registro(ADC_0_o_1,up_down,0x38)>>16) & 0xFF;
        //Leggiamo il registro 0x38 per verificare che l'ADc non sia in standby
        if ( registro38 != 0x70){
            //Attesa misura disponibile
            limite=0;
            while (( GPIO_PinRead(ref_locale_ADCready->porta_num,ref_locale_ADCready->pin_num) == 1  )  && (limite<10)){
                         Aspetta_tanti_ms(1);
                        limite++;           
                        }
            if( (limite>=10) ) ERROR_codifica_errore(up_down, error_address_reg_ADC0, ADC_RDY_pin_fault, 1);
            
            GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 0); // Viene abbassato il chip selector ADC per la lettura
            //Leggiamo il risultato della lettura
            uint8_t dati_da_trasmettere[]={indirizzo_registro_lettura,0,0,0};   
            SPIdrv->Transfer (&dati_da_trasmettere, &valore_da_ricevere ,4);
            limite=0;
            while( (SPIdrv->GetStatus().busy) && (limite<10) ){
                         Aspetta_tanti_ms(1);
                        limite++;
        }
            if( (limite>=10) || Error_bad_operation){
                errorone=SPIdrv->GetStatus();
                status = SPIdrv->Control(ARM_SPI_ABORT_TRANSFER,0);
                ERROR_codifica_errore(up_down, error_address_SPI, Error_bad_operation, 1);
            }
        
                GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1); // Viene alzto il chip selector ADC per la lettura
            //Il primo byte letto \'e il MSB
            risultato_ =(valore_da_ricevere[1]<<16) + (valore_da_ricevere[2]<<8 )+( valore_da_ricevere[3] );
 
            GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1); // Viene alzato il chip selector ADC 
//              if( ADC_sleep_off==0){
//                  GPIO_PinWrite(ref_locale_ResBuffer->porta_num, ref_locale_ResBuffer->pin_num, 1); // Riconsumiamo dummy
//                  GPIO_PinWrite(ref_locale_ResBuffer_->porta_num, ref_locale_ResBuffer_->pin_num, 1); // Riconsumiamo dummy
//              }
                /*  Per convertire il risultato in MICROVOLT si dovrebbe fare: (risultato/2^24*20E6) -10E6
                        Una formula equivalente \'e:        { [(risultato*2)-(2^24)]*10E6 } / 2^24  
                        Notando che 10^6 = (78125  * 2^7)   allora   10^6 / 2^24 = 78125 / 2^17             */
            risultato = (  (long long int) ( (int)(risultato_ << 1) - (1 << 24) ) * 78125  ) >> 17 ;
        }
//      ADC_Sleep_fun(up_down + +ADC_sleep_off);
        ADC_sleep_ON_OFF(scheda_su_scheda_giu , 0 + ADC_sleep_off );  //ADC off se serve
    }
        
    return risultato;  //Risultato in microV
}
//! <!-- [fun_ADC_lettura_24bit] -->
 
 
/*!  \brief This function allows to read a whatver regsiter of the ADC
\param[in] line_to_read    : the read node 
\param[in] lettura_ADC     : the value read from the ADC, in microV
\param[in] lettura_offset  : the offset read from the ADC, this is proportional to the input current, in microV
 
*\return   risultato_intermedio is the voltage at the actual node in microV.
 
*\snippetlineno Adc.c fun_ADC_compensazione_al_nodo
*/
//! <!-- [fun_ADC_compensazione_al_nodo] -->
int ADC_compensazione_al_nodo(uint8_t line_to_read , int32_t lettura_ADC , int32_t lettura_offset){
    long int risultato_intermedio= lettura_ADC;
    //Questo varrebbe se il nodo di lettura fosse cortocircuitato a gnd
//  risultato_intermedio = risultato_intermedio - lettura_offset + ((risultato_intermedio - lettura_offset)*ADC_coefficiente[line_to_read].numeratore) / ADC_coefficiente[line_to_read].denominatore ;
    //Questo vale se la sola re all'ingresso dell'oa fosse presente
    risultato_intermedio = risultato_intermedio  + ((risultato_intermedio - lettura_offset)*ADC_coefficiente[line_to_read].numeratore) / ADC_coefficiente[line_to_read].denominatore ;  
    if( (line_to_read >= node_voltage_Analog_Mux_0_offset  ) && (line_to_read <= node_voltage_Analog_Mux_meas_input_bias_neg  ) ){
        risultato_intermedio = (risultato_intermedio * ADC_coefficiente[indice_attenuatore_BIAS].numeratore ) / ADC_coefficiente[indice_attenuatore_BIAS].denominatore ;
    }
    return risultato_intermedio;
}
//! <!-- [fun_ADC_compensazione_al_nodo] --
 
/*!  \brief This function allows to read a whatver regsiter of the ADC
 
\param[in] ADC_0_o_1     : which of the 2 ADCs the register is considered
\param[in] up_down       : which of the 2 ADCs to consider
\param[in] registro_ch0  : the address of the register to read. the address is for ch0. If ch1 is selected according to ADC_0_o_1
 
*\return   ADC_misura_fatta is the voltage measured in microV.
 
*\snippetlineno Adc.c fun_ADC_lettura_registro
*/
//! <!-- [fun_ADC_lettura_registro] -->
uint32_t ADC_lettura_registro(char ADC_0_o_1 /*0=ADC0, 1=ADC1*/, uint8_t up_down, uint8_t registro_ch0){
 
//  unsigned  long int          registro_di_controllo;
    long int    risultato=0;
    uint8_t byte_da_trasmettere_ricevere=2;
    if(up_down>1)up_down=1;
    if( (registro_ch0>=5) && (registro_ch0<=0x18) ) byte_da_trasmettere_ricevere=4;
 
    uint8_t ii=0,scelta_ADC=ADC_mode_reg_ch0, valore_da_ricevere[4]={0,0,0,0}, registro_lettura=read_from_CH0 ;
    
    const porta_pin_def  *ref_locale, *ref_locale_ADCready;
    
    if ( up_down == I2C_mux_Scheda_giu){
        ref_locale =&ADC_Chip_Sel_down;             
    }else{
        ref_locale =&ADC_Chip_Sel_up;
    }
    
    if (registro_ch0 ==0x38){
        registro_lettura= registro_ch0 +0x40; //il mode register, 0x38 si pu\'o leggere solo sul canale CH0
    }else{
            registro_lettura= registro_ch0 + ADC_0_o_1*2 +0x40;
    }
 
    
GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 0); // Viene abbassato il chip selector ADC per la lettura
 
//  SPIdrv->Receive ( &valore_da_trasmettere ,3);
    uint8_t istruzione[]={registro_lettura,0,0,0};  
    SPIdrv->Transfer (&istruzione, &valore_da_ricevere ,byte_da_trasmettere_ricevere);
//  while( (SPIdrv->GetStatus().busy)  ){}
        
            uint8_t troppa_attesa=0;
            while( (SPIdrv->GetStatus().busy) && (troppa_attesa <250) ){
                Aspetta_tanti_ms(1);
                troppa_attesa++;
            } //wait end of transmission     ;
            if((troppa_attesa>=250) || (Error_bad_operation)) ERROR_codifica_errore(scheda_su_scheda_giu, error_address_SPI, SPI_error_EVENT_DATA_LOST,1);      
    
GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1); // Viene abbassato il chip selector ADC per la lettura
   if( byte_da_trasmettere_ricevere ==4){
        risultato = (valore_da_ricevere[1]<<16) + (valore_da_ricevere[2]<<8) + (valore_da_ricevere[3]);
     }else{
         risultato = (valore_da_ricevere[1]);
     }
return          risultato;  
}
//! <!-- [fun_ADC_lettura_registro] -->
 
 
/*!  \brief This function allows to read a whatver regsiter of the ADC
 
\param[in] ADC_0_o_1                : which of the 2 ADCs the register is considered
\param[in] up_down                  : which of the 2 ADCs to consider
\param[in] indirizzo_registro_ch0   : the address of the register to read. the address is for ch0. If ch1 is selected according to ADC_0_o_1
\param[in] value_to_write           : the value to write in the register
 
*\return   no return.
 
*\snippetlineno Adc.c fun_ADC_scrittura_registro
*/
//! <!-- [fun_ADC_scrittura_registro] -->
void  ADC_scrittura_registro(char ADC_0_o_1 /*0=ADC0, 1=ADC1*/, uint8_t up_down, uint8_t indirizzo_registro_ch0, int32_t value_to_write){
//  unsigned  long int          registro_di_controllo;
 
    uint8_t byte_da_trasmettere_ricevere=2;
    if(up_down>1)up_down=1;
    if( (indirizzo_registro_ch0>=5) && (indirizzo_registro_ch0<=0x18) ) byte_da_trasmettere_ricevere=4;
 
    uint8_t ii=0,scelta_ADC=indirizzo_registro_ch0, *valore_da_trasmettere, registro_scrittura=value_to_write ;
    
    const porta_pin_def  *ref_locale, *ref_locale_ADCready;
    
    if ( up_down == I2C_mux_Scheda_giu){
        ref_locale =&ADC_Chip_Sel_down;             
    }else{
        ref_locale =&ADC_Chip_Sel_up;
    }
    
    if (indirizzo_registro_ch0 ==0x38){
        registro_scrittura= indirizzo_registro_ch0 ; //il mode register, 0x38 si pu\'o leggere solo sul canale CH0
    }else{
            registro_scrittura= indirizzo_registro_ch0 + ADC_0_o_1*2 ;
    }
 
    valore_da_trasmettere= (uint8_t *) &value_to_write ;
    
 GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 0); // Viene abbassato il chip selector ADC per la lettura
 
//  SPIdrv->Receive ( &valore_da_trasmettere ,3);
    uint8_t istruzione[]={registro_scrittura,valore_da_trasmettere[0],valore_da_trasmettere[1],valore_da_trasmettere[2]};   
    SPIdrv->Send ( &istruzione ,byte_da_trasmettere_ricevere);
//  while( (SPIdrv->GetStatus().busy)  ){}
        
            uint8_t troppa_attesa=0;
            while( (SPIdrv->GetStatus().busy) && (troppa_attesa <250) ){
                Aspetta_tanti_ms(1);
                troppa_attesa++;
            } //wait end of transmission     ;
            if((troppa_attesa>=250) || (Error_bad_operation)) ERROR_codifica_errore(scheda_su_scheda_giu, error_address_SPI, SPI_error_EVENT_DATA_LOST,1);
    
 GPIO_PinWrite(ref_locale->porta_num, ref_locale->pin_num, 1); // Viene abbassato il chip selector ADC per la lettura
 
    
}
//! <!-- [fun_ADC_scrittura_registro] -->
 
/*!  \brief This function allows to read the voltage of any of the selectable nodes
*\param[in] scheda_su_scheda_giu_  : which boards: up or down
*\param[in] node_to_read          : which of the 49 nodes to read
*\param[in] cosa_fare             : cosa_fare=1 measurement is launched, but the result is not waited; 
                                                                 \n cosa_fare=2 measurement is launched and the result is waited; 
                                                                 \n cosa_fare=3 only the result is waited
*\return ADC_misura_fatta         : the measurement result
 
*\snippetlineno Adc.c fun_ADC_lettura
*/
//! <!-- [fun_ADC_lettura] -->
int32_t ADC_lettura(uint8_t scheda_su_scheda_giu_, uint8_t node_to_read, uint8_t cosa_fare){
    //Da implementare: lettura di un qualsiasi nodo con ADC interno
        status = SPIdrv->Control(SPI_control_for_relay_driver,spi_clock_for_relais);
        if(scheda_su_scheda_giu_>1)scheda_su_scheda_giu_=1;
    if( cosa_fare <=2){
            //Si seleziona l'analog mux sulla mainboard, se serve
        if ( (node_to_read >= node_voltage_Analog_Mux_0_offset ) ){//Questo \'e il mux della mainboard A
            Analog_mux_line_to_select_deselect(scheda_su_scheda_giu_, node_to_read & 0xF, 1);
        }       
            //si seleziona l'analog mux  sulla postmainboard
            Analog_mux_line_to_select_deselect_for_postmainboard ( scheda_su_scheda_giu_,  node_to_read,  1 )       ;
            //si toglie la res da 10k, questo viene fatto all'interno della funzione della lettura ADC
            //si seleziona l' ADC       
            //si spara la misura in parallelo
            ADC_misura_fatta = ADC_lettura_24bit( node_to_read, scheda_su_scheda_giu_,  cosa_fare);  //Lancio la misura con (2)(non in parallelo) o senza (1) polling
    }
 
    if ( cosa_fare ==3){
        //si leggono solo gli ADC
        ADC_misura_fatta = ADC_lettura_24bit( node_to_read, scheda_su_scheda_giu_, 3 ); 
    }
    if( cosa_fare>=2){
        //Si de-seleziona l'analog mux sulla mainboard, se serve
        if ( (node_to_read >= node_voltage_Analog_Mux_0_offset ) ){//Questo \'e il mux della mainboard A
            Analog_mux_line_to_select_deselect(scheda_su_scheda_giu_, node_to_read & 0xF, 0);
        }       
        //si de-seleziona l'analog mux  sulla postmainboard
            Analog_mux_line_to_select_deselect_for_postmainboard ( scheda_su_scheda_giu_,  node_to_read,  0 )       ;
    }
//      uint8_t numeratore=1, denominatore=1;  //Attenuation is always 1 but with detector bias
//      if( (node_to_read >=node_voltage_Analog_Mux_0_offset) && (node_to_read <=(node_voltage_Analog_Mux_0_offset +14))){ //14=12 bias voltage  + 2 external bias
//          numeratore=ADC_numeratore_Bias;
//          denominatore= ADC_denominatore_Bias;
//      }
//      ADC_misura_fatta = (ADC_misura_fatta *numeratore) / denominatore;
//      ADC_misura_fatta = (ADC_misura_fatta * ADC_coefficiente[node_to_read / ADC_molteplicita_node_to_read].numeratore )\
//                      / ADC_coefficiente[node_to_read / ADC_molteplicita_node_to_read].denominatore ;
 
    return ADC_misura_fatta;
}
//! <!-- [fun_ADC_lettura] -->
 
 
/*!  \brief All the posible nodes voltages can be read with this instruction. Either the internal or
an external ADC can be used. The external ADC option will become obsolote at the time of installation.
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Adc.c fun_instr_ADC_LETTURA_function
*/
//! <!-- [fun_instr_ADC_LETTURA_function] -->
void instr_ADC_LETTURA_function(void){
    uint8_t offset,nodo_da_leggere = tx_data[6], iii;
    uint8_t ADC_interno_esterno= tx_data[5] & 1;
    uint8_t ADC_diff_1_single_0= tx_data[5] >>1 & 1;
    int32_t ADC_misura_fatta_neg=0, ADC_misura_fatta_pos=0,ADC_misura;
    
    scheda_su_scheda_giu =  (nodo_da_leggere >>7) & 1;
    nodo_da_leggere = nodo_da_leggere & 0x7F ;
//  if ( (nodo_da_leggere >= node_voltage_Analog_Mux_0_offset ) & ADC_interno_esterno){//L'ADC ha gi\'a implementato il mux.
//      Analog_mux_line_to_select_deselect(scheda_su_scheda_giu, nodo_da_leggere , 1);
//  }
        if( vettore_istruzioni[3]==1){ 
            ADC_non_leggi_lo_offset_se_true=true; 
        }else{
            ADC_non_leggi_lo_offset_se_true=false;
        }
    ADC_medie_per_misura = (uint8_t) vettore_istruzioni[4];
        if (ADC_medie_per_misura==0) ADC_medie_per_misura=1;
        if( ADC_medie_per_misura >200) ADC_medie_per_misura=200;    
    
//  if(ADC_interno_esterno){
//      //Lettrura con ADC esterno
//      ADC_misura_fatta_pos=  preamplifier_ADC_external_measured_node_function(scheda_su_scheda_giu , nodo_da_leggere);
//      *(int32_t *)tx_data = ADC_misura_fatta;     
////        ADC_misura_fatta = (ADC_misura_fatta * ADC_coefficiente[nodo_da_leggere / ADC_molteplicita_node_to_read].numeratore )\
////                        / ADC_coefficiente[nodo_da_leggere / ADC_molteplicita_node_to_read].denominatore ;      
//  }else{
//      //Lesstura con ADC interno
//      ADC_sleep_ON_OFF(scheda_su_scheda_giu , 2);  //ADC ON
//      uint8_t provvisorio= ADC_sleep_off;
//      ADC_sleep_off=10; //ADC smpre accesi durante la media
//      for(iii=0; iii<ADC_medie_per_misura;iii++){
//              ADC_misura= ADC_lettura(scheda_su_scheda_giu, nodo_da_leggere,  2);
//              int risul_vof= (ADC_lettura_24bit( nodo_da_leggere,scheda_su_scheda_giu, 2) ) ;
//              ADC_misura_fatta_pos += ADC_compensazione_al_nodo(nodo_da_leggere,ADC_misura, risul_vof);           
//              if( nodo_da_leggere <= node_voltage_PreOut_ch_5  ){//PGA o Pre out
//                  ADC_misura = ADC_lettura(scheda_su_scheda_giu, nodo_da_leggere + 6,  2);
//                  risul_vof= (ADC_lettura_24bit( nodo_da_leggere+6,scheda_su_scheda_giu, 2) ) ;
//                  ADC_misura_fatta_neg += ADC_compensazione_al_nodo(nodo_da_leggere+6,ADC_misura, risul_vof);             
//              }
//  }   
//      ADC_sleep_off = provvisorio;
//      ADC_sleep_ON_OFF(scheda_su_scheda_giu , 0 + ADC_sleep_off );  //ADC off se serve
//      ADC_misura_fatta_pos = ADC_misura_fatta_pos / ADC_medie_per_misura;
//      ADC_misura_fatta_neg = ADC_misura_fatta_neg / ADC_medie_per_misura;
//  
//      if(ADC_diff_single ){// misure positiva e negativa in mV
//              *(int16_t *)&tx_data[0] = (ADC_misura_fatta_pos / 1000) & 0xffff;
//              *(int16_t *)&tx_data[2] = (ADC_misura_fatta_neg / 1000) & 0xffff;
//      }else{  //misura standard differenziale
//              *(int32_t *)tx_data = ADC_misura_fatta_pos - ADC_misura_fatta_neg;
//      }
//  }
 
    ADC_misura_fatta_pos = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,ADC_interno_esterno,nodo_da_leggere,ADC_diff_1_single_0);
    if (ADC_diff_1_single_0==0){
            if( nodo_da_leggere <= node_voltage_PreOut_ch_5 ){
                offset=6;
                ADC_misura_fatta_neg = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,ADC_interno_esterno,nodo_da_leggere+offset,ADC_diff_1_single_0);
            }else if (nodo_da_leggere >= node_voltage_Analog_Mux_meas_bias_pos_ch0 ){
                offset=1;
                ADC_misura_fatta_neg = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,ADC_interno_esterno,nodo_da_leggere+offset,ADC_diff_1_single_0);
            }
        }
    
    if(ADC_interno_esterno){
        *(int32_t *)tx_data = ADC_misura_fatta_pos;
    }else if ( (ADC_diff_1_single_0==0) && ( ( nodo_da_leggere <= node_voltage_PreOut_ch_5 ) ||\
                        (nodo_da_leggere >= node_voltage_Analog_Mux_meas_bias_pos_ch0 )) ){// misure positiva e negativa in mV
                *(int16_t *)&tx_data[0] = (ADC_misura_fatta_pos / 1000) & 0xffff;
                *(int16_t *)&tx_data[2] = (ADC_misura_fatta_neg / 1000) & 0xffff;
    }else{  //misura standard differenziale
                *(int32_t *)tx_data = ADC_misura_fatta_pos - ADC_misura_fatta_neg;
        }
 
}
//! <!-- [fun_instr_ADC_LETTURA_function] -->
 
 
 
/*!  \brief This function performs a differential or single ended measurement on nodes.
 
\param[in] scheda_su_scheda_giu      : the board to consider
\param[in] nodo_da_leggere           : the positive node to read (the negtive node is the positive plus an offset determined by the function)
\param[in] differenziale_1_single_0  : information about the measurement to perform
 
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Adc.c fun_ADC_misura_differenziale_single_ended
*/
//! <!-- [fun_ADC_misura_differenziale_single_ended] -->
static int32_t ADC_misura_differenziale_single_ended(uint8_t scheda_su_scheda_giu , uint8_t nodo_da_leggere, uint8_t differenziale_1_single_0 ){
    int32_t ADC_misura_fatta_pos=0, ADC_misura_fatta_neg=0,risul_vof=0;
    uint8_t offset;
        {   
            ADC_misura_fatta_pos= ADC_lettura(scheda_su_scheda_giu, nodo_da_leggere,  2);
            if(ADC_non_leggi_lo_offset_se_true){
                risul_vof=0;
            }else{
            risul_vof= (ADC_lettura_24bit( nodo_da_leggere,scheda_su_scheda_giu, 2) ) ;
            }
            ADC_misura_fatta_pos = ADC_compensazione_al_nodo(nodo_da_leggere,ADC_misura_fatta_pos, risul_vof);          
        }
        if(differenziale_1_single_0){//PGA o Pre out neg 
            if( nodo_da_leggere <= node_voltage_PreOut_ch_5 ){
                offset=6;
            }else{
                offset=1;
            }
            ADC_misura_fatta_neg = ADC_lettura(scheda_su_scheda_giu, nodo_da_leggere + offset,  2);
            if(ADC_non_leggi_lo_offset_se_true){
                risul_vof=0;
            }else{          
            risul_vof= (ADC_lettura_24bit( nodo_da_leggere+6,scheda_su_scheda_giu, 2) ) ;
            }
            ADC_misura_fatta_neg = ADC_compensazione_al_nodo(nodo_da_leggere+offset,ADC_misura_fatta_neg, risul_vof);               
        }else{
            ADC_misura_fatta_neg=0;
        }
    return ADC_misura_fatta_pos = ADC_misura_fatta_pos - ADC_misura_fatta_neg;
}
//! <!-- [fun_ADC_misura_differenziale_single_ended] -->
 
 
 
/*!  \brief This function sets the original gain when a few LSb have to be determined. The umber of bits
is bit_to_go.
 
*\param[in]  scheda_su_scheda_giu_                     : the selected board
*\param[in]  preamplifier_externalADC_1_onboardADC_0   : the chosen between the external ADC (1), or the internal ADC (0)
*\param[in]  nodo_da_misurare                          : the channel number of PGA
*\param[in]  differenziale_1_single_0                  : the measurement type
 
*\return   ADC_misura_fatta   : the final measurement
 
*\snippetlineno .\Adc.c fun_ADC_misura_differenziale_con_media_at_PGA
*/
//! <!-- [fun_ADC_misura_differenziale_con_media_at_PGA] -->
int32_t ADC_misura_differenziale_con_media_generico(uint8_t scheda_su_scheda_giu_, uint8_t preamplifier_externalADC_1_onboardADC_0, uint8_t nodo_da_misurare, uint8_t differenziale_1_single_0){
    
    uint16_t iii, media_prov=ADC_medie_per_misura;
    int32_t ADC_misura_fatta_prov, ADC_misura_fatta_prov_vet[200], maggiore, minore,scarto=0,sigmetta=0;
//  int64_t sigma2=0;
    if( ADC_medie_per_misura==0) {
        ADC_medie_per_misura=1;
        media_prov=ADC_medie_per_misura;
    }
    scheda_su_scheda_giu=scheda_su_scheda_giu_;
                                //Misuro con ADC da scegliere
                            if( preamplifier_externalADC_1_onboardADC_0){
                                //Misura con adc esterno
                                ADC_misura_fatta = preamplifier_ADC_external_measured_node_function(scheda_su_scheda_giu_, nodo_da_misurare);
                            }else{
                                //Misuro con adc interno
                                ADC_sleep_ON_OFF(scheda_su_scheda_giu , 2);  //ADC sempre ON durante la misura
                                uint8_t provvisorio= ADC_sleep_off; 
                                ADC_sleep_off=10;
                                ADC_misura_fatta_prov=0;
                                Aspetta_tanti_ms(50);
                                for(iii=0; iii<ADC_medie_per_misura;iii++){
                                    ADC_misura_fatta_prov_vet[iii] = ADC_misura_differenziale_single_ended(scheda_su_scheda_giu_,nodo_da_misurare,differenziale_1_single_0);
//                                  ADC_misura_fatta_prov_vet[iii] = ADC_misura_differenziale(scheda_su_scheda_giu_ , nodo_da_misurare );
                                    ADC_misura_fatta_prov +=ADC_misura_fatta_prov_vet[iii];
                                }
                                ADC_misura_fatta_prov = ADC_misura_fatta_prov / ADC_medie_per_misura;                               
                                for(iii=0; iii<ADC_medie_per_misura;iii++){
                                    //Misuriamo la sigma
                                    if( ADC_misura_fatta_prov_vet[iii] >= ADC_misura_fatta_prov){
                                        sigmetta += ADC_misura_fatta_prov_vet[iii] - ADC_misura_fatta_prov;
                                    }else{
                                        sigmetta += ADC_misura_fatta_prov - ADC_misura_fatta_prov_vet[iii] ;
                                    }
                                    
                                }
                                sigmetta= sigmetta / ADC_medie_per_misura; 
                                //3 sigma sono circa 4 volte il valore ottenuto con l'integrale del modulo: 3sigma=3(pi/2)^.5sigmetta=3.8sigmetta
                                maggiore= ADC_misura_fatta_prov + 4 * sigmetta;
                                minore= ADC_misura_fatta_prov - 4 * sigmetta;
                                for(iii=0; iii<ADC_medie_per_misura;iii++){
                                    if( (ADC_misura_fatta_prov_vet[iii] > maggiore) || (ADC_misura_fatta_prov_vet[iii] < minore)){
                                        //I punti fuori gaussiana li buttiamo
                                                media_prov--;
                                                scarto +=ADC_misura_fatta_prov_vet[iii];
                                    }
                                }
                                if( media_prov){
                                    ADC_misura_fatta = ( ADC_misura_fatta_prov * ADC_medie_per_misura - scarto) /  media_prov ;                             
                                }else{
                                    ADC_misura_fatta = ADC_misura_fatta_prov;
                                }
                                    ADC_sleep_off = provvisorio;  //Rimettiamo l'adc come serve
                                    ADC_sleep_ON_OFF(scheda_su_scheda_giu , 0 + ADC_sleep_off );  //ADC off se serve
                            }
            return  ADC_misura_fatta;
}
//! <!-- [fun_ADC_misura_differenziale_con_media_at_PGA] -->
 
 
//CROSS FINE
 
/*****************************************************************************
  SPItx
******************************************************************************/
/*!  \brief This is a blocking function that transmits one byte over the SPI
\param[in] dato the byte to be transmitted                                                                                                              
*\return   No output
 
*\snippetlineno Adc.c fun_SPItx
*/
//! <!-- [fun_SPItx] -->
void SPItx(unsigned char dato){
// Trasmissione di 1 byte via SPI
    LPC_SPI->SPDR=dato;                                                 // Viene trasmesso il dato
    while (!((LPC_SPI->SPSR & 0x80) == 0x80)){} // Si attende che il flag SPIF si alzi
    dato=LPC_SPI->SPSR;                                                 // Dummy op per azzerare lo status reg
    dato=LPC_SPI->SPDR;                                                 // Dummy op necessaria
}
//! <!-- [fun_SPItx] -->
 
unsigned int Radc_internal=15e6; //!< The ADC has 2 interbnal resistors R=Radc_internal and 7R. The resistor is experessed in mOhm
unsigned int Rmultiplexer=200e3; //!< This is the multiplexer resistor and the series resistor connected in series to it
 
struct coeffcienti_misura_ADC_type coeffcienti_misura_ADC[indice_default+1];
unsigned char coeffcienti_misura_ADC_nodi[72];
unsigned char medie_ADC= 2 ; //!< The number of averages done is 1 <<  medie_ADC, or 2^medie_ADC
 
    
 
 
 
 
void calibrazione_Resistenze_sterne_ADC(void){
    
    long int voltage_10k,voltage_for_Rmul;
    
//  selfcal_ADC();  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    
    //Leggiamo dal nodo a 10k verso massa
//  voltage_10k = lettura_ADC( ADC_GND_con_10k);
    Radc_internal =( R_ref_10k * ( ADC_reference_voltage - voltage_10k) ) / 8 / voltage_10k; 
    
    //Cerchiamo di determinare anche Rmultiplexer
//  voltage_for_Rmul = lettura_ADC( ADC_Misura_bias_20_att_ch1_p); //Usato fino a che non si \'e usato la lettura del bias esterno
//  voltage_for_Rmul = lettura_ADC( ADC_Misura_bias_20_att_ch0_p);
    Rmultiplexer = (8 * Radc_internal  ) ;
    Rmultiplexer = ( Rmultiplexer / ( ADC_reference_voltage - voltage_for_Rmul) ) * voltage_for_Rmul;
    
    coeffcienti_misura_ADC[indice_Vbias].coefficiente_Vmeas = Coefficiente_Vmeas_Vbias;
    coeffcienti_misura_ADC[indice_Vbias].coefficiente_Vref = Coefficiente_Vref_Vbias;
    coeffcienti_misura_ADC[indice_Vbias].partizione_per_1000 = bias_reading_attenuation;
 
    coeffcienti_misura_ADC[indice_PoerSupply].coefficiente_Vmeas = Coefficiente_Vmeas_PowerSupply;
    coeffcienti_misura_ADC[indice_PoerSupply].coefficiente_Vref = Coefficiente_Vref_PowerSupply;
    coeffcienti_misura_ADC[indice_PoerSupply].partizione_per_1000 = 1024;
 
    coeffcienti_misura_ADC[indice_default].coefficiente_Vmeas = Coefficiente_Vmeas_deafult;
    coeffcienti_misura_ADC[indice_default].coefficiente_Vref = Coefficiente_Vref_default;
    coeffcienti_misura_ADC[indice_default].partizione_per_1000 = 1024;
    
    coeffcienti_misura_ADC[indice_100_ohm].coefficiente_Vmeas = Coefficiente_Vmeas_100_ohm;
    coeffcienti_misura_ADC[indice_100_ohm].coefficiente_Vref = Coefficiente_Vref_100_ohm;
    coeffcienti_misura_ADC[indice_100_ohm].partizione_per_1000 = 1024;
    
    coeffcienti_misura_ADC[indice_10_Kohm].coefficiente_Vmeas = Coefficiente_Vmeas_10k_ohm;
    coeffcienti_misura_ADC[indice_10_Kohm].coefficiente_Vref = Coefficiente_Vref_10k_ohm;
    coeffcienti_misura_ADC[indice_10_Kohm].partizione_per_1000 = 1024;  
    
    coeffcienti_misura_ADC[indice_Vbias_extern].coefficiente_Vmeas = Coefficiente_Vmeas_Vbias_extern;
    coeffcienti_misura_ADC[indice_Vbias_extern].coefficiente_Vref = Coefficiente_Vref_Vbias_extern;
    coeffcienti_misura_ADC[indice_Vbias_extern].partizione_per_1000 = bias_reading_attenuation_extern;
 
 
//mux 1
coeffcienti_misura_ADC_nodi[ADC_GND_con_10k]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_Vdig5V_micro_passed]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_Vcc]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_Vee]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_JFET_c_ch1_S2]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_PRE_term_ch1]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_pos_in_ch1]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_neg_in_ch1]=indice_default;
//mux 2
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_10_att_ch1_p]=indice_Vbias;
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_10_att_ch1_n]=indice_Vbias;
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_20_att_ch1_p]=indice_Vbias_extern;
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_20_att_ch1_n]=indice_Vbias_extern;
coeffcienti_misura_ADC_nodi[ADC_CommonMode_ch1]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_CommonMode_ch2]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_pos_out_ch1]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_neg_out_ch1]=indice_default;
//mux 3
coeffcienti_misura_ADC_nodi[ADC_Vdig5V_micro_in]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_Vcc_in]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_Vee_in]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_Vref_pos_in]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_Vref_neg_in]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_PRE_term_ch2]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_pos_in_ch0]=indice_100_ohm;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_neg_in_ch0]=indice_100_ohm;
//mux 4
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_10_att_ch0_p]=indice_Vbias;
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_10_att_ch0_n]=indice_Vbias;
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_20_att_ch0_p]=indice_Vbias;
coeffcienti_misura_ADC_nodi[ADC_Misura_bias_20_att_ch0_n]=indice_Vbias;
coeffcienti_misura_ADC_nodi[ADC_JFET_c_ch0_S1]=indice_PoerSupply;
coeffcienti_misura_ADC_nodi[ADC_JFET_c_ch0_S2]=indice_default;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_pos_out_ch0]=indice_100_ohm;
coeffcienti_misura_ADC_nodi[ADC_ADC_PGA_neg_out_ch0]=indice_100_ohm;
}
 
int correzione_misura_ADC(char quali_coefficienti, int misura){
    
    long long int primo_termine;
    long long int secondo_termine;
    signed char segno=1;
    
    primo_termine= (long long int)misura * (coeffcienti_misura_ADC[quali_coefficienti].coefficiente_Vmeas >> 10) - (coeffcienti_misura_ADC[quali_coefficienti].coefficiente_Vref>>10) * (long long int)ADC_reference_voltage ;
    if (primo_termine <0){
        segno=-1*segno;
        primo_termine=primo_termine*segno;
    }
    secondo_termine = primo_termine / (long long int)(RADC_tot>>10) ;
//  secondo_termine=divisione_di_gianlu( primo_termine , (RADC_tot>>10));
    secondo_termine = (secondo_termine * coeffcienti_misura_ADC[quali_coefficienti].partizione_per_1000) >> 10 ;
    secondo_termine=secondo_termine*segno;
return secondo_termine;
    
}
 
/*! \brief The division operator on 32 or 64 bit, positive/negative integers
 
*@param[in] Numeratore the numerator;
*\param[in] denominatore the denominator;
*\return The result
*/
long long int divisione_di_gianlu( long long int Numeratore, long long int denominatore) {
    
//  #define meta_scala 0x8000000000000000
    char ii,passi_da_fare=64;
    char aa=0;
    long long int risultato=0,temporaneo=0;
    //meta_scala=(1 << 63);;
    
    if (Numeratore < 0) {  //La divisione funziona se abbiamo numeri > 0, perci\'o positivizziamo e aggiorniamo dopo
        aa++;
        Numeratore=-Numeratore;
    }
    if (denominatore<0){
        aa++;
        denominatore=-denominatore;
    }
    if(Numeratore < 0x100000000){ //Se minore di 2^32 \'e inutile considerare altri 32 bit
        passi_da_fare=32;
            }
    
    for( ii=1; ii <= passi_da_fare; ii++) { // E' come nelle divisioni normali, confrontiamo le cifre + significative con il denominatore
        temporaneo=(temporaneo <<1); //Temporaneo contiene le cifre piu' significative che stiamo valutando
        risultato= (risultato << 1); //Risultato contiene il risultato della divisione mentre si forma
        if ( (Numeratore >> (passi_da_fare-1) ) & 1 /*(Numeratore & meta_scala) >0 */) {//Abbiam oruotato a sx tempraneo, la LSB \'e 0. Gli mettiamo un 1 se il MSB di numeratore, che verr\'a ruotato, \'e 1
            temporaneo=temporaneo+1;
        }
        if ( temporaneo >= denominatore) {// Ogni volta che temporaneo \'e > di denominatore glielo togliamo, ed aggiungiamo 1 a risultato
            temporaneo=temporaneo-denominatore;
            risultato++;
        }  // Alla fine temporaneo contiene il resto della divisione, che deve essere < di denominatore
        Numeratore=(Numeratore << 1);
        
    }
    if ( aa==1) risultato=-risultato; //La divisione \'e un numero negativo
    return risultato;  // In questo programma non siamo interessati al resto della divisione
}