public DownlinkPktFwdMessage Serialize(string appKey, string datr, double freq, long tmst, string devEUI)
        {
            var algoinput = this.Mhdr.ToArray().Concat(this.AppNonce.ToArray()).Concat(this.NetID.ToArray()).Concat(this.DevAddr.ToArray()).Concat(this.DlSettings.ToArray()).Concat(this.RxDelay.ToArray()).ToArray();
            if (!this.CfList.Span.IsEmpty)
                algoinput = algoinput.Concat(this.CfList.ToArray()).ToArray();

            this.CalculateMic(appKey, algoinput);
            this.PerformEncryption(appKey);

            var downlinkPktFwdMessage = new DownlinkPktFwdMessage(this.GetByteMessage(), datr, freq, tmst);
            if (Logger.LoggerLevel < LogLevel.Information)
            {
                var jsonMsg = JsonConvert.SerializeObject(downlinkPktFwdMessage);

                if (devEUI.Length != 0)
                {
                    Logger.Log(devEUI, $"{((LoRaMessageType)this.Mhdr.Span[0]).ToString()} {jsonMsg}", LogLevel.Debug);
                }
                else
                {
                    Logger.Log(ConversionHelper.ByteArrayToString(this.DevAddr.Span.ToArray()), $"{((LoRaMessageType)this.Mhdr.Span[0]).ToString()} {jsonMsg}", LogLevel.Debug);
                }
            }

            return downlinkPktFwdMessage;
        }
        async Task IPacketForwarder.SendDownstreamAsync(DownlinkPktFwdMessage downstreamMessage)
        {
            try
            {
                if (downstreamMessage?.Txpk != null)
                {
                    var jsonMsg     = JsonConvert.SerializeObject(downstreamMessage);
                    var messageByte = Encoding.UTF8.GetBytes(jsonMsg);
                    var token       = await this.GetTokenAsync();

                    PhysicalPayload pyld = new PhysicalPayload(token, PhysicalIdentifier.PULL_RESP, messageByte);
                    if (this.pullAckRemoteLoRaAggregatorPort != 0 && !string.IsNullOrEmpty(this.pullAckRemoteLoRaAddress))
                    {
                        Logger.Log("UDP", $"sending message with ID {ConversionHelper.ByteArrayToString(token)}, to {this.pullAckRemoteLoRaAddress}:{this.pullAckRemoteLoRaAggregatorPort}", LogLevel.Debug);
                        await this.UdpSendMessageAsync(pyld.GetMessage(), this.pullAckRemoteLoRaAddress, this.pullAckRemoteLoRaAggregatorPort);

                        Logger.Log("UDP", $"message sent with ID {ConversionHelper.ByteArrayToString(token)}", LogLevel.Debug);
                    }
                    else
                    {
                        Logger.Log(
                            "UDP",
                            "waiting for first pull_ack message from the packet forwarder. The received message was discarded as the network server is still starting.",
                            LogLevel.Debug);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Log("UDP", $"error processing the message {ex.Message}, {ex.StackTrace}", LogLevel.Error);
            }
        }
Пример #3
0
        public override void NotifySucceeded(LoRaDevice loRaDevice, DownlinkPktFwdMessage downlink)
        {
            base.NotifySucceeded(loRaDevice, downlink);

            this.ResponseDownlink    = downlink;
            this.ProcessingSucceeded = true;
            this.complete.Release();
        }
Пример #4
0
        public LoRaMessageWrapper(LoRaPayload payload, LoRaMessageType type, byte[] physicalToken, string datr, uint rfch, double freq, long tmst)
        {
            LoRaPayloadMessage = payload;
            PktFwdPayload      = new DownlinkPktFwdMessage(Convert.ToBase64String(LoRaPayloadMessage.GetByteMessage()), datr, rfch, freq, tmst);
            var jsonMsg = JsonConvert.SerializeObject(PktFwdPayload);

            Logger.Log(ConversionHelper.ByteArrayToString(payload.GetLoRaMessage().DevEUI.ToArray()), $"{((MType)(payload.Mhdr.Span[0])).ToString()} {jsonMsg}", Logger.LoggingLevel.Full);
            var messageBytes = Encoding.Default.GetBytes(jsonMsg);

            PhysicalPayload = new PhysicalPayload(physicalToken, PhysicalIdentifier.PULL_RESP, messageBytes);
        }
Пример #5
0
        private void EnsureDownlinkIsCorrect(DownlinkPktFwdMessage downlink, SimulatedDevice simDevice, ReceivedLoRaCloudToDeviceMessage sentMessage)
        {
            Assert.NotNull(downlink);
            Assert.NotNull(downlink.Txpk);
            Assert.True(downlink.Txpk.Imme);
            Assert.Equal(0, downlink.Txpk.Tmst);
            Assert.NotEmpty(downlink.Txpk.Data);

            byte[] downstreamPayloadBytes = Convert.FromBase64String(downlink.Txpk.Data);
            var    downstreamPayload      = new LoRaPayloadData(downstreamPayloadBytes);

            Assert.Equal(sentMessage.Fport, downstreamPayload.GetFPort());
            Assert.Equal(downstreamPayload.DevAddr.ToArray(), ConversionHelper.StringToByteArray(simDevice.DevAddr));
            var decryptedPayload = downstreamPayload.GetDecryptedPayload(simDevice.AppSKey);

            Assert.Equal(sentMessage.Payload, Encoding.UTF8.GetString(decryptedPayload));
        }
Пример #6
0
 /// <summary>
 /// This contructor is used in case of downlink message
 /// </summary>
 /// <param name="inputMessage"></param>
 /// <param name="type">
 /// 0 = Join Request
 /// 1 = Join Accept
 /// 2 = Unconfirmed Data up
 /// 3 = Unconfirmed Data down
 /// 4 = Confirmed Data up
 /// 5 = Confirmed Data down
 /// 6 = Rejoin Request</param>
 public LoRaMessageWrapper(LoRaPayload payload, LoRaMessageType type, byte[] physicalToken)
 {
     LoRaPayloadMessage = payload;
     // construct a Join Accept Message
     if (type == LoRaMessageType.JoinAccept)
     {
         var downlinkmsg = new DownlinkPktFwdMessage(Convert.ToBase64String(payload.GetByteMessage()));
         PktFwdPayload = downlinkmsg;
         var jsonMsg      = JsonConvert.SerializeObject(downlinkmsg);
         var messageBytes = Encoding.Default.GetBytes(jsonMsg);
         PhysicalPayload = new PhysicalPayload(physicalToken, PhysicalIdentifier.PULL_RESP, messageBytes);
     }
     else if (type == LoRaMessageType.UnconfirmedDataDown)
     {
         throw new NotImplementedException();
     }
     else if (type == LoRaMessageType.ConfirmedDataDown)
     {
         throw new NotImplementedException();
     }
 }
 public override void NotifySucceeded(LoRaDevice loRaDevice, DownlinkPktFwdMessage downlink)
 {
     this.wrappedRequest.NotifySucceeded(loRaDevice, downlink);
     this.LogProcessingTime(loRaDevice?.DevEUI);
 }
 internal DownlinkMessageBuilderResponse(DownlinkPktFwdMessage downlinkPktFwdMessage, bool isMessageTooLong)
 {
     this.DownlinkPktFwdMessage = downlinkPktFwdMessage;
     this.IsMessageTooLong      = isMessageTooLong;
 }
 public LoRaDeviceRequestProcessResult(LoRaDevice loRaDevice, LoRaRequest request, DownlinkPktFwdMessage downlinkMessage = null)
 {
     this.LoRaDevice      = loRaDevice;
     this.Request         = request;
     this.DownlinkMessage = downlinkMessage;
 }
 public virtual void NotifySucceeded(LoRaDevice loRaDevice, DownlinkPktFwdMessage downlink)
 {
 }
Пример #11
0
 public Task SendDownstreamAsync(DownlinkPktFwdMessage message)
 {
     this.DownlinkMessages.Add(message);
     return(Task.FromResult(0));
 }