All Posts By

Fabien Aubret

Image de une - Algorithmes récursifs

Algorithmes récursifs

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

I- Introduction à la récursivité

Récursif ou itératif… Voilà un sujet de discussion encore non élucidé entre les développeurs du monde entier. Pourtant, avant de chercher à argumenter dans un sens ou dans l’autre autour de cette question, il faut déjà comprendre ce que l’on appelle algorithme récursif (et donc algorithme itératif). Si l’on remonte ainsi aux débuts de l’informatique, un programme en langage machine s’exécutait « verticalement » en lisant tour à tour les instructions écrites, autorisant néanmoins l’instruction « jump » qui permettait de sauter vers une étape particulière du programme. L’informatique évoluant, la puissance des ordinateurs aussi, on a pu arriver petit à petit à des algorithmes plus ou moins efficaces que ces derniers. Parmi les voie d’optimisation, on a développé les algorithmes récursifs, c’est-à-dire des algorithmes qui s’appellent eux-mêmes lors de l’exécution et qui sont donc plus « compactes » mais aussi et surtout plus compréhensibles selon les cas. Des avantages de la programmation récursive, on pourra souligner :

  • La facilité d’explication de certains algorithmes beaucoup plus complexes
  • L’optimisation du code par les compilateurs qui est rendue plus facile par l’abstraction
  • L’existence de structures qui se prêtent facilement à l’utilisation de tels algorithmes

Encore aujourd’hui, la programmation récursive constitue un outil à part entière et on peut souvent « simplifier » nos codes en faisant appel à des fonctions récursives. De plus, la plupart des langages auxquels nous accédons aujourd’hui ont un environnement qui permet l’utilisation de fonctions récursives. Cela se résume bien souvent à la gestion astucieuse d’une pile de stockage mémoire…

Dans cet article, j’aborderai un exemple commun d’algorithme récursif en implémentant le calcul de la fonction mathématiques factorielle.

II- Programmation

a) La fonction factorielle

Avant de se lancer dans la programmation, j’ai souhaité écrire quelques lignes sur la fonction factorielle afin que l’on parle tous de la même chose et que l’on s’accorde sur les termes et notations.
En mathématiques, la fonction factorielle est définie de la manière suivante :

Définition de la fonction factorielle
Dès lors, on note  l’image de x par la fonction factorielle. A titre indicatif, on notera les valeurs suivantes :

Valeurs de la fonction factorielle

On remarque ainsi que l’on peut écrire la fonction factorielle de la manière suivante :

Forme réduite factorielle
Et nous voilà ainsi arrivés à l’écriture dont nous aurons besoin dans la suite de notre article. En effet, la formule ci-dessus nous permet de calculer la factorielle de « rang » n en calculant auparavant la factorielle de « rang » n-1. On peut alors répéter l’opération jusqu’à arriver à la factorielle de « rang » 0 dont la valeur est définie à 1

b) Du code, enfin…

Dans un premier temps, je vous propose une implémentation « à l’ancienne » de la fonction factorielle. En fait, cela correspond à un algorithme itératif, littéralement qui va itérer sur notre produit jusqu’à arriver à la fin :

1
2
3
4
5
6
7
8
9
10
11
import time
def factorielle(n):
    resultat = 1
    for k in range(1, n+1):
        resultat *= k
    return resultat
 
clock1 = time.perf_counter_ns()
print(factorielle(1000))
clock2 = time.perf_counter_ns()
print("Temps d'exécution: " + str(clock2 - clock1) + "ns")

Dans ce script, j’ai inclus le calcul du temps d’exécution qui pourrait bien nous être utile pour la suite…

Quant à l’algorithme récursif, il est en fait beaucoup plus clair car on applique directement les formules établies dans la première partie. Cet algorithme est dit récursif car il s’appelle lui-même dans sa fonction. Cela devrait être bien plus explicite à la lecture du code suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
import time
 
def factorielle(n):
    if n == 0:
        return 1
    else:
        return n * factorielle(n-1)
 
clock1 = time.perf_counter_ns()
print(factorielle(100))
clock2 = time.perf_counter_ns()
 
print("Temps d'exécution: " + str(clock2 - clock1) + "ns")

A la lecture du temps d’exécution des deux programmes, on remarque que l’algorithme itératif est bien plus rapide (environ deux fois) mais l’algorithme récursif est bien plus simple à comprendre. Du moins, il est plus proche de la vision mathématique que l’on a de la fonction. On peut cependant lui trouver une limite si l’on demande à calculer factorielle(1000), Python refusera alors le calcul. En effet, lorsque le nombre d’appel de l’algorithme (« profondeur » de récursivité) est trop élevé, l’occupation mémoire de l’algorithme devient trop importante et Python met alors en place une limite pour éviter les erreurs.

III- Conclusion

Au cours de cet article, nous avons abordé les fondamentaux de la programmation récursive. Si l’intérêt ne semble à première vue pas gigantesque, comprenez que ce type de programme nous permet de calculer des formes fractales ou autres étranges beautés mathématiques d’une manière souvent bien plus élégante que la méthode récursive.

L’objectif n’est pas ici de maitriser un algorithme en particulier mais bien de comprendre l’intérêt d’une telle méthode pour un développeur confronté à un problème bien particulier. Nous aurons sans doute par la suite l’occasion d’aborder de nouveau ce type de programmation.

Image de Une

Participation à la MakerFaire 2018

By | Non classé | No Comments

Chers Maker,
Voici venu le temps de la rentrée, annonciateur souvent du retour de projets, d’articles mais aussi de conventions.
A propos de convention, vous pouvez dès à présent réserver les dates du 23, 24 et 25 novembre 2018 pour passer nous voir lors de l’édition 2018 de la MakerFaire Paris. En effet, pour une année supplémentaire, notre équipe sera présente pour vous accueillir et vous présenter nos divers projets. En supplément, vous aurez l’occasion cette année de découvrir plus en détail le projet SimpleDomo qui s’est largement précisé lors de ces deux derniers mois que nous avons pu passer à travailler dessus.

Ainsi, vous aurez l’occasion de découvrir les premiers prototypes de prises domotique ainsi que ceux de la centrale SimpleDomo. Vous pourrez en comprendre le fonctionnement et mieux cerner les finalités de notre projet. En complément, nous continuerons bien sûr à présenter notre volonté de transmettre nos connaissances sur la plateforme SimpleDuino en réalisant des projets concrets sur un vaste champ de sujets (Tracker solaire notamment) ou encore des projets futurs, portés sur le long terme, dont nous développons des « proof of concept », sortes de preuves de faisabilité, notamment avec l’idée d’un miroir connecté…

En conclusion, nous ne pouvons qu’insister sur la nécessité de passer nous voir, ne serait-ce que pour mettre un visage sur notre équipe qui s’efforce depuis près de trois années à vous proposer des articles d’une clarté, précision et rigueur à la hauteur de vos attentes.

A bientôt !

Manipulation de fichiers Excel en Python

Manipulation de documents Excel en Python

By | Débutant Raspberry Pi, Informatique | 10 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.

Calcul intégral en Python

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

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

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: précision

Illustration de l’importance du nombre de subdivisions dans 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.

Gestion de fichiers

Manipulation de fichiers en Python

By | Débutant Raspberry Pi, Informatique | 8 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.

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 😉

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.

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

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 :

[email protected]

L’équipe Simple-Duino

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.