diff --git a/CMakeLists.txt b/CMakeLists.txt index d8ef04736..76af0b8c4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12.1) +CMAKE_MINIMUM_REQUIRED(VERSION 3.5) SET(PROJECT_VER_MAJOR 0) SET(PROJECT_VER_MINOR 2) @@ -133,6 +133,7 @@ SET(SOURCES include/internal/libfreenect2/rgb_packet_stream_parser.h include/internal/libfreenect2/threading.h + src/status_codes.cpp src/transfer_pool.cpp src/event_loop.cpp src/usb_control.cpp diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index 8741f67fd..bd79025b1 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -1,4 +1,4 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12.1) +CMAKE_MINIMUM_REQUIRED(VERSION 3.5) if(WIN32 AND NOT MINGW) if(NOT DEFINED CMAKE_DEBUG_POSTFIX) diff --git a/include/internal/libfreenect2/protocol/command_transaction.h b/include/internal/libfreenect2/protocol/command_transaction.h old mode 100644 new mode 100755 index 9865442ce..59e31f894 --- a/include/internal/libfreenect2/protocol/command_transaction.h +++ b/include/internal/libfreenect2/protocol/command_transaction.h @@ -30,6 +30,7 @@ #include #include #include +#include namespace libfreenect2 { @@ -48,10 +49,12 @@ class CommandTransaction ~CommandTransaction(); bool execute(const CommandBase& command, Result& result); + + SensorStatusCode getCommandStatus(); private: libusb_device_handle *handle_; int inbound_endpoint_, outbound_endpoint_, timeout_; - Result response_complete_result_; + ResponseFooter response_complete_result_; bool send(const CommandBase& command); diff --git a/include/internal/libfreenect2/protocol/response.h b/include/internal/libfreenect2/protocol/response.h index b83c8e2f5..4f6874ec2 100644 --- a/include/internal/libfreenect2/protocol/response.h +++ b/include/internal/libfreenect2/protocol/response.h @@ -34,12 +34,22 @@ #include #include #include +#include namespace libfreenect2 { namespace protocol { +// Original struct name: NUISENSOR_USB_PACKET_RESPONSE +LIBFREENECT2_PACK(struct ResponseFooter +{ + uint32_t PacketType; // Magic number: 0x0A6FE000 + uint32_t TransactionId; + SensorStatusCode Status; + uint32_t Reserved; +}); + class SerialNumberResponse { private: @@ -328,7 +338,7 @@ LIBFREENECT2_PACK(struct P0TablesResponse LIBFREENECT2_PACK(struct ColorSettingResponse { uint32_t NumStatus; - uint32_t CommandListStatus; + uint32_t CommandListStatus; // value from SensorStatusCode // Result of the first command -- we only send one at a time for now. // Equivalent of a fixed-length array of NUISENSOR_RGB_CHANGE_STREAM_SETTING_REPLY_STATUS in NuiSensorLib.h uint32_t Status; diff --git a/include/libfreenect2/status_codes.h b/include/libfreenect2/status_codes.h new file mode 100644 index 000000000..e3eab4886 --- /dev/null +++ b/include/libfreenect2/status_codes.h @@ -0,0 +1,291 @@ +/* + * This file is part of the OpenKinect Project. http://www.openkinect.org + * + * Copyright (c) 2026 individual OpenKinect contributors. See the CONTRIB file + * for details. + * + * This code is licensed to you under the terms of the Apache License, version + * 2.0, or, at your option, the terms of the GNU General Public License, + * version 2.0. See the APACHE20 and GPL2 files for the text of the licenses, + * or the following URLs: + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/gpl-2.0.txt + * + * If you redistribute this file in source form, modified or unmodified, you + * may: + * 1) Leave this header intact and distribute it under the same terms, + * accompanying it with the APACHE20 and GPL20 files, or + * 2) Delete the Apache 2.0 clause and accompany it with the GPL2 file, or + * 3) Delete the GPL v2 clause and accompany it with the APACHE20 file + * In all cases you must keep the copyright notice intact and include a copy + * of the CONTRIB file. + * + * Binary distributions must follow the binary distribution requirements of + * either License. + */ + +#ifndef STATUS_CODES_H_ +#define STATUS_CODES_H_ + +namespace libfreenect2 +{ + +// The following information was found by using the library released by Microsoft under MIT license, +// https://github.com/Microsoft/MixedRealityCompanionKit/tree/master/KinectIPD/NuiSensor +// Debugging the library assembly shows the original enum name was _PETRA_STATUS. +// +// Note: There may be other status codes returned by the sensor than these, +// and some of these may never be returned by the sensor. +enum SensorStatusCode { + STATUS_CODE_SUCCESS = 0, + STATUS_CODE_UNKNOWN_COMMAND = 1, + STATUS_CODE_INVALID_PARAMETER = 3, + STATUS_CODE_UART_RX_OVERFLOW = 4, + STATUS_CODE_BAD_COMMAND_HANDLER = 5, + STATUS_CODE_ABORT = 6, + STATUS_CODE_COMMAND_BUSY = 7, + STATUS_CODE_NOT_IMPLEMENTED = 8, + STATUS_CODE_OUT_OF_MEMORY = 9, + STATUS_CODE_BIST_NOT_SUPPORTED = 10, + STATUS_CODE_NO_MORE_DATA = 11, + STATUS_CODE_ACCESS_DENIED = 12, + STATUS_CODE_PARAM_BAD_TAG = 13, + STATUS_CODE_PARAM_BAD_VALUE = 14, + STATUS_CODE_DATA_TRUNCATED = 15, + STATUS_CODE_IO_PENDING = 16, + STATUS_CODE_DATA_TOO_BIG = 17, + STATUS_CODE_INVALID_PAYLOAD_SIZE = 18, + STATUS_CODE_INVALID_COMMAND_PACKET = 19, + STATUS_CODE_UNEXPECTED_DATA_PHASE = 20, + STATUS_CODE_DATA_PHASE_ERROR = 21, + STATUS_CODE_FAILED = 99, + STATUS_CODE_I2C_NO_RESOURCES = 100, + STATUS_CODE_I2C_INVALID_HANDLE = 101, + STATUS_CODE_I2C_DEVICE_NOT_SUPPORTED = 102, + STATUS_CODE_I2C_PENDING = 103, + STATUS_CODE_I2C_IDLE_TIMEOUT = 104, + STATUS_CODE_I2C_READ_TIMEOUT = 105, + STATUS_CODE_I2C_WRITE_TIMEOUT = 106, + STATUS_CODE_I2C_STOP_TIMEOUT = 107, + STATUS_CODE_I2C_TX_ABORT = 108, + STATUS_CODE_I2C_RX_ABORT = 109, + STATUS_CODE_NAND_RESET_ERROR = 300, + STATUS_CODE_NAND_NOT_READY = 301, + STATUS_CODE_NAND_READ_ID_FAILED = 302, + STATUS_CODE_NAND_ERASE_FAILED = 303, + STATUS_CODE_NAND_ECC_CALC_TIMEOUT = 304, + STATUS_CODE_NAND_ECC_CORRECTION_ERROR = 305, + STATUS_CODE_NAND_PAGE_PROGRAM_FAILED = 306, + STATUS_CODE_NAND_NOT_INITIALIZED = 307, + STATUS_CODE_NAND_ADDR_OUT_OF_RANGE = 308, + STATUS_CODE_NAND_BBT_BAD_MAGIC = 309, + STATUS_CODE_NAND_TOO_MANY_BAD_BLOCKS = 310, + STATUS_CODE_NAND_BAD_BLOCK_FOUND = 311, + STATUS_CODE_DDR_TRAINING_NO_VALID_VALUE = 350, + STATUS_CODE_MUTEX_OUT_OF_MEMORY = 400, + STATUS_CODE_MUTEX_NOT_ACQUIRED = 401, + STATUS_CODE_MUTEX_NOT_RELEASED = 402, + STATUS_CODE_NOR_OPERATION_TIMEOUT = 500, + STATUS_CODE_NOR_FLASH_NOT_IDENTIFIED = 501, + STATUS_CODE_NOR_NOT_INITIALIZED = 502, + STATUS_CODE_NOR_WRITE_ERROR = 503, + STATUS_CODE_NOR_OUT_OF_MEMORY = 504, + STATUS_CODE_NOR_BUSY = 505, + STATUS_CODE_NOR_PURGE_FIFO_TIMEOUT = 506, + STATUS_CODE_NOR_SET_MODE_TIMEOUT = 507, + STATUS_CODE_NOR_READ_FIFO_TIMEOUT = 508, + STATUS_CODE_NOR_READ_STATUS_ERROR = 509, + STATUS_CODE_NOR_WAIT_SEQ_DONE_TIMEOUT = 510, + STATUS_CODE_NOR_FLASH_NOT_READY = 511, + STATUS_CODE_NOR_BAD_DEVICE_ID = 512, + STATUS_CODE_NOR_ERASE_TIMEOUT = 513, + STATUS_CODE_NOR_READ_DATA_LOSS = 514, + STATUS_CODE_NOR_WRITE_STATUS_ERROR = 515, + STATUS_CODE_NOR_READ_TIMEOUT = 516, + STATUS_CODE_NOR_WRITE_TIMEOUT = 517, + STATUS_CODE_NOR_SET_STATUS_TIMEOUT = 518, + STATUS_CODE_SSP_TX_FIFO_OVERFLOW = 600, + STATUS_CODE_SSP_RX_TIMEOUT = 601, + STATUS_CODE_SSP_TRANSFER_COMPLETE_TIMEOUT = 602, + STATUS_CODE_FPGA_BAD_MAGIC_HEADER = 650, + STATUS_CODE_FPGA_FLASH_DATA_MISMATCH = 651, + STATUS_CODE_GZIP_UNEXPECTED_EOF = 652, + STATUS_CODE_GZIP_MORE_DATA = 653, + STATUS_CODE_GZIP_CRC_ERROR = 654, + STATUS_CODE_PMC_ERROR = 700, + STATUS_CODE_PMC_BUSY = 701, + STATUS_CODE_PMC_DATA_MISMATCH = 702, + STATUS_CODE_PMC_TIMEOUT = 703, + STATUS_CODE_PMC_COMMAND_EXECUTING = 704, + STATUS_CODE_PMC_COMMAND_ABORTED = 705, + STATUS_CODE_PMC_CANNOT_UPDATE = 706, + STATUS_CODE_IR_SEQ_VERIFICATION_FAILED = 800, + STATUS_CODE_IR_FIFO_OVERRUN = 801, + STATUS_CODE_IR_D02_WRITE_ERROR = 802, + STATUS_CODE_IR_CAPTURE_FAILED = 803, + STATUS_CODE_IR_POWERED_DOWN = 804, + STATUS_CODE_IR_OSC_ERROR = 805, + STATUS_CODE_IR_ACCESS_ERROR = 806, + STATUS_CODE_FW_UPDATE_CRC_ERROR = 900, + STATUS_CODE_FW_UPDATE_INVALID_SIZE = 901, + STATUS_CODE_FW_UPDATE_INVALID_STATE = 902, + STATUS_CODE_FW_UPDATE_BAD_TAG = 903, + STATUS_CODE_FW_UPDATE_BAD_IMAGE = 904, + STATUS_CODE_FW_UPDATE_IMAGE_TOO_BIG = 905, + STATUS_CODE_FW_UPDATE_VERIFY_FAILED = 906, + STATUS_CODE_FW_UPDATE_ABORTED = 907, + STATUS_CODE_FW_UPDATE_BAD_PLATFORM = 908, + STATUS_CODE_FW_UPDATE_BLOCKED = 909, + STATUS_CODE_FW_UPDATE_SIGNATURE_FAULT = 910, + STATUS_CODE_CAL_OPEN_FAILED = 1000, + STATUS_CODE_CAL_CREATE_CONFIG_FAILED = 1001, + STATUS_CODE_CAL_SET_CUR_CONFIG_FAILED = 1002, + STATUS_CODE_CAL_SET_D02_FAILED = 1003, + STATUS_CODE_CAL_START_STREAM_FAILED = 1004, + STATUS_CODE_CAL_DMA_ALLOC_NO_MEMORY = 1005, + STATUS_CODE_CAL_JPEG_SETTING_FAILED = 1006, + STATUS_CODE_CAL_GET_RGB_FRAME_FAILED = 1007, + STATUS_CODE_CAL_STATE_NOT_IDLE = 1008, + STATUS_CODE_CAL_OS_REGISTER_FAILED = 1009, + STATUS_CODE_CAL_UNEXPECTED_STATE = 1010, + STATUS_CODE_CAL_FRAME_BUFFER_TOO_SMALL = 1011, + STATUS_CODE_CAL_USB_TX_OPEN_FAILED = 1012, + STATUS_CODE_CAL_USB_NO_FREE_REQ_BUFFER = 1013, + STATUS_CODE_CAL_USB_NOT_INITIALIZED = 1014, + STATUS_CODE_CAL_USB_WRITE_FAILED = 1015, + STATUS_CODE_CAL_DEVICE_NOT_READY = 1016, + STATUS_CODE_CAL_DMA_MOVE_TIMEOUT = 1017, + STATUS_CODE_CAL_CAL_ERROR_NONE = 1018, + STATUS_CODE_CAL_CAL_ERROR_UNKNOWN = 1019, + STATUS_CODE_CAL_CAL_ERROR_NOT_IMPL = 1020, + STATUS_CODE_CAL_CAL_ERROR_TIMEOUT = 1021, + STATUS_CODE_CAL_CAL_ERROR_CTRL_IFACE = 1022, + STATUS_CODE_CAL_CAL_ERROR_SENSOR_IFACE = 1023, + STATUS_CODE_CAL_CAL_ERROR_OUTPUT_IFACE = 1024, + STATUS_CODE_CAL_CAL_ERROR_MEMORY = 1025, + STATUS_CODE_CAL_CAL_ERROR_COMPRESSION = 1026, + STATUS_CODE_CAL_CAL_ERROR_ZOOM = 1027, + STATUS_CODE_CAL_CAL_ERROR_SYNC = 1028, + STATUS_CODE_CAL_CAL_ERROR_INVALID_PARAM = 1029, + STATUS_CODE_CAL_CAL_ERROR_INVALID_CMD = 1030, + STATUS_CODE_CAL_CAL_ERROR_CONFIG = 1031, + STATUS_CODE_CAL_CAL_ERROR_CONFIG_NOT_SUPPORTED = 1032, + STATUS_CODE_CAL_CAL_ERROR_CONFIG_NOT_EXIST = 1033, + STATUS_CODE_CAL_CAL_ERROR_CONFIG_ALREADY_EXIST = 1034, + STATUS_CODE_CAL_CAL_ERROR_CONFIG_INDEX_OUT_OF_RANGE = 1035, + STATUS_CODE_CAL_USB_MDLS_BACKED_UP = 1036, + STATUS_CODE_CAL_DMA_OVERRUN = 1037, + STATUS_CODE_VSYNC_STREAM_NOT_STARTED = 1100, + STATUS_CODE_VSYNC_PARAM_BAD_VALUE = 1105, + STATUS_CODE_VSYNC_RGB_SLAVE_MODE_FAILED = 1110, + STATUS_CODE_ADC_INVALID_CHANNEL = 1200, + STATUS_CODE_ADC_INCORRECT_CHANNEL = 1201, + STATUS_CODE_ADC_TIMEOUT = 1202, + STATUS_CODE_ADC_UNKNOWN_DEVICE = 1203, + STATUS_CODE_ADC_UNSUPPORTED_DEVICE = 1204, + STATUS_CODE_ADC_UNSUPPORTED_SIGNAL = 1205, + STATUS_CODE_ADC_INVALID_INPUT = 1206, + STATUS_CODE_ADC_DATA_NOT_AVAILABLE = 1207, + STATUS_CODE_JNFU_ERROR = 1300, + STATUS_CODE_JNFU_NOR_WRITE_FAILED = 1305, + STATUS_CODE_JNFU_NOR_READ_FAILED = 1310, + STATUS_CODE_JNFU_NOR_VERIFY_FAILED = 1315, + STATUS_CODE_JNFU_MEM_ALLOC_FAILED = 1320, + STATUS_CODE_JNFU_BAD_CONFIG_DATA = 1325, + STATUS_CODE_POWER_STATE_CHANGE_FAILED = 1400, + STATUS_CODE_POWER_PG_TIMEOUT = 1401, + STATUS_CODE_POWER_SHUTDOWN_TIMEOUT = 1402, + STATUS_CODE_POWER_1V6_TIMEOUT = 1403, + STATUS_CODE_POWER_INVALID_STATE = 1404, + STATUS_CODE_LDD_UNKNOWN_REGISTER = 1500, + STATUS_CODE_LDD_NV_SIZE_MISMATCH = 1501, + STATUS_CODE_LDD_FAULT = 1502, + STATUS_CODE_LDD_WRITE_VERIFY_FAIL = 1503, + STATUS_CODE_USB_CORE_REVISION_MISMATCH = 1600, + STATUS_CODE_USB_DEVICE_NOT_INT = 1601, + STATUS_CODE_USB_DEVICE_INIT = 1602, + STATUS_CODE_USB_DEVICE_RESET_TIMEOUT = 1603, + STATUS_CODE_USB_DEVICE_NOT_CONFIGURED = 1604, + STATUS_CODE_USB_DEVICE_SUSPENDED = 1605, + STATUS_CODE_USB_INVALID_DESCRIPTOR = 1606, + STATUS_CODE_USB_DISCONNECTED = 1607, + STATUS_CODE_USB_DEVICE_ACTIVE = 1608, + STATUS_CODE_USB_RE_CONFIG_STACK = 1609, + STATUS_CODE_USB_STACK_CONFIGED = 1610, + STATUS_CODE_USB_SETPHY_FAILED = 1611, + STATUS_CODE_USB_BUF_ALLOC_FAILED = 1612, + STATUS_CODE_USB_INVALID_CALLBACK = 1613, + STATUS_CODE_USB_STACK_UNCONFIG = 1614, + STATUS_CODE_USB_EP_ACTIVE = 1615, + STATUS_CODE_USB_EP_NOT_ACTIVE = 1616, + STATUS_CODE_USB_INTERFACE_NO_EP = 1617, + STATUS_CODE_USB_EP_STALL = 1618, + STATUS_CODE_USB_BUF_FULL = 1619, + STATUS_CODE_USB_BUF_EMPTY = 1620, + STATUS_CODE_USB_REQUEST_SCHEDULED = 1621, + STATUS_CODE_USB_EP_INVALID_REQUEST = 1622, + STATUS_CODE_USB_EP_MISSED_ISOC = 1623, + STATUS_CODE_USB_EP_NOFFN_ISOC = 1624, + STATUS_CODE_USB_NULL_POINTER = 1625, + STATUS_CODE_USB_INVALID_HANDLE = 1626, + STATUS_CODE_USB_INVALID_REQUEST = 1627, + STATUS_CODE_USB_EP_PIPE_NOTOPEN = 1628, + STATUS_CODE_USB_END_TRANSFER = 1629, + STATUS_CODE_USB_EP_WRITE_FAILED = 1630, + STATUS_CODE_USB_EVT_BUFFER_OVERFLOW = 1631, + STATUS_CODE_USB_ERRATIC_ERROR = 1632, + STATUS_CODE_USB_SUSPEND = 1633, + STATUS_CODE_USB_REMOTE_WAKEUP = 1634, + STATUS_CODE_USB_EP_RESETPIPE = 1635, + STATUS_CODE_USB_EXPIRY_ISOC_BUS_TIME = 1636, + STATUS_CODE_USB_RESET = 1637, + STATUS_CODE_USB_SETINTERFACE = 1638, + STATUS_CODE_USB_NO_TRB_AVAILABLE = 1639, + STATUS_CODE_USB_DEVICE_RESUME = 1640, + STATUS_CODE_USB_RESUME_TIMEOUT = 1641, + STATUS_CODE_SECURITY_COMMAND_TIMEOUT = 1700, + STATUS_CODE_SECURITY_OTP_TIMEOUT = 1701, + STATUS_CODE_SECURITY_BAD_KEY = 1702, + STATUS_CODE_OS_REGISTER_FAILED = 1800, + STATUS_CODE_OS_STACK_OVERFLOW = 1801, + STATUS_CODE_OS_STACK_UNDERFLOW = 1802, + STATUS_CODE_ACCEL_INIT_FAILED = 1900, + STATUS_CODE_ACCEL_READ_FAILED = 1905, + STATUS_CODE_ACCEL_GET_CALIB_FAILED = 1910, + STATUS_CODE_INSTR_COMMAND_EXECUTING = 2000, + STATUS_CODE_LSTB_NOT_READY = 2100, + STATUS_CODE_LSTB_INVALID_BLOCK_IDX = 2105, + STATUS_CODE_LSTB_INVALID_SETTINGS = 2110, + STATUS_CODE_WOV_DMA_ALLOC_NO_MEMORY = 2200, + STATUS_CODE_WOV_AUDIO_LENGTH_ERROR = 2201, + STATUS_CODE_WOV_STATUS_INVALID = 2202, + STATUS_CODE_WOV_RECO_BIT_ERROR = 2203, + STATUS_CODE_WOV_DATA_NOT_READY = 2204, + STATUS_CODE_WOV_NOT_ACTIVE = 2205, + STATUS_CODE_WOV_WRITE_ERROR = 2206, + STATUS_CODE_WOV_INVALID_PARAM = 2207, + STATUS_CODE_WOV_NV_RECOVERY_MISSING = 2208, + STATUS_CODE_WOV_NV_OUT_OF_SPACE = 2209, + STATUS_CODE_WOV_FLASH_SECTOR_TOO_BIG = 2210, + STATUS_CODE_WOV_WRAP_BIT_ERROR = 2211, + STATUS_CODE_AUDIO_DEVICE_NOT_READY = 2300, + STATUS_CODE_AUDIO_ADC_ENABLE_FAILED = 2301, + STATUS_CODE_AUDIO_ADC_DISABLE_FAILED = 2302, + STATUS_CODE_AUDIO_ADC_RESET_FAILED = 2303, + STATUS_CODE_AUDIO_ADC_INIT_FAILED = 2304, + STATUS_CODE_AUDIO_USB_TX_OPEN_FAILED = 2305, + STATUS_CODE_AUDIO_USB_NOT_INITIALIZED = 2306, + STATUS_CODE_AUDIO_USB_NO_FREE_REQ_BUF = 2307, + STATUS_CODE_AUDIO_I2S_DMA_NO_MEMORY = 2308, + + STATUS_CODE_COUNT, + + // Not from Microsoft's library; included in case of a problem on our end + STATUS_CODE_NONE = -1 +}; + +const char *KinectStatusCodeString(unsigned int code); + +} /* namespace libfreenect2 */ + +#endif /* STATUS_CODES_H_ */ diff --git a/src/command_transaction.cpp b/src/command_transaction.cpp index e3dc9b004..b5f44fb73 100644 --- a/src/command_transaction.cpp +++ b/src/command_transaction.cpp @@ -43,14 +43,21 @@ CommandTransaction::CommandTransaction(libusb_device_handle *handle, int inbound outbound_endpoint_(outbound_endpoint), timeout_(1000) { + response_complete_result_.Status = STATUS_CODE_NONE; } CommandTransaction::~CommandTransaction() {} +SensorStatusCode CommandTransaction::getCommandStatus() +{ + return response_complete_result_.Status; +} + bool CommandTransaction::execute(const CommandBase& command, Result& result) { + CommandTransaction::Result resultFooter; result.resize(command.maxResponseLength()); - response_complete_result_.resize(ResponseCompleteLength); + resultFooter.resize(ResponseCompleteLength); // send command if (!send(command)) @@ -63,19 +70,27 @@ bool CommandTransaction::execute(const CommandBase& command, Result& result) return false; if (isResponseCompleteResult(result, command.sequence())) { - LOG_ERROR << "received premature response complete!"; + memcpy(&response_complete_result_, result.data(), sizeof(response_complete_result_)); + result.resize(0); + LOG_ERROR << "received premature response complete! Error code: " << KinectStatusCodeString(getCommandStatus()) << " (" << getCommandStatus() << ")"; return false; } } // receive response complete - if (!receive(response_complete_result_, ResponseCompleteLength)) + if (!receive(resultFooter, ResponseCompleteLength)) return false; - if (!isResponseCompleteResult(response_complete_result_, command.sequence())) + if (!isResponseCompleteResult(resultFooter, command.sequence())) { LOG_ERROR << "missing response complete!"; return false; } + + memcpy(&response_complete_result_, resultFooter.data(), sizeof(response_complete_result_)); + + if (getCommandStatus()) { + LOG_ERROR << "Device reported command was unsuccessful! Error code: " << KinectStatusCodeString(getCommandStatus()) << " (" << getCommandStatus() << ")"; + } return true; } @@ -126,13 +141,18 @@ bool CommandTransaction::isResponseCompleteResult(CommandTransaction::Result& re { if(result.size() == ResponseCompleteLength) { - uint32_t *data = reinterpret_cast(&result[0]); + ResponseFooter *data = reinterpret_cast(&result[0]); - if(data[0] == ResponseCompleteMagic) + if(data->PacketType == ResponseCompleteMagic) { - if(data[1] != sequence) + if(data->TransactionId != sequence) + { + LOG_ERROR << "response complete with wrong sequence number! expected: " << sequence << " got: " << data->TransactionId; + } + + if(data->Status != STATUS_CODE_SUCCESS) { - LOG_ERROR << "response complete with wrong sequence number! expected: " << sequence << " got: " << data[1]; + LOG_ERROR << "response complete with unsuccessful status code! status:" << KinectStatusCodeString(data->Status) << " (" << data->Status << ")"; } return true; } diff --git a/src/status_codes.cpp b/src/status_codes.cpp new file mode 100644 index 000000000..279d5dc5a --- /dev/null +++ b/src/status_codes.cpp @@ -0,0 +1,282 @@ +/* + * This file is part of the OpenKinect Project. http://www.openkinect.org + * + * Copyright (c) 2014 individual OpenKinect contributors. See the CONTRIB file + * for details. + * + * This code is licensed to you under the terms of the Apache License, version + * 2.0, or, at your option, the terms of the GNU General Public License, + * version 2.0. See the APACHE20 and GPL2 files for the text of the licenses, + * or the following URLs: + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/gpl-2.0.txt + * + * If you redistribute this file in source form, modified or unmodified, you + * may: + * 1) Leave this header intact and distribute it under the same terms, + * accompanying it with the APACHE20 and GPL20 files, or + * 2) Delete the Apache 2.0 clause and accompany it with the GPL2 file, or + * 3) Delete the GPL v2 clause and accompany it with the APACHE20 file + * In all cases you must keep the copyright notice intact and include a copy + * of the CONTRIB file. + * + * Binary distributions must follow the binary distribution requirements of + * either License. + */ + +/** @file status_codes.cpp Utility function for printing status code as string. */ +#include +#define STRERROR_CASE(ErrorName) case (unsigned int)STATUS_CODE_##ErrorName: return #ErrorName + +namespace libfreenect2 { + +const char *KinectStatusCodeString(unsigned int code) +{ + switch (code) { + STRERROR_CASE(SUCCESS); + STRERROR_CASE(UNKNOWN_COMMAND); + STRERROR_CASE(INVALID_PARAMETER); + STRERROR_CASE(UART_RX_OVERFLOW); + STRERROR_CASE(BAD_COMMAND_HANDLER); + STRERROR_CASE(ABORT); + STRERROR_CASE(COMMAND_BUSY); + STRERROR_CASE(NOT_IMPLEMENTED); + STRERROR_CASE(OUT_OF_MEMORY); + STRERROR_CASE(BIST_NOT_SUPPORTED); + STRERROR_CASE(NO_MORE_DATA); + STRERROR_CASE(ACCESS_DENIED); + STRERROR_CASE(PARAM_BAD_TAG); + STRERROR_CASE(PARAM_BAD_VALUE); + STRERROR_CASE(DATA_TRUNCATED); + STRERROR_CASE(IO_PENDING); + STRERROR_CASE(DATA_TOO_BIG); + STRERROR_CASE(INVALID_PAYLOAD_SIZE); + STRERROR_CASE(INVALID_COMMAND_PACKET); + STRERROR_CASE(UNEXPECTED_DATA_PHASE); + STRERROR_CASE(DATA_PHASE_ERROR); + STRERROR_CASE(FAILED); + STRERROR_CASE(I2C_NO_RESOURCES); + STRERROR_CASE(I2C_INVALID_HANDLE); + STRERROR_CASE(I2C_DEVICE_NOT_SUPPORTED); + STRERROR_CASE(I2C_PENDING); + STRERROR_CASE(I2C_IDLE_TIMEOUT); + STRERROR_CASE(I2C_READ_TIMEOUT); + STRERROR_CASE(I2C_WRITE_TIMEOUT); + STRERROR_CASE(I2C_STOP_TIMEOUT); + STRERROR_CASE(I2C_TX_ABORT); + STRERROR_CASE(I2C_RX_ABORT); + STRERROR_CASE(NAND_RESET_ERROR); + STRERROR_CASE(NAND_NOT_READY); + STRERROR_CASE(NAND_READ_ID_FAILED); + STRERROR_CASE(NAND_ERASE_FAILED); + STRERROR_CASE(NAND_ECC_CALC_TIMEOUT); + STRERROR_CASE(NAND_ECC_CORRECTION_ERROR); + STRERROR_CASE(NAND_PAGE_PROGRAM_FAILED); + STRERROR_CASE(NAND_NOT_INITIALIZED); + STRERROR_CASE(NAND_ADDR_OUT_OF_RANGE); + STRERROR_CASE(NAND_BBT_BAD_MAGIC); + STRERROR_CASE(NAND_TOO_MANY_BAD_BLOCKS); + STRERROR_CASE(NAND_BAD_BLOCK_FOUND); + STRERROR_CASE(DDR_TRAINING_NO_VALID_VALUE); + STRERROR_CASE(MUTEX_OUT_OF_MEMORY); + STRERROR_CASE(MUTEX_NOT_ACQUIRED); + STRERROR_CASE(MUTEX_NOT_RELEASED); + STRERROR_CASE(NOR_OPERATION_TIMEOUT); + STRERROR_CASE(NOR_FLASH_NOT_IDENTIFIED); + STRERROR_CASE(NOR_NOT_INITIALIZED); + STRERROR_CASE(NOR_WRITE_ERROR); + STRERROR_CASE(NOR_OUT_OF_MEMORY); + STRERROR_CASE(NOR_BUSY); + STRERROR_CASE(NOR_PURGE_FIFO_TIMEOUT); + STRERROR_CASE(NOR_SET_MODE_TIMEOUT); + STRERROR_CASE(NOR_READ_FIFO_TIMEOUT); + STRERROR_CASE(NOR_READ_STATUS_ERROR); + STRERROR_CASE(NOR_WAIT_SEQ_DONE_TIMEOUT); + STRERROR_CASE(NOR_FLASH_NOT_READY); + STRERROR_CASE(NOR_BAD_DEVICE_ID); + STRERROR_CASE(NOR_ERASE_TIMEOUT); + STRERROR_CASE(NOR_READ_DATA_LOSS); + STRERROR_CASE(NOR_WRITE_STATUS_ERROR); + STRERROR_CASE(NOR_READ_TIMEOUT); + STRERROR_CASE(NOR_WRITE_TIMEOUT); + STRERROR_CASE(NOR_SET_STATUS_TIMEOUT); + STRERROR_CASE(SSP_TX_FIFO_OVERFLOW); + STRERROR_CASE(SSP_RX_TIMEOUT); + STRERROR_CASE(SSP_TRANSFER_COMPLETE_TIMEOUT); + STRERROR_CASE(FPGA_BAD_MAGIC_HEADER); + STRERROR_CASE(FPGA_FLASH_DATA_MISMATCH); + STRERROR_CASE(GZIP_UNEXPECTED_EOF); + STRERROR_CASE(GZIP_MORE_DATA); + STRERROR_CASE(GZIP_CRC_ERROR); + STRERROR_CASE(PMC_ERROR); + STRERROR_CASE(PMC_BUSY); + STRERROR_CASE(PMC_DATA_MISMATCH); + STRERROR_CASE(PMC_TIMEOUT); + STRERROR_CASE(PMC_COMMAND_EXECUTING); + STRERROR_CASE(PMC_COMMAND_ABORTED); + STRERROR_CASE(PMC_CANNOT_UPDATE); + STRERROR_CASE(IR_SEQ_VERIFICATION_FAILED); + STRERROR_CASE(IR_FIFO_OVERRUN); + STRERROR_CASE(IR_D02_WRITE_ERROR); + STRERROR_CASE(IR_CAPTURE_FAILED); + STRERROR_CASE(IR_POWERED_DOWN); + STRERROR_CASE(IR_OSC_ERROR); + STRERROR_CASE(IR_ACCESS_ERROR); + STRERROR_CASE(FW_UPDATE_CRC_ERROR); + STRERROR_CASE(FW_UPDATE_INVALID_SIZE); + STRERROR_CASE(FW_UPDATE_INVALID_STATE); + STRERROR_CASE(FW_UPDATE_BAD_TAG); + STRERROR_CASE(FW_UPDATE_BAD_IMAGE); + STRERROR_CASE(FW_UPDATE_IMAGE_TOO_BIG); + STRERROR_CASE(FW_UPDATE_VERIFY_FAILED); + STRERROR_CASE(FW_UPDATE_ABORTED); + STRERROR_CASE(FW_UPDATE_BAD_PLATFORM); + STRERROR_CASE(FW_UPDATE_BLOCKED); + STRERROR_CASE(FW_UPDATE_SIGNATURE_FAULT); + STRERROR_CASE(CAL_OPEN_FAILED); + STRERROR_CASE(CAL_CREATE_CONFIG_FAILED); + STRERROR_CASE(CAL_SET_CUR_CONFIG_FAILED); + STRERROR_CASE(CAL_SET_D02_FAILED); + STRERROR_CASE(CAL_START_STREAM_FAILED); + STRERROR_CASE(CAL_DMA_ALLOC_NO_MEMORY); + STRERROR_CASE(CAL_JPEG_SETTING_FAILED); + STRERROR_CASE(CAL_GET_RGB_FRAME_FAILED); + STRERROR_CASE(CAL_STATE_NOT_IDLE); + STRERROR_CASE(CAL_OS_REGISTER_FAILED); + STRERROR_CASE(CAL_UNEXPECTED_STATE); + STRERROR_CASE(CAL_FRAME_BUFFER_TOO_SMALL); + STRERROR_CASE(CAL_USB_TX_OPEN_FAILED); + STRERROR_CASE(CAL_USB_NO_FREE_REQ_BUFFER); + STRERROR_CASE(CAL_USB_NOT_INITIALIZED); + STRERROR_CASE(CAL_USB_WRITE_FAILED); + STRERROR_CASE(CAL_DEVICE_NOT_READY); + STRERROR_CASE(CAL_DMA_MOVE_TIMEOUT); + STRERROR_CASE(CAL_CAL_ERROR_NONE); + STRERROR_CASE(CAL_CAL_ERROR_UNKNOWN); + STRERROR_CASE(CAL_CAL_ERROR_NOT_IMPL); + STRERROR_CASE(CAL_CAL_ERROR_TIMEOUT); + STRERROR_CASE(CAL_CAL_ERROR_CTRL_IFACE); + STRERROR_CASE(CAL_CAL_ERROR_SENSOR_IFACE); + STRERROR_CASE(CAL_CAL_ERROR_OUTPUT_IFACE); + STRERROR_CASE(CAL_CAL_ERROR_MEMORY); + STRERROR_CASE(CAL_CAL_ERROR_COMPRESSION); + STRERROR_CASE(CAL_CAL_ERROR_ZOOM); + STRERROR_CASE(CAL_CAL_ERROR_SYNC); + STRERROR_CASE(CAL_CAL_ERROR_INVALID_PARAM); + STRERROR_CASE(CAL_CAL_ERROR_INVALID_CMD); + STRERROR_CASE(CAL_CAL_ERROR_CONFIG); + STRERROR_CASE(CAL_CAL_ERROR_CONFIG_NOT_SUPPORTED); + STRERROR_CASE(CAL_CAL_ERROR_CONFIG_NOT_EXIST); + STRERROR_CASE(CAL_CAL_ERROR_CONFIG_ALREADY_EXIST); + STRERROR_CASE(CAL_CAL_ERROR_CONFIG_INDEX_OUT_OF_RANGE); + STRERROR_CASE(CAL_USB_MDLS_BACKED_UP); + STRERROR_CASE(CAL_DMA_OVERRUN); + STRERROR_CASE(VSYNC_STREAM_NOT_STARTED); + STRERROR_CASE(VSYNC_PARAM_BAD_VALUE); + STRERROR_CASE(VSYNC_RGB_SLAVE_MODE_FAILED); + STRERROR_CASE(ADC_INVALID_CHANNEL); + STRERROR_CASE(ADC_INCORRECT_CHANNEL); + STRERROR_CASE(ADC_TIMEOUT); + STRERROR_CASE(ADC_UNKNOWN_DEVICE); + STRERROR_CASE(ADC_UNSUPPORTED_DEVICE); + STRERROR_CASE(ADC_UNSUPPORTED_SIGNAL); + STRERROR_CASE(ADC_INVALID_INPUT); + STRERROR_CASE(ADC_DATA_NOT_AVAILABLE); + STRERROR_CASE(JNFU_ERROR); + STRERROR_CASE(JNFU_NOR_WRITE_FAILED); + STRERROR_CASE(JNFU_NOR_READ_FAILED); + STRERROR_CASE(JNFU_NOR_VERIFY_FAILED); + STRERROR_CASE(JNFU_MEM_ALLOC_FAILED); + STRERROR_CASE(JNFU_BAD_CONFIG_DATA); + STRERROR_CASE(POWER_STATE_CHANGE_FAILED); + STRERROR_CASE(POWER_PG_TIMEOUT); + STRERROR_CASE(POWER_SHUTDOWN_TIMEOUT); + STRERROR_CASE(POWER_1V6_TIMEOUT); + STRERROR_CASE(POWER_INVALID_STATE); + STRERROR_CASE(LDD_UNKNOWN_REGISTER); + STRERROR_CASE(LDD_NV_SIZE_MISMATCH); + STRERROR_CASE(LDD_FAULT); + STRERROR_CASE(LDD_WRITE_VERIFY_FAIL); + STRERROR_CASE(USB_CORE_REVISION_MISMATCH); + STRERROR_CASE(USB_DEVICE_NOT_INT); + STRERROR_CASE(USB_DEVICE_INIT); + STRERROR_CASE(USB_DEVICE_RESET_TIMEOUT); + STRERROR_CASE(USB_DEVICE_NOT_CONFIGURED); + STRERROR_CASE(USB_DEVICE_SUSPENDED); + STRERROR_CASE(USB_INVALID_DESCRIPTOR); + STRERROR_CASE(USB_DISCONNECTED); + STRERROR_CASE(USB_DEVICE_ACTIVE); + STRERROR_CASE(USB_RE_CONFIG_STACK); + STRERROR_CASE(USB_STACK_CONFIGED); + STRERROR_CASE(USB_SETPHY_FAILED); + STRERROR_CASE(USB_BUF_ALLOC_FAILED); + STRERROR_CASE(USB_INVALID_CALLBACK); + STRERROR_CASE(USB_STACK_UNCONFIG); + STRERROR_CASE(USB_EP_ACTIVE); + STRERROR_CASE(USB_EP_NOT_ACTIVE); + STRERROR_CASE(USB_INTERFACE_NO_EP); + STRERROR_CASE(USB_EP_STALL); + STRERROR_CASE(USB_BUF_FULL); + STRERROR_CASE(USB_BUF_EMPTY); + STRERROR_CASE(USB_REQUEST_SCHEDULED); + STRERROR_CASE(USB_EP_INVALID_REQUEST); + STRERROR_CASE(USB_EP_MISSED_ISOC); + STRERROR_CASE(USB_EP_NOFFN_ISOC); + STRERROR_CASE(USB_NULL_POINTER); + STRERROR_CASE(USB_INVALID_HANDLE); + STRERROR_CASE(USB_INVALID_REQUEST); + STRERROR_CASE(USB_EP_PIPE_NOTOPEN); + STRERROR_CASE(USB_END_TRANSFER); + STRERROR_CASE(USB_EP_WRITE_FAILED); + STRERROR_CASE(USB_EVT_BUFFER_OVERFLOW); + STRERROR_CASE(USB_ERRATIC_ERROR); + STRERROR_CASE(USB_SUSPEND); + STRERROR_CASE(USB_REMOTE_WAKEUP); + STRERROR_CASE(USB_EP_RESETPIPE); + STRERROR_CASE(USB_EXPIRY_ISOC_BUS_TIME); + STRERROR_CASE(USB_RESET); + STRERROR_CASE(USB_SETINTERFACE); + STRERROR_CASE(USB_NO_TRB_AVAILABLE); + STRERROR_CASE(USB_DEVICE_RESUME); + STRERROR_CASE(USB_RESUME_TIMEOUT); + STRERROR_CASE(SECURITY_COMMAND_TIMEOUT); + STRERROR_CASE(SECURITY_OTP_TIMEOUT); + STRERROR_CASE(SECURITY_BAD_KEY); + STRERROR_CASE(OS_REGISTER_FAILED); + STRERROR_CASE(OS_STACK_OVERFLOW); + STRERROR_CASE(OS_STACK_UNDERFLOW); + STRERROR_CASE(ACCEL_INIT_FAILED); + STRERROR_CASE(ACCEL_READ_FAILED); + STRERROR_CASE(ACCEL_GET_CALIB_FAILED); + STRERROR_CASE(INSTR_COMMAND_EXECUTING); + STRERROR_CASE(LSTB_NOT_READY); + STRERROR_CASE(LSTB_INVALID_BLOCK_IDX); + STRERROR_CASE(LSTB_INVALID_SETTINGS); + STRERROR_CASE(WOV_DMA_ALLOC_NO_MEMORY); + STRERROR_CASE(WOV_AUDIO_LENGTH_ERROR); + STRERROR_CASE(WOV_STATUS_INVALID); + STRERROR_CASE(WOV_RECO_BIT_ERROR); + STRERROR_CASE(WOV_DATA_NOT_READY); + STRERROR_CASE(WOV_NOT_ACTIVE); + STRERROR_CASE(WOV_WRITE_ERROR); + STRERROR_CASE(WOV_INVALID_PARAM); + STRERROR_CASE(WOV_NV_RECOVERY_MISSING); + STRERROR_CASE(WOV_NV_OUT_OF_SPACE); + STRERROR_CASE(WOV_FLASH_SECTOR_TOO_BIG); + STRERROR_CASE(WOV_WRAP_BIT_ERROR); + STRERROR_CASE(AUDIO_DEVICE_NOT_READY); + STRERROR_CASE(AUDIO_ADC_ENABLE_FAILED); + STRERROR_CASE(AUDIO_ADC_DISABLE_FAILED); + STRERROR_CASE(AUDIO_ADC_RESET_FAILED); + STRERROR_CASE(AUDIO_ADC_INIT_FAILED); + STRERROR_CASE(AUDIO_USB_TX_OPEN_FAILED); + STRERROR_CASE(AUDIO_USB_NOT_INITIALIZED); + STRERROR_CASE(AUDIO_USB_NO_FREE_REQ_BUF); + STRERROR_CASE(AUDIO_I2S_DMA_NO_MEMORY); + STRERROR_CASE(NONE); + default: + return "(unknown status code)"; + } +} + +}; \ No newline at end of file