main_for_CROSS_FrontEnd.c

Go to the documentation of this file.

 
/*****DOCUMENTAZIONE DOXYGEN             (premi il - a sinistra per ridurla a icona) il manuale html \'e nella cartella************/
/// \file
 
/*! 
 
\mainpage  Introduction
\brief <span style="color:red;"> The firmware and setup of the PostFrontend board of the CROSS experiment </span>
 
 @author    INFN Milano Bicocca
 @date          Start: November 2020
<hr width="90%" size="10" align="left"> 
 
 
  \tableofcontents
 
 \b SUMMARY:
*\arg \ref section0
*\arg \ref section1
*\arg \ref subsection2
 
 \section section0 Information about the creation of this documentation
 <hr width="90%" size="10" align="left">
 
 \n This documentation is based on the Doxygen editor. The files used to run Doxygen are in the folder \b "DocumentazionePerDoxygen" which is in the folder of the 
 fw project \b "FW_CROSS_POSTFRONTEND". The repository of all the generated html files are in the sub-folder \b "html". 
 \n The configuration file that must be loaded in \b Doxywizard, the Doxygen compilator to be run, is \b "Doxyfile_CROSS_POSTFRONTEND". There is a file \b "lista_file_cartelle.txt"
 that must be included at the end of the configuration file by the command \b "@INCLUDE = lista_file_cartelle.txt". This file allow to reduce the list of the processed files. 
 It is useful when we want to run Doxywizard faster. If the latex version of the documentation has to be generated, 
 then the order of the chapters follows the alphabetic order, unless the file order is indicated in INPUT. 
 In this case do not forget to write "../" in front of the project file name.
 
\remark If the configuration file is saved from the \b Doxywizard the command @INCLUDE =.. or any added command of the form @... are lost and must be re-added at the end of the 
configuration fileopen in text mode.
 
 \n The layout of this web setup is in \b "Gianlu_layoutdoxy_CROSS_POSTFRONTEND.xml". 
 \n Figures are in the sub-folder: \b "Figure".
 \n Other files used for web are \b "new_footer_gianlu.html" for "HTML_FOOTER" and \b "doxygen_gianlu.css" for "HTML_STYLESHEET", while for Latex is: \b "new_header_gianlu.tex".
 Best way to understand the meaning of these 3 files is to open them with a tex editor.
 \n The \b pdf versione of this documentation is here: <a href="https://pessina.mib.infn.it/CROSS/refman.pdf"  target=_blank><b>refman.pdf</b></a>
 
 \remark After any change it is important to reload the projec file in \b Doxywizard. Sometimes, the modifications are not set 
 if \b Doxywizard is only closed and the re-open.
     
 \section section1 General description
 <hr width="90%" size="10" align="left">
 
\subsection subsection1 General idea
 
\n The PostFrontEnd board manages the FrontEnd from the detector to the antialiasing/DAQ board. It has an ARM microprocessor with which 
manages 12 channels, or 2 FrontEnd boards (6 channels each) which are located on the frdge. This split is intended for minimizing EMI disturbances close to the detectors. 
Communication from the PostFrontEnd to the FrontEnd is via \b I2C and \b SPI serial buses.
The ARM microporcessor is a \b LPC1768 from NXP (here its user manual: <a href="./File_pdf/LPC1768_UM10360.pdf" target=_blank><b>LPC1768 UM</b></a>).
Each element on both the FrontEnd and PostFrontEnd that has logic function has its own dedicated driver (a .c and 
its corresponding .h files), some common drivers (such as spi.c, I2c0.c, ...) are also present.
\n Communication with the control room is via serial CAN bus, fibre optic based.
\n There is an instruction set at <a href="_instruction_set.html">Instruction set</a>.
 
 
 \subsection subsection2 Documentation developed so far
 
\n This is the list of the parts documented:
 
- \ref I2C_to_parallel
- \ref I2C_mux_page
- \ref Multiplexer_strutture_funzioni_definizioni_page
- \ref I2C_0_page
- \ref I2C_1_page
- \ref Detector_Relays_managing_page
- \ref Detector_Bias
- \ref Preamplifier_Offset_Drift_Correcttion_page
- \ref DAC_PGA_page
- \ref Trimmer_page
- \ref SPI_page
- \ref Preamplifier_Gain_page
- \ref Thermometer
- \ref CAN
- \ref GPIO
- \ref Timer_
- \ref Inizializzazione_
 
 
 
 
 
*/
 
