Dela via

Skicka och ta emot meddelanden från molnet till enheten

  • Artikel

Azure IoT Hub är en fullständigt hanterad tjänst som möjliggör dubbelriktad kommunikation, inklusive C2D-meddelanden (moln-till-enhet) från lösningens serverdelar till miljontals enheter.

Den här artikeln beskriver hur du använder Azure IoT SDK:er för att skapa följande typer av program:

  • Enhetsprogram som tar emot och hanterar meddelanden från molnet till enheten från en IoT Hub-meddelandekö.

  • Serverdelsprogram som skickar meddelanden från molnet till enheten till en enda enhet via en IoT Hub-meddelandekö.

Den här artikeln är avsedd att komplettera runnable SDK-exempel som refereras inifrån den här artikeln.

Kommentar

De funktioner som beskrivs i den här artikeln är endast tillgängliga på standardnivån för IoT Hub. Mer information om de grundläggande och standard-/kostnadsfria IoT Hub-nivåerna finns i Välj rätt IoT Hub-nivå för din lösning.

Översikt

För att ett enhetsprogram ska kunna ta emot meddelanden från molnet till enheten måste det ansluta till IoT Hub och sedan konfigurera en meddelandehanterare för att bearbeta inkommande meddelanden. Azure IoT Hub-enhetens SDK:er tillhandahåller klasser och metoder som en enhet kan använda för att ta emot och hantera meddelanden från tjänsten. Den här artikeln beskriver viktiga element i alla enhetsprogram som tar emot meddelanden, inklusive:

  • Deklarera ett enhetsklientobjekt
  • Ansluta till IoT Hub
  • Hämta meddelanden från IoT Hub-meddelandekön
  • Bearbeta meddelandet och skicka tillbaka en bekräftelse till IoT Hub
  • Konfigurera en återförsöksprincip för mottagna meddelanden

För att ett serverdelsprogram ska kunna skicka meddelanden från moln till enhet måste det ansluta till en IoT Hub och skicka meddelanden via en IoT Hub-meddelandekö. Azure IoT Hub-tjänstens SDK:er tillhandahåller klasser och metoder som ett program kan använda för att skicka meddelanden till enheter. Den här artikeln beskriver viktiga element i alla program som skickar meddelanden till enheter, inklusive:

  • Deklarera ett tjänstklientobjekt
  • Ansluta till IoT Hub
  • Skapa och skicka meddelandet
  • Få feedback om leverans
  • Konfigurera en återförsöksprincip för att skicka meddelanden

Förstå meddelandekön

För att förstå meddelanden från moln till enhet är det viktigt att förstå några grunder om hur IoT Hub-enhetsmeddelandeköer fungerar.

Meddelanden från moln till enhet som skickas från ett serverdelsprogram för lösningen till en IoT-enhet dirigeras via IoT Hub. Det finns ingen direkt peer-to-peer-meddelandekommunikation mellan lösningens serverdelsprogram och målenheten. IoT Hub placerar inkommande meddelanden i sin meddelandekö, redo att laddas ned av IoT-målenheter.

För att garantera meddelandeleverans minst en gång bevarar IoT Hub meddelanden från moln till enhet i köer per enhet. Enheter måste uttryckligen bekräfta slutförandet av ett meddelande innan IoT Hub tar bort meddelandet från kön. Den här metoden garanterar återhämtning mot anslutnings- och enhetsfel.

När IoT Hub placerar ett meddelande i en enhetsmeddelandekö anger det meddelandetillståndet till Enqueued. När en enhetstråd tar ett meddelande från kön låser IoT Hub meddelandet genom att ange meddelandetillståndet till Osynligt. Det här tillståndet förhindrar att andra trådar på enheten bearbetar samma meddelande. När en enhetstråd slutför bearbetningen av ett meddelande meddelar den IoT Hub och sedan anger IoT Hub meddelandetillståndet till Slutfört.

Ett enhetsprogram som tar emot och bearbetar ett meddelande sägs slutföra meddelandet. Men om det behövs kan en enhet också:

  • Avvisa meddelandet, vilket gör att IoT Hub ställer in det på tillståndet Död bokstav. Enheter som ansluter via MQTT-protokollet (Message Queuing Telemetry Transport) kan inte avvisa meddelanden från moln till enhet.
  • Överge meddelandet, vilket gör att IoT Hub placerar tillbaka meddelandet i kön, med meddelandetillståndet inställt på Enqueued. Enheter som ansluter via MQTT-protokollet kan inte överge meddelanden från moln till enhet.

Mer information om meddelandelivscykeln från moln till enhet och hur IoT Hub bearbetar meddelanden från moln till enhet finns i Skicka meddelanden från moln till enhet från en IoT-hubb.

Ta emot meddelanden från moln till enhet

I det här avsnittet beskrivs hur du tar emot meddelanden från molnet till enheten med klassen DeviceClient i Azure IoT SDK för .NET.

Det finns två alternativ som ett enhetsklientprogram kan använda för att ta emot meddelanden:

  • Avsökning: Enhetsprogrammet söker efter nya IoT Hub-meddelanden med hjälp av en kodloop (till exempel en while eller for -loop). Loopen körs kontinuerligt och söker efter meddelanden.
  • Återanrop: Enhetsprogrammet konfigurerar en asynkron meddelandehanterare som anropas omedelbart när ett meddelande tas emot.

Deklarera ett DeviceClient-objekt

DeviceClient innehåller metoder och egenskaper som krävs för att ta emot meddelanden från IoT Hub.

Till exempel:

static DeviceClient deviceClient;

Ange anslutningsparametrarna

Ange det primära IoT Hub-niska veze- och enhets-ID:t till DeviceClient med metoden CreateFromConnectionString. Förutom den obligatoriska primära IoT Hub-niska veze CreateFromConnectionString kan metoden överbelastas för att inkludera följande valfria parametrar:

  • transportType – Transportprotokollet: varianter av HTTP version 1, AMQP eller MQTT. AMQP används som standard. Information om hur du ser alla tillgängliga värden finns i TransportType Enum.
  • transportSettings – Gränssnitt som används för att definiera olika transportspecifika inställningar för DeviceClient och ModuleClient. Mer information finns i ITransportSettings Interface.
  • ClientOptions – Alternativ som tillåter konfiguration av enhets- eller modulklientinstansen under initieringen.

I det här exemplet anropas CreateFromConnectionString för att definiera DeviceClient inställningarna för anslutnings-IoT Hub och enhets-ID.

static string connectionString = "{your IoT hub connection string}";
static string deviceID = "{your device ID}";
deviceClient = DeviceClient.CreateFromConnectionString(connectionString,deviceID);

