Sensoreigenschappen instellen en ophalen

In dit onderwerp wordt beschreven hoe u waarden voor sensoreigenschappen ophaalt en instelt. De ISensor interface biedt de methoden voor het instellen en ophalen van waarden voor sensoreigenschappen.

Sensoreigenschappen ophalen

U kunt bepaalde eigenschapswaarden ophalen van een sensor voordat de gebruiker deze heeft ingeschakeld. Informatie zoals de naam van de fabrikant of het model van de sensor kan u helpen om te bepalen of uw programma de sensor kan gebruiken.

U kunt ervoor kiezen om één eigenschapswaarde op te halen of om een verzameling eigenschapswaarden samen op te halen. Als u één waarde wilt ophalen, roept u ISensor::GetPropertyaan. Als u een verzameling waarden wilt ophalen, roept u ISensor::GetPropertiesaan. U kunt alle eigenschappen voor een sensor ophalen door NULL door te geven als de eerste parameter naar ISensor::GetPropertieste.

Met de volgende voorbeeldcode wordt een helperfunctie gemaakt waarmee de waarde van één eigenschap wordt afgedrukt. De functie ontvangt een aanwijzer naar de sensor waaruit de waarde en een eigenschapssleutel worden opgehaald die de eigenschap bevat die moet worden afgedrukt. De functie kan waarden afdrukken voor getallen, tekenreeksen en GUID-s, maar niet voor andere, complexere typen.

HRESULT PrintSensorProperty(ISensor* pSensor, REFPROPERTYKEY pk)
{
    assert(pSensor);

    HRESULT hr = S_OK;

    PROPVARIANT pv = {};

    hr = pSensor->GetProperty(pk, &pv);

    if(SUCCEEDED(hr))
    {
        if(pv.vt == VT_UI4)  // Number
        {
            wprintf_s(L"\nSensor integer value: %u\n", pv.ulVal);
        }
        else if(pv.vt == VT_LPWSTR)  // String
        {
            wprintf_s(L"\nSensor string value: %s\n", pv.pwszVal);
        }
        else if(pv.vt == VT_CLSID)  // GUID
        {
            int iRet = 0;

            // Convert the GUID to a string.
            OLECHAR wszGuid[39] = {}; // Buffer for string.
            iRet = ::StringFromGUID2(*(pv.puuid), wszGuid, 39);

            assert(39 == iRet); // Count of characters returned for GUID.

            wprintf_s(L"\nSensor GUID value: %s\n", wszGuid);
        }
        else  // Interface or vector
        {
            wprintf_s(L"\nSensor property is a compound type. Unable to print value.");
        }
    }

    PropVariantClear(&pv);

    return hr;    
}

Met de volgende voorbeeldcode wordt een functie gemaakt waarmee een verzameling eigenschappen wordt opgehaald en afgedrukt. De set eigenschappen die moeten worden afgedrukt, wordt gedefinieerd door de matrix SensorProperties.

