instr_Vbias_to_be_set_function()

void instr_Vbias_to_be_set_function

(

void

)

The detector bias will be set at the value set with the function instr_detector_Vbias_we_want_to_set_function() with which the target values are stored in the vector Detector_bias_target[].

Returns

No Parameters, the actual result is sent to the CAN bus output throught tx_data.

void instr_Vbias_to_be_set_function(void){
uint8_t iii,canale, indice, dati_scambio[4], Detector_pre_out_offset_no_change, no_slope=0; 
uint8_t volatile    tx_data_buffer[8],fai_fai=1;
int8_t variazione, scheda_su_scheda_giu,Detector_offset_starts_at_half_scale;   
int32_t delta;
        
    ADC_medie_per_misura = (uint8_t) vettore_istruzioni[2];
//uint8_t non_toccare_il_gain_del_pre=  vettore_istruzioni[3] & 0x2;
    
        for(iii=0;iii < 8;iii++){// Potrebbe essere richiesto qualcosa sul can, 
            //bufferizziamo l'istruzione
        tx_data_buffer[iii]= tx_data[iii];
    }
// Ora interpretiamo l'istruzione
        //attesa tra le misure
        Detector_attesa_tra_le_misure = vettore_istruzioni[4] *100;
        if (Detector_attesa_tra_le_misure==0) Detector_attesa_tra_le_misure=100;
        //errore tollerato
        Detector_error_voltage= vettore_istruzioni[5] *1000;
      if (Detector_error_voltage==0) Detector_error_voltage=200e3;
        if( Detector_error_voltage < minimum_error_detector_voltage) Detector_error_voltage = minimum_error_detector_voltage;
        //i canali da agiustare
        Detector_canali_da_regolare= vettore_istruzioni[6];
        uint8_t Detector_canali_da_regolare_iniziali = Detector_canali_da_regolare;
        scheda_su_scheda_giu = ((vettore_istruzioni[6] >> 7) & 1)*6;
    
//Flags dal byte 3 dell'istruzione  
        Detector_externalADC_1_onboardADC_0 = vettore_istruzioni[3] & 1; //l'adc da usare, interno o esterno
        Detector_pre_out_offset_no_change = (vettore_istruzioni[3]>>3 ) & 1; //pre output offset no change
        Detector_offset_starts_at_half_scale = ( vettore_istruzioni[3] >> 4 ) & 1;    //
 
//  struct EPROM_detector_{
//  int32_t slope_coarse_positiva;
////    int32_t coefficiente_raccordo_slope_coarse;  //=(slope_coarse_pos<<10)/(slope_coarse_neg), ricordarsi di dividere per 2^10 quando si usa
//  int32_t slope_coarse_negativa;
//  int32_t slope_fine_positiva;
////    int32_t coefficiente_raccordo_slope_fine; //=(slope_fine_pos<<10)/(slope_fine_neg), ricordarsi di dividere per 2^10 quando si usa
//  int32_t slope_fine_negativa;    
////    int8_t offset_coarse_neg;
////    int8_t offset_fine_neg;
//};
 
#define det_slope_default_coarse (int32_t) -264000
#define det_slope_default_fine   (int32_t) 3000
EPROM_detector__ EPROM_detector[6]={det_slope_default_coarse,det_slope_default_coarse,det_slope_default_fine,det_slope_default_fine,
                                                                        det_slope_default_coarse,det_slope_default_coarse,det_slope_default_fine,det_slope_default_fine,
                                                                        det_slope_default_coarse,det_slope_default_coarse,det_slope_default_fine,det_slope_default_fine,
                                                                        det_slope_default_coarse,det_slope_default_coarse,det_slope_default_fine,det_slope_default_fine,
                                                                        det_slope_default_coarse,det_slope_default_coarse,det_slope_default_fine,det_slope_default_fine,
                                                                        det_slope_default_coarse,det_slope_default_coarse,det_slope_default_fine,det_slope_default_fine};
 
ERROR_codifica_errore( 0, 0, 0, 0 ); // In caso il canale 0 non sia compreso resettiamo qui
    
//Leggiamo le memorie
//Inganniamo e prepariamo l'istruzione per l'eventuale valutazione della pendenza qui sotto
for(iii=0;iii<4;iii++){
    tx_data[iii]=0;
}
tx_data[4]= (tx_data_buffer[3] & 1 )+ (vettore_istruzioni[2] << 2);
 
    for(canale=0;canale<6;canale++){//Carichiamo o determiniamo le pendenze
        if( (Detector_canali_da_regolare >> canale) &1){
                EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, Memory_detector_coarse_slope_calibration_ON_0_OFF_ff <<2,dati_scambio);
 
            if(flag_error_verified) Detector_canali_da_regolare =0; //Lettura fallita, non facciamo pi\'u niente
            
            if(dati_scambio[0] & (flag_error_verified ==0)){// Calibrazione non ancora fatta. 
                //Se non c'e' calibrazione usiamo il default e segnaliamo l'errore
                  ERROR_codifica_errore( scheda_su_scheda_giu, error_address_Bias_adjustment  , Detector_bias_slopes_not_available , 1);
                    flag_error_verified=0; //Forziamo la misura
                    no_slope =0xFF;  //Segnaliamo per� l'errore
//              tx_data[5]=2; //coarse measurement
//              tx_data[6] = canale;
//              tx_data[4]= (tx_data_buffer[3] & 1 )+ (vettore_istruzioni[2] << 2);
//              if (scheda_su_scheda_giu) tx_data[6] += 0x80;
//              instr_DetBias_trimmer_calibration_function();  //Si misura e si mette nella eprom la pendenza coarse
//              if(flag_error_verified) Detector_canali_da_regolare =0; //Lettura fallita, non facciamo pi\'u niente
            }
//          if ( (flag_error_verified ==0)){ //provvisorio, poi si toglie
                if( dati_scambio[0] ==0){
                    EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, Memory_detector_positive_address_coarse_trimmer_slope_bias <<2,dati_scambio);
                    EPROM_detector[canale].slope_coarse_positiva=*(int32_t *)dati_scambio;
                    EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, Memory_detector_negative_address_coarse_trimmer_slope_bias <<2,dati_scambio);
                    EPROM_detector[canale].slope_coarse_negativa=   *(int32_t *)dati_scambio;
//                  EPROM_detector[canale].coefficiente_raccordo_slope_coarse = (EPROM_detector[canale].slope_coarse_positiva << 10) / EPROM_detector[canale].slope_coarse_negativa ;
            }
            
            EPROM_lettura_M24C32_64(scheda_su_scheda_giu,I2C_mainboard,  canale, Memory_detector_fine_slope_calibration_ON_0_OFF_ff  <<2,dati_scambio);
            if(flag_error_verified) Detector_canali_da_regolare =0; //Lettura fallita, non facciamo pi\'u niente
            
            if(flag_error_verified) Detector_canali_da_regolare =0; //Lettura fallita, non facciamo pi\'u niente            
            if(dati_scambio[0] & (flag_error_verified ==0)){
                tx_data[5]=1; //fine measurement
                tx_data[6] = canale ;
                tx_data[4]= (tx_data_buffer[3] & 1 )+ (vettore_istruzioni[2] << 2);
                if(scheda_su_scheda_giu) tx_data[6] += 0x80;
                instr_DetBias_trimmer_calibration_function();  //Si misura e si mette nella eprom la pendenza fine
                if(flag_error_verified) Detector_canali_da_regolare =0;
            }           
            if (  (flag_error_verified ==0)){ //provvisorio, poi si toglie
                    EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, Memory_detector_positive_address_fine_trimmer_slope_bias <<2,dati_scambio);
                    EPROM_detector[canale].slope_fine_positiva=*(int32_t *)dati_scambio;
                    EPROM_lettura_M24C32_64(scheda_su_scheda_giu, I2C_mainboard, canale, Memory_detector_negative_address_fine_trimmer_slope_bias <<2,dati_scambio);
                    EPROM_detector[canale].slope_fine_negativa= *(int32_t *)dati_scambio;