#include "tutti_gli_header.h"
 
 
// Definisco due comandi per il can
int8_t  spegnimento[8]  =   {6,0,0,0,0,0,0,0};
int8_t  accensione[8]   =   {6,1,0,0,0,0,0,0};
 
/**************************************************************************************
Variabili di gianlu
***************************************************************************************/
int wait_for_ADC_setting=100;  //!< settable from the can
volatile int8_t vettore_istruzioni[8];  //!< This is a copy of the received 8 bytes from the CAN
unsigned int FW_version;  //!< This is where the FW version is stored
 long int risultato;
 bool flag_power_down   = false;  //!< if flag_power_down is true the u-controller goes in power down after a while
 
 
 
/**************************************************************************************
FINE Variabili di gianlu
***************************************************************************************/
 
 
//extern ARM_DRIVER_CAN *CANdrv;
 
/*****************************************************************************
  Main function
 *****************************************************************************/
uint8_t tappo, per_non_ripetere=255;
 
/*! \brief The main...
 
 *\param[in,out] no param                                                                   
 *\return No Parameters
 */
int main (void)
{   
    uint8_t canale_ ;
    tappo=100;
    uint32_t temperatura_in_microK;
    uint8_t i;
//  LPC_SC->PCONP =0;
    rx_data[6]=0;
    instr_inizializza_tutto_da_zero_function(); //Questa va ottimizzata
 
 
    LED_accendi_spegni( LED_RED, spegni);
    LED_accendi_spegni( LED_GREEN, accendi);
 
    NVIC_SetPriority (SysTick_IRQn, 29); /* set Priority for Systick Interrupt */
 
 
tx_msg_info.id = ARM_CAN_EXTENDED_ID(0xff);                // Viene impostato l'indirizzo esteso per il messaggio trasmesso
tx_data[0]=1;
tx_data[1]=2;
tx_data[2]=3;
tx_data[3]=4;
tx_data[4]=5;
tx_data[5]=6;
tx_data[6]=7;
tx_data[7]=8;
messaggio_CAN_spedito =false;
evento_CAN = 5;
CANdrv->MessageSend(tx_obj_idx, &tx_msg_info, tx_data, 8U);
uint16_t  attesa=0;
while( (evento_CAN  !=   CAN_EVENT_SEND_COMPLETE) && (attesa < 250) ){
    Aspetta_tanti_ms(4);
    attesa++;
}
if (attesa >=250) { //Spegnamo il CAN se nessuno lege il messaggio
    CANdrv->Control(ARM_CAN_ABORT_MESSAGE_SEND, tx_obj_idx);
    LPC_CAN1->MOD |=1;     //Si annullano tutte le possibili azioni pendenti
    LPC_CAN1->GSR  &= ~CAN_GSR_TXERR_Msk; // Azzeriamo gli errori di trasmissione
    LPC_CAN1->MOD &=~1;    //Si riabilita il CAN
        uint32_t LPC_dummy= LPC_CAN1->ICR;
}
 
POWER_DOWN_TEMPO_ATTESA=0;
POWER_DOWN_ABILITA_CONTEGGIO=1;
per_non_ripetere=255;
    while (1)
    {
//          if(messaggio_CAN_arrivato==true)    // Flag che indica se \'e stato inviato un messaggio dal CAN
            if (    evento_CAN  == ARM_CAN_EVENT_RECEIVE)
            {   
//                  Spegni_led_verde();
//                  Accendi_led_rosso();
                    POWER_DOWN_ABILITA_CONTEGGIO=0;
                    POWER_DOWN_TEMPO_ATTESA=0;
                    for(i=0;i<8;++i)
                    {
                        vettore_istruzioni[i]= rx_data[i];
                        tx_data[i]= rx_data[i];
                    }
                    messaggio_CAN_arrivato= false;
                    tempo=0;
                    evento_CAN=10;
                    if( (per_non_ripetere == vettore_istruzioni[istruzione_codice])  ){
                            per_non_ripetere=255;
                    }else{                  
 
                    if( (rx_msg_info.id & maschera_togli_bit31)== indirizzo_CAN_della_scheda){
                                LPC_CAN1->IER &= ~CAN_IER_RIE; //Disabilitiamo la ricezione
                                LED_accendi_spegni(LED_RED, accendi);
                                LED_rosso_fondo_scala=LED_corto;
                                LED_verde_attivo =1;
                                LED_rosso_attivo =1;
                                per_non_ripetere= vettore_istruzioni[istruzione_codice];
                                            per_non_ripetere=255;
                        if (vettore_istruzioni[istruzione_codice] < The_total_number_of_instrucions){
                                ptr_istruzioni[vettore_istruzioni[istruzione_codice]]();    
                        }else{
                                tx_data[7]= 255; //Errore istruzioini fuori range
                        }
 
 
                    //  if( instr_NO_operation == per_non_ripetere) per_non_ripetere=255;
                                tx_msg_info.id = ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda);                // Viene impostato l'indirizzo esteso per il messaggio trasmesso
                                CANdrv->MessageSend(tx_obj_idx, &tx_msg_info, tx_data, 8U);                     
//                              while( evento_CAN  !=   CAN_EVENT_SEND_COMPLETE ){} 
//                      Aspetta_tanti_ms(100);
                    attesa=0;
                    while( (evento_CAN  !=   CAN_EVENT_SEND_COMPLETE) && (attesa < 500) ){
                        Aspetta_tanti_ms(4);
                        attesa++;
                    }
                
//                  if (attesa >=500) { //Spegnamo il CAN se nessuno lege il messaggio
                    if (1) { //Spegnamo il CAN se nessuno lege il messaggio                 
                        CANdrv->Control(ARM_CAN_ABORT_MESSAGE_SEND, tx_obj_idx);
                        LPC_CAN1->MOD |=1;     //Si annullano tutte le possibili azioni pendenti
                        LPC_CAN1->GSR  &= ~CAN_GSR_TXERR_Msk; // Azzeriamo gli errori di trasmissione
                        LPC_CAN1->MOD &=~1;    //Si riabilita il CAN
                    }
                        LPC_CAN1->IER |= CAN_IER_RIE; //abilitiamo la ricezione                 
//                  Spegni_led_rosso();
//                  Accendi_led_verde();
//                  Aspetta_tanti_ms(10);
                        LED_verde_attivo =0;
                        LED_rosso_attivo =0;
                        LED_accendi_spegni(LED_GREEN, accendi);
//                      LED_accendi_spegni(LED_RED, spegni);
                    }else if ( (rx_msg_info.id & maschera_togli_bit31) == indirizzo_generico_CAN){
                                LPC_CAN1->IER &= ~CAN_IER_RIE; //Disabilitiamo la ricezione                     
                                LED_verde_attivo =1;
 
                        if (vettore_istruzioni[istruzione_codice] < The_total_number_of_instrucions){
                                ptr_istruzioni[vettore_istruzioni[istruzione_codice]]();    
                        }else{
                                tx_data[7]= 255; //Errore istruzioini fuori range
                        }           
                            per_non_ripetere= vettore_istruzioni[istruzione_codice];
                                                    per_non_ripetere=255;
                                tx_msg_info.id = ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda);                // Viene impostato l'indirizzo esteso per il messaggio trasmesso
                                CANdrv->MessageSend(tx_obj_idx, &tx_msg_info, tx_data, 8U);     
                                attesa=0;   
                                per_non_ripetere= vettore_istruzioni[istruzione_codice];
                                while( (evento_CAN  !=   CAN_EVENT_SEND_COMPLETE) && (attesa < 500) ){
                                    Aspetta_tanti_ms(4);
                                    attesa++;
                                }
                            
                    if (1) { //Spegnamo il CAN se nessuno lege il messaggio
                        CANdrv->Control(ARM_CAN_ABORT_MESSAGE_SEND, tx_obj_idx);
                        LPC_CAN1->MOD |=1;     //Si annullano tutte le possibili azioni pendenti
                        LPC_CAN1->GSR  &= ~CAN_GSR_TXERR_Msk; // Azzeriamo gli errori di trasmissione
                        LPC_CAN1->MOD &=~1;    //Si riabilita il CAN
                    }
                                LED_verde_attivo =0;
                                LED_rosso_attivo =0;
                                LED_accendi_spegni(LED_GREEN, accendi);
                                LED_accendi_spegni(LED_RED, spegni);
                                LPC_CAN1->IER |= CAN_IER_RIE; //Abilitiamo la ricezione
                    }
                }
                
                    POWER_DOWN_TEMPO_ATTESA=0;
                    POWER_DOWN_ABILITA_CONTEGGIO=1;
                    LED_remote_ON_OFF();
            }
            //else{
            {
/*!
 
 */
//! <!-- [fun_power_down_main] -->              
    //COMANDI PER IL POWER_DOWN     
                if (POWER_DOWN_TEMPO_ATTESA >= POWER_DOWN_MAX_ATTESA)                           // Viene incrementato tempo finch\'e non arriva a quel valore
                        {
                    per_non_ripetere = 255;
                    POWER_DOWN_TEMPO_ATTESA=0;
                    if((flag_power_down == true) && POWER_DOWN_ABILITA_CONTEGGIO)                           // Se il flag \'e true, viene attivata la modalit\'a Power Down
                            {
                    // Il micro entra nella modalit\'a Power-down
        //                      POWER_DOWN_ABILITA_CONTEGGIO=0;
                                LED_accendi_spegni(LED_RED, spegni);
                                LED_accendi_spegni(LED_GREEN, spegni);                  
                                LED_remote_ON_OFF();
                                PowerControl_PowerDown();
//                              Pwd_Paolo();
                        }               
                    }
//! <!-- [fun_power_down_main] -->                      
        }
    }
 
 
