def test_script(self):
        """
        test that tests the printing of v from a pre determined recording
        :return:
        """
        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 128 * 128  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_cond_exp", 256)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0,
                           'e_rev_E': 0.,
                           'e_rev_I': -80.
                           }

        populations = list()
        projections = list()

        weight_to_spike = 0.035
        delay = 17

        spikes = read_spikefile('test.spikes', n_neurons)
        print spikes
        spike_array = {'spike_times': spikes}

        populations.append(p.Population(
            n_neurons, p.SpikeSourceArray, spike_array, label='inputSpikes_1'))
        populations.append(p.Population(
            n_neurons, p.IF_cond_exp, cell_params_lif, label='pop_1'))
        projections.append(p.Projection(
            populations[0], populations[1], p.OneToOneConnector(
                weights=weight_to_spike, delays=delay)))
        populations[1].record()

        p.run(1000)

        spikes = populations[1].getSpikes(compatible_output=True)

        if spikes is not None:
            print spikes
            pylab.figure()
            pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
            pylab.xlabel('Time/ms')
            pylab.ylabel('spikes')
            pylab.title('spikes')
            pylab.show()
        else:
            print "No spikes received"

        p.end()

    def test_recording_numerious_element_over_limit(self):
        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 2000  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        boxed_array = numpy.zeros(shape=(0, 2))
        spike_array = list()
        for neuron_id in range(0, n_neurons):
            spike_array.append(list())
            for random_time in range(0, 200000):
                random_time2 = random.randint(0, 50000)
                boxed_array = numpy.append(
                    boxed_array, [[neuron_id, random_time2]], axis=0)
                spike_array[neuron_id].append(random_time)
        spike_array_params = {'spike_times': spike_array}
        populations.append(p.Population(n_neurons, p.IF_curr_exp,
                                        cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(n_neurons, p.SpikeSourceArray,
                                        spike_array_params,
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[1], populations[0],
                           p.OneToOneConnector()))

        populations[1].record()

        p.run(50000)

        spike_array_spikes = populations[1].getSpikes()
        boxed_array = boxed_array[numpy.lexsort((boxed_array[:, 1],
                                                 boxed_array[:, 0]))]
        numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
        p.end()

    def test_get_weights(self):
        # Population parameters
        cell_params = {
            'cm': 0.2,  # nF
            'i_offset': 0.2,
            'tau_m': 20.0,
            'tau_refrac': 5.0,
            'tau_syn_E': 5.0,
            'tau_syn_I': 10.0,
            'v_reset': -60.0,
            'v_rest': -60.0,
            'v_thresh': -50.0
        }

        # Reduce number of neurons to simulate on each core
        sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100)

        # Build inhibitory plasticity  model
        stdp_model = sim.STDPMechanism(
            timing_dependence=sim.SpikePairRule(
                tau_plus=20.0, tau_minus=12.7, nearest=True),
            weight_dependence=sim.AdditiveWeightDependence(
                w_min=0.0, w_max=1.0, A_plus=0.05),
            mad=True
        )

        # Build plastic network
        plastic_ex_pop, plastic_ie_projection =\
            self.build_network(sim.SynapseDynamics(slow=stdp_model), 
                               cell_params)

        # Run simulation
        sim.run(10000)

        # Get plastic spikes and save to disk
        plastic_spikes = plastic_ex_pop.getSpikes(compatible_output=True)
        #numpy.save("plastic_spikes.npy", plastic_spikes)

        plastic_weights = plastic_ie_projection.getWeights(format="array")
        #  mean_weight = numpy.average(plastic_weights)

        # End simulation on SpiNNaker
        sim.end()

def main():
    # setup timestep of simulation and minimum and maximum synaptic delays
    Frontend.setup(timestep=simulationTimestep, min_delay=minSynapseDelay, max_delay=maxSynapseDelay, threads=4)

    # create a spike sources
    retinaLeft = createSpikeSource("RetL")
    retinaRight = createSpikeSource("RetR")
    
    # create network and attach the spike sources 
    network, (liveConnectionNetwork, liveConnectionRetinas) = createCooperativeNetwork(retinaLeft=retinaLeft, retinaRight=retinaRight)

    # non-blocking run for time in milliseconds
    print "Simulation started..."
    Frontend.run(simulationTime)                                          
    print "Simulation ended."
    
    # plot results  
    #
