Пример #1
0

def e2():
    manager.receive_into(v2dt)
    pass


ev0 = EventWrapper(e0, 0)
ev1 = EventWrapper(e1, marm.calculate_timeout(115200))
ev2 = EventWrapper(
    e2,
    marm.calculate_timeout(115200) + v2dt.calculate_timeout(115200))

sertest = AutoTimer(period=1, events=[ev0, ev1, ev2])

if manager.open_port('0', 115200):
    sertest.start()

try:
    while True:

        if dataflag:
            print(marm.voltages)
            print(marm.test)
            dataflag = False

            #user_input = raw_input()
            '''
		if manager.open_port(user_input, 115200):
			sertest.start()
		else:
from pololu_controller import PololuController
from Servo import *
from data_structures import mini_arm as marm

utils = Utility()
alive = True

def quit():
	global alive
	alive = False

manager1 = SerialManager()
print 'Ports available'
manager1.list_ports()
print 'Select Dynamixel port'
user_input = utils.getch()

if manager1.open_port(user_input, 57600):
	
	serv_2 = Robotis_Servo(manager1, 1)
	print 'Setting up Dynamixel 2'
	
	print 'Dynamixel 2 at ' + str(serv_2.read_angle())

	while(alive):
		serv_2.move_angle(1, 1.5, blocking=False)
		time.sleep(1)
		serv_2.move_angle(2, 1.5, blocking=False)
		time.sleep(1)

manager1.close()
Пример #3
0
def e1():
	global dataflag
	dataflag = manager.receive_into(marm)
	manager.write(v2dt.get_outgoing_struct())

def e2():
	manager.receive_into(v2dt)
	pass

ev0 = EventWrapper(e0, 0)
ev1 = EventWrapper(e1, marm.calculate_timeout(115200))
ev2 = EventWrapper(e2, marm.calculate_timeout(115200) + v2dt.calculate_timeout(115200))

sertest = AutoTimer(period=1, events=[ev0,ev1,ev2])

if manager.open_port('0', 115200):
	sertest.start()

try:
	while True:

		if dataflag:
			print(marm.voltages)
			print(marm.test)
			dataflag = False

		#user_input = raw_input()

			'''
		if manager.open_port(user_input, 115200):
			sertest.start()
Пример #4
0
for baudrate in baudrates :
	print(str(baudrate) + ' bps')

	
current_baudrate = raw_input()
print (str(current_baudrate))


if int(current_baudrate) not in baudrates:
	print('incorrect baudrate selected')
	quit()


ser.list_ports()

for i, port in enumerate(ser.ports):
	if ser.open_port(i, current_baudrate):
		print('Scanning at ' + str(current_baudrate))
		for i in range(0, 10):
			print('scanning servo at id ' + str(i))
			try:
				r = Robotis_Servo(ser, i);
				ang = r.read_angle()
				print('Servo found at id ' + str(i) + ' at angle %.3f' % ang)
			except RuntimeError, e:
				pass
		ser.serial_io.close()
time.sleep(1)

servo_list = []
Пример #5
0
class TestStand:
    def __init__(self):
        self.serial_manager = SerialManager()
        try:
            self.database = Database()
        except KeyError:
            print('Error loading database')
            self.abort_test()
        self.csv_logger = CSVLogger()

    # create test log directories, select a serial port and begin the test
    def start_test(self):
        self.test_num = self.database.find_next_test_number()
        self.csv_logger.test_num = self.test_num
        print(f'\nStarting test {self.csv_logger.test_num}\n')
        self.csv_logger.make_test_data_dir()
        self.csv_logger.make_test_dir()

        print('Scanning serial ports\n')
        ports = self.serial_manager.get_available_serial_ports()
        if not ports:
            print('No serial ports were found')
            self.quit_test()
        else:
            # let user select the correct serial port
            print(('Choose a port from the options below.\n'
                   'Type the number of the port and press enter:'))
            for port in ports:
                print(ports.index(port) + 1, ' - ', port)
            choice = input()
            self.port = ports[int(choice) - 1]

        print(f'Press enter to start test {self.test_num}\n')
        input()
        self.run_test()

    # connect to the serial port, start the listener thread
    def run_test(self):
        self.serial_manager.open_port(self.port)
        print("Test started!")
        try:
            while True:
                # log serial telemetry to the influx database
                data = self.serial_manager.read_telemetry()
                if data:
                    data['test_number'] = self.test_num
                    self.database.log_data(data)
        except KeyboardInterrupt:
            self.finish_test()

    # allow the user to make notes about the test, then
    # log the test's notes and data inside it's directory
    def finish_test(self):
        print()
        print("Ending test")
        results = self.database.export_test(self.test_num)
        if results:
            self.csv_logger.log_as_csv(results)

    def abort_test(self):
        try:
            self.csv_logger.delete_test_files()
        except AttributeError:
            pass
        sys.exit()
