Introduction

Ce guide vous aidera à comprendre comment commencer à utiliser Blynk et vous donnera un aperçu
compréhensible de toutes ses fonctionnalités.

Si vous souhaitez commencer directement à jouer avec Blynk, regardez le guide de démarrage.

GUIDE DE DÉMARRAGE

Comment fonctionne Blynk

Blynk a été conçu pour l’Internet des Objets. Il peut contrôler un hardware à distance, il peut afficher
des données de capteur, il peut stocker des données, les visualiser et faire beaucoup d’autres trucs
cools.

Il y a trois composants majeurs dans la plateforme:

 Application Blynk - vous permet de créer de fantastiques interfaces pour vos projets en
utilisant différents widgets que nous fournissons.

 Serveur Blynk - responsable de toute les communications entre le smartphone et le

hardware. Vous pouvez utiliser notre Cloude Blynk ou faire tourner votre Serveur privé
Blynk localement. C’est open-source, ça peut facilement gérer des milliers de périphériques
et peut même être démarré sur une Raspberry Pi.

 Bibliothèque Blynk - pour toutes les plateformes hardware populaires - active la

communication avec le serveur et traite toutes les commandes entrantes et sortantes.

Maintenant imaginez: chaque fois que vous pressez un Bouton sur l’application Blynk, le message
voyage vers l’espace le Cloud Blynk, où il trouve magicalement un chemin vers votre hardware. Ça
marche de la même manière dans l’autre sens et tout se déroule en un clignotement.
Fonctionnalités

 API et UI similaire pour tous les hardwares et périphériques supportés

 Connexion au cloud via:

o Ethernet

o WiFi

o Bluetooth et BLE

o USB (Serial)

o …

 Collection de widgets faciles à utiliser

 Manipulation des broches directes sans code à écrire

 Facilité d’intégrer et ajouter de nouvelles fonctionnalités en utilisant les broches virtuelles

 Surveillance de l’historique des données via le widget History Graph

 Communication Périphérique-à-Périphérique en utilisant le widget Bridge

 Envoi d’emails, de tweets, de notifications push, etc.

 … de nouvelles fonctionnalités sont constamment ajoutées !

Vous pouvez trouver des croquis d’example couvrant les fonctionnalités basiques de Blynk. Ils sont
inclus dans la bibliothèque. Tous les croquis sont conçus pour être facilement combiné entre eux.

Comment commencer à faire du Blynk ?

À ce niveau vous devez certainement penser : “Okay, je veux ça. Que faire pour commencer ?” –
Juste quelques trucs, vraiment :

1. Hardware.

Un Arduino, Raspberry Pi, ou un kit de développement similaire.

Blynk fonctionne à travers Internet. Ce signifie que le hardware que vous choisissez doit être
capable de connecter avec internet. Certaines cartes, comme l’Arduino Uno, vont nécesser un Shield
Ethernet ou Wi-Fi pour communiquer, tandis que d’autres sont déjà capables de communiquer avec
internet : comme l’ESP8266, le Raspberry Pi avec le donglet Wi-Fi, le Particle Photon ou le SparkFun
Blynk Boarf. Néanmoins, même si vous n’avez pas de Shield, vous pouvez le connecter à travers le
port USB de votre ordinateur (c’est un poil compliqué pour les débutants, mais nous vous couvrons).
Ce qui est cool, c’est que la liste des hardwares fonctionnant avec Blynk est immense et continue de
grandir.

2. Un Smartphone.

L’application Blynk est une bâtisseuse d’interface bien conçue. Elle marche à la fois sur iOS et
Android, donc aucune guerre sainte ici, ok ?

Téléchargements

Application Blynk pour iOS ou Android

Bibliothèque Blynk

TÉLÉCHARGEZ LA BIBLIOTHÈQUE BLYNK

Au cas où vous aurez oublié ou e savez pas comment installer une bibliothèque Arduino, cliquez-ici.

Guide de démarrage
Ce guide vous permettra de commencer en 5 minutes (lire ne compte pas !). Nous allons activer une
LED connectée à votre Arduino à l’aide de l’application Blynk sur votre smartphone.

Connectez une LED comme montré ici :

Guide de démarrage de l’Application Blynk

1. Créer un compte Blynk

Une fois l’application Blynk téléchargée, vous aurez besoin de créer un nouveau compte Blynk. Ce
compte est séparé des comptes utilisés pour les Forums Blynk, au cas où vous en avez déjà un.

Nous recommandons d’utiliser une réelle adresse e-mail car ça vous simplifiera les choses plus tard.
Pourquoi ai-je besoin de créer un compte ?

Un compte est nécessaire afin de sauvegarder vos projets et y avoir accès à partir de plusieurs
périphériques et de n’importe où. C’est aussi une mesure de sécurité.

Vous pouvez toujours configurer votre propre serveur privé Blynk et avoir le contrôle absolu.

2. Créer un nouveau Projet

Après vous être correctement identifié avec votre compte, commencez par créer un nouveau projet.
Donnez-lui un nom.

3. Choisir son hardware

Sélectionnez le modèle de hardware que vous allez utiliser. Vous pouvez vérifier la liste des
hardwares supportés!

4. Jeton d’Authentification

Le Jeton d’Authentification est un identifiant unique nécessaire pour connecter votre hardware à
votre smartphone. Chaque nouveau projet que vous créérez a son propre Jeton d’Authentification.
Vous obtiendrez un Jeton d’Authentification automatiquement sur votre e-mail après la création
d’un projet. Vous pouvez aussi le copier manuellement. Cliquez sur la section périphériques :
Cliquez sur le périphérque :
Et vous verrez le jeton :
NOTE : Ne partagez votre Jeton d’Authentification avec personne, à moins que vous ne souhaitiez
que quelqu’un puisse avoir accès à votre hardware.

C’est vraiment pratique de l’envoyer via l’e-mail. Pressez le bouton e-mail et le jeton vous sera
envoyé à l’adresse e-mail utilisée lors de l’inscription. Vous pouvez aussi appuyer sur la ligne du Jeton
et il sera copié vers le presse-papier.

Pressez maintenant le bouton “Create”.

5. Ajouter un Widget

Votre grille de projet est vide, ajoutons un bouton pour crontrôler notre LED.

Appuyez n’importe où sur la grille pour ouvrir la liste des Widgets. Tous les widgets disponibles sont
situés ici. Maintenant, choisissez un boutton.

Liste des widgets

Glisser-Déposer - Tapotez et garder le Widget pour le déposer vers sa nouvelle position.

Paramètres du Widget - Chaque Widget a ses propres paramètres. Tapez sur le widget pour y
accéder.
Le paramètre le plus important est PIN (broche, en anglais). La liste des broches reflète les broches
physiques définies par votre hardware. Si votre LED est connectée à la broche digitale 8 - alors
sélectionnez D8 (D - est pour Digital).

6. Démarrer le Projet

Quand vous aurez terminé avec les Paramètres - appuyez sur le bouton PLAY. Vous basculerez ainsi
du mode ÉDITION au mode JOUER où vous pouvez interragir avec votre hardware. Pendant le mode
JOUER, vous n’êtes pas autorisé à déplacer ou configurer de nouveaux widgets, appuyez sur STOP et
retournez au mode ÉDITION pour l’être de nouveau.

Vous obtiendrez un message indiquant “Arduino UNO is offline” (Arduino UNO est hors-ligne). Nous
traiterons cela dans la prochaine section.

Guide de démarrage du Hardware

Comment utiliser un croquis d’example

Vous devriez à partir de maintenant avoir la bibliothèque Blynk installée sur votre ordinateur. Si ce
n’est pas le cas - cliquez-ici.

Les croquis d’exemple vous aideront à connecter votre hardware rapidement et à mettre en place les
fonctionnalités majeures de Blynk.

Ouvrez le croquis d’exemple en fonction du modèle de votre hardware et du shield que vous utilisez.

Jetons un coup d’oeil au croquis d’exemple pour un Arduino UNO + Shield Ethernet

#define BLYNK_PRINT Serial

#include <SPI.h>

#include <Ethernet.h>

#include <BlynkSimpleEthernet.h>

char auth[] = "YourAuthToken";

void setup()

Serial.begin(9600); // Affiche l'état de la connexion dans le moniteur Série

Blynk.begin(auth); // Votre Arduino se connecte ici au Cloud de Blynk

void loop()

Blynk.run(); // Toute la magie de Blynk se passe ici...

Jeton d’Authentification

Dans ce croquis d’exemple, trouvez cette ligne :

char auth[] = "YourAuthToken";

C’est le Jeton d’Authentification que vous vous êtes envoyé par e-mail. Vérifiez votre e-mail et
copiez-le, puis collez-le entre les guillemets.

Ce devrait ressembler à ceci :

char auth[] = "f45626c103a94983b469637978b0c78a";

Téléversez le croquis vers la carte et ouvrez le moniteur Série. Attendez jusqu’à ce que vous voyez
quelque chose comme ceci :

Blynk v.X.X.X

Your IP is 192.168.0.11

Connecting...

Blynk connected!

Félicitations ! Vous l’avez fait ! Le hardware est désormais connecté au Cloud de Blynk !

Jouer avec Blynk

Retournez sur l’application de Blynk, appuyez sur le bouton et activez puis désactivez la LED ! Elle
devrait clignoter.

Regardez d’autres croquis d’exemple.

Sentez vous libre d’expérimenter et de combiner différents exemples ensembles afin de créer vos
propres projets.

Par exemple, pour attacher une LED à une broche PWM sur votre Arduino, paramétrez le
widget slider afin de contrôler la luminosité d’une LED. Utilisez les mêmes étapes décrites plus haut.

Paramètres du Hardware

Arduino à travers l’USB (sans Shield)

Si vous n’avez pas de Shield et que votre hardware n’a aucune connectivité, vous pouvez tout de
même utiliser Blynk – directement par l’USB :

1. Ouvrez l’exemple Arduino Serial USB et changez le Jeton d’Authentification

2. // Vous pourriez utiliser un Serial Hardware supplémentaire sur les cartes qui en ont
(comme le Mega)

3. #include <SoftwareSerial.h>

4. SoftwareSerial DebugSerial(2, 3); // RX, TX

5.

6. #define BLYNK_PRINT DebugSerial

 7. #include <BlynkSimpleStream.h>

8.

9. // Vous devez récupérer le Jeton d'Authentification dans l'application Blynk.

10. // Allez dans les Paramètres du Projet (Icône d'écrou).

11. char auth[] = "YourAuthToken";

12.

13. void setup()

14. {

15. // Console de débuggage

16. DebugSerial.begin(9600);

17.

18. // Blynk fonctionnera à travers le Serial

19. Serial.begin(9600);

20. Blynk.begin(auth, Serial);

21. }

22.

23. void loop()

