agrego carpetas examples y experiments

artiq_master/repository/Examples/Misc/rpdummy.py

+import random
+import numpy as np
+
+class RedPitaya:
+    def __init__(self):
+        pass
+    def give_measurement(self):
+        return 0.5*(random.random()+1)

artiq_master/repository/Examples/Misc/test_rp_dummy.py

+from artiq.experiment import *
+from urukul import UrukulCh
+import time
+import numpy as np
+from rpdummy import RedPitaya
+
+class TestDataset(EnvExperiment):
+    """Test dataset con Pitaya dummy
+    """
+    def build(self):
+        self.setattr_device("core")
+        # global attenuation
+        self.setattr_argument("nro_meds", NumberValue(10, min=1, step=1, ndecimals=0))
+
+        self.RP = RedPitaya()
+        self.setattr_device("ccb")
+
+    def run(self):
+        self.set_dataset("tensiones", np.full(self.nro_meds, 0.), broadcast=True, archive=False)
+        self.ccb.issue("create_applet", "datos_medidos",
+                        "${artiq_applet}plot_xy "
+                        "tensiones")
+
+        self.kernel_run()
+
+    @rpc
+    def get_measurement(self, i):
+        val = self.RP.give_measurement()
+        self.mutate_dataset("tensiones", i, val)
+
+    @kernel
+    def kernel_run(self):
+        self.core.reset()
+        delay(10*ms)
+
+        for i in range(self.nro_meds):
+            self.get_measurement(i)
+            delay(1*s)
+            self.core.break_realtime()
+
+    def analyze(self):
+        datos = self.get_dataset("tensiones")
+        print(f"Media: {np.mean(datos)}")
+        print(f"Std: {np.std(datos)}")
+

artiq_master/repository/Experiments/counts_histogram_plotting.py

+import numpy as np
+#import matplotlib.pyplot as plt
+import sys
+from datetime import datetime
+from artiq.experiment import *
+
+
+class ContinuousCountsHistograms(EnvExperiment):
+    """
+    Histogramas prueba
+    Codigo de recoleccion de lecturas de cuentas del PMT.
+    Recolecta N mediciones de x segundos del PMT y las muestra en un grafico.
+    Sirve para realizar checks rapidos tipo verificacion del PMT.
+
+    CONECCIONES:
+    ============
+    TTL0 input  <- PMT
+
+    USO:
+    ====
+    Correr la siguiente linea, definiendo el estado del led/laser como apagado 'led=0' o
+    prendido, 'led=1'
+        artiq_run lectura_referencia_pmt.py led={0,1}
+
+    PARAMETROS:
+    ===========
+    self.estado_inicial  <- Determina si la medicion se hara con el led prendido (1) o apagado (0)
+
+    SALIDA:
+    =======
+    Histograma de cuentas registradas.
+    Prompt para guardar las mediciones obtenidas.
+    """
+
+#    def prepare(self):
+        #pongo parametros de medicion
+#        self.setattr_argument("nro_meds", NumberValue(50)) #mide 50 veces        
+#        self.setattr_argument("window", NumberValue(50, unit='ms', scale=1e-3)) #ventanas de 50 ms
+    
+#        self.nro_meds       = 1000 # Cantidad de repeticiones a hacer
+#        self.tau_med        = 1*s # Tiempo de cada medicion
+#        self.t_between      = 500 * us # Tiempo entre mediciones (minimo 500us?)
+
+    def build(self):
+        # Defino los conectores a utilizar
+
+        #self.setattr_argument("nro_meds", NumberValue(50)) #mide 50 veces        
+        self.nro_meds = 50        
+        self.setattr_argument("window", NumberValue(50, unit='ms', scale=1)) #ventanas de 50 ms
+
+        self.setattr_device("core")
+        self.pmt = self.get_device("ttl0")
+        self.setattr_device("ccb")
+
+    @kernel
+    def run(self):
+        self.core.reset()
+        self.pmt.input()
+        # Pre-aloco el dataset, total ya se cuan largo va a ser.
+        self.set_dataset('ticks', np.full(self.nro_meds, np.nan), broadcast=True, archive=False)
+#        delay(100*ms) # agrego el delay necesario despues del input para no tener un underflow
+
+        t0 = now_mu() # guardo el tiempo de comienzo de la medicion
+        try:
+            for i in range(self.nro_meds): # corro 1000 veces
+                # Cuento solamente los rising edges en el intervalo
+                # modifico el i-esimo elemento del dataset con las cuentas
+                self.mutate_dataset('ticks', i, self.pmt.count(self.pmt.gate_rising(self.window)))
+                # Aqui probablemente tenga que poner un delay
+                #1self.core.break_realtime() #esto no se si esta bueno o hay que corregirlo
+                delay(self.window) #esto es para que mida por ventanas?
+                print('done')
+        except Exception as err:
+            print("Tiempo de error: ", end='')
+            print(self.core.mu_to_seconds(now_mu()-t0))
+            print("Iteracion nro: ", end='')
+            print(i)
+            self.core.break_realtime() # uso esto para asegurarme que corra la siguiente linea
+            
+            raise err
+
+        print(self.core.mu_to_seconds(now_mu()-t0))
+
+
+#    def analyze(self):
+#        """
+#        Aprovecho la existencia de este metodo que llama el mismo programa
+#        para guardar los archivos que vayamos recolectando
+#        """
+#
+#        # traigo el dataset para guardarlo
+#        ticks_med = self.get_dataset('ticks')
+#
+#        # Armo el plot
+#        fig, ax = plt.subplots()
+#        ax.hist(ticks_med)
+#        ax.set_title(f"Histograma de cuentas/seg. Led {estado}")
+#        ax.set_xlabel("cuentas")
+#        ax.set_ylabel("ocurrencias")
+#        fig.tight_layout()
+#        fig.show()
+#
+#        if input("Guardar datos? (y/[n]): ") in ("y", "Y"):
+#            folder = "mediciones/" #TODO: Eleccion para el usuario?
+#            realtime = datetime.now().strftime("%Y%m%d_%H%M%S") # Tiempo de ejecucion
+#            fname = f"{folder}{realtime}_{estado}_tmed{self.tau_med}_ticks.txt"
+#            print(f"Guardando: {fname}")
+#            np.savetxt(fname, ticks_med, delimiter=',', \
+#-+                    header=f"no_meds={self.nro_meds},tau_med={self.tau_med},estado={estado}")
+