def __init__(self, port="ttyACM0", auto_calibrate=False): self.uno = arduino.Arduino(port, baud=9600) time.sleep(2) # Wait for serial to connect self.__valve(False) self.horizontal_motor = Motor(self.uno, dir_pin=3, step_pin=2, trigger_pos=6, trigger_neg=UNCONNECTED_3, home_dir=1, home_offset=500 * 16, ms1=LEFT_RIGHT_MS1, ms2=LEFT_RIGHT_MS2, ms3=LEFT_RIGHT_MS3) self.vertical_motor = Motor(self.uno, dir_pin=4, step_pin=5, trigger_pos=UNCONNECTED_3, trigger_neg=7, home_dir=0, home_offset=200 * 16, ms1=UP_DOWN_MS1, ms2=UP_DOWN_MS2, ms3=UP_DOWN_MS3) answer = None while answer not in ('y', 'n') and auto_calibrate: answer = raw_input("Calibrate (y/n)? ").lower() if answer == 'y': self.calibrate()
def run(self): """ Run Training :return: """ with arduino.Arduino() as ard: pass
def __init__(self, port="ttyACM0"): self.uno = arduino.Arduino(port, baud=9600) time.sleep(2) self.uno.Blink(13, 0.3) self.horizontal_motor = Motor(self.uno, dir_pin=3, step_pin=2, trigger_pos=6, trigger_neg=UNCONNECTED_3, home_dir=1, home_offset=500, ms1=LEFT_RIGHT_MS1, ms2=LEFT_RIGHT_MS2, ms3=LEFT_RIGHT_MS3) self.vertical_motor = Motor(self.uno, dir_pin=4, step_pin=5, trigger_pos=UNCONNECTED_3, trigger_neg=7, home_dir=0, home_offset=200, ms1=UP_DOWN_MS1, ms2=UP_DOWN_MS2, ms3=UP_DOWN_MS3) self.calibrate()
def set_config(self, param_dict): '''this method sets the config, and is called in the brain this is _not_ done in the constructor, since the behaviors construct this class as well, and they dont have the param_dict''' global USE_MARYTTS mary = param_dict.get_option("body", "marytts", None) if mary is not None: mary = eval(mary) self.use_marytts = USE_MARYTTS = mary self.__nao_list = [] #list of the nao objects self.__pioneer_list = [] #list of the pioneer objects self.__alice_list = [] #list of the alice objects self.__movebase = None #the movebase objects self.__param_dict = param_dict self.arduino = None if self.__param_dict.get_option('body', 'arduino') == "True": self.arduino = arduino.Arduino() self.__create_robots() self.speak_cnt = 0 self.use_svox_speach = True self.speech_commands = [] self.prev_speech_command = {} self.remove_all_prev_speech_files()
def __init__(self, panelFile=None): # instantiate serial self.arduino = None try: self.arduino = arduino.Arduino() except Exception as e: print e.message if panelFile is None: # read from serial the panel id? pass else: self.panelFile = panelFile # build panel self.panels = dict() self.panels[1] = panel.Panel(self.panelFile, panelId=1) # the key is = to panelId self.currentPanelId = 1 # here the messages from Control will arrive # onOffQueue will contain string messages with 'on' and 'off' # panelQueue will contain panel that will be drawn # optionQueue will contain option that was selected self.onOffQueue = Queue.Queue() self.panelQueue = Queue.Queue() queues = (self.onOffQueue, self.panelQueue) # create GUI self.synchGUI = threading.Event() self.gui = GUI.GUI(queues, self.synchGUI) self.state = 'off'
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_LinearTrackUI() self.ui.setupUi(self) # Trigger checkbox QtCore.QObject.connect(self.ui.cb_trigger, QtCore.SIGNAL("clicked()"), self.toggleTrigger) # Status bar self.statusBar().showMessage("Ready") # Actions exit = QtGui.QAction(QtGui.QIcon('icons/exit.png'), 'Exit', self) exit.setShortcut('Ctrl+Q') exit.setStatusTip('Exit Spotter') self.connect(exit, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()')) self.arduino = arduino.Arduino('COM3') self.timer = QtCore.QTimer() self.timer.timeout.connect(self.checkPhysState) self.timer.start(5) self.t_elapsed = QtCore.QTime() self.t_elapsed.start()
def serialInit(self, port='ACM0', baud=9600): self.ard = arduino.Arduino(port, baud) time.sleep(2) data = self.ard.recv() while data != None and data != '' and data != b'': time.sleep(0.05) #ard.send((str(i)).encode('utf-8')) #print(ard.recv()) print(data) data = self.ard.recv()
def __init__(self, device_list): self.arduino_handlers = {} self.cv = threading.Condition() print 'Device list: %s' % device_list for path in device_list: try: device = self.ArduinoHandler(arduino.Arduino(path), self.cv) except Exception as e: print('Error while initializing device %s: %s' % (path, e)) continue id = device.get_id() self.arduino_handlers[id] = device print 'Got device with ID=%s' % id
def start_scanner(): con_list = {} while True: # Scan all ports ports = get_serial_ports() # If a device connected if len(ports) > 0: # For-Loop in the scanned ports for current in ports: # New Arduino is connected # Register to con_list # Returns False because we don't connect yet if current not in con_list: con_list[current] = False # Arduino is connected if current in con_list and con_list[current] == False: con = arduino.Arduino(current, 9600) if con.open(max_attempt=5): con_list[current] = True to_node("status", { "name": "connect", "data": "connected" }) thread = threading.Thread(target=con.start_serial()) thread.start() # Arduino in con_list, nothing to do elif current in con_list and con_list[current] == True: continue # Any Arduino connected, set them all False # We are not goint to clean the list because we will check if it is connected again elif len(con_list) > 0: for con in con_list: if con_list[con] == True: con_list[con] = False to_node("status", { "name": "connect", "data": "disconnected" }) time.sleep(1)
def __init__(self, update_shift_reg=False, update_arduino=True): self.last_time = time.time() gpio.setmode(gpio.BCM) gpio.setwarnings(False) if update_arduino: self.arduino = arduino.Arduino() else: self.arduino = None for output in Outputs: if output.value < _SHIFT_REG_ADDRESS_OFFSET: gpio.setup(output.value, gpio.OUT) self.WriteOutput(output, 0) for pin in Inputs: gpio.setup(pin.value, gpio.IN, pull_up_down=gpio.PUD_UP) if update_shift_reg: self.current_shifted_byte = [0] * 24 self.current_shifted_byte[Outputs.COMPRESSOR.value - _SHIFT_REG_ADDRESS_OFFSET] = 1 self.signal_refresh = Queue.Queue(1) self.thread = threading.Thread(target=self.__RefreshShiftOutputs) self.thread.daemon = True self.thread.start() self.WriteOutput(Outputs.COMPRESSOR, 1)
def __init__(self, tof_lib): """ Constructor """ # Create a list of servo's self.servos = dict() # Add Motor Servo's. NOTE: Left motor esc is reversed. self.servos[ServoEnum.LEFT_MOTOR_ESC] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=True), LEFT_MOTOR_ESC_PIN, 'Left Motor' ] self.servos[ServoEnum.RIGHT_MOTOR_ESC] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), RIGHT_MOTOR_ESC_PIN, 'Right Motor' ] # Add Auxilary servo's. NOTE: Aux esc's are not reversed. self.servos[ServoEnum.LEFT_AUX_ESC] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), LEFT_AUX_ESC_PIN, 'Left Aux' ] self.servos[ServoEnum.RIGHT_AUX_ESC] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), RIGHT_AUX_ESC_PIN, 'Right Aux' ] # Add Auxilary servo's. NOTE: Ball Flinger esc's are not reversed. self.servos[ServoEnum.LEFT_FLINGER_ESC] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), LEFT_FLINGER_ESC_PIN, 'Left Flinger ESC' ] self.servos[ServoEnum.RIGHT_FLINGER_ESC] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), RIGHT_FLINGER_ESC_PIN, 'Right Flinger ESC' ] # Add Auxilary servo's. NOTE: Ball Flinger esc's are not reversed. self.servos[ServoEnum.LEFT_FLINGER_SERVO] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), LEFT_FLINGER_SERVO_PIN, 'Left Flinger Servo' ] self.servos[ServoEnum.RIGHT_FLINGER_SERVO] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), RIGHT_FLINGER_SERVO_PIN, 'Right Flinger Servo' ] # Add Auxilary servo's. NOTE: Aux 4 servo is not reversed. self.servos[ServoEnum.WINCH_SERVO] = [ servo_control.Servo_Controller(min=800, mid=1300, max=1800, bReverse=False), WINCH_SERVO_PIN, 'Winch' ] # Always set these to None for initialisation self.PWMservo = None self.arduino = None self.arduino_mode = 0 # Not using Arduino self.lidars = [] if (self.arduino_mode == 1): self.arduino = arduino.Arduino() else: self.arduino = None self.PWMservo = PWM.Servo(pulse_incr_us=1) # I2C lidar sensors should be enabled # in both Arduino mode or direct pi mode. for pin in range(0, 3): i2c_lidar.xshut([LIDAR_PINS[pin]]) self.lidars.append( i2c_lidar.create(LIDAR_PINS[pin], tof_lib, 0x2a + pin))
#!/usr/bin/env python import time import arduino uno = arduino.Arduino("ttyACM", baud=9600) UNCONNECTED_1 = 8 UNCONNECTED_2 = 9 UNCONNECTED_3 = 12 ICE_STEPS = 6 class Motor(object): def __init__(self, uno, dir_pin, step_pin, trigger_neg, trigger_pos, home_dir, home_offset): self.uno = uno self.dir_pin = dir_pin self.step_pin = step_pin self.trigger_neg = trigger_neg self.trigger_pos = trigger_pos self.home_dir = home_dir self.home_offset = home_offset def Move(self, forward, steps): self.uno.Move(stepper_dir_pin=self.dir_pin, stepper_pulse_pin=self.step_pin, negative_trigger_pin=self.trigger_neg, positive_trigger_pin=self.trigger_pos, done_pin=UNCONNECTED_1, forward=forward, steps=steps,
def __init__(self, tof_lib): """ Constructor """ # Minimum and maximum theoretical pulse widths. Ignore reversing here # ESC "DB1" midpoint is about 1440 # ESC "DB2" midpoint is 1500 self.LEFT_MIN = 800 self.LEFT_MID = 1300 self.LEFT_MAX = 1800 self.RIGHT_MIN = 800 self.RIGHT_MID = 1300 self.RIGHT_MAX = 1800 self.LEFT_AUX_1_MIN = 800 self.LEFT_AUX_1_MID = 1300 self.LEFT_AUX_1_MAX = 1800 self.RIGHT_AUX_1_MIN = 800 self.RIGHT_AUX_1_MID = 1300 self.RIGHT_AUX_1_MAX = 1800 self.left_servo = servo_control.Servo_Controller( self.LEFT_MIN, self.LEFT_MID, self.LEFT_MAX, True) self.right_servo = servo_control.Servo_Controller( self.RIGHT_MIN, self.RIGHT_MID, self.RIGHT_MAX, False) self.left_aux_1_servo = servo_control.Servo_Controller( self.LEFT_AUX_1_MIN, self.LEFT_AUX_1_MID, self.LEFT_AUX_1_MAX, False) self.right_aux_1_servo = servo_control.Servo_Controller( self.RIGHT_AUX_1_MIN, self.RIGHT_AUX_1_MID, self.RIGHT_AUX_1_MAX, False) self.left_channel = 1 self.right_channel = 2 # Proximity sensor: roughly cm from closest measurable point # self.tof_left = sensor.Sensor(0, 450, 20, 0) # self.PWMservo = PWM.Servo(pulse_incr_us=1) # Always set these to None for initialisation self.PWMservo = None self.arduino = None self.arduino_mode = 0 # Not using Arduino self.lidars = [] if (self.arduino_mode == 1): self.arduino = arduino.Arduino() else: self.arduino = None self.PWMservo = PWM.Servo(pulse_incr_us=1) for pin in range(0, 3): i2c_lidar.xshut([LIDAR_PINS[pin]]) self.lidars.append(i2c_lidar.create(LIDAR_PINS[pin], tof_lib, 0x2a + pin))
import sys sys.path.append("../..") import time import arduino ard = arduino.Arduino() m0 = arduino.Motor(ard, 0, 2, 3) ard.run() # Start the Arduino communication thread while True: m0.setSpeed(127) time.sleep(1) m0.setSpeed(0) time.sleep(1) m0.setSpeed(-127) time.sleep(1) m0.setSpeed(0) time.sleep(1)
def __init__(self): self.arduino = arduino.Arduino()
#in this file: # headers # creation of a device from a list of commands # execution of device # command line workings import arduino import creator import properties as P import sys if __name__ == "__main__": try: with open(sys.argv[1], "r") as f: listtobeprocessed = [] for line in f: line = line.strip() if line != "" and line[0] != "#": listtobeprocessed.append(line) except IndexError: listtobeprocessed = creator.main() except IOError: print "Exception: The input file could not be found. Aborting..." quit() dev = arduino.Arduino() o1 = dev.add("thermal_iterator") #add output dev.add("diode_output", o1) #add output o2 = dev.add("thermal_iterator") #add output dev.add("diode_output", o2) #add output print dev.build()
import time import arduino import driver device1 = '/dev/ttyACM0' device2 = '/dev/ttyACM1' a1 = arduino.Arduino(device1) a2 = arduino.Arduino(device2) d = driver.Driver while True: d.stop() print("Move forward 5") d.forward(5) d.wait() print("Reading") a1.read() a2.read() print(device1 + str(a1.sensor_input)) print(device2 + str(a2.sensor_input)) print("Turn left 90 degrees") d.turn_left(90) d.wait() time.sleep(1)
import arduino import telegram from time import sleep while True: comand = telegram.get_my_posts() my_arduino = arduino.Arduino('test') print(f">>> Comando recebido pelo Telegram: {comand}") my_arduino.set(comand)
split_data = data[0].split() ipaddr = split_data[split_data.index('src') + 1] # Unique number of raspberry pi dat = {'did': 'raspberry002', 'ip': ipaddr} # Server ID serverURL = "http://rails-beanstalk.gb6ktuimmz.ap-northeast-2.elasticbeanstalk.com/regist" # make public queue commandQueue = Queue.Queue() # init module andRaspTCP = tcpServer.TCPServer(commandQueue, ipaddr, 1234) andRaspTCP.start() arduinoSerial = arduino.Arduino(commandQueue) arduinoSerial.start() # set module to executer commandExecuter = executer.Executer(andRaspTCP, arduinoSerial) # post raspby device id, ip res = requests.post(serverURL, data=dat) print(res.text) while True: try: command = commandQueue.get() commandExecuter.startCommand(command) except: pass
import tempsensors import relay import time import mqttcom import configparser import math import arduino import time print("Starting HeatingPI V0.2") ard = arduino.Arduino('/dev/ttyACM0') hpConfig = configparser.ConfigParser() hpConfig.read("config.ini") #myOled = oled.OLED() #myOled.showSplashScreen() # mySens = tempsensors.TempSensors("28-3c01f0964f8c", "28-3c01f0965e56") mySens = tempsensors.TempSensors(hpConfig["sensors"]["T1"], hpConfig["sensors"]["T2"], hpConfig["sensors"]["T3"], hpConfig["sensors"]["T4"]) # mySens = tempsensors.TempSensors("28-0317607252ff", "28-051760bdebff") relayBoard = relay.RelayBoard() mqttClient = mqttcom.MQTTComm(hpConfig["mqtt"]["server_address"], hpConfig["mqtt"]["base_topic"])
#-*- coding: utf-8 -*- # stino/__init__.py import sublime import utils import stpanel import setting import const import osfile import language import smonitor import arduino import stmenu import actions import compilation log_panel = stpanel.STPanel() serial_listener = smonitor.SerialPortListener() cur_language = language.Language() arduino_info = arduino.Arduino() cur_menu = stmenu.STMenu(cur_language, arduino_info) status_info = setting.Status(const.settings, arduino_info, cur_language) serial_port_in_use_list = [] serial_port_monitor_dict = {}
import time import sys sys.path.append("../..") import arduino # Example code to run an IR sensor. Turns on the LED # at digital pin 13 when the IR sensor detects anything within # a certain distance. THRESH = 200.0 # Experimentally chosen ard = arduino.Arduino() # Create the Arduino object a0 = arduino.AnalogInput(ard, 0) # Create an analog sensor on pin A0 ard.run() # Start the thread which communicates with the Arduino # Main loop -- check the sensor and update the digital output while True: ir_val = a0.getValue() # Note -- the higher value, the *closer* the dist print ir_val, ir_val >= THRESH time.sleep(0.1)
delta = self.ttl for led in range(len(self.cur_chain)): for clr in range(3): self.cur_chain[led][clr] = self.slopes[led][clr] * delta + \ self.old_chain[led][clr] self.cur_chain.draw() if delta >= self.ttl: raise StopIteration if __name__ == '__main__': #port = "/dev/tty.usbserial-A800ewuP" port = "/dev/ttyUSB0" debug = True debug = False hwport = arduino.Arduino(port, debug=debug) hwport.reset(5) chain = Chain(hwport) chain.length = 2 chain.clear() HSV = 1000 while 1: for hue in range(HSV): hue = hue / float(HSV) for led in range(chain.length): chain.lights[led].hsv = (hue, 1, 1) chain.draw() #time.sleep(.1) """ while 1: for x in range(1023):
def __init__(self, parent, verbose=False, emulate_wheel=False, print_arduino=False): self.parent = parent parent.columnconfigure(0, weight=1) # parent.rowconfigure(1, weight=1) self.verbose = verbose self.var_cache_size = tk.IntVar() self.var_sess_dur = tk.IntVar() self.var_rec_zeros = tk.IntVar() self.var_emulate_wheel = tk.IntVar() self.var_track_per = tk.IntVar() self.var_save_txt = tk.BooleanVar() self.var_cache_size.set(500) self.var_sess_dur.set(1) self.var_rec_zeros.set(1) self.var_emulate_wheel.set(emulate_wheel) self.var_track_per.set(50) self.var_save_txt.set(True) self.parameters = { 'emulate_wheel': self.var_emulate_wheel, 'session_dur': self.var_sess_dur, 'record_zeros': self.var_rec_zeros, 'track_period': self.var_track_per, } self.var_print_arduino = tk.BooleanVar() self.var_stop = tk.BooleanVar() self.var_print_arduino.set(print_arduino) self.var_stop.set(False) # Counters # IMPORTANT: need to keep `counter_vars` in same order as `arduino_events` self.var_counter_wheel = tk.IntVar() counter_vars = [self.var_counter_wheel] self.counter = { ev: var_count for ev, var_count in zip(arduino_events.values(), counter_vars) } self.var_start_time = tk.StringVar() self.var_stop_time = tk.StringVar() # Lay out GUI frame_setup = tk.Frame(parent) frame_setup.grid(row=0, column=0) frame_setup_col0 = tk.Frame(frame_setup) frame_setup_col1 = tk.Frame(frame_setup) # frame_setup_col2 = tk.Frame(frame_setup) frame_setup_col0.grid(row=0, column=0, sticky='we') frame_setup_col1.grid(row=0, column=1, sticky='we') # frame_setup_col2.grid(row=0, column=2, sticky='we') frame_monitor = tk.Frame(parent) frame_monitor.grid(row=1, column=0) # frame_monitor.rowconfigure(0, weight=1) # frame_monitor.columnconfigure(1, weight=1) # Session frame frame_params = tk.Frame(frame_setup_col0) frame_params.grid(row=0, column=0, padx=15, pady=5) frame_params.columnconfigure(0, weight=1) frame_session = tk.Frame(frame_params) frame_misc = tk.Frame(frame_params) frame_session.grid(row=0, column=0, sticky='e', padx=px, pady=py) frame_misc.grid(row=2, column=0, sticky='e', padx=px, pady=py) # Arduino frame frame_arduino = ttk.LabelFrame(frame_setup_col0, text='Arduino') frame_arduino.grid(row=1, column=0, padx=px, pady=py, sticky='we') # Notes frame frame_notes = tk.Frame(frame_setup_col1) frame_notes.grid(row=0, sticky='wens', padx=px, pady=py) frame_notes.grid_columnconfigure(0, weight=1) # Saved file frame frame_file = tk.Frame(frame_setup_col1) frame_file.grid(row=1, column=0, padx=px, pady=py, sticky='we') frame_file.columnconfigure(0, weight=3) frame_file.columnconfigure(1, weight=1) # Start-stop frame frame_start = tk.Frame(frame_setup_col1) frame_start.grid(row=3, column=0, sticky='we', padx=px, pady=py) frame_start.grid_columnconfigure(0, weight=1) frame_start.grid_columnconfigure(1, weight=1) # Monitor frame frame_counter = tk.Frame(frame_monitor) frame_live = tk.Frame(frame_monitor) frame_counter.grid(row=0, column=0, padx=px, pady=py, sticky='we') frame_live.grid(row=1, column=0, padx=px, pady=py, sticky='wens') # Add GUI components ## frame_params ### frame_session ## UI for trial control self.entry_session_dur = ttk.Entry(frame_session, textvariable=self.var_sess_dur, width=entry_width) tk.Label(frame_session, text='Session duration (min): ', anchor='e').grid(row=0, column=0, sticky='e') self.entry_session_dur.grid(row=0, column=1, sticky='w') ### frame_misc ### UI for miscellaneous parameters self.entry_rec_all = ttk.Checkbutton(frame_misc, variable=self.var_rec_zeros) self.entry_track_period = ttk.Entry(frame_misc, textvariable=self.var_track_per, width=entry_width) tk.Label(frame_misc, text='Record zeros: ', anchor='e').grid(row=0, column=0, sticky='e') tk.Label(frame_misc, text='Track period (ms): ', anchor='e').grid(row=1, column=0, sticky='e') self.entry_rec_all.grid(row=0, column=1, sticky='w') self.entry_track_period.grid(row=1, column=1, sticky='w') ### frame_arduino ### UI for Arduino self.arduino = arduino.Arduino(frame_arduino, main_window=self.parent, verbose=self.verbose, params=self.parameters) self.arduino.grid(row=0, column=0, sticky='we') self.arduino.var_uploaded.trace_add('write', self.gui_util) ## Notes self.entry_subject = ttk.Entry(frame_notes) self.entry_weight = ttk.Entry(frame_notes) self.scrolled_notes = ScrolledText(frame_notes, width=20, height=15) tk.Label(frame_notes, text='Subject: ').grid(row=0, column=0, sticky='e') tk.Label(frame_notes, text='Weight (g): ').grid(row=1, column=0, sticky='e') tk.Label(frame_notes, text='Notes:').grid(row=2, column=0, columnspan=2, sticky='w') self.entry_subject.grid(row=0, column=1, sticky='w') self.entry_weight.grid(row=1, column=1, sticky='w') self.scrolled_notes.grid(row=3, column=0, columnspan=2, sticky='wens') ## UI for saved file self.entry_save_file = ttk.Entry(frame_file) self.button_set_file = ttk.Button(frame_file, command=self.get_save_file) tk.Label(frame_file, text='File to save data:', anchor='w').grid(row=0, column=0, columnspan=2, sticky='w') self.entry_save_file.grid(row=1, column=0, sticky='wens') self.button_set_file.grid(row=1, column=1, sticky='e') folder_icon_file = os.path.join(source_path, 'graphics/folder.png') icon_folder = ImageTk.PhotoImage(file=folder_icon_file) self.button_set_file.config(image=icon_folder) self.button_set_file.image = icon_folder ## Start frame self.button_start = ttk.Button( frame_start, text='Start', command=lambda: self.parent.after(0, self.start)) self.button_stop = ttk.Button(frame_start, text='Stop', command=lambda: self.var_stop.set(True)) self.button_start.grid(row=2, column=0, sticky='we') self.button_stop.grid(row=2, column=1, sticky='we') ## Counter frame tk.Label(frame_counter, text='Start time: ').grid(row=0, column=0, sticky='e') tk.Label(frame_counter, text='End time: ').grid(row=1, column=0, sticky='e') self.entry_start_time = ttk.Entry(frame_counter, textvariable=self.var_start_time, state='readonly', width=entry_width) self.entry_stop_time = ttk.Entry(frame_counter, textvariable=self.var_stop_time, state='readonly', width=entry_width) self.entry_start_time.grid(row=0, column=1, sticky='wens') self.entry_stop_time.grid(row=1, column=1, sticky='wens') ## Live frame data_types = {arduino_events[code_wheel]: 'line'} # tk.Label(frame_live, text='Also under construction').grid() self.live_view = live_data_view.LiveDataView(frame_live, x_history=30000, scale_x=0.001, data_types=data_types, ylim=(-25, 50), xlabel='Time (s)') ###### GUI OBJECTS ORGANIZED BY TIME ACTIVE ###### # List of components to disable at open self.obj_to_disable_on_upload = [ child for child in (frame_session.winfo_children() + frame_misc.winfo_children()) ] self.obj_to_enable_on_upload = [self.button_start] self.obj_to_disable_at_open = [ self.entry_session_dur, self.entry_track_period, ] self.obj_to_enable_at_open = [ self.button_start, ] self.obj_to_disable_at_start = [ self.entry_subject, self.entry_weight, self.entry_save_file, self.button_set_file, self.button_start, ] self.obj_to_enable_at_start = [self.button_stop] # Default values self.button_start['state'] = 'disabled' self.button_stop['state'] = 'disabled' ###### SESSION VARIABLES ###### self.q_serial = Queue()
print 'arduino_listen: found terminate flag. Exit' return line = ard.read() # read line from arduino if line == '': # if serial timeout is reached continue print(line) dispatch(line) if __name__ == '__main__': #log('Smart home started') getWeather() ##### Objects configuration ###### ard = arduino.Arduino( '/dev/serial/by-id/usb-FTDI_FT232R_USB_UART_A80090sP-if00-port0', onFound=onArduinoFound, onLost=onArduinoLost) hole_motion.onOn = onHoleMotion hole_motion.onOff = onHoleMotionOff init_IR_codes() # init dict: { IR_CODE : function } ### Threads creating ### sock_thr = Thread(target=sock_listen, args=(), name="sock_thr") sock_thr.start() glob.get('threads').append(sock_thr) ard_thr = Thread(target=arduino_listen, args=(), name="ard_thr") ard_thr.start() glob.get('threads').append(ard_thr) ds = Thread(target=get_T, args=(), name="ds") ds.start() # ds18s20 temerature sensor glob.get('threads').append(ds)
import arduino import constants from time import sleep, time import threading import angle_master feedback_ard = arduino.Arduino(constants.ID_FEEDBACK_ARDUINO, 57600) movement_ard = arduino.Arduino(constants.ID_MOVEMENT_ARDUINO, 57600) sleep(2) present_angles = [0, 0, 0, 0, 0, 0] def handle_interrupts(data): pass a1 = 0 a2 = 0 def get_feedbacks(): global a1 global a2 while True: data = feedback_ard.readline() # print(data) if data and 'F' in data and len: raw_values = data.strip().split(',')[1:] # print(raw_values) try: a1 = angle_master.get_angle(
last_error = error - roll_olderror roll_olderror = error roll_out = error * roll_Kp + roll_sum * roll_Ki + last_error * roll_Kd + roll_MID if (roll_out > roll_MAX): roll_out = roll_MAX elif (roll_out < roll_MIN): roll_out = roll_MIN return roll_out # Init print("[INFO] init_\n") sum_dir = np.zeros(2) count_dir = np.zeros((5), dtype=np.int) Arduino = arduino.Arduino() cap_count = 0 while True: cap = cv2.VideoCapture(cap_count) if (cap.isOpened()): break elif (cap_count == 8): cap_count = 0 else: cap_count += 1 print("[INFO] camera_open\n") print(count_dir) count_dir[4] = 0 Arduino.send(count_dir) ret, frame = cap.read()
import sys import time import subprocess from werkzeug.datastructures import MultiDict import flask app = flask.Flask(__name__) import fergboard # fergboard_motors.py motors = fergboard.Motors() import arduino # arduino.py arduino_uno = arduino.Arduino() class MJpegStream(): def __init__(self): self.proc = None self.params = MultiDict() def start(self, params): """ Start mjpg-streamer, wait until it has warmed up, and return success/failure """ if self.proc: self.stop() self.proc = subprocess.Popen(self.create_args(params), stderr=subprocess.PIPE, universal_newlines=True) # Block until we have read the line "Encoder Buffer Size" from stderr.
import sys, time sys.path.append("/home/maslab-team-5/Maslab/tart/Libraries/") import arduino from tart.actuators import drive if __name__ == "__main__": try: ard = arduino.Arduino(debug=True) dt = drive.SimpleDrive(ard, (2, 0), (2, 1)) ard.start() assert ard.waitReady() dt.setMotors(127, 127) time.sleep(10) dt.setMotors(-127, -127) time.sleep(10) dt.setMotors(0, 0) #This is so that when you hit ctrl-C in the terminal, all the arduino threads close. You can do something similar with threads in your program. except KeyboardInterrupt: print "Ending Program" finally: ard.stop()