agrego meds despues de mucho tiempo

artiq_master/last_rid.pyon

-17973
+19363

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