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

analisis/plots/20230510_MotionalSpectrum/DataElectricNew/Ion centro costado/sscostado.dat

+Time frequency Roi data 
+1.684501639729290247e+09 7.500000000000000000e+05 1.057962322627156198e+02
+1.684501640240523100e+09 7.502666999999999534e+05 1.056358449101276733e+02
+1.684501640743400335e+09 7.505333000000000466e+05 1.051597381435489922e+02
+1.684501641255287647e+09 7.508000000000000000e+05 1.054144111151188099e+02
+1.684501641758347988e+09 7.510666999999999534e+05 1.056630985046349309e+02
+1.684501642261260271e+09 7.513333000000000466e+05 1.059665944081455251e+02
+1.684501642763063192e+09 7.516000000000000000e+05 1.060698469696651500e+02
+1.684501643273214817e+09 7.518666999999999534e+05 1.054307631507700904e+02
+1.684501643776178360e+09 7.521333000000000466e+05 1.059618820145220894e+02
+1.684501644289127350e+09 7.524000000000000000e+05 1.052702804690939615e+02
+1.684501644794743776e+09 7.526666999999999534e+05 1.056775823921798718e+02
+1.684501645296723366e+09 7.529333000000000466e+05 1.058741912912485788e+02
+1.684501645802136898e+09 7.532000000000000000e+05 1.054713625028461763e+02
+1.684501646323873758e+09 7.534666999999999534e+05 1.059016812439564035e+02
+1.684501646831197500e+09 7.537333000000000466e+05 1.055809957817394320e+02
+1.684501647341693640e+09 7.540000000000000000e+05 1.057627870536329624e+02
+1.684501647862028599e+09 7.542666999999999534e+05 1.061107591322073063e+02
+1.684501648366507769e+09 7.545333000000000466e+05 1.053471360976418225e+02
+1.684501648956963062e+09 7.548000000000000000e+05 1.058681416394489787e+02
+1.684501649461413622e+09 7.550666999999999534e+05 1.057293445747148724e+02
+1.684501649973096848e+09 7.553333000000000466e+05 1.055619875391527529e+02
+1.684501650475609779e+09 7.556000000000000000e+05 1.059287984533500691e+02
+1.684501650977217436e+09 7.558666999999999534e+05 1.060156207336121099e+02
+1.684501651478737354e+09 7.561333000000000466e+05 1.058320827031614471e+02
+1.684501651987373590e+09 7.564000000000000000e+05 1.058334080263687298e+02
+1.684501652490891695e+09 7.566666999999999534e+05 1.059402203715675626e+02
+1.684501653001297474e+09 7.569333000000000466e+05 1.056532808181053014e+02
+1.684501653506118298e+09 7.572000000000000000e+05 1.058094932320671830e+02
+1.684501654011878490e+09 7.574666999999999534e+05 1.053757109904070148e+02
+1.684501654514950037e+09 7.577333000000000466e+05 1.058101558244294722e+02
+1.684501655027047157e+09 7.580000000000000000e+05 1.057501084750339828e+02
+1.684501655531497002e+09 7.582666999999999534e+05 1.054632082943388127e+02
+1.684501656046223402e+09 7.585333000000000466e+05 1.056960832427985224e+02
+1.684501656550313234e+09 7.588000000000000000e+05 1.057633559308540043e+02
+1.684501657061682701e+09 7.590665999999999767e+05 1.056744140315921214e+02
+1.684501657569905519e+09 7.593333000000000466e+05 1.057313883054121249e+02
+1.684501658073472500e+09 7.596000000000000000e+05 1.054661628758858853e+02
+1.684501658586979628e+09 7.598665999999999767e+05 1.055505596745855001e+02
+1.684501659090919495e+09 7.601333000000000466e+05 1.056806981722646128e+02
+1.684501659598078728e+09 7.604000000000000000e+05 1.054702241310691022e+02
+1.684501660106486082e+09 7.606665999999999767e+05 1.054449221066358291e+02
+1.684501660614853382e+09 7.609333000000000466e+05 1.051018385869548695e+02
+1.684501661122471333e+09 7.612000000000000000e+05 1.058244667433406789e+02
+1.684501661629243851e+09 7.614665999999999767e+05 1.053535845892344156e+02
+1.684501662155399323e+09 7.617333000000000466e+05 1.057888688737147334e+02
+1.684501662660742998e+09 7.620000000000000000e+05 1.055246232443015941e+02
+1.684501663164952517e+09 7.622665999999999767e+05 1.060469247212179056e+02
+1.684501663675855637e+09 7.625333000000000466e+05 1.055453238898710566e+02
+1.684501664178664923e+09 7.628000000000000000e+05 1.055598603066664651e+02
+1.684501664698883057e+09 7.630665999999999767e+05 1.054188539206375594e+02
+1.684501665202533722e+09 7.633333000000000466e+05 1.052575496960261319e+02
+1.684501665719206095e+09 7.636000000000000000e+05 1.055315309848485157e+02
+1.684501666223351002e+09 7.638665999999999767e+05 1.056605702708680212e+02
+1.684501666724290848e+09 7.641333000000000466e+05 1.058114388491267590e+02
+1.684501667225528240e+09 7.644000000000000000e+05 1.056964602282512544e+02
+1.684501667727974176e+09 7.646665999999999767e+05 1.054981135686371658e+02
+1.684501668233735085e+09 7.649333000000000466e+05 1.060160295046568422e+02
+1.684501668739785910e+09 7.652000000000000000e+05 1.058987659152363392e+02
+1.684501669241633177e+09 7.654665999999999767e+05 1.055931216476991352e+02
+1.684501669741793633e+09 7.657333000000000466e+05 1.055994981710391301e+02
+1.684501670245151758e+09 7.660000000000000000e+05 1.057444113806882910e+02
+1.684501670746149778e+09 7.662665999999999767e+05 1.060330102537597838e+02
+1.684501671257243156e+09 7.665333000000000466e+05 1.058255979398891640e+02
+1.684501671759479523e+09 7.667999000000000233e+05 1.058975271268376162e+02
+1.684501672270390034e+09 7.670665999999999767e+05 1.056975010557708146e+02
+1.684501672772568226e+09 7.673333000000000466e+05 1.059699356252284019e+02
+1.684501673273460627e+09 7.675999000000000233e+05 1.055532005359679175e+02
+1.684501673775414467e+09 7.678665999999999767e+05 1.055471865717028237e+02
+1.684501674279220581e+09 7.681334000000000233e+05 1.055477635933051346e+02
+1.684501674780410528e+09 7.684000000000000000e+05 1.054534330462505380e+02
+1.684501675284853697e+09 7.686666999999999534e+05 1.053065448734569429e+02
+1.684501675788726091e+09 7.689334000000000233e+05 1.050739914357521343e+02
+1.684501676311673641e+09 7.692000000000000000e+05 1.059704983982465762e+02
+1.684501676818765163e+09 7.694666999999999534e+05 1.055112776801950361e+02
+1.684501677325134516e+09 7.697334000000000233e+05 1.056964654293280006e+02
+1.684501677826064825e+09 7.700000000000000000e+05 1.058494438113853136e+02
+1.684501678339076042e+09 7.702666999999999534e+05 1.059458460287933406e+02
+1.684501678845904112e+09 7.705334000000000233e+05 1.059088124193833096e+02
+1.684501679358922005e+09 7.708000000000000000e+05 1.058764809913594291e+02
+1.684501679865512848e+09 7.710666999999999534e+05 1.052745328991864682e+02
+1.684501680379861355e+09 7.713334000000000233e+05 1.058466674946519959e+02
+1.684501680891193628e+09 7.716000000000000000e+05 1.061153607273604820e+02
+1.684501681397329807e+09 7.718666999999999534e+05 1.057044732769883382e+02
+1.684501681918127298e+09 7.721334000000000233e+05 1.057473343760910751e+02
+1.684501682427760363e+09 7.724000000000000000e+05 1.061307659673771724e+02
+1.684501682932178497e+09 7.726666999999999534e+05 1.054160506436689815e+02
+1.684501683433796644e+09 7.729334000000000233e+05 1.059239284739493456e+02
+1.684501683945353746e+09 7.732000000000000000e+05 1.059747773080104594e+02
+1.684501684447279215e+09 7.734666999999999534e+05 1.060052879250608697e+02
+1.684501684951122761e+09 7.737334000000000233e+05 1.054222653318642386e+02
+1.684501685452907085e+09 7.740000000000000000e+05 1.057917664763205750e+02
+1.684501685966594934e+09 7.742666999999999534e+05 1.050595419423648451e+02
+1.684501686471085787e+09 7.745334000000000233e+05 1.059358652943644898e+02
+1.684501686971700668e+09 7.748000000000000000e+05 1.052708638795575524e+02
+1.684501687482766390e+09 7.750666999999999534e+05 1.055810071624329538e+02
+1.684501688008466482e+09 7.753334000000000233e+05 1.051393730159725237e+02
+1.684501688523342133e+09 7.756000000000000000e+05 1.056385105202694632e+02
+1.684501689027891636e+09 7.758666999999999534e+05 1.058416382004984797e+02
+1.684501689533393860e+09 7.761333000000000466e+05 1.051385989498045745e+02
+1.684501690040616035e+09 7.764000000000000000e+05 1.053140287871225809e+02
+1.684501690545718193e+09 7.766666999999999534e+05 1.050281776879711799e+02
+1.684501691046734095e+09 7.769333000000000466e+05 1.052806927296723529e+02
+1.684501691555079699e+09 7.772000000000000000e+05 1.046663747434706551e+02
+1.684501692060579777e+09 7.774666999999999534e+05 1.053679573444642443e+02
+1.684501692578980446e+09 7.777333000000000466e+05 1.054489206140365951e+02
+1.684501693082375050e+09 7.780000000000000000e+05 1.054866635950457834e+02
+1.684501693584363461e+09 7.782666999999999534e+05 1.055168444065446636e+02
+1.684501694094769716e+09 7.785333000000000466e+05 1.056003199343430623e+02
+1.684501694603845596e+09 7.788000000000000000e+05 1.051446001337750857e+02
+1.684501695126619816e+09 7.790666999999999534e+05 1.050904267732263548e+02
+1.684501695643915176e+09 7.793333000000000466e+05 1.052974659800009363e+02
+1.684501696157111883e+09 7.796000000000000000e+05 1.053248815772630564e+02
+1.684501696660631657e+09 7.798666999999999534e+05 1.052062417983436831e+02
+1.684501697169892311e+09 7.801333000000000466e+05 1.048983900628870600e+02
+1.684501697672113180e+09 7.804000000000000000e+05 1.043370635447581094e+02
+1.684501698171932936e+09 7.806666999999999534e+05 1.050875657177795262e+02
+1.684501698672964334e+09 7.809333000000000466e+05 1.045735929894800762e+02
+1.684501699173612356e+09 7.812000000000000000e+05 1.041673336828976772e+02
+1.684501699674838543e+09 7.814666999999999534e+05 1.042785434783587277e+02
+1.684501700176228046e+09 7.817333000000000466e+05 1.046413431339242663e+02
+1.684501700691556931e+09 7.820000000000000000e+05 1.038696655263029527e+02
+1.684501701208663464e+09 7.822666999999999534e+05 1.038359031266747081e+02
+1.684501701722482443e+09 7.825333000000000466e+05 1.035350120675553001e+02
+1.684501702236111641e+09 7.828000000000000000e+05 1.029183922392565762e+02
+1.684501702743361712e+09 7.830666999999999534e+05 1.028257973453028740e+02
+1.684501703248235703e+09 7.833333000000000466e+05 1.022953503724312725e+02
+1.684501703773160934e+09 7.836000000000000000e+05 1.015602103635531819e+02
+1.684501704286607265e+09 7.838666999999999534e+05 1.018395704271373603e+02
+1.684501704792518377e+09 7.841333000000000466e+05 1.013956089113853096e+02
+1.684501705296266079e+09 7.844000000000000000e+05 1.012624332199537633e+02
+1.684501705800289869e+09 7.846665999999999767e+05 1.011409125464705738e+02
+1.684501706306635618e+09 7.849333000000000466e+05 1.010744374853240259e+02
+1.684501706808105230e+09 7.852000000000000000e+05 1.006193310216598746e+02
+1.684501707321662426e+09 7.854665999999999767e+05 1.001074369957100032e+02
+1.684501707837909937e+09 7.857333000000000466e+05 1.004180907908336451e+02
+1.684501708360549450e+09 7.860000000000000000e+05 1.000344353058658982e+02
+1.684501708865760326e+09 7.862665999999999767e+05 1.005866817312851254e+02
+1.684501709385003328e+09 7.865333000000000466e+05 1.003882384834753339e+02
+1.684501709894536257e+09 7.868000000000000000e+05 1.003522355850329149e+02
+1.684501710401455402e+09 7.870665999999999767e+05 1.000083025901592038e+02
+1.684501710903697252e+09 7.873333000000000466e+05 1.013471623734434246e+02
+1.684501711420283556e+09 7.876000000000000000e+05 1.012965080621093250e+02
+1.684501711923038006e+09 7.878665999999999767e+05 1.013460722258381708e+02

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
-
-
-
-

