def test1():
    streamhandler = StreamHandler()
    
    # Configure and start
    dev = FakeDigital(streamhandler = streamhandler)
    dev.configure( name = 'Test dev',
                                nb_channel = 10,
                                sampling_rate =1000.,
                                buffer_length = 10.,
                                packet_size = 128,
                                )
    dev.initialize()
    dev.start()
    
    # Create and starts receiver with multuprocessing
    stream0 = dev.streams[0]
    stop_recv = mp.Value('i', 0)
    process = mp.Process(target= test_recv_loop, args = (stream0['port'],stop_recv))
    process.start()
    time.sleep(10.)
    stop_recv.value = 1
    process.join()
    

    # Stop and release the device
    dev.stop()
    dev.close()
def test1():
    streamhandler = StreamHandler()
    
    # Configure and start
    dev = FakeDigital(streamhandler = streamhandler)
    dev.configure( 
                                nb_channel = 30,
                                sampling_rate =1000000.,
                                buffer_length = 60.,
                                packet_size = 20,
                                )
    dev.initialize()
    dev.start()
    
    app = QtGui.QApplication([])
    
    #~ w1=OscilloscopeDigital(stream = dev.streams[0])
    #~ w1.show()
    #~ w1.set_params(xsize = 5., decimate= 500)

    w2=OscilloscopeDigital(stream = dev.streams[0])
    w2.show()
    w2.set_params(xsize = 30, mode = 'scroll', decimate= 500, auto_decimate = True)
    

    
    app.exec_()
    
    # Stope and release the device
    dev.stop()
    dev.close()
def filter_analog1():
    streamhandler = StreamHandler()
    
    # Configure and start
    dev = FakeMultiSignals(streamhandler = streamhandler)
    dev.configure(     nb_channel = 2,
                                sampling_rate =10000.,
                                buffer_length = 30.,
                                packet_size = 100,
                                last_channel_is_trig = True,
                                )
    dev.initialize()
    dev.start()

    dev2 = FakeDigital(streamhandler = streamhandler)
    dev2.configure( 
                                nb_channel = 30,
                                sampling_rate =10000.,
                                buffer_length = 30.,
                                packet_size = 100,
                                )
    dev2.initialize()
    dev2.start()

    
    
    
    filter = BandPassFilter(stream = dev.streams[0],
                                                streamhandler= streamhandler,
                                                autostart = False,
                                                f_start =0.,
                                                f_stop = dev.streams[0].sampling_rate/10./2.,
                                                )
    decimator = SimpleDecimator( filter.out_stream,
                                                streamhandler= streamhandler,
                                                downsampling_factor = 10,
                                                autostart = False,
                                                )

    decimator2 = SimpleDecimator( dev2.streams[0],
                                                streamhandler= streamhandler,
                                                downsampling_factor = 10,
                                                autostart = False,
                                                )
    print decimator2.out_stream._params
    
                                                
    app = QtGui.QApplication([])
    
    filter.start()
    decimator.start()
    decimator2.start()

    visibles = np.ones(dev.nb_channel, dtype = bool)
    visibles[1:] = False
    
    w1=Oscilloscope(stream = dev.streams[0])
    w2=Oscilloscope(stream = filter.out_stream)
    w3=Oscilloscope(stream = decimator.out_stream)
    
    w4 = OscilloscopeDigital(stream = dev2.streams[0])
    w5 = OscilloscopeDigital(stream = decimator2.out_stream)

    time.sleep(.5)
    
    
    for w in [w1, w2, w3]:
        w.auto_gain_and_offset(mode = 0)
        w.set_params(xsize = 1.,
                                        mode = 'scan',
                                        visibles = visibles,
                                        ylims = [-5,5]
                                        )
        w.show()
    
    for w in [w4, w5]:
        w.set_params(xsize = 1.,
                                        mode = 'scan',
                                        )
        w.show()
    
    
    
    
    app.exec_()
    w1.stop()
    w2.stop()
    
    
    dev.stop()

    dev.close()
