aqgrego meds del finde

analisis/plots/20230510_MotionalSpectrum/DataElectricNew/Ion centro costado/metadata04.txt

+Meta data file
+CameraModel ZYLA-4.2P-USB3
+PixelEncoding Mono12
+SerialNumber VSC-07693
+ExposureTime 0.400008
+SensorWidth 2048
+SensorHeight 2048
+PicWidth 2048
+PicHeight 2048
+AOIBinning 1x1
+SensorTemp -0.4399999999999977
+TemperatureStatus Stabilised
+FrameRate 2.354714240382922
+AccumulateCount None
+ShutteringMode Rolling
+FanSpeed On
+CycleMode Continuous
+PixelReadoutRate 100 MHz
+SimplePreAmpGainControl 12-bit (high well capacity)
+SpuriousNoiseFilter False
+ImageSizeBytes 8388608
+Date 2023-05-19
+Time 10:07:18
+TimeAbsolute 1684501638.9876375
+
+gui params 0
+start 750000.0
+end 830000.0
+steps 301
+directory /home/liaf-ankylosaurus-admin/Documents/Rigol_TCA/total_control_app/resources/
+comment 1 ion radaial 1 centro
+piezoA397 0.0
+piezoB397 0.8134062
+piezoA866 0.0
+piezoB866 1.74
+piezo423 5.9
+dcA -0.08
+dcB 0.27
+compC 0.0
+compD 3.1
+compOven 3.4
+compExYb 0.0
+Roi Pos Point(-960.307061, 989.450080)
+Roi Size Point(4.511002, 5.722516)
+Amplitude 7.500000E+00
+Offset 0.000000E+00

artiq_master/last_rid.pyon

-11791
+12094

artiq_master/repository/Calibrations/Power Calibration AOM/IR/IR_Power_calibration_BS_rpi.py

@@ -31,7 +31,7 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
                                         global_min = 1*MHz,
                                         global_max = 400*MHz
                                        )
-                             )        
+                             )
 
 
     @rpc
@@ -60,21 +60,21 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
         mid_amplitude = round(0.5*(initial_amplitude+final_amplitude), 4)
         #print(f'mid_amplitude: {mid_amplitude}')
         if abs(initial_amplitude - mid_amplitude) < 0.00001 or abs(final_amplitude - mid_amplitude) < 0.00001:
-            #print('toco un borde jejox')            
+            #print('toco un borde jejox')
             return mid_amplitude
         #else:
         if mid_amplitude > self.Max_amplitude or mid_amplitude < self.Min_amplitude:
             print('Pusiste al reves los limites')
             raise
         self.change_frequency(current_freq, mid_amplitude)
-        #self.measure_PD(dump=True)   
+        #self.measure_PD(dump=True)
         self.measure_PD()
         measured_PD = self.get_dataset("Current_PD_IR")[0]
         if np.abs(measured_PD - pd_value) > 0.00005:
-            if measured_PD > pd_value:        
-                return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq) 
+            if measured_PD > pd_value:
+                return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq)
             elif measured_PD < pd_value:
-                return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)                 
+                return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)
             else:
                 #print('no se, fijate, paso algo')
                 return 0
@@ -83,12 +83,12 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
 
 
     @rpc(flags={"async"})
-    def measure_PD(self, dump=False):
+    def measure_PD(self, dump=False): #este dump esta al pedo, habra que sacarlo en el futuro
         value = rpi.ReadPD_average_pi(0, 1)
         print(value)
         if not dump:
             self.mutate_dataset(f"Current_PD_IR", 0, np.abs(value))
-        
+
 
     @kernel
     def init_kernel(self):
@@ -113,7 +113,7 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
         self.laserIR.set_frequency(freq, amp)
         delay(50*ms)
 
-       
+
     def run(self):
         self.create_datasets()
         self.create_applets()
@@ -125,7 +125,7 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
         initial_amplitude = self.Min_amplitude
         final_amplitude = self.Max_amplitude
 
-        initial_PD = self.Target_PD_Value                
+        initial_PD = self.Target_PD_Value
 
         for freq in self.Calibration_freqs_IR.sequence:
             self.change_frequency(freq, initial_amplitude)
