CROSS Technical Documentation User Manual and Technical Doc.
INFN Milano Bicocca
Loading...
Searching...
No Matches

◆ Detector_aggiusta_offset_SAR()

static void Detector_aggiusta_offset_SAR ( EPROM_detector__ *  EPROM_detector_sar,
uint8_t  scheda_su_scheda_giu_ 
)
static

This function provide the output offset with the fast SAR method: only a few LS bits are left for this.

Parameters
[in]EPROM_detector_saris a struct with the necessary information about trimmer calibration retrievd from memory.
[in]scheda_su_scheda_giu_the selected board
Returns
No Parameters, except ffor the global variables such as the trimmers contents.
748static void Detector_aggiusta_offset_SAR(EPROM_detector__ *EPROM_detector_sar, uint8_t scheda_su_scheda_giu_){
749 uint8_t canale, non_misuro;
750 uint8_t indice,iii;
751 int32_t variabile_ponte,ADC_misura_fatta_pos,ADC_misura_fatta_neg,mezzo_bit;
752 uint8_t i_2_trimmer[]={Detector_trimmer_coarse_bias_pos , Detector_trimmer_fine_bias_pos}, indice_trimmer,scalata,confronto;
753 uint8_t target_raggiunto_1_non_raggiunto_0[]={0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0}; // si misura fino a che non diventa 1
754 int32_t risul_vof;
755
756
757 if(scheda_su_scheda_giu_>=1) scheda_su_scheda_giu_=6;
758 misura_il_valore_trimmer_detector( EPROM_detector_sar , scheda_su_scheda_giu_, Detector_canali_da_regolare, Detector_trimmer_coarse_bias_pos);
759 mezzo_bit=0;
760 iii=0;
761 for (canale=0;canale<6;canale++){
762 if( (Detector_canali_da_regolare >> canale ) & 1) {
763 // si usa il meno perch\'e la pendenza \'e negativa, mentre vogliamo un valore positivo
764 iii ++;
765 mezzo_bit = mezzo_bit - EPROM_detector_sar[canale].slope_coarse_positiva - EPROM_detector_sar[canale].slope_coarse_negativa;
766 //Qui invece inizializziamo i trimmer MS
767 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, Detector_trimmer_coarse_bias_pos, \
768 Detector_SAR_ini[canale +scheda_su_scheda_giu_ ].starting_value_pos , Detector_scrivi_il_trimmer );//Trimmer inizializzato a zero coarse pos
769 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, Detector_trimmer_coarse_bias_neg, \
770 Detector_SAR_ini[canale +scheda_su_scheda_giu_ ].starting_value_neg, Detector_scrivi_il_trimmer );//Trimmer inizializzato a zero coarse neg
771 if ( flag_error_verified ){ ERROR_codifica_errore( scheda_su_scheda_giu_, error_address_PGA_DetectorTrimmer_down , DetectorTrimmer_error_0 + canale, 1);
772 Detector_canali_da_regolare=0;
773 }
774 }
775 }
776 mezzo_bit = mezzo_bit / (4*iii) ; // mezzo_bit medio, il / 4 \'e /2 perch\'e ad ogni iii abbiamo 2 somme e /2 perch\'e vogliamo mezzo bit
777// if( Detector_error_voltage > mezzo_bit) mezzo_bit = Detector_error_voltage;
778
779//FINE Inizializzazione dei trimmer che servono alla regolazione
780
781// Esploriamo i 2 trimmer, a partie dal+ significativo, cio\'e il SAR veroe e proprio
782 for(indice_trimmer=0; indice_trimmer<2;indice_trimmer++){
783
784 if( i_2_trimmer[indice_trimmer] == Detector_trimmer_fine_bias_pos) {
785 for(canale=0;canale<6;canale++){//Al secondo giro fine si pu\'o ancora migliorare, di principio
786 if( (Detector_canali_da_regolare >> canale ) & 1){
787 Detector_SAR_ini[canale + scheda_su_scheda_giu_].target_non_raggiunto_neg=true;
788 Detector_SAR_ini[canale +scheda_su_scheda_giu_].target_non_raggiunto_pos=true;
789 }
790 }
791 misura_il_valore_trimmer_detector( EPROM_detector_sar, scheda_su_scheda_giu_, Detector_canali_da_regolare, Detector_trimmer_fine_bias_pos);
792 mezzo_bit=0;
793 iii=0;
794 for (canale=0;canale<6;canale++){
795 if( (Detector_canali_da_regolare >> canale ) & 1) {
796 indice= canale + scheda_su_scheda_giu_;
797 //determiniamo il mezzo bit per il LS
798 mezzo_bit = mezzo_bit + EPROM_detector_sar[canale].slope_fine_negativa + EPROM_detector_sar[canale].slope_fine_positiva;
799 iii++;
800 //Condizioni iniziali per i trimmer
801 //Qui invece inizializziamo i trimmer MS
802 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, Detector_trimmer_fine_bias_pos, \
803 Detector_SAR_ini[indice ].starting_value_pos, Detector_scrivi_il_trimmer );//Trimmer inizializzato a zero fine pos
804 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, Detector_trimmer_fine_bias_neg, \
805 Detector_SAR_ini[indice ].starting_value_neg, Detector_scrivi_il_trimmer );//Trimmer inizializzato a zero fine neg
806 }
807 }
808 mezzo_bit = mezzo_bit / (4*iii) ; //Determiniamo il nuovo mezzo bit medio
809 if( Detector_error_voltage > mezzo_bit) mezzo_bit = Detector_error_voltage;
810 }
811
812// for (canale=0;canale<6;canale++){
813// if( (Detector_canali_da_regolare >> canale ) & 1) {
814//
815// }
816// }
817 for(scalata=0; scalata<8; scalata++){
818 confronto= 1 << (7-scalata); //Impostiamo il valore di prova da aggiungere al trimmer
819 non_misuro =0;
820 for(canale=0; canale<6;canale++){ // Scansoniamo tutti i possibili canali sulla scheda selezionata
821 indice= canale + scheda_su_scheda_giu_; //Solito 2 schede possibili, la prima schede ha indirizzi da 0 a 5, la seconda da 6 a 11
822 if( (Detector_canali_da_regolare >> canale) & 1){//Selezionaiamo solo i canali indicati
823 if( ((Detector_SAR_ini[indice].starting_exp_value_pos >= (7-scalata))) &&\
824 Detector_SAR_ini[indice].target_non_raggiunto_pos){ //Job starts just with the minimal cheks, always for the lower 8 bits
825 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]] += confronto;
826 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer], \
827 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]], Detector_scrivi_il_trimmer );
828 non_misuro=1;
829 }
830 if( ((Detector_SAR_ini[indice].starting_exp_value_neg >= (7-scalata))) && \
831 Detector_SAR_ini[indice].target_non_raggiunto_neg){ //Job starts just with the minimal cheks, always for the lower 8 bits
832 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]+1] |= confronto;
833 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer]+1, \
834 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]+1], Detector_scrivi_il_trimmer );
835 non_misuro=1;
836 }
837 }
838 }
839 if( non_misuro){ //Inutile perdere tempo se non c'e' niente di selezionato da misurare
840 Aspetta_tanti_ms( Detector_attesa_tra_le_misure );
841
842 for(canale=0; canale<6;canale++){ // Scansoniamo tutti i possibili canali sulla scheda selezionata
843 indice= canale + scheda_su_scheda_giu_; //Solito 2 schede possibili, la prima schede ha indirizzi da 0 a 5, la seconda da 6 a 11
844 if( (Detector_canali_da_regolare >> canale) & 1){//Selezionaiamo solo i canali indicati
845 //Misuro con ADC
846// if( Detector_externalADC_1_onboardADC_0){
847// //Misura con adc esterno
848// if( (Detector_SAR_ini[indice].target_non_raggiunto_pos) && \
849// (Detector_SAR_ini[indice].starting_exp_value_pos >= (7-scalata))){
850// ADC_misura_fatta_pos = preamplifier_ADC_external_measured_node_function(scheda_su_scheda_giu_, \
851// node_voltage_Analog_Mux_0_offset + canale *2 );}
852// Aspetta_tanti_ms(100);
853// if( (Detector_SAR_ini[indice].target_non_raggiunto_neg) && \
854// (Detector_SAR_ini[indice].starting_exp_value_neg >= (7-scalata))){
855// ADC_misura_fatta_neg = preamplifier_ADC_external_measured_node_function(scheda_su_scheda_giu_, \
856// node_voltage_Analog_Mux_0_offset + canale *2+1 ); }
857// Aspetta_tanti_ms(100);
858// if( flag_error_verified){
859// ERROR_codifica_errore(scheda_su_scheda_giu_, error_address_reg_ADC0 , ADC_external_fails , 1);
860// Detector_canali_da_regolare=0;
861// }
862// }else{
863 {
864 //Misuro con adc interno
865 if( (Detector_SAR_ini[indice].target_non_raggiunto_pos) && \
866 (Detector_SAR_ini[indice].starting_exp_value_pos >= (7-scalata))){
867// ADC_misura_fatta_pos = ADC_lettura(scheda_su_scheda_giu_, node_voltage_Analog_Mux_0_offset + canale *2, 2 );
868// risul_vof= (ADC_lettura_24bit( node_voltage_Analog_Mux_0_offset + canale *2,scheda_su_scheda_giu_, 2) ) ;
869// ADC_misura_fatta_pos = ADC_compensazione_al_nodo(node_voltage_Analog_Mux_0_offset + canale *2,ADC_misura_fatta_pos, risul_vof);
870
871// ADC_misura_fatta_pos = ADC_misura_differenziale_single_ended(scheda_su_scheda_giu_, node_voltage_Analog_Mux_0_offset + canale *2,0);
872
873 ADC_misura_fatta_pos = ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu_,Detector_externalADC_1_onboardADC_0,node_voltage_Analog_Mux_0_offset + canale *2,0);
874 }
875 Aspetta_tanti_ms(100);
876 if( (Detector_SAR_ini[indice].target_non_raggiunto_neg) && \
877 (Detector_SAR_ini[indice].starting_exp_value_neg >= (7-scalata))){
878// ADC_misura_fatta_neg = ADC_lettura(scheda_su_scheda_giu_, node_voltage_Analog_Mux_0_offset + canale *2+1, 2 );
879// risul_vof= (ADC_lettura_24bit( node_voltage_Analog_Mux_0_offset + canale *2+1,scheda_su_scheda_giu_, 2) ) ;
880// ADC_misura_fatta_neg = ADC_compensazione_al_nodo(node_voltage_Analog_Mux_0_offset + canale *2+1, ADC_misura_fatta_neg, risul_vof);
881
882// ADC_misura_fatta_neg= ADC_misura_differenziale_single_ended(scheda_su_scheda_giu_, node_voltage_Analog_Mux_0_offset + canale *2+1,0);
883 ADC_misura_fatta_neg= ADC_misura_differenziale_con_media_generico(scheda_su_scheda_giu_,Detector_externalADC_1_onboardADC_0,node_voltage_Analog_Mux_0_offset + canale *2+1,0);
884 }
885 Aspetta_tanti_ms(100);
886 if( flag_error_verified){ ERROR_codifica_errore(scheda_su_scheda_giu_, error_address_reg_ADC0 , ADC_internal_General_fails , 1);
887 Detector_canali_da_regolare=0;
888 }
889 }
890//Inizio Test sulla parte positiva *****************************************************************************************
891 if( (Detector_SAR_ini[indice].target_non_raggiunto_pos) && (Detector_SAR_ini[indice].starting_exp_value_pos >= (7-scalata))){
892 if( ( ADC_misura_fatta_pos - Detector_bias_target[indice] ) < ( - mezzo_bit) ){
893 //siamo fuori tolleranza
894 if(i_2_trimmer[indice_trimmer] == Detector_trimmer_coarse_bias_pos){//Gain opposto per coarse rispetto a fine
895 contenuto_trimmer_detector[indice][ i_2_trimmer[indice_trimmer]] -= confronto;
896 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer], \
897 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]], Detector_scrivi_il_trimmer );
898 }
899 }else if ( (( ADC_misura_fatta_pos - Detector_bias_target[indice] ) <= 0 ) && \
900 (( ADC_misura_fatta_pos - Detector_bias_target[indice] ) >= -Detector_error_voltage ) ){
901 //Siamo in tolleranza e dobbiamo fermarci
902 Detector_SAR_ini[indice].target_non_raggiunto_pos =false;
903 }else if ( ( ADC_misura_fatta_pos - Detector_bias_target[indice] ) > ( mezzo_bit)){
904 //siamo fuori tolleranza
905 //Cerchiamo di stare entro mezzo bit
906 if( (confronto ==1) && (i_2_trimmer[indice_trimmer] == Detector_trimmer_coarse_bias_pos)){
907 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]] ++;
908 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer], \
909 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]], Detector_scrivi_il_trimmer );
910 }
911// Detector_misura_fatta_old[indice]= ADC_misura_fatta; //
912 if(i_2_trimmer[indice_trimmer] == Detector_trimmer_fine_bias_pos){//Gain opposto per coarse rispetto a fine
913 contenuto_trimmer_detector[indice][ i_2_trimmer[indice_trimmer]] -= confronto;
914 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer], \
915 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]], Detector_scrivi_il_trimmer );
916 }
917 }else if ( (( ADC_misura_fatta_pos - Detector_bias_target[indice] ) >=0) &&\
918 (( ADC_misura_fatta_pos - Detector_bias_target[indice] ) <= Detector_error_voltage) ){
919 //siamo in tolleranza
920 Detector_SAR_ini[indice].target_non_raggiunto_pos =false;
921 }
922 }
923//Fine Test sulla parte positiva *****************************************************************************************
924
925//Inizio Test sulla parte negativa *****************************************************************************************
926 if( (Detector_SAR_ini[indice].target_non_raggiunto_neg) && \
927 (Detector_SAR_ini[indice].starting_exp_value_neg >= (7-scalata))){
928 if( ( -ADC_misura_fatta_neg - Detector_bias_target[indice] ) < \
929 ( - mezzo_bit) ){
930 //siamo fuori tolleranza
931 if(i_2_trimmer[indice_trimmer] == Detector_trimmer_fine_bias_pos){//Gain opposto per coarse rispetto a fine
932 contenuto_trimmer_detector[indice][ i_2_trimmer[indice_trimmer]+1] -= confronto;
933 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer]+1, \
934 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]+1], Detector_scrivi_il_trimmer );
935 }
936 //Crechiamo di stare entro mezzo bit
937 if( (confronto ==1) && (i_2_trimmer[indice_trimmer ] == Detector_trimmer_coarse_bias_pos)){
938 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]+1] ++;
939 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer]+1, \
940 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]+1], Detector_scrivi_il_trimmer );
941 }
942
943 }else if ( (( -ADC_misura_fatta_neg - Detector_bias_target[indice] ) <=0) && \
944 (( -ADC_misura_fatta_neg - Detector_bias_target[indice] ) >= -Detector_error_voltage) ){
945 //Siamo in tolleranza e dobbiamo fermarci
946 Detector_SAR_ini[indice].target_non_raggiunto_neg =false;
947 }else if ( ( -ADC_misura_fatta_neg - Detector_bias_target[indice] ) >\
948 ( mezzo_bit)){
949 //siamo fuori tolleranza
950 if(i_2_trimmer[indice_trimmer] == Detector_trimmer_coarse_bias_pos){//Gain opposto per coarse rispetto a fine
951 contenuto_trimmer_detector[indice][ i_2_trimmer[indice_trimmer]+1] -= confronto;
952 detector_scrittura_lettura_trimmer_bias( scheda_su_scheda_giu_, canale, i_2_trimmer[indice_trimmer]+1, \
953 contenuto_trimmer_detector[indice][i_2_trimmer[indice_trimmer]+1], Detector_scrivi_il_trimmer );
954 }
955 }else if ( (( -ADC_misura_fatta_neg - Detector_bias_target[indice] ) >= 0 ) && \
956 (( -ADC_misura_fatta_neg - Detector_bias_target[indice] ) <= Detector_error_voltage ) ){
957 //siamo in tolleranza
958 Detector_SAR_ini[indice].target_non_raggiunto_neg =false;
959 }
960 }
961//Fine Test sulla parte negativa *****************************************************************************************
962 if( (Detector_SAR_ini[indice].target_non_raggiunto_neg || Detector_SAR_ini[indice].target_non_raggiunto_pos)==false){
963 //sia parte positiva che negativa sono ok
964 Detector_canali_da_regolare -= 1 << canale ;
965 }
966 }
967 }
968 }//non misuro
969 }
970 }
971}
ADC_misura_differenziale_con_media_generico
int32_t ADC_misura_differenziale_con_media_generico(uint8_t scheda_su_scheda_giu_, uint8_t preamplifier_externalADC_1_onboardADC_0, uint8_t nodo_da_misurare, uint8_t differenziale_1_single_0)
This function sets the original gain when a few LSb have to be determined. The umber of bits is bit_t...
Definition: Adc.c:899
misura_il_valore_trimmer_detector
static void misura_il_valore_trimmer_detector(EPROM_detector__ *EPROM_detector, uint8_t scheda_su_scheda_giu_, uint8_t canali_da_regolare, uint8_t trimmer_da_scrivere)
Definition: Detector_Bias.c:553
Detector_aggiusta_offset_SAR
static void Detector_aggiusta_offset_SAR(EPROM_detector__ *EPROM_detector_sar, uint8_t scheda_su_scheda_giu_)
This function provide the output offset with the fast SAR method: only a few LS bits are left for thi...
Definition: Detector_Bias.c:748
Detector_bias_target
int32_t Detector_bias_target[12]
Detector bias target values.
Definition: Detector_Bias.c:246
Detector_trimmer_fine_bias_pos
#define Detector_trimmer_fine_bias_pos
Definition: Detector_Bias.h:100
Detector_trimmer_coarse_bias_pos
#define Detector_trimmer_coarse_bias_pos
Definition: Detector_Bias.h:98
Detector_trimmer_fine_bias_neg
#define Detector_trimmer_fine_bias_neg
Definition: Detector_Bias.h:101
Detector_trimmer_coarse_bias_neg
#define Detector_trimmer_coarse_bias_neg
Definition: Detector_Bias.h:99
Detector_scrivi_il_trimmer
#define Detector_scrivi_il_trimmer
Definition: Detector_Bias.h:94
ERROR_codifica_errore
void ERROR_codifica_errore(uint8_t scheda_su_scheda_giu, unsigned char error_addres, unsigned char code_to_shift, uint8_t reset_count_se_0)
If an error is found its flag is codified here.
Definition: Error_handling.c:664
ADC_internal_General_fails
@ ADC_internal_General_fails
ADC general fault.
Definition: Error_handling.h:77
error_address_reg_ADC0
@ error_address_reg_ADC0
Error register for ADC0.
Definition: Error_handling.h:39
error_address_PGA_DetectorTrimmer_down
@ error_address_PGA_DetectorTrimmer_down
Error register for on board PGA/detector trimmer
Definition: Error_handling.h:56
DetectorTrimmer_error_0
@ DetectorTrimmer_error_0
detector trimmer setting error for CH0
Definition: Error_handling.h:274
node_voltage_Analog_Mux_0_offset
@ node_voltage_Analog_Mux_0_offset
Starting Offset for this set of nodes, 32.
Definition: Multiplexer_strutture_funzioni_definizioni.h:20
Aspetta_tanti_ms
void Aspetta_tanti_ms(int millisecondi)
The timing function.
Definition: Timer.c:52
contenuto_trimmer_detector
uint8_t contenuto_trimmer_detector[12][4]
Content of the trimmer for detector bias system.
Definition: Trimmer.c:161
detector_scrittura_lettura_trimmer_bias
void detector_scrittura_lettura_trimmer_bias(uint8_t scheda_su_scheda_giu, uint8_t canale, uint8_t trimmer, uint8_t valore, uint8_t scrivi_1_leggi_0)
Setting the value of any trimmer for detector biasing, the contents of the trimmers are stored in the...
Definition: Trimmer.c:238
EPROM_detector_
Definition: Detector_Bias.h:37

Definition at line 748 of file Detector_Bias.c.