avsökning

Avsökning använder ReceiveAsync för att söka efter meddelanden.

Ett anrop till ReceiveAsync kan ha följande formulär:

  • ReceiveAsync() – Vänta till standardtidsgränsen för ett meddelande innan du fortsätter.
  • ReceiveAsync (Timespan) – Ta emot ett meddelande från enhetskön med en specifik tidsgräns.
  • ReceiveAsync (CancellationToken) – Ta emot ett meddelande från enhetskön med en annulleringstoken. När du använder en annulleringstoken används inte standardtidsgränsen.

När du använder en transporttyp av HTTP 1 i stället för MQTT eller AMQP ReceiveAsync returnerar metoden omedelbart. Det mönster som stöds för meddelanden från moln till enhet med HTTP 1 är tillfälligt anslutna enheter som söker efter meddelanden sällan (minst var 25:e minut). Att utfärda fler HTTP 1 tar emot resultat i IoT Hub som begränsar begäranden. Mer information om skillnaderna mellan MQTT-, AMQP- och HTTP 1-stöd finns i Vägledning för kommunikation från moln till enhet och Välj ett kommunikationsprotokoll.

CompleteAsync-metod

När enheten har tagit emot ett meddelande anropar enhetsprogrammet metoden CompleteAsync för att meddela IoT Hub att meddelandet har bearbetats och att meddelandet kan tas bort från IoT Hub-enhetskön på ett säkert sätt. Enheten bör anropa den här metoden när bearbetningen slutförs oavsett vilket transportprotokoll den använder.

Meddelande som överges, avvisas eller överskrids

Med protokollen AMQP och HTTP version 1, men inte MQTT-protokollet, kan enheten också:

  • Överge ett meddelande genom att anropa AbandonAsync. Detta resulterar i att IoT Hub behåller meddelandet i enhetskön för framtida förbrukning.
  • Avvisa ett meddelande genom att anropa RejectAsync. Detta tar bort meddelandet permanent från enhetskön.

Om något händer som hindrar enheten från att slutföra, avbryta eller avvisa meddelandet kommer IoT Hub efter en fast tidsgräns att köa meddelandet för leverans igen. Därför måste logiken för meddelandebearbetning i enhetsappen vara idempotent, så att samma meddelande får samma resultat flera gånger.

Mer information om meddelandelivscykeln från moln till enhet och hur IoT Hub bearbetar meddelanden från moln till enhet finns i Skicka meddelanden från moln till enhet från en IoT-hubb.

Avsökningsloop

Med hjälp av avsökning använder ett program en kodloop som anropar ReceiveAsync metoden upprepade gånger för att söka efter nya meddelanden tills den stoppas.

Om du använder ReceiveAsync med ett timeout-värde eller en standardtimeout väntar varje anrop ReceiveAsync i loopen på den angivna tidsgränsen. Om ReceiveAsync tidsgränsen överskrids returneras ett null värde och loopen fortsätter.

När ett meddelande tas emot returneras ett aktivitetsobjekt av ReceiveAsync som ska skickas till CompleteAsync. Ett anrop till CompleteAsync meddelar IoT Hub att ta bort det angivna meddelandet från meddelandekön baserat på parametern Task .

I det här exemplet anropas ReceiveAsync loopen tills ett meddelande tas emot eller avsökningsloopen stoppas.

static bool stopPolling = false;

while (!stopPolling)
{
   // Check for a message. Wait for the default DeviceClient timeout period.
   using Message receivedMessage = await _deviceClient.ReceiveAsync();

   // Continue if no message was received
   if (receivedMessage == null)
   {
      continue;
   }
   else  // A message was received
   {
      // Print the message received
      Console.WriteLine($"{DateTime.Now}> Polling using ReceiveAsync() - received message with Id={receivedMessage.MessageId}");
      PrintMessage(receivedMessage);

      // Notify IoT Hub that the message was received. IoT Hub will delete the message from the message queue.
      await _deviceClient.CompleteAsync(receivedMessage);
      Console.WriteLine($"{DateTime.Now}> Completed C2D message with Id={receivedMessage.MessageId}.");
   }

   // Check to see if polling loop should end
   stopPolling = ShouldPollingstop ();
}

Motringning

För att kunna ta emot meddelanden från molnet till enheten i enhetsprogrammet måste programmet ansluta till IoT Hub och konfigurera en lyssnare för återanrop för att bearbeta inkommande meddelanden. Inkommande meddelanden till enheten tas emot från IoT Hub-meddelandekön.

Med hjälp av återanrop konfigurerar enhetsprogrammet en meddelandehanterarmetod med SetReceiveMessageHandlerAsync. Meddelandehanteraren anropas och sedan tas ett meddelande emot. Om du skapar en motringningsmetod för att ta emot meddelanden tas behovet av att kontinuerligt söka efter mottagna meddelanden bort.

Återanrop är endast tillgängligt med hjälp av följande protokoll:

  • Mqtt
  • Mqtt_WebSocket_Only
  • Mqtt_Tcp_Only
  • Amqp
  • Amqp_WebSocket_Only
  • Amqp_Tcp_only

Protokollalternativet Http1 stöder inte återanrop eftersom SDK-metoderna skulle behöva söka efter mottagna meddelanden ändå, vilket motverkar återanropsprincipen.

I det här exemplet SetReceiveMessageHandlerAsync konfigurerar du en motringningshanterare med namnet OnC2dMessageReceivedAsync, som anropas varje gång ett meddelande tas emot.

// Subscribe to receive C2D messages through a callback (which isn't supported over HTTP).
await deviceClient.SetReceiveMessageHandlerAsync(OnC2dMessageReceivedAsync, deviceClient);
Console.WriteLine($"\n{DateTime.Now}> Subscribed to receive C2D messages over callback.");

Ta emot princip för återförsök av meddelande

Principen för återförsök av enhetsklientmeddelande kan definieras med hjälp av DeviceClient.SetRetryPolicy.

Tidsgränsen för återförsök av meddelandet lagras i egenskapen DeviceClient.OperationTimeoutInMilliseconds .

Exempel på SDK-mottagningsmeddelande

.NET/C# SDK innehåller ett exempel på meddelande ta emot som innehåller metoderna för att ta emot meddelanden som beskrivs i det här avsnittet.

Skicka meddelanden från moln till enhet

I det här avsnittet beskrivs viktig kod för att skicka ett meddelande från ett serverdelsprogram för lösningen till en IoT-enhet med hjälp av klassen ServiceClient i Azure IoT SDK för .NET. Som tidigare nämnts ansluter ett serverdelsprogram för lösningen till en IoT Hub och meddelanden skickas till IoT Hub-kodade med en målenhet. IoT Hub lagrar inkommande meddelanden i meddelandekön och meddelanden levereras från IoT Hub-meddelandekön till målenheten.

