示例#1
0
        protected override async Task InitDevices()
        {
            _frontDoor =
                await _hub.GetDeviceByMappedName <ContactSensor>("Contact.FrontDoor");

            _frontDoorLock =
                await _hub.GetDeviceByMappedName <LockDevice>("Lock.FrontDoorDeadbolt");

            _notificationDevices =
                new List <Speaker>()
            {
                await _hub.GetDeviceByMappedName <Speaker>("Speaker.WebhookNotifier"),
                await _hub.GetDeviceByMappedName <Speaker>("Speaker.KitchenSpeaker")
            };
        }
        protected async override Task InitDevices()
        {
            _gates = new List <ContactSensor>()
            {
                await _hub.GetDeviceByMappedName <ContactSensor>("Contact.EastGate"),
                await _hub.GetDeviceByMappedName <ContactSensor>("Contact.WestGate"),
                await _hub.GetDeviceByMappedName <ContactSensor>("Contact.SouthGate")
            };

            _slidingDoor = await _hub.GetDeviceByMappedName <ContactSensor>("Contact.SlidingDoor");

            _notificationDevices = new List <Speaker>()
            {
                await _hub.GetDeviceByMappedName <Speaker>("Speaker.WebhookNotifier"),
                await _hub.GetDeviceByMappedName <Speaker>("Speaker.KitchenSpeaker")
            };
        }
        //
        // 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}", accelerometerEvent.AccelerationX);
                        mTextAccY.Text = string.Format("{0:F3}", accelerometerEvent.AccelerationY);
                        mTextAccZ.Text = string.Format("{0:F3}", 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}", gyroscopeEvent.AccelerationX);
                        mTextGyroAccY.Text = string.Format("{0:F3}", gyroscopeEvent.AccelerationY);
                        mTextGyroAccZ.Text = string.Format("{0:F3}", gyroscopeEvent.AccelerationZ);
                        mTextGyroAngX.Text = string.Format("{0:F2}", gyroscopeEvent.AngularVelocityX);
                        mTextGyroAngY.Text = string.Format("{0:F2}", gyroscopeEvent.AngularVelocityY);
                        mTextGyroAngZ.Text = string.Format("{0:F2}", gyroscopeEvent.AngularVelocityZ);
                    });
                };
            }

            if (heartRateSensor == null)
            {
                heartRateSensor = sensorMgr.CreateHeartRateSensor();
                heartRateSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var heartRateEvent = e.SensorReading;
                        mTextHeartRate.Text = Convert.ToString(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}", pedometerEvent.TotalSteps);
                    });
                };
            }

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

            if (uvSensor == null)
            {
                uvSensor = sensorMgr.CreateUVSensor();
                uvSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var uvEvent = e.SensorReading;
                        mTextUltraviolet.Text = uvEvent.UVIndexLevel.ToString();
                    });
                };
            }
        }
        //
        // 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);
                    });
                };
            }
        }
        public void ContactSensor_FromDynamic_ShouldReturnExpectedResult(InstalledAppInstance installedApp)
        {
            var expectedResult = new ContactSensor()
            {
                Id           = Guid.NewGuid().ToString(),
                Label        = "MyDevice",
                CurrentState = ContactState.Closed
            };

            var deviceJson = $@"{{
                ""deviceId"": ""{expectedResult.Id}"",
                ""name"": ""NAME"",
                ""label"": ""{expectedResult.Label}"",
                ""locationId"": ""{installedApp.InstalledLocation.Id}""
            }}";

            var statusJson = $@"{{
                ""deviceId"": ""{expectedResult.Id}"",
                ""name"": ""NAME"",
                ""label"": ""{expectedResult.Label}"",
                ""locationId"": ""{installedApp.InstalledLocation.Id}"",
                ""components"" : {{
                    ""main"": {{
                        ""contactSensor"": {{
                            ""contact"": {{
                                ""value"": ""closed""
                            }}
                        }}
                    }}
                }}
            }}";

            dynamic device = JObject.Parse(deviceJson);
            dynamic status = JObject.Parse(statusJson);

            var result = ContactSensor.ContactSensorFromDynamic(device,
                                                                status);

            Assert.Equal(expectedResult, result);

            expectedResult.CurrentState = ContactState.Open;
            statusJson = $@"{{
                ""deviceId"": ""{expectedResult.Id}"",
                ""name"": ""NAME"",
                ""label"": ""{expectedResult.Label}"",
                ""locationId"": ""{installedApp.InstalledLocation.Id}"",
                ""components"" : {{
                    ""main"": {{
                        ""contactSensor"": {{
                            ""contact"": {{
                                ""value"": ""open""
                            }}
                        }}
                    }}
                }}
            }}";

            status = JObject.Parse(statusJson);

            result = ContactSensor.ContactSensorFromDynamic(device,
                                                            status);

            Assert.Equal(expectedResult, result);

            expectedResult.CurrentState = ContactState.Unknown;
            statusJson = $@"{{
                ""deviceId"": ""{expectedResult.Id}"",
                ""name"": ""NAME"",
                ""label"": ""{expectedResult.Label}"",
                ""locationId"": ""{installedApp.InstalledLocation.Id}"",
                ""components"" : {{
                    ""main"": {{
                        ""contactSensor"": {{
                            ""contact"": {{
                                ""value"": ""unknown""
                            }}
                        }}
                    }}
                }}
            }}";

            status = JObject.Parse(statusJson);

            result = ContactSensor.ContactSensorFromDynamic(device,
                                                            status);

            Assert.Equal(expectedResult, result);

            _ = expectedResult.GetHashCode();
            _ = expectedResult.ToJson();
        }
