Detector_Relays_managing.c

Go to the documentation of this file.

 
 
 
#include "tutti_gli_header.h"
 
//DOCUMENTAZIONE DOXYGEN
/// \file
 
/*! \page Detector_Relays_managing_page Detector_Relays_managing
\brief <span style="color:red;"> <b> Relais operation </b> </span>
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref user_use_of_relais
 
 
*\section user_use_of_relais User use of relais
<hr width="75%" size="10" align="left">
\n Connections of the detectors to the front-end need to be very accurate. For that we use 2 different kind of 
bi-stable relais as switches. Their difference is mainly in shape. The relay that allows to select between internal or 
external power supplies to the detector bias system is small, with a pin pitch of 100 mils, figure \ref Figure_rele_internal_external_bias and 
 <a href="./File_pdf/TQ2-L2-5V.pdf"  target=_blank><b>TQ2-L2-5V datasheet</b></a>. The relais which are directely
connected to the detector need a very large impedance and are larger, with a pin pitch of 200 mils, figure
\ref Figure_rele_to_detector and <a href="./File_pdf/DS2-L2-5V.pdf"  target=_blank><b>DS2-L2-5V datasheet</b></a>.
 
*\anchor Figure_rele_internal_external_bias
*\image html TQ2-L2-5V.jpg "Figure_Relay_internal_external_bias 1: This is the bi-stable relay for selecting internal or external bias." width=10%  
*\image latex TQ2-L2-5V.jpg "Figure_Relay_internal_external_bias 1: This is the bi-stable relay for selecting internal or external bias." width=10% 
 
*\anchor Figure_rele_to_detector
*\image html DS2-L2-5V.jpg "Figure_Relay_to_detector 2: This are the bi-stable relais for detector operation: load resistor selection, preamplifier connection to dummy resistors or to detector and detector bias inversion." width=10%    
*\image latex DS2-L2-5V.jpg "Figure_Relay_to_detector 2: This are the bi-stable relais for detector operation: load resistor selection, preamplifier connection to dummy resistors or to detector and detector bias inversion." width=10%   
 
\n Being bi-stable relais they need 2 signals for their setting/resetting and the <a href="./File_pdf/MAX4820.pdf"  target=_blank><b>MAX4820</b></a>
is the 8 signals driver we use for it. Its schematic diagram is in figure \ref Figure_Max4820_schemme. 
It communicates with SPI and for this we use the function Relays_driver_set_reset_channel() with input parameters <i> uint8_t scheda_su_giu, uint8_t numero_canale , uint8_t valore_da_trasmettere </i>
where \b scheda_su_giu is the selected board, \b numero_canale is the channel for which we need to apply the new setting 
and \b valore_da_trasmettere is the action to apply. The possible settings are as it follows, where for setting the 
bit it needs either to use the definition or setting a "1" in the position defined by the bullet (for instance
to set the large Load resistor we can use #Detector_large_RLOAD or 1<<2):
\n 
<center>
\anchor Table_relais_settings \b Table \b Detector \b Relais \b Settings 
Data                              | Bit     |  Setting                    |
:---------------------------------| :------:| :---------------------------|
| Detecor bias polarity           | 1 << 0  |  #Detector_bias_invertito   |
| ^                               | 1 << 1  |  #Detector_bias_diretto     |
| Load Resistor setting           | 1 << 2  |  #Detector_large_RLOAD      |
| ^                               | 1 << 3  |  #Detector_small_RLOAD      |
| Preamplifier to dummy resistors | 1 << 4  | #Detector_prea_to_GND       |
| Preamplifier to detector        | 1 << 5  | #Detector_prea_to_det       |
| Detector bias source (*)        | 1 << 6  | #Detector_external_bias     |
| ^                               | 1 << 7  | #Detector_internal_bias     |
</center>
 
\attention <b> (*):</b> for safety reason these 2 switches,  #Detector_external_bias and 
#Detector_internal_bias, are set if and only if the positive 
external applied detector biasing voltage is within <b> 1 V </b> and <b> 6 V </b> and the negative external detector applied 
biasing voltage is within <b> -6 V </b> and <b> -1 V </b>. The absolute limits of &plusmn;1 V and &plusmn;6 V are subjected to change 
and are defined at #Detector_min_voltage_for_switch and #Detector_max_voltage_for_switch.
 
\n Note that the state of the settings is stored in the vector:
*\snippet Detector_Bias.c vec_detector_Relay_state
\n that maintains the same flag positions as in \ref Table_relais_settings, or:
\snippet Detector_Relays_managing.h def_detector_Relay_flags_setting
\note Because of the relaies can change state at power ON there is not assurance that
the state is effective if a power cut or a reset happened.
 
\n Here an example for connecting all the channels to the internal dummy resistors:
<span style="color:orange;"> <I>
\code {.c}
    uint8_t canale_;
    for( canale_=0; canale_ <6; canale_ ++ ){
        Relays_driver_set_reset_channel(scheda_su_scheda_giu_provvisorio, canale_ ,  Detector_prea_to_GND );
    }
\endcode
</I> </span>
 
*\anchor Figure_Max4820_schemme
*\image html Max48220.png "Figure_max4820 3: Schematic diagram of the driver MAX4820." width=40%    
*\image latex Max48220.png "Figure_max4820 3: Schematic diagram of the driver MAX4820." width=40%   
 
\n The codes for Relais setting are: 
- \ref Detector_Relays_managing.c
- \ref Detector_Relays_managing.h
 
*/
 
