Hid Utilities for HID based dynamic sensor
An HID utility library for constructing HID based dynamic sensor. Primary functionality is in HidParser.h, which parses HID descriptor into useful data structures. Supporting classes and structures can be used individually as well. Test: run tests in HidUtils/test Bug: 37482274 Change-Id: Icfb59414bb6a1e7b6cdd1078a1a83820e70bbef8
This commit is contained in:
Peng Xu
parent
17d4579494
commit
5beee10b17
24 changed files with 6194 additions and 2 deletions
|
|
@ -32,7 +32,7 @@ COMMON_CFLAGS := -Wall -Werror -Wextra
|
|||
include $(CLEAR_VARS)
|
||||
LOCAL_MODULE := libdynamic_sensor_ext
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
LOCAL_MODULE_OWNER := google
|
||||
# intended to be integrated into hal, thus proprietary
|
||||
LOCAL_PROPRIETARY_MODULE := true
|
||||
|
||||
LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"DynamicSensorExt\"
|
||||
|
|
@ -61,7 +61,7 @@ include $(CLEAR_VARS)
|
|||
LOCAL_MODULE := sensors.dynamic_sensor_hal
|
||||
LOCAL_MODULE_RELATIVE_PATH := hw
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
LOCAL_MODULE_OWNER := google
|
||||
# hal module, thus proprietary
|
||||
LOCAL_PROPRIETARY_MODULE := true
|
||||
|
||||
LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"DynamicSensorHal\"
|
||||
|
|
@ -83,3 +83,6 @@ LOCAL_SHARED_LIBRARIES := \
|
|||
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
|
||||
|
||||
include $(BUILD_SHARED_LIBRARY)
|
||||
|
||||
include $(LOCAL_PATH)/HidUtils/Android.mk
|
||||
|
||||
|
|
|
|||
99
modules/sensors/dynamic_sensor/HidUtils/Android.mk
Normal file
99
modules/sensors/dynamic_sensor/HidUtils/Android.mk
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
# Copyright (C) 2017 The Android Open Source Project
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
COMMON_CFLAGS := -Wall -Werror -Wextra
|
||||
|
||||
hidparser_src := \
|
||||
HidGlobal.cpp \
|
||||
HidItem.cpp \
|
||||
HidLocal.cpp \
|
||||
HidParser.cpp \
|
||||
HidReport.cpp \
|
||||
HidTree.cpp
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_MODULE := libhidparser
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
# indended to be used by hal components, thus propietary
|
||||
LOCAL_PROPRIETARY_MODULE := true
|
||||
|
||||
LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"HidUtil\"
|
||||
LOCAL_SRC_FILES := $(hidparser_src)
|
||||
LOCAL_SHARED_LIBRARIES := libbase
|
||||
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
|
||||
include $(BUILD_SHARED_LIBRARY)
|
||||
|
||||
#
|
||||
# host side shared library (for host test, example, etc)
|
||||
#
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_MODULE := libhidparser_host
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
|
||||
LOCAL_CFLAGS += $(COMMON_CFLAGS)
|
||||
|
||||
LOCAL_SRC_FILES := $(hidparser_src)
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
|
||||
include $(BUILD_HOST_SHARED_LIBRARY)
|
||||
|
||||
#
|
||||
# Example of HidParser
|
||||
#
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_MODULE := hidparser_example
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
|
||||
LOCAL_CFLAGS += $(COMMON_CFLAGS)
|
||||
LOCAL_SRC_FILES := \
|
||||
$(hidparser_src) \
|
||||
test/HidParserExample.cpp \
|
||||
test/TestHidDescriptor.cpp
|
||||
|
||||
LOCAL_C_INCLUDES += $(LOCAL_PATH)/test
|
||||
include $(BUILD_HOST_EXECUTABLE)
|
||||
|
||||
#
|
||||
# Another example of HidParser
|
||||
#
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_MODULE := hidparser_example2
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
|
||||
LOCAL_CFLAGS += $(COMMON_CFLAGS)
|
||||
LOCAL_SRC_FILES := \
|
||||
$(hidparser_src) \
|
||||
test/HidParserExample2.cpp \
|
||||
test/TestHidDescriptor.cpp
|
||||
|
||||
LOCAL_C_INCLUDES += $(LOCAL_PATH)/test
|
||||
include $(BUILD_HOST_EXECUTABLE)
|
||||
|
||||
#
|
||||
# Test for TriState template
|
||||
#
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_MODULE := tristate_test
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
|
||||
LOCAL_CFLAGS += $(COMMON_CFLAGS)
|
||||
LOCAL_SRC_FILES := test/TriStateTest.cpp
|
||||
|
||||
LOCAL_STATIC_LIBRARIES := \
|
||||
libgtest \
|
||||
libgtest_main
|
||||
|
||||
LOCAL_C_INCLUDES += $(LOCAL_PATH)/test
|
||||
include $(BUILD_HOST_NATIVE_TEST)
|
||||
117
modules/sensors/dynamic_sensor/HidUtils/HidDefs.h
Normal file
117
modules/sensors/dynamic_sensor/HidUtils/HidDefs.h
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDDEFS_H_
|
||||
#define HIDUTIL_HIDDEFS_H_
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
// HID specification constants definition
|
||||
//
|
||||
// Definitions are from HID specification v1.11, which can be obtained from http://www.usb.org
|
||||
//
|
||||
// Preferred namespace for namespace restriction than enum class as enum class has strong type
|
||||
// which is inconvenient in a parser, in which input binary values has to be compared with these
|
||||
// definitions frequnetly.
|
||||
namespace HidDef {
|
||||
// Hid spec 6.2.2.3
|
||||
namespace TagType {
|
||||
enum {
|
||||
MAIN,
|
||||
GLOBAL,
|
||||
LOCAL,
|
||||
RESERVED
|
||||
};
|
||||
} // namespace TagType
|
||||
|
||||
// HID spec 6.2.2.4
|
||||
namespace ReportFlag {
|
||||
enum {
|
||||
DATA_CONST = 1,
|
||||
ARRAY_VARIABLE = 2,
|
||||
WRAP = 4,
|
||||
NONLINEAR = 8,
|
||||
NO_PREFERRED = 0x10,
|
||||
NULL_STATE = 0x20,
|
||||
VOLATILE = 0x40,
|
||||
// bit 7 reserved
|
||||
BUFFERED_BYTES = 0x100
|
||||
};
|
||||
} // namespace ReportFlag
|
||||
|
||||
// HID spec 6.2.2.5
|
||||
namespace MainTag {
|
||||
enum {
|
||||
INPUT = 8,
|
||||
OUTPUT = 9,
|
||||
COLLECTION = 10,
|
||||
FEATURE = 11,
|
||||
END_COLLECTION = 12,
|
||||
LONG_ITEM = 15,
|
||||
};
|
||||
} // namespace MainTag
|
||||
|
||||
// HID spec 6.2.2.6
|
||||
namespace CollectionType {
|
||||
enum {
|
||||
PHYSICAL = 0,
|
||||
APPLICATION,
|
||||
LOGICAL,
|
||||
REPORT,
|
||||
NAMED_ARRAY,
|
||||
USAGE_SWITCH,
|
||||
USAGE_MODIFIER
|
||||
};
|
||||
} // namespace CollectionType
|
||||
|
||||
// HID spec 6.2.2.7
|
||||
namespace GlobalTag {
|
||||
enum {
|
||||
USAGE_PAGE,
|
||||
LOGICAL_MINIMUM,
|
||||
LOGICAL_MAXIMUM,
|
||||
PHYSICAL_MINIMUM,
|
||||
PHYSICAL_MAXIMUM,
|
||||
UNIT_EXPONENT,
|
||||
UNIT,
|
||||
REPORT_SIZE,
|
||||
REPORT_ID,
|
||||
REPORT_COUNT,
|
||||
PUSH,
|
||||
POP
|
||||
};
|
||||
} //namespace GlobalTag
|
||||
|
||||
// HID spec 6.2.2.8
|
||||
namespace LocalTag {
|
||||
enum HidLocalTag {
|
||||
USAGE,
|
||||
USAGE_MINIMUM,
|
||||
USAGE_MAXIMUM,
|
||||
DESIGNATOR_INDEX,
|
||||
DESIGNATOR_MINIMUM,
|
||||
DESIGNATOR_MAXIMUM,
|
||||
// there is a hole here in the spec
|
||||
STRING_INDEX = 7,
|
||||
STRING_MINIMUM,
|
||||
STRING_MAXIMUM,
|
||||
DELIMITOR
|
||||
};
|
||||
} // namespace LocalTag
|
||||
|
||||
} //namespace HidDef
|
||||
} //namespace HidUtil
|
||||
|
||||
#endif // HIDUTIL_HIDDEFS_H_
|
||||
125
modules/sensors/dynamic_sensor/HidUtils/HidGlobal.cpp
Normal file
125
modules/sensors/dynamic_sensor/HidUtils/HidGlobal.cpp
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "HidDefs.h"
|
||||
#include "HidGlobal.h"
|
||||
#include "HidLog.h"
|
||||
|
||||
namespace HidUtil {
|
||||
using namespace HidDef::GlobalTag;
|
||||
|
||||
bool HidGlobal::append(const HidItem &i) {
|
||||
using namespace HidDef::TagType;
|
||||
if (i.type != GLOBAL) {
|
||||
LOG_E << "HidGlobal::append cannot process tag that is not global, " << i << LOG_ENDL;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (i.tag == PUSH || i.tag == POP) {
|
||||
LOG_E << "PUSH and POP should be handled in HidGlobalStack, " << i << LOG_ENDL;
|
||||
return false;
|
||||
}
|
||||
|
||||
int signedInteger;
|
||||
unsigned unsignedInteger;
|
||||
bool signedError = !i.dataAsSigned(&signedInteger);
|
||||
bool unsignedError = !i.dataAsUnsigned(&unsignedInteger);
|
||||
|
||||
bool valueError = false;
|
||||
bool ret = true;
|
||||
switch (i.tag) {
|
||||
case USAGE_PAGE:
|
||||
usagePage = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case LOGICAL_MINIMUM:
|
||||
logicalMin = signedInteger;
|
||||
valueError = signedError;
|
||||
break;
|
||||
case LOGICAL_MAXIMUM:
|
||||
logicalMax = signedInteger;
|
||||
valueError = signedError;
|
||||
break;
|
||||
case PHYSICAL_MINIMUM:
|
||||
physicalMin = signedInteger;
|
||||
valueError = signedError;
|
||||
break;
|
||||
case PHYSICAL_MAXIMUM:
|
||||
physicalMax = signedInteger;
|
||||
valueError = signedError;
|
||||
break;
|
||||
case UNIT_EXPONENT:
|
||||
exponent = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case UNIT:
|
||||
unit = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case REPORT_SIZE:
|
||||
reportSize = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case REPORT_ID:
|
||||
reportId = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case REPORT_COUNT:
|
||||
reportCount = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
default:
|
||||
LOG_E << "unknown global tag, " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
}
|
||||
|
||||
if (valueError) {
|
||||
LOG_E << "Cannot get signed / unsigned data at " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool HidGlobalStack::append(const HidItem &i) {
|
||||
using namespace HidDef::TagType;
|
||||
if (i.type != GLOBAL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ret = true;
|
||||
if (i.tag == PUSH) {
|
||||
mStack.push_back(top());
|
||||
} else if (i.tag == POP) {
|
||||
mStack.pop_back();
|
||||
if (mStack.size() == 0) {
|
||||
mStack.push_back(HidGlobal()); // fail-safe
|
||||
ret = false;
|
||||
}
|
||||
} else {
|
||||
ret = mStack.back().append(i);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
HidGlobalStack::HidGlobalStack() {
|
||||
// default element
|
||||
mStack.push_back(HidGlobal());
|
||||
}
|
||||
|
||||
const HidGlobal& HidGlobalStack::top() const {
|
||||
return mStack.back();
|
||||
}
|
||||
|
||||
} // namespace HidUtil
|
||||
60
modules/sensors/dynamic_sensor/HidUtils/HidGlobal.h
Normal file
60
modules/sensors/dynamic_sensor/HidUtils/HidGlobal.h
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDGLOBAL_H_
|
||||
#define HIDUTIL_HIDGLOBAL_H_
|
||||
|
||||
#include "HidItem.h"
|
||||
#include "TriState.h"
|
||||
|
||||
namespace HidUtil {
|
||||
// A set of global states that parser has to keep track during parsing.
|
||||
// They are all specified in HID spec v1.11 section 6.2.2.7
|
||||
struct HidGlobal {
|
||||
// add a token and change global states, returns value indicates if operation is successful
|
||||
bool append(const HidItem &i);
|
||||
|
||||
tri_uint usagePage;
|
||||
tri_int logicalMin;
|
||||
tri_int logicalMax;
|
||||
tri_int physicalMin;
|
||||
tri_int physicalMax;
|
||||
tri_uint exponent;
|
||||
tri_uint unit;
|
||||
tri_uint reportSize;
|
||||
tri_uint reportId;
|
||||
tri_uint reportCount;
|
||||
};
|
||||
|
||||
// HID specs allows PUSH and POP to save a snapshot of current global states and come back to the
|
||||
// saved sates later. HidStack manages this logic. Note that PUSH and POP are also HidItems, so
|
||||
// there is no explicit push and pop function in this stack implementation.
|
||||
class HidGlobalStack {
|
||||
public:
|
||||
HidGlobalStack();
|
||||
|
||||
// add a token and change global states, returns value indicates if operation is successful
|
||||
// it the token is push/pop, the stack push/pop accordingly.
|
||||
bool append(const HidItem &i);
|
||||
|
||||
// get reference to top element on the stack
|
||||
const HidGlobal& top() const;
|
||||
private:
|
||||
std::vector<HidGlobal> mStack;
|
||||
};
|
||||
|
||||
} //namespace HidUtil
|
||||
|
||||
#endif // HIDUTIL_HIDGLOABL_H_
|
||||
132
modules/sensors/dynamic_sensor/HidUtils/HidItem.cpp
Normal file
132
modules/sensors/dynamic_sensor/HidUtils/HidItem.cpp
Normal file
|
|
@ -0,0 +1,132 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "HidItem.h"
|
||||
#include "HidDefs.h"
|
||||
#include "StreamIoUtil.h"
|
||||
#include <iostream>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
bool HidItem::dataAsUnsigned(unsigned int *out) const {
|
||||
if (data.size() > 4 || data.size() == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*out = 0;
|
||||
int shift = 0;
|
||||
|
||||
for (auto i : data) {
|
||||
*out |= (i << shift);
|
||||
shift += 8;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool HidItem::dataAsSigned(int *out) const {
|
||||
unsigned int u;
|
||||
if (!dataAsUnsigned(&u)) {
|
||||
return false;
|
||||
}
|
||||
size_t bitSize_1 = data.size() * 8 - 1;
|
||||
unsigned int sign = u & (1 << bitSize_1);
|
||||
*out = u | ((sign == 0) ? 0 : ( ~0 << bitSize_1));
|
||||
return true;
|
||||
}
|
||||
|
||||
std::vector<HidItem> HidItem::tokenize(const uint8_t *begin, size_t size) {
|
||||
// construct a stream
|
||||
charvectorbuf<unsigned char> buf(begin, size);
|
||||
std::istream is(&buf);
|
||||
return tokenize(is);
|
||||
}
|
||||
|
||||
std::vector<HidItem> HidItem::tokenize(const std::vector<uint8_t> &descriptor) {
|
||||
// construct a stream
|
||||
charvectorbuf<unsigned char> buf(descriptor);
|
||||
std::istream is(&buf);
|
||||
return tokenize(is);
|
||||
}
|
||||
|
||||
std::vector<HidItem> HidItem::tokenize(std::istream &is) {
|
||||
std::vector<HidItem> hidToken;
|
||||
|
||||
// this is important to avoid skipping characters
|
||||
is.unsetf(std::ios_base::skipws);
|
||||
while (!is.eof()) {
|
||||
HidItem i;
|
||||
is >> i;
|
||||
if (i.valid) {
|
||||
hidToken.push_back(i);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return hidToken;
|
||||
}
|
||||
|
||||
std::istream& operator>>(std::istream &is, HidUtil::HidItem &h) {
|
||||
using namespace HidUtil::HidDef::MainTag;
|
||||
using namespace HidUtil::HidDef::TagType;
|
||||
|
||||
h.valid = false;
|
||||
h.offset = is.tellg();
|
||||
h.byteSize = 0;
|
||||
unsigned char first;
|
||||
is >> first;
|
||||
if (!is.eof()) {
|
||||
static const size_t lenTable[] = { 0, 1, 2, 4 };
|
||||
size_t len = lenTable[first & 0x3]; // low 2 bits are length descriptor
|
||||
h.tag = (first >> 4);
|
||||
h.type = (first & 0xC) >> 2;
|
||||
|
||||
if (h.tag == LONG_ITEM && h.type == RESERVED) { // long item
|
||||
//long item
|
||||
unsigned char b = 0;
|
||||
is >> b;
|
||||
len = b;
|
||||
is >> b;
|
||||
h.tag = b;
|
||||
}
|
||||
|
||||
h.data.resize(len);
|
||||
for (auto &i : h.data) {
|
||||
if (is.eof()) {
|
||||
break;
|
||||
}
|
||||
is >> i;
|
||||
}
|
||||
h.byteSize = (ssize_t) is.tellg() - h.offset;
|
||||
h.valid = !is.eof();
|
||||
}
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream &os, const HidUtil::HidItem &h) {
|
||||
os << "offset: " << h.offset << ", size: " << h.byteSize
|
||||
<< ", tag: " << h.tag << ", type: " << h.type << ", data: ";
|
||||
if (h.data.empty()) {
|
||||
os << "[empty]";
|
||||
} else {
|
||||
os << h.data.size() << " byte(s) {";
|
||||
for (auto i : h.data) {
|
||||
os << (int) i << ", ";
|
||||
}
|
||||
os << "}";
|
||||
}
|
||||
return os;
|
||||
}
|
||||
} // namespace HidUtil
|
||||
54
modules/sensors/dynamic_sensor/HidUtils/HidItem.h
Normal file
54
modules/sensors/dynamic_sensor/HidUtils/HidItem.h
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDITEM_H_
|
||||
#define HIDUTIL_HIDITEM_H_
|
||||
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
struct HidItem {
|
||||
bool valid;
|
||||
unsigned int type;
|
||||
unsigned int tag;
|
||||
ssize_t offset;
|
||||
ssize_t byteSize;
|
||||
std::vector<uint8_t> data;
|
||||
|
||||
bool dataAsUnsigned(unsigned int *out) const;
|
||||
bool dataAsSigned(int *out) const;
|
||||
|
||||
// friend stream functions
|
||||
friend std::istream& operator>>(std::istream &is, HidItem &h);
|
||||
friend std::ostream& operator<<(std::ostream &os, const HidItem &h);
|
||||
|
||||
// tokenize from a unsigned char vector
|
||||
static std::vector<HidItem> tokenize(const std::vector<uint8_t> &descriptor);
|
||||
static std::vector<HidItem> tokenize(const uint8_t *begin, size_t size);
|
||||
static std::vector<HidItem> tokenize(std::istream &is);
|
||||
};
|
||||
|
||||
// parsing in from binary stream
|
||||
std::istream& operator>>(std::istream &is, HidUtil::HidItem &h);
|
||||
|
||||
// output as human readable string to stream
|
||||
std::ostream& operator<<(std::ostream &os, const HidUtil::HidItem &h);
|
||||
} //namespace HidUtil
|
||||
|
||||
#endif // HIDUTIL_HIDITEM_H_
|
||||
118
modules/sensors/dynamic_sensor/HidUtils/HidLocal.cpp
Normal file
118
modules/sensors/dynamic_sensor/HidUtils/HidLocal.cpp
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "HidDefs.h"
|
||||
#include "HidLocal.h"
|
||||
#include "HidLog.h"
|
||||
#include <cstddef>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
constexpr uint32_t INVALID_USAGE = 0xFFFF;
|
||||
constexpr uint32_t INVALID_DESIGNATOR = 0xFFFF;
|
||||
constexpr uint32_t INVALID_STRING = 0xFFFF;
|
||||
|
||||
uint32_t HidLocal::getUsage(size_t index) const {
|
||||
if (usage.empty()) {
|
||||
return INVALID_USAGE;
|
||||
}
|
||||
return (index >= usage.size()) ? usage.back() : usage[index];
|
||||
}
|
||||
|
||||
uint32_t HidLocal::getDesignator(size_t index) const {
|
||||
if (designator.empty()) {
|
||||
return INVALID_DESIGNATOR;
|
||||
}
|
||||
return (index >= designator.size()) ? designator.back() : designator[index];
|
||||
}
|
||||
|
||||
uint32_t HidLocal::getString(size_t index) const {
|
||||
if (string.empty()) {
|
||||
return INVALID_STRING;
|
||||
}
|
||||
return (index >= string.size()) ? string.back() : string[index];
|
||||
}
|
||||
|
||||
void HidLocal::clear() {
|
||||
*this = HidLocal();
|
||||
}
|
||||
|
||||
bool HidLocal::append(const HidItem &i) {
|
||||
using namespace HidDef::LocalTag;
|
||||
|
||||
bool ret = true;
|
||||
unsigned unsignedInteger;
|
||||
bool unsignedError = !i.dataAsUnsigned(&unsignedInteger);
|
||||
bool valueError = false;
|
||||
|
||||
switch (i.tag) {
|
||||
case USAGE:
|
||||
usage.push_back(unsignedInteger);
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case USAGE_MINIMUM:
|
||||
usageMin = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case USAGE_MAXIMUM:
|
||||
if (!usageMin.isSet()) {
|
||||
LOG_E << "usage min not set when saw usage max " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
} else {
|
||||
uint32_t usagemax = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
for (size_t j = usageMin.get(0); j <= usagemax; ++j) {
|
||||
usage.push_back(j);
|
||||
}
|
||||
usageMin.clear();
|
||||
}
|
||||
break;
|
||||
case STRING_INDEX:
|
||||
string.push_back(unsignedInteger);
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case STRING_MINIMUM:
|
||||
stringMin = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
case STRING_MAXIMUM: {
|
||||
if (!usageMin.isSet()) {
|
||||
LOG_E << "string min not set when saw string max " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
} else {
|
||||
uint32_t stringMax = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
for (size_t j = stringMin.get(0); j <= stringMax; ++j) {
|
||||
string.push_back(j);
|
||||
}
|
||||
stringMin.clear();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case DELIMITOR:
|
||||
delimeter = unsignedInteger;
|
||||
valueError = unsignedError;
|
||||
break;
|
||||
default:
|
||||
LOG_E << "unknown local tag, " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
}
|
||||
if (valueError) {
|
||||
LOG_E << "Cannot get unsigned data at " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
} //namespace HidUtil
|
||||
55
modules/sensors/dynamic_sensor/HidUtils/HidLocal.h
Normal file
55
modules/sensors/dynamic_sensor/HidUtils/HidLocal.h
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDLOCAL_H_
|
||||
#define HIDUTIL_HIDLOCAL_H_
|
||||
|
||||
#include "HidItem.h"
|
||||
#include "TriState.h"
|
||||
#include <cstddef>
|
||||
#include <vector>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
// A set of local states that parser has to keep track during parsing.
|
||||
// They are all specified in HID spec v1.11 section 6.2.2.8
|
||||
struct HidLocal {
|
||||
// add a token to change local states, return value indicates if operation is successful
|
||||
bool append(const HidItem &i);
|
||||
// clear all local states. This need to be done after each main tag
|
||||
void clear();
|
||||
|
||||
// multiple usage, designator or strings may exist for single input/output/feature report
|
||||
uint32_t getUsage(size_t index) const;
|
||||
uint32_t getDesignator(size_t index) const;
|
||||
uint32_t getString(size_t index) const;
|
||||
|
||||
std::vector<uint32_t> usage;
|
||||
// keep track of usage min when expecting a usage max
|
||||
tri_uint usageMin;
|
||||
|
||||
std::vector<uint32_t> designator;
|
||||
// keep track of designator min when expecting designator max
|
||||
tri_uint designatorMin;
|
||||
|
||||
std::vector<uint32_t> string;
|
||||
// keep track of string min when expecting string max
|
||||
tri_uint stringMin;
|
||||
|
||||
tri_uint delimeter;
|
||||
};
|
||||
} // namespace HidUtil
|
||||
|
||||
#endif // HIDUTIL_HIDLOCAL_H_
|
||||
37
modules/sensors/dynamic_sensor/HidUtils/HidLog.h
Normal file
37
modules/sensors/dynamic_sensor/HidUtils/HidLog.h
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDLOG_H_
|
||||
#define HIDUTIL_HIDLOG_H_
|
||||
|
||||
#if defined(__ANDROID__) && !defined(LOG_TO_CONSOLE)
|
||||
#include <android-base/logging.h>
|
||||
#define LOG_ENDL ""
|
||||
#define LOG_E LOG(ERROR)
|
||||
#define LOG_W LOG(WARNING)
|
||||
#define LOG_I LOG(INFO)
|
||||
#define LOG_D LOG(DEBUG)
|
||||
#define LOG_V LOG(VERBOSE)
|
||||
#else
|
||||
#include <iostream>
|
||||
#define LOG_ENDL std::endl
|
||||
#define LOG_E (std::cerr << "E: ")
|
||||
#define LOG_W (std::cerr << "W: ")
|
||||
#define LOG_I (std::cerr << "I: ")
|
||||
#define LOG_D (std::cerr << "D: ")
|
||||
#define LOG_V (std::cerr << "V: ")
|
||||
#endif
|
||||
|
||||
#endif // HIDUTIL_HIDLOG_H_
|
||||
319
modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
Normal file
319
modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
Normal file
|
|
@ -0,0 +1,319 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "HidDefs.h"
|
||||
#include "HidParser.h"
|
||||
#include "HidLog.h"
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
void HidParser::reset() {
|
||||
mGlobalStack = HidGlobalStack();
|
||||
mLocal = HidLocal();
|
||||
mTree = std::make_shared<HidTreeNode>();
|
||||
mCurrent = mTree;
|
||||
}
|
||||
|
||||
bool HidParser::parse(const std::vector<HidItem> &token) {
|
||||
// Clean up internal states of the parser for a new stream of descriptor token
|
||||
reset();
|
||||
|
||||
bool ret = true;
|
||||
using namespace HidDef::TagType;
|
||||
|
||||
for (auto &i : token) {
|
||||
switch (i.type) {
|
||||
case MAIN:
|
||||
ret = processMainTag(i);
|
||||
break;
|
||||
case GLOBAL:
|
||||
ret = mGlobalStack.append(i);
|
||||
break;
|
||||
case LOCAL:
|
||||
ret = mLocal.append(i);
|
||||
break;
|
||||
default:
|
||||
LOG_E << "HidParser found illegal HidItem: " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
}
|
||||
|
||||
// in case a parse failure, quit prematurely
|
||||
if (!ret) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool HidParser::processMainTag(const HidItem &i) {
|
||||
using namespace HidDef::MainTag;
|
||||
using namespace HidDef::ReportFlag;
|
||||
|
||||
bool ret = true;
|
||||
switch (i.tag) {
|
||||
case COLLECTION: {
|
||||
unsigned int collectionType;
|
||||
if (!i.dataAsUnsigned(&collectionType)) {
|
||||
LOG_E << "Cannot get collection type at offset " << i.offset << LOG_ENDL;
|
||||
ret = false;
|
||||
break;
|
||||
}
|
||||
unsigned int fullUsage =
|
||||
mGlobalStack.top().usagePage.get(0) << 16 | mLocal.getUsage(0);
|
||||
mCurrent = mCurrent->addChild(
|
||||
std::make_shared<HidTreeNode>(mCurrent, collectionType, fullUsage));
|
||||
break;
|
||||
}
|
||||
case END_COLLECTION:
|
||||
mCurrent = mCurrent->getParent();
|
||||
if (!mCurrent) {
|
||||
// trigger parse failure so that mCurrent will not be accessed
|
||||
LOG_E << "unmatched END_COLLECTION at " << i.offset << LOG_ENDL;
|
||||
ret = false;
|
||||
}
|
||||
break;
|
||||
case INPUT:
|
||||
case OUTPUT:
|
||||
case FEATURE: {
|
||||
unsigned int reportType = i.tag;
|
||||
unsigned int flag;
|
||||
if (!i.dataAsUnsigned(&flag)) {
|
||||
LOG_E << "Cannot get report flag at offset " << i.offset << LOG_ENDL;
|
||||
ret = false;
|
||||
break;
|
||||
}
|
||||
const HidGlobal &top = mGlobalStack.top();
|
||||
|
||||
// usage page, local min/max, report size and count have to be defined at report
|
||||
// definition.
|
||||
if (!(top.usagePage.isSet() && top.logicalMin.isSet() && top.logicalMax.isSet()
|
||||
&& top.reportSize.isSet() && top.reportCount.isSet())) {
|
||||
LOG_E << "Report defined at " << i.offset
|
||||
<< " does not have all mandatory fields set" << LOG_ENDL;
|
||||
ret = false;
|
||||
break;
|
||||
}
|
||||
if (top.reportSize.get(0) > 32) {
|
||||
LOG_E << "Report defined at " << i.offset
|
||||
<< " has unsupported report size(> 32 bit)" << LOG_ENDL;
|
||||
ret = false;
|
||||
break;
|
||||
}
|
||||
|
||||
HidReport report(reportType, flag, top, mLocal);
|
||||
mReport.push_back(report);
|
||||
std::shared_ptr<HidTreeNode> node(new HidReportNode(mCurrent, report));
|
||||
mCurrent->addChild(node);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
LOG_E << "unknown main tag, " << i << LOG_ENDL;
|
||||
ret = false;
|
||||
}
|
||||
// locals is cleared after any main tag according to HID spec
|
||||
mLocal.clear();
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool HidParser::parse(const unsigned char *begin, size_t size) {
|
||||
std::vector<HidItem> hidItemVector = HidItem::tokenize(begin, size);
|
||||
return parse(hidItemVector);
|
||||
}
|
||||
|
||||
void HidParser::filterTree() {
|
||||
if (mTree != nullptr) {
|
||||
filterTree(mTree);
|
||||
}
|
||||
}
|
||||
|
||||
void HidParser::filterTree(std::shared_ptr<HidTreeNode> &node) {
|
||||
if (node->isReportCollection()) {
|
||||
std::shared_ptr<HidReportNode> reportNode =
|
||||
std::static_pointer_cast<HidReportNode>(node->getChildren().front());
|
||||
if (reportNode != nullptr) {
|
||||
reportNode->collapse(node->getFullUsage());
|
||||
node = reportNode;
|
||||
}
|
||||
} else {
|
||||
for (auto &i : node->getChildren()) {
|
||||
filterTree(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
HidParser::DigestVector HidParser::generateDigest(
|
||||
const std::unordered_set<unsigned int> &interestedUsage) {
|
||||
DigestVector digestVector;
|
||||
digest(&digestVector, mTree, interestedUsage);
|
||||
return digestVector;
|
||||
}
|
||||
|
||||
void HidParser::digest(HidParser::DigestVector *digestVector,
|
||||
const std::shared_ptr<HidTreeNode> &node,
|
||||
const std::unordered_set<unsigned int> &interestedUsage) {
|
||||
if (digestVector == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (node->isUsageCollection()
|
||||
&& interestedUsage.find(node->getFullUsage()) != interestedUsage.end()) {
|
||||
// this collection contains the usage interested
|
||||
ReportSetGroup reportSetGroup;
|
||||
|
||||
// one layer deep search
|
||||
for (auto &i : node->getChildren()) {
|
||||
// skip all nodes that is not a report node
|
||||
if (i->getNodeType() != HidTreeNode::TYPE_REPORT) {
|
||||
continue;
|
||||
}
|
||||
const HidReport &report =
|
||||
std::static_pointer_cast<HidReportNode>(i)->getReport();
|
||||
|
||||
unsigned int id = report.getReportId();;
|
||||
if (reportSetGroup.find(id) == reportSetGroup.end()) {
|
||||
// create an id group if it is not created
|
||||
reportSetGroup.emplace(id, ReportSet());
|
||||
}
|
||||
|
||||
ReportSet &reportGroup = reportSetGroup[id];
|
||||
switch(report.getType()) {
|
||||
using namespace HidDef::MainTag;
|
||||
case FEATURE:
|
||||
reportGroup[REPORT_TYPE_FEATURE].push_back(report);
|
||||
break;
|
||||
case INPUT:
|
||||
reportGroup[REPORT_TYPE_INPUT].push_back(report);
|
||||
break;
|
||||
case OUTPUT:
|
||||
reportGroup[REPORT_TYPE_OUTPUT].push_back(report);
|
||||
break;
|
||||
}
|
||||
}
|
||||
ReportDigest digest = {
|
||||
.fullUsage = node->getFullUsage(),
|
||||
.packets = convertGroupToPacket(reportSetGroup)
|
||||
};
|
||||
digestVector->emplace_back(digest);
|
||||
} else {
|
||||
for (const auto &child : node->getChildren()) {
|
||||
if (child->getNodeType() == HidTreeNode::TYPE_NORMAL) {
|
||||
// only follow into collection nodes
|
||||
digest(digestVector, child, interestedUsage);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<HidParser::ReportPacket> HidParser::convertGroupToPacket(
|
||||
const HidParser::ReportSetGroup &group) {
|
||||
std::vector<ReportPacket> packets;
|
||||
|
||||
const std::vector<int> types = {REPORT_TYPE_FEATURE, REPORT_TYPE_INPUT, REPORT_TYPE_OUTPUT};
|
||||
|
||||
for (const auto &setPair : group) {
|
||||
unsigned int id = setPair.first;
|
||||
for (auto type : types) {
|
||||
const auto &reports = setPair.second[type]; // feature
|
||||
|
||||
// template
|
||||
ReportPacket packet = {
|
||||
.type = type,
|
||||
.id = id,
|
||||
.bitSize = 0
|
||||
};
|
||||
|
||||
for (const auto &r : reports) {
|
||||
auto logical = r.getLogicalRange();
|
||||
auto physical = r.getPhysicalRange();
|
||||
|
||||
int64_t offset = physical.first - logical.first;
|
||||
double scale = static_cast<double>((physical.second - physical.first))
|
||||
/ (logical.second - logical.first);
|
||||
scale *= r.getExponentValue();
|
||||
|
||||
ReportItem digest = {
|
||||
.usage = r.getFullUsage(),
|
||||
.id = id,
|
||||
.minRaw = logical.first,
|
||||
.maxRaw = logical.second,
|
||||
.a = scale,
|
||||
.b = offset,
|
||||
.bitOffset = packet.bitSize,
|
||||
.bitSize = r.getSize(),
|
||||
.count = r.getCount(),
|
||||
.unit = r.getUnit(),
|
||||
};
|
||||
packet.reports.push_back(digest);
|
||||
packet.bitSize += digest.bitSize * digest.count;
|
||||
}
|
||||
if (!packet.reports.empty()) {
|
||||
packets.push_back(std::move(packet));
|
||||
}
|
||||
}
|
||||
}
|
||||
return packets;
|
||||
}
|
||||
|
||||
static std::string reportTypeToString(int reportType) {
|
||||
switch (reportType) {
|
||||
case HidParser::REPORT_TYPE_INPUT:
|
||||
return "INPUT";
|
||||
case HidParser::REPORT_TYPE_OUTPUT:
|
||||
return "OUTPUT";
|
||||
case HidParser::REPORT_TYPE_FEATURE:
|
||||
return "FEATURE";
|
||||
default:
|
||||
return "INVALID REPORT";
|
||||
}
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream &os, const HidParser::DigestVector &digests) {
|
||||
for (const auto &i : digests) {
|
||||
os << "Usage: 0x" << std::hex << i.fullUsage << std::dec
|
||||
<< ", " << i.packets.size() << " report packet:" << LOG_ENDL;
|
||||
for (const auto &packet : i.packets) {
|
||||
os << reportTypeToString(packet.type) << " id: " << packet.id
|
||||
<< " size: " << packet.bitSize
|
||||
<< "b(" << packet.getByteSize() << "B), "
|
||||
<< packet.reports.size() << " entries" << LOG_ENDL;
|
||||
|
||||
for (const auto &report : packet.reports) {
|
||||
double min, max;
|
||||
report.decode(report.mask(report.minRaw), &min);
|
||||
report.decode(report.mask(report.maxRaw), &max);
|
||||
|
||||
os << " " << report.bitOffset << " size: " << report.bitSize
|
||||
<< ", count: " << report.count
|
||||
<< ", usage: " << std::hex << std::setfill('0') << std::setw(8)
|
||||
<< report.usage << std::dec
|
||||
<< ", min: " << report.minRaw << ", max: " << report.maxRaw
|
||||
<< ", minDecoded: " << min
|
||||
<< ", maxDecoded: " << max
|
||||
<< ", a: " << report.a << ", b: " << report.b
|
||||
<< std::hex
|
||||
<< ", minRawHex: 0x" << report.mask(report.minRaw)
|
||||
<< ", maxRawHex: 0x" << report.mask(report.maxRaw)
|
||||
<< ", rawMasked: 0x" << report.rawMask()
|
||||
<< std::dec << LOG_ENDL;
|
||||
}
|
||||
}
|
||||
os << LOG_ENDL;
|
||||
}
|
||||
os << LOG_ENDL;
|
||||
return os;
|
||||
}
|
||||
} // namespace HidUtil
|
||||
178
modules/sensors/dynamic_sensor/HidUtils/HidParser.h
Normal file
178
modules/sensors/dynamic_sensor/HidUtils/HidParser.h
Normal file
|
|
@ -0,0 +1,178 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDPARSER_H_
|
||||
#define HIDUTIL_HIDPARSER_H_
|
||||
|
||||
#include "HidItem.h"
|
||||
#include "HidTree.h"
|
||||
#include "HidGlobal.h"
|
||||
#include "HidLocal.h"
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <vector>
|
||||
#include <array>
|
||||
#include <ostream>
|
||||
|
||||
namespace HidUtil {
|
||||
class HidParser {
|
||||
public:
|
||||
enum {
|
||||
REPORT_TYPE_FEATURE = 0,
|
||||
REPORT_TYPE_INPUT = 1,
|
||||
REPORT_TYPE_OUTPUT = 2
|
||||
};
|
||||
|
||||
struct ReportItem;
|
||||
struct ReportPacket;
|
||||
|
||||
// report (including input output and feature) grouped by full usage
|
||||
struct ReportDigest {
|
||||
unsigned int fullUsage;
|
||||
std::vector<ReportPacket> packets;
|
||||
};
|
||||
|
||||
typedef std::vector<ReportDigest> DigestVector;
|
||||
|
||||
// parse HID descriptor
|
||||
bool parse(const std::vector<HidItem> &token);
|
||||
bool parse(const unsigned char *begin, size_t size);
|
||||
|
||||
// filter the tree to eliminate single child report leaf node causes by usage array type
|
||||
// reports
|
||||
void filterTree();
|
||||
|
||||
// generate a list of report digest for all interested usage. It will automatically
|
||||
// call filterTree().
|
||||
DigestVector generateDigest(const std::unordered_set<unsigned int> &interestedUsage);
|
||||
|
||||
// get parsed tree (filtered or not filtered)
|
||||
const std::shared_ptr<HidTreeNode> getTree() const { return mTree; }
|
||||
|
||||
// get all parsed report in a parsed form.
|
||||
const std::vector<HidReport>& getReport() const { return mReport; }
|
||||
|
||||
private:
|
||||
typedef std::array<std::vector<HidReport>, 3> ReportSet;
|
||||
typedef std::unordered_map<unsigned int /* reportId */, ReportSet> ReportSetGroup;
|
||||
|
||||
// helper subroutines
|
||||
void reset();
|
||||
bool processMainTag(const HidItem &i);
|
||||
static void filterTree(std::shared_ptr<HidTreeNode> &node);
|
||||
static void digest(
|
||||
DigestVector *digestVector,
|
||||
const std::shared_ptr<HidTreeNode> &node,
|
||||
const std::unordered_set<unsigned int> &interestedUsage);
|
||||
static std::vector<ReportPacket> convertGroupToPacket(const ReportSetGroup &group);
|
||||
|
||||
HidGlobalStack mGlobalStack;
|
||||
HidLocal mLocal;
|
||||
std::shared_ptr<HidTreeNode> mTree;
|
||||
std::shared_ptr<HidTreeNode> mCurrent;
|
||||
std::vector<HidReport> mReport;
|
||||
};
|
||||
|
||||
struct HidParser::ReportItem {
|
||||
unsigned int usage;
|
||||
unsigned int id;
|
||||
int type; // feature, input or output
|
||||
|
||||
int64_t minRaw;
|
||||
int64_t maxRaw;
|
||||
|
||||
// conversion for float point values
|
||||
// real value = (signExtendIfNeeded(raw) + b) * a
|
||||
// raw value = mask(real/a - b);
|
||||
//
|
||||
// conversion for integer values
|
||||
// real value = signExtendedIfNeeded(raw) + b;
|
||||
// raw value = mask(real - b);
|
||||
double a; // scaling
|
||||
int64_t b; // offset
|
||||
unsigned int unit;
|
||||
|
||||
size_t bitOffset;
|
||||
size_t bitSize; // bit length per unit
|
||||
size_t count;
|
||||
|
||||
// helper function
|
||||
bool isSigned() const {
|
||||
return minRaw < 0;
|
||||
}
|
||||
|
||||
bool isByteAligned() const {
|
||||
return (bitOffset & 7) == 0 && (bitSize & 7) == 0;
|
||||
}
|
||||
|
||||
// convert raw values to unsigned format
|
||||
uint32_t mask(int64_t input) const {
|
||||
return static_cast<uint32_t>(input & rawMask());
|
||||
}
|
||||
|
||||
bool decode(uint32_t input, double *output) const {
|
||||
if (output == nullptr) {
|
||||
return false;
|
||||
}
|
||||
int64_t s = signExtendIfNeeded(input);
|
||||
if (s < minRaw || s > maxRaw) {
|
||||
return false;
|
||||
}
|
||||
*output = (s + b) * a;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool encode(double input, uint32_t *output) const {
|
||||
if (output == nullptr) {
|
||||
return false;
|
||||
}
|
||||
input = input / a - b;
|
||||
if (input < minRaw || input > maxRaw) {
|
||||
return false;
|
||||
}
|
||||
*output = static_cast<uint32_t>(static_cast<int64_t>(input) & rawMask());
|
||||
return true;
|
||||
}
|
||||
|
||||
int64_t rawMask() const {
|
||||
constexpr int64_t one = 1;
|
||||
return (one << bitSize) - 1;
|
||||
}
|
||||
|
||||
int64_t signExtendIfNeeded(int64_t value) const {
|
||||
return value | ((isSigned() && isNegative(value)) ? ~rawMask() : 0);
|
||||
}
|
||||
|
||||
bool isNegative(int64_t value) const {
|
||||
constexpr int64_t one = 1;
|
||||
return ((one << (bitSize - 1)) & value) != 0;
|
||||
}
|
||||
};
|
||||
|
||||
// a collection of report item that forms a packet
|
||||
// this is the input output unit with HID hardware
|
||||
struct HidParser::ReportPacket {
|
||||
std::vector<ReportItem> reports;
|
||||
size_t bitSize;
|
||||
int type; // REPORT_TYPE_FEATURE/INPUT/OUTPUT
|
||||
unsigned int id;
|
||||
|
||||
size_t getByteSize() const { return (bitSize + 7) / 8; };
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream &os, const HidParser::DigestVector &digest2);
|
||||
} // namespace HidUtil
|
||||
|
||||
#endif // HIDUTIL_HIDPARSER_H_
|
||||
229
modules/sensors/dynamic_sensor/HidUtils/HidReport.cpp
Normal file
229
modules/sensors/dynamic_sensor/HidUtils/HidReport.cpp
Normal file
|
|
@ -0,0 +1,229 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "HidReport.h"
|
||||
#include "HidDefs.h"
|
||||
#include <cmath>
|
||||
#include <sstream>
|
||||
#include <iomanip>
|
||||
|
||||
namespace HidUtil {
|
||||
HidReport::HidReport(uint32_t type, uint32_t data,
|
||||
const HidGlobal &global, const HidLocal &local)
|
||||
: mReportType(type),
|
||||
mFlag(data),
|
||||
mUsagePage(global.usagePage.get(0)), // default value 0
|
||||
mUsage(local.getUsage(0)),
|
||||
mUsageVector(local.usage),
|
||||
mLogicalMin(global.logicalMin.get(0)), // default value 0
|
||||
mLogicalMax(global.logicalMax.get(0)),
|
||||
mReportSize(global.reportSize),
|
||||
mReportCount(global.reportCount),
|
||||
mPhysicalMin(global.physicalMin),
|
||||
mPhysicalMax(global.physicalMax),
|
||||
mExponent(global.exponent),
|
||||
mUnit(global.unit),
|
||||
mReportId(global.reportId) { }
|
||||
|
||||
std::string HidReport::getStringType() const {
|
||||
return reportTypeToString(mReportType);
|
||||
}
|
||||
|
||||
std::string HidReport::reportTypeToString(int type) {
|
||||
using namespace HidDef::MainTag;
|
||||
switch(type) {
|
||||
case INPUT:
|
||||
return "INPUT";
|
||||
case OUTPUT:
|
||||
return "OUTPUT";
|
||||
case FEATURE:
|
||||
return "FEATURE";
|
||||
default:
|
||||
return "<<UNKNOWN>>";
|
||||
}
|
||||
}
|
||||
|
||||
double HidReport::getExponentValue() const {
|
||||
if (!mExponent.isSet()) {
|
||||
return 1;
|
||||
}
|
||||
// default exponent is 0
|
||||
int exponentInt = mExponent.get(0);
|
||||
if (exponentInt > 15 || exponentInt < 0) {
|
||||
return NAN;
|
||||
}
|
||||
return pow(10.0, static_cast<double>((exponentInt <= 7) ? exponentInt : exponentInt - 16));
|
||||
}
|
||||
|
||||
std::string HidReport::getExponentString() const {
|
||||
int exponentInt = mExponent.get(0);
|
||||
if (exponentInt > 15 || exponentInt < 0) {
|
||||
return "[error]";
|
||||
}
|
||||
return std::string("x10^")
|
||||
+ std::to_string((exponentInt <= 7) ? exponentInt : exponentInt - 16);
|
||||
}
|
||||
|
||||
std::string HidReport::getUnitString() const {
|
||||
if (!mUnit.isSet()) {
|
||||
return "default";
|
||||
}
|
||||
return "[not implemented]";
|
||||
|
||||
std::ostringstream ret;
|
||||
ret << std::hex << std::setfill('0') << std::setw(2) << mUnit.get(0);
|
||||
return ret.str();
|
||||
}
|
||||
|
||||
std::string HidReport::getFlagString() const {
|
||||
using namespace HidDef::ReportFlag;
|
||||
std::string ret;
|
||||
ret += (mFlag & DATA_CONST) ? "Const " : "Data ";
|
||||
ret += (mFlag & ARRAY_VARIABLE) ? "Variable " : "Array ";
|
||||
ret += (mFlag & WRAP) ? "Wrap " : "";
|
||||
ret += (mFlag & NONLINEAR) ? "Nonlinear " : "";
|
||||
ret += (mFlag & NO_PREFERRED) ? "NoPreferred " : "";
|
||||
ret += (mFlag & NULL_STATE) ? "NullState " : "";
|
||||
ret += (mFlag & VOLATILE) ? "Volatile " : "";
|
||||
ret += (mFlag & BUFFERED_BYTES) ? "BufferedBytes " : "";
|
||||
return ret;
|
||||
}
|
||||
|
||||
// isArray() will return true for reports that may contains multiple values, e.g. keyboard scan
|
||||
// code, which can have multiple value, each denoting a key pressed down at the same time. It will
|
||||
// return false if repor represent a vector or matrix.
|
||||
//
|
||||
// This slightly deviates from HID's definition, it is more convenient this way as matrix/vector
|
||||
// input is treated similarly as variables.
|
||||
bool HidReport::isArray() const {
|
||||
using namespace HidDef::ReportFlag;
|
||||
return (mFlag & ARRAY_VARIABLE) == 0 && mIsCollapsed;
|
||||
}
|
||||
|
||||
bool HidReport::isVariable() const {
|
||||
return !isArray();
|
||||
}
|
||||
|
||||
bool HidReport::isData() const {
|
||||
using namespace HidDef::ReportFlag;
|
||||
return (mFlag & DATA_CONST) == 0;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const HidReport& h) {
|
||||
os << h.getStringType() << ", "
|
||||
<< "usage: " << std::hex << h.getFullUsage() << std::dec << ", ";
|
||||
|
||||
if (h.isData()) {
|
||||
auto range = h.getLogicalRange();
|
||||
os << "logMin: " << range.first << ", "
|
||||
<< "logMax: " << range.second << ", ";
|
||||
|
||||
if (range == h.getPhysicalRange()) {
|
||||
os << "phy===log, ";
|
||||
} else {
|
||||
range = h.getPhysicalRange();
|
||||
os << "phyMin: " << range.first << ", "
|
||||
<< "phyMax: " << range.second << ", ";
|
||||
}
|
||||
|
||||
if (h.isArray()) {
|
||||
os << "map: (" << std::hex;
|
||||
for (auto i : h.getUsageVector()) {
|
||||
os << i << ",";
|
||||
}
|
||||
os << "), " << std::dec;
|
||||
}
|
||||
|
||||
os << "exponent: " << h.getExponentString() << ", "
|
||||
<< "unit: " << h.getUnitString() << ", ";
|
||||
} else {
|
||||
os << "constant: ";
|
||||
}
|
||||
os << "size: " << h.getSize() << "bit x " << h.getCount() << ", "
|
||||
<< "id: " << h.mReportId;
|
||||
|
||||
return os;
|
||||
}
|
||||
|
||||
std::pair<int64_t, int64_t> HidReport::getLogicalRange() const {
|
||||
int64_t a = mLogicalMin;
|
||||
int64_t b = mLogicalMax;
|
||||
|
||||
if (a > b) {
|
||||
// might be unsigned
|
||||
a = a & ((static_cast<int64_t>(1) << getSize()) - 1);
|
||||
b = b & ((static_cast<int64_t>(1) << getSize()) - 1);
|
||||
if (a > b) {
|
||||
// bad hid descriptor
|
||||
return {0, 0};
|
||||
}
|
||||
}
|
||||
return {a, b};
|
||||
}
|
||||
|
||||
std::pair<int64_t, int64_t> HidReport::getPhysicalRange() const {
|
||||
if (!(mPhysicalMin.isSet() && mPhysicalMax.isSet())) {
|
||||
// physical range undefined, use logical range
|
||||
return getLogicalRange();
|
||||
}
|
||||
|
||||
int64_t a = mPhysicalMin.get(0);
|
||||
int64_t b = mPhysicalMax.get(0);
|
||||
|
||||
if (a > b) {
|
||||
a = a & ((static_cast<int64_t>(1) << getSize()) - 1);
|
||||
b = b & ((static_cast<int64_t>(1) << getSize()) - 1);
|
||||
if (a > b) {
|
||||
return {0, 0};
|
||||
}
|
||||
}
|
||||
return {a, b};
|
||||
}
|
||||
|
||||
unsigned int HidReport::getFullUsage() const {
|
||||
return mUsage | (mUsagePage << 16);
|
||||
}
|
||||
|
||||
size_t HidReport::getSize() const {
|
||||
return mReportSize;
|
||||
}
|
||||
|
||||
size_t HidReport::getCount() const {
|
||||
return mReportCount;
|
||||
}
|
||||
|
||||
unsigned int HidReport::getUnit() const {
|
||||
return mUnit.get(0); // default unit is 0 means default unit
|
||||
}
|
||||
|
||||
unsigned HidReport::getReportId() const {
|
||||
// if report id is not specified, it defaults to zero
|
||||
return mReportId.get(0);
|
||||
}
|
||||
|
||||
unsigned HidReport::getType() const {
|
||||
return mReportType;
|
||||
}
|
||||
|
||||
void HidReport::setCollapsed(uint32_t fullUsage) {
|
||||
mUsage = fullUsage & 0xFFFF;
|
||||
mUsagePage = fullUsage >> 16;
|
||||
mIsCollapsed = true;
|
||||
}
|
||||
|
||||
const std::vector<unsigned int>& HidReport::getUsageVector() const {
|
||||
return mUsageVector;
|
||||
}
|
||||
} // namespace HidUtil
|
||||
100
modules/sensors/dynamic_sensor/HidUtils/HidReport.h
Normal file
100
modules/sensors/dynamic_sensor/HidUtils/HidReport.h
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDREPORT_H_
|
||||
#define HIDUTIL_HIDREPORT_H_
|
||||
|
||||
#include "HidGlobal.h"
|
||||
#include "HidLocal.h"
|
||||
#include "TriState.h"
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <iostream>
|
||||
#include <utility>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
class HidParser;
|
||||
class HidTreeNode;
|
||||
|
||||
// HidReport represent an input, output or feature report
|
||||
class HidReport {
|
||||
friend std::ostream& operator<<(std::ostream& os, const HidReport& h);
|
||||
public:
|
||||
HidReport(uint32_t type_, uint32_t data, const HidGlobal &global, const HidLocal &local);
|
||||
|
||||
// This is called during parsing process when the parser regroups multi-valued report into one
|
||||
void setCollapsed(uint32_t fullUsage);
|
||||
|
||||
// get report id
|
||||
unsigned int getReportId() const;
|
||||
// get type of report, return constant of HidDef::MainTag
|
||||
unsigned int getType() const;
|
||||
// Full sensor usage
|
||||
unsigned int getFullUsage() const;
|
||||
|
||||
// binary properties
|
||||
bool isArray() const;
|
||||
bool isData() const;
|
||||
bool isVariable() const;
|
||||
|
||||
// logical and physical value range
|
||||
std::pair<int64_t, int64_t> getLogicalRange() const;
|
||||
std::pair<int64_t, int64_t> getPhysicalRange() const;
|
||||
double getExponentValue() const;
|
||||
|
||||
// return HID unit nibbles in an unsigned int
|
||||
unsigned int getUnit() const;
|
||||
|
||||
// size in bits
|
||||
size_t getSize() const;
|
||||
// dimension (if it is vector/matrix) or number of concurrent input values
|
||||
// it is also used to calculate memory foot print
|
||||
size_t getCount() const;
|
||||
|
||||
// for output to stream
|
||||
static std::string reportTypeToString(int type);
|
||||
std::string getStringType() const;
|
||||
std::string getExponentString() const;
|
||||
std::string getUnitString() const;
|
||||
std::string getFlagString() const;
|
||||
const std::vector<unsigned int>& getUsageVector() const;
|
||||
private:
|
||||
bool mIsCollapsed;
|
||||
|
||||
// mandatary fields
|
||||
unsigned int mReportType;
|
||||
unsigned int mFlag;
|
||||
unsigned int mUsagePage;
|
||||
unsigned int mUsage;
|
||||
std::vector<unsigned int> mUsageVector;
|
||||
|
||||
int mLogicalMin; // 32 bit is enough
|
||||
int mLogicalMax;
|
||||
unsigned int mReportSize;
|
||||
unsigned int mReportCount;
|
||||
|
||||
// these below are optional
|
||||
tri_int mPhysicalMin;
|
||||
tri_int mPhysicalMax;
|
||||
|
||||
tri_uint mExponent;
|
||||
tri_uint mUnit;
|
||||
tri_uint mReportId;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const HidReport& h);
|
||||
} // namespace HidUtil
|
||||
#endif // HIDUTIL_HIDREPORT_H_
|
||||
127
modules/sensors/dynamic_sensor/HidUtils/HidTree.cpp
Normal file
127
modules/sensors/dynamic_sensor/HidUtils/HidTree.cpp
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "HidDefs.h"
|
||||
#include "HidLog.h"
|
||||
#include "HidTree.h"
|
||||
#include <memory>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
// HidTreeNode
|
||||
HidTreeNode::HidTreeNode() : mNodeType(TYPE_UNINITIALIZED), mData(0), mFullUsage(0) {
|
||||
}
|
||||
|
||||
HidTreeNode::HidTreeNode(std::shared_ptr<HidTreeNode> parent,
|
||||
uint32_t data, uint32_t fullUsage, int nodeType)
|
||||
: mNodeType(nodeType), mData(data),
|
||||
mFullUsage(fullUsage), mParent(parent) {
|
||||
}
|
||||
|
||||
HidTreeNode::HidTreeNode(std::shared_ptr<HidTreeNode> parent,
|
||||
uint32_t data, uint32_t fullUsage)
|
||||
: mNodeType(TYPE_NORMAL), mData(data),
|
||||
mFullUsage(fullUsage), mParent(parent) {
|
||||
}
|
||||
|
||||
void HidTreeNode::outputRecursive(std::ostream &os, int level) const {
|
||||
insertIndentation(os, level);
|
||||
os << "Node data: " << mData
|
||||
<< ", usage " << std::hex << mFullUsage << std::dec << LOG_ENDL;
|
||||
|
||||
for (auto &child : mChildren) {
|
||||
child->outputRecursive(os, level + 1);
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<HidTreeNode> HidTreeNode::deepCopy(
|
||||
std::shared_ptr<HidTreeNode> parent) const {
|
||||
std::shared_ptr<HidTreeNode> copy(new HidTreeNode(parent, mData, mFullUsage, mNodeType));
|
||||
for (auto &i : mChildren) {
|
||||
copy->mChildren.push_back(i->deepCopy(copy));
|
||||
}
|
||||
return copy;
|
||||
}
|
||||
|
||||
void HidTreeNode::insertIndentation(std::ostream &os, int level) const {
|
||||
constexpr char indentCharacter = '\t';
|
||||
std::fill_n(std::ostreambuf_iterator<char>(os), level, indentCharacter);
|
||||
}
|
||||
|
||||
std::shared_ptr<HidTreeNode> HidTreeNode::addChild(std::shared_ptr<HidTreeNode> child) {
|
||||
mChildren.push_back(child);
|
||||
return child;
|
||||
}
|
||||
|
||||
std::shared_ptr<HidTreeNode> HidTreeNode::getParent() const {
|
||||
return mParent.lock();
|
||||
}
|
||||
|
||||
bool HidTreeNode::isReportCollection() const {
|
||||
return mNodeType == TYPE_NORMAL && mChildren.size() == 1
|
||||
&& mChildren.front()->mNodeType == TYPE_REPORT;
|
||||
}
|
||||
|
||||
unsigned int HidTreeNode::getFullUsage() const {
|
||||
return mFullUsage;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<HidTreeNode>>& HidTreeNode::getChildren() {
|
||||
return mChildren;
|
||||
}
|
||||
|
||||
const std::vector<std::shared_ptr<HidTreeNode>>& HidTreeNode::getChildren() const {
|
||||
return mChildren;
|
||||
}
|
||||
|
||||
bool HidTreeNode::isUsageCollection() const {
|
||||
using namespace HidDef::CollectionType;
|
||||
return mNodeType == TYPE_NORMAL && (mData == PHYSICAL || mData == APPLICATION);
|
||||
}
|
||||
|
||||
int HidTreeNode::getNodeType() const {
|
||||
return mNodeType;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const HidTreeNode& n) {
|
||||
n.outputRecursive(os, 0);
|
||||
return os;
|
||||
}
|
||||
|
||||
// HidReportNode
|
||||
HidReportNode::HidReportNode(std::shared_ptr<HidTreeNode> parent, const HidReport &report)
|
||||
: HidTreeNode(parent, 0 /*data*/, 0 /*fullUsage*/, TYPE_REPORT), mReport(report) {
|
||||
}
|
||||
|
||||
void HidReportNode::outputRecursive(std::ostream &os, int level) const {
|
||||
insertIndentation(os, level);
|
||||
os << mReport << LOG_ENDL;
|
||||
}
|
||||
|
||||
std::shared_ptr<HidTreeNode> HidReportNode::deepCopy(
|
||||
std::shared_ptr<HidTreeNode> parent) const {
|
||||
std::shared_ptr<HidTreeNode> copy(new HidReportNode(parent, mReport));
|
||||
return copy;
|
||||
}
|
||||
|
||||
const HidReport& HidReportNode::getReport() const {
|
||||
return mReport;
|
||||
}
|
||||
|
||||
void HidReportNode::collapse(unsigned int newUsage) {
|
||||
mReport.setCollapsed(newUsage);
|
||||
}
|
||||
|
||||
} //namespace HidUtil
|
||||
103
modules/sensors/dynamic_sensor/HidUtils/HidTree.h
Normal file
103
modules/sensors/dynamic_sensor/HidUtils/HidTree.h
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_HIDTREE_H_
|
||||
#define HIDUTIL_HIDTREE_H_
|
||||
|
||||
#include "HidReport.h"
|
||||
|
||||
#include <cstddef>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
// HID report parser output tree node
|
||||
class HidTreeNode {
|
||||
friend std::ostream& operator<<(std::ostream& os, const HidTreeNode& n);
|
||||
public:
|
||||
enum {
|
||||
TYPE_UNINITIALIZED = 0,
|
||||
TYPE_NORMAL = 1,
|
||||
TYPE_REPORT = 2 // can be cast to HidReportNode
|
||||
};
|
||||
HidTreeNode();
|
||||
HidTreeNode(std::shared_ptr<HidTreeNode> parent, uint32_t data, uint32_t fullUsage);
|
||||
|
||||
virtual ~HidTreeNode() = default;
|
||||
|
||||
// make a deep copy of tree at and below this node and attach it to specified parent node
|
||||
virtual std::shared_ptr<HidTreeNode> deepCopy(
|
||||
std::shared_ptr<HidTreeNode> parent = nullptr) const;
|
||||
|
||||
// add child to this node
|
||||
std::shared_ptr<HidTreeNode> addChild(std::shared_ptr<HidTreeNode> child);
|
||||
|
||||
// get all children of a node
|
||||
std::vector<std::shared_ptr<HidTreeNode>>& getChildren();
|
||||
const std::vector<std::shared_ptr<HidTreeNode>>& getChildren() const;
|
||||
|
||||
// get parent (nullptr if it is root node or if lock weak_ptr failed)
|
||||
std::shared_ptr<HidTreeNode> getParent() const;
|
||||
|
||||
// access usage of this node
|
||||
unsigned int getFullUsage() const;
|
||||
|
||||
bool isReportCollection() const;
|
||||
bool isUsageCollection() const;
|
||||
int getNodeType() const;
|
||||
protected:
|
||||
// for derived class to define different nodeType
|
||||
HidTreeNode(std::shared_ptr<HidTreeNode> parent,
|
||||
uint32_t data, uint32_t fullUsage, int nodeType);
|
||||
|
||||
// helper for stream output
|
||||
void insertIndentation(std::ostream &os, int level) const;
|
||||
private:
|
||||
// helper for stream output
|
||||
virtual void outputRecursive(std::ostream& os, int level) const;
|
||||
|
||||
int mNodeType;
|
||||
uint32_t mData;
|
||||
uint32_t mFullUsage;
|
||||
|
||||
std::vector<std::shared_ptr<HidTreeNode>> mChildren;
|
||||
std::weak_ptr<HidTreeNode> mParent;
|
||||
};
|
||||
|
||||
// Tree node that corresponds to an input, output or feature report
|
||||
class HidReportNode : public HidTreeNode {
|
||||
public:
|
||||
HidReportNode(std::shared_ptr<HidTreeNode> parent, const HidReport &report);
|
||||
|
||||
virtual std::shared_ptr<HidTreeNode> deepCopy(
|
||||
std::shared_ptr<HidTreeNode> parent = nullptr) const override;
|
||||
|
||||
// obtain HidReport attached to this node
|
||||
const HidReport& getReport() const;
|
||||
|
||||
// reset usage of node and set underlying report to collapsed
|
||||
void collapse(unsigned int newUsage);
|
||||
private:
|
||||
virtual void outputRecursive(std::ostream &os, int level) const override;
|
||||
|
||||
HidReport mReport;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const HidTreeNode& n);
|
||||
|
||||
} // namespace HidUtil
|
||||
|
||||
#endif // HIDUTIL_HIDTREE_H_
|
||||
177
modules/sensors/dynamic_sensor/HidUtils/StreamIoUtil.h
Normal file
177
modules/sensors/dynamic_sensor/HidUtils/StreamIoUtil.h
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_STREAM_IO_UTIL_H_
|
||||
#define HIDUTIL_STREAM_IO_UTIL_H_
|
||||
|
||||
#include "HidLog.h"
|
||||
#include <istream>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
#include <cassert>
|
||||
|
||||
namespace HidUtil {
|
||||
|
||||
template<typename CharT>
|
||||
class charvectorbuf : public std::streambuf { // class name is consistent with std lib
|
||||
static_assert(std::is_const<CharT>::value == false, "cannot use const type");
|
||||
public:
|
||||
// r/w buffer constructors
|
||||
charvectorbuf(std::vector<CharT> &vec) {
|
||||
init(vec.data(), vec.size());
|
||||
}
|
||||
|
||||
charvectorbuf(CharT *begin, CharT *end) {
|
||||
assert(end >= begin);
|
||||
init(begin, end - begin);
|
||||
}
|
||||
|
||||
charvectorbuf(CharT *begin, size_t size) {
|
||||
init(begin, size);
|
||||
}
|
||||
|
||||
// r/o buffer constructor
|
||||
charvectorbuf(const std::vector<CharT> &vec) {
|
||||
init(vec.data(), vec.size());
|
||||
}
|
||||
|
||||
charvectorbuf(const CharT *begin, const CharT *end) {
|
||||
assert(end >= begin);
|
||||
init(begin, end - begin);
|
||||
}
|
||||
|
||||
charvectorbuf(const CharT *begin, size_t size) {
|
||||
init(begin, size);
|
||||
}
|
||||
protected:
|
||||
virtual std::streampos seekpos(
|
||||
std::streampos sp, std::ios_base::openmode which =
|
||||
std::ios_base::in | std::ios_base::out) override {
|
||||
return seekoff(std::streamoff(sp), std::ios_base::beg, which);
|
||||
}
|
||||
|
||||
// this is needed to use ftell() on stream
|
||||
virtual std::streampos seekoff(
|
||||
std::streamoff off, std::ios_base::seekdir way,
|
||||
std::ios_base::openmode which =
|
||||
std::ios_base::in | std::ios_base::out) override {
|
||||
|
||||
// pptr() == nullptr: read-only
|
||||
assert(pptr() == nullptr || egptr() - eback() == epptr() - pbase());
|
||||
bool in = which & std::ios_base::in;
|
||||
bool out = which & std::ios_base::out;
|
||||
pos_type end = egptr() - eback();
|
||||
|
||||
if (!in && !out) {
|
||||
return pos_type(-1);
|
||||
}
|
||||
|
||||
if (in && out && way == std::ios_base::cur) {
|
||||
return pos_type(-1);
|
||||
}
|
||||
|
||||
off_type noff;
|
||||
switch (way) {
|
||||
case std::ios_base::beg:
|
||||
noff = 0;
|
||||
break;
|
||||
case std::ios_base::cur:
|
||||
if (in) {
|
||||
noff = gptr() - eback();
|
||||
} else {
|
||||
noff = pptr() - pbase();
|
||||
}
|
||||
break;
|
||||
case std::ios_base::end:
|
||||
noff = end;
|
||||
break;
|
||||
default:
|
||||
return pos_type(-1);
|
||||
}
|
||||
noff += off;
|
||||
if (noff < 0 || noff > end) {
|
||||
return pos_type(-1);
|
||||
}
|
||||
|
||||
if (noff != 0 && ((in && gptr() == nullptr) || (out && pptr() == nullptr))) {
|
||||
return pos_type(-1);
|
||||
}
|
||||
|
||||
if (in) {
|
||||
setg(eback(), eback() + noff, egptr());
|
||||
}
|
||||
|
||||
if (out) {
|
||||
setp(pbase(), epptr());
|
||||
pbump(noff);
|
||||
}
|
||||
|
||||
return pos_type(noff);
|
||||
}
|
||||
private:
|
||||
// read only buffer init
|
||||
void init(const CharT *base, size_t size) {
|
||||
setg((char*)base, (char*)base, (char*)(base + size));
|
||||
}
|
||||
|
||||
// read write buffer init
|
||||
void init(CharT *base, size_t size) {
|
||||
setg((char*)base, (char*)base, (char*)(base + size));
|
||||
setp((char*)base, (char*)(base + size));
|
||||
}
|
||||
};
|
||||
|
||||
// dump binary values
|
||||
template <class ForwardIterator>
|
||||
void hexdumpToStream(std::ostream &os, const ForwardIterator &first, const ForwardIterator &last) {
|
||||
static_assert(
|
||||
std::is_convertible<
|
||||
typename std::iterator_traits<ForwardIterator>::iterator_category,
|
||||
std::forward_iterator_tag>::value
|
||||
&& std::is_convertible<
|
||||
typename std::iterator_traits<ForwardIterator>::value_type,
|
||||
unsigned char>::value
|
||||
&& sizeof(typename std::iterator_traits<ForwardIterator>::value_type)
|
||||
== sizeof(unsigned char),
|
||||
"Only accepts forward iterator of a type of size 1 "
|
||||
"that can be convert to unsigned char.\n");
|
||||
size_t c = 0;
|
||||
std::ostringstream ss;
|
||||
for (ForwardIterator i = first; i != last; ++i, ++c) {
|
||||
unsigned char v = *i;
|
||||
// formatting
|
||||
switch (c & 0xf) {
|
||||
case 0:
|
||||
// address
|
||||
os << ss.str() << LOG_ENDL;
|
||||
ss.str("");
|
||||
ss << std::hex;
|
||||
ss << std::setfill('0') << std::setw(4) << c << ": ";
|
||||
break;
|
||||
case 8:
|
||||
// space
|
||||
ss << " ";
|
||||
break;
|
||||
}
|
||||
ss << std::setfill('0') << std::setw(2)
|
||||
<< static_cast<unsigned>(static_cast<unsigned char>(v)) << " ";
|
||||
}
|
||||
os << ss.str() << LOG_ENDL;
|
||||
}
|
||||
} //namespace HidUtil
|
||||
|
||||
#endif // HIDUTIL_STREAM_IO_UTIL_H_
|
||||
|
||||
254
modules/sensors/dynamic_sensor/HidUtils/TriState.h
Normal file
254
modules/sensors/dynamic_sensor/HidUtils/TriState.h
Normal file
|
|
@ -0,0 +1,254 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_TRISTATE_H_
|
||||
#define HIDUTIL_TRISTATE_H_
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
namespace HidUtil {
|
||||
template<typename T>
|
||||
class TriState {
|
||||
public:
|
||||
// constructor
|
||||
TriState() : mIsSet(false) { }
|
||||
TriState(const TriState<T> &other) : mIsSet(other.mIsSet), mValue(other.mValue) { }
|
||||
explicit TriState(const T &value) : mIsSet(true), mValue(value) { }
|
||||
|
||||
void clear() {
|
||||
mValue = T();
|
||||
mIsSet = false;
|
||||
}
|
||||
bool isSet() const {
|
||||
return mIsSet;
|
||||
}
|
||||
|
||||
const T get(const T &defaultValue) const {
|
||||
return isSet() ? mValue : defaultValue;
|
||||
}
|
||||
|
||||
// operator overloading
|
||||
explicit operator T () const {
|
||||
assert(mIsSet);
|
||||
return mValue;
|
||||
}
|
||||
|
||||
TriState<T>& operator=(const TriState<T> &other) {
|
||||
mIsSet = other.mIsSet;
|
||||
mValue = other.mValue;
|
||||
return *this;
|
||||
}
|
||||
|
||||
TriState<T>& operator=(const T& value) {
|
||||
mIsSet = true;
|
||||
mValue = value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
TriState<T>& operator++() {
|
||||
if (mIsSet) {
|
||||
mValue++;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
TriState<T> operator++(int) {
|
||||
TriState<T> tmp(*this);
|
||||
operator++();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
TriState<T>& operator--() {
|
||||
if (mIsSet) {
|
||||
mValue--;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
TriState<T> operator--(int) {
|
||||
TriState<T> tmp(*this);
|
||||
operator--();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
#define UNARY_OP(op) \
|
||||
TriState<T> operator op() { \
|
||||
TriState<T> tmp(*this); \
|
||||
if (mIsSet) { \
|
||||
tmp.mValue = op tmp.mValue; \
|
||||
} \
|
||||
return tmp; \
|
||||
}
|
||||
|
||||
UNARY_OP(!);
|
||||
UNARY_OP(-);
|
||||
UNARY_OP(~);
|
||||
#undef UNARY_OP
|
||||
|
||||
#define COMPOUND_ASSIGN_OP(op) \
|
||||
TriState<T>& operator op (const TriState<T>& rhs) { \
|
||||
if (mIsSet && rhs.mIsSet) { \
|
||||
mValue op rhs.mValue; \
|
||||
} else { \
|
||||
mIsSet = false; \
|
||||
} \
|
||||
return *this; \
|
||||
} \
|
||||
TriState<T>& operator op(const T& rhs) { \
|
||||
if (mIsSet) { \
|
||||
mValue op rhs; \
|
||||
} \
|
||||
return *this; \
|
||||
}
|
||||
|
||||
COMPOUND_ASSIGN_OP(+=);
|
||||
COMPOUND_ASSIGN_OP(-=);
|
||||
COMPOUND_ASSIGN_OP(*=);
|
||||
COMPOUND_ASSIGN_OP(/=);
|
||||
COMPOUND_ASSIGN_OP(%=);
|
||||
COMPOUND_ASSIGN_OP(&=);
|
||||
COMPOUND_ASSIGN_OP(|=);
|
||||
COMPOUND_ASSIGN_OP(^=);
|
||||
#undef COMPOUND_ASSIGN_OP
|
||||
|
||||
TriState<T>& operator >>=(int i) {
|
||||
if (mIsSet) {
|
||||
mValue >>= i;
|
||||
}
|
||||
return *this; \
|
||||
}
|
||||
|
||||
TriState<T>& operator <<=(int i) {
|
||||
if (mIsSet) {
|
||||
mValue <<= i;
|
||||
}
|
||||
return *this; \
|
||||
}
|
||||
|
||||
TriState<T> operator <<(int i) { \
|
||||
TriState<T> tmp(*this);
|
||||
operator<<(i);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
TriState<T> operator >>(int i) { \
|
||||
TriState<T> tmp(*this);
|
||||
operator>>(i);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
#define BINARY_OP(op, compound_op) \
|
||||
friend TriState<T> operator op(TriState<T> lhs, const TriState<T>& rhs) { \
|
||||
lhs compound_op rhs; \
|
||||
return lhs; \
|
||||
}\
|
||||
friend TriState<T> operator op(TriState<T> lhs, const T& rhs) { \
|
||||
lhs compound_op rhs; \
|
||||
return lhs; \
|
||||
}\
|
||||
friend TriState<T> operator op(const T &lhs, const TriState<T>& rhs) { \
|
||||
TriState<T> tmp(lhs); \
|
||||
return tmp op rhs; \
|
||||
}
|
||||
|
||||
BINARY_OP(+, +=);
|
||||
BINARY_OP(-, -=);
|
||||
BINARY_OP(*, *=);
|
||||
BINARY_OP(/, /=);
|
||||
BINARY_OP(%, %=);
|
||||
BINARY_OP(&, &=);
|
||||
BINARY_OP(|, |=);
|
||||
BINARY_OP(^, ^=);
|
||||
#undef BINARY_OP
|
||||
|
||||
#define RELATION_OP(op) \
|
||||
friend TriState<bool> operator op(const TriState<T>& lhs, const TriState<T>& rhs) { \
|
||||
if (lhs.mIsSet && rhs.mIsSet) { \
|
||||
return TriState<bool>(lhs.mValue op rhs.mValue); \
|
||||
} else { \
|
||||
return TriState<bool>(); \
|
||||
} \
|
||||
} \
|
||||
friend TriState<bool> operator op(const TriState<T>& lhs, const T& rhs) { \
|
||||
if (lhs.mIsSet) { \
|
||||
return TriState<bool>(lhs.mValue op rhs); \
|
||||
} else { \
|
||||
return TriState<bool>(); \
|
||||
} \
|
||||
} \
|
||||
friend TriState<bool> operator op(const T& lhs, const TriState<T>& rhs) { \
|
||||
if (rhs.mIsSet) { \
|
||||
return TriState<bool>(lhs op rhs.mValue); \
|
||||
} else { \
|
||||
return TriState<bool>(); \
|
||||
} \
|
||||
}
|
||||
|
||||
RELATION_OP(==);
|
||||
RELATION_OP(!=);
|
||||
RELATION_OP(>=);
|
||||
RELATION_OP(<=);
|
||||
RELATION_OP(>);
|
||||
RELATION_OP(<);
|
||||
#undef RELATION_OP
|
||||
|
||||
friend TriState<bool> operator &&(TriState<T>& lhs, const TriState<T>& rhs) {
|
||||
if (lhs.mIsSet && rhs.mIsSet) {
|
||||
return TriState<bool>(lhs.mValue && rhs.mValue);
|
||||
} else {
|
||||
return TriState<bool>();
|
||||
}
|
||||
}
|
||||
|
||||
friend TriState<bool> operator ||(TriState<T>& lhs, const TriState<T>& rhs) {
|
||||
if (lhs.mIsSet && rhs.mIsSet) {
|
||||
return TriState<bool>(lhs.mValue || rhs.mValue);
|
||||
} else {
|
||||
return TriState<bool>();
|
||||
}
|
||||
}
|
||||
|
||||
friend std::ostream& operator <<(std::ostream &os, const TriState<T> &v) {
|
||||
if (v.mIsSet) {
|
||||
os << v.mValue;
|
||||
} else {
|
||||
os << "[not set]";
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
friend std::istream& operator >>(std::istream &is, const TriState<T> &v) {
|
||||
T a;
|
||||
is >> a;
|
||||
v = TriState<T>(a);
|
||||
return is;
|
||||
}
|
||||
private:
|
||||
bool mIsSet;
|
||||
T mValue;
|
||||
};
|
||||
|
||||
// commonly used ones
|
||||
typedef TriState<unsigned> tri_uint;
|
||||
typedef TriState<int> tri_int;
|
||||
|
||||
typedef TriState<uint32_t> tri_uint32_t;
|
||||
typedef TriState<int32_t> tri_int32_t;
|
||||
typedef TriState<uint8_t> tri_uint8_t;
|
||||
typedef TriState<uint16_t> tri_uint16_t;
|
||||
}
|
||||
|
||||
#endif // HIDUTIL_TRISTATE_H_
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "HidLog.h"
|
||||
#include "HidParser.h"
|
||||
#include "TestHidDescriptor.h"
|
||||
#include <errno.h>
|
||||
|
||||
using HidUtil::HidParser;
|
||||
|
||||
bool doParse() {
|
||||
HidParser hidParser;
|
||||
bool ret = true;
|
||||
|
||||
for (const TestHidDescriptor *p = gDescriptorArray; ; ++p) {
|
||||
if (p->data == nullptr || p->len == 0) {
|
||||
break;
|
||||
}
|
||||
const char *name = p->name != nullptr ? p->name : "unnamed";
|
||||
bool parseResult = hidParser.parse(p->data, p->len);
|
||||
|
||||
if (parseResult) {
|
||||
LOG_V << name << " filtered tree: " << LOG_ENDL;
|
||||
LOG_V << *(hidParser.getTree());
|
||||
} else {
|
||||
ret = false;
|
||||
LOG_E << name << " parsing error!" << LOG_ENDL;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool doParseAndFilter() {
|
||||
HidParser hidParser;
|
||||
bool ret = true;
|
||||
|
||||
for (const TestHidDescriptor *p = gDescriptorArray; ; ++p) {
|
||||
if (p->data == nullptr || p->len == 0) {
|
||||
break;
|
||||
}
|
||||
const char *name = p->name != nullptr ? p->name : "unnamed";
|
||||
bool parseResult = hidParser.parse(p->data, p->len);
|
||||
|
||||
if (parseResult) {
|
||||
hidParser.filterTree();
|
||||
LOG_V << name << " filtered tree: " << LOG_ENDL;
|
||||
LOG_V << *(hidParser.getTree());
|
||||
} else {
|
||||
ret = false;
|
||||
LOG_E << name << " parsing error!" << LOG_ENDL;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool doDigest() {
|
||||
HidParser hidParser;
|
||||
bool ret = true;
|
||||
|
||||
// value from HID sensor usage page spec
|
||||
std::unordered_set<unsigned int> interestedUsage = {
|
||||
0x200073, // accelerometer 3d
|
||||
0x200076, // gyro 3d
|
||||
0x200083, // mag 3d
|
||||
0x20008a, // device orientation (rotation vector)
|
||||
};
|
||||
|
||||
for (const TestHidDescriptor *p = gDescriptorArray; ; ++p) {
|
||||
if (p->data == nullptr || p->len == 0) {
|
||||
break;
|
||||
}
|
||||
const char *name = p->name != nullptr ? p->name : "unnamed";
|
||||
bool parseResult = hidParser.parse(p->data, p->len);
|
||||
|
||||
if (!parseResult) {
|
||||
LOG_E << name << " parsing error!" << LOG_ENDL;
|
||||
ret = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
hidParser.filterTree();
|
||||
LOG_V << name << " digest: " << LOG_ENDL;
|
||||
HidParser::DigestVector digestVector = hidParser.generateDigest(interestedUsage);
|
||||
LOG_V << digestVector;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void printUsage(char *argv0) {
|
||||
LOG_V << "Usage: " << argv0 << " test_name" << LOG_ENDL;
|
||||
LOG_V << " test_name can be parse, parse_filter, digest." << LOG_ENDL;
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
int ret;
|
||||
|
||||
if (argc != 2) {
|
||||
LOG_E << "Error: need param" << LOG_ENDL;
|
||||
printUsage(argv[0]);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (strcmp(argv[1], "parse") == 0) {
|
||||
ret = doParse() ? 0 : 1;
|
||||
} else if (strcmp(argv[1], "parse_filter") == 0) {
|
||||
ret = doParseAndFilter() ? 0 : 1;
|
||||
} else if (strcmp(argv[1], "digest") == 0) {
|
||||
ret = doDigest() ? 0 : 1;
|
||||
} else {
|
||||
LOG_E << "Error: unknown test name" << LOG_ENDL;
|
||||
printUsage(argv[0]);
|
||||
ret = -ENOENT;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "TestHidDescriptor.h"
|
||||
#include "HidLog.h"
|
||||
#include "HidParser.h"
|
||||
#include "StreamIoUtil.h"
|
||||
|
||||
using namespace HidUtil;
|
||||
|
||||
void printRawValue(const std::vector<unsigned char> &descriptor) {
|
||||
LOG_D << "Descriptor [" << descriptor.size() << "]: " << std::hex;
|
||||
hexdumpToStream(LOG_D, descriptor.begin(), descriptor.end());
|
||||
}
|
||||
|
||||
void printToken(const std::vector<HidItem> &hidItemVector) {
|
||||
LOG_V << "Total " << hidItemVector.size() << " tokens" << LOG_ENDL;
|
||||
for (auto &i : hidItemVector) {
|
||||
LOG_V << i << LOG_ENDL;
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
const TestHidDescriptor *t = findTestDescriptor("accel3");
|
||||
constexpr unsigned int ACCEL_3D_USAGE = 0x200073;
|
||||
|
||||
assert(t != nullptr);
|
||||
std::vector<unsigned char> descriptor(t->data, t->data + t->len);
|
||||
|
||||
// parse can be done in one step with HidParser::parse(const unsigned char *begin, size_t size);
|
||||
// here it is done in multiple steps for illustration purpose
|
||||
HidParser hidParser;
|
||||
// print out raw value
|
||||
printRawValue(descriptor);
|
||||
|
||||
// tokenize it
|
||||
std::vector<HidItem> hidItemVector = HidItem::tokenize(descriptor);
|
||||
|
||||
// print out tokens
|
||||
printToken(hidItemVector);
|
||||
|
||||
// parse it
|
||||
if (hidParser.parse(hidItemVector)) {
|
||||
// making a deepcopy of tree (not necessary, but for illustration)
|
||||
std::shared_ptr<HidTreeNode> tree = hidParser.getTree()->deepCopy();
|
||||
|
||||
LOG_V << "Tree: " << LOG_ENDL;
|
||||
LOG_V << *tree;
|
||||
LOG_V << LOG_ENDL;
|
||||
|
||||
hidParser.filterTree();
|
||||
LOG_V << "FilteredTree: " << LOG_ENDL;
|
||||
LOG_V << *(hidParser.getTree());
|
||||
|
||||
LOG_V << "DigestVector: " << LOG_ENDL;
|
||||
std::unordered_set<unsigned int> interested = {ACCEL_3D_USAGE};
|
||||
HidParser::DigestVector digestVector = hidParser.generateDigest(interested);
|
||||
LOG_V << digestVector;
|
||||
|
||||
} else {
|
||||
LOG_V << "Parsing Error" << LOG_ENDL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
2607
modules/sensors/dynamic_sensor/HidUtils/test/TestHidDescriptor.cpp
Normal file
2607
modules/sensors/dynamic_sensor/HidUtils/test/TestHidDescriptor.cpp
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -0,0 +1,30 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_TEST_HIDDESCRIPTOR_H_
|
||||
#define HIDUTIL_TEST_HIDDESCRIPTOR_H_
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
struct TestHidDescriptor {
|
||||
const unsigned char *data;
|
||||
size_t len;
|
||||
const char *name;
|
||||
};
|
||||
|
||||
extern const TestHidDescriptor gDescriptorArray[];
|
||||
const TestHidDescriptor *findTestDescriptor(const char *name);
|
||||
|
||||
#endif // HIDUTIL_TEST_HIDDESCRIPTOR_H_
|
||||
859
modules/sensors/dynamic_sensor/HidUtils/test/TestHidSensorSpec.h
Normal file
859
modules/sensors/dynamic_sensor/HidUtils/test/TestHidSensorSpec.h
Normal file
|
|
@ -0,0 +1,859 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef HIDUTIL_TEST_HIDSENSORSPEC_H
|
||||
#define HIDUTIL_TEST_HIDSENSORSPEC_H
|
||||
/**
|
||||
* Example HID sensor definition in from published document "HID Sensors Usage"
|
||||
* (hid-sensors-usage.docx). This file is added as part of the test case.
|
||||
*
|
||||
* It is slightly modified in order to compile.
|
||||
*/
|
||||
#define HID_USAGE_PAGE_SENSOR 0x05,0x20
|
||||
|
||||
//sensor category usages
|
||||
#define HID_USAGE_SENSOR_TYPE_COLLECTION 0x09,0x01
|
||||
//sensor category biometric
|
||||
#define HID_USAGE_SENSOR_CATEGORY_BIOMETRIC 0x09,0x10
|
||||
#define HID_USAGE_SENSOR_TYPE_BIOMETRIC_PRESENCE 0x09,0x11
|
||||
#define HID_USAGE_SENSOR_TYPE_BIOMETRIC_PROXIMITY 0x09,0x12
|
||||
#define HID_USAGE_SENSOR_TYPE_BIOMETRIC_TOUCH 0x09,0x13
|
||||
//sensor category electrical
|
||||
#define HID_USAGE_SENSOR_CATEGORY_ELECTRICAL 0x09,0x20
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_CAPACITANCE 0x09,0x21
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_CURRENT 0x09,0x22
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_POWER 0x09,0x23
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_INDUCTANCE 0x09,0x24
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_RESISTANCE 0x09,0x25
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_VOLTAGE 0x09,0x26
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_POTENTIOMETER 0x09,0x27
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_FREQUENCY 0x09,0x28
|
||||
#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_PERIOD 0x09,0x29
|
||||
//sensor category environmental
|
||||
#define HID_USAGE_SENSOR_CATEGORY_ENVIRONMENTAL 0x09,0x30
|
||||
#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_ATMOSPHERIC_PRESSURE 0x09,0x31
|
||||
#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_HUMIDITY 0x09,0x32
|
||||
#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_TEMPERATURE 0x09,0x33
|
||||
#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_WIND_DIRECTION 0x09,0x34
|
||||
#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_WIND_SPEED 0x09,0x35
|
||||
//sensor category light
|
||||
#define HID_USAGE_SENSOR_CATEGORY_LIGHT 0x09,0x40
|
||||
#define HID_USAGE_SENSOR_TYPE_LIGHT_AMBIENTLIGHT 0x09,0x41
|
||||
#define HID_USAGE_SENSOR_TYPE_LIGHT_CONSUMER_INFRARED 0x09,0x42
|
||||
//sensor category location
|
||||
#define HID_USAGE_SENSOR_CATEGORY_LOCATION 0x09,0x50
|
||||
#define HID_USAGE_SENSOR_TYPE_LOCATION_BROADCAST 0x09,0x51
|
||||
#define HID_USAGE_SENSOR_TYPE_LOCATION_DEAD_RECKONING 0x09,0x52
|
||||
#define HID_USAGE_SENSOR_TYPE_LOCATION_GPS 0x09,0x53
|
||||
#define HID_USAGE_SENSOR_TYPE_LOCATION_LOOKUP 0x09,0x54
|
||||
#define HID_USAGE_SENSOR_TYPE_LOCATION_OTHER 0x09,0x55
|
||||
#define HID_USAGE_SENSOR_TYPE_LOCATION_STATIC 0x09,0x56
|
||||
#define HID_USAGE_SENSOR_TYPE_LOCATION_TRIANGULATION 0x09,0x57
|
||||
//sensor category mechanical
|
||||
#define HID_USAGE_SENSOR_CATEGORY_MECHANICAL 0x09,0x60
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_BOOLEAN_SWITCH 0x09,0x61
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_BOOLEAN_SWITCH_ARRAY 0x09,0x62
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_MULTIVALUE_SWITCH 0x09,0x63
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_FORCE 0x09,0x64
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_PRESSURE 0x09,0x65
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_STRAIN 0x09,0x66
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_SCALE_WEIGHT 0x09,0x67
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_VIBRATOR 0x09,0x68
|
||||
#define HID_USAGE_SENSOR_TYPE_MECHANICAL_HALL_EFFECT_SWITCH 0x09,0x69
|
||||
//sensor category motion
|
||||
#define HID_USAGE_SENSOR_CATEGORY_MOTION 0x09,0x70
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER_1D 0x09,0x71
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER_2D 0x09,0x72
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER_3D 0x09,0x73
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER_1D 0x09,0x74
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER_2D 0x09,0x75
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER_3D 0x09,0x76
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_MOTION_DETECTOR 0x09,0x77
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_SPEEDOMETER 0x09,0x78
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER 0x09,0x79
|
||||
#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER 0x09,0x7A
|
||||
//sensor category orientation
|
||||
#define HID_USAGE_SENSOR_CATEGORY_ORIENTATION 0x09,0x80
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS_1D 0x09,0x81
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS_2D 0x09,0x82
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS_3D 0x09,0x83
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER_1D 0x09,0x84
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER_2D 0x09,0x85
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER_3D 0x09,0x86
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE_1D 0x09,0x87
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE_2D 0x09,0x88
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE_3D 0x09,0x89
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DEVICE_ORIENTATION 0x09,0x8A
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS 0x09,0x8B
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER 0x09,0x8C
|
||||
#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE 0x09,0x8D
|
||||
//sensor category scanner
|
||||
#define HID_USAGE_SENSOR_CATEGORY_SCANNER 0x09,0x90
|
||||
#define HID_USAGE_SENSOR_TYPE_SCANNER_BARCODE 0x09,0x91
|
||||
#define HID_USAGE_SENSOR_TYPE_SCANNER_RFID 0x09,0x92
|
||||
#define HID_USAGE_SENSOR_TYPE_SCANNER_NFC 0x09,0x93
|
||||
//sensor category time
|
||||
#define HID_USAGE_SENSOR_CATEGORY_TIME 0x09,0xA0
|
||||
#define HID_USAGE_SENSOR_TYPE_TIME_ALARM 0x09,0xA1
|
||||
#define HID_USAGE_SENSOR_TYPE_TIME_RTC 0x09,0xA2
|
||||
//sensor category other
|
||||
#define HID_USAGE_SENSOR_CATEGORY_OTHER 0x09,0xE0
|
||||
#define HID_USAGE_SENSOR_TYPE_OTHER_CUSTOM 0x09,0xE1
|
||||
#define HID_USAGE_SENSOR_TYPE_OTHER_GENERIC 0x09,0xE2
|
||||
#define HID_USAGE_SENSOR_TYPE_OTHER_GENERIC_ENUMERATOR 0x09,0xE3
|
||||
|
||||
//unit usages
|
||||
#define HID_USAGE_SENSOR_UNITS_NOT_SPECIFIED 0x65,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_LUX 0x67,0xE1,0x00,0x00,0x01 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_KELVIN 0x67,0x01,0x00,0x01,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_FAHRENHEIT 0x67,0x03,0x00,0x01,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_PASCAL 0x66,0xF1,0xE1 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_NEWTON 0x66,0x11,0xE1 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_METERS_PER_SECOND 0x66,0x11,0xF0 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_METERS_PER_SEC_SQRD 0x66,0x11,0xE0 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_FARAD 0x67,0xE1,0x4F,0x20,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_AMPERE 0x67,0x01,0x00,0x10,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_WATT 0x66,0x21,0xD1 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_HENRY 0x67,0x21,0xE1,0xE0,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_OHM 0x67,0x21,0xD1,0xE0,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_VOLT 0x67,0x21,0xD1,0xF0,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_HERTZ 0x66,0x01,0xF0 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_DEGREES 0x65,0x14 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_DEGREES_PER_SECOND 0x66,0x14,0xF0 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_DEGREES_PER_SEC_SQRD 0x66,0x14,0xE0 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_RADIANS 0x65,0x12 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_RADIANS_PER_SECOND 0x66,0x12,0xF0 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_RADIANS_PER_SEC_SQRD 0x66,0x12,0xE0 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_SECOND 0x66,0x01,0x10 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_GAUSS 0x67,0x01,0xE1,0xF0,0x00 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_GRAM 0x66,0x01,0x01 // Unit
|
||||
#define HID_USAGE_SENSOR_UNITS_CENTIMETER 0x65,0x11 // Unit
|
||||
#ifdef DEFINE_NON_HID_UNITS
|
||||
#define HID_USAGE_SENSOR_UNITS_CELSIUS "Use Unit(Kelvin) and subtract 273.15"
|
||||
#define HID_USAGE_SENSOR_UNITS_KILOGRAM "Use Unit(gram) and UnitExponent(0x03)"
|
||||
#define HID_USAGE_SENSOR_UNITS_METER "Use Unit(centimeter) and UnitExponent(0x02)"
|
||||
#define HID_USAGE_SENSOR_UNITS_BAR "Use Unit(Pascal) and UnitExponent(0x05)"
|
||||
#define HID_USAGE_SENSOR_UNITS_KNOT "Use Unit(m/s) and multiply by 1852/3600"
|
||||
#define HID_USAGE_SENSOR_UNITS_PERCENT "Use Unit(Not_Specified)"
|
||||
#define HID_USAGE_SENSOR_UNITS_G "Use Unit(m/s2) and divide by 9.8"
|
||||
#define HID_USAGE_SENSOR_UNITS_MILLISECOND "Use Unit(second) and UnitExponent(0x0D)"
|
||||
#define HID_USAGE_SENSOR_UNITS_MILLIGAUSS "Use Unit(Gauss) and UnitExponent(0x0D)"
|
||||
#endif
|
||||
//unit deprecated usages
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_LUX 0x01
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_KELVIN 0x02
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_CELSIUS 0x03
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_PASCAL 0x04
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_NEWTON 0x05
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_METERS_PER_SECOND 0x06
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_KILOGRAM 0x07
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_METER 0x08
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_METERS_PER_SEC_SQRD 0x09
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_FARAD 0x0A
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_AMPERE 0x0B
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_WATT 0x0C
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_HENRY 0x0D
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_OHM 0x0E
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_VOLT 0x0F
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_HERTZ 0x10
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_BAR 0x11
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREES_ANTI_CLOCKWISE 0x12
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREES_CLOCKWISE 0x13
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREE 0x14
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREES_PER_SECOND 0x15
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_KNOT 0x16
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_PERCENT 0x17
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_SECOND 0x18
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_MILLISECOND 0x19
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_G 0x1A
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_BYTES 0x1B
|
||||
#define HID_USAGE_SENSOR_UNITS_DEPRECATED_MILLIGAUSS 0x1C
|
||||
|
||||
//data type usage modifiers -- we use them as modifiers for sensor properties & data fields
|
||||
//to create thresholds, for example.
|
||||
//NOTE: the usage tables actually define these as two bytes, but in order
|
||||
//to get the define macros to work so these are ‘or-ed’ these are defined
|
||||
//here as only one byte.
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_NONE 0x00 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS 0x10 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_MAX 0x20 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_MIN 0x30 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_ACCURACY 0x40 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_RESOLUTION 0x50 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_THRESHOLD_HIGH 0x60 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_THRESHOLD_LOW 0x70 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_CALIBRATION_OFFSET 0x80 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_CALIBRATION_MULTIPLIER 0x90 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_REPORT_INTERVAL 0xA0 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_FREQUENCY_MAX 0xB0 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_PERIOD_MAX 0xC0 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_RANGE_PCT 0xD0 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_REL_PCT 0xE0 // US
|
||||
#define HID_USAGE_SENSOR_DATA_MOD_VENDOR_RESERVED 0xF0 // US
|
||||
|
||||
|
||||
//state usages
|
||||
#define HID_USAGE_SENSOR_STATE 0x0A,0x01,0x02 // NAry
|
||||
//state selectors
|
||||
#define HID_USAGE_SENSOR_STATE_UNKNOWN_SEL 0x0A,0x00,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_STATE_READY_SEL 0x0A,0x01,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_STATE_NOT_AVAILABLE_SEL 0x0A,0x02,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_STATE_NO_DATA_SEL 0x0A,0x03,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_STATE_INITIALIZING_SEL 0x0A,0x04,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_STATE_ACCESS_DENIED_SEL 0x0A,0x05,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_STATE_ERROR_SEL 0x0A,0x06,0x08 // Sel
|
||||
//state enums
|
||||
#define HID_USAGE_SENSOR_STATE_UNKNOWN_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_SENSOR_STATE_READY_ENUM 0x02 // Enum
|
||||
#define HID_USAGE_SENSOR_STATE_NOT_AVAILABLE_ENUM 0x03 // Enum
|
||||
#define HID_USAGE_SENSOR_STATE_NO_DATA_ENUM 0x04 // Enum
|
||||
#define HID_USAGE_SENSOR_STATE_INITIALIZING_ENUM 0x05 // Enum
|
||||
#define HID_USAGE_SENSOR_STATE_ACCESS_DENIED_ENUM 0x06 // Enum
|
||||
#define HID_USAGE_SENSOR_STATE_ERROR_ENUM 0x07 // Enum
|
||||
//state deprecated enums
|
||||
#define HID_USAGE_SENSOR_STATE_DEPRECATED_UNKNOWN_ENUM 0x00
|
||||
#define HID_USAGE_SENSOR_STATE_DEPRECATED_NOT_AVAILABLE_ENUM 0x01
|
||||
#define HID_USAGE_SENSOR_STATE_DEPRECATED_READY_ENUM 0x02
|
||||
#define HID_USAGE_SENSOR_STATE_DEPRECATED_NO_DATA_ENUM 0x03
|
||||
#define HID_USAGE_SENSOR_STATE_DEPRECATED_INITIALIZING_ENUM 0x04
|
||||
#define HID_USAGE_SENSOR_STATE_DEPRECATED_ACCESS_DENIED_ENUM 0x05
|
||||
#define HID_USAGE_SENSOR_STATE_DEPRECATED_ERROR_ENUM 0x06
|
||||
|
||||
//event usages
|
||||
#define HID_USAGE_SENSOR_EVENT 0x0A,0x02,0x02 // NAry
|
||||
//event selectors
|
||||
#define HID_USAGE_SENSOR_EVENT_UNKNOWN_SEL 0x0A,0x10,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_STATE_CHANGED_SEL 0x0A,0x11,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_PROPERTY_CHANGED_SEL 0x0A,0x12,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_DATA_UPDATED_SEL 0x0A,0x13,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_POLL_RESPONSE_SEL 0x0A,0x14,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_CHANGE_SENSITIVITY_SEL 0x0A,0x15,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_MAX_REACHED_SEL 0x0A,0x16,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_MIN_REACHED_SEL 0x0A,0x17,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_SEL 0x0A,0x18,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THESHOLD_CROSS_ABOVE_SEL HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_SEL
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_SEL 0x0A,0x19,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_BELOW_SEL HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_SEL
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_SEL 0x0A,0x1A,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_ABOVE_SEL HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_SEL
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_SEL 0x0A,0x1B,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_BELOW_SEL HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_SEL
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_SEL 0x0A,0x1C,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_ABOVE_SEL HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_SEL
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_SEL 0x0A,0x1D,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_BELOW_SEL HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_SEL
|
||||
#define HID_USAGE_SENSOR_EVENT_PERIOD_EXCEEDED_SEL 0x0A,0x1E,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_FREQUENCY_EXCEEDED_SEL 0x0A,0x1F,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_EVENT_COMPLEX_TRIGGER_SEL 0x0A,0x20,0x08 // Sel
|
||||
//event enums
|
||||
#define HID_USAGE_SENSOR_EVENT_UNKNOWN_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_STATE_CHANGED_ENUM 0x02 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_PROPERTY_CHANGED_ENUM 0x03 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_DATA_UPDATED_ENUM 0x04 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_POLL_RESPONSE_ENUM 0x05 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_CHANGE_SENSITIVITY_ENUM 0x06 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_MAX_REACHED_ENUM 0x07 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_MIN_REACHED_ENUM 0x08 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_ENUM 0x09 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THESHOLD_CROSS_ABOVE_ENUM HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_ENUM
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_ENUM 0x0A // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_BELOW_ENUM HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_ENUM
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_ENUM 0x0B // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_ABOVE_ENUM HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_ENUM
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_ENUM 0x0C // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_BELOW_ENUM HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_ENUM
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_ENUM 0x0D // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_ABOVE_ENUM HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_ENUM
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_ENUM 0x0E // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_BELOW_ENUM HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_ENUM
|
||||
#define HID_USAGE_SENSOR_EVENT_PERIOD_EXCEEDED_ENUM 0x0F // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_FREQUENCY_EXCEEDED_ENUM 0x10 // Enum
|
||||
#define HID_USAGE_SENSOR_EVENT_COMPLEX_TRIGGER_ENUM 0x11 // Enum
|
||||
//event deprecated enums
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_UNKNOWN_ENUM 0x00
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_STATE_CHANGED_ENUM 0x01
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_PROPERTY_CHANGED_ENUM 0x02
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_DATA_UPDATE_ENUM 0x03
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_POLL_RESPONSE_ENUM 0x04
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_CHANGE_SENSITIVITY_ENUM 0x05
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_MAX_REACHED_ENUM 0x06
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_MIN_REACHED_ENUM 0x07
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_HIGH_THRESHHOLD_CROSS_ABOVE_ENUM 0x08
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_HIGH_THRESHHOLD_CROSS_BELOW_ENUM 0x09
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_LOW_THRESHHOLD_CROSS_ABOVE_ENUM 0x0A
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_LOW_THRESHHOLD_CROSS_BELOW_ENUM 0x0B
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_ZERO_THRESHOLD_CROSS_ABOVE_ENUM 0x0C
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_ZERO_THRESHOLD_CROSS_BELOW_ENUM 0x0D
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_PERIOD_EXCEEDED_ENUM 0x0E
|
||||
#define HID_USAGE_SENSOR_EVENT_DEPRECATED_FREQUENCY_EXCEEDED_ENUM 0x0F
|
||||
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY 0x0A,0x00,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_FRIENDLY_NAME 0x0A,0x01,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_PERSISTENT_UNIQUE_ID 0x0A,0x02,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SENSOR_STATUS 0x0A,0x03,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_MINIMUM_REPORT_INTERVAL 0x0A,0x04,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SENSOR_MANUFACTURER 0x0A,0x05,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SENSOR_MODEL 0x0A,0x06,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SENSOR_SERIAL_NUMBER 0x0A,0x07,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SENSOR_DESCRIPTION 0x0A,0x08,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SENSOR_CONNECTION_TYPE 0x0A,0x09,0x03 // NAry
|
||||
//begin connection type selectors
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_INTEGRATED_SEL 0x0A,0x30,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_ATTACHED_SEL 0x0A,0x31,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_EXTERNAL_SEL 0x0A,0x32,0x08 // Sel
|
||||
//end connection type selectors
|
||||
//begin connection type enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_INTEGRATED_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_ATTACHED_ENUM 0x02 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_EXTERNAL_ENUM 0x03 // Enum
|
||||
//end connection type enums
|
||||
//begin connection type deprecated enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_CONNECTION_TYPE_PC_INTEGRATED_ENUM 0x00 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_CONNECTION_TYPE_PC_ATTACHED_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_CONNECTION_TYPE_PC_EXTERNAL_ENUM 0x02 // Enum
|
||||
//end connection type deprecated enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SENSOR_DEVICE_PATH 0x0A,0x0A,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_HARDWARE_REVISION 0x0A,0x0B,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_FIRMWARE_VERSION 0x0A,0x0C,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_RELEASE_DATE 0x0A,0x0D,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORT_INTERVAL 0x0A,0x0E,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CHANGE_SENSITIVITY_ABS 0x0A,0x0F,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CHANGE_SENSITIVITY_RANGE_PCT 0x0A,0x10,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_CHANGE_SENSITIVITY_REL_PCT 0x0A,0x11,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_ACCURACY 0x0A,0x12,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_RESOLUTION 0x0A,0x13,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_RANGE_MAXIMUM 0x0A,0x14,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_RANGE_MINIMUM 0x0A,0x15,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE 0x0A,0x16,0x03 // NAry
|
||||
//begin reporting state selectors
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_SEL 0x0A,0x40,0x08 // Sel
|
||||
#define HID_USAGE_REPORTING_STATE_ON_NONE_SEL HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_SEL
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_SEL 0x0A,0x41,0x08 // Sel
|
||||
#define HID_USAGE_REPORTING_STATE_ON_ALL_SEL HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_SEL
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_SEL 0x0A,0x42,0x08 // Sel
|
||||
#define HID_USAGE_REPORTING_STATE_ON_THRESHOLD_SEL HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_SEL
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_WAKE_SEL 0x0A,0x43,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_WAKE_SEL 0x0A,0x44,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_WAKE_SEL 0x0A,0x45,0x08 // Sel
|
||||
//end reporting state selectors
|
||||
//begin reporting state enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_REPORTING_STATE_ON_NONE_ENUM HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_ENUM
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_ENUM 0x02 // Enum
|
||||
#define HID_USAGE_REPORTING_STATE_ON_ALL_ENUM HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_ENUM
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_ENUM 0x03 // Enum
|
||||
#define HID_USAGE_REPORTING_STATE_ON_THRESHOLD_ENUM HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_ENUM
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_SEL_WAKE_ENUM 0x04 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_SEL_WAKE_ENUM 0x05 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_WAKE_ENUM 0x06 // Enum
|
||||
//end reporting state enums
|
||||
//begin reporting state deprecated enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_NO_EVENTS_ENUM 0x00 // Enum
|
||||
#define HID_USAGE_DEPRECATED_REPORTING_STATE_ON_NONE_ENUM HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_NO_EVENTS_ENUM
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_ALL_EVENTS_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_DEPRECATED_REPORTING_STATE_ON_ALL_ENUM HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_ALL_EVENTS_ENUM
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_THRESHOLD_EVENTS_ENUM 0x02 // Enum
|
||||
#define HID_USAGE_DEPRECATED_REPORTING_STATE_ON_THRESHOLD_ENUM HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_THRESHOLD_EVENTS_ENUM
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_NO_EVENTS_WAKE_ENUM 0x03 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_ALL_EVENTS_WAKE_ENUM 0x04 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_THRESHOLD_EVENTS_WAKE_ENUM 0x05 // Enum
|
||||
//end reporting state deprecated enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SAMPLING_RATE 0x0A,0x17,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_RESPONSE_CURVE 0x0A,0x18,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE 0x0A,0x19,0x03 // NAry
|
||||
//begin power state selectors
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_UNDEFINED_SEL 0x0A,0x50,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D0_FULL_POWER_SEL 0x0A,0x51,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D1_LOW_POWER_SEL 0x0A,0x52,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D2_STANDBY_WITH_WAKE_SEL 0x0A,0x53,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D3_SLEEP_WITH_WAKE_SEL 0x0A,0x54,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D4_POWER_OFF_SEL 0x0A,0x55,0x08 // Sel
|
||||
//end power state selectors
|
||||
//begin power state enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_UNDEFINED_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D0_FULL_POWER_ENUM 0x02 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D1_LOW_POWER_ENUM 0x03 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D2_STANDBY_WITH_WAKE_ENUM 0x04 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D3_SLEEP_WITH_WAKE_ENUM 0x05 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D4_POWER_OFF_ENUM 0x06 // Enum
|
||||
//end power state enums
|
||||
//begin deprecated power state enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_UNDEFINED_ENUM 0x00 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D0_FULL_POWER_ENUM 0x01 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D1_LOW_POWER_ENUM 0x02 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D2_STANDBY_WITH_WAKE_ENUM 0x03 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D3_SLEEP_WITH_WAKE_ENUM 0x04 // Enum
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D4_POWER_OFF_ENUM 0x05 // Enum
|
||||
//end deprecated power state enums
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_FEATURE_PAGE_COUNT 0x0A,0x1A,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_FEATURE_PAGE_ID 0x0A,0x1B,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_INPUT_PAGE_COUNT 0x0A,0x1C,0x03
|
||||
#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_INPUT_PAGE_ID 0x0A,0x1D,0x03
|
||||
|
||||
//data type location
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION 0x0A,0x00,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_DESIRED_ACCURACY 0x0A,0x01,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITUDE_ANTENNA_SEALEVEL 0x0A,0x02,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_DIFFERENTIAL_REFERENCE_STATION_ID 0x0A,0x03,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITIDE_ELIPSOID_ERROR 0x0A,0x04,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITIDE_ELIPSOID 0x0A,0x05,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITUDE_SEALEVEL_ERROR 0x0A,0x06,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITUDE_SEALEVEL 0x0A,0x07,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_DGPS_DATA_AGE 0x0A,0x08,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ERROR_RADIUS 0x0A,0x09,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_FIX_QUALITY 0x0A,0x0A,0x04 // NAry
|
||||
//begin fix quality selectors
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_QUALITY_NO_FIX 0x0A,0x70,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_QUALITY_GPS 0x0A,0x71,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_QUALITY_DGPS 0x0A,0x72,0x08 // Sel
|
||||
//end fix quality selectors
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_FIX_TYPE 0x0A,0x0B,0x04 // NAry
|
||||
//begin fix type selectors
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_NO_FIX 0x0A,0x80,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_GPS_SPS_MODE_FIX_VALID 0x0A,0x81,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_DGPS_SPS_MODE_FIX_VALID 0x0A,0x82,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_GPS_PPS_MODE_FIX_VALID 0x0A,0x83,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_REAL_TIME_KINEMATIC 0x0A,0x84,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_FLOAT_RTK 0x0A,0x85,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_ESTIMATED_DEAD_RECKONING 0x0A,0x86,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_MANUAL_INPUT_MODE 0x0A,0x87,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_FIX_TYPE_SIMULATOR_MODE 0x0A,0x88,0x08 // Sel
|
||||
//end fix type selectors
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_GEOIDAL_SEPARATION 0x0A,0x0C,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_GPS_OPERATION_MODE 0x0A,0x0D,0x04 // NAry
|
||||
//begin gps operation mode selectors
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_OP_MODE_MANUAL 0x0A,0x90,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_OP_MODE_AUTOMATIC 0x0A,0x91,0x08 // Sel
|
||||
//end gps operation mode selectors
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_GPS_SELECTION_MODE 0x0A,0x0E,0x04 // NAry
|
||||
//begin gps selection mode selectors
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_AUTONOMOUS 0x0A,0xA0,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_DGPS 0x0A,0xA1,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_ESTIMATED_DEAD_RECKONING 0x0A,0xA2,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_MANUAL_INPUT 0x0A,0xA3,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_SIMULATOR 0x0A,0xA4,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_DATA_NOT_VALID 0x0A,0xA5,0x08 // Sel
|
||||
//end gps selection mode selectors
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_GPS_STATUS 0x0A,0x0F,0x04 // NAry
|
||||
//begin gps status selectors
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_STATUS_DATA_VALID 0x0A,0xB0,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DATA_GPS_STATUS_DATA_NOT_VALID 0x0A,0xB1,0x08 // Sel
|
||||
//end gps status selectors
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_POSITION_DILUTION_OF_PRECISION 0x0A,0x10,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_HORIZONTAL_DILUTION_OF_PRECISION 0x0A,0x11,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_VERTICAL_DILUTION_OF_PRECISION 0x0A,0x12,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_LATITUDE 0x0A,0x13,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_LONGITUDE 0x0A,0x14,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_TRUE_HEADING 0x0A,0x15,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_MAGNETIC_HEADING 0x0A,0x16,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_MAGNETIC_VARIATION 0x0A,0x17,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SPEED 0x0A,0x18,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW 0x0A,0x19,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_AZIMUTH 0x0A,0x1A,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_ELEVATION 0x0A,0x1B,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_ID 0x0A,0x1C,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_PRNs 0x0A,0x1D,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_STN_RATIO 0x0A,0x1E,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_USED_COUNT 0x0A,0x1F,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_USED_PRNs 0x0A,0x20,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_NMEA_SENTENCE 0x0A,0x21,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ADDRESS_LINE_1 0x0A,0x22,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_ADDRESS_LINE_2 0x0A,0x23,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_CITY 0x0A,0x24,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_STATE_OR_PROVINCE 0x0A,0x25,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_COUNTRY_OR_REGION 0x0A,0x26,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LOCATION_POSTAL_CODE 0x0A,0x27,0x04
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY_LOCATION 0x0A,0x2A,0x04
|
||||
#define HID_USAGE_SENSOR_PROPERTY_LOCATION_DESIRED_ACCURACY 0x0A,0x2B,0x04 // NAry
|
||||
//begin location desired accuracy selectors
|
||||
#define HID_USAGE_SENSOR_DESIRED_ACCURACY_DEFAULT 0x0A,0x60,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DESIRED_ACCURACY_HIGH 0x0A,0x61,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DESIRED_ACCURACY_MEDIUM 0x0A,0x62,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_DESIRED_ACCURACY_LOW 0x0A,0x63,0x08 // Sel
|
||||
//end location desired accuracy selectors
|
||||
|
||||
//data type environmental
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL 0x0A,0x30,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_ATMOSPHERIC_PRESSURE 0x0A,0x31,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_REFERENCE_PRESSURE 0x0A,0x32,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_RELATIVE_HUMIDITY 0x0A,0x33,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_TEMPERATURE 0x0A,0x34,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_WIND_DIRECTION 0x0A,0x35,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_WIND_SPEED 0x0A,0x36,0x04
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY_ENVIRONMENTAL 0x0A,0x40,0x04
|
||||
#define HID_USAGE_SENSOR_PROPERTY_ENVIRONMENTAL_REFERENCE_PRESSURE 0x0A,0x41,0x04
|
||||
|
||||
//data type motion
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION 0x0A,0x50,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_STATE 0x0A,0x51,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION 0x0A,0x52,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION_X_AXIS 0x0A,0x53,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION_Y_AXIS 0x0A,0x54,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION_Z_AXIS 0x0A,0x55,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY 0x0A,0x56,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY_X_AXIS 0x0A,0x57,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY_Y_AXIS 0x0A,0x58,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY_Z_AXIS 0x0A,0x59,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION 0x0A,0x5A,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION_X_AXIS 0x0A,0x5B,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION_Y_AXIS 0x0A,0x5C,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION_Z_AXIS 0x0A,0x5D,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_SPEED 0x0A,0x5E,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MOTION_INTENSITY 0x0A,0x5F,0x04
|
||||
|
||||
//data type orientation
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION 0x0A,0x70,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING 0x0A,0x71,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING_X 0x0A,0x72,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING_Y 0x0A,0x73,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING_Z 0x0A,0x74,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_COMPENSATED_MAGNETIC_NORTH 0x0A,0x75,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_COMPENSATED_TRUE_NORTH 0x0A,0x76,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_NORTH 0x0A,0x77,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_TRUE_NORTH 0x0A,0x78,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE 0x0A,0x79,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_X 0x0A,0x7A,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_Y 0x0A,0x7B,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_Z 0x0A,0x7C,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_OUT_OF_RANGE 0x0A,0x7D,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT 0x0A,0x7E,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT_X 0x0A,0x7F,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT_Y 0x0A,0x80,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT_Z 0x0A,0x81,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_ROTATION_MATRIX 0x0A,0x82,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_QUATERNION 0x0A,0x83,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX 0x0A,0x84,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX_X_AXIS 0x0A,0x85,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX_Y_AXIS 0x0A,0x86,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX_Z_AXIS 0x0A,0x87,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY 0x0A,0x88,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY_LOW 0x0A,0xE0,0x08
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY_MEDIUM 0x0A,0xE1,0x08
|
||||
#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY_HIGH 0x0A,0xE2,0x08
|
||||
|
||||
//data type mechanical
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL 0x0A,0x90,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_BOOLEAN_SWITCH_STATE 0x0A,0x91,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_BOOLEAN_SWITCH_ARRAY_STATES 0x0A,0x92,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_MULTIVALUE_SWITCH_VALUE 0x0A,0x93,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_FORCE 0x0A,0x94,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_ABSOLUTE_PRESSURE 0x0A,0x95,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_GAUGE_PRESSURE 0x0A,0x96,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_STRAIN 0x0A,0x97,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_WEIGHT 0x0A,0x98,0x04
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY_MECHANICAL 0x0A,0xA0,0x04
|
||||
#define HID_USAGE_SENSOR_PROPERTY_MECHANICAL_VIBRATION_STATE 0x0A,0xA1,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_VIBRATION_SPEED_FORWARD 0x0A,0xA2,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_MECHANICAL_VIBRATION_SPEED_BACKWARD 0x0A,0xA3,0x04
|
||||
|
||||
//data type biometric
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_BIOMETRIC 0x0A,0xB0,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_PRESENCE 0x0A,0xB1,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_PROXIMITY_RANGE 0x0A,0xB2,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_PROXIMITY_OUT_OF_RANGE 0x0A,0xB3,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_TOUCH_STATE 0x0A,0xB4,0x04
|
||||
|
||||
//data type light sensor
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_LIGHT 0x0A,0xD0,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LIGHT_ILLUMINANCE 0x0A,0xD1,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LIGHT_COLOR_TEMPERATURE 0x0A,0xD2,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LIGHT_CHROMATICITY 0x0A,0xD3,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LIGHT_CHROMATICITY_X 0x0A,0xD4,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LIGHT_CHROMATICITY_Y 0x0A,0xD5,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_LIGHT_CONSUMER_IR_SENTENCE_RECEIVE 0x0A,0xD6,0x04
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY_LIGHT 0x0A,0xE0,0x04
|
||||
#define HID_USAGE_SENSOR_PROPERTY_LIGHT_CONSUMER_IR_SENTENCE_SEND 0x0A,0xE1,0x04
|
||||
|
||||
//data type scanner
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_SCANNER 0x0A,0xF0,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_SCANNER_RFID_TAG 0x0A,0xF1,0x04
|
||||
#define HID_USAGE_SENSOR_DATA_SCANNER_NFC_SENTENCE_RECEIVE 0x0A,0xF2,0x04
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SCANNER 0x0A,0xF8,0x04
|
||||
#define HID_USAGE_SENSOR_PROPERTY_SCANNER_NFC_SENTENCE_SEND 0x0A,0xF9,0x04
|
||||
|
||||
//data type electrical
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL 0x0A,0x00,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_CAPACITANCE 0x0A,0x01,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_CURRENT 0x0A,0x02,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_POWER 0x0A,0x03,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_INDUCTANCE 0x0A,0x04,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_RESISTANCE 0x0A,0x05,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_VOLTAGE 0x0A,0x06,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_FREQUENCY 0x0A,0x07,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_PERIOD 0x0A,0x08,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ELECTRICAL_PERCENT_OF_RANGE 0x0A,0x09,0x05
|
||||
|
||||
//data type time
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_TIME 0x0A,0x20,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_YEAR 0x0A,0x21,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_MONTH 0x0A,0x22,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_DAY 0x0A,0x23,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_DAY_OF_WEEK 0x0A,0x24,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_HOUR 0x0A,0x25,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_MINUTE 0x0A,0x26,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_SECOND 0x0A,0x27,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_MILLISECOND 0x0A,0x28,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_TIMESTAMP 0x0A,0x29,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_TIME_JULIAN_DAY_OF_YEAR 0x0A,0x2A,0x05
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY_TIME 0x0A,0x30,0x05
|
||||
#define HID_USAGE_SENSOR_PROPERTY_TIME_TIME_ZONE_OFFSET_FROM_UTC 0x0A,0x31,0x05
|
||||
#define HID_USAGE_SENSOR_PROPERTY_TIME_TIME_ZONE_NAME 0x0A,0x32,0x05
|
||||
#define HID_USAGE_SENSOR_PROPERTY_TIME_DAYLIGHT_SAVINGS_TIME_OBSERVED 0x0A,0x33,0x05
|
||||
#define HID_USAGE_SENSOR_PROPERTY_TIME_TIME_TRIM_ADJUSTMENT 0x0A,0x34,0x05
|
||||
#define HID_USAGE_SENSOR_PROPERTY_TIME_ARM_ALARM 0x0A,0x35,0x05
|
||||
|
||||
//data type custom
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM 0x0A,0x40,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_USAGE 0x0A,0x41,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_BOOLEAN_ARRAY 0x0A,0x42,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE 0x0A,0x43,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_1 0x0A,0x44,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_2 0x0A,0x45,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_3 0x0A,0x46,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_4 0x0A,0x47,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_5 0x0A,0x48,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_6 0x0A,0x49,0x05
|
||||
|
||||
#if 1 //define vendor-specific (non-spec) custom datafields
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_7 0x0A,0x4A,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_8 0x0A,0x4B,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_9 0x0A,0x4C,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_10 0x0A,0x4D,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_11 0x0A,0x4E,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_12 0x0A,0x4F,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_13 0x0A,0x50,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_14 0x0A,0x51,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_15 0x0A,0x52,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_16 0x0A,0x53,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_17 0x0A,0x54,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_18 0x0A,0x55,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_19 0x0A,0x56,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_20 0x0A,0x57,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_21 0x0A,0x58,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_22 0x0A,0x59,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_23 0x0A,0x5A,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_24 0x0A,0x5B,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_25 0x0A,0x5C,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_26 0x0A,0x5D,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_27 0x0A,0x5E,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_28 0x0A,0x5F,0x05
|
||||
#endif
|
||||
|
||||
//data type generic
|
||||
//data field usages (input report)
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC 0x0A,0x60,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_GUID_OR_PROPERTYKEY 0x0A,0x61,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_CATEGORY_GUID 0x0A,0x62,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_TYPE_GUID 0x0A,0x63,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_EVENT_PROPERTYKEY 0x0A,0x64,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_PROPERTY_PROPERTYKEY 0x0A,0x65,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_DATAFIELD_PROPERTYKEY 0x0A,0x66,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_EVENT 0x0A,0x67,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_PROPERTY 0x0A,0x68,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_DATAFIELD 0x0A,0x69,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ENUMERATOR_TABLE_ROW_INDEX 0x0A,0x6A,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_ENUMERATOR_TABLE_ROW_COUNT 0x0A,0x6B,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_GUID_OR_PROPERTYKEY_KIND 0x0A,0x6C,0x05 // NAry
|
||||
//begin GorPK kind selectors
|
||||
#define HID_USAGE_SENSOR_GORPK_KIND_CATEGORY 0x0A,0xD0,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_GORPK_KIND_TYPE 0x0A,0xD1,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_GORPK_KIND_EVENT 0x0A,0xD2,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_GORPK_KIND_PROPERTY 0x0A,0xD3,0x08 // Sel
|
||||
#define HID_USAGE_SENSOR_GORPK_KIND_DATAFIELD 0x0A,0xD4,0x08 // Sel
|
||||
//end GorPK kind selectors
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_GUID 0x0A,0x6D,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_PROPERTYKEY 0x0A,0x6E,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_TOP_LEVEL_COLLECTION_ID 0x0A,0x6F,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_ID 0x0A,0x70,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_ITEM_POSITION_INDEX 0x0A,0x71,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_FIRMWARE_VARTYPE 0x0A,0x72,0x05 // NAry
|
||||
//begin firmware vartype selectors
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_NULL 0x0A,0x00,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_BOOL 0x0A,0x01,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI1 0x0A,0x02,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I1 0x0A,0x03,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI2 0x0A,0x04,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I2 0x0A,0x05,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI4 0x0A,0x06,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I4 0x0A,0x07,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI8 0x0A,0x08,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I8 0x0A,0x09,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_R4 0x0A,0x0A,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_R8 0x0A,0x0B,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_WSTR 0x0A,0x0C,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_STR 0x0A,0x0D,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_CLSID 0x0A,0x0E,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_VECTOR_VT_UI1 0x0A,0x0F,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E0 0x0A,0x10,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E1 0x0A,0x11,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E2 0x0A,0x12,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E3 0x0A,0x13,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E4 0x0A,0x14,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E5 0x0A,0x15,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E6 0x0A,0x16,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E7 0x0A,0x17,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E8 0x0A,0x18,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E9 0x0A,0x19,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EA 0x0A,0x1A,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EB 0x0A,0x1B,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EC 0x0A,0x1C,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16ED 0x0A,0x1D,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EE 0x0A,0x1E,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EF 0x0A,0x1F,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E0 0x0A,0x20,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E1 0x0A,0x21,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E2 0x0A,0x22,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E3 0x0A,0x23,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E4 0x0A,0x24,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E5 0x0A,0x25,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E6 0x0A,0x26,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E7 0x0A,0x27,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E8 0x0A,0x28,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E9 0x0A,0x29,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EA 0x0A,0x2A,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EB 0x0A,0x2B,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EC 0x0A,0x2C,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32ED 0x0A,0x2D,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EE 0x0A,0x2E,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EF 0x0A,0x2F,0x09 // Sel
|
||||
//end firmware vartype selectors
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_UNIT_OF_MEASURE 0x0A,0x73,0x05 // NAry
|
||||
//begin unit of measure selectors
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_NOT_SPECIFIED 0x0A,0x40,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_LUX 0x0A,0x41,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_KELVIN 0x0A,0x42,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_CELSIUS 0x0A,0x43,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_PASCAL 0x0A,0x44,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_NEWTON 0x0A,0x45,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_METERS_PER_SECOND 0x0A,0x46,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_KILOGRAM 0x0A,0x47,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_METER 0x0A,0x48,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_METERS_PER_SEC_SQRD 0x0A,0x49,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_FARAD 0x0A,0x4A,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_AMPERE 0x0A,0x4B,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_WATT 0x0A,0x4C,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_HENRY 0x0A,0x4D,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_OHM 0x0A,0x4E,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_VOLT 0x0A,0x4F,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_HERTZ 0x0A,0x50,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_BAR 0x0A,0x51,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_ANTI_CLOCKWISE 0x0A,0x52,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_CLOCKWISE 0x0A,0x53,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES 0x0A,0x54,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_PER_SECOND 0x0A,0x55,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_PER_SEC_SQRD 0x0A,0x56,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_KNOT 0x0A,0x57,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_PERCENT 0x0A,0x58,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_SECOND 0x0A,0x59,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_MILLISECOND 0x0A,0x5A,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_G 0x0A,0x5B,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_BYTES 0x0A,0x5C,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_MILLIGAUSS 0x0A,0x5D,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_UNIT_BITS 0x0A,0x5E,0x09 // Sel
|
||||
//end unit of measure selectors
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_UNIT_EXPONENT 0x0A,0x74,0x05 // NAry
|
||||
//begin unit exponent selectors
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_0 0x0A,0x70,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_1 0x0A,0x71,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_2 0x0A,0x72,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_3 0x0A,0x73,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_4 0x0A,0x74,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_5 0x0A,0x75,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_6 0x0A,0x76,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_7 0x0A,0x77,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_8 0x0A,0x78,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_9 0x0A,0x79,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_A 0x0A,0x7A,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_B 0x0A,0x7B,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_C 0x0A,0x7C,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_D 0x0A,0x7D,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_E 0x0A,0x7E,0x09 // Sel
|
||||
#define HID_USAGE_SENSOR_GENERIC_EXPONENT_F 0x0A,0x7F,0x09 // Sel
|
||||
//end unit exponent selectors
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_SIZE 0x0A,0x75,0x05
|
||||
#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_COUNT 0x0A,0x76,0x05
|
||||
//property usages (get/set feature report)
|
||||
#define HID_USAGE_SENSOR_PROPERTY_GENERIC 0x0A,0x80,0x05
|
||||
#define HID_USAGE_SENSOR_PROPERTY_ENUMERATOR_TABLE_ROW_INDEX 0x0A,0x81,0x05
|
||||
#define HID_USAGE_SENSOR_PROPERTY_ENUMERATOR_TABLE_ROW_COUNT 0x0A,0x82,0x05
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Other HID definitions
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//NOTE: These definitions are designed to permit compiling the HID report descriptors
|
||||
// with somewhat self-explanatory information to help readability and reduce errors
|
||||
|
||||
//input,output,feature flags
|
||||
#define Data_Arr_Abs 0x00
|
||||
#define Const_Arr_Abs 0x01
|
||||
#define Data_Var_Abs 0x02
|
||||
#define Const_Var_Abs 0x03
|
||||
#define Data_Var_Rel 0x06
|
||||
//collection flags
|
||||
#define Physical 0x00
|
||||
#define Application 0x01
|
||||
#define Logical 0x02
|
||||
#define NamedArray 0x04
|
||||
#define UsageSwitch 0x05
|
||||
//other
|
||||
#define Undefined 0x00
|
||||
|
||||
#define HID_USAGE_PAGE(a) 0x05,a
|
||||
#define HID_USAGE(a) 0x09,a
|
||||
#define HID_USAGE16(a,b) 0x0A,a,b
|
||||
#define HID_USAGE_SENSOR_DATA(a,b) a|b //This or-s the mod into usage
|
||||
#define HID_COLLECTION(a) 0xA1,a
|
||||
#define HID_REPORT_ID(a) 0x85,a
|
||||
#define HID_REPORT_SIZE(a) 0x75,a
|
||||
#define HID_REPORT_COUNT(a) 0x95,a
|
||||
#define HID_USAGE_MIN_8(a) 0x19,a
|
||||
#define HID_USAGE_MIN_16(a,b) 0x1A,a,b
|
||||
#define HID_USAGE_MAX_8(a) 0x29,a
|
||||
#define HID_USAGE_MAX_16(a,b) 0x2A,a,b
|
||||
#define HID_LOGICAL_MIN_8(a) 0x15,a
|
||||
#define HID_LOGICAL_MIN_16(a,b) 0x16,a,b
|
||||
#define HID_LOGICAL_MIN_32(a,b,c,d) 0x17,a,b,c,d
|
||||
#define HID_LOGICAL_MAX_8(a) 0x25,a
|
||||
#define HID_LOGICAL_MAX_16(a,b) 0x26,a,b
|
||||
#define HID_LOGICAL_MAX_32(a,b,c,d) 0x27,a,b,c,d
|
||||
#define HID_UNIT_EXPONENT(a) 0x55,a
|
||||
#define HID_INPUT(a) 0x81,a
|
||||
#define HID_OUTPUT(a) 0x91,a
|
||||
#define HID_FEATURE(a) 0xB1,a
|
||||
#define HID_END_COLLECTION 0xC0
|
||||
|
||||
#endif // HIDUTIL_TEST_HIDSENSORSPEC_H
|
||||
202
modules/sensors/dynamic_sensor/HidUtils/test/TriStateTest.cpp
Normal file
202
modules/sensors/dynamic_sensor/HidUtils/test/TriStateTest.cpp
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "TriState.h"
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
|
||||
using HidUtil::TriState;
|
||||
typedef TriState<uint32_t> tri_uint32_t;
|
||||
typedef TriState<int32_t> tri_int32_t;
|
||||
typedef TriState<int16_t> tri_int16_t;
|
||||
|
||||
TEST(TriStateTest, Constructor) {
|
||||
tri_uint32_t a;
|
||||
EXPECT_FALSE(a.isSet());
|
||||
|
||||
a += 1;
|
||||
EXPECT_FALSE(a.isSet());
|
||||
|
||||
a -= 1;
|
||||
EXPECT_FALSE(a.isSet());
|
||||
|
||||
a *= 1;
|
||||
EXPECT_FALSE(a.isSet());
|
||||
|
||||
a /= 1;
|
||||
EXPECT_FALSE(a.isSet());
|
||||
|
||||
tri_uint32_t b;
|
||||
b = a;
|
||||
EXPECT_FALSE(b.isSet());
|
||||
|
||||
a = 1;
|
||||
EXPECT_TRUE(a.isSet());
|
||||
|
||||
b = a;
|
||||
EXPECT_TRUE(b.isSet());
|
||||
|
||||
a.clear();
|
||||
EXPECT_FALSE(a.isSet());
|
||||
EXPECT_TRUE(b.isSet());
|
||||
|
||||
tri_uint32_t c(b);
|
||||
EXPECT_TRUE(c.isSet());
|
||||
|
||||
c.clear();
|
||||
EXPECT_FALSE(c.isSet());
|
||||
|
||||
tri_uint32_t d(a);
|
||||
EXPECT_FALSE(c.isSet());
|
||||
}
|
||||
|
||||
TEST(TriStateTest, IncAndDecOperation) {
|
||||
tri_int32_t a(1);
|
||||
|
||||
EXPECT_EQ(2, (++a).get(0));
|
||||
EXPECT_EQ(2, (a++).get(0));
|
||||
EXPECT_EQ(3, a.get(0));
|
||||
|
||||
EXPECT_EQ(2, (--a).get(0));
|
||||
EXPECT_EQ(2, (a--).get(0));
|
||||
EXPECT_EQ(1, a.get(0));
|
||||
|
||||
tri_uint32_t b;
|
||||
EXPECT_EQ(static_cast<uint32_t>(100), (++b).get(100));
|
||||
EXPECT_EQ(static_cast<uint32_t>(101), (b++).get(101));
|
||||
EXPECT_EQ(static_cast<uint32_t>(102), b.get(102));
|
||||
EXPECT_FALSE(b.isSet());
|
||||
|
||||
EXPECT_EQ(static_cast<uint32_t>(103), (--b).get(103));
|
||||
EXPECT_EQ(static_cast<uint32_t>(104), (b--).get(104));
|
||||
EXPECT_EQ(static_cast<uint32_t>(105), b.get(105));
|
||||
EXPECT_FALSE(b.isSet());
|
||||
}
|
||||
|
||||
TEST(TriStateTest, Comparison) {
|
||||
tri_int32_t a(1);
|
||||
tri_int32_t b(1);
|
||||
tri_int32_t c(2);
|
||||
tri_int32_t d;
|
||||
|
||||
EXPECT_EQ(a, b);
|
||||
EXPECT_FALSE((a != b));
|
||||
EXPECT_TRUE(!(a != b));
|
||||
EXPECT_NE(-1, a);
|
||||
|
||||
EXPECT_LT(a, c);
|
||||
EXPECT_LT(a, 3);
|
||||
|
||||
EXPECT_GT(c, b);
|
||||
EXPECT_GT(c, 0);
|
||||
|
||||
EXPECT_LE(a, 1);
|
||||
EXPECT_LE(a, c);
|
||||
EXPECT_LE(a, 3);
|
||||
EXPECT_LE(a, b);
|
||||
|
||||
EXPECT_GE(c, b);
|
||||
EXPECT_GE(b, a);
|
||||
EXPECT_GE(c, 0);
|
||||
EXPECT_GE(c, 2);
|
||||
|
||||
EXPECT_FALSE((a == d).isSet());
|
||||
EXPECT_FALSE((a >= d).isSet());
|
||||
EXPECT_FALSE((a <= d).isSet());
|
||||
EXPECT_FALSE((a != d).isSet());
|
||||
EXPECT_FALSE((a > d).isSet());
|
||||
EXPECT_FALSE((a < d).isSet());
|
||||
|
||||
//EXPECT_EQ(a, d); // will cause runtime failure
|
||||
// due to converting a not-set TriState<bool> to bool
|
||||
}
|
||||
|
||||
TEST(TriStateTest, CompoundAssign) {
|
||||
tri_uint32_t x;
|
||||
|
||||
x += 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x -= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x *= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x /= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x &= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x |= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x %= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x <<= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
x >>= 10;
|
||||
EXPECT_FALSE(x.isSet());
|
||||
|
||||
tri_int32_t y, z, w;
|
||||
#define TEST_COMPOUND_ASSIGN(a, op, op_c, b) \
|
||||
y = z = a; \
|
||||
w = b; \
|
||||
y op_c b; \
|
||||
EXPECT_TRUE(y.isSet()); \
|
||||
EXPECT_EQ(y, (a op b)); \
|
||||
EXPECT_EQ(y, (z op b)); \
|
||||
EXPECT_EQ(y, (a op w));
|
||||
|
||||
TEST_COMPOUND_ASSIGN(123, +, +=, 456);
|
||||
TEST_COMPOUND_ASSIGN(123, -, -=, 456);
|
||||
TEST_COMPOUND_ASSIGN(123, *, *=, 456);
|
||||
TEST_COMPOUND_ASSIGN(123, /, /=, 456);
|
||||
TEST_COMPOUND_ASSIGN(123, |, |=, 456);
|
||||
TEST_COMPOUND_ASSIGN(123, &, &=, 456);
|
||||
TEST_COMPOUND_ASSIGN(123, ^, ^=, 456);
|
||||
TEST_COMPOUND_ASSIGN(123, %, %=, 456);
|
||||
#undef TEST_COMPOUND_ASSIGN
|
||||
y = z = 123;
|
||||
w = 10;
|
||||
y <<= 10;
|
||||
EXPECT_TRUE(y.isSet());
|
||||
EXPECT_EQ(123 << 10, y);
|
||||
|
||||
y = z = 12345;
|
||||
w = 10;
|
||||
y >>= 10;
|
||||
EXPECT_TRUE(y.isSet());
|
||||
EXPECT_EQ(12345 >> 10, y);
|
||||
}
|
||||
|
||||
TEST(TriStateTest, UnaryOperation) {
|
||||
tri_int16_t p;
|
||||
EXPECT_FALSE((!p).isSet());
|
||||
EXPECT_FALSE((-p).isSet());
|
||||
EXPECT_FALSE((~p).isSet());
|
||||
|
||||
tri_int16_t q(1234);
|
||||
EXPECT_TRUE((!q).isSet());
|
||||
EXPECT_EQ(!static_cast<int16_t>(1234), (!q));
|
||||
|
||||
tri_int16_t r(1234);
|
||||
EXPECT_TRUE((-r).isSet());
|
||||
EXPECT_EQ(-1234, (-r));
|
||||
|
||||
tri_int16_t s(1234);
|
||||
EXPECT_TRUE((~s).isSet());
|
||||
EXPECT_EQ(~static_cast<int16_t>(1234), ~s);
|
||||
}
|
||||
|
||||
Loading…
Reference in a new issue