Turn all the output devices on.
438494
def on(self):
        
        for device in self:
            if isinstance(device, (OutputDevice, CompositeOutputDevice)):
                device.on()
199405
void onStart(Device device) {
	  KernelDeviceProfile currentDeviceProfile = deviceProfiles.get(device);
      if (currentDeviceProfile == null) {    	 
         currentDeviceProfile = new KernelDeviceProfile(this, kernelClass, device);
         KernelDeviceProfile existingProfile = deviceProfiles.putIfAbsent(device, currentDeviceProfile);
         if (existingProfile != null) {
        	 currentDeviceProfile = existingProfile;
         }
      }
      
      currentDeviceProfile.onEvent(ProfilingEvent.START);
      currentDevice.set(device);
   }
557781
public void activateOptions() {
    if (!isActive()) {
      setActive(true);
      if (advertiseViaMulticastDNS) {
        zeroConf = new ZeroConfSupport(ZONE, port, getName());
        zeroConf.advertise();
      }

      fireConnector(false);
    }
  }
636580
def startAll(self):
		
		self.logger.info("Starting all workers...")

		for worker in self.getWorkers():
			process = self.getWorker(worker)
			self.logger.debug("Starting {0}".format(process.name))
			process.start()

		self.logger.info("Started all workers")
827886
def start(self):
        """"""
        self._websocket = AIOWSClient(loop=self._loop,
                                      session=self._session,
                                      url=self._ws_url,
                                      async_callback=self._async_ws_handler)
        self._websocket.start()
1096559
def start(bt_device=''):
        '''
        
        '''
        # import ptyprocess here so as long as all implementations are in the same file, all will work
        import ptyprocess

        if not bt_device:
            bt_device = 'hci0'

        log.info('Start receiving broadcasts (device %s)', bt_device)
        DEVNULL = subprocess.DEVNULL if sys.version_info >= (3, 3) else open(os.devnull, 'wb')

        subprocess.call('sudo hciconfig %s reset' % bt_device, shell=True, stdout=DEVNULL)
        hcitool = subprocess.Popen(['sudo', '-n', 'hcitool', 'lescan', '--duplicates'], stdout=DEVNULL)
        hcidump = ptyprocess.PtyProcess.spawn(['sudo', '-n', 'hcidump', '--raw'])
        return (hcitool, hcidump)
848743
def setup(self):
        
        self.devices = self.system.devman.devices
        self.ndevice = len(self.devices)

        self.gcalls = [''] * self.ndevice
        self.fcalls = [''] * self.ndevice
        self.gycalls = [''] * self.ndevice
        self.fxcalls = [''] * self.ndevice
        self.jac0s = [''] * self.ndevice

        self.build_vec()
        self.build_strings()
        self._compile_newton()
        self._compile_fdpf()
        self._compile_pfload()
        self._compile_pfgen()
        self._compile_seriesflow()
        self._compile_int()
        self._compile_int_f()
        self._compile_int_g()
        self._compile_bus_injection()
957712
private function _power()
    {
        if (isset($this->_buf['Power'])) foreach ($this->_buf['Power'] as $name=>$value) {
            $dev = new SensorDevice();
            $dev->setName($name);
            $dev->setValue($value);
            $this->mbinfo->setMbPower($dev);
        }
    }
36013
def devices(self):
        """"""
        return [StartActionItem(
            self.start_action,
            i,
            self.state,
            self.path,
            self.raw) for i in range(
                len(self.raw[ROOT_START_ACTION]))]
901880
async def start(self):
        """"""

        self._command_task.start()

        try:
            await self._cleanup_old_connections()
        except Exception:
            await self.stop()
            raise

        #FIXME: This is a temporary hack, get the actual device we are serving.
        iotile_id = next(iter(self.adapter.devices))
        self.device = self.adapter.devices[iotile_id]

        self._logger.info("Serving device 0x%04X over BLED112", iotile_id)
        await self._update_advertisement()

        self.setup_client(self.CLIENT_ID, scan=False, broadcast=True)
1347081
public void start() {
        Thread thread = new Thread(new LogCatCommandExecutor());
        thread.setName(getClass().getSimpleName() + " logcat for " + device.getSerialNumber());
        thread.start();

        try {
            sleep(500); // ignore old output that logcat feeds us
        } catch (InterruptedException e) {
        }

        logListenerCommandShell.activate();
    }
228794
def run(self):
        """"""
        self.signal_init()
        self.listen_init()
        self.logger.info('starting')
        self.loop.start()
434225
def setup(self):
        
        [c.start() for c in self.controllers]
        [c.wait_to_start() for c in self.controllers]
253887
def start(self, plugins):
        """"""
        self.nvim.run_loop(self._on_request,
                           self._on_notification,
                           lambda: self._load(plugins),
                           err_cb=self._on_async_err)
40220
def start(self):
        
        print("Entering monitoring mode, press CTRL-C to quit")
        serial = self._connection.serial

        while True:
            serial.write(b"@R")
            length = int(serial.read(), 16)
            data = serial.read(length * 2)
            message = messages.parse(data)
            if not (self._options.filter and
                    message.entity and
                    message.entity in self._devices):
                logging.debug(" ".join(message.bytes))
            if not self._options.config or \
               message.entity is None or \
               message.entity in self._devices:
                continue

            print("New device found")
            ha_id = input("Enter home assistant unique ID: ")
            name = input("Enter name: ")
            self._add_device(scs_id=message.entity, ha_id=ha_id, name=name)
356806
def start_all(self):
        """"""
        for alias, service in self._service_objects.items():
            if not service.is_alive:
                with expects.expect_no_raises(
                        'Failed to start service "%s".' % alias):
                    service.start()
81691
def refresh_devices(self):
        ''''''
        try:
            response = self.api.get("/api/v2/devices", {'properties':'all'})
            for device_data in response['DeviceList']:
                self.devices.append(Device(device_data, self))
        except APIError as e:
            print("API error: ")
            for key,value in e.data.iteritems:
                print(str(key) + ": " + str(value))