Memoria_pre_M24CXX.c

Go to the documentation of this file.

 
// DOCUMENTAZIONE DOXYGEN
/// \file 
 
/*! \page Flash_M24CXX I2C EPROM memory
*\brief  <b> This chip is exploited to store the preamplifier parameters and settings  </b>
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref preamplifier_flash_memory 
*\arg \ref state_store_recovering
*\arg \ref sw_detail
*\arg \ref location_list
*\arg \ref location_list_mainboard
*\arg \ref location_list_postmainboard
 
\section preamplifier_flash_memory Use of the Preamplifier EPROM memory
<hr width="100%" size="20" align="left">
 
\n Each unit of the system has its own EPROM memory where to store at least its sn and, when present, the fw version.
The first samples of the preamplifier has the <a href="./File_pdf/MC24C08.pdf"  target=_blank><b>MC24C08</b></a>,
that is a 8 Kb I2C flash memory. The frontend board has a <a href="./File_pdf/MC24C16.pdf"  target=_blank><b>MC24C16</b></a>.
Finally the postfrontend board has the <a href="./File_pdf/MC24C64.pdf"  target=_blank><b>MC24C64</b></a>. The different memory sizes 
have different cell address organization. From 1Kb up to 16Kb they are shown in figure \ref Figure_M24C00_16K. Namely, depending on the size, the 8-LSb bits 
are in the first word sent, while the MSb in excess of 8 are in the first bits of the I2C addres, so that the larger is the size, the lesser is the available 
choice left for the I2C addres (4 of the 7 I2C address bits are fixed). Different is the approach for the M24C32 and M24C64 that 
uses 2 bytes of data for addressing and have the 3 available bits free for I2C address, the case 1 KB in \ref Figure_M24C00_16K.
\n In our frontend we are going to use the \b M24C32 for both the preamplifier and the frontend board and the \b M24C64 in the post frontend board. 
The different choices are only due to the availability at the moment of the population of the boards. Both memories requires a 2-bytes address.
\n An example of use of 4-bytes writing of the 32k/64K EPROM at addres \b 0x20 of the channel6 EPROM is here:
 
<span style="color:orange;"> <I>
\code {.c}
dati_da_scrivere[0]= 50;  // The value is arbitrary
dati_da_scrivere[1]= 60;
dati_da_scrivere[2]= 70;
dati_da_scrivere[3]= 80;
EPROM_scrittura_M24C32_64(scheda_su_scheda_giu_provvisorio, I2C_mainboard,, canale6 , 0x20 ,  dati_da_scrivere);
\endcode
</I> </span>
 
*\anchor Figure_M24C00_16K
*\image html M24C00_16K.jpg "Figure_M24C00_16K 1: M24C00_16K I2C address organization" width=30%    
*\image latex M24C00_16K.jpg "Figure_M24C00_16K 1: M24C00_16K I2C address organization" width=30%
 
\n There are a number of variables and definitions to manage the memories, but the the functions to use are 
only 2 and very simple. To read from the memory we use EPROM_lettura_M24C32_64(uint8_t scheda_su_scheda_giu,uint8_t I2C_mainboard,uint8_t canale, short indirizzo_memoria , uint8_t *dati_letti),
while to write EPROM_scrittura_M24C32_64(uint8_t scheda_su_scheda_giu, uint8_t mainboard_postmainboard , uint8_t  canale, short indirizzo_memoria , uint8_t *dati_da_scrivere).
\n \b scheda_su_scheda_giu is one of the 2 boards to select, \b canali is the preamplifier memory or the frontend 
board memory, according to the following enum #canali_eprom:
\snippet Memoria_pre_M24CXX.h fun_canali_eprom
\n \b indirizzo_memoria is the address of the memory to write to or to read from and \b *dati_da_scrivere the pointer to the data to read/write. Take care: 
only 4 bytes can be read or written for each call.
 
\remark The EPROM is organized per pages whose length is 16 Bytes from sizes from 0 Kb up to 16 Kb, while it is 32 Bytes for
the 32 Kb and 64 Kb. Writing can be done only per single page, namely, a writing cannot cover 2 pages contemporary. 
To avoid loss of data during writing in the stream of data the address bits from A4 to the MSb must not change, 
for EPROM size smaller or equal to 16 Kb. The same applies to the 32 Kb and 64 Kb except that in this case bits 
from A5 to the MSb are those that should not change during a data storage.
 
\note Variables stored into the memories are located at fixed defined positions. To have a copy of them
the .h files for the preamplifirs EPROM is the "enum    preamplifier_EPROM" on the following
link: <a href="_memoria__pre___m24_c_x_x_8h.html" download>Memoria_pre_M24CXX.h</a>. Note that each element of the link 
must be multiplied by 4 for getting the actual address since the memory is orhanized as a uint32.
 
\section state_store_recovering Channel state store and recovery
<hr width="100%" size="20" align="left">
\n The state condition of the channel cane be recordered and aplied in a differenta ways. The variables that reflect 
the state are stored in 2 memory loactions. 
\n The first state is that recalled at startup. This state requires that the PGA gain is 1 and that the preamplifier 
is connected to GND. The memory location for this state is #Memory_preamplifier_startup_offset_trimmer. Note that at sturtup
this state is applied only if the memory location #Memory_preamplifier_startup_offset_trimmer_ON_0_OFF_ff is set to 0 value.
This is done by the sw at the time the storing takes place.
The state can be called also by setting the corresponding bit, but take care that for this case gain and detector state 
are not resumed and the user must do it.
The startup state is created at the end of the offset adjustment, if the corresponding flag is set.
\n Another possible state is the user state. In this case it is stored at #Memory_preamplifier_user_offset_trimmer and
#Memory_preamplifier_user_detector_and_gain which reflect the full condition for the channel, both offset, gain and
detector condition. This state can be stored in 2 ways. After offset adjustment by setting the corresponding bit, or by
a picture of the state, with no other actions than the storing of the variables, by setting the corresponding bit. 
\n The state can be recovered by the corresponding bit and this work only if the 
#Memory_preamplifier_user_offset_trimmer_ON_0_OFF_ff was set to 0. This is done by the sw at the time the storing takes place.
\n The bits to set are in the 
<a href="_instruction_set.html#instr_output_offset_to_be_set_option" download>instr_output_offset_to_be_set</a>, 
at the Byte<sub>3</sub> option.
 
\remark If the startup stored is invoked remember that it refers to a PGA gain of 1 V/V and the detector disconnected. 
If the user state stored is invoked all the channel settings are recovered from memory: offset, PGA gain end detector settings. 
Regarding the detector setting the amount of the external bias, if it that consodered is not set.
 
\n The function invoked is the following:
*\snippet{lineno} Memoria_pre_M24CXX.c fun_EPROM_store_recover_state_M24C32_64
\n 
 
\section sw_detail Functions and vars details
<hr width="100%" size="20" align="left">
\n Concerning the functions which are able to work with the EPROM having size smaller or equalt o 16Kb we have that 
the reading function is here:
*\snippet{lineno} Memoria_pre_M24CXX.c fun_EPROM_lettura_M24C32_64
\n While the writng function is here:
\snippet{lineno} Memoria_pre_M24CXX.c fun_EPROM_scrittura_M24C32_64
\n There are 4 different I2C channels (selected at  I2C_mux_select_ch()) and 2 I2C addresses are exploitable 
for the preamplifier EPROMs: 
#EPROM_I2C_addres_memory_ch_pari and #EPROM_I2C_addres_memory_ch_dispari, while the onboard EPROM is at
#EPROM_mainboard_I2C_addres. The I2C paremeters for each EPROM are in the structure #address_detector_bias_trimmer_type:
*\snippet Memoria_pre_M24CXX.h fun_EPROM_I2C
\n So that the 7 positions strucure is #EPROM_address.
 
\n The codes for I2C_0 is at: 
- \ref Memoria_pre_M24CXX.c
- \ref Memoria_pre_M24CXX.h
 
\anchor preamplifier_memory_location_list
\section location_list The list of locations of the preamplifier EPROM
<hr width="100%" size="20" align="left">
\n Here the list of the locations of preamplifier EPROM, remember to multiply by 4, or <<2, the bullet number
to set the actual address, an unsigned int:
 
<ol start="0">
  <li> #Memory_preamplifier_address_SN; 
<!-- Preamplifier offset trimmer -->    
    <li> #Memory_preamplifier_slope_calibration_ON_0_OFF_ff;
  <li> #Memory_preamplifier_address_fine_trimmer_slope_offset;  
    <li> #Memory_preamplifier_address_coarse_trimmer_slope_offset;
<!-- Offset trimmer for sturtup --> 
    <li> #Memory_preamplifier_startup_offset_trimmer_ON_0_OFF_ff;   
    <li> #Memory_preamplifier_startup_offset_trimmer;
<!-- User Offset trimmer -->        
    <li> #Memory_preamplifier_user_offset_trimmer_ON_0_OFF_ff;  
    <li> #Memory_preamplifier_user_offset_trimmer;  
    <li> #Memory_preamplifier_user_detector_and_gain;   
    <li> #Memory_preamplifier_user_detector_trimmer;    
<!-- Detector trimmer coarse calibration voltage -->    
    <li> #Memory_detector_coarse_slope_calibration_ON_0_OFF_ff;     
    <li> #Memory_detector_positive_address_coarse_trimmer_slope_bias;       
    <li> #Memory_detector_negative_address_coarse_trimmer_slope_bias;
<!-- Detector trimmer fine calibration voltage -->  
    <li> #Memory_detector_fine_slope_calibration_ON_0_OFF_ff;   
    <li> #Memory_detector_positive_address_fine_trimmer_slope_bias;
    <li> #Memory_detector_negative_address_fine_trimmer_slope_bias.
<!-- Preamplifier Drift parameteers --> 
    <li> #Memory_preamplifier_drift_ON_0_OFF_ff, 
    <li> #Memory_preamplifier_trimmers_for_drift,  
    <li> #Memory_preamplifier_offset_slope_trimmer_with_temp
    <li> #Memory_preamplifier_compensation_slope_trimmer_with_temp
    <li> #Memory_preamplifier_compensation_slope
    <li> #Memory_preamplifier_last_memory_used_first_free
    </li>
</ol>
 
The last memory cell used is #Memory_preamplifier_last_memory_used. If it not coincide with the length of the list above it means that the list is not upgraded.
 
 
\anchor mainboard_memory_location_list
\section location_list_mainboard The list of locations of the mainboard EPROM adrress
<hr width="100%" size="20" align="left">
 
\n Here the list of the locations of mainboard EPROM, remember to multiply by 4, or <<2, the bullet number
to set the actual address, an unsigned int:
 
<ol start="0">
    <li> #Memory_mainboard_address_SN;
<!-- CAN addresses -->
    <li> #Memory_mainboard_address_fw;
    <li> #Memory_mainboard_address_CAN_own_filter;
    <li> #Memory_mainboard_address_CAN_common_filter;
<!-- Preamplifier information -->
    <li> #Memory_mainboard_preamplifier_address_SN_0;
    <li> #Memory_mainboard_preamplifier_address_SN_1;
    <li> #Memory_mainboard_preamplifier_address_SN_2;
    <li> #Memory_mainboard_preamplifier_address_SN_3;
    <li> #Memory_mainboard_preamplifier_address_SN_4;
    <li> #Memory_mainboard_preamplifier_address_SN_5;   
<!-- Copy of the detector trimmer slopes for ch0 -->
    <li> #Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch0;
    <li> #Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch0;
    <li> #Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch0;      
    <li> #Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch0;
    <li> #Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch0;            
    <li> #Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch0;
<!-- Copy of the detector trimmer slopes for ch1 -->
    <li> #Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch1;
    <li> #Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch1;
    <li> #Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch1;      
    <li> #Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch1;
    <li> #Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch1;            
    <li> #Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch1;
<!-- Copy of the detector trimmer slopes for ch2 -->
    <li> #Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch2;
    <li> #Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch2;
    <li> #Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch2;      
    <li> #Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch2;
    <li> #Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch2;        
    <li> #Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch2;    
<!-- Copy of the detector trimmer slopes for ch3 -->
    <li> #Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch3;
    <li> #Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch3;
    <li> #Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch3;      
    <li> #Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch3;
    <li> #Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch3;            
    <li> #Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch3;        
<!-- Copy of the detector trimmer slopes for ch4 -->
    <li> #Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch4;
    <li> #Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch4;
    <li> #Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch4;      
    <li> #Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch4;
    <li> #Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch4;            
    <li> #Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch4;    
<!-- Copy of the detector trimmer slopes for ch5 -->
    <li> #Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch5;
    <li> #Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch5;
    <li> #Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch5;      
    <li> #Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch5;
    <li> #Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch5;            
    <li> #Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch5;
<!-- Last used memory -->
    <li> #Memory_mainboard_last_memory_used_first_free.
 
\anchor postmainboard_memory_location_list
\section location_list_postmainboard The list of locations of the post-mainboard EPROM adrress
<hr width="100%" size="20" align="left">
 
\n Here the list of the locations of post-mainboard EPROM, remember to multiply by 4, or <<2, the bullet number
to set the actual address, an unsigned int:
 
<ol start="0">
    <li> #Memory_postmainboard_address_SN;
<!-- CAN addresses -->  
    <li> #Memory_postmainboard_address_fw;
    <li> #Memory_postmainboard_address_CAN_own_filter;
    <li> #Memory_postmainboard_address_CAN_common_filter;
    <li> #Memory_postmainboard_CAN_from_hw_switch_1_from_EPROM_0;   
<!-- Preamplifier information -->
    <li> #Memory_postmainboard_preamplifier_address_SN_0;
    <li> #Memory_postmainboard_preamplifier_address_SN_1;
    <li> #Memory_postmainboard_preamplifier_address_SN_2;
    <li> #Memory_postmainboard_preamplifier_address_SN_3;
    <li> #Memory_postmainboard_preamplifier_address_SN_4;
    <li> #Memory_postmainboard_preamplifier_address_SN_5;   
<!-- Power ON/OFF of micro-controller and ADCs -->
    <li> #Memory_postmainboard_micro_powdown_active_1_alwaysON_0;
    <li> #Memory_postmainboard_ADCs_always_ON_0_powerdown_1;
    <li> #Memory_postmainboard_micro_PD_wait_time_in_sec;
<!-- Last used memory -->
    <li> #Memory_postmainboard_last_memory_used_first_free.
 
 
<!-- pappa -->  
*/
 