//preamplifier_set_reset_pre_gain ( scheda_su_scheda_giu_provvisorio,  canale5,  preamplifier_Gain_basso  );
 
//preamplifier_set_reset_pre_gain ( scheda_su_scheda_giu_provvisorio,  canale6,  preamplifier_Gain_basso  );
 
 
//preamplifier_set_reset_pre_gain ( scheda_su_scheda_giu_provvisorio,  canale5,  preamplifier_Gain_alto  );
 
 
//preamplifier_set_reset_pre_gain ( scheda_su_scheda_giu_provvisorio,  canale6,  preamplifier_Gain_alto  );
 
//PGA_GAIN( 0,  4 ,  2);
 
//PGA_GAIN( 0,  4 ,  4);
 
//PGA_GAIN( 0,  5 ,  2);
 
//PGA_GAIN( 0,  5 ,  4);
//   
//   for( canale_=4; 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_, 132, 1  );
//   }
//}
 
//Connettiamo i pre a GND
//   for( canale_=0; canale_ <6; canale_ ++ ){
//  Relays_driver_set_reset_channel( canale_ ,  Detector_prea_to_GND);
// } 
    while(1);
    
//  
//  
////INIZIALIZZAZIONE PARTE QUI
//  
////    unsigned char dati_letti[4];
////    FW_version =  __INT_DATE__;
//  //Definizione puntatore sitruzioni
//  Setting_of_the_pointer_for_command_parser ( );
//// 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  
 
