mediciones del 2207

analisis/plots/20250716_fluorescence_correlation/check_rffrequency.py

@@ -89,10 +89,8 @@ Esto deberia hacerse asi para ver la oscilacion a la RF (micromocion)
 BINW = 1e-3
 T0 = -0.4e-6
 
-#files = [20577,20578,20579,20580,20581] #el 19613 es el que muestra el pico en 48.5 Hz
 
-files = [22809,22813,22817,22818,22819,22820] 
-files  =  [22838]
+files  =  [22845]
 
 def bin_time_arrivals(arrival_times, tau):
     """
@@ -134,8 +132,8 @@ for i, fname in enumerate(files):
     Amplitud en funcion de la frecuencia de bineo de la rf
     """
     
-    freqrf = 7.186226e6
-    freqrfvec = np.arange(-4,4,0.01) + freqrf
+    freqrf =  7186226.67
+    freqrfvec = freqrf + np.arange(-5,5,0.01)
     
     amps = []
     
@@ -176,8 +174,8 @@ Grafico temporal replicado 3 veces a la frecuencia dada
 
 
 #freqrf = 7262766.13
-
-taurf = 1/(4e-7+freqrf)
+freqrf = 7186226.62
+taurf = 1/(freqrf)
 
 tiemposarreglados = bin_time_arrivals(counts, taurf)
 

analisis/plots/20250721_tickling_for_mm/check_rffrequency.py