Ett serverdelsprogram för lösningen kan också begära och ta emot leveransfeedback för ett meddelande som skickas till IoT Hub som är avsett för enhetsleverans via meddelandekön.

Deklarera ett ServiceClient-objekt

ServiceClient innehåller metoder och egenskaper som krävs för att skicka meddelanden från ett program via IoT Hub till en enhet.

static ServiceClient serviceClient;

Ange niska veze

Ange den primära IoT Hub-niska veze med ServiceClient metoden CreateFromConnectionString. Förutom den obligatoriska primära IoT Hub-niska veze CreateFromConnectionString kan metoden överbelastas för att inkludera följande valfria parametrar:

  • transportType - Amqp eller Amqp_WebSocket_Only.
  • transportSettings – AMQP- och HTTP-proxyinställningarna för tjänstklienten.
  • ServiceClientOptions – Alternativ som tillåter konfiguration av tjänstklientinstansen under initieringen. Mer information finns i ServiceClientOptions.

Det här exemplet skapar ServiceClient objektet med hjälp av IoT Hub-niska veze.

static string connectionString = "{your iot hub connection string}";
serviceClient = ServiceClient.CreateFromConnectionString(connectionString);

Skicka ett asynkront meddelande från moln till enhet

Använd sendAsync för att skicka ett asynkront meddelande från ett program via molnet (IoT Hub) till enheten. Anropet görs med hjälp av AMQP-protokollet.

sendAsync använder följande parametrar:

  • deviceID – Strängidentifieraren för målenheten.
  • message – Meddelandet från moln till enhet. Meddelandet är av typen Meddelande och kan formateras därefter.
  • timeout – Ett valfritt timeout-värde. Standardvärdet är en minut om det är ospecificerat.

I det här exemplet skickas ett testmeddelande till målenheten med ett timeoutvärde på 10 sekunder.

string targetDevice = "Device-1";
static readonly TimeSpan operationTimeout = TimeSpan.FromSeconds(10);
var commandMessage = new
Message(Encoding.ASCII.GetBytes("Cloud to device message."));
await serviceClient.SendAsync(targetDevice, commandMessage, operationTimeout);

Få feedback om leverans

Ett sändningsprogram kan begära leveransbekräftelser (eller förfallodatum) från IoT Hub för varje meddelande från moln till enhet. Med det här alternativet kan sändningsprogrammet använda informations-, återförsöks- eller kompensationslogik. En fullständig beskrivning av åtgärder och egenskaper för feedback om meddelanden beskrivs i Meddelandefeedback.

Så här tar du emot feedback om meddelandeleverans:

  • Skapa objektet feedbackReceiver
  • Skicka meddelanden med parametern Ack
  • Vänta med att få feedback

Skapa feedbackReceiver-objektet

Anropa GetFeedbackReceiver för att skapa ett FeedbackReceiver-objekt . FeedbackReceiver innehåller metoder som tjänster kan använda för att utföra feedbackåtgärder.

var feedbackReceiver = serviceClient.GetFeedbackReceiver();

Skicka meddelanden med hjälp av parametern Ack

Varje meddelande måste innehålla ett värde för leveransbekräftelseegenskapen Ack för att få feedback om leveransen. Egenskapen Ack kan vara ett av följande värden:

  • none (standard): inget feedbackmeddelande genereras.

  • Positive: få ett feedbackmeddelande om meddelandet har slutförts.

  • Negative: få ett feedbackmeddelande om meddelandet har upphört att gälla (eller maximalt antal leveranser har nåtts) utan att slutföras av enheten.

  • Full: feedback för både Positive och Negative resultat.

I det här exemplet är egenskapen Ack inställd på Fulloch begär feedback om både positiv eller negativ meddelandeleverans för ett meddelande.

var commandMessage = new
Message(Encoding.ASCII.GetBytes("Cloud to device message."));
commandMessage.Ack = DeliveryAcknowledgement.Full;
await serviceClient.SendAsync(targetDevice, commandMessage);

Vänta med att få feedback

Definiera en CancellationToken. I en loop anropar du Sedan ReceiveAsync upprepade gånger och söker efter feedbackmeddelanden om leverans. Varje anrop väntar ReceiveAsync på den tidsgräns som definierats för ServiceClient objektet.

  • Om en ReceiveAsync tidsgräns upphör att gälla utan att något meddelande tas emot ReceiveAsync returneras null och loopen fortsätter.
  • Om ett feedbackmeddelande tas emot returneras ett aktivitetsobjekt av ReceiveAsync som ska skickas till CompleteAsync tillsammans med annulleringstoken. Ett anrop för att CompleteAsync ta bort det angivna skickade meddelandet från meddelandekön baserat på parametern Task .
  • Om det behövs kan mottagningskoden anropa AbandonAsync för att skicka tillbaka ett meddelande i kön.
var feedbackReceiver = serviceClient.GetFeedbackReceiver();

// Define the cancellation token.
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
// Call ReceiveAsync, passing the token. Wait for the timout period.
var feedbackBatch = await feedbackReceiver.ReceiveAsync(token);
if (feedbackBatch == null) continue;

Det här exemplet visar en metod som innehåller de här stegen.

private async static void ReceiveFeedbackAsync()
{
      var feedbackReceiver = serviceClient.GetFeedbackReceiver();

      Console.WriteLine("\nReceiving c2d feedback from service");
      while (true)
      {
         // Check for messages, wait for the timeout period.
         var feedbackBatch = await feedbackReceiver.ReceiveAsync();
         // Continue the loop if null is received after a timeout.
         if (feedbackBatch == null) continue;

         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine("Received feedback: {0}",
            string.Join(", ", feedbackBatch.Records.Select(f => f.StatusCode)));
         Console.ResetColor();

         await feedbackReceiver.CompleteAsync(feedbackBatch);
      }
   }

Observera att det här återkopplingsmönstret liknar det mönster som används för att ta emot meddelanden från molnet till enheten i enhetsappen.

Återanslutning av tjänstklient

När ett undantag uppstår vidarebefordrar tjänstklienten den informationen till det anropande programmet. Då rekommenderar vi att du inspekterar undantagsinformationen och vidtar nödvändiga åtgärder.

Till exempel:

  • Om det är ett nätverksfel kan du försöka utföra åtgärden igen.
  • Om det är ett säkerhetsfel (obehörigt undantag) kontrollerar du dina autentiseringsuppgifter och kontrollerar att de är uppdaterade.
  • Om det är ett undantag för begränsning/kvot överskreds övervakar du och/eller ändrar frekvensen för att skicka begäranden eller uppdaterar hubbinstansens skalningsenhet. Mer information finns i kvoter och begränsningar för IoT Hub.