/*!
 
    
*/
 
 
//Inizio CROSS
 /****************************************************************************
 Funzioni di Gianlu
 *****************************************************************************/
 /*! \brief Setting the state of the detector realis: pre connected to detector or intrnal resistor,
 polarity of the detector bias, load resistro choiche and internal or external detector bias.
 
 *\param[in] scheda_su_giu the board to be managed of the 2 available
 *\param[in] numero_canale the channel for which we need to manage the relay        
 *\param[in] valore_da_trasmettere      the relay to be managed         
 *\return No Parameters
 
 *\snippetlineno Detector_Relays_managing.c   fun_Relays_driver_set_reset_channel
 */
 //! <!-- [fun_Relays_driver_set_reset_channel] -->
 void Relays_driver_set_reset_channel(uint8_t scheda_su_giu, uint8_t numero_canale , uint8_t valore_da_trasmettere){
            
            SPIdrv->Control(SPI_control_for_relay_driver, spi_clock_for_relais); // SPI fits Relay driver specs at 8 bits and speed
            //Detector Relays Drivers reset and un-reset all together with the reset pin
            I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_giu,      detector_reset_all_relays_driver.I2C_to_parallel_chip_num, detector_reset_all_relays_driver.I2C_to_parallel_chip__pin_num);         
            Aspetta_tanti_ms(10);    
            I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_giu,      detector_reset_all_relays_driver.I2C_to_parallel_chip_num, \
                                                                                    I2C_to_Parallel_ini_set[detector_reset_all_relays_driver.I2C_to_parallel_chip_num] );   
            Aspetta_tanti_ms(1);    
     
     //Chip_select: now select the chip to speak with
            I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_giu,      detector_chip_select_bias[numero_canale].I2C_to_parallel_chip_num, \
                                                                                detector_chip_select_bias[numero_canale].I2C_to_parallel_chip__pin_num);
            Aspetta_tanti_ms(1);
//          SPItx(valore_da_trasmettere);
            SPIdrv->Send ( &valore_da_trasmettere ,1); //send the 16 bits
//          while( SPIdrv->GetStatus().busy ){} //wait end of transmission   
//          Aspetta_tanti_ms(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(scheda_su_giu, error_address_SPI, SPI_error_EVENT_DATA_LOST,1);
                            
            I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_giu,      detector_chip_select_bias[numero_canale].I2C_to_parallel_chip_num,\
                        I2C_to_Parallel_ini_set[detector_chip_select_bias[numero_canale].I2C_to_parallel_chip_num]); //Set the driver OFF: it is important to switch off the chip because ony in this moment the outputs are
                                                                    // enabled
            Aspetta_tanti_ms(wait_time_for_rele_setting);   //Wait the time the relay takes action, 5 ms at least.
            
            I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_giu,      detector_chip_select_bias[numero_canale].I2C_to_parallel_chip_num, \
                                    detector_chip_select_bias[numero_canale].I2C_to_parallel_chip__pin_num);//Select the cip again
            Aspetta_tanti_ms(1);
//          SPItx(0);       
            uint8_t zero=0;
            SPIdrv->Send ( &zero ,1); // Set high all the ouputs
            Aspetta_tanti_ms(1);
            I2C_to_Parallel_set_PCA9554_outputs_values(  scheda_su_giu,      detector_chip_select_bias[numero_canale].I2C_to_parallel_chip_num,\
                                I2C_to_Parallel_ini_set[detector_chip_select_bias[numero_canale].I2C_to_parallel_chip_num]);    //Disable the chip and set high the ouputs 
            Aspetta_tanti_ms(wait_time_for_rele_setting);   
 