//                  EPROM_detector[canale].coefficiente_raccordo_slope_fine = (EPROM_detector[canale].slope_fine_positiva << 10) / EPROM_detector[canale].slope_fine_negativa ;
            }   
        }           
    }
    for(iii=0;iii<8;iii++){
        tx_data[iii]= tx_data_buffer[iii]; //recuperiamo l'istruzione
    }
    
if (Detector_offset_starts_at_half_scale){
//Initialization for default SAR, changes are applied in fastSAR, eventually    
            for( canale=0;canale<12;canale++){  
                Detector_SAR_ini[canale].starting_value_pos =128;
                Detector_SAR_ini[canale].starting_value_neg =128;
            }           
        }else{//Si inizia ad aggiustare da dove si \'e
            for( canale=0;canale<6;canale++){
                Detector_SAR_ini[canale + scheda_su_scheda_giu].starting_value_pos =contenuto_trimmer_detector[canale + scheda_su_scheda_giu][Detector_trimmer_coarse_bias_pos];
                Detector_SAR_ini[canale + scheda_su_scheda_giu].starting_value_neg =contenuto_trimmer_detector[canale + scheda_su_scheda_giu][Detector_trimmer_coarse_bias_neg];    
            }               
        }
            
            for( canale=0;canale<6;canale++){
                if( (Detector_canali_da_regolare >> canale) &1 ){
                    Detector_SAR_ini[canale + scheda_su_scheda_giu].target_non_raggiunto_neg=true;
                    Detector_SAR_ini[canale +scheda_su_scheda_giu].target_non_raggiunto_pos=true;
                    Detector_SAR_ini[canale +scheda_su_scheda_giu].starting_exp_value_pos=7;  
                    Detector_SAR_ini[canale +scheda_su_scheda_giu].starting_exp_value_neg=7;                    
                }
            }
            
