Multiplexer_strutture_funzioni_definizioni.c

Go to the documentation of this file.

 
 
 
#include "tutti_gli_header.h"
 
//DOCUMENTAZIONE DOXYGEN
 /// \file
 
 /*! \page Multiplexer_strutture_funzioni_definizioni_page Multiplexer_strutture_funzioni_definizioni
 \brief <span style="color:red;"> <b> ADC/Mux ADG1408 description page </b> </span>
 
*\tableofcontents
 
*\b SUMMARY:
*\arg \ref user_use_of_ADC_on_mainboard
*\arg \ref user_use_of_ADC_on_postmainboard
<hr width="75%" size="5" align="center">
 
\n This chip is the \b ADG1408 (<a href="./File_pdf/ADG1408.pdf"  target=_blank><b>ADG1408 datasheet</b></a>). 
2 \b ADG1408 are on the mainobard  and 8 are present on the postmainboard.
 
*\section user_use_of_ADC_on_mainboard User use of the ADC/Mux on mainboard
<hr width="75%" size="5" align="center">
\n Thre are 2 ADG1408 chips on the board whose scheme is in figure \ref Figure_Analog_mux. Each one allows to multiplex 8 analog 
inputs into one ouput. To select the input 4 signals are needed. The chip select that, for this chip, is active high and 3 parallel 
lines that codify the selected inpt. Once this is done, the output is available to be measured from the ADC. The series resistance 
of the chip is smaller than 10 &Omega; and 100 &Omega; are connected in series to the ouput for protecion.
\n To manage the chip there is only one function: Analog_mux_line_to_select_deselect( uint8_t scheda_su_scheda_giu, uint8_t line_to_select, uint8_t select_1_deselect_0)
that is called 2 times in measurement. First it needs to activate the output and the parameter \b select_1_deselect_0 is 1. \b line_to_select is the line to select
according to the following list, where the numbers on the left are the code to pass, and the definition on the right 
of the numbers are their equivalent aliases:
<ul> 
<li> The first analog mux has connected the following nodes, whose adrresses are on the left (the starting offset 
is defined as #node_voltage_Analog_Mux_0_offset): </li>
        <ol start="32">
            <li> #node_voltage_Analog_Mux_meas_bias_pos_ch0 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_neg_ch0 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_pos_ch1 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_neg_ch1 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_pos_ch2 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_neg_ch2 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_pos_ch3 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_neg_ch3 </li>
        </ol>
    <li> The second analog mux has connected the following nodes, whose adrresses are on the left (the starting offset
    is defined at #node_voltage_Analog_Mux_1_offset): </li>
        <ol start="40">
            <li> #node_voltage_Analog_Mux_meas_bias_pos_ch4 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_neg_ch4 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_pos_ch5 </li>
            <li> #node_voltage_Analog_Mux_meas_bias_neg_ch5 </li>
            <li> #node_voltage_Analog_Mux_meas_input_bias_pos </li>
            <li> #node_voltage_Analog_Mux_meas_input_bias_neg   </li>
            <li> #node_voltage_Analog_Mux_meas_none </li>
            <li> #node_voltage_Analog_Mux_meas_10k_to_gnd </li>
        </ol>
</ul>
 
 
\note Mux_1 output is routed at pin 15 and Mux_2 output is routed at pin 16 of the 50 pins header output
connector of the \b mainboard \b A. Note that the 2 nodes is better if read with respect to the local ground, 
pins 13, 14, 17 and 18 of the same connector.
 
\n Once the measurement is done the function is called again with the same parameters, except 
\b select_1_deselect_0 that must be 0 this time.
\n Here an example of use of Analog_mux_line_to_select_deselect():
 
<span style="color:orange;"> <I>
\code {.c}
  function_which_must_use_the_ADC( scheda_su_acheda_giu, node_to_measure){
 
        Analog_mux_line_to_select_deselect( scheda_su_acheda_giu,   node_to_measure, 1);  //the node is enabled to the output
        
        //Measure with the ADC
        
        Analog_mux_line_to_select_deselect( scheda_su_acheda_giu,   node_to_measure, 0);  //the node is de-selected
    }
\endcode
</I> </span>
 
\sa The analog mux's on mainboard are managed by the I2C to parallel chips: \ref I2C_to_parallel
 
*\anchor Figure_Analog_mux
\image html ADG408_mux.png "Figure_Analog_mux 1: Analog mux scheme" width=20%
\image latex ADG408_mux.png "Figure_Analog_mux 1: Analog mux scheme" width=20%
 
*\section user_use_of_ADC_on_postmainboard User use of the ADC/Mux on postmainboard
<hr width="75%" size="5" align="center">
 
\n Postmainboard has 2 ADCs dedicated each to one of the 2 connected mainboards. Nodes to measure are routed by 2
groups of 4 analog multiplexers. In this case chip select lines and selection lines are all provided by the microcontroller
and some functions are available:
 
- Configure_Reset_selection_port_analog_mux_ResIn_ADC_buffer(void);
- Analog_mux_line_to_select_deselect_for_postmainboard( uint8_t scheda_su_scheda_giu, uint8_t line_to_select, uint8_t select_1_deselect_0 )
 
Configure_Reset_selection_port_analog_mux_ResIn_ADC_buffer() is called at startup to set the pins and set the mux's in idle mode. 
It alsosets the pins for the switch put in series to the resistors at the ADC buffer input. The aim of this switch is to set this equivalent impedance to infinite value
when the node voltage to measure is connected. Due to the fact that an attenuation is needed to avoid the rails the switches are always maintained in the closed state.
\n Analog_mux_line_to_select_deselect_for_postmainboard(), needs to know the mainboard to manage by \b scheda_su_scheda_giu, the node
to measure by \b line_to_select and the setting of the path of the node to the ADC and is disconnession, by \b select_1_deselect_0. 
\b line_to_select are those listed at \ref lista_nodi. 
\n On the postamainboard there are 8 analog multiplexers, 2 groups of 4 for each connected mainboard. 
The multiplexers have simmetrical connections. To individuate an input line the syntax is: 
bits 0 to 3 are common to all the MUXs and select one of the input analog lines; bits 4 to 5 are the 
address for the chips select for the 2 groups of 4 MUXs. 
The selection of the MUX group is trhough the board_up_down. 
To select the lines a vector is dedicated to this. It is #ADC_node_map[]:
 
*\snippet{lineno} Gpio.c vect_ADC_node_map
 
 
 The codes for mamnaging the mux are: 
 - \ref  Multiplexer_strutture_funzioni_definizioni.c   
 - \ref  Multiplexer_strutture_funzioni_definizioni.h
<!-- pappa --> 
*/
 
 
 
 //INIZIO CROSS
 
 