#     plotExperiment(retinaLeft, retinaRight, network)
    # finalise program and simulation
    Frontend.end()

    def test_recording_1_element(self):
        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 200  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        spike_array = {'spike_times': [[0]]}
        populations.append(p.Population(n_neurons, p.IF_curr_exp,
                                        cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[0], populations[0],
                           p.OneToOneConnector()))

        populations[1].record()

        p.run(5000)

        spike_array_spikes = populations[1].getSpikes()
        boxed_array = numpy.zeros(shape=(0, 2))
        boxed_array = numpy.append(boxed_array, [[0, 0]], axis=0)
        numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)

        p.end()

    def simulate(self, spinnaker, input_spike_times):

        # Cell parameters
        cell_params = {
            'tau_m': 20.0,
            'v_rest': -60.0,
            'v_reset': -60.0,
            'v_thresh': -40.0,
            'tau_syn_E': 2.0,
            'tau_syn_I': 2.0,
            'tau_refrac': 2.0,
            'cm': 0.25,
            'i_offset': 0.0,
        }

        rng = p.NumpyRNG(seed=28375)
        v_init = p.RandomDistribution('uniform', [-60, -40], rng)

        p.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)

        pop = p.Population(1, p.IF_curr_exp, cell_params, label='population')
        pop.randomInit(v_init)
        pop.record()
        pop.record_v()

        noise = p.Population(1, p.SpikeSourceArray,
                             {"spike_times": input_spike_times})

        p.Projection(noise, pop, p.OneToOneConnector(weights=0.4, delays=1),
                     target='excitatory')

        # Simulate
        p.run(self.simtime)

        pop_voltages = pop.get_v(compatible_output=True)
        pop_spikes = pop.getSpikes(compatible_output=True)

        p.end()
        return pop_voltages, pop_spikes

    def test_recording_poisson_spikes_rate_0(self):

        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 256  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        populations.append(p.Population(n_neurons, p.IF_curr_exp,
                                        cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(n_neurons, p.SpikeSourcePoisson,
                                        {'rate': 0},
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[1], populations[0],
                           p.OneToOneConnector()))

        populations[1].record()

        p.run(5000)

        spikes = populations[1].getSpikes()
        print spikes

        p.end()

live_spikes_connection = SpynnakerLiveSpikesConnection(
    receive_labels=None, local_port=19999, send_labels=["spike_injector_forward"])
# Set up callbacks to occur at the start of simulation
live_spikes_connection.add_start_callback("spike_injector_forward", send_input_forward)
# if not using the c visualiser, then a new spynnaker live spikes connection
# is created to define that there are python code which receives the
# outputted spikes.
live_spikes_connection = SpynnakerLiveSpikesConnection(
    receive_labels=["pop_forward"], local_port=19996, send_labels=None)
# Set up callbacks to occur when spikes are received
live_spikes_connection.add_receive_callback("pop_forward", receive_spikes)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0:
    pylab.figure()
    if len(spikes_forward) != 0:
        pylab.plot([i[1] for i in spikes_forward],
                   [i[0] for i in spikes_forward], "b.")
    pylab.ylabel('neuron id')
    pylab.xlabel('Time/ms')
    pylab.title('spikes')
    pylab.show()
else:
    print "No spikes received"
# Clear data structures on spiNNaker to leave the machine in a clean state for
# future executions
Frontend.end()

else:
    print "No spikes received"

# Make some graphs

if v != None:
    ticks = len(v) / nNeurons
    pylab.figure()
    pylab.xlabel('Time/ms')
    pylab.ylabel('v')
    pylab.title('v')
    for pos in range(0, nNeurons, 20):
        v_for_neuron = v[pos * ticks : (pos + 1) * ticks]
        pylab.plot([i[1] for i in v_for_neuron], 
                [i[2] for i in v_for_neuron])
    pylab.show()

if gsyn != None:
    ticks = len(gsyn) / nNeurons
    pylab.figure()
    pylab.xlabel('Time/ms')
    pylab.ylabel('gsyn')
    pylab.title('gsyn')
    for pos in range(0, nNeurons, 20):
        gsyn_for_neuron = gsyn[pos * ticks : (pos + 1) * ticks]
        pylab.plot([i[1] for i in gsyn_for_neuron], 
                [i[2] for i in gsyn_for_neuron])
    pylab.show()

p.end(stop_on_board=False)

import spynnaker.pyNN as sim

sim.setup(timestep=1.0, min_delay=1.0, max_delay=1.0)

simtime = 1000

pg_pop1 = sim.Population(2, sim.SpikeSourcePoisson,
                         {'rate': 10.0, 'start':0,
                          'duration':simtime}, label="pg_pop1")
pg_pop2 = sim.Population(2, sim.SpikeSourcePoisson,
                         {'rate': 10.0, 'start':0,
                          'duration':simtime}, label="pg_pop2")

pg_pop1.record()
pg_pop2.record()

sim.run(simtime)

spikes1 = pg_pop1.getSpikes(compatible_output=True)
spikes2 = pg_pop2.getSpikes(compatible_output=True)

print spikes1
print spikes2

sim.end()

def run():

  Frontend.run(run_time)

  Frontend.end()

    pylab.title('spikes')
    pylab.show()
else:
    print "No spikes received"

# Make some graphs

if v is not None:
    ticks = len(v) / nNeurons
    pylab.figure()
    pylab.xlabel('Time/ms')
    pylab.ylabel('v')
    pylab.title('v')
    for pos in range(0, nNeurons, 20):
        v_for_neuron = v[pos * ticks: (pos + 1) * ticks]
        pylab.plot([i[2] for i in v_for_neuron])
    pylab.show()

if gsyn is not None:
    ticks = len(gsyn) / nNeurons
    pylab.figure()
    pylab.xlabel('Time/ms')
    pylab.ylabel('gsyn')
    pylab.title('gsyn')
    for pos in range(0, nNeurons, 20):
        gsyn_for_neuron = gsyn[pos * ticks: (pos + 1) * ticks]
        pylab.plot([i[2] for i in gsyn_for_neuron])
    pylab.show()

p.end()

ExternalDevices.activate_live_output_for(populations[0])

projections.append(
    FrontEnd.Projection(populations[1], populations[0], FrontEnd.OneToOneConnector(weights=weight_to_spike))
)

loopConnections = list()
for i in range(0, nNeurons - 1):
    singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, 3)
    loopConnections.append(singleConnection)

