agrego meds despues de mucho tiempo

artiq_master/last_rid.pyon

-17973
+19363

artiq_master/repository/Experiments/Transitory/coherent_raman_beats.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+import numpy as np
+
+# TODO:
+#     [ ] Revisar los tiempos
+#     [ ] Ver por que da overflow intermitentemente en las corrids
+#     [ ] Ver como esta guardando los resultados y guardar lo que falta
+#     [ ] Cambiarle los parametros a los laseres cuando arranca el exp
+
+class CRB(EnvExperiment):
+    """Coherent Raman Beats Experiment"""
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        self.pmt = self.get_device("ttl0")
+        #self.pmt_state = self.get_device("ttl4")
+
+        self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
+        self.laserIR1 = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR1") #corresponde a 0.8 Vpp
+        self.laserIR2 = UrukulCh(self, ch=3, freq=80.0, amp=0.2, name="IR2") #corresponde a 0.8 Vpp
+        self.laserIR2shift = UrukulCh(self, ch=0, freq=270.0, amp=0.7, name="IR2shift") #corresponde a 0.8 Vpp
+
+#        self.setattr_argument("bin", NumberValue(50e-9, unit='us'), "Binning params")
+
+        self.setattr_argument("no_measures",
+                              NumberValue(1000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+
+
+        self.setattr_argument(f"t_prepDS",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1000*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_wait",
+                              NumberValue(5*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"UV_preparation_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_preparation_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_preparation_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_preparation_amp",
+                              NumberValue(0.19, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_preparation_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_preparation_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_measurement_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_measurement_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_measurement_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_measurement_amp",
+                              NumberValue(0.19, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_measurement_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_measurement_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_cooling_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR1_cooling_freq",
+                              NumberValue(225*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR1_cooling_amp",
+                              NumberValue(0.25, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_cooling_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_cooling_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_final_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.3),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR1_final_freq",
+                              NumberValue(225*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR1_final_amp",
+                              NumberValue(0.25, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_final_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR2_final_amp",
+                              NumberValue(0.3, min=0.0, max=0.35),
+                             "Cooling params")
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("counts", [],
+                            broadcast=True, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+        self.set_dataset("t_prepDS", self.t_prepDS, broadcast=False, archive=True)
+        self.set_dataset("t_enfriar_ion", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_wait", self.t_wait, broadcast=False, archive=True)
+        self.set_dataset("no_measures", self.no_measures, broadcast=False, archive=True)
+
+
+        self.set_dataset("IR1_preparation_freq", self.IR1_preparation_freq, broadcast=False, archive=True)
+        self.set_dataset("IR1_preparation_amp", self.IR1_preparation_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR2_preparation_freq", self.IR2_preparation_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_preparation_amp", self.IR2_preparation_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_preparation_freq", self.UV_preparation_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_preparation_amp", self.UV_preparation_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR1_cooling_freq", self.IR1_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR1_cooling_amp", self.IR1_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR2_cooling_freq", self.IR2_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_cooling_amp", self.IR2_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_cooling_freq", self.UV_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_cooling_amp", self.UV_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR1_measurement_freq", self.IR1_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR1_measurement_amp", self.IR1_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR2_measurement_freq", self.IR2_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_measurement_amp", self.IR2_measurement_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_measurement_freq", self.UV_measurement_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_measurement_amp", self.UV_measurement_amp, broadcast=False, archive=True)
+
+        self.laserIR1.generate_dataset()
+        self.laserIR2.generate_dataset()
+        self.laserUV.generate_dataset()
+        #self.set_dataset("frec_UV",self.frec_UV, broadcast=False,archive=True)
+        #self.set_dataset("frec_IR",self.frec_IR, broadcast=False,archive=True)
+        # TODO: Agregar forma de guardar los datos de los canales del Urukul.
+        # o bien guardando todos aca, o armando un metodo apropiado en su controlador
+        self.set_dataset("Comments", self.Comments)
+        #self.set_dataset("binvector", np.arange(0, self.t_readout, self.bin*1e-6), broadcast=True, archive=False)
+
+
+    @rpc
+    def create_applets(self):
+        self.ccb.issue("create_applet", "cuentas",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+
+
+    @kernel
+    def run(self):
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+        delay(1*ms)
+
+        self.enfriar_ion()
+        for runN in range(self.no_measures):
+            # Aprovecho el tiempo que necesito para extraer datos
+            # par enfriar al ion con los dos laseres prendidos
+            if runN % 50 == 0:
+            # Aprovecho el tiempo que necesito para extraer datos
+            # par enfriar al ion con los dos laseres prendidos
+                at_mu(self.core.get_rtio_counter_mu() + self.core.seconds_to_mu(self.t_cool) )
+            else:
+                at_mu(self.core.get_rtio_counter_mu() + self.core.seconds_to_mu(100*us) )
+            self.prep_DS()
+            t_end = self.medicion_y_lectura()
+            self.save_counts(t_end)
+            #self.mutate_dataset("counts", runN, counts)
+
+        #self.cleanup()
+        self.core.break_realtime()
+        self.enfriar_ion()
+        self.core.break_realtime()
+
+        self.laserIR1.select_profile(3)
+        self.laserIR2.select_profile(3)
+        self.laserUV.select_profile(3)
+        self.laserIR2shift.select_profile(3)
+
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserUV.on()
+        self.laserIR2shift.on()
+
+        #self.core.break_realtime()
+        #delay(1*ms)
+        #self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=0)
+        #self.core.break_realtime()
+        #delay(1*ms)
+        #self.laserIR1.set_frequency(self.IR1_final_freq, self.IR1_final_amp, profile=0)
+        #self.core.break_realtime()
+        #delay(1*ms)
+        #self.laserIR2.set_frequency(self.IR2_final_freq, self.IR2_final_amp, profile=0)
+        
+
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.pmt_state.output()
+        #self.laserIR.initialize_channel()
+        #self.laserUV.initialize_channel()
+        # Quizas haya errores de tiempo.
+        #self.pmt_state.off()
+        #self.laserIR.set_channel()
+        #self.laserUV.set_channel()
+        #self.core.wait_until_mu(now_mu())
+        delay(1*ms)
+        self.laserIR1.set_channel()
+        delay(1*ms)
+        self.laserIR2.set_channel()
+        delay(1*ms)
+        self.laserIR2shift.set_channel()
+        delay(1*ms)
+        self.laserUV.set_channel()
+        self.core.wait_until_mu(now_mu())
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_measurement_freq, self.UV_measurement_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR1.set_frequency(self.IR1_measurement_freq, self.IR1_measurement_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_measurement_freq, self.IR2_measurement_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=0)
+
+        self.core.break_realtime()
+
+        delay(1*ms)
+        self.laserIR1.set_channel(profile=1)
+        delay(1*ms)
+        self.laserIR2.set_channel(profile=1)
+        delay(1*ms)
+        self.laserIR2shift.set_channel(profile=1)
+        delay(1*ms)
+        self.laserUV.set_channel(profile=1)
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR1.set_frequency(self.IR1_cooling_freq, self.IR1_cooling_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_cooling_freq, self.IR2_cooling_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=1)
+
+        self.core.break_realtime()
+
+        delay(1*ms)
+        self.laserIR1.set_channel(profile=2)
+        delay(1*ms)
+        self.laserIR2.set_channel(profile=2)
+        delay(1*ms)
+        self.laserIR2shift.set_channel(profile=2)
+        delay(1*ms)
+        self.laserUV.set_channel(profile=2)
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_preparation_freq, self.UV_preparation_amp, profile=2)
+        self.core.break_realtime()
+        self.laserIR1.set_frequency(self.IR1_preparation_freq, self.IR1_preparation_amp, profile=2)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_preparation_freq, self.IR2_preparation_amp, profile=2)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=2)
+
+        self.core.break_realtime()
+
+        delay(1*ms)
+        self.laserIR1.set_channel(profile=3)
+        delay(1*ms)
+        self.laserIR2.set_channel(profile=3)
+        delay(1*ms)
+        self.laserIR2shift.set_channel(profile=3)
+        delay(1*ms)
+        self.laserUV.set_channel(profile=3)
+
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_final_freq, self.UV_final_amp, profile=3)
+        self.core.break_realtime()
+        self.laserIR1.set_frequency(self.IR1_final_freq, self.IR1_final_amp, profile=3)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_final_freq, self.IR2_final_amp, profile=3)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(270*MHz, 0.7, profile=3)
+
+        self.core.break_realtime()
+
+
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Preparo el ion prendiendo ambos laseres"""
+        self.laserUV.select_profile(1)
+        self.laserIR1.select_profile(1)
+        self.laserIR2.select_profile(1)
+        self.laserIR2shift.select_profile(1)
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserUV.on()
+        self.laserIR2shift.on()
+        #delay(self.t_cool)
+
+    @kernel
+    def prep_DS(self):
+        """Preparo el estado oscuro prendiendo los 3 laseres con las frecuencias correctas"""
+        self.core.break_realtime()
+        self.laserIR1.select_profile(2)
+        self.laserIR2.select_profile(2)
+        self.laserUV.select_profile(2)
+        self.laserIR2shift.select_profile(2)
+        self.laserUV.on()
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserIR2shift.on()
+        delay(self.t_prepDS)
+
+    @kernel
+    def medicion_y_lectura(self):
+        """Registro cuentas emitidas con el laser UV prendido"""
+        self.laserUV.off()
+        self.laserIR1.off()
+        self.laserIR2.off()
+        self.laserIR2shift.off()
+        #self.pmt.gate_rising(self.t_readout)        
+        self.laserIR1.select_profile(0)
+        self.laserIR2.select_profile(0)
+        self.laserUV.select_profile(0)
+        self.laserIR2shift.select_profile(0)
+        self.laserUV.on()
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserIR2shift.on()
+
+        #delay(self.t_wait)
+
+        # Prendo y apago la TTL para ver en el osc.
+        #self.pmt_state.on()
+        self.pmt.gate_rising(self.t_readout)
+        #with parallel:
+        #self.pmt_state.off()
+        self.enfriar_ion()
+
+        #self.pmt_state.pulse(self.t_readout)
+        #cuentas = self.pmt.count(here)
+        #delay(1*us)
+        #self.enfriar_ion()
+        return now_mu()
+
+
+    @kernel
+    def save_counts(self, t_end):
+        count = self.pmt.timestamp_mu(t_end)
+        t0 = t_end - self.core.seconds_to_mu(self.t_readout)
+        while count > 0:
+            self.append_to_dataset("counts", self.core.mu_to_seconds(count - t0) )
+            count = self.pmt.timestamp_mu(t_end)
+
+
+    @kernel
+    def readout(self):
+        """NO SE USA ESTA FUNCION - Registro cuentas emitidas con el laser IR prendido"""
+        self.laserUV.off()
+        delay(1*us)
+        self.laserIR1.on()
+
+        # Prendo y apago la TTL para ver en el osc.
+        #self.pmt_state.on()
+        #self.pmt.gate_rising(self.t_readout)
+        #with parallel:
+        #self.pmt_state.off()
+        self.laserUV.on()
+        self.laserIR1.off()
+
+        #self.pmt_state.pulse(self.t_readout)
+        #cuentas = self.pmt.count(here)
+        #delay(1*us)
+        self.enfriar_ion()
+        return now_mu()
+
+    @kernel
+    def cleanup(self):
+        """NO SE USA ESTA FUNCION"""
+        self.core.break_realtime()
+        self.laserIR1.off()
+        self.laserIR2.off()
+        self.laserUV.off()
+        #self.pmt_state.off()

artiq_master/repository/Experiments/Trapping/Blinking_IR_Trapping.py

@@ -11,15 +11,17 @@ class PMTCalibration(EnvExperiment):
         self.setattr_device("scheduler")
         self.setattr_device("core")
         self.pmt = self.get_device("ttl0")
+        self.led = self.get_device("ttl6")
 
         self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
         self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp
 
         self.setattr_argument(f"t_readout",
                               NumberValue(300*ms, unit='ms', scale=ms, min=1*ms),
-                             "PMT Calibration")
+                             "Trapping")
 
-        self.setattr_argument("Blink", BooleanValue(1==0), "PMT Calibration")
+        self.setattr_argument("Blink", BooleanValue(1==0), "Trapping")
+        self.setattr_argument("LED", BooleanValue(1==0), "Trapping")
 
 
     @rpc
@@ -62,6 +64,7 @@ class PMTCalibration(EnvExperiment):
         #self.laserIR.channel.init()
         #self.laserUV.initialize_channel()
 
+        self.led.output()
 
         self.pmt.input()
 
@@ -76,6 +79,12 @@ class PMTCalibration(EnvExperiment):
         self.laserIR.on()
         self.laserUV.on()
 
+        if self.LED==True:
+            self.led.off()
+        else:
+            self.led.on()
+        delay(1000*us)
+
 
     def run(self):
         self.create_datasets()

artiq_master/repository/Experiments/Trapping/master_control.py

+import numpy as np
+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+
+
+class MasterControl(EnvExperiment):
+    """Master control of the experiment"""
+
+    def build(self):
+        self.setattr_device("ccb")
+        self.setattr_device("scheduler")
+        self.setattr_device("core")
+        self.pmt = self.get_device("ttl0")
+        self.led = self.get_device("ttl6")
+        self.laser423 = self.get_device("ttl7")
+
+        #self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
+        #self.laserIR = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR") #corresponde a 0.8 Vpp
+
+        self.laserUV = UrukulCh(self, ch=2, freq=110.0, amp=0.3, name="UV") #corresponde a 0.7 Vpp
+        self.laserIR1 = UrukulCh(self, ch=1, freq=208.0, amp=0.35, name="IR1") #corresponde a 0.8 Vpp
+        self.laserIR2 = UrukulCh(self, ch=3, freq=80.0, amp=0.2, name="IR2") #corresponde a 0.8 Vpp
+        self.laserIR2shift = UrukulCh(self, ch=0, freq=270.0, amp=0.7, name="IR2shift") #corresponde a 0.8 Vpp
+
+
+        self.setattr_argument(f"IR1_freq",
+                              NumberValue(229*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_amp",
+                              NumberValue(0.25, min=0.0, max=0.35),
+                             "Laser params")
+
+        self.setattr_argument(f"IR1_status",
+                              BooleanValue(1==0),
+                             "Laser params")
+
+
+        self.setattr_argument(f"UV_freq",
+                              NumberValue(115*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_amp",
+                              NumberValue(0.19, min=0.0, max=0.3),
+                             "Laser params")
+
+        self.setattr_argument(f"UV_status",
+                              BooleanValue(1==0),
+                             "Laser params")
+
+
+        self.setattr_argument(f"IR2_freq",
+                              NumberValue(80*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_amp",
+                              NumberValue(0.3, min=0.0, max=0.4),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2_status",
+                              BooleanValue(1==0),
+                             "Laser params")
+
+
+        self.setattr_argument(f"IR2shift_freq",
+                              NumberValue(270*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2shift_amp",
+                              NumberValue(0.7, min=0.0, max=0.8),
+                             "Laser params")
+
+        self.setattr_argument(f"IR2shift_status",
+                              BooleanValue(1==0),
+                             "Laser params")
+
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(300*ms, unit='ms', scale=ms, min=1*ms),
+                             "Trapping")
+
+        self.setattr_argument("Change_laser_params", BooleanValue(1==0), "Trapping")        
+        self.setattr_argument("Blink", BooleanValue(1==0), "Trapping")
+        self.setattr_argument("LED", BooleanValue(1==0), "Trapping")
+        self.setattr_argument("laser423", BooleanValue(1==0), "Trapping")
+
+#        if self.Change_laser_params:
+#            set_default_scheduling(priority=5)
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("pmt_counts_diff", np.zeros(1, dtype=int), broadcast=True, archive=False)
+        self.set_dataset("pmt_counts_on", np.zeros(1, dtype=int), broadcast=True, archive=False)
+        self.set_dataset("pmt_counts_off", np.zeros(1, dtype=int), broadcast=True, archive=False)
+
+    @rpc
+    def create_applets(self):
+
+        if self.Blink:
+            self.ccb.issue("create_applet", "Trapping_on_off",
+                            "${python} -m pyLIAF.artiq.applets.realtime "
+                            "400 "
+                            "pmt_counts_on "
+                            "--y2 pmt_counts_off")
+
+        else:
+            self.ccb.issue("create_applet", "Monitoring_fluorescence",
+                            "${python} -m pyLIAF.artiq.applets.realtime_lines "
+                            "400 "
+                            "pmt_counts_on "
+                            "--y2 pmt_counts_off")
+            
+
+        self.ccb.issue("create_applet", "DIFF_calibration_pmt_blinking",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "40 "
+                        "pmt_counts_diff")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        #self.laserIR.initialize_channel()
+        #self.laserUV.channel.cpld.init()
+        #self.laserUV.channel.init()
+        #self.laserIR.channel.cpld.init()
+        #self.core.wait_until_mu(now_mu())
+        #self.laserIR.channel.init()
+        #self.laserUV.initialize_channel()
+
+        self.led.output()
+        self.laser423.output()
+
+        self.pmt.input()
+
+        delay(1000*us)
+
+        self.laserIR1.set_channel()
+        self.laserIR2.set_channel()
+        self.laserIR2shift.set_channel()
+        self.laserUV.set_channel()
+
+        self.core.wait_until_mu(now_mu())
+
+        delay(1*ms)
+
+        self.core.break_realtime()
+        self.set_lasers()
+        self.core.break_realtime()
+
+        delay(1*ms)
+
+        if self.LED==True:
+            self.led.off()
+        else:
+            self.led.on()
+        delay(1000*us)
+
+
+    def run(self):
+        self.create_datasets()
+        self.create_applets()
+        self.init_kernel()
+
+        if not self.Change_laser_params:
+            try:
+                while True:
+                    self.measure_counts()
+                    while self.scheduler.check_pause():
+                        print("PAUSED BLINKING")
+                        self.core.comm.close()
+                        self.scheduler.pause()
+                        # TODO: reset freqs/amps
+                        print("RESUMED BLINKING")
+            except TerminationRequested:
+                self.cleanup()
+                print("STOPPED BLINKING")
+
+    @kernel
+    def readout(self):
+        """Registro de cuentas emitidas"""
+       
+        here = self.pmt.gate_rising(self.t_readout)
+
+        cuentas = self.pmt.count(here)
+        delay(1*us)
+        return cuentas
+
+    @kernel
+    def measure_counts(self):
+        self.core.break_realtime()
+        #self.laserUV.on()
+        if self.Blink:
+            self.laserIR1.off()
+            delay(10*us)
+            counts_off = self.readout()
+            self.mutate_dataset("pmt_counts_off", 0, counts_off)
+            at_mu(self.core.get_rtio_counter_mu() + 10000)
+            self.laserIR1.on()
+        delay(10*us)          
+        counts_on = self.readout()
+        self.mutate_dataset("pmt_counts_on", 0, counts_on)
+        at_mu(self.core.get_rtio_counter_mu() + 1000)        
+        #self.mutate_dataset("pmt_counts_diff", 0, counts_on/counts_off)
+
+    @kernel
+    def set_lasers(self):
+        self.laserIR1.set_frequency(self.IR1_freq, self.IR1_amp, profile=0)
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_freq, self.UV_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_freq, self.IR2_amp, profile=0)
+        self.core.break_realtime()
+        self.laserIR2shift.set_frequency(self.IR2shift_freq, self.IR2shift_amp, profile=0)
+        self.core.break_realtime()
+
+        if self.IR1_status:
+            self.laserIR1.on()
+        else:
+            self.laserIR1.off()
+        self.core.break_realtime()
+
+        if self.UV_status:
+            self.laserUV.on()
+        else:
+            self.laserUV.off()
+        self.core.break_realtime()
+
+        if self.IR2_status:
+            self.laserIR2.on()
+        else:
+            self.laserIR2.off()
+        self.core.break_realtime()
+
+        if self.IR2shift_status:
+            self.laserIR2shift.on()
+        else:
+            self.laserIR2shift.off()
+        self.core.break_realtime()
+
+
+    @kernel
+    def cleanup(self):
+        self.core.break_realtime()
+        self.laserIR1.off()
+        self.laserUV.off()
+

artiq_master/repository/Tests/Artiq_Recon_v2.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jun  3 15:38:39 2024
+
+@author: liaf-ankylosaurus-admin
+"""
+
+import numpy as np
+from artiq.experiment import *
+from time import sleep
+#from pyLIAF.GenFunc.generador import Generador
+PORT = 60000
+PASS = b'Secr3t Pa55W0rd'
+from multiprocessing.connection import Client
+
+class InOut(EnvExperiment):
+    """
+    Reconocimiento v2
+    """
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+        self.ttl0 = self.get_device("ttl0")
+        self.ttl4 = self.get_device("ttl4")
+        
+        self.setattr_argument(f"t_med",
+                             NumberValue(300*ms, unit='ms', scale=ms, min=0.1*ms, max=1000*ms),
+                            "Experiment params")
+        
+        self.setattr_argument("t_exp",
+                             NumberValue(200*s, unit='s', scale=s, min=5*s, max=3000*s),
+                            "Experiment params")
+        
+        self.setattr_argument("N_ions_objective",
+                             NumberValue(1, min=1, max=15, ndecimals=0, step=1), 
+                            "Experiment params")
+         
+        self.setattr_argument("Measurement_type",
+                                  EnumerationValue(["finite_time", "indefinite_time"]),
+                              "Scan params")
+
+#        self.setattr_argument("Nsigma",
+#                                  NumberValue(5, min=2, max=8,ndecimals=0, step=1),
+#                              "Scan params")
+        
+        self.setattr_argument("tseg",
+                                  NumberValue(2*s,unit='s',scale=s,min=1*s, max=3*s),
+                              "Scan params")
+
+        
+    @rpc
+    def initialize_tca_com(self):
+        address = ('localhost', PORT)
+        self.conn = Client(address, authkey=PASS)
+        sleep(0.1)
+
+
+    @rpc
+    def blinkRF(self,cmd='turnOnOffRF'):
+        self.conn.send(f'{cmd} blink')
+        rta = self.conn.recv()
+
+
+    @rpc(flags={"async"})
+    def create_datasets(self): 
+        self.set_dataset('time', [], broadcast=True, archive=True)
+        self.set_dataset('counts', [], broadcast=True, archive=True)
+        self.set_dataset('counts_indefinite',np.array([0.0]), broadcast=True, archive=False)
+        self.set_dataset("N_ions", [], broadcast=False, archive=True)
+
+        
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "test_IR_espectro_fixeddelays",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "#Tiene que estar el espacio!!!
+                        "--x time") #Aca habria que definir bien el vector que se use en el eje x
+
+        self.ccb.issue("create_applet", "test_histogram_realtime",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+        
+        self.ccb.issue("create_applet", "test_histogram_realtime_indefinite",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "400 "
+                        "counts_indefinite")
+
+    @rpc
+    def TurnOnRF(self):
+        pass
+    
+    @rpc
+    def TurnOffRF(self):
+        pass
+    
+    @rpc
+    def Varianza(self,sig)  -> TList(TFloat):
+        ruido=np.std(sig)
+        print(ruido)
+        return [ruido]
+
+    @kernel
+    def run(self): 
+        self.initialize_tca_com()
+        #Preparamos las variables y los graficos
+        self.create_datasets()
+        self.create_applets()
+        #Se prenden los "canales" a usar
+        self.core.reset()
+        self.ttl4.output()
+        self.ttl0.input()
+        self.ttl4.on()
+        
+        delay(20*ms)  # time for the artiq init.
+        
+        if self.Measurement_type=="indefinite_time":
+            while True:
+                cuentas=self.ttl0.gate_rising(self.t_med)
+                cuentas=self.ttl0.count(cuentas)
+                self.mutate_dataset("counts_indefinite",0,cuentas)
+                print(cuentas)
+                
+                self.core.break_realtime()
+                      
+        else:
+            sig=[]
+            for i in range(int(3/self.t_med)):
+                cuentas=self.ttl0.gate_rising(self.t_med)
+                sig=sig+[self.ttl0.count(cuentas)]
+                self.append_to_dataset("counts",sig[-1])
+                self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
+                self.core.break_realtime()
+            ruido=self.Varianza(sig)[0]
+            delay(20*ms)
+            
+            for i in range(int(3/self.t_med),int(self.t_exp/self.t_med)):
+                cuentas=self.ttl0.gate_rising(self.t_med)
+                cuentas=self.ttl0.count(cuentas)
+                self.append_to_dataset("counts",cuentas)   
+                self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
+
+                print(cuentas)
+                                    
+                self.core.break_realtime()
+            
+        start_time = now_mu()  # Record the start timeself.core.break_realtime()
+        self.core.break_realtime()

artiq_master/repository/Tests/aperturecontrol.py

@@ -10,6 +10,12 @@ Created on Wed Apr 24 14:24:05 2024
 import numpy as np
 from artiq.experiment import *
 #from pyliaf.GenFun.generador import nombredelaclase
+from time import sleep
+
+
+PORT = 60000
+PASS = b'Secr3t Pa55W0rd'
+from multiprocessing.connection import Client
 
 class InOut(EnvExperiment):
     """
@@ -23,23 +29,42 @@ class InOut(EnvExperiment):
         self.setattr_argument("N_blinks", NumberValue(1, min=1, max=200, ndecimals=0, step=1), "Experiment params")
 
 
+    @rpc
+    def initialize_tca_com(self):
+        address = ('localhost', PORT)
+        self.conn = Client(address, authkey=PASS)
+        sleep(0.1)
+
+
+    @rpc
+    def blinkRF(self,cmd='turnOnOffRF'):
+        self.conn.send(f'{cmd} blink')
+        rta = self.conn.recv()
+
+
     @kernel
     def run(self): 
         #Preparamos las variables
         
+        self.initialize_tca_com()
+
         #Se prenden los "canales" a usar
         self.core.reset()
         self.ttl6.output()
         
-        delay(20*ms)  # time for the artiq init.
+        delay(200*ms)  # time for the artiq init.
+        
+        self.ttl6.on()
 
-        for i in range(self.N_blinks):
-            self.ttl6.on()
-            delay(1000*ms)
-            self.ttl6.off()
-            delay(1000*ms)
-            
-     
+        delay(100*ms)
+           
+        self.blinkRF()
+
+#        for i in range(self.N_blinks):
+#            self.ttl6.on()   #ON CIERRA
+#            delay(1000*ms)
+#            self.ttl6.off()  #OFF ABRE
+#            delay(1000*ms)
             
 
             

artiq_master/repository/Tests/copia_seguridad.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Sep  4 13:51:16 2024
+
+@author: liaf-ankylosaurus-admin
+"""
+
+import numpy as np
+from artiq.experiment import *
+from time import sleep
+PORT = 60000
+PASS = b'Secr3t Pa55W0rd'
+from multiprocessing.connection import Client
+
+class InOut(EnvExperiment):
+    """
+    Copia seguridad v3
+    """
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+        self.ttl0 = self.get_device("ttl0")
+        self.ttl4 = self.get_device("ttl4")
+        self.ttl6 = self.get_device("ttl6")
+        
+        self.setattr_argument(f"t_med",
+                             NumberValue(300*ms, unit='ms', scale=ms, min=0.1*ms, max=1000*ms),
+                            "Experiment params")
+        
+        self.setattr_argument("t_exp",
+                             NumberValue(200*s, unit='s', scale=s, min=1*s, max=3000*s),
+                            "Experiment params")
+        
+        self.setattr_argument("N_ions_objective",
+                             NumberValue(1, min=1, max=15, ndecimals=0, step=1), 
+                            "Experiment params")
+        
+        self.setattr_argument("waiting_time",
+                             NumberValue(60*s, unit='s',min=15*s, max=300*s), 
+                            "Experiment params")
+        
+        self.setattr_argument("tseg",
+                                  NumberValue(2*s,unit='s',scale=s,min=1*s, max=3*s),
+                              "Scan params")
+        
+        self.setattr_argument("Calibration",
+                                  BooleanValue(1==0),
+                              "Calibration params")
+        
+        self.setattr_argument("fluo per ion",
+                                  NumberValue(1, min=1, max=10000, ndecimals=0, step=1),
+                              "Calibration params")
+
+        self.setattr_argument("Read_with",
+                                  EnumerationValue(["PMT", "Camera"]),
+                              "Experiment params")
+        
+
+
+        
+    @rpc
+    def initialize_tca_com(self):
+        address = ('localhost', PORT)
+        self.conn = Client(address, authkey=PASS)
+        sleep(0.1)
+
+
+    @rpc
+    def blinkRF(self,cmd='turnOnOffRF'):
+        self.conn.send(f'{cmd} blink')
+        rta = self.conn.recv()
+        
+        
+    @rpc(flags={"async"})
+    def create_datasets(self): 
+        self.set_dataset('time', [], broadcast=True, archive=True)
+        self.set_dataset('counts', [], broadcast=True, archive=True)
+        self.set_dataset("N_ions", [], broadcast=False, archive=True)
+        self.set_dataset("fluo", [], broadcast=False, archive=True)
+        #self.set_dataset('Cuentas_transitorio', [0], broadcast=True, archive=True)
+
+        
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "test_IR_espectro_fixeddelays",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "#Tiene que estar el espacio!!!
+                        "--x time") #Aca habria que definir bien el vector que se use en el eje x
+
+        self.ccb.issue("create_applet", "test_histogram_realtime",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+        
+        self.ccb.issue("create_applet", "test_histogram_realtime_indefinite",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "400 "
+                        "counts_indefinite")
+        
+        self.ccb.issue("create_applet", "test_N_ions",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "N_ions "
+                        "--x time")
+
+    
+    @kernel
+    def ShutterClose(self):#Que controle el prendido de los dos Shutters #Abre
+        self.core.break_realtime()
+        self.ttl6.on()
+        print("Cerrado")
+    
+    @kernel
+    def ShutterOpen(self):#Que controle el apagado de los dos Shutters #Cierra
+        self.core.break_realtime()
+        self.ttl6.off()
+        print("Abierto")
+    
+#    @rpc
+#    def Varianza(self,sig)  -> TList(TFloat):
+#        ruido=np.std(sig)
+#        print(ruido)
+#        return [ruido]
+    
+    @rpc
+    def listas(self,sig,ruido):
+        self.paso=[]
+        self.pasom=[]
+        self.med=[]
+        self.medmax=[]
+        self.N=[]
+        self.fluo=[]
+        self.atrapados=[]
+        self.desviacion=[]
+        for i in range(int(3/self.t_med)):
+            self.med=self.med+[sig[i]]
+            self.medmax=self.medmax+[sig[i]+ruido]
+            self.N=self.N+[0]
+                
+    @rpc
+    def func(self,i,s,mu,b,c,ruido)  -> TList(TInt64):
+        recon_dev = self.Recon(i,s,self.t_med,self.tseg,mu,b,c,ruido,self.paso,self.pasom,self.med,self.medmax,self.N,self.fluo,self.atrapados,self.desviacion)
+        return recon_dev
+
+    @rpc
+    def read_counts(self,t_med)  -> TList(TInt64):
+        if self.Read_with=="Camera":
+            self.conn.send('rois_count True')
+            cuentas=self.conn.recv()
+            #self.mutate_dataset("Cuentas_transitorio",0,cuentas)
+        else:
+            print(1)
+            print(t_med)
+            cuentas=self.ttl0.gate_rising(t_med)
+            cuentas=self.ttl0.count(cuentas)
+            print(cuentas)
+            #self.mutate_dataset("Cuentas_transitorio",0,cuentas)
+        #return [cuentas[0]]
+        return [int(cuentas[0])]
+
+    @rpc
+    def Recon(self, i,s,med_ss,tseg,mu,b,c,ruido,paso,pasom,med,medmax,N,fluo,atrapados,desviacion)  -> TList(TInt64):
+        """
+        Funcion que reconoce iones
+        i: iteracion
+        s: vector de mediciones
+        """
+        med_s=1/med_ss
+        med.append(np.mean(s[b:i-1]))
+        medmax.append(med[-1]+ruido)
+        if abs(s[i]-med[-2])>ruido: #Supera la cota
+            if (s[i]-med[-2])>0: #Supera por arriba
+                z=1
+            else:
+                z=-1
+            if c>(tseg*med_s): #Supera el criterio
+                fluo.append(np.mean(s[b:i-int(tseg*med_s+1)]))
+                if len(fluo)>1:
+                    a=abs(fluo[-1]-fluo[-2])
+                    print(a)
+                    A=[]
+                    for k in range(len(mu)):
+                        A.append(abs(a-mu[k]))
+                    atrapados.append(np.argmin(A)+1)
+                    desviacion.append(min(A))
+                if z==1:
+                    paso.append(i)
+                else:
+                    pasom.append(i)
+                for k in range(int(tseg*med_s+1)): #Fortaleciendo med
+                    med[-1-k]=s[i-k]
+                    medmax[-1-k]=s[i-k]+ruido
+                if z==1:
+                    if len(paso)>1 and (paso[-1]-paso[-2])<(tseg*med_s): #Limpieza y ruido adaptativo, cuando aumenta N
+                        paso.pop(-2)
+                        N[-1]=N[-2]
+                else:
+                    if len(pasom)>1 and (pasom[-1]-pasom[-2])<(tseg*med_s) and z==-1: #Limpieza
+                        pasom.pop(-2)
+                        N[-1]=N[-2]
+                b=i-1
+                c=0
+                if len(fluo)==1:  #Cantidad de iones
+                    N.append(1)
+                else:
+                    N.append(N[-1]+z*atrapados[-1])
+                for k in range(len(N)):
+                    if (b+k-int(tseg*med_s+1))==(len(N)):
+                        break
+                    else:
+                        N[b+k-int(tseg*med_s+1)]=N[-1]
+            else:
+                med[-1]=med[-2]
+                medmax[-1]=medmax[-2]
+                c=c+1
+                N.append(N[-1])
+        else: #Cae dentro de la cota
+            c=0
+            N.append(N[-1])
+        print(N[-1])
+        return [b,c,0,N[-1]]
+
+    @kernel
+    def run(self): 
+        #Preparamos las variables y los graficos
+        self.initialize_tca_com()
+        self.create_datasets()
+        self.create_applets()
+        #Se prenden los "canales" a usar
+        self.core.reset()
+        self.ttl4.output()
+        self.ttl0.input()
+        self.ttl4.on()
+        self.ttl6.output()
+        self.ShutterOpen()
+        self.blinkRF()
+        delay(20*ms)
+      
+        
+        if self.Calibration==True:
+            #mu=calib
+            mu=[500*i for i in [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]]
+        else:
+            #mu=self.load_calibration()
+            mu=[700*i for i in [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]]
+        
+            self.core.break_realtime()
+            delay(10*ms)
+            sig=[]
+            b=0
+            c=0
+            d=0 #Cantidad buscada? Si-No
+            e=0 #Tiempo con cantidad buscada
+            for i in range(int(3/self.t_med)):
+                rta = self.read_counts(self.t_med)
+                print("2")
+                #rta=self.get_dataset("Cuentas_transitorio")
+                #rta = 
+                #rta = self.Cuentas_transitorio
+                print("3")
+                sig=sig+rta
+                self.append_to_dataset("counts",rta[0])
+                self.append_to_dataset("time",self.t_exp*i/int(self.t_exp/self.t_med))
+                self.core.break_realtime()
+            ruido=500#.5*mu[0]
+            self.listas(sig,ruido)         
+            self.core.break_realtime()
+            delay(20*ms)
+            
+            for i in range(int(3/self.t_med),int(self.t_exp/self.t_med)):
+                rta = self.read_counts(self.t_med)
+                #rta=self.get_dataset("Cuentas_transitorio")
+                sig=sig+rta
+                self.append_to_dataset("counts",rta[0])
+                self.append_to_dataset("time",self.t_exp*i/int(self.t_exp/self.t_med))
+
+                recon_dev=self.func(i,sig,mu,b,c,ruido)
+
+                b,c,fl,n=recon_dev[0],recon_dev[1],recon_dev[2],recon_dev[3]
+                #self.append_to_dataset("fluo",fl)
+                self.append_to_dataset("N_ions",n)
+                
+                #Chequeo cantidad de iones
+                if d==0:
+                    if n==self.N_ions_objective:
+                        d=1
+                        e=0
+                        self.ShutterClose()
+                    elif n>self.N_ions_objective:
+                        self.blinkRF()
+                        self.mutate_dataset("N_ions",-1,0)
+                        c=0
+                        b=i
+                        print("Cantidad de iones superada, reiniciando")
+                elif d==1 and e<self.waiting_time*self.t_med:
+                    if n==self.N_ions_objective:
+                        e=e+1
+                    else:
+                        d=0
+                        print("Abriendo shutters")
+                        self.ShutterOpen()
+                elif d==1 and e==self.waiting_time/self.t_med:
+                    print("Cantidad de iones alcanzada")
+                    break
+                
+                self.core.break_realtime()
+            
+        start_time=now_mu()  # Record the start timeself.core.break_realtime()
+        self.core.break_realtime()
+

artiq_master/repository/Tests/loadingions.py

@@ -6,58 +6,92 @@ Created on Fri May  3 22:37:57 2024
 
 import numpy as np
 from artiq.experiment import *
-#from pyLIAF.GenFunc.generador import Generador
+from time import sleep
+PORT = 60000
+PASS = b'Secr3t Pa55W0rd'
+from multiprocessing.connection import Client
 
 class InOut(EnvExperiment):
     """
-    Test de lectura de TTL y recopilacion de datos
+    Automatic calcium ion trapping in ring Paul trap
     """
     def build(self):
         self.setattr_device("core")
         self.setattr_device("ccb")
         self.ttl0 = self.get_device("ttl0")
         self.ttl4 = self.get_device("ttl4")
+        self.ttl6 = self.get_device("ttl6")
         
         self.setattr_argument(f"t_med",
                              NumberValue(300*ms, unit='ms', scale=ms, min=0.1*ms, max=1000*ms),
                             "Experiment params")
         
         self.setattr_argument("t_exp",
-                             NumberValue(200*s, unit='s', scale=s, min=5*s, max=3000*s),
+                             NumberValue(200*s, unit='s', scale=s, min=1*s, max=3000*s),
                             "Experiment params")
         
         self.setattr_argument("N_ions_objective",
                              NumberValue(1, min=1, max=15, ndecimals=0, step=1), 
                             "Experiment params")
-         
-        self.setattr_argument("Measurement_type",
-                                  EnumerationValue(["finite_time", "indefinite_time"]),
-                              "Scan params")
-
-#        self.setattr_argument("Nsigma",
-#                                  NumberValue(5, min=2, max=8,ndecimals=0, step=1),
-#                              "Scan params")
         
-        self.setattr_argument("tsub",
+        self.setattr_argument("waiting_time",
+                             NumberValue(60*s, unit='s',min=15*s, max=300*s), 
+                            "Experiment params")
+        
+        self.setattr_argument("tseg",
                                   NumberValue(2*s,unit='s',scale=s,min=1*s, max=3*s),
                               "Scan params")
         
-        self.setattr_argument("tbaj",
-                                  NumberValue(2*s,unit='s',scale=s,min=2*s, max=5*s),
-                              "Scan params")
+        self.setattr_argument("Calibration",
+                                  EnumerationValue(["Manual", "Automatic", "Use preexisting"]),
+                              "Calibration params")
+        
+        self.setattr_argument("First_ion_fluorescence",
+                                  NumberValue(1000, min=1, max=10000, ndecimals=0, step=1),
+                              "Calibration params")
+        
+        self.setattr_argument("Rest_ion_fluorescence",
+                                  NumberValue(700, min=1, max=10000, ndecimals=0, step=1),
+                              "Calibration params")
+
+        self.setattr_argument("Read_with",
+                                  EnumerationValue(["PMT", "Camera"]),
+                              "Experiment params")
+        
+        self.setattr_argument("N_tir",
+                                  NumberValue(10, min=1, max=10000, ndecimals=0, step=1),
+                              "Calibration params")
+        
+        self.setattr_argument("t_tir",
+                                  NumberValue(30*s, unit='s', min=15, max=120, ndecimals=0, step=1),
+                              "Calibration params")
+        
+    @rpc
+    def initialize_tca_com(self):
+        address = ('localhost', PORT)
+        self.conn = Client(address, authkey=PASS)
+        sleep(0.1)
+
+    @rpc
+    def blinkRF(self,cmd='turnOnOffRF'):
+        self.conn.send(f'{cmd} blink')
+        rta = self.conn.recv()
+        
         
     @rpc(flags={"async"})
     def create_datasets(self): 
         self.set_dataset('time', [], broadcast=True, archive=True)
         self.set_dataset('counts', [], broadcast=True, archive=True)
-        self.set_dataset('counts_indefinite',np.array([0.0]), broadcast=True, archive=False)
         self.set_dataset("N_ions", [], broadcast=False, archive=True)
+        self.set_dataset("fluo_calib", [], broadcast=True, archive=True)
+        self.set_dataset("fluo", [], broadcast=False, archive=True)
+        #self.set_dataset('Cuentas_transitorio', [0], broadcast=True, archive=True)
 
         
     @rpc(flags={"async"})
     def create_applets(self):
 
-        self.ccb.issue("create_applet", "test_IR_espectro_fixeddelays",
+        self.ccb.issue("create_applet", "test_cuentas",
                         "${python} -m pyLIAF.artiq.applets.plot_xy "
                         "counts "#Tiene que estar el espacio!!!
                         "--x time") #Aca habria que definir bien el vector que se use en el eje x
@@ -71,63 +105,363 @@ class InOut(EnvExperiment):
                         "${python} -m pyLIAF.artiq.applets.realtime "
                         "400 "
                         "counts_indefinite")
+        
+        self.ccb.issue("create_applet", "test_N_ions",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "N_ions "
+                        "--x time")
 
+    #Funciones para controlar el experimento
+    
+    @kernel
+    def ShutterClose(self):#Cierra los dos Shutters
+        self.core.break_realtime()
+        self.ttl6.on()
+        print("Shutter cerrado")
+    
+    @kernel
+    def ShutterOpen(self):#Abre los dos Shutters
+        self.core.break_realtime()
+        self.ttl6.off()
+        print("Shutter abierto")
+    
+    @rpc
+    def read_camera(self)  -> TInt64:#Realizar medición con la cámara
+        self.conn.send('rois_count True')
+        cuentas=self.conn.recv()
+        return int(cuentas[0])
+    
+    @kernel
+    def read_pmt(self,t_med)  -> TInt64:#Realizar medición con el PMT
+        cuentas=self.ttl0.gate_rising(t_med)
+        cuentas=self.ttl0.count(cuentas)
+        return int(cuentas)
+    
+    @kernel
+    def read_counts(self,t_med)  -> TInt64:
+        if self.Read_with=="Camera":
+            cuentas=self.read_camera()
+        else:
+            self.core.break_realtime()
+            cuentas=self.read_pmt(t_med)
+            self.core.break_realtime()
+        return cuentas
+    
+    #Funciones que calculan cosas en numpy
+    
     @rpc
-    def TurnOnRF(self):
-        pass
+    def ruidito(self,sig,b)  -> TInt64:#Calcula el ruido inicial, definido como el máximo de diferencia
+        sigo=np.array(sig)
+        a=b*(np.max(sigo)-np.min(sigo))
+        print("Ruido inicial = "+str(a))
+        return int(b*a)
     
     @rpc
-    def TurnOffRF(self):
-        pass
+    def diferencias(self,A)  -> TList(TInt64):#Calcula las diferencias entre componentes contiguas de una lista
+        return list(abs(np.diff(A)))
+
+    @rpc
+    def promedio(self,A)  -> TInt64:#Calcula promedios
+        return int(np.mean(A))
+    
+    @rpc
+    def promedio32(self,A)  -> TInt32:#Calcula promedios en int32 (problemas del artiq......)
+        return int(np.mean(A))
+    
+    @rpc
+    def diezmo(self,A)  -> TInt32:
+        a=np.mean(A)
+        err=np.std(A)
+        B=[]
+        for i in range(len(A)):
+            if A[i]>=(a+err):
+                z=1
+            else:
+                z=0
+            B.append(A[i]/(z+1))
+        return int(np.mean(B))
+
+    #Funciones que definen/modifican listas de python que no son utilizadas en el entorno de artiq
     
     @rpc
-    def Varianza(self,sig)  -> TList(TFloat):
-        ruido=np.std(sig)
-        print(ruido)
-        return [ruido]
+    def listas(self,oscuridad,ruido):
+        self.paso=[]
+        self.pasom=[]
+        self.med=[]
+        self.medmax=[]
+        self.N=[]
+        self.fluo=[oscuridad]
+        self.atrapados=[]
+        self.desviacion=[]
+        self.med=self.med+[oscuridad]
+        self.medmax=self.medmax+[oscuridad+ruido]
+        self.N=self.N+[0]
+
+    @rpc
+    def caida(self,i,s,ruido): #Resetea el codigo cuando se blinkea el generador(Ponerlo en funcion del promedio del escalon 0)
+        self.paso=self.paso+[i]
+        self.med[-1]=s[-1]
+        self.medmax[-1]=s[-1]+ruido
+        self.N[-1]=0
+        
+    @kernel
+    def ruido_inicial(self,t_med,t_ruido=3):#Calcula el ruido inicial. t_ruido debe estar en segundos. Con 3seg funciona bien
+        sig=[]
+        for i in range(int(t_ruido/self.t_med)):
+            rta=self.read_counts(self.t_med)
+            sig=sig+[rta]
+            self.core.break_realtime()
+        prom=self.promedio(sig)
+        print("Cuentas de oscuridad = ")
+        print(prom)
+        return prom,self.ruidito(sig,3) #El número es la cantidad de desviaciones
+        
+    #El famoso código de reconocimiento
+    
+    @rpc
+    def func(self,i,s,mu,mu0,b,c,ruido)  -> TList(TInt64):#Necesaria porque por alguna razon a artiq no le gusta que "Recon" funcione directo.
+        recon_dev=self.Recon(i,s,self.t_med,self.tseg,mu,mu0,b,c,ruido,self.paso,self.pasom,self.med,self.medmax,self.N,self.fluo,self.atrapados,self.desviacion)
+        print(recon_dev[3])
+        return recon_dev
+
+    @rpc
+    def Recon(self,i,s,med_ss,tseg,mu,mu0 #El famoso código de reconocimiento
+         ,b,c,ruido,paso,pasom,med,medmax,N,fluo,atrapados,desviacion)   -> TList(TInt64):
+        med_s=1/med_ss
+        med.append(np.mean(s[b:i-1]))
+        medmax.append(med[-1]+ruido)
+        g=0
+        if abs(s[i]-med[-2])>ruido: #Supera la cota
+            if (s[i]-med[-2])>0: #Supera por arriba
+                z=1
+            else:
+                z=-1
+            if c>(tseg*med_s): #Supera el criterio
+                medio_actual=np.mean(s[i-int(tseg*med_s-1):]) #Toma la fluo como el promedio de las ultimas mediciones
+                fluo.append(s[-1])                
+                #fluo.append(np.mean(s[b:i-int(tseg*med_s-1)]))
+                g=1
+                if N[-1]==0:
+                    mus=mu0
+                else:
+                    mus=mu
+#                if s[-1]<(fluo[0]+ruido):
+#                    atrapados.append(z*N[-1])
+#                    desviacion.append(.1)
+#                else:
+                a=abs(fluo[-1]-fluo[-2])
+                print(a)
+                atrapados.append(z*(1+round(abs(mus-a)/mu)))
+                print(atrapados)
+                desviacion.append(abs(mus-a)/mus)
+                if z==1:
+                    paso.append(i)
+                else:
+                    pasom.append(i)
+                for k in range(int(tseg*med_s+1)): #Fortaleciendo med
+                    med[-1-k]=s[i-k]
+                    medmax[-1-k]=s[i-k]+ruido
+                #Escribir la parte del ruido adaptativo
+                b=i-1
+                c=0
+                if len(fluo)==1:  #Cantidad de iones
+                    N.append(1)
+                else:
+                    N.append(N[-1]+atrapados[-1])
+                for k in range(len(N)):
+                    if (b+k-int(tseg*med_s+1))==(len(N)):
+                        break
+                    else:
+                        N[b+k-int(tseg*med_s+1)]=N[-1]
+            else:
+                med[-1]=med[-2]
+                medmax[-1]=medmax[-2]
+                c=c+1
+                N.append(N[-1])
+        else: #Cae dentro de la cota
+            c=0
+            N.append(N[-1])
+        #print(N[-1])
+        if g==0:
+            fluo_temporal=0
+        else:
+            fluo_temporal=fluo[-1]
+        return [b,c,int(fluo_temporal),int(N[-1])]
+
+    #Cuerpo principal del código
 
     @kernel
     def run(self): 
-        #Preparamos las variables y los graficos
+        #Inicializacion artiq
+        self.initialize_tca_com()
         self.create_datasets()
         self.create_applets()
-        #Se prenden los "canales" a usar
+        #Canales
         self.core.reset()
         self.ttl4.output()
         self.ttl0.input()
         self.ttl4.on()
+        self.ttl6.output()
+        #Blinkeo y apertura shutters
+        self.ShutterOpen()
+        self.blinkRF() #Tal vez se podria apagar al inicio y prender cuando termina de inicializar. Implementar
+        delay(20*ms)
         
-        delay(20*ms)  # time for the artiq init.
+        oscu,ruido0=self.ruido_inicial(self.t_med) #Oscu es el valor medio de las cuentas de oscuridad, ruido0 su varianza. (Es usado despues)
         
-        if self.Measurement_type=="indefinite_time":
-            while True:
-                cuentas=self.ttl0.gate_rising(self.t_med)
-                cuentas=self.ttl0.count(cuentas)
-                self.mutate_dataset("counts_indefinite",0,cuentas)
-                print(cuentas)
-                
-                self.core.break_realtime()
-                      
-        else:
-            sig=[]
-            for i in range(int(3/self.t_med)):
-                cuentas=self.ttl0.gate_rising(self.t_med)
-                sig=sig+[self.ttl0.count(cuentas)]
-                self.append_to_dataset("counts",sig[-1])
-                self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
+        if self.Calibration=="Manual":
+            mu0=self.First_ion_fluorescence
+            mu=self.Rest_ion_fluorescence
+        elif self.Calibration=="Automatic":
+            b=0
+            c=0
+            d=0 #Cantidad buscada? Si-No
+            e=0 #Tiempo con cantidad buscada
+
+            A0=[]
+            A=[]
+            k=0
+            kk=0
+            while k<(self.N_tir):#El ciclo se repite hasta que haya N_tir tiradas en que haya detectado algun ion.
+                s=[]
+                fluoresc=[oscu]
+                b=0
+                c=0
+                d=0
+                e=0
+                self.listas(oscu,ruido0)
                 self.core.break_realtime()
-            ruido=self.Varianza(sig)[0]
-            delay(10*ms)
+                delay(20*ms)
+                print('Tirada numero ')
+                print(kk+1)#El +1 esta para que comience con 1.
+                for i in range(int(self.t_tir/self.t_med)):
+                    rta = self.read_counts(self.t_med)
+                    #rta=self.get_dataset("Cuentas_transitorio")
+                    s=s+[rta]
+                    self.append_to_dataset("counts",rta)
+                    self.append_to_dataset("time",kk*self.t_tir+self.t_exp*i/int(self.t_exp/self.t_med))
+
+                    recon_dev=self.func(i,s,100,100,b,c,ruido0)
+                    b,c,fl,n=recon_dev[0],recon_dev[1],recon_dev[2],recon_dev[3]
+                    if fl!=0:
+                        fluoresc=fluoresc+[fl]
             
-            for i in range(int(3/self.t_med),int(self.t_exp/self.t_med)):
-                cuentas=self.ttl0.gate_rising(self.t_med)
-                cuentas=self.ttl0.count(cuentas)
-                self.append_to_dataset("counts",cuentas)   
-                self.append_to_dataset("time",i/int(self.t_exp/self.t_med))
-
-                print(cuentas)
-                                    
-                self.core.break_realtime()
+                    self.core.break_realtime()
+                
+                temporal=self.diferencias(fluoresc)
+                print("Fluorescencias atrapadas")
+                print(temporal)
+                if len(temporal)>1:
+                    A0=A0+[temporal[0]]
+                    A=A+temporal[1:]
+                    print("Fluorescencia del primero = ")
+                    print(temporal[0])
+                    print("Fluorescencia del resto= ")
+                    print(temporal[1:])
+                    k+=1
+                else:
+                    print("No se atrapó suficiente cantidad")
+                self.blinkRF()
+                kk+=1            
+
+
+            print("Fluorescencias primer ion = ")
+            print(A0)
+            print("Fluorescencias del resto = ")
+            print(A)
+            zzzz=self.diezmo(A)
+            print("Fluorescencia del resto con diezmo= ")
+            print(zzzz)
+            mu0=self.promedio32(A0)
+            mu=self.promedio32(A)
+            print("Calibración final del primero = ")
+            print(mu0)
+            print("Calibración final del resto = ")
+            print(mu)
+
+            self.set_dataset("calib",[mu0,mu], broadcast=True,archive=True)#Guarda la calibracion
+        else: #Utilizar calibración existente
+            mu0 = 1000
+            mu = 700
+#            try:
+#                calib_obtenida = self.get_dataset("calib")
+#            except:
+#                calib_obtenida = [2000,700]
+#            if calib_obtenida != None:
+#                print('1')
+#                #mu0 = calib_obtenida[0]
+#                #mu = calib_obtenida[1]
+#                mu0 = self.First_ion_fluorescence
+#                mu = self.Rest_ion_fluorescence
+#            else:
+#                print('No hay una calibracion preexistente, usando valores manuales')
+#                mu0=self.First_ion_fluorescence
+#                mu=self.Rest_ion_fluorescence
+        
+        #Imprimimos los valores calibrados de flurescencia que seran usados
+
+
+
+
+
+        #Luego de definir la calibracion comienza el codigo
+        self.create_datasets()
+        print("Fluorescencia del primero = ")
+        print(mu0)
+        print("Fluorescencia resto = ")
+        print(mu)
+        print("Calibracion finalizada")
+
+        self.core.break_realtime()
+        delay(10*ms)
+        sig=[]
+        b=0
+        c=0
+        d=0 #Cantidad buscada? Si-No
+        e=0 #Tiempo con cantidad buscada
+        self.listas(oscu,ruido0)
+        self.core.break_realtime()
+        delay(20*ms)
+        
+        for i in range(int(self.t_exp/self.t_med)):
+            rta = self.read_counts(self.t_med)
+            sig=sig+[rta]
+            self.append_to_dataset("counts",rta)
+            self.append_to_dataset("time",self.t_exp*i/int(self.t_exp/self.t_med))
+
+            recon_dev=self.func(i,sig,mu,mu0,b,c,ruido0)
+
+            b,c,fl,n=recon_dev[0],recon_dev[1],recon_dev[2],recon_dev[3]
+            #self.append_to_dataset("fluo",fl)
+            self.append_to_dataset("N_ions",n)
             
-        start_time = now_mu()  # Record the start timeself.core.break_realtime()
-        self.core.break_realtime()
\ No newline at end of file
+            #Chequeo cantidad de iones
+            if d==0:
+                if n==self.N_ions_objective:
+                    d=1
+                    e=0
+                    self.ShutterClose()
+                elif n>self.N_ions_objective:
+                    self.blinkRF()
+                    sig[-1]=sig[0] #tambien cambiar el valor de "counts"
+                    c=0
+                    b=i+1
+                    self.caida(i,sig,ruido0)
+                    print("Cantidad de iones superada, reiniciando")
+            elif d==1 and e<self.waiting_time/self.t_med:
+                if n==self.N_ions_objective:
+                    e=e+1
+                    print(e*self.t_med)
+                else:
+                    d=0
+                    self.ShutterOpen()
+            elif d==1 and e>=self.waiting_time/self.t_med:
+                print("Cantidad de iones alcanzada, finalizando")
+                break
+            
+            self.core.break_realtime()
+            
+        start_time=now_mu()  # Record the start 
+        self.core.break_realtime()
+
+

artiq_master/repository/Tests/loadingions_2.py

+"""
+Created on Fri May  3 22:37:57 2024
+
+@author: juamp y rom
+"""
+
+import numpy as np
+from artiq.experiment import *
+from time import sleep
+PORT = 60000
+PASS = b'Secr3t Pa55W0rd'
+from multiprocessing.connection import Client
+
+class InOut(EnvExperiment):
+    """
+    Reconocimiento iones 
+    """
+    def build(self):
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+        self.ttl0 = self.get_device("ttl0")
+        self.ttl4 = self.get_device("ttl4")
+        self.ttl6 = self.get_device("ttl6")
+        
+        self.setattr_argument(f"t_med",
+                             NumberValue(300*ms, unit='ms', scale=ms, min=0.1*ms, max=1000*ms),
+                            "Experiment params")
+        
+        self.setattr_argument("t_exp",
+                             NumberValue(200*s, unit='s', scale=s, min=1*s, max=3000*s),
+                            "Experiment params")
+        
+        self.setattr_argument("N_ions_objective",
+                             NumberValue(1, min=1, max=15, ndecimals=0, step=1), 
+                            "Experiment params")
+        
+        self.setattr_argument("waiting_time",
+                             NumberValue(60*s, unit='s',min=15*s, max=300*s), 
+                            "Experiment params")
+        
+        self.setattr_argument("tseg",
+                                  NumberValue(2*s,unit='s',scale=s,min=1*s, max=3*s),
+                              "Scan params")
+        
+        self.setattr_argument("Calibration",
+                                  BooleanValue(1==0),
+                              "Calibration params")
+        
+        self.setattr_argument("fluo per ion",
+                                  NumberValue(1, min=1, max=10000, ndecimals=0, step=1),
+                              "Calibration params")
+
+        self.setattr_argument("Read_with",
+                                  EnumerationValue(["PMT", "Camera"]),
+                              "Experiment params")
+        
+
+
+        
+    @rpc
+    def initialize_tca_com(self):
+        address = ('localhost', PORT)
+        self.conn = Client(address, authkey=PASS)
+        sleep(0.1)
+
+
+    @rpc
+    def blinkRF(self,cmd='turnOnOffRF'):
+        self.conn.send(f'{cmd} blink')
+        rta = self.conn.recv()
+        
+        
+    @rpc(flags={"async"})
+    def create_datasets(self): 
+        self.set_dataset('time', [], broadcast=True, archive=True)
+        self.set_dataset('counts', [], broadcast=True, archive=True)
+        self.set_dataset("N_ions", [], broadcast=False, archive=True)
+        self.set_dataset("fluo", [], broadcast=False, archive=True)
+        self.set_dataset('Cuentas', [], broadcast=True, archive=True)
+
+        
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "test_IR_espectro_fixeddelays",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "#Tiene que estar el espacio!!!
+                        "--x time") #Aca habria que definir bien el vector que se use en el eje x
+
+        self.ccb.issue("create_applet", "test_histogram_realtime",
+                        "${python} -m pyLIAF.artiq.applets.histogram "
+                        "counts "
+                        "--update-delay 0.2")
+        
+        self.ccb.issue("create_applet", "test_histogram_realtime_indefinite",
+                        "${python} -m pyLIAF.artiq.applets.realtime "
+                        "400 "
+                        "counts_indefinite")
+        
+        self.ccb.issue("create_applet", "test_N_ions",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "N_ions "
+                        "--x time")
+
+    
+    @kernel
+    def ShutterClose(self):#Que controle el prendido de los dos Shutters #Abre
+        self.core.break_realtime()
+        self.ttl6.on()
+        print("Cerrado")
+    
+    @kernel
+    def ShutterOpen(self):#Que controle el apagado de los dos Shutters #Cierra
+        self.core.break_realtime()
+        self.ttl6.off()
+        print("Abierto")
+    
+#    @rpc
+#    def Varianza(self,sig)  -> TList(TFloat):
+#        ruido=np.std(sig)
+#        print(ruido)
+#        return [ruido]
+    
+    @rpc
+    def listas(self,sig,ruido):
+        self.paso=[]
+        self.pasom=[]
+        self.med=[]
+        self.medmax=[]
+        self.N=[]
+        self.fluo=[]
+        self.atrapados=[]
+        self.desviacion=[]
+        for i in range(int(3/self.t_med)):
+            self.med=self.med+[sig[i]]
+            self.medmax=self.medmax+[sig[i]+ruido]
+            self.N=self.N+[0]
+                
+    @rpc
+    def func(self,i,s,mu,b,c,ruido)  -> TList(TInt64):
+        recon_dev = self.Recon(i,s,self.t_med,self.tseg,mu,b,c,ruido,self.paso,self.pasom,self.med,self.medmax,self.N,self.fluo,self.atrapados,self.desviacion)
+        return recon_dev
+
+    @rpc
+    def read_counts(self,t_med):
+        if self.Read_with=="Camera":
+            self.conn.send('rois_count True')
+            cuentas=self.conn.recv()
+            self.append_to_dataset("Cuentas",cuentas)
+        else:
+            cuentas=self.ttl0.gate_rising(t_med)
+            cuentas=self.ttl0.count(cuentas)
+            self.append_to_dataset("Cuentas",cuentas)
+
+
+    @rpc
+    def Recon(self, i,s,med_ss,tseg,mu,b,c,ruido,paso,pasom,med,medmax,N,fluo,atrapados,desviacion)  -> TList(TInt64):
+        """
+        Funcion que reconoce iones
+        i: iteracion
+        s: vector de mediciones
+        """
+        med_s=1/med_ss
+        med.append(np.mean(s[b:i-1]))
+        medmax.append(med[-1]+ruido)
+        if abs(s[i]-med[-2])>ruido: #Supera la cota
+            if (s[i]-med[-2])>0: #Supera por arriba
+                z=1
+            else:
+                z=-1
+            if c>(tseg*med_s): #Supera el criterio
+                fluo.append(np.mean(s[b:i-int(tseg*med_s+1)]))
+                if len(fluo)>1:
+                    a=abs(fluo[-1]-fluo[-2])
+                    print(a)
+                    A=[]
+                    for k in range(len(mu)):
+                        A.append(abs(a-mu[k]))
+                    atrapados.append(np.argmin(A)+1)
+                    desviacion.append(min(A))
+                if z==1:
+                    paso.append(i)
+                else:
+                    pasom.append(i)
+                for k in range(int(tseg*med_s+1)): #Fortaleciendo med
+                    med[-1-k]=s[i-k]
+                    medmax[-1-k]=s[i-k]+ruido
+                if z==1:
+                    if len(paso)>1 and (paso[-1]-paso[-2])<(tseg*med_s): #Limpieza y ruido adaptativo, cuando aumenta N
+                        paso.pop(-2)
+                        N[-1]=N[-2]
+                else:
+                    if len(pasom)>1 and (pasom[-1]-pasom[-2])<(tseg*med_s) and z==-1: #Limpieza
+                        pasom.pop(-2)
+                        N[-1]=N[-2]
+                b=i-1
+                c=0
+                if len(fluo)==1:  #Cantidad de iones
+                    N.append(1)
+                else:
+                    N.append(N[-1]+z*atrapados[-1])
+                for k in range(len(N)):
+                    if (b+k-int(tseg*med_s+1))==(len(N)):
+                        break
+                    else:
+                        N[b+k-int(tseg*med_s+1)]=N[-1]
+            else:
+                med[-1]=med[-2]
+                medmax[-1]=medmax[-2]
+                c=c+1
+                N.append(N[-1])
+        else: #Cae dentro de la cota
+            c=0
+            N.append(N[-1])
+        print(N[-1])
+        return [b,c,0,N[-1]]
+
+    @kernel
+    def run(self): 
+        #Preparamos las variables y los graficos
+        self.initialize_tca_com()
+        self.create_datasets()
+        self.create_applets()
+        #Se prenden los "canales" a usar
+        self.core.reset()
+        self.ttl4.output()
+        self.ttl0.input()
+        self.ttl4.on()
+        self.ttl6.output()
+        self.ShutterOpen()
+        delay(20*ms)
+      
+        
+        if self.Calibration==True:
+            #mu=calib
+            mu=[500*i for i in [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]]
+        else:
+            #mu=self.load_calibration()
+            mu=[500*i for i in [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]]
+        
+            self.core.break_realtime()
+            delay(10*ms)
+            sig=[]
+            s=[]
+            b=0
+            c=0
+            d=0 #Cantidad buscada? Si-No
+            e=0 #Tiempo con cantidad buscada
+            for i in range(int(3/self.t_med)):
+                self.read_counts(self.t_med)
+                self.append_to_dataset("time",self.t_exp*i/int(self.t_exp/self.t_med))
+                self.core.break_realtime()
+            ruido=.5*mu[0]
+            self.listas(sig,ruido)         
+            self.core.break_realtime()
+            delay(20*ms)
+            
+            for i in range(int(3/self.t_med),int(self.t_exp/self.t_med)):
+                self.read_counts(self.t_med)
+                self.append_to_dataset("time",self.t_exp*i/int(self.t_exp/self.t_med))
+
+                recon_dev=self.func(i,s,mu,b,c,ruido)
+
+"""                b,c,fl,n=recon_dev[0],recon_dev[1],recon_dev[2],recon_dev[3]
+                #self.append_to_dataset("fluo",fl)
+                self.append_to_dataset("N_ions",n)
+                
+                #Chequeo cantidad de iones
+                if d==0:
+                    if n==self.N_ions_objective:
+                        d=1
+                        e=0
+                        self.ShutterClose()
+                    elif n>self.N_ions_objective:
+                        self.blinkRF()
+                        print("Cantidad de iones superada, reiniciando")
+                elif d==1 and e<self.waiting_time*self.t_med:
+                    if n==self.N_ions_objective:
+                        e=e+1
+                        print(e)
+                    else:
+                        d=0
+                        print("Abriendo shutters")
+                        self.ShutterOpen()
+                elif d==1 and e>self.waiting_time*self.t_med:
+                    print("Cantidad de iones alcanzada")
+                    break
+                                    """
+                self.core.break_realtime()
+            
+        start_time=now_mu()  # Record the start timeself.core.break_realtime()
+        self.core.break_realtime()
+
+

artiq_master/repository/Tests/seguridad.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 26 15:49:53 2024
+
+@author: liaf-ankylosaurus-admin
+"""
+#%%
+import pyvisa
+from time import sleep
+
+instruction="blink"
+
+
+rm=pyvisa.ResourceManager("@py")
+gen= rm.open_resource('TCPIP0::192.168.1.245::INSTR')
+        
+def TurnOn(channel=1):
+    gen.write(f"OUTPut{channel}:STATe ON")
+
+def TurnOff(channel=1):
+    gen.write(f"OUTPut{channel}:STATe OFF")
+
+if instruction=="blink":
+    TurnOff()
+    sleep(1)
+    TurnOn()
+    
+elif instruction=="on":
+    TurnOn()
+
+elif instruction=="off":
+    TurnOff()
+
+else:
+    print('wrong instruction')
+
+gen.close()
\ No newline at end of file