artiq_master/repository/Experiments/Spectrum/With_calibration/Motional/urukul_RAM_AM_scan2_test.py

+from artiq.experiment import *                                              #Imports everything from experiment library
+from artiq.coredevice.ad9910 import (                                       #Imports RAM destination amplitude scale factor and RAM mode bidirectional ramp methods from AD9910 Source
+    RAM_DEST_ASF, RAM_MODE_BIDIR_RAMP, RAM_MODE_CONT_RAMPUP)
+
+from numpy import load,sin,linspace,pi,array
+import numpy as np
+
+
+from time import sleep,time
+# This code demonstrates use of the urukul RAM.
+# It produces a 50 MHz square waveform attenuated
+
+
+
+# import pyximport;
+# # pyximport.install(reload_support=True)
+# # from importlib import reload
+# pyximport.install()
+
+from freq_syn import optimal_param, optimal_param2, optimal_param3
+# import freq_syn
+# reload(freq_syn)
+# optimal_param = freq_syn.optimal_param
+
+
+
+def test_fail(x):
+    if int(x-1) & 840 == 840:
+        return True
+    if int(x-1) & 900 == 900:
+        return True
+
+
+def get_urukul_array(frec: TInt32, num_samples: TInt32, n_harmonic: TInt32) -> list :
+    """
+    get the array values for AM modulation in urukul for the frequency f0
+
+    params:
+        f0 (float): frequency to set on AM
+    """
+
+    xx         = linspace(0, 2*pi*n_harmonic, num=num_samples, endpoint=False)
+    modulation = sin(xx)
+
+    return modulation.tolist()
+
+
+
+
+def convert_amp_to_data(amp):
+    """
+    takes amp values (from 0 to 1) and returns data values (suitable for DDS load)
+    """
+    MAX = 2**9-1
+    # N   = 10
+
+    # if not iterable(amp):
+    #     amp = [amp]
+
+    # return list([ int(round(val*MAX)) << 23 for val in amp ])
+    return list([ int(round(val*MAX)) for val in amp ])
+
+
+
+class AD9910RAM(EnvExperiment):
+    '''TEST Amplitude Modulation SCAN (V2)'''
+    def build(self): #this code runs on the host computer
+        self.setattr_device("core")                                         #sets core device drivers as attributes
+        self.setattr_device("ccb")
+        self.u = [ self.get_device("urukul0_ch0"),
+                   self.get_device("urukul0_ch1"),
+                   self.get_device("urukul0_ch2"),
+                   self.get_device("urukul0_ch3")]
+
+        self.pmt = self.get_device("ttl0")
+
+
+        # self.data=[0]*512 + [1000<<23]*512
+        self.data     = [0]*1024
+        self.data_len = 1024
+
+        # GUI
+        self._channel_list = list( [ f'Ch{jj}' for jj in range(4) ] )
+        self.setattr_argument("channel",EnumerationValue(self._channel_list))
+
+        # self.frequency = self.get_argument(f"frequency",NumberValue(100*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz))
+        # self.amplitude = self.get_argument(f"amplitude",NumberValue(     0.25,                        min=0.000, max=1.000))
+        self.depth     = self.get_argument(f"AM Floor", NumberValue(     0.15,                        min=0.000, max=1.000))
+        # self.am_freq   = self.get_argument(f"AM frequency",NumberValue(700*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz))
+
+        self._channel = 0
+
+        self.scan_time_step = self.get_argument(f"Scan time step"         ,NumberValue(0.01 , min=0.01, max=60,unit="s") )
+        self.sorted = self.get_argument(f"sorted", BooleanValue(True))
+
+        self.setattr_argument("freqs", Scannable(
+            default=CenterScan(700*kHz, 20*kHz, 1*kHz),
+                unit="kHz",
+                scale=kHz,
+                global_min = 1,
+                global_max = 2*MHz
+            )
+        )
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(300*ms, unit='ms', scale=ms, min=0.001*ms),
+                             "Experiment params")
+        self.setattr_argument(f"t_trans",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        # Ch1 ********************
+        self.setattr_argument(f"IR1_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"IR1_amp",
+                              NumberValue(0.25, min=0., max=0.8),
+                             "Experiment params")
+
+        # Ch2 ********************
+        self.setattr_argument(f"UV_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"UV_amp",
+                              NumberValue(0.12, min=0., max=0.3),
+                             "Experiment params")
+
+        # Ch3 ********************
+        self.setattr_argument(f"IR2_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Experiment params")
+
+        self.setattr_argument(f"IR2_amp",
+                              NumberValue(0.25, min=0., max=0.8),
+                             "Experiment params")
+
+
+
+    def run(self):
+
+        t0 = time()
+        self._channel = self._channel_list.index( self.channel )
+
+        print("canal:", self._channel)
+        # assert  self._channel==3
+
+        if self.sorted:
+            sequence = sorted(self.freqs.sequence)
+        else:
+            sequence = self.freqs.sequence
+
+        self.create_datasets()
+        self.create_applets()
+
+        t0 = time() #; jj=0
+        self.Set_Amplitudes()
+        print(f"Set_Amplitudes() time: {round(time()-t0,2)}")
+
+        for ind,am_freq in enumerate(sequence):
+            self.mutate_dataset("real_freq",  ind, am_freq)
+
+
+        amplitudes = [0, self.IR1_amp, self.UV_amp, self.IR2_amp]
+        amplitude  = amplitudes[self._channel]
+
+        for ind,am_freq in enumerate(sequence):
+            t0 = time() #; jj=0
+            # print(f"{jj}: {time()-t0}") ; jj += 1
+
+            parameters  = optimal_param2( am_freq )
+            for jj in range(0,12,4):
+
+                # print(f"1step time: {round(time()-t0,2)}")
+                frec, num_samples, n_harmonic, clock_step = parameters[jj:jj+4]
+                modulation  = get_urukul_array(frec, num_samples, n_harmonic)
+                #modulation  = (array(modulation)/2 * self.depth ) + (self.amplitude-self.depth)
+                # print(f"2step time: {round(time()-t0,2)}")
+                modulation = amplitude*(1+0.5*(1-self.depth)*(array(modulation)-1))
+                data        = convert_amp_to_data( modulation )
+                self.clock_step = clock_step
+
+                self.data_len = int(num_samples)
+                self.ind = ind
+
+                # print(f"3step time: {round(time()-t0,2)}")
+                if test_fail(num_samples):
+                    self.fix = True
+                    data = data + [0]*10
+                    self.data = [0]*len(data)
+                    for ii in range(len(data)):
+                        self.data[ii] = data[ii]
+                else:
+                    self.fix = False
+                    self.data = [0]*len(data)
+                    for ii in range(len(data)):
+                        self.data[ii] = data[ii]
+
+
+
+                print(f"frec: {frec} | am_freq: {am_freq} | num_samples:{num_samples} | clock_step: {clock_step}")
+
+                try:
+                    # print(f"4step time: {round(time()-t0,2)}")
+                    self.run_kernel()
+                    # print(f"5step time: {round(time()-t0,2)}")
+                    self.mutate_dataset("set_freq",  ind, am_freq)
+                    self.mutate_dataset("real_freq", ind, frec)
+                    break
+
+                except:
+                    print(f"HUBO UNA FALLA DEL run_kernel() (intento {int(jj/4+1)})")
+                    self.mutate_dataset("error_freq",  ind,  1 )
+
+                    if jj==8:
+                        print(F"NO SE PUDO SINTETIZAR F_am={am_freq} Hz POR ERRORES DEL KERNEL")
+                        self.mutate_dataset("error_freq",  ind,  2 )
+
+                    # print(f"6step time: {round(time()-t0,2)}")
+
+            sleep(self.scan_time_step)
+            print(f"step time: {round(time()-t0,2)}")
+
+        self.end_kernel()
+        self.Set_Amplitudes()
+        print("FFIIINNN")
+
+
+    @rpc
+    def create_datasets(self):
+
+        self.set_dataset("counts"   , np.zeros( len(self.freqs.sequence)  , dtype=int  ), broadcast=True, archive=True)
+        self.set_dataset("set_freq" , np.zeros( len(self.freqs.sequence)  , dtype=float), broadcast=True, archive=True)
+        self.set_dataset("real_freq", np.zeros( len(self.freqs.sequence)  , dtype=float), broadcast=True, archive=True)
+        self.set_dataset("error_freq", np.zeros( len(self.freqs.sequence)  , dtype=float), broadcast=True, archive=True)
+        self.set_dataset("channel"   , self.channel, broadcast=False, archive=True)
+        # self.set_dataset("freq_carrier"   , str(self.frequency), broadcast=False, archive=True)
+        # self.set_dataset("amplitude_carrier"   , str(self.amplitude), broadcast=False, archive=True)
+        self.set_dataset("AM_depth_mod"   , str(self.depth), broadcast=False, archive=True)
+
+        self.set_dataset("UV_freq", self.UV_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_amp", self.UV_amp, broadcast=False, archive=True)
+        self.set_dataset("IR1_freq", self.IR1_freq, broadcast=False, archive=True)
+        self.set_dataset("IR1_amp", self.IR1_amp, broadcast=False, archive=True)
+        self.set_dataset("IR2_freq", self.IR2_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_amp", self.IR2_amp, broadcast=False, archive=True)
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "Motional_spectrum_AM",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "
+                        "--x real_freq")
+
+
+    @kernel
+    def Set_Amplitudes(self):
+        self.core.break_realtime()
+        # self.core.reset()
+        # self.core.break_realtime()
+        for jj in range(1,4):
+            self.u[jj].cpld.init()
+            self.core.break_realtime()
+            self.u[jj].init()
+            self.core.break_realtime()
+
+        self.core.break_realtime()
+        delay(5*ms)
+        # self.u[1].set_frequency(self.IR1_freq)
+        # self.u[1].set_amplitude(self.IR1_amp)
+        self.u[1].set(self.IR1_freq, amplitude=self.IR1_amp)
+        delay(5*ms)
+        # self.u[2].set_frequency(self.UV_freq)
+        # self.u[2].set_amplitude(self.UV_amp)
+        self.u[2].set(self.UV_freq, amplitude=self.UV_amp)
+        delay(5*ms)
+        # self.u[3].set_frequency(self.IR2_freq)
+        # self.u[3].set_amplitude(self.IR2_amp)
+        self.u[3].set(self.IR2_freq, amplitude=self.IR2_amp)
+        self.core.break_realtime()
+
+        delay(5*ms)
+        #self.u[2].set_frequency(self.UV_freq, self.UV_amp)
+        #self.u[3].set_frequency(self.IR2_freq, self.IR2_amp)
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+
+        # delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        # self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas
+
+
+    @kernel #this code runs on the FPGA
+    def end_kernel(self):
+        self.core.break_realtime()
+        self.u[self._channel].cpld.init()
+        self.core.break_realtime()
+        self.u[self._channel].init()
+        delay(1*ms)
+
+        self.core.break_realtime()
+        self.u[self._channel].set_cfr1(ram_enable=0)
+        self.u[self._channel].cpld.io_update.pulse_mu(8)
+
+
+    @kernel #this code runs on the FPGA
+    def run_kernel(self):
+
+        if self.fix:
+            local_data_len = self.data_len + 10
+        else:
+            local_data_len = self.data_len
+        data = [0] * local_data_len
+        for ii in range(local_data_len):
+            data[ii] = self.data[ii] << 23
+
+        self.core.break_realtime()
+
+        # modulation, frec, clock_step = get_urukul_array( self.am_freq )
+        # modulation                   = (modulation/2 * self.depth )+0.9
+        # data                         = convert_amp_to_data( modulation )
+        # data  = [0]*512 + [1000<<23]*512
+        # clock_step = 1
+
+        #reset core
+        # self.core.reset()
+        #     Esto último hace saltar un error de de underflow
+
+
+        #initialise
+        self.u[self._channel].cpld.init()
+        self.core.break_realtime()
+        self.u[self._channel].init()
+        delay(1*ms)
+
+        #set ram profile 0 -----------------------------
+        self.u[self._channel].set_profile_ram(
+            start=0, end=0 + self.data_len - 1, step=self.clock_step,
+            profile=0, mode=RAM_MODE_CONT_RAMPUP)
+
+        self.u[self._channel].cpld.set_profile(0)
+        self.u[self._channel].cpld.io_update.pulse_mu(8)
+        delay(1*ms)  # ES ESTE
+        #write to ram
+        self.u[self._channel].write_ram(data)
+
+        delay(10*ms)
+
+        self.core.break_realtime()
+
+
+
+        # --------------------------
+        # self.u.cpld.set_profile(0)
+        # self.u.cpld.io_update.pulse_mu(8)
+        # delay(1*ms)
+
+
+        #write to cfr
+        self.u[self._channel].set_cfr1(ram_enable=1, ram_destination=RAM_DEST_ASF, internal_profile=0)
+
+        self.u[self._channel].sw.on()
+        #set urukuln parameters and turn channel on
+        # self.u[self._channel].set_frequency(self.frequency)
+        self.u[self._channel].cpld.io_update.pulse_mu(8)
+        # self.u.set_att(10*dB)
+
+        # self.core.break_realtime()
+        # delay(1*ms)
+        #self.u.sw.off()
+
+        delay(self.t_trans)
+        cuentas = self.readout()
+        #delay(1*ms)
+        self.mutate_dataset("counts", self.ind, cuentas )