コード例 #1
0
    def move(self, goal_dist, callback=None, erase=True):
        """
        same thing as moveTo
        """
        if erase:
            self.goal_dist = []

        self.goal_dist.append(Distance(goal_dist, callback))
        motion.move(goal_dist, self.private_move_callback)
コード例 #2
0
def mainloop(j, sx, ex, srange, erange, ups, ls):
    k2 = translate(j, sx, ex, srange, erange)
    y2 = 150
    # put your y2 equation here
    te3, te4 = move(k2, y2)
    alpha = translate(te3, 0, 180, ups.sp, ups.ep)
    beta = translate(te4 - 90, 0, 180, ls.sp, ls.ep)
    return alpha, beta
コード例 #3
0
def callback(data):
    motion.move(data.data)
コード例 #4
0
ファイル: main.py プロジェクト: ewilson/tanks
 def _move(self):
     delta_x, delta_y = motion.move(self.speed, self.angle)
     self.center_x += delta_x
     self.center_y += delta_y
コード例 #5
0
import socket

from motion import click, move

# UDP_IP = "127.0.0.1"
UDP_IP = "0.0.0.0"
UDP_PORT = 5005
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # UDP
sock.bind((UDP_IP, UDP_PORT))
while True:
    data, _ = sock.recvfrom(16)
    print("received message:", data)

    message = data.decode()
    tab = message.split(' ')
    # x, y, cl (int, int 0/1)
    x, y, cl = int(tab[0]), int(tab[1]), int(tab[2])
    move(x, y)
    if cl == 1:
        click()
コード例 #6
0
import motion
import socket

CONNECTION_LIST = [] # list of socket clients
REVC_BUFFER = 4096
PORT = 8080
HOST = '192.168.1.108'

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

try:
    s.bind(HOST, PORT)
except socket.error as msg:
    print "Bind failed. Error code: " + str(msg[0] + "Message" + msg[1])
    exit(1)

s.listen(5)
print "socket binds successfully, and is listening now."

conn, addr = s.accept()
print "Connected with " + addr[0] + str(addr[1]) 

while True:
	

s.close()
motion.move("fr")
コード例 #7
0
    #         outputs.remove(s)
    #     else:
    #         s.send(next_msg)

    for s in exceptional:
        inputs.remove(s)
        if s in outputs:
            outputs.remove(s)
        s.close()
        del message_queues[s]

    rightTurn = [0.0, 0.0, 0.40]
    leftTurn = [0.0, 0.0, -0.40]
    walkForward = [0.8, 0.0, 0.0]
    standing = False

    if (message == "StandIsGo" and not standing):
        posture.goToPosture("StandInit", 1.0)
        standing = True
    elif (message == "WalkIsGo"):
        motion.move(walkForward[0], walkForward[1], walkForward[2])
    elif (message == "WalkIsStop"):
        motion.move(0, 0, 0.0)
    elif (message == "TurnRight"):
        print(message)
        motion.post.moveTo(rightTurn[0], rightTurn[1], rightTurn[2])
    elif (message == "TurnLeft"):
        print(message)
        motion.post.moveTo(leftTurn[0], leftTurn[1], leftTurn[2])
    elif (message == "Sit"):
        posture.goToPosture("Sit", 1.0)
