Python Arduino.exit方法代码示例

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
class ArduinoConnection(ConnectionBase):
    def __init__(self, connection_type, port_name):
        super().__init__()
        self.connectionStatus = ConnectionStatus.Closed
        self.connectionType = connection_type
        self.portName = port_name
        self._iterator = None

    def open_connection(self):
        if self.connectionStatus == ConnectionStatus.Open:
            print(self.connectionStatus)
            return None
        try:
            if self.board is None:
                print("Initializing board object specified connected to port {} ...".format(self.portName))
                self.board = Arduino(self.portName)
                print("Board object created!")
            if self._iterator is None:
                print("Initializing iterator object to prevent overflow serial buffer ...")
                self._iterator = util.Iterator(self.board)
                print("Iterator object created!")
                self._iterator.start()
            self.connectionStatus = ConnectionStatus.Open
            print("{}, {} , {} ".format(self.connectionStatus, self.connectionType, self.portName))

        except serial.SerialException as e:
            print(e.args[0])
            if self.board is not None:
                self.board.exit()
            raise SystemExit

    def close_connection(self):
        if self.connectionStatus == ConnectionStatus.Closed:
            print("Connection is already closed!")
        else:
            self.board.exit()
            self.board = None
            self._iterator = None
            self.connectionStatus = ConnectionStatus.Closed
            print(self.connectionStatus)

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
def main():
    parser = ArgumentParser(
        description='Bridge connecting Arduino and hat webapp')
    parser.add_argument('-s', '--server', default='127.0.0.1:3000',
                        help='Server the webapp is running on')
    parser.add_argument('device',
                        help='Path to Arduino device, e.g., /dev/tty/ACM0')
    args = parser.parse_args()

    url = ddp.ServerUrl(args.server)
    board = None
    hat_controller = None

    try:
        print 'Connecting to Arduino board...'
        board = Arduino(args.device)

        print 'Connecting to DDP server...'
        hat_controller = HatController(url, board)

        hat_controller.connect()
        wait_for_user_to_exit()
    finally:
        if hat_controller is not None:
            try:
                hat_controller.disconnect()
            except:
                print (
                    'An error occurred while disconnecting from the DDP '
                    'server.'
                )

        if board is not None:
            try:
                board.exit()
            except:
                print 'An error occurred while exiting from the Arduino board.'

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
class Board(SerializableModel):
    pk = None
    port = None
    pins = None
    name = None
    written_pins = set()

    json_export = ('pk', 'port', 'pins')

    def __init__(self, pk, port, *args, **kwargs):
        self.pk = pk
        self.port = port
        self._board = Arduino(self.port)
        self.pins = dict(((i, Pin(pk, i)) for i in range(14)))

        [setattr(self, k, v) for k, v in kwargs.items()]
        super(Board, self).__init__(*args, **kwargs)

    def __del__(self):
        try:
            self.disconnect()
        except:
            print(traceback.format_exc())

    def disconnect(self):
        for pin in self.written_pins:
            pin.write(0)
        return self._board.exit()

    def firmata_pin(self, identifier):
        return self._board.get_pin(identifier)

    def release_pin(self, identifier):
        bits = identifier.split(':')
        a_d = bits[0] == 'a' and 'analog' or 'digital'
        pin_nr = int(bits[1])
        self._board.taken[a_d][pin_nr] = False

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
# This code is supporting material for the book
# Python Programming for Arduino
# by Pratik Desai
# published by PACKT Publishing

from pyfirmata import Arduino, PWM
from time import sleep
import random

# Setting up the Arduino board
port = '/dev/cu.usbmodemfa1311'
board = Arduino(port)
# Need to give some time to pyFirmata and Arduino to synchronize
sleep(5)

# Setup mode of pin 2 as PWM
pin = 11
board.digital[pin].mode = PWM

for i in range(0, 99):
    # This python method generate random value between given range
    r = random.randint(1, 100)

    board.digital[pin].write(r / 100.00)
    # divide by 100.00 here as the answer will be float, integer otherwise
    sleep(0.1)

