// *************************************************************************
//
// IOHIDElement_SetupCalibration(inIOHIDElementRef)
//
// Purpose: set default values for the element calibration parameters
//
// Inputs: inIOHIDElementRef - the IOHIDElementRef for this element
//
// Returns: nothing
//
void IOHIDElement_SetupCalibration(IOHIDElementRef inIOHIDElementRef) {
// these are the min/max values returned by IOHIDValueGetScaledValue(v, kIOHIDValueScaleTypeCalibrated);
IOHIDElement_SetCalibrationMin(inIOHIDElementRef, IOHIDElementGetLogicalMin(inIOHIDElementRef));
IOHIDElement_SetCalibrationMax(inIOHIDElementRef, IOHIDElementGetLogicalMax(inIOHIDElementRef));
CFIndex phyMin = IOHIDElementGetPhysicalMin(inIOHIDElementRef);
CFIndex phyMax = IOHIDElementGetPhysicalMax(inIOHIDElementRef);
CFIndex phyRange = phyMax - phyMin;
// calculate the middle physical value we would expect from this element
double phyMid = (phyMin + phyMax) / 2.f;
// this is the granularity of the values returned by IOHIDValueGetScaledValue(v, kIOHIDValueScaleTypeCalibrated);
// for example if set to 0.1 the values returned will be multiples of 0.1 (0.1, 0.2, 0.3, etc.)
IOHIDElement_SetCalibrationGranularity(inIOHIDElementRef, 0.);
Boolean isRelative = IOHIDElementIsRelative(inIOHIDElementRef);
Boolean hasPreferredState = IOHIDElementHasPreferredState(inIOHIDElementRef);
// define the dead zone (like in the middle of joystick axis)
if (!isRelative && hasPreferredState && (phyRange > 3)) {
IOHIDElement_SetCalibrationDeadZoneMin(inIOHIDElementRef, phyMid - 1.0);
IOHIDElement_SetCalibrationDeadZoneMax(inIOHIDElementRef, phyMid + 1.0);
} else {
IOHIDElement_SetCalibrationDeadZoneMin(inIOHIDElementRef, 0.);
IOHIDElement_SetCalibrationDeadZoneMax(inIOHIDElementRef, 0.);
}
// get the current value of this element
double phyValue = IOHIDElement_GetValue(inIOHIDElementRef, kIOHIDValueScaleTypePhysical);
#if true
// use that that value to determine the min/max saturation values used for calibration
IOHIDElement_SetCalibrationSaturationMin(inIOHIDElementRef, phyValue);
IOHIDElement_SetCalibrationSaturationMax(inIOHIDElementRef, phyValue);
#else // if 1
#if true
// this value determines the min/max values that have been recieved from the device element
IOHIDElement_SetCalibrationSaturationMin(inIOHIDElementRef, (phyMin + phyMid) / 2.f);
IOHIDElement_SetCalibrationSaturationMax(inIOHIDElementRef, (phyMid + phyMax) / 2.f);
#else // if 1
// use it as our min/max saturation
// this value determines the min/max values that have been recieved from the device element
IOHIDElement_SetCalibrationSaturationMin(inIOHIDElementRef, phyMid);
IOHIDElement_SetCalibrationSaturationMax(inIOHIDElementRef, phyMid);
#endif // if 1
// and the current value to adjust the current saturation values if it's outside their range
if (phyValue < IOHIDElement_GetCalibrationSaturationMin(inIOHIDElementRef)) {
IOHIDElement_SetCalibrationSaturationMin(inIOHIDElementRef, phyValue);
}
if (phyValue > IOHIDElement_GetCalibrationSaturationMax(inIOHIDElementRef)) {
IOHIDElement_SetCalibrationSaturationMax(inIOHIDElementRef, phyValue);
}
#endif // if 1
} // IOHIDElement_SetupCalibration
// utility routine to dump element info
void HIDDumpElementInfo(IOHIDElementRef inIOHIDElementRef) {
if (inIOHIDElementRef) {
printf(" Element: %p = { ", inIOHIDElementRef);
#if false
IOHIDDeviceRef tIOHIDDeviceRef = IOHIDElementGetDevice(inIOHIDElementRef);
printf("Device: %p, ", tIOHIDDeviceRef);
#endif // if 0
IOHIDElementRef parentIOHIDElementRef = IOHIDElementGetParent(inIOHIDElementRef);
printf("parent: %p, ", parentIOHIDElementRef);
#if false
CFArrayRef childrenCFArrayRef = IOHIDElementGetChildren(inIOHIDElementRef);
printf("children: %p: { ", childrenCFArrayRef);
fflush(stdout);
CFShow(childrenCFArrayRef);
fflush(stdout);
printf(" }, ");
#endif // if 0
IOHIDElementCookie tIOHIDElementCookie = IOHIDElementGetCookie(inIOHIDElementRef);
printf("cookie: 0x%08lX, ", (long unsigned int) tIOHIDElementCookie);
IOHIDElementType tIOHIDElementType = IOHIDElementGetType(inIOHIDElementRef);
switch (tIOHIDElementType) {
case kIOHIDElementTypeInput_Misc:
{
printf("type: Misc, ");
break;
}
case kIOHIDElementTypeInput_Button:
{
printf("type: Button, ");
break;
}
case kIOHIDElementTypeInput_Axis:
{
printf("type: Axis, ");
break;
}
case kIOHIDElementTypeInput_ScanCodes:
{
printf("type: ScanCodes, ");
break;
}
case kIOHIDElementTypeOutput:
{
printf("type: Output, ");
break;
}
case kIOHIDElementTypeFeature:
{
printf("type: Feature, ");
break;
}
case kIOHIDElementTypeCollection:
{
IOHIDElementCollectionType tIOHIDElementCollectionType = IOHIDElementGetCollectionType(inIOHIDElementRef);
switch (tIOHIDElementCollectionType) {
case kIOHIDElementCollectionTypePhysical:
{
printf("type: Physical Collection, ");
break;
}
case kIOHIDElementCollectionTypeApplication:
{
printf("type: Application Collection, ");
break;
}
case kIOHIDElementCollectionTypeLogical:
{
printf("type: Logical Collection, ");
break;
}
case kIOHIDElementCollectionTypeReport:
{
printf("type: Report Collection, ");
break;
}
case kIOHIDElementCollectionTypeNamedArray:
{
printf("type: Named Array Collection, ");
break;
}
case kIOHIDElementCollectionTypeUsageSwitch:
{
printf("type: Usage Switch Collection, ");
break;
}
case kIOHIDElementCollectionTypeUsageModifier:
{
printf("type: Usage Modifier Collection, ");
break;
}
default:
{
printf("type: %p Collection, ", (void *) tIOHIDElementCollectionType);
break;
}
} // switch
break;
}
default:
{
printf("type: %p, ", (void *) tIOHIDElementType);
break;
}
} /* switch */
uint32_t usagePage = IOHIDElementGetUsagePage(inIOHIDElementRef);
uint32_t usage = IOHIDElementGetUsage(inIOHIDElementRef);
printf("usage: 0x%04lX:0x%04lX, ", (long unsigned int) usagePage, (long unsigned int) usage);
CFStringRef tCFStringRef = HIDCopyUsageName(usagePage, usage);
if (tCFStringRef) {
char usageString[256] = "";
(void) CFStringGetCString(tCFStringRef, usageString, sizeof(usageString), kCFStringEncodingUTF8);
printf("\"%s\", ", usageString);
CFRelease(tCFStringRef);
}
CFStringRef nameCFStringRef = IOHIDElementGetName(inIOHIDElementRef);
char buffer[256];
if ( nameCFStringRef && CFStringGetCString(nameCFStringRef, buffer, sizeof(buffer), kCFStringEncodingUTF8) ) {
printf("name: %s, ", buffer);
}
uint32_t reportID = IOHIDElementGetReportID(inIOHIDElementRef);
uint32_t reportSize = IOHIDElementGetReportSize(inIOHIDElementRef);
uint32_t reportCount = IOHIDElementGetReportCount(inIOHIDElementRef);
printf("report: { ID: %lu, Size: %lu, Count: %lu }, ",
(long unsigned int) reportID, (long unsigned int) reportSize, (long unsigned int) reportCount);
uint32_t unit = IOHIDElementGetUnit(inIOHIDElementRef);
uint32_t unitExp = IOHIDElementGetUnitExponent(inIOHIDElementRef);
if (unit || unitExp) {
printf("unit: %lu * 10^%lu, ", (long unsigned int) unit, (long unsigned int) unitExp);
}
CFIndex logicalMin = IOHIDElementGetLogicalMin(inIOHIDElementRef);
CFIndex logicalMax = IOHIDElementGetLogicalMax(inIOHIDElementRef);
if (logicalMin != logicalMax) {
printf("logical: {min: %ld, max: %ld}, ", logicalMin, logicalMax);
}
CFIndex physicalMin = IOHIDElementGetPhysicalMin(inIOHIDElementRef);
CFIndex physicalMax = IOHIDElementGetPhysicalMax(inIOHIDElementRef);
if (physicalMin != physicalMax) {
printf("physical: {min: %ld, max: %ld}, ", physicalMin, physicalMax);
}
Boolean isVirtual = IOHIDElementIsVirtual(inIOHIDElementRef);
if (isVirtual) {
printf("isVirtual, ");
}
Boolean isRelative = IOHIDElementIsRelative(inIOHIDElementRef);
if (isRelative) {
printf("isRelative, ");
}
Boolean isWrapping = IOHIDElementIsWrapping(inIOHIDElementRef);
if (isWrapping) {
printf("isWrapping, ");
}
Boolean isArray = IOHIDElementIsArray(inIOHIDElementRef);
if (isArray) {
printf("isArray, ");
}
Boolean isNonLinear = IOHIDElementIsNonLinear(inIOHIDElementRef);
if (isNonLinear) {
printf("isNonLinear, ");
}
Boolean hasPreferredState = IOHIDElementHasPreferredState(inIOHIDElementRef);
if (hasPreferredState) {
printf("hasPreferredState, ");
}
Boolean hasNullState = IOHIDElementHasNullState(inIOHIDElementRef);
if (hasNullState) {
printf("hasNullState, ");
}
printf(" }\n");
}
} // HIDDumpElementInfo