示例#6
0
    public void InitializeModules(AgentGenome genome, Agent agent)
    {
        atmosphereSensorList = new List <AtmosphereSensor>();
        basicJointList       = new List <BasicJoint>();
        basicWheelList       = new List <BasicWheel>();
        contactSensorList    = new List <ContactSensor>();
        gravitySensorList    = new List <GravitySensor>();
        healthModuleList     = new List <HealthModule>();
        oscillatorList       = new List <InputOscillator>();
        raycastSensorList    = new List <RaycastSensor>();
        shieldList           = new List <Shield>();
        targetSensorList     = new List <TargetSensor>();
        thrusterEffectorList = new List <ThrusterEffector>();
        torqueEffectorList   = new List <TorqueEffector>();
        trajectorySensorList = new List <TrajectorySensor>();
        valueList            = new List <InputValue>();
        weaponProjectileList = new List <WeaponProjectile>();
        weaponTazerList      = new List <WeaponTazer>();

        for (int i = 0; i < genome.bodyGenome.atmosphereSensorList.Count; i++)
        {
            AtmosphereSensor atmosphereSensor = new AtmosphereSensor();
            atmosphereSensor.Initialize(genome.bodyGenome.atmosphereSensorList[i], agent);
            atmosphereSensorList.Add(atmosphereSensor);
        }
        for (int i = 0; i < genome.bodyGenome.basicJointList.Count; i++)
        {
            BasicJoint basicJoint = new BasicJoint();
            basicJoint.Initialize(genome.bodyGenome.basicJointList[i], agent);
            basicJointList.Add(basicJoint);
            //basicJointList[i].Initialize(genome.basicJointList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.basicWheelList.Count; i++)
        {
            BasicWheel basicWheel = new BasicWheel();
            basicWheel.Initialize(genome.bodyGenome.basicWheelList[i], agent);
            basicWheelList.Add(basicWheel);
            //OLD:
            //basicWheelList[i].Initialize(genome.basicWheelList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.contactSensorList.Count; i++)
        {
            ContactSensor contactSensor = new ContactSensor();
            //agent.segmentList[genome.contactSensorList[i].parentID].AddComponent<ContactSensorComponent>();
            contactSensor.Initialize(genome.bodyGenome.contactSensorList[i], agent);
            contactSensorList.Add(contactSensor);

            //contactSensorList[i].Initialize(genome.contactSensorList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.gravitySensorList.Count; i++)
        {
            GravitySensor gravitySensor = new GravitySensor();
            gravitySensor.Initialize(genome.bodyGenome.gravitySensorList[i], agent);
            gravitySensorList.Add(gravitySensor);
        }
        for (int i = 0; i < genome.bodyGenome.healthModuleList.Count; i++)
        {
            HealthModule healthModule = new HealthModule();
            //agent.segmentList[genome.healthModuleList[i].parentID].AddComponent<HealthModuleComponent>();
            healthModule.Initialize(genome.bodyGenome.healthModuleList[i], agent);
            healthModuleList.Add(healthModule);
            //healthModuleList[i].Initialize(genome.healthModuleList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.oscillatorInputList.Count; i++)
        {
            InputOscillator inputOscillator = new InputOscillator();
            inputOscillator.Initialize(genome.bodyGenome.oscillatorInputList[i], agent);
            oscillatorList.Add(inputOscillator);
            //oscillatorList[i].Initialize(genome.oscillatorInputList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.raycastSensorList.Count; i++)
        {
            RaycastSensor raycastSensor = new RaycastSensor();
            raycastSensor.Initialize(genome.bodyGenome.raycastSensorList[i], agent);
            raycastSensorList.Add(raycastSensor);
            //raycastSensorList[i].Initialize(genome.raycastSensorList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.shieldList.Count; i++)
        {
            Shield shield = new Shield();
            shield.Initialize(genome.bodyGenome.shieldList[i], agent);
            shieldList.Add(shield);
        }
        for (int i = 0; i < genome.bodyGenome.targetSensorList.Count; i++)
        {
            TargetSensor targetSensor = new TargetSensor();
            targetSensor.Initialize(genome.bodyGenome.targetSensorList[i], agent);
            targetSensorList.Add(targetSensor);
            //targetSensorList[i].Initialize(genome.targetSensorList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.thrusterList.Count; i++)
        {
            // Create Functional GameObjects & Components:
            // none in this case

            // Create Logic Module:
            ThrusterEffector thrusterEffector = new ThrusterEffector();
            // Initialize and HookUp Logic Module:
            thrusterEffector.Initialize(genome.bodyGenome.thrusterList[i], agent);
            // If Visible, Create Renderable GameObjects & Components:
            if (isVisible)
            {
                // Find appropriate Prefab based on Agent & Module Genome:
                GameObject thrusterGO = Instantiate(Resources.Load("Prefabs/Modules/Thrusters/thrusterTest")) as GameObject;
                thrusterGO.transform.parent        = agent.segmentList[genome.bodyGenome.thrusterList[i].parentID].transform;
                thrusterGO.transform.localPosition = genome.bodyGenome.thrusterList[i].forcePoint;
                thrusterGO.transform.localRotation = Quaternion.identity;
                // Hook into Logic Module
                thrusterEffector.thrusterComponent = thrusterGO.GetComponent <ThrusterComponent>();
            }
            // Add Logic Module to Agent's Master List
            thrusterEffectorList.Add(thrusterEffector);
        }
        for (int i = 0; i < genome.bodyGenome.torqueList.Count; i++)
        {
            TorqueEffector torqueEffector = new TorqueEffector();
            torqueEffector.Initialize(genome.bodyGenome.torqueList[i], agent);
            torqueEffectorList.Add(torqueEffector);
            //torqueEffectorList[i].Initialize(genome.torqueList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.trajectorySensorList.Count; i++)
        {
            TrajectorySensor trajectorySensor = new TrajectorySensor();
            trajectorySensor.Initialize(genome.bodyGenome.trajectorySensorList[i], agent);
            trajectorySensorList.Add(trajectorySensor);
        }
        for (int i = 0; i < genome.bodyGenome.valueInputList.Count; i++)
        {
            InputValue inputValue = new InputValue();
            inputValue.Initialize(genome.bodyGenome.valueInputList[i], agent);
            valueList.Add(inputValue);
            //valueList[i].Initialize(genome.valueInputList[i]);
        }
        for (int i = 0; i < genome.bodyGenome.weaponProjectileList.Count; i++)
        {
            WeaponProjectile weaponProjectile = new WeaponProjectile();
            weaponProjectile.Initialize(genome.bodyGenome.weaponProjectileList[i], agent);

            if (isVisible)
            {
                // Find appropriate Prefab based on Agent & Module Genome:
                GameObject weaponGO = Instantiate(Resources.Load("Prefabs/Modules/WeaponProjectiles/projectileTest")) as GameObject;
                weaponGO.transform.parent        = agent.segmentList[genome.bodyGenome.weaponProjectileList[i].parentID].transform;
                weaponGO.transform.localPosition = genome.bodyGenome.weaponProjectileList[i].muzzleLocation;
                weaponGO.transform.localRotation = Quaternion.identity;
                // Hook into Logic Module
                weaponProjectile.weaponProjectileComponent = weaponGO.GetComponent <WeaponProjectileComponent>();
            }

            weaponProjectileList.Add(weaponProjectile);

            /*weaponProjectileList[i].Initialize(genome.weaponProjectileList[i]);
             *
             * if (isVisible) {
             *  GameObject particleGO = Instantiate(Resources.Load(weaponProjectileList[i].GetParticleSystemURL())) as GameObject;
             *  ParticleSystem particle = particleGO.GetComponent<ParticleSystem>();
             *  ParticleSystem.EmissionModule emission = particle.emission;
             *  emission.enabled = false;
             *  particle.gameObject.transform.parent = rootObject.transform;
             *  particle.gameObject.transform.localPosition = new Vector3(0f, 0.5f, 0f);
             *  particle.gameObject.transform.localRotation = Quaternion.identity;
             *  weaponProjectileList[i].particles = particle; // save reference
             * }
             */
        }
        for (int i = 0; i < genome.bodyGenome.weaponTazerList.Count; i++)
        {
            WeaponTazer weaponTazer = new WeaponTazer();
            weaponTazer.Initialize(genome.bodyGenome.weaponTazerList[i], agent);

            if (isVisible)
            {
                // Find appropriate Prefab based on Agent & Module Genome:
                GameObject weaponGO = Instantiate(Resources.Load("Prefabs/Modules/WeaponTazers/tazerTest")) as GameObject;
                weaponGO.transform.parent        = agent.segmentList[genome.bodyGenome.weaponTazerList[i].parentID].transform;
                weaponGO.transform.localPosition = genome.bodyGenome.weaponTazerList[i].muzzleLocation;
                weaponGO.transform.localRotation = Quaternion.identity;
                // Hook into Logic Module
                weaponTazer.weaponTazerComponent = weaponGO.GetComponent <WeaponTazerComponent>();
            }

            weaponTazerList.Add(weaponTazer);

            /*weaponTazerList[i].Initialize(genome.weaponTazerList[i]);
             * if (isVisible) {
             *  GameObject particleGO = Instantiate(Resources.Load(weaponTazerList[i].GetParticleSystemURL())) as GameObject;
             *  ParticleSystem particle = particleGO.GetComponent<ParticleSystem>();
             *  ParticleSystem.EmissionModule emission = particle.emission;
             *  emission.enabled = false;
             *  particle.gameObject.transform.parent = weaponTazerList[i].parentBody.transform;
             *  particle.gameObject.transform.localPosition = weaponTazerList[i].muzzleLocation;
             *  particle.gameObject.transform.localRotation = Quaternion.identity;
             *  weaponTazerList[i].particles = particle; // save reference
             * }
             */
        }
    }
示例#7
0
        //
        // 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}", accelerometerEvent.AccelerationX);
                        mTextAccY.Text         = string.Format("{0:F3}", accelerometerEvent.AccelerationY);
                        mTextAccZ.Text         = string.Format("{0:F3}", accelerometerEvent.AccelerationZ);
                    });
                };
            }

            if (contactSensor == null)
            {
                contactSensor = sensorMgr.CreateContactSensor();
                contactSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var contactEvent  = e.SensorReading;
                        mTextContact.Text = contactEvent.ContactStatus.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.PedometerMode.ToString();
                    });
                };
            }

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

            if (heartRateSensor == null)
            {
                heartRateSensor = sensorMgr.CreateHeartRateSensor();
                heartRateSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var heartRateEvent         = e.SensorReading;
                        mTextHeartRate.Text        = Convert.ToString(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}", pedometerEvent.TotalSteps);
                    });
                };
            }

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

            if (uvSensor == null)
            {
                uvSensor = sensorMgr.CreateUVSensor();
                uvSensor.ReadingChanged += (sender, e) =>
                {
                    Activity.RunOnUiThread(() =>
                    {
                        var uvEvent           = e.SensorReading;
                        mTextUltraviolet.Text = uvEvent.UVIndexLevel.ToString();
                    });
                };
            }
        }
        //
        // 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);
                    });
                };
            }
        }