//Qui consideriamo la varibaile di stato per il detector relay
    uint8_t canalone=scheda_su_giu *6 + numero_canale;
    if (valore_da_trasmettere &     Detector_prea_to_det){
        detector_Relay_state[canalone] |=Detector_prea_to_det;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_prea_to_GND);
    }else if (valore_da_trasmettere &   Detector_prea_to_GND){
        detector_Relay_state[canalone] |=Detector_prea_to_GND;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_prea_to_det);
    }
    if (valore_da_trasmettere &     Detector_large_RLOAD){
        detector_Relay_state[canalone] |=Detector_large_RLOAD;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_small_RLOAD);
    }else if (valore_da_trasmettere &   Detector_small_RLOAD){
        detector_Relay_state[canalone] |=Detector_small_RLOAD;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_large_RLOAD);
    }
    if (valore_da_trasmettere &     Detector_external_bias){
        detector_Relay_state[canalone] |=Detector_external_bias;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_internal_bias);
    }else if(valore_da_trasmettere &    Detector_internal_bias){
        detector_Relay_state[canalone] |=Detector_internal_bias;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_external_bias);
    }   
    if (valore_da_trasmettere &     Detector_bias_invertito){
        detector_Relay_state[canalone] |=Detector_bias_invertito;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_bias_diretto);
    }else if(valore_da_trasmettere &    Detector_bias_diretto){
        detector_Relay_state[canalone] |=Detector_bias_diretto;
        detector_Relay_state[canalone] &= ~(uint8_t)(Detector_bias_invertito);
    }       
                
 }
  //! <!-- [fun_Relays_driver_set_reset_channel] -->
 
 //Fine CROSS
 
 
//Commento tutto da qui
 
 void Funzione_per_attivare(uint8_t numero_canale /*0=ch0,1=ch1*/, uint8_t valore_da_trasmettere/*rele to set*/)
{
//  uint8_t chip_sel; 
    porta_pin_def chip_da_usare;
//  GPIO_PinWrite(rele_driver_ch1.porta_num, rele_driver_ch1.pin_num ,1);   // Set off both the drivers to start
    GPIO_PinWrite(rele_driver_ch0.porta_num, rele_driver_ch0.pin_num,1);    
    if(numero_canale ==0) //select the driver 
    {
//      chip_sel = Chip_Sel_rele_0;
        chip_da_usare=rele_driver_ch0;
    }
    else
    {
//      chip_sel = Chip_Sel_rele_1; 
//      chip_da_usare=rele_driver_ch1;
    }
        GPIO_PinWrite(chip_da_usare.porta_num, chip_da_usare.pin_num, 0); //Set the driver ON
        SPItx(valore_da_trasmettere);
        Aspetta_tanti_ms(10);
        GPIO_PinWrite(chip_da_usare.porta_num, chip_da_usare.pin_num, 1); //Set the driver OFF: the set is applied 
        Aspetta_tanti_ms(wait_time_for_rele_setting);                                           // Bisogna aspettare almeno 5 ms prima di inviare un'altra istruzione
            
        GPIO_PinWrite(chip_da_usare.porta_num, chip_da_usare.pin_num, 0);   //Set the driver ON
        SPItx(0);                                                                   // Viene inviato un 0, in questo modo viene azzerato tutto
        Aspetta_tanti_ms(10);
        GPIO_PinWrite(chip_da_usare.porta_num, chip_da_usare.pin_num, 1);   //Set the driver OFF: the set is applied
        Aspetta_tanti_ms(wait_time_for_rele_setting);   
}
 
 /****************************************************************************
 FINE Funzioni di Gianlu
 *****************************************************************************/
 
/*****************************************************************************
 *****************************************************************************
 RELE S1
 *****************************************************************************
 *****************************************************************************/
// typedef struct rele_s1 {
//  void              (*Attiva_OUT1_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT1_ch0
//  void              (*Attiva_OUT2_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT2_ch0
//} const struttura_rele_s1;
 
 /****************************************************************************
 Funzioni del RELE S1
 *****************************************************************************/
void Attiva_OUT_1_ch0 (void)
{
    Funzione_per_attivare(0,1);
}
 
void Attiva_OUT_2_ch0 (void)
{
    Funzione_per_attivare(0,2);
}
 
// La struttura rele_s1 viene controllata con relee_s1
// La struttura multi_1 viene controllata con multipl_1
struttura_rele_s1 Rele_s1= {
        Attiva_OUT_1_ch0,
        Attiva_OUT_2_ch0,
};
 
 struttura_rele_s1 *RELE_S1= &Rele_s1;                              // Viene creato un puntatore a relee_s1
 
 
 