//// Configurazione delle Periferiche   
//  Configure_Bit_Address_for_CAN();
//  CAN_Inizialize();                                                                       // Viene inizializzata la periferica CAN
//  SPI_Inizialize();                                                                       // Viene inizializzata la periferica SPI
//  I2C_1_Initialize();                                                                 // Viene inizializzata la periferica I2C_A
//  I2C_0_Initialize();                                                                 // Viene inizializzata la periferica I2C_B
//  I2C_termometro_Initialize();                                                // Viene inizializzata la periferica I2C_termometro_Inizialize
//  
////    importa_le_costanti_dalla_memoria();
//  
//// CHIP SELECTOR per i multiplexer
//  Configure_Chip_Sel();                                                               // Vengono configurati i pin del Chip Selector per i multiplexer
//  Configure_Sel_Par_Interruttori();                                       // Vengono configurati i pin del Sel Par Interruttori per i multiplexer
////    Abbassa_chip_selector_multiplexer();                                // Vengono abbassati tutti i pin dei quattro chip selector dei multiplexer
//// ADC READY
//  Configure_Adc_Ready();                                                          // Viene configurato l'ADC READY
//  GPIO_PinWrite(1, Adc_ready, 0);                                         // Viene abbassato l'ADC READY
//// CHIP SELECTOR dell'ADC 
//  Configure_Chip_Sel_ADC();                                                       // Viene configurato il Chip Sel dell'ADC
//  GPIO_PinWrite(0, Chip_Sel_Adc, 1);                                  // Viene alzato il Chip_Sel_Adc
//// CHIP SELECTOR RELE del canale 0    
//  Configure_Chip_Sel_rele_ch0();                                          // Vengono configurati i pin del Chip Selector dei rel\'e del canale 0
//  GPIO_PinWrite(0, Chip_Sel_rele_0, 1);                               // Viene alzato il Chip Sel rele del canale 0
//// RESET e SET canale 0
//  Configure_Reset_ch0();                                                          // Vengono configurati i pin del Reset per i rel\'e del canale 0
//  Configure_Set_ch0();                                                                // Vengono configurati i pin del Set per i rel\'e del canale 0
//  GPIO_PinWrite(1, Set_ch0, 1);                                               // Impostando il set a 1 non vengono abbassati tutti gli interruttori
//  GPIO_PinWrite(1, Reset_ch0 ,1);                                         // Viene impostato il Reset a 1, in questo modo non \'e pi\'u 0
//// CHIP SELECTOR RELE del canale 1    
//  Configure_Chip_Sel_rele_ch1();                                          // Vengono configurati i pin del Chip Selector dei rel\'e del canale 1
//  GPIO_PinWrite(0, Chip_Sel_rele_1, 1);                               // Viene alzato il Chip Sel rele del canale 1
//// RESET E SET canale 1   
//  Configure_Reset_ch1();                                                          // Vengono configurati i pin del Reset per i rel\'e del canale 1
//  Configure_Set_ch1();                                                                // Vengono configurati i pin del Set per i rel\'e del canale 1
//  GPIO_PinWrite(1, Set_ch1, 1);                                               // Impostando il set a 1 non vengono abbassati tutti gli interruttori
//  GPIO_PinWrite(1, Reset_ch1 ,1);                                         // Viene impostato il Reset a 1, in questo modo non \'e pi\'u 0
//// CHIP SELECTOR DAC del canale 0 
//  Configure_PGA_Chip_Sel_DAC_ch0();                                       // Vengono configurati i pin del Chip Selector del DAC del canale 0
//  GPIO_PinWrite(0, PGA_Chip_Sel_DAC_ch0, 1);                  // Viene alzato il Chip Sel del DAC del canale 0
//// CHIP SELECTOR DAC del canale 1 
//  Configure_PGA_Chip_Sel_DAC_ch1();                                       // Vengono configurati i pin del Chip Selector del DAC del canale 1
//  GPIO_PinWrite(0, PGA_Chip_Sel_DAC_ch1, 1);                  // Viene alzato il Chip Sel del DAC del canale 1
//// RELE K2
//  Configure_PGA_rele_ch0_1();                                                 // Vengono configurati i pin del PGA_rele_canale 0 numero 1
//  GPIO_PinWrite(1, PGA_rele_ch0_1, 0);                                // Viene abbassato il PGA_rele_canale 0 numero 1
//  Configure_PGA_rele_ch0_2();                                                 // Vengono configurati i pin del PGA_rele_canale 0 numero 2
//  GPIO_PinWrite(1, PGA_rele_ch0_2, 0);                                // Viene abbassato il PGA_rele_canale 0 numero 2                    
//// RELE K3
//  Configure_PGA_rele_ch1_1();                                                 // Vengono configurati i pin del PGA_rele_canale 1 numero 1
//  GPIO_PinWrite(1, PGA_rele_ch1_1, 0);                                // Viene abbassato il PGA_rele_canale 1 numero 1                        
//  Configure_PGA_rele_ch1_2();                                                 // Vengono configurati i pin del PGA_rele_canale 1 numero 2
//  GPIO_PinWrite(1, PGA_rele_ch1_2, 0);                                // Viene abbassato il PGA_rele_canale 1 numero 2                        
//// TRIMMER canale 0 e canale 1 del Preamplificatore
//  Imposta_wiper_a_meta_scala_canale_0_I2CA();                 // Vengono impostati i wiper a met\'a scala dei trimmer del preamplificatore del canale 0
//  Imposta_wiper_a_meta_scala_canale_1_I2CA();                 // Vengono impostati i wiper a met\'a scala dei trimmer del preamplificatore del canale 1
//// Trimmer del Rivelatore
//  Imposta_wiper_a_meta_scala_canale_0_I2CB();                 // Vengono impostati i wiper a met\'a scala dei trimmer del rivelatore del canale 0
//  Imposta_wiper_a_meta_scala_canale_1_I2CB();                 // Vengono impostati i wiper a met\'a scala dei trimmer del rivelatore del canale 1
////Configurazione pin per alimentazione                                // Vengono configurati i Pin dell'alimentazione analogica
//  Configure_Pin_Alimentazione();
/////*********************************************************************************************************************************/
 