/*! \brief Selection of the line to mesure with the analog MUX of the mainboard, driven by the I2C->parallel mux
 
*\param[in] scheda_su_scheda_giu   The board to consider
*\param[in] line_to_select  the line to be measured
*\param[in] select_1_deselect_0 Select or deselect the output, send the same pattern in both cases in line_to_select
*\return   No Parameters
\callgraph
 
*\snippet{lineno} Multiplexer_strutture_funzioni_definizioni.c fun_Analog_mux_line_to_select
*/
//! <!-- [fun_Analog_mux_line_to_select] -->
void Analog_mux_line_to_select_deselect ( uint8_t scheda_su_scheda_giu, uint8_t line_to_select, uint8_t select_1_deselect_0 ){
    uint8_t select_PCA;
    uint8_t seleziona_lo_analog_mux, de_seleziona_lo_analog_mux,the_3_selction_lines,pattern_uscita_solo_linee;
//  if (line_to_select < node_voltage_Analog_Mux_1_offset ){
//      //Seleziono il primo mux
//      line_to_select= (line_to_select - node_voltage_Analog_Mux_0_offset );
//  }else{
//      //seleziono il secondo mux
//      line_to_select= line_to_select - node_voltage_Analog_Mux_1_offset ;
//  }
    line_to_select= (line_to_select - node_voltage_Analog_Mux_0_offset ); //line_to_select ha il quarto bit a 0
            //se la linea \'e nel primo mux, altrimenti il 4 bit \'e 1 
    
    //Selezionare il chip I2C parallelo dal bit3 di line_to_select
    the_3_selction_lines= line_to_select & Analog_Mux_maschera_quali_linee ;//le prime 3 linee indicano quale delle
                                                //8 uscite va selezionata
    the_3_selction_lines = the_3_selction_lines << posizione_del_pattern_delle_linee ;//nel chip I2C-->parallel
                                                //le 3 linee stanno alla "posizione_del_pattern_delle_linee" 
    pattern_uscita_solo_linee = the_3_selction_lines | I2C_to_Parallel_maschera_linee_ucita;
    
    if (line_to_select & Analog_Mux_maschera_quale_chip){//test sul mux da usare
        //Selezionimao il secondo mux
        select_PCA = I2C_to_Parallel_name_2;
        seleziona_lo_analog_mux = 0x8f | the_3_selction_lines ;//chip select of second mux is MSb of PCA2 (enabled if 1)
        de_seleziona_lo_analog_mux =I2C_to_Parallel_2_ini_set;
    }else{
        //Selezionimao il primo mux
        select_PCA = I2C_to_Parallel_name_3;
        seleziona_lo_analog_mux = 0xff;    //chip select of first mux is bit 2 of PCA3 (enabled if 1)
        de_seleziona_lo_analog_mux = I2C_to_Parallel_3_ini_set;
    }
 
    if (select_1_deselect_0){ //definire se selezionare l'uscita o deselezionare l'uscita
        //First we write the line to select, line 5 to 7 of PCA2
      I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_scheda_giu,     I2C_to_Parallel_name_2, \
                                                                                                pattern_uscita_solo_linee );
//                                                                                          I2C_to_Parallel_2_ini_set & the_3_selction_lines );
        //And now enable the analog mux, either mux 1 or mux 2 chip select
      I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_scheda_giu,     select_PCA, seleziona_lo_analog_mux );     
        //Selezionare la linea di uscita
    } else{
        //de-Selezioniamo la linea di uscita e gli analog mux
            I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_scheda_giu,   select_PCA, de_seleziona_lo_analog_mux );
    }
}
//! <!-- [fun_Analog_mux_line_to_select] --> 
 
 
/*! \brief Selection of the line to measure with the analog MUX's of the postmainboard, directely driven by the microprocessor port
 
*\param[in] scheda_su_scheda_giu   The board to consider
*\param[in] line_to_select  the line to be measured
*\param[in] select_1_deselect_0 Select or deselect the output, send the same pattern in both cases in line_to_select
*\return   No Parameters
\callgraph
 
*\snippet{lineno} Multiplexer_strutture_funzioni_definizioni.c fun_Analog_mux_line_to_select_deselect_for_postmainboard
*/
//! <!-- [fun_Analog_mux_line_to_select_deselect_for_postmainboard] -->
void Analog_mux_line_to_select_deselect_for_postmainboard ( uint8_t scheda_su_scheda_giu, uint8_t line_to_select, uint8_t select_1_deselect_0 ){
    #define offset_per_board_down 32
    uint8_t offset_per_mux=0,actual_line_to_select,analog_node,analog_mux;
    porta_pin_def mux_in_gioco[]={Mux_enable_postmainboard_1, Mux_enable_postmainboard_2, Mux_enable_postmainboard_3, Mux_enable_postmainboard_4, \
                                Mux_enable_postmainboard_5, Mux_enable_postmainboard_6, Mux_enable_postmainboard_7, Mux_enable_postmainboard_8};
    
//  uint8_t seleziona_lo_analog_mux, de_seleziona_lo_analog_mux,the_3_selction_lines,pattern_uscita_solo_linee;
    //Sono invertiti gli indici dei 2 gruppi da 4 perch\'e il down va da 4 a 8.
 
  if (scheda_su_scheda_giu==0) offset_per_mux =     offset_per_board_down; //servono i mux da 4 a 7                                         
                                                            
    actual_line_to_select= ADC_node_map[line_to_select] + offset_per_mux; //La linea analogica che considera una delle 8 nel mux,
                //i primi 3 bit, ed il mux, i successivi 3 bit.
    
    analog_node = actual_line_to_select & 7; //la linea analogica da selezionare nel mux
    analog_mux= (actual_line_to_select >> 3) & 7; //il mux da selezionare
                                
    if(select_1_deselect_0){//Abilitiamo l'uscita
    //scriviamo il numero della linea da selezionare
            GPIO_PinWrite(Mux_select_word_0.porta_num, Mux_select_word_0.pin_num, ((analog_node>>0) & 1));
            GPIO_PinWrite(Mux_select_word_1.porta_num, Mux_select_word_1.pin_num, ((analog_node>>1) & 1));
            GPIO_PinWrite(Mux_select_word_2.porta_num, Mux_select_word_2.pin_num, ((analog_node>>2) & 1));
            
            //ed ora abilitiamo il mux
            GPIO_PinWrite(mux_in_gioco[analog_mux].porta_num, mux_in_gioco[analog_mux].pin_num, 1);
    }else{//Disabilitiamo il mux
            GPIO_PinWrite(mux_in_gioco[analog_mux].porta_num, mux_in_gioco[analog_mux].pin_num, 0);
    }
    
}
//! <!-- [fun_Analog_mux_line_to_select_deselect_for_postmainboard] -->
 
 //FINE CROSS
 
 
