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