board.digital[pin].write(0)
board.exit()

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
class Form(QDialog):
    def __init__(self, app, parent=None):
        super(Form, self).__init__(parent)

        # Pyfirmata code
        self.potPin = 0
        self.servoPin = 9
        self.ledPin = 13
        self.board = Arduino("/dev/ttyACM0")

        iterator = util.Iterator(self.board)
        iterator.start()

        self.board.analog[self.potPin].enable_reporting()
        # self.board.digital[self.servoPin].mode = SERVO

        # PyQT Code
        servoLabel = QLabel("Servo")
        self.servoDial = QDial()
        self.servoDial.setMinimum(0)
        self.servoDial.setMaximum(180)
        self.servoPosition = 0

        potLabel = QLabel("Potenciometro")
        self.potSlider = QSlider()
        self.potSlider.setMinimum(0)
        self.potSlider.setMaximum(1000)

        ledLabel = QLabel("Led 13")
        self.ledButton = QPushButton("Light")

        grid = QGridLayout()
        grid.addWidget(servoLabel, 0, 0)
        grid.addWidget(potLabel, 0, 1)
        grid.addWidget(ledLabel, 0, 2)
        grid.addWidget(self.servoDial, 1, 0)
        grid.addWidget(self.potSlider, 1, 1)
        grid.addWidget(self.ledButton, 1, 2)
        self.setLayout(grid)

        self.connect(self.ledButton, SIGNAL("pressed()"), self.ledOn)
        self.connect(self.ledButton, SIGNAL("released()"), self.ledOff)

        # self.connect(self.servoDial,
        # SIGNAL("valueChanged(int)"), self.moveServo)

        self.connect(app, SIGNAL("lastWindowClosed()"), self.cleanup)

        self.timer = QTimer()
        self.timer.setInterval(500)

        self.connect(self.timer, SIGNAL("timeout()"), self.readPot)

        self.setWindowTitle("Arduino")

        self.timer.start()

    def ledOn(self):
        print "Led on"
        self.board.digital[self.ledPin].write(1)

    def ledOff(self):
        print "Led off"
        self.board.digital[self.ledPin].write(0)

    """
    def moveServo(self):
        position = self.servoDial.value()
        if abs(position - self.servoPosition) > 10:
            self.servoPosition = position
            print "Servo at position: %s" % position
            self.board.digital[self.servoPin].write(position)
    """

    def cleanup(self):
        print "cleanup"
        self.board.exit()

    def readPot(self):
        value = self.board.analog[self.potPin].read()
        if value is not None:
            position = value * 1000
            print "Read Pot: %s" % position
            self.potSlider.setValue(position)

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
class Uarm(object):
    # uarm = None

    def __init__(self, port, claw=False):
        self.uarm_status = 0
        # self.pin2_status = 0
        self.coord = {}
        self.g_interpol_val_arr = {}
        self.angle = {}
        self.claw = claw
        self.uarm = Arduino(port)
        self.assignServos()
        self.uarmDetach()

    def assignServos(self):
        self.servo_base = Servo(self.uarm, 1, 11, 2)
        self.servo_left = Servo(self.uarm, 2, 13, 0)
        self.servo_right = Servo(self.uarm, 3, 12, 1)
        self.servo_end = Servo(self.uarm, 4, 10, 3)
        self.servomap = {1: self.servo_base,
                         2: self.servo_left,
                         3: self.servo_right,
                         4: self.servo_end}
        if self.claw:
            self.servo_claw = Servo(self.uarm, 5, 9, 5)
            self.servomap[5] = self.servo_claw;

    def servos(self, servo_number=None):
        if servo_number is None:
            servo_number = list(self.servomap.keys())
        servo_number = self._aslist(servo_number)
        return [self.servomap[servo] for servo in servo_number]

    def servoAttach(self, servo_number=None, preserveAngle=True):
        for servo in self.servos(servo_number):
            servo.attach(preserveAngle=preserveAngle)

    def servoDetach(self, servo_number=None):
        for servo in self.servos(servo_number):
            servo.detach()
            self.uarm_status = 0

    def _aslist(self, v):
        try:
            return list(v)
        except TypeError:
            return [v]

    def uarmDisconnect(self, detach=True):
        if detach:
            self.servoDetach()
        self.uarm.exit()

    def uarmAttach(self):
        self.servoAttach()
        self.uarm_status = 1

    def uarmDetach(self):
        self.servoDetach()

    def angleConstrain(self, Angle):
        if Angle < 0:
            return 0
        elif Angle > 180:
            return 180
        else:
            return Angle

    def writeServoAngleRaw(self, servo_number, angle, constrain=False):
        self.servomap[servo_number].writeAngle(raw=True, constrain=constrain)

    def writeServoAngle(self, servo_number, angle, constrain=True):
        self.servomap[servo_number].writeAngle(raw=False, constrain=constrain)

    def writeAngle(self, *args, raw=False, constrain=True):
        for angle, servo in zip(args, self.servos()):
            servo.writeAngle(angle, raw=raw, constrain=constrain)

    def writeAngleRaw(self, *args, constrain=False):
        self.writeAngle(*args, raw=True, constrain=constrain)

    def readAnalog(self, servo_number=None):
        if servo_number is None or not hasattr(servo_number, 'len'):
            return [servo.readAnalog() for servo in self.servos(servo_number)]
        else:
            return self.servomap[servo_number].readAnalog()

    def readServoOffset(self, servo_number):
        if servo_number is None or not hasattr(servo_number, 'len'):
            return [servo.readOffset() for servo in self.servos(servo_number)]
        else:
            return self.servomap[servo_number].readServoOffset()

    def readToAngle(self, input_analog, servo_number, trigger):
        return self.servomap[servo_number].readToAngle(input_analog, raw=trigger)

    def fwdKine(self, theta_1, theta_2, theta_3):
        g_l3_1 = MATH_L3 * math.cos(theta_2 / MATH_TRANS)
        g_l4_1 = MATH_L4 * math.cos(theta_3 / MATH_TRANS);
        g_l5 = (MATH_L2 + MATH_L3 * math.cos(theta_2 / MATH_TRANS) + MATH_L4 * math.cos(theta_3 / MATH_TRANS));