/*! \brief Once the Mux is selected, one of its 8 input analogue lines is routed to its output.
 
*\param[in] aa   The parameter is a number between 0 and 7: the input selected line to be routed to the output.
*\return   No Parameters
 
 
*\snippetlineno Multiplexer_strutture_funzioni_definizioni.c fun_Line_select_in_the_mux
*/
//! <!-- [fun_Line_select_in_the_mux] -->
// void Line_select_in_the_mux(  unsigned char aa){
//      char ii;
//    for( ii =0; ii<3; ii++){          
//          GPIO_PinWrite(porta_1, Sel_Par_Interruttori_1 - ii , (((aa) >> ii ) & 1) );
//      }
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 , ((aa >> 2 ) & 1));    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 , ((aa >> 1 ) & 1));    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 , ((aa >> 0 ) & 1) );   
//}
//! <!-- [fun_Line_select_in_the_mux] --> 
 
 
/*! \brief Here the Mux, one over 4, to be used is selected.
 
*\param[in] aa   The parameter is a number between 1 and 4: the selected Mux. The value of zero as input parameter de-select all the mux.
*\return   No Parameters
 
 
*\snippetlineno Multiplexer_strutture_funzioni_definizioni.c fun_ATTIVA_CHIP_SELECTOR_MULTIPLEXER
*/
//! <!-- [fun_ATTIVA_CHIP_SELECTOR_MULTIPLEXER] -->
// void ATTIVA_CHIP_SELECTOR_MULTIPLEXER (unsigned char aa)
//{
//      char uno=0, /*due=0,tre=0,quattro=0,*/ ii;
//      for( ii=0;ii<4;ii++){
//          uno=0;
//          if ( aa==(ii+1)) uno=1;
//          GPIO_PinWrite(porta_1, Chip_Sel_Multiplexer_1 - ii ,uno);
//      }
//}
//! <!-- [fun_ATTIVA_CHIP_SELECTOR_MULTIPLEXER] -->
 
 /****************************************************************************
 FINE Funzioni di Gianlu
 *****************************************************************************/
 
 /****************************************************************************
 Funzioni del MULTIPLEXER 1
 *****************************************************************************/
