Windows IOT App Services et tâches d'arrière-plan

Question

pour le moment J'ai une application sans interface Windows IOT qui consiste en une tâche d'arrière-plan opérée par une minuterie, qui envoie et reçoit des données via le port série. Maintenant, j'ai besoin d'une application dirigée pour pouvoir envoyer des commandes via le port série, mais comme je ne veux pas que plusieurs applications accèdent au port série en même temps, j'ai pensé à communiquer avec l'application headless. un service d'application.

Ma question est: Est-il possible d'avoir une tâche de fond et un App Service sur la même application sans tête? Si oui, est-il possible d'arrêter la tâche en arrière-plan pendant que le service App est appelé? Merci.

Cordialement, Carlos

Answer 1

Il existe deux méthodes.

On utilise la fonctionnalité de SerialDevice.FromIdAsync() API. Parce que lorsque le périphérique série est en cours d'utilisation d'un processus, les autres processus obtiendront une valeur de retour null d'appel SerialDevice.FromIdAsync() et ne peuvent pas l'utiliser jusqu'à ce que le premier processus le dispose. Vous pouvez le faire comme ceci:

SerialDevice serialPort = null; 
private async void SerialDeviceOperation() 
{ 
    var selector = SerialDevice.GetDeviceSelector(); 
    var device = await DeviceInformation.FindAllAsync(selector); 

    try 
    { 
     while (serialPort == null) 
     { 
      serialPort = await SerialDevice.FromIdAsync(device[0].Id); 
     } 

     // Your code in here 

    } 
    catch (Exception ex) 
    { 
     System.Diagnostics.Debug.WriteLine(ex.Message); 
    } 

    // Do something... 
    // Write or read data via serial device 
    // ... 

    // After complete the operation, dispose the device 
    serialPort.Dispose(); 
    serialPort = null; 
} 

Un autre utilise App Service. Votre application sans écran peut héberger un service d'application et votre application dirigée peut appeler ce service. Vous pouvez mettre votre appareil en série dans le service App et chaque fois que votre application sans tête ou dirigée qui veut utiliser le périphérique série doit suspendre le sémaphore dans le service App. Ainsi, vous pouvez atteindre l'objectif de protection du périphérique série. Vous pouvez le faire comme ceci:

Créer le sémaphores dans votre service App:

private static Semaphore semaphore = new Semaphore(1,1); 

et de fournir ces deux API à votre application sans tête:

public bool pendSemphore() 
{ 
    return semaphore.WaitOne(); 
} 

public void releaseSemphore() 
{ 
    semaphore.Release(); 
} 

Dans votre application sans tête, vous avez besoin de la lignes de code suivantes:

Inventory inventory = new Inventory(); 

     private void SerialCommunication() 
     { 
      inventory.pendSemphore(); 

      // Put your serial device operation here 
      // ... 

      inventory.releaseSemphore(); 
     } 

Dans votre application dirigée, vous pouvez utiliser un périphérique série en appelant le service d'application e. Plus d'informations que vous pouvez référencer "how to create and consume an app service".