示例#1
0
        static void Main(string[] args)
        {
            AmbientLightSensor.ApplyPreset(AmbientLightSensor.Preset100ms);

            var last = 0;

            while (true)
            {
                var raw = (int)AmbientLightSensor.LuminanceRaw;
                var lux = (int)AmbientLightSensor.Lux;
                var p   = 10 + (raw * 100 / LUX_MAX);

                if (p < 30)
                {
                    p += 10;
                }
                else
                {
                    p += 20;
                }

                var brightness = Math.Min(p * 10, 1000);

                if (last != brightness)
                {
                    last = brightness;
                    Display.Brightness = brightness;
                    //Fade(brightness);
                }
                Thread.Sleep(1000);
                Console.WriteLine($"Lux: {lux}, Raw: {raw} Brightness: {Display.Brightness} P: {p}");
            }
        }
示例#2
0
        /// <summary>
        /// Adds an individual sensor as a sensor source for ambient light. This
        /// sensor is assumed to be an ambient light sensor.
        /// </summary>
        /// <param name="sensor"></param>
        private void AddSensor(AmbientLightSensor sensor)
        {
            if (sensor != null)
            {
                System.Diagnostics.Debug.WriteLine("AddSensor: " + sensor.FriendlyName);
                sensor.DataUpdated += new SensorDataUpdatedEventHandler(OnDataUpdated);
                sensor.SensorLeave += new SensorLeaveEventHandler(OnLeave);
                Sensors.Add(sensor);

                if (Sensors.Contains(sensor))
                {
                    // get the current sensor state
                    switch (sensor.State)
                    {
                    case SensorState.Ready:
                        RequestSensorDataReport(sensor);
                        break;

                    case SensorState.AccessDenied:
                        RequestSensorAccess(sensor);
                        break;

                    default:
                        // sensor device state is currently not actionable.
                        break;
                    }
                }
            }
        }
示例#3
0
        public override string ToString()
        {
            var optionValues = new List <string>
            {
                Geolocation.ToString(),
                Midi.ToString(),
                Notifications.ToString(),
                Push.ToString(),
                SyncXhr.ToString(),
                Microphone.ToString(),
                Camera.ToString(),
                Magnetometer.ToString(),
                Gyroscope.ToString(),
                Speaker.ToString(),
                Vibrate.ToString(),
                Fullscreen.ToString(),
                Payment.ToString(),
                Accelerometer.ToString(),
                AmbientLightSensor.ToString(),
                Autoplay.ToString(),
                EncryptedMedia.ToString(),
                PictureInPicture.ToString(),
                Usb.ToString(),
                Vr.ToString()
            };

            optionValues.AddRange(Other.Select(o =>
            {
                o.Value.FeatureName = o.Key;
                return(o.Value.ToString());
            }));

            return(string.Join("; ", optionValues.Where(s => s.Length > 0)));
        }
示例#4
0
 public WpfAmbientLight(AmbientLightSensor sensor)
     : base(sensor)
 {
     this._ambientLightSensor = (AmbientLightSensor)sensor;
     if (_ambientLightSensor == null)
     {
         throw new ArgumentException("sensor must be an AmbienLightSensor type");
     }
 }
示例#5
0
        /// <summary>
        /// Fired when a sensor is attached.
        /// </summary>
        void OnSensorEnter(Sensor sensor, SensorState state)
        {
            AmbientLightSensor als = sensor as AmbientLightSensor;

            // check that the sensor is an ambient light sensor
            if (als != null)
            {
                AddSensor(als);
            }
        }
示例#6
0
        /// <summary>
        /// Constructs a new GameMarbleBounce
        /// </summary>
        public GameMarbleBounce()
        {
            AmbientLightSensor[] lightSensors = SensorManager.GetSensorsByType <AmbientLightSensor>();
            if (lightSensors.Length > 0)
            {
                _lightSensor = lightSensors[0];
                _lightSensor.ReportInterval = _lightSensor.MinReportInterval;
            }

            _graphics             = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";

            _graphics.PreferredBackBufferWidth  = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width;
            _graphics.PreferredBackBufferHeight = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height;
            _graphics.IsFullScreen = true;
        }
示例#7
0
        void DataReportChanged(Sensor sender, EventArgs e)
        {
            AmbientLightSensor als = sender as AmbientLightSensor;

            // The data report update comes in on a non-UI thread.
            // Whip up an anonymous delegate to handle the UI update.
            BeginInvoke(new MethodInvoker(delegate
            {
                // find the progress bar for this sensor
                ProgressBar pb = sensorMap[sender.SensorId.Value];

                // report data (clamp value to progress bar maximum )
                float current = als.CurrentLuminousIntensity.Intensity;
                pb.Value      = Math.Min((int)current, maxIntensity);
            }));
        }
