Use of the Preamplifier EPROM memory

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 MC24C08, that is a 8 Kb I2C flash memory. The frontend board has a MC24C16. Finally the postfrontend board has the MC24C64. The different memory sizes have different cell address organization. From 1Kb up to 16Kb they are shown in figure 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 Figure_M24C00_16K.
In our frontend we are going to use the M24C32 for both the preamplifier and the frontend board and the 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.
An example of use of 4-bytes writing of the 32k/64K EPROM at addres 0x20 of the channel6 EPROM is here:

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);

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)
Wriring the EEPROM.
Definition: Memoria_pre_M24CXX.c:435

Figure_M24C00_16K 1: M24C00_16K I2C address organization

br

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).
scheda_su_scheda_giu is one of the 2 boards to select, canali is the preamplifier memory or the frontend board memory, according to the following enum canali_eprom:

enum canali_eprom{
    canale1,
    canale2,
    canale3,
    canale4,
    canale5,
    canale6,
    Canale_Eprom_mainboard,
    Canale_EPROM_postmainboard_down,
    Canale_EPROM_postmainboard_up};  

indirizzo_memoria is the address of the memory to write to or to read from and *dati_da_scrivere the pointer to the data to read/write. Take care: only 4 bytes can be read or written for each call.

Remarks: 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: Memoria_pre_M24CXX.h. 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.

Channel state store and recovery

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.
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.
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.
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.
The bits to set are in the instr_output_offset_to_be_set, at the Byte₃ option.

Remarks: 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.

The function invoked is the following:

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  );
                                    }
                        }
                        }
                    }
                }
                    
                }   
}

Functions and vars details

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:

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 );
    }
 
}

While the writng function is here:

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);
    }
}

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:

//struct address_detector_bias_trimmer_type {
//  uint8_t quale_I2C;  
//  uint8_t indirizzo_I2C;
//};

So that the 7 positions strucure is EPROM_address.

The codes for I2C_0 is at:

The list of locations of the preamplifier EPROM

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:

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.

The list of locations of the mainboard EPROM adrress

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:

The list of locations of the post-mainboard EPROM adrress

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:

Table of Contents