/// <summary>
/// Updates the sensors used in ZipatoSensors.
/// </summary>
public void Update()
{
for (int i = 0; i < VirtualMeters.Count; ++i)
{
var uuid = VirtualMeters[i].Uuid;
VirtualMeters[i] = new VirtualMeter(_zipato, uuid);
}
for (int i = 0; i < ConsumptionMeters.Count; ++i)
{
var uuid = ConsumptionMeters[i].Uuid;
ConsumptionMeters[i] = new ConsumptionMeter(_zipato, uuid);
}
for (int i = 0; i < TemperatureSensors.Count; ++i)
{
var uuid = TemperatureSensors[i].Uuid;
TemperatureSensors[i] = new TemperatureSensor(_zipato, uuid);
}
for (int i = 0; i < HumiditySensors.Count; ++i)
{
var uuid = HumiditySensors[i].Uuid;
HumiditySensors[i] = new HumiditySensor(_zipato, uuid);
}
for (int i = 0; i < LuminanceSensors.Count; ++i)
{
var uuid = LuminanceSensors[i].Uuid;
LuminanceSensors[i] = new LuminanceSensor(_zipato, uuid);
}
Status = _zipato?.Data?.Status ?? Uncertain;
}
private void Submit(object param)
{
Sensor sensor;
switch (SelectedItem)
{
case "Temperature":
sensor = new TemperatureSensor(Name, Url, Description, Latitude, Longitude, Tracking, MinValue, MaxValue);
break;
case "Humidity":
sensor = new HumiditySensor(Name, Url, Description, Latitude, Longitude, Tracking, MinValue, MaxValue);
break;
case "Electricity Consumption":
sensor = new PowerConsumptionSensor(Name, Url, Description, Latitude, Longitude, Tracking, MinValue, MaxValue);
break;
case "Noise":
sensor = new TemperatureSensor(Name, Url, Description, Latitude, Longitude, Tracking, MinValue, MaxValue);
break;
case "Window/Door":
sensor = new WindowDoorSensor(Name, Url, Description, Latitude, Longitude, Tracking, Opened);
break;
default:
sensor = null;
break;
}
sensors.List.Add(sensor);
UpdateXml(sensors);
}
public TempGaugeCtrl(TemperatureSensor sensor)
{
InitializeComponent();
ToolTip = sensor.Name;
lbl_Name.Content = sensor.Name;
this.sensor = sensor;
try
{
model = HttpService.SensorList.First(item => item.Tag == sensor.Link);
timer = new DispatcherTimer
{
Interval = TimeSpan.FromSeconds(model.MinPollingIntervalInSeconds)
};
timer.Tick += Timer_Tick;
timer.Start();
FirstTick();
}
catch
{
unit.Foreground = new SolidColorBrush(Colors.LightGray);
stateIndicator.Fill = new SolidColorBrush(Colors.LightGray);
}
}
public Sensor ToSensor(int id)
{
Sensor sensor = null;
switch (Type.ToUpper())
{
case "ZLLTEMPERATURE":
sensor = new TemperatureSensor
{
Id = id,
Name = Name,
Type = SensorType.Temperature,
BatteryPercentage = Config.Battery,
State = new TemperatureSensorState
{
Temperature = State.Temperature / 100f
}
};
break;
default:
sensor = new DummySensor()
{
Id = id,
Name = Name,
Type = SensorType.Dummy,
BatteryPercentage = Config.Battery
};
break;
}
return(sensor);
}
public async Task GetTemperatureSensor_Found()
{
var hueSensorProvider = Substitute.For <IHueSensorProvider>();
TemperatureSensor sensor = new TemperatureSensor
{
Id = 6,
Name = "Sensor6",
Type = SensorType.Temperature,
BatteryPercentage = 51,
State = new TemperatureSensorState
{
Temperature = 24.57f
}
};
hueSensorProvider.GetTemperatureSensorByIdAsync(6).Returns(Task.FromResult(sensor));
var controller = new MeasurementController(hueSensorProvider);
var result = await controller.GetTemperatureSensor(6);
var okResult = Assert.IsType <OkObjectResult>(result.Result);
var sensorResult = Assert.IsType <TemperatureSensor>(okResult.Value);
Assert.Equal(sensor, sensorResult);
}
/// <summary>
/// Event handler for the user clicking the 'Unregister' button.
/// </summary>
/// <param name="sender">Instance of object raising event.</param>
/// <param name="e">Generic event args.</param>
private void buttonUnregister_Click(object sender, EventArgs e)
{
TemperatureSensor selectedTemperatureSensor = GetSelectedTemperatureSensor();
//We need both an email and a sensor to perform an unregistration.
if (string.IsNullOrEmpty(comboBoxRegisteredEmails.SelectedItem as string) == false && selectedTemperatureSensor != null)
{
//Unregister the alarm.
string emailAddress = comboBoxRegisteredEmails.SelectedItem as string;
AsyncHelper.RunSync(() => { return(m_temperatureAlarm.Unregister(selectedTemperatureSensor, emailAddress)); });
//Reload the UI components.
Reload();
//Inform the end-user.
MessageBox.Show("Temperature Alarm Successfully Unregistered",
"Success",
MessageBoxButtons.OK);
}
else
{
MessageBox.Show("Please select both the Temperature Sensor and Email Address to unregister from.",
"Warning",
MessageBoxButtons.OK);
}
}
/// <summary>
/// Worker method to reload all Temperature Alarmt data.
/// </summary>
private void LoadData(bool addEmailAddresses)
{
//Query the current state of all Temperature Alarms.
m_temperatureAlarm = AsyncHelper.RunSync(() => { return(TemperatureAlarm.QueryCurrentTemperatureAlarms()); });
//Erase ComboBox listings and other components.
comboBoxRegisteredEmails.Items.Clear();
textBoxTemperatureMin.Text = string.Empty;
textBoxTemperatureMax.Text = string.Empty;
//Configure the ComboxBox now.
try
{
if (addEmailAddresses == true)
{
List <Tuple <string, Single, Single> > registeredAlarms = null;
TemperatureSensor selectedTemperatureSensor = GetSelectedTemperatureSensor();
if (m_temperatureAlarm.TryGetRegistrationInfo(selectedTemperatureSensor, out registeredAlarms) == true)
{
Debug.Assert(registeredAlarms != null);
var emails = registeredAlarms.Select(obj => obj.Item1).Distinct();
foreach (var email in emails)
{
comboBoxRegisteredEmails.Items.Add(email);
}
}
}
}
catch { Debug.Assert(false); }
}
/// <summary>
/// Initializes a new instance of the <c>TPA81</c> class.
/// </summary>
public TPA81()
{
for (int i = 0; i < temps.Length; ++i)
{
temps[i] = new TemperatureSensor(this);
}
}
public override void Execute()
{
var temperatureSensor = new TemperatureSensor();
var heater = new Heater(temperatureSensor, maxHeatingTemperature: 18); // 64° F
var airConditioner = new AirConditioner(temperatureSensor, minCoolingTemperature: 21); // 70° F
temperatureSensor.Temperature = 17; // 62° F
Assert.True(heater.IsHeating);
Assert.False(airConditioner.IsCooling);
temperatureSensor.Temperature = 20; // 68° F
Assert.False(heater.IsHeating);
Assert.False(airConditioner.IsCooling);
temperatureSensor.Temperature = 22; // 72° F
Assert.False(heater.IsHeating);
Assert.True(airConditioner.IsCooling);
temperatureSensor.RemoveListener(heater);
temperatureSensor.Temperature = 17; // 62° F
Assert.False(heater.IsHeating);
Assert.False(airConditioner.IsCooling);
// heater is no longer subscribed, so it wasn't notified of the temperature changes.
}
public async Task SimulateTemperatureEvents()
{
deviceId = "1";
RegisterDeviceAsync().Wait();
bool deviceActivated = await ActivateDeviceAsync();
if (deviceActivated)
{
InitDeviceClient();
stopWatch.Restart();
numEventsSent = 0;
LogStatus("Sending Temperature Events...");
SensorBase sensor = new TemperatureSensor(deviceId, TransmitEvent);
sensor.InitSchedule(10);
Console.WriteLine("Generated {0:###,###,###} Events", sensor.CountOfDataPoints);
sensor.Start().Wait();
FlushIoTHubBuffer();
stopWatch.Stop();
Console.WriteLine("Completed transmission in {0} seconds. Sent {1:###,###,###} events.",
stopWatch.Elapsed.TotalSeconds, numEventsSent);
}
else
{
LogError("Device Not Activated.");
}
}
public async Task <IActionResult> PutTemperatureSensor(int id, TemperatureSensor temperatureSensor)
{
if (id != temperatureSensor.Id)
{
return(BadRequest());
}
_context.Entry(temperatureSensor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TemperatureSensorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void TestPostNewSensor()
{
var optionsBuilder = new DbContextOptionsBuilder <Context>();
optionsBuilder.UseInMemoryDatabase(Guid.NewGuid().ToString());
Context context = new Context(optionsBuilder.Options);
var Entity = new TemperatureSensor()
{
TemperatureSensorId = 1,
DeviceName = "Device-abcde",
DeviceModel = "Model1B",
IsOnline = true,
LocationName = "Groningen"
};
context.TemperatureSensor.Add(Entity);
context.SaveChangesAsync();
IDataRepository <TemperatureSensor> repository = new TemperatureSensorManager(context);
repository.AddAsync(Entity);
Assert.AreEqual(1, context.TemperatureSensor.Count());
}
//TemperatureSensor Detach event handler....Clear the fields and disable the modify sensitivity textbox so that
//new sensity value can't be sent while there is no device attached, otherwise this would generate a PhidgetException
void tempSensor_Detach(object sender, DetachEventArgs e)
{
TemperatureSensor temperatureSensor = (TemperatureSensor)sender;
attachedTxt.Text = temperatureSensor.Attached.ToString();
nameTxt.Text = "";
serialTxt.Text = "";
versionTxt.Text = "";
numThermoTxt.Text = "";
thermoTempTxt.Text = "";
thermoPotTxt.Text = "";
onboardTempTxt.Text = "";
SensitivityTrk.Enabled = false;
SensitivityTrk.Value = 0;
sensitivityTxt.Clear();
thermoRange.Text = "";
potentialRange.Text = "";
ambientRange.Text = "";
thermoTypeComboBox.Enabled = false;
thermoCmb.Enabled = false;
thermoCmb.Items.Clear();
}
public MySoilTemperatureSensor(int hubPort, string type, string hubName, double minThreshold, double maxThreshold, bool wireless) : base(hubPort, type, hubName, minThreshold, maxThreshold, wireless)
{
device = new TemperatureSensor();
device.HubPort = hubPort;
device.IsHubPortDevice = false;
device.TemperatureChange += Device_TemperatureChange;;
}
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 async Task <IActionResult> GetSecondaryDataAsync()
{
var temperatureSensor = new TemperatureSensor(_temperatureStorage);
var pressureSensor = new PressureSensor(_pressureStorage);
var humiditySensor = new HumiditySensor(_humidityStorage);
var windDirectionSensor = new WindDirectionSensor(_windStorage);
var windSpeedSensor = new WindSpeedSensor(_windStorage);
var windChill = new WindChill(temperatureSensor, windSpeedSensor);
var dewPoint = new DewPoint(temperatureSensor, humiditySensor);
var timeSpan = new TimeSpan(3, 0, 0);
var result = new SecondaryDataDTO()
{
WindChill = (int)windChill.CalculateWindChill(),
DewPoint = (int)dewPoint.CalculateDewPoint(),
MaximalTemperature = (int)temperatureSensor.HighValue().Value,
MinimalTemperature = (int)temperatureSensor.LowValue().Value,
MaximalHumidity = (int)humiditySensor.HighValue().Value,
MinimalHumidity = (int)humiditySensor.LowValue().Value,
MinimalPressure = (int)pressureSensor.LowValue().Value,
MaximalPressure = (int)pressureSensor.HighValue().Value,
MinimalTemperatureTime = temperatureSensor.TimeOfLowValue().TimeOfDay.Add(timeSpan).ToString().Substring(0, 5),
MaximalTemperatureTime = temperatureSensor.TimeOfHighValue().TimeOfDay.Add(timeSpan).ToString().Substring(0, 5),
MinimalHumidityTime = humiditySensor.TimeOfLowValue().TimeOfDay.Add(timeSpan).ToString().Substring(0, 5),
MaximalHumidityTime = humiditySensor.TimeOfHighValue().TimeOfDay.Add(timeSpan).ToString().Substring(0, 5),
MinimalPressureTime = pressureSensor.TimeOfLowValue().TimeOfDay.Add(timeSpan).ToString().Substring(0, 5),
MaximalPressureTime = pressureSensor.TimeOfHighValue().TimeOfDay.Add(timeSpan).ToString().Substring(0, 5),
};
return(Ok(result));
}
public async Task <ActionResult <TemperatureSensor> > PostTemperatureSensor(TemperatureSensor temperatureSensor)
{
_context.TemperatureSensor.Add(temperatureSensor);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTemperatureSensor", new { id = temperatureSensor.Id }, temperatureSensor));
}
public async Task RunDeviceAsync()
{
deviceClient = DeviceClient.CreateFromConnectionString(connectionString,
TransportType.Mqtt, new ClientOptions {
ModelId = modelId
});
tempSensor = new TemperatureSensor(deviceClient, "tempSensor1", logger);
diag = new DiagnosticsInterface(deviceClient, "diag");
deviceInfo = new DeviceInformation(deviceClient, "deviceInfo");
sdkInfo = new SdkInformation(deviceClient, "sdkInfo");
await deviceInfo.ReportDeviceInfoPropertiesAsync(DeviceInfo.ThisDeviceInfo);
await sdkInfo.ReportSdkInfoPropertiesAsync();
diag.OnRebootCommand += Diag_OnRebootCommand;
tempSensor.OnTargetTempReceived += TempSensor_OnTargetTempReceived;
await tempSensor.InitAsync();
await Task.Run(async() =>
{
logger.LogWarning("Entering Device Loop");
while (!quitSignal.IsCancellationRequested)
{
await tempSensor.SendTemperatureTelemetryValueAsync(CurrentTemperature);
await diag.SendWorkingTelemetryAsync(Environment.WorkingSet);
logger.LogInformation("Sending workingset and temp " + CurrentTemperature);
await Task.Delay(5000);
}
});
}
public TemperaturePage()
{
Model = new TemperatureModel
{
IsSupported = TemperatureSensor.IsSupported,
SensorCount = TemperatureSensor.Count
};
InitializeComponent();
if (Model.IsSupported)
{
Temperature = new TemperatureSensor();
Temperature.DataUpdated += Temperature_DataUpdated;
canvas.ChartScale = 200;
canvas.Series = new List <Series>()
{
new Series()
{
Color = SKColors.Red,
Name = "Temperature",
FormattedText = "Temperature={0}°",
},
};
}
}
public IObservable <double> WhenReadingTaken()
{
this.observable = this.observable ?? Observable.Create <double>(ob =>
{
var handler = new EventHandler <TemperatureSensorDataUpdatedEventArgs>((sender, args) =>
ob.OnNext(args.Temperature)
);
var sensor = new TemperatureSensor
{
Interval = 250
};
sensor.DataUpdated += handler;
sensor.Start();
return(() =>
{
sensor.Stop();
sensor.DataUpdated -= handler;
sensor.Dispose();
});
})
.Publish()
.RefCount();
return(this.observable);
}
public object AddSensor(HttpRequestParams request)
{
var displayName = request.GetRequiredString("displayName");
var channel = request.GetRequiredInt32("channel");
var showHumidity = request.GetRequiredBool("showHumidity");
Logger.Debug("add sensor: channel={0}; displayName={1}; showHumidity={2}", channel, displayName, showHumidity);
using (var session = Context.OpenSession())
{
var sensor = new TemperatureSensor
{
Id = Guid.NewGuid(),
Channel = channel,
DisplayName = displayName,
ShowHumidity = showHumidity,
Timestamp = DateTime.Now
};
session.Save(sensor);
session.Flush();
return(sensor.Id);
}
}
public async Task <IActionResult> Edit(string id, [Bind("Address,Name")] TemperatureSensor temperatureSensor)
{
if (id != temperatureSensor.Address)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var sensor = await _context.Sensors.SingleOrDefaultAsync(x => x.Address == id);
if (sensor != null)
{
sensor.Name = temperatureSensor.Name;
await _context.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException)
{
if (!TemperatureSensorExists(temperatureSensor.Address))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index), "Settings"));
}
return(View(temperatureSensor));
}
public int AddTemperatureSensorHistory(TemperatureSensor sensor)
{
if (sensor == null)
{
throw new Exception("Sensore object cannot be null");
}
sensorHistory = new SensorHistory
{
HouseId = sensor.HouseId,
SensorId = sensor.SensorId,
Type = sensor.Type,
Name = sensor.Name,
Temperature = sensor.Temperature,
IsOn = sensor.IsOn
};
try
{
_databaseContext.SensorHistories.Add(sensorHistory);
_databaseContext.SaveChanges();
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
return(sensorHistory.SensorHistoryId);
}
public static void Initialize(SensorContext context)
{
context.Database.EnsureCreated();
if (context.TemperatureSensor.Any())
{
return; // DB has already been seeded
}
var temperature = new TemperatureSensor[] {
new TemperatureSensor {
Id = 1, Value = 19.21, ReadDate = DateTime.Parse("2005-09-01 12:10")
},
new TemperatureSensor {
Id = 2, Value = 20.27, ReadDate = DateTime.Parse("2005-09-01 12:20")
},
new TemperatureSensor {
Id = 3, Value = 21.12, ReadDate = DateTime.Parse("2005-09-01 12:30")
},
new TemperatureSensor {
Id = 4, Value = 21.05, ReadDate = DateTime.Parse("2005-09-01 12:40")
},
new TemperatureSensor {
Id = 5, Value = 21.02, ReadDate = DateTime.Parse("2005-09-01 12:50")
}
};
foreach (TemperatureSensor t in temperature)
{
context.TemperatureSensor.Add(t);
}
context.SaveChanges();
}
public void ConfirmTemperatureUpdate()
{
var probe = CreateTestProbe();
var sensor = Sys.ActorOf(TemperatureSensor.Props("a", "1"));
sensor.Tell(new RequestUpdateTemperature(42, 100), probe.Ref);
probe.ExpectMsg <RespondTemperatureUpdated>(m => Assert.Equal(42, m.RequestId));
}
IPhidgetViewModel CreateThermoPhidgetViewModelViewModel(TemperatureSensor phidget)
{
if (phidget.ChannelName == "Thermocouple Input")
{
return(new ThermocoupleInputViewModel(phidget));
}
return(new TemperatureSensorViewModel(phidget));
}
static void Main(string[] args)
{
TemperatureSensor monitor = new TemperatureSensor();
TemperatureReporter reporter = new TemperatureReporter();
reporter.StartReporting(monitor);
monitor.GetTemperature();
}
IPhidgetViewModel CreateViewModel(TemperatureSensor phidget)
{
try {
var type = phidget.ThermocoupleType;
return(new FourTimesThermocouplePhidgetViewModel(phidget));
} catch { }
return(CreateThermoPhidgetViewModelViewModel(phidget));
}
static void Main(string[] args)
{
TemperatureSensor sensor = new TemperatureSensor();
TemperatureReporter reporter = new TemperatureReporter();
reporter.StartReporting(sensor);
sensor.Notify();
}
public async Task <ActionResult <TemperatureSensor> > PostTemperatureSensor(TemperatureSensor temperatureSensor)
{
System.Diagnostics.Debug.Print("POST request: id=" + temperatureSensor.Id + ", value=" + temperatureSensor.Value);
_context.TemperatureSensor.Add(temperatureSensor);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTemperatureSensor", new { id = temperatureSensor.Id }, temperatureSensor));
}
public Form1()
{
InitializeComponent();
list1 = new PointPairList();
list2 = new PointPairList();
therm = new TemperatureSensor();
start = new DateTime();
}
public static IoTKitHoLSensor GetCurrent(TemperatureSensor sensorKind)
{
if(currentSensor== null)
{
currentSensor = new IoTKitHoLSensor(sensorKind);
currentSensor.Initialize();
}
return currentSensor;
}
//Initialize our temperatureSensor object and hook the event handlers
private void Form1_Load(object sender, EventArgs e)
{
phidgetTemperature = new TemperatureSensor();
//Hook the event handlers to the object
phidgetTemperature.Attach += new AttachEventHandler(tempSensor_Attach);
phidgetTemperature.Detach += new DetachEventHandler(tempSensor_Detach);
phidgetTemperature.Error += new ErrorEventHandler(tempSensor_Error);
phidgetTemperature.TemperatureChange += new TemperatureChangeEventHandler(tempSensor_TemperatureChange);
openCmdLine(phidgetTemperature);
}
static void Main(string[] args)
{
try
{
//Declare a TemperatureSensor object
TemperatureSensor tempSensor = new TemperatureSensor();
//hook the basic event handlers
tempSensor.Attach += new AttachEventHandler(tempSensor_Attach);
tempSensor.Detach += new DetachEventHandler(tempSensor_Detach);
tempSensor.Error += new ErrorEventHandler(tempSensor_Error);
//hook the phidget specific event handlers
tempSensor.TemperatureChange += new TemperatureChangeEventHandler
(tempSensor_TemperatureChange);
//open the phidget object to allow connections with phidget temperature
//sensor devices
tempSensor.open();
//Make the program wait for a Phidget TemperatureSensor to be attached
//before trying to communicate with one. If we try and call the methods
//of the tempSensor object without a TemperatureSensor device attached,
//a PhidgetException
//will be thrown
Console.WriteLine("Waiting for TemperatureSensor to be attached....");
tempSensor.waitForAttachment();
//Get the program to wait for user input to continue so that we can see
//some events fire and console output to be displayed
Console.WriteLine("Hit any key to end the program....");
Console.Read();
//Since user input was read, we'll terminate the program, so close the
//tempSensor object
tempSensor.close();
//null he object to clear it from memory
tempSensor = null;
//If no exceptions were thrown at this point, the program is ok to
//terminate
Console.WriteLine("ok");
}
catch (PhidgetException ex)
{
Console.WriteLine(ex.Description);
}
}
private void Form1_Load(object sender, EventArgs e)
{
startBtn.Enabled = false;
list1 = new PointPairList();
list2 = new PointPairList();
list3 = new PointPairList();
list4 = new PointPairList();
list5 = new PointPairList();
start = new DateTime();
oStream = new FileStream(Environment.CurrentDirectory + "\\ThermoData.csv", FileMode.Create, FileAccess.Write);
writer = new StreamWriter(oStream);
for (int i = 0; i < 5; i++)
{
sensors[i] = new TemperatureSensor();
}
try
{
//NewK = 1010101
sensors[0].open(1010101);
sensors[0].waitForAttachment();
sensors[0].thermocouples[0].Sensitivity = 0.0;
sensors[0].thermocouples[0].Type = TemperatureSensorSensor.ThermocoupleType.PHIDGET_TEMPERATURE_SENSOR_K_TYPE;
//oldK = 33112
sensors[1].open(33112);
sensors[1].waitForAttachment();
sensors[1].thermocouples[0].Type = TemperatureSensorSensor.ThermocoupleType.PHIDGET_TEMPERATURE_SENSOR_K_TYPE;
//oldT = 33038
sensors[2].open(33038);
sensors[2].waitForAttachment();
sensors[2].thermocouples[0].Type = TemperatureSensorSensor.ThermocoupleType.PHIDGET_TEMPERATURE_SENSOR_T_TYPE;
//oldJ = 33095
sensors[3].open(33095);
sensors[3].waitForAttachment();
sensors[3].thermocouples[0].Type = TemperatureSensorSensor.ThermocoupleType.PHIDGET_TEMPERATURE_SENSOR_J_TYPE;
//oldE = 33087
sensors[4].open(33087);
sensors[4].waitForAttachment();
sensors[4].thermocouples[0].Type = TemperatureSensorSensor.ThermocoupleType.PHIDGET_TEMPERATURE_SENSOR_E_TYPE;
sensors[0].TemperatureChange += new TemperatureChangeEventHandler(Sensor_TemperatureChange);
}
catch (PhidgetException ex)
{
MessageBox.Show(ex.Description, "Phidget Exception: " + ex.Code, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
startBtn.Enabled = true;
CreateGraph(zedGraphControl1);
SetSize();
}
/// <summary>
/// Constructs a new Temperature handler.
/// </summary>
public TemperatureHandler()
{
tempSensor = new TemperatureSensor();
}
/// <summary>
/// Handles the shutdown sequence of the componenent
/// </summary>
public void Shutdown()
{
tempSensor.close();
tempSensor = null;
}
private void StartWorking(TemperatureSensor temperatureSensor, HeatingElement heatingElement)
{
GridCompress();
PlatformDown();
temperatureSensor.ActivateSensor();
heatingElement.StartHeating();
DiodOn();
}
/// <summary>
/// Initializes a new instance of the <c>TPA81</c> class.
/// </summary>
public TPA81()
{
for (int i = 0; i < temps.Length; ++i)
{
temps[i] = new TemperatureSensor(this);
}
}
private async void TemperatureWatcher_Added(TemperatureWatcher sender, AllJoynServiceInfo args)
{
TemperatureJoinSessionResult joinResult = await TemperatureConsumer.JoinSessionAsync(args, sender);
AllJoynAboutDataView view = await AllJoynAboutDataView.GetDataBySessionPortAsync(args.UniqueName, this.temperatureBusAttachment, args.SessionPort);
var device = SensorClient.Factory.AllJoynDeviceFactory.GetAllJoynDevice(view);
if (joinResult.Status == AllJoynStatus.Ok)
{
TemperatureSensor newSensor = new TemperatureSensor(joinResult.Consumer, args.UniqueName);
var dispatcher = CoreApplication.MainView.CoreWindow.Dispatcher;
await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
if (TemperatureSensorSessionStarted != null)
TemperatureSensorSessionStarted.Invoke(newSensor, device);
});
}
else
{
throw new Exception(String.Format("Joining the session went wrong for TemperatureSensor {0}", args.UniqueName));
}
}
private IoTKitHoLSensor(TemperatureSensor sensorKind)
{
CurrentSensorKind = sensorKind;
}