#include "tutti_gli_header.h"
 
//Inizio CROSS
 
//enum canali_eprom{
//  canale1,
//  canale2,
//  canale3,
//  canale4,
//  canale6,
//  Canale_Eprom_mainboard};
 
/*! \brief This is the structure from which the I2C addressess and the I2C of the
preamplifier and frontend board are located
*/
const struct address_detector_bias_trimmer_type /*{
//  uint8_t quale_I2C;  
//  uint8_t indirizzo_I2C   
}*/ EPROM_address[9]={I2C_mux_abilita_0, EPROM_I2C_addres_memory_ch_pari, 
                                            I2C_mux_abilita_0, EPROM_I2C_addres_memory_ch_dispari, 
                                            I2C_mux_abilita_1,EPROM_I2C_addres_memory_ch_pari,
                                            I2C_mux_abilita_1, EPROM_I2C_addres_memory_ch_dispari,  
                                            I2C_mux_abilita_2, EPROM_I2C_addres_memory_ch_pari, 
                                            I2C_mux_abilita_2,EPROM_I2C_addres_memory_ch_dispari,//< Address of the memroies on the preamplifiers, 32k bits
                                            I2C_mux_abilita_3, EPROM_mainboard_I2C_addres,  //< Address of the memoies onboard, this is a 32k bits
                                            I2C_mux_abilita_3, EPROM_postmainboard_I2C_addres,  //< Address of the memoies onboard, this is a 32k bits
                                            I2C_mux_abilita_3, EPROM_postmainboard_I2C_addres};  //< Address of the memoies onboard, this is a 32k bits                                         
 
 