Återförsöksprincip för skicka meddelande

Principen ServiceClient för återförsök av meddelanden kan definieras med hjälp av ServiceClient.SetRetryPolicy.

Exempel på SDK-sändningsmeddelande

.NET/C# SDK innehåller ett tjänstklientexempel som innehåller metoderna för att skicka meddelanden som beskrivs i det här avsnittet.

Ta emot meddelanden från moln till enhet

I det här avsnittet beskrivs hur du tar emot meddelanden från molnet till enheten med klassen DeviceClient från Azure IoT SDK för Java.

För att ett Java-baserat enhetsprogram ska kunna ta emot meddelanden från molnet till enheten måste det ansluta till IoT Hub och sedan konfigurera en lyssnare och meddelandehanterare för att bearbeta inkommande meddelanden från IoT Hub. Enhetsappen bör också kunna identifiera och hantera frånkopplingar om meddelandeanslutningen mellan enheter och IoT Hub bryts.

Importera Azure IoT Java SDK-bibliotek

Koden som refereras i den här artikeln använder dessa SDK-bibliotek.

import com.microsoft.azure.sdk.iot.device.*;
import com.microsoft.azure.sdk.iot.device.exceptions.IotHubClientException;
import com.microsoft.azure.sdk.iot.device.transport.IotHubConnectionStatus;

Deklarera ett DeviceClient-objekt

Instansiering av DeviceClient-objekt kräver följande parametrar:

  • connString – IoT-enheten niska veze. Niska veze är en uppsättning nyckel/värde-par som avgränsas med ';', med nycklar och värden avgränsade med '='. Den bör innehålla värden för dessa nycklar: HostName, DeviceId, and SharedAccessKey.
  • Transportprotokoll – Anslutningen DeviceClient kan använda något av följande IoTHubClientProtocol-transportprotokoll . AMQP är den mest mångsidiga, gör det möjligt att kontrollera meddelanden ofta och tillåter avvisande av meddelanden och avbryta. MQTT stöder inte metoder för avvisande av meddelanden eller avbrutna meddelanden:
    • AMQPS
    • AMQPS_WS
    • HTTPS
    • MQTT
    • MQTT_WS

Till exempel:

static string connectionString = "{a device connection string}";
static protocol = IotHubClientProtocol.AMQPS;
DeviceClient client = new DeviceClient(connectionString, protocol);

Ange metoden för återanrop av meddelande

Använd metoden setMessageCallback för att definiera en meddelandehanteraresmetod som meddelas när ett meddelande tas emot från IoT Hub.

setMessageCallback innehåller följande parametrar:

  • callback – Namn på återanropsmetod. Kan vara null.
  • context – En valfri kontext av typen object. Använd null om det är ospecificerat.

I det här exemplet skickas en callback metod med namnet MessageCallback utan kontextparameter till setMessageCallback.

client.setMessageCallback(new MessageCallback(), null);

Skapa en hanterare för motringning av meddelanden

En meddelandehanterare för återanrop tar emot och bearbetar ett inkommande meddelande som skickas från IoT Hub-meddelandekön.

I det här exemplet bearbetar meddelandehanteraren ett inkommande meddelande och returnerar sedan IotHubMessageResult.COMPLETE. Ett IotHubMessageResult.COMPLETE returvärde meddelar IoT Hub att meddelandet har bearbetats och att meddelandet kan tas bort på ett säkert sätt från enhetskön. Enheten bör returneras IotHubMessageResult.COMPLETE när bearbetningen har slutförts och meddelar IoT Hub att meddelandet ska tas bort från meddelandekön, oavsett vilket protokoll den använder.

  protected static class MessageCallback implements com.microsoft.azure.sdk.iot.device.MessageCallback
  {
      public IotHubMessageResult onCloudToDeviceMessageReceived(Message msg, Object context)
      {
          System.out.println(
                  "Received message with content: " + new String(msg.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET));
          // Notify IoT Hub that the message
          return IotHubMessageResult.COMPLETE;
      }
  }

Alternativ för att avbryta och avvisa meddelanden

Även om det stora antalet inkommande meddelanden till en enhet ska tas emot och resultera i IotHubMessageResult.COMPLETEkan det vara nödvändigt att avbryta eller avvisa ett meddelande.

  • Med AMQP och HTTPS, men inte MQTT, kan ett program:
    • IotHubMessageResult.ABANDON meddelandet. IoT-hubben skickar den igen och skickar den igen senare.
    • IotHubMessageResult.REJECT meddelandet. IoT-hubben lämnar inte meddelandet på nytt och tar permanent bort meddelandet från meddelandekön.
  • Klienter som använder MQTT eller MQTT_WS inte kan ABANDON eller REJECT meddelanden.

Om något händer som hindrar enheten från att slutföra, avbryta eller avvisa meddelandet kommer IoT Hub efter en fast tidsgräns att köa meddelandet för leverans igen. Därför måste logiken för meddelandebearbetning i enhetsappen vara idempotent, så att samma meddelande får samma resultat flera gånger.

Mer information om meddelandelivscykeln från moln till enhet och hur IoT Hub bearbetar meddelanden från moln till enhet finns i Skicka meddelanden från moln till enhet från en IoT-hubb.

Kommentar

Om du använder HTTPS i stället för MQTT eller AMQP som transport söker DeviceClient-instansen efter meddelanden från IoT Hub sällan (minst var 25:e minut). Mer information om skillnaderna mellan MQTT-, AMQP- och HTTPS-stöd finns i Vägledning för kommunikation från moln till enhet och Välj ett kommunikationsprotokoll.

Skapa återanropsmetoden för meddelandetillstånd

Ett program kan använda registerConnectionStatusChangeCallback för att registrera en återanropsmetod som ska köras när enhetens anslutningsstatus ändras. På så sätt kan programmet identifiera en nedkopplad meddelandeanslutning och försöka återansluta.

I det här exemplet IotHubConnectionStatusChangeCallbackLogger registreras som återanropsmetod för ändring av anslutningsstatus.

client.registerConnectionStatusChangeCallback(new IotHubConnectionStatusChangeCallbackLogger(), new Object());

Återanropet utlöses och skickas ett ConnectionStatusChangeContext objekt.

Anropa connectionStatusChangeContext.getNewStatus() för att hämta det aktuella anslutningstillståndet.

IotHubConnectionStatus status = connectionStatusChangeContext.getNewStatus();