projections.append(FrontEnd.Projection(populations[0], populations[0], FrontEnd.FromListConnector(loopConnections)))


FrontEnd.run(run_time)

spikes = populations[0].getSpikes(compatible_output=True)

if spikes is not None:
    print spikes
    pylab.figure()
    pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
    pylab.ylabel("neuron id")
    pylab.xlabel("Time/ms")
    pylab.title("spikes")
    pylab.show()
else:
    print "No spikes received"

FrontEnd.end()

def main():
    minutes = 0
    seconds = 30
    milliseconds = 0
    run_time = minutes*60*1000 + seconds*1000 + milliseconds

    weight_to_spike = 4.

    model = sim.IF_curr_exp
    cell_params = {'cm'        : 0.25, # nF
                    'i_offset'  : 0.0,
                    'tau_m'     : 10.0,
                    'tau_refrac': 2.0,
                    'tau_syn_E' : 2.5,
                    'tau_syn_I' : 2.5,
                    'v_reset'   : -70.0,
                    'v_rest'    : -65.0,
                    'v_thresh'  : -55.4
                    }
    # Available resolutions
    # 16, 32, 64, 128
    mode = ExternalDvsEmulatorDevice.MODE_64
    cam_res = int(mode)
    cam_fps = 90
    frames_per_saccade = cam_fps/3 - 1
    polarity = ExternalDvsEmulatorDevice.MERGED_POLARITY
    output_type = ExternalDvsEmulatorDevice.OUTPUT_TIME
    history_weight = 1.0
    behaviour = VirtualCam.BEHAVE_ATTENTION
    vcam = VirtualCam("./mnist", behaviour=behaviour, fps=cam_fps, 
                      resolution=cam_res, frames_per_saccade=frames_per_saccade)
                      
    cam_params = {'mode': mode,
                  'polarity': polarity,
                  'threshold': 12,
                  'adaptive_threshold': False,
                  'fps': cam_fps,
                  'inhibition': False,
                  'output_type': output_type,
                  'save_spikes': "./spikes_from_cam.pickle",
                  'history_weight': history_weight,
                  #'device_id': 0, # for an OpenCV webcam device
                  #'device_id': 'path/to/video/file', # to encode pre-recorded video
                  'device_id': vcam,
                 }
    if polarity == ExternalDvsEmulatorDevice.MERGED_POLARITY:
        num_neurons = 2*(cam_res**2)
    else:
        num_neurons = cam_res**2
      
    sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)

    target = sim.Population(num_neurons, model, cell_params)

    stimulation = sim.Population(num_neurons, DvsEmulatorDevice, cam_params,
                                 label="Webcam population")

    connector = sim.OneToOneConnector(weights=weight_to_spike)

    projection = sim.Projection(stimulation, target, connector)

    target.record()
        
    sim.run(run_time)

    
    spikes = target.getSpikes(compatible_output=True)

    sim.end()
    #stimulation._vertex.stop()
    
    
    print ("Raster plot of the spikes that Spinnaker echoed back")
    fig = pylab.figure()
    
    spike_times = [spike_time for (neuron_id, spike_time) in spikes]
    spike_ids   = [neuron_id  for (neuron_id, spike_time) in spikes]
    
    pylab.plot(spike_times, spike_ids, ".", markerfacecolor="None",
               markeredgecolor="Blue", markersize=3)
    
    pylab.show()

        projections[-1].append(sim.Projection(pre_pop, post_pop, sim.OneToOneConnector(weights = start_w),
            synapse_dynamics = sim.SynapseDynamics(slow = stdp_model)
        ))

