static void Main()
{
Thermostat thermostat = new Thermostat();
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
static void Main(string[] args)
{
//coздать объект класса Thermostat
Thermostat thermostat = new Thermostat();
//coздать объект класса Heater установив начальную температуру равную 30 градусов
//coздать объект класса Cooler установив начальную температуру равную 40 градусов
//объект класса Heater - подписаться на событие изменения температуры класса Thermostat
//объект класса Cooler - подписаться на событие изменения температуры класса Thermostat
//эмуляция изменения температуры объекта класса Thermostat
//объект класса Cooler - отписаться от события изменения температуры класса Thermostat
//эмуляция изменения температуры объекта класса Thermostat на 45 градусов
Type type = thermostat.GetType();
foreach (var t in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
Console.WriteLine(t.Name);
}
}
async Task Connect(Thermostat thermostat)
{
var name = thermostat.Serial;
var uuid = thermostat.Uuid;
var connectedThermostat = await accessor.ConnectToPeripheralWithNameAndUuid(name, uuid);
var mainService = FindService(connectedThermostat, Uuids.MAIN_SERVICE);
var batteryService = FindService(connectedThermostat, Uuids.BATTERY_SERVICE);
var mainServiceCharacteristics = await accessor.DiscoverCharacteristicsFor(mainService);
var secretValueCharacteristic = Array.Find(mainServiceCharacteristics, c => c.Uuid == Uuids.SECRET_KEY);
if (secretValueCharacteristic == null && !thermostats.HasSecretAndUuidFor(serial))
{
Console.Error.WriteLine("You need to push the timer button on the thermostat");
Environment.Exit(1);
}
var pinCodeCharacteristic = CharacteristicWithUuid(mainServiceCharacteristics, Uuids.PIN_CODE_CHARACTERISTIC);
if (pinCodeCharacteristic == null)
{
Console.Error.WriteLine($"Did not find pin code characteristic ({Uuids.PIN_CODE_CHARACTERISTIC})");
Environment.Exit(1);
}
Console.Error.WriteLine("Writing pin code");
byte[] zeroBytes = { 0, 0, 0, 0 };
await accessor.WriteCharacteristicValue(mainService, pinCodeCharacteristic, zeroBytes);
Console.Error.WriteLine("Wrote pin code");
var batteryServiceCharacteristics = await accessor.DiscoverCharacteristicsFor(batteryService);
Console.Error.WriteLine("Discovered battery service characteristics");
thermostat.BatteryLevel = await ReadCharacteristicWithUuid(batteryService, batteryServiceCharacteristics, Uuids.BATTERY_LEVEL);
thermostat.Name = await ReadCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.DEVICE_NAME);
thermostat.Temperature = await ReadCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.TEMPERATURE);
thermostat.Settings = await ReadCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.SETTINGS);
thermostat.Schedule1 = await ReadCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.SCHEDULE_1);
thermostat.Schedule2 = await ReadCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.SCHEDULE_2);
thermostat.Schedule3 = await ReadCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.SCHEDULE_3);
var parsedThermostat = new ParsedThermostat(thermostat);
parsedThermostat.ApplyUpdates();
await WriteCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.TEMPERATURE, thermostat.Temperature);
await WriteCharacteristicWithUuid(mainService, mainServiceCharacteristics, Uuids.SETTINGS, thermostat.Settings);
await accessor.Disconnect();
}
public async Task ShouldSetMethodToPost()
{
var thermostat = new Thermostat("id123");
await _webService.SetHvacModeAsync(thermostat, HvacMode.Off);
_webRequest.VerifySet(w => w.Method = "POST");
}
static internal void Update_RemoteDevice(Thermostat thermostat, SensorCapabilities capability, DeviceDataPoint ddPoint, EcobeeConnection ecobee)
{
string name;
string id = GetDeviceKeys(ddPoint.device, out name);
if (name.Equals("Temperature Sensor"))
{
if (capability.value != "unknown")
{
var temp = Int16.Parse(capability.value) / 10;
hs.SetDeviceValueByRef(ddPoint.dvRef, temp, true);
}
else
{
hs.SetDeviceString(ddPoint.dvRef, "unknown", true);
}
ddPoint.device.set_ScaleText(hs, thermostat.settings.useCelsius ? "C" : "F");
}
if (name.Equals("Occupancy Sensor"))
{
if (capability.value.Equals("true"))
{
hs.SetDeviceValueByRef(ddPoint.dvRef, 1, true);
}
else
{
hs.SetDeviceValueByRef(ddPoint.dvRef, 0, true);
}
}
}
public async Task ShouldSetContentTypeToJson()
{
var thermostat = new Thermostat("id123");
await _webService.SetHvacModeAsync(thermostat, HvacMode.Off);
_webRequest.VerifySet(w => w.ContentType = ContentType.Json);
}
static void Main(string[] args)
{
Thermostat thermostat = new Thermostat();
Heater heater = new Heater(30);
Cooler cooler = new Cooler(40);
thermostat.Add_TemperatureChanged(heater.OnTemperatureChanged);
thermostat.Add_TemperatureChanged(cooler.Update);
thermostat.EmulateTemperatureChange();
thermostat.Remove_TemperatureChanged(cooler.Update);
thermostat.EmulateTemperatureChange();
Type type = thermostat.GetType();
foreach (var t in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
Console.WriteLine(t.Name);
}
Console.ReadKey();
}
public void SetUp()
{
_statusProvider = new Mock <IStatusProvider>();
_sessionProvider = new Mock <ISessionProvider>();
_analyticsService = new Mock <IAnalyticsService>();
_nestWebService = new Mock <INestWebService>();
_statusUpdaterService = new Mock <IStatusUpdaterService>();
_structure = new Structure("1");
_firstThermostat = new Thermostat("1");
_secondThermostat = new Thermostat("1");
_structure.Thermostats.Add(_firstThermostat);
_structure.Thermostats.Add(_secondThermostat);
var structures = new List <Structure> {
_structure
};
_nestWebService.Setup(w => w.LoginAsync(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(new WebServiceResult()));
_nestWebService.Setup(w => w.UpdateTransportUrlAsync()).Returns(Task.FromResult(new WebServiceResult()));
_nestWebService.Setup(w => w.SetAwayMode(It.IsAny <Structure>(), It.IsAny <bool>())).Returns(Task.FromResult(new WebServiceResult()));
_nestWebService.Setup(w => w.GetFullStatusAsync()).Returns(Task.FromResult(new GetStatusResult(structures)));
_nestWebService.Setup(w => w.ChangeTemperatureAsync(It.IsAny <Thermostat>(), It.IsAny <double>(), It.IsAny <TemperatureMode>())).Returns(Task.FromResult(new WebServiceResult()));
_nestWebService.Setup(w => w.SetFanModeAsync(It.IsAny <Thermostat>(), It.IsAny <FanMode>())).Returns(Task.FromResult(new WebServiceResult()));
_nestWebService.Setup(w => w.SetHvacModeAsync(It.IsAny <Thermostat>(), It.IsAny <HvacMode>())).Returns(Task.FromResult(new WebServiceResult()));
_statusUpdaterService.Setup(s => s.UpdateStatusAsync()).Returns(Task.Delay(0));
ServiceContainer.RegisterService <IStatusProvider>(_statusProvider.Object);
ServiceContainer.RegisterService <ISessionProvider>(_sessionProvider.Object);
ServiceContainer.RegisterService <IAnalyticsService>(_analyticsService.Object);
ServiceContainer.RegisterService <INestWebService>(_nestWebService.Object);
ServiceContainer.RegisterService <IStatusUpdaterService>(_statusUpdaterService.Object);
_viewModel = new NestViewModel();
}
protected double UpdatePlant(Thermostat dev, double current, double outside_temp)
{
if (!dev.Enabled)
{
return(0.0);
}
var max_error = 1.0;
if (_running)
{
max_error = 0.05; //once on, drive error low
}
var error = current - dev.SetPoint.C;
var plant_drive = 0.0;
if (Math.Abs(error) > max_error)
{
plant_drive = Math.Sign(error) * (outside_temp - current) * _thermal_rate * 2.0;
_running = true;
}
else if (_running) //error is below, and running, shut off.
{
_running = false;
}
return(plant_drive);
}
public void Update(IDeviceState state, bool fromDatabase = false)
{
//TODO: update more properties?
if (!fromDatabase)
{
if (Name == null && state.Name != null)
{
Name = state.Name;
}
if ((Type == null || Type.Equals(DeviceType.Unknown)) && state.Type != null)
{
Type = state.Type;
}
}
Location = (state.Location == null) ? null : new Location(state.Location.GetParts());
IsConnected = state.IsConnected;
CurrentAction = state.CurrentAction;
BinarySwitch.Update(state.BinarySwitchState ?? ReadOnlyBinarySwitchSwitchState.Blank());
MultilevelSwitch.Update(state.MultilevelSwitchState ?? ReadOnlyMultilevelSwitchState.Blank());
ColorSwitch.Update(state.ColorSwitchState ?? ReadOnlyColorSwitchState.Blank());
BinarySensor.Update(state.BinarySensorState ?? ReadOnlyBinarySensorState.Blank());
PowerSensor.Update(state.PowerSensorState ?? ReadOnlyMultilevelSensorState <IPower> .Blank());
TemperatureSensor.Update(state.TemperatureSensorState ?? ReadOnlyMultilevelSensorState <ITemperature> .Blank());
HumiditySensor.Update(state.HumiditySensorState ?? ReadOnlyMultilevelSensorState <IHumidity> .Blank());
IlluminanceSensor.Update(state.IlluminanceSensorState ?? ReadOnlyMultilevelSensorState <IIlluminance> .Blank());
Thermostat.Update(state.ThermostatState ?? ReadOnlyThermostatState.Blank());
}
public void ConstrAvecParamCasHorsLimiteMaxPlusUnRetourExceptionTest()
{
// Arranger (Arrange) Agir (Agir)
Thermostat objThermostat = new Thermostat(Thermostat.MAX_TEMPERATURE + 1);
// Auditer (Assert)
// ArgumentOutOfRangeException attendue intercepté au niveau de l'annotation [ExpectedException(typeof(ArgumentOutOfRangeException))]
}
public void testEquals_shouldReturnFalseWithNonThermostat()
{
Object o = new Object();
Thermostat t = new Thermostat();
Assert.IsFalse(t.Equals(o));
}
public void ShouldUpdateHvacMode()
{
var thermostat = new Thermostat("");
_deserializer.UpdateThermostatStatusFromSharedStatusResult(FakeJsonMessages.GetSharedStatusResultTempRangeMode, thermostat);
Assert.AreEqual(HvacMode.HeatAndCool, thermostat.HvacMode);
}
private async void sendDeviceMetaData()
{
DeviceProperties device = new DeviceProperties();
Thermostat thermostat = new Thermostat();
thermostat.ObjectType = "DeviceInfo";
thermostat.IsSimulatedDevice = false;
thermostat.Version = "1.0";
device.HubEnabledState = true;
device.DeviceID = deviceId;
device.Manufacturer = "Raspberry";
device.ModelNumber = "Pi2";
device.SerialNumber = "5849735293875";
device.FirmwareVersion = "10";
device.Platform = "Windows 10";
device.Processor = "RaspBerry";
device.InstalledRAM = "976 MB";
device.DeviceState = "normal";
string pos = await GetGeoLocFromWeb();
var nloc = pos.IndexOf("loc");
var sub01 = pos.Substring(nloc + 7);
string location = sub01.Substring(0, sub01.IndexOf('"'));
var x = location.Split(',');
device.Latitude = System.Convert.ToDouble(x[0]);
device.Longitude = System.Convert.ToDouble(x[1]);
thermostat.DeviceProperties = device;
Command TriggerAlarm = new Command();
TriggerAlarm.Name = "TriggerAlarm";
CommandParameter param = new CommandParameter();
param.Name = "Message";
param.Type = "String";
TriggerAlarm.Parameters = new CommandParameter[] { param };
thermostat.Commands = new Command[] { TriggerAlarm };
try
{
var msg = new Message(Serialize(thermostat));
if (deviceClient != null)
{
await deviceClient.SendEventAsync(msg);
}
}
catch (System.Exception e)
{
Debug.Write("Exception while sending device meta data :\n" + e.Message.ToString());
}
Debug.Write("Sent meta data to IoT Suite\n" + hostName);
}
public async Task <ActionResult> Initialize(string connectionString, int transportType)
{
await Uninitialize(connectionString);
thermostat = new Thermostat(connectionString, transportType);
await thermostat.Initialize();
return(Json(new { success = true }));
}
public async Task ShouldUseCorrectUrl()
{
var thermostat = new Thermostat("id123");
await _webService.SetHvacModeAsync(thermostat, HvacMode.Off);
var expectedUri = new Uri(BaseUrl + "/v2/put/shared.id123");
_requestProvider.Verify(r => r.CreateRequest(expectedUri));
}
public ThermostatGetDto ThermostatGetDtoConversion(Thermostat t) => new ThermostatGetDto()
{
Name = t.Name,
Code = t.Code,
HumidityReading = t.HumidityReading,
Location = t.Location,
TemperatureReading = t.TemperatureReading,
TemperatureSetting = t.TemperatureSetting
};
public void Create(Thermostat thermostat)
{
Validator.RequireString(thermostat.BarcodeNumber);
Validator.RequireString(thermostat.SerialNumber);
Validator.RequireString(thermostat.Model);
context.Thermostats.Add(thermostat);
context.SaveChanges();
}
public void TemperatureSetCasHorsLimiteMaxPlusUnRetourExceptionTest()
{
// Arranger (Arrange)
Thermostat objThermostat = new Thermostat(Thermostat.TEMPERATURE_INITIALE);
// Agir
objThermostat.Temperature = Thermostat.MAX_TEMPERATURE + 1;
// Auditer (Assert)
// ArgumentOutOfRangeException attendue intercepté au niveau de l'annotation [ExpectedException(typeof(ArgumentOutOfRangeException))]
}
public void ShouldUpdateTargetTemperatureHigh()
{
var thermostat = new Thermostat("");
_deserializer.UpdateThermostatStatusFromSharedStatusResult(FakeJsonMessages.GetSharedStatusResultTempRangeMode, thermostat);
double expectedTemperature = Math.Round(24d.CelsiusToFahrenheit());
Assert.AreEqual(expectedTemperature, thermostat.TargetTemperatureHigh);
}
public static void ShowStatus(Light light, Fan fan, Thermostat thermostat)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"Light is turned {light}");
Console.WriteLine($"Fan is turned {fan}");
Console.WriteLine($"Thermostat is turned {thermostat}");
//Console.ForegroundColor = ConsoleColor.White;
Console.ResetColor();
Console.WriteLine("-------------------");
}
public void Post([FromBody] Record rec)
{
Db.Save(rec);
var source = Db.GetSource(rec.SourceId);
if (source.Outside == false)
{
Thermostat.AdjustTemperature(source.Id);
}
}
public void DiminuerTemperatureCasAuLimiteMinRetourExceptionTest()
{
// Arranger (Arrange)
Thermostat objThermostat = new Thermostat(Thermostat.MIN_TEMPERATURE);
//Agir (Act)
objThermostat.DiminuerTemperature();
//Auditer (Assert)
// InvalidOperationException attendue intercepté au niveau de l'annotation [ExpectedException(typeof(InvalidOperationException))]
}
public async Task ShouldSetAuthorizationHeaderOnRequest()
{
string accessToken = "token";
_sessionProvider.SetupGet(s => s.AccessToken).Returns(accessToken);
var thermostat = new Thermostat("id123");
await _webService.SetHvacModeAsync(thermostat, HvacMode.Off);
_webHeaderCollection.VerifySet(w => w["Authorization"] = "Basic " + accessToken);
}
public void CancelVacation(Thermostat thermostat)
{
if (attributeValues.Length != 0)
{
Console.Error.WriteLine($"Expected no further arguments for cancel vacation, got {attributeValues.Length}");
Environment.Exit(1);
}
thermostat.CancelVacation();
}
public void ShouldUpdateCurrentTemperature()
{
var thermostat = new Thermostat("");
_deserializer.UpdateThermostatStatusFromSharedStatusResult(FakeJsonMessages.GetSharedStatusResult, thermostat);
double expectedTemperature = Math.Round(21.89d.CelsiusToFahrenheit());
Assert.AreEqual(expectedTemperature, thermostat.CurrentTemperature);
}
public void ConstrAvecParamCasTempInitRetourTempInitTest()
{
// Arranger (Arrange) Agir (Act)
Thermostat objThermostat = new Thermostat(15);
// Auditer (Assert)
int ValeurAttendue = 15;
int valeurRetournee = objThermostat.Temperature;
Assert.AreEqual(ValeurAttendue, valeurRetournee);
}
private async void sendDeviceMetaData()
{
DeviceProperties device = new DeviceProperties();
Thermostat thermostat = new Thermostat();
thermostat.ObjectType = "DeviceInfo";
thermostat.IsSimulatedDevice = false;
thermostat.Version = "1.0";
device.HubEnabledState = true;
device.DeviceID = deviceId;
device.Manufacturer = "Microsoft";
device.ModelNumber = "Lumia950";
device.SerialNumber = "5849735293875";
device.FirmwareVersion = "10";
device.Platform = "Windows 10";
device.Processor = "SnapDragon";
device.InstalledRAM = "3GB";
device.DeviceState = "normal";
Geolocator geolocator = new Geolocator();
Geoposition pos = await geolocator.GetGeopositionAsync();
device.Latitude = (float)pos.Coordinate.Point.Position.Latitude;
device.Longitude = (float)pos.Coordinate.Point.Position.Longitude;
thermostat.DeviceProperties = device;
Command TriggerAlarm = new Command();
TriggerAlarm.Name = "TriggerAlarm";
CommandParameter param = new CommandParameter();
param.Name = "Message";
param.Type = "String";
TriggerAlarm.Parameters = new CommandParameter[] { param };
thermostat.Commands = new Command[] { TriggerAlarm };
try
{
var msg = new Message(Serialize(thermostat));
if (deviceClient != null)
{
await deviceClient.SendEventAsync(msg);
}
}
catch (System.Exception e)
{
Debug.Write("Exception while sending device meta data :\n" + e.Message.ToString());
}
Debug.Write("Sent meta data to IoT Suite\n" + hostName);
}
public void TemperatureGetCasTempInitRetourTempInitTest()
{
// Arranger (Arrange)
Thermostat objThermostat = new Thermostat(Thermostat.TEMPERATURE_INITIALE);
// Agir (Act)
int valeurRetournee = objThermostat.Temperature;
// Auditer (Assert)
int ValeurAttendue = Thermostat.TEMPERATURE_INITIALE;
Assert.AreEqual(ValeurAttendue, valeurRetournee);
}
public void ConstrAvecParamCasAuLimiteMaxRetourLimiteMaxTest()
{
// Arranger (Arrange) Agir (Act)
Thermostat objThermostat = new Thermostat(Thermostat.MAX_TEMPERATURE);
// Auditer (Assert)
int ValeurAttendue = Thermostat.MAX_TEMPERATURE;
int valeurRetournee = objThermostat.Temperature;
Assert.AreEqual(ValeurAttendue, valeurRetournee);
}
public void ToString_NormalUse_ReturnsExpectedString()
{
// Arrange
var thermostat = new Thermostat
{
Name = "TestDevice",
CurrentTemp = new Measurement<float?>(10, new DateTime(2013, 01, 01, 01, 02, 03))
};
const string expectedToString = "Thermostat TestDevice, CurrentTemp = 10 (2013-01-01 01:02:03)";
// Act
string actualToString = thermostat.ToString();
// Assert
Assert.AreEqual(expectedToString, actualToString);
}
public string GetThermostatState(Thermostat thermostat)
{
string tstate = "The {0} is set to {1}({2}), is {3} and the temp. is {4}";
SensorReading setpoint = null;
int level = (int)thermostat.level;
string setMode = "unknown";
if (level >= 99)
{
setMode = "comfort";
}
if (level == 0)
{
setMode = "econ";
}
else
{
setMode = "comfort";
}
string currentState = string.Empty;
try
{
#region setpoints
if ((thermostat.sr != null) && (thermostat.sr.Length > 0))
{
List<SensorReading> setpoints = thermostat.sr.ToList<SensorReading>();
SensorReading temperature = setpoints.Find(s => (s.name.StartsWith("Temperature")));
string state = string.Empty;
switch (thermostat.thermostatSystemMode)
{
case ThermoSystemMode.Heat:
setpoint = (setMode == "comfort") ? setpoints.Find(s => (s.name == "Heating1")) : setpoints.Find(s => (s.name == "EnergyHeat"));
break;
case ThermoSystemMode.Cool:
setpoint = (setMode == "comfort") ? setpoints.Find(s => (s.name == "Cooling1")) : setpoints.Find(s => (s.name == "EnergyCool"));
break;
case ThermoSystemMode.Off:
return "The " + thermostat.name + " is set to " + setMode + ", and is off, current temp. is " + thermostat.currentThermTempF;
case ThermoSystemMode.EnergySaveCool:
setpoint = setpoints.Find(s => (s.name == "EnergyHeat"));
break;
case ThermoSystemMode.EnergySaveHeat:
setpoint = setpoints.Find(s => (s.name == "EnergyCool"));
break;
default:
Console.WriteLine(thermostat.thermostatSystemMode.ToString());
break;
}
}
#endregion
string sysState = (thermostat.thermostatSystemState.ToString().ToUpper() == "OFF") ? "idle" : thermostat.thermostatSystemState.ToString().ToLower() + "ing";
string t_state = String.Format(tstate, thermostat.deviceName, setMode, setpoint.value, sysState, thermostat.currentThermTempF);
return t_state;
}
catch
{
return "Unable to retrieve " + thermostat.name + " information";
}
}
public string SetTemperature(Thermostat t, int temperature)
{
var service = HaService.getService(url, port);
string setPointname = string.Empty;
switch (t.thermostatSystemMode)
{
case ThermoSystemMode.Heat:
service.setThermoSetpoint(password, t.deviceId.ToString(), "Heating1", (decimal)temperature);
setPointname = "Heating1";
break;
case ThermoSystemMode.Cool:
service.setThermoSetpoint(password, t.deviceId.ToString(), "Cooling1", (decimal)temperature);
setPointname = "Cooling1";
break;
default:
if ((DateTime.Now.Month >= 1) && (DateTime.Now.Month <= 4))
{
service.setThermoSetpoint(password, t.deviceId.ToString(), "Heating1", (decimal)temperature);
setPointname = "Heating1";
}
break;
}
Thermostat tChanged = (Thermostat)service.getDevice(password, t.nodeId.ToString());
return GetThermostatState(tChanged);
}
private async void sendDeviceMetaData()
{
DeviceProperties device = new DeviceProperties();
Thermostat thermostat = new Thermostat();
thermostat.ObjectType = "DeviceInfo";
thermostat.IsSimulatedDevice = false;
thermostat.Version = "1.0";
device.HubEnabledState = true;
device.DeviceID = deviceId;
device.Manufacturer = "Microsoft";
device.ModelNumber = "Lumia950";
device.SerialNumber = "5849735293875";
device.FirmwareVersion = "10";
device.Platform = "Windows 10";
device.Processor = "SnapDragon";
device.InstalledRAM = "3GB";
device.DeviceState = "normal";
Geolocator geolocator = new Geolocator();
Geoposition pos = await geolocator.GetGeopositionAsync();
device.Latitude = (float)pos.Coordinate.Point.Position.Latitude;
device.Longitude = (float)pos.Coordinate.Point.Position.Longitude;
thermostat.DeviceProperties = device;
Command TriggerAlarm = new Command();
TriggerAlarm.Name = "TriggerAlarm";
CommandParameter param = new CommandParameter();
param.Name = "Message";
param.Type = "String";
TriggerAlarm.Parameters = new CommandParameter[] { param };
thermostat.Commands = new Command[] { TriggerAlarm };
try
{
var msg = new Message(Serialize(thermostat));
if (deviceClient != null)
{
await deviceClient.SendEventAsync(msg);
}
}
catch (System.Exception e)
{
Debug.Write("Exception while sending device meta data :\n" + e.Message.ToString());
}
Debug.Write("Sent meta data to IoT Suite\n" + hostName);
}
public static void Main()
{
Thermostat thermostat = new Thermostat();
Heater heater = new Heater(60);
Cooler cooler = new Cooler(80);
string temperature;
// Using C# 2.0 or later syntax.
thermostat.OnTemperatureChange +=
heater.OnTemperatureChanged;
thermostat.OnTemperatureChange +=
cooler.OnTemperatureChanged;
Console.Write("Enter temperature: ");
temperature = Console.ReadLine();
thermostat.CurrentTemperature = int.Parse(temperature);
}
public static void Main()
{
Thermostat thermostat = new Thermostat();
Heater heater = new Heater(60);
Cooler cooler = new Cooler(80);
// Note: Use new Action(
// cooler.OnTemperatureChanged) if C# 1.0.
thermostat.OnTemperatureChange +=
heater.OnTemperatureChanged;
thermostat.OnTemperatureChange +=
cooler.OnTemperatureChanged;
// Bug: Should not be allowed
thermostat.OnTemperatureChange(42);
}
public void AddRemoveHandlerWorks()
{
Thermostat t = new Thermostat();
float temp = 0;
Thermostat.TemperatureChangeHandler T_OnTemperatureChange = (sender, newTemperature) =>
{
temp = newTemperature.NewTemperature;
};
t.OnTemperatureChange += T_OnTemperatureChange;
t.CurrentTemperature = 12;
Assert.AreEqual(12, temp);
t.OnTemperatureChange -= T_OnTemperatureChange;
t.CurrentTemperature = 20;
Assert.AreEqual(12, temp);
}
public static void Main()
{
Thermostat thermostat = new Thermostat();
Heater heater = new Heater(60);
Cooler cooler = new Cooler(80);
string temperature;
// Note: Use new Action(
// cooler.OnTemperatureChanged) if C# 1.0
thermostat.OnTemperatureChange =
heater.OnTemperatureChanged;
// Bug: assignment operator overrides
// previous assignment.
thermostat.OnTemperatureChange =
cooler.OnTemperatureChanged;
Console.Write("Enter temperature: ");
temperature = Console.ReadLine();
thermostat.CurrentTemperature = int.Parse(temperature);
}
public static void Main()
{
Thermostat thermostat = new Thermostat();
Heater heater = new Heater(60);
Cooler cooler = new Cooler(80);
Action<float> delegate1;
Action<float> delegate2;
Action<float> delegate3;
// Note: Use new Action(cooler.OnTemperatureChanged)
// for C# 1.0 syntax.
delegate1 = heater.OnTemperatureChanged;
delegate2 = cooler.OnTemperatureChanged;
Console.WriteLine("Combine delegates using + operator:");
delegate3 = delegate1 + delegate2;
delegate3(60);
Console.WriteLine("Uncombine delegates using - operator:");
delegate3 = delegate3 - delegate2;
delegate3(60);
}
public static void Main()
{
Thermostat thermostat = new Thermostat();
Heater heater = new Heater(60);
Cooler cooler = new Cooler(80);
Action<float> delegate1;
Action<float> delegate2;
Action<float> delegate3;
// use Constructor syntax for C# 1.0.
delegate1 = heater.OnTemperatureChanged;
delegate2 = cooler.OnTemperatureChanged;
Console.WriteLine("Invoke both delegates:");
delegate3 = delegate1;
delegate3 += delegate2;
delegate3(90);
Console.WriteLine("Invoke only delegate2");
delegate3 -= delegate1;
delegate3(30);
}
private static void SubscribeToNestDeviceDataUpdates()
{
var thermostats = new List<Thermostat>();
Thermostat myThermostat = new Thermostat();
var firebaseClient = new Firebase("https://developer-api.nest.com", _accessToken);
var response = firebaseClient.GetStreaming("devices",
//changed: (s, args) => UpdatedItem(args)
changed: (s, e) => {
/* if (e.Path.EndsWith("name"))
//myThermostat.name = e.Data;
Console.WriteLine("Name: {0}.", e.Data);
if (e.Path.Contains("last_connection"))
//myThermostat.last_connection = e.Data;
Console.WriteLine("Last connection: {0}.", e.Data);
if (e.Path.Contains("ambient_temperature_f"))
//myThermostat.ambient_temperature_f = e.Data;
Console.WriteLine("Current temperature: {0}.", e.Data);
if (e.Path.Contains("target_temperature_f"))
//myThermostat.target_temperature_f = e.Data;
Console.WriteLine("Target temperature: {0}.", e.Data);
if (e.Path.Contains("humidity"))
//myThermostat.Humidity = e.Data;
Console.WriteLine("Humidity: {0}.", e.Data);
if (e.Path.Contains("hvac_state"))
//myThermostat.hvac_state = e.Data;
Console.WriteLine("Current mode: {0}.", e.Data);
//thermostats.Add(myThermostat);
var JSON = JsonConvert.SerializeObject(e.Data);
//Console.WriteLine(JSON);
*/
var JSON = JsonConvert.SerializeObject(e.Data);
Console.WriteLine(JSON);
//Console.WriteLine(e.Path.Remove(0, 54) + "-" + e.Data);
}
);
Console.WriteLine("Change the current temperature of the Nest Thermostat in the Nest Developer Chrome Extension to see the real-time updates.");
}
public static void Main()
{
Thermostat thermostat = new Thermostat();
Heater heater = new Heater(60);
Cooler cooler = new Cooler(80);
string temperature;
// Using C# 2.0 or later syntax.
thermostat.OnTemperatureChange +=
heater.OnTemperatureChanged;
// Using C# 3.0. Change to anonymous method
// if using C# 2.0
thermostat.OnTemperatureChange +=
(newTemperature) =>
{
throw new InvalidOperationException();
};
thermostat.OnTemperatureChange +=
cooler.OnTemperatureChanged;
Console.Write("Enter temperature: ");
temperature = Console.ReadLine();
thermostat.CurrentTemperature = int.Parse(temperature);
}
