Mon Tutoriel de la voiture connectée Azure Sphere – Partie 4

Dans mes précédents articles, je démarrais la présentation du matériel nécessaire et de l’installation que j’ai faite pour réaliser ma petite voiture connectée et téléguidée. J’ai ensuite décrit les différentes étapes permettant de contrôler les moteurs de la voiture. Puis, j’ai démontré comment nous pouvons utiliser les Direct Method pour contrôler depuis le Cloud l’appareil (au travers de Google Home par exemple).

Les différentes étapes de ma réalisation sont décrites dans les pages précédentes disponibles ici :

Nous arrivons à la dernière étape de ma réalisation. Celle-ci concerne l’utilisation d’une carte BLE permettant de communiquer avec la carte Azure Sphere depuis un téléphone portable par exemple.

Click BLE 4 de MikroE

Un peu comme mon article sur l’Utilisation de Azure Sphere et LoRa Click, j’ai récupéré le code source disponible sur le GitHub de MikroE (MikroElektronika/mikrosdk_click_v2 (github.com)) pour l’intégrer dans le fonctionnement de Azure Sphere.

La plupart des modifications concernent les fonctions internes permettant l’utilisation des GPIO sur la carte et des temps d’attentes (Delay_xxxms), que j’ai ré-implémenté…

Déclaration dans le HardwareDefinition et app_manifest.json

Pour l’utilisation, j’ai branché ma carte sur le socket 1 de la carte Azure Sphere. Et comme d’habitude lorsque l’on utilise des interfaces sur la carte Azure Sphere il faut les déclarer dans la définition du Hardware ainsi que le manifest de l’application…