@@ -136,7 +136,3 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
             #initial_amplitude = calibrated_amplitude-0.1
             #final_amplitude = calibrated_amplitude+0.1
             i = i + 1
-
-
-
-

artiq_master/repository/Calibrations/Power Calibration AOM/IR/IR_Power_calibration_BS_rpi_multiple.py

+import numpy as np
+from time import sleep
+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from pyLIAF.RedPitaya import Read_analog as rp
+from pyLIAF.RaspberryPi.PD_reader import PDreader as rpi
+from scipy import interpolate
+
+class IR_LaserPowerCalibration_BS(EnvExperiment):
+    """Multiple powers - Binary search - IR Laser power calibration with photodiode and a raspberry pi """
+
+    def build(self):
+        self.setattr_device("ccb")
+        self.setattr_device("scheduler")
+        self.setattr_device("core")
+
+        self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.3, name="IR") #corresponde a 0.7 Vpp
+
+        self.setattr_argument("Target_PD_Value", NumberValue(0.4, min=0.01, max=3), "Calibration_parameters")
+
+        self.setattr_argument("Max_amplitude", NumberValue(0.30, min=0.01, max=0.35), "Calibration_parameters")
+        self.setattr_argument("Min_amplitude", NumberValue(0.01, min=0.01, max=0.35), "Calibration_parameters")
+
+        #self.setattr_argument("tolerance", NumberValue(0.005, max=0.5), "Calibration_parameters")
+
+
+        self.setattr_argument("Calibration_freqs_IR", Scannable(
+                                        default=CenterScan(208*MHz, 10*MHz, 0.1*MHz),
+                                        unit="MHz",
+                                        scale=MHz,
+                                        global_min = 1*MHz,
+                                        global_max = 400*MHz
+                                       )
+                             )
+
+
+    @rpc
+    def create_datasets(self):
+        #self.set_dataset("PD_UV_counts", list(np.zeros(len(self.Calibration_freqs.sequence)*len(self.Calibration_amps.sequence), dtype=int)), broadcast=True, archive=True)
+
+        self.set_dataset("Current_PD_IR", np.array([0.05]), broadcast=True, archive=False)
+        self.set_dataset("Calibration_freqs", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
+
+        self.set_dataset("Experiment_freqs_IR", self.Calibration_freqs_IR.sequence, broadcast=True, archive=True)
+        self.set_dataset("Experiment_amps_IR", np.zeros(len(self.Calibration_freqs_IR.sequence), dtype=float), broadcast=True, archive=True)
+
+
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "IR_powercalibration_BS",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "Experiment_amps_IR "
+                        "--x Calibration_freqs")
+
+
+    @rpc(flags={"async"})
+    def Binary_Search(self, pd_value, initial_amplitude, final_amplitude, current_freq):
+        mid_amplitude = round(0.5*(initial_amplitude+final_amplitude), 4)
+        #print(f'mid_amplitude: {mid_amplitude}')
+        if abs(initial_amplitude - mid_amplitude) < 0.00001 or abs(final_amplitude - mid_amplitude) < 0.00001:
+            #print('toco un borde jejox')
+            return mid_amplitude
+        #else:
+        if mid_amplitude > self.Max_amplitude or mid_amplitude < self.Min_amplitude:
+            print('Pusiste al reves los limites')
+            raise
+        self.change_frequency(current_freq, mid_amplitude)
+        #self.measure_PD(dump=True)
+        self.measure_PD()
+        measured_PD = self.get_dataset("Current_PD_IR")[0]
+        if np.abs(measured_PD - pd_value) > 0.00005:
+            if measured_PD > pd_value:
+                return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq)
+            elif measured_PD < pd_value:
+                return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)
+            else:
+                #print('no se, fijate, paso algo')
+                return 0
+        else:
+            return mid_amplitude
+
+
+    @rpc(flags={"async"})
+    def measure_PD(self, dump=False): #este dump esta al pedo, habra que sacarlo en el futuro
+        value = rpi.ReadPD_average_pi(0, 1)
+        print(value)
+        if not dump:
+            self.mutate_dataset(f"Current_PD_IR", 0, np.abs(value))
+
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        delay(1*ms)
+        self.core.break_realtime()
+        #self.laserIR.initialize_channel()
+
+        delay(100*us)
+
+        self.laserIR.set_channel()
+
+        self.core.wait_until_mu(now_mu())
+
+        delay(1*ms)
+        self.laserIR.on()
+
+    @kernel
+    def change_frequency(self, freq, amp):
+        self.core.break_realtime()
+        delay(50*ms)
+        self.laserIR.set_frequency(freq, amp)
+        delay(50*ms)
+
+
+    def run(self):
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        i = 0
+
+        self.measure_PD(dump=True)
+
+        initial_amplitude = self.Min_amplitude
+        final_amplitude = self.Max_amplitude
+
+        initial_PD = self.Target_PD_Value
+
+        for freq in self.Calibration_freqs_IR.sequence:
+            self.change_frequency(freq, initial_amplitude)
+            #self.measure_PD(dump=True)
+            calibrated_amplitude = self.Binary_Search(initial_PD, initial_amplitude, final_amplitude, freq)
+            print(f'Done freq {freq}')
+            self.mutate_dataset("Experiment_amps_IR", i, calibrated_amplitude)
+            #initial_amplitude = calibrated_amplitude-0.1
+            #final_amplitude = calibrated_amplitude+0.1
+            i = i + 1

