Mercurial > hg > fxanalyse

comparison FXAnalyse.c @ 118:43b35f4aae78

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fix N3 measurement. Simply frequnecy ramping functions.
author Daniele Nicolodi <daniele.nicolodi@obspm.fr>
date Thu, 12 Sep 2013 15:49:27 +0200
parents 96ab53ab9496
children f9fb17fb64cc
comparison
equal deleted inserted replaced
117:96ab53ab9496 118:43b35f4aae78
102 double FrequencyDDS3Init = 0.0; 102 double FrequencyDDS3Init = 0.0;
103 103
104 double DeltaDDS3=0.0,Delta10K_Plus=0.0,Delta10K_Minus=0.0; 104 double DeltaDDS3=0.0,Delta10K_Plus=0.0,Delta10K_Minus=0.0;
105 double Nu1=0.0, Nu2= 200000-147000+282143746.557455e6; 105 double Nu1=0.0, Nu2= 200000-147000+282143746.557455e6;
106 106
107 double f_rep_slope;
107 double f_rep_plus, f_rep_minus; 108 double f_rep_plus, f_rep_minus;
108 double f_beat_Sr_plus, f_beat_Sr_minus; 109 double f_beat_Sr_plus, f_beat_Sr_minus;
109
110 double Step1=800000.0,Step2=800000.0;
111 110
112 double Ch4Plus=0.0,Ch4Minus=0.0; 111 double Ch4Plus=0.0,Ch4Minus=0.0;
113 112
114 double Frequencystep1=10000.0, tbegin1=0.0, Frepbefore1=0.0, Frequency1=0.0; 113 double Frequencystep1=10000.0, tbegin1=0.0, Frepbefore1=0.0, Frequency1=0.0;
115 double Frequencystep2=10.0, tbegin2=0.0, Frepbefore2=0.0, Ch2before=0.0, Frequency2=0.0; 114 double Frequencystep2=10.0, tbegin2=0.0, Frepbefore2=0.0, Ch2before=0.0, Frequency2=0.0;
741 Slope_1 = stat_math1.slope; 740 Slope_1 = stat_math1.slope;
742 Ch4Slope = stat_ch4.slope; 741 Ch4Slope = stat_ch4.slope;
743 SetCtrlVal(CalcNPanel, CALCN_SLOPE, Slope_1); 742 SetCtrlVal(CalcNPanel, CALCN_SLOPE, Slope_1);
744 743
745 // frep positive step 744 // frep positive step
746 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1, FrequDDS1 + DeltakHz_1 * 1000.0, FREP_STEP_SIZE); 745 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 + DeltakHz_1 * 1000.0, FREP_STEP_SIZE);
747 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 + DeltakHz_1 * 1000.0); 746 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 + DeltakHz_1 * 1000.0);
748 747
749 // allow counter to settle 748 // allow counter to settle
750 settling = 3; 749 settling = 3;
751 750
761 if (settling > 0) { 760 if (settling > 0) {
762 settling--; 761 settling--;
763 break; 762 break;
764 } 763 }
765 764
766 double fDDS2; 765 double fDDS2 = DDS4xAD9912_GetFrequency(&DDS4xAD9912, 2);
767 GetCtrlVal(MainPanel, PANEL_DDS2, &fDDS2);
768 fDDS2 += 275000 - Ch4; 766 fDDS2 += 275000 - Ch4;
769 SetCtrlVal(MainPanel, PANEL_DDS2, fDDS2); 767 SetCtrlVal(MainPanel, PANEL_DDS2, fDDS2);
770 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 2, fDDS2); 768 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 2, fDDS2);
771 769
772 // allow counter to settle 770 // allow counter to settle
795 Frepplus_1 = Frepplus_1 / n_1; 793 Frepplus_1 = Frepplus_1 / n_1;
796 Ch4Plus = Ch4Plus / n_1; 794 Ch4Plus = Ch4Plus / n_1;
797 n_1 = 0; 795 n_1 = 0;
798 796
799 // frep negative step 797 // frep negative step
800 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 + DeltakHz_1 * 1000.0, FrequDDS1 - DeltakHz_1 * 1000.0, FREP_STEP_SIZE); 798 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 - DeltakHz_1 * 1000.0, FREP_STEP_SIZE);
801 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 - DeltakHz_1 * 1000.0); 799 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 - DeltakHz_1 * 1000.0);
802 800
803 // allow counter to settle 801 // allow counter to settle
804 settling = 3; 802 settling = 3;
805 803
837 t3_1 = 0.0; 835 t3_1 = 0.0;
838 Frepminus_1 = 0.0; 836 Frepminus_1 = 0.0;
839 Frepplus_1 = 0.0; 837 Frepplus_1 = 0.0;
840 838
841 // back to nominal frep 839 // back to nominal frep
842 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 - DeltakHz_1 * 1000.0, FrequDDS1, FREP_STEP_SIZE); 840 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1, FREP_STEP_SIZE);
843 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1); 841 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1);
844 SetCtrlVal(MainPanel, PANEL_DDS2, FrequencyDDSBesInit); 842 SetCtrlVal(MainPanel, PANEL_DDS2, FrequencyDDSBesInit);
845 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 2, FrequencyDDSBesInit); 843 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 2, FrequencyDDSBesInit);
846 844
847 // done 845 // done
888 SetCtrlVal(CalcNPanel, CALCN_SLOPE, Beatslope_2); 886 SetCtrlVal(CalcNPanel, CALCN_SLOPE, Beatslope_2);
889 887
890 // frep positive step 888 // frep positive step
891 double fDDS1 = FrequDDS1 + DeltakHz_2 * 1000; 889 double fDDS1 = FrequDDS1 + DeltakHz_2 * 1000;
892 printf("fDDS1 = %g\n", fDDS1); 890 printf("fDDS1 = %g\n", fDDS1);
893 DDS4xAD9912_RampFrequency(&DDS4xAD9912,1, FrequDDS1, fDDS1, FREP_STEP_SIZE); 891 DDS4xAD9912_RampFrequency(&DDS4xAD9912,1, fDDS1, FREP_STEP_SIZE);
894 SetCtrlVal(MainPanel, PANEL_DDS1, fDDS1); 892 SetCtrlVal(MainPanel, PANEL_DDS1, fDDS1);
895 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, fDDS1); 893 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, fDDS1);
896 894
897 // adjust DDS3 to keep beatnote within the bandpass filter. prediction 895 // adjust DDS3 to keep beatnote within the bandpass filter. prediction
898 double fDDS3 = FrequencyDDS3Init - DeltakHz_2*1000*(-Signe1/Signe2)*Ndiv*(Nu2)/(Nu1) - Beatslope_2*(utc-t1_2); 896 double fDDS3 = FrequencyDDS3Init - DeltakHz_2*1000*(-Signe1/Signe2)*Ndiv*(Nu2)/(Nu1) - Beatslope_2*(utc-t1_2);
954 Delta10K_Plus = Delta10K_Plus / n_2; 952 Delta10K_Plus = Delta10K_Plus / n_2;
955 n_2 = 0; 953 n_2 = 0;
956 954
957 // negative frequency step 955 // negative frequency step
958 double fDDS1 = FrequDDS1 - DeltakHz_2 * 1000; 956 double fDDS1 = FrequDDS1 - DeltakHz_2 * 1000;
959 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, DDS4xAD9912.Frequency1, fDDS1, FREP_STEP_SIZE); 957 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, fDDS1, FREP_STEP_SIZE);
960 SetCtrlVal(MainPanel, PANEL_DDS1, fDDS1); 958 SetCtrlVal(MainPanel, PANEL_DDS1, fDDS1);
961 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, fDDS1); 959 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, fDDS1);
962 960
963 // adjust DDS3 to keep beatnote within the bandpass filter. prediction 961 // adjust DDS3 to keep beatnote within the bandpass filter. prediction
964 double fDDS3 = FrequencyDDS3Init + DeltakHz_2*1000*(-Signe1/Signe2)*Ndiv*(Nu2)/(Nu1); 962 double fDDS3 = FrequencyDDS3Init + DeltakHz_2*1000*(-Signe1/Signe2)*Ndiv*(Nu2)/(Nu1);
984 982
985 if (t3_1 == 0.0) 983 if (t3_1 == 0.0)
986 t3_1 = utc; 984 t3_1 = utc;
987 985
988 Frepminus_2 = Frepminus_2 + Math1 + 250000000 - Slope_2 * (utc - t3_2); 986 Frepminus_2 = Frepminus_2 + Math1 + 250000000 - Slope_2 * (utc - t3_2);
989 Delta10K_Minus= Delta10K_Minus + 10000 - (Ch2 - Beatslope_2 * (utc - t3_2)); 987 Delta10K_Minus = Delta10K_Minus + 10000 - (Ch2 - Beatslope_2 * (utc - t3_2));
990 n_2 += 1; 988 n_2 += 1;
991 989
992 if ((utc -t3_2) > DeltaT_2) { 990 if ((utc -t3_2) > DeltaT_2) {
993 Frepminus_2 = Frepminus_2 / n_2; 991 Frepminus_2 = Frepminus_2 / n_2;
994 Delta10K_Minus = Delta10K_Minus / n_2; 992 Delta10K_Minus = Delta10K_Minus / n_2;
997 // compute N2 995 // compute N2
998 N_2 = (Signe2)*(-DeltaDDS3+Delta10K_Plus-Delta10K_Minus-Beatslope_2*(t3_2-t2_2) )/(Frepminus_2-Frepplus_2-Slope_2*(t3_2-t2_2)); 996 N_2 = (Signe2)*(-DeltaDDS3+Delta10K_Plus-Delta10K_Minus-Beatslope_2*(t3_2-t2_2) )/(Frepminus_2-Frepplus_2-Slope_2*(t3_2-t2_2));
999 SetCtrlVal(CalcNPanel, CALCN_N, N_2); 997 SetCtrlVal(CalcNPanel, CALCN_N, N_2);
1000 998
1001 // back to nominal frequency 999 // back to nominal frequency
1002 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1-DeltakHz_2*1000,FrequDDS1, FREP_STEP_SIZE); 1000 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1, FREP_STEP_SIZE);
1003 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1); 1001 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1);
1004 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, FrequDDS1); 1002 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, FrequDDS1);
1005 SetCtrlVal(MainPanel, PANEL_DDS2, FrequencyDDSBesInit); 1003 SetCtrlVal(MainPanel, PANEL_DDS2, FrequencyDDSBesInit);
1006 DDS4xAD9912_SetFrequency (&DDS4xAD9912, 2, FrequencyDDSBesInit ); 1004 DDS4xAD9912_SetFrequency (&DDS4xAD9912, 2, FrequencyDDSBesInit);
1007 SetCtrlVal(MainPanel, PANEL_DDS3, FrequencyDDS3Init-Beatslope_2*(utc-t1_2)); 1005 SetCtrlVal(MainPanel, PANEL_DDS3, FrequencyDDS3Init-Beatslope_2*(utc-t1_2));
1008 DDS4xAD9912_SetFrequency (&DDS4xAD9912, 3, FrequencyDDS3Init-Beatslope_2*(utc-t1_2) ); 1006 DDS4xAD9912_SetFrequency (&DDS4xAD9912, 3, FrequencyDDS3Init-Beatslope_2*(utc-t1_2) );
1009 1007
1010 t1_2 = 0.0; 1008 t1_2 = 0.0;
1011 t2_2 = 0.0; 1009 t2_2 = 0.0;
1033 SetCtrlVal(MainPanel, 1, FrequDDS1); 1031 SetCtrlVal(MainPanel, 1, FrequDDS1);
1034 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, FrequDDS1); 1032 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 1, FrequDDS1);
1035 settling = 3; 1033 settling = 3;
1036 1034
1037 t1_3 = utc; 1035 t1_3 = utc;
1038 stat_zero(&stat_ch2); 1036 stat_zero(&stat_math1);
1039 stat_zero(&stat_ch3);
1040 f_rep_plus = f_rep_minus = 0.0; 1037 f_rep_plus = f_rep_minus = 0.0;
1041 f_beat_Sr_plus = f_beat_Sr_minus = 0.0; 1038 f_beat_Sr_plus = f_beat_Sr_minus = 0.0;
1042 1039
1043 // record current DDS3 frequency 1040 // record current DDS frequencies
1044 GetCtrlVal(MainPanel, PANEL_DDS3, &FrequencyDDS3Init); 1041 FrequencyDDSBesInit = DDS4xAD9912.Frequency2;
1042 FrequencyDDS3Init = DDS4xAD9912.Frequency3;
1045 1043
1046 // next step 1044 // next step
1047 Measuring_3 += 1; 1045 Measuring_3 += 1;
1048 break; 1046 break;
1049 1047
1053 if (settling > 0) { 1051 if (settling > 0) {
1054 settling--; 1052 settling--;
1055 break; 1053 break;
1056 } 1054 }
1057 1055
1058 stat_accumulate(&stat_ch2, Ch2); 1056 stat_accumulate(&stat_math1, Math1);
1059 stat_accumulate(&stat_ch3, Ch3);
1060 1057
1061 if (utc - t1_3 > SlopeTime3) { 1058 if (utc - t1_3 > SlopeTime3) {
1062 // slope measurement 1059 // slope measurement
1063 Slope_3 = stat_ch2.slope; 1060 f_rep_slope = stat_math1.slope;
1064 1061
1065 t2_3 = utc; 1062 t2_3 = utc;
1066 stat_zero(&stat_ch2);
1067 stat_zero(&stat_ch3);
1068 1063
1069 // frep positive step 1064 // frep positive step
1070 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 + DeltakHz_3 * 1000); 1065 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 + DeltakHz_3 * 1000);
1071 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1, FrequDDS1 + DeltakHz_3 * 1000, FREP_STEP_SIZE); 1066 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 + DeltakHz_3 * 1000, FREP_STEP_SIZE);
1072 // compensate with DDS3 to keep measured beatnote in counter box range 1067 // compensate with DDS3 to keep measured beatnote in counter box range
1073 double fDDS3 = FrequencyDDS3Init + Signe1 * Signe3 * N3/N1 * Ndiv * DeltakHz_3 * 1000; 1068 double fDDS3 = FrequencyDDS3Init + Signe1 * Signe3 * N3/N1 * Ndiv * DeltakHz_3 * 1000;
1074 SetCtrlVal(MainPanel, PANEL_DDS3, fDDS3); 1069 SetCtrlVal(MainPanel, PANEL_DDS3, fDDS3);
1075 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 3, fDDS3); 1070 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 3, fDDS3);
1076 1071
1110 settling--; 1105 settling--;
1111 break; 1106 break;
1112 } 1107 }
1113 1108
1114 n_3++; 1109 n_3++;
1115 f_rep_plus += Math1 + 250000000 - Slope_3 * (utc - t3_2); 1110 f_rep_plus += Math1 + 250000000 - f_rep_slope * (utc - t3_2);
1116 f_beat_Sr_plus += Ch3; 1111 f_beat_Sr_plus += Ch3;
1117 1112
1118 if (utc - t2_3 > DeltaT_3) { 1113 if (utc - t2_3 > DeltaT_3) {
1119 // positive step measurement 1114 // positive step measurement
1120 f_rep_plus = f_rep_plus / n_3; 1115 f_rep_plus = f_rep_plus / n_3;
1123 n_3 = 0; 1118 n_3 = 0;
1124 t3_3 = utc; 1119 t3_3 = utc;
1125 1120
1126 // frep negative step 1121 // frep negative step
1127 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 - DeltakHz_3 * 1000); 1122 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1 - DeltakHz_3 * 1000);
1128 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 + DeltakHz_3 * 1000, FrequDDS1 - DeltakHz_3 * 1000, FREP_STEP_SIZE); 1123 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 - DeltakHz_3 * 1000, FREP_STEP_SIZE);
1129 // compensate with DDS3 to keep measured beatnote in counter box range 1124 // compensate with DDS3 to keep measured beatnote in counter box range
1130 double fDDS3 = FrequencyDDS3Init - Signe1 * Signe3 * N3/N1 * Ndiv * DeltakHz_3 * 1000; 1125 double fDDS3 = FrequencyDDS3Init - Signe1 * Signe3 * N3/N1 * Ndiv * DeltakHz_3 * 1000;
1131 SetCtrlVal(MainPanel, PANEL_DDS3, fDDS3); 1126 SetCtrlVal(MainPanel, PANEL_DDS3, fDDS3);
1132 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 3, fDDS3); 1127 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 3, fDDS3);
1133 1128
1136 1131
1137 // next step 1132 // next step
1138 Measuring_3 += 1; 1133 Measuring_3 += 1;
1139 } 1134 }
1140 break; 1135 break;
1141 1136
1142
1143 case N_MEASUREMENT_FREP_MINUS: 1137 case N_MEASUREMENT_FREP_MINUS:
1144 // frep negative step 1138 // frep negative step
1145 1139
1146 if (settling > 0) { 1140 if (settling > 0) {
1147 settling--; 1141 settling--;
1148 break; 1142 break;
1149 } 1143 }
1150 1144
1151 n_3++; 1145 n_3++;
1152 f_rep_minus += Math1 + 250000000 - Slope_3 * (utc - t3_2); 1146 f_rep_minus += Math1 + 250000000 - f_rep_slope * (utc - t3_2);
1153 f_beat_Sr_minus += Ch3; 1147 f_beat_Sr_minus += Ch3;
1154 1148
1155 if (utc - t3_3 > DeltaT_3) { 1149 if (utc - t3_3 > DeltaT_3) {
1156 // negative step measurement 1150 // negative step measurement
1157 f_rep_minus = f_rep_minus / n_3; 1151 f_rep_minus = f_rep_minus / n_3;
1158 f_beat_Sr_minus = f_beat_Sr_plus / n_3; 1152 f_beat_Sr_minus = f_beat_Sr_minus / n_3;
1159 1153
1160 // check delta frep 1154 // check delta frep
1161 double delta_f_rep = f_rep_plus - f_rep_minus; 1155 double delta_f_rep_m = f_rep_plus - f_rep_minus;
1162 double expected = Ndiv * 2.0 * DeltakHz_3 * 1000.0 / N1; 1156 double delta_f_rep = Ndiv * 2.0 * DeltakHz_3 * 1000.0 / N1;
1163 logmsg("delta frep=%g Hz expected=%g Hz", delta_f_rep, expected); 1157 logmsg("delta frep: measured=%.12e Hz expected=%.12e Hz difference=%.12e",
1158 delta_f_rep_m, delta_f_rep, delta_f_rep_m - delta_f_rep);
1159
1160 logmsg("f_beat_Sr_minus=%.12e", f_beat_Sr_minus);
1161 logmsg("f_beat_Sr_plus =%.12e", f_beat_Sr_plus);
1164 1162
1165 // compute N3 1163 // compute N3
1166 double delta_f_beat_Sr = f_beat_Sr_plus - f_beat_Sr_minus + 2.0 * N3/N1 * Ndiv * DeltakHz_3 * 1000; 1164 double delta_f_beat_Sr = f_beat_Sr_plus - f_beat_Sr_minus + 2.0 * Signe1 * Signe3 * N3/N1 * Ndiv * DeltakHz_3 * 1000;
1167 logmsg("delta fbeat=%g", delta_f_beat_Sr); 1165 double delta_f_beat_Sr_expected = delta_f_rep * N3;
1166 logmsg("delta fbeat: measured=%.12e expected=%.12e", delta_f_beat_Sr, delta_f_beat_Sr_expected);
1168 N_3 = delta_f_beat_Sr / delta_f_rep; 1167 N_3 = delta_f_beat_Sr / delta_f_rep;
1168 logmsg("measured N3=%.3f", N_3);
1169 SetCtrlVal(CalcNPanel, CALCN_N, N_3); 1169 SetCtrlVal(CalcNPanel, CALCN_N, N_3);
1170 1170
1171 t1_3=0.0; 1171 t1_3=0.0;
1172 t2_3=0.0; 1172 t2_3=0.0;
1173 t3_3=0.0; 1173 t3_3=0.0;
1174 n_3 = 0; 1174 n_3 = 0;
1175 1175
1176 // back to nominal frep 1176 // back to nominal frep
1177 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1); 1177 SetCtrlVal(MainPanel, PANEL_DDS1, FrequDDS1);
1178 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1 - DeltakHz_3 * 1000, FrequDDS1, FREP_STEP_SIZE); 1178 DDS4xAD9912_RampFrequency(&DDS4xAD9912, 1, FrequDDS1, FREP_STEP_SIZE);
1179 // back to initial DDS3 frequency 1179 // back to initial DDS3 frequency
1180 SetCtrlVal(MainPanel, PANEL_DDS3, FrequencyDDS3Init); 1180 SetCtrlVal(MainPanel, PANEL_DDS3, FrequencyDDS3Init);
1181 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 3, FrequencyDDS3Init); 1181 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 3, FrequencyDDS3Init);
1182 // adjust DDS frequency to keep 55 MHz tracker oscillator locked 1182 // back to initial DDS2 frequency
1183 double fDDS2 = DDS4xAD9912.Frequency2 + 275000 - Ch4; 1183 SetCtrlVal(MainPanel, PANEL_DDS2, FrequencyDDSBesInit);
1184 SetCtrlVal(MainPanel, PANEL_DDS2, fDDS2); 1184 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 2, FrequencyDDSBesInit);
1185 DDS4xAD9912_SetFrequency(&DDS4xAD9912, 2, fDDS2);
1186 1185
1187 // done 1186 // done
1188 Measuring_3 = N_MEASUREMENT_NONE; 1187 Measuring_3 = N_MEASUREMENT_NONE;
1189 } 1188 }
1190 break; 1189 break;
2124 // set current frep 2123 // set current frep
2125 SetCtrlVal(EstimateN3Panel, ESTIMATEN3_FREP, 250e6 + Math1); 2124 SetCtrlVal(EstimateN3Panel, ESTIMATEN3_FREP, 250e6 + Math1);
2126 // default wavelenght for Sr cavity 2125 // default wavelenght for Sr cavity
2127 GetCtrlVal(EstimateN3Panel, ESTIMATEN3_WAVELENGTH, &wl); 2126 GetCtrlVal(EstimateN3Panel, ESTIMATEN3_WAVELENGTH, &wl);
2128 if (wl == 0.0) 2127 if (wl == 0.0)
2129 SetCtrlVal(EstimateN3Panel, ESTIMATEN3_WAVELENGTH, 698.50); 2128 SetCtrlVal(EstimateN3Panel, ESTIMATEN3_WAVELENGTH, 698.446);
2130 // reset N3 estimate 2129 // reset N3 estimate
2131 SetCtrlVal(EstimateN3Panel, ESTIMATEN3_N, 0.0); 2130 SetCtrlVal(EstimateN3Panel, ESTIMATEN3_N, 0.0);
2132 break; 2131 break;
2133 } 2132 }
2134 break; 2133 break;