示例#9
0
        public void InitSensors(TestMeViewModel b)
        {
            if (!_client.IsConnected)
            {
                return;
            }
            _hrSensor        = _hrSensor ?? _client.SensorManager.CreateHeartRateSensor();
            _gsrSensor       = _gsrSensor ?? _client.SensorManager.CreateGsrSensor();
            _rrSensor        = _rrSensor ?? _client.SensorManager.CreateRRIntervalSensor();
            _contactSensor   = _contactSensor ?? _client.SensorManager.CreateContactSensor();
            _distancerSensor = _distancerSensor ?? _client.SensorManager.CreateDistanceSensor();

            if (_contactSensor == null || _hrSensor == null || _gsrSensor == null || _rrSensor == null || _distancerSensor == null)
            {
                return;
            }
            Activity activity = Droid.MainActivity.instance;

            //register contact listener
            _contactSensor.ReadingChanged += (sender, e) =>
            {
                var contactEvent = e.SensorReading;
                _bandState = contactEvent.ContactState;
            };
            //register heart rate listener
            _hrSensor.ReadingChanged += (sender, e) =>
            {
                activity.RunOnUiThread(() =>
                {
                    var heartRateEvent = e.SensorReading;
                    //_hrReadings.Add(heartRateEvent.HeartRate);
                    if (heartRateEvent.Quality == HeartRateQuality.Locked)
                    {
                        _hrSensor.StopReadings();
                        _contactSensor.StopReadings();
                        // if (b != null) { b.HR = _hrReadings[_hrReadings.Count - 1]; } //update ViewModel
                    }
                    if (_bandState != BandContactState.Worn) //user took off the band while reading
                    {
                        _hrSensor.StopReadings();
                        _contactSensor.StopReadings();
                        _bandState = null;
                        return;
                    }
                });
            };
            //register gsr listener
            _gsrSensor.ReadingChanged += (sender, e) =>
            {
                activity.RunOnUiThread(() =>
                {
                    var gsrEvent = e.SensorReading;
                    _gsrReadings.Add(gsrEvent.Resistance);
                    if (b != null)
                    {
                        b.GsrList = gsrEvent.Resistance.ToString();
                    }

                    if (_gsrDone)
                    {
                        _gsrSensor.StopReadings();
                        _contactSensor.StopReadings();
                        return;
                    }
                });
            };
            //register RR Intervals listener
            _rrSensor.ReadingChanged += (sender, e) =>
            {
                if (_bandState != BandContactState.Worn) //user took off the band while reading
                {
                    _rrSensor.StopReadings();
                    _contactSensor.StopReadings();
                    _bandState     = null;
                    b.StressResult = "Error: band is not worn.";
                    return;
                }
                var rrEvent = e.SensorReading;
                _rrIntervalsReadings.Add(rrEvent.Interval);
            };
            _distancerSensor.ReadingChanged += (sender, e) =>
            {
                currentMotionTyp = e.SensorReading.MotionType;
                _distancerSensor.StopReadings();
            };
        }