/*! \brief CAN insrtuction to Read from preamplifier,  on-board and post frontend board EPROM
                                
*\return No Parameters
\showrefby
\showrefs
*\snippet{lineno} Memoria_pre_M24CCXX.c fun_instr_EPROM_read_write_function
 */
//! <!-- [fun_instr_EPROM_read_write_function] -->
void instr_EPROM_read_write_function(void){
    uint16_t indirizzo_memoria= *(uint16_t *)tx_data;
    uint8_t quale_memoria = (tx_data[6]>>3) & 3;
    uint8_t Write_read = (tx_data[6] >>5) &1;
    uint8_t canale,quale_canale = (tx_data[6] & 7) ;
    uint8_t scheda_su_scheda_giu = ((tx_data[6]>>7) & 1)*6;
    uint8_t dati_letti[4],canale_da_usare;
    #define preamplifier_memory 0
    #define mainboard_memory 1
    #define postfronend_memory 2
    ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
    switch (quale_memoria){
        case  preamplifier_memory: //Preamplifier
//                  for(canale=0;canale<6;canale++){
//                      if( (quale_canale >> canale ) & 1 ) break;
//                  }           
//              canale = (1 << quale_canale) & 0x3F;
                canale = quale_canale;
                if( Write_read==0){
                    //Lettura
                            EPROM_lettura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard, canale, indirizzo_memoria , &tx_data[2]);
//                          *(uint32_t *)&tx_data[2] = *(uint32_t *)dati_letti ;
                }else{
                    //scrittura
                            EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard, canale,  indirizzo_memoria , (uint8_t *) &rx_data[2]);
                }   
                break;      
        case mainboard_memory: //Mainboard A memory
                if( Write_read==0){
                    //Lettura
                            EPROM_lettura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard, Canale_Eprom_mainboard, indirizzo_memoria , &tx_data[2]);