//FINE: Initialization for default SAR, changes are applied in fastSAR, eventually      
            
//Se vogliamo conservare l'offset dobbiamo  misurarlo.
        if(Detector_pre_out_offset_no_change){
            for( canale=0;canale<6;canale++){
                if( (Detector_canali_da_regolare >> canale) &1 ){
                        preamplifier_Output_offset_target[scheda_su_scheda_giu + canale] = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu,preamplifier_externalADC_1_onboardADC_0,canale,1);
                }
            }               
        }
//Impostiamo tutti i guadagni del PGA ad 1 e del pre a 20
if(flag_error_verified==0){         
    for(canale=0; canale< 6; canale++){
    preamplifier_set_reset_pre_gain ( scheda_su_scheda_giu,  canale,  preamplifier_Gain_basso  );
        indice= canale + scheda_su_scheda_giu;
        Detector_PGA_settled_gain_old[indice]= PGA_settled_gain[indice];        
        PGA_GAIN_CROSS( scheda_su_scheda_giu , canale , guadagno_minimo_PGA );
        if(flag_error_verified) Detector_canali_da_regolare =0;
        //Inserire test errori qui
    }   
}
 
            
 //SAR ottimizzato
    Detector_aggiusta_offset_SAR(  EPROM_detector, scheda_su_scheda_giu);
        
 
//Riportiamo i guadagni al valore nominale 
 
    for(canale=0; canale< 6; canale++){
    preamplifier_set_reset_pre_gain ( scheda_su_scheda_giu,  canale, preamplifier_Gain_alto  );
        indice= canale + scheda_su_scheda_giu;  
        if(Detector_pre_out_offset_no_change==0) PGA_GAIN_CROSS( scheda_su_scheda_giu , canale , Detector_PGA_settled_gain_old[indice] );
    }   
    
    if(Detector_pre_out_offset_no_change){
        uint8_t istruzione_old[8];
        for(iii=0;iii<8;iii++){
            istruzione_old[iii]=vettore_istruzioni[iii];
        }
        for(iii=0;iii<6;iii++){
            PGA_settled_gain[iii+scheda_su_scheda_giu]= Detector_PGA_settled_gain_old[iii+scheda_su_scheda_giu];
        }           
            vettore_istruzioni[0]=0;vettore_istruzioni[1]=0;
            vettore_istruzioni[2]=istruzione_old[2];vettore_istruzioni[3]=0;
            if(vettore_istruzioni[2] ==0) vettore_istruzioni[2]=10;
            vettore_istruzioni[4]=istruzione_old[4];
            if(vettore_istruzioni[4]==0) vettore_istruzioni[4]=10;
            vettore_istruzioni[5]=istruzione_old[5];
            if(vettore_istruzioni[5]==0) vettore_istruzioni[5] =50;
            vettore_istruzioni[6]=istruzione_old[6];
            vettore_istruzioni[7]= instr_output_offset_to_be_set;
            instr_output_offset_to_be_set_function();  //Lanciamo la funzione di aggiustamento offset, che alla fine imposter\'a i guadagni corretti finali
        for(iii=0;iii<8;iii++){
            vettore_istruzioni[iii]=istruzione_old[iii];
        }       
    }
    
        for(iii=0;iii < 8 ;iii++){
        tx_data[iii]= tx_data_buffer[iii];
    }
        tx_data[0] = no_slope; //Se la slope non � nella rom la notifichiamo
        tx_data[6] = Detector_canali_da_regolare & 0x3F; //i canali non in tolleranza hanno un 1 in corrispondenza  
        tx_data[5] = Detector_error_voltage / 1000;
        Error_imposta_la_istruzione();
    
    //Dobbiamo scrivere in memoria se richiesto, da abilitare
//  EPROM_store_recover_detector_voltage_M24C32_64( scheda_su_scheda_giu, Detector_canali_da_regolare_iniziali, \
// Detector_Voltage_Bias[3 + scheda_su_scheda_giu]  , 0 );
    
}   

Definition at line 333 of file Detector_Bias.c.