print("Simulating for %us" % (sim_time / 1000))

# Run simulation
sim.run(sim_time)

# Read weights from each parameter value being tested
weights = []
for projection_delta_t in projections:
    weights.append([p.getWeights()[0] for p in projection_delta_t])

# End simulation on SpiNNaker
sim.end(stop_on_board=True)

#-------------------------------------------------------------------
# Plotting
#-------------------------------------------------------------------
# Sjostrom et al. (2001) experimental data
data_w = [
    [ -0.29, -0.41, -0.34, 0.56, 0.75 ],
    [ -0.04, 0.14, 0.29, 0.53, 0.56 ]
]
data_e = [
    [ 0.08, 0.11, 0.1, 0.32, 0.19 ],
    [ 0.05, 0.1, 0.14, 0.11, 0.26 ]
]

# Plot Frequency response

projections.append(spynn.Projection(pop_spikes_in_1, pop_spikes_out_1,spynn.OneToOneConnector(weights=weight_to_spike)))
projections.append(spynn.Projection(pop_spikes_in_2, pop_spikes_out_2,spynn.OneToOneConnector(weights=weight_to_spike)))

spynn.run(runTimeMs + 1000) #add extra second to get all downstream spikes

spikes1 = pop_spikes_out_1.getSpikes(compatible_output=True)
spikes2 = pop_spikes_out_2.getSpikes(compatible_output=True)
#For raster plot of all together, we need to convert neuron ids to be global not local to each pop
for j in spikes2:
    j[0]=j[0] + nNeurons1

totalSpikes = len(spikes1) +  len(spikes1)
print 'Total spikes generated: ' , totalSpikes
if  totalSpikes > 0:
    print "Last spike pop 1: " , spikes1[len(spikes1) - 1]
    print "Last spike pop 2: " , spikes2[len(spikes2) - 1]
    #print spikes
    pylab.figure()
    pylab.plot([i[1] for i in spikes1], [i[0] for i in spikes1], "k,")  #black pixels
    pylab.plot([i[1] for i in spikes2], [i[0] for i in spikes2], "k,")  #black pixels
    pylab.ylabel('neuron id')
    pylab.xlabel('Time/ms')
    pylab.title('Raster Plot')
    pylab.show()
else:
    print "No spikes received"


