def __init__(self): self.servoLeft = 8 self.servoRight = 9 self.board = pymata4.Pymata4() self.board.set_pin_mode_servo(self.servoLeft) self.board.set_pin_mode_servo(self.servoRight)
def keep_alive_test(pin_number): """ This program will set a digital output pin to high. It is assumed that an LED is connected to this pin. After 2 seconds the program exits, and in approximately one second the LED should extinguish. If keep_alive is working, the LED should extinguish. :param pin_number: A pin with an LED connected to it """ board = pymata4.Pymata4() # set the as a digital output board.set_pin_mode_digital_output(pin_number) # set the pin high board.digital_write(pin_number, 1) # turn on keep_alives board.keep_alive() print('Sleeping for 2 seconds...') time.sleep(2) print('Exiting. In about 1 second, the LED should extinguish.') sys.exit(0)
def __init__(self, analog_pin=2, poll_time=5, differential=5): """ :param analog_pin: arduino analog input pin number :param poll_time: polling interval in seconds :param differential: difference between current value and previous value to consider the change in value a change event """ self.analog_pin = analog_pin self.poll_time = poll_time self.differential = differential # Callback data indices self.CB_PIN_MODE = 0 # pin mode (see pin modes in private_constants.py) self.CB_PIN = 1 # pin number self.CB_VALUE = 2 # reported value self.CB_TIME = 3 # raw time stamp # instantiate pymata4 self.board = pymata4.Pymata4() # set the pin mode for analog input self.board.set_pin_mode_analog_input(self.analog_pin, self.the_callback, self.differential) # start polling self.keep_polling()
def connectToBoard(): #TODO: Add timeout if board does not connect in time. global BOARD ProgramLogger.info("Connecting to board.") try: #TODO: Document connecting to an Arduino Due. BOARD = pymata4.Pymata4() ProgramLogger.info( f"Total Digital Pins: {str(len(BOARD.digital_pins))} Total Analog Pins: {str(len(BOARD.analog_pins))}" ) except AttributeError: #TODO: Check if borad is an Arduino Due. loading.destroy() info = "Could not connect to arduino board. Is it pluged in? Reconnect the arduino USB cable, then try again. Or check that the arduino board is assigned a COM port in Device Manager." ProgramLogger.critical(info, exc_info=True) messagebox.showerror( PROGRAM_NAME, f"{info}\n\nCheck program log file for more info.") return except RuntimeError as err: loading.destroy() info = f"An error occurred during board communication. If this error has somthing to do with a timeout, close the program and reconnect the arduino USB cable.\n\n{err}" ProgramLogger.critical(info, exc_info=True) messagebox.showerror( PROGRAM_NAME, f"{info}\n\nCheck program log file for more info.") return attatchSteppers()
def main(): board = pymata4.Pymata4() app = QApplication(sys.argv) app.setStyle('Fusion') ex = pwmUI(board=board) sys.exit(app.exec_())
def __init__(self): self.values = { 'leftX': 0, 'leftY': 0, 'rightX': 0, 'rightY': 0, 'sonar': 0, 'distance': 0, 'light': 0, 'temp': 0, 'rot': 0, } self.pins = { 'pwmOut': { 'leftEnA': 3, 'leftEnB': 2, 'rightEnA': 4, 'rightEnB': 5, }, 'digitalOut': { 'leftIn1': 24, 'leftIn2': 25, 'leftIn3': 22, 'leftIn4': 23, 'rightIn1': 26, 'rightIn2': 27, 'rightIn3': 28, 'rightIn4': 29, 'relay': 53, }, 'analogOut': { 'distance': 0, 'light': 1, 'temp': 2, 'rot': 3 }, 'sonar': { 'trigger': 12, 'echo': 13 } } self.board = pymata4.Pymata4() [ self.board.set_pin_mode_pwm_output(self.pins['pwmOut'][x]) for x in self.pins['pwmOut'] ] [ self.board.set_pin_mode_pwm_output(self.pins['digitalOut'][x]) for x in self.pins['digitalOut'] ] [ self.board.set_pin_mode_pwm_output(self.pins['analogOut'][x]) for x in self.pins['analogOut'] ] self.board.set_pin_mode_sonar(self.pins['sonar']['trigger'], self.pins['sonar']['echo'])
def __init__(self): self.servoPin = 9 self.enaPin = 5 self.in1Pin = 6 self.in2Pin = 7 self.board = pymata4.Pymata4() self.board.set_pin_mode_servo(self.servoPin) self.board.set_pin_mode_pwm_output(self.enaPin) self.board.set_pin_mode_digital_output(self.in1Pin) self.board.set_pin_mode_digital_output(self.in2Pin)
def setup(tempSensors, sensorGroups, hvacControlPins): LOGGER = logging.getLogger("__main__.hvac.setup") LOGGER.debug("tempSensors {}\nsensorGroups {}\nhvacControlPins {}".format( tempSensors, sensorGroups, hvacControlPins)) hvac = HVAC() # Setup the thermostat hvac.thermostat = Thermostat() # Add the sensors to the thermostat for sensorName, sensorData in tempSensors.items(): hvac.thermostat.addSensor( sensors.TempSensor(sensorName, sensorData[0], sensorData[1])) # Create the groups of sensors for groupName, sensorNames in sensorGroups.items(): hvac.thermostat.createSensorGroup(groupName) # Add the sensors to the group for sName in sensorNames: for sensor in hvac.thermostat.tempSensors: if sName == sensor.name: hvac.thermostat.addSensorToGroup(sensor, groupName) # Setup the heater hvac.heater = Heater() hvac.heater.controlPins = hvacControlPins["HEAT_PINS"] # Setup the vent hvac.vent = Vent() hvac.vent.controlPins = hvacControlPins["VENT_PINS"] # Setup the AC hvac.ac = AirConditioner() hvac.ac.controlPins = hvacControlPins["AC_PINS"] # Setup the pymata board hvac.board = pymata4.Pymata4() # Add all of the control and sensor pins to the board # Sensor pins for tSensor in hvac.thermostat.tempSensors: hvac.board.set_pin_mode_analog_input(tSensor.controlPin) # LOGGER.debug("{} {}".format(tSensor, tSensor.controlPin)) # Control pins # Heater for pin in hvac.heater.controlPins: hvac.board.set_pin_mode_digital_output(pin) LOGGER.debug("heater controlPin {}".format(pin)) # Vent for pin in hvac.vent.controlPins: hvac.board.set_pin_mode_digital_output(pin) LOGGER.debug("vent controlPin {}".format(pin)) # AC for pin in hvac.ac.controlPins: hvac.board.set_pin_mode_digital_output(pin) LOGGER.debug("ac controlPin {}".format(pin)) return hvac
def __init__(self): self.board = pymata4.Pymata4() self.LED_PIN = 9 self.Q1_PIN = 3 self.Q2_PIN = 5 self.T1_PIN = 0 self.T2_PIN = 2 self.board.set_pin_mode_pwm_output(self.LED_PIN) self.board.set_pin_mode_pwm_output(self.Q1_PIN) self.board.set_pin_mode_pwm_output(self.Q2_PIN) self.board.set_pin_mode_analog_input(self.T1_PIN) self.board.set_pin_mode_analog_input(self.T2_PIN) self._Q1 = 0 self._Q2 = 0 time.sleep(0.1)
def sensor_manager(): global status, light # Intialize node and topic pub_light = rospy.Publisher('light_data', Int16MultiArray, queue_size=10) pub_force = rospy.Publisher('force_data', Int16MultiArray, queue_size=10) pub_mic = rospy.Publisher('mic_data', Int16MultiArray, queue_size=10) rospy.init_node('senor_manager', anonymous=False) rate = rospy.Rate(10) # 10hz # msg = vect_msg() # Initialize Arduino Leoardo with pymata4 board = pymata4.Pymata4() # Initialize i2c board.set_pin_mode_i2c() board.i2c_write(bh1750_address, [bh1750_power_on]) board.i2c_write(bh1750_address, [bh1750_resolution]) # Initialize input analog pins for pin in analog_pins: board.set_pin_mode_analog_input(pin_number=pin) # Initialize output digital pins for pin in digital_pins: board.set_pin_mode_digital_output(pin_number=pin) mic_msg = Int16MultiArray() fsr_msg = Int16MultiArray() light_msg = Int16MultiArray() # Get raw data from board while True: # mic data mic_val = [] for pin in mic: mic_val.append(list(board.analog_read(pin))) time.sleep(0.01) mic_msg.data = [mic_val[0][0], mic_val[1][0]] pub_mic.publish(mic_msg) # fsr data fsr_val = [] for pin in fsr: fsr_val.append(list(board.analog_read(pin))) time.sleep(0.01) fsr_msg.data = [fsr_val[0][0], fsr_val[1][0]] pub_force.publish(fsr_msg) # light board.i2c_read(address=bh1750_address, register=None, number_of_bytes=nbytes, callback=ckb) light_msg.data = light pub_light.publish(light_msg) time.sleep(0.2) # status led status = not status board.digital_write(led_status, status) rospy.loginfo('Sent data') rate.sleep()
""" This example demonstrates running a stepper motor """ NUM_STEPS = 512 ARDUINO_PINS = [8, 9, 10, 11] def stepper(my_board, steps_per_rev, pins): """ Set the motor control control pins to stepper mode. Rotate the motor. :param my_board: pymata_express instance :param steps_per_rev: Number of steps per motor revolution :param pins: A list of the motor control pins """ my_board.set_pin_mode_stepper(steps_per_rev, pins) time.sleep(1) my_board.stepper_write(20, 500) board = pymata4.Pymata4() try: stepper(board, NUM_STEPS, ARDUINO_PINS) board.shutdown() except KeyboardInterrupt: board.shutdown() sys.exit(0)
high_nibble: int = value & 0xf0 low_nibble: int = (value << 4) & 0xf0 self.write_4_bits(high_nibble | mode) self.write_4_bits(low_nibble | mode) def write_4_bits(self, value: int) -> None: self.expander_write(value) self.pulse_enable(value) def expander_write(self, data: int) -> None: self.board.i2c_write(self.address, [data, self._backlight_value]) def pulse_enable(self, data: int) -> None: self.expander_write(data | self.ENABLE_BIT) sleep(0.000001) self.expander_write(data & ~self.ENABLE_BIT) sleep(0.00005) def print(self, string: AnyStr) -> None: for character in string: self.write(ord(character)) sleep(0.000001) else: sleep(0.00005) Board = pymata4.Pymata4("/dev/ttyACM0") LCD = LiquidCrystal_I2C(0x27, 0, 1, Board) LCD.enable_backlight() LCD.print("Hello, Worlds!")
def arduino_init(delay=2): if pymata_ex: return pymata_express.PymataExpress(arduino_wait=delay) else: return pymata4.Pymata4(arduino_wait=delay)
# set the servo to 90 degrees my_board.servo_write(pin, 90) def servo_rev(my_board, pin): my_board.set_pin_mode_servo(pin) my_board.servo_write(pin, 40) def stepper(my_board, steps_per_rev, pins): """ Set the motor control control pins to stepper mode. Rotate the motor. :param my_board: pymata4 :param steps_per_rev: Number of steps per motor revolution :param pins: A list of the motor control pins """ my_board.stepper_write(10, 100) my_board.stepper_write(10, -100) board = pymata4.Pymata4("COM4") try: sonar(board, TRIGGER_PIN, ECHO_PIN, the_callback) board.shutdown() except (KeyboardInterrupt, RuntimeError): board.shutdown() sys.exit(0)
def __init__(self, root): root.title("TJ-Collaborative Robotics Platform") root.geometry("500x500") mainframe = ttk.Frame(root) mainframe.grid(column=0, row=0, sticky=(N, W, E, S)) self.ultrasonicVar = StringVar() self.distanceVar = StringVar() self.lightVar = StringVar() self.tempVar = StringVar() self.rotVar = StringVar() self.relayVar = StringVar() self.ultrasonicAverage = streamingMovingAverage(50) self.distanceAverage = streamingMovingAverage(50) self.lightAverage = streamingMovingAverage(50) self.tempAverage = streamingMovingAverage(50) self.rotAverage = streamingMovingAverage(15) self.relayAverage = streamingMovingAverage(50) ttk.Label(mainframe, text='Data').grid(column=0, row=0, sticky=(W, E)) ttk.Label(mainframe, text='Ultrasonic').grid(column=0, row=1, sticky=(W, E)) ttk.Label(mainframe, textvariable=self.ultrasonicVar).grid(column=1, row=1) ttk.Label(mainframe, text='Distance').grid(column=0, row=2, sticky=(W, E)) ttk.Label(mainframe, textvariable=self.distanceVar).grid(column=1, row=2) ttk.Label(mainframe, text='Light').grid(column=0, row=3, sticky=(W, E)) ttk.Label(mainframe, textvariable=self.lightVar).grid(column=1, row=3) ttk.Label(mainframe, text='Temperature').grid(column=0, row=4, sticky=(W, E)) ttk.Label(mainframe, textvariable=self.tempVar).grid(column=1, row=4) ttk.Label(mainframe, text='Rotations').grid(column=0, row=5, sticky=(W, E)) ttk.Label(mainframe, textvariable=self.rotVar).grid(column=1, row=5) ttk.Label(mainframe, text='Relay').grid(column=0, row=6, sticky=(W, E)) ttk.Label(mainframe, textvariable=self.relayVar).grid(column=1, row=6) self.board = pymata4.Pymata4() self.board.set_pin_mode_sonar( sensorDict["ultrasonicSensor"]["triggerPin"], sensorDict["ultrasonicSensor"]["triggerPin"], self.ultrasonicCallback) self.board.set_pin_mode_analog_input( sensorDict["distanceSensor"]["pin"], callback=self.distanceCallback, differential=10) self.board.set_pin_mode_analog_input(sensorDict["lightSensor"]["pin"], callback=self.lightCallback, differential=10) self.board.set_pin_mode_analog_input(sensorDict["tempSensor"]["pin"], callback=self.tempCallback) self.board.set_pin_mode_analog_input(sensorDict["rotSensor"]["pin"], callback=self.rotCallback)
#!/usr/bin/python3 import rospy from std_msgs.msg import String import sys import time from pymata4 import pymata4 BOARD_PORT = "/dev/ttyACM0" SERVO_PIN = 5 def servo_callback(angle): angle_data = float(angle.data) / 1.5 board.servo_write(SERVO_PIN, int(angle_data)) if __name__ == '__main__': try: #ros node init\ board = pymata4.Pymata4(BOARD_PORT) rospy.init_node("pymata") rospy.Subscriber("angle", String, servo_callback) board.set_pin_mode_servo(SERVO_PIN) rospy.spin() except KeyboardInterrupt: board.shutdown() sys.exit(0)
def blink(my_board, pin): """ This function will to toggle a digital pin. :param my_board: an PymataExpress instance :param pin: pin to be controlled """ # set the pin mode my_board.set_pin_mode_digital_output(pin) my_board.digital_write(pin, 1) # toggle the pin 4 times and exit for x in range(4): print('ON') my_board.digital_write(pin, 1) time.sleep(1) print('OFF') my_board.digital_write(pin, 0) time.sleep(1) my_board.shutdown() board = pymata4.Pymata4(ip_address=IP_ADDRESS, ip_port=IP_PORT) try: blink(board, DIGITAL_PIN) except KeyboardInterrupt: board.shutdown() sys.exit(0)
# print('OFF') # my_board.digital_write(pin, 0) # time.sleep(1) #my_board.shutdown() def on_connect(client, userdata, flags, rc): print("Connected with result code "+str(rc)) client.subscribe("Hellos/+") def on_message(client, userdata, msg): incoming_gesture = msg.payload.decode('ascii') print("Topic: {} message {}".format(msg.topic, incoming_gesture)) blink(board, incoming_gesture) ### Initialize the board board = pymata4.Pymata4(com_port='/dev/ttyS5') client = mqtt.Client() client.on_connect = on_connect client.on_message = on_message client.connect("127.0.0.1", 1883, 60) try: client.loop_forever() except: board.shutdown() sys.exit(0) #from pymata4.private_constants import PrivateConstants """