#.........这里部分代码省略.........

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
class Uarm(object):
	
    
	uarm = None
	kAddrOffset = 90
	kAddrAandB = 60

	uarm_status = 0
	pin2_status = 0
	coord = {}
	g_interpol_val_arr = {}
	angle = {}

	attachStaus = 0

	def __init__(self,port):
		
		self.uarm = Arduino(port)
		self.uarmDetach()
		

	def servoAttach(self,servo_number):
		if servo_number == 1:
			self.servo_base = self.uarm.get_pin('d:11:s')
		elif servo_number == 2:
			self.servo_left = self.uarm.get_pin('d:13:s')
		elif servo_number == 3:
			self.servo_right = self.uarm.get_pin('d:12:s')
		elif servo_number == 4:
			self.servo_end = self.uarm.get_pin('d:10:s')
		else:
			return	


	def servoDetach(self,servo_number):
		if servo_number == 1:
			self.uarm.servoDetach(11)
		elif servo_number == 2:
			self.uarm.servoDetach(13)
		elif servo_number == 3:
			self.uarm.servoDetach(12)
		elif servo_number == 4:
			self.uarm.servoDetach(10)
		else:
			return	
	

	def uarmDisconnect(self):
		self.uarm.exit()
	

	def uarmAttach(self):

		curAngles = {}

		if self.uarm_status == 0:
			for n in range(1,5):
				curAngles[n] = self.readAngle(n)
			time.sleep(0.1)
			n = 1
			while n<5:
				self.servoAttach(n)
				n += 1
			time.sleep(0.1)
			self.writeAngle(curAngles[1],curAngles[2],curAngles[3],curAngles[4])
			self.uarm_status = 1
	

	def uarmDetach(self):
		n = 1
		while n<5:
			self.servoDetach(n)
			n += 1
		self.uarm_status = 0


	def angleConstrain(self,Angle):
		if Angle <0:
			return 0
		elif Angle >180:
			return 180
		else:	
			return Angle


	def writeServoAngleRaw(self,servo_number,Angle):
		
		if servo_number == 1:
			self.servo_base.write(self.angleConstrain(round(Angle)))
		elif servo_number == 2:
			self.servo_left.write(self.angleConstrain(round(Angle)))
		elif servo_number == 3:
			
			self.servo_right.write(self.angleConstrain(round(Angle)))
		elif servo_number == 4:
			
			self.servo_end.write(self.angleConstrain(round(Angle)))
		else:
			return

