private static SensorData[] GetParse(ushort[] dataSensors) { SensorData[] resultParse = new SensorData[dataSensors.Length]; uint firstMask = 0x1; uint secondMask = 0x1FFE; for (int i = 0; i < dataSensors.Length; i++) { int counter = 0; int dataResult = dataSensors[i]; while (dataResult > 0) { dataResult = dataResult >> 1; counter++; } int amountOfBits = counter - 1; int cod = dataSensors[i] >> 13; uint controlBit = dataSensors[i] & firstMask; uint val = (dataSensors[i] & secondMask) >> 1; if ((amountOfBits % 2 == 0 && controlBit == 0) || (amountOfBits % 2 != 0 && controlBit == 1)) { resultParse[i] = new SensorData(Convert.ToUInt16(cod), Convert.ToUInt16(val), Convert.ToUInt16(controlBit)); } else { Console.WriteLine("Данные {0} со счетчика {1} повреждены", dataSensors[i], cod); } } return resultParse; }
private static double[] GetAverageBySensor(SensorData[] resultParse) { int counterFirstSensor = 0; int counterSecondSensor = 0; int counterThirdSensor = 0; int sumFirstSensor = 0; int sumSecondSensor = 0; int sumThirdSensor = 0; for (int i = 0; i < resultParse.Length; i++) { switch (resultParse[i].codeSensor) { case 1: counterFirstSensor++; sumFirstSensor += resultParse[i].valueSensor; break; case 2: counterSecondSensor++; sumSecondSensor += resultParse[i].valueSensor; break; case 3: counterThirdSensor++; sumThirdSensor += resultParse[i].valueSensor; break; default: break; } } double[] AverageBySensor = { (sumFirstSensor / counterFirstSensor), (sumSecondSensor / counterSecondSensor), (sumThirdSensor / counterThirdSensor) }; return AverageBySensor; }
public SensorClientData(SensorInfo ci, SensorData sd) { this.SensorId = ci.SensorId.ToString(); this.Lat = ci.Lat; this.Lng = ci.Lng; this.Name = ci.Name; this.Organization = ci.Organization; this.Humidity = sd.Humidity; this.Temperature = sd.Temperature; }
public override double SquaredDistanceFrom(SensorData other) { other.GetType(); var otherSensor = other as WlanSensorData; if (!BusinessEquals(otherSensor, false)) return 1d; Debug.Assert(otherSensor != null, "otherSensor != null"); return Math.Pow(SignalStrength - otherSensor.SignalStrength, 2); }
private void getMessage() { while (true) { NetworkStream stream = _clientSocket.GetStream (); BinaryFormatter formatter = new BinaryFormatter (); object obj = formatter.Deserialize (stream); SensorData data = (SensorData)obj; //Console.WriteLine (data.BottomLeft + " - " + data.BottomoRight + " - " + data.TopLeft + " - " + data.TopRight); _data = (SensorData)obj; } }
private void UpdateUI(SensorData.Vector reading) { ScenarioOutput_X.Text = String.Format("{0,5:0.00}", reading.X); ScenarioOutput_Y.Text = String.Format("{0,5:0.00}", reading.Y); ScenarioOutput_Z.Text = String.Format("{0,5:0.00}", reading.Z); // Show the values graphically xLine.X2 = xLine.X1 + reading.X * 100; yLine.Y2 = yLine.Y1 - reading.Y * 100; zLine.X2 = zLine.X1 - reading.Z * 50; zLine.Y2 = zLine.Y1 + reading.Z * 50; }
public async Task OnWeatherData(SensorData data) { if (this.SensorInfo == null) return; var o = new SensorClientData(this.SensorInfo, data); //Tell monitors about the new data (not the sensors) await this.InvokeTo<Monitor>(p => p.ClientType == ClientType.Monitor && p.TempThreshold < o.Temperature, o, "wd"); await this.ScaleOut(o, "swd"); //Store data on Azure Storage await this.StorageSet(o.SensorId, o); }
private void UpdateUI(SensorData.Vector reading) { statusTextBlock.Text = "Receiving data from accelerometer..."; // Show the numeric values xTextBlock.Text = "X: " + reading.X.ToString("0.00"); yTextBlock.Text = "Y: " + reading.Y.ToString("0.00"); zTextBlock.Text = "Z: " + reading.Z.ToString("0.00"); // Show the values graphically xLine.X2 = xLine.X1 + reading.X * 100; yLine.Y2 = yLine.Y1 - reading.Y * 100; zLine.X2 = zLine.X1 - reading.Z * 50; zLine.Y2 = zLine.Y1 + reading.Z * 50; }
public void ShowSensorData(string args) { SensorData sensorData = SomneoApiClient.GetSensorData(); if (sensorData == null) { Console.WriteLine("Unable to retrieve the sensor data."); return; } Console.WriteLine( $@"Sensor data: Temperature: {sensorData.CurrentTemperature} °C (avg: {sensorData.AverageTemperature} °C) Light: {sensorData.CurrentLight} lux (avg: {sensorData.AverageLight} lux) Sound: {sensorData.CurrentSound} dB (avg: {sensorData.AverageSound} dB) Humidity: {sensorData.CurrentHumidity} % (avg: {sensorData.AverageHumidity} %)"); }
private async Task <SensorData> movementChangedProc(byte[] bArray, bool doCallback) { SensorData values = null; if (bArray.Length == DataLength[(int)this.SensorIndex]) { Int16 dataGyroX = (Int16)(((UInt16)bArray[1] << 8) + (UInt16)bArray[0]); Int16 dataGyroY = (Int16)(((UInt16)bArray[3] << 8) + (UInt16)bArray[2]); Int16 dataGyroZ = (Int16)(((UInt16)bArray[5] << 8) + (UInt16)bArray[4]); Int16 dataAccX = (Int16)(((UInt16)bArray[7] << 8) + (UInt16)bArray[6]); Int16 dataAccY = (Int16)(((UInt16)bArray[9] << 8) + (UInt16)bArray[8]); Int16 dataAccZ = (Int16)(((UInt16)bArray[11] << 8) + (UInt16)bArray[10]); Int16 dataMagX = (Int16)(256 * ((UInt16)bArray[13]) + (UInt16)bArray[12]); Int16 dataMagY = (Int16)(256 * ((UInt16)bArray[15]) + (UInt16)bArray[14]); Int16 dataMagZ = (Int16)(256 * ((UInt16)bArray[17]) + (UInt16)bArray[16]); values = new SensorData { Sensor_Index = SensorIndex, Values = new double[] { sensorMpu9250GyroConvert(dataGyroX), sensorMpu9250GyroConvert(dataGyroY), sensorMpu9250GyroConvert(dataGyroZ), sensorMpu9250AccConvert(dataAccX), sensorMpu9250AccConvert(dataAccY), sensorMpu9250AccConvert(dataAccZ), sensorMpu9250MagConvert(dataMagX), sensorMpu9250MagConvert(dataMagY), sensorMpu9250MagConvert(dataMagZ) }, Raw = bArray }; if (doCallback) { if (CallMeBack != null) { CallMeBack(values); } } } return(values); }
public override void Append(SensorData data) { // Add to the internal array _data.Add(data); // Save to disk using (var f = File.Open(_filename, FileMode.Append)) { using (var b = new BinaryWriter(f)) { WriteRecord(b, data); b.Close(); } f.Close(); } // We're good _dirty = false; }
private void DisplayValue(string sVal) { try { ushort v = ushort.Parse(sVal); if (v < 0 || v > maxPhotoVal) { return; } SensorData data = new SensorData(DateTime.Now, v); photoDatas.Add(data); TxtSensorCount.Text = photoDatas.Count.ToString(); PgbPhotoRegistor.Value = v; LblPhotoRegistor.Text = v.ToString(); string item = $"{photoDatas.Count} {DateTime.Now.ToString("yy-MM-dd hh:mm:ss")}\t{v}"; RtbLog.AppendText($"{item}\n"); RtbLog.ScrollToEnd(); vs.Add(v); Time.Add(time); linegraph.PlotY(vs); if (IsSimulation == false) { BtnPortValue.Content = $"{serial.PortName}\n{sVal}"; InsertDataToDB(data); } else { BtnPortValue.Content = $"{sVal}"; } } catch (Exception ex) { RtbLog.AppendText($"Error : {ex.Message}\n"); RtbLog.ScrollToEnd(); } }
public IHttpActionResult GetLocationReadings(int locationId, string startDate = null, string endDate = null) { Location location = Location.GetById(locationId); if (location == null) { return(NotFound()); } DateTime _startDateTime, _endDateTime; Nullable <DateTime> startDateTime = null, endDateTime = null; if (startDate != null) { startDateTime = DateTime.TryParse(startDate, out _startDateTime) ? _startDateTime : (DateTime?)null; } if (startDate != null && startDateTime == null) { return(this.Content(HttpStatusCode.BadRequest, new ApiError("Invalid start date"))); } if (startDateTime != null && (startDateTime < DateTime.MinValue || startDateTime > DateTime.MaxValue)) { return(this.Content(HttpStatusCode.BadRequest, new ApiError("Invalid start date"))); } if (endDate != null) { endDateTime = DateTime.TryParse(endDate, out _endDateTime) ? _endDateTime : (DateTime?)null; } if (endDate != null && endDateTime == null) { return(this.Content(HttpStatusCode.BadRequest, new ApiError("Invalid end date"))); } if (endDateTime != null && (endDateTime < DateTime.MinValue || endDateTime > DateTime.MaxValue)) { return(this.Content(HttpStatusCode.BadRequest, new ApiError("Invalid end date"))); } if ((startDateTime != null && endDateTime != null) && endDateTime < startDateTime) { return(this.Content(HttpStatusCode.BadRequest, new ApiError("Invalid date range; endDate must be greater than or equal to startDate"))); } return(Ok(SensorData.GetAllByLocationId(locationId, startDateTime, endDateTime))); }
// Key press change handler // Algorithm taken from http://processors.wiki.ti.com/index.php/SensorTag_User_Guide#Simple_Key_Service public async void keyChanged(GattCharacteristic sender, GattValueChangedEventArgs eventArgs) { byte[] bArray = new byte[eventArgs.CharacteristicValue.Length]; DataReader.FromBuffer(eventArgs.CharacteristicValue).ReadBytes(bArray); if (bArray.Length == DataLength[(int)this.SensorIndex]) { byte data = bArray[0]; double left; double right; double reed; if ((data & 0x01) == 0x01) { right = 1; } else { right = 0; } if ((data & 0x02) == 0x02) { left = 1; } else { left = 0; } if ((data & 0x04) == 0x04) { reed = 1; } else { reed = 0; } var values = new SensorData { Sensor_Index = SensorIndex, Values = new double[] { right, left, reed }, Raw = bArray }; CallMeBack(values); } }
static void Main(string[] args) { Post postData = new Post(); //Vi sætter her den port vi skal bruge til at modtage data fra raspberry pi'en. UdpClient receiveUdp = new UdpClient(9001); IPEndPoint receiveEndPoint = new IPEndPoint(IPAddress.Any, 0); try { while (true) { //Her modtager vi data som bytes fra vores raspberry pi og konverterer det til en string Byte[] receiveBytes = receiveUdp.Receive(ref receiveEndPoint); string receivedData = Encoding.ASCII.GetString(receiveBytes); Console.WriteLine("This message was sent from " + receiveEndPoint.Address.ToString() + " on their port number " + receiveEndPoint.Port.ToString()); Console.WriteLine(receivedData); //Vi splitter vores string op i bidder så man kan bruge dem til at lave et objekt. string[] txtSplit = receivedData.Split(" "); for (int i = 0; i < txtSplit.Length; i++) { Console.WriteLine(txtSplit[i]); } //Her laver vi et objekt af det modtaget data, hvor vi konverterer de forskellige txtsplit til den ønskede data type. SensorData sensorData = new SensorData(Convert.ToInt16(txtSplit[0]), Convert.ToInt16(txtSplit[1]), Convert.ToInt32(txtSplit[2]), Convert.ToBoolean(txtSplit[3]), Convert.ToString(txtSplit[4])); //Vi laver her en PostRequest til at sende objektet til vores database. postData.PostItemHttpTask(sensorData); Thread.Sleep(1000); } } catch (Exception e) { Console.WriteLine(e); throw; } }
// Polls for new skeleton data /// <summary> /// 轮询新的骨架数据 /// </summary> /// <param name="sensorData">传感器数据</param> /// <param name="bodyFrame">身体帧</param> /// <param name="kinectToWorld">Kinect世界矩阵</param> /// <returns></returns> public static bool PollBodyFrame(SensorData sensorData, ref BodyFrameData bodyFrame, ref Matrix4x4 kinectToWorld) { bool bNewFrame = false; if (sensorData.sensorInterface != null) { //获取新的身体帧 bNewFrame = sensorData.sensorInterface.PollBodyFrame(sensorData, ref bodyFrame, ref kinectToWorld); if (bNewFrame) { for (int i = 0; i < sensorData.bodyCount; i++) { if (bodyFrame.bodyData[i].bIsTracked != 0) { // calculate joint directions //计算关节方向 for (int j = 0; j < sensorData.jointCount; j++) { if (j == 0) { bodyFrame.bodyData[i].joint[j].direction = Vector3.zero; } else { //获取关节的父节点 int jParent = (int)sensorData.sensorInterface.GetParentJoint(bodyFrame.bodyData[i].joint[j].jointType); //当前关节和父关节都不是未跟踪时,则进行处理 if (bodyFrame.bodyData[i].joint[j].trackingState != TrackingState.NotTracked && bodyFrame.bodyData[i].joint[jParent].trackingState != TrackingState.NotTracked) { //设置身体数据关节方向 bodyFrame.bodyData[i].joint[j].direction = bodyFrame.bodyData[i].joint[j].position - bodyFrame.bodyData[i].joint[jParent].position; } } } } } } } return(bNewFrame); }
/// <summary> /// 处理并计算统计数据 /// </summary> /// <param name="sd"></param> /// <param name="period"></param> /// <returns></returns> private async Task<bool> ProcessStatistics(SensorData sd, int period) { var key = StatisticsProcessor.GetStatisticsKey(sd.Time, period, sd.DeviceCode); var sts = _redisClient.HashGet<DeviceTimeSharingStatisticsDto>(RedisKeyString.DeviceTimeSharingStatistics, key, RedisSerializeType.DataType); if (sts == null) { sts = new DeviceTimeSharingStatisticsDto { DeviceSerialnum = sd.DeviceCode, Serialnum = key, TimeSharing = period }; sts.MaxValue = sts.MinValue = sts.StartValue = sts.EndValue = sts.AvgValue = sd.Value; sts.CreateTime = DateTime.Now; } else { if (sd.Value > sts.MaxValue) sts.MaxValue = sd.Value; if (sd.Value < sts.MinValue) sts.MinValue = sd.Value; sts.EndValue = sd.Value; sts.AvgValue = (sts.AvgValue + sd.Value) / 2; } sts.Count++; sts.UpdateTime = sd.Time; //取上下限 var deviceExceptionSetService = AhnqIotContainer.Container.Resolve<IDeviceExceptionSetService>(); var set = await deviceExceptionSetService.GetDeviceExceptionSetByDeviceIdAsny(sd.DeviceCode); if (set == null) return _redisClient.HashSetFieldValue(RedisKeyString.DeviceTimeSharingStatistics, key, sts, RedisSerializeType.DataType) > 0; sts.Max = set.Max; sts.Min = set.Min; if (sd.Value > set.Max || sd.Value < set.Min) { sts.ExceptionCount++; } return _redisClient.HashSetFieldValue(RedisKeyString.DeviceTimeSharingStatistics, key, sts, RedisSerializeType.DataType) > 0; }
public void AddSensorData(SensorData message) { lock (_accessLock) { foreach (var pair in _currentSessions) { if (UserRoleHelper.IsAllSensorsAllowed(pair.Key)) { pair.Value.AddUpdate(message); } else if (pair.Key.IsSensorAvailable(message.Key)) { pair.Value.AddUpdate(message); } } } }
public async Task <ActionResult <SensorData> > PostSensorData(SensorData sensorData) { var sensor = await _context.Sensor.Include(sd => sd.Data).FirstOrDefaultAsync(s => s.Id == sensorData.SensorId); if (sensor == null) { return(NotFound()); } if (sensor.Data == null) { sensor.Data = new List <SensorData>(); } sensor.Data.Add(sensorData); await _context.SaveChangesAsync(); return(NoContent()); }
public IActionResult GetUpdate() { var update = deviceService.GetUpdate(); if (int.TryParse(update.Humidity.Split('.')[0], out int h) && int.TryParse(update.Temperature.Split('.')[0], out int t)) { var data = new SensorData { Humidity = h, Temperature = t, Timestamp = update.TimeStamp, LedOn = update.LedOn }; return(base.Json(data)); } return(base.BadRequest()); }
/// <summary> /// This function adds a sensor with the data from the fields to the collection of sensors /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Add_Click(object sender, RoutedEventArgs e) { SensorData data = new SensorData { Name = txtName.Text, Description = txtDesc.Text, Location = new Location((double)numLat.Value, (double)numLong.Value), Type = sensorTypeChooser.Text, PollingInterval = (int)numPoll.Value }; RangeBoundaries <string> boundaries = new RangeBoundaries <string>(numMinVal.Text, numMaxVal.Text); if (logic.AddSensor(data, boundaries)) { logic.SaveState(); } }
public void WriteSensorData(SensorDataMessage message) { var sensor = context.Sensors.FirstOrDefault(x => x.Id == message.SensorId && x.Device.Token == message.Token); if (sensor == null) { throw new SensorIdOrTokenNotFoundException(); } var data = new SensorData { EventDateTime = DateTime.Now, SensorId = sensor.Id, Value = message.Value }; context.SensorData.Add(data); context.SaveChanges(); }
private async void OnDataReceived(MqttApplicationMessageReceivedEventArgs arg) { try { var json_data = Encoding.UTF8.GetString(arg.ApplicationMessage.Payload); Console.WriteLine(json_data); SensorData sensorData = JsonConvert.DeserializeObject <SensorData>(json_data); if (_mqttService.IsConnected()) { await _mqttService.Publish(sensorData, "data-analytics/data"); } this.saveData(sensorData); } catch (Exception e) { Console.WriteLine(e.Message); } }
public async void SendToRest(SensorData obj) { // http client - PostAsync using (HttpClient client = new HttpClient()) { StringContent content = new StringContent( JsonConvert.SerializeObject(obj), Encoding.UTF8, "application/json"); HttpResponseMessage resp = await client.PostAsync(URI, content); //if (resp.IsSuccessStatusCode) //{ // return; //} //throw new ArgumentException("opret fejlede"); } }
public Identifier AddSensorData(PointerDeviceType deviceType, List <PointerData> pointerDataList) { Identifier inputContextId = mDeviceTypeMap[deviceType]; InputContext inputContext = mInputContexts[inputContextId]; SensorContext sensorContext = mSensorContexts[inputContext.SensorContextId]; // Create sensor data using the input context SensorData sensorData = new SensorData( Identifier.FromNewGuid(), inputContext.Id, InkState.Plane); PopulateSensorData(sensorData, sensorContext, pointerDataList); mSensorDataMap.TryAdd(sensorData.Id, sensorData); return(sensorData.Id); }
public void AddUpdate(SensorData message) { lock (_lockObj) { _monitoringQueue.Enqueue(message); ++_elementsCount; } if (_elementsCount >= ErrorCapacity) { OnQueueOverflow(); } if (_elementsCount >= WarningCapacity) { OnQueueOverflowWarning(); } }
public async void Start() { UdpClient proxyClient = new UdpClient(10100); while (true) { IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); var buffer = proxyClient.Receive(ref remoteEndPoint); string receivedString = Encoding.UTF8.GetString(buffer); Console.WriteLine(receivedString); SensorData sd = JsonSerializer.Deserialize <SensorData>(receivedString); Console.WriteLine(sd); Console.WriteLine(await PostToRestAsync(JsonSerializer.Serialize(sd))); Thread.Sleep(5000); } }
private static SensorData LoadSensorData(SqlDataReader reader) { SensorData sensorData = new SensorData(); sensorData.Id = (int)reader["Id"]; sensorData.SensorId = (int)reader["SensorId"]; sensorData.TimeStamp = (reader["TimeStamp"] == DBNull.Value) ? new DateTime(0, 0, 0) : (DateTime)reader["TimeStamp"]; if (reader["Temperature"] != DBNull.Value) { sensorData.Temperature = (double)reader["Temperature"]; } if (reader["Humidity"] != DBNull.Value) { sensorData.Humidity = (double)reader["Humidity"]; } return(sensorData); }
private void EncodeCurrentStrokeCommon(string pointerDeviceType, InkBuilder inkBuilder, Style style) { // Create the ink input provider using the pointer device type InkInputProvider inkInputProvider = CreateAndAddInkProvider(pointerDeviceType); // Create the input device using EasClientDeviceInformation or any other class providing relevant info InputDevice inputDevice = CreateAndAddInputDevice(); // Create the sensor context SensorContext sensorContext = CreateAndAddSensorContext(inkInputProvider, inputDevice); // Create the input context using the environment and the sensor context Identifier inputContextId = CreateAndAddInputContext(sensorContext.Id); // Create sensor data using the input context SensorData sensorData = new SensorData( Identifier.FromNewGuid(), inputContextId, Wacom.Ink.Serialization.InkState.Plane); // Get the sensor data from the ink builders List <PointerData> pointerDataList = inkBuilder.GetPointerDataList(); // Fill the default channels with the sensor data FillDefaultChannels(sensorData, sensorContext, pointerDataList); InkDocument.SensorData.Add(sensorData); Spline spline = inkBuilder.SplineProducer.AllData; PathPointLayout layout = inkBuilder.Layout; Stroke stroke = new Stroke( Identifier.FromNewGuid(), spline.Clone(), style, layout, sensorData.Id); StrokeNode strokeNode = new StrokeNode(Identifier.FromNewGuid(), stroke); InkDocument.InkTree.Root.Add(strokeNode); }
public int AddSensor(SensorData sd) { string sql = "insert into Sensor (node,sensor,v1,v2,datetime) values (@node,@sensor,@v1,@v2,@datetime)"; SqlParameter[] pars = { new SqlParameter("@node", SqlDbType.VarChar, 20), new SqlParameter("@sensor", SqlDbType.VarChar, 20), new SqlParameter("@v1", SqlDbType.VarChar, 20), new SqlParameter("@v2", SqlDbType.VarChar, 20), new SqlParameter("@datetime", SqlDbType.DateTime) }; pars[0].Value = sd.Node; pars[1].Value = sd.Sensor; pars[2].Value = sd.V1; pars[3].Value = sd.V2; pars[4].Value = sd.DTTime; return(SqlHelper.ExecuteNonQuery(sql, CommandType.Text, pars)); }
public Watering CheckWatering(string mac) { // make sensor obj Sensor sensor = sensorController.GetSensor(mac); // make sensorData obj SensorData sensorData = sensorDataController.GetSensorData(mac); // Get User User user = userController.GetUserGeo(sensor.FK_UserId); Watering wat = new Watering(); wat.Port = sensorController.GetPort(mac).Port; if (sensorData.Humidity < sensor.LimitLow) { userController.UpdateWaterCount(user.Id); wat.Water = 1; return(wat); //return true; } else if (sensorData.Humidity < sensor.LimitUp) { // Generate Weathermodels weatherAPI = new WeatherAPI(user.Lat, user.Lon); WeatherModel weatherModel = weatherAPI.GetForecast(); double incommingRain = 0; for (int i = 0; i < threeHourIntervals; i++) { incommingRain += weatherModel.list[i].rain._3h; } if (incommingRain <= rainRequirementInMM) { userController.UpdateWaterCount(user.Id); wat.Water = 1; return(wat); } } wat.Water = 0; return(wat); }
private void JSONToOrientation(string json) { // float deltaTime = Time.time - lastTime; // lastTime = Time.time; SensorData data = JsonUtility.FromJson <SensorData>(json); // deserialize JSON data if (data != null) // if serialization successful => pipe to AHRS algorithm { ahrs.accelerometer = data.accelerometer.ToVector(); ahrs.magnetsensor = data.magnetometer.ToVector(); ahrs.gyroscope = new Vector3( data.gyroscope.x * Mathf.Deg2Rad, data.gyroscope.y * Mathf.Deg2Rad, data.gyroscope.z * Mathf.Deg2Rad ); //ahrs.samplePeriod = deltaTime; // time components could be used to adapt the sample rate } }
public void importData(SensorData sensorData) { _sensorData = new SensorData(); Debug.Log(sensorData); try { _sensorData._id = sensorData._id; _sensorData.attrNames = sensorData.attrNames; _sensorData.attrs = sensorData.attrs; _sensorData.credate = sensorData.credate; _sensorData.modDate = sensorData.modDate; _sensorData.location = sensorData.location; } catch { Debug.Log("Device importData failed"); } populateServices(); }
public void AddValue(string productName, SensorData sensorData) { lock (_syncRoot) { SortedList <string, SensorData> list; if (!_productSensorDictionary.ContainsKey(productName)) { list = new SortedList <string, SensorData>(); _productSensorDictionary[productName] = list; } else { list = _productSensorDictionary[productName]; } list[sensorData.Path] = sensorData.Clone(); } }
public void SetupServer() { LoggerSingleton.Instance.Log("Setting up server..."); try { _sensorData = new SensorData(); _serverSocket.Bind(new IPEndPoint(_ip, _port)); // place the socket in a listen state. Max queue of 5 connections at a time _serverSocket.Listen(5); _serverSocket.BeginAccept(AcceptCallback, null); LoggerSingleton.Instance.Log("Socket server started"); } catch (Exception ex) { LoggerSingleton.Instance.Log("The following error occurred on setupserver", ex); throw; } }
IEnumerator WaitForRequest(WWW www) { yield return(www); // check for errors if (www.error == null) { data = JsonUtility.FromJson <SensorData>(www.text); //Debug.Log(JsonUtility.ToJson(data)); foodManager.temperature = data.temperature; foodManager.co2 = data.carboneDioxide; string[] s = data.lastMovement.Split(':'); foodManager.timeStir = 60 * float.Parse(s[1]) + float.Parse(s[2]); } else { Debug.Log("WWW Error: " + www.error); } }
/// <summary> /// Adds sensor with the given "data" to the Sensors List /// </summary> /// <param name="data"></param> /// <param name="rangeBoundaries"></param> /// <returns>True if the sensor is added successfully, False otherwise</returns> public bool AddSensor(SensorData data, RangeBoundaries <string> rangeBoundaries) { bool success = true; Sensor sensor = null; try { switch (data.Type) { case "DoorSensor": sensor = new DoorSensor(data); break; case "ElPowerSensor": sensor = new ElPowerSensor(data, new RangeBoundaries <int>(int.Parse(rangeBoundaries.Min), int.Parse(rangeBoundaries.Max))); break; case "NoiseSensor": sensor = new NoiseSensor(data, new RangeBoundaries <int>(int.Parse(rangeBoundaries.Min), int.Parse(rangeBoundaries.Max))); break; case "HumiditySensor": sensor = new HumiditySensor(data, new RangeBoundaries <float>(float.Parse(rangeBoundaries.Min), float.Parse(rangeBoundaries.Max))); break; case "TemperatureSensor": sensor = new TemperatureSensor(data, new RangeBoundaries <double>(double.Parse(rangeBoundaries.Min), double.Parse(rangeBoundaries.Max))); break; default: break; } Sensors.Add(sensor); SaveState(); } catch (Exception) { MessageBox.Show("Failed to add the sensor!", "Error", MessageBoxButton.OK, MessageBoxImage.Error); success = false; } return(success); }
public void HandleEvent(object sender, EventArgs args) { CustomEventArgs eventArgs = (CustomEventArgs)args; int indicator = eventArgs.getIndicator(); switch (indicator) { case (int)ShimmerBluetooth.ShimmerIdentifier.MSG_IDENTIFIER_STATE_CHANGE: System.Diagnostics.Debug.Write(((ShimmerBluetooth)sender).GetDeviceName() + " State = " + ((ShimmerBluetooth)sender).GetStateString() + System.Environment.NewLine); int state = (int)eventArgs.getObject(); if (state == (int)ShimmerBluetooth.SHIMMER_STATE_CONNECTED) { System.Console.WriteLine("Connected"); } else if (state == (int)ShimmerBluetooth.SHIMMER_STATE_CONNECTING) { System.Console.WriteLine("Connecting"); } else if (state == (int)ShimmerBluetooth.SHIMMER_STATE_NONE) { System.Console.WriteLine("Disconnected"); } else if (state == (int)ShimmerBluetooth.SHIMMER_STATE_STREAMING) { System.Console.WriteLine("Streaming"); System.Console.WriteLine("Data being written to ecg.csv"); } break; case (int)ShimmerBluetooth.ShimmerIdentifier.MSG_IDENTIFIER_NOTIFICATION_MESSAGE: break; case (int)ShimmerBluetooth.ShimmerIdentifier.MSG_IDENTIFIER_DATA_PACKET: ObjectCluster objectCluster = (ObjectCluster)eventArgs.getObject(); SensorData data = objectCluster.GetData(Shimmer3Configuration.SignalNames.ECG_LA_RA, "CAL"); if (data != null) { System.Console.Write(data.Data + ","); } logging.WriteData(objectCluster); break; } }
/// <summary> /// Tests for the lineparser format. Additionally it looks for the header row and /// trys to determine the third value seperated by semicolom. /// </summary> /// <param name="line">The line to parse</param> /// <returns>True is successful</returns> /// <exception cref="LineparserException">If no linematcher is set</exception> public override bool test(string line) { // Is header line? if (line.IndexOf("Date;Time;") != -1) { // Split header line by semicolom. String[] splits = line.Split(';'); if (splits.Length != 3) { return false; } // set additional value SensorData tValue = (SensorData)Enum.Parse(typeof(SensorData), splits[splits.Length - 1]); this.extraValue = tValue; // set supported values SensorData[] t = { SensorData.Date, tValue }; this.SupportedValues = t; } // run the actual test return base.test(line); }
// closes opened readers and closes the sensor public static void CloseSensor(SensorData sensorData) { if (sensorData != null && sensorData.sensorInterface != null) { sensorData.sensorInterface.CloseSensor(sensorData); } if (sensorData.bodyIndexBuffer != null) { sensorData.bodyIndexBuffer.Release(); sensorData.bodyIndexBuffer = null; } if (sensorData.depthImageBuffer != null) { sensorData.depthImageBuffer.Release(); sensorData.depthImageBuffer = null; } if (sensorData.depthHistBuffer != null) { sensorData.depthHistBuffer.Release(); sensorData.depthHistBuffer = null; } if (sensorData.depth2ColorBuffer != null) { sensorData.depth2ColorBuffer.Release(); sensorData.depth2ColorBuffer = null; } }
public static void FinishBackgroundRemoval(SensorData sensorData) { if (sensorData.alphaBodyTexture != null) { sensorData.alphaBodyTexture.Release(); sensorData.alphaBodyTexture = null; } sensorData.erodeBodyMaterial = null; sensorData.dilateBodyMaterial = null; sensorData.blurBodyMaterial = null; if (sensorData.color2DepthBuffer != null) { sensorData.color2DepthBuffer.Release(); sensorData.color2DepthBuffer = null; } if (sensorData.color2DepthTexture != null) { sensorData.color2DepthTexture.Release(); sensorData.color2DepthTexture = null; } sensorData.color2DepthMaterial = null; sensorData.color2DepthCoords = null; }
// public static EventHandler<SensorData> MeasurementComplete; /// <summary> /// Raises the <see cref="MeasurementComplete"/> event. /// </summary> /// <param name="sender">The object that raised the event.</param> /// <param name="sensorData">The <see cref="SensorData"/> object that contains the results of the measurement.</param> public void OnMeasurementCompleteEvent(Accelaccelerometer sender, SensorData sensorData) { if (_OnMeasurementComplete == null) _OnMeasurementComplete = OnMeasurementCompleteEvent; }
public FilteredDatabaseDataSet(SensorData[] SupportedValues) { this.SupportedValues = SupportedValues; }
// Polls for new skeleton data public static bool PollBodyFrame(SensorData sensorData, ref BodyFrameData bodyFrame, ref Matrix4x4 kinectToWorld) { bool bNewFrame = false; if(sensorData.sensorInterface != null) { bNewFrame = sensorData.sensorInterface.PollBodyFrame(sensorData, ref bodyFrame, ref kinectToWorld); if(bNewFrame) { for(int i = 0; i < sensorData.bodyCount; i++) { if(bodyFrame.bodyData[i].bIsTracked != 0) { // calculate joint directions for(int j = 0; j < sensorData.jointCount; j++) { if(j == 0) { bodyFrame.bodyData[i].joint[j].direction = Vector3.zero; } else { int jParent = (int)sensorData.sensorInterface.GetParentJoint(bodyFrame.bodyData[i].joint[j].jointType); if(bodyFrame.bodyData[i].joint[j].trackingState != TrackingState.NotTracked && bodyFrame.bodyData[i].joint[jParent].trackingState != TrackingState.NotTracked) { bodyFrame.bodyData[i].joint[j].direction = bodyFrame.bodyData[i].joint[j].position - bodyFrame.bodyData[i].joint[jParent].position; } } } } } } } return bNewFrame; }
// frees last multi source frame public static void FreeMultiSourceFrame(SensorData sensorData) { if(sensorData.sensorInterface != null) { sensorData.sensorInterface.FreeMultiSourceFrame(sensorData); } }
// gets new multi source frame public static bool GetMultiSourceFrame(SensorData sensorData) { bool bResult = false; if(sensorData.sensorInterface != null) { bResult = sensorData.sensorInterface.GetMultiSourceFrame(sensorData); } return bResult; }
// invoked periodically to update sensor data, if needed public static bool UpdateSensorData(SensorData sensorData) { bool bResult = false; if(sensorData.sensorInterface != null) { bResult = sensorData.sensorInterface.UpdateSensorData(sensorData); } return bResult; }
// closes opened readers and closes the sensor public static void CloseSensor(SensorData sensorData) { if(sensorData != null && sensorData.sensorInterface != null) { sensorData.sensorInterface.CloseSensor(sensorData); } }
// returns the foregound frame rectangle, as to the required resolution public static Rect GetForegroundFrameRect(SensorData sensorData, bool isHiResPrefered) { if (isHiResPrefered && sensorData != null && sensorData.sensorInterface != null) { if (sensorData.sensorInterface.IsBRHiResSupported() && sensorData.colorImage != null) { return new Rect(0f, 0f, sensorData.colorImageWidth, sensorData.colorImageHeight); } } return sensorData != null ? new Rect(0f, 0f, sensorData.depthImageWidth, sensorData.depthImageHeight) : new Rect(); }
private static bool GetForegroundAlphaFrame(SensorData sensorData, bool bLimitedUsers, ICollection<int> alTrackedIndexes, ref byte[] fgAlphaFrame) { if (sensorData == null || sensorData.bodyIndexImage == null) return false; CvMat cvAlphaMap = new CvMat(sensorData.depthImageHeight, sensorData.depthImageWidth, MatrixType.U8C1); System.IntPtr rawPtrAlpha; cvAlphaMap.GetRawData(out rawPtrAlpha); if (sensorData.selectedBodyIndex != 255 || bLimitedUsers) { // copy body-index selectively byte btSelBI = sensorData.selectedBodyIndex; int iBodyIndexLength = sensorData.bodyIndexImage.Length; for (int i = 0; i < iBodyIndexLength; i++) { byte btBufBI = sensorData.bodyIndexImage[i]; bool bUserTracked = btSelBI != 255 ? btSelBI == btBufBI : (btBufBI != 255 ? alTrackedIndexes.Contains((int)btBufBI) : false); if (bUserTracked) { cvAlphaMap.Set1D(i, btBufBI); } else { cvAlphaMap.Set1D(i, 255); } } } else { // copy the entire body-index buffer Marshal.Copy(sensorData.bodyIndexImage, 0, rawPtrAlpha, sensorData.bodyIndexImage.Length); } // make the image b&w cvAlphaMap.Threshold(cvAlphaMap, 254, 255, ThresholdType.BinaryInv); // apply erode, dilate and blur cvAlphaMap.Erode(cvAlphaMap); cvAlphaMap.Dilate(cvAlphaMap); cvAlphaMap.Smooth(cvAlphaMap, SmoothType.Blur, 5, 5); //cvAlphaMap.Smooth(cvAlphaMap, SmoothType.Median, 7); // get the foreground image Marshal.Copy(rawPtrAlpha, fgAlphaFrame, 0, fgAlphaFrame.Length); return true; }
public override object getValue(SensorData target) { switch (target) { case SensorData.Activity: return this.data.ToArray()[currentRow].Activity; case SensorData.ActivityY: return this.data.ToArray()[currentRow].ActivityY; case SensorData.ActivityZ: return this.data.ToArray()[currentRow].ActivityZ; case SensorData.CaloriesActivity: return this.data.ToArray()[currentRow].CaloriesActivity; case SensorData.CaloriesTotal: return this.data.ToArray()[currentRow].CaloriesTotal; case SensorData.Date: return this.data.ToArray()[currentRow].Date; case SensorData.Inclinometer: return this.data.ToArray()[currentRow].Inclinometer; case SensorData.Steps: return this.data.ToArray()[currentRow].Steps; case SensorData.Vmu: return this.data.ToArray()[currentRow].Vmu; default: return null; } }
// Polls for new infrared frame data public static bool PollInfraredFrame(SensorData sensorData) { bool bNewFrame = false; if(sensorData.sensorInterface != null) { bNewFrame = sensorData.sensorInterface.PollInfraredFrame(sensorData); } return bNewFrame; }
public override object getNextValue(SensorData target) { read(); return getValue(target); }
// returns depth frame coordinates for the given 3d Kinect-space point public static Vector2 MapSpacePointToDepthCoords(SensorData sensorData, Vector3 kinectPos) { Vector2 vPoint = Vector2.zero; if(sensorData.sensorInterface != null) { vPoint = sensorData.sensorInterface.MapSpacePointToDepthCoords(sensorData, kinectPos); } return vPoint; }
// public static EventHandler<SensorData> MeasurementComplete; /// <summary> /// Raises the <see cref="MeasurementComplete"/> event. /// </summary> /// <param name="sender">The object that raised the event.</param> /// <param name="sensorData">The <see cref="SensorData"/> object that contains the results of the measurement.</param> public void OnMeasurementCompleteEvent(Magnetometer sender, SensorData sensorData) { if (_OnMeasurementComplete == null) _OnMeasurementComplete = OnMeasurementCompleteEvent; }
// returns color-map coordinates for the given depth point public static Vector2 MapDepthPointToColorCoords(SensorData sensorData, Vector2 depthPos, ushort depthVal) { Vector2 vPoint = Vector2.zero; if(sensorData.sensorInterface != null) { vPoint = sensorData.sensorInterface.MapDepthPointToColorCoords(sensorData, depthPos, depthVal); } return vPoint; }
// estimates color-map coordinates for the current depth frame public static bool MapDepthFrameToColorCoords(SensorData sensorData, ref Vector2[] vColorCoords) { bool bResult = false; if(sensorData.sensorInterface != null) { bResult = sensorData.sensorInterface.MapDepthFrameToColorCoords(sensorData, ref vColorCoords); } return bResult; }
// returns the foregound frame length, as to the required resolution public static int GetForegroundFrameLength(SensorData sensorData, bool isHiResPrefered) { if (isHiResPrefered && sensorData != null && sensorData.sensorInterface != null) { if (sensorData.sensorInterface.IsBRHiResSupported() && sensorData.colorImage != null) { return sensorData.colorImage.Length; } } return (sensorData != null && sensorData.bodyIndexImage != null) ? sensorData.bodyIndexImage.Length * 4 : 0; }
// converts current body frame to a single csv line. returns empty string if there is no new data public static string GetBodyFrameAsCsv(SensorData sensorData, ref BodyFrameData bodyFrame, ref long liRelTime, ref float fUnityTime) { // check for invalid sensor data and if the frame is still the same if (sensorData == null) return string.Empty; if (bodyFrame.liRelativeTime == liRelTime) return string.Empty; // create the output string StringBuilder sbBuf = new StringBuilder(); const char delimiter = ','; sbBuf.Append("kb").Append(delimiter); sbBuf.Append(bodyFrame.liRelativeTime).Append(delimiter); liRelTime = bodyFrame.liRelativeTime; fUnityTime = Time.time; sbBuf.Append(sensorData.bodyCount).Append(delimiter); sbBuf.Append(sensorData.jointCount).Append(delimiter); // add information for all bodies for (int i = 0; i < sensorData.bodyCount; i++) { sbBuf.Append(bodyFrame.bodyData[i].bIsTracked).Append(delimiter); if (bodyFrame.bodyData[i].bIsTracked != 0) { // add information for the tracked body - body-id and joints sbBuf.Append(bodyFrame.bodyData[i].liTrackingID).Append(delimiter); for (int j = 0; j < sensorData.jointCount; j++) { KinectInterop.JointData jointData = bodyFrame.bodyData[i].joint[j]; sbBuf.Append((int)jointData.trackingState).Append(delimiter); if (jointData.trackingState != TrackingState.NotTracked) { sbBuf.AppendFormat("{0:F3}", jointData.kinectPos.x).Append(delimiter); sbBuf.AppendFormat("{0:F3}", jointData.kinectPos.y).Append(delimiter); sbBuf.AppendFormat("{0:F3}", jointData.kinectPos.z).Append(delimiter); } } } } // remove the last delimiter if (sbBuf.Length > 0 && sbBuf[sbBuf.Length - 1] == delimiter) { sbBuf.Remove(sbBuf.Length - 1, 1); } return sbBuf.ToString(); }
public static bool InitBackgroundRemoval(SensorData sensorData, bool isHiResPrefered) { if (sensorData != null && sensorData.bodyIndexImage != null && sensorData.colorImage != null && IsDirectX11Available()) { sensorData.alphaBodyTexture = new RenderTexture(sensorData.depthImageWidth, sensorData.depthImageHeight, 0); sensorData.alphaBodyTexture.wrapMode = TextureWrapMode.Clamp; //sensorData.alphaBodyTexture.filterMode = FilterMode.Point; Shader erodeBodyShader = Shader.Find("Custom/Erode"); sensorData.erodeBodyMaterial = new Material(erodeBodyShader); sensorData.erodeBodyMaterial.SetFloat("_TexResX", (float)sensorData.depthImageWidth); sensorData.erodeBodyMaterial.SetFloat("_TexResY", (float)sensorData.depthImageHeight); //sensorData.erodeBodyMaterial.SetTexture("_MainTex", sensorData.bodyIndexTexture); Shader dilateBodyShader = Shader.Find("Custom/Dilate"); sensorData.dilateBodyMaterial = new Material(dilateBodyShader); sensorData.dilateBodyMaterial.SetFloat("_TexResX", (float)sensorData.depthImageWidth); sensorData.dilateBodyMaterial.SetFloat("_TexResY", (float)sensorData.depthImageHeight); //sensorData.dilateBodyMaterial.SetTexture("_MainTex", sensorData.bodyIndexTexture); Shader blurBodyShader = Shader.Find("Custom/BlurShader"); sensorData.blurBodyMaterial = new Material(blurBodyShader); sensorData.blurBodyMaterial.SetFloat("_Amount", 1.5f); if (isHiResPrefered) { Shader color2DepthShader = Shader.Find("Kinect/Color2DepthShader"); if (color2DepthShader) { sensorData.color2DepthTexture = new RenderTexture(sensorData.colorImageWidth, sensorData.colorImageHeight, 0); sensorData.color2DepthTexture.wrapMode = TextureWrapMode.Clamp; //sensorData.color2DepthTexture.filterMode = FilterMode.Point; sensorData.color2DepthMaterial = new Material(color2DepthShader); sensorData.color2DepthMaterial.SetFloat("_ColorResX", (float)sensorData.colorImageWidth); sensorData.color2DepthMaterial.SetFloat("_ColorResY", (float)sensorData.colorImageHeight); sensorData.color2DepthMaterial.SetFloat("_DepthResX", (float)sensorData.depthImageWidth); sensorData.color2DepthMaterial.SetFloat("_DepthResY", (float)sensorData.depthImageHeight); sensorData.color2DepthBuffer = new ComputeBuffer(sensorData.colorImageWidth * sensorData.colorImageHeight, sizeof(float) * 2); sensorData.color2DepthMaterial.SetBuffer("_DepthCoords", sensorData.color2DepthBuffer); } } } if (isHiResPrefered && sensorData != null && sensorData.bodyIndexImage != null && sensorData.colorImage != null) { sensorData.color2DepthCoords = new Vector2[sensorData.colorImageWidth * sensorData.colorImageHeight]; } return true; }