I2C_to_parallel.c

Go to the documentation of this file.

 
 
#include "tutti_gli_header.h"
 
// DOCUMENTAZIONE DOXYGEN
/// \file 
 
/*! \page I2C_to_parallel
*\brief  <span style="color:red;"> <b> This chip is exploited to set the chips select  </b> </span>
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref managing_of_I2C_to_parallel
 
 
*\section managing_of_I2C_to_parallel User use of I2C to Parallel
<hr width="75%" size="10" align="left">
 
\n This chip is the PCA9554 (<a href="./File_pdf/PCA9554_9554A.pdf"  target=_blank><b>PCA9554A datasheet</b></a>).
 
\n This chip is exploited to manage the chip select pins of the chips that work with SPI or with a parallel bus. They are 3 chips that are selected, by mean of the user functions by:
 - #I2C_to_Parallel_name_1
 - #I2C_to_Parallel_name_2
 - #I2C_to_Parallel_name_3
 
 \n The 3 chips are I2C and their addresses, trasparent to the user, are:
 - #I2C_to_Parallel_address_1 
 - #I2C_to_Parallel_address_2
 - #I2C_to_Parallel_address_3
 
\n There are 2 functions to use. The first is the initialization function: I2C_to_Parallel_ini_PCA9554() with input parameters: <i>uint8_t scheda_su_scheda_giu,    uint8_t select_PCA</i>. 
The second operational function, I2C_to_Parallel_set_PCA9554_outputs_values() with input parameters: <i>uint8_t scheda_su_scheda_giu,   uint8_t select_PCA, uint8_t value</i> 
is the one that allows to set the port. 
 
\n The PCA9554 has 4 commands listed below. Only the fourth command, which allows to set the chip as an output port,
is exploited for our purpose. For diagnostic purpose the first command, the reading command, is exploited.
\n The 4 commands are implicitily used in the above functions: 
    -# #I2C_to_Parallel_Command_read_output,                        Read output pin, either if they are inputs or outpus
    -# #I2C_to_Parallel_Command_data_to_write,                      Data are written in the bits set as output
    -# #I2C_to_Parallel_Command_polarity_inversion,         Polarity inversion of the read bit, set all 0 in our case
    -# #I2C_to_Parallel_Command_configuration_register, Configuration register, set to 0 for ouput of the corresponding bit     
 
\n The scheme of the PCA9554 is in Figure \ref Figure_I2C_to_parallel.
 
 
 \n The first action to do is to initialize all the 3 PCA9554s. Here the case for the first:
 
<span style="color:orange;"> <I>
\code {.c}
I2C_to_Parallel_ini_PCA9554( scheda_su_scheda_giu,  I2C_to_Parallel_name_1 );  
\endcode
</I> </span>
 
\n Every chip select is active low, but one, so the starting output values, all chps off, transparent to user, 
is not 0xFF for the 3 chpis, but:
    - #I2C_to_Parallel_1_ini_set
    - #I2C_to_Parallel_2_ini_set
    - #I2C_to_Parallel_3_ini_set
    
\n To easy the job there is the 4 taps vector #I2C_to_Parallel_ini_set that contains the 3 values above in the last 3 positions 
(the first poition is unusued).
 
\n There are also structured vectors of constants that have set the parameters of interest regarding the PCA and its pin to select:
 *\snippet I2C_to_parallel.h struct_chip_select_type
 
\n The I2C_to_Parallel_set_PCA9554_outputs_values() allows to set any value at the output port and it is usefull for parallel bus driven chips, 
such as the analog mux \ref Multiplexer_strutture_funzioni_definizioni "ADG14082". For this latter refer to its 
\ref Multiplexer_strutture_funzioni_definizioni "specific page".
\n Whenever we need to manage a SPI driven chip the first think to do is to anable it and the first function to use is the
I2C_to_Parallel_set_PCA9554_outputs_values() to enable the chip; after the job is done, do not forget to disable the chip. Here
is an example:
 
<span style="color:orange;"> <I>
\code {.c}
speak_with_a_chipX( scheda_su_scheda_giu,   #I2C_to_Parallel_name_1 ){
I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_scheda_giu,   select_PCA_of_chipX,  select_PCA_of_chipX ) ;
 
// Do the job
 
I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_scheda_giu,   select_PCA_of_chipX,  I2C_to_Parallel_ini_set[ini_value_for_the_PCA_of_chipX]) ;
}
\endcode
</I> </span>
 
\sa A more specific use of the I2C_to_Parallel_set_PCA9554_outputs_values() function can be seen here Relays_driver_set_reset_channel().
\n The function is used in: Analog_mux_line_to_select_deselect(), instr_inizializza_tutto_da_zero_function(), Relays_driver_set_reset_channel() 
and PGA_GAIN().
 
\note A mnemonic way to refer to the output pins is to use the enum pin_x, x=1,..,8: 
\snippet I2C_to_parallel.c enum_I2C_to_Parallel_pin_type
 
    
*\anchor Figure_I2C_to_parallel
*\image html I2C_to_Parallel_PCA9554.png "Figure I2C_to_parallel 1: I2C to parallel PCA9554" width=60%  
*\image latex I2C_to_Parallel_PCA9554.png "Figure I2C_to_parallel 1: I2C to parallel PCA9554" width=60% 
 
 
 The codes for mamnaging the mux are: 
 - \ref  I2C_to_parallel.h  
 - \ref  I2C_to_parallel.c
 
<!-- pappa -->  
*/
 