//                          *(uint32_t *)&tx_data[2] = *(uint32_t *)dati_letti ;
                }else{
                    //scrittura
                            EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard, Canale_Eprom_mainboard,  indirizzo_memoria , (uint8_t *) &rx_data[2]);
                }           
                break;
        case postfronend_memory://mainboard B memory
                if (scheda_su_scheda_giu == I2C_mux_Scheda_giu){
                    canale_da_usare= Canale_EPROM_postmainboard_down;
                }else if (scheda_su_scheda_giu >= I2C_mux_Scheda_su){
                    canale_da_usare=Canale_EPROM_postmainboard_up;
                }
                if( Write_read==0){
                    //Lettura
                            EPROM_lettura_M24C32_64( scheda_su_scheda_giu, I2C_postmainboard, canale_da_usare, indirizzo_memoria , &tx_data[2]);                            
//                          *(uint32_t *)&tx_data[2] = *(uint32_t *)dati_letti ;
                }else{
                    //scrittura
                            EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_postmainboard,  canale_da_usare,  indirizzo_memoria , (uint8_t *) &rx_data[2]);
                }   
                break;
    }
    Error_imposta_la_istruzione();
            if(flag_error_verified){
            if( tx_data[0]==255){
                tx_data[0]=250;
            }else{
                tx_data[0]= 255;
            }
        }   
}   
//! <!-- [fun_instr_EPROM_read_write_function] -->
 
 
/*! \brief Read from preamplifier and on-board flashes 
 
\param[in] scheda_su_scheda_giu 
\param[in] canale           
\param[in] indirizzo_memoria
\param[out] *dati_letti (4 bytes)                               
*\return No Parameters
\showrefby
\showrefs
*\snippet{lineno} Memoria_pre_M24CCXX.c fun_EPROM_lettura_M24C08_16
 */