示例#8
0
        /// <summary>
        /// Query the sensor for any sensor data it has, then update the sensor
        /// data by using the OnDataUpdated callback.
        /// </summary>
        private void RequestSensorDataReport(AmbientLightSensor sensor)
        {
            if (sensor != null)
            {
                // If the sensor is ready, we can query for the current sensor value
                AmbientLightSensorDataReport data = null;
                try
                {
                    data = (AmbientLightSensorDataReport)sensor.GetDataReport();
                }
                catch (COMException ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex.Message);
                }

                if (data != null)
                {
                    // Initialize the sensor data value using the callback
                    OnDataUpdated(sensor, data);
                }
            }
        }
        //
        // Sensor event handlers
        //
        private void EnsureSensorsCreated()
        {
            IBandSensorManager sensorMgr = Model.Instance.Client.SensorManager;

            if (accelerometerSensor == null)
            {
                accelerometerSensor = sensorMgr.CreateAccelerometerSensor();
                accelerometerSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var accelerometerEvent = e.SensorReading;
                        mTextAccX.Text         = string.Format("{0:F3} m/s/s", accelerometerEvent.AccelerationX);
                        mTextAccY.Text         = string.Format("{0:F3} m/s/s", accelerometerEvent.AccelerationY);
                        mTextAccZ.Text         = string.Format("{0:F3} m/s/s", accelerometerEvent.AccelerationZ);
                    });
                };
            }

            if (contactSensor == null)
            {
                contactSensor = sensorMgr.CreateContactSensor();
                contactSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var contactEvent  = e.SensorReading;
                        mTextContact.Text = contactEvent.ContactState.ToString();
                    });
                };
            }

            if (distanceSensor == null)
            {
                distanceSensor = sensorMgr.CreateDistanceSensor();
                distanceSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var distanceEvent       = e.SensorReading;
                        mTextTotalDistance.Text = string.Format("{0:D} cm", distanceEvent.TotalDistance);
                        mTextSpeed.Text         = string.Format("{0:F2} cm/s", distanceEvent.Speed);
                        mTextPace.Text          = string.Format("{0:F2} ms/m", distanceEvent.Pace);
                        mTextPedometerMode.Text = distanceEvent.MotionType.ToString();
                    });
                };
            }

            if (gyroscopeSensor == null)
            {
                gyroscopeSensor = sensorMgr.CreateGyroscopeSensor();
                gyroscopeSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var gyroscopeEvent = e.SensorReading;
                        mTextGyroAccX.Text = string.Format("{0:F3} m/s/s", gyroscopeEvent.AccelerationX);
                        mTextGyroAccY.Text = string.Format("{0:F3} m/s/s", gyroscopeEvent.AccelerationY);
                        mTextGyroAccZ.Text = string.Format("{0:F3} m/s/s", gyroscopeEvent.AccelerationZ);
                        mTextGyroAngX.Text = string.Format("{0:F2} deg/s", gyroscopeEvent.AngularVelocityX);
                        mTextGyroAngY.Text = string.Format("{0:F2} deg/s", gyroscopeEvent.AngularVelocityY);
                        mTextGyroAngZ.Text = string.Format("{0:F2} deg/s", gyroscopeEvent.AngularVelocityZ);
                    });
                };
            }

            if (heartRateSensor == null)
            {
                heartRateSensor = sensorMgr.CreateHeartRateSensor();
                heartRateSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var heartRateEvent         = e.SensorReading;
                        mTextHeartRate.Text        = string.Format("{0:D} beats/min", heartRateEvent.HeartRate);
                        mTextHeartRateQuality.Text = heartRateEvent.Quality.ToString();
                    });
                };
            }

            if (pedometerSensor == null)
            {
                pedometerSensor = sensorMgr.CreatePedometerSensor();
                pedometerSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var pedometerEvent   = e.SensorReading;
                        mTextTotalSteps.Text = string.Format("{0:D} steps", pedometerEvent.TotalSteps);
                    });
                };
            }

            if (skinTemperatureSensor == null)
            {
                skinTemperatureSensor = sensorMgr.CreateSkinTemperatureSensor();
                skinTemperatureSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var skinTemperatureEvent  = e.SensorReading;
                        mTextSkinTemperature.Text = string.Format("{0:F1} (C)", skinTemperatureEvent.Temperature);
                    });
                };
            }

            if (uvSensor == null)
            {
                uvSensor = sensorMgr.CreateUVSensor();
                uvSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var uvEvent           = e.SensorReading;
                        mTextUltraviolet.Text = uvEvent.UVIndexLevel.ToString();
                    });
                };
            }

            if (altimeterSensor == null)
            {
                altimeterSensor = sensorMgr.CreateAltimeterSensor();
                altimeterSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var altimeterEvent         = e.SensorReading;
                        mTextFlightsAscended.Text  = string.Format("{0:D} floors", altimeterEvent.FlightsAscended);
                        mTextFlightsDescended.Text = string.Format("{0:D} floors", altimeterEvent.FlightsDescended);
                        mTextRate.Text             = string.Format("{0:F2} cm/s", altimeterEvent.Rate);
                        mTextSteppingGain.Text     = string.Format("{0:D} cm", altimeterEvent.SteppingGain);
                        mTextSteppingLoss.Text     = string.Format("{0:D} cm", altimeterEvent.SteppingLoss);
                        mTextStepsAscended.Text    = string.Format("{0:D} steps", altimeterEvent.StepsAscended);
                        mTextStepsDescended.Text   = string.Format("{0:D} steps", altimeterEvent.StepsDescended);
                        mTextTotalGain.Text        = string.Format("{0:D} cm", altimeterEvent.TotalGain);
                        mTextTotalLoss.Text        = string.Format("{0:D} cm", altimeterEvent.TotalLoss);
                    });
                };
            }

            if (ambientLightSensor == null)
            {
                ambientLightSensor = sensorMgr.CreateAmbientLightSensor();
                ambientLightSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var ambientLightEvent = e.SensorReading;
                        mTextBrightness.Text  = string.Format("{0:D} lux", ambientLightEvent.Brightness);
                    });
                };
            }

            if (barometerSensor == null)
            {
                barometerSensor = sensorMgr.CreateBarometerSensor();
                barometerSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var barometerEvent    = e.SensorReading;
                        mTextAirPressure.Text = string.Format("{0:D} hPa", barometerEvent.AirPressure);
                        mTextTemperature.Text = string.Format("{0:D} (C)", barometerEvent.Temperature);
                    });
                };
            }

            if (caloriesSensor == null)
            {
                caloriesSensor = sensorMgr.CreateCaloriesSensor();
                caloriesSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var caloriesEvent  = e.SensorReading;
                        mTextCalories.Text = string.Format("{0:D} kcals", caloriesEvent.Calories);
                    });
                };
            }

            if (gsrSensor == null)
            {
                gsrSensor = sensorMgr.CreateGsrSensor();
                gsrSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var gsrEvent         = e.SensorReading;
                        mTextResistance.Text = string.Format("{0:D} kohms", gsrEvent.Resistance);
                    });
                };
            }

            if (rrIntervalSensor == null)
            {
                rrIntervalSensor = sensorMgr.CreateRRIntervalSensor();
                rrIntervalSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var rrIntervalEvent = e.SensorReading;
                        mTextInterval.Text  = string.Format("{0:2F} s", rrIntervalEvent.Interval);
                    });
                };
            }
        }
        //
        // Sensor event handlers
        //
        private void EnsureSensorsCreated()
        {
            IBandSensorManager sensorMgr = Model.Instance.Client.SensorManager;

            if (accelerometerSensor == null)
            {
                accelerometerSensor = sensorMgr.CreateAccelerometerSensor();
                accelerometerSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var accelerometerEvent = e.SensorReading;
                        mTextAccX.Text = string.Format("{0:F3} m/s/s", accelerometerEvent.AccelerationX);
                        mTextAccY.Text = string.Format("{0:F3} m/s/s", accelerometerEvent.AccelerationY);
                        mTextAccZ.Text = string.Format("{0:F3} m/s/s", accelerometerEvent.AccelerationZ);
                    });
                };
            }

            if (contactSensor == null)
            {
                contactSensor = sensorMgr.CreateContactSensor();
                contactSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var contactEvent = e.SensorReading;
                        mTextContact.Text = contactEvent.ContactState.ToString();
                    });
                };
            }

            if (distanceSensor == null)
            {
                distanceSensor = sensorMgr.CreateDistanceSensor();
                distanceSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var distanceEvent = e.SensorReading;
                        mTextTotalDistance.Text = string.Format("{0:D} cm", distanceEvent.TotalDistance);
                        mTextSpeed.Text = string.Format("{0:F2} cm/s", distanceEvent.Speed);
                        mTextPace.Text = string.Format("{0:F2} ms/m", distanceEvent.Pace);
                        mTextPedometerMode.Text = distanceEvent.MotionType.ToString();
                    });
                };
            }

            if (gyroscopeSensor == null)
            {
                gyroscopeSensor = sensorMgr.CreateGyroscopeSensor();
                gyroscopeSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var gyroscopeEvent = e.SensorReading;
                        mTextGyroAccX.Text = string.Format("{0:F3} m/s/s", gyroscopeEvent.AccelerationX);
                        mTextGyroAccY.Text = string.Format("{0:F3} m/s/s", gyroscopeEvent.AccelerationY);
                        mTextGyroAccZ.Text = string.Format("{0:F3} m/s/s", gyroscopeEvent.AccelerationZ);
                        mTextGyroAngX.Text = string.Format("{0:F2} deg/s", gyroscopeEvent.AngularVelocityX);
                        mTextGyroAngY.Text = string.Format("{0:F2} deg/s", gyroscopeEvent.AngularVelocityY);
                        mTextGyroAngZ.Text = string.Format("{0:F2} deg/s", gyroscopeEvent.AngularVelocityZ);
                    });
                };
            }

            if (heartRateSensor == null)
            {
                heartRateSensor = sensorMgr.CreateHeartRateSensor();
                heartRateSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var heartRateEvent = e.SensorReading;
                        mTextHeartRate.Text = string.Format("{0:D} beats/min", heartRateEvent.HeartRate);
                        mTextHeartRateQuality.Text = heartRateEvent.Quality.ToString();
                    });
                };
            }

            if (pedometerSensor == null)
            {
                pedometerSensor = sensorMgr.CreatePedometerSensor();
                pedometerSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var pedometerEvent = e.SensorReading;
                        mTextTotalSteps.Text = string.Format("{0:D} steps", pedometerEvent.TotalSteps);
                    });
                };
            }

            if (skinTemperatureSensor == null)
            {
                skinTemperatureSensor = sensorMgr.CreateSkinTemperatureSensor();
                skinTemperatureSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var skinTemperatureEvent = e.SensorReading;
                        mTextSkinTemperature.Text = string.Format("{0:F1} (C)", skinTemperatureEvent.Temperature);
                    });
                };
            }

            if (uvSensor == null)
            {
                uvSensor = sensorMgr.CreateUVSensor();
                uvSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var uvEvent = e.SensorReading;
                        mTextUltraviolet.Text = uvEvent.UVIndexLevel.ToString();
                    });
                };
            }
            
            if (altimeterSensor == null)
            {
                altimeterSensor = sensorMgr.CreateAltimeterSensor();
                altimeterSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var altimeterEvent = e.SensorReading;
                        mTextFlightsAscended.Text = string.Format("{0:D} floors", altimeterEvent.FlightsAscended);
                        mTextFlightsDescended.Text = string.Format("{0:D} floors", altimeterEvent.FlightsDescended);
                        mTextRate.Text = string.Format("{0:F2} cm/s", altimeterEvent.Rate);
                        mTextSteppingGain.Text = string.Format("{0:D} cm", altimeterEvent.SteppingGain);
                        mTextSteppingLoss.Text = string.Format("{0:D} cm", altimeterEvent.SteppingLoss);
                        mTextStepsAscended.Text = string.Format("{0:D} steps", altimeterEvent.StepsAscended);
                        mTextStepsDescended.Text = string.Format("{0:D} steps", altimeterEvent.StepsDescended);
                        mTextTotalGain.Text = string.Format("{0:D} cm", altimeterEvent.TotalGain);
                        mTextTotalLoss.Text = string.Format("{0:D} cm", altimeterEvent.TotalLoss);
                    });
                };
            }

            if (ambientLightSensor == null)
            {
                ambientLightSensor = sensorMgr.CreateAmbientLightSensor();
                ambientLightSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var ambientLightEvent = e.SensorReading;
                        mTextBrightness.Text = string.Format("{0:D} lux", ambientLightEvent.Brightness);
                    });
                };
            }
            
            if (barometerSensor == null)
            {
                barometerSensor = sensorMgr.CreateBarometerSensor();
                barometerSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var barometerEvent = e.SensorReading;
                        mTextAirPressure.Text = string.Format("{0:D} hPa", barometerEvent.AirPressure);
                        mTextTemperature.Text = string.Format("{0:D} (C)", barometerEvent.Temperature);
                    });
                };
            }
            
            if (caloriesSensor == null)
            {
                caloriesSensor = sensorMgr.CreateCaloriesSensor();
                caloriesSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var caloriesEvent = e.SensorReading;
                        mTextCalories.Text = string.Format("{0:D} kcals", caloriesEvent.Calories);
                    });
                };
            }
            
            if (gsrSensor == null)
            {
                gsrSensor = sensorMgr.CreateGsrSensor();
                gsrSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var gsrEvent = e.SensorReading;
                        mTextResistance.Text = string.Format("{0:D} kohms", gsrEvent.Resistance);
                    });
                };
            }
            
            if (rrIntervalSensor == null)
            {
                rrIntervalSensor = sensorMgr.CreateRRIntervalSensor();
                rrIntervalSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var rrIntervalEvent = e.SensorReading;
                        mTextInterval.Text = string.Format("{0:2F} s", rrIntervalEvent.Interval);
                    });
                };
            }
        }