24. {

25. Blynk.run();

26. Lancez le script qui est habituellement situé dans le dossier /scripts :

o Windows : Mes Documents\Arduino\libraries\Blynk\scripts

o Mac User$/Documents/Arduino/libraries/Blynk/scripts

Sur Windows :

Ouvrez cmd.exe

Écrivez votre chemin vers le dossier de blynk-ser.bat. Par exemple :

cd C:\blynk-library-0.3.1\blynk-library-0.3.1\scripts

Lancez le fichier blynk-ser.bat. Par exemple : blynk-ser.bat -c COM4 (où COM4 le port où est
connecté votre Arduino)

Et pressez “Entrée”, pressez “Entrée” puis pressez “Entrée”.

Sur Linux et Mac:

Naviguez vers le dossier /scripts. Par exemple :

cd User$/Documents/Arduino/libraries/Blynk/scripts

Une fois à l’intérieur du dossier, lancez :

user:scripts User$ ./blynk-ser.sh

Attention : Ne fermez pas une fenêtre de terminal avec un script qui tourne.

Dans certains cas, vous aurez aussi besoin d’exécuter :

user:scripts User$ chmod +x blynk-ser.sh

Vous pourriez aussi avoir besoin de l’exécuter avec sudo

user:scripts User$ sudo ./blynk-ser.sh

C’est ce que vous verrez dans l’application Terminal sur Mac (l’adresse d’usbmodem peut être
différente) :

[ Press Ctrl+C to exit ]

/dev/tty.usbmodem not found.

Select serial port [ /dev/tty.usbmodem1451 ]:

Copiez l’adresse du port série : /dev/tty.usbmodem1451 et collez-le à côté:

Select serial port [ /dev/tty.usbmodem1451 ]: /dev/tty.usbmodem1451

Après avoir pressé “Entrée”, vous devriez voir quelque chose de similaire à ceci :

Resetting device /dev/tty.usbmodem1451...

Connecting:
GOPEN:/dev/tty.usbmodem1451,raw,echo=0,clocal=1,cs8,nonblock=1,ixoff=0,ixon=0,ispeed=9600,os
peed=9600,crtscts=0 <-> openssl-connect:blynk-cloud.com:8441,cafile=/Users/.../server.crt,nodelay

2015/10/03 00:29:45 socat[30438.2046857984] N opening character device

"/dev/tty.usbmodem1451" for reading and writing

2015/10/03 00:29:45 socat[30438.2046857984] N opening connection to LEN=16 AF=2

45.55.195.102:8441

2015/10/03 00:29:45 socat[30438.2046857984] N successfully connected from local address LEN=16

AF=2 192.168.0.2:56821

2015/10/03 00:29:45 socat[30438.2046857984] N SSL connection using AES128-SHA

2015/10/03 00:29:45 socat[30438.2046857984] N starting data transfer loop with FDs [3,3] and [4,4]

NOTE : Arduino IDE peut se plaindre avec “programmer is not responding” (Le programmeur ne
répond pas, en anglais). Vous devez terminer vos scripts avant de téléverser de nouveaux croquis.

Contenus additionnels :

 Tutoriel: Contrôler Arduino via l’USB avec l’Application Blynk. Aucun Shield Nécessaire. (Mac
OS) - En Anglais
  Comment contrôler Arduino (Sans fil) avec Blynk via l’USB. Windows - En Anglais

 Instructables : Contrôlez Arduino avec Blynk à travers l’USB - En Anglais

Raspberry Pi

1. Connectez votre Rapsberry Pi à Internet et ouvrez sa console.

2. Lancez cette commande (elle met à jour les dépôts de paquets de votre système
d’exploitation pour y inclure les paquets requis) :

curl -sL "https://deb.nodesource.com/setup_6.x" | sudo -E bash -

3. Téléchargez et créez la bibliothèque Blynk JS en utilisant npm :

4. sudo apt-get update && sudo apt-get upgrade

5. sudo apt-get install build-essential

6. sudo npm install -g npm

7. sudo npm install -g onoff

sudo npm install -g blynk-library

8. Lancez le script de test de Blynk (Mettez votre Jeton d’Authentification):

blynk-client 715f8cafe95f4a91bae319d0376caa8c

9. Vous pouvez écrire votre propre script basé sur les exemples

10. Pour activer l’auto-redémarrage de Blynk pour Pi, trouvez le fichier /etc/rc.local et ajoutez
avant exit 0 :

node chemin_complet_vers_votre_script.js <Auth Token>

Contenus Supplémentaires:

 Instructables: Blynk avec Javascript pour Raspberry Pi, Intel Edison et autres - En Anglais

 Instructables: Utiliser les capteurs DHT11/DHT12 avec Raspberry Pi et Blynk - En Anglais

Note : Plutôt que d’utiliser Node.js, vous pouvez aussi créer une installation de la version C++ de la
bibliothèque (La même que Arduino, basé sur WiringPI) : - LISEZ-MOI de la Bibliothèque pour Linux -
En Anglais - Sujet de la Communauté Blynk : Comment faire avec Raspberry-Pi - En Anglais - Tutoriel
Vidéo - Configurer Blynk et Raspberry Pi - En Anglais

ESP8266 Standalone

Vous pouvez faire tourner Blynk directement sur l’ESP8266 !

Installez la dernière version de la bibliothèque ESP8266 pour Arduino en utilisant ce guide.

Croquis d’exemple : Sketch ESP8266_Standalone

Contenus supplémentaires:

 Instructables: ESP8266 ESP-12(Standalone)+ Blynk - En Anglais

 Instructables: ESP8266-12 standalone Blynk lm35 capteur de température - En Anglais

Tutoriel étape-par-étape - En Russe

NodeMCU

Suivez ces instructions détaillées. Ou visionnez ce tutoriel vidéo - En Anglais.

Particle

Blynk fonctionne avec la famille entière de produits Particle : Core, Photon et Electron

1. Ouvrez l’IDE Particle Web.

2. Allez dans les bibliothèques.

3. Recherchez Blynk dans les bibliothèques de la Communauté et cliquez dessus

4. Ouvrez l’exemple 01_PARTICLE.INO

5. Cliquez sur “utiliser cet exemple”

6. Mettez votre Jeton d’Authentification ici : char auth[] = "YourAuthToken"; et flashez le

Particle !

Vous pouvez scanner ce code QR à partir de l’application Blynk et vous obtiendrez un projet prêt-à-
tester pour Particle Photon. Mettez simplement votre Jeton d’Authentification dans
l’exemple 01_PARTICLE.INO.

Contenus supplémentaires:

 Particle core + DHT22 - En Anglais

Opérations Principales de Blynk

Broches Virtuelles

Blynk peut contrôler des broches Digitales et Analogiques d’entrée et sortie sur votre hardware
directement. Vous n’avez même pas à écrire de code pour cela. C’est génial pour faire clignoter des
LEDs mais ce n’est souvent pas suffisant…

Nous avons conçu les broches Virtuelles pour envoyer toute sorte de données de votre micro-
controlleur vers l’Application Blynk et inversement.

Tout ce que vous connecterez à votre hardware sera capable de communiquer avec Blynk. Avec les
broches Virtuelles vous pouvez envoyer quelque-choque à partir de l’Application, le traiter sur le
micro-controlleur et le renvoyer vers le smartphone. Vous pouvez déclencher des fonctions, lire des
périphériques I2C, convertir des valeurs, contrôler des servo et DC moteurs, etc.

Les broches Virtuelles peuvent être utiliser pour interfacer avec des bibliothèques externes (Servo,
LCD, et autres) et implémenter des fonctionnalités personnalisées.

Le hardware peut envoyer des données aux Widgets à travers les broches Virtuels de cette manière :

Blynk.virtualWrite(pin, "abc");

Blynk.virtualWrite(pin, 123);

Blynk.virtualWrite(pin, 12.34);

Blynk.virtualWrite(pin, "hello", 123, 12.34);

Pour plus d’informations sur les broches Virtuelles, lisez ceci

Envoyer des données de l’application au hardware

Vous pouvez envoyer n’importe quelle donnée à partir des Widgets de votre application vers le
hardware.

Tous les Widgets Controller peuvent envoyer des données aux broches virtuelles de votre hardware.
Par exemple, le code ci-dessous montre comment obtenir des valeurs à partir du Widget Button de
l’Application

BLYNK_WRITE(V1) // Le Widget Button écrit à la broche virtuelle V1

int pinData = param.asInt();

Quand vous appuyez sur un Button, l’Application Blynk envoie 1. Au deuxième clic, elle envoie 0

Voici comment le Widget Button est configuré :

Croquis d’exemple complet: Obtenir des données

Envoyer un tableau à partir d’un Widget

Certains Widgets (comme le Joystick ou zeRGBa) ont plus d’une sortie.

Cette sortie peut être écrite à une broche Virtuelle en tant que tableau de valeurs. Du côté hardware
- Vous pouvez obtenir n’importe quel élément du tableau [0, 1, 2…] en utilisant :

BLYNK_WRITE(V1) // Le Widget ÉCRIT sur la broche Virtuelle V1

int x = param[0].asInt(); // Obtient la pemière valeur

int y = param[1].asInt(); // Obtient la seconde valeur

int z = param[N].asInt(); // Obtient la valeur N

Croquis : JoystickTwoAxis

Obtenir des données du hardware

Il y a deux manières d’envoyer des données de votre hardware vers les Widgets de votre application
à travers les broches Virtuelles.

Effectuer des requêtes par Widget

 En utilisant la fréquence de lecture intégrée pendant que l’Application est active en

configurant le paramètre ‘Reading Frequency’ à un certain interval :
BLYNK_READ(V5) // Le Widget dans l'application LIT la broche virtuelle V5 avec une certaine
fréquence

// Cette commande écrit le temps de disponibilité de l'Arduino en secondes à la broche Virtuelle V5

Blynk.virtualWrite(5, millis() / 1000);

Croquis : PushDataOnRequest

Envoyer des données à partir du hardware

Si vous avez besoin d’ENVOYER des données de capteur ou autre de votre hardware au Widget, vous
pouvez écrire la logique que vous souhaitez. Configurez simplement la fréquence en mode PUSH.
Toute commande que le hardware envoie au Cloud de Blynk est automatiquement stoqué sur le
serveur et vous obtenez cette information soit avec le widget History Graph soit avec HTTP API.

Nous vous recommandons d’envoyer des données par interval et d’éviter une erreur Flood.
Vous pouvez utiliser des chronomètres comme BlynkTimer. Suivez les instructions de ce croquis
d’exemple pour plus de détails.

Voici comment cela peut marcher :

#include <SPI.h>

#include <Ethernet.h>
#include <BlynkSimpleEthernet.h>

char auth[] = "YourAuthToken"; // Mettez votre jeton ici

BlynkTimer timer; // Créé un objet Chronomètre nommé timer

void setup()

Serial.begin(9600);

Blynk.begin(auth);

timer.setInterval(1000L, sendUptime); // Ici vous configurez l'interval (1sec) et quelle fonction

appeler

void sendUptime()

// Cette fonction envoie la durée de diponibilité de l'Arduino toutes les secondes au port Virtuel
(V5)

// Dans l'application, la fréquence de lecture du Widget devrait être paramétré sur PUSH

// Vous pouvez envoyer n'importe quoi avec n'importe quel interval en utilisant cette structure

// N'envoyez pas plus de dix valeurs par seconde

Blynk.virtualWrite(V5, millis() / 1000);

void loop()

Blynk.run(); // Toute la magie de Blynk se passe ici

timer.run(); // BlynkTimer fonctione...

Croquis : PushData
État de la synchronisation

Pour le hardware

Si votre hardware perd la connexion internet et redémarrage, vous pouvez restaurer toutes les
valeurs à partir des Widgets dans l’application Blynk.

BLYNK_CONNECTED() {

if (isFirstConnect) {

Blynk.syncAll();

// Ici, les gestionnaires pour la commande de synchronisation

BLYNK_WRITE(V0) {

....

La commande Blynk.syncAll() restaure toues les valeurs du Widget basées sur les dernières valeurs
sauvegardées sur le serveur. Les états des toutes les broches analogiques et digitales seront
restaurés. Chaque broche Virtuelle va effectuer un évènnement BLYNK_WRITE.

Synchroniser le hardware avec l’état de l’Application - En Anglais

Vous pouvez aussi ne mettre à jour qu’une seule broche Virtuelle en

appelant Blynk.syncVirtual(V0) ou vous pouvez mettre à jour plusieurs broches
avec Blynk.syncVirtual(V0, V1, V2, ...).

Vous pouvez aussi utiliser le serveur pour stocker n’importe quelle valeur sans Widget. Appelez
simplement Blynk.virtualWrite(V0, value).

Stocker une seule valeur sur le serveur - En Anglais

Stocker plusieurs valeurs sur le serveur - En Anglais

Pou l’application

Si vous avez besoin de synchroniser votre hardware avec l’état de votre Widget même si votre
application est hors ligne utilisez Blynk.virtualWrite.

Imaginez vous avez un Widget LED connecté à la broche Virtuelle V1 dans l’application et un bouton
physique attaché à votre hardware. Quand vous appuyez sur le bouton physique, vous attendez que
l’application affiche l’état du Widget LED mis à jour. Pour y parvenir vous avez besoin
d’envoyer Blynk.virtualWrite(V1, 255) quand un bouton physique est pressé.

Représenter l’état d’un bouton physique via le widget LED avec des interrupteurs - En Anglais

Représenter l’état d’un bouton physique via le widget LED avec Scrutation - En Anglais

Représenter l’état d’un bouton physique via le widget Button avec Scrutation - En Anglais
Contrôle de plusieurs périphériques

L’Application Blynk supporte plusieurs périphériques. Ce sinifie que vous pouvez assigner n’importe
quel widget à un périphérique spécifique avec son propre jeton d’authentification. Par exemple -
vous pouvez avoir un boutton sur V1 qui contrôle le voyant Wi-Fi A et un autre bouton sur V1 qui
contrôle le voyant Wi-Fi B. Afin de faire cela vous avez besoin de plus d’un périphérique dans votre
projet. Pour y parvenir, allez dans les paramètres du projet et cliquez sur la section “Devices” :

Vous obtiendrez une liste des périphériques :

Et pourrez ajouter de nouveaux périphériques :

Après les étapes ci-dessus, chaque widget aura plus d’un champ “Target” :
Désormais, vous avez besoin d’assigner le périphérique au widget et après cela le widget contrôlera
seulement ce périphérique spécifique.

C’est tout ! Maintenant vous avez besoin de téléverser des croquis avec les bons Jetons
d’Authentification dans votre hardware.

Étiquettes

La fonctionnalité Tags (étiquettes, en anglais) vous permet de grouper de multiples périphériques

entre eux. Les Tags sont très utiles lorsque vous voulez contrôler plusieurs périphériques avec un seul
widget. Par exemple, imaginez un cas où vous avez 3 ampoules intelligentes et vous voulez allumer
toutes ces ampoules avec un unique clic. Vous avez besoin d’assigner 3 périphériques à 1 tag et
assigner le tag à un bouton. C’est tout.

Les widgets Tag supportent aussi la synchronisation de l’état. Vous pouvez donc obtenir l’état du
widget à partir de votre hardware. Néanmoins vous ne pouvez mettre à jour l’état de tels widgets à
partir du hardware.

État des périphériques connectés

L’application Blynk supporte l’état de connectivité de plusieurs périphériques.

Dans un monde idéal, quand le périphérique ferme la connexion TCP avec connection.close() - le
serveur connecté reçoit une notification indiquant la fermeture de la connexion. Vous pouvez donc
obtenir une mise à jour instantanée de l’état sur l’interface utilisateur. Néanmoins, dans le monde
réel, c’est plutôt une situation exceptionnelle. Dans la majorité des cas, il n’y a pas de manière facile
et instantannée de découvrir que la connexion n’est plus active.

C’est pourquoi Blynk utilise le méchanisme HEARTBEAT. Avec cette approche, le périphérique envoie
périodiquement des commandes ping à un interval prédéfini (10 secondes par
défault, propriété BLYNK_HEARTBEAT). Dans le cas où le hardware n’envoie rien dans les dix
secondes, le serveur attend cinq secondes supplémentaires et après ça, la connexion est considérée
comme interrompue et fermée par le serveur. Sur l’interface utilisateur, vous verrez donc la mise à
jour de l’état 15 secondes après que ce soit réellement arrivé.

Vous pouvez aussi modifier l’interval de HEARTBEAT du côté hardware via Blynk.config. Dans ce cas,
la formule newHeartbeatInterval * 2.3 sera appliquée. Donc dans le cas où vous avez décider de
mettre l’interval HEARTBEAT à 5 secondes, vous serez notifié à propos de la connexion avec un délai
de 11 secondes dans le pire des cas.

Changer les propriétés d’un Widget

Changer certaines propriétés d’un widget à partir du côté hardware est aussi supporté. Par exemple,
vous pouvez changer la couleur du widget LED basé sur une condition :

// Change la couleur de la LED

Blynk.setProperty(V0, "color", "#D3435C");

// Change le label de la LED

Blynk.setProperty(V0, "label", "My New Widget Label");

// Change les labels du MENU

Blynk.setProperty(V0, "labels", "Menu Item 1", "Menu Item 2", "Menu Item 3");

Modifier les propriétés pour un champ à valeur unique- En Anglais

Modifier les propriétés pour un champ à valeur multiples - En Anglais

NOTE : Changer ces paramètres fonctionne SEULEMENT pour les widgets attachés à des broches
Virtuelles (les broches analogiques/digitales ne marcheront pas).

Quatre propriétés de widget sont supportées - color, label, min, max pour tous les widgets :

label est une chaîne de caractères pour le label de tous les widgets

color est une chaîne de caractères au format HEX (sous la forme: #RRGGBB, où RR (rouge), GG (vert)
et BB (bleu) sont des valeurs hexadécimales entre 00 et FF). Par exemple :

#define BLYNK_GREEN "#23C48E"

#define BLYNK_BLUE "#04C0F8"

#define BLYNK_YELLOW "#ED9D00"

#define BLYNK_RED "#D3435C"

#define BLYNK_DARK_BLUE "#5F7CD8"

Du côté logiciel, les objets widget supportent aussi les fonctions setLabel() et setColor().

Propriétés de Widget Spécifiques:

Button

onLabel est une chaîne de caractères pour le label ON du bouton;

offLabel est une chaîne de caractères pour le label OFF du bouton;

Music Player

isOnPlay est un booléen acceptant true/false;

Blynk.setProperty(V0, "isOnPlay", "true");

Menu

labels est une liste de chaînes de caractères pour la sélection du widget Menu;

Blynk.setProperty(V0, "labels", "label 1", "label 2", "label 3");

Vous pouvez aussi changer les propriétés d’un widget via l’API HTTP.
Limitations et Recommendations

 Ne mettez pas Blynk.virtualWrite ou n’importe quelle commande Blynk.* à l’intérieur de void

loop()- ce provoquera une tonne de messages sortants vers notre serveur et votre connexion
sera interrompue.

 Nous recommandons d’utiliser les fonctions avec des intervals. Par exemple, avec BlynkTimer

 Évitez d’utiliser de longs délais avec delay() – ce peut causer des interruptions de la
connexion;

 Si vous envoyez plus de cent valeurs par seconde - vous pouvez provoquer une erreur
Flood et votre hardware sera automatiquement déconnecté du serveur;

 Faites attention à ne pas envoyer trop de comamndes Blynk.virtualWrite puisque de

nombreux périphériques ne sont pas très puissants (comme l’ESP8266) alors il ne pourra pas
gérer beaucoup de requêtes.

Widgets

Les Widgets sont des modules d’interface. Chacun d’un effectue une fonction d’entrée / sortée
spécifique quand il communique avec le matériel.

Il y a 4 types de Widgets:

 Contrôleurs - ils envoient des commandes au matériel. Utilisez-les pour contrôler votre
équipement;

 Afficheurs - utilisés pour diverses visualisations de données qui viennent du matériel vers le
smartphone;

 Notifications - sont différents widgets utilisés pour envoyer des messages et des
notifications;

 Interface - sont divers widgets donnant un meilleur aspect à votre Interface Utilisateur;

 Autres - les widgets qui ne conviennent à aucune catégorie;

Chaque Widget a ses propres paramètres.

Certains des Widgets (par exemple le Widget Bridge) sont utilisés pour activer certaines
fonctionnalités et n’ont aucun paramètre.

Paramètres Communs des Widgets

Sélection de la Broche (Pin Select)

C’est un des paramètres principaux que vous avez besoin de définir. Il définit quelle broche contrôler
et quelle broche lire.
Broches Digitales - représente les broches d’entrée et sortie physiques de votre matériel. Les
broches PWM sont marquées avec le symbole ~

Broches Analogiques - représente les broches d’entrée et sortie analogiques de votre matériel

Broches Virtuelles - n’a aucune représentation physique. Elles sont utilisées pour n’importe quel
transfère de données entre l’Application Blynk et votre matériel. Lisez-en plus sur les Broches
Virtuelles ici.

Représentation des Données

Dans le cas où vous souhaitez représenter les données entrantes avec échelle spécifique vous pouvez
utiliser le bouton de représentation :
Disons que votre capteur envoie une valeur entre 0 et 1023. Vous souhaitez cependant afficher les
valeurs entre 0 et 100 dans l’application. Avec la représentation des données activée, la valeur
entrante 1023 sera représentée par 100.

SÉPARER/FUSIONNER (SPLIT/MERGE)

Certains Widgets peuvent envoyer plus d’une valeur et avec cet interrupteur vous pouvez contrôler
comment les envoyer.

 SÉPARER (SPLIT) : Chaque paramètre est envoyé directement à la broche de votre matériel
(par exemple D7). Vous n’avez pas besoin d’écrire le moindre code.

NOTE : Avec ce mode vous envoyez plusieurs commande à partir d’un widget, ce qui peut entraîner
des baisses de performance sur votre matériel.

Exemple : Si vous avez un Widget Joystick et qu’il est paramétré sur D3 et D4, il va envoyer 2
commandes sur Internet :

digitalWrite(3, value);

digitalWrite(4, value);
  FUSIONNER (MERGE): Quand le mode FUSIONNER est sélectionné, vous envoyez juste 1
message, consistant en un tableau de valeurs. Vous aurez néanmoins besoin de le traiter du
côté matériel.

Ce mode ne peut être utilisé qu’avec des Broches Virtuelles.

Exemple : Ajoutez un Widget zeRGBa et paramétrez-le sur le mode FUSIONNER. Choisissez la Broche
Virtuelle V1

BLYNK_WRITE(V1) // Il y a un Widget qui ÉCRIT des données sur V1

int r = param[0].asInt(); // récupère une valeur du canal ROUGE

int g = param[1].asInt(); // récupère une valeur du canal VERT

int b = param[2].asInt(); // récupère une valeur du canal BLEU

Envoyer Au Relâchement (Send On Release)

Cette option est disponible pour la plupart des widgets contrôleurs et vous permet de réduire le
trafic de données sur votre matériel. Par exemple, quand vous bougez un widget Joystick, les
commandes sont diffusées continuellement vers votre matériel et durant un simple mouvement de
Joystick, vous pouvez envoyer des dizaines de commandes. Dans certains cas d’utilisation cela peut
être nécessaire mais créer une telle charge peut causer un redémarrage du matériel. Nous
recommandons d’activer la fonctionnalité Envoyer Au Relâchement dans la plupart des cas, à moins
que vous ayez réellement besoin d’un retour instantanné. Cette option est activée par défaut.

Gradient de Couleurs

Certains widgets d’affichage ont la capacité de sélectionner un gradient. Le Gradient vous permet de
changer la couleur de vos Widgets sans aucun code. Nous fournissons actuellement 2 gradients :

 Chaud : Vert - Orange - Rouge;

 Froid : Vert - Bleu - Violet;

Les Gradients changent la couleur de votre widget en fonction de leur propriété min/max. Par
exemple, si vous sélectionnez le gradient chaud pour votre widget d’affichage de niveau avec comme
valeurs 0 en minimum et 100 en maximum, quand la valeur 10 arrivera au widget il va devenir vert,
quand la valeur 50 arrivera vous verrez du orange et quand la valeur 80 arrivera il deviendra rouge.

Contrôleurs

Bouton (Button)

Fonctionne en mode Presser (Push) ou Interrupteur (Switch). Vous permet d’envoyer des valeurs 0/1
(LOW/HIGH). Le bouton envoie 1 (HIGH) à la pression et 0 (LOW) au relâchement.
Croquis : BlynkBlink

Glissière (Slider)

Similaire à un potentiomètre. Vous permet d’envoyer des valeurs entre MIN et MAX.
Croquis : BlynkBlink

Chronomètre (Timer)

Le Chronomètre déclenche des actions à un moment spécifique, Même si le smartphone est hors-
ligne. Le temps de démarrage (START) envoie 1 (HIGH) et le temps d’arrêt (STOP) envoie 0 (LOW).

Les versions récentes d’Android ont aussi un Chronomètre amélioré avec le widget Eventor. Avec
l’évennement Eventor Chronométré vous pouvez assigner plusieurs chronomètres à la même broche,
envoyer n’importe quelle chaîne de caractères/nombre, sélectionner des jours et un fuseau horaire.
Il est recommendé d’utiliser le widget Eventor à la place du Chronomètre. Cependant, le widget
Chronomètre convient toujours à de simples évènements chronométrés.

Croquis : Timer

Joystick

Permet de contrôler les mouvements d’un servo-moteur dans 4 directions

Paramètres :

 Modes SÉPARER/FUSIONNER (SPLIT/MERGE) - lisez ici

 Pivoter sur Inclinaison (Rotate on Tilt)

Quand défini sur ON, le Joystick pivotera automatiquement si vous utilisez votre smartphone avec
l’orientation paysage.
  Retour Automatique (Autoreturn)

Quand défini sur OFF, le Joystick ne retournera pas à la position centrale. Il restera toujours là où
vous l’aurez laissé.

Croquis : JoystickTwoAxis

zeRGBa

zeRGBa est un contrôleur RVB classique (un sélecteur de couleur).

Paramètres :

 SÉPARER (SPLIT) : Chacun des paramètres est envoyé directement à la broche de votre
matériel (par exemple D7). Vous n’avez à écrire aucun code.

NOTE : Avec ce mode vous envoyez plusieurs commande à partir d’un widget, ce qui peut entraîner
des baisses de performance sur votre matériel.

Exemple: Si vous avez un Widget zeRGBa et qu’il est défini à D1, D2, D3, il enverra 3 commandes vers
Internet :

digitalWrite(1, r);

digitalWrite(2, g);
 digitalWrite(3, b);

 FUSIONNER (MERGE) : Quand le mode FUSIONNER (MERGE) est sélectionné, vous n’envoyez
qu’un message, consistant en un tableau de valeurs. Néanmoins vous avez besoin de le
traiter du côté matériel.

Ce mode ne peut être utilisé qu’avec des Broches Virtuelles.

Exemple: Ajoutez un Widget zeRGBa et paramétrez-le sur le mode FUSIONNER. Choisissez la Broche
Virtuelle V1.

BLYNK_WRITE(V1) // zeRGBa assigné à V1

// Récupère une valeur du canal ROUGE

int r = param[0].asInt();

// Récupère une valeur du canal VERT

int g = param[1].asInt();

// Récupère une valeur du canal BLEU

int b = param[2].asInt();

Contrôle du Pas (Step Control)

Le contrôle du Pas est comme 2 boutons assignés à 1 broche. Un bouton incrémente vos valeurs par
le pas désiré tandis que l’autre les décrémente. C’est très pratique dans des cas d’utilisation où vous
avez besoin de changer vos valeurs très précisément et que vous ne pouvez atteindre cette précision
avec le widget Glissière (Slider).

L’option Envoyer le Pas (Send Step) vous permet d’envoyer le pas au matériel à la place de la valeur
actuelle du widget. L’option Boucler la Valeur (Loop Value) vous permet de réinitialiser la valeur du
widget au début quand la valeur maximale est atteinte.

Croquis : Croquis Basique

Afficheurs

Afficheur de Valeur (Value Display)

Affiche les données entrantes de vos capteurs ou Broches Virtuelles.

Croquis : BlynkBlink

Valeur labelée (Labeled Value)

Affiche les données entrantes de vos capteurs ou Broches Virtuelles. C’est une version meilleure que
‘Afficheur de Valeur’ (Value Display) car il possède le formatage des chaînes de caractères, donc vous
pouvez formater les données entrantes vers n’importe quelle chaîne de caractère vous souhaitez.
Croquis : BlynkBlink

Options de Formatage

Assumons que votre capteur envoie le nombre 12.6789 à votre application Blynk. Les options de
formatage suivantes sont supportées :

/pin/ - affiche la valeur sans formatage (12.6789)

/pin./ - affiche la valeur sans la partie décimale (13)

/pin.#/ - affiche la valeur avec une décimale (12.7)

/pin.##/ - affiche la valeur avec deux décimales (12.68)

LED

Une simple LED d’information. Vous devez envoyer 0 afin d’éteindre la LED et 255 pour l’allumer.
Sinon, utilisez simplement l’API Blynk comme indiqué ci-dessous :

WidgetLED led1(V1); // Enregistre comme Broche Virtuelle V1

led1.off();

led1.on();

Toutes les valeurs entre 0 et 255 changeront la luminosité de la LED :

WidgetLED led2(2);

led2.setValue(127); // Défini la luminosité de la LED à 50%

Croquis : LED

Jauge (Gauge)

Un moyen visuel génial pour afficher les valeurs numériques entrantes.

Croquis : BlynkBlink

Options de Formattage

Jauge a aussi un champ “Label” qui nous permet d’utiliser le formatage. Assumons que votre capteur
envoie le nombre 12.6789 à votre application Blynk. Les options de formatage suivantes sont
supportées :

/pin/ - affiche la valeur sans formatage (12.6789)

/pin./ - affiche la valeur sans la partie décimale (13)

/pin.#/ - affiche la valeur avec une décimale (12.7)

/pin.##/ - affiche la valeur avec deux décimales (12.68)

LCD

C’est un affichage LCD 16x2 régulier fabriqué dans notre station secrète en Chine.

MODE SIMPLE / AVANCÉ (SIMPLE / ADVANCED)

Commandes

Vous avez besoin d’utiliser des commandes spéciales avec ce widget :

lcd.print(x, y, "Votre message");

Où x est un symbole de position (0-15), y est le numéro d’une ligne (0 ou 1)

lcd.clear();
Croquis : LCD Mode Avancé Croquis : LCD Mode Simple Écriture Croquis : LCD Mode Simple Lecture

Options de formattage

Assumons que votre capteur envoie le nombre 12.6789 à votre application Blynk. Les options de
formatage suivantes sont supportées :

/pin/ - affiche la valeur sans formatage (12.6789)

/pin./ - affiche la valeur sans la partie décimale (13)

/pin.#/ - affiche la valeur avec une décimale (12.7)

/pin.##/ - affiche la valeur avec deux décimales (12.68)

Graphique (Graph)

Tracez facilement les données de votre projet sous différentes formes.

Croquis : BlynkBlink

Graphique d’Historique (History Graph)

Vous permet de visualiser n’importe quelle données que votre matériel aura envoyé au préalable. Le
Graphique d’Historique a 3 types de précision :

 Précision à la Minute - 1h, 6h;

 Précision à l’Heure - 1d, 1w;

 Précision au Jour - 1m, 3m;

Cela signifie que l’interval de mise à jour minimum pour le graphique est de 1 minute pour les
périodes 1h et 6h, 1 heure pour 1d et 1w`` et 1 jour pour1met3m. Puisque Blynk Cloud est gratuit,
nous limitons combien de données vous pouvez stocker. Pour le moment, Blynk n'accepte qu'un
message par minute et par broche. Dans le cas où vous en envoyez plus fréquemment, une
moyennes de vos valeurs sera faite. Par exemple, dans le cas où vous envoyez ``10 à 12:12:05 puis
encore 12 à 12:12:45, vous verrez comme résultat, dans votre graphique d’historique la valeur ``11```
pour 12:12.

Afin de voir des données dans le graphique d’historique vous avez besoin de widgets avec l’intervalle
“Fréquence de lecture” (Frequency reading - dans ce cas votre application doit être ouverte et
lancée) ou vous pouvez utiliser Blynk.virtualWrite du côté matériel. Chaque
commande Blynk.virtualWrite est stockée automatiquement sur le serveur. Dans ce cas vous n’avez
pas besoin que l’application soit démarrée.

Vous pouvez aussi facilement vider les données pour les broches sélectionnées ou récupérer toutes
les données des brohes par email - Faitez juste glisser vers la gauche le graphique d’historique et
cliquez sur “Supprimer les données” (Erase data).

Vous pouvez aussi obtenir les données des broches via l’API HTTP.
Croquis : PushData

Terminal

Affiche des données à partir de votre matériel. Aussi, vous permet d’envoyer n’importe quelle chaîne
de caractère à votre matériel. Les terminaux conservent toujours les 25 derniers messages que votre
matériel a envoyé au Cloud Blynk. Cette limite peut être augmentée sur un Serveur Local.

Vous avez besoin d’utiliser des commandes spéciales avec ce widget :

terminal.print(); // Affiche des valeurs, comme Serial.print()

terminal.println(); // Affiche des valeurs, comme Serial.println()

terminal.write(); // Écrit un tampon de données brut

terminal.flush(); // S'assure que les données ont bien été envoyées au périphérique
Croquis : Terminal

Flux Vidéo (Video Streaming)

Widget simple vous permettant d’afficher n’importe quel flux direct. Le Widget supporte RTSP (RP,
SDP), HTTP/S flux progressif, HTTP/S flux direct. Pour plus d’informations, référez-vous à
la documentation officielle d’Android.

Pour le moment Blynk ne propose pas de serveurs de flux. Vous pouvez donc soit créer un flux
directement à partir de votre caméra, utiliser un service tiers ou héberger un serveur de flux sur
votre propre serveur (Sur un Raspberry par exemple).

Affichage du Niveau (Level Display)

Affiche les données entrantes de vos capteurs ou Broches Virtuelles. L’Affichage du Niveau est très
similaire à la barre de progression, offrant une vue agréable et moderne pour indiquer des
évènnements “remplis”, comme le “niveau de batterie”. Vous pouvez mettre à jour l’affichage de la
valeur du côté matériel avec le code :

Blynk.virtualWrite(V1, val);

Chaque message que le matériel envoie au serveur est stocké automatiquement sur le serveur. Le
mode PUSH ne requiert pas que l’application soit en ligne ou ouverte.

Croquis : Exemple de PUSH

Notifications

Twitter

Le widget Twitter connecte votre compte Twitter à Blynk et vous permet d’envoyer des Tweets à
partir de votre matériel.
Code d’exemple :

Blynk.tweet("Hey, Blynkers! Mon Arduino peut désormais Tweeter !");

Limites :

 vous ne pouvez envoyer 2 tweets avec le même message (ce sont les conditions d’utilisation
de Twitter)

 seulement 1 Tweet toutes les 15 secondes est autorisé

Croquis : Twitter

Email

Le widget d’Email vous permet d’envoyer un email à partir de votre matériel vers n’importe quelle
adresse.

Code d’exemple :

Blynk.email("mon_email@exemple.com", "Sujet", "Entrez votre message ici");

Il contient aussi le champ destinataire (to). Avec ce champ vous pouvez défini le destinataire de
l’email dans l’application. Dans ce cas, vous n’avez pas besoin de préciser le destinataire du côté
matériel :
Blynk.email("Sujet", "Entrez votre message ici");

Limites :

 Nombre maximum de caractères autorisés pour la longueur de l’email + le sujet + le message

est de 120 caractères. Néanmoins vous pouvez augmenter cette limite si cela est nécessaire
en ajoutant #define BLYNK_MAX_SENDBYTES XXX à votre croquis. Où XXX est la taille
maximale désirée pour votre email. Par exemple, pour un ESP vous pouvez définir à 1200 la
longueur maximale #define BLYNK_MAX_SENDBYTES 1200. Le #define
BLYNK_MAX_SENDBYTES 1200 doit être inclus avant n’importe quel include de Blynk.

Croquis : Email

Notifications Push (Push Notifications)

Le widget Notification Push vous permet d’envoyez des notifications push de votre matériel à votre
périphérique. Actuellement il contient 2 options aditionnelles :

 Notifier quand le matériel est Hors-ligne (Notify when hardware offline) - vous recevrez
une notification push lorsque le matériel deviendra hors-ligne.

 Période d’Ignorance du status Hors-ligne (Offline Ignore Period) - défini combien de temps
votre matériel peut être hors-ligne (après qu’il soit passé hors-ligne) avant d’envoyer la
notification. Dans le cas où la période est dépassée - La notification “matériel hors-ligne”
 (hardware offline) sera envoyée. Vous ne recevrez pas de notification dans le cas où le
matériel se reconnecte avant la fin de la période indiquée.

 Priorité Une haute priorité donne plus de chances que votre message sera délivré sans délai.
Consultez les explications supplémentaires ici.

ATTENTION : une priorité haute use plus de batterie que la priorité normale.

Code d’exemple :

Blynk.notify("Hey, Blynkers! Mon matériel peut push désormais !");

Limites :

 La longueur maximale du corps du message est de 120 caractères.

 Seulement 1 notification toutes les 15 secondes est autorisée

Croquis : PushNotification
Unicode dans les notifications, email, push, …

La bibliothèque gère toutes les chaînes de caractères en UTF-8 Unicode. Si vous faites face à
quelques problèmes, essayez d’afficher le message dans le moniteur Série et voyez si cela fonctionne
(le moniteur doit être paramétré sur l’encodage UTF-8). Si cela ne fonctionne pas, vous devriez
probablement lire à propos du support de l’unicode de votre compilateur. Si cela marche mais que
votre message est tronqué - vous avez besoin d’augmenter la taille limite (tout caractère Unicode
utilise au moins deux fois la taille des caractères Latin).

Augmentation de la taille limite

Vous pouvez augmenter la longueur maximale d’un message en ajoutant en haut de votre croquis
(avant les include Blynk) :

#define BLYNK_MAX_SENDBYTES 256 // 128 par défaut

Interface

Onglets (Tabs)

Le seul but du widget Onglets est d’étendre l’espace de votre projet. Vous pouvez avoir jusqu’à 4
onglets. Aussi, vous pouvez déplacer les widgets entre les onglets. Déplacez simplement le widget sur
le label de l’onglet voulu du widget onglets.

Menu

Le widget Menu vous permet d’envoyer des commandes à votre matériel basé sur la sélection faite
sur l’Interface Utilisateur. Le Menu envoie l’index de l’élément que vous sélectionnez et non la valeur
du label. Les index envoyés commencent à partir de 1. Il fonctionne de la même manière que
l’élément habituel ComboBox. Vous pouvez aussi définir des objets Menu à partir du côté matériel.
Code d’exemple:

switch (param.asInt())

case 1: { // Objet 1

Serial.println("Objet 1 sélectionné");

break;

case 2: { // Item 2

Serial.println("Objet 2 sélectionné");

break;

Croquis : Menu

Entrée Temps (Time Input)

Le widget Entrée Temps vous permet de sélectionner des valeurs de démarrage/arrêt, du jour de la
semaine, de fuseau horaire formatées et de les envoyer à votre matériel. Les valeurs actuellement
supportées pour le temps sont HH:MM et HH:MM AM/PM.

Hardware will get selected on UI time as seconds of day (3600 * hours + 60 * minutes) for start/stop
time.
Croquis : Simple Entrée Temps pour le temps de démarrage

Croquis : Entrée Temps Avancée

Carte (Map)

Le widget Carte vous permet de définir des points/marqueurs sur votre carte à partir du côté
matériel. C’est un widget très utile si vous possédez plusieurs périphériques et que vous voulez pister
leurs valeurs sur une carte.

Vous pouvez envoyer un point vers la carte avec la commande write classique :

Blynk.virtualWrite(V1, pointIndex, lat, lon, "valeur");

Nous avons aussi créé un adaptateur pour vous afin de rendre l’utilisation de la carte plus facile :

Vous pouvez changer les labels des boutons à partir du matériel avec :

WidgetMap myMap(V1);

...

int index = 1;

float lat = 51.5074;

float lon = 0.1278;

myMap.location(index, lat, lon, "valeur");

Utiliser un index sauvegardé vous permet de surcharger la valeur d’un point.

Croquis : Croquis Basique

Tableau (Table)

Le widget Tableau s’avère utile quand vous avez besoin de structurer des données similaire dans 1
élément graphique. Il marche comme un tableau habituel.
Vous pouvez ajouter une ligne au tableau avec :

Blynk.virtualWrite(V1, "add", id, "Nom", "Valeur");

Note : Le nombre maximum de lignes dans un tableau est de 100. Quand vous atteignez cette limite,
le tableau fonctionnera comme une liste FIFO (First In First Out - Premier Arrivé Premier Sorti). Cette
limite peut être changée en configurant la propriété table.rows.pool.size pour les serveurs locaux.

Surligner n’importe quel objet dans un tableau en utilisant son index, dans un tableau commençant à
partir de 0 :

Blynk.virtualWrite(V1, "pick", 0);

Vider le tableau à n’importe quel moment avec :

Blynk.virtualWrite(V1, "clr");

Vous pouvez aussi gérer d’autres actions provenant du tableau. Par exemple, utiliser une ligne
comme un bouton Interrupter (Switch).

BLYNK_WRITE(V1) {

String cmd = param[0].asStr();

if (cmd == "select") {

//La ligne a été sélectionée dans le tableau

int rowId = param[1].asInt();

}
 if (cmd == "deselect") {

//La ligne a été désélectionée dans le tableau

int rowId = param[1].asInt();

if (cmd == "order") {

//Les lignes ont été réorganisées dans le tableau

int oldRowIndex = param[1].asInt();

int newRowIndex = param[2].asInt();

Croquis : Utilisation Simple des Tableaux

Sélecteur de Périphérique (Device Selector)

Le Sélecteur de Périphérique est un widget puissant vous permettant de mettre à jour les widgets en
fonction d’un périphérique actif. Ce widget est particulièrement utile lorsque vous avez une flotte de
périphériques avec une fonctionnalité similaire.

Imaginez vous avez 4 périphériques et que chaque périphérique a un capteur de Température &
d’Humidité branché dessus. Pour afficher les données des quatre périphériques vous aurez besoin
d’ajouter 8 widgets.

Avec le Sélecteur de Périphérique, vous pouvez utiliser seulement 2 Widgets qui affichera la
Température et l’Humidité basé sur le périphérique actif choisi avec le Sélecteur de Périphérique.

Tout ce dont vous avez besoin est : 1. Ajouter le widget Sélecteur de Périphérique (Device Selector)
au projet 2. Ajouter 2 widgets (par exemple, le widget Afficheur de Valeur (Value Display)) afin
d’afficher la Température et l’Humidité 3. Dans les paramètres des widgets vous serez en mesure de
les assigner au Sélecteur de Périphérique (Section Source ou Destinataire (Target)) 4. Quitter les
paramètres. Lancer le projet.

Désormais vous pouvez changer le périphérique actif dans le sélecteur de périphériques et vous
verrez que les valeurs de la Température et de l’Humidité reflètent les données mises à jour pour le
périphérique que vous avez choisi.

NOTE : Les widgets Graphique d’Historique (History Graph) et Webhook ne fonctionnent pas (encore)
avec le Sélecteur de Périphérique.

Capteurs

Accéléromètre (Accelerometer)

L’Accéléromètre est un type de capteurs de mouvement vous permettant de détecter les

mouvements de votre smartphone. Utile pour analyser les mouvements d’un périphérique, comme
l’inclinaison, la secousse, la rotation, ou le balancement. Conceptuellement, un capteur
d’accélération détermine l’accélération appliquée à un périphérique par la mesure des forces
appliquées sur le capteur. Mesurée en m/s^2 appliquée aux axes x, y, z.
Afin d’accepter des données de ce capter, vous avez besoin de :

BLYNK_WRITE(V1) {

//Force d'accélération appliquée à l'axe x

int x = param[0].asFloat();

//Force d'accélération appliquée à l'axe y

int y = param[1].asFloat();

//Force d'accélération appliquée à l'axe z

int z = param[2].asFloat();

Le widget Accéléromètre ne fonctionne pas en tâche de fond.

Baromètre/Pression (Barometer/Pressure)

Le capteur Baromètre/Pression est un type de capteurs environnementaux vous permettant de

mesure la pression de l’air ambiant.

Mesurée en hPa ou mbar.

Afin d’accepter des données de ce capteur vous avez besoin de :

BLYNK_WRITE(V1) {

//pression en mbar

int pressure = param[0].asInt();

Le widget Baromètre ne fonctionne pas en tâche de fond.

Gravité (Gravity)

Le capteur Gravité est un type de capteurs de mouvement vous permettant de détecter les
mouvements de votre smartphone. Utile pour analyser les mouvements d’un périphérique, comme
l’inclinaison, la secousse, la rotation, ou le balancement.

Le capteur de gravité fourni un vecteur à trois dimensions indiquant la direction et la magnitude de la

gravité.

Mesuré en m/s^2 de force de gravité appliquée aux axes x, y, z.

Afin d’accepter des données de ce capteur vous avez besoin de :

BLYNK_WRITE(V1) {

//Force de gravité appliquée à l'axe x

int x = param[0].asFloat();

//Force de gravité appliquée à l'axe y

 int y = param[1].asFloat();

//Force de gravité appliquée à l'axe z

int z = param[2].asFloat();

Le widget Gravité ne fonctionne pas en tâche de fond.

Humidité (Humidity)

Le capteur d’Humidité est un type de capteurs environnementaux vous permettant de mesurer

l’humidité relative ambiante.

Mesurée en % - l’humidité relative actuelle en pourcentage.

Afin d’accepter des données de ce capteur vous avez besoin de :

BLYNK_WRITE(V1) {

// humidité en %

int humidity = param.asInt();

Le widget Humidité ne fonctionne pas en tâche de fond.

Luminosité (Light)

Le capteur de Luminosité est un type de capteurs environnementaux vous permettant de mesurer le

niveau de luminosité (mesure le niveau de luminosité ambiant (illumination) en lx). Dans les
téléphones il est utilisé pour contrôler la luminosité de l’écran.

Afin d’accepter des données de ce capteur vous avez besoin de :

BLYNK_WRITE(V1) {

//Valeur de la luminosité

int lx = param.asInt();

Le widget Luminosité ne fonctionne pas en tâche de fond.

Proximité (Proximity)

Le capteur de Proximité est un type de capteurs de position vous permettant de déterminer combien
est proche la face d’un smartphone vis-à-vis d’un objet. Mesurée en cm - la distance de la face d’un
téléphone vis-à-vis d’un objet. Néanmoins, la majorité de ces capteurs retournent seulement
l’information LOIN / PROCHE (FAR / NEAR). La valeur retournée sera donc 0/1. Où 0/LOW est LOIN et
1/HIGH est PROCHE.

Afin d’accepter des données de ce capteur vous avez besoin de :

BLYNK_WRITE(V1) {

// distance d'un objet

 int proximity = param.asInt();

if (proximity) {

//PROCHE

} else {

//LOIN

Le widget Proximité ne fonctionne pas en tâche de fond.

Température

Le capteur de Température est un type de capteurs environnementaux vous permettant de mesurer

la température de l’air ambiant. Mesurée en °C - celcius.

Afin d’accepter des données de ce capteur vous avez besoin de :

BLYNK_WRITE(V1) {

// température en celcius

int celcius = param.asInt();

Le widget Température ne fonctionne pas en tâche de fond.

Déclencheur GPS (GPS Trigger)

Le Déclencheur GPS vous permet de déclencher facilement des évènements lorsque vous arrivez ou
quittez une destination. Ce widget fonctionnera en tâche de fond et vérifiera périodiquement vos
coordonnées. Dans le cas où votre position est à l’intérieur/à l’extérieur du rayon requis (sélectionné
sur le widget Carte (Map)), le widget enverra la commande HIGH/LOW au matériel. Par exemple,
assumons que vous avez le widget Déclencheur GPS assigné à la broche V1 et l’option Déclencher
Quand Entrée (Trigger When Enter). Dans cette situation, lorsque vous arrivez au point de
destination, le widget va déclencher l’évennement HIGH.

BLYNK_WRITE(V1) {

int state = param.asInt();

if (state) {

//Vous entrez dans une destination

} else {

//Vous quittez une destination

Plus de détails sur le fonctionnement du widget GPS peuvent être lus ici.
Le widget Déclencheur GPS fonctionne en tâche de fond.

Flux GPS (GPS Streaming)

Utile pour analyser des données sur la position du smarthone comme la latitude, longitude, altitude
et vitesse (speed - la vitesse peut souvent être sur 0 dans le cas où le smartphone ne le supporte
pas).

Afin d’accepter des données de ce capteur vous avez besoin de :

BLYNK_WRITE(V1) {

float latitude = param[0].asFloat();

float longitude = param[1].asFloat();

float altitude = param[2].asFloat();

float speed = param[3].asFloat();

ou vous pouvez utiliser l’adaptateur préparé GpsParam :

BLYNK_WRITE(V1) {

GpsParam gps(param);

// Affiche 7 décimales pour la Latitude

Serial.println(gps.getLat(), 7);

Serial.println(gps.getLon(), 7);

Serial.println(gps.getAltitude(), 2);

Serial.println(gps.getSpeed(), 2);

Le widget Flux GPS fonctionne en tâche de fond.

Croquis : Flux GPS

Autre

Pont (Bridge)

Le Pont peut être utilisé pour une communication de Périphérique-à-Périphérique (pas d’application
impliquée). Vous pouvez envoyer des commandes d’écriture (write) digitales/analogiques/virtuelles
d’un périphérique à un autre, une fois le jeton d’authentification connu. Pour le moment le widget
Pont ne nécessite pas le côté application (Il est surtout utilisé comme indication que nous possédons
une telle fonctionnalité).

Vous pouvez utiliser plusieurs ponts pour contrôler plusieurs périphériques.

Le widget Pont prend une broche virtuelle et la transforme en un canal afin de contrôler un autre
périphérique. Ce signifie que vous pouvez contrôler n’importe quelle broche virtuelle, digitale ou
analogique du périphérique ciblé. Faites attention à ne pas utiliser de broches comme A0, A1, A2
... lorsque vous communiquez entre différents types de périphériques, car le Coeur d’Arduino peut se
référer aux mauvaises branches dans de tels cas.

Code d’exemple pour un périphérique A envoyant des valeurs au périphérique B :

WidgetBridge bridge1(V1); //Initialise le widget Pont sur la broche V1 du Périphérique A

// ...

void setup() {

Blynk.begin(...);

while (Blynk.connect() == false) {

// Attend jusqu'à ce que Blynk soit connecté

}
 bridge1.digitalWrite(9, HIGH); // déclenche D9 HIGH sur le périphérique B. Aucun code n'est requis
sur le périphérique B

bridge1.analogWrite(10, 123);

bridge1.virtualWrite(V1, "hello"); // Vous avez besoin d'écrire du code sur le périphérique B afin de
recevoir cette valeur. Observez plus bas

bridge1.virtualWrite(V2, "value1", "value2", "value3");

BLYNK_CONNECTED() {

bridge1.setAuthToken("OtherAuthToken"); // Jeton du périphérique B

IMPORTANT : pendant l’exécution de virtualWrite() avec le widget Pont, le périphérique B devra

traiter les données provenant du périphérique A. Par exemple, si vous envoyez une valeur à partir du
périphérique A vers le périphérique B en utilisant bridge.virtualWrite(V5) vous aurez besoin d’utiliser
cette méthode sur le périphérique B :

BLYNK_WRITE(V5){

int pinData = param.asInt(); // la variable pinData va stocker la valeur récupérée via le Pont

Gardez en tête que bridge.virtualWrite n’envoie aucune valeur à l’application mobile. Vous avez
besoin d’appeler Blynk.virtualWrite pour cela.

Croquis : Bridge

Eventor

Le widget Eventor vous permet de créer de simples règles comportementales

ou évennements (events). Observons un cas d’utilisation typique : lire la température d’un capteur
DHT et envoyer une notification push quand la température est au dessus d’une certaine limite :

float t = dht.readTemperature();

if (isnan(t)) {

return;

if (t > 40) {

Blynk.notify(String("La Température est trop élevée : ") + t);

Avec l’Eventor, vous n’avez pas besoin d’écrire ce code. Tout ce dont vous avez besoin est d’envoyer
une valeur du capteur vers le serveur :
 float t = dht.readTemperature();

Blynk.virtualWrite(V0, t);

N’oubliez pas que les commandes virtualWrite ne peuvent être utilisées dans la boucle principale.

Maintenant, configurez le nouvel Évennement (Event) dans le widget Eventor :

NOTE : N’oubliez pas d’ajouter un widget de notification.

L’Eventor se révèle utile lorsque vous avez besoin de changer des conditions à la colée sans
téléverser de nouveau le croquis vers le matériel. Vous pouvez créer autant d’évennements que vous
le souhaitez. L’Eventor supporte aussi des évennements Chronomètre (Timer). Par exemple, vous
pouvez définir la broche V1 ON/HIGH à 21:00:00 tous les Vendredi. Avec l’Évennement Chronomètre
d’Eventor vous pouvez assigner de multiples chronomètres sur la même broche, leur envoyer
n’importe quelle chaîne de caractères/nombre, sélectionner des jours et un fuseau horaire.

Afin de supprimer un évennement créé, faites-le glisser. Vous pouvez aussi faire glisser dehors le
dernier élément de l’Évennement lui-même.
Croquis: Eventor

NOTE : Les évennemens sont déclenchés uniquement lorsque la condition est rencontrée.
Néanmoins il y a une exception : Considérons le simple évènement suivant if (temperature > 40) send
notification. Quand la température dépasse le seuil de 40 - l’action notification est déclenchée. Si la
tepérature continue de rester au delà du seuil de 40, aucune action ne sera déclenché. Mais si la
notification temperature descend en dessous du seuil puis passe de nouveau au dessus - la
notification sera de nouveau envoyée (il n’y a pas de limite de 15 secondes pour les notifications
d’Eventor).

Horloge Temps-Réel (Real-time clock)

L’Horloge Temps-Réel vous permet d’obtenir l’heure du serveur. Vous pouvez préselectionner
n’importe quel fuseau horaire sur l’Interface Utilisateur afin d’obtenir l’heure sur le matériel dans la
langue requise. Aucune broche n’est requise pour le widget Horloge Temps-Réel
Croquis : Horloge Temps-Réel

BLE

Widget pour activer le support du Bluetooth Basse Énergie (Bluetooth Low Energy). Pour le moment
le widget BLE n’est supporté que pour Android et requiert une connexion internet afin de se
connecter et charger votre profil. Néanmoins, ce sera bien résolu. Aussi, certains widgets Blynk ne
sont pas compatibles avec le widget BLE.

Actuellement, Blynk supporte beaucoup de modules différents. Référez-vous aux croquis ci-dessous.
Croquis : BLE

Bluetooth

Widget pour activer le support du Bluetooth. Widget for enabling Bluetooth support. Pour le
moment le widget Bluetooth n’est supporté que pour Android et requiert une connexion internet
afin de se connecter et charger votre profil. Néanmoins, ce sera bien résolu. Aussi, certains widgets
Blynk ne sont pas compatibles avec le widget Bluetooth.

Actuellement, Blynk supporte beaucoup de modules différents. Référez-vous aux croquis ci-dessous.
Croquis : Bluetooth

Lecteur de Musique (Music Player)

Un simple élément d’Interface Utilisateur avec 3 boutons - simule l’interface d’un lecteur de
musique. Chaque bouton envoie sa propre commande au matériel : play, stop, prev, next.

Vous pouvez aussi changer l’état marche/arrêt (play/stop) du widget via la fonctionnalité Changer
une Propriété de Widget avec la propriété isOnPlay.

Croquis : Lecteur d Musique

Webhook

Le Webhook est un widget pour l’intégration de services tiers. Avec le widget webhook vous pouvez
envoyer des requêtes HTTP/S aux serveurs de services tiers ou à un périphérique qui possède une
API HTTP/S (par exemple le Philips Hue).

Toute opération d’écriture du côté matériel déclenche le widget Webhook (de la même manière que
pour l’Eventor). Vous pouvez aussi déclencher le Webhook à partir de l’application si un widget
contrôleur est assigné à la même broche que le Webhook. Vous pouvez déclencher un service tiers
avec le simple appui sur un bouton.

Par exemple, imaginons un cas où vous souhaitez envoyer des données de votre matériel non
seulement à Blynk mais aussi au serveur Thingspeak. Dans un cas classique typique vous aurez besoin
d’écrire du code comme celui-ci (c’est le code minimal et non le croquis entier) :

WiFiClient client;

if (client.connect("api.thingspeak.com", 80)) {
 client.print("POST /update HTTP/1.1\n");

client.print("Host: api.thingspeak.com\n");

client.print("Connection: close\n");

client.print("X-THINGSPEAKAPIKEY: " + apiKeyThingspeak1 + "\n");

client.print("Content-Type: application/x-www-form-urlencoded\n");

client.print("Content-Length: ");

client.print(postStr.length());

client.print("\n\n");

client.print(postStr);

Avec le widget Webhook ce n’est plus nécessaire. Vous avez juste besoin de remplir les champs ci-
dessous :

Et faire l’habituel :

Blynk.virtualWrite(V0, value);

où V0 est la broche assignée au widget Webhook.

Vous pouvez aussi utiliser les chaînes génériques habituelles pour la valeur de la broche dans le corps
(body) ou l’url. Par exemple :
https://api.thingspeak.com/update?api_key=xxxxxx&field1=/pin/

ou pour le corps

["/pin/"]

Vous pouvez aussi vous référer aux indexes spécifiques des broches à multiples valeurs (les broches à
multiples valeurs supportent jusqu’à 5 valeurs) :

/pin[0]/,/pin[1]/, /pin[2]/

Un autre fait sympa à propos du Webhook est que vous pouvez faire des requêtes GET à partir du
Serveur Blynk et retourner la réponse directement à votre matériel. Ce qui est intéressant ici est que
vous n’avez pas besoin de programmer une requête vers le service tiers. Imaginez un cas où vous
souhaiter obtenir la météo d’un service tiers. Par exemple, vous avez l’url http://api.sunrise-
sunset.org/json?lat=33.3823&lng=35.1856&date=2016-10-01, vous souhaitez la mettre dans le
widget, sélectionnez la broche V0, et faites l’habituel :

BLYNK_WRITE(V0){

String webhookdata = param.asStr();

Serial.println(webhookdata);

Maintenant, chaque fois que vous déclencherez la broche V0 (avec Blynk.virtualWrite(V0, 1) du côté
matériel ou un widget contrôleur assigné à V0) - BLYNK_WRITE(V0) sera appelé.

NOTE : habituellement les serveurs de services tiers retournent de grosses réponses, alors vous
devez augmenter la taille maximale autorisée par votre matériel avec #define
BLYNK_MAX_READBYTES 1024. Où 1024 - est la taille maximum autorisée d’un message.

NOTE : Le cloud de Blynk a une limitation pour le widget Webhook - vous n’êtes autorisé de
n’envoyer qu’une seule requête par seconde. Vous pouvez changer ceci sur les serveurs locaux
avec webhooks.frequency.user.quota.limit. Faites très attention en utilisant les Webhooks car de
nombreuses ressources ne sont pas capables de gérer 1 req/sec, donc vous pourriez être banni par
certaines d’entre elles. Par exemple, ThingSpeak n’autorise qu’une requête toutes les 15 secondes.

NOTE : Afin d’éviter de polluer Blynk, le Webhook a une limitation supplémentaire - dans le cas où la
requête Webhook a échoué dix fois de suite, votre widget Webhook sera arrêté. Afin de le
redémarrer vous aurez besoin d’ouvrir le widget et de le sauvegarder de nouveau. Les requêtes
échouées sont des requêtes retournant un code status différent de 200 ou 302.

Partage

Blynk dispose de deux manières pour partager vos projets avec d’autres personnes :

 Partager l’accès à votre hardware. Imaginez donner à quelqu’un une Application pour votre
Projet. Ils ne peuvent le modifier mais peuvent contrôler et voir ce qu’il y a dedans.

 Partager la configuration de votre Projet. Les autres obtiendront un clone de votre projet en
scannant un lien QR, mais ils ne seront pas en mesure de contrôler votre hardware. C’est
génial pour les tutoriels, instructables, etc.

Accès partagé à votre hardware

Imaginez donner à quelqu’un une Application pour contrôler votre Projet.

 Les personnes à qui vous avez partagé votre projet ne peuvent rien modifier. Elles ne
peuvent que l’utiliser

 Vous pouvez mettre à jour votre application, changer la disposition, ajouter des widgets et
tout sera immédiatement synchronisé à tout le monde

 Vous pouvez révoquer l’accès à tout moment

Comment cela fonctionne : - vous envoyez un code QR à vos utilisateurs (vous pouvez l’envoyer par
email, l’imprimer, le publier sur les réseaux sociaux, faire ce que vous voulez avec) - les autres
téléchargent l’Application Blynk, scannent le code QR et votre application s’ouvre pour eux, prête à
l’usage. Ils n’ont même pas besoin de se connecter ou de créer un compte.

Allez dans vos Paramètres de Projet :

Cliquez sur le bouton “Générer un lien” (Generate link) :

Ce génèrera un code QR que vous pourrez partager avec les autres :

C’est tout ! Maintenant Quittez les paramètres et pressez le bouton LANCER.

L’autre personne aura besoin d’installer l’application Blynk et de scanner le code QR à partir de
l’écran de connexion (Scanner à partir d’un profil existant n’est pas encore supporté) :
NOTE : Votre projet doit être actif, n’oubliez pas d’appuyer sur le bouton LANCER.

ATTENTIOn : Partager coûte 1000 d’énergie et cette énergie n’est pas récupérable, même si vous
n’avez rien partagé du tout.

Partager la configuration de votre Projet

Dans le cas où vous souhaitez partager la configuration de votre projet sans donner l’accès à votre
hardware (Par exemple pour créer un tutoriel) - suivez ces étapes :

Dans les Paramètres du Projet, utilisez le bouton Cloner (Clone).

Un code QR que vous pourrez partager avec tout le monde sera généré.

L’autre personne devra se Connecter (Log In) à l’application Blynk et appuyer sur le bouton QR dans
la gallerie de Projets.
Après le scan, un nouveau Projet sera créé, tous les widgets, les paramètres et leur disposition seront
clonés. L’autre personne aura besoin de suffisamment d’Énergie pour cloner votre Projet.

Le Jeton d’Authentification sera différent !. Personne n’aura accès à votre hardware. Ils auront juste
une copie de votre disposition et des paramètres.

API RESTful HTTP

L’API RESTful HTTP vous permet de lire et écrire facilement les valeurs des broches dans les
applications et hardwares connectés à Blynk. La description de l’API peut être trouvée ici - En Anglais.

Hardwares Supportés

Blynk supporte déjà plus de 400 cartes, offrant le support pour Arduino, Particle, ARM-basés, TI
Energia, MicroPython, Node.js, OpenWRT et de nombreuses ordinateurs à carte unique. Vous pouvez
ajouter vos propres types de connexion facilement (voyez ces exemples pour Arduino) !

Plateformes

 Arduino (https://github.com/blynkkk/blynk-library)

o Arduino Uno, Duemilanove

o Arduino Nano, Mini, Pro Mini, Pro Micro, Due, Mega

o Arduino 101 (Intel Curie, with BLE)

o Arduino MKR1000

o Arduino Zero

o Arduino Yún (onboard WiFi and Ethernet, via Bridge)

 Semblables à l’Arduino
 o Blynk Board

o ESP8266 (Generic, NodeMCU, Witty Cloud, Huzzah, WeMos D1, Seeed Wio Link, etc.)

o ESP32 Dev Board

o Intel Edison

o Intel Galileo

o Teensy 3.2/3.1

o Blue Pill (STM32F103C)

o BBC micro:bit

o LightBlue Bean , soon

o DFRobot Bluno

o RedBear Duo (WiFi, BLE)

o RedBearLab Blend Micro

o RedBearLab BLE Nano (v1 and v2)

o Seeed Tiny BLE

o Simblee BLE

o RFduino BLE

o The AirBoard (BLE-Link, RN-XV)

o Feather M0 WiFi

o Feather 32u4 BLE

o Fishino Guppy, Uno, Mega

o TinyCircuits TinyDuino (CC3000)

o Microduino/mCookie Core, Core+, CoreUSB

o Wicked WildFire V2, V3, V4

o Digistump Oak

o chipKIT Uno32

o Alorium XLR8 (FPGA)

o LinkIt ONE (WiFi only)

 Energia

o Texas Instruments

 CC3200-LaunchXL

 Tiva C Connected LaunchPad

  Stellaris LM4F120 LaunchPad

 MSP430F5529 + CC3100

 LaunchPad MSP432

o RedBearLab (CC3200, WiFi Mini)

 Particle https://github.com/vshymanskyy/blynk-library-spark)

o Core

o Photon

o Electron

o RPi

o SparkFun RedBoard

o RedBear Duo (WiFi & BLE)

 ARM-basés (https://developer.mbed.org/users/vshymanskyy/code/Blynk/)

o Seeed Tiny BLE

o RedBearLab BLE Nano

o BBC micro:bit

o STM32 Nucleo + Wiznet 5100 , soon

 JavaScript (Node.js, Espruino, Browsers) (https://www.npmjs.com/package/blynk-library)

o Regular PC with Linux / Windows / OS X

o Raspberry Pi (Banana Pi, Orange Pi, …)

o BeagleBone Black

o Onion Omega

o Intel Galileo

o Intel Edison

o Intel Joule

o LeMaker Guitar

o LeMaker Banana Pro

o Samsung ARTIK 5

o PandaBoard, CubieBoard, pcDuino, Tessel 2

o VoCore (OpenWRT + Espruino package)

o Espruino Pico

o …
  Python (MicroPython) (https://github.com/wipy/wipy/tree/master/lib/blynk)

o WiPy

 Lua (https://github.com/blezek/blynk-esp)

o NodeMCU

Types de Connexions à l’Arduino

 USB (Serial), connecté à votre ordinateur

 Ethernet :

o Arduino Ethernet Shield (W5100)

o Arduino Ethernet Shield 2 (W5500)

o SeeedStudio Ethernet Shield V2.0 (W5200)

o ENC28J60-based modules

 WiFi :

o ESP8266 comme modem WiFi (avec le logiciel original)

o Arduino WiFi 101 Shield

o Arduino WiFi Shield

o Adafruit CC3000 WiFi Breakout / Shield

o RN-XV WiFly

 Bluetooth Smart (BLE 4.0):

o HM-10, HC-08

o DFRobot BLE-Link module

o Microduino/mCookie BLE

o RedBearLab BLE Mini

o nRF8001-based boards (Adafruit Bluefruit LE, etc.)

 Bluetooth 2.0 Serial Port Profile (SPP)

o HC-05, HC-06, …

 GSM/3G:

o SIMCom SIM800 series (SIM800A, SIM800C, SIM800L, SIM800H, SIM808, SIM868)

o SIMCom SIM900 series (SIM900A, SIM900D, SIM908, SIM968)

o M590

o A6/A7 (alpha)

o GPRSbee
 o Microduino GSM

o Adafruit FONA (Mini Cellular GSM Breakout)

o Adafruit FONA 800/808 Shield

Faits par la Communauté

 WIZnet-W5500-EVB

 LabVIEW

 Node-RED (can be used as bridge to HTTP, TCP, UDP, MQTT, XMPP, IRC, OSC…)

Cartes reconnues pour avoir des problèmes

Ces cartes ne sont pas supportées et semblent avoir un problème pour marcher hors de leur
fonctionnement original : - Arduino UNO WiFi - Arduino Tian

Résolution des Problèmes

Connexion

Si vous expérimpentez des problèmes de connexion, suivez ces étapes : 1. Vérifiez que votre
matériel, vos câbles et votre alimentation électrique sont de bonne qualité, non-endommagés, etc.
Utilisez des câbles et ports USB à haute puissance. 2. Vérifiez vos câblages en utilisant les exemples
(Client TCP/HTTP ou similaire) fournis avec votre shield ou matériel. Une fois que vous comprenez
comment gérer la connexion, il est bien plus simple d’utiliser Blynk. 3. Essayez de lancer la
commande telnet blynk-cloud.com 8442 à partir de votre PC, connecté au même réseau que votre
matériel. Vous devriez voir quelque chose comme : Connected to blynk-cloud.com.. 4. Essayez de
lancer les exemples par défaut de Blynk pour votre plateforme sans faire de modifications afin de voir
si ils fonctionnent. Vérifiez par deux fois que vous avez sélectionné le bon exemple pour votre type
de connexion et modèle de matériel. Nos exemples sont fournis avec des commentaires et des
explications. Lisez-les attentivement. Vérifiez que votre Jeton d’Authentification est valide (copié à
partir de l’Application et ne contient pas d’espace, etc.). * Si cela ne marche pas, jetez un coup d’oeil
à l’affichage du débogage série. 5. Voilà ! Ajoutez vos modifications et fonctionnalités. Amusez-vous
bien avec Blynk !

Note : lorsque vous avez plusieurs périphériques connectés à votre réseau, ils doivent avoir des
adresses MAC et IP différentes. Par exemple, lorsque vous utilisez 2 Arduino UNO avec des shields
Ethernet, lancer l’exemple par défaut aux deux causera un problème de connexion. Vous devriez
plutôt utiliser l’exemple de [configuration manuelle d’ethernet]manual ethernet configuration.

Connexion au réseau WiFi

Si vous rencontrez des problèmes de connexion WiFi, voici quelques pièges auxquels faire attention :

 Vous essayez de vous connecter au réseau “WPA & WPA2 Entreprise” (souvent utilisé dans
les bureaux) et votre shield ne supporte pas cette méthode de sécurité

 Votre connexion WiFi a une page de connexion qui vous demande d’entrer un jeton d’accès
(souvent utilisé dans les restaurants)

 La sécurité de votre réseau WiFi interdit la connexion de périphériques étrangers (Filtrage

MAC, etc)
  Il y a un pare-feu activé. Le port par défaut pour les connexions matériel est 8442. Assurez-
vous qu’il soit ouvert

Délai

Si vous utilisez un delay() long ou demandez à votre matériel de se mettre en veille dans le loop(),
attendez-vous à des pertes de connexion ou des performances détériorées.

NE FAITES PAS CELA :

void loop()

...

delay(1000); // C'est un délai long, ce doit être évité

other_long_operation();

...

Blynk.run();

Note : Cela s’applique aussi aux commandes BLYNK_READ et BLYNK_WRITE !

SOLUTION : Si vous avez besoin d’effectuer des actions à des intervalles réguliers - utilisez les
chronomètres (timers), par exemple BlynkTimer.

Erreur Flood

Si votre code envoie fréquemment de nombreuses requêtes à notre serveur, votre matériel sera
déconnecté. L’Application Blynk indiquera que votre matériel est hors-ligne (“Your hardware is
offline”).

Lorsque Blynk.virtualWrite est dans le void loop, il génère des centaines d’écritures (writes) par
seconde.

Voici un exemple pouvant causer du flood. NE FAITES PAS CELA :

void loop()

Blynk.virtualWrite(1, value); // Cette ligne envoie des centaines de messages au serveur Blynk

Blynk.run();

SOLUTION : Si vous avez besoin d’effectuer des actions à des intervalles réguliers - utilisez les
chronomètres (timers), par exemple BlynkTimer.

Utiliser un delay() ne résoudra pas le problème non plus. Ce peut causer un autre problème. Utilisez
les Chronomètres !
Si envoyer des centaines de requêtes est ce dont vous avez besoin pour votre produit, vous pouvez
augmenter la limite de flood sur un serveur local et dans la bibliothèque Blynk. Pour le serveur local,
vous avez besoin de modifier la propriété user.message.quota.limit dans le fichier server.properties

#100 Req/sec rate limit per user.

user.message.quota.limit=100

Pour le bibliothèque vous aurez besoin de changer la propriété BLYNK_MSG_LIMIT dans le

fichier BlynkConfig.h :

// Limite le nombre de commandes sortantes

#define BLYNK_MSG_LIMIT 20

Activer le débogage

Pour activer l’affichage du débogage sur le Serial par défaut, ajoutez ceci en haut de votre croquis (ce
doit être la première ligne de votre croquis) :

#define BLYNK_DEBUG // Optionel, affiche de nombreux messages

#define BLYNK_PRINT Serial

Et activez le Serial dans void setup() :

Serial.begin(9600);

Vous pouvez aussi utiliser d’autres ports matériels de série ou SoftwareSerial pour l’affichage du
débogage (Vous aurez besoin d’un adaptateur pour le connecter à l’ordinateur).

Note : activer le mode débogage rendra la puissance de traitement de votre matériel jusqu’à dix fois
plus lente.

Problèmes Geo DNS

Le cloud de Blynk utilise Geo DNS pour les solutions non-commerciales afin de minimiser les coûts de
maintenance des serveurs. Cela signifie que lorsque vous vous connectez à blynk-cloud.com, le
service DNS vous redirige vers le serveur le plus proche, en foncton de votre adresse IP. Le problème
est que l’application et le matériel ne sont parfois pas dans le même réseau. Et il y a une chance pour
que le matériel et le smartphone soient connectés à des serveurs différents. Vous obtiendrez alors
une erreur vous indiquant l’utilisateur n’est pas enregistré (User is not registered).

Il y a deux manières de résoudre ce problème :

 Utiliser un [Serveur Blynk Local] (https://booteille.github.io/blynk-docs-fr/#serveur-blynk)

 ping blynk-cloud.com à partir du réseau où votre matériel est connecté. Utilisez l’adresse IP
que vous obtenez durant ce ping et indiquez-le dans votre application mobile de cette
manière :
Réinitialiser le Mot de Passe

Sur l’écran de connexion, cliquez sur “Problems signin in?” et puis sur le bouton “Reset Password”.
Vous obtiendrez des instructions par email.

Sécurité

Le serveur Blynk a 3 ports ouverts pour les différents niveaux de sécurité.

 8441 - Connexion SSL/TLS pour le hardware

 8442 - Connexion TCP pleine pour le hardware (pas de sécurité)

 8443 - Connexion pour l’authentification mutuelle (SSL mutuel) pour les Applications Mobile

Le hardware peut choisir de se connecter au port 8441 ou 8442, en fonction de ses capacités.

Utiliser une Passerelle SSL

La plupart des plateformes ne sont pas capables de gérer SSL, alors ils se connectent au port 8442.
Néanmoins, notre script de passerelle peut être utilisé pour ajouter une couche de sécurité SSL à la
communication.

./blynk-ser.sh -f SSL

Cela va rediriger toutes les connexions hardwareles du port 8441 au serveur via la passerelle SSL.
Vous pouvez lancer ce script sur votre Raspberry Pi, ordinateur, ou même directement sur votre
routeur !

Note : lorsque vous utilisez votre propre serveur, vous devez écraser le certificat server.crt fourni, ou
en spécifier un au script en utilisant l’option --cert :
./blynk-ser.sh -f SSL -s <server ip> -p 8441 --cert=<certificate>.crt

L’option -f SSL est activée par défaut pour les communications USB donc vous n’avez pas à le déclarer
explicitement.

Note : SSL n’est supporté à travers la passerelle que sur Linux/OSX actuellement.

Si vous voulez éviter SSL et vous connecter via TCP, vous pouvez aussi faire ceci :

./blynk-ser.sh -t TCP

Utiliser un Serveur Local Blynk

Afin d’obtenir une sécurité maximale vous pouvez installer le serveur Blynk localement et restraindre
l’accès à votre réseau, donc personne à part vous ne pourra y accéder. Dans ce cas toutes les
données sont stockées localement dans votre réseau et ne sont pas envoyées vers Internet. Dans le
cas d’un serveur local Blynk il n’y aussi aucun besoin de protéger la connexion entre votre hardware
et le serveur local Blynk. C’est vrai pour les connexions Ethernet et partiellement vrai pour les
connexion Wi-Fi. Dans le cas du Wi-Fi vous devez au moins utiliser le type WPA, WPA2 (Wi-Fi
Protected Access) afin de protéger le traffic sans fil.

WPA et WPA2 offrent une encryption robuste qui pourra certainement protéger toutes les données
voyageant à travers les ondes, si un mot de passe assez fort est utilisé. Même si vos données sont en
TCP/IP pleins, un autre utilisateur ne sera pas en mesure de déchiffrer les paquets capturés. Dans
tous les cas, assurez-vous que votre mot de passe est assez fort, faute de quoi le seul facteur limitant
un attaquant est le temps.

Serveur Blynk

Le serveur Blynk est un serveur Java Open Source, responsable de la redirection des messages entre
l’application Blynk et les différents micro-contrôleurs (type Arduino, Raspberry Pi, etc).

Téléchargez la dernière version du serveur :

TÉLÉCHARGER LE SERVEUR BLYNK*

* Un projet expérimental et non-officiel permettant de gérer plus facilement le serveur a vu le

jour: Blynk CLI

Pourquoi ai-je besoin d’un serveur local ?

 Meilleure sécurite. Vous êtes le seul qui sait à propos du serveur. Vous pouvez définir des
politiques de sécurité liées à vos besoins spécifiques (MAC, IPs, noms de connexion, etc).
Vous pouvez aussi ne rendre celui-ci accessible que dans votre réseau privé.

 Meilleure stabilité. Vous ne comptez sur aucune solution de Cloud tiers. Vous avez le
contrôle absolu.

 Confidentialité maximale. Toutes les données sont stockées localement et ne sont partagées
avec personne.

Installer votre propre serveur local Blynk

 Pour des instructions détaillées, référez-vous à la page github - En Anglais.

  Si vous avez opté pour l’installation avec Blynk CLI, référez-vous plutôt à la documentation
française

Logiciel Blynk

Configuration

Blynk.begin()

La manière la plus simple de configurer Blynk est d’appeler Blynk.begin() :

Blynk.begin(auth, ...);

Cette méthode prend de nombreux paramètres pour différents hardwares, en fonction du type de
connexion que vous utilisez. Suivez les croquis d’exemple pour votre carte.

begin() suit basiquement ces étapes :

1. Se connecte à un réseau (WiFi, Ethernet, …)

2. Appelle Blynk.config(...) - défini le jeton d’authentification, l’adresse de l’hôte

3. Essaie de se connecter au serveur une fois (peut bloquer pour plus de 30s)

Si votre type de connexion/shield n’est pas encore supporté, vous pouvez aisément en créer un vous-
même ! Voici quelques exemples.

Blynk.config()

config() vous permet de gérer la connexion au réseau par vous-même. Vous pouvez configurer votre
shield (WiFi, Ethernet, …) manuellement, puis appeler :

Blynk.config(auth, server, port);

ou simplement

Blynk.config(auth);

Note : Juste après Blynk.config(...), Blynk n’est pas encore connecté au serveur. Il essaiera de se
connecter quand il atteindra le premier appel à Blynk.run() ou Blynk.connect(). Si vous souhaitez
éviter de vous connecter au serveur, appelez simplement Blynk.disconnect() juste après la
configuration.

Pour paramétrer une connexion WiFi, vous pouvez utiliser connectWiFi (juste pour le confort) :

Blynk.connectWiFi(ssid, pass);

Pour se connecter à des réseaux WiFi ouverts, définissez le mot de passe comme étant une chaîne de
caractères vide ("").

Gestion des connexions

Il existe plusieurs fonctions aidant à gérer les connexions :

Blynk.connect()

# Cette fonction essaiera de se connecter au serveur Blynk.

# Retourne true quand connecté, false si le délai maximum de connexion est atteint.
# Le délai maximum est par défaut de 30 secondes.

bool result = Blynk.connect();

bool result = Blynk.connect(timeout);

Blynk.disconnect()

Pour se déconnecter du serveur Blynk, utilisez :

Blynk.disconnect();

Blynk.connected()

Pour obtenir l’état de la connexion au serveur Blynk, utilisez :

bool result = Blynk.connected();

Blynk.run()

Cette fonction doit être appelée fréquemment pour traiter les commandes entrantes et entretenir la
connexion Blynk. Elle est habituellement appelée dans le void loop() {}.

Vopus pouvez l’initier à d’autres endroits, à moins que vous excédiez le tas de la mémoire (heap
memory - dans les fonctions imbriquées avec la mémoire locale). Par exemple, il n’est pas
recommendé d’appeler Blynk.run() à l’intérieur des fonctions BLYNK_READ et BLYNK_WRITE sur des
périphériques ayant peu de mémoire vive (RAM).

Contrôle des broches Analogiques et Digitales

La bibliothèque peut exécuter nativement des opérations basiques sur des broches d’entrée et sortie
: digitalRead digitalWrite analogRead analogWrite (Signal Analogique ou PWM en fonction de la
plateforme)

Pas la peine d’écrire du code pour de simples choses comme les LEDs, les relais et les capteurs
analogiques.

Contrôle des broches Virtuelles

Les broches Virtuelles sont conçues pour envoyer des données de votre micro-contrôleur à
l’Application Blynk et inversement. Pensez aux broches Virtuelles comme à des canaux permettant
d’envoyer des données. Assurez-vous de bien différencier les broches Virtuelles des broches
physiques de votre hardware. Les broches Virtuelles n’ont pas de représentation physique.

Les broches Virtuelles peuvent être utilisées comme interface avec les bibliothèques (Servo, LCD, et
autres) et implémentent des fonctionnalités personnalisées. Le périphérique peut envoyer des
données à l’Application en utilisant Blynk.virtualWrite(pin, value) et recevoir des données de
l’Application en utilisant BLYNK_WRITE(vPIN).

Types de données des broches Virtuelles

Les valeurs actuelles sont envoyées en tant que chaînes de caractères, don il n’y a pas de limite
pratique sur les données qui peuvent être envoyées. Néanmoins, souvenez-vous des limitations de la
plateforme quand vous traitez des nombres. Par exemple les nombres entiers sur l’Arduino font 16
bits, permettant des nombres entre -32768 et 32767. Vous pouvez interpréter les données entrantes
comme étant des nombres entiers (Integer), décimaux (Float, Double) et des chaînes de caractères
(String) :

param.asInt();

param.asFloat();

param.asDouble();

param.asStr();

Vous pouvez aussi récupérer les données brutes à partir du paramètre tampon.

param.getBuffer()

param.getLength()

Blynk.virtualWrite(vPin, value)

Vous pouvez envoyer tous les formats de données aux broches Virtuelles

// Envoie une chaîne de caractères

Blynk.virtualWrite(pin, "abc");

// Envoie un nombre entier

Blynk.virtualWrite(pin, 123);

// Envoie un nombre décimal

Blynk.virtualWrite(pin, 12.34);

// Envoie plusieurs valeurs en tant que tableau (array)

Blynk.virtualWrite(pin, "hello", 123, 12.34);

// Envoie les données brutes

Blynk.virtualWriteBinary(pin, buffer, length);

Note : Appeler virtualWrite provoque une tentative d’envoyer la valeur au réseau immédiatement.

Blynk.setProperty(vPin, “property”, value)

Cela permet de changer les propriétés d’un widget

BLYNK_WRITE(vPIN)

BLYNK_WRITE défini une fonction qui est appelée lorsque le périphérique reçoit une mise à jour de la
valeur de la broche Virtuelle à partir du serveur :

BLYNK_WRITE(V0)
{

int value = param.asInt(); // Obtient la valeur comme étant un nombre entier

// Le paramètre peut contenir plusieurs valeurs, auquel cas :

int x = param[0].asInt();

int y = param[1].asInt();

BLYNK_READ(vPIN)

BLYNK_READ défini une fonction qui est appelée quand il est demandé au périphérique d’envoyer la
valeur actuelle d’une broche Virtuelle au serveur. Normalement, cette fonction doit contenir
quelques appels à Blynk.virtualWrite.

BLYNK_READ(V0)

Blynk.virtualWrite(V0, newValue);

BLYNK_WRITE_DEFAULT()

Redéfini la commande pour chaque broche qui ne sont pas couvertes par des
fonctions BLYNK_WRITE personnalisées.

BLYNK_WRITE_DEFAULT()

int pin = request.pin; // Quelle broche est gérée, exactement ?

int value = param.asInt(); // Utilise le paramètre comme d'habitude.

BLYNK_READ_DEFAULT()

Redéfini la commande pour chaque broche qui ne sont pas couvertes par des
fonctions BLYNK_READ personnalisées.

BLYNK_READ_DEFAULT()

int pin = request.pin; // Quelle broche est gérée, exactement ?

Blynk.virtualWrite(pin, newValue);

BLYNK_CONNECTED()
Cette fonction est appelée à chaque fois que Blynk se connecte au serveur. Il est convenu d’utiliser
des fonctions de synchronisation ici.

BLYNK_CONNECTED() {

// Votre code ici

Blynk.syncAll()

Demande au serveur d’envoyer les valeurs les plus récentes pour chaque widget. En d’autres mots,
les états de toutes les broches analogiques/digitales seront restaurés et chaque broche virtuelle
génèrera un évennement BLYNK_WRITE.

BLYNK_CONNECTED() {

if (isFirstConnect) {

Blynk.syncAll();

Blynk.syncVirtual(vPin)

Demande une mise à jour de la valeur des broches Virtuelles. La commande BLYNK_WRITE est
appelée comme résultat.

Blynk.syncVirtual(V0);

# Envoyer une requête à plusieurs broches est aussi possible :

Blynk.syncVirtual(V0, V1, V6, V9, V16);

BlynkTimer

BlynkTimer vous permet d’exécuter des actions périodiquement dans le contexte loop() principal.
C’est le même que le communément utilisé SimpleTimer, mais corrige différents
problèmes. BlynkTimer est inclus dans la bibliothèque Blynk par défaut, donc il n’y a pas besoin
d’installer SimpleTimer séparément ou d’inclure SimpleTimer.h. Notez qu’un seul objet BlynkTimer
vous autorise de planifier jusqu’à 16 chronomètres. Pour plus d’informations sur l’utilisation du
chronomètre, vous pouvez vous référer ici : http://playground.arduino.cc/Code/SimpleTimer
Et voici un croquis d’exemple pour BlynkTimer.

Déboguage

#define BLYNK_PRINT

#define BLYNK_DEBUG

Pour activer l’affichage des messages de déboguage sur le port Série par défaut, ajoutez en haut de
votre croquis (doit être la première ligne) : To enable debug prints on the default Serial, add on the
top of your sketch (should be the first line):

#define BLYNK_PRINT Serial // Défini l'objet utilisé pour l'affichage

#define BLYNK_DEBUG // Optionnel, active un affichage plus détaillé

Et activez la sortie Série dans le setup() :

Serial.begin(9600);

Ouvrez le Moniteur Série et vous verrez l’affichage des messages de déboguage.

Vous pouvez aussi utiliser d’autres ports hardwares de série ou SoftwareSerial pour l’affichage du
débogage (Vous aurez besoin d’un adaptateur pour le connecter à l’ordinateur).

Note : activer le mode débogage rendra la puissance de traitement de votre hardware jusqu’à dix
fois plus lente.

BLYNK_LOG()

Lorsque BLYNK_PRINT est défini, vous pouvez utiliser BLYNK_LOG pour afficher vos journaux. Son
utilisation est similaire à printf :

BLYNK_LOG("Voici ma valeur : %d", 10);

Sur d’autres plateformes (comme l’Arduino 101) BLYNK_LOG peut être indisponible, ou peut utiliser
trop de ressources. Dans ce cas vous pouvez utiliser un groupe de fonctions de journalisation simples
:

BLYNK_LOG1("Heeey"); // Affiche une chaîne de caractères

BLYNK_LOG1(10); // Affiche un nombre

BLYNK_LOG2("Voici ma valeur : ", 10); // Affiche 2 valeurs

BLYNK_LOG4("Température: ", 24, " Humidité: ", 55); // Affiche 4 valeurs

// ...

Réduire l’empreinte

Pour minimiser la mémoire vive/flash de votre programme, vous pouvez désactiver certaines
fonctionnalités natives :

1. Commentez #define BLYNK_PRINT pour supprimer les affichages

2. Ajoutez en haut de votre croquis :

3. #define BLYNK_NO_BUILTIN // Désactive les opérations natives des broches digitales et

analogiques

#define BLYNK_NO_FLOAT // Désactive les opérations des décimales

Souvenez-vous aussi qu’un simple BlynkTimer peut planifier plusieurs chronomètres, vous n’aurez
donc probablement besoin que d’une seule instance de BlynkTimer dans votre croquis.

Porter, Bidouiller

Si vous voulez plonger dans la fabrication/modification/portage d’une implémentation de la

bibliothèque Blynk, veuillez vous référer à cette documentation.

FAQ
  J’ai soutenu Blynk sur Kickstarter. Où sont mes widgets et pourquoi l’application est gratuite
?

L’Application est gratuite parce que sinon vous devriez payer pour la télécharger. C’est comme cela
que l’AppStore et le Google Play fonctionnent. La version actuelle de Blynk a un nombre limité de
widgets. Nous avons décidé de les rendre gratuit pour tous jusqu’à ce que nous implémentions une
boutique. Après cela, chaque widget sera payé. Néanmoins, chaque investisseur les obtiendra
gratuitement (en accord avec l’engagement).

 Qu’est-ce que le Cloud Blynk ?

Le Cloud Blynk est un logiciel open-source écrit en Java, utilisant des sockets TCP/IP et TCP/IP
sécurisés (pour les hardwares le supportant) et tournant sur notre serveur. Les applications iOS et
Android de Blynk se connectent au Cloud BLynk par défaut. L’accès est gratuit pour tous les
utilisateurs de Blynk. Nous fournissons aussi une distribution du serveur privé pour ceux qui
voudraient l’installer localement.

 Combien coûte l’accès au serveur du Cloud Blynk ?

C’est gratuit pour tous les utilisateurs de Blynk.

 Puis-je lancer le serveur Blynk localement ?

Oui. Ceux d’entre vous, souhaitant une meilleure sécurité ou n’ont pas de connexion internet,
peuvent installer le serveur Blynk local et le faire tourner sur votre propre réseau local. Le serveur
Blynk est Open-Source et prend moins de quelques secondes à se déployer. Toutes les instructions et
fichiers sont ici.

 Quels sont les pré-requis pour faire tourner le serveur privé Blynk ?

Pour faire tourner le serveur privé Blynk, vous aurez seulement besoin de Java Runtime Environment.

 Puis-je faire tourner le serveur Blynk sur Raspberry Pi ?

Bien sûr! Voici les instructions - En Anglais.

 Est-ce que l’application Blynk fonctionne à travers le Bluetooth ?

Non, mais c’est prévu pour les prochaines versions.

 Est-ce que Blynk supporte Ethernet / Wi-Fi / UART ?

Oui, il les supporte tous. La liste complète des hardwares et shields supportés est disponible ici.

 Je n’ai aucun shield. Puis-je utiliser Blynk avec mon ordinateur ?

Oui, vous pouvez utiliser Blynk simplement avec un câble USB. Il y a des instructions étape-par-
étape sur comment s’y prendre.

 Est-ce que Blynk peut gérer plusieurs Arduino ?

Oui. Il y a actuellement 2 manières de s’y prendre :

o Vous pouvez utiliser le même Jeton d’Authentification pour chaque hardware. Dans
ce cas vous pouvez contrôler plusieurs hardwares à partir d’un seul tableau de bord.
 o Vous pouvez le faire en utilisant la fonctionnalité Bridge qui vous permet d’envoyer
des messages d’un hardware à un autre.

 Est-ce que le serveur Blynk stocke les données des capteurs lorsque l’application passe hors-
ligne ?

Oui, chaque commande que le hardware envoie au serveur est stocké. Vous pouvez utiliser le
widget Graphique d’Histoirque afin de les visualiser.