//void ATTIVA_CHIP_SELECTOR_MULTIPLEXER_1 (void)
//{
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_4 ,0);                
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_3 ,0);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_2 ,0);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_1 ,1);
//}
 
//void Attiva_linea_AN1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_AN2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_AN3 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_AN4 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_AN5 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_CC2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_DD2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_EE2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
 
// La struttura multi_1 viene controllata con multipl_1
//struttura_multiplexer_1 Multiplexer_1= {
//  ATTIVA_CHIP_SELECTOR_MULTIPLEXER_1,
//  Attiva_linea_AN1,
//  Attiva_linea_AN2,
//  Attiva_linea_AN3,
//  Attiva_linea_AN4,
//  Attiva_linea_AN5,
//  Attiva_linea_CC2,
//  Attiva_linea_DD2,
//  Attiva_linea_EE2
//};
 
// struttura_multiplexer_1 *MULTIPLEXER_1= &Multiplexer_1;                              // Viene creato un puntatore a multipl_1
 
 
 
 
/*****************************************************************************
 *****************************************************************************
 MULTIPLEXER 2
 *****************************************************************************
 *****************************************************************************/
// typedef struct multiplexer_2 {
 
//  void                            (*ATTIVA_CHIP_SELECTOR_MULTIPLEXER_2) (void);               ///< Puntatore a \ref ATTIVA_CHIP_SELECTOR_MULTIPLEXER_2
//  void              (*Attiva_linea_MM1)       (void);                             ///< Puntatore a \ref Attiva_linea_MM1
//  void              (*Attiva_linea_MM2)       (void);                             ///< Puntatore a \ref Attiva_linea_MM2
//  void              (*Attiva_linea_NN1)       (void);                             ///< Puntatore a \ref Attiva_linea_NN1
//  void              (*Attiva_linea_NN2)       (void);                             ///< Puntatore a \ref Attiva_linea_NN2
//  void              (*Attiva_linea_TT1)       (void);                             ///< Puntatore a \ref Attiva_linea_TT1
//  void              (*Attiva_linea_TT2)       (void);                             ///< Puntatore a \ref Attiva_linea_TT2
//  void              (*Attiva_linea_HH2)       (void);                             ///< Puntatore a \ref Attiva_linea_HH2
//  void              (*Attiva_linea_LL2)       (void);                             ///< Puntatore a \ref Attiva_linea_LL2
//} const struttura_multiplexer_2;
 
 /****************************************************************************
 Funzioni del MULTIPLEXER 2
 *****************************************************************************/