Anslutningstillståndet som returneras kan vara ett av följande värden:

  • IotHubConnectionStatus.DISCONNECTED
  • IotHubConnectionStatus.DISCONNECTED_RETRYING
  • IotHubConnectionStatus.CONNECTED

Anropa connectionStatusChangeContext.getNewStatusReason() för att hämta orsaken till ändringen av anslutningsstatusen.

IotHubConnectionStatusChangeReason statusChangeReason = connectionStatusChangeContext.getNewStatusReason();

Anropa connectionStatusChangeContext.getCause() för att hitta orsaken till ändringen av anslutningsstatusen. getCause() kan returneras null om ingen information är tillgänglig.

Throwable throwable = connectionStatusChangeContext.getCause();
if (throwable != null)
    throwable.printStackTrace();

I exemplet HandleMessages som visas i avsnittet exempel på SDK-ta emot meddelanden i den här artikeln finns ett fullständigt exempel som visar hur du extraherar status för ändring av status för återanropsmetod, orsak till att enhetens status har ändrats och kontexten.

Öppna anslutningen mellan enheten och IoT Hub

Använd öppna för att skapa en anslutning mellan enheten och IoT Hub. Enheten kan nu asynkront skicka och ta emot meddelanden till och från en IoT Hub. Om klienten redan är öppen gör metoden ingenting.

client.open(true);

Exempel på SDK-mottagningsmeddelande

HandleMessages: en exempelenhetsapp som ingår i Microsoft Azure IoT SDK för Java, som ansluter till din IoT-hubb och tar emot meddelanden från molnet till enheten.

Skicka meddelanden från moln till enhet

I det här avsnittet beskrivs hur du skickar ett meddelande från molnet till enheten med hjälp av klassen ServiceClient från Azure IoT SDK för Java. Ett serverdelsprogram för lösningen ansluter till en IoT Hub och meddelanden skickas till IoT Hub-kodade med en målenhet. IoT Hub lagrar inkommande meddelanden i meddelandekön och meddelanden levereras från IoT Hub-meddelandekön till målenheten.

Ett serverdelsprogram för lösningen kan också begära och ta emot leveransfeedback för ett meddelande som skickas till IoT Hub som är avsett för enhetsleverans via meddelandekön.

Lägg till beroendeutdraget

Lägg till beroendet för att använda iothub-java-service-client-paketet i ditt program för att kommunicera med din IoT Hub-tjänst:

<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.7.23</version>
</dependency>

Lägga till importinstruktioner

Lägg till dessa importinstruktioner för att använda Azure IoT Java SDK och undantagshanteraren.

import com.microsoft.azure.sdk.iot.service.*;
import java.io.IOException;
import java.net.URISyntaxException;

Definiera anslutningsprotokollet

Använd IotHubServiceClientProtocol för att definiera det protokoll på programnivå som används av tjänstklienten för att kommunicera med en IoT Hub.

IotHubServiceClientProtocol accepterar AMQPS endast uppräkningen eller AMQPS_WS .

private static final IotHubServiceClientProtocol protocol =    
    IotHubServiceClientProtocol.AMQPS;

Skapa ServiceClient-objektet

Skapa ServiceClient-objektet med Iot Hub-niska veze och protokoll.

private static final String connectionString = "{yourhubconnectionstring}";
private static final ServiceClient serviceClient (connectionString, protocol);

Öppna anslutningen mellan programmet och IoT Hub

öppna AMQP-avsändaranslutningen. Den här metoden skapar anslutningen mellan programmet och IoT Hub.

serviceClient.open();

Öppna en feedbackmottagare för feedback om meddelandeleverans

Du kan använda en FeedbackReceiver för att få skickad meddelandeleverans till IoT Hub-feedback. A FeedbackReceiver är en specialiserad mottagare vars Receive metod returnerar en FeedbackBatch i stället för en Message.

I det här exemplet FeedbackReceiver skapas objektet och instruktionen open() anropas för att invänta feedback.

FeedbackReceiver feedbackReceiver = serviceClient
  .getFeedbackReceiver();
if (feedbackReceiver != null) feedbackReceiver.open();

Lägg till meddelandeegenskaper

Du kan också använda setProperties för att lägga till meddelandeegenskaper. Dessa egenskaper ingår i meddelandet som skickas till enheten och kan extraheras av enhetsprogrammet vid mottagandet.

Map<String, String> propertiesToSend = new HashMap<String, String>();
propertiesToSend.put(messagePropertyKey,messagePropertyKey);
messageToSend.setProperties(propertiesToSend);

Skapa och skicka ett asynkront meddelande

Objektet Meddelande lagrar meddelandet som ska skickas. I det här exemplet levereras meddelandet "Moln till enhet".

Använd setDeliveryAcknowledgement för att begära leverans/inte levererad till IoT Hub-meddelandeköbekräftelse. I det här exemplet är Fullden begärda bekräftelsen , antingen levererad eller inte levererad.

Använd SendAsync för att skicka ett asynkront meddelande från klienten till enheten. Du kan också använda Send metoden (inte asynkron), men den här funktionen synkroniseras internt så att endast en sändningsåtgärd tillåts i taget. Meddelandet levereras från programmet till IoT Hub. IoT Hub placerar meddelandet i meddelandekön, redo att levereras till målenheten.

Message messageToSend = new Message("Cloud to device message.");
messageToSend.setDeliveryAcknowledgementFinal(DeliveryAcknowledgement.Full);
serviceClient.sendAsync(deviceId, messageToSend);

Få feedback om meddelandeleverans

När ett meddelande har skickats från programmet kan programmet anropa ta emot med eller utan ett timeout-värde. Om ett timeout-värde inte anges används standardtimeouten. Detta skickar tillbaka ett FeedbackBatch-objekt som innehåller feedbackegenskaper för meddelandeleverans som kan undersökas.

Det här exemplet skapar FeedbackBatch mottagaren och anropar getEnqueuedTimeUtc och skriver ut meddelandets kötid.

FeedbackBatch feedbackBatch = feedbackReceiver.receive(10000);
if (feedbackBatch != null) {
  System.out.println("Message feedback received, feedback time: "
    + feedbackBatch.getEnqueuedTimeUtc().toString());
}

SDK:et skickar meddelandeexempel

Installera Azure IoT SDK-biblioteket

Installera SDK-biblioteket för azure-iot-device på utvecklingsdatorn innan du anropar någon relaterad kod:

pip install azure-iot-device

Det finns två Python SDK-klasser som används för att skicka meddelanden till och från IoT-enheter. Metoder för meddelandehantering från dessa klasser beskrivs i avsnitt på den här sidan.

  • Klassen IoTHubDeviceClient innehåller metoder för att skapa en synkron anslutning från en enhet till en Azure IoT Hub och ta emot meddelanden från IoT Hub.

  • Klassen IoTHubRegistryManager innehåller API:er för IoT Hub Registry Manager-åtgärder. I den här artikeln visar metoder från den här klassen hur du ansluter till IoT Hub och skickar ett meddelande till en enhet.