def trigger_digital1():
    streamhandler = StreamHandler()
    
    # Configure and start
    dev = FakeDigital(streamhandler = streamhandler)
    dev.configure( 
                                nb_channel = 32,
                                sampling_rate =100000.,
                                buffer_length = 60.,
                                packet_size = 100,
                                )
    dev.initialize()
    dev.start()

    def print_pos(pos):
        print pos
    
    trigger = DigitalTrigger(stream = dev.streams[0],
                                    front = '-', 
                                    channel = 0,
                                    #~ debounce_mode = 'no-debounce',
                                    debounce_mode = 'after-stable',
                                    #~ debounce_mode = 'before-stable',
                                    debounce_time = 0.05,
                                    callbacks = [ print_pos,  ]
                                    )

    
    app = QtGui.QApplication([])
    
    w1=OscilloscopeDigital(stream = dev.streams[0])
    w1.show()
    visibles = np.ones(dev.nb_channel, dtype = bool)
    visibles[1:] = False
    w1.set_params(xsize = 4.7,
                                    mode = 'scan',
                                visibles = visibles,
                                refresh_interval = .1)


    time.sleep(.5)
    #~ w1.auto_gain_and_offset(mode = 2)

    
    app.exec_()
    print 1
    # Stope and release the device
    trigger.stop()
    print 2
    dev.stop()
    print 3
    dev.close()
    print 4
def test2():
    # record on trigger
    
    streamhandler = StreamHandler()
    
    
    dev0 = FakeMultiSignals(streamhandler = streamhandler)
    dev0.configure(
                                nb_channel = 16,
                                sampling_rate =1000.,
                                buffer_length = 64,
                                packet_size = 10,
                                last_channel_is_trig = True,
                                )
    
    dev1 = FakeDigital(streamhandler = streamhandler)
    dev1.configure(
                                nb_channel = 10,
                                sampling_rate =1000.,
                                buffer_length = 10.,
                                packet_size = 128,
                                )
    
    devs = [dev0, dev1]
    #~ devs = [dev0]
    
    for dev in devs:
        dev.initialize()

    dirname_base = os.path.join(user.home, 'test_pyacq_recording')
    if not os.path.exists(dirname_base):
        os.mkdir(dirname_base)
    dirname = os.path.join(dirname_base, 'rec {}'.format(datetime.datetime.now()))
    if not os.path.exists(dirname):
        os.mkdir(dirname)
        
    
    global is_started
    is_started = 0
    
    def start_rec(pos):
        global is_started
        is_started +=1
        if is_started!=5:
            return
        print 'start_rec', pos, is_started
        streams = [dev.streams[0] for dev in  devs]
        
        bound_indexes = {dev0.streams[0] : (pos-1000, pos+1000),
                                            dev1.streams[0] : (pos-1000, pos+1000),
                         }
        rec = RawDataRecording(streams, dirname, bound_indexes = bound_indexes)
        rec.start()
        

    #~ trigger.start()
    
    
    for dev in devs:
        dev.start()
    
    trigger = AnalogTrigger(stream = dev0.streams[0],
                                    threshold = 0.25,
                                    front = '+', 
                                    channel = dev0.nb_channel-1,
                                    #~ debounce_mode = 'no-debounce',
                                    #~ debounce_mode = 'after-stable',
                                    debounce_mode = 'before-stable',
                                    debounce_time = 0.05,
                                    callbacks = [ start_rec,  ]
                                    )    
    time.sleep(5.)
    
    #~ rec.stop()
    
    # Stope and release the device
    for dev in devs:
        dev.stop()
        dev.close()
    
    
    # Read the files
    reader = neo.RawBinarySignalIO(filename = os.path.join(dirname, 'fake 16 analog input.raw'))
    seg = reader.read_segment(sampling_rate = 1.*pq.kHz,
                                            t_start = 0.*pq.s,
                                            unit = pq.V,
                                            nbchannel = 16,
                                            dtype = np.float32,
                                            )
    app = QtGui.QApplication([])
    viewer = SegmentViewer(segment = seg)
    #~ viewer = SignalViewer(analogsignals = seg.analogsignals, with_time_seeker = True)
    viewer.show()
    
    print seg.analogsignals[0].shape
    sig = seg.analogsignals[-1].magnitude
    print np.where((sig[:-1]<.25)&(sig[1:]>=.25))
    
    analogsignals2 = [ ]
    arr = np.memmap(filename = os.path.join(dirname, u'fake 10 digital input.raw'), mode = 'r', dtype = np.uint8)
    arr = arr.reshape(-1, 2)
    print arr.shape
    for chan in range(10):
        b = chan//8
        mask = 1<<(chan%8)
        sig = (arr[:,b]&mask>0).astype(float)
        analogsignals2.append(neo.AnalogSignal(sig*pq.V, t_start = 0*pq.s, sampling_rate = 1*pq.kHz))
    viewer2 = SignalViewer(analogsignals = analogsignals2, with_time_seeker = True)
    
    viewer2.show()
    
    
    app.exec_()    
