instruction_Detector_bias()

void instruction_Detector_bias

(

void

)

The detector bias is set at the value passed from the CAN.

This instruction needs to know which channel to set at byte istruzione_byte_4_e_scelta_canale and the the setting value, in mV, byte_istr_dati_0 and byte_istr_dati_1 of the CAN message.

Returns

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

void instruction_Detector_bias(void)
{
    //Per la positiva
//  long int vout_pos, vout_neg;
    #define offset_adjusted_at_the_pre_bias_set 0   /*Byte_1*/
    #define bias_adjustement_start_from_half_scale 1 /*Byte_1*/
    bool errore_pos[2]={true,true}, errore_neg[2]={true,true},errore_generale=true;
//  int valore_positivo,valore_negativo, tolleranza=((vettore_istruzioni[istruzione_byte_3]*1000)/bias_reading_attenuation)/2;//diviso 2 perch\'e \'e sulle 2 tensioni che si determina l'errore
    int valore_positivo,valore_negativo, tolleranza=((vettore_istruzioni[istruzione_byte_3]*1000))/2;//diviso 2 perch\'e \'e sulle 2 tensioni che si determina l'errore
    unsigned int attesa;
    long int discrepanza;
    char canale=0, troppe_misure=0,ii;
//  int tensione_target_attenuata[]={(Detector_Voltage_Bias[0]>>1)/bias_reading_attenuation, (Detector_Voltage_Bias[1]>>1)/bias_reading_attenuation};
        int tensione_target_attenuata[]={(Detector_Voltage_Bias[0]>>1), (Detector_Voltage_Bias[1]>>1)};
//  vout_pos = ( vettore_istruzioni[byte_istr_dati_0] & 0xFF+ ((vettore_istruzioni[byte_istr_dati_1] & 0xFF) << 8) );           // Viene letto il valore scelto da remoto
//  vout_pos = ((vout_pos>>1) * 1000)/ bias_reading_attenuation ;
    int offset; 
    char nodo_di_misura_1[]={ADC_ADC_PGA_neg_out_ch0, ADC_ADC_PGA_neg_out_ch1};
    char nodo_di_misura_2[]={ADC_ADC_PGA_pos_out_ch0, ADC_ADC_PGA_pos_out_ch1};
//  int coarse_trimmer_step = coarse_Trimmer_offset_step * guadagno_minimo_PGA ; //*********************************************
//  int fine_trimmer_step = fine_Trimmer_offset_step * guadagno_minimo_PGA ;     //*********************************************        
 
//  vout_neg=-vout_pos;
//  int16_t Valori_per_i_trimmer_pos[2],Valori_per_i_trimmer_neg[2];        // Qui verranno inseriti i valori per i trimmer
    struct canale_ADC_type{
        unsigned char att_pos;
        unsigned char att_neg;
    }canale_ADC[]={ADC_Misura_bias_10_att_ch0_p,ADC_Misura_bias_10_att_ch0_n,ADC_Misura_bias_10_att_ch1_p,ADC_Misura_bias_10_att_ch1_n} ;
    
    //PGA a 1 per evitare sconquassi
    if( vettore_istruzioni[istruzione_byte_1] >> offset_adjusted_at_the_pre_bias_set) {
        //Vogliamo lacsiare l'offset inalterato
            for( canale=0;canale<2;canale++){
                    if( ((vettore_istruzioni[istruzione_byte_4_e_scelta_canale]&3) >> canale) & 1){ 
//                          offset=lettura_ADC( nodo_di_misura_1[canale]) - lettura_ADC( nodo_di_misura_2[canale]); //Il <<1 \'e per renderlo differenziale
                            valore_target_per_offset[canale]=correzione_misura_ADC(coeffcienti_misura_ADC_nodi[nodo_di_misura_1[canale]], offset);
                            //Voglim mantenere la tenione allo stesso livello se \'e in scala, altrimenti aggiustiamo a zero
                            if( (valore_target_per_offset[canale] >= saturazione_positiva) || ( valore_target_per_offset[canale] <= saturazione_negativa ) ) {
                                valore_target_per_offset[canale]=0;
                            }
                            //L'offset all'uscita del pga che vorremo avere a guadagno 1
                            valore_target_per_offset[canale] = ( valore_target_per_offset[canale] * (int)guadagno_minimo_PGA ) / (int)PGA_Gain_V_su_V[canale] ;
                            }
            }
    }
    char PGA_Gain_V_su_V_old[]={PGA_Gain_V_su_V[0], PGA_Gain_V_su_V[1]};
    PGA_GAIN_set(3,1);
 
//  if ( vettore_istruzioni[istruzione_byte_4_e_scelta_canale]) canale=1;
 
 
    if (vettore_istruzioni[istruzione_byte_2]==0){ 
        attesa =1000;
    }else {
        attesa= vettore_istruzioni[istruzione_byte_2] *100;
    }
    for(ii =0; ii<2;ii++){
        if( ( ((vettore_istruzioni[istruzione_byte_4_e_scelta_canale]) >> ii) & 1) == 0) {
            errore_pos[ii]=false;
            errore_neg[ii]=false;
        }
    }
 
    if( (vettore_istruzioni[istruzione_byte_1] >> bias_adjustement_start_from_half_scale) ){
    for(canale =0; canale<2;canale++){
        if ( errore_pos[canale] ){
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_pos, 0x80);         // Viene fatta una misura con entrambi i trimmer a met\'a scala per ricavare l'offset   
            detector_Trimmer_bias[canale].coarse_pos=0x80;
            detector_Trimmer_bias[canale].fine_pos=0x80;
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_pos, 0x80);   
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_neg, 0x80);             // Viene fatta una misura con entrambi i trimmer a met\'a scala per ricavare l'offset       
            detector_Trimmer_bias[canale].coarse_neg=0x80;
            detector_Trimmer_bias[canale].fine_neg=0x80;
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_neg , 0x80);  
            }
    }
        Aspetta_tanti_ms(attesa);
}
    
    for(canale =0; canale<2;canale++){
        if ( errore_pos[canale] ){
//          offset = lettura_ADC( canale_ADC[canale].att_pos); // Viene misurato l'offset   per usscita pos e valutato il nuvo valore dei trimmer
            offset = correzione_misura_ADC(indice_Vbias, offset);
            discrepanza =  tensione_target_attenuata[canale] - offset;
//          Trova_valori_trimmer_per_la_Vbias_del_rivelatore_per_la_tensione_in_uscita_uguale_a_vout ( tensione_target_attenuata[canale], &detector_Trimmer_bias[canale].coarse_pos, offset);       
            imposta_il_trimmer_del_bias(&detector_Trimmer_bias[canale].coarse_pos,   discrepanza, trimmer_bias_coarse_step_actual[canale], trimmer_bias_fine_step_actual[canale]);
    
 
//          offset = lettura_ADC( canale_ADC[canale].att_neg); // Viene misurato l'offset per uscita neg e valutato il nuovo valore dei trimmer
            offset = correzione_misura_ADC(indice_Vbias, offset);
            discrepanza =  -tensione_target_attenuata[canale] - offset;
//          Trova_valori_trimmer_per_la_Vbias_del_rivelatore_per_la_tensione_in_uscita_uguale_a_vout ( -tensione_target_attenuata[canale], &detector_Trimmer_bias[canale].coarse_neg, offset);
            imposta_il_trimmer_del_bias(&detector_Trimmer_bias[canale].coarse_neg,   discrepanza, trimmer_bias_coarse_step_actual[canale], trimmer_bias_fine_step_actual[canale]);  
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_neg, detector_Trimmer_bias[canale].coarse_neg);                                     
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_neg, detector_Trimmer_bias[canale].fine_neg);         
            
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_pos, detector_Trimmer_bias[canale].coarse_pos);                                     
            Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_pos, detector_Trimmer_bias[canale].fine_pos);
            }           
    }
    Aspetta_tanti_ms(attesa);                           
    