Ta emot meddelanden från moln till enhet

I det här avsnittet beskrivs hur du tar emot meddelanden från molnet till enheten med klassen IoTHubDeviceClient från Azure IoT SDK för Python.

För att ett Python-baserat enhetsprogram ska kunna ta emot meddelanden från molnet till enheten måste det ansluta till IoT Hub och sedan konfigurera en samtalsmeddelandehanterare för att bearbeta inkommande meddelanden från IoT Hub.

Importera IoTHubDeviceClient-objektet

Lägg till en kodrad för att importera IoTHubDeviceClient funktionerna från azure.iot.device SDK.

from azure.iot.device import IoTHubDeviceClient

Ansluta enhetsklienten

Instansiera IoTHubDeviceClient och skicka en IoT Hub-niska veze till create_from_connection_string. Detta skapar en anslutning från enheten till IoT Hub.

Du kan också ansluta IoTHubDeviceClienttill en enhet med någon av följande metoder:

deviceConnectionString = "{your IoT hub connection string}";
client = IoTHubDeviceClient.create_from_connection_string ({deviceConnectionString})

Hantera återanslutning

IoTHubDeviceClient försöker som standard återupprätta en borttagen anslutning. Återanslutningsbeteendet styrs av connection_retry IoTHubDeviceClient och connection_retry_interval parametrarna.

Skapa en meddelandehanterare

Skapa meddelandehanterarfunktionen för att bearbeta inkommande meddelanden till enheten.

I det här exemplet message_handler anropas när ett meddelande tas emot. Meddelandeegenskaperna (.items) skrivs ut till konsolen med hjälp av en loop.

def message_handler(message):
    global RECEIVED_MESSAGES
    RECEIVED_MESSAGES += 1
    print("")
    print("Message received:")

    # print data from both system and application (custom) properties
    for property in vars(message).items():
        print ("    {}".format(property))

    print("Total calls received: {}".format(RECEIVED_MESSAGES))

Tilldela meddelandehanteraren

Använd metoden on_message_received för att tilldela meddelandehanterarmetoden till IoTHubDeviceClient objektet.

I det här exemplet kopplas en meddelandehanterarmetod med namnet message_handler till IoTHubDeviceClient client objektet. Objektet client väntar på att få ett meddelande från molnet till enheten från en IoT Hub. Den här koden väntar upp till 300 sekunder (5 minuter) på ett meddelande eller avslutas om en tangent trycks ned.

try:
    # Attach the handler to the client
    client.on_message_received = message_handler

    while True:
        time.sleep(300)
except KeyboardInterrupt:
    print("IoT Hub C2D Messaging device sample stopped")
finally:
    # Graceful exit
    print("Shutting down IoT Hub Client")
    client.shutdown()

Exempel på SDK-mottagningsmeddelande

Ta emot meddelande – Ta emot C2D-meddelanden (moln-till-enhet) som skickas från Azure IoT Hub till en enhet.

Skicka meddelanden från moln till enhet

I det här avsnittet beskrivs hur du skickar ett meddelande från molnet till enheten med klassen IoTHubRegistryManager från Azure IoT SDK för Python. Ett serverdelsprogram för lösningen ansluter till en IoT Hub och meddelanden skickas till IoT Hub-kodade med en målenhet. IoT Hub lagrar inkommande meddelanden i meddelandekön och meddelanden levereras från IoT Hub-meddelandekön till målenheten.

Importera IoTHubRegistryManager-objektet

Lägg till följande import instruktion. IoTHubRegistryManager innehåller API:er för IoT Hub Registry Manager-åtgärder.

from azure.iot.hub import IoTHubRegistryManager

Ansluta IoT Hub-registerhanteraren

Instansiera IoTHubRegistryManager-objektet som ansluter till en IoT-hubb och skicka en IoT Hub-niska veze till from_connection_string.

IoTHubConnectionString = "{Primary connection string to an IoT hub}"
registry_manager = IoTHubRegistryManager.from_connection_string(IoTHubConnectionString)

Skapa och skicka ett meddelande

Använd send_c2d_message för att skicka ett meddelande via molnet (IoT Hub) till enheten.

send_c2d_message använder följande parametrar:

  • deviceID – Strängidentifieraren för målenheten.
  • message – Meddelandet från moln till enhet. Meddelandet är av typen str (sträng).
  • properties – En valfri samling egenskaper av typen dict. Egenskaper kan innehålla programegenskaper och systemegenskaper. Standardvärdet är {}.

Det här exemplet skickar ett testmeddelande till målenheten.

# define the device ID
deviceID = "Device-1"

# define the message
message = "{\"c2d test message\"}"

# include optional properties
props={}
props.update(messageId = "message1")
props.update(prop1 = "test property-1")
props.update(prop1 = "test property-2")
prop_text = "Test message"
props.update(testProperty = prop_text)

# send the message through the cloud (IoT Hub) to the device
registry_manager.send_c2d_message(deviceID, message, properties=props)

Exempel på SDK-sändningsmeddelande

send_message.py – Visar hur du skickar ett meddelande från moln till enhet.

Installera Node.js meddelandepaket

Kör dessa kommandon för att installera paketen azure-iot-device och azure-iothub på utvecklingsdatorn:

npm install azure-iot-device --save
npm install azure-iothub --save

Paketet azure-iot-device innehåller objekt som samverkar med IoT-enheter. Den här artikeln beskriver Client klasskod som tar emot meddelanden från IoT Hub.

Azure-iothub-paketet innehåller objekt som samverkar med IoT Hub. I den här artikeln beskrivs Client klasskod som skickar ett meddelande från ett program till en enhet via IoT Hub.

Ta emot meddelanden i enhetsprogrammet

I det här avsnittet beskrivs hur du tar emot meddelanden från moln till enhet med azure-iot-device-paketet i Azure IoT SDK för Node.js.

För att ett Node.js-baserat enhetsprogram ska ta emot meddelanden från molnet till enheten måste det ansluta till IoT Hub och sedan konfigurera en lyssnare och meddelandehanterare för att bearbeta inkommande meddelanden från IoT Hub. Enhetsappen bör också kunna identifiera och hantera frånkopplingar om meddelandeanslutningen mellan enheter och IoT Hub bryts.

Skapa en klientmodul

Från paketet azure-iot-device skapar du en Client med hjälp av klassen Client . Klassen Client innehåller metoder som en enhet kan använda för att ta emot från och skicka till IoT Hub.

