0
0
was successfully added to your cart.
All Posts By

Fabien Aubret

Mar 29
0
Manipulation de fichiers Excel en Python

Manipulation de documents Excel en Python

By | Débutant Raspberry Pi, Informatique | No Comments

Il y a peu, j’abordai la manipulation de fichiers basiques en Python au sein d’un article. Aujourd’hui, j’ai souhaité vous présenter les fondamentaux de l’utilisation de fichiers Excel sous Python. En effet, Excel permet l’organisation et le traitement d’un grand nombre de données mais, on peut aussi supposer avoir préparer un document sous Excel afin qu’il soit lisible par n’importe quel individu, et d’avoir besoin pour un quelconque traitement informatique d’importer ce document sous Python.
Bien sûr, il m’est compliqué de m’adapter à toutes les situations. La diversité des documents Excel ne permet pas de réaliser un article « universel » qui traiterait de tous les cas possibles de document sur Excel. Je me limiterai à un document relativement simpliste que je présenterai dans quelques lignes… Etant donné que le logiciel Excel permet de gérer des documents multipages, j’aborderai aussi cette notion.

Dès lors, et avant d’aller plus loin dans cet article, il nous sera nécessaire d’utiliser (et donc d’avoir installé) la librairie « xlrd » sous Python. Je vous renvoie pour cela au cours sur l’installation de librairie sous Python grâce à l’utilitaire pip. Vous aurez simplement besoin de connaitre le nom de la librairie telle que pip la connait, à savoir « xlrd ». Pour ceux d’entre-vous qui ont parcouru rapidement l’article traitant de cet utilitaire, je vous donne tout de même directement la ligne de commande permettant l’installation de la librairie :

1

pip install xlrd

Si vous rencontrez des problèmes à l’installation, pensez à lire notre article sur l’utilitaire pip, j’insiste sur ce point car on y traite certains problèmes qui peuvent être récurrents avec cet utilitaire…

Si l’installation s’est correctement déroulée, alors vous êtes fin prêt et nous allons pouvoir commencer ensemble en important notre premier fichier Excel dans Python.

1- Première importation et manipulations

Afin d’uniformiser le tutoriel, je vous propose d’utiliser une feuille de calcul dont la structure est semblable à celle-ci :

Capture d'écran feuille de calcul Excel 1

Capture d’écran de la première feuille de calcul de notre document Excel
Capture d'écran feuille de calcul Excel 2

Capture d’écran de la seconde feuille de calcul de notre document Excel

C’est un document Excel en deux feuilles de calcul dont la première (image de gauche) représente les images de la fonction f(x) = x^2 + 4 pour les x donnés et la seconde (image de droite) représente les images de f(x) = x^3 + 4
Notre objectif sera de récupérer sous Python ces données et d’en afficher les courbes représentatives. J’utiliserai d’ailleurs pour cela la bibliothèque matplotlib que vous pouvez installer depuis pip si vous le souhaitez. Si vous n’installez pas cette librairie, vous pourrez tout de même suivre ce tutoriel, le tracé sera la seule partie que vous ne pourrez pas exécuter. A ce propos, je ne détaillerai pas les fonctions utilisées pour le tracé (mais les codes seront fournis). L’utilisation de la bibliothèque matplotlib fera l’objet d’un article à part entière étant donné le fait que ce soit une librairie très complète.

La première étape consiste bien sûr à importer la librairie dans Python et à ouvrir notre fichier. Pour l’import de la librairie, on utilisera le classique

1

import xlrd

Et l’importation du document dans Python se fait au moyen de la fonction « open_workbook » de la librairie xlrd :

1

document = xlrd.open_workbook("document_excel.xlsx")

On veillera alors à bien placer notre fichier Excel dans le même répertoire que le fichier Python. Dans le cas contraire, on devra indiquer un chemin relatif vers le fichier (exemple « ../document_excel.xlsx » si le document se situe dans le dossier parent du fichier Python)

On peut alors accéder à quelques propriétés intéressantes, notamment le nombre de feuilles que contient notre document Excel (dans notre cas, 2) et le nom de chacune de ces feuilles sous la forme d’une liste. Cela s’obtient de la manière suivante :

1
2

print("Nombre de feuilles: "+str(document.nsheets))
print("Noms des feuilles: "+str(document.sheet_names()))

Vous noterez que je décide d’afficher ces données au moyen de « print ».
Mais l’objectif finalement, c’est de pouvoir récupérer les données que l’on a précédemment enregistré dans nos feuilles de calcul. Pour cela, on doit donc logiquement sélectionner notre première feuille de calcul, récupérer nos données, sélectionner la seconde, et ainsi de suite. On doit donc utiliser la fonction « sheet_by_index ». Au passage, il existe une fonction « sheet_by_name » qui fonctionne de la même manière en spécifiant simplement le nom de la feuille de calcul en paramètre. Je préfère utiliser la première fonction car je n’ai pas à faire attention à des caractères particuliers, espaces ou autres « altérations » possibles de ma chaine de caractère. Pour l’intérêt pédagogique, j’inclue cependant dans le script suivant les deux structures.

1
2

feuille_1 = document.sheet_by_index(0)
feuille_1 = document.sheet_by_name("Fonction 1")

Maintenant, j’ai dans l’objet « feuille_1 » la possibilité de retrouver toutes mes données. Mais avant de les obtenir, je vais avoir besoin d’accéder aux dimensions de ma feuille (nombre de lignes et de colonnes). J’ai pour cela la possibilité d’accéder à certaines informations de ma feuille, notamment son nom, son nombre de lignes et son nombre de colonnes au moyen des fonctions suivantes :

1
2
3
4

print("Format de la feuille 1:")
print("Nom: "+str(feuille_1.name))
print("Nombre de lignes: "+str(feuille_1.nrows))
print("Nombre de colonnes: "+str(feuille_1.ncols))

Vous remarquerez que je décide encore une fois d’afficher ces informations mais je vais dès à présent les stocker dans des variables que j’aurai sans doute l’occasion d’utiliser plus tard :

1
2

cols = feuille_1.ncols
rows = feuille_1.nrows

Vient alors le moment tant attendu, celui d’accéder à mes données. Pour cela, j’ai deux manières de procéder. La première, que je qualifierai de méthode bourrine, serait de parcourir toutes les lignes et colonnes de mon document et de tout stocker dans un tableau. Cette méthode a l’avantage de ne pas nécessiter la connaissance préalable du format du document Excel. Cependant, ce n’est pas la méthode que je souhaite utiliser ici. Je vais privilégier une méthode plus élégante étant donné que je sais déjà que ma première colonne contient mes valeurs de x  et la seconde de f(x) . Au passage, je n’oublie pas que ma première ligne me sert à nommer les colonnes afin de pouvoir comprendre le document Excel si un jour me viens l’envie de le relire. Alors ma « sélection » de données sous Python devra commencer à la seconde ligne.
Pour sélectionner la valeur d’une cellule dont je connais la ligne et la colonne, j’utilise la fonction suivante :

1
2

cellule = feuille_1.cell_value(rowx=1, colx=0)
print(cellule)

Attention, les cellules sont numérotées en partant de 0 pour leur ligne et leur colonne. Cela signifie que la cellule tout en haut à gauche est en position (0, 0)  et non (1, 1) . Si cela vous semble être une mauvaise idée de la part des concepteurs de Python, sachez qu’en fait, cela va nous permettre de parcourir très facilement nos lignes et colonnes. Par ailleurs, sachez que dans la plupart des langages de programmation, les tableaux démarrent à l’index 0 et que donc Python essaye, au moins sur ce coup, d’être en accord avec les autres…
En parcourant donc ma feuille de calcul à l’aide d’une boucle for pour former mes listes X et Y qui contiennent respectivement les valeurs de x  et de f(x) , j’en viens à adopter la structure suivante :

1
2
3
4
5

X = []
Y= []
for r in range(1, rows):
    X += [feuille_1.cell_value(rowx=r, colx=0)]
    Y += [feuille_1.cell_value(rowx=r, colx=1)]

Et je peux alors former très rapidement le graphe représentatif de ma fonction :

1
2

plt.plot(X, Y)
plt.show()

Et voici finalement mon script au complet :

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

