summaryrefslogtreecommitdiff
path: root/tmk_core/protocol/usb_hid/USB_Host_Shield_2.0/hidescriptorparser.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tmk_core/protocol/usb_hid/USB_Host_Shield_2.0/hidescriptorparser.cpp')
m---------tmk_core/protocol/usb_hid/USB_Host_Shield_2.00
-rw-r--r--tmk_core/protocol/usb_hid/USB_Host_Shield_2.0/hidescriptorparser.cpp1588
2 files changed, 1588 insertions, 0 deletions
diff --git a/tmk_core/protocol/usb_hid/USB_Host_Shield_2.0 b/tmk_core/protocol/usb_hid/USB_Host_Shield_2.0
deleted file mode 160000
-Subproject 7c2e6c1bcdcc22cfdbd82edd9d8fc4c4276ead4
diff --git a/tmk_core/protocol/usb_hid/USB_Host_Shield_2.0/hidescriptorparser.cpp b/tmk_core/protocol/usb_hid/USB_Host_Shield_2.0/hidescriptorparser.cpp
new file mode 100644
index 0000000000..e4491b4e97
--- /dev/null
+++ b/tmk_core/protocol/usb_hid/USB_Host_Shield_2.0/hidescriptorparser.cpp
@@ -0,0 +1,1588 @@
+/* Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
+
+This software may be distributed and modified under the terms of the GNU
+General Public License version 2 (GPL2) as published by the Free Software
+Foundation and appearing in the file GPL2.TXT included in the packaging of
+this file. Please note that GPL2 Section 2[b] requires that all works based
+on this software must also be made publicly available under the terms of
+the GPL2 ("Copyleft").
+
+Contact information
+-------------------
+
+Circuits At Home, LTD
+Web : http://www.circuitsathome.com
+e-mail : support@circuitsathome.com
+ */
+
+#include "hidescriptorparser.h"
+
+const char * const ReportDescParserBase::usagePageTitles0[] PROGMEM = {
+ pstrUsagePageGenericDesktopControls,
+ pstrUsagePageSimulationControls,
+ pstrUsagePageVRControls,
+ pstrUsagePageSportControls,
+ pstrUsagePageGameControls,
+ pstrUsagePageGenericDeviceControls,
+ pstrUsagePageKeyboardKeypad,
+ pstrUsagePageLEDs,
+ pstrUsagePageButton,
+ pstrUsagePageOrdinal,
+ pstrUsagePageTelephone,
+ pstrUsagePageConsumer,
+ pstrUsagePageDigitizer,
+ pstrUsagePagePID,
+ pstrUsagePageUnicode
+};
+
+const char * const ReportDescParserBase::usagePageTitles1[] PROGMEM = {
+ pstrUsagePageBarCodeScanner,
+ pstrUsagePageScale,
+ pstrUsagePageMSRDevices,
+ pstrUsagePagePointOfSale,
+ pstrUsagePageCameraControl,
+ pstrUsagePageArcade
+};
+const char * const ReportDescParserBase::genDesktopTitles0[] PROGMEM = {
+ pstrUsagePointer,
+ pstrUsageMouse,
+ pstrUsageJoystick,
+ pstrUsageGamePad,
+ pstrUsageKeyboard,
+ pstrUsageKeypad,
+ pstrUsageMultiAxisController,
+ pstrUsageTabletPCSystemControls
+
+};
+const char * const ReportDescParserBase::genDesktopTitles1[] PROGMEM = {
+ pstrUsageX,
+ pstrUsageY,
+ pstrUsageZ,
+ pstrUsageRx,
+ pstrUsageRy,
+ pstrUsageRz,
+ pstrUsageSlider,
+ pstrUsageDial,
+ pstrUsageWheel,
+ pstrUsageHatSwitch,
+ pstrUsageCountedBuffer,
+ pstrUsageByteCount,
+ pstrUsageMotionWakeup,
+ pstrUsageStart,
+ pstrUsageSelect,
+ pstrUsagePageReserved,
+ pstrUsageVx,
+ pstrUsageVy,
+ pstrUsageVz,
+ pstrUsageVbrx,
+ pstrUsageVbry,
+ pstrUsageVbrz,
+ pstrUsageVno,
+ pstrUsageFeatureNotification,
+ pstrUsageResolutionMultiplier
+};
+const char * const ReportDescParserBase::genDesktopTitles2[] PROGMEM = {
+ pstrUsageSystemControl,
+ pstrUsageSystemPowerDown,
+ pstrUsageSystemSleep,
+ pstrUsageSystemWakeup,
+ pstrUsageSystemContextMenu,
+ pstrUsageSystemMainMenu,
+ pstrUsageSystemAppMenu,
+ pstrUsageSystemMenuHelp,
+ pstrUsageSystemMenuExit,
+ pstrUsageSystemMenuSelect,
+ pstrUsageSystemMenuRight,
+ pstrUsageSystemMenuLeft,
+ pstrUsageSystemMenuUp,
+ pstrUsageSystemMenuDown,
+ pstrUsageSystemColdRestart,
+ pstrUsageSystemWarmRestart,
+ pstrUsageDPadUp,
+ pstrUsageDPadDown,
+ pstrUsageDPadRight,
+ pstrUsageDPadLeft
+};
+const char * const ReportDescParserBase::genDesktopTitles3[] PROGMEM = {
+ pstrUsageSystemDock,
+ pstrUsageSystemUndock,
+ pstrUsageSystemSetup,
+ pstrUsageSystemBreak,
+ pstrUsageSystemDebuggerBreak,
+ pstrUsageApplicationBreak,
+ pstrUsageApplicationDebuggerBreak,
+ pstrUsageSystemSpeakerMute,
+ pstrUsageSystemHibernate
+};
+const char * const ReportDescParserBase::genDesktopTitles4[] PROGMEM = {
+ pstrUsageSystemDisplayInvert,
+ pstrUsageSystemDisplayInternal,
+ pstrUsageSystemDisplayExternal,
+ pstrUsageSystemDisplayBoth,
+ pstrUsageSystemDisplayDual,
+ pstrUsageSystemDisplayToggleIntExt,
+ pstrUsageSystemDisplaySwapPriSec,
+ pstrUsageSystemDisplayLCDAutoscale
+};
+const char * const ReportDescParserBase::simuTitles0[] PROGMEM = {
+ pstrUsageFlightSimulationDevice,
+ pstrUsageAutomobileSimulationDevice,
+ pstrUsageTankSimulationDevice,
+ pstrUsageSpaceshipSimulationDevice,
+ pstrUsageSubmarineSimulationDevice,
+ pstrUsageSailingSimulationDevice,
+ pstrUsageMotocicleSimulationDevice,
+ pstrUsageSportsSimulationDevice,
+ pstrUsageAirplaneSimulationDevice,
+ pstrUsageHelicopterSimulationDevice,
+ pstrUsageMagicCarpetSimulationDevice,
+ pstrUsageBicycleSimulationDevice
+};
+const char * const ReportDescParserBase::simuTitles1[] PROGMEM = {
+ pstrUsageFlightControlStick,
+ pstrUsageFlightStick,
+ pstrUsageCyclicControl,
+ pstrUsageCyclicTrim,
+ pstrUsageFlightYoke,
+ pstrUsageTrackControl
+};
+const char * const ReportDescParserBase::simuTitles2[] PROGMEM = {
+ pstrUsageAileron,
+ pstrUsageAileronTrim,
+ pstrUsageAntiTorqueControl,
+ pstrUsageAutopilotEnable,
+ pstrUsageChaffRelease,
+ pstrUsageCollectiveControl,
+ pstrUsageDiveBrake,
+ pstrUsageElectronicCountermeasures,
+ pstrUsageElevator,
+ pstrUsageElevatorTrim,
+ pstrUsageRudder,
+ pstrUsageThrottle,
+ pstrUsageFlightCommunications,
+ pstrUsageFlareRelease,
+ pstrUsageLandingGear,
+ pstrUsageToeBrake,
+ pstrUsageTrigger,
+ pstrUsageWeaponsArm,
+ pstrUsageWeaponsSelect,
+ pstrUsageWingFlaps,
+ pstrUsageAccelerator,
+ pstrUsageBrake,
+ pstrUsageClutch,
+ pstrUsageShifter,
+ pstrUsageSteering,
+ pstrUsageTurretDirection,
+ pstrUsageBarrelElevation,
+ pstrUsageDivePlane,
+ pstrUsageBallast,
+ pstrUsageBicycleCrank,
+ pstrUsageHandleBars,
+ pstrUsageFrontBrake,
+ pstrUsageRearBrake
+};
+const char * const ReportDescParserBase::vrTitles0[] PROGMEM = {
+ pstrUsageBelt,
+ pstrUsageBodySuit,
+ pstrUsageFlexor,
+ pstrUsageGlove,
+ pstrUsageHeadTracker,
+ pstrUsageHeadMountedDisplay,
+ pstrUsageHandTracker,
+ pstrUsageOculometer,
+ pstrUsageVest,
+ pstrUsageAnimatronicDevice
+};
+const char * const ReportDescParserBase::vrTitles1[] PROGMEM = {
+ pstrUsageStereoEnable,
+ pstrUsageDisplayEnable
+};
+const char * const ReportDescParserBase::sportsCtrlTitles0[] PROGMEM = {
+ pstrUsageBaseballBat,
+ pstrUsageGolfClub,
+ pstrUsageRowingMachine,
+ pstrUsageTreadmill
+};
+const char * const ReportDescParserBase::sportsCtrlTitles1[] PROGMEM = {
+ pstrUsageOar,
+ pstrUsageSlope,
+ pstrUsageRate,
+ pstrUsageStickSpeed,
+ pstrUsageStickFaceAngle,
+ pstrUsageStickHeelToe,
+ pstrUsageStickFollowThough,
+ pstrUsageStickTempo,
+ pstrUsageStickType,
+ pstrUsageStickHeight
+};
+const char * const ReportDescParserBase::sportsCtrlTitles2[] PROGMEM = {
+ pstrUsagePutter,
+ pstrUsage1Iron,
+ pstrUsage2Iron,
+ pstrUsage3Iron,
+ pstrUsage4Iron,
+ pstrUsage5Iron,
+ pstrUsage6Iron,
+ pstrUsage7Iron,
+ pstrUsage8Iron,
+ pstrUsage9Iron,
+ pstrUsage10Iron,
+ pstrUsage11Iron,
+ pstrUsageSandWedge,
+ pstrUsageLoftWedge,
+ pstrUsagePowerWedge,
+ pstrUsage1Wood,
+ pstrUsage3Wood,
+ pstrUsage5Wood,
+ pstrUsage7Wood,
+ pstrUsage9Wood
+};
+const char * const ReportDescParserBase::gameTitles0[] PROGMEM = {
+ pstrUsage3DGameController,
+ pstrUsagePinballDevice,
+ pstrUsageGunDevice
+};
+const char * const ReportDescParserBase::gameTitles1[] PROGMEM = {
+ pstrUsagePointOfView,
+ pstrUsageTurnRightLeft,
+ pstrUsagePitchForwardBackward,
+ pstrUsageRollRightLeft,
+ pstrUsageMoveRightLeft,
+ pstrUsageMoveForwardBackward,
+ pstrUsageMoveUpDown,
+ pstrUsageLeanRightLeft,
+ pstrUsageLeanForwardBackward,
+ pstrUsageHeightOfPOV,
+ pstrUsageFlipper,
+ pstrUsageSecondaryFlipper,
+ pstrUsageBump,
+ pstrUsageNewGame,
+ pstrUsageShootBall,
+ pstrUsagePlayer,
+ pstrUsageGunBolt,
+ pstrUsageGunClip,
+ pstrUsageGunSelector,
+ pstrUsageGunSingleShot,
+ pstrUsageGunBurst,
+ pstrUsageGunAutomatic,
+ pstrUsageGunSafety,
+ pstrUsageGamepadFireJump,
+ pstrUsageGamepadTrigger
+};
+const char * const ReportDescParserBase::genDevCtrlTitles[] PROGMEM = {
+ pstrUsageBatteryStrength,
+ pstrUsageWirelessChannel,
+ pstrUsageWirelessID,
+ pstrUsageDiscoverWirelessControl,
+ pstrUsageSecurityCodeCharEntered,
+ pstrUsageSecurityCodeCharErased,
+ pstrUsageSecurityCodeCleared
+};
+const char * const ReportDescParserBase::ledTitles[] PROGMEM = {
+ pstrUsageNumLock,
+ pstrUsageCapsLock,
+ pstrUsageScrollLock,
+ pstrUsageCompose,
+ pstrUsageKana,
+ pstrUsagePower,
+ pstrUsageShift,
+ pstrUsageDoNotDisturb,
+ pstrUsageMute,
+ pstrUsageToneEnable,
+ pstrUsageHighCutFilter,
+ pstrUsageLowCutFilter,
+ pstrUsageEqualizerEnable,
+ pstrUsageSoundFieldOn,
+ pstrUsageSurroundOn,
+ pstrUsageRepeat,
+ pstrUsageStereo,
+ pstrUsageSamplingRateDetect,
+ pstrUsageSpinning,
+ pstrUsageCAV,
+ pstrUsageCLV,
+ pstrUsageRecordingFormatDetect,
+ pstrUsageOffHook,
+ pstrUsageRing,
+ pstrUsageMessageWaiting,
+ pstrUsageDataMode,
+ pstrUsageBatteryOperation,
+ pstrUsageBatteryOK,
+ pstrUsageBatteryLow,
+ pstrUsageSpeaker,
+ pstrUsageHeadSet,
+ pstrUsageHold,
+ pstrUsageMicrophone,
+ pstrUsageCoverage,
+ pstrUsageNightMode,
+ pstrUsageSendCalls,
+ pstrUsageCallPickup,
+ pstrUsageConference,
+ pstrUsageStandBy,
+ pstrUsageCameraOn,
+ pstrUsageCameraOff,
+ pstrUsageOnLine,
+ pstrUsageOffLine,
+ pstrUsageBusy,
+ pstrUsageReady,
+ pstrUsagePaperOut,
+ pstrUsagePaperJam,
+ pstrUsageRemote,
+ pstrUsageForward,
+ pstrUsageReverse,
+ pstrUsageStop,
+ pstrUsageRewind,
+ pstrUsageFastForward,
+ pstrUsagePlay,
+ pstrUsagePause,
+ pstrUsageRecord,
+ pstrUsageError,
+ pstrUsageSelectedIndicator,
+ pstrUsageInUseIndicator,
+ pstrUsageMultiModeIndicator,
+ pstrUsageIndicatorOn,
+ pstrUsageIndicatorFlash,
+ pstrUsageIndicatorSlowBlink,
+ pstrUsageIndicatorFastBlink,
+ pstrUsageIndicatorOff,
+ pstrUsageFlashOnTime,
+ pstrUsageSlowBlinkOnTime,
+ pstrUsageSlowBlinkOffTime,
+ pstrUsageFastBlinkOnTime,
+ pstrUsageFastBlinkOffTime,
+ pstrUsageIndicatorColor,
+ pstrUsageIndicatorRed,
+ pstrUsageIndicatorGreen,
+ pstrUsageIndicatorAmber,
+ pstrUsageGenericIndicator,
+ pstrUsageSystemSuspend,
+ pstrUsageExternalPowerConnected
+};
+const char * const ReportDescParserBase::telTitles0 [] PROGMEM = {
+ pstrUsagePhone,
+ pstrUsageAnsweringMachine,
+ pstrUsageMessageControls,
+ pstrUsageHandset,
+ pstrUsageHeadset,
+ pstrUsageTelephonyKeyPad,
+ pstrUsageProgrammableButton
+};
+const char * const ReportDescParserBase::telTitles1 [] PROGMEM = {
+ pstrUsageHookSwitch,
+ pstrUsageFlash,
+ pstrUsageFeature,
+ pstrUsageHold,
+ pstrUsageRedial,
+ pstrUsageTransfer,
+ pstrUsageDrop,
+ pstrUsagePark,
+ pstrUsageForwardCalls,
+ pstrUsageAlternateFunction,
+ pstrUsageLine,
+ pstrUsageSpeakerPhone,
+ pstrUsageConference,
+ pstrUsageRingEnable,
+ pstrUsageRingSelect,
+ pstrUsagePhoneMute,
+ pstrUsageCallerID,
+ pstrUsageSend
+};
+const char * const ReportDescParserBase::telTitles2 [] PROGMEM = {
+ pstrUsageSpeedDial,
+ pstrUsageStoreNumber,
+ pstrUsageRecallNumber,
+ pstrUsagePhoneDirectory
+};
+const char * const ReportDescParserBase::telTitles3 [] PROGMEM = {
+ pstrUsageVoiceMail,
+ pstrUsageScreenCalls,
+ pstrUsageDoNotDisturb,
+ pstrUsageMessage,
+ pstrUsageAnswerOnOff
+};
+const char * const ReportDescParserBase::telTitles4 [] PROGMEM = {
+ pstrUsageInsideDialTone,
+ pstrUsageOutsideDialTone,
+ pstrUsageInsideRingTone,
+ pstrUsageOutsideRingTone,
+ pstrUsagePriorityRingTone,
+ pstrUsageInsideRingback,
+ pstrUsagePriorityRingback,
+ pstrUsageLineBusyTone,
+ pstrUsageReorderTone,
+ pstrUsageCallWaitingTone,
+ pstrUsageConfirmationTone1,
+ pstrUsageConfirmationTone2,
+ pstrUsageTonesOff,
+ pstrUsageOutsideRingback,
+ pstrUsageRinger
+};
+const char * const ReportDescParserBase::telTitles5 [] PROGMEM = {
+ pstrUsagePhoneKey0,
+ pstrUsagePhoneKey1,
+ pstrUsagePhoneKey2,
+ pstrUsagePhoneKey3,
+ pstrUsagePhoneKey4,
+ pstrUsagePhoneKey5,
+ pstrUsagePhoneKey6,
+ pstrUsagePhoneKey7,
+ pstrUsagePhoneKey8,
+ pstrUsagePhoneKey9,
+ pstrUsagePhoneKeyStar,
+ pstrUsagePhoneKeyPound,
+ pstrUsagePhoneKeyA,
+ pstrUsagePhoneKeyB,
+ pstrUsagePhoneKeyC,
+ pstrUsagePhoneKeyD
+};
+const char * const ReportDescParserBase::consTitles0[] PROGMEM = {
+ pstrUsageConsumerControl,
+ pstrUsageNumericKeyPad,
+ pstrUsageProgrammableButton,
+ pstrUsageMicrophone,
+ pstrUsageHeadphone,
+ pstrUsageGraphicEqualizer
+};
+const char * const ReportDescParserBase::consTitles1[] PROGMEM = {
+ pstrUsagePlus10,
+ pstrUsagePlus100,
+ pstrUsageAMPM
+};
+const char * const ReportDescParserBase::consTitles2[] PROGMEM = {
+ pstrUsagePower,
+ pstrUsageReset,
+ pstrUsageSleep,
+ pstrUsageSleepAfter,
+ pstrUsageSleepMode,
+ pstrUsageIllumination,
+ pstrUsageFunctionButtons
+
+};
+const char * const ReportDescParserBase::consTitles3[] PROGMEM = {
+ pstrUsageMenu,
+ pstrUsageMenuPick,
+ pstrUsageMenuUp,
+ pstrUsageMenuDown,
+ pstrUsageMenuLeft,
+ pstrUsageMenuRight,
+ pstrUsageMenuEscape,
+ pstrUsageMenuValueIncrease,
+ pstrUsageMenuValueDecrease
+};
+const char * const ReportDescParserBase::consTitles4[] PROGMEM = {
+ pstrUsageDataOnScreen,
+ pstrUsageClosedCaption,
+ pstrUsageClosedCaptionSelect,
+ pstrUsageVCRTV,
+ pstrUsageBroadcastMode,
+ pstrUsageSnapshot,
+ pstrUsageStill
+};
+const char * const ReportDescParserBase::consTitles5[] PROGMEM = {
+ pstrUsageSelection,
+ pstrUsageAssignSelection,
+ pstrUsageModeStep,
+ pstrUsageRecallLast,
+ pstrUsageEnterChannel,
+ pstrUsageOrderMovie,
+ pstrUsageChannel,
+ pstrUsageMediaSelection,
+ pstrUsageMediaSelectComputer,
+ pstrUsageMediaSelectTV,
+ pstrUsageMediaSelectWWW,
+ pstrUsageMediaSelectDVD,
+ pstrUsageMediaSelectTelephone,
+ pstrUsageMediaSelectProgramGuide,
+ pstrUsageMediaSelectVideoPhone,
+ pstrUsageMediaSelectGames,
+ pstrUsageMediaSelectMessages,
+ pstrUsageMediaSelectCD,
+ pstrUsageMediaSelectVCR,
+ pstrUsageMediaSelectTuner,
+ pstrUsageQuit,
+ pstrUsageHelp,
+ pstrUsageMediaSelectTape,
+ pstrUsageMediaSelectCable,
+ pstrUsageMediaSelectSatellite,
+ pstrUsageMediaSelectSecurity,
+ pstrUsageMediaSelectHome,
+ pstrUsageMediaSelectCall,
+ pstrUsageChannelIncrement,
+ pstrUsageChannelDecrement,
+ pstrUsageMediaSelectSAP,
+ pstrUsagePageReserved,
+ pstrUsageVCRPlus,
+ pstrUsageOnce,
+ pstrUsageDaily,
+ pstrUsageWeekly,
+ pstrUsageMonthly
+};
+const char * const ReportDescParserBase::consTitles6[] PROGMEM = {
+ pstrUsagePlay,
+ pstrUsagePause,
+ pstrUsageRecord,
+ pstrUsageFastForward,
+ pstrUsageRewind,
+ pstrUsageScanNextTrack,
+ pstrUsageScanPreviousTrack,
+ pstrUsageStop,
+ pstrUsageEject,
+ pstrUsageRandomPlay,
+ pstrUsageSelectDisk,
+ pstrUsageEnterDisk,
+ pstrUsageRepeat,
+ pstrUsageTracking,
+ pstrUsageTrackNormal,
+ pstrUsageSlowTracking,
+ pstrUsageFrameForward,
+ pstrUsageFrameBackwards,
+ pstrUsageMark,
+ pstrUsageClearMark,
+ pstrUsageRepeatFromMark,
+ pstrUsageReturnToMark,
+ pstrUsageSearchMarkForward,
+ pstrUsageSearchMarkBackwards,
+ pstrUsageCounterReset,
+ pstrUsageShowCounter,
+ pstrUsageTrackingIncrement,
+ pstrUsageTrackingDecrement,
+ pstrUsageStopEject,
+ pstrUsagePlayPause,
+ pstrUsagePlaySkip
+};
+const char * const ReportDescParserBase::consTitles7[] PROGMEM = {
+ pstrUsageVolume,
+ pstrUsageBalance,
+ pstrUsageMute,
+ pstrUsageBass,
+ pstrUsageTreble,
+ pstrUsageBassBoost,
+ pstrUsageSurroundMode,
+ pstrUsageLoudness,
+ pstrUsageMPX,
+ pstrUsageVolumeIncrement,
+ pstrUsageVolumeDecrement
+};
+const char * const ReportDescParserBase::consTitles8[] PROGMEM = {
+ pstrUsageSpeedSelect,
+ pstrUsagePlaybackSpeed,
+ pstrUsageStandardPlay,
+ pstrUsageLongPlay,
+ pstrUsageExtendedPlay,
+ pstrUsageSlow
+};
+const char * const ReportDescParserBase::consTitles9[] PROGMEM = {
+ pstrUsageFanEnable,
+ pstrUsageFanSpeed,
+ pstrUsageLightEnable,
+ pstrUsageLightIlluminationLevel,
+ pstrUsageClimateControlEnable,
+ pstrUsageRoomTemperature,
+ pstrUsageSecurityEnable,
+ pstrUsageFireAlarm,
+ pstrUsagePoliceAlarm,
+ pstrUsageProximity,
+ pstrUsageMotion,
+ pstrUsageDuresAlarm,
+ pstrUsageHoldupAlarm,
+ pstrUsageMedicalAlarm
+};
+const char * const ReportDescParserBase::consTitlesA[] PROGMEM = {
+ pstrUsageBalanceRight,
+ pstrUsageBalanceLeft,
+ pstrUsageBassIncrement,
+ pstrUsageBassDecrement,
+ pstrUsageTrebleIncrement,
+ pstrUsageTrebleDecrement
+};
+const char * const ReportDescParserBase::consTitlesB[] PROGMEM = {
+ pstrUsageSpeakerSystem,
+ pstrUsageChannelLeft,
+ pstrUsageChannelRight,
+ pstrUsageChannelCenter,
+ pstrUsageChannelFront,
+ pstrUsageChannelCenterFront,
+ pstrUsageChannelSide,
+ pstrUsageChannelSurround,
+ pstrUsageChannelLowFreqEnhancement,
+ pstrUsageChannelTop,
+ pstrUsageChannelUnknown
+};
+const char * const ReportDescParserBase::consTitlesC[] PROGMEM = {
+ pstrUsageSubChannel,
+ pstrUsageSubChannelIncrement,
+ pstrUsageSubChannelDecrement,
+ pstrUsageAlternateAudioIncrement,
+ pstrUsageAlternateAudioDecrement
+};
+const char * const ReportDescParserBase::consTitlesD[] PROGMEM = {
+ pstrUsageApplicationLaunchButtons,
+ pstrUsageALLaunchButtonConfigTool,
+ pstrUsageALProgrammableButton,
+ pstrUsageALConsumerControlConfig,
+ pstrUsageALWordProcessor,
+ pstrUsageALTextEditor,
+ pstrUsageALSpreadsheet,
+ pstrUsageALGraphicsEditor,
+ pstrUsageALPresentationApp,
+ pstrUsageALDatabaseApp,
+ pstrUsageALEmailReader,
+ pstrUsageALNewsreader,
+ pstrUsageALVoicemail,
+ pstrUsageALContactsAddressBook,
+ pstrUsageALCalendarSchedule,
+ pstrUsageALTaskProjectManager,
+ pstrUsageALLogJournalTimecard,
+ pstrUsageALCheckbookFinance,
+ pstrUsageALCalculator,
+ pstrUsageALAVCapturePlayback,
+ pstrUsageALLocalMachineBrowser,
+ pstrUsageALLANWANBrow,
+ pstrUsageALInternetBrowser,
+ pstrUsageALRemoteNetISPConnect,
+ pstrUsageALNetworkConference,
+ pstrUsageALNetworkChat,
+ pstrUsageALTelephonyDialer,
+ pstrUsageALLogon,
+ pstrUsageALLogoff,
+ pstrUsageALLogonLogoff,
+ pstrUsageALTermLockScrSav,
+ pstrUsageALControlPannel,
+ pstrUsageALCommandLineProcessorRun,
+ pstrUsageALProcessTaskManager,
+ pstrUsageALSelectTaskApplication,
+ pstrUsageALNextTaskApplication,
+ pstrUsageALPreviousTaskApplication,
+ pstrUsageALPreemptiveHaltTaskApp,
+ pstrUsageALIntegratedHelpCenter,
+ pstrUsageALDocuments,
+ pstrUsageALThesaurus,
+ pstrUsageALDictionary,
+ pstrUsageALDesktop,
+ pstrUsageALSpellCheck,
+ pstrUsageALGrammarCheck,
+ pstrUsageALWirelessStatus,
+ pstrUsageALKeyboardLayout,
+ pstrUsageALVirusProtection,
+ pstrUsageALEncryption,
+ pstrUsageALScreenSaver,
+ pstrUsageALAlarms,
+ pstrUsageALClock,
+ pstrUsageALFileBrowser,
+ pstrUsageALPowerStatus,
+ pstrUsageALImageBrowser,
+ pstrUsageALAudioBrowser,
+ pstrUsageALMovieBrowser,
+ pstrUsageALDigitalRightsManager,
+ pstrUsageALDigitalWallet,
+ pstrUsagePageReserved,
+ pstrUsageALInstantMessaging,
+ pstrUsageALOEMFeaturesBrowser,
+ pstrUsageALOEMHelp,
+ pstrUsageALOnlineCommunity,
+ pstrUsageALEntertainmentContentBrow,
+ pstrUsageALOnlineShoppingBrowser,
+ pstrUsageALSmartCardInfoHelp,
+ pstrUsageALMarketMonitorFinBrowser,
+ pstrUsageALCustomCorpNewsBrowser,
+ pstrUsageALOnlineActivityBrowser,
+ pstrUsageALResearchSearchBrowser,
+ pstrUsageALAudioPlayer
+};
+const char * const ReportDescParserBase::consTitlesE[] PROGMEM = {
+ pstrUsageGenericGUIAppControls,
+ pstrUsageACNew,
+ pstrUsageACOpen,
+ pstrUsageACClose,
+ pstrUsageACExit,
+ pstrUsageACMaximize,
+ pstrUsageACMinimize,
+ pstrUsageACSave,
+ pstrUsageACPrint,
+ pstrUsageACProperties,
+ pstrUsageACUndo,
+ pstrUsageACCopy,
+ pstrUsageACCut,
+ pstrUsageACPaste,
+ pstrUsageACSelectAll,
+ pstrUsageACFind,
+ pstrUsageACFindAndReplace,
+ pstrUsageACSearch,
+ pstrUsageACGoto,
+ pstrUsageACHome,
+ pstrUsageACBack,
+ pstrUsageACForward,
+ pstrUsageACStop,
+ pstrUsageACRefresh,
+ pstrUsageACPreviousLink,
+ pstrUsageACNextLink,
+ pstrUsageACBookmarks,
+ pstrUsageACHistory,
+ pstrUsageACSubscriptions,
+ pstrUsageACZoomIn,
+ pstrUsageACZoomOut,
+ pstrUsageACZoom,
+ pstrUsageACFullScreenView,
+ pstrUsageACNormalView,
+ pstrUsageACViewToggle,
+ pstrUsageACScrollUp,
+ pstrUsageACScrollDown,
+ pstrUsageACScroll,
+ pstrUsageACPanLeft,
+ pstrUsageACPanRight,
+ pstrUsageACPan,
+ pstrUsageACNewWindow,
+ pstrUsageACTileHoriz,
+ pstrUsageACTileVert,
+ pstrUsageACFormat,
+ pstrUsageACEdit,
+ pstrUsageACBold,
+ pstrUsageACItalics,
+ pstrUsageACUnderline,
+ pstrUsageACStrikethrough,
+ pstrUsageACSubscript,
+ pstrUsageACSuperscript,
+ pstrUsageACAllCaps,
+ pstrUsageACRotate,
+ pstrUsageACResize,
+ pstrUsageACFlipHorizontal,
+ pstrUsageACFlipVertical,
+ pstrUsageACMirrorHorizontal,
+ pstrUsageACMirrorVertical,
+ pstrUsageACFontSelect,
+ pstrUsageACFontColor,
+ pstrUsageACFontSize,
+ pstrUsageACJustifyLeft,
+ pstrUsageACJustifyCenterH,
+ pstrUsageACJustifyRight,
+ pstrUsageACJustifyBlockH,
+ pstrUsageACJustifyTop,
+ pstrUsageACJustifyCenterV,
+ pstrUsageACJustifyBottom,
+ pstrUsageACJustifyBlockV,
+ pstrUsageACIndentDecrease,
+ pstrUsageACIndentIncrease,
+ pstrUsageACNumberedList,
+ pstrUsageACRestartNumbering,
+ pstrUsageACBulletedList,
+ pstrUsageACPromote,
+ pstrUsageACDemote,
+ pstrUsageACYes,
+ pstrUsageACNo,
+ pstrUsageACCancel,
+ pstrUsageACCatalog,
+ pstrUsageACBuyChkout,
+ pstrUsageACAddToCart,
+ pstrUsageACExpand,
+ pstrUsageACExpandAll,
+ pstrUsageACCollapse,
+ pstrUsageACCollapseAll,
+ pstrUsageACPrintPreview,
+ pstrUsageACPasteSpecial,
+ pstrUsageACInsertMode,
+ pstrUsageACDelete,
+ pstrUsageACLock,
+ pstrUsageACUnlock,
+ pstrUsageACProtect,
+ pstrUsageACUnprotect,
+ pstrUsageACAttachComment,
+ pstrUsageACDeleteComment,
+ pstrUsageACViewComment,
+ pstrUsageACSelectWord,
+ pstrUsageACSelectSentence,
+ pstrUsageACSelectParagraph,
+ pstrUsageACSelectColumn,
+ pstrUsageACSelectRow,
+ pstrUsageACSelectTable,
+ pstrUsageACSelectObject,
+ pstrUsageACRedoRepeat,
+ pstrUsageACSort,
+ pstrUsageACSortAscending,
+ pstrUsageACSortDescending,
+ pstrUsageACFilter,
+ pstrUsageACSetClock,
+ pstrUsageACViewClock,
+ pstrUsageACSelectTimeZone,
+ pstrUsageACEditTimeZone,
+ pstrUsageACSetAlarm,
+ pstrUsageACClearAlarm,
+ pstrUsageACSnoozeAlarm,
+ pstrUsageACResetAlarm,
+ pstrUsageACSyncronize,
+ pstrUsageACSendReceive,
+ pstrUsageACSendTo,
+ pstrUsageACReply,
+ pstrUsageACReplyAll,
+ pstrUsageACForwardMessage,
+ pstrUsageACSend,
+ pstrUsageACAttachFile,
+ pstrUsageACUpload,
+ pstrUsageACDownload,
+ pstrUsageACSetBorders,
+ pstrUsageACInsertRow,
+ pstrUsageACInsertColumn,
+ pstrUsageACInsertFile,
+ pstrUsageACInsertPicture,
+ pstrUsageACInsertObject,
+ pstrUsageACInsertSymbol,
+ pstrUsageACSaveAndClose,
+ pstrUsageACRename,
+ pstrUsageACMerge,
+ pstrUsageACSplit,
+ pstrUsageACDistributeHorizontaly,
+ pstrUsageACDistributeVerticaly
+};
+const char * const ReportDescParserBase::digitTitles0[] PROGMEM = {
+ pstrUsageDigitizer,
+ pstrUsagePen,
+ pstrUsageLightPen,
+ pstrUsageTouchScreen,
+ pstrUsageTouchPad,
+ pstrUsageWhiteBoard,
+ pstrUsageCoordinateMeasuringMachine,
+ pstrUsage3DDigitizer,
+ pstrUsageStereoPlotter,
+ pstrUsageArticulatedArm,
+ pstrUsageArmature,
+ pstrUsageMultiplePointDigitizer,
+ pstrUsageFreeSpaceWand
+};
+const char * const ReportDescParserBase::digitTitles1[] PROGMEM = {
+ pstrUsageStylus,
+ pstrUsagePuck,
+ pstrUsageFinger
+
+};
+const char * const ReportDescParserBase::digitTitles2[] PROGMEM = {
+ pstrUsageTipPressure,
+ pstrUsageBarrelPressure,
+ pstrUsageInRange,
+ pstrUsageTouch,
+ pstrUsageUntouch,
+ pstrUsageTap,
+ pstrUsageQuality,
+ pstrUsageDataValid,
+ pstrUsageTransducerIndex,
+ pstrUsageTabletFunctionKeys,
+ pstrUsageProgramChangeKeys,
+ pstrUsageBatteryStrength,
+ pstrUsageInvert,
+ pstrUsageXTilt,
+ pstrUsageYTilt,
+ pstrUsageAzimuth,
+ pstrUsageAltitude,
+ pstrUsageTwist,
+ pstrUsageTipSwitch,
+ pstrUsageSecondaryTipSwitch,
+ pstrUsageBarrelSwitch,
+ pstrUsageEraser,
+ pstrUsageTabletPick
+};
+const char * const ReportDescParserBase::aplphanumTitles0[] PROGMEM = {
+ pstrUsageAlphanumericDisplay,
+ pstrUsageBitmappedDisplay
+};
+const char * const ReportDescParserBase::aplphanumTitles1[] PROGMEM = {
+ pstrUsageDisplayAttributesReport,
+ pstrUsageASCIICharacterSet,
+ pstrUsageDataReadBack,
+ pstrUsageFontReadBack,
+ pstrUsageDisplayControlReport,
+ pstrUsageClearDisplay,
+ pstrUsageDisplayEnable,
+ pstrUsageScreenSaverDelay,
+ pstrUsageScreenSaverEnable,
+ pstrUsageVerticalScroll,
+ pstrUsageHorizontalScroll,
+ pstrUsageCharacterReport,
+ pstrUsageDisplayData,
+ pstrUsageDisplayStatus,
+ pstrUsageStatusNotReady,
+ pstrUsageStatusReady,
+ pstrUsageErrorNotALoadableCharacter,
+ pstrUsageErrorFotDataCanNotBeRead,
+ pstrUsageCursorPositionReport,
+ pstrUsageRow,
+ pstrUsageColumn,
+ pstrUsageRows,
+ pstrUsageColumns,
+ pstrUsageCursorPixelPosition,
+ pstrUsageCursorMode,
+ pstrUsageCursorEnable,
+ pstrUsageCursorBlink,
+ pstrUsageFontReport,
+ pstrUsageFontData,
+ pstrUsageCharacterWidth,
+ pstrUsageCharacterHeight,
+ pstrUsageCharacterSpacingHorizontal,
+ pstrUsageCharacterSpacingVertical,
+ pstrUsageUnicodeCharset,
+ pstrUsageFont7Segment,
+ pstrUsage7SegmentDirectMap,
+ pstrUsageFont14Segment,
+ pstrUsage14SegmentDirectMap,
+ pstrUsageDisplayBrightness,
+ pstrUsageDisplayContrast,
+ pstrUsageCharacterAttribute,
+ pstrUsageAttributeReadback,
+ pstrUsageAttributeData,
+ pstrUsageCharAttributeEnhance,
+ pstrUsageCharAttributeUnderline,
+ pstrUsageCharAttributeBlink
+};
+const char * const ReportDescParserBase::aplphanumTitles2[] PROGMEM = {
+ pstrUsageBitmapSizeX,
+ pstrUsageBitmapSizeY,
+ pstrUsagePageReserved,
+ pstrUsageBitDepthFormat,
+ pstrUsageDisplayOrientation,
+ pstrUsagePaletteReport,
+ pstrUsagePaletteDataSize,
+ pstrUsagePaletteDataOffset,
+ pstrUsagePaletteData,
+ pstrUsageBlitReport,
+ pstrUsageBlitRectangleX1,
+ pstrUsageBlitRectangleY1,
+ pstrUsageBlitRectangleX2,
+ pstrUsageBlitRectangleY2,
+ pstrUsageBlitData,
+ pstrUsageSoftButton,
+ pstrUsageSoftButtonID,
+ pstrUsageSoftButtonSide,
+ pstrUsageSoftButtonOffset1,
+ pstrUsageSoftButtonOffset2,
+ pstrUsageSoftButtonReport
+};
+const char * const ReportDescParserBase::medInstrTitles0[] PROGMEM = {
+ pstrUsageVCRAcquisition,
+ pstrUsageFreezeThaw,
+ pstrUsageClipStore,
+ pstrUsageUpdate,
+ pstrUsageNext,
+ pstrUsageSave,
+ pstrUsagePrint,
+ pstrUsageMicrophoneEnable
+};
+const char * const ReportDescParserBase::medInstrTitles1[] PROGMEM = {
+ pstrUsageCine,
+ pstrUsageTransmitPower,
+ pstrUsageVolume,
+ pstrUsageFocus,
+ pstrUsageDepth
+};
+const char * const ReportDescParserBase::medInstrTitles2[] PROGMEM = {
+ pstrUsageSoftStepPrimary,
+ pstrUsageSoftStepSecondary
+};
+const char * const ReportDescParserBase::medInstrTitles3[] PROGMEM = {
+ pstrUsageZoomSelect,
+ pstrUsageZoomAdjust,
+ pstrUsageSpectralDopplerModeSelect,
+ pstrUsageSpectralDopplerModeAdjust,
+ pstrUsageColorDopplerModeSelect,
+ pstrUsageColorDopplerModeAdjust,
+ pstrUsageMotionModeSelect,
+ pstrUsageMotionModeAdjust,
+ pstrUsage2DModeSelect,
+ pstrUsage2DModeAdjust
+};
+const char * const ReportDescParserBase::medInstrTitles4[] PROGMEM = {
+ pstrUsageSoftControlSelect,
+ pstrUsageSoftControlAdjust
+};
+
+void ReportDescParserBase::Parse(const uint16_t len, const uint8_t *pbuf, const uint16_t &offset) {
+ uint16_t cntdn = (uint16_t)len;
+ uint8_t *p = (uint8_t*)pbuf;
+
+
+ totalSize = 0;
+
+ while(cntdn) {
+ //USB_HOST_SERIAL.println("");
+ //PrintHex<uint16_t>(offset + len - cntdn);
+ //USB_HOST_SERIAL.print(":");
+
+ ParseItem(&p, &cntdn);
+
+ //if (ParseItem(&p, &cntdn))
+ // return;
+ }
+ //USBTRACE2("Total:", totalSize);
+}
+
+void ReportDescParserBase::PrintValue(uint8_t *p, uint8_t len) {
+ E_Notify(PSTR("("), 0x80);
+ for(; len; p++, len--)
+ PrintHex<uint8_t > (*p, 0x80);
+ E_Notify(PSTR(")"), 0x80);
+}
+
+void ReportDescParserBase::PrintByteValue(uint8_t data) {
+ E_Notify(PSTR("("), 0x80);
+ PrintHex<uint8_t > (data, 0x80);
+ E_Notify(PSTR(")"), 0x80);
+}
+
+void ReportDescParserBase::PrintItemTitle(uint8_t prefix) {
+ switch(prefix & (TYPE_MASK | TAG_MASK)) {
+ case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
+ E_Notify(PSTR("\r\nPush"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_POP):
+ E_Notify(PSTR("\r\nPop"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
+ E_Notify(PSTR("\r\nUsage Page"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN):
+ E_Notify(PSTR("\r\nLogical Min"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX):
+ E_Notify(PSTR("\r\nLogical Max"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN):
+ E_Notify(PSTR("\r\nPhysical Min"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX):
+ E_Notify(PSTR("\r\nPhysical Max"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP):
+ E_Notify(PSTR("\r\nUnit Exp"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
+ E_Notify(PSTR("\r\nUnit"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
+ E_Notify(PSTR("\r\nReport Size"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
+ E_Notify(PSTR("\r\nReport Count"), 0x80);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
+ E_Notify(PSTR("\r\nReport Id"), 0x80);
+ break;
+ case (TYPE_LOCAL | TAG_LOCAL_USAGE):
+ E_Notify(PSTR("\r\nUsage"), 0x80);
+ break;
+ case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
+ E_Notify(PSTR("\r\nUsage Min"), 0x80);
+ break;
+ case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
+ E_Notify(PSTR("\r\nUsage Max"), 0x80);
+ break;
+ case (TYPE_MAIN | TAG_MAIN_COLLECTION):
+ E_Notify(PSTR("\r\nCollection"), 0x80);
+ break;
+ case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
+ E_Notify(PSTR("\r\nEnd Collection"), 0x80);
+ break;
+ case (TYPE_MAIN | TAG_MAIN_INPUT):
+ E_Notify(PSTR("\r\nInput"), 0x80);
+ break;
+ case (TYPE_MAIN | TAG_MAIN_OUTPUT):
+ E_Notify(PSTR("\r\nOutput"), 0x80);
+ break;
+ case (TYPE_MAIN | TAG_MAIN_FEATURE):
+ E_Notify(PSTR("\r\nFeature"), 0x80);
+ break;
+ } // switch (**pp & (TYPE_MASK | TAG_MASK))
+}
+
+uint8_t ReportDescParserBase::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
+ //uint8_t ret = enErrorSuccess;
+ //reinterpret_cast<>(varBuffer);
+ switch(itemParseState) {
+ case 0:
+ if(**pp == HID_LONG_ITEM_PREFIX)
+ USBTRACE("\r\nLONG\r\n");
+ else {
+ uint8_t size = ((**pp) & DATA_SIZE_MASK);
+
+ itemPrefix = (**pp);
+ itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
+
+ PrintItemTitle(itemPrefix);
+ }
+ (*pp)++;
+ (*pcntdn)--;
+ itemSize--;
+ itemParseState = 1;
+
+ if(!itemSize)
+ break;
+
+ if(!pcntdn)
+ return enErrorIncomplete;
+ case 1:
+ //USBTRACE2("\r\niSz:",itemSize);
+
+ theBuffer.valueSize = itemSize;
+ valParser.Initialize(&theBuffer);
+ itemParseState = 2;
+ case 2:
+ if(!valParser.Parse(pp, pcntdn))
+ return enErrorIncomplete;
+ itemParseState = 3;
+ case 3:
+ {
+ uint8_t data = *((uint8_t*)varBuffer);
+
+ switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
+ case (TYPE_LOCAL | TAG_LOCAL_USAGE):
+ if(pfUsage) {
+ if(theBuffer.valueSize > 1) {
+ uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
+ pfUsage(*ui16);
+ } else
+ pfUsage(data);
+ }
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
+ rptSize = data;
+ PrintByteValue(data);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
+ rptCount = data;
+ PrintByteValue(data);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN):
+ case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX):
+ case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN):
+ case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX):
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
+ case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
+ case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
+ case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP):
+ case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
+ PrintValue(varBuffer, theBuffer.valueSize);
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
+ case (TYPE_GLOBAL | TAG_GLOBAL_POP):
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
+ SetUsagePage(data);
+ PrintUsagePage(data);
+ PrintByteValue(data);
+ break;
+ case (TYPE_MAIN | TAG_MAIN_COLLECTION):
+ case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
+ switch(data) {
+ case 0x00:
+ E_Notify(PSTR(" Physical"), 0x80);
+ break;
+ case 0x01:
+ E_Notify(PSTR(" Application"), 0x80);
+ break;
+ case 0x02:
+ E_Notify(PSTR(" Logical"), 0x80);
+ break;
+ case 0x03:
+ E_Notify(PSTR(" Report"), 0x80);
+ break;
+ case 0x04:
+ E_Notify(PSTR(" Named Array"), 0x80);
+ break;
+ case 0x05:
+ E_Notify(PSTR(" Usage Switch"), 0x80);
+ break;
+ case 0x06:
+ E_Notify(PSTR(" Usage Modifier"), 0x80);
+ break;
+ default:
+ E_Notify(PSTR(" Vendor Defined("), 0x80);
+ PrintHex<uint8_t > (data, 0x80);
+ E_Notify(PSTR(")"), 0x80);
+ }
+ break;
+ case (TYPE_MAIN | TAG_MAIN_INPUT):
+ case (TYPE_MAIN | TAG_MAIN_OUTPUT):
+ case (TYPE_MAIN | TAG_MAIN_FEATURE):
+ totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
+ rptSize = 0;
+ rptCount = 0;
+ E_Notify(PSTR("("), 0x80);
+ PrintBin<uint8_t > (data, 0x80);
+ E_Notify(PSTR(")"), 0x80);
+ break;
+ } // switch (**pp & (TYPE_MASK | TAG_MASK))
+ }
+ } // switch (itemParseState)
+ itemParseState = 0;
+ return enErrorSuccess;
+}
+
+ReportDescParserBase::UsagePageFunc ReportDescParserBase::usagePageFunctions[] /*PROGMEM*/ = {
+ &ReportDescParserBase::PrintGenericDesktopPageUsage,
+ &ReportDescParserBase::PrintSimulationControlsPageUsage,
+ &ReportDescParserBase::PrintVRControlsPageUsage,
+ &ReportDescParserBase::PrintSportsControlsPageUsage,
+ &ReportDescParserBase::PrintGameControlsPageUsage,
+ &ReportDescParserBase::PrintGenericDeviceControlsPageUsage,
+ NULL, // Keyboard/Keypad
+ &ReportDescParserBase::PrintLEDPageUsage,
+ &ReportDescParserBase::PrintButtonPageUsage,
+ &ReportDescParserBase::PrintOrdinalPageUsage,
+ &ReportDescParserBase::PrintTelephonyPageUsage,
+ &ReportDescParserBase::PrintConsumerPageUsage,
+ &ReportDescParserBase::PrintDigitizerPageUsage,
+ NULL, // Reserved
+ NULL, // PID
+ NULL // Unicode
+};
+
+void ReportDescParserBase::SetUsagePage(uint16_t page) {
+ pfUsage = NULL;
+
+ if(VALUE_BETWEEN(page, 0x00, 0x11)) {
+ pfUsage = (usagePageFunctions[page - 1]);
+
+ } else {
+ switch(page) {
+ case 0x14:
+ pfUsage = &ReportDescParserBase::PrintAlphanumDisplayPageUsage;
+ break;
+ case 0x40:
+ pfUsage = &ReportDescParserBase::PrintMedicalInstrumentPageUsage;
+ break;
+ }
+ }
+}
+
+void ReportDescParserBase::PrintUsagePage(uint16_t page) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(page, 0x00, 0x11, w, E_Notify, usagePageTitles0, 0x80)
+ else output_if_between(page, 0x8b, 0x92, w, E_Notify, usagePageTitles1, 0x80)
+ else if(VALUE_BETWEEN(page, 0x7f, 0x84))
+ E_Notify(pstrUsagePageMonitor, 0x80);
+ else if(VALUE_BETWEEN(page, 0x83, 0x8c))
+ E_Notify(pstrUsagePagePower, 0x80);
+ else if(page > 0xfeff /* && page <= 0xffff */)
+ E_Notify(pstrUsagePageVendorDefined, 0x80);
+ else
+ switch(page) {
+ case 0x14:
+ E_Notify(pstrUsagePageAlphaNumericDisplay, 0x80);
+ break;
+ case 0x40:
+ E_Notify(pstrUsagePageMedicalInstruments, 0x80);
+ break;
+ default:
+ E_Notify(pstrUsagePageUndefined, 0x80);
+ }
+}
+
+void ReportDescParserBase::PrintButtonPageUsage(uint16_t usage) {
+ E_Notify(pstrSpace, 0x80);
+ E_Notify(PSTR("Btn"), 0x80);
+ PrintHex<uint16_t > (usage, 0x80);
+ E_Notify(PSTR("\r\n"), 0x80);
+ //USB_HOST_SERIAL.print(usage, HEX);
+}
+
+void ReportDescParserBase::PrintOrdinalPageUsage(uint16_t usage) {
+ E_Notify(pstrSpace, 0x80);
+ E_Notify(PSTR("Inst"), 0x80);
+ // Sorry, HEX for now...
+ PrintHex<uint16_t > (usage, 0x80);
+ E_Notify(PSTR("\r\n"), 0x80);
+ //USB_HOST_SERIAL.print(usage, DEC);
+}
+
+void ReportDescParserBase::PrintGenericDesktopPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x0a, w, E_Notify, genDesktopTitles0, 0x80)
+ else output_if_between(usage, 0x2f, 0x49, w, E_Notify, genDesktopTitles1, 0x80)
+ else output_if_between(usage, 0x7f, 0x94, w, E_Notify, genDesktopTitles2, 0x80)
+ else output_if_between(usage, 0x9f, 0xa9, w, E_Notify, genDesktopTitles3, 0x80)
+ else output_if_between(usage, 0xaf, 0xb8, w, E_Notify, genDesktopTitles4, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintSimulationControlsPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x0d, w, E_Notify, simuTitles0, 0x80)
+ else output_if_between(usage, 0x1f, 0x26, w, E_Notify, simuTitles1, 0x80)
+ else output_if_between(usage, 0xaf, 0xd1, w, E_Notify, simuTitles2, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintVRControlsPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x0b, w, E_Notify, vrTitles0, 0x80)
+ else output_if_between(usage, 0x1f, 0x22, w, E_Notify, vrTitles1, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintSportsControlsPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x05, w, E_Notify, sportsCtrlTitles0, 0x80)
+ else output_if_between(usage, 0x2f, 0x3a, w, E_Notify, sportsCtrlTitles1, 0x80)
+ else output_if_between(usage, 0x4f, 0x64, w, E_Notify, sportsCtrlTitles2, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintGameControlsPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x04, w, E_Notify, gameTitles0, 0x80)
+ else output_if_between(usage, 0x1f, 0x3a, w, E_Notify, gameTitles1, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintGenericDeviceControlsPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x1f, 0x27, w, E_Notify, genDevCtrlTitles, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintLEDPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x4e, w, E_Notify, ledTitles, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintTelephonyPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x08, w, E_Notify, telTitles0, 0x80)
+ else output_if_between(usage, 0x1f, 0x32, w, E_Notify, telTitles1, 0x80)
+ else output_if_between(usage, 0x4f, 0x54, w, E_Notify, telTitles2, 0x80)
+ else output_if_between(usage, 0x6f, 0x75, w, E_Notify, telTitles3, 0x80)
+ else output_if_between(usage, 0x8f, 0x9f, w, E_Notify, telTitles4, 0x80)
+ else output_if_between(usage, 0xaf, 0xc0, w, E_Notify, telTitles5, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintConsumerPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x07, w, E_Notify, consTitles0, 0x80)
+ else output_if_between(usage, 0x1f, 0x23, w, E_Notify, consTitles1, 0x80)
+ else output_if_between(usage, 0x2f, 0x37, w, E_Notify, consTitles2, 0x80)
+ else output_if_between(usage, 0x3f, 0x49, w, E_Notify, consTitles3, 0x80)
+ else output_if_between(usage, 0x5f, 0x67, w, E_Notify, consTitles4, 0x80)
+ else output_if_between(usage, 0x7f, 0xa5, w, E_Notify, consTitles5, 0x80)
+ else output_if_between(usage, 0xaf, 0xcf, w, E_Notify, consTitles6, 0x80)
+ else output_if_between(usage, 0xdf, 0xeb, w, E_Notify, consTitles7, 0x80)
+ else output_if_between(usage, 0xef, 0xf6, w, E_Notify, consTitles8, 0x80)
+ else output_if_between(usage, 0xff, 0x10e, w, E_Notify, consTitles9, 0x80)
+ else output_if_between(usage, 0x14f, 0x156, w, E_Notify, consTitlesA, 0x80)
+ else output_if_between(usage, 0x15f, 0x16b, w, E_Notify, consTitlesB, 0x80)
+ else output_if_between(usage, 0x16f, 0x175, w, E_Notify, consTitlesC, 0x80)
+ else output_if_between(usage, 0x17f, 0x1c8, w, E_Notify, consTitlesD, 0x80)
+ else output_if_between(usage, 0x1ff, 0x29d, w, E_Notify, consTitlesE, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintDigitizerPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x0e, w, E_Notify, digitTitles0, 0x80)
+ else output_if_between(usage, 0x1f, 0x23, w, E_Notify, digitTitles1, 0x80)
+ else output_if_between(usage, 0x2f, 0x47, w, E_Notify, digitTitles2, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintAlphanumDisplayPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ output_if_between(usage, 0x00, 0x03, w, E_Notify, aplphanumTitles0, 0x80)
+ else output_if_between(usage, 0x1f, 0x4e, w, E_Notify, aplphanumTitles1, 0x80)
+ else output_if_between(usage, 0x7f, 0x96, w, E_Notify, digitTitles2, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+void ReportDescParserBase::PrintMedicalInstrumentPageUsage(uint16_t usage) {
+ const char * const * w;
+ E_Notify(pstrSpace, 0x80);
+
+ if(usage == 1) E_Notify(pstrUsageMedicalUltrasound, 0x80);
+ else if(usage == 0x70)
+ E_Notify(pstrUsageDepthGainCompensation, 0x80);
+ else output_if_between(usage, 0x1f, 0x28, w, E_Notify, medInstrTitles0, 0x80)
+ else output_if_between(usage, 0x3f, 0x45, w, E_Notify, medInstrTitles1, 0x80)
+ else output_if_between(usage, 0x5f, 0x62, w, E_Notify, medInstrTitles2, 0x80)
+ else output_if_between(usage, 0x7f, 0x8a, w, E_Notify, medInstrTitles3, 0x80)
+ else output_if_between(usage, 0x9f, 0xa2, w, E_Notify, medInstrTitles4, 0x80)
+ else E_Notify(pstrUsagePageUndefined, 0x80);
+}
+
+uint8_t ReportDescParser2::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
+ //uint8_t ret = enErrorSuccess;
+
+ switch(itemParseState) {
+ case 0:
+ if(**pp == HID_LONG_ITEM_PREFIX)
+ USBTRACE("\r\nLONG\r\n");
+ else {
+ uint8_t size = ((**pp) & DATA_SIZE_MASK);
+ itemPrefix = (**pp);
+ itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
+ }
+ (*pp)++;
+ (*pcntdn)--;
+ itemSize--;
+ itemParseState = 1;
+
+ if(!itemSize)
+ break;
+
+ if(!pcntdn)
+ return enErrorIncomplete;
+ case 1:
+ theBuffer.valueSize = itemSize;
+ valParser.Initialize(&theBuffer);
+ itemParseState = 2;
+ case 2:
+ if(!valParser.Parse(pp, pcntdn))
+ return enErrorIncomplete;
+ itemParseState = 3;
+ case 3:
+ {
+ uint8_t data = *((uint8_t*)varBuffer);
+
+ switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
+ case (TYPE_LOCAL | TAG_LOCAL_USAGE):
+ if(pfUsage) {
+ if(theBuffer.valueSize > 1) {
+ uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
+ pfUsage(*ui16);
+ } else
+ pfUsage(data);
+ }
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
+ rptSize = data;
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
+ rptCount = data;
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
+ rptId = data;
+ break;
+ case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
+ useMin = data;
+ break;
+ case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
+ useMax = data;
+ break;
+ case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
+ SetUsagePage(data);
+ break;
+ case (TYPE_MAIN | TAG_MAIN_OUTPUT):
+ case (TYPE_MAIN | TAG_MAIN_FEATURE):
+ rptSize = 0;
+ rptCount = 0;
+ useMin = 0;
+ useMax = 0;
+ break;
+ case (TYPE_MAIN | TAG_MAIN_INPUT):
+ OnInputItem(data);
+
+ totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
+
+ rptSize = 0;
+ rptCount = 0;
+ useMin = 0;
+ useMax = 0;
+ break;
+ } // switch (**pp & (TYPE_MASK | TAG_MASK))
+ }
+ } // switch (itemParseState)
+ itemParseState = 0;
+ return enErrorSuccess;
+}
+
+void ReportDescParser2::OnInputItem(uint8_t itm) {
+ uint8_t byte_offset = (totalSize >> 3); // calculate offset to the next unhandled byte i = (int)(totalCount / 8);
+ uint32_t tmp = (byte_offset << 3);
+ uint8_t bit_offset = totalSize - tmp; // number of bits in the current byte already handled
+ uint8_t *p = pBuf + byte_offset; // current byte pointer
+
+ if(bit_offset)
+ *p >>= bit_offset;
+
+ uint8_t usage = useMin;
+
+ bool print_usemin_usemax = ((useMin < useMax) && ((itm & 3) == 2) && pfUsage) ? true : false;
+
+ uint8_t bits_of_byte = 8;
+
+ // for each field in field array defined by rptCount
+ for(uint8_t field = 0; field < rptCount; field++, usage++) {
+
+ union {
+ uint8_t bResult[4];
+ uint16_t wResult[2];
+ uint32_t dwResult;
+ } result;
+
+ result.dwResult = 0;
+ uint8_t mask = 0;
+
+ if(print_usemin_usemax)
+ pfUsage(usage);
+
+ // bits_left - number of bits in the field(array of fields, depending on Report Count) left to process
+ // bits_of_byte - number of bits in current byte left to process
+ // bits_to_copy - number of bits to copy to result buffer
+
+ // for each bit in a field
+ for(uint8_t bits_left = rptSize, bits_to_copy = 0; bits_left;
+ bits_left -= bits_to_copy) {
+ bits_to_copy = (bits_left > bits_of_byte) ? bits_of_byte : bits_left;
+
+ result.dwResult <<= bits_to_copy; // Result buffer is shifted by the number of bits to be copied into it
+
+ uint8_t val = *p;
+
+ val >>= (8 - bits_of_byte); // Shift by the number of bits already processed
+
+ mask = 0;
+
+ for(uint8_t j = bits_to_copy; j; j--) {
+ mask <<= 1;
+ mask |= 1;
+ }
+
+ result.bResult[0] = (result.bResult[0] | (val & mask));
+
+ bits_of_byte -= bits_to_copy;
+
+ if(bits_of_byte < 1) {
+ bits_of_byte = 8;
+ p++;
+ }
+ }
+ PrintByteValue(result.dwResult);
+ }
+ E_Notify(PSTR("\r\n"), 0x80);
+}
+
+void UniversalReportParser::Parse(HID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf) {
+ ReportDescParser2 prs(len, buf);
+
+ uint8_t ret = hid->GetReportDescr(0, &prs);
+
+ if(ret)
+ ErrorMessage<uint8_t > (PSTR("GetReportDescr-2"), ret);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-28 21:19:13 +0000