instr_output_offset_to_be_set_function()

void instr_output_offset_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_output_offset_to_be_set_function(void){
uint8_t iii,canale, indice; 
uint8_t volatile    tx_data_buffer[8],fai_fai=1;
int8_t variazione;
    LED_rosso_fondo_scala=LED_lungo;
    
        ERROR_codifica_errore(0,0,0,0);  //Reset_ch0 errori
        for(iii=0;iii < 8;iii++){// Potrebbe essere richiesto qualcosa sul can, 
            //bufferizziamo l'istruzione
        tx_data_buffer[iii]= tx_data[iii];
    }
 
    //La funzione va sviluppata per ora si ritrona il fw 
    //verificare le modalit\'a di misura:
        ADC_medie_per_misura = (uint8_t) vettore_istruzioni[2];
        if (ADC_medie_per_misura==0) ADC_medie_per_misura=1;
        if( ADC_medie_per_misura >200) ADC_medie_per_misura=200;
        //attesa tra le misure
        preamplifier_attesa_tra_le_misure = vettore_istruzioni[4] *100;
        if ( preamplifier_attesa_tra_le_misure <100) preamplifier_attesa_tra_le_misure=100;
        if (preamplifier_attesa_tra_le_misure > 10000) preamplifier_attesa_tra_le_misure=10000;
        //errore tollerato
        preamplifier_error_voltage= vettore_istruzioni[5] *1000;
        //i canali da agiustare
        preamplifier_canali_da_regolare= vettore_istruzioni[6] & 0x7F;
        preamplifier_canali_da_regolare_old=preamplifier_canali_da_regolare;
        scheda_su_scheda_giu = ((vettore_istruzioni[6] >> 7) & 1)*6;
        //l'adc da usare, interno o esterno
        preamplifier_externalADC_1_onboardADC_0 = vettore_istruzioni[3] & 1;
//      preamplifier_SAR_1_no_SAR_0 = ( vettore_istruzioni[3] >> 1 ) & 1;
//      preamplifier_fastSAR_1_no_fastSAR_0 = ( vettore_istruzioni[3] >> 2 ) & 1;
    
    if ( vettore_istruzioni[3] & detector_bit_store_state_in_user_as_it_is ){
        vettore_istruzioni[3] =0;  //Non si fa altro
        fai_fai=0;
        EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu, vettore_istruzioni[6],0,0);
    }
    
    if ( vettore_istruzioni[3] & detector_bit_recall_startup){
        //Offset recalled from startup
        EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu,preamplifier_canali_da_regolare,1,1);
        fai_fai=0;
    }
        if ( vettore_istruzioni[3] & detector_bit_recall_user_defined){
        //Offset recalled from user location
        EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu,preamplifier_canali_da_regolare,1,0);      
        fai_fai=0;
        }
        
        //Leggiamo le pendenze
        uint8_t dati_scambio[4] , scheda=scheda_su_scheda_giu;
    for( canale=0;canale<6;canale++){   
//          if(canale==6) scheda =1;
            EPROM_lettura_M24C32_64(scheda, I2C_mainboard, canale, Memory_preamplifier_slope_calibration_ON_0_OFF_ff <<2,dati_scambio);
            if(dati_scambio[0] ==0){//solo se la misura \'e stata fatta si aggiornano le pendenze, altrimenti vale il fedault
                    EPROM_lettura_M24C32_64(scheda, I2C_mainboard, canale, Memory_preamplifier_address_coarse_trimmer_slope_offset <<2,dati_scambio);
                    preamplifier_coarse_step_trimmer[canale+scheda]=*(int32_t *)dati_scambio;
                    EPROM_lettura_M24C32_64(scheda, I2C_mainboard, canale, Memory_preamplifier_address_fine_trimmer_slope_offset <<2,dati_scambio);
                    preamplifier_fine_step_trimmer[canale+scheda]=  *(int32_t *)dati_scambio;
            }
            preamplifier_error_voltage_at_the_moment[canale+scheda]= preamplifier_coarse_step_trimmer[canale+scheda] >>1;  //mezzo bit di errore sul coarse all'inizio
    }
 
    if(fai_fai){
//Initialization for default SAR
        if ( vettore_istruzioni[3] & detector_offset_from_half_scale){
                for( canale=0;canale<12;canale++){  
                    preamplifier_SAR_ini[canale].starting_value =128;
                    preamplifier_SAR_ini[canale].starting_exp_value[0]=7;
                    preamplifier_SAR_ini[canale].starting_exp_value[1]=7;
                }
        }
            for( canale=0;canale<6;canale++){ //a met\'a scala i trimmer fine che ci interssano
                if((preamplifier_canali_da_regolare >> canale) & 1){
                    preamplifier_scrittura_lettura_trimmer( scheda_su_scheda_giu,   canale,\
                        trimmer_fine_offset, 128,   preamplifier_scrivi_il_trimmer  );//Trimmer fine inizializzato met\'a scala
                }   
            }
            
//Ora impostiamo ad 1 tutti i guadagni, normalizziamo gli errori ed i target            
preamplifier_normalize_gain_offset_error(scheda_su_scheda_giu)  ;   
            
//FINE: Initialization for default SAR, changes are applied in fastSAR, eventually
            
            for( canale=0;canale<6;canale++){ //impostiamo la compensazione termica di default, se \'e stata fatta.
                if((preamplifier_canali_da_regolare >> canale) & 1){            
                     preamplifier_determina_trimmer_therma_comp( scheda_su_scheda_giu, canale, 0,  1);
                    termalizzazione_fatta[canale + scheda_su_scheda_giu]=0;
                }
            }
            
            
   preamplifier_trova_il_guess(trimmer_coarse_offset);      
     preamplifier_aggiusta_offset_SAR();
            
    //Ora aggiustiamo il controllo termico per quei canali che inizialmente erano saturi
    uint8_t     ri_misuriamo=0;preamplifier_canali_da_regolare_old=preamplifier_canali_da_regolare;
        for( canale=0;canale<6;canale++){ //impostiamo la compensazione termica di default, se \'e stata fatta.
                if((preamplifier_canali_da_regolare_old >> canale) & 1){
                        if (termalizzazione_fatta[canale + scheda_su_scheda_giu]==0){
                            preamplifier_canali_da_regolare=1 <<canale;
                            ri_misuriamo=1;
                        }
                }
            }
        //Se c'erano canali inizalmente saturi riaggiustiamo
            if(ri_misuriamo){
                    preamplifier_trova_il_guess(trimmer_coarse_offset);     
                    preamplifier_aggiusta_offset_SAR();     
            }
 
        
//Ora vediamo qualche setting       
        if(vettore_istruzioni[3] & detector_bit_per_storing_startup){
            //Offset to be stored at memory location for sturtup
            EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu,vettore_istruzioni[6],0,1);            
        }
        if(vettore_istruzioni[3] & detector_bit_per_storing_user_state){
            //Offset to be stored at user memory location for sturtup
            EPROM_store_recover_state_M24C32_64(scheda_su_scheda_giu, vettore_istruzioni[6],0,0);
        }
    }
        for(iii=0;iii < 8 ;iii++){
        tx_data[iii]= tx_data_buffer[iii];
    }
        tx_data[6] = preamplifier_canali_da_regolare; //i canali non in tolleranza hanno un 1 in corrispondenza 
    int32_t somma=0;
    for( iii=0;iii<6;iii++){
        somma += preamplifier_error_voltage_at_PGA_gain[iii+scheda_su_scheda_giu];
    }
    somma = somma / 6000;
    if( somma >255) somma=255;
        tx_data[5] = somma;
    Error_imposta_la_istruzione();
}   

Definition at line 277 of file Preamplifier_Offset_Drift_Correcttion.c.