import xlrd
import matplotlib.pyplot as plt
 
document = xlrd.open_workbook("document_excel.xlsx")
 
print("Nombre de feuilles: "+str(document.nsheets))
print("Noms des feuilles: "+str(document.sheet_names()))
 
feuille_1 = document.sheet_by_index(0)
feuille_1 = document.sheet_by_name("Fonction 1")
 
print("Format de la feuille 1:")
print("Nom: "+str(feuille_1.name))
print("Nombre de lignes: "+str(feuille_1.nrows))
print("Nombre de colonnes: "+str(feuille_1.ncols))
 
cols = feuille_1.ncols
rows = feuille_1.nrows
 
X = []
Y= []
 
for r in range(1, rows):
    X += [feuille_1.cell_value(rowx=r, colx=0)]
    Y += [feuille_1.cell_value(rowx=r, colx=1)]
 
plt.plot(X, Y)
plt.show()

Ce script fonctionne parfaitement pour la feuille 1 et je vous laisse libre soin de l’adapter pour la feuille 2 (les modifications sont infimes…)

2- Conclusion

En conclusion, j’ai souhaité vous démontrer ici toute la simplicité de l’utilisation d’Excel en collaboration avec Python. Si l’exemple que nous avons abordé ici n’est pas d’une pertinence absolue étant donné que l’on aurait pu directement tracer la courbe sur Excel ou obtenir la fonction sous Python, il a au moins le mérite d’être simple et d’expliquer clairement les fondamentaux de la manipulation de documents Excel.
Nul doute que nous serons amenés plus tard à manipuler des fichiers d’une manières plus avancés, notamment parce qu’un document Excel permet le stockage ordonné d’un grand nombre de données et semble donc parfaitement adapté à une utilisation pour le Machine Learning…

D’ici là, vous pouvez vous entrainer sur des classeurs Excel de votre composition afin de manipuler correctement les fondamentaux de la librairie xlrd. Si vous êtes curieux, sachez que le projet xlrd et disponible sur Github à l’adresse suivante : https://github.com/python-excel/xlrd et que vous y aurez tout loisir de découvrir comment fonctionne cette bibliothèque (attention, si vous débutez, vous risquez de vous perdre au milieu de toutes ces lignes de code…)

Fabien A.

Mar 17
0
Calcul intégral en Python

Calcul approché d’intégrales: Méthode des rectangles

By | Débutant Raspberry Pi, Informatique | One Comment

1- Introduction au calcul intégral

Deux raisons ont pu vous pousser à la lecture de cet article. La première, c’est que vous connaissez le calcul intégral dans sa définition mathématique et que vous cherchez simplement à comprendre comment implémenter de tels calculs en Python (ou tout autre langage de programmation). La seconde, c’est que vous avez été attiré ici par votre esprit de curiosité.
Dans tous les cas, vous avez fait le bon choix. Le calcul intégral tient une place essentielle dans l’acquisition de données (au moyen, par exemple, d’un accéléromètre/gyroscope) ou le traitement de données (aspect probabiliste, statistiques, etc…)

On introduit généralement le calcul d’intégrales au lycée comme le fait de calculer « l’aire sous la courbe d’une fonction ». Plus généralement, le calcul d’intégrales permet aussi de déterminer des primitives de fonctions connues, c’est-à-dire des fonctions qui, lorsque nous calculerons leurs dérivées, nous donneront la fonction de départ.

Concrètement, si je cherche à calculer la primitive d’une fonction , je serai amené à effectuer le calcul suivant :

F(x) = \int f(x) dx

Le symbole \int , sorte de S étiré, provient en fait historiquement de la déformation du S de « somme ». En fait, une intégrale n’est qu’une somme qu’on qualifie de continue, c’est-à-dire que sa variable d’intégration peut prendre toutes les valeurs comprises entre les bornes a et b. Dans notre exemple, cela signifie que x \in [a, b]  ou encore, a \leq x \leq b  lorsque nous calculerons l’intégrale.
Si je m’attarde sur la notion mathématiques, c’est parce qu’elle va me permettre de justifier de l’utilité du calcul intégral et de la nécessité d’avoir développé des méthodes informatiques permettant son implémentation.
Lorsque l’on calcul « à la main » une intégrale, on se retrouve à déterminer la primitive de la fonction de manière instinctive, en utilisant les primitives que l’on connait déjà et en « bidouillant » la fonction de départ de sorte à la décomposer comme somme ou composée de fonctions dont on connait les primitives. On voit ici que l’instinct humain est essentiel dans la démarche et que l’on ne peut donc pas implémenter un tel algorithme sur un ordinateur. Pourtant, son calcul est absolument essentiel. Un exemple simple : On sait que la vitesse d’un point se définie comme la dérivée par rapport au temps de sa position, c’est-à-dire le quotient de la variation de sa position sur un intervalle de temps aussi petit que possible. En particulier, on écrit :
v(t) = \frac{dx(t)}{dt}

Il en va de même pour l’accélération qui prend cette fois-ci la valeur de la dérivée de la vitesse (variation de la vitesse sur un instant donné) :
a(t) = \frac{dv(t)}{dt}

Alors, étant donné qu’un accéléromètre ne nous délivre qu’une variation d’accélération, on veut pouvoir remonter facilement à la position angulaire de notre système. On va donc procéder à une double intégration :
a(t) = \frac{dv(t)}{dt} = \frac{dx(t)}{dt} \Leftrightarrow x(t) = \int \!\!\! \int a(t) dt

Le calcul d’intégrales est donc absolument nécessaire dans ce cas mais ce n’est qu’un cas parmi tant d’autres que vous pourrez rencontrer.
Ainsi, si vous êtes par exemple étudiant et que l’on vous propose d’apprendre à utiliser la méthode des rectangles, vous ne pouvez négliger ce point. C’est un outil essentiel dans votre vie d’étudiant qui pourrait vous permettre de résoudre de nombreux problèmes.

Là est l’intérêt de la définition comme « aire sous la courbe » d’une fonction pour une intégrale. En effet, si l’on ne peut apprendre à un ordinateur à déterminer une primitive, il semble déjà plus facile de l’amener à calculer une aire. Et pour faciliter encore plus le travail, le mathématicien allemand Bernhard Riemann a proposé de simplifier cette aire en une succession de petits rectangles de la manière suivante :

Méthode des rectangles: principe

Illustration du principe de la méthode des rectangles

Je vous propose donc de développer un petit script Python qui se chargera pour nous de calculer l’aire sous la courbe, c’est-à-dire l’intégrale, d’une fonction entre deux points.

2- Programme

Je vous propose de commencer sans attendre en définissant une fonction. Nous utiliserons dans cette exemple la fonction la plus simple qui soit :

f(x) = x

C’est une fonction linéaire, très simple, dont tout étudiant de prépa connait particulièrement bien l’intégrale entre 1 et 2 qui vaut \frac{3}{2} et entre 1 et 3 qui vaut \frac{5}{2}. Cela nous permettra de vérifier rapidement la validité de notre programme.
J’introduis donc ma fonction f(x) dans Python :

1
2

def f(x):
    return x

Ensuite, je vous propose la même image que précédemment afin d’expliquer le principe de la méthode des rectangles :

Méthode des rectangles: principe

Illustration du principe de la méthode des rectangles

Sur cette image, on repère les deux bornes d’intégrations, a et b, et ce que l’on appelle les subdivisions. Le nombre de subdivisions, c’est en fait le nombre de rectangles et il correspond à la précision de calcul de l’intégrale. Plus ce nombre est grand, plus le calcul est précis mais plus il est long à réaliser. Il y a donc un juste milieu à déterminer…

Cette variation sur la précision vient des écarts que l’on repère entre les rectangles et la courbes. Plus les rectangles sont nombreux entre les bornes a et b, plus ces écarts sont faibles. Voici pour preuve le même calcul d’intégrale illustré avec un nombre n de subdivision supérieur au précédent :

Méthode des rectangles: précision

Illustration de l’importance du nombre de subdivisions dans la méthode des rectangles

L’objectif va donc être de calculer l’aire de chacun des rectangles et d’en faire la somme avant de l’afficher à l’utilisateur. Pour cela, je vous propose le schéma suivant, situation simplifié qui va me permettre de détailler le calcul de l’aire d’un rectangle de la méthode (on a pris ici n=2, soit 2 subdivisions entre les bornes a et b).