//! <!-- [fun_EPROM_lettura_M24C08_16] -->
void EPROM_lettura_M24C08_16(uint8_t scheda_su_scheda_giu,enum canali_eprom canale, short indirizzo_memoria , uint8_t *dati_letti){
    uint8_t indirizzi_I2C=EPROM_address[canale].indirizzo_I2C;
    indirizzo_memoria = indirizzo_memoria & 0xFFFC; //4 bytes at a time and composed of 2 bytes
    dati_letti[0]= (indirizzo_memoria & 0xFF); //first 2 bytes are the 8 LSB bits sent as data
    indirizzi_I2C |=  (indirizzo_memoria & 0x300)>>8 ; //I primi 2 bit nel secondo byte sono indirizzo
        //Memory read
    I2C_mux_select_ch(  scheda_su_scheda_giu_provvisorio,  I2C_mainboard, EPROM_address[canale].quale_I2C);
  I2CBdrv->MasterTransmit (indirizzi_I2C, dati_letti , 1, false);  //Scriviamo l'indirizzo iniziale
    while (I2CBdrv->GetStatus().busy);      
 
    I2CBdrv-> MasterReceive (indirizzi_I2C, dati_letti, 4, false);  //Ora leggiamo
    while (I2CBdrv->GetStatus().busy);
    I2C_mux_select_ch(  scheda_su_scheda_giu_provvisorio, I2C_mainboard,  I2C_mux_disabilita_tutto);
    
}
//! <!-- [fun_EPROM_lettura_M24C08_16] -->
 
 
/*! \brief Wriring the EEPROM
 
\param[in] scheda_su_scheda_giu 
\param[in] canale           
\param[in] indirizzo_memoria
\param[in] *dati_da_scrivere                                    
*\return No Parameters
 \showrefby
 \showrefs
*\snippet{lineno} Memoria_pre_M24CCXX.c fun_EPROM_scrittura_M24C08_16
 */
//! <!-- [fun_EPROM_scrittura_M24C08_16] -->
void EPROM_scrittura_M24C08_16(uint8_t scheda_su_scheda_giu, enum canali_eprom canale, short indirizzo_memoria , uint8_t *dati_da_scrivere){
    
    uint8_t Indirizzo_I2C_effettivo = (indirizzo_memoria & 0x3FF) >>8 ;  //< The 2 MSB of the address memory are the 
                                                                                        //first 2 bits of the I2C address
    uint8_t indirizzo_memoria_8LSB= indirizzo_memoria & 0xFF;
    uint8_t dati_da_spedire[5];
    
    dati_da_spedire[0]=indirizzo_memoria_8LSB; //< this is the 8 LSB of the memory address
    dati_da_spedire[1]=dati_da_scrivere[0]; //<First data to store
    dati_da_spedire[2]=dati_da_scrivere[1]; //<Second data to store
    dati_da_spedire[3]=dati_da_scrivere[2]; //<Third  data to store
    dati_da_spedire[4]=dati_da_scrivere[3]; //<Fourth data to store
    
    Indirizzo_I2C_effettivo += EPROM_address[canale].indirizzo_I2C;
    
    I2C_mux_select_ch(  scheda_su_scheda_giu_provvisorio,  I2C_mainboard, EPROM_address[canale].quale_I2C);
  I2CBdrv->MasterTransmit (Indirizzo_I2C_effettivo, dati_da_spedire , 5, false);  //Scriviamo l'indirizzo iniziale
    while (I2CBdrv->GetStatus().busy);
    Aspetta_tanti_ms(10);  //Attenzione, se non si temporeggia qui si blocca tutto.
    I2C_mux_select_ch(  scheda_su_scheda_giu_provvisorio,  I2C_mainboard, I2C_mux_disabilita_tutto);
    
}
//! <!-- [fun_EPROM_scrittura_M24C08_16] -->
 
 
/*! \brief Wriring the EEPROM
 
\param[in] scheda_su_scheda_giu 
\param[in] mainboard_postmainboard for selecting the I2C mux on mainboard, if I2C_mainboard, 
                         or postmainboard, if I2C_postmainboard
\param[in] canale           
\param[in] indirizzo_memoria
\param[in] *dati_da_scrivere                                    
 
\return No Parameters
 \showrefby
 \showrefs
*\snippet{lineno} Memoria_pre_M24CCXX.c fun_EPROM_scrittura_M24C32_64
 */
