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