Méthode des rectangles: modèle à n=2

Illustration de la méthode des rectangles avec n=2 subdivisions

On remarque que les dimensions des rectangles sont de \frac{b-a}{n}  en largeur et de f\left (a + k*\frac{b-a}{n}\right )  en hauteur. J’explique ces valeurs : La valeur \frac{b-a}{n}  traduit le fait que l’on découpe l’intervalle [a, b]  en n subdivisions. Vous pourrez vous convaincre seul sur un dessin à main levé qu’alors, si l’on veut diviser cet intervalle en n subdivisions, la « largeur » de chaque subdivision sera de \frac{b-a}{n} . Pour la valeur f\left (a + k*\frac{b-a}{n}\right ) , l’idée est la même. La partie gauche du rectangle (celle à laquelle est calculée la hauteur du rectangle) correspond en fait à la valeur de la borne inférieure (a ici) à laquelle on a ajouté k fois la largeur des rectangles. Le k correspond à « l’index » de chacun des rectangles. Le premier a pour index 0, le second 1, etc… Cette variable k a surtout l’avantage de pouvoir être traduite simplement en Python. Ainsi, le calcul de l’aire d’un rectangle s’effectue de la manière suivante :

1
2
3
4
5
6

a = 1
b = 2
 
largeur = (b-a)/n
hauteur = f(a + k*(b-a)/n)
aire = largeur * hauteur

Attention : Cette structure n’est pas directement valable en Python et, si vous tentez de l’exécuter, devrait vous renvoyer une erreur car la variable k n’est pas définie

Alors le calcul de la somme se révèle être très simple à l’aide d’un boucle for :

1
2
3
4
5
6
7
8
9
10
11
12

a = 1    # Borne d'intégration inférieure
b = 2    # Borne d'intégration supérieure
n = 20   # Nombre de subdivisions
 
integrale = 0   # Variable stockant la somme des aires
for k in range(0, n):
    largeur = (b-a)/n
    hauteur = f(a + k*(b-a)/n)
    aire = largeur * hauteur
    integrale += aire
 
print(integrale)

Puis le script final :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def f(x):
    return x
 
a = 1    # Borne d'intégration inférieure
b = 2    # Borne d'intégration supérieure
n = 20   # Nombre de subdivisions
 
integrale = 0   # Variable stockant la somme des aires
for k in range(0, n):
    largeur = (b-a)/n
    hauteur = f(a + k*(b-a)/n)
    aire = largeur * hauteur
    integrale += aire
 
print(integrale)

Si vous exécutez ce script, vous devriez obtenir une valeur d’intégrale de 1.47 environ, étonnement proche de la valeur \frac{3}{2}   ne trouvez-vous pas ? Vous aurez tout loisir d’augmenter le nombre de subdivisions pour voir les conséquences sur la précision du calcul. De même, vous avez la possibilité de changer les bornes d’intégration et même la fonction à intégrer.

3- Conclusion

Vous l’aurez vu par vous-même, la méthode d’intégration dite « des rectangles » est en fait relativement simple à mettre en œuvre en Python mais aussi dans d’autres langages dont nous avons l’habitude ici (Java, C++, etc…)
C’est une méthode essentielle dans la manipulation de certains capteurs et qui permet d’obtenir une précision convenable en un minimum de temps (tant au développement qu’à l’exécution du programme)

J’espère dans cet article être parvenu à vous transmettre les fondamentaux du calcul d’intégrales par des méthodes informatiques. Dans le cas contraire, n’hésitez pas à commenter cet article (d’ailleurs, si vous l’avez aimé, vous pourrez aussi nous en faire part ;-))

Fabien A.

Mar 07
0
Gestion de fichiers

Manipulation de fichiers en Python

By | Débutant Raspberry Pi, Informatique | 4 Comments

1-    Introduction à la manipulation de fichiers

Vous aurez sans doute l’occasion d’être confronté, de manière régulière, à de la gestion de données plus ou moins massives. Qu’elles proviennent de capteurs ou d’informations d’utilisateurs, les données sont en fait absolument essentielles à n’importe quel projet. Plus encore, depuis quelques années, on s’intéresse au Big Data où, cette fois-ci, les données deviennent des marchandises que l’on peut s’échanger et qui possèdent une grande valeur.

Pourtant, traiter un grand volume de données n’a pas toujours été facile dans l’histoire de l’informatique. Aujourd’hui, à l’heure du tera-octet de données sur un ordinateur portable, on développe des jeux ou des programmes de plusieurs giga-octets. Pourtant, quelques années en arrière, on comptait encore en kilobits, kilo-octet ou autres unités qui nous semble maintenant désuètes. Il serait bon parfois de repenser à cet ancien temps où le travail du développeur était d’optimiser ses programmes et où cette dernière jouait en rôle absolument essentiel dans la qualité d’un programme.

Bref, aujourd’hui, tout cela est dépassé. On peut traiter plusieurs tera-octets de données sans que cela ne choque plus personne. On a su développer des outils performants nous permettant de traiter de tels volumes de données. Ces outils, on les utilises d’ailleurs parfois à torts et à travers, on utilise la hache pour abattre une tulipe.
L’idée de la manipulation de fichier, c’est de stocker des données sous une autre forme que celle d’une base de données par exemple. En fait, c’est d’être capable de les enregistrer dans un fichier texte de manière formatée et d’être ensuite capable de travailler sur ce fichier. Cela a pour avantage de ne pas nécessiter la mise en place d’un serveur de base de données et donc de faire gagner plus ou moins de temps dans la réalisation de nos « petits » projets personnels.

J’insiste. L’idée de ce tutoriel est bien de nous porter sur la manipulation de fichier d’une manière basique. Je n’aborderai pas les notions de JSON ou la manipulation de feuilles de calculs excel (pourtant très utiles par ailleurs). Peut-être cela viendra-t-il plus tard mais on peut aussi se dire que dès lors que les données sont « importées » dans Python, alors on est théoriquement capable de faire tout le traitement…

L’avantage de ce tutoriel, c’est qu’il ne nécessite aucune bibliothèque. De plus, il est là pour poser les bases d’une série de tutoriels en préparation et qui nécessitera de maitriser les fichiers et les données diverses et variées de manière agile afin d’être en mesure de se consacrer sur le traitement en lui-même. Croyez-moi, en préparant ce tutoriel, vous prendrez une avance essentielle sur la suite et pourrez donc suivre la série de manière plus « détendue »…

2-    Manipulons des fichiers

A-     Création d’un fichier et écriture

Il est alors temps de nous lancer, de créer notre propre fichier. Pour cela, deux moyens s’offrent à nous. Le premier, c’est créer bêtement un fichier texte dans lequel on rentre nos données manuellement. Le second, c’est de créer ce même fichier depuis Python, cela aura pour avantage de nous permettre une génération pseudo-aléatoire (l’aléatoire en informatique est une notion bien délicate).
Bien sûr, vous avez aussi la possibilité d’utiliser un fichier que vous aurez généré par exemple depuis votre Arduino lors de l’acquisition de données et de leur enregistrement sur une carte SD.

La création d’un fichier nécessite de connaitre les trois modes d’ouverture d’un fichier depuis Python :

r Ouverture du fichier en mode lecture uniquement
w Ouverture du fichier en mode écriture seulement
a Ouverture du fichier en mode ‘append’, c’est-à-dire que l’on ajoute du contenu en fin de fichier

 

Mais quelle est donc la différence entre le mode ‘w’ – write – et ‘a’ – append ?
En fait, la différence réside dans l’idée que le mode écriture permet d’écrire dans le fichier en écrasant ce qu’il contient déjà. Le mode ajout quant à lui permet de rajouter du contenu en fin de fichier, en préservant ce qui est déjà enregistré.

L’ouverture d’un fichier en Python s’effectue à l’aide de la commande suivante :

1

file = open(chemin_vers_le_fichier, mode_d_ouverture)

Par exemple :

1

file = open(‘donnees_meteo.txt’, ‘w’)