//! <!-- [fun_EPROM_scrittura_M24C32_64] -->
void EPROM_scrittura_M24C32_64(uint8_t scheda_su_scheda_giu, uint8_t mainboard_postmainboard, uint8_t  canale, short indirizzo_memoria , uint8_t *dati_da_scrivere){
    
//  uint8_t Indirizzo_I2C_effettivo = (indirizzo_memoria & 0x3FF) >>8 ;  //< The 2 MSB of the address memory are the 
                                                                                        //first 2 bits of the I2C address
//  uint8_t indirizzo_memoria_8LSB= indirizzo_memoria & 0xFF;
    uint8_t dati_da_spedire[6], tampone_qui=100, error_I2C;
    
    dati_da_spedire[1]=indirizzo_memoria & 0xFF; //< this is the 8 LSb of the memory address
    dati_da_spedire[0]=( indirizzo_memoria >> 8) & 0xFF; //< this is the 8 MSb of the memory address
    dati_da_spedire[2]=dati_da_scrivere[0]; //<First data to store
    dati_da_spedire[3]=dati_da_scrivere[1]; //<Second data to store
    dati_da_spedire[4]=dati_da_scrivere[2]; //<Third  data to store
    dati_da_spedire[5]=dati_da_scrivere[3]; //<Fourth data to store
    
//  Indirizzo_I2C_effettivo += EPROM_address[canale].indirizzo_I2C;
    if(mainboard_postmainboard == I2C_mainboard){ //memoria su postmainboard  o mainboard
        tampone_qui=I2C_mainboard;
        error_I2C= error_address_I2C1;
    }else if (mainboard_postmainboard == I2C_postmainboard){
        tampone_qui=I2C_postmainboard;
        error_I2C= error_address_I2C0;
    }
    if (tampone_qui<100){   
            I2C_mux_select_ch(  scheda_su_scheda_giu,  tampone_qui, EPROM_address[canale].quale_I2C);
            I2C_mux->MasterTransmit (EPROM_address[canale].indirizzo_I2C, dati_da_spedire , 6, false);  //Scriviamo l'indirizzo iniziale
            while (I2C_mux->GetStatus().busy);
            if(Error_bad_operation)  ERROR_codifica_errore( scheda_su_scheda_giu, error_I2C  , I2C_error_EPROM_0  + canale , 1 );
            Aspetta_tanti_ms(10);  //Attenzione, se non si temporeggia qui si blocca tutto.
            I2C_mux_select_ch(  scheda_su_scheda_giu,  tampone_qui, I2C_mux_disabilita_tutto);
    }
}
//! <!-- [fun_EPROM_scrittura_M24C32_64] -->
 
 
/*! \brief Read from preamplifier and on-board flashes 
 
\param[in] scheda_su_scheda_giu_     : the selected board
\param[in] mainboard_postmainboard   : memory read from mainboard, if I2C_mainboard, or postamainboard, if I2C_mainboard
\param[in] canale                          : the selected channel
\param[in] indirizzo_memoria                 : memory address
\param[out] *dati_letti              : the 4 read bytes
 
*\return No Parameters
\showrefby
\showrefs
*\snippet{lineno} Memoria_pre_M24CCXX.c fun_EPROM_lettura_M24C32_64
 */
//! <!-- [fun_EPROM_lettura_M24C32_64] -->
void EPROM_lettura_M24C32_64(uint8_t scheda_su_scheda_giu_, uint8_t mainboard_postmainboard, uint8_t canale, \
                                    short indirizzo_memoria , uint8_t *dati_letti){
    uint8_t tampone_qui=100,error_I2C;
//  uint8_t indirizzi_I2C=EPROM_address[canale].indirizzo_I2C;
//  indirizzo_memoria = indirizzo_memoria & 0xFFFC; //4 bytes at a time and composed of 2 bytes
    dati_letti[1]= (indirizzo_memoria & 0xFF); //first 2 bytes are the 8 LSB bits sent as data
    dati_letti[0]=( (indirizzo_memoria >> 8) & 0xFF); //first 2 bytes are the 8 LSB bits sent as data
    
//  indirizzi_I2C |=  (indirizzo_memoria & 0x300)>>8 ; //I primi 2 bit nel secondo byte sono indirizzo
 
    if(mainboard_postmainboard == I2C_mainboard){ //memoria su postmainboard  o mainboard
        tampone_qui=I2C_mainboard;
        error_I2C =error_address_I2C1 ;
    }else if (mainboard_postmainboard == I2C_postmainboard){
        tampone_qui=I2C_postmainboard;
        error_I2C = error_address_I2C0 ;
    }
    if (tampone_qui<100){       //Memory read
        I2C_mux_select_ch(  scheda_su_scheda_giu_,  tampone_qui, EPROM_address[canale].quale_I2C);
        I2C_mux->MasterTransmit (EPROM_address[canale].indirizzo_I2C, dati_letti , 2, false);  //Scriviamo l'indirizzo iniziale
        while (I2C_mux->GetStatus().busy);      
        if(Error_bad_operation)  ERROR_codifica_errore( scheda_su_scheda_giu, error_I2C  , I2C_error_EPROM_0   + canale , 1 );      
        I2C_mux-> MasterReceive (EPROM_address[canale].indirizzo_I2C, dati_letti, 4, false);  //Ora leggiamo
        while (I2C_mux->GetStatus().busy);
        I2C_mux_select_ch(  scheda_su_scheda_giu_, tampone_qui,  I2C_mux_disabilita_tutto);
        if(Error_bad_operation)  ERROR_codifica_errore( scheda_su_scheda_giu, error_I2C  , I2C_error_EPROM_0   + canale , 1 );
    }
 
}
//! <!-- [fun_EPROM_lettura_M24C32_64] -->
 
 
/*! \brief Store the system state or recover and apply the system state 
 
\param[in] scheda_su_scheda_giu 
\param[in] canali_da_regolare the channels to be worked out, 1= yes, 0=no. Ex: 101001= ch 0, ch 3 and ch 5 are worked.          
\param[in] set_1_store_0 store the system state in memory, if 1, recover and apply the stored setup, if 0
\param[out] startup_1_user_0    store/recover from the startup, if 1, or from the user location, if 0       
*\return No Parameters
\showrefby
\showrefs
*\snippet{lineno} Memoria_pre_M24CXX.c fun_EPROM_store_recover_state_M24C32_64
 */