...
    "Peripherals": [
        ...
{
            "Name": "BLE4_UART_RXTX",
            "Type": "Uart",
            "Mapping": "AVNET_MT3620_SK_ISU0_UART",
            "Comment": "MT3620 SK: MikroBUS 1 UART Connector."
        },
        {
            "Name": "BLE4_UART_RST",
            "Type": "Gpio",
            "Mapping": "AVNET_MT3620_SK_GPIO16",
            "Comment": "MT3620 SK:  MikroBUS 1 UART RST Channel."
        },
        {
            "Name": "BLE4_UART_CTS",
            "Type": "Gpio",
            "Mapping": "AVNET_MT3620_SK_GPIO34",
            "Comment": "MT3620 SK: MikroBUS 1 UART CS Channel."
        },
        {
            "Name": "BLE4_UART_DSR",
            "Type": "Gpio",
            "Mapping": "AVNET_MT3620_SK_GPIO0",
            "Comment": "MT3620 SK: MikroBUS 1 UART PWM Channel."
        },
        {
            "Name": "BLE4_UART_DTR",
            "Type": "Gpio",
            "Mapping": "AVNET_MT3620_SK_GPIO42",
            "Comment": "MT3620 SK: MikroBUS 1 UART AN Channel."
        },
        {
            "Name": "BLE4_UART_RTS",
            "Type": "Gpio",
            "Mapping": "AVNET_MT3620_SK_GPIO2",
            "Comment": "MT3620 SK: MikroBUS 1 UART INT Channel."
        }
        ...
...

Et maintenant, nous pouvons déclarer l’utilisation de ces interfaces dans notre app_manifest.json :

...
  "Capabilities": {
    ...
    "Uart": [ "$BLE4_UART_RXTX" ],
    "Gpio": [ 
      ...
      "$BLE4_UART_RST",
      "$BLE4_UART_CTS",
      "$BLE4_UART_DSR",
      "$BLE4_UART_DTR",
      "$BLE4_UART_RTS"
      ...
    ]
    ...
  },
...

Initialisation de BLE

Maintenant que nous avons notre driver de commande BLE disponible pour Azure Sphere nous pouvons initialiser notre puce Bluetooth comme suit :

BLECommands_ExitCode JoyitCar_InitBLECommandHandlers(EventLoop *eventLoop)
{
    struct timespec bleCheckPeriod = {.tv_sec = 0, .tv_nsec = 1000 * 1000 * 50};

    if (ble4_init(&ble4) != BLE4_OK)
    {
        return BLECommands_ExitCode_Initevice;
    }

    ble4_reset(&ble4);
    Delay_1sec();

    Log_Debug("Configuring the BLE module...\n");
    Delay_1sec();

    ble4_set_dsr_pin(&ble4, 1);
    Delay_ms(20);

    do
    {
        ble4_set_echo_cmd(&ble4, 1);
        Delay_100ms();
    } while (ble4_process() != 1);

    do
    {
        ble4_set_local_name_cmd(&ble4, "JoyItCar");
        Delay_100ms();
    } while (ble4_process() != 1);

    do
    {
        ble4_connectability_en_cmd(&ble4, BLE4_GAP_CONNECTABLE_MODE);
        Delay_100ms();
    } while (ble4_process() != 1);

    do
    {
        ble4_discoverability_en_cmd(&ble4, BLE4_GAP_GENERAL_DISCOVERABLE_MODE);
        Delay_100ms();
    } while (ble4_process() != 1);

    do
    {
        ble4_enter_mode_cmd(&ble4, BLE4_DATA_MODE);
        Delay_100ms();
    } while (ble4_process() != 1);

    ble4_set_dsr_pin(&ble4, 0);
    Delay_ms(20);
    Log_Debug("The BLE module has been configured.\n");

    bleCommandPollTimer =
        CreateEventLoopPeriodicTimer(eventLoop, &BLECommandTimerEventHandler, &bleCheckPeriod);
    if (bleCommandPollTimer == NULL)
    {
        return BLECommands_ExitCode_InitTimer;
    }

    return BLECommands_ExitCode_Success;
}

Une fois mon appareil démarré et le Bluetooth initialisé, ma voiture sera visible par Bluetooth avec le nom suivant : JoyItCar.

BLE Command Handler

Maintenant que tout est initialisé, nous avons la possibilité d’intégrer notre gestionnaire de commandes BLE au travers de la méthode suivante :

static void BLECommandTimerEventHandler(EventLoopTimer *timer)
{
    if (ConsumeEventLoopTimerEvent(timer) != 0)
    {
        return;
    }

    if (!has_data())
    {
        return;
    }

    Log_Debug("%s\n", current_parser_buf);

    if (strcmp(current_parser_buf, "Forward") == 0)
    {
        JoyitCar_GoForward();
    }
    else if (strcmp(current_parser_buf, "Backward") == 0)
    {
        JoyitCar_GoBackward();
    }
    else if (strcmp(current_parser_buf, "Break") == 0)
    {
        JoyitCar_Break();
    }
    else if (strcmp(current_parser_buf, "Right") == 0)
    {
        JoyitCar_TurnRight();
    }
    else if (strcmp(current_parser_buf, "Left") == 0)
    {
        JoyitCar_TurnLeft();
    }

    nanosleep(&runDuration, &runDuration);

    JoyitCar_Break();
}

Cette méthode vérifie alors les données lues par la puce Bluetooth (en provenance de notre téléphone) et déclenche les méthodes correspondantes.

Télécommande Android

Alors, j’avoue que je ne suis pas, mais alors pas du tout, un développeur mobile. Mais je plaide coupable, j’aurais pu faire un petit effort… Au lieu de cela j’ai utilisé une application disponible sur le store me permettant de se connecter sur un appareil Bluetooth et envoyer des commandes (que l’on configure) sur l’appareil connecté. Cette application dispose d’une disposition sous la forme de GamePad, plutôt idéale pour cette télécommande.

Si vous voulez le tester, vous pouvez le télécharger sur Google Play : Bluetooth Commander – Applications sur Google Play.

Conclusions

Arrivé au bout de ces implémentations, j’ai pu donc construire une voiture télécommandée par Bluetooth Low Energy et téléguidée par Google Home. Pour pouvoir réaliser cela, j’ai utilisé une Azure Sphere en combinaisons avec une carte de contrôle de moteur par I2C. Puis l’utilisation d’une carte Click BLE connectée en UART fournit une solution de communication en champs proche pour la télécommande. Le même type de voiture peut également être réalisé sur un Arduino (ESP8266 par exemple) et c’est d’ailleurs ce que je vais proposer aux étudiants de l’UCA.

La connexion à IoT Hub dans cet exemple apporte un aperçu de la capacité à envoyer des données de télémétrie vers le cloud ainsi que la possibilité de déclencher des méthodes depuis le cloud sur l’appareil.

C’était un road trip assez amusant et ludique, mes enfants et ma chienne en sont fous ;). J’espère que les étudiants prendront également du plaisir dans ces réalisations…