code: def start(self, channel=None):
          
  
          super(ReferenceDevice, self).start(channel)
  
          try:
              self.controller.start(channel)
  
              # Guarantee an initialization order so that our trace files are deterministic
              for address, tile in sorted(self._tiles.items()):
                  if address == 8:
                      continue
  
                  if not isinstance(tile, EmulatedPeripheralTile):
                      raise DataError("An emulated ReferenceDevice can only have a single controller and all other tiles must inherit from EmulatedPeripheralTile",
                                      address=address)
  
                  tile.start(channel)
  
              async def _launch_tiles():
                  await self.controller.reset()
                  await asyncio.wait_for(self.controller.initialized.wait(), 2.0)
  
                  # Note that we do not explicitly reset the tiles.
                  # The controller resets all tiles in its reset method.
                  for address, tile in sorted(self._tiles.items()):
                      if address == 8:
                          continue
  
                      await asyncio.wait_for(tile.initialized.wait(), 2.0)
  
              self.emulator.run_task_external(_launch_tiles())
  
              if self._simulating_time:
                  self.emulator.add_task(None, self._time_ticker())
          except:
              self.stop()
              raise
docs: Start this emulated device.
  
          This triggers the controller to call start on all peripheral tiles in
          the device to make sure they start after the controller does and then
          it waits on each one to make sure they have finished initializing
          before returning.
  
          Args:
              channel (IOTilePushChannel): the channel with a stream and trace
                  routine for streaming and tracing data through a VirtualInterface