docs: def connect(self, devicelist, calibration=True):
          """Establish a connection to one or more SK8 devices.
  
          Given a list of 1 or more :class:`ScanResult` objects, this method will attempt
          to create a connection to each SK8 in sequence. It will return when
          all connections have been attempted, although they may not all have succeeded. In
          addition, the dongle has a limit on simultaneous connections, which you can
          retrieve by calling :meth:`get_supported_connections`. If the number of 
          supplied device names exceeds this value then the method will abort 
          immediately. 
  
          Args:
              devicelist (list): a list of :class:`ScanResult` instances, one for each
                  SK8 you wish to create a connection to. 
              calibration (bool): True if calibration data should be loaded post-connection,
                  for each device (if available).
  
          Returns:
              tuple (`result`, `devices`), where `result` is a bool indicating if 
              connections were successfully made to all given devices. If True, 
              `devices` will contain a list of :class:`SK8` instances representing
              the connected SK8 devices. If False, `devices` will contain a smaller
              number of :class:`SK8` instances depending on the number of connections
              that succeeded (possibly 0). 
          """
          if not isinstance(devicelist, list):
              devicelist = [devicelist]
  
          logger.debug('Connecting to {} devices'.format(len(devicelist)))
          if len(devicelist) > self.supported_connections:
              logging.error('Dongle firmware supports max {} connections, {} device connections requested!'.format(self.supported_connections, len(devicelist)))
              return (False, [])
  
          # TODO check number of active connections and fail if exceeds max
  
          connected_devices = []
          all_connected = True
          for dev in devicelist:
              logger.info('Connecting to {} (name={})...'.format(dev.addr, dev.name))
              self._set_state(self._STATE_CONNECTING)
              self.api.ble_cmd_gap_connect_direct(dev.raw_addr, 0, 6, 14, 100, 50)
              self._wait_for_state(self._STATE_CONNECTING, 5)
  
              if self.state != self._STATE_CONNECTED:
                  logger.warn('Connection failed!')
                  # send end procedure to cancel connection attempt
                  self._set_state(self._STATE_GAP_END)
                  self.api.ble_cmd_gap_end_procedure()
                  self._wait_for_state(self._STATE_GAP_END)
                  all_connected = False
                  continue
  
              conn_handle = self.conn_handles[-1]
              logger.info('Connection OK, handle is 0x{:02X}'.format(conn_handle))
              sk8 = SK8(self, conn_handle, dev, calibration)
              self._add_device(sk8)
              connected_devices.append(sk8)
              sk8._discover_services()
  
              time.sleep(0.1) # TODO
          return (all_connected, connected_devices)