#.........这里部分代码省略.........

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
class HoduinoBoardInterface():
    """
        This is the Arduino Board Interface.
        This class initialize the Board and provides all the methods
        for the interaction with it.
    """
    __metaclass__ = Singleton

    def __init__(self, port):

        try:
            self.board = Arduino(port)
        except OSError as e:
            raise Exception("Arduino not found on: {0}".format(port))
        self._setup()

    def _setup(self):
        # Setup the pins
        self.pin_manager = PinManager(self.board)

        self.motor_pin = self.pin_manager.get_digital_pin_out(9)
        self.pin_manager.set_pin_mode(self.motor_pin, "Servo")

        self.buzzer_pin = self.pin_manager.get_digital_pin_out(3)
        self.pin_manager.set_pin_mode(self.buzzer_pin, "PWM")

    def _spin(self, degrees):
        # spin the weel
        self.motor_pin.write(degrees)
        time.sleep(SLEEP_TIME)

    def _buzzer(self, value):
        self.buzzer_pin.write(value)
        time.sleep(SLEEP_TIME)
        self.buzzer_pin.write(0.0)

    def _melody(self):
        notes = {
            'c': 62, 
            'd': 94, 
            'e': 30, 
            'f': 49, 
            'g': 50, 
            'a': 140, 
            'b': 194, 
            'C': 223
          }

        freqs = ['c', 'g', 'a', 'a', 'f', 'e']

        for f in freqs:
            self.buzzer_pin.write(notes[f]/255.0)
            time.sleep(0.2)

        self.buzzer_pin.write(0.0)

    def donation_reaction(self):
        # buzzer
        # self._melody()

        # spin procedure for donation reaction
        self._spin(90)
        self._spin(150)
        self._spin(30)
        self._spin(150)
        self._spin(30)
        self._spin(90)

    def close_arduino(self):
        self._exit()

    def _exit(self):
        try:
            self.board.exit()
            print "Succesfully exit from arduino board"
        except:
            print "Error while exiting arduino board"

# 需要导入模块: from pyfirmata import Arduino [as 别名]
# 或者: from pyfirmata.Arduino import exit [as 别名]
#           potentiometer -> brightness of led

from pyfirmata import Arduino, util, PWM
from time import sleep
import os

# setup board
port = '/dev/cu.usbmodem1421'
board = Arduino(port)
sleep(5)
#s = board.get_firmata_version()
#print("Firmata version=", s)
it = util.Iterator(board) # iterate over the board
it.start() #start

# setup pin A0 which is connected to potentiometer
# setup pin 3 for LED - PWM
a0 = board.get_pin('a:0:i')
ledPin = board.get_pin('d:3:p') #digital, pin 3, PWM

# main section, interruptable gracefully with Ctrl-c
try:
    # read A0 and set brightness...
    while True:
        p = a0.read() # 0.0 < p < 1.0
        #print(p)  #debugging
        ledPin.write(p)
except KeyboardInterrupt:
    board.exit() #exit board
    os._exit(0) #exit program