was successfully added to your cart.
Category

Expert Arduino

Image de Une du tutoriel expliquant Labview pour Arduino

Labview pour Arduino

By | Expert Arduino | No Comments

Bonjour à tous !

Aujourd’hui nous allons découvrir comment utiliser le logiciel LabVIEW avec un Arduino. Nous allons voir comment récupérer les données de différents capteurs, comment par l’appuie sur un bouton nous pouvons allumer une LED, faire tourner un moteur. Les applications sont infinies !

LabVIEW est un logiciel développé par National Instruments permettant de coder à l’aide de diagramme. Vous pouvez grâce à ce logiciel créer des outils de mesure et de contrôle souvent très utilisés dans des projets de recherches.

Nous allons partir du principe où vous connaissez les bases de la programmation sous LabVIEW.

Comment installer les VIs Arduino ?

  • Installer LabVIEW en créant un compte sur leur site : http://france.ni.com/
  • Télécharger et installer la dernière version d’évaluation de LabVIEW : http://www.ni.com/trylabview/
  • Télécharger et installer la dernière version des drivers NI-VISA : http://www.ni.com/download/ni-visa-15.0.1/5693/en/
  • Télécharger et installer le module VIPM (VI Package Manager) permettant d’ajouter de nombreux compléments, dont ceux de l’arduino : http://jki.net/vipm/download
  • Rechercher « Labview Interface for Arduino » puis cliquer sur (installer)
  • Enfin, rendez-vous à cette adresse (pour ma part, qui devrait être similaire pour vous) « C:\Program Files\National Instruments\LabVIEW 2014\vi.lib\LabVIEW Interface for Arduino\Firmware\LIFA_Base »
    Ouvrez le ficher « LIFA_Base.ino » avec la version 1.0.5 de l’IDE Arduino. (le téléversement ne fonctionnera pas avec une autre version) Vous pouvez trouver la version de l’IDE à cette adresse https://www.arduino.cc/en/Main/OldSoftwareReleases

Comment fonctionne LabVIEW ?

Un programme LabVIEW se compose de deux parties. Une partie appelée « Front_Panel » (partie gauche de la photo) est l’interface sur laquelle l’utilisateur va interagir pour commander son arduino. Puis une partie « Block-Diagram » où le programme sera écrit.

Exemple d’un programme Labview fonctionnant avec un Arduino

Faisons un rappel de la constitution d’un programme arduino. Chaque programme (sketch) est constitué de deux parties :

  • Void setup()
  • Void loop() qui est une boucle while qui tourne en permanence (while(1))

Lorsque nous allons coder un programme Arduino sous LabVIEW nous mettrons donc en premier lieu une structure de type « while loop »

Création d’une boucle while permettant d’exécuter le programme indéfiniment

Nous allons ensuite pouvoir créer le corps de notre programme à l’aide des deux palettes d’outils précédemment installées :

Ouverture de la palette outils Arduino du Block_Diagram

 

Ouverture de la palette outils Arduino du Front_Panel

Une chose importante à savoir, quel que soit le nombre de capteur ou de pin que nous souhaitons gérer, seule une seule fonction « init » est nécessaire. Néanmoins il nous faudra autant de fonction « close » que de fonction dans votre programme.

Description des éléments d’un programme

Une fois nos principales composantes du programme placées, il va falloir configurer les ports, la carte, et le Front_Panel. Pour cela, on survole une fonction, on se place au niveau d’un connecteur puis on clique droit et clique sur « create ».

Explication du survol d’une fonction sur un connecteur pour créer des contrôleurs

Paramètre fonction

A cet instant nous avons le choix entre :

  • Constant : permet de fixer la donnée sans pouvoir la modifier lors de l’exécution du programme
  • Control : permet de modifier la donnée pendant l’exécution du programme
  • Indicator : permet d’avoir un retour visuel sur le connecteur

Le « Control » est intéressant lorsque l’on définit notre matériel, type de carte, port, baud, pin du capteur, état du capteur…