////Spengo e riaccendo. cos\'i resetto tutto
//Spegni_led_verde();                               
//  Accendi_led_rosso();
////    Esegui_istruzione(spegnimento);
//  Spegnimento_delle_alimentazioni_analogiche();   
//  Aspetta_tanti_ms(500);
////    Esegui_istruzione(accensione);
//  Accensione_delle_alimentazioni_analogiche();    
//  Spegni_led_rosso();
//  Accendi_led_verde();
//  calibrazione_Resistenze_sterne_ADC();
 
///* Inizializzazione canali  */
////Da completare con offset iniziale, per ora metto a met\'a scala
//char ii;
//for (ii =0; ii<2;ii++){
//  //preamplifier offset half scale
////    Trimmer_offset_preampli[ii].coarse_offset = 0x80;
//  Trimmer_offset_preampli[ii].fine_offset =0x80;
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (ii, preampli_fine_offset_trimmer, 0x80);        
////    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (ii, preampli_corse_offset_trimmer, 0x80);
//  
//  //Carichiamo l'offset a zero V
//  unsigned char dati_letti[4];
////    lettura_EPROM(ii,  Memory_address_JFET_trimmer_offset , dati_letti);
//  Trimmer_offset_preampli[ii].JFET_Offset= dati_letti[0];
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (ii, preampli_JFET_Offset_trimmer, Trimmer_offset_preampli[ii].JFET_Offset);
//  Trimmer_offset_preampli[ii].coarse_offset= dati_letti[1];
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (ii, preampli_corse_offset_trimmer, Trimmer_offset_preampli[ii].coarse_offset);
////    
//  
//  //Trimmer thermal a met\'a scala
//  Trimmer_offset_preampli[ii].coarse_thermal =0x80;
//  //detector bias half scale
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (ii, trimmer_bias_coarse_pos, 0x80);         // Viene fatta una misura con entrambi i trimmer a met\'a scala per ricavare l'offset   
//  detector_Trimmer_bias[ii].coarse_pos=0x80;
//  detector_Trimmer_bias[ii].fine_pos=0x80;
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (ii, trimmer_bias_fine_pos, 0x80);   
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (ii, trimmer_bias_coarse_neg, 0x80);             // Viene fatta una misura con entrambi i trimmer a met\'a scala per ricavare l'offset       
//  detector_Trimmer_bias[ii].coarse_neg=0x80;
//  detector_Trimmer_bias[ii].fine_neg=0x80;
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (ii, trimmer_bias_fine_neg , 0x80);
//}
////Preamplifiers to GND
////vettore_istruzioni[istruzione_byte_4_e_scelta_canale]=Detector_prea_to_GND_ch0;
////Detector_PGA_Rele(Detector_prea_to_GND_ch0);
////vettore_istruzioni[istruzione_byte_4_e_scelta_canale]=Detector_prea_to_GND_ch1;
////Detector_PGA_Rele(Detector_prea_to_GND_ch1);
////Rele PGA gain=1
////vettore_istruzioni[istruzione_byte_4_e_scelta_canale]=PGA_pre_gain_1_ch0_code;
////Detector_PGA_Rele();
////Detector_PGA_Rele(PGA_pre_gain_1_ch0_code);
////vettore_istruzioni[istruzione_byte_4_e_scelta_canale]=PGA_pre_gain_1_ch1_code;
////Detector_PGA_Rele();
////Detector_PGA_Rele(PGA_pre_gain_1_ch1_code);
////PGA gain =1
////vettore_istruzioni[byte_istr_dati_0]=0;
////vettore_istruzioni[byte_istr_dati_1]=0;
////vettore_istruzioni[istruzione_byte_4_e_scelta_canale]=3;
////instruction_for_PGA_GAIN_set();
//PGA_GAIN_set(3, 1);
 
///* FINE Inizializzazione canali  */
////INIZIALIZZAZIONE FINISCE  QUI
 
}