C++ (Cpp) mxt_get_msg_bytes Examples

Example #1

File: bridge.c Project: sub77-bkp/mxt-app

//******************************************************************************
/// \brief Read MXT messages and send them to other end
/// \return #mxt_rc
static int handle_messages(struct mxt_device *mxt, struct bridge_context *bridge_ctx)
{
  int msg_count, length;
  int ret;
  int i, j;

  unsigned char databuf[20];

  if (!bridge_ctx->msgs_enabled)
    return MXT_SUCCESS;

  ret = mxt_get_msg_count(mxt, &msg_count);
  if (ret)
    return ret;

  for (i = 0; i < msg_count; i++) {
    int num_bytes;
    ret = mxt_get_msg_bytes(mxt, databuf, sizeof(databuf), &num_bytes);
    if (ret == MXT_ERROR_NO_MESSAGE)
      continue;
    else if (ret)
      return ret;

    length = snprintf(mxt->msg_string, sizeof(mxt->msg_string),
                      MXT_ADB_CLIENT_MSG_PREFIX);

    for (j = 0; j < num_bytes; j++) {
      length += snprintf(mxt->msg_string + length,
                         sizeof(mxt->msg_string) - length,
                         "%02X", databuf[j]);
    }

    ret = write(bridge_ctx->sockfd, mxt->msg_string, strlen(mxt->msg_string));
    if (ret < 0) {
      mxt_err(mxt->ctx, "Write failure: %s (%d)", strerror(errno), errno);
      return mxt_errno_to_rc(ret);
    }

    ret = write(bridge_ctx->sockfd, "\n", 1);
    if (ret < 0) {
      mxt_err(mxt->ctx, "Write failure: %s (%d)", strerror(errno), errno);
      return mxt_errno_to_rc(ret);
    }
  }

  return MXT_SUCCESS;
}

Example #2

File: self_test.c Project: prajoshpremdas/obp-utils

//******************************************************************************
/// \brief Handle messages from the self test object
/// \return #mxt_rc
static int self_test_handle_messages(struct mxt_device *mxt)
{
   bool done = false;
   int count, i;
   time_t now;
   time_t start_time = time(NULL);
   static const uint8_t TIMEOUT = 10; // seconds
   uint8_t buf[10];
   int len;
   unsigned int object_type;
   int ret;

   while (!done)
   {
      mxt_msg_wait(mxt, 100);

      now = time(NULL);
      if ((now - start_time) > TIMEOUT)
      {
         mxt_err(mxt->ctx, "Timeout");
         return MXT_ERROR_TIMEOUT;
      }

      ret = mxt_get_msg_count(mxt, &count);
      if (ret)
        return ret;

      if (count > 0)
      {
         for (i = 0; i < count; i++)
         {
            ret = mxt_get_msg_bytes(mxt, buf, sizeof(buf), &len);
            if (ret)
              return ret;

            if (len > 0)
            {
               object_type = mxt_report_id_to_type(mxt, buf[0]);

               mxt_verb(mxt->ctx, "Received message from T%u", object_type);
               
               if (object_type == SPT_SELFTEST_T25)
               {
                  switch (buf[1])
                  {
                  case SELF_TEST_ALL:
                     mxt_info(mxt->ctx, "PASS: All tests passed");
                     ret = MXT_SUCCESS;
                     break;
                  case SELF_TEST_INVALID:
                     mxt_err(mxt->ctx, "FAIL: Invalid test command");
                     ret = MXT_ERROR_NOT_SUPPORTED;
                     break;
                  case SELF_TEST_TIMEOUT:
                     mxt_err(mxt->ctx, "FAIL: Test timeout");
                     ret = MXT_ERROR_TIMEOUT;
                     break;
                  case SELF_TEST_ANALOG:
                     mxt_err(mxt->ctx, "FAIL: AVdd Analog power is not present");
                     ret = MXT_ERROR_SELF_TEST_ANALOG;
                     break;
                  case SELF_TEST_PIN_FAULT:
                     mxt_err(mxt->ctx, "FAIL: Pin fault");
                     ret = MXT_ERROR_SELF_TEST_PIN_FAULT;
                     break;
                  case SELF_TEST_PIN_FAULT_2:
                     mxt_err(mxt->ctx, "FAIL: Pin fault 2");
                     ret = MXT_ERROR_SELF_TEST_PIN_FAULT;
                     break;
                  case SELF_TEST_AND_GATE:
                     mxt_err(mxt->ctx, "FAIL: AND Gate Fault");
                     ret = MXT_ERROR_SELF_TEST_AND_GATE;
                     break;
                  case SELF_TEST_SIGNAL_LIMIT:
                     mxt_err(mxt->ctx, "FAIL: Signal limit fault");
                     ret = MXT_ERROR_SELF_TEST_SIGNAL_LIMIT;
                     break;
                  case SELF_TEST_GAIN:
                     mxt_err(mxt->ctx, "FAIL: Gain error");
                     ret = MXT_ERROR_SELF_TEST_GAIN;
                     break;
                  default:
                     mxt_err(mxt->ctx, "Unrecognised status %02X", buf[1]);
                     ret = MXT_ERROR_UNEXPECTED_DEVICE_STATE;
                     break;
                  }

                  done = true;
               }
            }
         }
      }
   }

   return ret;
}