//INIZIO CROSS
 
/*! \brief These are the aliases for the I2C to parallel output
 */
 //! <!-- [enum_I2C_to_Parallel_pin_type] -->
enum I2C_to_Parallel_pin_type{
    pin_1, //!< This is the first pin of the output port
    pin_2,
    pin_3,
    pin_4,
    pin_5,
    pin_6,
    pin_7,
    pin_8 //!< This is the last pin of the output port
} ;
 //! <!-- [enum_I2C_to_Parallel_pin_type] -->
 
 
//struct  chip_select_type{
//uint8_t I2C_to_parallel_chip_num;
//uint8_t I2C_to_parallel_chip__pin_num;
//} ;
 
/*! \brief This is the vector of constant values which allows to enable the relays drivers of each channels, one at a time. 
Every selecting pin to be enabled needs to select the chip, namely the port to which is connected, and the pin on the port.
 
\note <b> ... & #I2C_to_Parallel_2_ini_set </b> The analog mux ADG1408 chip select is idle when 0 it equals 0x7F
\n <b> ... & #I2C_to_Parallel_2_ini_set </b> is also set for the reson above.
\n More about the ADG1408 can be found at \ref Multiplexer_strutture_funzioni_definizioni.
\n \emoji :wink:
 
*/
 //! <!-- [vec_detector_chip_select_bias] -->
const struct chip_select_type detector_chip_select_bias[channel_number]=
            {I2C_to_Parallel_name_1, ~(1<<pin_1 ),
            I2C_to_Parallel_name_1, ~(1<<pin_3 ),
            I2C_to_Parallel_name_1, ~(1<<pin_5 ),
            I2C_to_Parallel_name_1, ~(1<<pin_7 ),   
            I2C_to_Parallel_name_2, (~(1<<pin_1 ) & I2C_to_Parallel_2_ini_set),     
            I2C_to_Parallel_name_2, (~(1<<pin_3 ) & I2C_to_Parallel_2_ini_set)} ;                           
 //! <!-- [vec_detector_chip_select_bias] -->
                                                                                                                                    
                                                                                                                                    
const struct chip_select_type     detector_reset_all_relays_driver={I2C_to_Parallel_name_3, (~(1<<pin_1 ) & I2C_to_Parallel_3_ini_set)} ; //< reset signal to the reset pin of 
                            //the 6 relays drivers.
 
const struct chip_select_type    PGA_DAC_chip_select[channel_number]={I2C_to_Parallel_name_1, ~(1<<pin_2 ),
                                                                                                                                       I2C_to_Parallel_name_1, ~(1<<pin_4 ),
                                                                                                                                       I2C_to_Parallel_name_1, ~(1<<pin_6 ),
                                                                                                                                       I2C_to_Parallel_name_1, (uint8_t) ~(1<<pin_8 ),
                                                                                                                                       I2C_to_Parallel_name_2, (~(1<<pin_2 ) & I2C_to_Parallel_2_ini_set),
                                                                                                                                       I2C_to_Parallel_name_2, (~(1<<pin_4 ) & I2C_to_Parallel_2_ini_set) } ;
 //! ...
const uint8_t I2C_to_Parallel_ini_set[4]={0, I2C_to_Parallel_1_ini_set, I2C_to_Parallel_2_ini_set, I2C_to_Parallel_3_ini_set};                                                                                                                                  
 
 /*! \brief The I2C_to_Parallel_ini_PCA9554 inits the I2C_to_Parallel_ini_PCA9554 chips by setting all the outputs high, 
                    but the 2 chip select analog muxes, to disable all the chips
 
 *\param[in] scheda_su_scheda_giu one of the 2 boards that the postfrontend manages
 *\param[in] select_PCA the channel in the mux to be enabled, 1, 2 or 3
 *\return No Parameters
 
 *\snippet{lineno} I2C_to_parallel.c fun_I2C_to_Parallel_ini_PCA9554
 */
 //! <!-- [fun_I2C_to_Parallel_ini_PCA9554] -->
