def main():
global ser
global joy
ser = Serial("COM6", 115200)
joy = pyxinput.vController()
print("id : ", joy.id)
while True:
line = ser.readline().decode().replace('\n', '')
[X1, Y1, X2, Y2, B1, B2, B3, B4] = [int(x) for x in line.split(',')]
joy.set_value('AxisLx',
-((min(1024, max(424, int(X1))) - 424) / 600) * 2 - 1)
joy.set_value('AxisLy',
((min(1024, max(424, int(Y1))) - 424) / 600) * 2 - 1)
joy.set_value('AxisRx',
-((min(1024, max(424, int(X2))) - 424) / 600) * 2 - 1)
joy.set_value('AxisRy',
((min(1024, max(424, int(Y2))) - 424) / 600) * 2 - 1)
joy.set_value('TriggerR', (1 - B1))
joy.set_value('BtnA', 1 - B3)
joy.set_value('BtnX', 1 - B4)
joy.set_value('BtnShoulderR', 1 - B2)
def __init__(self):
"""
"""
self._button_x = False
self._button_y = False
self._button_a = False
self._button_b = False
self._button_left_shoulder = False
self._button_right_shoulder = False
self._button_dpad_up = False
self._button_dpad_right = False
self._button_dpad_down = False
self._button_dpad_left = False
self._button_left_thumb = False
self._button_right_thumb = False
self._button_start = False
self._button_back = False
self._virtual_controller = pyxinput.vController(percent=False)
def main():
simCon = pyxinput.vController(1)
# infinite loop that detects for ('w+a') or ('w+d') in order to apply double movement
while True:
if keyboard.is_pressed('w+a'):
move_left(simCon)
elif keyboard.is_pressed('w+d'):
move_right(simCon)
elif keyboard.is_pressed('w'):
move_forward(simCon)
reset_stick_x(simCon)
elif keyboard.is_pressed('a'):
move_true_left(simCon)
# reset_stick_y(simCon)
elif keyboard.is_pressed('d'):
move_true_right(simCon)
#reset_stick_y(simCon)
elif keyboard.is_pressed('s'):
move_backward(simCon)
reset_stick_x(simCon)
elif keyboard.is_pressed('s+a'):
move_backLeft(simCon)
elif keyboard.is_pressed('s+d'):
move_backRight(simCon)
else:
resetStick(simCon)
def main():
Amiro = pyxinput.vController(1)
while True:
if keyboard.is_pressed('w+a'):
move_left(Amiro)
elif keyboard.is_pressed('w+d'):
move_right(Amiro)
elif keyboard.is_pressed('w'):
move_forward(Amiro)
reset_stick_x(Amiro)
elif keyboard.is_pressed('a'):
move_true_left(Amiro)
elif keyboard.is_pressed('d'):
move_true_right(Amiro)
elif keyboard.is_pressed('s'):
move_backward(Amiro)
reset_stick_x(Amiro)
elif keyboard.is_pressed('s+a'):
move_backLeft(Amiro)
elif keyboard.is_pressed('s+d'):
move_backRight(Amiro)
else:
resetStick(Amiro)
def main():
controller = vController()
handlers = dict()
for handler in json.load(open("controller.json", "r"))["handlers"]:
handler_command = handler["command"]
handler_class = handler_types.get(handler["type"])
handler_args = handler.get("args", [])
handlers[handler_command] = handler_class(controller=controller,
**handler_args)
pygame.midi.init()
if pygame.midi.get_default_input_id() == -1:
log.error("No MIDI input found (device ID is -1)!")
exit(-1)
log.info("Initializing MIDI input '%i'.",
pygame.midi.get_default_input_id())
midi = pygame.midi.Input(pygame.midi.get_default_input_id())
log.info("Ready!")
while True:
try:
if midi.poll():
command = midi.read(1)[0][0]
log.debug("Command is: '%s'", command)
handler = handlers.get(command[1], None)
if handler is not None:
handler.handle(command)
time.sleep(0.001)
except KeyboardInterrupt:
exit(1)
def send_input(self, terminator, freq, steering_value_deg, lock_to_lock):
print('creating virtual xinput controller')
virtualSteeringWheel = pyxinput.vController()
virtualSteeringWheel.percent = True
virtualSteeringWheel.set_value('AxisLx', 0.0)
last_frame_overtime = 0.0
while not terminator.value:
start = datetime.datetime.now()
steering = steering_value_deg.value / (lock_to_lock.value / 2)
steering = self.clamp(steering, -1.0, 1.0)
virtualSteeringWheel.set_value('AxisLx', steering)
# timing management in order to achieve target frequency
end = datetime.datetime.now()
real_delta_t = (end - start).microseconds / 1000
combined_delta_t = real_delta_t + last_frame_overtime
if combined_delta_t <= 1000 / freq.value:
sleep_time = ((1000 / freq.value) - combined_delta_t)
time.sleep(sleep_time / 1000)
last_frame_overtime = 0.0
else:
last_frame_overtime += real_delta_t - (1000 / freq.value)
real_end = datetime.datetime.now()
# print('art. delta_t:', (real_end - start).microseconds / 1000)
virtualSteeringWheel.set_value('AxisLx', 0.0)
virtualSteeringWheel.UnPlug(True)
print('virtual xinput controller unplugged')
def live_driving(self):
controller = pyxinput.vController()
paused = False
old_screens = []
while (True):
if not paused:
map_screen = grab_screen(region=self.map_region)
map_screen = cv2.cvtColor(map_screen, cv2.COLOR_BGR2RGB)
cam_screen = grab_screen(region=self.cam_region)
cam_screen = cv2.cvtColor(cam_screen, cv2.COLOR_BGR2RGB)
cam_screen = cv2.resize(cam_screen, (360, 240))
if self.data_gen.view_resize:
cam_screen = cv2.resize(cam_screen,
self.data_gen.view_resize)
speed_screen = grab_screen(region=self.speed_region)
speed_screen = cv2.cvtColor(speed_screen, cv2.COLOR_BGR2RGB)
speed_screen = cv2.cvtColor(speed_screen,
cv2.COLOR_RGB2GRAY)[:, :, None]
if self.data_gen.seq_len == 1:
X = [
x for name, x in zip(
['map_view', 'cam_view', 'speed_view'], [
map_screen[None, :, :, :], cam_screen[
None, :, :, :], speed_screen[None, :, :, :]
]) if self.inputs[name]
]
else:
if old_screens == []:
old_screens = [
cam_screen for i in range(self.data_gen.seq_len)
]
old_screens.append(cam_screen)
old_screens = old_screens[-self.data_gen.seq_len:]
X = np.array(old_screens)[None, :, :, :, :]
if self.data_gen.return_buttons:
ax_predictions, button_predictions = self.predict(X)
else:
ax_predictions = self.predict(X)
button_predictions = []
print(ax_predictions) #, X[0].shape, X[1].shape)
self.make_input(ax_predictions[0], button_predictions,
controller)
self.clock.tick(self.frame_rate)
keys = key_check()
# p pauses game and can get annoying.
if 'T' in keys:
if paused:
print("unpausing")
paused = False
time.sleep(1)
else:
print("pausing")
paused = True
time.sleep(1)
if 'Q' in keys:
break
def connect_virtual_controlers():
v_controler_container = []
while True:
try:
v_controler_container.append(pyxinput.vController())
logging.debug(
f'Controller {len(v_controler_container)} connected.')
except:
logging.debug(f'Controller FAILED connection.')
return v_controler_container
def __init__(self):
# Setup virtual controller
self.controller = pyxinput.vController()
# Really hacky way to wake it up but hey it should work
time.sleep(0.5)
self.controller.set_value('BtnA', 1)
time.sleep(0.5)
self.controller.set_value('BtnA', 0)
self.analog_values_y = {'old': 0., 'current': 0.}
self.analog_values_x = {'old': 0., 'current': 0.}
self.prev_prediction = None
def run(self):
virtualController = pyxinput.vController(
) # initialize virtual controller
dataJson = self.socket.recv(ServerExecutor.PACKET_LENGTH)
self.socket.send("1".encode())
while (dataJson):
data = json.loads(dataJson)
decoded_code = self.events_code[data["event_code"]]
virtualController.set_value(decoded_code, data["event_state"])
print("[Controller-ID #{}] Ping precedent packet: {} milliseconds".
format(self.id_controller, data["previous_ping"]))
dataJson = self.socket.recv(ServerExecutor.PACKET_LENGTH)
self.socket.send("1".encode())
else:
print("[INFO] Connection with {} interrupted.".format(
self.id_controller))
def __init__(self):
super(Main, self).__init__()
uic.loadUi('gui.txt', self)
#Handles Configuration:
config = open('config.txt', "r+")
self.lineEdit.returnPressed.connect(self.handleCommands)
# self.pushButtonInstall.clicked.connect(self.onClick)
config = config.readlines()
titleBarHidden = config[0]
titleBarHidden = [
int(i) for i in titleBarHidden.split() if i.isdigit()
][0]
screenSizeX = config[1]
screenSizeX = [int(i) for i in screenSizeX.split() if i.isdigit()][0]
screenSizeY = config[2]
screenSizeY = [int(i) for i in screenSizeY.split() if i.isdigit()][0]
print("Title: " + str(titleBarHidden))
#Handles Title and low level window control (gui)
self.titleBar = titleBarHidden
if (self.titleBar == 0):
self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint
| QtCore.Qt.FramelessWindowHint)
else:
self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.setWindowTitle("Universal DollyCam")
self.working_dir = "."
self.setFixedSize(screenSizeX, screenSizeY)
self.hideVal = 0
self.move(0, 0)
self.textBrowser.setText("Universal Dollycam by c4syner" + "\n")
#Handles virtual controller and modes for the dollycam
self.controller = pyxinput.vController()
self.init_mode = 0 #Init mode 1 is left joystick constant velocity
self.mode = 0 #Mode 1 is left joystick velocity only
#Constants:
self.camLeftX = 0
def handleController(msg):
global xcontroller
if (not xSupport):
print('Sad! You don\'t have Windows :(')
return
if ('Toggle' in msg[0]):
if (msg[1] == '1'):
xcontroller = vController()
elif (xcontroller != None):
xcontroller.UnPlug(force=True)
del xcontroller
xcontroller = None
return
if xcontroller == None:
return
if ('down' == msg[0] or 'up' == msg[0]):
if ('Btn' in msg[1]):
typeInt = 1 if msg[0] == 'down' else 0
xcontroller.set_value(msg[1], typeInt)
elif ('Trigger' in msg[1]):
typeInt = 255 if msg[0] == 'down' else 0
xcontroller.set_value(msg[1], typeInt)
elif ('Axis' in msg[0]):
xcontroller.set_value(msg[0], float(msg[1]))
elif ('Dpad' in msg[0]):
xcontroller.set_value(msg[0], int(msg[1]))
else:
print(msg)
print('^Not yet handled in driver^')
def __init__(self):
self.controller = pyxinput.vController()
import tensorflow as tf
import pyxinput
from mss import mss
import cv2
import numpy as np
import time
joystick = pyxinput.vController()
MODEL_PATH = "./model/frozen_model.pb"
with tf.gfile.GFile(MODEL_PATH, "rb") as f:
restored_graph_def = tf.GraphDef()
restored_graph_def.ParseFromString(f.read()) # Reads the model
with tf.Graph().as_default() as graph: # this graph variable is available outside this with block as it is defined as_default
tf.import_graph_def(restored_graph_def, input_map=None, return_elements=None, name="") # This is to import model graph into TensorFlow
input_tensor = graph.get_tensor_by_name("input_tensor:0")
output = graph.get_tensor_by_name("output:0")
sct = mss()
mon = {'top': 38, 'left': 0, 'width': 800, 'height': 600}
with tf.Session(graph=graph) as sess:
print("STARTING YAAY")
while True:
img = np.array(sct.grab(mon))
cv2.imshow("Seen", img)
img = cv2.cvtColor(img, cv2.COLOR_BGRA2RGB)
img = cv2.resize(img, (200, 150))
if cv2.waitKey(1) & 0xFF == ord("q"):
break
import pyxinput
import time
MyVirtual = pyxinput.vController(percent=False)
while True:
for x in range(10):
MyVirtual.set_value('BtnX', 1)
time.sleep(0.5)
print("Pressed X")
for x in range(10):
MyVirtual.set_value('BtnX', 0)
time.sleep(0.5)
print("Released X")
#!/usr/bin/python
import socket
import threading
import pyxinput
from time import sleep
import pickle
# Define server ip and port
ip = '192.168.122.1'
port = 2222
# Create virtual controller
MyVirtual = pyxinput.vController()
# Connect to Server
conn = socket.create_connection((ip, port))
from_server = conn.makefile(mode='rb')
#Decode Sever message
#unpickler = pickle.Unpickler(file)
while True:
#decodedServerData = unpickler.load()
decodedServerData = pickle.load(from_server)
#print("Raw Data:", from_server)
#print("Unpicked Data: ", decodedServerData)
# pyxinput will only accept values one at a time, so we need to apply the items in the dictionary one by one
for event, state in decodedServerData.items():
MyVirtual.set_value(event, state)
#print('\''+event+'\''+',', state)
import serial
import time
import pyxinput
import numpy as np
ser = serial.Serial('COM4', 250000, timeout=0)
if ser.isOpen():
ser.close()
ser.open()
steering = 1500
throttle = 1500
controller = pyxinput.vController()
t=s=AxisRx=A=B=0
control_file = 'data_file.npy'
input_file = 'input_file.npy'
while 1:
while(ser.inWaiting()<10):
pass
#print(steering)
steering = ord(ser.read())<<8|ord(ser.read())
throttle = ord(ser.read())<<8|ord(ser.read())
right_stick = ord(ser.read())<<8|ord(ser.read())
A = ord(ser.read())<<8|ord(ser.read())
B = ord(ser.read())<<8|ord(ser.read())
s = (steering - 1500)*0.004
virtual_controller.set_value('BtnA', btn_a)
virtual_controller.set_value('BtnX', btn_x)
virtual_controller.set_value('BtnY', btn_y)
if __name__ == '__main__':
print('Loading model...')
PATH = 'models\\'
FILE = 'neural-throne.tfl'
model = neural_network_model()
model.load(PATH + FILE)
AUTO_KEY = 'F5'
USER_KEY = 'F6'
STOP_KEY = 'F9'
WINDOW_NAME = 'Nuclear Throne'
virtual_controller = pyxinput.vController()
usermode = True
running = True
while running:
if usermode:
virtual_controller.set_value('BtnA', keyboard.is_pressed('enter'))
virtual_controller.set_value('BtnB', keyboard.is_pressed('escape'))
virtual_controller.set_value(
'AxisLx',
keyboard.is_pressed('right') - keyboard.is_pressed('left'))
virtual_controller.set_value(
'AxisLy',
keyboard.is_pressed('up') - keyboard.is_pressed('down'))
else:
result, screen = getScreenShot(WINDOW_NAME)
if result:
___ __ _ ___ __ _ __| | __ _ _ __ ___
/ _ \/ _` |/ _ \/ _` |/ _` |/ _` | '_ ` _ \
| __/ (_| | __/ (_| | (_| | (_| | | | | | |
\___|\__, |\___|\__,_|\__,_|\__,_|_| |_| |_|
__/ |
|___/
https://egeadam.com \n
""")
print("First Controller Setup Started")
serleft = serial.Serial("COM6", 9600,
timeout=1) #Edit for your COM port and your baudrate
#print("Second Controller Setup Started")
#serright = serial.Serial("COM7", 9600, timeout = 1) #Change your port name COM... and your baudrate
virtualGamepad = pyxinput.vController()
print("Setup finished")
def translate(value, leftMin, leftMax, rightMin, rightMax):
leftSpan = leftMax - leftMin
rightSpan = rightMax - rightMin
valueScaled = float(value - leftMin) / float(leftSpan)
return rightMin + (valueScaled * rightSpan)
def retrieveData():
data = serleft.readline().decode('ascii')
return data
def __init__(self):
self.controller = vController()
from flask import Flask, request, jsonify
import pyxinput, time
joypad = pyxinput.vController()
app = Flask(__name__)
BUTTONS = {1: "BtnA", 2: "BtnB", 3: "BtnX", 4: "BtnY"}
@app.route("/btn-click", methods=['POST'])
def btn_click():
data = request.json.get("button", 1)
btn = BUTTONS.get(data, "BtnA")
time.sleep(0.1)
joypad.set_value(btn, 1)
time.sleep(0.3)
joypad.set_value(btn, 0)
return jsonify("Btn Accepted")
if __name__ == "__main__":
app.run(debug=True)
def main():
print("Connecting to serial on port {}...".format(SERIAL_PORT))
try:
s = serial.Serial(SERIAL_PORT, SERIAL_BAUD)
except SerialException:
print("ERROR: '{}' serial port not available".format(SERIAL_PORT))
sys.exit(1)
print("Creating fake XBOX 360 Controller...")
v = pyxinput.vController()
print("Ready!")
x_overflow_warning_shown = False
y_overflow_warning_shown = False
while True:
buf = s.read_until()
elems = buf.split(b" ")
buttons = elems[0]
x = float(int(elems[1])) / JOYSTICK_MAX_VALUE_X
y = float(int(elems[2])) / JOYSTICK_MAX_VALUE_Y
if (x > 1.0 or x < -1.0) and not x_overflow_warning_shown:
print(
"WARNING: X value was larger than expected - increase JOYSTICK_MAX_VALUE_X!"
)
x_overflow_warning_shown = True
if (y > 1.0 or y < -1.0) and not y_overflow_warning_shown:
print(
"WARNING: Y value was larger than expected - increase JOYSTICK_MAX_VALUE_Y!"
)
y_overflow_warning_shown = True
# N64 A -> Xbox A / XInput Button 1
v.set_value("BtnA", (1 if buttons[0] == 52 else 0))
# N64 B -> Xbox B / XInput Button 2
v.set_value("BtnB", (1 if buttons[1] == 52 else 0))
# N64 Z -> Xbox Back / XInput Button 7
v.set_value("BtnBack", (1 if buttons[2] == 52 else 0))
# N64 Start -> Xbox Start / XInput Button 8
v.set_value("BtnStart", (1 if buttons[3] == 52 else 0))
# D-pad
d_value = 0
d_value |= 1 if buttons[4] == 52 else 0
d_value |= 2 if buttons[5] == 52 else 0
d_value |= 4 if buttons[6] == 52 else 0
d_value |= 8 if buttons[7] == 52 else 0
v.set_value("Dpad", d_value)
# Skip 8 & 9
# N64 L -> Xbox LB / XInput Button 5
v.set_value("BtnShoulderL", (1 if buttons[10] == 52 else 0))
# N64 R -> Xbox RB / XInput Button 6
v.set_value("BtnShoulderR", (1 if buttons[11] == 52 else 0))
# N64 C-up -> Xbox Left Stick Click / XInput Button 9
v.set_value("BtnThumbL", (1 if buttons[12] == 52 else 0))
# N64 C-down -> Xbox X / XInput Button 3
v.set_value("BtnX", (1 if buttons[13] == 52 else 0))
# N64 C-left -> Xbox Y / XInput Button 4
v.set_value("BtnY", (1 if buttons[14] == 52 else 0))
# N64 C-right -> Xbox Right Stick Click / XInput Button 10
v.set_value("BtnThumbR", (1 if buttons[15] == 52 else 0))
v.set_value("AxisLx", x)
v.set_value("AxisLy", y)
def __init__(self):
self.MyVirtual = pyxinput.vController()
self.control_throttle = 'TriggerR'
self.control_brakes = 'TriggerL'
self.control_steering = 'AxisLx'
def __init__(self):
self.virtual_controller = pyxinput.vController()
print("Virtual xbox 360 controller crated")