Choisissons « Control ». On se retrouve maintenant dans cette situation. On peut remarquer l’apparition d’un bouton de contrôle sur le Front_Panel.

Création d’un bouton de contrôle

Nous allons procéder de la même façon pour les entrées des capteurs.

Avancement du programme : état presque terminé

Voici à présent ce que ça donne. Tous les paramètres ont été créés. Il ne nous reste plus qu’à créer des indicateurs pour lire la valeur des capteurs de température et de luminosité.

Voilà à quoi ressemble notre programme une fois terminé :

Programme final Labview pour Arduino

Il ne nous reste plus qu’à connecter l’arduino sur l’ordinateur, d’ouvrir l’IDE 1.0.5 et d’uploader le fichier LIFA_Base.ino sur votre carte. Ensuite lancer le programme LabVIEW en cliquant sur la flèche  ou en faisant « ctrl+r ».

Pour arrêter le programme, cliquez sur le bouton stop sur le Front_Panel.

 

A quoi cela peut-il servir ?

Il est possible qu’au cours de vos études, vous soyez menés à jumeler arduino et labview. Cela permet d’avoir un contrôle et un visuel virtuel de vos capteurs et de votre système. De plus, étant donné que le code uploadé sur l’arduino n’est jamais modifié, on peut imaginer utiliser seulement une puce AtMega328 bootloadée et programmée afin de créer un arduino maison. Je vous apprendrai à en créer un dans un nouveau tutoriel !

Thomas A.

Une Communication wifi Low-Cost

Découvrez la communication wifi low-cost avec Arduino

By | Expert Arduino | No Comments

1- Introduction

Qui n’a jamais rêvé de pouvoir utiliser la communication sans-fil, et notamment, wifi avec son Arduino ? Il y a quelques mois, nous vous aurions dit que cela coutait chère, que le shield officiel Arduino n’était pas forcément la meilleure solution, mais aujourd’hui c’est différent.
En effet, le monde de l’électronique évolue rapidement, la miniaturisation et la réduction des coûts a notamment joué un rôle essentiel puisque aujourd’hui, relier un système quelconque à un réseau wifi pour 3,50€ et ce, grâce aux fameux modules ESP8266.
Si vous vous êtes récemment intéressé à la domotique ou à d’autres formes d’objets connectés, vous n’avez certainement pas pu passer à côté de ces petits modules. Les modules ESP8266 utilisent des commandes AT via le port série pour recevoir des ordres qui sont ensuite interprétés.
L’essentiel pour nous, c’est de savoir que ces modules ont deux fonctions extrêmement intéressantes. La première, c’est la possibilité de mettre en place dessus un mini serveur de données. La seconde, c’est celle de relier le module à un réseau existant (celui de votre box par exemple) et donc, de lier votre système à internet en moins de 30 secondes. De plus, votre module peut suivre deux comportements différents selon votre souhait, soit il agira comme un périphérique supplémentaire connecté à un réseau, soit comme un « Access Point », point d’accès, sans forcément être un serveur pour autant.

2- Spécifications techniques

Avant de débuter dans l’utilisation de votre module ESP8266, nous devons aborder ensemble certains points clés des spécifications techniques de ces modules.
Ce que vous devez savoir en tout premier lieu, c’est que les modules ESP8266 fonctionnent en 3.3V. Là, vous devez instantanément faire le lien avec les niveaux logiques 5V de l’Arduino, et donc vous occuper de ce premier problème. En effet, même si les chipset des ESP8266 tolèrent du 5V en niveau logique, il est toujours préférable d’adapter le niveau logique de votre port série grâce un adaptateur spécifique. Pour ma part, j’utilise des adaptateurs achetés sur E-bay semblables à ceux-ci:
https://www.sparkfun.com/products/12009
Nous vous conseillons très fortement d’utiliser des adaptateurs de niveaux logiques avec votre module wifi.
Autre spécification qui a son importance, de base, lors de la réception, le débit série par défaut sera définie, dans la plupart des cas, sur 115200 bauds. Si la version du firmware présente dans le module le permet, vous pourrez modifier ce débit. Dans le cas inverse, nous verrons bien plus tard comment mettre à jour le firmware de votre module.
Pour résumer, notre ESP8266 fonctionne en niveau logique 3.3V avec un débit série de 115200 bauds. Il nécessite donc un adaptateur de niveau logique 3.3V –> 5V pour être utilisé avec l’Arduino ainsi qu’une bonne configuration de notre terminal série.
La liste du matériel nécessaire à ce tutoriel se résume donc à:
– Un Arduino
– Un ESP8266
– Un convertisseur de niveau logique bidirectionnel
– Quelques fils
– Une plaque de connexion sans soudure (breadboard)