void I2C_to_Parallel_ini_PCA9554( uint8_t scheda_su_scheda_giu,     uint8_t select_PCA ){
    uint8_t indirizzo= I2C_to_Parallel_address_1; //We set the first chip; below we will see if this is true
    uint8_t impostazione_iniziale_della_porta= I2C_to_Parallel_1_ini_set; //Default setting for first chip is this.
    uint8_t comando[]={I2C_to_Parallel_Command_configuration_register,0};  //the value of 0 set all bits as ouput and default to 1
    
        if ( select_PCA == I2C_to_Parallel_name_2){
            indirizzo= I2C_to_Parallel_address_2;
            impostazione_iniziale_della_porta=I2C_to_Parallel_2_ini_set;
    }else if (select_PCA == I2C_to_Parallel_name_3){
        indirizzo= I2C_to_Parallel_address_3;
        impostazione_iniziale_della_porta=I2C_to_Parallel_3_ini_set;
    }
//void I2C_mux_select_ch( uint8_t scheda_su_scheda_giu, I2C_mainboard,uint8_t  canale_da_abilitare)
 I2C_mux_select_ch(  scheda_su_scheda_giu,  I2C_mainboard, I2C_mux_abilita_3);  //I2C_mux_abilita_3= the i2C connected to the PCA's
 
            I2C_mux -> MasterTransmit( indirizzo, comando, 2,false); //Set all bits as outputs
            while( I2C_mux -> GetStatus().busy);  // White transmission complete
    
            comando[0]=I2C_to_Parallel_Command_data_to_write;
            comando[1]= impostazione_iniziale_della_porta;  //Ouputs all high   
            I2C_mux -> MasterTransmit( indirizzo, comando, 2,false);  //setbuf all bits to high
            while( I2C_mux -> GetStatus().busy);  // White transmission complete        
    
            comando[0]=I2C_to_Parallel_Command_read_output;
            I2C_mux -> MasterTransmit( indirizzo, comando, 1,true); //Set input register to read
            while( I2C_mux -> GetStatus().busy);  // White transmission complete
            comando[0]=0;
            comando[1]=0;
            I2C_mux -> MasterReceive( indirizzo, comando, 1,false);  //Read back, not needed
            while( I2C_mux -> GetStatus().busy);    
    I2C_mux_select_ch(  scheda_su_scheda_giu,  I2C_mainboard, I2C_mux_disabilita_tutto); //Idle
}
 //! <!-- [fun_I2C_to_Parallel_ini_PCA9554] -->
 
 
 /*! \brief The function I2C_to_Parallel_set_PCA9554_outputs_values allow to set the output pin of the I2C to parallel, there are
structures for this. The detector: detector_chip_select_bias, the PGA_DAC
 
 *\param[in] scheda_su_scheda_giu one of the 2 boards that the postfrontend manages
 *\param[in] select_PCA   the mux to be enabled, 1, 2 or 3
 *\param[in] value  the vlue to be set
 *\return No Parameters
 
 
 *\snippetlineno I2C_to_parallel.c fun_I2C_to_Parallel_set_PCA9554_outputs_values
 */
 //! <!-- [fun_I2C_to_Parallel_set_PCA9554_outputs_values] -->
void I2C_to_Parallel_set_PCA9554_outputs_values( uint8_t scheda_su_scheda_giu,  uint8_t select_PCA, uint8_t value ){
    uint8_t indirizzo= I2C_to_Parallel_address_1;  //Indirizzo di default
    uint8_t comando[]={I2C_to_Parallel_Command_data_to_write, value }, scheda_su_scheda_giu_qui;  //All bits set to ouput and to 1
    
        if ( select_PCA == I2C_to_Parallel_name_2){
            indirizzo= I2C_to_Parallel_address_2;
    }else if (select_PCA == I2C_to_Parallel_name_3){
        indirizzo= I2C_to_Parallel_address_3;
    }
 
 
//void I2C_mux_select_ch( uint8_t scheda_su_scheda_giu, uint8_t  canale_da_abilitare)
         I2C_mux_select_ch(  scheda_su_scheda_giu, I2C_mainboard, I2C_mux_abilita_3);
 
            I2C_mux -> MasterTransmit( indirizzo, comando, 2,false); //Set all bits as outputs
            while( I2C_mux -> GetStatus().busy);  // White transmission complete
        
    
            comando[0]=I2C_to_Parallel_Command_read_output;
            I2C_mux -> MasterTransmit( indirizzo, comando, 1,true); //Set input register to read
            while( I2C_mux -> GetStatus().busy);  // White transmission complete
            if(Error_bad_operation) ERROR_codifica_errore(scheda_su_scheda_giu , error_address_I2C0 , I2C_Error_I2C_to_parallel_PCA9554_0  + I2C_mux_abilita_3, 1);
            comando[0]=0;
            comando[1]=0;
            I2C_mux -> MasterReceive( indirizzo, comando, 1,false);  //Read back, not needed
            while( I2C_mux -> GetStatus().busy);    
            if(Error_bad_operation) ERROR_codifica_errore(scheda_su_scheda_giu , error_address_I2C0 , I2C_Error_I2C_to_parallel_PCA9554_0  + I2C_mux_abilita_3, 1); 
}
//! <!-- [fun_I2C_to_Parallel_set_PCA9554_outputs_values] -->
 
//Fine cross