docs: async def request(self, command, payload, retry=3):
          """Request data."""
          # pylint: disable=too-many-return-statements
  
          if self._token is None:
              _LOGGER.error("No token")
              return None
  
          _LOGGER.debug(command, payload)
  
          nonce = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(16))
          url = API_ENDPOINT_2 + command
          timestamp = int(time.time())
          signature = hashlib.sha1(str(REQUEST_TIMEOUT
                                       + str(timestamp)
                                       + nonce
                                       + self._token).encode("utf-8")).hexdigest()
  
          headers = {
              "Content-Type": "application/x-zc-object",
              "Connection": "Keep-Alive",
              "X-Zc-Major-Domain": "seanywell",
              "X-Zc-Msg-Name": "millService",
              "X-Zc-Sub-Domain": "milltype",
              "X-Zc-Seq-Id": "1",
              "X-Zc-Version": "1",
              "X-Zc-Timestamp": str(timestamp),
              "X-Zc-Timeout": REQUEST_TIMEOUT,
              "X-Zc-Nonce": nonce,
              "X-Zc-User-Id": str(self._user_id),
              "X-Zc-User-Signature": signature,
              "X-Zc-Content-Length": str(len(payload)),
          }
          try:
              with async_timeout.timeout(self._timeout):
                  resp = await self.websession.post(url,
                                                    data=json.dumps(payload),
                                                    headers=headers)
          except asyncio.TimeoutError:
              if retry < 1:
                  _LOGGER.error("Timed out sending command to Mill: %s", command)
                  return None
              return await self.request(command, payload, retry - 1)
          except aiohttp.ClientError:
              _LOGGER.error("Error sending command to Mill: %s", command, exc_info=True)
              return None
  
          result = await resp.text()
  
          _LOGGER.debug(result)
  
          if not result or result == '{"errorCode":0}':
              return None
  
          if 'access token expire' in result or 'invalid signature' in result:
              if retry < 1:
                  return None
              if not await self.connect():
                  return None
              return await self.request(command, payload, retry - 1)
  
          if '"error":"device offline"' in result:
              if retry < 1:
                  _LOGGER.error("Failed to send request, %s", result)
                  return None
              _LOGGER.debug("Failed to send request, %s. Retrying...", result)
              await asyncio.sleep(3)
              return await self.request(command, payload, retry - 1)
  
          if 'errorCode' in result:
              _LOGGER.error("Failed to send request, %s", result)
              return None
          data = json.loads(result)
          return data