//void ATTIVA_CHIP_SELECTOR_MULTIPLEXER_2 (void)
//{
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_4 ,0);                
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_3 ,0);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_2 ,1);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_1 ,0);
//}
// 
//void Attiva_linea_MM1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_MM2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_NN1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_NN2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_TT1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_TT2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_HH2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_LL2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
 
// La struttura multi_2 viene controllata con multipl_2
//struttura_multiplexer_2 Multiplexer_2= {
//  ATTIVA_CHIP_SELECTOR_MULTIPLEXER_2,
//  Attiva_linea_MM1,
//  Attiva_linea_MM2,
//  Attiva_linea_NN1,
//  Attiva_linea_NN2,
//  Attiva_linea_TT1,
//  Attiva_linea_TT2,
//  Attiva_linea_HH2,
//  Attiva_linea_LL2
//};
 
// struttura_multiplexer_2 *MULTIPLEXER_2= &Multiplexer_2;                              // Viene creato un puntatore a multipl_2
 
 
 
 
/*****************************************************************************
 *****************************************************************************
 MULTIPLEXER 3
 *****************************************************************************
 *****************************************************************************/
// typedef struct multiplexer_3 {
//  void                            (*ATTIVA_CHIP_SELECTOR_MULTIPLEXER_3) (void);               ///< Puntatore a \ref ATTIVA_CHIP_SELECTOR_MULTIPLEXER_3 
//  void              (*Attiva_linea_CC1)       (void);                             ///< Puntatore a \ref Attiva_linea_CC1 
//  void              (*Attiva_linea_DD1)       (void);                             ///< Puntatore a \ref Attiva_linea_DD1 
//  void              (*Attiva_linea_EE1)       (void);                             ///< Puntatore a \ref Attiva_linea_EE1
//} const struttura_multiplexer_3;
 
 
 /****************************************************************************
 Funzioni del MULTIPLEXER 3
 *****************************************************************************/
//void ATTIVA_CHIP_SELECTOR_MULTIPLEXER_3 (void)
//{
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_4 ,0);                
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_3 ,1);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_2 ,0);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_1 ,0);
//}
 