//! [fun_EPROM_store_recover_state_M24C32_64]
void EPROM_store_recover_state_M24C32_64(uint8_t scheda_su_scheda_giu,uint8_t canali_da_regolare, \
uint8_t set_1_store_0 , uint8_t startup_1_user_0){
 
        uint8_t dati_da_leggere[4],ii_,canale,dati_da_scrivere[]={0,0,0,0},esegui=0;
        uint16_t memoria_per_trimmer, memoria_per_abilitazione, memoria_per_relay_PGA,memoria_per_detector_trimmer;
        if(scheda_su_scheda_giu) scheda_su_scheda_giu=6;
        
        if( startup_1_user_0){
            memoria_per_abilitazione=Memory_preamplifier_startup_offset_trimmer_ON_0_OFF_ff <<2 ;
            memoria_per_trimmer=Memory_preamplifier_startup_offset_trimmer <<2;
            memoria_per_relay_PGA=0;
            esegui=1;
        }else if(startup_1_user_0 ==0){
            memoria_per_abilitazione=Memory_preamplifier_user_offset_trimmer_ON_0_OFF_ff <<2;
            memoria_per_trimmer=Memory_preamplifier_user_offset_trimmer <<2;
            memoria_per_detector_trimmer=Memory_preamplifier_user_detector_trimmer;
            memoria_per_relay_PGA = Memory_preamplifier_user_detector_and_gain <<2;
            esegui=1;
        }
        
        if ((set_1_store_0 ==0) && esegui){  //Quindi scriviamo
                for(canale=0;canale<6;canale++){
                    if((canali_da_regolare >> canale) &1 ){
                EPROM_scrittura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard,canale,\
                        memoria_per_abilitazione , dati_da_scrivere);
                EPROM_scrittura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale,\
                        memoria_per_trimmer , (uint8_t *)&contenuto_trimmer_preamplifier[canale+scheda_su_scheda_giu]); 
                        if (memoria_per_relay_PGA){
                                dati_da_scrivere[0]= detector_Relay_state[scheda_su_scheda_giu + canale];
                                dati_da_scrivere[1]= PGA_settled_gain[scheda_su_scheda_giu+canale];
                                dati_da_scrivere[2]= 0;
                                dati_da_scrivere[3]= 0;
                                EPROM_scrittura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard,canale,  \
                                        memoria_per_relay_PGA , dati_da_scrivere);
                                dati_da_scrivere[0]= 0;
                                dati_da_scrivere[1]= 0;
                                EPROM_scrittura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard,canale,\
                                        memoria_per_detector_trimmer , (uint8_t *)&contenuto_trimmer_detector[canale+scheda_su_scheda_giu]);
                        }                       
                    }
                }
        }
        
                if (set_1_store_0 && esegui){  //Quindi recuperiamo ed applichiamo o stato
                    for(canale=0;canale<6;canale++){
                                if((canali_da_regolare >> canale) &1 ){                 
                        EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                                    memoria_per_abilitazione , dati_da_leggere);
                    if(*(uint32_t *)dati_da_leggere ==0){
                            EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                                    memoria_per_trimmer , dati_da_leggere);
                                    for(ii_=0;ii_<4;ii_++){
                            preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,  canale, ii_, \
                                    dati_da_leggere[ii_], preamplifier_scrivi_il_trimmer  );
                                    }
                                    if(memoria_per_relay_PGA){
                                        EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                                                memoria_per_relay_PGA , dati_da_leggere);
                                                PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale, dati_da_leggere[1]  );
                                                for(ii_=0;ii_<7;ii_++){
                                                    if( (dati_da_leggere[0] >> ii_) & 1){
                                                        Relays_driver_set_reset_channel(scheda_su_scheda_giu,canale, (1<<ii_));
                                }
                            }
                                EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                                    memoria_per_detector_trimmer , dati_da_leggere);
                                for(ii_=0;ii_<4;ii_++){
                                        detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu,  canale, ii_, \
                                                dati_da_leggere[ii_], preamplifier_scrivi_il_trimmer  );
                                    }
                        }
                        }
                    }
                }
                    
                }   
}
//! [fun_EPROM_store_recover_state_M24C32_64]
 
 
//************************** questa è in costruzione ************************************
 