Aussitôt la fonction open() introduite, je tiens à introduire la fonction close(). De la même manière que l’on range un livre après l’avoir pris dans la bibliothèque, on doit « ranger » le fichier que l’on a édité. C’est précisément ce que permet la fonction close, elle s’utilise alors de la manière suivante :

1

file.close()

En reprenant la notation introduite pour l’ouverture du fichier.
Pour écrire dans le fichier, cela reste relativement facile en utilisant la fonction ‘write’ à bon escient de la manière suivante :

1

file.write(‘Hello world !’)

On peut alors utiliser les caractères « \n » et « \r » pour insérer des retours à la ligne / retour chariot afin de formater un minimum notre fichier.

\n New line – Nouvelle ligne Permet de revenir à la ligne (équivalent d’un appui sur la touche entrée sur Word )
\r Carriage return – Retour chariot Renvoie le curseur d’écriture en début de ligne

 

Pour résumer cette première partie, voilà le code qui m’a permis de créer un fichier « premier_fichier.txt » dans le même répertoire que mon script Python.

 

1
2
3

file = open("premier_fichier.txt", "w")
file.write("Hello world !")
file.close()

B-     Lecture d’un fichier

Vous êtes donc désormais en mesure de créer et d’éditer un fichier mais l’utilité serait bien faible si l’on ne pouvait pas le lire à nouveau ensuite. La méthode de lecture d’un fichier est très semblable à celle de l’écriture. L’idée est toujours d’ouvrir le fichier puis de travailler dessus. Cependant, il n’est pas forcément très facile de traiter les données qui arrivent du fichier. On récupère le plus souvent une chaine de texte brute contenant l’ensemble du fichier, dans le meilleur des cas un tableau contenant chacune des lignes. L’objectif est alors d’effectuer un pré-traitement permettant de formater correctement les données.

Ainsi, pour ce tutoriel, j’ai décidé de vous montrer de quelle manière on pouvait passer d’un fichier semblable au suivant dans sa structure :

1
2
3
4
5

Numero_du_point, abscisse, ordonnée
Numero_du_point, abscisse, ordonnée
Numero_du_point, abscisse, ordonnée
Numero_du_point, abscisse, ordonnée
etc...

 

A un simple tableau contenant chacune des lignes et les présentant sous la forme d’une liste [Numero_du_point, abscisse, ordonnée]. Si l’exemple n’est pas général, j’ai pensé que c’était cependant un cas qui se présentait assez souvent. En effet, lors de l’enregistrement des données, par exemple depuis l’Arduino, on est en fait assez libre de la manière de le faire. On peut ainsi insérer facilement un séparateur (, ; . ! etc…) entre les différentes valeurs, ce qui permettra alors de retrouver plus aisément ensuite la liste originale des valeurs.

Partant donc d’un fichier semblable à celui présenté ci-dessus, on se propose de l’ouvrir en mode écriture :

1

fichier = open(‘mesures_altitude.txt’, ‘r’)

Désormais, on a alors accès à l’intégralité des fonctions liées aux fichiers sur Python. On a alors un choix à faire. On peut choisir de lire l’intégralité du fichier et de stocker son contenu dans une variable sous la forme d’une chaine de caractères, ou alors on peut lire chacune des lignes et les stocker dans une liste que nous pourrons parcourir par la suite. C’est la second méthode que j’ai choisi ici mais vous pourrez utiliser la première à l’aide de la structure suivante et en utilisant astucieusement les quelques fonctions que je présenterai par la suite :

1

contenu = fichier.read()

Pour adopter ma méthode, on utilisera plus simplement la structure suivante :

1

lignes = fichier.readlines()

Alors, chaque ligne sera stockée dans une grande liste et sera terminé par un classique « \n » spécifiant un retour à la ligne. On a alors l’avantage de pouvoir itérer, c’est-à-dire parcourir, chacune des lignes en utilisant la structure suivante :

 

1
2

for ligne in lignes :
   # Faire quelque chose

 

Et je vous propose alors simplement d’afficher la ligne courante de la manière suivante :

1
2

for ligne in lignes :
   print(ligne)

 

Vous remarquerez alors la présence d’un double retour à la ligne (retour à la ligne + saut de ligne) à chaque affichage.

1
2
3
4
5
6
7
8
9

point_1, 9, 10
 
point_2, 6, 8
 
point_3, 1, 5
 
point_4, 6, 1
 
point_5, 9, 0

Pour gérer cela, je dois vous présenter la fonction replace() s’appliquant à une chaine de caractère. Elle s’utilise en spécifiant deux arguments. Le premier est le bout de chaine de caractère à remplacer. On peut aussi spécifier une expression régulière mais le sujet est alors bien trop vaste pour être détaillé ici. Le second argument quant à lui constitue la chaine de caractère de remplacement, c’est-à-dire celle qui viendra se substituer au bout de chaine de caractère que l’on souhaite remplacer.

Dans notre cas, le double retour à la ligne est en fait causé par le « \n » dont je vous ai parlé auparavant. On peut résoudre ce problème à l’aide de la structure suivante :

1
2
3

for ligne in lignes :
   ligne = ligne.replace(‘\n’, ‘’)
   print(ligne)

 

et l’on obtient alors dans mon cas l’affichage suivant :

1
2
3
4
5

point_1, 9, 10
point_2, 6, 8
point_3, 1, 5
point_4, 6, 1
point_5, 9, 0

 

Enfin, j’ai parlé au début de récupérer les points sous la forme d’une liste [numero, x, y]. Etant donné que mon fichier est correctement formaté, on peut directement utiliser la fonction split() qui s’utilise en spécifiant un argument, le séparateur, autour duquel on viendra « découper » notre chaine. Dans mon cas, le séparateur est « , » (j’insiste sur l’espace suivant la virgule). On utilise alors la syntaxe suivante pour former notre liste :

1
2
3
4

for ligne in lignes:
   ligne = ligne.replace('\n', '')
   donnees = ligne.split(', ')
   print(donnees)

 