def test1():
    streamhandler = StreamHandler()
    
    
    dev0 = FakeMultiSignals(streamhandler = streamhandler)
    dev0.configure( #name = 'Analog fake 0',
                                nb_channel = 16,
                                sampling_rate =1000.,
                                buffer_length = 64,
                                packet_size = 10,
                                )
    
    dev1 = FakeDigital(streamhandler = streamhandler)
    dev1.configure( #name = u'Digital fake 1 éà',
                                nb_channel = 10,
                                sampling_rate =1000.,
                                buffer_length = 10.,
                                packet_size = 128,
                                )
    
    devs = [dev0, dev1]
    
    for dev in devs:
        dev.initialize()
    
    
    streams = [dev.streams[0] for dev in  devs]
    dirname_base = os.path.join(user.home, 'test_pyacq_recording')
    if not os.path.exists(dirname_base):
        os.mkdir(dirname_base)
    dirname = os.path.join(dirname_base, 'rec {}'.format(datetime.datetime.now()))
    if not os.path.exists(dirname):
        os.mkdir(dirname)
    
    rec = RawDataRecording(streams, dirname)
    rec.start()
    
    for dev in devs:
        dev.start()
    
    time.sleep(10.)
    
    rec.stop()
    
    # Stope and release the device
    for dev in devs:
        dev.stop()
        dev.close()
    
    
    # Read the files
    reader = neo.RawBinarySignalIO(filename = os.path.join(dirname, 'fake 16 analog input.raw'))
    seg = reader.read_segment(sampling_rate = 1.*pq.kHz,
                                            t_start = 0.*pq.s,
                                            unit = pq.V,
                                            nbchannel = 16,
                                            dtype = np.float32,
                                            )
    app = QtGui.QApplication([])
    viewer = SegmentViewer(segment = seg)
    #~ viewer = SignalViewer(analogsignals = seg.analogsignals, with_time_seeker = True)
    viewer.show()
    
    print seg.analogsignals[0].shape
    
    analogsignals2 = [ ]
    arr = np.memmap(filename = os.path.join(dirname, u'fake 10 digital input.raw'), mode = 'r', dtype = np.uint8)
    arr = arr.reshape(-1, 2)
    print arr.shape
    for chan in range(10):
        b = chan//8
        mask = 1<<(chan%8)
        sig = (arr[:,b]&mask>0).astype(float)
        analogsignals2.append(neo.AnalogSignal(sig*pq.V, t_start = 0*pq.s, sampling_rate = 1*pq.kHz))
    viewer2 = SignalViewer(analogsignals = analogsignals2, with_time_seeker = True)
    
    viewer2.show()
    
    
    app.exec_()
def test2():
    
    for name, info_device in FakeDigital.get_available_devices().items():
        print name
        print info_device