def _connect_controller(self):
try:
self.xbox_controller = Xbox360Controller(index=1,
axis_threshold=0.05)
except Exception as e: # this library emits a stupid general exception that makes it difficult to retry
try:
self.xbox_controller = Xbox360Controller(index=2,
axis_threshold=0.05)
except Exception as e:
self.xbox_controller = Xbox360Controller(index=0,
axis_threshold=0.05)
def _connect_controller(self):
try:
xbox_controller = Xbox360Controller(index=1, axis_threshold=0.05)
except Exception as e: # this library emits a stupid general exception that makes it difficult to retry
try:
xbox_controller = Xbox360Controller(index=2,
axis_threshold=0.05)
except Exception as e:
xbox_controller = Xbox360Controller(index=0,
axis_threshold=0.05)
xbox_controller.hat.when_moved = self._d_pad
xbox_controller.button_start.when_pressed = self._start
return xbox_controller
def establish_controller(index, logger, light_sender, gui):
try:
controller = Xbox360Controller(index=index)
logger.info(controller.name)
except Exception:
logger.error(
f'Encountered exception initiating controller at index {index}',
exc_info=True)
return
if 'Drum' in controller.name:
light_sender.add_controller(
'drums',
Drums(controller, logger, 'drums', (0, 0, 0), light_sender, gui),
1)
elif 'WingMan' in controller.name:
controller.axis_threshold = 0.05
light_sender.add_controller(
'car', Car(controller, logger, 'car', (0, 0, 0), light_sender,
gui), 2)
elif 'Guitar' in controller.name:
light_sender.add_controller(
'guitar1',
Guitar(controller, logger, 'guitar1', (0, 0, 0), light_sender,
gui), 3)
else:
logger.error(
f'Unrecognized controller found with name {controller.name}. Skipping it.'
)
controller.close()
def HandleInput(self):
try:
self.isActive = True
with Xbox360Controller(0, axis_threshold=0.0) as controller:
# Button A events
controller.button_a.when_pressed = self.on_button_pressed
controller.button_a.when_released = self.on_button_released
# Button B events
controller.button_b.when_pressed = self.on_button_pressed
controller.button_b.when_released = self.on_button_released
# Button Y events
controller.button_y.when_pressed = self.on_button_pressed
controller.button_y.when_released = self.on_button_released
# Button X events
controller.button_x.when_pressed = self.on_button_pressed
controller.button_x.when_released = self.on_button_released
# Button Trigger L events
controller.button_trigger_l.when_pressed = self.on_button_pressed
# Button Trigger R events
controller.button_trigger_r.when_pressed = self.on_button_pressed
# Button Thumb L events
controller.button_thumb_l.when_pressed = self.on_button_pressed
# Button Thumb R events
controller.button_thumb_r.when_pressed = self.on_button_pressed
# Start Button events
controller.button_start.when_pressed = self.on_button_pressed
# Left and right axis move event
controller.axis_l.when_moved = self.on_axis_moved
controller.axis_r.when_moved = self.on_axis_moved
signal.pause()
except KeyboardInterrupt:
self.isActive = False
pass
def main():
try:
configure_gpIO()
except Exception as e:
print(e)
try:
with Xbox360Controller(0, axis_threshold=0.2) as controller:
# Button A events
controller.button_a.when_pressed = walk_forward
controller.button_a.when_released = stop
controller.button_b.when_pressed = walk_backward
controller.button_b.when_released = stop
# Left and right axis move event
#controller.axis_l.when_moved = on_axis_moved
controller.axis_l.when_moved = on_axis_moved
controller.trigger_r.when_moved = on_trigger_pressed
signal.pause()
except KeyboardInterrupt:
pass
def _connect_controller(self):
try:
xbox_controller = Xbox360Controller(index=1, axis_threshold=0.05)
except Exception as e: # this library emits a stupid general exception that makes it difficult to retry
try:
xbox_controller = Xbox360Controller(index=2,
axis_threshold=0.05)
except Exception as e:
xbox_controller = Xbox360Controller(index=0,
axis_threshold=0.05)
xbox_controller.button_trigger_r.when_pressed = lambda axis: self.cycle_right.emit(
axis)
xbox_controller.button_trigger_l.when_pressed = lambda axis: self.cycle_left.emit(
axis)
return xbox_controller
def Start(self):
with Xbox360Controller(0, axis_threshold=self.deadzone) as controller:
# BUTTONS
controller.button_a.when_pressed = self.on_pressed # A
controller.button_a.when_released = self.on_released
controller.button_b.when_pressed = self.on_pressed # B
controller.button_b.when_released = self.on_released
controller.button_x.when_pressed = self.on_pressed # X
controller.button_x.when_released = self.on_released
controller.button_y.when_pressed = self.on_pressed # Y
controller.button_y.when_released = self.on_released
controller.button_trigger_l.when_pressed = self.on_pressed # LB
controller.button_trigger_l.when_released = self.on_released
controller.button_trigger_r.when_pressed = self.on_pressed # RB
controller.button_trigger_r.when_released = self.on_released
controller.button_thumb_l.when_pressed = self.on_pressed # LS
controller.button_thumb_l.when_released = self.on_released
controller.button_thumb_r.when_pressed = self.on_pressed # RS
controller.button_thumb_r.when_released = self.on_released
controller.button_select.when_pressed = self.on_pressed # back
controller.button_select.when_released = self.on_released
controller.button_start.when_pressed = self.on_pressed # start
controller.button_start.when_released = self.on_released
controller.button_mode.when_pressed = self.on_pressed # mode
controller.button_mode.when_released = self.on_released
# AXES
controller.axis_l.when_moved = self.on_moved # left
controller.axis_r.when_moved = self.on_moved # right
controller.hat.when_moved = self.on_moved # hat
controller.trigger_l.when_moved = self.on_moved # LT
controller.trigger_r.when_moved = self.on_moved # RT
# The Loop
counter = 0
while self.run:
#self.steering()
time.sleep(0.005)
try:
#print("przed metoda")
self._run_in_thread2(self.silnik_1.Jedz,
self.right_stick[1])
self._run_in_thread2(self.silnik_2.Jedz,
self.left_stick[1])
# if(self.stara_pozycja_1 != (self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780) or self.stara_pozycja_2 != (self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780)):
# os.system("clear")
# print("Silnik 1: \t{:>5.3f}".format((self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780)))
# print("Silnik 2: \t{:>5.3f}".format((self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780)))
# self.stara_pozycja_1 = (self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780)
# self.stara_pozycja_2 = (self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780)
#print("za metoda")
# Zostawione jako przyklad self.RPI.set_engine_driver_values(self.engines[0]/100, self.engines[1]/100, self.engines[2]/100,self.engines[3]/100, 0, 0)
except Exception as e:
print(e)
print(self.right_stick[1])
pass
def Start(self):
with Xbox360Controller(0, axis_threshold=self.deadzone) as controller:
# BUTTONS
controller.button_a.when_pressed = self.on_pressed # A
controller.button_a.when_released = self.on_released
controller.button_b.when_pressed = self.on_pressed # B
controller.button_b.when_released = self.on_released
controller.button_x.when_pressed = self.on_pressed # X
controller.button_x.when_released = self.on_released
controller.button_y.when_pressed = self.on_pressed # Y
controller.button_y.when_released = self.on_released
controller.button_trigger_l.when_pressed = self.on_pressed # LB
controller.button_trigger_l.when_released = self.on_released
controller.button_trigger_r.when_pressed = self.on_pressed # RB
controller.button_trigger_r.when_released = self.on_released
controller.button_thumb_l.when_pressed = self.on_pressed # LS
controller.button_thumb_l.when_released = self.on_released
controller.button_thumb_r.when_pressed = self.on_pressed # RS
controller.button_thumb_r.when_released = self.on_released
controller.button_select.when_pressed = self.on_pressed # back
controller.button_select.when_released = self.on_released
controller.button_start.when_pressed = self.on_pressed # start
controller.button_start.when_released = self.on_released
controller.button_mode.when_pressed = self.on_pressed # mode
controller.button_mode.when_released = self.on_released
# AXES
controller.axis_l.when_moved = self.on_moved # left
controller.axis_r.when_moved = self.on_moved # right
controller.hat.when_moved = self.on_moved # hat
controller.trigger_l.when_moved = self.on_moved # LT
controller.trigger_r.when_moved = self.on_moved # RT
# The Loop
counter = 0
while self.run:
self.steering()
time.sleep(0.005)
counter += 1
if counter == 20:
counter = 0
#print(self.engines)
for e in self.engines:
if e > 50:
e = -50
if e < 50:
e = -50
try:
self.RPI.set_engine_driver_values(self.engines[0] / 100,
self.engines[1] / 100,
self.engines[2] / 100, 0,
0, self.engines[3] / 100)
except Exception:
pass
def __init__(self, player, usb, comms_config, verbose):
self.controller_state = ControllerState()
self.joystick_deadband = 25 # Out of 512
# Launch comms thread
self.comms = CommsThread(comms_config, self.controller_state, verbose)
self.comms.daemon = True
self.comms.start()
print(f"Controller: Launched player {player}")
try:
with Xbox360Controller(usb, axis_threshold=0.0) as self.controller:
# Left and right joysticks
self.controller.axis_l.when_moved = self.on_left_joystick_moved
self.controller.axis_r.when_moved = self.on_right_joystick_moved
# Dpad
self.controller.hat.when_moved = self.on_dpad_pressed
# Triggers
self.controller.trigger_l.when_moved = self.on_left_trigger
self.controller.trigger_r.when_moved = self.on_right_trigger
# Bumpers
self.controller.button_trigger_l.when_pressed = self.on_left_bumper_pressed
self.controller.button_trigger_l.when_released = self.on_left_bumper_released
self.controller.button_trigger_r.when_pressed = self.on_right_bumper_pressed
self.controller.button_trigger_r.when_released = self.on_right_bumper_released
# Button events
self.controller.button_a.when_pressed = self.on_a_button_pressed
self.controller.button_a.when_released = self.on_a_button_released
self.controller.button_b.when_pressed = self.on_b_button_pressed
self.controller.button_b.when_released = self.on_b_button_released
self.controller.button_x.when_pressed = self.on_x_button_pressed
self.controller.button_x.when_released = self.on_x_button_released
self.controller.button_y.when_pressed = self.on_y_button_pressed
self.controller.button_y.when_released = self.on_y_button_released
self.controller.button_select.when_pressed = self.on_back_button_pressed
self.controller.button_select.when_released = self.on_back_button_released
self.controller.button_mode.when_pressed = self.on_guide_button_pressed
self.controller.button_mode.when_released = self.on_guide_button_released
self.controller.button_start.when_pressed = self.on_start_button_pressed
self.controller.button_start.when_released = self.on_start_button_released
# while True:
# self.controller.set_rumble(self.controller_state.collision*0.2, self.controller_state.collision*0.2,
# duration=100)
# time.sleep(0.1)
signal.pause()
except KeyboardInterrupt:
pass
def Start(self):
with Xbox360Controller(0, axis_threshold=self.deadzone) as controller:
# BUTTONS
controller.button_a.when_pressed = self.on_pressed # A
controller.button_a.when_released = self.on_released
controller.button_b.when_pressed = self.on_pressed # B
controller.button_b.when_released = self.on_released
controller.button_x.when_pressed = self.on_pressed # X
controller.button_x.when_released = self.on_released
controller.button_y.when_pressed = self.on_pressed # Y
controller.button_y.when_released = self.on_released
controller.button_trigger_l.when_pressed = self.on_pressed # LB
controller.button_trigger_l.when_released = self.on_released
controller.button_trigger_r.when_pressed = self.on_pressed # RB
controller.button_trigger_r.when_released = self.on_released
controller.button_thumb_l.when_pressed = self.on_pressed # LS
controller.button_thumb_l.when_released = self.on_released
controller.button_thumb_r.when_pressed = self.on_pressed # RS
controller.button_thumb_r.when_released = self.on_released
controller.button_select.when_pressed = self.on_pressed # back
controller.button_select.when_released = self.on_released
controller.button_start.when_pressed = self.on_pressed # start
controller.button_start.when_released = self.on_released
controller.button_mode.when_pressed = self.on_pressed # mode
controller.button_mode.when_released = self.on_released
# AXES
controller.axis_l.when_moved = self.on_moved # left
controller.axis_r.when_moved = self.on_moved # right
controller.hat.when_moved = self.on_moved # hat
controller.trigger_l.when_moved = self.on_moved # LT
controller.trigger_r.when_moved = self.on_moved # RT
# The Loop
counter =0
while self.run:
#self.steering() # Kompletnie niepotrzebne dla manipulatora, mozna wywalic
time.sleep(0.005)
try:
#print("przed metoda")
self._run_in_thread2(self.silnik_1.Jedz, self.right_stick[1]) # Dzialania silnika sa uruchamiane w watku zeby mozna bylo sterowac np. dwoma silnikami jednoczenie bez
self._run_in_thread2(self.silnik_2.Jedz, self.left_stick[1]) # przerywania pracy programu i monitorowania pada
# if(self.stara_pozycja_1 != (self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780) or self.stara_pozycja_2 != (self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780)):
# os.system("clear")
# print("Silnik 1: \t{:>5.3f}".format((self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780))) =========================================================
# print("Silnik 2: \t{:>5.3f}".format((self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780))) =MA RAZIE NIE DZIALA TRZEBA USTAWIC ODPOWIEDNIO ENKODERY=
# self.stara_pozycja_1 = (self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780) =WYSKALOWAC ENKODERY WZGLEDEM MOZLIWYCH OBROTOW MANIPU. =
# self.stara_pozycja_2 = (self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780) =ZEBY NIE BYLO W POLOWIE OBROTU RAMIENIA ZMIANY ODCZYTU =
#print("za metoda") =Z 0 NA 2V. =
#=========================================================
except Exception as e:
print(e)
print(self.right_stick[1])
pass
def ControllerMovement():
try:
with Xbox360Controller(0, axis_threshold=0.2) as controller:
controller.axis_r.when_moved = axis_move
controller.axis_l.when_moved = speed
controller.button_a.when_pressed = thrower
signal.pause()
except KeyboardInterrupt:
pass
def __init__(self):
#Extra Variables
self.gripper_load = 0.0
#----------------------------------------------------------------------------------------------------
#Pygame/Joystick Initialization
#----------------------------------------------------------------------------------------------------
#Provide Pygame with a Dummy Video Driver to enable functionality
os.environ["SDL_VIDEODRIVER"] = "dummy"
#Initialize Pygame Module
pygame.init()
# Initialize the joysticks
pygame.joystick.init()
#Initialize only one joystick connected
self.joystick = pygame.joystick.Joystick(0)
self.joystick.init()
#Initiate Xbox Controller
self.xbox = Xbox360Controller()
#----------------------------------------------------------------------------------------------------
#ROS Initialization
#----------------------------------------------------------------------------------------------------
rospy.init_node("joystick_controller")
#Initialize arm stuff
self.arm_pub = rospy.Publisher('control_signal', Point, queue_size=10)
self.arm_msg = Point()
rospy.Subscriber("xbox_vibrate", Int64, self.vibrateXbox)
#Initialize gripper stuff
self.gripper_pub = rospy.Publisher("/dual_gripper_controller/command",
Float64,
queue_size=10)
rospy.Subscriber("/dual_gripper_controller/state", JointState,
self.updateGripperLoad)
self.gripper_msg = Float64()
self.gripper_msg.data = 0.0
self.gripper_pub.publish(self.gripper_msg)
#Initialize rover stuff
self.rover_pub = rospy.Publisher("arlo_wheels", String, queue_size=10)
self.rover_msg = String()
self.rover_speed = 35.0 #Out of 200 max , Was 20
self.rover_msg.data = "rst\r"
self.rover_pub.publish(self.rover_msg)
#Rate for loop
self.rate = rospy.Rate(10) #10 Hertz
def __init__(self):
self.pub = rospy.Publisher('/cmd_vel', Twist, queue_size=10)
try:
self.controller = Xbox360Controller(0, axis_threshold=0.1)
# Left and right axis move event
self.controller.axis_l.when_moved = self.movement
self.controller.axis_r.when_moved = self.movement
# Button stop and kill
self.controller.button_a.when_released = self.kill
self.controller.button_b.when_released = self.stop
except Exception:
rospy.logwarn("x360 controller disconnected")
rospy.signal_shutdown("controller disconnected")
def Start(self):
with Xbox360Controller(0, axis_threshold=self.deadzone) as controller:
# BUTTONS
controller.button_a.when_pressed = self.on_pressed # A
controller.button_a.when_released = self.on_released
controller.button_b.when_pressed = self.on_pressed # B
controller.button_b.when_released = self.on_released
controller.button_x.when_pressed = self.on_pressed # X
controller.button_x.when_released = self.on_released
controller.button_y.when_pressed = self.on_pressed # Y
controller.button_y.when_released = self.on_released
controller.button_trigger_l.when_pressed = self.on_pressed # LB
controller.button_trigger_l.when_released = self.on_released
controller.button_trigger_r.when_pressed = self.on_pressed # RB
controller.button_trigger_r.when_released = self.on_released
controller.button_thumb_l.when_pressed = self.on_pressed # LS
controller.button_thumb_l.when_released = self.on_released
controller.button_thumb_r.when_pressed = self.on_pressed # RS
controller.button_thumb_r.when_released = self.on_released
controller.button_select.when_pressed = self.on_pressed # back
controller.button_select.when_released = self.on_released
controller.button_start.when_pressed = self.on_pressed # start
controller.button_start.when_released = self.on_released
controller.button_mode.when_pressed = self.on_pressed # mode
controller.button_mode.when_released = self.on_released
# AXES
controller.axis_l.when_moved = self.on_moved # left
controller.axis_r.when_moved = self.on_moved # right
controller.hat.when_moved = self.on_moved # hat
controller.trigger_l.when_moved = self.on_moved # LT
controller.trigger_r.when_moved = self.on_moved # RT
# The Loop
counter = 0
minA = 250 #kat do warunkow, z zapasem w góre zamiast 180
maxA = 350 #kat do warunkow, z zapasem w dół zamiast 360
minB = 100 #kat do warunkow, z zapasem w dół zamiast 450
maxB = 260 #kat do warunkow, z zapasem w dół zamiast 450
dodatnia = 0.5 #rotation speed
ujemna = -0.5 #predkosc obrotow przeciwnie z wskazówkami zegara
while self.run:
time.sleep(0.005)
try:
#=========================================================
pass
except Exception as e:
print(e)
pass
def __init__(self, active_scene, cursor, ms):
global launchOut
self.init_joystick()
self.active_scene = active_scene
self.buttons = [
'A', 'B', 'X', 'Y', 'LB', 'RB', 'Menu', 'Start', 'LS', 'RS', 'R'
]
self.hats = ['Up', 'Down', 'Left', 'Right']
# If you would like there to be a keyboard fallback configuration, fill those out
# here in this mapping.
self.key_map = {
pygame.K_UP: 'up',
pygame.K_DOWN: 'down',
pygame.K_LEFT: 'left',
pygame.K_RIGHT: 'right',
pygame.K_RETURN: 'start',
pygame.K_a: 'A',
pygame.K_b: 'B',
pygame.K_x: 'X',
pygame.K_y: 'Y',
pygame.K_l: 'L',
pygame.K_r: 'R'
}
self.cursor = cursor
self.speed = 75
self.lastPacketSendTime = datetime.datetime.now()
# This dictionary will tell you which logical buttons are pressed, whether it's
# via the keyboard or joystick
self.keys_pressed = {}
self.intakeTimer = pygame.time.get_ticks()
for button in self.buttons:
self.keys_pressed[button] = False
self.quit_attempt = False
self.launchSpeed = 0
self.launchTime = pygame.time.get_ticks()
launchOut = 0
self.decay = False
self.count = 0
self.ms = ms
self.controller = Xbox360Controller(0)
self.ballpos = deque()
self.robpos = deque()
self.vectors = deque()
def laptopNode():
global c_angle, c_speed, img, lscan
# controller = PurePursuit() #PurePursuitPlusPID()
print("h1")
rospy.init_node('ros_node_laptop')
print("h2")
pub = rospy.Publisher('/NN_angle_speed', String, queue_size=1)
print("h2.1")
img_sub = rospy.Subscriber('/raspicam_node/image/compressed',
CompressedImage, img_callback)
print("h2.2")
car_sub = rospy.Subscriber('/car_angle_speed', String, car_callback)
# lidar_sub = rospy.Subscriber('/rplidarNode/scan', LaserScan, lidar_callback)
print("h3")
rate = rospy.Rate(60) # 30 hz
if TRAINING:
xbox = Xbox360Controller()
print("h4")
while not rospy.is_shutdown():
if not TRAINING:
# img = process_img(img)
# # get into correct shape for network
# img = img.reshape(1,200,400,3).reshape(1,1,200,400,3)
# prediction = model.predict(img)[0]
# # construct line from predicted points, each being one meter apart
# trajectory_prediction = np.array([[float(x),prediction[x]] for x in range(len(prediction))])
# speed, angle = controller.get_control(trajectory_prediction, speed, desired_speed = 25, dt=1./FPS)
speed, angle = 0, 0
else:
angle = xbox.axis_l.x if abs(xbox.axis_l.x) > 0.15 else 0
speed = xbox.trigger_r.value - xbox.trigger_l.value if abs(
xbox.trigger_r.value - xbox.trigger_l.value) > 0.075 else 0
speed = -1 * speed / 2
# with open(f"training_{fname}.p",'a') as ff:
# pngname = {datetime.now().strftime('%m_%d_%H_%M_%S')}
# data = {"time" : rospy.get_time(), "c_angle" : c_angle, "c_speed" : c_speed, \
# "lscan" : lscan, "img" : f"raspicam_{pngname}.png"}
# cv2.imwrite(f"raspicam_{pngname}.png",img)
# pickle.dump(data,ff)
pub.publish(f"{angle},{speed}")
print(
f"NN Ang: {round(angle,2)}\tNN Vel: {round(speed,2)}\tCar Ang: {round(c_angle,2)}\tCar Vel: {round(c_speed,2)}\tAng Err: {round(c_angle-angle,2)}\tVel Err: {round(c_speed-speed,2)}"
)
rate.sleep()
if TRAINING:
xbox.close()
def configure_gamepad(self, index):
from xbox360controller import Xbox360Controller
self.gamepads.append([])
try:
with Xbox360Controller(index, raw_mode=True) as controller:
self.log("configuring gamepad", index)
for b in controller.buttons:
b.when_pressed = self.on_button_pressed
self.gamepads[index].append(b)
for a in controller.axes:
a.when_moved = self.on_axis_moved_raw
self.gamepads[index].append(a)
pause()
except Exception as error:
print(
f"{self.term_fail}No USB Controller connected. Skipped. \nError : {error}{self.term_endc}"
)
def trainNetwork():
global Recording
client = airsim.CarClient()
client.confirmConnection()
print('Connect succcefully！')
# client.enableApiControl(True)
# client.reset()
print('Environment initialized!')
controller = Xbox360Controller()
# Initialize the buffer
replay_experiences = deque()
replay_experiences = store_transition(replay_experiences, 'read')
# get the first state
kinematics = client.getCarState().kinematics_estimated
img = get_image(client)
velocity_x = kinematics.linear_velocity.x_val + 1.6
velocity_y = kinematics.linear_velocity.y_val - 15
velocity = np.sqrt(velocity_x**2 + velocity_y**2)
acc_x = kinematics.linear_acceleration.x_val
acc_y = kinematics.linear_acceleration.y_val
acc = np.sqrt(acc_x**2 + acc_y**2)
kinematics_state = np.array([velocity, acc])
state_previous = {}
state_previous['image'] = img
state_previous['kinematics_state'] = kinematics_state
reward_previous = 10
pbar = tqdm(total=MEMORY_SIZE - len(replay_experiences))
controller.button_mode.when_pressed = mode_button_pressed
client.simSetTimeOfDay(False)
start_size = int(len(replay_experiences))
difference = int(MEMORY_SIZE - len(replay_experiences))
# for i in tqdm(range(MEMORY_SIZE+10)):
while len(replay_experiences) < MEMORY_SIZE:
if len(replay_experiences) + 1 == start_size + difference // 2:
client.simSetTimeOfDay(True, "2019-6-17 18:00:00", move_sun=True)
if (len(replay_experiences) + 1 - start_size) % (difference // 2) == 0:
client.simSetWeatherParameter(airsim.WeatherParameter.Rain, 0)
client.simSetWeatherParameter(airsim.WeatherParameter.Snow, 0)
client.simSetWeatherParameter(airsim.WeatherParameter.MapleLeaf, 0)
if (len(replay_experiences) + 1 -
start_size) % (difference // 2) == (difference // 2) * (1 / 4):
client.simSetWeatherParameter(airsim.WeatherParameter.Rain, 0.99)
if (len(replay_experiences) + 1 -
start_size) % (difference // 2) == (difference // 2) * (1 / 4):
client.simSetWeatherParameter(airsim.WeatherParameter.Snow, 0.99)
if (len(replay_experiences) + 1 -
start_size) % (difference // 2) == (difference // 2) * (1 / 4):
client.simSetWeatherParameter(airsim.WeatherParameter.Rain, 0)
client.simSetWeatherParameter(airsim.WeatherParameter.MapleLeaf,
0.99)
if (len(replay_experiences) + 1) % 200 == 0:
signal_back = store_transition(replay_experiences, 'store')
if signal_back:
print('store pkl file succcefully')
car_state = client.getCarState()
_, reward_step = compute_reward(car_state)
kinematics = car_state.kinematics_estimated
img = get_image(client)
velocity_x = kinematics.linear_velocity.x_val + 1.6
velocity_y = kinematics.linear_velocity.y_val - 15
velocity = np.sqrt(velocity_x**2 + velocity_y**2)
acc_x = kinematics.linear_acceleration.x_val
acc_y = kinematics.linear_acceleration.y_val
acc = np.sqrt(acc_x**2 + acc_y**2)
kinematics_state = np.array([velocity, acc])
state = {}
state['image'] = img
state['kinematics_state'] = kinematics_state
steer = controller.axis_l.x
brake = controller.trigger_l.value
acc = controller.trigger_r.value
if steer >= -0.25 and steer <= 0.25:
steer = 0
elif steer > 0.25:
steer = 4 / 3.0 * steer - 1 / 3.0
elif steer < -0.25:
steer = 4 / 3.0 * steer + 1 / 3.0
print('acc: %f brake: %f steer: %f' % (acc, brake, steer))
print('reward:', reward_previous)
print('Recording: %d' % Recording)
print('memory: %d' % len(replay_experiences))
print('weather:', times_a, times_b, times_x, times_y)
action = np.array([acc, brake, steer])
if Recording:
replay_experiences.append(
(state_previous, action, reward_previous))
pbar.update(1)
state_previous = copy.deepcopy(state)
reward_previous = reward_step
time.sleep(0.1)
client.simSetTimeOfDay(False)
print(len(replay_experiences))
signal_back = store_transition(replay_experiences, 'store')
if signal_back:
print('store pkl file succcefully')
print(len(replay_experiences))
p = GPIO.PWM(signalPin, freq)
p.start(dc)
# def speed2dc():
# dc = dc_n + (speed*20)
# if dc > dc_n-1 and dc < dc_n+1:
# dc = 0
# elif dc < dc_min:
# dc = dc_min
# elif dc > dc_max:
# dc = dc_max
# p.ChangeDutyCycle(dc)
# print("Freqency: ", freq, "Duty Cycle: ", dc)
controller = Xbox360Controller(0, axis_threshold=0.2)
while (1):
# randomVal = controller.axis_l._value_y
# speed = float(input("Enter Speed [-1,1]: "))
speed = controller.axis_l._value_y
dc = dc_n + (speed * 20)
if dc > dc_n - 1 and dc < dc_n + 1:
dc = 0
elif dc < dc_min:
dc = dc_min
elif dc > dc_max:
dc = dc_max
p.ChangeDutyCycle(dc)
print("L Axis: ", controller.axis_l._value_y, "Freqency: ", freq,
"Duty Cycle: ", dc)
import time
from xbox360controller import Xbox360Controller
import signal
def create_callback(command):
def on_button_released(button):
print(command, flush=True)
return on_button_released
if __name__ == '__main__':
try:
with Xbox360Controller(0, axis_threshold=0.2) as controller:
controller.button_a.when_released = create_callback("playpause")
controller.button_b.when_released = create_callback(
"previous-context")
controller.button_y.when_released = create_callback(
"play-album-current")
controller.button_x.when_released = create_callback(
"stop-listening")
controller.button_trigger_r.when_released = create_callback(
"next-track")
controller.button_trigger_l.when_released = create_callback(
"previous-track")
controller.button_start.when_released = create_callback(
"start-on raspberry spotify:user:11102248483:playlist:3ar6blvho0KSTjNaYfzlt2"
)
controller.button_mode.when_released = create_callback(
async def main(args):
global controller_state
if not os.path.exists('/dev/input/js0'):
print('Controller not plugged')
return
# parse the spi flash
if args.spi_flash:
with open(args.spi_flash, 'rb') as spi_flash_file:
spi_flash = FlashMemory(spi_flash_file.read())
else:
# Create memory containing default controller stick calibration
spi_flash = FlashMemory()
controller = Controller.PRO_CONTROLLER
factory = controller_protocol_factory(controller, spi_flash=spi_flash)
ctl_psm, itr_psm = 17, 19
transport, protocol = await create_hid_server(
factory,
reconnect_bt_addr=args.reconnect_bt_addr,
ctl_psm=ctl_psm,
itr_psm=itr_psm,
capture_file=None,
device_id=args.device_id)
controller_state = protocol.get_controller_state()
with Xbox360Controller(0, axis_threshold=-1) as xcontroller:
if args.xbox_layout:
xcontroller.button_a.when_pressed = a_pressed
xcontroller.button_a.when_released = a_released
xcontroller.button_b.when_pressed = b_pressed
xcontroller.button_b.when_released = b_released
xcontroller.button_x.when_pressed = x_pressed
xcontroller.button_x.when_released = x_released
xcontroller.button_y.when_pressed = y_pressed
xcontroller.button_y.when_released = y_released
else:
xcontroller.button_a.when_pressed = b_pressed
xcontroller.button_a.when_released = b_released
xcontroller.button_b.when_pressed = a_pressed
xcontroller.button_b.when_released = a_released
xcontroller.button_x.when_pressed = y_pressed
xcontroller.button_x.when_released = y_released
xcontroller.button_y.when_pressed = x_pressed
xcontroller.button_y.when_released = x_released
xcontroller.button_trigger_l.when_pressed = l_pressed
xcontroller.button_trigger_l.when_released = l_released
xcontroller.button_trigger_r.when_pressed = r_pressed
xcontroller.button_trigger_r.when_released = r_released
xcontroller.button_thumb_l.when_pressed = ls_pressed
xcontroller.button_thumb_l.when_released = ls_released
xcontroller.button_thumb_r.when_pressed = rs_pressed
xcontroller.button_thumb_r.when_released = rs_released
xcontroller.button_mode.when_pressed = home_pressed
xcontroller.button_mode.when_released = home_released
xcontroller.button_start.when_pressed = plus_pressed
xcontroller.button_start.when_released = plus_released
xcontroller.button_select.when_pressed = minus_pressed
xcontroller.button_select.when_released = minus_released
xcontroller.trigger_l.when_moved = lt_moved
xcontroller.trigger_r.when_moved = rt_moved
xcontroller.hat.when_moved = hat_moved
xcontroller.axis_l.when_moved = axis_l_moved
xcontroller.axis_r.when_moved = axis_r_moved
while True:
try:
await controller_state.send()
except NotConnectedError:
print('Connection Lost')
return
x_axis = round(axis.x * 500)
y_axis = round(axis.y * -500)
if abs(x_axis) <= 150:
x_axis = 0
if abs(y_axis) <= 150:
y_axis = 0
print('Axis {0} moved to {1} {2}'.format(axis.name, x_axis, y_axis))
payload = json.dumps({
"axis": axis.name,
"x_axis": x_axis,
"y_axis": y_axis
})
client.publish(robotName, payload)
try:
with Xbox360Controller(int(robot_number) - 1,
axis_threshold=0.2) as controller:
# Button A events
controller.button_a.when_pressed = on_button_pressed
controller.button_a.when_released = on_button_released
# Left and right axis move event
controller.axis_l.when_moved = on_axis_moved
signal.pause()
except KeyboardInterrupt:
pass
def Start(self):
with Xbox360Controller(0, axis_threshold=self.deadzone) as controller:
# BUTTONS
controller.button_a.when_pressed = self.on_pressed # A
controller.button_a.when_released = self.on_released
controller.button_b.when_pressed = self.on_pressed # B
controller.button_b.when_released = self.on_released
controller.button_x.when_pressed = self.on_pressed # X
controller.button_x.when_released = self.on_released
controller.button_y.when_pressed = self.on_pressed # Y
controller.button_y.when_released = self.on_released
controller.button_trigger_l.when_pressed = self.on_pressed # LB
controller.button_trigger_l.when_released = self.on_released
controller.button_trigger_r.when_pressed = self.on_pressed # RB
controller.button_trigger_r.when_released = self.on_released
controller.button_thumb_l.when_pressed = self.on_pressed # LS
controller.button_thumb_l.when_released = self.on_released
controller.button_thumb_r.when_pressed = self.on_pressed # RS
controller.button_thumb_r.when_released = self.on_released
controller.button_select.when_pressed = self.on_pressed # back
controller.button_select.when_released = self.on_released
controller.button_start.when_pressed = self.on_pressed # start
controller.button_start.when_released = self.on_released
controller.button_mode.when_pressed = self.on_pressed # mode
controller.button_mode.when_released = self.on_released
# AXES
controller.axis_l.when_moved = self.on_moved # left
controller.axis_r.when_moved = self.on_moved # right
controller.hat.when_moved = self.on_moved # hat
controller.trigger_l.when_moved = self.on_moved # LT
controller.trigger_r.when_moved = self.on_moved # RT
# The Loop
counter =0
minA = 250 #kat do warunkow, z zapasem w góre zamiast 180
maxA = 350 #kat do warunkow, z zapasem w dół zamiast 360
minB = 100 #kat do warunkow, z zapasem w dół zamiast 450
maxB = 260 #kat do warunkow, z zapasem w dół zamiast 450
dodatnia = 0.5 #rotation speed
ujemna = -0.5 #predkosc obrotow przeciwnie z wskazówkami zegara
while self.run:
time.sleep(0.005)
try:
#print("przed metoda")
# self.updateAngle()
# if (self.AM2 < self.AM1 and self.AM1 - self.AM2 < 180):
self._run_in_thread2(self.silnik_1.Jedz, self.right_stick[1]) # Dzialania silnika sa uruchamiane w watku zeby mozna bylo sterowac np. dwoma silnikami jednoczenie bez
self._run_in_thread2(self.silnik_2.Jedz, self.left_stick[1]) # przerywania pracy programu i monitorowania pada
## elif (self.AM1 <= minA):
## self._run_in_thread2(self.silnik_1.Jedz, ujemna)
## print("A<minA")
##
## elif (sef.AM1 >= maxA):
## self._run_in_thread2(self.silnik_1.Jedz, dodatnia)
## print("A>=maxA")
# elif (self.AM2 + 5 >= self.AM1):
# self._run_in_thread2(self.silnik_2.Jedz, ujemna)
# print("B+5>=A")
## elif (self.AM2 <= minB):
## self._run_in_thread2(self.silnik_2.Jedz, dodatnia)
## print("B<=minB")
## elif (self.AM2 >= maxB):
## self._run_in_thread2(self.silnik_2.Jedz, ujemna)
## print("B>=maxB")
#elif (self.AM1 - self.AM2 >= 180):
# self._run_in_thread2(self.silnik_2.Jedz, dodatnia)
# print("A-B>=180")
## if(AM1 != oldAM1 or AM2 != oldAM2)
## if(self.stara_pozycja_1 != (self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780) or self.stara_pozycja_2 != (self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780)):
## os.system("clear")
## #print("Silnik 1: \t{:>5.3f}".format((self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780))) #=========================================================
## #print("Silnik 2: \t{:>5.3f}".format((self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780))
## print("Silnik 1: \t{:>5.3f}".format(AM1)
## print("Silnik 1: \t{:>5.3f}".format(AM2) #=MA RAZIE NIE DZIALA TRZEBA USTAWIC ODPOWIEDNIO ENKODERY=
## self.stara_pozycja_1 = (self.silnik_1.pozycja.voltage-0.780)*360/(3.946 - 0.780) #=WYSKALOWAC ENKODERY WZGLEDEM MOZLIWYCH OBROTOW MANIPU. =
## self.stara_pozycja_2 = (self.silnik_2.pozycja.voltage-0.780)*360/(3.946 - 0.780) #=ZEBY NIE BYLO W POLOWIE OBROTU RAMIENIA ZMIANY ODCZYTU =
## print("za metoda") #=Z 0 NA 2V. =
## #=========================================================
except Exception as e:
print(e)
pass
buzzer_command = RobotBuzzer()
buzzer_command.header = BaseTypes.PACKET_TYPE_ROBOT_BUZZER
buzzer_command.remVersion = BaseTypes.LOCAL_REM_VERSION
buzzer_command.id = self.robot_id
buzzer_command.period = int(buzzer_value * 1000)
buzzer_command.duration = 0.1
message = np.concatenate(
(self.command.encode(), buzzer_command.encode()))
print(message)
return message
return self.command.encode()
print(Xbox360Controller.get_available())
# wrappers = [JoystickWrapper(Xbox360Controller(i)) for i in range(len(Xbox360Controller.get_available()))]
wrappers = [
JoystickWrapper(controller)
for controller in Xbox360Controller.get_available()
]
while True:
# Open basestation with the basestation
if basestation is None or not basestation.isOpen():
basestation = utils.openContinuous(timeout=0.001)
try:
while True:
# Run at {packet_Hz}fps
def main(args):
with BotRecorder(
args.filename,
args.device) as recorder, Xbox360Controller(0) as controller:
input('hit enter to start recording\n')
# Axis
# Sticks
controller.axis_l.when_moved = lambda a: recorder.stick_move(
a, L_STICK)
controller.axis_r.when_moved = lambda a: recorder.stick_move(
a, R_STICK)
# DPAD
controller.hat.when_moved = lambda a: recorder.dpad_move(a)
# Raw Axis
# Trigger
controller.trigger_l.when_moved = lambda ra: recorder.trigger_move(
ra, ZL)
controller.trigger_r.when_moved = lambda ra: recorder.trigger_move(
ra, ZR)
# Buttons
# are mapped to the switch button layout
controller.button_b.when_pressed = lambda b: recorder.button_press(A)
controller.button_b.when_released = lambda b: recorder.button_release(A
)
controller.button_a.when_pressed = lambda b: recorder.button_press(B)
controller.button_a.when_released = lambda b: recorder.button_release(B
)
controller.button_y.when_pressed = lambda b: recorder.button_press(X)
controller.button_y.when_released = lambda b: recorder.button_release(X
)
controller.button_x.when_pressed = lambda b: recorder.button_press(Y)
controller.button_x.when_released = lambda b: recorder.button_release(Y
)
controller.button_trigger_l.when_pressed = lambda b: recorder.button_press(
L)
controller.button_trigger_l.when_released = lambda b: recorder.button_release(
L)
controller.button_trigger_r.when_pressed = lambda b: recorder.button_press(
R)
controller.button_trigger_r.when_released = lambda b: recorder.button_release(
R)
controller.button_mode.when_pressed = lambda b: recorder.button_press(
HOME)
controller.button_mode.when_released = lambda b: recorder.button_release(
HOME)
controller.button_select.when_pressed = lambda b: recorder.button_press(
MINUS)
controller.button_select.when_released = lambda b: recorder.button_release(
MINUS)
controller.button_start.when_pressed = lambda b: recorder.button_press(
PLUS)
controller.button_start.when_released = lambda b: recorder.button_release(
PLUS)
controller.button_thumb_l.when_pressed = lambda b: recorder.button_press(
LCLICK)
controller.button_thumb_l.when_released = lambda b: recorder.button_release(
LCLICK)
controller.button_thumb_r.when_pressed = lambda b: recorder.button_press(
RCLICK)
controller.button_thumb_r.when_released = lambda b: recorder.button_release(
RCLICK)
recorder.start()
print('setup recording started...\n')
input('hit enter to proceed to loop phase\n')
recorder.next_phase()
print('loop recording started...\n')
input('hit enter to finish\n')
print('done')
def on_axis_moved(axis):
print('Axis {0} moved to {1} {2}'.format(axis.name, axis.x, axis.y))
presets = {
"button_a": Preset(1),
"button_b": Preset(2),
"button_x": Preset(3),
"button_y": Preset(4),
}
if __name__ == '__main__':
try:
name = ''.join([
x if x in string.printable else ''
for x in Xbox360Controller.get_available()[0].name
])
if name == "Logitech Logitech RumblePad 2 USB":
switchAxisR = True
else:
switchAxisR = False
print(switchAxisR)
with Xbox360Controller(
0, axis_threshold=0,
switch_axis_r_with_trigger_l=switchAxisR) as controller:
# Button A events
controller.button_trigger_l.when_pressed = zoomout
controller.button_trigger_r.when_pressed = zoomin
controller.button_trigger_l.when_released = zoomstop
controller.button_trigger_r.when_released = zoomstop
def __init__(self):
#Extra Variables
self.gripper_load = 0.0
# #----------------------------------------------------------------------------------------------------
# #Pan/Tilt Camera IP Socket Camera #1
# #----------------------------------------------------------------------------------------------------
# self.IP_ADDRESS = "192.168.1.9"
# self.IP_PORT = 23000
# self.client = TCPClient(self.IP_ADDRESS, self.IP_PORT, stateChanged = self.onStateChangedOne)
# self.rc = self.client.connect()
# if(self.rc):
# print("Connected 1")
# else:
# print("Not connected 1")
# #----------------------------------------------------------------------------------------------------
# #Pan/Tilt Camera IP Socket Camera #2
# #----------------------------------------------------------------------------------------------------
# self.IP_ADDRESS_2 = "192.168.1.8"
# self.IP_PORT_2 = 24000
# self.client_2 = TCPClient(self.IP_ADDRESS_2, self.IP_PORT_2, stateChanged = self.onStateChangedTwo)
# self.rc_2 = self.client_2.connect()
# if(self.rc_2):
# print("Connected 2")
# else:
# print("Not connected 2")
#----------------------------------------------------------------------------------------------------
#Pygame/Joystick Initialization
#----------------------------------------------------------------------------------------------------
pygame.init()
# Initialize the joysticks
pygame.joystick.init()
#Initialize only one joystick connected
self.joystick = pygame.joystick.Joystick(0)
self.joystick.init()
#Initiate Xbox Controller
self.xbox = Xbox360Controller()
#----------------------------------------------------------------------------------------------------
#ROS Initialization
#----------------------------------------------------------------------------------------------------
rospy.init_node("joystick_controller")
#Initialize arm stuff
self.arm_pub = rospy.Publisher('control_signal', Point, queue_size=10)
self.arm_msg = Point()
rospy.Subscriber("xbox_vibrate", Int64, self.vibrateXbox)
#Initialize gripper stuff
self.gripper_pub = rospy.Publisher("/dual_gripper_controller/command",
Float64,
queue_size=10)
rospy.Subscriber("/dual_gripper_controller/state", JointState,
self.updateGripperLoad)
self.gripper_msg = Float64()
self.gripper_msg.data = 0.0
self.gripper_pub.publish(self.gripper_msg)
#Initialize rover stuff
self.rover_pub = rospy.Publisher("arlo_wheels", String, queue_size=10)
self.rover_msg = String()
self.rover_speed = 35.0 #Out of 200 max , Was 20
self.rover_msg.data = "rst\r"
self.rover_pub.publish(self.rover_msg)
#Rate for loop
self.rate = rospy.Rate(10) #10 Hertz
def on_button_a_pressed(button):
global fsm_state, data
fsm_state = "DATA_AVAILABLE"
data = "Button a was pressed"
print(data)
def o_axis_r_moved(axis):
global fsm_state, data
fsm_state = "DATA_AVAILABLE"
data = f"Axis {axis.name} moved to {axis.x} {axis.y}"
print(data)
i = 0
with Xbox360Controller(axis_threshold=0.05) as c:
c.button_a.when_pressed = on_button_a_pressed
# c.axis_r.when_moved = o_axis_r_moved
with Serial(port=PORT, baudrate=BAUDRATE) as s:
fsm_state = "SERIAL_OPEN"
fsm_state = "NO_DATA_TO_SEND"
while True:
if fsm_state == "DATA_AVAILABLE":
tic = time()
s.write(f"-{i}-".encode())
fsm_state = "NO_DATA_TO_SEND"
data = None
i += 1