3- Mise en œuvre

D’un point de vue montage pur, l’ensemble reste relativement simple et ce, malgré le nombre important de fils utilisés et les composants que vous ne connaissez pas forcément. Nous vous proposons ainsi le montage détaillé autour du convertisseur de niveau logique ainsi qu’un vue générale de l’ensemble des laisons entre le module wifi, le convertisseur de niveau logique et l’Arduino.
Nous avons symbolisé les broches du module ESP8266 au moyen « d’étiquettes », vous retrouvez la position de chaque broche sur cette image (Notez que le module est vu de dessus):

Brochage esp8266

Position des broches d’entrées / sorties sur le module ESP8266

 

Montage complet

Montage complet du module ESP8266 avec son convertisseur de niveaux logiques

 

Vue détaillée autour du convertisseur de niveaux logiques

Vue détaillée des liaisons entre le convertisseur de niveaux logiques et l’Arduino


Désormais, vous devez donc avoir connecté l’ensemble des composants entre eux et donc, à l’Arduino aussi. De notre côté, nous arrivons à ce résultat:

Voilà pour la mise en œuvre du tutoriel, nous allons désormais passer à l’utilisation du circuit que nous venons de concevoir. C’est la dernière étape de notre tutoriel avant de conclure.

4- Application et utilisation du système conçu

Désormais, nous sommes en mesure d’utiliser notre module wifi esp8266 avec notre Arduino. Vous pouvez tout d’abord uploader le script « blink » sur votre Arduino et ouvrir une console série. L’intérêt, c’est que vous allez pouvoir utiliser votre Arduino comme un simple adaptateur série USB grâce à la console série intégrée à l’IDE Arduino. Lorsque vous aurez ouvert cette console, vous pouvez la paramétrez sur 115200 bauds avec CR et NR:

Réglages du port série

Réglages à effectuer afin de pouvoir communiquer avec notre module ESP8266

Ensuite, vous pourrez, en théorie, écrire « AT » dans la console et envoyez cette chaine de caractère. Vous devriez alors obtenir un retour « OK ». Là, je vous propose de tester la version de votre firmware, simplement comme information en envoyant la commande suivante au module: « AT+GMR ». Vous devriez obtenir un retour semblable à celui-ci:

Retour du AT+GMR

Retour d’affichage de la commande AT+GMR sur l’ESP8266

En regardant dans la liste de vos réseaux wifi disponibles sur votre ordinateur, vous devriez détecter le module ESP8266. Je vous propose dès à présent de modifier le nom du réseau ainsi que son mot de passe de sécurité en exécutant la commande suivante: « AT+CWSAP= »nom_du_reseau », »mot_de_passe »,1,2″
Le mot de passe doit impérativement être composé de chiffres et de lettres. Après avoir exécuté cette commande, vous devriez obtenir le retour suivant:

Retour du AT+CWSAP

Retour d’affichage de la commande AT+CWSAP sur l’ESP8266

Désormais, nous pouvons enfin créer notre mini serveur sur notre module wifi. Pour cela, nous devons tout d’abord autoriser la gestion des connexions multiples sur le module à l’aide de la commande « AT+CIPMUX=1 » (« AT+CIPMUX=0 » pour désactiver cette fonctionnalité). Le retour obtenu sera donc le suivant:

Retour du AT+CIPMUX

Retour d’affichage de la commande AT+CIPMUX sur l’ESP8266

Enfin, nous pouvons finalement ouvrir notre serveur en tant que tel grâce à la commande « AT+CIPSERVER=1,port » (« AT+CIPSERVER=0 » pour éteindre le serveur) Dans mon cas, le port sera 80. Vous devriez avoir le retour suivant:

Retour du AT+CIPSERVER

Retour d’affichage de la commande AT+CIPSERVER sur l’ESP8266

Ajoutons une commande qui peut se révéler bien utile, celle qui permet d’effectuer un reset du module: « AT+RST ». Le retour obtenu est ici bien plus long et devrait ressembler à ceci:

Retour d'affichage de la commande AT+RST sur l'ESP8266

Retour d’affichage de la commande AT+RST sur l’ESP8266

5- Conclusion

Voilà tout pour aujourd’hui. Vous êtes désormais capable de connecter un système quelconque à internet grâce à des modules wifi low-cost de types ESP8266. De plus, vous avez désormais la possibilité de créer des mini-serveurs à l’aide de ces modules, ce qui vous permettra de découvrir de nouveaux moyens d’interagir avec vos systèmes. N’oubliez pas que les modules ESP8266 constituent une solution fiable et low-cost lorsque la nécessité d’ajouter une connexion wifi à votre circuit est omniprésente.

Merci d’avoir suivi ce tutoriel, bon bidouillage à tous !

Fabien A.

ProgressBar afficheur LCD et Arduino

By | Expert Arduino | 2 Comments

Bonjour à tous,

J’ai décidé aujourd’hui de vous proposer un tutoriel sur l’utilisation des écrans LCDs.

Je vous propose un « exercice d’application », (TP) qui va vous mener pas à pas à la réalisation d’une barre de chargement sur votre afficheur LCD.

Petite précision avant tout, vous ne pouvez utiliser ici que les afficheurs LCDs normalisés, c’est-à-dire que j’exclus ici les afficheurs de type « nokia 5110 », fiez-vous souvent au prix des afficheurs pour choisir le bon. Pour ma part, l’afficheur « nokia 5110 » à 10€ me paraissait un bon plan, j’ai été déçu d’apprendre que la librairie que nous allons utiliser ici n’était pas compatible. Si vous avez un doute, n’achetez pas trop vite et posez vos questions sur notre forum.

Allez, on y va !!

 

Le tutoriel sera divisé en trois parties :

1- Matériel nécessaire (Hardware)

2- Programmation (Software)

     2.1- La gestion de l’afficheur LCD

       2.2- La gestion des caractères

       2.3- La gestion de la progression

3- Branchements (Hardware)

4- Test

_______________________________________________

1- Matériel nécessaire

Pour suivre ce tutoriel, vous aurez besoin :

– D’un afficheur LCD 4×20 caractères (ou plus grand ou plus petit mais vous devrez adapter le code dans ce cas)

– D’un potentiomètre de 20 kohms

– D’un Arduino

– De fils

– Une plaque de connexion sans soudure « Breadboard » (pas obligatoire mais plus pratique)

2- Programmation

       2.1- La gestion de l’afficheur

Il y a 7 fonctions utiles à connaitre pour la gestion de l’afficheur dans ce TP :

Mise en place de la librairie LiquidCrystal :

1
#include  //Inclusion de la librairie LiquidCrystal

Précision des pins de connexion de l’afficheur sur l’arduino(rs, enable, d4, d5, d6, d7) en mode 4 bits :

1
LiquidCrystal lcd(2, 3, 4, 5, 6, 7); //Pins de l'afficheurs lcd

Activation et démarrage de l’afficheur LCD :

1
lcd.begin(20, 4); //Activation de l'afficheur lcd

Positionnement du curseur :

