instruction_Some_parameters_to_set()

void instruction_Some_parameters_to_set

(

void

)

Some usefull parematers can be set here.

The list of parameters is the enum DA AGGIUNGERE This instruction needs to know which parameter to set at byte istruzione_byte_4_e_scelta_canale and the parameter value at bytes 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_Some_parameters_to_set(void){
    //The second byte from the CAN says which paremetr to set
    //The last byt from the CAN says which value to set
    char ii, canale;
enum R_W_Parameters {
 read_write_value_for_wait_for_ADC_setting                  ,       //!< NOP, in future release the fw version will be replayed     
 read_write_medie_ADC,  
 read_PGA_Gain_code,
 read_PGA_Gain_V_su_V,
 read_write_guadagno_minimo_PGA,
 read_write_massimo_guadagno_impostabile,
 read_write_Trimmer_offset_preampli,
 read_write_Trimmer_thermal_preampli,
 read_write_Trimmer_detector_bias_positive,
 read_write_Trimmer_detector_bias_negative,
 read_write_Trimmer_drift_in_micro_su_C,
 read_write_Trimmer_common_mode
}  ;    
    //Da aggiungere: 
 
    char sottoistruzione = vettore_istruzioni[istruzione_byte_4_e_scelta_canale];
    for(ii =0;ii<2;ii++){
        if( (sottoistruzione >> ii) && 1) canale=ii;
    }
 
    switch (vettore_istruzioni[istruzione_byte_2])
    {
        case read_write_value_for_wait_for_ADC_setting:
            {
                if( vettore_istruzioni[istruzione_byte_3]){
                wait_for_ADC_setting= (vettore_istruzioni[byte_istr_dati_1] <<8) + vettore_istruzioni[byte_istr_dati_0];
                //MAximu time is 10 sec: time from the mux and ADC setting and the measurement
                //Default is 100 ms
                if (wait_for_ADC_setting >10000) wait_for_ADC_setting=10000;
                }
                tx_data[0]= wait_for_ADC_setting &0xFF;
                tx_data[1]= (wait_for_ADC_setting >>8 ) & 0xFF;
                return;
            }
        case read_write_medie_ADC:
        {
                if( vettore_istruzioni[istruzione_byte_3]){
                medie_ADC=  vettore_istruzioni[byte_istr_dati_0];
                //Default is 2: take care the number of averages is (1 << medie_ADC), or 2^medie_ADC
                }
                tx_data[0]= medie_ADC &0xFF;            
            return;
        }
        case read_PGA_Gain_code:  //Read only
            {
                tx_data[0]= PGA_Gain_code[canale] & 0xFF;
                tx_data[1]= (PGA_Gain_code[canale] >>8 ) & 0xFF;    
                return;
            }
        case read_PGA_Gain_V_su_V:
        {
                tx_data[0]= PGA_Gain_V_su_V[canale] & 0xFF;     
        return;
        }
        case read_write_guadagno_minimo_PGA:
        {
                if( vettore_istruzioni[istruzione_byte_3]){
                guadagno_minimo_PGA=  vettore_istruzioni[byte_istr_dati_0];
                //Default is 4:
                }
                tx_data[0]= guadagno_minimo_PGA &0xFF;          
            return;         
        }
        case read_write_massimo_guadagno_impostabile:
        {
                if( vettore_istruzioni[istruzione_byte_3]){
                massimo_guadagno_impostabile=  vettore_istruzioni[byte_istr_dati_0];
                //Default is 100:
                }
                tx_data[0]= massimo_guadagno_impostabile &0xFF;         
            return;         
        }
        case read_write_Trimmer_offset_preampli:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                Trimmer_offset_preampli[canale].coarse_offset= vettore_istruzioni[byte_istr_dati_1];
                Trimmer_offset_preampli[canale].fine_offset = vettore_istruzioni[byte_istr_dati_0];
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_corse_offset_trimmer, Trimmer_offset_preampli[canale].coarse_offset);                                      
    Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_offset_trimmer, Trimmer_offset_preampli[canale].fine_offset);                 
            }
                tx_data[0]= Trimmer_offset_preampli[canale].fine_offset & 0xFF;
                tx_data[1]= Trimmer_offset_preampli[canale].coarse_offset & 0xFF;       
            return;
        }
        case read_write_Trimmer_thermal_preampli:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                Trimmer_offset_preampli[canale].coarse_thermal= vettore_istruzioni[byte_istr_dati_1];
                Trimmer_offset_preampli[canale].JFET_Offset = vettore_istruzioni[byte_istr_dati_0];
//              Trimmer_offset_preampli[canale].fine_thermal = vettore_istruzioni[byte_istr_dati_0];
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_coarse_thermal_trimmer , Trimmer_offset_preampli[canale].coarse_thermal);                                      
                Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_JFET_Offset_trimmer , Trimmer_offset_preampli[canale].JFET_Offset);
//  Imposta_canale_del_trimmer_ennesimo_al_valore_I2CA (canale, preampli_fine_thermal_trimmer, Trimmer_offset_preampli[canale].fine_thermal);                   
            }
//              tx_data[0]= Trimmer_offset_preampli[canale].fine_thermal & 0xFF;
                tx_data[1]= Trimmer_offset_preampli[canale].coarse_thermal & 0xFF;  
                tx_data[0]= Trimmer_offset_preampli[canale].JFET_Offset & 0xFF;
            return;
        }   
        case read_write_Trimmer_detector_bias_positive:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                detector_Trimmer_bias[canale].fine_pos= vettore_istruzioni[byte_istr_dati_0];
                detector_Trimmer_bias[canale].coarse_pos = vettore_istruzioni[byte_istr_dati_1];
            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);                 
            }
                tx_data[0]= detector_Trimmer_bias[canale].fine_pos & 0xFF;
                tx_data[1]= detector_Trimmer_bias[canale].coarse_pos & 0xFF;            
            return;
        }
        case read_write_Trimmer_detector_bias_negative:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                detector_Trimmer_bias[canale].fine_neg= vettore_istruzioni[byte_istr_dati_0];
                detector_Trimmer_bias[canale].coarse_neg = vettore_istruzioni[byte_istr_dati_1];
            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);                 
            }
                tx_data[0]= detector_Trimmer_bias[canale].fine_neg & 0xFF;
                tx_data[1]= detector_Trimmer_bias[canale].coarse_neg & 0xFF;                
            return;
        }
        case read_write_Trimmer_drift_in_micro_su_C:
        {
            if( vettore_istruzioni[istruzione_byte_3]){
                reference_thermal_drift_actual= vettore_istruzioni[byte_istr_dati_0];           
            }
        case read_write_Trimmer_common_mode:
        {//Lettura/scrittura del trimmer per aggiustare il CMRR
            if( vettore_istruzioni[istruzione_byte_3]){
                Trimmer_CMRR_JFET_COLD.CMRR[canale]=vettore_istruzioni[byte_istr_dati_0];
                Imposta_trimmer_common_mode_I2CB  ( Trimmer_numero_offset + canale, Trimmer_CMRR_JFET_COLD.CMRR[canale]);                   
            }
                tx_data[0]= Trimmer_CMRR_JFET_COLD.CMRR[canale] & 0xFF;
                tx_data[1]= 0;              
            return;         
        }           
        }
    }
}

Definition at line 577 of file Istruzioni.c.