agrego meds

artiq_master/last_rid.pyon

-10803
+11074

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

@@ -186,7 +186,7 @@ class AD9910RAM(EnvExperiment):
 
         #reset core
         self.core.reset()
-
+        self.core.break_realtime()
         #initialise
         self.u[self._channel].cpld.init()
         self.u[self._channel].init()

artiq_master/repository/Experiments/Spectrum/With_calibration/Motional/urukul_RAM_AM_scan_ch3.py → artiq_master/repository/Experiments/Spectrum/With_calibration/Motional/urukul_RAM_AM_ch3.py

@@ -4,13 +4,11 @@ from artiq.coredevice.ad9910 import (                                       #Imp
 
 from numpy import load,sin,linspace,pi,array
 
-from time import sleep, time
-
 # This code demonstrates use of the urukul RAM.
-# It has a GUI for Artiq
+# It produces a 50 MHz square waveform attenuated
 
 
-FILENAME = "/home/liaf-ankylosaurus-admin/Documents/artiq/artiq_master/repository/Experiments/Spectrum/With_calibration/Motional/parametros_AM.npz"
+FILENAME = "/home/liaf-ankylosaurus-admin/Documents/artiq/artiq_master/repository/Examples/Amplitude_Modulation/parametros_AM.npz"
 
 dd = load(FILENAME)['dd']
 
@@ -51,8 +49,10 @@ def get_urukul_params(f0: TFloat) -> list:
         f0 (float): frequency to set on AM
     """
 
-    param      = first(dd , lambda x: x[0]>=f0 , index=False)
+    param = first(dd , lambda x: x[0]>=f0 , index=False)
+
     frec, num_samples, clock_step, n_harmonic = param
+
     xx         = linspace(0, 2*pi*n_harmonic, num=num_samples, endpoint=False)
     modulation = sin(xx)
 
@@ -91,89 +91,76 @@ def convert_amp_to_data(amp):
 
 
 class AD9910RAM(EnvExperiment):
-    '''Amplitude Modulation SCAN (ch3)'''
+    '''Amplitude Modulation (for Ch3)'''
     def build(self): #this code runs on the host computer
         self.setattr_device("core")                                         #sets core device drivers as attributes
-        self.u = self.get_device(f"urukul0_ch3")                            #sets urukul 0, channel 1 device drivers as attributes and renames object self.u
+        self.u = self.get_device("urukul0_ch3")                             #sets urukul 0, channel 1 device drivers as attributes and renames object self.u
+
         # self.data=[0]*512 + [1000<<23]*512
         self.data     = [0]*1024
         self.data_len = 1024
 
         # GUI
-        self._channel_list = list( [ f'Ch{jj}' for jj in range(4) ] )
-
-        # self.channel   = EnumerationValue(self._channel_list)
-        self.setattr_argument("channel",EnumerationValue(self._channel_list))
-        self.frequency = self.get_argument(f"frequency"   ,NumberValue( 208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz   ))
-        self.amplitude = self.get_argument(f"amplitude"   ,NumberValue(    0.25,                        min=0.000, max=1.000     ))
-        self.depth     = self.get_argument(f"AM Depth"    ,NumberValue(    0.15,                        min=0.000, max=1.000     ))
 
+        self.frequency = self.get_argument(f"frequency",NumberValue(100*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz),'ch3')
+        self.amplitude = self.get_argument(f"amplitude",NumberValue(     0.25,                        min=0.000, max=1.000),'ch3')
+        self.depth     = self.get_argument(f"AM Depth", NumberValue(   0.15,                        min=0.000, max=1.000),'ch3')
+        self.am_freq   = self.get_argument(f"AM frequency",NumberValue(700*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz),'ch3')
 
-        # self.am_freq   = self.get_argument(f"AM frequency",NumberValue(100*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz),'ch1')
 
-        # GUI barrido
-        # self.am_freq_start  = self.get_argument(f"AM frequency scan START",NumberValue(600*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz),'ch1')
-        # self.am_freq_end    = self.get_argument(f"AM frequency scan END"  ,NumberValue(800*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz),'ch1')
-        self.scan_time_step = self.get_argument(f"Scan time step"         ,NumberValue(1 , min=0.01, max=60))
-        # self.scan_frec_step = self.get_argument(f"AM frequency step"      ,NumberValue(1,       unit='Hz',             min=1      , max=1000000 ),'ch1')
 
-        self.sorted = self.get_argument(f"sorted", BooleanValue(1==0))
-
-        self.setattr_argument("freqs", Scannable(
-            default=CenterScan(700*kHz, 20*kHz, 1*kHz),
-                unit="kHz",
-                scale=kHz,
-                global_min = 1,
-                global_max = 1*MHz
-            )
-        )
 
     def run(self):
         # print(self.am_freq)
+        # for am_delta in range(1000,5000,1000):
+        #     parameters  = get_urukul_params( self.am_freq + am_delta )
+        parameters  = get_urukul_params( self.am_freq )
+        frec, num_samples, clock_step, n_harmonic = parameters
+        modulation  = get_urukul_array(frec, num_samples, n_harmonic)
+        modulation  = (array(modulation)/2 * self.depth ) + (self.amplitude-self.depth)
+        data        = convert_amp_to_data( modulation )
+        self.clock_step = clock_step
 
-        if self.sorted:
-            sequence = sorted(self.freqs.sequence)
-        else:
-            sequence = self.freqs.sequence
+        self.data_len = int(num_samples)
+        # entre 865 y 870
+        # self.data_len = 871
 
-        # self.ch_num    = self._channel_list.index(self.channel)
+        self.fix = False
+        # if (870 <= self.data_len <= 880) or self.data_len == 908:
+        #     data = data + [0]*10
+        #     self.fix = True
 
-        print(f"Making SCAN from {sequence[0]/1000} kHz to {sequence[-1]/1000} on steps of {sequence[1]-sequence[0]} Hz.")
-        t0 = time()
-        frec_vec = []
+        for ii in range(len(data)):
+            self.data[ii] = data[ii]
 
-        for am_freq in sequence:
-            parameters  = get_urukul_params( am_freq )
-            frec, num_samples, clock_step, n_harmonic = parameters
-            modulation  = get_urukul_array(frec, num_samples, n_harmonic)
-            # modulation  = (array(modulation)/2 * self.depth ) + (self.amplitude-self.depth)
-            modulation  = ( (0.5+array(modulation)/2) * self.depth*self.amplitude ) +   self.amplitude*(1-self.depth)
-            data        = convert_amp_to_data( modulation )
-            self.clock_step = clock_step
 
-            self.data_len = len(data)
-            for ii in range(self.data_len):
-                self.data[ii] = data[ii]
+        # print(self.data)
 
-            # print(self.data)
+        print(f"frec: {frec} | am_freq: {self.am_freq} | num_samples:{num_samples} | clock_step: {clock_step}")
 
-            print(f"{round(time()-t0,1)} : frec: {frec} | am_freq: {am_freq} | num_samples:{num_samples} | clock_step: {clock_step}")
+        try:
             self.run_kernel()
+        except:
+            print("HUBO UNA FALLA DEL run_kernel()")
 
-            frec_vec += [frec]
+            self.fix = True
+            data = data + [0]*10
 
-            # print(f"{round(time()-t0,1)} : {frec} | {am_freq}")
-            sleep(self.scan_time_step)
+            for ii in range(len(data)):
+                self.data[ii] = data[ii]
+            self.run_kernel()
 
 
-        print("Real frequencies values used:")
-        print(frec_vec)
 
     @kernel #this code runs on the FPGA
     def run_kernel(self):
 
-        data = [0] * self.data_len
-        for ii in range(self.data_len):
+        if self.fix:
+            local_data_len = self.data_len + 10
+        else:
+            local_data_len = self.data_len
+        data = [0] * local_data_len
+        for ii in range(local_data_len):
             data[ii] = self.data[ii] << 23
 
         self.core.break_realtime()
@@ -194,19 +181,61 @@ class AD9910RAM(EnvExperiment):
 
         #set ram profile 0 -----------------------------
         self.u.set_profile_ram(
-            start=0, end=0 + len(data) - 1, step=self.clock_step,
+            start=0, end=0 + self.data_len - 1, step=self.clock_step,
             profile=0, mode=RAM_MODE_CONT_RAMPUP)
 
         self.u.cpld.set_profile(0)
         self.u.cpld.io_update.pulse_mu(8)
-        delay(1*ms)
-
+        delay(1*ms)  # ES ESTE
         #write to ram
-        if self.data_len>100:
-            self.u.write_ram(data[:100])
-            self.u.write_ram(data[100:])
-        else:
-            self.u.write_ram(data)
+        self.u.write_ram(data)
+
+
+        #
+        #
+        # if self.data_len>100:
+        #     self.u.set_profile_ram(
+        #         start=0, end=0 + len(data[:100]) - 1, step=self.clock_step,
+        #         profile=0, mode=RAM_MODE_CONT_RAMPUP)
+        #
+        #     self.u.cpld.set_profile(0)
+        #     self.u.cpld.io_update.pulse_mu(8)
+        #     delay(1*ms)  # ES ESTE
+        #     #write to ram
+        #     self.u.write_ram(data[:100])
+        #
+        #     delay(1*ms)
+        #
+        #     self.u.set_profile_ram(
+        #         start=len(data[:100]), end=len(data[:100]) + len(data[100:]) - 1, step=self.clock_step,
+        #         profile=0, mode=RAM_MODE_CONT_RAMPUP)
+        #
+        #     self.u.cpld.set_profile(0)
+        #     self.u.cpld.io_update.pulse_mu(8)
+        #     delay(1*ms)  # ES ESTE
+        #     #write to ram
+        #     self.u.write_ram(data[100:])
+        #
+        #     delay(1*ms)
+        #     self.u.set_profile_ram(
+        #         start=0, end=0 + len(data[:100]) - 1, step=self.clock_step,
+        #         profile=0, mode=RAM_MODE_CONT_RAMPUP)
+        #
+        #
+        # else:
+        #     self.u.set_profile_ram(
+        #         start=0, end=0 + len(data) - 1, step=self.clock_step,
+        #         profile=0, mode=RAM_MODE_CONT_RAMPUP)
+        #
+        #     self.u.cpld.set_profile(0)
+        #     self.u.cpld.io_update.pulse_mu(8)
+        #     delay(1*ms)  # ES ESTE
+        #     #write to ram
+        #     self.u.write_ram(data)
+
+
+
+
 
         delay(10*ms)
 

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

@@ -3,14 +3,15 @@ from artiq.coredevice.ad9910 import (                                       #Imp
     RAM_DEST_ASF, RAM_MODE_BIDIR_RAMP, RAM_MODE_CONT_RAMPUP)
 
 from numpy import load,sin,linspace,pi,array
+import numpy as np
 
-from time import sleep, time
 
+from time import sleep,time
 # This code demonstrates use of the urukul RAM.
-# It has a GUI for Artiq
+# It produces a 50 MHz square waveform attenuated
 
 
-FILENAME = "/home/liaf-ankylosaurus-admin/Documents/artiq/artiq_master/repository/Experiments/Spectrum/With_calibration/Motional/parametros_AM.npz"
+FILENAME = "/home/liaf-ankylosaurus-admin/Documents/artiq/artiq_master/repository/Examples/Amplitude_Modulation/parametros_AM.npz"
 
 dd = load(FILENAME)['dd']
 
@@ -51,8 +52,10 @@ def get_urukul_params(f0: TFloat) -> list:
         f0 (float): frequency to set on AM
     """
 
-    param      = first(dd , lambda x: x[0]>=f0 , index=False)
+    param = first(dd , lambda x: x[0]>=f0 , index=False)
+
     frec, num_samples, clock_step, n_harmonic = param
+
     xx         = linspace(0, 2*pi*n_harmonic, num=num_samples, endpoint=False)
     modulation = sin(xx)
 
@@ -91,38 +94,34 @@ def convert_amp_to_data(amp):
 
 
 class AD9910RAM(EnvExperiment):
-    '''Amplitude Modulation SCAN (multichannel)'''
+    '''Amplitude Modulation SCAN'''
     def build(self): #this code runs on the host computer
         self.setattr_device("core")                                         #sets core device drivers as attributes
+        self.setattr_device("ccb")
+        self.u = [ self.get_device("urukul0_ch0"),
+                   self.get_device("urukul0_ch1"),
+                   self.get_device("urukul0_ch2"),
+                   self.get_device("urukul0_ch3")]
 
-        self.u0 = self.get_device("urukul0_ch0")
-        self.u1 = self.get_device("urukul0_ch1")
-        self.u2 = self.get_device("urukul0_ch2")
-        self.u3 = self.get_device("urukul0_ch3")
+        self.pmt = self.get_device("ttl0")
 
         # self.data=[0]*512 + [1000<<23]*512
         self.data     = [0]*1024
         self.data_len = 1024
 
         # GUI
-        # self._channel_list = list( [ f'Ch{jj}' for jj in range(4) ] )
-
-        # self.channel   = EnumerationValue(self._channel_list)
-        # self.setattr_argument("channel",EnumerationValue(self._channel_list))
-        self.frequency = self.get_argument(f"frequency"   ,NumberValue( 208*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz   ))
-        self.amplitude = self.get_argument(f"amplitude"   ,NumberValue(    0.25,                        min=0.000, max=1.000     ))
-        self.depth     = self.get_argument(f"AM Depth"    ,NumberValue(    0.15,                        min=0.000, max=1.000     ))
+        self._channel_list = list( [ f'Ch{jj}' for jj in range(4) ] )
+        self.setattr_argument("channel",EnumerationValue(self._channel_list))
 
+        self.frequency = self.get_argument(f"frequency",NumberValue(100*MHz, unit='MHz', scale=MHz, min=1*MHz, max=400*MHz))
+        self.amplitude = self.get_argument(f"amplitude",NumberValue(     0.25,                        min=0.000, max=1.000))
+        self.depth     = self.get_argument(f"AM Depth", NumberValue(   0.15,                        min=0.000, max=1.000))
+        # self.am_freq   = self.get_argument(f"AM frequency",NumberValue(700*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz))
 
-        # self.am_freq   = self.get_argument(f"AM frequency",NumberValue(100*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz),'ch1')
+        self._channel = 0
 
-        # GUI barrido
-        # self.am_freq_start  = self.get_argument(f"AM frequency scan START",NumberValue(600*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz),'ch1')
-        # self.am_freq_end    = self.get_argument(f"AM frequency scan END"  ,NumberValue(800*kHz, unit='kHz', scale=kHz, min=100*kHz, max=2000*kHz),'ch1')
-        self.scan_time_step = self.get_argument(f"Scan time step"         ,NumberValue(1 , min=0.01, max=60))
-        # self.scan_frec_step = self.get_argument(f"AM frequency step"      ,NumberValue(1,       unit='Hz',             min=1      , max=1000000 ),'ch1')
-
-        self.sorted = self.get_argument(f"sorted", BooleanValue(1==0))
+        self.scan_time_step = self.get_argument(f"Scan time step"         ,NumberValue(1 , min=0.01, max=60,unit="s") )
+        self.sorted = self.get_argument(f"sorted", BooleanValue(True))
 
         self.setattr_argument("freqs", Scannable(
             default=CenterScan(700*kHz, 20*kHz, 1*kHz),
@@ -133,52 +132,124 @@ class AD9910RAM(EnvExperiment):
             )
         )
 
+        self.setattr_argument(f"t_readout",
+                              NumberValue(50*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+        self.setattr_argument(f"t_trans",
+                              NumberValue(10*us, unit='us', scale=us, min=1*us),
+                             "Experiment params")
+
+
+
     def run(self):
         # print(self.am_freq)
+        # for am_delta in range(1000,5000,1000):
+        #     parameters  = get_urukul_params( self.am_freq + am_delta )
+        t0 = time()
+        self._channel = self._channel_list.index( self.channel )
+
+        print("canal:", self._channel)
+        # assert  self._channel==3
 
         if self.sorted:
             sequence = sorted(self.freqs.sequence)
         else:
             sequence = self.freqs.sequence
 
-        # self.ch_num    = self._channel_list.index(self.channel)
+        self.create_datasets()
+        self.create_applets()
 
-        print(f"Making SCAN from {sequence[0]/1000} kHz to {sequence[-1]/1000} on steps of {sequence[1]-sequence[0]} Hz.")
-        t0 = time()
-        frec_vec = []
+        for ind,am_freq in enumerate(sequence):
+            # t0 = time() ; jj=0
+            # print(f"{jj}: {time()-t0}") ; jj += 1
 
-        for am_freq in sequence:
             parameters  = get_urukul_params( am_freq )
+
+
             frec, num_samples, clock_step, n_harmonic = parameters
             modulation  = get_urukul_array(frec, num_samples, n_harmonic)
-            modulation  = (array(modulation)/2 * self.depth ) + (self.amplitude-self.depth)
-            # modulation  = ( (0.5+array(modulation)/2) * self.depth*self.amplitude ) +   self.amplitude*(1-self.depth)
+            #modulation  = (array(modulation)/2 * self.depth ) + (self.amplitude-self.depth)
+            modulation = self.amplitude*(1+0.5*(1-self.depth)*(array(modulation)-1))
             data        = convert_amp_to_data( modulation )
             self.clock_step = clock_step
 
-            self.data_len = len(data)
-            for ii in range(self.data_len):
+            self.data_len = int(num_samples)
+            # entre 865 y 870
+            # self.data_len = 871
+
+            self.fix = False
+            self.ind = ind
+            # if (870 <= self.data_len <= 880) or self.data_len == 908:
+            #     data = data + [0]*10
+            #     self.fix = True
+            for ii in range(len(data)):
                 self.data[ii] = data[ii]
 
             # print(self.data)
 
-            print(f"{round(time()-t0,1)} : frec: {frec} | am_freq: {am_freq} | num_samples:{num_samples} | clock_step: {clock_step}")
-            self.run_kernel()
+            print(f"frec: {frec} | am_freq: {am_freq} | num_samples:{num_samples} | clock_step: {clock_step}")
+
+            self.mutate_dataset("set_freq",  ind, am_freq)
+            self.mutate_dataset("real_freq", ind, frec)
+
+
+            try:
+                self.run_kernel()
+            except:
+                print("HUBO UNA FALLA DEL run_kernel()")
+
+                self.fix = True
+                data = data + [0]*10
+
+                for ii in range(len(data)):
+                    self.data[ii] = data[ii]
+                self.run_kernel()
 
-            frec_vec += [frec]
+                self.mutate_dataset("error_freq",  ind,  1 )
 
-            # print(f"{round(time()-t0,1)} : {frec} | {am_freq}")
             sleep(self.scan_time_step)
+        print("FFIIINNN")
 
 
-        print("Real frequencies values used:")
-        print(frec_vec)
+    @rpc
+    def create_datasets(self):
+
+        self.set_dataset("counts"   , np.zeros( len(self.freqs.sequence)  , dtype=int  ), broadcast=True, archive=True)
+        self.set_dataset("set_freq" , np.zeros( len(self.freqs.sequence)  , dtype=float), broadcast=True, archive=True)
+        self.set_dataset("real_freq", np.zeros( len(self.freqs.sequence)  , dtype=float), broadcast=True, archive=True)
+        self.set_dataset("error_freq", np.zeros( len(self.freqs.sequence)  , dtype=float), broadcast=True, archive=True)
+
+
+    @rpc(flags={"async"})
+    def create_applets(self):
+
+        self.ccb.issue("create_applet", "Motional_spectrum_AM",
+                        "${python} -m pyLIAF.artiq.applets.plot_xy "
+                        "counts "
+                        "--x real_freq")
+
+
+    @kernel
+    def readout(self) -> TInt64:
+        """Registro de cuentas emitidas"""
+
+        # delay(self.t_trans)
+
+        here = self.pmt.gate_rising(self.t_readout) # Que mida durante t_readout
+        # self.enfriar_ion() # ya pongo a enfriar, asi todos los retardos estan enfriando
+
+        return self.pmt.count(here) # recupero las cuentas medidas
+
 
     @kernel #this code runs on the FPGA
     def run_kernel(self):
 
-        data = [0] * self.data_len
-        for ii in range(self.data_len):
+        if self.fix:
+            local_data_len = self.data_len + 10
+        else:
+            local_data_len = self.data_len
+        data = [0] * local_data_len
+        for ii in range(local_data_len):
             data[ii] = self.data[ii] << 23
 
         self.core.break_realtime()
@@ -193,26 +264,21 @@ class AD9910RAM(EnvExperiment):
         self.core.reset()
 
         #initialise
-        self.u3.cpld.init()
-        self.u3.init()
+        self.u[self._channel].cpld.init()
+        self.core.break_realtime()
+        self.u[self._channel].init()
         delay(1*ms)
 
         #set ram profile 0 -----------------------------
-        self.u3.set_profile_ram(
-            start=0, end=0 + len(data) - 1, step=self.clock_step,
+        self.u[self._channel].set_profile_ram(
+            start=0, end=0 + self.data_len - 1, step=self.clock_step,
             profile=0, mode=RAM_MODE_CONT_RAMPUP)
 
-        self.u3.cpld.set_profile(0)
-        self.u3.cpld.io_update.pulse_mu(8)
-        delay(1*ms)
-
+        self.u[self._channel].cpld.set_profile(0)
+        self.u[self._channel].cpld.io_update.pulse_mu(8)
+        delay(1*ms)  # ES ESTE
         #write to ram
-        self.u3.write_ram(data)
-        # if self.data_len>100:
-        #     self.u3.write_ram(data[:100])
-        #     self.u3.write_ram(data[100:])
-        # else:
-        #     self.u3.write_ram(data)
+        self.u[self._channel].write_ram(data)
 
         delay(10*ms)
 
@@ -227,14 +293,19 @@ class AD9910RAM(EnvExperiment):
 
 
         #write to cfr
-        self.u3.set_cfr1(ram_enable=1, ram_destination=RAM_DEST_ASF, internal_profile=0)
+        self.u[self._channel].set_cfr1(ram_enable=1, ram_destination=RAM_DEST_ASF, internal_profile=0)
 
-        self.u3.sw.on()
+        self.u[self._channel].sw.on()
         #set urukuln parameters and turn channel on
-        self.u3.set_frequency(self.frequency)
-        self.u3.cpld.io_update.pulse_mu(8)
+        self.u[self._channel].set_frequency(self.frequency)
+        self.u[self._channel].cpld.io_update.pulse_mu(8)
         # self.u.set_att(10*dB)
 
         # self.core.break_realtime()
-        delay(1*ms)
+        # delay(1*ms)
         #self.u.sw.off()
+
+        delay(self.t_trans)
+        cuentas = self.readout()
+        #delay(1*ms)
+        self.mutate_dataset("counts", self.ind, cuentas )

artiq_master/repository/Experiments/Trapping/Turning_ON.py

@@ -31,19 +31,21 @@ class ControlAllRF(EnvExperiment):
         delay(1000*ms)
         # initialises CPLD all the selected channels
         for rf_ch in self.RF_chs:
+			#delay(100*ms)
             rf_ch.initialize_channel()
             self.core.break_realtime()
-
-        delay(100*ms)
-        
+            delay(100*ms)
+			        
         for rf_ch in self.RF_chs:
             rf_ch.set_channel()
             self.core.break_realtime()
-
+            delay(100*ms)
         for rf_ch in self.RF_chs:
             rf_ch.channel.set_att(0.)
             self.core.break_realtime()
-
+            delay(100*ms)
+			
+			
         #self.get_measurement(medN)
 #        self.core.break_realtime()