Allumer une lampe depuis une montre Pebble

Allumer une lampe depuis une montre Pebble

Vous avez peut-être déjà entendu parler de la montre Pebble, cette fameuse "smart watch" qui se connecte à votre téléphone pour vous informer des nouveaux emails, SMS, appels entrant, etc. Plus d'une année après son annonce, Pebble a enfin publié le SDK pour créer sa propre "Watch App" pour cette montre. Nous avons pensé qu'il serait amusant et pratique de pouvoir contrôler l'environnement qui nous entoure directement depuis sa montre. Afin de tester ce nouveau SDK, nous avons décidé d'écrire une petite application Pebble qui va contrôler la lampe que nous avions utilisée avec le Yocto-LatchedRelay.



Pour ce projet, nous allons utiliser une montre Pebble, un téléphone Android, un YoctoHub-Ethernet et un Yocto-LatchedRelay. Le YoctoHub-Ethernet va nous permettre de rendre accessible le Yocto-LatchedRelay à n'importe quelle machine du réseau. Concrètement un YoctoHub-Ethernet est équivalent à un PC qui lance un VirtualHub, mais en plus compact, et en consommant encore 3 fois moins qu'un Raspberry Pi. Le YoctoHub-Ethernet n'est pas encore disponible à la vente, mais plusieurs prototypes sont déjà en test chez certains de nos clients. Si tout se passe bien, nous devrions pouvoir annoncer plus de choses sur ce produit d'ici quelques semaines.




L'application Pebble

Pour notre application, nous allons afficher les informations d'un relais à la fois. Les boutons haut et bas seront utilisés pour la navigation entre les relais. Le bouton du milieu sera utilisé pour permuter l'état du relais courant. L'essentiel de la complexité est déporté sur l'application Android: la montre va envoyer un message à chaque bouton pressé, laissant à l'application Android le soin d’effectuer les actions requises et d’envoyer à la montre les informations mises à jour.

Capture d'écran de l'application Pebble
Capture d'écran de l'application Pebble




Pour écrire une application Pebble, c’est un peu plus compliqué que pour écrire une application smartphone habituelle. Il faut commencer par installer le PebbleKit. Pour cela, il faut une machine Mac OS X ou Linux (pas encore de support Windows), et l'installation est assez pénible. Une fois cette étape effectuée, vous pourrez commencer à coder votre "Watch App" Pebble. Une application Pebble est écrite en C pur sucre: sans allocation dynamique, sans stockage permanent, sans printf, sans rien... Enfin presque : le SDK fournit quand même un grand nombre de fonctions bien documentées pour afficher ce que l'on désire et communiquer avec le téléphone. Mais les développeurs habitués aux langages de haut niveau risquent de se sentir un peu perdus au début.

Un peu comme pour une application Android, on définit des callbacks qui sont automatiquement appelés par la montre en fonction des événements (bouton pressé, message du téléphone, etc.). Le code de notre application Pebble est relativement long mais assez simple, nous n'allons donc pas le détailler dans cet article. Les sources sont disponibles sur GitHub.

L'application Android

Pour l'application Android, nous allons faire quelque chose de très basique: l'application va lister les relais présents sur le YoctoHub-Ethernet et inverser l'état du relais correspondant à chaque click (ou plutôt "touch"). Pour initialiser l'API Yoctopuce afin d’utiliser le YoctoHub-Ethernet, il faut appeler YAPI.RegisterHub() en lui passant l'adresse IP (ou le hostame) du YoctoHub-Ethernet au lieu du traditionnel "usb". Toutes les autres fonctions de la librairie fonctionnent de la même manière que si les relais étaient connectés directement en USB.

Cependant l'OS Android est un peu plus compliqué que notre librairie pour les accès réseau. Il faut tout abord montrer patte blanche et déclarer que nous désirons accéder à internet. Cela se fait en ajoutant <uses-permission android:name="android.permission.INTERNET" /> dans le fichier AndroidManifest.xml. Il y a une autre contrainte un peu plus pénible: Android n'autorise pas les accès réseau depuis le thread principal. Il faut donc soit implémenter un Service, soit utiliser des AsyncTask pour appeler les méthodes de L'API Yoctopuce.

Capture d'écran de l'application Android
Capture d'écran de l'application Android




Pour que notre application Android puisse recevoir les messages de la montre, il faut implémenter et enregistrer un BroadcastReceiver qui sera appelé à chaque message que le téléphone reçoit de la montre. En fonction de la commande que nous allons recevoir, l'application devra soit mettre à jour le pointeur sur le relais courant, soit changer l'état du relais. A la fin, l'application renvoie à la montre les informations à jour avec le nouvel état du relais.



public void onReceive(Context context, Intent intent)
{
  if (intent.getAction().equals(Constants.INTENT_APP_RECEIVE)) {
    final UUID receivedUuid = (UUID) intent.getSerializableExtra(Constants.APP_UUID);

    // Pebble-enabled apps are expected to be good citizens and only
    // inspect broadcasts containing their UUID
    if (!PEBBLE_APP_UUID.equals(receivedUuid)) {
      return;
    }

    final int transactionId = intent.getIntExtra(Constants.TRANSACTION_ID, -1);
    final String jsonData = intent.getStringExtra(Constants.MSG_DATA);
    if (jsonData == null || jsonData.isEmpty()) {
      return;
    }
    int cmd=PREVIOUS_RELAY;
    try {
      final PebbleDictionary data = PebbleDictionary.fromJson(jsonData);
      cmd = data.getUnsignedInteger(CMD_KEY).intValue();
    } catch (JSONException e) { return;}
    Log.i(TAG, "receive command" + cmd);
    // acknowledge the command
    PebbleKit.sendAckToPebble(context, transactionId);
    RelayListStorage singleton = RelayListStorage.get(context);
    Relay relay;
    switch(cmd){
    case PREVIOUS_RELAY:
      singleton.pebblePrevious();
      break;
    case TOGGLE_RELAY:
      relay = singleton.pebbleGetCurrent();
      if(relay==null)
        break;
      relay.toggle();
      singleton.notfyChanges();
      // send message to the  application service
      Intent serviceintent = new Intent(context, YoctoService.class);
      serviceintent.putExtra(YoctoService.EXTRA_TOGGLE, relay.getHwId());
      context.startService(serviceintent);
      break;
    case NEXT_RELAY:
      singleton.pebbleNext();
      break;
    default:
    }
    relay = singleton.pebbleGetCurrent();
    if (relay !=null) {
      PebbleDictionary dictionary = relay.toPebbleDictionary();
      PebbleKit.sendDataToPebble(context, PEBBLE_APP_UUID, dictionary);
    } else {
      PebbleDictionary dictionary = Relay.getEmtpyPebbleDictionary();
      PebbleKit.sendDataToPebble(context, PEBBLE_APP_UUID, dictionary);
    }
  }
}
 



Le code de cette application Android va être ajouté aux exemples inclus avec notre librairie Android.

Pour finir, voici la démonstration du Yocto-LatchedRelay, adaptée pour ajouter la commande par une montre Pebble.

  



Nous avons volontairement décidé de montrer un exemple simple pour tester l'API Pebble (allumer une ampoule vissée sur une planche n'est pas très impressionnant ni même utile), mais au vu de ces premiers essais, la possibilité de contrôler l’environnement depuis une montre semble réellement intéressante. Imaginez-vous ouvrir la porte de votre garage d'un simple clic de la montre....

Commenter aucun commentaire
Retour au blog












Yoctopuce, get your stuff connected.