1
lcd.setCursor(8, 1); //On place le curseur à la colonne 8, ligne 1

Ecriture d’un caractère ou d’une valeur :

1
2
lcd.print(i); //On écrit la valeur de i
lcd.print(«Bonjour») ; //On écrit la lettre « Bonjour »

Effacement des caractères :

1
lcd.clear(); //Si i = 100, on efface l'écran

Ecriture d’un caractère sous la forme brute :

1
lcd.write(byte(1)); //On affiche le caractère défini à 1
 

 

2.2- La gestion des caractères

Une structure à connaitre, la création du caractère de chargement (un rectangle plein) où les « 1 » représentent les pixels allumés et les « 0 » les pixels éteint. Cette structure représentera les « pourcentages » remplis sur la ProgressBar :

1
2
3
4
5
6
7
8
9
10
byte barre[] = { //Création du caractères de chargement
   B111111,
   B111111,
   B111111,
   B111111,
   B111111,
   B111111,
   B111111,
   B111111
};

 

 2.3- La gestion de la progression

 Ici c’est une fonction que j’ai créé pour vous,  je pense que vous avez toutes les clés pour la comprendre :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
void affichage(){ //Fonction permettant de gérer l'affichage du caractère de chargement.
  switch(i){
          case 5 :
            lcd.setCursor(0, 2);
            lcd.write(byte(1));
            break ;
        case 10 :
            lcd.setCursor(1, 2);
            lcd.write(byte(1));
            break ;
        case 15 :
            lcd.setCursor(2, 2);
            lcd.write(byte(1));
            break ;
        case 20 :
            lcd.setCursor(3, 2);
            lcd.write(byte(1));
            break ;
        case 25 :
            lcd.setCursor(4, 2);
            lcd.write(byte(1));
            break ;
        case 30 :
            lcd.setCursor(5, 2);
            lcd.write(byte(1));
            break ;
        case 35 :
            lcd.setCursor(6, 2);
            lcd.write(byte(1));
            break ;
        case 40 :
            lcd.setCursor(7, 2);
            lcd.write(byte(1));
            break ;
        case 45 :
            lcd.setCursor(8, 2);
            lcd.write(byte(1));
            break ;
        case 50 :
            lcd.setCursor(9, 2);
            lcd.write(byte(1));
            break ;
        case 55 :
            lcd.setCursor(10, 2);
            lcd.write(byte(1));
            break ;
        case 60 :
            lcd.setCursor(11, 2);
            lcd.write(byte(1));
            break ;
        case 65 :
            lcd.setCursor(12, 2);
            lcd.write(byte(1));
            break ;
        case 70 :
            lcd.setCursor(13, 2);
            lcd.write(byte(1));
            break ;
        case 75 :
            lcd.setCursor(14, 2);
            lcd.write(byte(1));
            break ;
        case 80 :
            lcd.setCursor(15, 2);
            lcd.write(byte(1));
            break ;
        case 85 :
            lcd.setCursor(16, 2);
            lcd.write(byte(1));
            break ;
        case 90 :
            lcd.setCursor(17, 2);
            lcd.write(byte(1));
            break ;
        case 95 :
            lcd.setCursor(18, 2);
            lcd.write(byte(1));
            break ;
        }

Allez, réfléchissez un peu !!

Voila ! C’est terminé !
Vous avez toutes les fonctions et informations nécessaires pour réaliser ce TP.

Bon allez…voici la correction !

correction :

Voici le programme à utiliser :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include  //Inclusion de la librairie LiquidCrystal
LiquidCrystal lcd(2, 3, 4, 5, 6, 7); //Pins de l'afficheurs lcd
int i, j ; //Déclaration de i et j, variables égales à zéro
byte barre[] = { //Création du caractère de chargement
B111111,
B111111,
B111111,
B111111,
B111111,
B111111,
B111111,
B111111
};
void setup() {
lcd.begin(20, 4); //Activation de l'afficheur lcd
}
void loop() {
while(i != 100){
while(i < 100){
lcd.createChar(1, barre); //Déclaration du caractère de chargement
delay(250); //On attends 250 ms
i++ ; //i augmente de 1
lcd.setCursor(8, 1); //On place le curseur à la colonne 8, ligne 1
lcd.print(i); //On écrit la valeur de i
lcd.print("%"); //Puis le signe % (pourcent)
affichage(); //Utilisation de la fonction affichage déclarée plus bas
if(i == 100){
lcd.clear(); //Si i = 100, on efface l'écran
}
}
while(i == 100 && j < 20){
lcd.setCursor(8, 1); //On place le curseur à la colonne 8, ligne 1
lcd.print(i); //On écrit la valeur de i
lcd.print("%"); //Puis le signe % (pourcent)
lcd.setCursor(j, 2); //On place le curseur à la colonne égale à la valeur de j et à la ligne 2
lcd.write(byte(1)); //On affiche le caractère de chargement
j++ ; //j augmente de 1
}
}
}
void affichage(){ //Fonction permettant de gérer l'affichage du caractère de chargement. Je ne la détaillerai pas ici
switch(i){
case 5 :
lcd.setCursor(0, 2);
lcd.write(byte(1));
break ;
case 10 :
lcd.setCursor(1, 2);
lcd.write(byte(1));
break ;
case 15 :
lcd.setCursor(2, 2);
lcd.write(byte(1));
break ;
case 20 :
lcd.setCursor(3, 2);
lcd.write(byte(1));
break ;
case 25 :
lcd.setCursor(4, 2);
lcd.write(byte(1));
break ;
case 30 :
lcd.setCursor(5, 2);
lcd.write(byte(1));
break ;
case 35 :
lcd.setCursor(6, 2);
lcd.write(byte(1));
break ;
case 40 :
lcd.setCursor(7, 2);
lcd.write(byte(1));
break ;
case 45 :
lcd.setCursor(8, 2);
lcd.write(byte(1));
break ;
case 50 :
lcd.setCursor(9, 2);
lcd.write(byte(1));
break ;
case 55 :
lcd.setCursor(10, 2);
lcd.write(byte(1));
break ;
case 60 :
lcd.setCursor(11, 2);
lcd.write(byte(1));
break ;
case 65 :
lcd.setCursor(12, 2);
lcd.write(byte(1));
break ;
case 70 :
lcd.setCursor(13, 2);
lcd.write(byte(1));
break ;
case 75 :
lcd.setCursor(14, 2);
lcd.write(byte(1));
break ;
case 80 :
lcd.setCursor(15, 2);
lcd.write(byte(1));
break ;
case 85 :
lcd.setCursor(16, 2);
lcd.write(byte(1));
break ;
case 90 :
lcd.setCursor(17, 2);
lcd.write(byte(1));
break ;
case 95 :
lcd.setCursor(18, 2);
lcd.write(byte(1));
break ;
}
}
 

3- Branchements

 Afficheur –>; Arduino

Vss –> GND

Vdd –> 5V

V0 (contraste) –> Potentiomètre 20kohms –> GND

RS –> D2

R/W –> GND

E –> D3

DB4 –> D4

DB5 –> D5

DB6 –> D6

DB7 –> D7

Led + –> 5V

Led – –> GND

Les branchements de votre afficheur ne sont pas forcément les mêmes, quoi qu’il en soit, vous retrouverez toujours les pins RS, R/W, E, DB4, DB5, DB6, DB7 sous des noms proches. Consultez toujours les datasheets avant de brancher quoi que ce soit.

4- Test

Reliez votre Arduino à l’USB ou à l’alimentation par connecteur Jack et admirez notre travail !!
La ProgressBar devrait se remplir de rectangles blancs et former une barre de chargement.
N’hésitez pas à poser vos questions en commentaires et à me signaler d’éventuels bugs de programme.

Une photo de mon coté :

TOSHIBA CAMCORDER

Bon Week-end et bon bidouillage à tous !!