//void Attiva_linea_CC1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_DD1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_EE1(void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
 
 
// La struttura multi_3 viene controllata con multipl_3
//struttura_multiplexer_3 Multiplexer_3= {
//  ATTIVA_CHIP_SELECTOR_MULTIPLEXER_3,
//  Attiva_linea_CC1,
//  Attiva_linea_DD1,
//  Attiva_linea_EE1
//};
 
// struttura_multiplexer_3 *MULTIPLEXER_3= &Multiplexer_3;                              // Viene creato un puntatore a multipl_3
 
 
 
 
 
/*****************************************************************************
 *****************************************************************************
 MULTIPLEXER 4
 *****************************************************************************
 *****************************************************************************/
 
// typedef struct multiplexer_4 {
//  void                            (*ATTIVA_CHIP_SELECTOR_MULTIPLEXER_4) (void);               ///< Puntatore a \ref ATTIVA_CHIP_SELECTOR_MULTIPLEXER_4     
//  void              (*Attiva_linea_FF1)       (void);                             ///< Puntatore a \ref Attiva_linea_FF1 
//  void              (*Attiva_linea_FF2)       (void);                             ///< Puntatore a \ref Attiva_linea_FF2       
//  void              (*Attiva_linea_GG1)       (void);                             ///< Puntatore a \ref Attiva_linea_GG1       
//  void              (*Attiva_linea_GG2)       (void);                             ///< Puntatore a \ref Attiva_linea_GG2       
//  void              (*Attiva_linea_UU1)       (void);                             ///< Puntatore a \ref Attiva_linea_UU1       
//  void              (*Attiva_linea_UU2)       (void);                             ///< Puntatore a \ref Attiva_linea_UU2       
//  void              (*Attiva_linea_HH1)       (void);                             ///< Puntatore a \ref Attiva_linea_HH1       
//  void              (*Attiva_linea_LL1)       (void);                             ///< Puntatore a \ref Attiva_linea_LL1
//} const struttura_multiplexer_4;
 
 /****************************************************************************
 Funzioni del MULTIPLEXER 4
 *****************************************************************************/
//void ATTIVA_CHIP_SELECTOR_MULTIPLEXER_4 (void)
//{
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_4 ,1);                
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_3 ,0);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_2 ,0);    
//      GPIO_PinWrite(1, Chip_Sel_Multiplexer_1 ,0);
//}
 
//void Attiva_linea_FF1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_FF2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_GG1(void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_GG2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_UU1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_UU2 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,0);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
//void Attiva_linea_HH1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,0);    
//}
 
//void Attiva_linea_LL1 (void)
//{
//      GPIO_PinWrite(1, Sel_Par_Interruttori_3 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_2 ,1);    
//      GPIO_PinWrite(1, Sel_Par_Interruttori_1 ,1);    
//}
 
 
// La struttura multi_4 viene controllata con multipl_4
 
//struttura_multiplexer_4 Multiplexer_4= {
//  ATTIVA_CHIP_SELECTOR_MULTIPLEXER_4,
//  Attiva_linea_FF1,
//  Attiva_linea_FF2,
//  Attiva_linea_GG1,
//  Attiva_linea_GG2,
//  Attiva_linea_UU1,
//  Attiva_linea_UU2,
//  Attiva_linea_HH1,
//  Attiva_linea_LL1
//};
 
// struttura_multiplexer_4 *MULTIPLEXER_4= &Multiplexer_4;                              // Viene creato un puntatore a multipl_4
 
 
 
/*****************************************************************************
 *****************************************************************************
    FUNZIONI UTILI
 *****************************************************************************
 *****************************************************************************/
 
 
/*****************************************************************************
    Attiva il CHIP SELECTOR del Multiplexer_Numero              numero_multiplexer [1,4]
 *****************************************************************************/ 
