Opens a Phidget.

 @param [Integer] serial_number Serial number of the phidget to open, -1 means any.
 @return [Boolean] returns true or raises an error
504498
def open_label_remote(label=nil, server_id=nil, password=nil)
		Phidgets::FFI::Common.openLabelRemote(@handle, label, server_id, password)
	    true
    end
1289730
def open(self):
        
        self._sendCmd(self.REG_PWR_MGMT_1, 0x00)
        self._sendCmd(self.REG_PWR_MGMT_2, 0x00)
1042815
def open(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.open(index=self._name, **kwargs)
954242
def serial(self, may_block=True):
        
        if not self.capabilities.have_serial_number():
            raise yubikey_base.YubiKeyVersionError("Serial number unsupported in YubiKey %s" % self.version() )
        return self._read_serial(may_block)
936796
def open(self, *args, **kwargs):
        
        Telnet.open(self, *args, **kwargs)
        if self.force_ssl:
            self._start_tls()
673494
def opened(self, *args):
        
        self._serial_open = True

        self.log("Opened: ", args, lvl=debug)
        self._send_command(b'l,1')  # Saying hello, shortly
        self.log("Turning off engine, pump and neutralizing rudder")
        self._send_command(b'v')
        self._handle_servo(self._machine_channel, 0)
        self._handle_servo(self._rudder_channel, 127)
        self._set_digital_pin(self._pump_channel, 0)
        # self._send_command(b'h')
        self._send_command(b'l,0')
        self._send_command(b'm,HFOS Control')
831759
def _get_serial_number(self):
        
        return usb.util.get_string(self._device.usb_dev, 64, self._device.usb_dev.iSerialNumber)
881419
def open(self):
        
        self.device = serial.Serial(port=self.devfile, baudrate=self.baudrate, bytesize=self.bytesize, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, timeout=self.timeout, dsrdtr=True)

        if self.device is not None:
            print "Serial printer enabled"
        else:
            print "Unable to open serial printer on: %s" % self.devfile
90292
def open?
      ProcTable.ps.any? { |p| p.comm == path }
    # See https://github.com/djberg96/sys-proctable/issues/44
    rescue ArgumentError
      false
    end
229237
def open(cls, typename):
		
		return cls(opcode=OMAPI_OP_OPEN, message=[(b"type", typename)], tid=-1)
687648
def _open_connection(self):
        """"""
        if (self._mode == PROP_MODE_SERIAL):
            self._serial = serial.Serial(self._serial_device, self._serial_speed)
        elif (self._mode == PROP_MODE_TCP):
            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self._socket.connect((self._ip, self._port))
        elif (self._mode == PROP_MODE_FILE):
            self._file = open(self._file_path, "r")
193829
def run
      begin
        unless self.symbology.nil?
          unless self.options[:ascii]
            Barcodes::Renderer::Pdf.new(Barcodes.create(self.symbology, self.options)).render(self.target)
          else
            Barcodes::Renderer::Ascii.new(Barcodes.create(self.symbology, self.options)).render(self.target)
          end
        end
      rescue Exception => e
        puts e.message
      end
    end
890504
function initSerial(robot, port, callback) {
	serial = new Serial.SerialPort(port, {
		//Defaults for Roomba Open Interface:
		baudrate:115200, dataBits:8,
		parity:'none', stopBits:1,
		flowControl:false
	});
	serial.on('open', function() {
		//Send Start Command:
		serial.write(Buffer([128]));
		setSensorRead(true, robot);
		//Listen to Incoming Data:
		serial.on('data', function(data) {
			//Combine Previous Data:
			if(robot.inputBuffer) {
				robot.inputBuffer = Buffer.concat([robot.inputBuffer,
				data], robot.inputBuffer.length + data.length);
			} else robot.inputBuffer = data;
			//Data Parsing Timer:
			if(robot.inputTimer) clearTimeout(robot.inputTimer);
			robot.inputTimer = setTimeout(function() {
				if(robot.dataParser && robot.inputBuffer && robot.inputBuffer.length >= 80)
				{ robot.dataParser(robot.inputBuffer); robot.inputBuffer = robot.inputTimer = null; }
				if(exports.debug && robot.inputBuffer && robot.inputBuffer.length != 80)
				console.log(chalk.bold.green("Packet Miss ["+robot.inputBuffer.length+"]"));
			}, 5);
		});
		if(callback) callback(robot);
	});
	return serial;
}
1290503
def begin(self):
        
        # Assert CS pin low for a second for PN532 to be ready.
        self._gpio.set_low(self._cs)
        time.sleep(1.0)
        # Call GetFirmwareVersion to sync up with the PN532.  This might not be
        # required but is done in the Arduino library and kept for consistency.
        self.get_firmware_version()
        self._gpio.set_high(self._cs)
828840
def try_open (*args, **kwargs):
    
    try:
        return io.open (*args, **kwargs)
    except IOError as e:
        if e.errno == 2:
            return None
        raise
1053731
def open
			@serial ||= SerialPort.new @port, @rate
			@serial_input = Enumerator.new { |y| loop do
				y.yield @serial.readbyte
			end }
			@connected = true
		end
979894
def serial_number(self, serial_number):
        
        if serial_number is not None and len(serial_number) > 64:
            raise ValueError("Invalid value for `serial_number`, length must be less than or equal to `64`")

        self._serial_number = serial_number