/*! \brief Store or load the detector bias trimmer content
 
\param[in] scheda_su_scheda_giu 
\param[in] canali_da_regolare the channels to be worked out, 1= yes, 0=no. Ex: 101001= ch 0, ch 3 and ch 5 are worked.          
\param[in] set_1_store_0 store the system state in memory, if 1, recover and apply the stored setup, if 0
\param[out] startup_1_user_0    store/recover from the startup, if 1, or from the user location, if 0       
*\return No Parameters
\showrefby
\showrefs
*\snippet{lineno} Memoria_pre_M24CXX.c fun_EPROM_store_recover_detector_voltage_M24C32_64
 */
//! [fun_EPROM_store_recover_detector_voltage_M24C32_64]
void EPROM_store_recover_detector_voltage_M24C32_64(uint8_t scheda_su_scheda_giu,uint8_t canali_da_regolare, \
uint32_t voltage_integer  ,uint8_t set_1_store_0 ){
 
        uint8_t dati_da_leggere[4],ii_,canale,dati_da_scrivere[]={0,0,0,0};
        uint16_t memoria_per_trimmer, memoria_per_abilitazione, memoria_per_relay_PGA,memoria_per_detector_trimmer;
        uint8_t valori_per_canale=51; //Valori da memorizzare, da 0 V a 50 V
        
        voltage_integer = voltage_integer /1000; //Bias trasformato in intero
        
        if(scheda_su_scheda_giu) scheda_su_scheda_giu=6;
        
        memoria_per_abilitazione=Memory_mainboard_det_chan_0_0V +  voltage_integer ; //A questo va aggiunto valori_per_canale x canale
 
        
        if ((set_1_store_0 ==0) ){  //Quindi scriviamo in memoria
                for(canale=0;canale<6;canale++){
                    if((canali_da_regolare >> canale) &1 ){
                        memoria_per_abilitazione += canale * valori_per_canale;             
                EPROM_scrittura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale,\
                        memoria_per_abilitazione << 2 , (uint8_t *)&contenuto_trimmer_detector[canale+scheda_su_scheda_giu]);                   
                    }
                }
        }
        
                if (set_1_store_0 ){  //Quindi recuperiamo ed applichiamo o stato
                    for(canale=0;canale<6;canale++){
                                if((canali_da_regolare >> canale) &1 ){ 
                        memoria_per_abilitazione += canale * valori_per_canale;                                 
                        EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, \
                                    memoria_per_abilitazione , dati_da_leggere);
 
                                for(ii_=0;ii_<4;ii_++){
                                        detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu,  canale, ii_, \
                                                dati_da_leggere[ii_], preamplifier_scrivi_il_trimmer  );
                                    }
                    }
                }
                    
                }   
}
//! [fun_EPROM_store_recover_detector_voltage_M24C32_64]
 
 
/*! \brief Preamplifier memory contents regarding detector trimmer slopes are restored from mainboard memory.
This is a patch: the storing of these data in the preamplifier memoery is unnecessary, but it was done and used from there. 
So now the content of the preamplifier memory is done also in the mainboard memory at the time of the slopes measurements. 
These data are restored in the preamplifier memory at startup so that if the preamplifier is changed or swapped the slopes are not lost.
 
\param[in] scheda_su_scheda_giu        :   which mmainboard 
\param[in] canale                      : the channel to where data are copied
 
*\return No Parameters
\showrefby
\showrefs
*\snippet{lineno} Memoria_pre_M24CXX.c fun_EPROM_copy_restore_detector_slopes
 */
//! [fun_EPROM_copy_restore_detector_slopes]
void EPROM_restore_detector_slopes_in_pream( uint8_t scheda_su_scheda_giu , uint8_t canale){
    uint8_t dati_da_scrivere[4], iii;
    
    //Data cells to restore are 6.
        
    for(iii=0;iii<6;iii++){
            
            EPROM_lettura_M24C32_64(scheda_su_scheda_giu,  I2C_mainboard,  Canale_Eprom_mainboard, \
                                         ((Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch0 +6*canale + iii)<<2) ,  dati_da_scrivere);
                
            EPROM_scrittura_M24C32_64( scheda_su_scheda_giu, I2C_mainboard,   canale, \
                                        (Memory_detector_coarse_slope_calibration_ON_0_OFF_ff + iii)<<2 ,  dati_da_scrivere);
            
    }
    
    
}
//! [fun_EPROM_copy_restore_detector_slopes]
 
//fine cross