spynn.end()

    def __init__(self):

        # initial call to set up the front end (pynn requirement)
        Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)

        use_c_visualiser = True
        use_spike_injector = True

        # neurons per population and the length of runtime in ms for the
        # simulation, as well as the expected weight each spike will contain
        self.n_neurons = 100

        # set up gui
        p = None
        if use_spike_injector:
            from multiprocessing import Process
            from multiprocessing import Event
            ready = Event()
            p = Process(target=GUI, args=[self.n_neurons, ready])
            p.start()
            ready.wait()

        # different runtimes for demostration purposes
        run_time = None
        if not use_c_visualiser and not use_spike_injector:
            run_time = 1000
        elif use_c_visualiser and not use_spike_injector:
            run_time = 10000
        elif use_c_visualiser and use_spike_injector:
            run_time = 100000
        elif not use_c_visualiser and use_spike_injector:
            run_time = 10000

        weight_to_spike = 2.0

        # neural parameters of the IF_curr model used to respond to injected
        # spikes.
        # (cell params for a synfire chain)
        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        ##################################
        # Parameters for the injector population.  This is the minimal set of
        # parameters required, which is for a set of spikes where the key is
        # not important.  Note that a virtual key *will* be assigned to the
        # population, and that spikes sent which do not match this virtual key
        # will be dropped; however, if spikes are sent using 16-bit keys, they
        # will automatically be made to match the virtual key.  The virtual
        # key assigned can be obtained from the database.
        ##################################
        cell_params_spike_injector = {

            # The port on which the spiNNaker machine should listen for
            # packets. Packets to be injected should be sent to this port on
            # the spiNNaker machine
            'port': 12345
        }

        ##################################
        # Parameters for the injector population.  Note that each injector
        # needs to be given a different port.  The virtual key is assigned
        # here, rather than being allocated later.  As with the above, spikes
        # injected need to match this key, and this will be done automatically
        # with 16-bit keys.
        ##################################
        cell_params_spike_injector_with_key = {

            # The port on which the spiNNaker machine should listen for
            # packets. Packets to be injected should be sent to this port on
            # the spiNNaker machine
            'port': 12346,

            # This is the base key to be used for the injection, which is used
            # to allow the keys to be routed around the spiNNaker machine.
            # This assignment means that 32-bit keys must have the high-order
            # 16-bit set to 0x7; This will automatically be prepended to
            # 16-bit keys.
            'virtual_key': 0x70000
        }

        # create synfire populations (if cur exp)
        pop_forward = Frontend.Population(
            self.n_neurons, Frontend.IF_curr_exp,
            cell_params_lif, label='pop_forward')
        pop_backward = Frontend.Population(
            self.n_neurons, Frontend.IF_curr_exp,
            cell_params_lif, label='pop_backward')

        # Create injection populations
        injector_forward = None
        injector_backward = None
        if use_spike_injector:
#.........这里部分代码省略.........

    def test_print_spikes(self):
        machine_time_step = 0.1

        p.setup(timestep=machine_time_step, min_delay=1.0, max_delay=14.40)
        n_neurons = 20  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)


        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        weight_to_spike = 2.0
        delay = 1.7

        loop_connections = list()
        for i in range(0, n_neurons):
            single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
                                 delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        spike_array = {'spike_times': [[0]]}
        populations.append(p.Population(n_neurons, p.IF_curr_exp,
                                        cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[0], populations[0],
                           p.FromListConnector(loop_connections)))
        projections.append(p.Projection(populations[1], populations[0],
                           p.FromListConnector(injection_connection)))

        populations[0].record_v()
        populations[0].record_gsyn()
        populations[0].record()

        p.run(500)

        spikes = populations[0].getSpikes(compatible_output=True)

        current_file_path = os.path.dirname(os.path.abspath(__file__))
        current_file_path = os.path.join(current_file_path, "spikes.data")
        spike_file = populations[0].printSpikes(current_file_path)

        spike_reader = p.utility_calls.read_spikes_from_file(
            current_file_path, min_atom=0, max_atom=n_neurons,
            min_time=0, max_time=500)
        read_in_spikes = spike_reader.spike_times
        p.end()
        os.remove(current_file_path)

        for spike_element, read_element in zip(spikes, read_in_spikes):
            self.assertEqual(round(spike_element[0], 1),
                             round(read_element[0], 1))
            self.assertEqual(round(spike_element[1], 1),
                             round(read_element[1], 1))

