public static ControlThinkThermostatMode?ToControlThinkType(this ThermostatMode input)
{
ControlThinkThermostatMode?result;
switch (input)
{
case ThermostatMode.Off:
result = ControlThinkThermostatMode.Off;
break;
case ThermostatMode.Heat:
result = ControlThinkThermostatMode.Heat;
break;
case ThermostatMode.Cool:
result = ControlThinkThermostatMode.Cool;
break;
case ThermostatMode.FanOnly:
result = ControlThinkThermostatMode.FanOnly;
break;
case ThermostatMode.Auto:
result = ControlThinkThermostatMode.Auto;
break;
default:
result = null;
break;
}
return(result);
}
internal async Task <SimpleAnswer> SetThermMod(string homeId, ThermostatMode thermalMode, DateTime endTime)
{
if (!await CheckConnectionAsync().ConfigureAwait(false))
{
return(null);
}
var parameters = HttpUtility.ParseQueryString(string.Empty);
parameters["home_id"] = homeId;
parameters["mode"] = thermalMode.FromThermostatMode();
parameters["endtime"] = endTime.FromLocalDateTime().ToString(CultureInfo.InvariantCulture);
using (HttpClient client = new HttpClient())
using (HttpRequestMessage request = new HttpRequestMessage())
{
request.Method = HttpMethod.Post;
request.RequestUri = new Uri(host + apiPath + "/setthermmode");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _accessToken);
request.Content = new StringContent(parameters.ToString(), Encoding.UTF8, "application/x-www-form-urlencoded");
HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
string responseBody = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
SimpleAnswer simpleAnswer = new SimpleAnswer().FromJson(responseBody);
if (simpleAnswer.Status == null)
{
ErrorMessageData errorMessageData = new ErrorMessageData().FromJson(responseBody);
_errorMessage = errorMessageData.Error.Message;
return(null);
}
return(simpleAnswer);
}
}
/// <summary>
/// Open driver
/// </summary>
/// <param name="conversionRate">Conversion rate</param>
/// <param name="shutdownMode">Shutdown mode</param>
/// <param name="thermostatMode">Thermostat mode</param>
/// <param name="alertPolarity">Polarity of the alert pin</param>
/// <param name="consecutiveFaults">Consecutive faults before activate alert pin</param>
/// <param name="temperatureHigh">Temperature High for alert</param>
/// <param name="temperatureLow">Temperature Low for alert</param>
/// <param name="alertPin">Alert pin</param>
/// <param name="i2cSelector">I2C selector string</param>
/// <returns>Driver opened</returns>
public async Task<bool> OpenAsync(
ConversionRate conversionRate = ConversionRate._4Hz,
bool shutdownMode = false,
ThermostatMode thermostatMode = ThermostatMode.Comparator,
AlertPolarity alertPolarity = AlertPolarity.ActiveLow,
ConsecutiveFaults consecutiveFaults = ConsecutiveFaults._1,
float temperatureHigh = TEMP_HIGH_DEFAULT,
float temperatureLow = TEMP_LOW_DEFAULT,
int alertPin = 0,
string i2cSelector = PI2_I2C_SELECTOR)
{
try
{
string advancedQuerySyntax = I2cDevice.GetDeviceSelector(i2cSelector);
DeviceInformationCollection device_information_collection = await DeviceInformation.FindAllAsync(advancedQuerySyntax);
string deviceId = device_information_collection[0].Id;
this.i2c = await I2cDevice.FromIdAsync(deviceId, this.i2cConfig);
// load configuration register
this.LoadConfiguration();
// set conversion rate
this.configuration = (ushort)(this.configuration & ~CONV_RATE_MASK);
this.configuration |= (ushort)conversionRate;
// set shutdown mode
this.configuration = (shutdownMode) ? (ushort)(this.configuration | SHUTDOWN_MODE) : (ushort)(this.configuration & ~SHUTDOWN_MODE);
// set thermostat mode
this.configuration = (thermostatMode == ThermostatMode.Interrupt) ? (ushort)(this.configuration | THERMOSTAT_MODE) : (ushort)(this.configuration & ~THERMOSTAT_MODE);
// set alert pin polarity
this.configuration = (alertPolarity == AlertPolarity.ActiveHigh) ? (ushort)(this.configuration | POLARITY) : (ushort)(this.configuration & ~POLARITY);
// set consecutive faults for alert
this.configuration = (ushort)(this.configuration & ~FAULT_QUEUE_MASK);
this.configuration |= (ushort)consecutiveFaults;
// save configuration register
this.ChangeConfiguration();
// set temperature high for alert
this.regAddress[0] = TEMP_HIGH_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureHigh);
this.WriteRegister(this.regAddress, this.regData);
// set temperature low for alert
this.regAddress[0] = TEMP_LOW_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureLow);
this.WriteRegister(this.regAddress, this.regData);
if (alertPin != 0)
{
GpioController gpioController = GpioController.GetDefault();
this.alertPin = gpioController.OpenPin(alertPin);
this.alertPin.ValueChanged += AlertPin_ValueChanged;
}
return true;
}
catch (Exception ex)
{
return false;
}
}
public void SetValue(ThermostatMode value)
{
var dataEntry = GetDataEntry();
if (dataEntry == null)
{
throw new CannotSetValueException();
}
var stringValue = value.ToString();
dataEntry.SetSelection(stringValue);
}
/// <summary>
/// Convert <paramref name="value"/> to a <see cref="string"/>
/// </summary>
/// <param name="value"></param>
/// <returns>The <see cref="string"/> corresponding to the input <paramref name="value"/></returns>
public static string FromThermostatMode(this ThermostatMode value)
{
switch (value)
{
case ThermostatMode.Schedule:
return("schedule");
case ThermostatMode.Away:
return("away");
case ThermostatMode.FrostGuard:
return("hg");
default:
return("schedule");
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="a0addrSelect">A0 pin connection for address selection</param>
/// <param name="clockRateKhz">I2C clock rate in KHz</param>
/// <param name="conversionRate">Conversion rate</param>
/// <param name="shutdownMode">Shutdown mode</param>
/// <param name="thermostatMode">Thermostat mode</param>
/// <param name="alertPolarity">Polarity of the alert pin</param>
/// <param name="consecutiveFaults">Consecutive faults before activate alert pin</param>
/// <param name="temperatureHigh">Temperature High for alert</param>
/// <param name="temperatureLow">Temperature Low for alert</param>
public TMP102(A0AddressSelect a0addrSelect = A0AddressSelect.GND,
int clockRateKhz = CLOCK_RATE_KHZ_DEFAULT,
ConversionRate conversionRate = ConversionRate._4Hz,
bool shutdownMode = false,
ThermostatMode thermostatMode = ThermostatMode.Comparator,
AlertPolarity alertPolarity = AlertPolarity.ActiveLow,
ConsecutiveFaults consecutiveFaults = ConsecutiveFaults._1,
float temperatureHigh = TEMP_HIGH_DEFAULT,
float temperatureLow = TEMP_LOW_DEFAULT)
{
// create buffers for one and two bytes for I2C communications
this.regAddress = new byte[REG_ADDRESS_SIZE];
this.regData = new byte[REG_DATA_SIZE];
// configure and create I2C reference device
I2CDevice.Configuration i2cConfig = new I2CDevice.Configuration((ushort)(TMP102_ADDRESS_BASE + a0addrSelect), clockRateKhz);
this.i2c = new I2CDevice(i2cConfig);
// load configuration register
this.LoadConfiguration();
// set conversion rate
this.configuration = (ushort)(this.configuration & ~CONV_RATE_MASK);
this.configuration |= (ushort)conversionRate;
// set shutdown mode
this.configuration = (shutdownMode) ? (ushort)(this.configuration | SHUTDOWN_MODE) : (ushort)(this.configuration & ~SHUTDOWN_MODE);
// set thermostat mode
this.configuration = (thermostatMode == ThermostatMode.Interrupt) ? (ushort)(this.configuration | THERMOSTAT_MODE) : (ushort)(this.configuration & ~THERMOSTAT_MODE);
// set alert pin polarity
this.configuration = (alertPolarity == AlertPolarity.ActiveHigh) ? (ushort)(this.configuration | POLARITY) : (ushort)(this.configuration & ~POLARITY);
// set consecutive faults for alert
this.configuration = (ushort)(this.configuration & ~FAULT_QUEUE_MASK);
this.configuration |= (ushort)consecutiveFaults;
// save configuration register
this.ChangeConfiguration();
// set temperature high for alert
this.regAddress[0] = TEMP_HIGH_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureHigh);
this.WriteRegister(this.regAddress, this.regData);
// set temperature low for alert
this.regAddress[0] = TEMP_LOW_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureLow);
this.WriteRegister(this.regAddress, this.regData);
}
public Thermostat ChangeMode([Service] IClient client, ThermostatMode mode)
{
Items.Room room = client.GetRoom(_id);
room.ControlMode = mode switch
{
ThermostatMode.Off => RoomControlMode.Off,
ThermostatMode.DayTemperature => RoomControlMode.Day,
ThermostatMode.NightTemperature => RoomControlMode.Night,
ThermostatMode.AircoTemperature => RoomControlMode.AircoTemp,
ThermostatMode.AircoContinuous => RoomControlMode.AircoContinu,
ThermostatMode.Curve => RoomControlMode.Auto,
_ => throw new InvalidOperationException($"Unknown mode {mode}"),
};
return(Thermostat.Create(room).WithMode(mode));
}
private Thermostat(
int id,
string name,
decimal currentTemperature,
decimal targetDayTemperature,
decimal targetNightTemperature,
decimal targetAircoTemperature,
ThermostatMode mode,
ThermostatCurveStep[] curve)
{
Id = id;
Name = name;
CurrentTemperature = currentTemperature;
TargetDayTemperature = targetDayTemperature;
TargetNightTemperature = targetNightTemperature;
TargetAircoTemperature = targetAircoTemperature;
Mode = mode;
Curve = curve;
}
public ReadOnlyThermostatCoreState(IEnumerable<ThermostatMode> supportedModes, ThermostatMode? mode, ThermostatCurrentAction? currentAction)
{
SupportedModes = supportedModes;
Mode = mode;
CurrentAction = currentAction;
}
public void SetMode(ThermostatMode mode)
{
//TODO: what happens for unsupported values?
_mode.SetValue(mode);
}
public void SetMode(ThermostatMode mode)
{
_device.DoCommand("SetThermostatMode", "ThermostatMode", mode.ToString());
}
public void ItParsesValuesProperly(string input, ThermostatMode expected)
{
var actual = ThermostatModeParser.Parse(input);
Assert.That(actual, Is.EqualTo(expected));
}
public void SetMode(ThermostatMode mode)
{
_device.DoCommand("SetThermostatMode", "ThermostatMode", mode.ToString());
}
/// <summary>
/// Configures the device.
/// </summary>
/// <param name="OneShot">If tepmerature conversions are made on request.</param>
/// <param name="FaultQueue">Fault queue.</param>
/// <param name="AlertPolarity">Alert polarity.</param>
/// <param name="ThermostatMode">Thermostat mode.</param>
/// <param name="ShutdownMode">Shutdown mode.</param>
/// <param name="ConversionRate">Conversion rate.</param>
/// <param name="ExtendedMode">Extended mode</param>
public void Configure(bool OneShot, FaultQueue FaultQueue, AlertPolarity AlertPolarity, ThermostatMode ThermostatMode, bool ShutdownMode, ConversionRate ConversionRate, bool ExtendedMode)
{
byte H = (byte)(OneShot ? 1 : 0);
H <<= 2;
H |= 3; // Resolution=11
H <<= 2;
H |= (byte)FaultQueue;
H <<= 1;
H |= (byte)AlertPolarity;
H <<= 1;
H |= (byte)ThermostatMode;
H <<= 1;
H |= (byte)(ShutdownMode ? 1 : 0);
byte L = (byte)ConversionRate;
L <<= 2;
L |= (byte)(ExtendedMode ? 1 : 0);
L <<= 4;
if (!this.i2cBus.Write(this.address, 1, H, L))
{
throw new System.IO.IOException("Unable to write register.");
}
}
// -------------------------------------------------------------------------------------------------------------------------------------
private bool Init(
ADD0 addressSelect,
bool oneShotMode,
AlertPolarity alertPolarity,
ConversionRate conversionRate,
ThermostatMode thermostatMode,
ConsecutiveFaults consecutiveFaults,
ushort limitHigh,
ushort limitLow)
{
// Sleep past first conversion
Thread.Sleep(30);
switch (addressSelect)
{
case ADD0.Gnd: _sensorAddress = 0x90 >> 1; break;
case ADD0.Vcc: _sensorAddress = 0x92 >> 1; break;
case ADD0.SDA: _sensorAddress = 0x94 >> 1; break;
case ADD0.SCL: _sensorAddress = 0x96 >> 1; break;
}
_TMP102 = new I2CDevice(new I2CDevice.Configuration(_sensorAddress, 100));
_alertPolarity = alertPolarity;
_oneShotMode = oneShotMode;
_thermostatMode = thermostatMode;
_consecutiveFaults = consecutiveFaults;
_registerNum[0] = (byte)Registers.Configuration;
int bytesTransfered = ReadRegister();
if (bytesTransfered == 3)
{
if (_oneShotMode)
_registerValue[0] = (byte)(_registerValue[0] | 0x01);
else
_registerValue[0] = (byte)(_registerValue[0] & 0xfe);
if (_thermostatMode == ThermostatMode.InterruptMode)
_registerValue[0] = (byte)(_registerValue[0] | 0x02);
else
_registerValue[0] = (byte)(_registerValue[0] & 0xfd);
if (_alertPolarity == AlertPolarity.activeLow)
_registerValue[0] = (byte)(_registerValue[0] | 0x04);
else
_registerValue[0] = (byte)(_registerValue[0] & ~0x04);
switch (conversionRate)
{
case ConversionRate.quarter_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x00 << 6)); break;
case ConversionRate.one_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x01 << 6)); break;
case ConversionRate.four_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x02 << 6)); break;
case ConversionRate.eight_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x03 << 6)); break;
}
bytesTransfered = WriteRegister();
Thread.Sleep(30);
}
return (bytesTransfered == 3);
}
public object InterfaceControl(MigInterfaceCommand request)
{
ResponseText returnValue = new ResponseText("OK");
bool raiseEvent = false;
string eventParameter = ModuleEvents.Status_Level;
string eventValue = "";
string nodeId = request.Address;
Commands command;
Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);
ZWaveNode node = null;
byte nodeNumber = 0;
if (byte.TryParse(nodeId, out nodeNumber))
{
if (nodeNumber > 0)
{
node = controller.GetNode(nodeNumber);
}
switch (command)
{
case Commands.Controller_Discovery:
controller.Discovery();
break;
case Commands.Controller_SoftReset:
controller.SoftReset();
break;
case Commands.Controller_HardReset:
controller.HardReset();
controller.Discovery();
break;
case Commands.Controller_HealNetwork:
controller.HealNetwork();
break;
case Commands.Controller_NodeNeighborUpdate:
controller.RequestNeighborsUpdateOptions(nodeNumber);
controller.RequestNeighborsUpdate(nodeNumber);
controller.GetNeighborsRoutingInfo(nodeNumber);
returnValue = GetResponseValue(nodeNumber, EventPath_RoutingInfo);
break;
case Commands.Controller_NodeRoutingInfo:
controller.GetNeighborsRoutingInfo(nodeNumber);
returnValue = GetResponseValue(nodeNumber, EventPath_RoutingInfo);
break;
case Commands.Controller_NodeAdd:
lastAddedNode = 0;
controller.BeginNodeAdd();
for (int i = 0; i < 20; i++)
{
if (lastAddedNode > 0)
{
break;
}
Thread.Sleep(500);
}
controller.StopNodeAdd();
returnValue = new ResponseText(lastAddedNode.ToString());
break;
case Commands.Controller_NodeRemove:
lastRemovedNode = 0;
controller.BeginNodeRemove();
for (int i = 0; i < 20; i++)
{
if (lastRemovedNode > 0)
{
break;
}
Thread.Sleep(500);
}
controller.StopNodeRemove();
returnValue = new ResponseText(lastRemovedNode.ToString());
break;
case Commands.Basic_Set:
{
raiseEvent = true;
var level = int.Parse(request.GetOption(0));
eventValue = level.ToString(CultureInfo.InvariantCulture);
Basic.Set(node, (byte)level);
}
break;
case Commands.Basic_Get:
Basic.Get(node);
returnValue = GetResponseValue(nodeNumber, EventPath_Basic);
break;
case Commands.SwitchBinary_Set:
{
raiseEvent = true;
var level = int.Parse(request.GetOption(0));
eventValue = level.ToString(CultureInfo.InvariantCulture);
SwitchBinary.Set(node, (byte)level);
}
break;
case Commands.SwitchBinary_Get:
SwitchBinary.Get(node);
returnValue = GetResponseValue(nodeNumber, EventPath_SwitchBinary);
break;
case Commands.SwitchMultilevel_Set:
{
raiseEvent = true;
var level = int.Parse(request.GetOption(0));
eventValue = level.ToString(CultureInfo.InvariantCulture);
SwitchMultilevel.Set(node, (byte)level);
}
break;
case Commands.SwitchMultilevel_Get:
SwitchMultilevel.Get(node);
returnValue = GetResponseValue(nodeNumber, EventPath_SwitchMultilevel);
break;
case Commands.MultiInstance_GetCount:
{
string commandType = request.GetOption(0).Replace(".", "");
switch (commandType)
{
case "SwitchBinary":
MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SwitchBinary);
break;
case "SwitchMultiLevel":
MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SwitchMultilevel);
break;
case "SensorBinary":
MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SensorBinary);
break;
case "SensorMultiLevel":
MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SensorMultilevel);
break;
}
returnValue = GetResponseValue(nodeNumber, EventPath_MultiInstance + "." + commandType + ".Count");
}
break;
case Commands.MultiInstance_Get:
{
byte instance = (byte)int.Parse(request.GetOption(1));
string commandType = request.GetOption(0).Replace(".", "");
switch (commandType)
{
case "SwitchBinary":
MultiInstance.SwitchBinaryGet(node, instance);
break;
case "SwitchMultiLevel":
MultiInstance.SwitchMultiLevelGet(node, instance);
break;
case "SensorBinary":
MultiInstance.SensorBinaryGet(node, instance);
break;
case "SensorMultiLevel":
MultiInstance.SensorMultiLevelGet(node, instance);
break;
}
returnValue = GetResponseValue(nodeNumber, EventPath_MultiInstance + "." + commandType + "." + instance);
}
break;
case Commands.MultiInstance_Set:
{
byte instance = (byte)int.Parse(request.GetOption(1));
int value = int.Parse(request.GetOption(2));
//
//raisepropchanged = true;
//parampath += "." + instance; // Status.Level.<instance>
//
switch (request.GetOption(0))
{
case "Switch.Binary":
MultiInstance.SwitchBinarySet(node, instance, value);
//raiseparam = (double.Parse(request.GetOption(2)) / 255).ToString();
break;
case "Switch.MultiLevel":
MultiInstance.SwitchMultiLevelSet(node, instance, value);
//raiseparam = (double.Parse(request.GetOption(2)) / 100).ToString(); // TODO: should it be 99 ?
break;
}
}
break;
case Commands.SensorBinary_Get:
SensorBinary.Get(node);
break;
case Commands.SensorMultiLevel_Get:
SensorMultilevel.Get(node);
break;
case Commands.Meter_Get:
// see ZWaveLib Sensor.cs for EnergyMeterScale options
int scaleType = 0;
int.TryParse(request.GetOption(0), out scaleType);
Meter.Get(node, (byte)(scaleType << 0x03));
break;
case Commands.Meter_SupportedGet:
Meter.GetSupported(node);
break;
case Commands.Meter_Reset:
Meter.Reset(node);
break;
case Commands.NodeInfo_Get:
controller.GetNodeInformationFrame(nodeNumber);
returnValue = GetResponseValue(nodeNumber, EventPath_NodeInfo);
break;
case Commands.Battery_Get:
Battery.Get(node);
returnValue = GetResponseValue(nodeNumber, EventPath_Battery);
break;
case Commands.Association_Set:
Association.Set(node, (byte)int.Parse(request.GetOption(0)), (byte)int.Parse(request.GetOption(1)));
break;
case Commands.Association_Get:
byte group = (byte)int.Parse(request.GetOption(0));
Association.Get(node, group);
returnValue = GetResponseValue(nodeNumber, EventPath_Associations + "." + group);
break;
case Commands.Association_Remove:
Association.Remove(node, (byte)int.Parse(request.GetOption(0)), (byte)int.Parse(request.GetOption(1)));
break;
case Commands.ManufacturerSpecific_Get:
ManufacturerSpecific.Get(node);
returnValue = GetResponseValue(nodeNumber, EventPath_ManufacturerSpecific);
break;
case Commands.Config_ParameterSet:
Configuration.Set(node, (byte)int.Parse(request.GetOption(0)), int.Parse(request.GetOption(1)));
break;
case Commands.Config_ParameterGet:
byte position = (byte)int.Parse(request.GetOption(0));
Configuration.Get(node, position);
returnValue = GetResponseValue(nodeNumber, EventPath_ConfigVariables + "." + position);
break;
case Commands.WakeUp_Get:
WakeUp.Get(node);
returnValue = GetResponseValue(nodeNumber, EventPath_WakeUpInterval);
break;
case Commands.WakeUp_Set:
WakeUp.Set(node, uint.Parse(request.GetOption(0)));
break;
case Commands.WakeUp_SendToSleep:
WakeUp.SendToSleep(node);
break;
case Commands.WakeUp_GetAlwaysAwake:
returnValue = new ResponseText(WakeUp.GetAlwaysAwake(node) ? "1" : "0");
break;
case Commands.WakeUp_SetAlwaysAwake:
WakeUp.SetAlwaysAwake(node, uint.Parse(request.GetOption(0)) == 1 ? true : false);
break;
case Commands.Version_Get:
returnValue = new ResponseText("ERROR");
CommandClass cclass;
Enum.TryParse <CommandClass>(request.GetOption(0), out cclass);
if (cclass != CommandClass.NotSet)
{
var nodeCclass = node.GetCommandClass(cclass);
if (nodeCclass != null && nodeCclass.Version != 0)
{
returnValue = new ResponseText(nodeCclass.Version.ToString());
}
else
{
ZWaveLib.CommandClasses.Version.Get(node, cclass);
returnValue = GetResponseValue(nodeNumber, "ZWaveNode.Version." + cclass);
}
}
break;
case Commands.Version_GetAll:
controller.GetNodeCcsVersion(node);
break;
case Commands.Control_On:
raiseEvent = true;
double lastLevel = GetNormalizedValue((double)GetNodeLastLevel(node));
eventValue = lastLevel > 0 ? lastLevel.ToString(CultureInfo.InvariantCulture) : "1";
if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
{
SwitchMultilevel.Set(node, 0xFF);
}
else if (node.SupportCommandClass(CommandClass.SwitchBinary))
{
SwitchBinary.Set(node, 0xFF);
}
else
{
Basic.Set(node, 0xFF);
}
SetNodeLevel(node, 0xFF);
break;
case Commands.Control_Off:
raiseEvent = true;
eventValue = "0";
if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
{
SwitchMultilevel.Set(node, 0x00);
}
else if (node.SupportCommandClass(CommandClass.SwitchBinary))
{
SwitchBinary.Set(node, 0x00);
}
else
{
Basic.Set(node, 0x00);
}
SetNodeLevel(node, 0x00);
break;
case Commands.Control_Level:
{
raiseEvent = true;
var level = int.Parse(request.GetOption(0));
eventValue = Math.Round(level / 100D, 2).ToString(CultureInfo.InvariantCulture);
// the max value should be obtained from node parameters specifications,
// here we assume that the commonly used interval is [0-99] for most multilevel switches
if (level >= 100)
{
level = 99;
}
if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
{
SwitchMultilevel.Set(node, (byte)level);
}
else
{
Basic.Set(node, (byte)level);
}
SetNodeLevel(node, (byte)level);
}
break;
case Commands.Control_Toggle:
raiseEvent = true;
if (GetNodeLevel(node) == 0)
{
double lastOnLevel = GetNormalizedValue((double)GetNodeLastLevel(node));
eventValue = lastOnLevel > 0 ? lastOnLevel.ToString(CultureInfo.InvariantCulture) : "1";
if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
{
SwitchMultilevel.Set(node, 0xFF);
}
else if (node.SupportCommandClass(CommandClass.SwitchBinary))
{
SwitchBinary.Set(node, 0xFF);
}
else
{
Basic.Set(node, 0xFF);
}
SetNodeLevel(node, 0xFF);
}
else
{
eventValue = "0";
if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
{
SwitchMultilevel.Set(node, 0x00);
}
else if (node.SupportCommandClass(CommandClass.SwitchBinary))
{
SwitchBinary.Set(node, 0x00);
}
else
{
Basic.Set(node, 0x00);
}
SetNodeLevel(node, 0x00);
}
break;
case Commands.Thermostat_ModeGet:
ThermostatMode.Get(node);
break;
case Commands.Thermostat_ModeSet:
{
ThermostatMode.Value mode = (ThermostatMode.Value)Enum.Parse(typeof(ThermostatMode.Value), request.GetOption(0));
//
raiseEvent = true;
eventParameter = "Thermostat.Mode";
eventValue = request.GetOption(0);
//
ThermostatMode.Set(node, mode);
}
break;
case Commands.Thermostat_SetPointGet:
{
ThermostatSetPoint.Value mode = (ThermostatSetPoint.Value)Enum.Parse(typeof(ThermostatSetPoint.Value), request.GetOption(0));
ThermostatSetPoint.Get(node, mode);
}
break;
case Commands.Thermostat_SetPointSet:
{
ThermostatSetPoint.Value mode = (ThermostatSetPoint.Value)Enum.Parse(typeof(ThermostatSetPoint.Value), request.GetOption(0));
double temperature = double.Parse(request.GetOption(1).Replace(',', '.'), CultureInfo.InvariantCulture);
//
raiseEvent = true;
eventParameter = "Thermostat.SetPoint." + request.GetOption(0);
eventValue = temperature.ToString(CultureInfo.InvariantCulture);
//
ThermostatSetPoint.Set(node, mode, temperature);
}
break;
case Commands.Thermostat_FanModeGet:
ThermostatFanMode.Get(node);
break;
case Commands.Thermostat_FanModeSet:
{
ThermostatFanMode.Value mode = (ThermostatFanMode.Value)Enum.Parse(typeof(ThermostatFanMode.Value), request.GetOption(0));
//
raiseEvent = true;
eventParameter = "Thermostat.FanMode";
eventValue = request.GetOption(0);
//
ThermostatFanMode.Set(node, mode);
}
break;
case Commands.Thermostat_FanStateGet:
ThermostatFanState.Get(node);
break;
case Commands.Thermostat_OperatingStateGet:
ThermostatOperatingState.GetOperatingState(node);
break;
case Commands.UserCode_Set:
byte userId = byte.Parse(request.GetOption(0));
byte userIdStatus = byte.Parse(request.GetOption(1));
byte[] tagCode = ZWaveLib.Utility.HexStringToByteArray(request.GetOption(2));
UserCode.Set(node, new ZWaveLib.Values.UserCodeValue(userId, userIdStatus, tagCode));
break;
case Commands.DoorLock_Get:
DoorLock.Get(node);
returnValue = GetResponseValue(nodeNumber, ModuleEvents.Status_DoorLock);
break;
case Commands.DoorLock_Set:
{
DoorLock.Value mode = (DoorLock.Value)Enum.Parse(typeof(DoorLock.Value), request.GetOption(0));
DoorLock.Set(node, mode);
}
break;
}
}
if (raiseEvent)
{
//ZWaveNode node = _controller.GetDevice ((byte)int.Parse (nodeid));
OnInterfacePropertyChanged(this.GetDomain(), nodeId, "ZWave Node", eventParameter, eventValue);
}
//
return(returnValue);
}
public void SetMode(ThermostatMode mode)
{
var controlThinkMode = mode.ToControlThinkType().Value;
_device.DoDeviceOperation(() => _thermostat.ThermostatMode = controlThinkMode);
}
public void SetMode(ThermostatMode mode)
{
var controlThinkMode = mode.ToControlThinkType().Value;
_device.DoDeviceOperation(() => _thermostat.ThermostatMode = controlThinkMode);
}
/// <summary>
/// Configures the device.
/// </summary>
/// <param name="OneShot">If tepmerature conversions are made on request.</param>
/// <param name="FaultQueue">Fault queue.</param>
/// <param name="AlertPolarity">Alert polarity.</param>
/// <param name="ThermostatMode">Thermostat mode.</param>
/// <param name="ShutdownMode">Shutdown mode.</param>
/// <param name="ConversionRate">Conversion rate.</param>
/// <param name="ExtendedMode">Extended mode</param>
public void Configure (bool OneShot, FaultQueue FaultQueue, AlertPolarity AlertPolarity, ThermostatMode ThermostatMode, bool ShutdownMode, ConversionRate ConversionRate, bool ExtendedMode)
{
byte H = (byte)(OneShot ? 1 : 0);
H <<= 2;
H |= 3; // Resolution=11
H <<= 2;
H |= (byte)FaultQueue;
H <<= 1;
H |= (byte)AlertPolarity;
H <<= 1;
H |= (byte)ThermostatMode;
H <<= 1;
H |= (byte)(ShutdownMode ? 1 : 0);
byte L = (byte)ConversionRate;
L <<= 2;
L |= (byte)(ExtendedMode ? 1 : 0);
L <<= 4;
if (!this.i2cBus.Write (this.address, 1, H, L))
throw new System.IO.IOException ("Unable to write register.");
}
public void SetMode(ThermostatMode mode)
{
//TODO: what happens for unsupported values?
_mode.SetValue(mode);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="a0addrSelect">A0 pin connection for address selection</param>
/// <param name="clockRateKhz">I2C clock rate in KHz</param>
/// <param name="conversionRate">Conversion rate</param>
/// <param name="shutdownMode">Shutdown mode</param>
/// <param name="thermostatMode">Thermostat mode</param>
/// <param name="alertPolarity">Polarity of the alert pin</param>
/// <param name="consecutiveFaults">Consecutive faults before activate alert pin</param>
/// <param name="temperatureHigh">Temperature High for alert</param>
/// <param name="temperatureLow">Temperature Low for alert</param>
public TMP102(A0AddressSelect a0addrSelect = A0AddressSelect.GND,
int clockRateKhz = CLOCK_RATE_KHZ_DEFAULT,
ConversionRate conversionRate = ConversionRate._4Hz,
bool shutdownMode = false,
ThermostatMode thermostatMode = ThermostatMode.Comparator,
AlertPolarity alertPolarity = AlertPolarity.ActiveLow,
ConsecutiveFaults consecutiveFaults = ConsecutiveFaults._1,
float temperatureHigh = TEMP_HIGH_DEFAULT,
float temperatureLow = TEMP_LOW_DEFAULT)
{
// create buffers for one and two bytes for I2C communications
this.regAddress = new byte[REG_ADDRESS_SIZE];
this.regData = new byte[REG_DATA_SIZE];
// configure and create I2C reference device
I2CDevice.Configuration i2cConfig = new I2CDevice.Configuration((ushort)(TMP102_ADDRESS_BASE + a0addrSelect), clockRateKhz);
this.i2c = new I2CDevice(i2cConfig);
// load configuration register
this.LoadConfiguration();
// set conversion rate
this.configuration = (ushort)(this.configuration & ~CONV_RATE_MASK);
this.configuration |= (ushort)conversionRate;
// set shutdown mode
this.configuration = (shutdownMode) ? (ushort)(this.configuration | SHUTDOWN_MODE) : (ushort)(this.configuration & ~SHUTDOWN_MODE);
// set thermostat mode
this.configuration = (thermostatMode == ThermostatMode.Interrupt) ? (ushort)(this.configuration | THERMOSTAT_MODE) : (ushort)(this.configuration & ~THERMOSTAT_MODE);
// set alert pin polarity
this.configuration = (alertPolarity == AlertPolarity.ActiveHigh) ? (ushort)(this.configuration | POLARITY) : (ushort)(this.configuration & ~POLARITY);
// set consecutive faults for alert
this.configuration = (ushort)(this.configuration & ~FAULT_QUEUE_MASK);
this.configuration |= (ushort)consecutiveFaults;
// save configuration register
this.ChangeConfiguration();
// set temperature high for alert
this.regAddress[0] = TEMP_HIGH_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureHigh);
this.WriteRegister(this.regAddress, this.regData);
// set temperature low for alert
this.regAddress[0] = TEMP_LOW_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureLow);
this.WriteRegister(this.regAddress, this.regData);
}
public bool Init(
ADD0 addressSelect = ADD0.Gnd,
bool oneShotMode = false,
AlertPolarity alertPolarity = AlertPolarity.activeHigh,
ConversionRate conversionRate = ConversionRate.four_Hz,
ThermostatMode thermostatMode = ThermostatMode.ComparatorMode)
{
return Init(addressSelect, oneShotMode, alertPolarity, conversionRate, thermostatMode, ConsecutiveFaults.one, 0, 0);
}
private void pushButtonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
{
if (args.Edge == GpioPinEdge.FallingEdge)
{
if (thermostatStatus == ThermostatStatus.Running)
{
thermostatStatus = ThermostatStatus.Off;
Debug.WriteLine("Thermostat status changed from Running to Off.");
}
switch (thermostatMode)
{
case ThermostatMode.Off:
thermostatMode = ThermostatMode.Cool;
rgbLedStatus = RgbLedStatus.Blue;
SetRgbLedStatus(RgbLedStatus.Blue);
ReadADC();
UpdateThermostat();
Debug.WriteLine("Thermostat mode changed from Off to Cool.");
break;
case ThermostatMode.Cool:
thermostatMode = ThermostatMode.Heat;
rgbLedStatus = RgbLedStatus.Red;
SetRgbLedStatus(RgbLedStatus.Red);
ReadADC();
UpdateThermostat();
Debug.WriteLine("Thermostat mode changed from Cool to Heat.");
break;
case ThermostatMode.Heat:
thermostatMode = ThermostatMode.Off;
rgbLedStatus = RgbLedStatus.Off;
SetRgbLedStatus(RgbLedStatus.Off);
Debug.WriteLine("Thermostat mode changed from Heat to Off.");
break;
}
}
}