//void Attiva_CHIP_SELECTOR_MULTIPLEXER_Numero(int numero_multiplexer)
//{
//  switch (numero_multiplexer)
//  {
//      case 1:
////            MULTIPLEXER_1->ATTIVA_CHIP_SELECTOR_MULTIPLEXER_1();
//      case 2:
//          MULTIPLEXER_2->ATTIVA_CHIP_SELECTOR_MULTIPLEXER_2();
//      case 3:
//          MULTIPLEXER_3->ATTIVA_CHIP_SELECTOR_MULTIPLEXER_3();
//      case 4:
//          MULTIPLEXER_4->ATTIVA_CHIP_SELECTOR_MULTIPLEXER_4();            
//  }
//}
 
/*****************************************************************************
Attiva_linea_del_Multiplexer    numero_linea [1,8]  numero_multiplexer [1,4]
 *****************************************************************************/
//void Attiva_linea_del_Multiplexer(int numero_linea, int numero_multiplexer)
//{
//  // Multiplexer 1
////    if(numero_multiplexer==1)
////    {
////        switch (numero_linea)
////        {
////            case 1:
//////              MULTIPLEXER_1->Attiva_linea_AN1();          
////            case 2:
//////              MULTIPLEXER_1->Attiva_linea_AN2();                  
////            case 3:
//////              MULTIPLEXER_1->Attiva_linea_AN3();                  
////            case 4:
//////              MULTIPLEXER_1->Attiva_linea_AN4();                  
////            case 5:
//////              MULTIPLEXER_1->Attiva_linea_AN5();              
////            case 6:
//////              MULTIPLEXER_1->Attiva_linea_CC2();                  
////            case 7:
//////              MULTIPLEXER_1->Attiva_linea_DD2();                  
////            case 8:
//////              MULTIPLEXER_1->Attiva_linea_EE2();                  
////        }       
////    }
//  
//  // Multiplexer 2
//  if(numero_multiplexer==2)
//  {
//      switch (numero_linea)
//      {
//          case 1:
//              MULTIPLEXER_2->Attiva_linea_MM1();
//          case 2:
//              MULTIPLEXER_2->Attiva_linea_MM2();              
//          case 3:
//              MULTIPLEXER_2->Attiva_linea_NN1();                  
//          case 4:
//              MULTIPLEXER_2->Attiva_linea_NN2();                  
//          case 5:
//              MULTIPLEXER_2->Attiva_linea_TT1();      
//          case 6:
//              MULTIPLEXER_2->Attiva_linea_TT2();              
//          case 7:
//              MULTIPLEXER_2->Attiva_linea_HH2();                  
//          case 8:
//              MULTIPLEXER_2->Attiva_linea_LL2();                  
//      }       
//  }
//  
//  // Multiplexer 3
//  if(numero_multiplexer==3)
//  {
//      switch (numero_linea)
//      {   
//          case 6:
//          MULTIPLEXER_3->Attiva_linea_CC1();              
//          case 7:
//          MULTIPLEXER_3->Attiva_linea_DD1();                  
//          case 8:
//          MULTIPLEXER_3->Attiva_linea_EE1();                      
//      }           
//  }
//  
//  // Multiplexer 4
//  if(numero_multiplexer==4)
//  {
//      switch (numero_linea)
//      {
//          case 1:
//              MULTIPLEXER_4->Attiva_linea_FF1();
//          case 2:
//              MULTIPLEXER_4->Attiva_linea_FF2();                  
//          case 3:
//              MULTIPLEXER_4->Attiva_linea_GG1();                      
//          case 4:
//              MULTIPLEXER_4->Attiva_linea_GG2();              
//          case 5:
//              MULTIPLEXER_4->Attiva_linea_UU1();  
//          case 6:
//              MULTIPLEXER_4->Attiva_linea_UU2();              
//          case 7:
//              MULTIPLEXER_4->Attiva_linea_HH1();                      
//          case 8:
//              MULTIPLEXER_4->Attiva_linea_LL1();              
//      }               
//  }
//}
 
 
 /****************************************************************************
    Abbassa_chip_selector_multiplexer
 *****************************************************************************/
//void Abbassa_chip_selector_multiplexer(void)
//{
//  GPIO_PinWrite(1, Chip_Sel_Multiplexer_4 ,0);                
//  GPIO_PinW