def main():
    minutes = 1
    seconds = 30
    milliseconds = 1000
    run_time = minutes * seconds * milliseconds

    weight_to_spike = 4.0

    model = sim.IF_curr_exp
    cell_params = {
        "cm": 0.25,  # nF
        "i_offset": 0.0,
        "tau_m": 10.0,
        "tau_refrac": 2.0,
        "tau_syn_E": 2.5,
        "tau_syn_I": 2.5,
        "v_reset": -70.0,
        "v_rest": -65.0,
        "v_thresh": -55.4,
    }
    # Available resolutions
    # 16, 32, 64, 128
    mode = ExternalDvsEmulatorDevice.MODE_32
    cam_res = int(mode)
    polarity = ExternalDvsEmulatorDevice.MERGED_POLARITY
    output_type = ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN_THR
    history_weight = 1.0
    cam_fps = 30

    behaviour = VirtualCam.BEHAVE_ATTENTION
    vcam = VirtualCam("./mnist/", fps=cam_fps, resolution=cam_res, behaviour=behaviour)

    cam_params = {
        "mode": mode,
        "polarity": polarity,
        "threshold": 12,
        "adaptive_threshold": False,
        "fps": cam_fps,
        "inhibition": False,
        "output_type": output_type,
        "save_spikes": "./spikes_from_cam.pickle",
        "history_weight": history_weight,
        "device_id": vcam,
        #'device_id': 0,
    }
    if polarity == ExternalDvsEmulatorDevice.MERGED_POLARITY:
        num_neurons = 2 * (cam_res ** 2)
    else:
        num_neurons = cam_res ** 2

    sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)

    target = sim.Population(num_neurons, model, cell_params)

    stimulation = sim.Population(num_neurons, DvsEmulatorDevice, cam_params, label="Webcam population")

    connector = sim.OneToOneConnector(weights=weight_to_spike)

    projection = sim.Projection(stimulation, target, connector)

    target.record()

    sim.run(run_time)

    spikes = target.getSpikes(compatible_output=True)

    sim.end()
    # stimulation._vertex.stop()

    print("Raster plot of the spikes that Spinnaker echoed back")
    fig = pylab.figure()

    spike_times = [spike_time for (neuron_id, spike_time) in spikes]
    spike_ids = [neuron_id for (neuron_id, spike_time) in spikes]

    pylab.plot(spike_times, spike_ids, ".", markerfacecolor="None", markeredgecolor="Blue", markersize=3)

    pylab.show()

    print("Converting spikes into video")
    s2v = SpikesToVideo(
        cam_res,
        spikes,
        fps=cam_fps,
        # fourcc='MJPG',
        scale=2,
    )

    def test_get_voltage(self):
        """
        test that tests the getting of v from a pre determined recording
        :return:
        """
        p.setup(timestep=0.1, min_delay=1.0, max_delay=14.40)
        n_neurons = 200  # number of neurons in each population
        runtime = 500
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        weight_to_spike = 2.0
        delay = 1.7

        loop_connections = list()
        for i in range(0, n_neurons):
            single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
                                 delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        spike_array = {'spike_times': [[0]]}
        populations.append(p.Population(n_neurons, p.IF_curr_exp, cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[0], populations[0],
                           p.FromListConnector(loop_connections)))
        projections.append(p.Projection(populations[1], populations[0],
                           p.FromListConnector(injection_connection)))

        populations[0].record_v()
        populations[0].record_gsyn()
        populations[0].record()

        p.run(runtime)

        v = populations[0].get_v(compatible_output=True)

        current_file_path = os.path.dirname(os.path.abspath(__file__))
        current_file_path = os.path.join(current_file_path, "v.data")
        pre_recorded_data = p.utility_calls.read_in_data_from_file(
            current_file_path, 0, n_neurons, 0, runtime)

        p.end()

        for spike_element, read_element in zip(v, pre_recorded_data):
            self.assertEqual(round(spike_element[0], 1),
                             round(read_element[0], 1))
            self.assertEqual(round(spike_element[1], 1),
                             round(read_element[1], 1))
            self.assertEqual(round(spike_element[2], 1),
                             round(read_element[2], 1))