#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(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) { Notify(PSTR("("), 0x80); for (; len; p++, len--) PrintHex (*p, 0x80); Notify(PSTR(")"), 0x80); } void ReportDescParserBase::PrintByteValue(uint8_t data) { Notify(PSTR("("), 0x80); PrintHex (data, 0x80); Notify(PSTR(")"), 0x80); } void ReportDescParserBase::PrintItemTitle(uint8_t prefix) { switch (prefix & (TYPE_MASK | TAG_MASK)) { case (TYPE_GLOBAL | TAG_GLOBAL_PUSH): Notify(PSTR("\r\nPush"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_POP): Notify(PSTR("\r\nPop"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE): Notify(PSTR("\r\nUsage Page"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN): Notify(PSTR("\r\nLogical Min"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX): Notify(PSTR("\r\nLogical Max"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN): Notify(PSTR("\r\nPhysical Min"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX): Notify(PSTR("\r\nPhysical Max"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP): Notify(PSTR("\r\nUnit Exp"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_UNIT): Notify(PSTR("\r\nUnit"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE): Notify(PSTR("\r\nReport Size"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT): Notify(PSTR("\r\nReport Count"), 0x80); break; case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID): Notify(PSTR("\r\nReport Id"), 0x80); break; case (TYPE_LOCAL | TAG_LOCAL_USAGE): Notify(PSTR("\r\nUsage"), 0x80); break; case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN): Notify(PSTR("\r\nUsage Min"), 0x80); break; case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX): Notify(PSTR("\r\nUsage Max"), 0x80); break; case (TYPE_MAIN | TAG_MAIN_COLLECTION): Notify(PSTR("\r\nCollection"), 0x80); break; case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION): Notify(PSTR("\r\nEnd Collection"), 0x80); break; case (TYPE_MAIN | TAG_MAIN_INPUT): Notify(PSTR("\r\nInput"), 0x80); break; case (TYPE_MAIN | TAG_MAIN_OUTPUT): Notify(PSTR("\r\nOutput"), 0x80); break; case (TYPE_MAIN | TAG_MAIN_FEATURE): 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: Notify(PSTR(" Physical"), 0x80); break; case 0x01: Notify(PSTR(" Application"), 0x80); break; case 0x02: Notify(PSTR(" Logical"), 0x80); break; case 0x03: Notify(PSTR(" Report"), 0x80); break; case 0x04: Notify(PSTR(" Named Array"), 0x80); break; case 0x05: Notify(PSTR(" Usage Switch"), 0x80); break; case 0x06: Notify(PSTR(" Usage Modifier"), 0x80); break; default: Notify(PSTR(" Vendor Defined("), 0x80); PrintHex (data, 0x80); 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; Notify(PSTR("("), 0x80); PrintBin (data, 0x80); 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_word*/(usagePageFunctions[page - 1]); //else if (page > 0x7f && page < 0x84) // Notify(pstrUsagePageMonitor); //else if (page > 0x83 && page < 0x8c) // Notify(pstrUsagePagePower); //else if (page > 0x8b && page < 0x92) // Notify((char*)pgm_read_word(&usagePageTitles1[page - 0x8c])); //else if (page > 0xfeff && page <= 0xffff) // Notify(pstrUsagePageVendorDefined); else switch (page) { case 0x14: pfUsage = &ReportDescParserBase::PrintAlphanumDisplayPageUsage; break; case 0x40: pfUsage = &ReportDescParserBase::PrintMedicalInstrumentPageUsage; break; } } void ReportDescParserBase::PrintUsagePage(uint16_t page) { Notify(pstrSpace, 0x80); if (page > 0x00 && page < 0x11) Notify((char*)pgm_read_word(&usagePageTitles0[page - 1]), 0x80); else if (page > 0x7f && page < 0x84) Notify(pstrUsagePageMonitor, 0x80); else if (page > 0x83 && page < 0x8c) Notify(pstrUsagePagePower, 0x80); else if (page > 0x8b && page < 0x92) Notify((char*)pgm_read_word(&usagePageTitles1[page - 0x8c]), 0x80); else if (page > 0xfeff && page <= 0xffff) Notify(pstrUsagePageVendorDefined, 0x80); else switch (page) { case 0x14: Notify(pstrUsagePageAlphaNumericDisplay, 0x80); break; case 0x40: Notify(pstrUsagePageMedicalInstruments, 0x80); break; default: Notify(pstrUsagePageUndefined, 0x80); } } void ReportDescParserBase::PrintButtonPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); Notify(PSTR("Btn"), 0x80); PrintHex (usage, 0x80); Notify(PSTR("\r\n"), 0x80); //USB_HOST_SERIAL.print(usage, HEX); } void ReportDescParserBase::PrintOrdinalPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); Notify(PSTR("Inst"), 0x80); // Sorry, HEX for now... PrintHex (usage, 0x80); Notify(PSTR("\r\n"), 0x80); //USB_HOST_SERIAL.print(usage, DEC); } void ReportDescParserBase::PrintGenericDesktopPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x0a) Notify((char*)pgm_read_word(&genDesktopTitles0[usage - 1]), 0x80); else if (usage > 0x2f && usage < 0x49) Notify((char*)pgm_read_word(&genDesktopTitles1[usage - 0x30]), 0x80); else if (usage > 0x7f && usage < 0x94) Notify((char*)pgm_read_word(&genDesktopTitles2[usage - 0x80]), 0x80); else if (usage > 0x9f && usage < 0xa9) Notify((char*)pgm_read_word(&genDesktopTitles3[usage - 0xa0]), 0x80); else if (usage > 0xaf && usage < 0xb8) Notify((char*)pgm_read_word(&genDesktopTitles4[usage - 0xb0]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintSimulationControlsPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x0d) Notify((char*)pgm_read_word(&simuTitles0[usage - 1]), 0x80); else if (usage > 0x1f && usage < 0x26) Notify((char*)pgm_read_word(&simuTitles1[usage - 0x20]), 0x80); else if (usage > 0xaf && usage < 0xd1) Notify((char*)pgm_read_word(&simuTitles2[usage - 0xb0]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintVRControlsPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x0b) Notify((char*)pgm_read_word(&vrTitles0[usage - 1]), 0x80); else if (usage > 0x1f && usage < 0x22) Notify((char*)pgm_read_word(&vrTitles1[usage - 0x20]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintSportsControlsPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x05) Notify((char*)pgm_read_word(&sportsCtrlTitles0[usage - 1]), 0x80); else if (usage > 0x2f && usage < 0x3a) Notify((char*)pgm_read_word(&sportsCtrlTitles1[usage - 0x30]), 0x80); else if (usage > 0x4f && usage < 0x64) Notify((char*)pgm_read_word(&sportsCtrlTitles2[usage - 0x50]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintGameControlsPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x04) Notify((char*)pgm_read_word(&gameTitles0[usage - 1]), 0x80); else if (usage > 0x1f && usage < 0x3a) Notify((char*)pgm_read_word(&gameTitles1[usage - 0x20]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintGenericDeviceControlsPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x1f && usage < 0x27) Notify((char*)pgm_read_word(&genDevCtrlTitles[usage - 0x20]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintLEDPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x4e) Notify((char*)pgm_read_word(&ledTitles[usage - 1]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintTelephonyPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x08) Notify((char*)pgm_read_word(&telTitles0[usage - 1]), 0x80); else if (usage > 0x1f && usage < 0x32) Notify((char*)pgm_read_word(&telTitles1[usage - 0x1f]), 0x80); else if (usage > 0x4f && usage < 0x54) Notify((char*)pgm_read_word(&telTitles2[usage - 0x4f]), 0x80); else if (usage > 0x6f && usage < 0x75) Notify((char*)pgm_read_word(&telTitles3[usage - 0x6f]), 0x80); else if (usage > 0x8f && usage < 0x9f) Notify((char*)pgm_read_word(&telTitles4[usage - 0x8f]), 0x80); else if (usage > 0xaf && usage < 0xc0) Notify((char*)pgm_read_word(&telTitles5[usage - 0xaf]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintConsumerPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x07) Notify((char*)pgm_read_word(&consTitles0[usage - 1]), 0x80); else if (usage > 0x1f && usage < 0x23) Notify((char*)pgm_read_word(&consTitles1[usage - 0x1f]), 0x80); else if (usage > 0x2f && usage < 0x37) Notify((char*)pgm_read_word(&consTitles2[usage - 0x2f]), 0x80); else if (usage > 0x3f && usage < 0x49) Notify((char*)pgm_read_word(&consTitles3[usage - 0x3f]), 0x80); else if (usage > 0x5f && usage < 0x67) Notify((char*)pgm_read_word(&consTitles4[usage - 0x5f]), 0x80); else if (usage > 0x7f && usage < 0xa5) Notify((char*)pgm_read_word(&consTitles5[usage - 0x7f]), 0x80); else if (usage > 0xaf && usage < 0xcf) Notify((char*)pgm_read_word(&consTitles6[usage - 0xaf]), 0x80); else if (usage > 0xdf && usage < 0xeb) Notify((char*)pgm_read_word(&consTitles7[usage - 0xdf]), 0x80); else if (usage > 0xef && usage < 0xf6) Notify((char*)pgm_read_word(&consTitles8[usage - 0xef]), 0x80); else if (usage > 0xff && usage < 0x10e) Notify((char*)pgm_read_word(&consTitles9[usage - 0xff]), 0x80); else if (usage > 0x14f && usage < 0x156) Notify((char*)pgm_read_word(&consTitlesA[usage - 0x14f]), 0x80); else if (usage > 0x15f && usage < 0x16b) Notify((char*)pgm_read_word(&consTitlesB[usage - 0x15f]), 0x80); else if (usage > 0x16f && usage < 0x175) Notify((char*)pgm_read_word(&consTitlesC[usage - 0x16f]), 0x80); else if (usage > 0x17f && usage < 0x1c8) Notify((char*)pgm_read_word(&consTitlesD[usage - 0x17f]), 0x80); else if (usage > 0x1ff && usage < 0x29d) Notify((char*)pgm_read_word(&consTitlesE[usage - 0x1ff]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintDigitizerPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x0e) Notify((char*)pgm_read_word(&digitTitles0[usage - 1]), 0x80); else if (usage > 0x1f && usage < 0x23) Notify((char*)pgm_read_word(&digitTitles1[usage - 0x1f]), 0x80); else if (usage > 0x2f && usage < 0x47) Notify((char*)pgm_read_word(&digitTitles2[usage - 0x2f]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintAlphanumDisplayPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage > 0x00 && usage < 0x03) Notify((char*)pgm_read_word(&aplphanumTitles0[usage - 1]), 0x80); else if (usage > 0x1f && usage < 0x4e) Notify((char*)pgm_read_word(&aplphanumTitles1[usage - 0x1f]), 0x80); else if (usage > 0x7f && usage < 0x96) Notify((char*)pgm_read_word(&digitTitles2[usage - 0x80]), 0x80); else Notify(pstrUsagePageUndefined, 0x80); } void ReportDescParserBase::PrintMedicalInstrumentPageUsage(uint16_t usage) { Notify(pstrSpace, 0x80); if (usage == 1) Notify(pstrUsageMedicalUltrasound, 0x80); else if (usage > 0x1f && usage < 0x28) Notify((char*)pgm_read_word(&medInstrTitles0[usage - 0x1f]), 0x80); else if (usage > 0x3f && usage < 0x45) Notify((char*)pgm_read_word(&medInstrTitles1[usage - 0x40]), 0x80); else if (usage > 0x5f && usage < 0x62) Notify((char*)pgm_read_word(&medInstrTitles2[usage - 0x60]), 0x80); else if (usage == 0x70) Notify(pstrUsageDepthGainCompensation, 0x80); else if (usage > 0x7f && usage < 0x8a) Notify((char*)pgm_read_word(&medInstrTitles3[usage - 0x80]), 0x80); else if (usage > 0x9f && usage < 0xa2) Notify((char*)pgm_read_word(&medInstrTitles4[usage - 0xa0]), 0x80); else 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); } 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 (PSTR("GetReportDescr-2"), ret); }