Ici, j’ai fait le choix d’afficher les données mais l’on pourrait tout autant poursuivre le traitement (d’autant qu’à ce moment précis, donnees contient mes données sous la forme de 3 chaines de caractères, bien peu utile pour du traitement mathématique par exemple. On peut alors convertir les chaines de caractères à l’aide des classique fonctions de conversion de type (int(), float(), etc…)

Il nous reste alors à mettre en place un traitement des données, ce sera précisément l’étude que nous mènerons dans de prochains tutoriels.

 

3-    Conclusion

J’espère au travers de ce tutoriel, être parvenu à vous présenter les bases de la manipulation de fichiers en Python. L’idée n’est certainement pas de maitriser l’ensemble des outils existants pour de tels traitement. Au contraire, j’ai volontairement choisi de présenter les bases de la manipulation de fichiers et ce pour pouvoir m’attarder plus longuement sur le traitement à l’aide d’algorithme plus complexes.

Les fichiers textes ne sont pas les seuls moyens de stockage de données. Il me semble absolument essentiel de vous parler de la gestion de données via base de données SQL au sein d’un prochain tutoriel.

Ce que vous avez appris ici vous servira sans doute de manière courante en Python et, en tous les cas, vous permettra d’aborder plus sereinement certains de nos tutoriels.

 

Fabien A.

Mai 26
0
SimpleDuino à la MakerFaire Paris 2017

SimpleDuino à la Maker Faire Paris 2017

By | Non classé | No Comments

Cette année encore, l’édition 2017 de la MakerFaire Paris s’annonce prometteuse. Cette fois-ci, les équipes MakerFaire Paris ont choisi de faire de cet évènement un grand rendez-vous des Maker en rassemblant une plus grande quantité de Maker à la cité des sciences où le bâtiment entier sera réservé à l’exposition de projets en tout genre.

Bien sûr, nous avons envoyé un dossier de participation aux organisateurs et nous avons reçu rapidement la confirmation de notre présence à l’édition 2017 de MakerFaire Paris. Au programme, nous présenterons notre projet de drone autonome, « Autonomous Drone System (AES) » mais aussi notre projet domotique SimpleDomo dont vous pouvez déjà découvrir les grandes lignes sur le site « simpledomo.simple-duino.com ». Enfin, nous devrions présenter en avant-première un projet inédit dont une présentation sur notre site sera publiée lors de l’été 2017.

MakerFaire Paris se déroulera du 9 au 11 Juin à la Cité des sciences de Paris. L’évènement sera ouvert au public durant les trois journées.

Alors, n’hésitez pas, venez découvrir notre équipe, certe diminuée à cause des horaires que nos études imposent, mais nous ferons de notre mieux pour assurer une présence continue. Ce sera d’ailleurs vraisemblablement le cas avec la présence de Thomas Aubret le vendredi 9 juin qui sera rejoint par Fabien Aubret le 10 juin aux alentours de midi. Vous pourrez, en plus, découvrir le projet Raybot où Alexis Thézier, son fondateur, et Grégoire Aubret, co-fondateur Raybot et SimpleDuino, prendrons plaisir à discuter avec vous de ce projet.

En espérant vous rencontrer lors de l’édition 2017 de MakerFaire Paris, l’équipe SimpleDuino entière vous souhaite une réussite pour vos projets et vos examens / concours si vous êtes encore étudiant. (Un peu de solidarité n’a jamais fait de mal)

 

A bientôt 😉

Mar 07
0
Illustration de l'article "Electronique, approche théorique"

Electronique, approche théorique

By | Intermédiaire Arduino, Intermédiaire Raspberry Pi | No Comments

I- Introduction

Ne vous êtes-vous jamais posé la question de savoir comment ou pourquoi le circuit électronique que vous avez devant les yeux exécute réellement ce que vous lui demandez ? Non ? Parce que nous oui !
En fait, pour comprendre cette science de la théorie, il faut s’intéresser aux phénomènes physiques en jeu et, malheureusement (ou avec joie pour d’autre), il faudra s’intéresser aux outils mathématiques afin de comprendre pleinement ce à quoi nous sommes confrontés.
Si ce tutoriel présentera certaines lois classiques d’électronique comme les lois de Kirchhoff, nous nous intéresserons aussi en détail à l’analyse de l’évolution d’une tension dans un circuit RC (Résistance / Condensateur).
Bien sûr, dans ce tutoriel, finies les contraintes de la vraie vie, nous vivrons dans un monde sans pertes, sans dissipation, bref un monde idéal. En mathématiques ou en physique, on appelle ça un modèle et croyez nous, il vaut mieux pour que nous restions dans ce cadre…
Certaines notions abordées sont étudiées en classes préparatoires scientifiques (maths sup/ maths spé). Nous essaierons de vulgariser au maximum. C’est l’objet de ce tutoriel et nous ferons en sorte que le plus grand nombre puisse comprendre ce que nous expliquons. N’hésitez pas à poser des questions complémentaires en commentaire, ou à nous corriger si des coquilles se glissent dans nos présentations !

II- Lois de Kirchhoff

Avant d’aller plus loin, il nous sera nécessaire de nous baser sur deux principes « fondamentaux » en électronique et sur un principe qui, pour le coup, est considéré comme fondamental pour la physique toute entière. Le premier, c’est celui de la conservation de la charge, il caractérise le fait que dans un système fermé (sans transfert de matière avec l’extérieur), la charge se conserve dans l’ensemble du circuit.
Partant de cette constatation, Kirchhoff, physicien allemand, a établi deux lois majeures en électronique, la loi des nœuds et la loi des mailles.

Loi des noeuds

 

Loi des mailles

III- Quelques formules

Il nous faudra admettre quelques formules pour étudier un système électronique. Je vous propose d’étudier ici les caractéristiques d’un condensateur et d’une résistance (circuit RC). Voyons ensemble quelques formules qui pourraient bien nous être utiles:
  

Pour le condensateur:

q=\frac{di(t)}{dt}
q est la charge du condensateur, i(t) est l’intensité du courant qui le traverse à l’instant t

q=C.u(t)
q est encore la charge du condensateur, C est sa capacité en farad, u(t) la tension à ses bornes à l’instant t

  

Pour la résistance:

u(t)=R.i(t)
u(t) est la tension aux bornes de la résistance à l’instant t, R sa résistance en ohm et i le courant qui la traverse à l’instant t

  

Notion de dérivation mathématiques:

Un outil important qui nous servira tout au long de notre étude est l’utilisation des dérivées en mathématiques. Pour faire simple, c’est un outil qui nous permet d’étudier les variations d’une fonction. En fait, c’est un outil extrêmement puissant dont nous aurions du mal à nous passer en physique comme en mathématiques. Dans nos exemples, nous étudierons l’évolution de la tension aux bornes d’un dipôle et nous devrons donc faire appel aux dérivées. Si nous ne verrons pas vraiment ensemble comment dériver telle ou telle fonction, nous vous donnerons les dérivées dont nous aurons besoin. En réalité, il est nécessaire de connaitre un certain nombre de dérivées de fonctions usuelles et de fonctions composées lorsqu’on travaille dans le monde mathématico-physique. D’un point de vu des notations uniquement, vous devez savoir que les trois notations suivantes sont équivalentes:
\frac{dx}{dt} = \dot{x} = (x)'

Attention cependant, la dernière notation n’est absolument pas rigoureuse dans ce cadre, on symbolise plus régulièrement la dérivation d’une fonction de la manière suivante:
f'(x)

Nous utiliserons très régulièrement à première et la seconde notation, bien moins la dernière, plus utilisées en mathématiques cependant.
Posons donc les bases de notre étude, un petit schéma électronique…

IV- Présentation de l’étude

Présentation de l'étude mathématiques

Schéma du circuit RC étudié par l’approche mathématiques de l’électronique


Le condensateur, est initialement chargé d’une tension u_0

V- Début de l’étude

On a placé nos dipôles en convention générateur. On est face à un circuit RC-Série, le courant dans le circuit est donc constant et on peut écrire, grâce à la loi des mailles:
u_r(t) + u_c(t) = 0
Or, la loi d’Ohm nous donne:
u_r(t) = R.i(t)
Et les formules précédentes sur le condensateur donnent :
u_c(t) = \frac{q(t)}{C}
Alors, finalement il vient:
R.i(t) + \frac{q(t)}{C} = 0
\leftrightarrow \frac{dq}{dt} + \frac{1}{RC}.q(t) = 0

On pose arbitrairement
\tau = R.C
On obtient alors:
\frac{dq}{dt} + \frac{1}{\tau}.q = 0
Autrement dit:
\dot{q}+\frac{1}{\tau}.q = 0 (E)

Cette équation est qualifiée d’équation différentielle du premier ordre, linéaire, sans second membre (donc homogène) et à coefficients constants.
Ouhlaaaa, une grande et vaste notion vient d’être abordée, celle des équations différentielles. Lançons-nous dans la résolution de celle que nous avons ci-dessus. Pour simplifier, une équation différentielle est une équation qui, à la différence d’une équation « algébrique », admettra une solution sous la forme d’une fonction. Si vous n’avez jamais eu de formation scientifique sur ce point, la résolution que nous allons détailler ci-dessous pourra vous sembler un peu complexe. Nous allons essayer d’expliquer chaque point et de détailler chacune des décisions que nous prendrons pour arriver à la résolution. Heureusement pour nous, cette équation est dite homogène, c’est-à-dire que son second membre est nul, et vous ne le savez peut-être pas encore mais cela va largement nous simplifier le travail puisque la solution est simplement une formule, là encore à connaitre par cœur lorsque l’on est en étude scientifique…
En fait, les équations différentielles ne sont pas toutes aussi simples, on a parfois des membres doublements dérivés (équations différentielles du second ordre), avec second membres, ou mêmes les deux à la fois.

VI- Résolution de l’équation différentielle

Rappelons (E):
\dot{q}+\frac{1}{\tau}.q = 0 (E)
Comme nous l’avons vu, cette équation différentielle est plus simple à résoudre. C’est une équation dite « homogène » qui se résout par la simple application d’une formule à connaître si l’on souhaite pouvoir en résoudre soi-même plus tard. Cette formule implique l’utilisation de la fonction exponentielle, nul doute que vous ayez déjà entendu ce mot puisqu’il est largement utilisé pour caractériser une évolution rapide d’un paramètre quelconque. En effet, la courbe caractéristique de la fonction exponentielle est la suivante:

Représentation de la fonction exponentielle

Représentation graphique de la fonction exponentielle tracée à l’aide du logiciel GeoGebra


On comprend alors cette augmentation rapide. Je n’entrerai pas en détail dans l’étude de cette fonction, c’est une fonction très utile, qui est caractérisée par deux points:
\frac{d}{dx}(e^x) = e^x
e^0 = 1
Bien, il est temps de revenir à notre équation différentielle. Cette dernière admet donc comme solutions les fonctions de la forme:
q(t) = A.e^{\frac{-t}{\tau}} , A \in \mathbb{R}

q(t)=Ae^((-t)/τ) ,A∈R
Nous avons bien dit les fonctions car il y en a une infinité en théorie grâce à la constante « A ». Bien sûr, nous allons devoir définir cette constante afin qu’elle caractérise exactement le circuit que nous avons choisi au départ. Pour cela, je vous propose de réinjecter notre solution dans u_c(t). Souvenons-nous d’abord de l’expression de &latex u_c(t)&s=1&bg=f8f8f8$:
q = C.u(t)
\leftrightarrow u_c(t) = \frac{q}{C}
On remplace alors « q » par la solution déterminée ci-dessus, on a alors:
u_c(t) = \frac{A.e^{\frac{-t}{\tau}}}{C}
Maintenant, il faut déterminer « A », pour cela on va utiliser les conditions initiales, en effet, on avait spécifié qu’à t = 0, u_c(t) = u_0, on a alors:
u_c(t=0)=\frac{A}{C}
\leftrightarrow A = C.u_0
Voilà notre constante exprimée, remplaçons « A » dans la solution par cette valeur:
q(t) = C.u_0.e^{-\frac{t}{\tau}}
Voilà, on a désormais l’équation qui régit la variation de la charge dans notre circuit. Mais pour nous, le plus intéressant serait de connaître l’évolution de la tension aux bornes du condensateur. Pour cela, on reprend notre formule de la tension du condensateur:
u_c(t) = \frac{q}{C}
Et on injecte cette fois-ci notre solution finale de l’équation différentielle, on a alors:
u_c(t) = \frac{C.u_0.e^{-\frac{t}{\tau}}}{C}
En simplifiant, il vient:
u_c(t) = u_0.e^{-\frac{t}{\tau}} avec \tau = R.C

Ensuite, on peut rentrer cette formule dans un logiciel qui permet de tracer des courbes, comme Geogebra ou Excel et observer l’effet d’une résistance ou d’une capacité différente.
Pour notre part, avec une résistance de 850 ohms, une capacité de 0,04 Farads et une tension u_0 = 4V, on obtient la courbe suivante:

Evolution de la tension dans un circuit RC

Représentation graphique de l’évolution de la tension aux bornes d’un condensateur dans un circuit RC obtenue à l’aide du logiciel GeoGebra


Le temps, en secondes, est en abscisse et la tension aux bornes du condensateur, en volts, est en ordonnée.

VII- Conclusion

Si vous avez eu le courage de lire en intégralité ce tutoriel, félicitation !
Vous devriez maintenant être en mesure d’étudier d’une manière plus mathématique un circuit électronique relativement simple. Relisez le tutoriel, comprenez chaque étape, posez vos questions et entraînez-vous avec des circuits un poil plus complexe avec deux résistances ou deux condensateurs. Evidemment, dans ce cas, il faudra utiliser les formules pour retrouver la résistance équivalente de deux résistances en série ou de deux condensateurs en série.

Ce tutoriel a été écrit par Fabien Aubret, relu et vulgarisé par Thomas Aubret et Grégoire Aubret.
Une relecture a été effectuée par un professeur de physique diplômé de l’Ecole Normale Supérieure (ENS), un grand merci à lui.

Mai 12
0
Arduino et radiofréquence

Découvrez la radiofréquence avec Arduino

By | Débutant Arduino | No Comments

1- Introduction au concept de Radiofréquence

Lorsque, pour un projet quelconque, on a besoin de faire communiquer deux Arduinos sans utiliser un seul fil les liants l’un à l’autre, on se retrouve souvent confronté au choix plus ou moins difficile du type de communication à mettre en place. Alors, on pourrait penser au bluetooth, au wifi ou encore à la radiofréquence. Si les deux premières options semblent intéressantes à première vue, ces technologies nécessitent une certaine prise en main avant d’être en mesure d’en utiliser toutes les possibilités. Cependant, ce n’est pas le cas de la radiofréquence qui se détache alors rapidement de ses deux « concurrents ». En effet, la radiofréquence constitue sans doute l’un des moyens les plus simples et rapide de faire communiquer deux Arduinos ensemble. Au travers de ce tutoriel, je vous propose d’avancer pas à pas afin de comprendre en détail le fonctionnement puis l’utilisation de tels modules.

2- Fonctionnement des modules Radiofréquence

Tout d’abord, et avant d’aller plus loin dans ce tutoriel, il est nécessaire de faire un point sur le matériel que nous avons entre nos mains. Pour ma part, j’avais un kit émetteur/récepteur FS1000A comme celui-ci :

Photographie émetteur/récepteur RF

Photographie d’un kit émetteur / récepteur radiofréquence de type FS1000A

Qui trainait dans un tiroir, je baserai donc mon tutoriel sur ce kit. En plus de cela, j’ai simplement eu besoin d’un Arduino, de quelques fils et d’une résistance de 10kohms (qui n’est pas forcément utile, nous verrons plus tard)
Bien, si vous avez les même que moi, vous devriez alors avoir, au-dessus des pins, une sérigraphie qui indique GND, Vcc et Data. Détaillons d’abord ce que signifient ces indications. Pour le GND, c’est évident, cela signifie « Ground », « Masse » en anglais. Pour Vcc, c’est la valeur de niveau logique haut. Pour faire simple, puisque notre Arduino fonctionne en niveau logique 5v, on va connecter la broche Vcc du module au 5v et il saura donc que lorsqu’il reçoit 0v, cela correspond au niveau logique 0 et lorsqu’il reçoit 5v, cela correspond au niveau logique 1. Quant au Data, justement, c’est là que nous allons appliquer un niveau logique 1 ou 0 sur l’émetteur et que nous lirons un niveau logique 1 ou 0 sur le récepteur.
Pour la partie théorique seulement, le principe de fonctionnement d’un émetteur/récepteur radiofréquence est relativement simple à appréhender. En effet, lorsqu’on applique un niveau logique haut (je dirai 1 dans la suite du tutoriel) sur l’émetteur, le récepteur lira ce même niveau logique 1. Idem pour le niveau logique 0. Ainsi, on comprend la force des modules radiofréquence. Puisqu’ils transmettent directement les niveaux logiques auxquels ils sont soumis, on peut imaginer les utiliser pour faire de la transmission d’informations via la liaison Série et tout cela sans fil. Si cette notion vous semble encore floue, sachez qu’elle n’est de toute manière pas forcément très fiable. Vous découvrirez dans la suite du tutoriel qu’un signal émis par radiofréquence est perturbé pour un rien et même, que dans votre maison, vous devriez recevoir de nombreuses perturbations à la lecture des signaux, cela est notamment dû aux nombreuses ondes électromagnétiques qui nous entourent.
Pour résumer, on ne peut envoyer que des 1 ou des 0 via la radiofréquence. Lors d’un envoie, si on « donne » 1 sur le Data de l’émetteur, le Data du récepteur « Donnera » un 1, idem pour 0. Ce type d’échange permet d’envisager l’utilisation de protocoles plus complexes par radiofréquence mais ce n’est pas le sujet de ce tutoriel.

3- Premier script: Gestion du récepteur

Si vous avez, jusqu’ici, été en mesure de comprendre l’intégralité du tutoriel, alors vous devriez avoir compris que nous pouvons gérer l’émetteur « à la main », sans Arduino dans un premier temps. Ainsi, dans ce premier script concernant l’utilisation de la radiofréquence, je vous propose de nous concentrer sur l’utilisation du récepteur. Comme nous l’avons vu, ce dernier ne peut recevoir que des 0 ou des 1 et nous allons donc le câbler sur une entrée numérique, digitale donc, de notre Arduino.
Ainsi, je vous propose le câblage suivant:

ArduinoRécepteur

5v Vcc
GND GND
D2 Data

Schématiquement, cela donne le câblage suivant:

Câblage du récepteur RF sur l'Arduino

Capture d’écran du câblage entre le récepteur radiofréquence et l’Arduino effectué sur le logiciel Fritzing

Pour le script, je vous propose le code suivant que j’ai intégralement commenté:

void setup() {
  Serial.begin(9600);        // On initie la communication série sur le débit de 9600 bauds
  pinMode(2, INPUT);         // On déclare la broche D2 comme étant une entrée
}

void loop() {
  Serial.println(digitalRead(2));          // On affiche la valeur de la broche D2 dans le port série (et on saute une ligne à chaque affichage)
  delay(50);                               // On attend 50ms, cela diminue les erreurs de lecture
}

Ensuite, vous pourrez brancher votre émetteur de la manière suivante:

ArduinoEmetteur

5v Vcc
GND GND
————————— Data

Cette fois ci, schématiquement on a le câblage suivant:

Câblage de l'émetteur RF en contrôle manuel

Capture d’écran du câblage entre l’émetteur radiofréquence et son contrôle par bouton poussoir sur le logiciel Fritzing

Dans le tableau, vous remarquez que je n’ai rien spécifier pour la connexion de la broche Data de l’émetteur. C’est normal, je vous propose de brancher un fil « volant » sur le Data de l’émetteur et de simplement le relier manuellement au 5v lorsque vous souhaiterez simuler l’envoie d’un bit par radiofréquence.
Vous remarquerez que nous observons des « impulsions » sur le port série du récepteur. C’est-à-dire qu’il ne reçoit 1 que lorsque l’on connecte manuellement le Data de l’émetteur au 5v. Si on laisse connecté le Data au 5v, le récepteur ne recevra plus de données particulières et affichera donc 0. Vous comprenez alors à cet instant que nous allons travailler avec des signaux carrés. Si cette dénomination vous semble barbare, pas de panique ! Nous n’allons pas générer des signaux complexes. Un signal carré, c’est un simple passage de l’état 0 à l’état 1 puis de l’état 1 à l’état 0. En somme, c’est ce que vous venez de faire manuellement en connectant la broche Data de l’émetteur au 5v !

Vous noterez que sans aucune intervention de votre part, il est possible que vous visualisiez des valeurs de 1 sur le récepteur. C’est la manifestation des perturbations dont je vous parlais tout à l’heure.

4- Utilisation de l’émetteur et du récepteur par Arduino

Finalement, on arrive enfin à votre objectif depuis le début de ce tutoriel: Gérer l’émission et la réception d’un signal radiofréquence via Arduino. Si vous avez bien compris la partie précédente, vous devriez être en mesure d’écrire vous-même le code de cette partie.
Dans cette partie du tutoriel, nous vous proposons de réutiliser les câblages précédents ainsi que le script. Cependant, nous allons utiliser un second Arduino et y connecter notre émetteur sur D3 afin d’être en mesure de transmettre des données au récepteur. Nous procédons de la même manière que dans la partie précédente en commentant intégralement le script.

On a donc le câblage suivant:

Câblage de l'émetteur RF sur l'Arduino

Capture d’écran du câblage entre l’émetteur radiofréquence et l’Arduino sur le logiciel Fritzing

Avec le script suivant:

 

void setup()
{
	pinMode(3, OUTPUT); //On déclare la broche D3 de l'Arduino comme une sortie
}

void loop()
{
	digitalWrite(3, HIGH); //On passe la sortie D3 à l'état haut pour que l'émetteur transmette un "1" au recepteur 
	delay(250); //On attend un peu (250ms)
	digitalWrite(3, LOW); //On passe la sortie D3 à l'état bas pour que l'émetteur transmette un "0" au recepteur 
	delay(500); //On attend un peu (500ms)
}

Là, il n’y a pas grand-chose à rajouter. En mettant simultanément en route le montage émetteur et le montage récepteur, vous devriez observer des séries de 0 et de 1 plus ou moins régulières. N’oubliez pas les perturbations, elles sont omniprésentes autour de vous et peuvent perturber le signal reçu d’une manière plus ou moins prononcée. D’ailleurs, pour en éliminer une partie, on peut rajouter une résistance de 10kOhms entre le Data du récepteur et le GND de l’Arduino.

5- Conclusion

Dans ce tutoriel, nous avons eu l’occasion de voir ensemble que la communication par radiofréquence n’était pas si complexe qu’elle le semblait. Elle constitue une réelle alternative low-cost au bluetooth ou au wifi. Il faut cependant tenir compte de deux paramètres: La perturbation du signal et la sécurité de la transmission. Pour le premier paramètre, vous avez eu l’occasion de la découvrir par vous-même, les perturbations sont omniprésentes et l’une des solutions pour contrer cela constitue en la conception d’un réel protocole d’échange en radiofréquence avec des bits de début et de fin par exemple. Pour le second paramètre, celui de la sécurité, il n’est pas forcément évident d’y remédier. L’une des solution consisterait encore une fois en la création d’un protocole d’échange. Une autre solution pourrait être de modifier la plage de fréquence utilisée pour la transmission, certaines plages de fréquences sont moins sensibles aux perturbations. Attention cependant, la réglementation est assez stricte sur les plages autorisées et sur la puissance d’émission.
Un dernier point, dans ce tutoriel, nous avons proposé l’utilisation de modules radiofréquence via l’Arduino. Pourtant, et comme vous l’aurez sans doute imaginé, l’Arduino n’est absolument pas obligatoire. C’est justement pour cela que nous vous avons proposé de travailler manuellement sur le premier exemple de ce tutoriel. Si vous pouvez contrôler manuellement la transmission via un simple bouton poussoir, il n’y a aucun doute que vous pouvez faire de même avec un circuit intégré tel Attiny ou grâce à des portes logiques directement.

Le kit presse de cet article est disponible en cliquant sur ce lien

Mar 16
0
SimpleDuino à la MFP16

Simple-Duino à la Maker Faire Paris 2016

By | Non classé | No Comments

Bonjour à tous,

Il y a maintenant près d’un mois, l’équipe Simple-Duino a soumis sa candidature de participation à la Maker Faire Paris 2016. Si notre dossier a été retenu relativement rapidement, nous avons pris le temps de préparer l’ensemble des projets que nous apporterons là-bas, d’imprimer des flyers, des banderoles, etc… Afin que vous puissiez retrouver notre stand aisément. Alors, aujourd’hui, nous vous annonçons que nous serons présents le week-end du 30 avril / 1er mai. Vous pourrez retrouver notamment notre projet domotique, l’imprimante 3D prusa i2 dont vous suivez la construction depuis quelques semaines sur le forum ainsi que notre drone, entièrement imprimé en 3D. Nous apporterons du matériel supplémentaire afin de réaliser de petits projets devant vous et d’initier les nouveaux dans le monde de l’électronique.

N’hésitez pas à nous dire, si vous venez nous voir, que vous êtes inscrit sur le forum ou sur le site. Mettre un visage sur un pseudo c’est toujours agréable. N’ayez pas peur de nous, nous avons tout autant que vous envie de partager notre passion. Nous amenons du matériel pour montrer ce que l’Arduino et le Raspberry Pi nous permet de faire, à ce propos, nous aurons une large gamme de Raspberry, du 1 B au Pi 3, que vous pourrez observer sous toutes les coutures si vous n’avez pas eu la chance de commander avant les ruptures de stock.

Alors, nous n’avons qu’un mot à dire, Stay Tuned, you’ll be welcome…

La Maker Faire aura donc lieu le 30 avril / 1er mai à Paris Expo Porte de Versailles.

Au passage, si vous souhaitez nous proposer des projets que nous pourrions exposer sur le stand, n’hésitez pas à envoyer un mail à l’adresse de contact de Simple-Duino :

contact@simple-duino.com

L’équipe Simple-Duino

Mar 10
1
Photo de une du tutoriel "Installer Raspian et VNC"

Sortie du Raspberry Pi 3

By | Non classé | No Comments

Hello world !

Si vous suivez un peu l’actu sur le site de l’organisation Raspberry Pi (http://raspberrypi.org) , alors vous êtes sans doute au courant qu’un nouveau Raspberry Pi a pointé le bout de son nez dans le froid de l’hiver le 29 février dernier. De notre côté, nous avons suivi cet evenement avec engouement puisque quelques fuites avaient déjà laissé présager de grands changements sur le nouveau Raspberry. Alors, lorsqu’il est sorti, nous nous sommes empréssé d’en commander un (en fait deux) le jour même. La bonne nouvelle, c’est qu’en écrivant ces lignes, j’en tient un exemplaire devant mes yeux. Des changements ?

Raspberry Pi 3 de dessus

Photographie du Raspberry Pi 3 vu de dessus

Raspberry Pi 3 de dessous

Photographie du Raspberry Pi 3 vu de dessous

Visuellement, assez peu. Le format est toujours le même, la position n’a pas changé et les boitiers du 2 B+ s’adapte donc parfaitement dessus. La position des composants n’a pas changé, à par peut être l’apparition de ce composant :

Zoom sur la puce wifi du Pi 3

Zoom effectué sur le principal nouveau composant du Rasbperry Pi 3: La puce Wifi/Bluetooth

Et oui, ce composant, c’est la principale nouveauté du Raspberry Pi 3… L’apparition du Wifi et Bluetooth L.E. (Low Energy) de série sur les cartes, un rêve pour tout bidouilleur. Et parce qu’ajouter tant de connectivité ne suffisait pas à Eben Upton, le Raspberry Pi bascule sur un processeur 64 bits cadencé à 1.2GHz (BCM2837). L’alimentation quant à elle n’a pas été oubliée, le Raspberry Pi tolère désormais 2.4A en alimentation (toujours 5V), ce qui permet d’y brancher des périphériques USB plus puissants, un disque dur externe par exemple. D’ailleurs, cette intensité est conseillée pour l’alimentation du Pi 3 puisqu’il faut aussi alimenter l’interface Wifi. On note trois détails moins importants sans doute, Le changement de connecteur MicroSD, plus besoin de « clipser » la carte, elle tient désormais simplement par friction. Les deux bornes RUN ont aussi été déplacé et enfin, la position des leds d’indication a aussi été modifiée.

Modifications Raspberry Pi 3 dessus

Photographie avec indications des modifications apportées sur le dessus du Raspberry Pi 3

Modifications Raspberry Pi 3 dessous

Photographie avec indications des modifications apportées sur le dessous du Raspberry Pi 3

Pour résumer, voici donc les nouvelles caractéristiques de la bête :

  • Processeur Broadcom BCM2837, 4 cœurs, 64 bits
  • Processeur cadencé à 1.2GHz
  • Toujours un port Ethernet
  • Wifi 802.11 b/g/n
  • Bluetooth Low Energy
  • Toujours le classique HDMI
  • Consommation de 2.5A
  • 1Go de RAM

Pour la mise en route, la dernière version de Raspbian datant du 26 février, les développeurs ont tout de même intégré la prise en charge du Pi 3 avec le Wifi et Bluetooth. Cependant, il devrait sans doute y avoir une version 64 bits de Raspbian qui correspondrait alors bien mieux au Raspberry Pi 3…

Je saute ici toute la partie installation de Raspbian, configuration initiale, etc… Ce n’est pas le sujet de cet article, vous retrouverez les principales étapes ici : https://simple-duino.com/bien-debuter-avec-le-raspberry-pi/

Notre objectif, c’est surtout de lancer notre Raspberry Pi 3 et de tenter ensuite de le configurer en wifi proprement… Allons y

En premier lieu, pour confirmer la présence d’une puce Wifi, j’ai lancé un ifconfig et j’ai obtenu le résultat suivant :

Visualisation du chipset wifi

Visualisation de la présence d’un chipset Wifi sur le Pi 3

 

A ce moment la, j’étais connecté en direct ethernet au Raspberry Pi 3. J’ai ensuite décidé de configurer le wifi pour qu’il se connecte à ma box, j’ai donc modifié le fichier /etc/network/interfaces de la manière suivante :

 

Aperçu du fichier interface

Aperçu du fichier interfaces du Raspberry Pi 3 après configuration Wifi

 

Un petit reboot et hop ! J’ai réussi à me reconnecter en ssh via wifi et à pinger les serveurs google :

 

Aperçu de la requête Ping

Aperçu de la requête Ping vers les serveurs Google lorsque le Pi 3 est connecté en Wifi

 

Le top du top sur ce nouveau modèle, c’est surtout que son prix n’augmente pas et reste aux alentours de 40€. Pour résumer, le Raspberry Pi 3 représente un tournant dans la gamme de produits Raspberry. Enfin, on intègre le Bluetooth et le Wifi directement sur la carte, gagnant ainsi en prix et en configuration. Le Raspberry Pi 3 permet de développer plus rapidement des projets IoT ou de coupler d’une manière relativement simple cet équipement à une application développée sur android par exemple.

Fabien A.

Déc 21
1
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.

Nov 21
0
Image de une de la présentation du module GeoThings

Un outil pour vos projets connectés, GeoThings sur KickStarter

By | Projets | No Comments

Introduction

Vous avez souvent l’habitude sur notre site de voir aborder des notions de domotique. En effet, si notre projet SimpleDomo existe toujours et subit des améliorations quasi-mensuelles, on observe sur les sites de crowdfounding des produits toujours plus innovants et créatifs. Celui que nous vous présentons aujourd’hui dans cette article se révèle intéressant à nos yeux puisque le concepteur est parti d’un problème simple que nous connaissons sans doute tous: La nécessité d’utiliser plusieurs shield (parfois 4 ou 5) sur des projets connectés. En effet, on utilise, pour les projets les plus complexes, une batterie, un shield GSM, GPS et une carte SD. Là justement, le système GeoThings permet d’effectuer une concaténation de tous ces éléments en un seul bien plus petit et intéressant. Il permet en plus de connecter un panneau solaire, le concepteur insiste bien sur ce fait.
Pour résumer, GeoThings regroupe l’ensemble des outils permettant de lier votre systèmes à Internet et plus précisément, à une application smartphone dédiée. Vous avez simplement à relier votre module capteur à votre GeoThings et le reste se fait d’une simplicité déconcertante selon l’auteur. Bien entendu, nous n’avons pas eu (encore) l’occasion de tester ce système mais il semble vraiment prometteur.

Le concepteur de ce module GeoThings rassure les contributeurs au projet: Son module est bel est bien compatible avec le langage Arduino, vous pouvez donc recoder tout ou partie pour l’adapter exactement à vos besoins et ce, sans avoir à réapprendre un nouveau langage. Le firmware embarqué correspond à 100% à celui des Arduino Duemilanove.

 

Module GeoThings et son panneau solaire

On observe sur la gauche le module GeoThings en lui-même et à droite, le panneau solaire inclut dans tous les packs GeoThings.

 

Caractéristiques techniques

Concernant l’aspect technique, la taille du module est de 40x45x9mm avec un poids de 19 grammes environ. Petit et léger, ce sera sans doute un outil vraiment intéressant pour un projet d’engin volant par exemple. Le « processeur » embarqué est un atmega328P cadencé à 16MHz, tout comme l’Arduino. GeoThings dispose en plus « d’au moins » 4 entrées/sorties digitales et 5 analogiques. Les sorties 5V et 3.3V étant toujours disponible. D’un point de vu logiciel, l’API GeoApp et les outils de développement GeoApp sont gratuits, un point de plus donc. Le GPS est une puce intégrée au circuit et la technologie de liaison GSM est disponible aussi bien en 2G qu’en 3G, il n’est pas nécessaire d’utiliser une antenne externe puisqu’elle est intégrée au circuit. Le module gère la recharge de la batterie via un panneau solaire, il est fourni avec un boitier étanche et un panneau solaire. La batterie de 1000mAh lithium-ion rechargeable est également fournie.

Et le prix alors ? Le financement sur kickstarter est toujours en cours au jour d’aujourd’hui et le GeoThings 2G y est affiché au prix de 70$, il faut bien entendu comparer ce prix à un ensemble Arduino + tous les shields que rassemblent cette carte bien utile, le prix devrait donc être interessant. Le projet est financé à hauteur de 2% pour l’instant et il reste 28 jours pour que le montant attendu (190 000$) soit récolté.