const Client = require('azure-iot-device').Client;

Välj ett transportprotokoll

Objektet Client stöder följande protokoll:

  • Amqp
  • Http – När du använder Httpsöker instansen Client efter meddelanden från IoT Hub sällan (minst var 25:e minut).
  • Mqtt
  • MqttWs
  • AmqpWs

Mer information om skillnaderna mellan MQTT-, AMQP- och HTTPS-stöd finns i Vägledning för kommunikation från moln till enhet och Välj ett kommunikationsprotokoll.

I det här exemplet tilldelas AMQP-protokollet till en Protocol variabel. Den här protokollvariabeln skickas till Client.fromConnectionString metoden i avsnittet Lägg till niska veze i den här artikeln.

const Protocol = require('azure-iot-device-mqtt').Amqp;

Funktioner för meddelandeavslut, avvisande och avbrutna meddelanden

Metoder för slutförande av meddelanden, avvisande och avbrutna meddelanden kan användas beroende på vilket protokoll som valts.

AMQP och HTTP

AMQP- och HTTP-transporterna kan slutföra, avvisa eller överge ett meddelande:

  • Slutför – För att slutföra ett meddelande meddelas tjänsten som skickade meddelandet från moln till enhet att meddelandet tas emot. IoT Hub tar bort meddelandet från meddelandekön. Metoden har formen client.complete(message, callback function).
  • Avvisa – Om du vill avvisa ett meddelande meddelas tjänsten som skickade meddelandet från molnet till enheten att meddelandet inte bearbetas av enheten. IoT Hub tar bort meddelandet permanent från enhetskön. Metoden har formen client.reject(message, callback function).
  • Abandon – Om du vill överge ett meddelande försöker IoT Hub omedelbart skicka det igen. IoT Hub behåller meddelandet i enhetskön för framtida förbrukning. Metoden har formen client.abandon(message, callback function).
MQTT

MQTT stöder inte funktioner för att slutföra, avvisa eller överge meddelanden. I stället accepterar MQTT ett meddelande som standard och meddelandet tas bort från IoT Hub-meddelandekön.

Försök att leverera igen

Om något händer som hindrar enheten från att slutföra, avbryta eller avvisa meddelandet kommer IoT Hub efter en fast tidsgräns att köa meddelandet för leverans igen. Därför måste logiken för meddelandebearbetning i enhetsappen vara idempotent, så att samma meddelande får samma resultat flera gånger.

Lägg till IoT Hub-strängen och transportprotokollet

Anropa fromConnectionString för att upprätta en anslutning mellan enheter och IoT-hubbar med hjälp av följande parametrar:

  • connStr – en niska veze som kapslar in "enhetsanslutningsbehörigheter" för en IoT-hubb. Niska veze innehåller värdnamn, enhets-ID och delad åtkomstnyckel i det här formatet: "HostName=<iothub_host_name>; DeviceId=<device_id>; SharedAccessKey=<device_key>"
  • transportCtor – transportprotokollet.
const Protocol = require('azure-iot-device-mqtt').Amqp;
let client = Client.fromConnectionString(deviceConnectionString, Protocol);

Skapa en inkommande meddelandehanterare

Meddelandehanteraren anropas för varje inkommande meddelande.

När ett meddelande har tagits emot anropar client.complete du metoden för att informera IoT Hub om att meddelandet kan tas bort från meddelandekön om du använder AMQP eller HTTP-transport.

Den här meddelandehanteraren skriver till exempel ut meddelande-ID:t och meddelandetexten till konsolen och anropar client.complete sedan för att meddela IoT Hub att det bearbetat meddelandet och att det säkert kan tas bort från enhetskön. Anropet till complete krävs inte om du använder MQTT-transport och kan utelämnas. Ett anrop tillcomplete krävs för AMQP- eller HTTPS-transport.

function messageHandler(msg) {
  console.log('Id: ' + msg.messageId + ' Body: ' + msg.data);
  client.complete(msg, printResultFor('completed'));
}

Skapa en anslutningskopplingshanterare

Frånkopplingshanteraren anropas när anslutningen kopplas från. En frånkopplingshanterare är användbar för att implementera återanslutningskod.

Det här exemplet fångar upp och visar felmeddelandet om frånkoppling till konsolen.

function disconnectHandler() {
  clearInterval(sendInterval);
  sendInterval = null;
  client.open().catch((err) => {
    console.error(err.message);
  });
}

Lägga till händelselyssnare

Du kan ange dessa händelselyssnare med hjälp av metoden .on .

  • Anslutningshanterare
  • Felhanterare
  • Koppla från hanteraren
  • Meddelandehanterare

Det här exemplet innehåller meddelande- och frånkopplingshanterare som definierats tidigare.

client.on('connect', connectHandler);
client.on('error', errorHandler);
client.on('disconnect', disconnectHandler);
client.on('message', messageHandler);

Öppna anslutningen till IoT Hub

Använd den öppna metoden för att öppna en anslutning mellan en IoT-enhet och IoT Hub. Använd .catch(err) för att fånga upp ett fel och anropa hanterarkod.

Till exempel:

client.open()
.catch((err) => {
  console.error('Could not connect: ' + err.message);
});

Exempel på SDK-mottagningsmeddelande

simple_sample_device – En enhetsapp som ansluter till din IoT-hubb och tar emot meddelanden från molnet till enheten.

Skicka meddelanden från moln till enhet

I det här avsnittet beskrivs hur du skickar ett meddelande från molnet till enheten med azure-iothub-paketet från Azure IoT SDK för Node.js. Som tidigare nämnts ansluter ett serverdelsprogram för lösningen till en IoT Hub och meddelanden skickas till IoT Hub-kodade med en målenhet. IoT Hub lagrar inkommande meddelanden i meddelandekön och meddelanden levereras från IoT Hub-meddelandekön till målenheten.

Ett serverdelsprogram för lösningen kan också begära och ta emot leveransfeedback för ett meddelande som skickas till IoT Hub som är avsett för enhetsleverans via meddelandekön.

Läs in klient- och meddelandemodulerna

Deklarera ett Client objekt med hjälp av Client -klassen från azure-iothub paketet.

Deklarera ett Message objekt med hjälp av Message -klassen från azure-iot-common paketet.

'use strict';
var Client = require('azure-iothub').Client;
var Message = require('azure-iot-common').Message;

Skapa klientobjektet

Skapa klienten med hjälp av fromConnectionString med hjälp av följande parametrar:

  • IoT Hub niska veze
  • Transporttyp

I det här exemplet skapas objektet serviceClient med Amqp transporttypen.