class TestStand:
    def __init__(self):
        self.serial_manager = SerialManager()
        try:
            self.database = Database()
        except KeyError:
            print(
                'Error loading database. Did you set the TEST_STAND_DB '
                'environment variable to the name of your InfluxDB database?')
            self.abort_test()
        self.csv_logger = CSVLogger()
        # thread for interpreting incoming serial data
        self.telemetry_thread = threading.Thread(target=self.telemetry_loop)
        self.thread_is_running = False

    # create test log directories, select a serial port and begin the test
    def start_test(self):
        self.test_num = self.database.find_next_test_number()
        self.csv_logger.test_num = self.test_num
        print(f'\nStarting test {self.csv_logger.test_num}\n')
        self.csv_logger.make_test_data_dir()
        self.csv_logger.make_test_dir()

        print('Scanning serial ports\n')
        ports = self.serial_manager.get_available_serial_ports()
        if not ports:
            print('No serial ports were found')
            self.quit_test()
        else:
            # let user select the correct serial port
            print(('Choose a port from the options below.\n'
                   'Type the number of the port and press enter:'))
            for port in ports:
                print(ports.index(port) + 1, ' - ', port)
            choice = input()
            self.port = ports[int(choice) - 1]

        print(f'Ready to start test {self.test_num}\n')
        keyword = input('To begin type "start": ')
        while keyword != 'start':
            keyword = input('Wrong keyword. To begin type "start": ')
        self.run_test()

    # connect to the serial port, start the listener thread and allow the user
    # to control the solenoid with the enter/return key
    def run_test(self):
        self.serial_manager.open_port(self.port)
        self.thread_is_running = True
        self.telemetry_thread.start()
        print('Press enter to toggle solenoid')
        while True:
            if input() == 'q':
                print('\n')
                self.finish_test()
                break
            self.serial_manager.toggle_solenoid()

    # drive the solenoid low, allow the user to make notes about the test, then
    # log the test's notes and data inside it's directory
    def finish_test(self):
        if self.serial_manager.solenoid_state:
            self.serial_manager.toggle_solenoid()
            while self.serial_manager.solenoid_event_queued:
                pass
        self.thread_is_running = False
        notes = []
        note = input('Make any notes about this test below:\n')
        while note != '':
            notes.append(note)
            note = input()
        self.csv_logger.log_notes(notes)

        results = self.database.export_test(self.test_num)
        if results:
            self.csv_logger.log_as_csv(results)

    def abort_test(self):
        self.thread_is_running = False
        try:
            self.csv_logger.delete_test_files()
        except AttributeError:
            pass
        sys.exit()

    def telemetry_loop(self):
        while self.thread_is_running:
            # if there is a toggle queued for the solenoid
            if self.serial_manager.solenoid_event_queued:
                # write a 0 or 1 to the serial port to toggle the solenoid
                self.serial_manager.serial.write(
                    str(self.serial_manager.solenoid_state).encode())
                self.serial_manager.solenoid_event_queued = False
            # log serial telemetry to the influx database
            data = self.serial_manager.read_telemetry()
            if data:
                data['test_number'] = self.test_num
                self.database.log_data(data)
Пример #7
0
from data_structures import mini_arm as marm

utils = Utility()
alive = True

def quit():
	global alive
	alive = False

manager1 = SerialManager()
print('Ports available')
manager1.list_ports()
print('Select Dynamixel port')
user_input = utils.getch()

if manager1.open_port(user_input, 115200):
	
	serv2 = Robotis_Servo(manager1,2)
	print('Setting up Dynamixel')
	print('Dynamixel angle at ' + str(serv2.read_angle()))
	print('Dynamixel encoder at ' + str(serv2.read_encoder()))

	serv5 = Robotis_Servo(manager1,5)
	print('Setting up Dynamixel')
	print('Dynamixel angle at ' + str(serv5.read_angle()))
	print('Dynamixel encoder at ' + str(serv5.read_encoder()))

	while(alive):
		#serv.move_angle(1, 1.5, blocking=False)
		serv2.move_angle(0.5,blocking=False)
		serv5.move_angle(0.1,blocking=False)
Пример #8
0
from data_structures import mini_arm as marm

utils = Utility()
alive = True

def quit():
	global alive
	alive = False

manager1 = SerialManager()
print 'Ports available'
manager1.list_ports()
print 'Select Dynamixel port'
user_input = utils.getch()

if manager1.open_port(user_input, 57600):
	
	serv_2 = Robotis_Servo(manager1, 2)
	print 'Setting up Dynamixel 2'
	serv_5 = Robotis_Servo(manager1, 5)
	print 'Setting up Dynamixel 5'
	
	serv_2.set_angvel(0.5)
	serv_2.set_cw_limit(1)
	serv_2.set_ccw_limit(4095)	
	serv_2.move_angle(2.5, 0.5, blocking=True)
	print 'Dynamixel 2 at ' + str(serv_2.read_angle())

	serv_5.set_angvel(0.5)
	serv_5.set_cw_limit(1)
	serv_5.set_ccw_limit(4095)