qmk-dactyl-manuform-a/lib/usbhost/USB_Host_Shield_2.0/hidescriptorparser.cpp

1589 lines
57 KiB
C++

/* 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);
}