/*****************************************************************************
 *****************************************************************************
 RELE S2
 *****************************************************************************
 *****************************************************************************/
//typedef struct rele_s2 {
//  void              (*Attiva_OUT3_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT3_ch0
//  void              (*Attiva_OUT4_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT4_ch0
//} const struttura_rele_s2;
 
 /****************************************************************************
 Funzioni del RELE S2
 *****************************************************************************/
void Attiva_OUT_3_ch0 (void)
{
    Funzione_per_attivare(0,4); 
}
 
void Attiva_OUT_4_ch0 (void)
{
    Funzione_per_attivare(0,8); 
}
 
 
// La struttura rele_s2 viene controllata con relee_s2
struttura_rele_s2 Rele_s2= {
        Attiva_OUT_3_ch0,
        Attiva_OUT_4_ch0,
};
 
 struttura_rele_s2 *RELE_S2= &Rele_s2;                              // Viene creato un puntatore a relee_s2
 
 
 
/*****************************************************************************
 *****************************************************************************
 RELE S3
 *****************************************************************************
 *****************************************************************************/
// typedef struct rele_s3 {
//  void              (*Attiva_OUT5_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT5_ch0
//  void              (*Attiva_OUT6_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT6_ch0
//} const struttura_rele_s3;
 
 /****************************************************************************
 Funzioni del RELE S3
 *****************************************************************************/
void Attiva_OUT_5_ch0 (void)
{
    Funzione_per_attivare(0,16);
}
 
void Attiva_OUT_6_ch0 (void)
{
    Funzione_per_attivare(0,32);    
}
 
 
// La struttura rele_s3 viene controllata con relee_s3
struttura_rele_s3 Rele_s3= {
        Attiva_OUT_5_ch0,
        Attiva_OUT_6_ch0,
};
 
 struttura_rele_s3 *RELE_S3= &Rele_s3;                              // Viene creato un puntatore a relee_s3
 
 
 
/*****************************************************************************
 *****************************************************************************
 RELE K4
 *****************************************************************************
 *****************************************************************************/
// typedef struct rele_k4 {
//  void              (*Attiva_OUT7_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT7_ch0
//  void              (*Attiva_OUT8_ch0)                (void);                             ///< Puntatore a \ref Attiva_OUT8_ch0
//} const struttura_rele_k4;
 
 /****************************************************************************
 Funzioni del RELE K4
 *****************************************************************************/
void Attiva_OUT_7_ch0 (void)
{
    Funzione_per_attivare(0,64);
}
 
void Attiva_OUT_8_ch0 (void)
{
    Funzione_per_attivare(0,128);   
}
 
 
// La struttura rele_k4 viene controllata con relee_k4
struttura_rele_k4 Rele_k4= {
        Attiva_OUT_7_ch0,
        Attiva_OUT_8_ch0,
};
 
 struttura_rele_k4 *RELE_K4= &Rele_k4;                              // Viene creato un puntatore a relee_k4
 
 
 
 
 
/*****************************************************************************
 *****************************************************************************
 RELE S4
 *****************************************************************************
 *****************************************************************************/
// typedef struct rele_s4 {
//  void              (*Attiva_OUT1_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT1_ch1
//  void              (*Attiva_OUT2_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT2_ch1
//} const struttura_rele_s4;
 
 /****************************************************************************
 Funzioni del RELE S4
 *****************************************************************************/
void Attiva_OUT_1_ch1 (void)
{
    Funzione_per_attivare(1,1);
}
void Attiva_OUT_2_ch1 (void)
{
    Funzione_per_attivare(1,2);
}
 
 
// La struttura rele_s4 viene controllata con relee_s4
struttura_rele_s4 Rele_s4= {
        Attiva_OUT_1_ch1,
        Attiva_OUT_2_ch1,
};
 
 struttura_rele_s4 *RELE_S4= &Rele_s4;                              // Viene creato un puntatore a relee_s4
 
 
 
/*****************************************************************************
 *****************************************************************************
 RELE S5
 *****************************************************************************
 *****************************************************************************/
// typedef struct rele_s5 {
//  void              (*Attiva_OUT3_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT3_ch1
//  void              (*Attiva_OUT4_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT4_ch1
//} const struttura_rele_s5;
 
 /****************************************************************************
 Funzioni del RELE S5
 *****************************************************************************/
void Attiva_OUT_3_ch1 (void)
{
    Funzione_per_attivare(1,4);
}
 
