class set_arm_control():
def __init__(self,RELAY_PIN=12):
self.arm = SwiftAPI()
self.arm.get_power_status()
self.RELAY_PIN = RELAY_PIN
self.arm.reset()
#機械手臂進行初始化動作
def set_arm_origin(self):
self.arm.waiting_ready()
self.arm.set_position(200, 0, 170, speed=100000)
# 機械手臂設定(x, y, z)座標移動
def set_arm_move(self, x, y, z):
self.arm.set_position(x, y, z, speed=100000)
# 機械手臂切斷連線
def arm_disconnect(self):
self.arm.disconnect()
def get_position(self):
print(self.arm.get_position())
#初始設定繼電器
def origin_pump(self):
GPIO.setmode(GPIO.BOARD) # 指定模式BOARD 啟用RPi板子相對應之腳位編號
GPIO.setwarnings(False) # 避免出現警告
GPIO.setup(self.RELAY_PIN, GPIO.OUT) # 設定pin腳為輸出
#打開幫浦=開啟繼電器(使電流流通)
def start_pump(self):
GPIO.output(self.RELAY_PIN, 0)
#關閉幫浦=關閉繼電器(使電流不能流通)
def close_pump(self):
GPIO.output(self.RELAY_PIN, 1)
def run(self):
while self.alive:
try:
ports = get_ports(filters={'hwid': 'USB VID:PID=2341:0042'})
for port in ports:
if port['device'] not in swifts.keys():
new_swift = SwiftAPI(port=port['device'])
new_swift.waiting_ready()
device_info = new_swift.get_device_info()
print(new_swift.port, device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(
('0.', '1.', '2.', '3.')):
new_swift.set_speed_factor(0.00001)
new_swift.set_mode(mode=0)
with lock:
swifts[port['device']] = new_swift
else:
swift = swifts[port['device']]
if not swift.connected:
with lock:
swifts.pop(port['device'])
except Exception as e:
pass
time.sleep(0.001)
def Arm_Init():
"""Robotic arm initiation"""
swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'},
cmd_pend_size=2,
callback_thread_pool_size=1)
swift.waiting_ready()
device_info = swift.get_device_info()
print(device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(
('0.', '1.', '2.', '3.')):
swift.set_speed_factor(0.00005)
swift.set_mode(0)
return swift
def run(self):
while self.alive:
try:
ports = get_ports(filters={'hwid': 'USB VID:PID=2341:0042'})
for port in ports:
if port['device'] not in swifts.keys():
new_swift = SwiftAPI(port=port['device'])
new_swift.waiting_ready()
device_info = new_swift.get_device_info()
print(new_swift.port, device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(('0.', '1.', '2.', '3.')):
new_swift.set_speed_factor(0.00001)
new_swift.set_mode(mode=0)
with lock:
pos = [150, 0, 150]
for swift in swifts.values():
swift.flush_cmd()
if len(swifts.values()) > 0:
time.sleep(1)
for swift in swifts.values():
pos = swift.get_position()
if isinstance(pos, list):
# print('sync pos:', pos)
break
# new_swift.reset(speed=speed)
swifts[port['device']] = new_swift
for swift in swifts.values():
swift.set_position(x=pos[0], y=pos[1], z=pos[2], speed=speed, wait=False)
for swift in swifts.values():
if swift.connected:
swift.flush_cmd(wait_stop=True)
# if len(swifts) > 1:
# time.sleep(3)
else:
swift = swifts[port['device']]
if not swift.connected:
with lock:
swifts.pop(port['device'])
except Exception as e:
pass
time.sleep(0.001)
class uarm:
def __init__(self):
logger.setLevel(logger.VERBOSE)
self.swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'},
callback_thread_pool_size=1)
self.swift.waiting_ready()
self.swift.set_speed_factor(factor=20)
self.swift.set_position(x=239.43, y=0, z=170)
def jump(self, press_time):
self.swift.set_position(x=239.43, y=0, z=-30)
print("robot:%f" % press_time)
time.sleep(press_time)
self.swift.set_position(x=239.43, y=0, z=170)
# if __name__ == '__main__':
# arm = uarm()
# arm.jump(0.75)
# time.sleep(5)
# arm.jump(0.75)
d = {
"A" : 0,
"B" : 1,
"C" : 2,
"D" : 3,
"E" : 4,
"F" : 5,
"G" : 6,
}
swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
# swift2 = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
# swift3 = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
swift.waiting_ready()
device_info = swift.get_device_info()
print(swift.port, device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(('0.', '1.', '2.', '3.')):
swift.set_speed_factor(0.00001)
swift.set_servo_detach()
input('A4')
swift.set_servo_attach()
pos = swift.get_position()
print(pos);
bias = 23;
from uarm.wrapper import SwiftAPI
import random
swift1 = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
swift2 = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
swift1.waiting_ready()
device_info = swift1.get_device_info()
print(swift1.port, device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(
('0.', '1.', '2.', '3.')):
swift1.set_speed_factor(0.00001)
swift2.waiting_ready()
device_info = swift2.get_device_info()
print(swift2.port, device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(
('0.', '1.', '2.', '3.')):
swift2.set_speed_factor(0.00001)
X = 0
Y = 1
Z = 2
R = 3
swift1.set_servo_detach()
swift1.register_report_position_callback(lambda position: swift2.set_position(
x=position[X], y=position[Y], z=position[Z], speed=100000000, timeout=1))
import os
import sys
import time
import functools
import threading
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from uarm.wrapper import SwiftAPI
swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'},
enable_handle_thread=False)
# swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'}, enable_write_thread=True)
# swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'}, enable_report_thread=True)
# swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'}, enable_handle_thread=True, enable_write_thread=True, enable_report_thread=True)
swift.waiting_ready() # wait the rebot ready
print(swift.get_device_info())
move_speed = 100
time.sleep(5) # <! must wait the effector check itself
rtn = swift.get_mode(wait=True, timeout=10) # <! make sure the work mode is 5
print(rtn)
if rtn != 5:
swift.set_mode(5)
time.sleep(5) # <! must wait the effector check itself
swift.set_position(x=150,
y=150,
z=150,
speed=move_speed,
#!/usr/bin/env python3
import sys
# import time
import asyncio
import socketio
from uarm.wrapper import SwiftAPI
sio = socketio.AsyncClient(reconnection=True)
try:
swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'},
callback_thread_pool_size=2)
swift.waiting_ready(timeout=10)
device_info = swift.get_device_info()
print(device_info)
# swift.set_speed_factor(100)
swift.set_mode(3)
swift.reset(wait=True, speed=250)
# firmware_version = device_info['firmware_version']
# if firmware_version and not firmware_version.startswith(('0.', '1.', '2.', '3.')):
# # swift.set_speed_factor(0.0005)
except Exception:
swift = False
print('swift uArm not connected')
def initialize():
global cartesian
test_a = True
test_b = True
data_start() # saving data
#convert cartesian coordinates to polar coordinates
if(cartesian):
print(Fore.BLUE + "Detecting cartesian coordinates, changing to polar")
#test to check converting cartesian to polar
if(test_converting(cartesian)):
print(Fore.GREEN + "TEST OK")
print(Style.RESET_ALL)
else:
print(Fore.RED + "TEST FAILED")
print(Style.RESET_ALL)
#debug outputs
# print(default_stretch)
# print(default_rotation)
# print(default_height)
change_variables_to_polar()
print(Fore.GREEN + "Conversion from cartesian to polar successfull")
print(Style.RESET_ALL)
time.sleep(2)
else:
print(Fore.BLUE + "Default polar coordinates are set")
print(Style.RESET_ALL)
try:
global serial_name
global ser
ser = serial.Serial('/dev/ttyUSB0',115200,timeout=2) #arduino serial
arduino_reset()
print(Fore.BLUE + "Arduino UNO\n")
except:
test_a = False
print(Fore.RED + "FAILED CONNECT TO ARDUINO!")
print(Style.RESET_ALL)
#setting up uArm SwiftPro
try:
global swift
#need to change
sys.path.append(os.path.join(os.path.dirname(__file__), '../uArm-Python-SDK')) #link to uArm SwiftPro python3.x.x library
swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
swift.waiting_ready(timeout=5)
swift.set_mode(0)
device_info = swift.get_device_info()
default_robot_position()
print(Fore.BLUE)
print(device_info)
print("\n")
except:
test_b = False
print(Fore.RED + "FAILED CONNECT TO uArm SwiftPro")
print(Style.RESET_ALL)
if test_a and test_b:
print(Fore.GREEN + "DONE!\n")
print(Style.RESET_ALL)
return
class uArm():
def __init__(self):
self.scope = 10
self.x0 = 160
self.y0 = 0
self.swift = SwiftAPI(filters={'hwid':'USB VID:PID=2341:0042'})
self.swift.waiting_ready(timeout=3)
# self.swift.set_speed_factor(0.005) # if you change this, be prepared for different movements!
self.swift.set_mode(mode=0)
time.sleep(0.5)
self.swift.set_servo_angle(angle=90)
self.swift.set_wrist(angle=90)
self.swift.set_position(x=200,y=0,z=20) # start it off with a salute
self.swift.set_buzzer(frequency=1000, duration=1) # signal ready
self.lstValidCharSet = ['?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',\
'-','0','1','2','3','4','5','6','7','8','9']
self.lstLetter = [self.QuestionMark, self.LetterA, self.LetterB, self.LetterC, self.LetterD, self.LetterE, self.LetterF,\
self.LetterG, self.LetterH, self.LetterI, self.LetterJ, self.LetterK, self.LetterL, self.LetterM, self.LetterN,\
self.LetterO, self.LetterP, self.LetterQ, self.LetterR, self.LetterS, self.LetterT, self.LetterU, self.LetterV,\
self.LetterW, self.LetterX, self.LetterY, self.LetterZ, self.Hyphen, self.Number0, self.Number1, self.Number2,\
self.Number3, self.Number4, self.Number5, self.Number6, self.Number7, self.Number8, self.Number9]
def __del__(self):
input("PLEASE SUPPORT uARM ARM!!, then strike ENTER to continue ...")
self.swift.set_buzzer(frequency=600, duration=2)
self.swift.set_position(x=200,y=0,z=20)
self.swift.flush_cmd()
self.swift.disconnect()
del self.swift
self.swift = None
def arm(self):
"""
Using this method to allow raw access to the uArm if required
"""
return self.swift
def insert_pen(self):
self.swift.set_buzzer(frequency=1000, duration=0.5) # signal ready
self.swift.set_servo_angle(angle=90)
time.sleep(0.5)
self.swift.set_wrist(angle=90)
time.sleep(0.5)
self.swift.set_position(x=200,y=0,z=0)
while (self.swift.get_is_moving()):
continue
input("Set pen in universal holder, then strike ENTER to continue ...")
self.swift.set_position(x=200,y=0,z=10)
return
def pen_up(self):
while (self.swift.get_is_moving()):
continue
x, y, z = self.swift.get_position()
self.swift.set_position(x, y, 10)
time.sleep(0.5)
return 10
def pen_down(self):
while (self.swift.get_is_moving()):
continue
x, y, z = self.swift.get_position()
self.swift.set_position(x, y, 0)
time.sleep(0.5)
return 0
def setScope(self, strName):
"""
based upon the length of strName, determine the scope (char width) and starting X, Y positions
assuming that the center of the page is 160,0
x extent is 110 - 210, y extent 80 - (-80) (x axis is PARALLEL to the arm, short edge of the paper)
"""
if type(strName) == str:
strName = strName[:26] # going to truncate user input to a 26 characters max
intLenName = len(strName)
if (intLenName < 4):
self.scope = 40.0 # keeping it real
else:
self.scope = math.floor(160.0/(intLenName * 1.1))
self.x0 = 160 - (0.5 * self.scope)
self.y0 = self.scope * intLenName * 1.1 / 2
return
def LetterSelect(self, c):
"""
given char c, return the plotting function
index 0 resolves to the question mark character
"""
index = 0
if type(c) == str:
if c == ' ':
return self.SpaceBar
else:
c = c.upper()
if c in self.lstValidCharSet:
index = self.lstValidCharSet.index(c) - self.lstValidCharSet.index('A') + 1 # 0th item is '?'
# if c in ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']:
# index = ord(c) - ord('A') + 1 # using question mark as the 0th index item
return self.lstLetter[index] # return the function to use
from uarm.wrapper import SwiftAPI
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
global swift1
global swift2
timeout = 200
speed = 35000
uarmStart = False
playerLetter = 'X'
computerLetter = 'O'
swift1 = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
swift1.waiting_ready() # Computer O
swift2 = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
swift2.waiting_ready() # Player X
def rahmen():
swift1.flush_cmd()
start()
swift1.set_position(230, 110 , 20, speed = speed, wait=True, timeout=timeout)
swift1.set_position(z = 10)
swift1.set_position(230, -110 , 10, speed = speed, wait=True, timeout=timeout)
swift1.set_position(z = 20)
swift1.set_position(160, -110 , 20, speed = speed, wait=True, timeout=timeout)
swift1.set_position(z = 10)
class UArmHandler(object):
def __init__(self, ui):
super(UArmHandler, self).__init__()
self.ui = ui
self.arm = None
self.port = None
self.cmd_que = queue.Queue(100)
self.cmd_thread = XArmThread(self.cmd_que, check=False)
self.cmd_thread.signal.connect(self.run_cmd)
self.cmd_thread.start()
self.report_que = queue.Queue()
self.report_thread = XArmThread(self.report_que, check=True)
self.report_thread.signal.connect(self.update_ui)
self.report_thread.start()
def run_cmd(self, item):
try:
if self.arm and self.arm.connected:
func = getattr(self.arm, item['cmd'])
# log(item['cmd']+':', func(*item.get('args', []), **item.get('kwargs', {})))
ret = func(*item.get('args', []), **item.get('kwargs', {}))
if item['cmd'] == 'get_position' and isinstance(
ret, list) and len(ret) >= 3:
self.report_que.put({
'type': 'location',
'item': {
'position': ret,
'angles': None
}
})
elif item['cmd'] == 'get_polar' and isinstance(
ret, list) and len(ret) >= 3:
self.report_que.put({
'type': 'location',
'item': {
'position': [None, None, None, *ret],
'angles': None
}
})
elif item['cmd'] == 'get_servo_angle' and isinstance(
ret, list) and len(ret) >= 3:
self.report_que.put({
'type': 'location',
'item': {
'position': None,
'angles': ret
}
})
elif item['cmd'] == 'get_device_info':
self.report_que.put({'type': 'info', 'item': ret})
elif item['cmd'] == 'get_mode' or item['cmd'] == 'set_mode':
self.report_que.put({
'type': 'mode',
'item': {
'mode': ret
}
})
# if isinstance(ret, int) and ret == TCP_OR_JOINT_LIMIT:
# self.ui.reset_flag()
logger.debug('cmd: {}, ret:{}, args: {}, kwargs: {}'.format(
item['cmd'], ret, item.get('args', []),
item.get('kwargs', {})))
else:
self.cmd_que.queue.clear()
self.report_connected_callback({'connected': False})
logger.debug('cmd: {}, ret: xArm is not connected'.format(
item['cmd']))
except:
pass
def connect(self, port):
try:
logger.debug('try connect to {}'.format(port))
if self.arm and self.arm.connected:
logger.info('disconnect from {}'.format(self.port))
self.arm.disconnect()
except Exception as e:
print(e)
threading.Thread(target=self.connnect_thread,
args=(port, ),
daemon=True).start()
def connnect_thread(self, port):
try:
self.port = port
self.arm = SwiftAPI(port=port, do_not_open=True)
self.arm.connect()
if not self.arm.connected:
time.sleep(0.5)
self.arm.waiting_ready()
self.report_connected_callback({'connected': True})
device_info = self.arm.get_device_info()
self.report_que.put({'type': 'info', 'item': device_info})
mode = self.arm.get_mode()
self.report_que.put({'type': 'mode', 'item': {'mode': mode}})
position = self.arm.get_position()
if isinstance(position, list) and len(position) >= 3:
self.report_que.put({
'type': 'location',
'item': {
'position': position,
'angles': None
}
})
polar = self.arm.get_polar()
if isinstance(polar, list) and len(polar) >= 3:
self.report_que.put({
'type': 'location',
'item': {
'position': [None, None, None, *polar],
'angles': None
}
})
angles = self.arm.get_servo_angle()
if isinstance(angles, list) and len(angles) >= 3:
self.report_que.put({
'type': 'location',
'item': {
'position': None,
'angles': angles
}
})
return True
except Exception as e:
# print(e)
self.report_connected_callback({'connected': False})
def disconnect(self):
try:
if self.arm and self.arm.connected:
self.arm.disconnect()
self.report_connected_callback({'connected': False})
# logger.info('diconnect from {}'.format(self.addr))
except Exception as e:
print(e)
def update_ui(self, data):
item = data['item']
if data['type'] == 'timeout':
if not self.arm or not self.arm.connected:
self.ui.update_connect_status(False)
elif data['type'] == 'connect':
self.ui.update_connect_status(item['connected'])
elif data['type'] == 'location':
pos = item['position']
angles = item['angles']
if angles:
self.ui.axis_ui.update_joints(angles)
if pos:
self.ui.cartesian_ui.update_cartesians(pos)
elif data['type'] == 'info':
self.ui.update_device_info(item)
elif data['type'] == 'mode':
self.ui.update_mode(item['mode'])
def report_connected_callback(self, item):
self.report_que.put({'type': 'connect', 'item': item})
def put_cmd_que(self, item):
self.cmd_que.put(item)
class uArmSwift:
def __init__(self):
self.swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'},
cmd_pend_size=2,
callback_thread_pool_size=1)
if not self.swift.connected:
print('lose connect')
self.swift.waiting_ready()
device_info = self.swift.get_device_info()
print(device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(
('0.', '1.', '2.', '3.')):
self.swift.set_speed_factor(0.00005)
self.swift.set_mode(0)
self.speed = 500000
self.swift.set_wrist(angle=90)
self.wristAngle = self.swift.get_servo_angle(0, timeout=10)
def set_position(self, x=100, y=0, z=100, wait=False):
self.swift.set_position(x, y, z, speed=self.speed, wait=wait)
def set_polar(self, stretch, rotation, height, wait=False):
self.swift.set_polar(stretch,
rotation,
height,
speed=self.speed,
wait=wait)
def set_servo_angle(self, num, angle, wait=False):
if num < 0 and num > 3:
print("num is wrong")
self.swift.set_servo_angle(num,
angle,
wait,
speed=self.speed,
wait=wait)
def set_wrist(self, angle=90, wait=False): # 第四电机
self.swift.set_wrist(angle, wait)
def set_pump(self, on=False):
self.swift.set_pump(on)
def set_buzzer(self, freq=1000, duration=1, wait=False):
self.swift.set_buzzer(freq, duration, wait)
def get_position(self):
return self.swift.get_position()
def get_servo_angle(self, id=0):
return self.swift.get_servo_angle(id, timeout=10)
def is_moving(self):
return self.swift.get_is_moving()
def disconnect(self):
self.swift.disconnect()
class uarmRobotClass(object):
def __init__(self):
self.x_pos = 0
self.y_pos = 0
self.tcp_rot = 0
self.z_pos = 0
self.pick = 0
self.connect = 0
self.swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
self.swift.waiting_ready(timeout=3)
self.swift.set_speed_factor(0.5)
self.swift.waiting_ready(timeout=3)
self.swift.disconnect()
def openPort(self):
self.swift.connect()
#swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
self.swift.waiting_ready(timeout=3)
self.swift.set_speed_factor(0.5)
self.swift.waiting_ready(timeout=3)
self.swift.set_position(150, 0, 50, wait=True)
def closePort(self):
self.swift.disconnect()
self.swift.waiting_ready(timeout=3)
def move(self):
Index = 0
pick = 0
connect = 0
while True:
if (dummy == False) and (connect == 0) and (self.connect == 1):
self.openPort()
ret = self.swift.get_position(wait=True)
print("ret values %d, %d, %d" % (ret[0], ret[1], ret[2]))
x_pos = ret[0]
y_pos = ret[1]
tcp_rot = ret[2]
print("connected")
connect = 1
if (dummy == False) and (connect == 1) and (self.connect == 0):
self.closePort()
connect = 0
print("disconnnected")
if (self.x_pos != 0) or (self.y_pos != 0) or (self.tcp_rot != 0) or (self.z_pos != 0) or (self.pick != 0) or (self.connect != 0):
if logLevel > 1:
print("index = %d: x_pos = %d; y_pos = %d; z_pos = %d; tcp_rot = %d; pick = %d; connect = %d" % (Index, self.x_pos, self.y_pos, self.z_pos, self.tcp_rot, self.pick, self.connect))
Index = Index + 1
if (dummy == False) and (connect == 1) and ((self.x_pos != 0) or (self.y_pos != 0) or (self.tcp_rot != 0) or (self.z_pos != 0)):
self.swift.set_position(x=self.x_pos, y=self.y_pos, z=self.z_pos, wait=True, relative=True);
ret = self.swift.get_position(wait=True)
if logLevel > 0:
print("ret values %d, %d, %d" % (ret[0], ret[1], ret[2]))
if (dummy == False) and (pick == 0) and (self.pick != 0):
self.swift.set_pump(on=True)
pick = 1
if (dummy == False) and (pick == 1) and (self.pick == 0):
self.swift.set_pump(on=False)
pick = 0
time.sleep(0.001);
#!/usr/bin/env python3
import time
from uarm.wrapper import SwiftAPI
swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
swift.waiting_ready(timeout=3)
device_info = swift.get_device_info()
print(device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(
('0.', '1.', '2.', '3.')):
swift.set_speed_factor(0.0005)
swift.set_mode(0)
swift.reset(wait=True, speed=10000)
swift.set_position(x=200, speed=10000 * 20)
swift.set_position(y=100)
swift.set_position(z=100)
swift.flush_cmd(wait_stop=True)
swift.set_polar(stretch=200, speed=10000 * 20)
swift.set_polar(rotation=90)
swift.set_polar(height=150)
print(swift.set_polar(stretch=200, rotation=90, height=150, wait=True))
swift.flush_cmd()
class MinionArm:
def __init__(self):
self.swift = SwiftAPI(filters={'hwid': 'USB VID:PID=2341:0042'})
self.swift.waiting_ready()
device_info = self.swift.get_device_info()
print(device_info)
firmware_version = device_info['firmware_version']
if firmware_version and not firmware_version.startswith(
('0.', '1.', '2.', '3.')):
self.swift.set_speed_factor(0.0005)
self.speed = 110000
self.test()
self.board = "right"
def test(self):
# self.swift.set_buzzer(frequency=1000, duration=0.5, wait=True)
self.swift.reset(wait=True, speed=self.speed)
self.move(1250, 0, 150, self.speed)
print(self.swift.get_position())
# self.swift.set_buzzer(frequency=1000, duration=0.5, wait=True)
def home(self):
print("going home")
self.swift.set_position(x=150, y=0, speed=self.speed * 0.5, wait=True)
self.move(145, 0, 100, self.speed * 1.5)
time.sleep(2)
# self.swift.set_buzzer(frequency=1000, duration=0.5, wait=True)
def rest(self):
print("going to rest position")
self.swift.set_position(x=150, speed=self.speed * 0.5, wait=True)
self.swift.set_position(x=125, y=0, speed=self.speed * 0.5, wait=True)
self.move(125, 0, 40, self.speed * 0.5)
time.sleep(2)
self.swift.set_buzzer(frequency=1000, duration=0.5)
def move(self, x, y, z, speed):
self.swift.set_position(x, y, z, speed, wait=True)
def flip(self):
print("flipping")
# self.home()
self.swift.set_buzzer(frequency=1000, duration=0.5, wait=True)
if self.board == "right":
self.flip_left()
self.board = "left"
else:
self.flip_right()
self.board = "right"
self.home()
self.swift.set_buzzer(frequency=500, duration=1.0, wait=True)
def flip_left(self):
self.move(180, 0, 150, self.speed)
self.move(240, 0, 150, self.speed)
# self.move(220, 10, 140, self.speed*.2)
self.move(220, 40, 150, self.speed * .2)
# self.move(220, 40, 110, self.speed*.2)
# self.move(220, 60, 100, self.speed*.2)
self.move(220, 50, 30, self.speed * .2)
time.sleep(1)
self.move(180, 50, 20, self.speed * .2)
time.sleep(2)
def flip_right(self):
self.move(180, 0, 150, self.speed)
self.move(240, -10, 150, self.speed)
# self.move(220, -20, 140, self.speed*.2)
self.move(220, -40, 150, self.speed * .2)
# self.move(220, -50, 110, self.speed*.2)
# self.move(220, -60, 100, self.speed*.2)
self.move(220, -60, 20, self.speed * .2)
self.move(180, -50, 20, self.speed * .2)
time.sleep(2)
def move_to_galton_cal_pos(self):
self.move(180, 0, 150, self.speed)
self.move(240, 0, 150, self.speed)
wait = input("waiting")
self.home()
def disconnect(self):
self.swift.disconnect()