artiq_master/repository/Calibrations/Power Calibration AOM/IR/IR_Power_calibration_BS.py → artiq_master/repository/Calibrations/Power Calibration AOM/IR/old/IR_Power_calibration_BS.py

@@ -6,7 +6,7 @@ from pyLIAF.RedPitaya import Read_analog as rp
 from scipy import interpolate
 
 class IR_LaserPowerCalibration_BS(EnvExperiment):
-    """Binary search - IR Laser power calibration with photodiode and a red pitaya """
+    """ESTE NO ES - Binary search - IR Laser power calibration with photodiode and a red pitaya """
 
     def build(self):
         self.setattr_device("ccb")
@@ -30,7 +30,7 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
                                         global_min = 1*MHz,
                                         global_max = 400*MHz
                                        )
-                             )        
+                             )
 
 
     @rpc
@@ -58,20 +58,20 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
         mid_amplitude = round(0.5*(initial_amplitude+final_amplitude), 4)
         print(f'mid_amplitude: {mid_amplitude}')
         if abs(initial_amplitude - mid_amplitude) < 0.00001 or abs(final_amplitude - mid_amplitude) < 0.00001:
-            print('toco un borde jejox')            
+            print('toco un borde jejox')
             return mid_amplitude
         #else:
         if mid_amplitude > self.Max_amplitude or mid_amplitude < self.Min_amplitude:
             raise
         self.change_frequency(current_freq, mid_amplitude)
-        self.measure_PD(dump=True)   
+        self.measure_PD(dump=True)
         self.measure_PD()
         measured_PD = self.get_dataset("Current_PD_IR")[0]
         if np.abs(measured_PD - pd_value) > 0.00005:
-            if measured_PD > pd_value:        
-                return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq) 
+            if measured_PD > pd_value:
+                return self.Binary_Search(pd_value, initial_amplitude, mid_amplitude, current_freq)
             elif measured_PD < pd_value:
-                return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)                 
+                return self.Binary_Search(pd_value, mid_amplitude, final_amplitude, current_freq)
             else:
                 print('no se, fijate, paso algo')
                 return 0
@@ -88,7 +88,7 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
         print(value)
         if not dump:
             self.mutate_dataset(f"Current_PD_IR", 0, np.abs(value))
-        
+
 
     @kernel
     def init_kernel(self):
@@ -113,7 +113,7 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
         self.laserIR.set_frequency(freq, amp)
         delay(50*ms)
 
-       
+
     def run(self):
         self.create_datasets()
         self.create_applets()
@@ -126,7 +126,7 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
         initial_amplitude = self.Min_amplitude
         final_amplitude = self.Max_amplitude
 
-        initial_PD = self.Target_PD_Value                
+        initial_PD = self.Target_PD_Value
 
         for freq in self.Calibration_freqs_IR.sequence:
             self.change_frequency(freq, initial_amplitude)
@@ -137,7 +137,3 @@ class IR_LaserPowerCalibration_BS(EnvExperiment):
             #initial_amplitude = calibrated_amplitude-0.1
             #final_amplitude = calibrated_amplitude+0.1
             i = i + 1
-
-
-
-