while( errore_generale &&   (troppe_misure<5) ){
    errore_generale=false;
    troppe_misure++;
    for( canale=0;canale<2;canale++){
        if(errore_pos[canale]){         
                
//              risultato= lettura_ADC( canale_ADC[canale].att_pos); // Viene misurato il Vbias Pos
                risultato = correzione_misura_ADC(indice_Vbias, risultato);
                discrepanza =  tensione_target_attenuata[canale] - risultato;   // Si itera finch\'e |discrepanza| < tot        
                errore_pos[canale]=(discrepanza < -tolleranza || discrepanza > tolleranza);
                imposta_il_trimmer_del_bias(&detector_Trimmer_bias[canale].coarse_pos,   discrepanza, trimmer_bias_coarse_step_actual[canale], trimmer_bias_fine_step_actual[canale]);
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_pos,detector_Trimmer_bias[canale].coarse_pos);                                      
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_pos, detector_Trimmer_bias[canale].fine_pos);                                             
        }   
        if (errore_neg[canale]){            
//              risultato= lettura_ADC( canale_ADC[canale].att_neg); 
                risultato = correzione_misura_ADC(indice_Vbias, risultato);
                discrepanza =  -tensione_target_attenuata[canale] - risultato;                                                                  // Si itera finch\'e |discrepanza| <1       
                errore_neg[canale]=(discrepanza <= -tolleranza || discrepanza >= tolleranza);       
                imposta_il_trimmer_del_bias(&detector_Trimmer_bias[canale].coarse_neg,   discrepanza, trimmer_bias_coarse_step_actual[canale], trimmer_bias_fine_step_actual[canale]);  
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_coarse_neg, detector_Trimmer_bias[canale].coarse_neg);                                     
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CB (canale, trimmer_bias_fine_neg, detector_Trimmer_bias[canale].fine_neg);                                     
        }
        errore_generale |=errore_neg[canale] | errore_pos[canale] ;
    }
        Aspetta_tanti_ms(attesa);
    }   
    
        //Ristabiliamo l'offset se richiesto 
    if( vettore_istruzioni[istruzione_byte_1] >> offset_adjusted_at_the_pre_bias_set) {
        //Il bias viene riaggiustato al valore originale
        vettore_istruzioni[istruzione_byte_3]=0;
        vettore_istruzioni[istruzione_byte_1]=0x40; //Offset target from elsewhere
        vettore_istruzioni[istruzione_byte_2]=10;
        instruction_Offset_compensation();
    }
    
                    tx_data[istruzione_byte_4_e_scelta_canale] =0;
    for ( canale=0;canale<2;canale++){
//          risultato= lettura_ADC( canale_ADC[canale].att_pos); // Viene misurato il Vbias Pos
            risultato = correzione_misura_ADC(indice_Vbias, risultato);
//          valore_positivo  = (risultato*bias_reading_attenuation)/1000;
            valore_positivo  = (int)(((risultato)/1000) & 0xFFFFFFFF);
//          tx_data[byte_istr_dati_0] = valore_positivo & 0xFF;
//          tx_data[byte_istr_dati_1] = (valore_positivo >>8) & 0xFF;
 
//          risultato= lettura_ADC( canale_ADC[canale].att_neg); 
            risultato = correzione_misura_ADC(indice_Vbias, risultato);
//          valore_negativo = (risultato*bias_reading_attenuation)/1000;
            valore_negativo = (int)(((risultato)/1000) & 0xFFFFFFFF);
            valore_negativo =valore_positivo - valore_negativo;
            tx_data[byte_istr_dati_0 + 2*canale] = (unsigned char)(valore_negativo & 0xFF);
            tx_data[byte_istr_dati_1+ 2*canale] = (unsigned char)((valore_negativo >>8) & 0xFF);    
            tx_data[istruzione_byte_4_e_scelta_canale] =  ( errore_neg[canale] | errore_pos[canale] )  << canale;
    }
        //PGA ristabilito
            PGA_GAIN_set(1,PGA_Gain_V_su_V_old[0]);
            PGA_GAIN_set(2,PGA_Gain_V_su_V_old[1]);
 
        
}   

Definition at line 1145 of file Detector_Bias.c.