USB_Host_Shield_2.0/hidescriptorparser.cpp

1627 lines
61 KiB
C++
Raw Normal View History

#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) {
2013-06-12 05:11:43 +02:00
//USB_HOST_SERIAL.println("");
//PrintHex<uint16_t>(offset + len - cntdn);
2013-06-12 05:11:43 +02:00
//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;
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)
pfUsage(*((uint16_t*)varBuffer));
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 (page > 0x00 && page < 0x11)
pfUsage = /*(UsagePageFunc)pgm_read_pointer*/(usagePageFunctions[page - 1]);
//else if (page > 0x7f && page < 0x84)
// E_Notify(pstrUsagePageMonitor);
//else if (page > 0x83 && page < 0x8c)
// E_Notify(pstrUsagePagePower);
//else if (page > 0x8b && page < 0x92)
// E_Notify((char*)pgm_read_pointer(&usagePageTitles1[page - 0x8c]));
//else if (page > 0xfeff && page <= 0xffff)
// E_Notify(pstrUsagePageVendorDefined);
else
switch (page) {
case 0x14:
pfUsage = &ReportDescParserBase::PrintAlphanumDisplayPageUsage;
break;
case 0x40:
pfUsage = &ReportDescParserBase::PrintMedicalInstrumentPageUsage;
break;
}
}
void ReportDescParserBase::PrintUsagePage(uint16_t page) {
E_Notify(pstrSpace, 0x80);
if (page > 0x00 && page < 0x11)
E_Notify((char*)pgm_read_pointer(&usagePageTitles0[page - 1]), 0x80);
else if (page > 0x7f && page < 0x84)
E_Notify(pstrUsagePageMonitor, 0x80);
else if (page > 0x83 && page < 0x8c)
E_Notify(pstrUsagePagePower, 0x80);
else if (page > 0x8b && page < 0x92)
E_Notify((char*)pgm_read_pointer(&usagePageTitles1[page - 0x8c]), 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);
2013-06-12 05:11:43 +02:00
//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);
2013-06-12 05:11:43 +02:00
//USB_HOST_SERIAL.print(usage, DEC);
}
void ReportDescParserBase::PrintGenericDesktopPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x0a)
E_Notify((char*)pgm_read_pointer(&genDesktopTitles0[usage - 1]), 0x80);
else if (usage > 0x2f && usage < 0x49)
E_Notify((char*)pgm_read_pointer(&genDesktopTitles1[usage - 0x30]), 0x80);
else if (usage > 0x7f && usage < 0x94)
E_Notify((char*)pgm_read_pointer(&genDesktopTitles2[usage - 0x80]), 0x80);
else if (usage > 0x9f && usage < 0xa9)
E_Notify((char*)pgm_read_pointer(&genDesktopTitles3[usage - 0xa0]), 0x80);
else if (usage > 0xaf && usage < 0xb8)
E_Notify((char*)pgm_read_pointer(&genDesktopTitles4[usage - 0xb0]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintSimulationControlsPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x0d)
E_Notify((char*)pgm_read_pointer(&simuTitles0[usage - 1]), 0x80);
else if (usage > 0x1f && usage < 0x26)
E_Notify((char*)pgm_read_pointer(&simuTitles1[usage - 0x20]), 0x80);
else if (usage > 0xaf && usage < 0xd1)
E_Notify((char*)pgm_read_pointer(&simuTitles2[usage - 0xb0]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintVRControlsPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x0b)
E_Notify((char*)pgm_read_pointer(&vrTitles0[usage - 1]), 0x80);
else if (usage > 0x1f && usage < 0x22)
E_Notify((char*)pgm_read_pointer(&vrTitles1[usage - 0x20]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintSportsControlsPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x05)
E_Notify((char*)pgm_read_pointer(&sportsCtrlTitles0[usage - 1]), 0x80);
else if (usage > 0x2f && usage < 0x3a)
E_Notify((char*)pgm_read_pointer(&sportsCtrlTitles1[usage - 0x30]), 0x80);
else if (usage > 0x4f && usage < 0x64)
E_Notify((char*)pgm_read_pointer(&sportsCtrlTitles2[usage - 0x50]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintGameControlsPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x04)
E_Notify((char*)pgm_read_pointer(&gameTitles0[usage - 1]), 0x80);
else if (usage > 0x1f && usage < 0x3a)
E_Notify((char*)pgm_read_pointer(&gameTitles1[usage - 0x20]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintGenericDeviceControlsPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x1f && usage < 0x27)
E_Notify((char*)pgm_read_pointer(&genDevCtrlTitles[usage - 0x20]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintLEDPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x4e)
E_Notify((char*)pgm_read_pointer(&ledTitles[usage - 1]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintTelephonyPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x08)
E_Notify((char*)pgm_read_pointer(&telTitles0[usage - 1]), 0x80);
else if (usage > 0x1f && usage < 0x32)
E_Notify((char*)pgm_read_pointer(&telTitles1[usage - 0x1f]), 0x80);
else if (usage > 0x4f && usage < 0x54)
E_Notify((char*)pgm_read_pointer(&telTitles2[usage - 0x4f]), 0x80);
else if (usage > 0x6f && usage < 0x75)
E_Notify((char*)pgm_read_pointer(&telTitles3[usage - 0x6f]), 0x80);
else if (usage > 0x8f && usage < 0x9f)
E_Notify((char*)pgm_read_pointer(&telTitles4[usage - 0x8f]), 0x80);
else if (usage > 0xaf && usage < 0xc0)
E_Notify((char*)pgm_read_pointer(&telTitles5[usage - 0xaf]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintConsumerPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x07)
E_Notify((char*)pgm_read_pointer(&consTitles0[usage - 1]), 0x80);
else if (usage > 0x1f && usage < 0x23)
E_Notify((char*)pgm_read_pointer(&consTitles1[usage - 0x1f]), 0x80);
else if (usage > 0x2f && usage < 0x37)
E_Notify((char*)pgm_read_pointer(&consTitles2[usage - 0x2f]), 0x80);
else if (usage > 0x3f && usage < 0x49)
E_Notify((char*)pgm_read_pointer(&consTitles3[usage - 0x3f]), 0x80);
else if (usage > 0x5f && usage < 0x67)
E_Notify((char*)pgm_read_pointer(&consTitles4[usage - 0x5f]), 0x80);
else if (usage > 0x7f && usage < 0xa5)
E_Notify((char*)pgm_read_pointer(&consTitles5[usage - 0x7f]), 0x80);
else if (usage > 0xaf && usage < 0xcf)
E_Notify((char*)pgm_read_pointer(&consTitles6[usage - 0xaf]), 0x80);
else if (usage > 0xdf && usage < 0xeb)
E_Notify((char*)pgm_read_pointer(&consTitles7[usage - 0xdf]), 0x80);
else if (usage > 0xef && usage < 0xf6)
E_Notify((char*)pgm_read_pointer(&consTitles8[usage - 0xef]), 0x80);
else if (usage > 0xff && usage < 0x10e)
E_Notify((char*)pgm_read_pointer(&consTitles9[usage - 0xff]), 0x80);
else if (usage > 0x14f && usage < 0x156)
E_Notify((char*)pgm_read_pointer(&consTitlesA[usage - 0x14f]), 0x80);
else if (usage > 0x15f && usage < 0x16b)
E_Notify((char*)pgm_read_pointer(&consTitlesB[usage - 0x15f]), 0x80);
else if (usage > 0x16f && usage < 0x175)
E_Notify((char*)pgm_read_pointer(&consTitlesC[usage - 0x16f]), 0x80);
else if (usage > 0x17f && usage < 0x1c8)
E_Notify((char*)pgm_read_pointer(&consTitlesD[usage - 0x17f]), 0x80);
else if (usage > 0x1ff && usage < 0x29d)
E_Notify((char*)pgm_read_pointer(&consTitlesE[usage - 0x1ff]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintDigitizerPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x0e)
E_Notify((char*)pgm_read_pointer(&digitTitles0[usage - 1]), 0x80);
else if (usage > 0x1f && usage < 0x23)
E_Notify((char*)pgm_read_pointer(&digitTitles1[usage - 0x1f]), 0x80);
else if (usage > 0x2f && usage < 0x47)
E_Notify((char*)pgm_read_pointer(&digitTitles2[usage - 0x2f]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintAlphanumDisplayPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage > 0x00 && usage < 0x03)
E_Notify((char*)pgm_read_pointer(&aplphanumTitles0[usage - 1]), 0x80);
else if (usage > 0x1f && usage < 0x4e)
E_Notify((char*)pgm_read_pointer(&aplphanumTitles1[usage - 0x1f]), 0x80);
else if (usage > 0x7f && usage < 0x96)
E_Notify((char*)pgm_read_pointer(&digitTitles2[usage - 0x80]), 0x80);
else
E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintMedicalInstrumentPageUsage(uint16_t usage) {
E_Notify(pstrSpace, 0x80);
if (usage == 1)
E_Notify(pstrUsageMedicalUltrasound, 0x80);
else if (usage > 0x1f && usage < 0x28)
E_Notify((char*)pgm_read_pointer(&medInstrTitles0[usage - 0x1f]), 0x80);
else if (usage > 0x3f && usage < 0x45)
E_Notify((char*)pgm_read_pointer(&medInstrTitles1[usage - 0x40]), 0x80);
else if (usage > 0x5f && usage < 0x62)
E_Notify((char*)pgm_read_pointer(&medInstrTitles2[usage - 0x60]), 0x80);
else if (usage == 0x70)
E_Notify(pstrUsageDepthGainCompensation, 0x80);
else if (usage > 0x7f && usage < 0x8a)
E_Notify((char*)pgm_read_pointer(&medInstrTitles3[usage - 0x80]), 0x80);
else if (usage > 0x9f && usage < 0xa2)
E_Notify((char*)pgm_read_pointer(&medInstrTitles4[usage - 0xa0]), 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)
pfUsage(*((uint16_t*)varBuffer));
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);
}