docs: def start_search(self):
          """
          Start the Gateway Search Request and return the address information
  
          :rtype: (string,int)
          :return: a tuple(string(IP),int(Port) when found or None when
              timeout occurs
          """
  
          self._asyncio_loop = asyncio.get_event_loop()
  
          # Creating Broadcast Receiver
          coroutine_listen = self._asyncio_loop.create_datagram_endpoint(
              lambda: self.KNXSearchBroadcastReceiverProtocol(
                  self._process_response,
                  self._timeout_handling,
                  self._timeout,
                  self._asyncio_loop
              ), local_addr=(self._broadcast_ip_address, 0)
          )
          self._listener_transport, listener_protocol = \
              self._asyncio_loop.run_until_complete(coroutine_listen)
  
          # We are ready to fire the broadcast message
          coroutine_broadcaster = self._asyncio_loop.create_datagram_endpoint(
              lambda: self.KNXSearchBroadcastProtocol(
                  self._asyncio_loop,
                  self._listener_transport.get_extra_info('sockname')
                  [1]),
              remote_addr=(self._broadcast_address, self._broadcast_port))
  
          self._broadcaster_transport, broadcast_protocol = \
              self._asyncio_loop.run_until_complete(coroutine_broadcaster)
          # Waiting for all Broadcast receive or timeout
          self._asyncio_loop.run_forever()
  
          # Got Response or Timeout
          if self._resolved_gateway_ip_address is None and \
             self._resolved_gateway_ip_port is None:
              LOGGER.debug("Gateway not found!")
              return None
          else:
              LOGGER.debug("Gateway found at %s:%s",
                           self._resolved_gateway_ip_address,
                           self._resolved_gateway_ip_port)
  
              return self._resolved_gateway_ip_address, \
                  self._resolved_gateway_ip_port