var connectionString = '{IoT Hub connection string}';
var serviceClient = Client.fromConnectionString(connectionString,`Amqp`);

Öppna klientanslutningen

Anropa den Client öppna metoden för att öppna en anslutning mellan ett program och IoT Hub.

open kan anropas med eller utan att ange en motringningsfunktion som anropas när åtgärden open är klar.

I det här exemplet open innehåller metoden en valfri återanropsfunktion err för öppen anslutning. Om ett öppet fel inträffar returneras ett felobjekt. Om den öppna anslutningen lyckas returneras ett null återanropsvärde.

serviceClient.open(function (err)
if (err)
  console.error('Could not connect: ' + err.message);

Skapa ett meddelande

Meddelandeobjektet innehåller det asynkrona meddelandet från molnet till enheten. Meddelandefunktionen fungerar på samma sätt över AMQP, MQTT och HTTP.

Meddelandeobjektet stöder flera egenskaper, inklusive dessa egenskaper. En fullständig lista finns i meddelandeegenskaperna .

  • ack - Feedback om leverans. Beskrivs i nästa avsnitt.
  • properties – En karta som innehåller strängnycklar och värden för lagring av anpassade meddelandeegenskaper.
  • messageId – används för att korrelera dubbelriktad kommunikation.

Lägg till meddelandetexten när meddelandeobjektet instansieras. I det här exemplet läggs ett 'Cloud to device message.' meddelande till.

var message = new Message('Cloud to device message.');
message.ack = 'full';
message.messageId = "My Message ID";

Leveransbekräftelse

Ett sändningsprogram kan begära leveransbekräftelser (eller förfallodatum) från IoT Hub för varje meddelande från moln till enhet. Med det här alternativet kan sändningsprogrammet använda informations-, återförsöks- eller kompensationslogik. En fullständig beskrivning av åtgärder och egenskaper för feedback om meddelanden beskrivs i Meddelandefeedback.

Varje meddelande som ska ta emot feedback om meddelanden måste innehålla ett värde för egenskapen leveransbekräftelse ack . Egenskapen ack kan vara ett av följande värden:

  • none (standard): inget feedbackmeddelande genereras.

  • sent: få ett feedbackmeddelande om meddelandet har slutförts.

  • : få ett feedbackmeddelande om meddelandet har upphört att gälla (eller maximalt antal leveranser har nåtts) utan att slutföras av enheten.

  • full: feedback för både skickade och inte skickade resultat.

I det här exemplet är egenskapen ack inställd på fulloch begär både skickad och inte skickad feedback om meddelandeleverans för ett meddelande.

message.ack = 'full';

Återanropsfunktionen för feedbackmottagaren är länkad till Client getFeedbackReceiver.

Mottagaren av feedback får två argument:

  • Felobjekt (kan vara null)
  • AmqpReceiver-objekt – Genererar händelser när nya feedbackmeddelanden tas emot av klienten.

Den här exempelfunktionen tar emot och skriver ut ett feedbackmeddelande om leverans till konsolen.

function receiveFeedback(err, receiver){
  receiver.on('message', function (msg) {
    console.log('Feedback message:')
    console.log(msg.getData().toString('utf-8'));
  });
}

Den här koden länkar återanropsfunktionen receiveFeedback för feedback till tjänstobjektet Client med hjälp av getFeedbackReceiver.

serviceClient.getFeedbackReceiver(receiveFeedback);

Definiera en resultathanterare för meddelandeslut

Återanropsfunktionen för att skicka meddelanden anropas efter att varje meddelande har skickats.

Den här exempelfunktionen skriver ut meddelandeåtgärdsresultatet send till konsolen. I det här exemplet printResultFor anges funktionen som en parameter till funktionen send som beskrivs i nästa avsnitt.

function printResultFor(op) {
  return function printResult(err, res) {
    if (err) console.log(op + ' error: ' + err.toString());
    if (res) console.log(op + ' status: ' + res.constructor.name);
  };
}

Skicka ett meddelande

Använd funktionen send för att skicka ett asynkront moln-till-enhet-meddelande till enhetsappen via IoT Hub.

send stöder följande parametrar:

  • deviceID – målenhetens enhets-ID.
  • message – brödtexten i meddelandet som ska skickas till enheten.
  • done – Den valfria funktion som ska anropas när åtgärden är klar. Klar anropas med två argument:
    • Felobjekt (kan vara null).
    • transportspecifikt svarsobjekt som är användbart för loggning eller felsökning.

Den här koden anropar send för att skicka ett meddelande från moln till enhet till enhetsappen via IoT Hub. Återanropsfunktionen printResultFor som definierades i föregående avsnitt tar emot leveransbekräftelseinformationen.

var targetDevice = '{device ID}';
serviceClient.send(targetDevice, message, printResultFor('send'));

Det här exemplet visar hur du skickar ett meddelande till enheten och hanterar feedbackmeddelandet när enheten bekräftar meddelandet från moln till enhet:

serviceClient.open(function (err) {
  if (err) {
    console.error('Could not connect: ' + err.message);
  } else {
    console.log('Service client connected');
    serviceClient.getFeedbackReceiver(receiveFeedback);
    var message = new Message('Cloud to device message.');
    message.ack = 'full';
    message.messageId = "My Message ID";
    console.log('Sending message: ' + message.getData());
    serviceClient.send(targetDevice, message, printResultFor('send'));
  }
});

Exempel på SDK-sändningsmeddelande

send_c2d_message.js – Skicka C2D-meddelanden till en enhet via IoT Hub.

Återanslutningsprincip för anslutning

Den här artikeln visar inte någon princip för återförsök av meddelanden för enheten till IoT Hub-anslutning eller externt program till IoT Hub-anslutning. I produktionskoden bör du implementera principer för återförsök av anslutningar enligt beskrivningen i Hantera enhetsåteranslutningar för att skapa motståndskraftiga program.

Kvarhållningstid för meddelanden, återförsök och maximalt antal leveranser

Enligt beskrivningen i Skicka meddelanden från moln till enhet från IoT Hub kan du visa och konfigurera standardvärden för följande meddelandevärden med hjälp av konfigurationsalternativen för portalen i IoT Hub eller Azure CLI. De här konfigurationsalternativen kan påverka meddelandeleverans och feedback.

  • Standard-TTL (time to live) – Den tid ett meddelande är tillgängligt för en enhet att använda innan det har upphört att gälla av IoT Hub.
  • Kvarhållningstid för feedback – Hur lång tid IoT Hub behåller feedbacken för förfallotid eller leverans av meddelanden från moln till enhet.
  • Antalet gånger IoT Hub försöker leverera ett meddelande från moln till enhet till en enhet.