コード例 #8
0
ファイル: simulation.py プロジェクト: aklawy/SNN_Navigation
def simulate_learning(neurons, receptors, nrns_sd, rctrs_sd, arena):
    """
    Run simulation for 40 seconds based on network topology encoded in
    individual.

    @param individual: Binary string encoding network topology.
    @param arena: The arena object in which the simulation is carried
                    out.
    @param n_step: Number of steps the simulation is divided in.
    @param t_step: Number of milliseconds in each step.
    @param reset: bool triggering the reset of the nest kernel.
    """

    global simtime
    simdata = create_empty_data_lists()

    if data['init'] == 'random':
        simdata['x_init'], simdata['y_init'], theta_init = \
                                                    select_random_pose(arena)
    x_cur = simdata['x_init']
    y_cur =  simdata['y_init']
    theta_cur = theta_init

    err_l, err_r = 0, 0

    simdata['rctr_nrn_trace'].append(np.zeros((18, 10)))
    simdata['nrn_nrn_trace'].append(np.zeros((10, 10)))
    motor_spks = nrns_sd[6:]

    for t in range(n_step):
        ev.update_refratory_perioud()
        simdata['traj'].append((x_cur, y_cur))

        px = network.set_receptors_firing_rate(x_cur, y_cur, theta_cur,
                                               err_l, err_r)
        simdata['pixel_values'].append(px)

        # Run simulation for time-step
        nest.Simulate(t_step)
        simtime += t_step
        motor_firing_rates = network.get_motor_neurons_firing_rates(motor_spks)

        v_l_act, v_r_act, v_t, w_t, err_l, err_r, col, v_l_des, v_r_des = \
        motion.update_wheel_speeds(x_cur, y_cur, theta_cur, motor_firing_rates)

        # Save dsired and actual speeds
        simdata['speed_log'].append((v_l_act, v_r_act))
        simdata['desired_speed_log'].append((v_l_des, v_r_des))

        # Save motor neurons firing rates
        simdata['motor_fr'].append(motor_firing_rates)

        # Save linear and angualr velocities
        simdata['linear_velocity_log'].append(v_t)
        simdata['angular_velocity_log'].append(w_t)

        # Move robot according to the read-out speeds from motor neurons
        x_cur, y_cur, theta_cur = motion.move(x_cur, y_cur, theta_cur, v_t,
                                              w_t)

        nrns_st, rctrs_st = learning.get_spike_times(nrns_sd, rctrs_sd)
        rec_nrn_tags, nrn_nrn_tags, rctr_t, nrn_t, pt = \
            learning.get_eligibility_trace(nrns_st, rctrs_st, simtime,
                    simdata['rctr_nrn_trace'][t], simdata['nrn_nrn_trace'][t])
        print simtime
        simdata['rctr_nrn_trace'].append(rec_nrn_tags)
        simdata['nrn_nrn_trace'].append(nrn_nrn_tags)

        # Stop simulation if collision occurs
        if col:
            simdata['speed_log'].extend((0, 0) for k in range(t, 400))
            break

    simdata['fitness'] = ev.get_fitness_value(simdata['speed_log'])

    return simdata, rctr_t, nrn_t, pt, col    
コード例 #9
0
ファイル: simulation.py プロジェクト: aklawy/SNN_Navigation
def simulate_evolution(individual, arena, n_step, t_step, reset=True):
    """
    Run simulation for 40 seconds based on network topology encoded in
    individual.

    @param individual: Binary string encoding network topology.
    @param arena: The arena object in which the simulation is carried
                    out.
    @param n_step: Number of steps the simulation is divided in.
    @param t_step: Number of milliseconds in each step.
    @param reset: bool triggering the reset of the nest kernel.
    """

    # Reset nest kernel just in case it was not reset & adjust
    # resolution.
    nest.ResetKernel()
    nest.SetKernelStatus({'resolution': 1.0, 'local_num_threads': 4})
    nest.set_verbosity('M_ERROR')

    if data['init'] == 'random':
        x, y, theta = select_random_pose(arena)

    simdata = create_empty_data_lists()
    simdata['x_init'] = x_init
    simdata['y_init'] = y_init
    simdata['theta_init'] = theta_init

    motor_spks = network.create_evolutionary_network(individual, data['model'])
    x_cur = x_init
    y_cur = y_init
    theta_cur = theta_init
    err_l, err_r = 0, 0

    for t in range(n_step):
        # Save current position in trajectory list
        simdata['traj'].append((x_cur, y_cur))

        # Add nioise to
        network.update_refratory_perioud(data['model'])

        # Set receptors' firing probability
        px = network.set_receptors_firing_rate(x_cur, y_cur, theta_cur,
                                               err_l, err_r, arena)
        simdata['pixel_values'].append(px)

        # Run simulation for 100 ms
        nest.Simulate(t_step)

        motor_firing_rates = network.get_motor_neurons_firing_rates(motor_spks)

        # Get desired and actual speeds
        col, speed_dict = motion.update_wheel_speeds(x_cur, y_cur, theta_cur,
                                                 motor_firing_rates, t_step,
                                                 arena)

        # Stop simulation if collision occurs
        if col:
            simdata['speed_log'].extend((0, 0) for k in range(t, 400))
            break

        # Save simulation data
        simdata['speed_log'].append((speed_dict['actual_left'],
                                     speed_dict['actual_right']))
        simdata['desired_speed_log'].append((speed_dict['desired_left'],
                                             speed_dict['desired_right']))
        simdata['motor_fr'].append(motor_firing_rates)
        simdata['linear_velocity_log'].append(speed_dict['linear'])
        simdata['angular_velocity_log'].append(speed_dict['angular'])

        # Move robot according to the read-out speeds from motor neurons
        x_cur, y_cur, theta_cur = motion.move(x_cur, y_cur, theta_cur,
                    speed_dict['linear'], speed_dict['angular'], t_step/1000.)

    # Calculate individual's fitness value
    simdata['fitness'] = ev.get_fitness_value(simdata['speed_log'])

    # Get average number of spikes per second for each neuron
    simdata['average_spikes'] = network.get_average_spikes_per_second()

    # Get Voltmeter data
    simdata['voltmeter_data'] = network.get_voltmeter_data()

    if reset:
        nest.ResetKernel()
    return simdata