HRESULT PrintSensorProperties(ISensor* pSensor)
{
    assert(pSensor);

    HRESULT hr = S_OK;

    DWORD cVals = 0; // Count of returned properties.
    IPortableDeviceKeyCollection* pKeys = NULL; // Input
    IPortableDeviceValues* pValues = NULL;  // Output

    // Properties to print.
    const PROPERTYKEY SensorProperties[] =
    {
        SENSOR_PROPERTY_MANUFACTURER,
        SENSOR_PROPERTY_SERIAL_NUMBER,
        SENSOR_PROPERTY_DESCRIPTION,
        SENSOR_PROPERTY_FRIENDLY_NAME
    };

    // CoCreate a key collection to store property keys.
    hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection, 
                                NULL, 
                                CLSCTX_INPROC_SERVER,                                 
                                IID_PPV_ARGS(&pKeys));

    if(SUCCEEDED(hr))
    {
        // Add the properties to the key collection.
        for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(SensorProperties); dwIndex++)
        {
            hr = pKeys->Add(SensorProperties[dwIndex]);

            if(FAILED(hr))
            {
                // Unexpected.
                // This example returns the failed HRESULT.
                // You may choose to ignore failures, here.
                break;
            }
        }
    }

    if(SUCCEEDED(hr))
    {
        // Retrieve the properties from the sensor.
        hr = pSensor->GetProperties(pKeys, &pValues);
    }

    if(SUCCEEDED(hr))
    {
        // Get the number of values returned.        
        hr = pValues->GetCount(&cVals);
    }

    if(SUCCEEDED(hr))
    {
        PROPERTYKEY pk; // Keys
        PROPVARIANT pv = {}; // Values

        // Loop through the values;
        for (DWORD i = 0; i < cVals; i++)
        {
            // Get the value at the current index.
            hr = pValues->GetAt(i, &pk, &pv);

            if(SUCCEEDED(hr))
            { 
                // Find and print the property.
                if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_MANUFACTURER))
                {
                    wprintf_s(L"\nManufacturer: %s\n", pv.pwszVal);
                }
                else if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_SERIAL_NUMBER))
                {
                    wprintf_s(L"Serial number: %s\n", pv.pwszVal);
                }
                else if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_FRIENDLY_NAME))
                {
                    wprintf_s(L"Friendly name: %s\n", pv.pwszVal);
                }
                else if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_DESCRIPTION))
                {
                    wprintf_s(L"Description: %s\n", pv.pwszVal);
                }
            }

            PropVariantClear(&pv);
        } // end i loop        
    }

    SafeRelease(&pKeys);
    SafeRelease(&pValues);

    return hr;
};

Sensoreigenschappen instellen

Voordat u eigenschapswaarden voor een sensor kunt instellen, moet de gebruiker de sensor inschakelen. Bovendien kunnen niet alle sensoreigenschappen worden ingesteld.

Als u een of meer waarden voor eigenschappen wilt instellen, roept u ISensor::SetPropertiesaan. U geeft deze methode op met een IPortableDeviceValues aanwijzer die de verzameling eigenschappen bevat die u wilt instellen en de bijbehorende waarden. De methode retourneert een overeenkomende IPortableDeviceValues interface die mogelijk foutcodes bevat voor eigenschappen die niet kunnen worden ingesteld.

Met de volgende voorbeeldcode wordt een helperfunctie gemaakt waarmee een nieuwe waarde voor de eigenschap SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL wordt ingesteld. De functie verwijst naar de sensor waarvoor de eigenschap moet worden ingesteld en een ULONG--waarde die aangeeft dat het nieuwe rapportinterval moet worden ingesteld. (Houd er rekening mee dat het instellen van een waarde voor deze specifieke eigenschap niet garandeert dat de sensor de opgegeven waarde accepteert. Zie sensoreigenschappen voor informatie over de werking van deze eigenschap.)

HRESULT SetCurrentReportInterval(ISensor* pSensor, ULONG ulNewInterval)
{
    assert(pSensor);

    HRESULT hr = S_OK;

    IPortableDeviceValues* pPropsToSet = NULL; // Input
    IPortableDeviceValues* pPropsReturn = NULL; // Output

    // Create the input object.
    hr = CoCreateInstance(__uuidof(PortableDeviceValues),
                            NULL,
                            CLSCTX_INPROC_SERVER,                           
                            IID_PPV_ARGS(&pPropsToSet));

    if(SUCCEEDED(hr))
    {
        // Add the current report interval property.
        hr = pPropsToSet->SetUnsignedIntegerValue(SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, ulNewInterval);
    }

    if(SUCCEEDED(hr))
    {
        // Only setting a single property, here.
        hr = pSensor->SetProperties(pPropsToSet, &pPropsReturn);
    }

    // Test for failure.
    if(hr == S_FALSE)
    {
        HRESULT hrError = S_OK;
      
        // Check results for failure.
        hr = pPropsReturn->GetErrorValue(SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, &hrError);

        if(SUCCEEDED(hr))
        {
            // Print an error message.
            wprintf_s(L"\nSetting current report interval failed with error 0x%X\n", hrError);

            // Return the error code.
            hr = hrError;
        }
    }
    else if(hr == E_ACCESSDENIED)
    {
        // No permission. Take appropriate action.
    }

    SafeRelease(&pPropsToSet);
    SafeRelease(&pPropsReturn);
   
    return hr;
}

Verwante onderwerpen

sensoreigenschappen