instr_DetBias_trimmer_calibration_function()

void instr_DetBias_trimmer_calibration_function

(

void

)

The fine and coarse trimmers for Detector bias adjustment are calibrated here

Returns

No Parameters

void instr_DetBias_trimmer_calibration_function(void){
        uint8_t canale,internalADC_0_externalADC_1=(tx_data[4] & 1), canale_selezionato=10;
    uint8_t trimmer_old[4], PGA_Gain_old[12], trimmer_fine_test, trimmer_coarse_test;
    uint8_t *dati_da_scrivere,dati_per_switch[]={0,0,0,0}, delta_trimmer, divisore;
    int32_t target_slope = *(int32_t *)tx_data, tampone;
    //convertiamo i valori di riferimento
    int32_t pendenza[]={0,0,0,0,},trimmer_riferimento_fine = (*(uint16_t *)&tx_data[0]);//fine trimmer in microV
    int32_t ADC_misura_fatta_first[]={0,0,0,0},ADC_misura_fatta_last[]={0,0,0,0},  risul_vof;//Coarse trimmer in unit\'a di 10^5
    ADC_medie_per_misura = tx_data[4] >>1;
        //Detrminare il canale da calibrare
    scheda_su_scheda_giu = ((tx_data[6] >> 7) & 1)*6;
    for(canale=0;canale<6;canale++){
        if((tx_data[6]>>canale)&1){
            canale_selezionato=canale;
            break;
        }
    }
    
    //Vettori corrispondenze
    typedef struct {
        uint8_t trimmer;  //Il trimmer da modificare
        uint16_t memoria_trimmer; //la cella di memoria dove star\'a la pendenza
        uint16_t memoria_switch_trimmer; //la cella di memoria che certifa la presenza della calibrazione
        int32_t     segno_uscita; //Coefficiente per la variazione del segnale di uscita
        uint8_t      nodo_lettura; //il nodo di tensione da leggere
    }trimmer_da_lavorare_;
    
    trimmer_da_lavorare_ trimmer_da_lavorare[]={Detector_trimmer_coarse_bias_pos,Memory_detector_positive_address_coarse_trimmer_slope_bias,Memory_detector_coarse_slope_calibration_ON_0_OFF_ff,-1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset ,
        Detector_trimmer_coarse_bias_neg,Memory_detector_negative_address_coarse_trimmer_slope_bias,Memory_detector_coarse_slope_calibration_ON_0_OFF_ff,1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset+1,
        Detector_trimmer_fine_bias_pos,Memory_detector_positive_address_fine_trimmer_slope_bias,Memory_detector_fine_slope_calibration_ON_0_OFF_ff,1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset,
        Detector_trimmer_fine_bias_neg,Memory_detector_negative_address_fine_trimmer_slope_bias,Memory_detector_fine_slope_calibration_ON_0_OFF_ff,-1,canale_selezionato*2+node_voltage_Analog_Mux_0_offset+1};
 
//Preamplifier memory contents regarding detector trimmer slopes are copied in the mainboard memory or restored.
//This is a patch: the storing of these data in the preamplifier memoery is unnecessary, but it was done. 
//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 the slopes are not lost. 
    trimmer_da_lavorare_    trimmer_da_lavorare_mainboard_CH0[]={
        0, Memory_mainboard_det_positive_ad_coarse_trim_slope_bias_ch0, Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch0, 0,0,
        0, Memory_mainboard_det_negative_ad_coarse_trim_slope_bias_ch0, Memory_mainboard_det_coa_slope_cali_ON_0_OFF_ff_ch0,0,0,
        0,Memory_mainboard_det_positive_ad_fine_trim_slope_bias_ch0, Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch0,0,0,
        0,Memory_mainboard_det_negative_ad_fine_trim_slope_bias_ch0,Memory_mainboard_det_fin_slope_cali_ON_0_OFF_ff_ch0,0,0 };
            
    uint8_t ii, trimmer_coarse_o_fine=10; //inizializzazione ad un valore abnorme
                
        
//L'offset da considerare in trimmer_da_lavorare per selezionare la coppia di trimmer giusti, i 2 coarse o i 2 fine.
    if( tx_data[5]==1){
        trimmer_coarse_o_fine=2;
        delta_trimmer=100;
        divisore=1;
    }else if (tx_data[5]==2){
        trimmer_coarse_o_fine=0;
        delta_trimmer=10;
        divisore=10;
    }
        
 
//Condizioni iniziale da ristabilire    
    //Memorizzare il valore dei trimmer, da poterer poi ristabilire ed impostiamo la met\'a scala
    for(canale=0;canale<4;canale++){
        trimmer_old[canale]=contenuto_trimmer_detector[canale_selezionato+scheda_su_scheda_giu][canale];
        detector_scrittura_lettura_trimmer_bias(scheda_su_scheda_giu, canale_selezionato, canale, 128, 1);
    }
    //Impostare il gain a 1
    for(canale=0;canale<6;canale++){
        PGA_Gain_old[canale]=PGA_settled_gain[canale + scheda_su_scheda_giu];
        PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale,  1  );
    }
    
    //Qui calibriamo    
    //Misuriamo a met\'a scala
    Aspetta_tanti_ms(500);
        for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
            ADC_misura_fatta_first[ii] = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,internalADC_0_externalADC_1,trimmer_da_lavorare[ii].nodo_lettura,0);
 
    detector_scrittura_lettura_trimmer_bias(scheda_su_scheda_giu, canale_selezionato, trimmer_da_lavorare[ii].trimmer, \
    128+trimmer_da_lavorare[ii].segno_uscita*delta_trimmer, 1);
    }
    Aspetta_tanti_ms(500);
    for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
        ADC_misura_fatta_last[ii] = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,internalADC_0_externalADC_1,trimmer_da_lavorare[ii].nodo_lettura,0);
    }
    for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
        pendenza[ii]=( (ADC_misura_fatta_last[ii] - ADC_misura_fatta_first[ii]) * (trimmer_da_lavorare[ii].segno_uscita ) )/ ( (int)delta_trimmer)  ; 
        tampone = ((int)100*pendenza[ii]) / target_slope;
        if (target_slope){ //If target_slope is passed 0 there is no comparison 
        if ( (tampone >130) || (tampone<70)){
            //valore non in tolleranza
            pendenza[ii]=target_slope;
            tx_data[5]=3 + ii -trimmer_coarse_o_fine;
        }
    }
    }
                //memorizzare il valore nella eprom se \'e in tolleranza
        for(ii= trimmer_coarse_o_fine; ii<(2+trimmer_coarse_o_fine);ii++){
                    dati_da_scrivere= (uint8_t *)&pendenza[ii];
                    EPROM_scrittura_M24C32_64( scheda_su_scheda_giu,I2C_mainboard,   canale_selezionato,  (trimmer_da_lavorare[ii].memoria_trimmer <<2) ,  dati_da_scrivere);   
                    //We store also in the mainboard EPROM, to be restored in the preamplifier memory at startup
                    EPROM_scrittura_M24C32_64(scheda_su_scheda_giu,I2C_mainboard, Canale_Eprom_mainboard,\
                                                    ((trimmer_da_lavorare_mainboard_CH0[ii].memoria_trimmer+6*canale_selezionato) <<2), dati_da_scrivere);
                    dati_per_switch[0]=0;
                    if( tx_data[5] >2){
                       dati_per_switch[0]=0xFF;   
                    }
                    EPROM_scrittura_M24C32_64( scheda_su_scheda_giu,  I2C_mainboard, canale_selezionato,  (trimmer_da_lavorare[ii].memoria_switch_trimmer << 2) ,  dati_per_switch);
                    //We store also in the mainboard EPROM, to be restored in the preamplifier memory at startup
                    EPROM_scrittura_M24C32_64(scheda_su_scheda_giu,I2C_mainboard, Canale_Eprom_mainboard,\
                                ((trimmer_da_lavorare_mainboard_CH0[ii].memoria_switch_trimmer+6*canale_selezionato) <<2), dati_per_switch);
                }
        pendenza[ trimmer_coarse_o_fine]  = (pendenza[ trimmer_coarse_o_fine] / divisore );
        tx_data[0]= (pendenza[ trimmer_coarse_o_fine]  )& 0xff;
        tx_data[1] =(( pendenza[ trimmer_coarse_o_fine] )>>8)& 0xff;
        pendenza[ trimmer_coarse_o_fine+1]= (pendenza[ trimmer_coarse_o_fine+1] / divisore );
        tx_data[2]= (pendenza[ trimmer_coarse_o_fine+1]  )& 0xff;
        tx_data[3]=( ( pendenza[ trimmer_coarse_o_fine+1])>>8)& 0xff;
        tx_data[4]= divisore;
//E qui riportiamo tutto come prima 
    //ristabilire i trimmer.
        for(canale=0;canale<4;canale++){
        detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu,  canale_selezionato, \
            canale, trimmer_old[canale],    Detector_scrivi_il_trimmer  );
    }
    //Ristabilire il guadagno
        for(canale=0;canale<6;canale++){
            PGA_GAIN_CROSS( scheda_su_scheda_giu,  canale,  PGA_Gain_old[canale]  );
    }
    
}

Definition at line 480 of file Trimmer.c.