Example #1
0
 private void OnDeviceDiscovery(DeviceDiscoveryEvent discoveryEvent)
 {
     if (_monitoringEvents)
     {
         if (discoveryEvent.DeviceDetails.MacAddress.IsNullOrEmpty() || !BleSystemConfiguration.BleTransmitters.ContainsKey(discoveryEvent.DeviceDetails.MacAddress))
         {
             return;
         }
         _discoveredEventHandler.Post(discoveryEvent);
         OnLogMessage(string.Format("Discovered: Name: {0}, Mac: {1} RSSI: {2}, IP: {3}", discoveryEvent.DeviceDetails.Name, discoveryEvent.DeviceDetails.MacAddress,
                                    discoveryEvent.Rssi, discoveryEvent.BleReceiver.IPAddress));
     }
 }
Example #2
0
        private void ExtractMacAddress(DeviceDiscoveryEvent discoveryEvent, string line)
        {
            var lineParts = line.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            foreach (var linePart in lineParts)
            {
                if (linePart.IsValidMacAddress())
                {
                    discoveryEvent.DeviceDetails.MacAddress = linePart;
                    return;
                }
            }
        }
Example #3
0
        private void ExtractDeviceName(DeviceDiscoveryEvent discoveryEvent, string line)
        {
            var nameStartIndex = line.IndexOf("'", StringComparison.Ordinal);

            if (nameStartIndex < 0 || nameStartIndex > line.Length - 3)
            {
                Console.WriteLine("Couldn't extract device name from  {0}", line);
                return;
            }
            nameStartIndex++;
            var nameEndIndex = line.IndexOf("'", nameStartIndex, StringComparison.Ordinal);

            if (nameEndIndex < 0)
            {
                Console.WriteLine("Couldn't extract device name from  {0} - couldn't find end of name", line);
                return;
            }
            discoveryEvent.DeviceDetails.Name = line.Substring(nameStartIndex, nameEndIndex - nameStartIndex);
        }
Example #4
0
        private void ExtractRSSI(DeviceDiscoveryEvent discoveryEvent, string line)
        {
            var lineParts = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            if (lineParts.Length <= 1)
            {
                Console.WriteLine("Can't extract RSSI from {0}", line);
                return;
            }
            foreach (var linePart in lineParts)
            {
                int rssi;
                if (int.TryParse(linePart, out rssi))
                {
                    discoveryEvent.Rssi = rssi;
                    return;
                }
            }
        }
Example #5
0
        private void ProcessFinalizedMessage(MessageWrapper messageWrapper)
        {
            var now     = DateTime.Now;
            var message = messageWrapper.MessageParts.ToString(messageWrapper.MessageStartCharIndex,
                                                               messageWrapper.MessageEnd - messageWrapper.MessageStartCharIndex + 1);

            if (message.IsNullOrEmpty())// || message.IndexOf(UnkownDeviceName, StringComparison.Ordinal) >= 0)
            {
                return;
            }
            var lines       = message.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
            var extractions = new Dictionary <string, Action <DeviceDiscoveryEvent, string> >()
            {
                { MacAddressKey, ExtractMacAddress },
                { DeviceNameKey, ExtractDeviceName },
                { RssiKey, ExtractRSSI }
            };
            var discoveryEvent = new DeviceDiscoveryEvent {
                DeviceDetails = new DeviceDetails(), TimeStamp = now
            };

            foreach (var line in lines)
            {
                string foundKey = null;
                foreach (var extraction in extractions)
                {
                    if (line.IndexOf(extraction.Key, StringComparison.Ordinal) < 0)
                    {
                        continue;
                    }

                    foundKey = extraction.Key;
                    extraction.Value(discoveryEvent, line);
                    break;
                }
                if (foundKey != null)
                {
                    extractions.Remove(foundKey);
                }
            }
            OnDeviceDiscovery(discoveryEvent);
        }
Example #6
0
        public void HandleDiscoveryEvent(DeviceDiscoveryEvent deviceDiscoveryEvent)
        {
            Dictionary <string, SignalEventDetails> receiverTransmitters;

            if (!_eventsByReceiver.TryGetValue(deviceDiscoveryEvent.BleReceiver, out receiverTransmitters))
            {
                return;
            }
            SignalEventDetails eventDetails;

            if (!receiverTransmitters.TryGetValue(deviceDiscoveryEvent.DeviceDetails.MacAddress, out eventDetails))
            {
                return;
            }
            eventDetails.Rssi      = deviceDiscoveryEvent.Rssi;
            eventDetails.TimeStamp = deviceDiscoveryEvent.TimeStamp;
            eventDetails.Distance  = _signalToDistanceConverter.GetDistance(deviceDiscoveryEvent.Rssi);
            if (TransmitterSignalDiscovered != null)
            {
                TransmitterSignalDiscovered(eventDetails);
            }
        }
Example #7
0
        private void HandleDiscoveryEvent(DeviceDiscoveryEvent discoveryEvent)
        {
            if (!_monitoringEvents)
            {
                return;
            }
            if (OnRegisteredTransmitterEvent != null)
            {
                OnRegisteredTransmitterEvent(discoveryEvent);
            }
            if (!_capturingEvents)
            {
                return;
            }
            List <DeviceDiscoveryEvent> events;

            lock (_captureLock)
            {
                if (!_capturingEvents || discoveryEvent.DeviceDetails.MacAddress.IsNullOrEmpty())
                {
                    return;
                }
                var signalStrength = discoveryEvent.Rssi;
                var receiver       = discoveryEvent.BleReceiver;
                if (signalStrength < receiver.SignalPassLowerBound || signalStrength > receiver.SignalPassUpperBound)
                {
                    OnLogMessage(string.Format("Rssi={0} out of range [{1}:{2}] for {3}", signalStrength,
                                               receiver.SignalPassLowerBound, receiver.SignalPassUpperBound, receiver.IPAddress));
                    return;
                }
                if (!_capturedEventsSession.CapturedEvents.TryGetValue(discoveryEvent.DeviceDetails.MacAddress, out events))
                {
                    return;
                }
                events.Add(discoveryEvent);
            }
        }