void Attiva_OUT_4_ch1 (void)
{
    Funzione_per_attivare(1,8);
}
 
 
// La struttura rele_s5 viene controllata con relee_s5
struttura_rele_s5 Rele_s5= {
        Attiva_OUT_3_ch1,
        Attiva_OUT_4_ch1,
};
 
 struttura_rele_s5 *RELE_S5= &Rele_s5;                              // Viene creato un puntatore a relee_s5
 
 
 
/*****************************************************************************
 *****************************************************************************
 RELE S6
 *****************************************************************************
 *****************************************************************************/
// typedef struct rele_s6 {
//  void              (*Attiva_OUT5_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT5_ch1
//  void              (*Attiva_OUT6_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT6_ch1
//} const struttura_rele_s6;
 
 /****************************************************************************
 Funzioni del RELE S6
 *****************************************************************************/
void Attiva_OUT_5_ch1 (void)
{
    Funzione_per_attivare(1,16);
}
 
void Attiva_OUT_6_ch1 (void)
{
    Funzione_per_attivare(1,32);    
}
 
 
// La struttura rele_s6 viene controllata con relee_s6
struttura_rele_s6 Rele_s6= {
        Attiva_OUT_5_ch1,
        Attiva_OUT_6_ch1,
};
 
 struttura_rele_s6 *RELE_S6= &Rele_s6;                              // Viene creato un puntatore a relee_s6
 
 
 
/*****************************************************************************
 *****************************************************************************
 RELE K5
 *****************************************************************************
 *****************************************************************************/
// typedef struct rele_k5 {
//  void              (*Attiva_OUT7_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT7_ch1
//  void              (*Attiva_OUT8_ch1)                (void);                             ///< Puntatore a \ref Attiva_OUT8_ch1
//} const struttura_rele_k5;
 
 /****************************************************************************
 Funzioni del RELE K5
 *****************************************************************************/
void Attiva_OUT_7_ch1 (void)
{
    Funzione_per_attivare(1,64);
}
 
void Attiva_OUT_8_ch1 (void)
{
    Funzione_per_attivare(1,128);   
}
 
 
// La struttura rele_k5 viene controllata con relee_k5
 
struttura_rele_k5 Rele_k5= {
        Attiva_OUT_7_ch1,
        Attiva_OUT_8_ch1,
};
 
 struttura_rele_k5 *RELE_K5= &Rele_k5;                              // Viene creato un puntatore a relee_k5
 
 
 
 
 
/*****************************************************************************
 *****************************************************************************
    FUNZIONI UTILI
 *****************************************************************************
 *****************************************************************************/
//void ATTIVA_CANALE_0_PER_I_RELE (void)
//{
//      GPIO_PinWrite(0, Chip_Sel_rele_1 ,1);           // Viene prima alzato quello del canale 1, in modo da non averne 2 abbassati
//      GPIO_PinWrite(0, Chip_Sel_rele_0 ,0);
//}
 
//void ATTIVA_CANALE_1_PER_I_RELE (void)
//{
//      GPIO_PinWrite(0, Chip_Sel_rele_0 ,1);           // Viene prima alzato quello del canale 0, in modo da non averne 2 abbassati
//      GPIO_PinWrite(0, Chip_Sel_rele_1 ,0);
//}
 
void RELE_ATTIVA(int canale, int OUTN)
{
    //Canale 0
    if(canale == 0)
    {
        switch (OUTN)
        {
            case 1:
                RELE_S1->Attiva_OUT1_ch0();                 
            case 2:
                RELE_S1->Attiva_OUT2_ch0();             
            case 3:
                RELE_S2->Attiva_OUT3_ch0();             
            case 4:
                RELE_S2->Attiva_OUT4_ch0();         
            case 5:
                RELE_S3->Attiva_OUT5_ch0();     
            case 6:
                RELE_S3->Attiva_OUT6_ch0();         
            case 7:
                RELE_K4->Attiva_OUT7_ch0();                 
            case 8:
                RELE_K4->Attiva_OUT8_ch0();                 
        }
    }
        
    
// Canale 1     
    if(canale == 1)
    {
        switch (OUTN)
        {
            case 1:
                RELE_S4->Attiva_OUT1_ch1();     
            case 2:
                RELE_S4->Attiva_OUT2_ch1();     
            case 3:
                RELE_S5->Attiva_OUT3_ch1();         
            case 4:
                RELE_S5->Attiva_OUT4_ch1();     
            case 5:
                RELE_S6->Attiva_OUT5_ch1(); 
            case 6:
                RELE_S6->Attiva_OUT6_ch1(); 
            case 7:
                RELE_K5->Attiva_OUT7_ch1();         
            case 8:
                RELE_K5->Attiva_OUT8_ch1();         
        }       
    }
}