+import h5py
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+import re
+import ast
+from scipy.optimize import curve_fit
+import os
+
+#os.chdir('/home/nico/Documents/artiq_experiments/analisis/plots/20221006_transitoriosv2')
+
+# os.chdir('/home/nico/Documents/artiq_experiments/analisis/plots/20250408_FluorescenceCorrelationsTests/Data1')
+
+def expo(T, tau, N0, C):
+    
+    global T0
+    return N0*np.exp(-(T-T0)/tau) + C
+
+def pow_from_amp(amp):
+    """Paso de amplitud urukul a potencia medida por Nico"""
+    # Forma altamente ineficiente de hacer esto, pero me salio asi
+    amplitudes_UV = np.flip(np.array([0.08, 0.10, 0.12, 0.14, 0.16, 0.18, 0.20, 0.22, 0.24, 0.26, 0.28, 0.30]))
+    assert amp in amplitudes_UV
+    potencias_UV = np.flip(np.array([4, 10, 19, 32, 49, 71, 96, 125, 155, 183, 208, 229]))
+    return potencias_UV[np.where(amplitudes_UV == amp)][0]
+
+
+def SP_Bkgr_builder(amp_in, amp_fin, derivadainicio, derivadafin, longbins):
+    CalibCurve = []
+    j=0
+    while j<longbins:
+        if j<=derivadainicio:
+            CalibCurve.append(amp_in)
+        elif j>=derivadainicio and j<=derivadafin:
+            pendiente=(amp_fin-amp_in)/(derivadafin-derivadainicio)
+            CalibCurve.append(amp_in+pendiente*(j-derivadainicio))
+        else:
+            CalibCurve.append(amp_fin)
+        j=j+1
+    return CalibCurve
+
+    
+
+"""
+plt.plot(amplitudes_UV, potencias_UV, 'ko-', lw=0.2)
+plt.xlabel("Amplitud Urukul")
+plt.ylabel("Potencia /uW")
+plt.grid()
+"""
+#%%
+import scipy.fftpack
+
+BINW = 1e-2
+T0 = -0.4e-6
+
+files = [22838]
+
+SP_Heigths = []
+SP_Bins = []
+
+for i, fname in enumerate(files):
+    #print(i)
+    #print(fname)
+    #data = h5py.File('0000'+str(fname)+'-MicromotionCompensation.h5', 'r')
+    data = h5py.File('./Data/0000'+str(fname)+'-FluorescenceCorrelation.h5', 'r')
+    # counts = np.array(data['datasets']['countsrf'])
+    counts = np.array(data['datasets']['time_stamps'])
+    bines = np.arange(counts.min(), counts.max()+BINW, BINW)
+
+    heigs, binsf  = np.histogram(counts, bines[bines>T0])
+    
+    SP_Heigths.append(heigs)
+    SP_Bins.append(binsf)
+
+
+#freq: 7.262 mhZ
+for k in range(len(counts)):
+    print(counts[k]-counts[k-1])
+    #print(1e-6/(counts[k]-counts[k-1]))
+
+
+
+#%%
+
+"""
+Esto deberia hacerse asi para ver la oscilacion a la RF (micromocion)
+"""
+
+BINW = 1e-3
+T0 = -0.4e-6
+
+#files = [20577,20578,20579,20580,20581] #el 19613 es el que muestra el pico en 48.5 Hz
+
+files = [22809,22813,22817,22818,22819,22820] 
+files  =  [22838]
+
+def bin_time_arrivals(arrival_times, tau):
+    """
+    Binea los tiempos de llegada de los fotones según el periodo tau.
+    
+    Parameters:
+        arrival_times (numpy array): Vector con los tiempos de llegada de los fotones.
+        tau (float): Periodo de bineado.
+        
+    Returns:
+        numpy array: Vector con los tiempos bienados.
+    """
+    return arrival_times - tau * (arrival_times // tau)
+
+
+SP_Heigths = []
+SP_Bins = []
+
+
+plt.figure()
+
+for i, fname in enumerate(files):
+    #print(i)
+    #print(fname)
+    data = h5py.File('./Data/0000'+str(fname)+'-FluorescenceCorrelation.h5', 'r')
+    counts = np.array(data['datasets']['time_stamps'])
+    bines = np.arange(counts.min(), counts.max()+BINW, BINW)
+
+    heigs, binsf  = np.histogram(counts, bines[bines>T0])
+    
+    SP_Heigths.append(heigs)
+    SP_Bins.append(binsf)
+    
+    
+
+    
+    
+    """
+    Amplitud en funcion de la frecuencia de bineo de la rf
+    """
+    
+    freqrf = 7.186226e6
+    freqrfvec = np.arange(-4,4,0.01) + freqrf
+    
+    amps = []
+    
+    
+    for freqrf in freqrfvec:
+        taurf = 1/freqrf
+        
+        tiemposarreglados = bin_time_arrivals(counts, taurf)
+        
+        b = taurf/500  # Ancho de bineo
+        bins = np.arange(0, taurf, b)
+        hist, bin_edges = np.histogram(tiemposarreglados, bins=bins)
+        
+        colors = ['b', 'g', 'r']  # Colores para cada repetición
+        
+        x_extended = np.concatenate([bin_edges[:-1] + i * taurf for i in range(3)])
+        y_extended = np.tile(hist, 3)
+        
+        def sinusoidal(x, A, C, D):
+            return A * np.sin(2*np.pi*freqrf * x + C) + D
+        
+        x_extended_dense = np.arange(np.min(x_extended),np.max(x_extended),0.1*(x_extended[1]-x_extended[0]))
+        
+        params, _ = curve_fit(sinusoidal, x_extended, y_extended, p0=[max(y_extended),  0, np.mean(y_extended)])
+        amps.append(np.abs(params[0]))
+
+
+    plt.plot([f*1e-6 for f in freqrfvec],amps,'o')
+    print(freqrfvec[np.argmax(amps)])
+plt.xlabel('Frecuencia RF (MHz)')
+plt.ylabel('Amplitud oscilacion')
+#plt.axvline(7262766.13*1e-6,linewidth=4,color='red',linestyle='dashed')
+#%%
+
+"""
+Grafico temporal replicado 3 veces a la frecuencia dada
+"""
+
+
+#freqrf = 7262766.13
+
+taurf = 1/(4e-7+freqrf)
+
+tiemposarreglados = bin_time_arrivals(counts, taurf)
+
+b = taurf/50  # Ancho de bineo
+bins = np.arange(0, taurf, b)
+hist, bin_edges = np.histogram(tiemposarreglados, bins=bins)
+
+colors = ['b', 'g', 'r']  # Colores para cada repetición
+
+x_extended = np.concatenate([bin_edges[:-1] + i * taurf for i in range(3)])
+y_extended = np.tile(hist, 3)
+
+def sinusoidal(x, A, C, D):
+    return A * np.sin(2*np.pi*freqrf * x + C) + D
+
+def lorentzian(x,A,b,C,det,fase,cte):
+    det = -10e6*2*np.pi
+    return A*((C**2)/(C**2 + (det-b*2*np.pi*freqrf*np.sin(2*np.pi*freqrf*x+fase))**2))+cte
+
+x_extended_dense = np.arange(np.min(x_extended),np.max(x_extended),0.1*(x_extended[1]-x_extended[0]))
+
+params, _ = curve_fit(sinusoidal, x_extended, y_extended, p0=[max(y_extended),  0, np.mean(y_extended)])
+#params, _ = curve_fit(lorentzian, x_extended, y_extended, p0=[1,1e-3,1e7,1e4,1,1])
+amps.append(np.abs(params[0]))
+
+
+# Graficar los datos y el ajuste
+plt.figure(figsize=(8, 4))
+
+#plt.plot(x_extended_dense, sinusoidal(x_extended_dense, *params), linestyle='--', label="Ajuste sinusoidal", color='black',linewidth=3,zorder=2)
+#plt.plot(x_extended_dense, lorentzian(x_extended_dense, *params), linestyle='--', label="Ajuste completo", color='black',linewidth=3,zorder=2)
+
+for i in range(3):
+    plt.plot(bin_edges[:-1] + i * taurf, hist, marker='o', linestyle='-', color=colors[i],markersize=3,zorder=1)
+
+plt.xlabel("Tiempo bineado (repetido 3 veces)")
+plt.ylabel("Frecuencia")
+plt.title("Distribución de tiempos bineados con ajuste completo")
+#plt.ylim(0,np.max(hist)*1.2)
+plt.ylim(0,400)
+plt.legend()
+plt.show()
+
+print(f'Amplitud normalizada: {np.abs(round(100*params[0]/params[2],3))}%')
+
+print(f'Beta: {np.abs(params[1])}')
+
+print(f'Amplitud: {params[0]}')

artiq_master/last_rid.pyon

-22886
+23015

artiq_master/repository/Tests/blink_ir.py

+from artiq.experiment import *
+from pyLIAF.artiq.controllers import UrukulCh
+#from artiq.coredevice.ad9910 import PHASE_MODE_ABSOLUTE
+import time
+import numpy as np
+
+class IR_Scan_simple(EnvExperiment):
+    """BlinkIR"""
+    def build(self):
+        # Agrego kernel invariants a ver si mejoro algo de la performance
+        kernel_invariants = getattr(self, 'kernel_invariants', set())
+        self.kernel_invariants = kernel_invariants | {"no_measures", "t_cool", "t_trans", "t_readout"}
+
+        self.setattr_device("core")
+        self.setattr_device("ccb")
+
+        self.pmt = self.get_device("ttl0")
+
+        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.laserIR3 = UrukulCh(self, ch=0, freq=215.0, amp=0.5, name="IR3") #corresponde a 0.8 Vpp
+
+        self.setattr_argument("no_measures",
+                              NumberValue(2000, min=1, ndecimals=0, step=1),
+                              "Experiment params")
+        self.setattr_argument("n_time",
+                              NumberValue(2000, min=1, ndecimals=0, step=1),
+                              "Experiment params")        
+
+
+        self.setattr_argument(f"IR1_cooling_freq",
+                              NumberValue(230*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"UV_cooling_freq",
+                              NumberValue(108*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_cooling_amp",
+                              NumberValue(0.05, min=0.0, max=0.3),
+                             "Cooling params")
+        
+        self.setattr_argument(f"IR3_cooling_freq",
+                              NumberValue(215*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "Cooling params")
+
+        self.setattr_argument(f"IR3_cooling_amp",
+                              NumberValue(0.5, min=0.0, max=0.7),
+                             "Cooling params")
+
+        self.setattr_argument(f"UV_CPT_freq",
+                              NumberValue(110*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"UV_CPT_amp",
+                              NumberValue(0.05, min=0.000, max=0.300, step=0.001),
+                             "CPT params")
+
+        self.setattr_argument(f"IR2_CPT_freq",
+                              NumberValue(85*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),
+                             "CPT params")
+
+        self.setattr_argument(f"IR2_CPT_amp",
+                              NumberValue(0.3, min=0., max=0.8),
+                             "CPT params")
+
+
+        self.setattr_argument(f"t_cool",
+                              NumberValue(1*ms, unit='ms', scale=ms, min=0.001*ms),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_trans",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+        self.setattr_argument(f"t_readout",
+                              NumberValue(200*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+        self.setattr_argument("Blink_IR3",BooleanValue(1==0),"Experiment params")
+
+
+        self.setattr_argument("Comments", StringValue(" "), "General comments")
+
+
+    @rpc
+    def create_datasets(self):
+
+
+        self.set_dataset("no_measures", self.no_measures, broadcast=True, 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("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("IR3_cooling_freq", self.IR3_cooling_freq, broadcast=False, archive=True)
+        self.set_dataset("IR3_cooling_amp", self.IR3_cooling_amp, broadcast=False, archive=True)
+
+        self.set_dataset("UV_CPT_freq", self.UV_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("UV_CPT_amp", self.UV_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("IR2_CPT_freq", self.IR2_CPT_freq, broadcast=False, archive=True)
+        self.set_dataset("IR2_CPT_amp", self.IR2_CPT_amp, broadcast=False, archive=True)
+
+        self.set_dataset("t_cool", self.t_cool, broadcast=False, archive=True)
+        self.set_dataset("t_trans", self.t_trans, broadcast=False, archive=True)
+        self.set_dataset("t_readout", self.t_readout, broadcast=False, archive=True)
+
+        self.set_dataset("Experiment_freqs_IR", [float(f) for f in np.arange(0,self.n_time)],broadcast = True,archive=True)
+        self.set_dataset("Comments", self.Comments, broadcast=False, archive=True)
+
+
+    @rpc(flags={"async"})
+    def create_applets(self, no_freqs):
+
+        self.ccb.issue("create_applet", "IR_espectro",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts_spectrum "
+                        "--x IR1_Frequencies")
+    @rpc
+    def Get_Calibrated_Frequencies(self)  -> TList(TFloat):
+
+        Calibrated_Experiment_freqs = self.get_dataset("Experiment_freqs_IR")
+        self.set_dataset("IR1_Frequencies_calibrated", np.array(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+
+        
+        Experiment_freqs = Calibrated_Experiment_freqs
+
+        self.set_dataset("IR1_Frequencies", np.array(Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("no_freqs", len(Calibrated_Experiment_freqs), broadcast=True, archive=True)
+        self.set_dataset("counts_spectrum", np.zeros(len(Experiment_freqs), dtype=int), broadcast=True, archive=True)
+        return Experiment_freqs
+
+    @rpc
+    def Get_Final_Params(self)  -> TList(TFloat):
+        finalIR1_freq = self.get_dataset("IR1_freq")
+        finalIR1_amp = self.get_dataset("IR1_amp")
+        finalUV_freq = self.get_dataset("UV_freq")
+        finalUV_amp = self.get_dataset("UV_amp")
+        finalIR2_freq = self.get_dataset("IR2_freq")
+        finalIR2_amp = self.get_dataset("IR2_amp")
+        finalIR3_freq = self.get_dataset("IR3_freq")
+        finalIR3_amp = self.get_dataset("IR3_amp")
+        return [finalIR1_freq, finalIR1_amp, finalUV_freq, finalUV_amp, finalIR2_freq, finalIR2_amp, finalIR3_freq, finalIR3_amp]
+
+
+    @kernel
+    def run(self):
+
+        t_cool_mu = self.core.seconds_to_mu(self.t_cool) # Precomputo esto para despues         
+        cuentas = 0
+        self.create_datasets()
+        Freqs = self.Get_Calibrated_Frequencies()
+        print(Freqs)
+                
+        self.create_applets(len(Freqs))
+        self.init_kernel()
+        delay(1*ms)
+
+        self.laserIR1.on()
+        self.laserIR2.on()
+        self.laserIR3.on()
+        self.laserUV.on()
+
+        self.enfriar_ion()
+
+        iter_index = 0
+        
+        while iter_index < len(Freqs):
+            #print(Freqs[iter_index])
+            #print(Amps[iter_index])
+            Accumulated_counts = 0
+            delay(10000*us)
+            for runN in range(self.no_measures):
+                if runN % 5 == 0:
+                    delay(self.t_cool)
+                else:
+                    delay(100*us)
+                cuentas = self.readout() # Hago la medicion y vuelvo con las cuentas
+                Accumulated_counts = Accumulated_counts + cuentas
+            self.mutate_dataset("counts_spectrum", iter_index, Accumulated_counts)
+            delay(5000*us)
+            iter_index = iter_index + 1
+        
+        delay(500*us)
+
+        self.laserUV.select_profile(1)
+        self.laserIR1.select_profile(1)
+        self.laserIR2.select_profile(1)
+
+
+        final = self.Get_Final_Params()
+
+        self.core.break_realtime()
+        delay(10*ms)
+
+        self.laserIR1.set_frequency(final[0], final[1], profile=1)
+        self.laserUV.set_frequency(final[2], final[3], profile=1)
+        self.laserIR2.set_frequency(final[4], final[5], profile=1)
+        self.laserIR3.set_frequency(final[6], final[7], profile=1)
+        
+        print("jose maria listorti")
+
+    @kernel
+    def init_kernel(self):
+        self.core.reset()
+        self.pmt.input()
+        #self.laserUV.initialize_channel()
+        #self.laserIR.initialize_channel()
+        delay(1*ms)
+        # Seteo los perfiles 0 y 1 con los mismos valores
+        # el 0 va a ser el de ENFRIADO, el 1 va a ser el de MEDICION y el 2 va a ser de CALENTAMIENTO
+        self.laserIR1.set_channel()
+        self.laserUV.set_channel()
+        self.laserIR2.set_channel()
+        self.laserIR3.set_channel()
+        self.laserIR1.set_frequency(self.IR1_cooling_freq, self.IR1_cooling_amp, profile=0)
+        self.laserIR3.set_frequency(self.IR3_cooling_freq, self.IR3_cooling_amp, profile=0)
+        self.laserUV.set_frequency(self.UV_cooling_freq, self.UV_cooling_amp, profile=0)
+        self.laserIR2.set_frequency(self.IR2_CPT_freq, self.IR2_CPT_amp, profile=0)
+        self.laserIR1.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserUV.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR3.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserIR2.set_channel(profile=1)
+        self.core.break_realtime()
+        self.laserUV.set_frequency(self.UV_CPT_freq, self.UV_CPT_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR2.set_frequency(self.IR2_CPT_freq, self.IR2_CPT_amp, profile=1)
+        self.core.break_realtime()
+        self.laserIR3.set_frequency(self.IR3_cooling_freq, self.IR3_cooling_amp,profile=1)
+        self.core.break_realtime()
+        # Me aseguro que todo termine antes de seguir
+        self.core.break_realtime()
+        self.core.wait_until_mu(now_mu())
+
+
+    @kernel
+    def enfriar_ion(self):
+        """Enfrio llevando el laser IR a una cierta frecuencia"""
+        self.laserIR1.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserUV.select_profile(0) # Pongo el laser en el perfil referencia
+        self.laserIR2.select_profile(0)
+        self.laserIR2.off()
+        self.laserIR3.select_profile(0)
+
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+
+        self.laserUV.select_profile(1) # Paso al perfil que cambia
+        self.laserIR1.select_profile(1) # Paso al perfil que cambia
+        self.laserIR2.select_profile(1) # Paso al perfil que cambia
+        self.laserIR2.on()        
+        self.laserIR3.select_profile(1)
+        if self.Blink_IR3 == True:        
+            self.laserIR3.off()
+        else:        
+            self.laserIR3.on()
+        delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas

artiq_master/repository/Tests/test_barrido_iseg.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Suppress specific pylance warnings 
+# pyright: reportMissingImports=false, reportUndefinedVariable=false
+
+
+"""
+Barrer un laser con la Iseg y adquirir
+"""
+
+from artiq.experiment import *
+
+from artiq.experiment import ( EnvExperiment, NumberValue, kernel,
+                               ms, us, delay, rpc )
+
+import numpy as np
+
+import time
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
+import requests
+import re
+
+
+CAMERA_TTL_NUM = 5
+
+class BarridoIseg(EnvExperiment):
+    """
+    Barrido Iseg
+    """
+
+    def voltageupdate(self,channel,voltage):
+        BASE_URL = 'http://liaf-iseg/api/setItem/55005e1a49cad-69/0/0/'+f'{channel:.0f}'+'/Control.voltageSet/'+f'{voltage:.2f}'+'/V'
+        response = requests.post(f"{BASE_URL}")
+
+    def build(self):
+        self.setattr_device("core")
+
+
+        ## Defino las ttls #####################################################
+        #self.camera_trigger = self.get_device(f"ttl{CAMERA_TTL_NUM}")
+
+
+        ## Controles de GUI ####################################################
+        # número de pulsos a enviar
+        self.setattr_argument("number",
+                            NumberValue(80, unit='', ndecimals=0, scale=1, step=1, type='int')
+                            )
+        
+        
+        self.setattr_argument("Voltage_Down",
+                            NumberValue(100, unit='', ndecimals=0, scale=0.1, step=0.1)
+                            )
+    
+        self.setattr_argument("Voltage_Set",
+                    NumberValue(0, unit='', ndecimals=0, scale=0.1, step=0.1)
+                    )
+    
+
+        self.setattr_argument("time_exposure",
+                            NumberValue(500*ms, unit='ms', ndecimals=10, step=1*ms,)
+                            )
+        
+        self.setattr_argument("time_delay",
+                            NumberValue(500*ms, unit='ms', ndecimals=1, step=1*ms,),
+                            "Triggers Settings"
+                            )
+        
+        self.setattr_argument("time_width",
+                            NumberValue(10*ms, unit='ms', ndecimals=10, step=1*ms,),
+                            "Triggers Settings"
+                            )
+
+    @rpc
+    def create_datasets(self):
+        self.set_dataset("count", np.zeros(self.number, dtype=float), broadcast=True, archive=True)
+
+    
+    @rpc
+    def run(self):
+        "Ejecución. Preparamos los dispositivos y llamamos al kernel."
+
+        self.create_datasets()
+
+        self.voltageupdate(2,self.Voltage_Set)
+
+        voltages=np.linspace(self.Voltage_Set,self.Voltage_Down,self.number)
+
+        #camera_set_exposure(self.time_exposure)
+        time.sleep(2)
+
+        # Reemplazo este código original por algo que usa GRAB
+
+
+        for jj in range(self.number):
+            self.voltageupdate(2,voltages[jj])
+            time.sleep(0.05)
+            #camera_snap_roi(gui=True,block=False)
+            time.sleep(self.time_delay)
+            #snap=cmd('get_response')
+            self.mutate_dataset("count", jj, 1 )
+
+        print('FIN')
+'''
+
+    @kernel
+    def conf(self):
+        "Configuración del dispositivo"
+        self.core.reset()
+        self.camera_trigger.output()
+        delay(16*ms)
+    
+    @kernel
+    def fire_trigger(self):
+        "Envío y medición de pulsos"
+        self.conf()
+
+        self.camera_trigger.on()
+        delay( self.time_width )
+        self.camera_trigger.off()
+        delay( self.time_delay )
+
+    @kernel
+    def fire(self):
+
+        self.conf()
+        delay(10*ms)
+
+        for _ in range(self.number+5):
+            self.fire_trigger()
+        
+'''
+  

my-artiq-env.nix

@@ -10,14 +10,14 @@ in
         # List desired Python packages here.
  
         artiq-full.artiq
-        artiq-full.artiq-comtools
- 
+        artiq-full.artiq-comtools 
         ps.pandas
         ps.numpy
         ps.scipy
         ps.matplotlib.override { enableQt = true; }
         ps.ipython
         ps.setuptools
+        #ps.requests
         #ps.spyder # esto lo rompe
       ]))