Inheritance: AbstractUpdateableComponent
 public void GetUpdateString_ValidUpdateStringGenerated_ValidUpdateStringReturned()
 {
     Battery b = new Battery(200) { ChargePerc = 20.0012f, Current = 23.5f, Temperature = 54.7456f };
     Assert.AreEqual(String.Format("<B;{0},{1},{2}>",
         Math.Round(b.ChargePerc, 3), Math.Round(b.Current, 3), Math.Round(b.Temperature, 3)),
         b.GetUpdateString());
 }
        public void UpdateFromString_InvalidUpdateString_ObjectUpdated()
        {
            Battery b = new Battery(200) { ChargePerc = 20.0f, Current = 23.5f, Temperature = 54.7f };
            string updateString;

            updateString = "<B;57.564,254500.122,70.523>";
            b.UpdateFromString(updateString);

            Assert.AreEqual(57.564f, b.ChargePerc);
            Assert.AreEqual(564, 254500.122f, b.Current);
            Assert.AreEqual(70.523f, b.Temperature);
        }
        public BatteryStatusViewModel()
        {
            battery = StatusUpdater.Instance.RoverStatus.Battery;

            battery.DangerousCurrentDetected += new MarsRover.DangerousCurrentDetectedDelegate<Battery>(CurrentStatusChanged);
            battery.WarningCurrentDetected += new MarsRover.WarningCurrentDetectedDelegate<Battery>(CurrentStatusChanged);
            battery.NormalCurrentDetected += new MarsRover.NormalCurrentDetectedDelegate<Battery>(CurrentStatusChanged);

            battery.DangerousTemperatureDetected += new MarsRover.DangerousTemperatureDetectedDelegate<Battery>(TemperatureStatusChanged);
            battery.WarningTemperatureDetected += new MarsRover.WarningTemperatureDetectedDelegate<Battery>(TemperatureStatusChanged);
            battery.NormalTemperatureDetected += new MarsRover.NormalTemperatureDetectedDelegate<Battery>(TemperatureStatusChanged);

            StatusUpdater.Instance.BatteryUpdated += new StatusUpdater.BatteryUpdatedDelegate(UpdateBattery);
        }
        public RoverStatus()
        {
            Motors = new Dictionary<Motor.Location, Motor>(6);
            Motors.Add(Motor.Location.FrontLeft, new Motor(Motor.Location.FrontLeft));
            Motors.Add(Motor.Location.FrontRight, new Motor(Motor.Location.FrontRight));
            Motors.Add(Motor.Location.BackLeft, new Motor(Motor.Location.BackLeft));
            Motors.Add(Motor.Location.BackRight, new Motor(Motor.Location.BackRight));
            Motors.Add(Motor.Location.MiddleLeft, new Motor(Motor.Location.MiddleLeft));
            Motors.Add(Motor.Location.MiddleRight, new Motor(Motor.Location.MiddleRight));

            Battery = new Battery(2000);
            GPSCoordinates = new GPSCoordinates();
            IMUSensor = new IMU();
            RoboArm = new RoboticArm();
        }
        public void UpdateFromString_InvalidUpdateString_ThrowException()
        {
            Battery b = new Battery(200) { ChargePerc = 20.0f, Current = 23.5f, Temperature = 54.7f };
            string updateString;

            updateString = "<V;57.564,254500.122,70.523>";
            Assert.Throws<InvalidUpdateStringException>(() => b.UpdateFromString(updateString));
            updateString = "<B;57.5624,254500.122,70.523>";
            Assert.Throws<InvalidUpdateStringException>(() => b.UpdateFromString(updateString));
            updateString = "<B;57.564,254500.122,70.523156>";
            Assert.Throws<InvalidUpdateStringException>(() => b.UpdateFromString(updateString));
            updateString = "B;57.564,254500.122,70.5";
            Assert.Throws<InvalidUpdateStringException>(() => b.UpdateFromString(updateString));
            updateString = "<B;57.564,70.523156>";
            Assert.Throws<InvalidUpdateStringException>(() => b.UpdateFromString(updateString));
        }
        private void CurrentStatusChanged(Battery battery)
        {
            if (battery.StatusCurrent == CurrentStatus.Dangerous)
            {
                IsDangerousCurrent = true;
                IsWarningCurrent = false;
            }
            else if (battery.StatusCurrent == CurrentStatus.Warning)
            {
                IsDangerousCurrent = false;
                IsWarningCurrent = true;
            }
            else
            {
                IsDangerousCurrent = false;
                IsWarningCurrent = false;
            }

            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs("IsDangerousCurrent"));
                PropertyChanged(this, new PropertyChangedEventArgs("IsWarningCurrent"));
            }
        }
        private void TemperatureStatusChanged(Battery battery)
        {
            if (battery.StatusTemperature == TemperatureStatus.Dangerous)
            {
                IsDangerousTemperature = true;
                IsWarningTemperature = false;
            }
            else if (battery.StatusTemperature == TemperatureStatus.Warning)
            {
                IsDangerousTemperature = false;
                IsWarningTemperature = true;
            }
            else
            {
                IsDangerousTemperature = false;
                IsWarningTemperature = false;
            }

            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs("IsDangerousTemperature"));
                PropertyChanged(this, new PropertyChangedEventArgs("IsWarningTemperature"));
            }
        }
 private void UpdateBattery(Battery battery)
 {
     if (PropertyChanged != null)
     {
         PropertyChanged(this, new PropertyChangedEventArgs("Battery"));
     }
 }