was successfully added to your cart.
Category

Débutant Raspberry Pi

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.

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.

Gestion de fichiers

Manipulation de fichiers en Python

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

Setup_RPI_Sans_Clavier_Sans_Ecran

Setup RaspberryPi: sans clavier, sans écran

By | Débutant Raspberry Pi | No Comments

De nombreux utilisateurs de RaspberryPi utilisent leurs machines pour mettre en place un serveur web ou bien un serveur de jeu ou encore faire tourner des scripts sans avoir nécessairement besoin d’un accès physique à la carte.

Nous allons voir ensemble comment faire l’installation et la mise en service d’une RaspberryPi sans clavier ni écran.
La méthode que nous allons voir ensemble est souvent nommée « Headless » sur les forums.


Afin de mettre en place l’installation de la carte, nous avons besoin:

  • Une RapberryPi
  • Une carte SD 8Go (minimum)
  • Une alimentation 5V

Il est également nécessaire de télécharger l’image disque de la dernière distribution de Raspbian sur le site de la fondation.

Procédez ensuite à la création de la carte SD à l’aide du logiciel Win32DiskImager.


1. Configuration

1.1 Activation du SSH

Avant de mettre en marche la RaspberryPi, il faut créer un fichier nommé « ssh » et le placer directement dans la partition boot.
En effet, depuis novembre 2016, la connexion SSH n’est plus activée par défaut suite aux attaques visant les objets connectés.

Lors de l’alimentation de la RaspberryPi, le fichier va permettre l’activation du SSH.

1.2 Connexion Wi-Fi

Maintenant que la connexion SSH est active, il est possible d’utiliser votre RPI via une connexion ethernet. Cependant, pour avoir une interaction vraiment sans contact physique, de nombreux makers, utilisateurs préféreront utiliser le réseau Wi-Fi.

Pour se connecter à votre réseau Wi-fi, il faut créer un fichier nommé « wpa_supplicant.conf » et le placer dans la partition boot comme le fichier « ssh » créé précédemment.

1
2
3
4
5
6
7
8
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=FR
network={
        ssid="NomReseau"
        psk="MotDePasse"
        key_mgmt=WPA-PSK
}

Vous pouvez maintenant connecter l’alimentation à la RaspberryPi et vous connecter sans fil.

Se connecter au WiFi avec le raspberry Pi 3

Se connecter au WiFi avec le Raspberry Pi 3

By | Débutant Raspberry Pi | No Comments

Voilà maintenant près d’un an que la marque à la framboise a sorti son dernier né, la carte Raspberry Pi 3. Comme vous le savez cette carte a la particularité de posséder une puce WiFi et Bluetooth. Ce qui permet d’imaginer de nouvelle utilisation en matière de système embarqué. En effet cela permet de libérer deux ports usb.

Cette puce WiFi n’est pas si compliquée à utiliser. Il y a deux manières de configurer la liaison WiFi entre la carte Pi et votre connexion.

  • En utilisant le bureau (à distance ou non)
  • En configurant la connexion en ligne de commande

Avant de commencer à configurer le Raspberry, il faut s’assurer que vous êtes à jour. Pour cela exécutez les commandes suivantes (que vous devez finir par connaître par cœur) :

1
2
3
4
5
6
7
8
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=FR
network={
        ssid="NomReseau"
        psk="MotDePasse"
        key_mgmt=WPA-PSK
}

Une fois l’opération terminée il vous suffit de redémarrer votre carte Raspberry.

I. Se connecter au WiFi à l’aide du bureau

Comme vous le savez, il est possible d’utiliser la carte Raspberry sous la forme d’un bureau (voir même sous la forme d’un bureau à distance, plus d’info ici).

Si vous utilisez votre raspberry sous forme bureautique, n’oubliez pas de débrancher le câble Ethernet. Si vous utilisez la forme d’un bureau à distance, il faut bien entendu laisser brancher le câble Ethernet le temps de la configuration du WiFi.

Comme vous pouvez le voir, une icône réseau est présent en haut à droite de l’écran juste à côté de l’horloge. Cliquez ensuite sur cette même icône. Une liste des différentes box dont vous captez le signal va s’afficher. Trouvez la vôtre et cliquez dessus, par exemple « livebox-A1A1 ».

Remarque : Seul les fréquences de 2,4GHz sont reconnues par le Raspberry Pi 3. Ne soyez donc pas surpris si les fréquences de 5GHz ne fonctionnent pas.

Comme vous le savez une clef est nécessaire pour se connecter au réseau. Ainsi, lorsque vous aurez sélectionné votre box, une fenêtre va s’afficher vous demandant la clef de connexion. Une fois le mot de passe rentré, cliquez sur « OK ». La tentative de connexion va s’opérer. Patientez et le tour est joué ! L’icône va alors afficher la puissance du signal.

II. Se connecter au WiFi à l’aide de ligne de commande

Si vous êtes des puristes de la ligne de commande, cette partie est faite pour vous ! Et je dois vous dire que je préfère la ligne de commande également !

Pour commencer, assurez-vous d’avoir branché le câble Ethernet. Connectez-vous à votre raspberry. Dans un premier temps, il va falloir éditer les interfaces. Pour cela entrez la commande suivante

1
sudo nano /etc/network/interfaces

Et ajoutez 4 lignes suivantes

1
2
3
4
auto wlan0
allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

Une fois cette étape terminée, il vous faudra entrer le login et le mot de passe wifi de votre box internet.

1
2
3
4
sudo -i
cd /etc/wpa_supplicant
wpa_passphrase *Votre_SSID* *VotreMotDePasseWiFi* >> wpa_supplicant.conf
exit

Et voila. Tout est paramétré. Néanmoins, pour s’assurer de la bonne prise en compte des informations indiquées vous pouvez lancer la commande :

1
sudo cat /etc/wpa_supplicant/wpa_supplicant.conf

Notez bien que le mot de passe est inscrit en clair. Donc attention à l’accès de votre Raspberry pour éviter tout intru sur votre réseau.

1
2
3
4
5
6
7
country=FR
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid=“votre_SSID“
psk=“VotreMotDePasse“
}

Enfin, et ce n’est pas trop conseillé, si vous vous connectez à une box ouverte (non protégée par un mot de passe), seul la ligne « ssid » est à renseigner.

N’oubliez pas de sauvegarder le fichier et de le quitter.

Votre raspberry est à présent connecté à internet grâce à sa puce WiFi. Il vous est possible de vérifier cette connexion en utilisant la commande ifconfig :

1
ifconfig wlan0

Vous pouvez à présent vous connecter sur le raspberry avec la console ssh. Il vous faudra récupérer l’adresse IP allouée par votre box puis se connecter comme vous savez le faire.

Vous voici à présent apte à commencer ou continuer à programmer ! Si vous rencontrez des soucis pour réaliser cette connexion ou sur vos projets, n’hésitez pas à venir poser vos questions sur le forum dédié.

Thomas A.

Image_Une

Installer un serveur Web sur votre Raspberry

By | Débutant Raspberry Pi | 7 Comments

Introduction

Depuis que j’ai reçu mon Raspberry Pi 3 je ne fais que le bidouiller. J’ai commencé par installer Raspian. Si vous ne l’avez pas encore fait, vous pouvez retrouver toutes les étapes d’installation dans ce tutoriel. Cependant la force du raspberry est de pouvoir l’utiliser en tant que serveur, par exemple en serveur Web. Nous pouvons bien évidemment installer d’autres serveur comme des serveur média, serveur de stockage, serveur domotique, serveur Minecraft… Les utilisations sont presque infinies. Nous verrons dans d’autres tutoriels comment installer plusieurs de ces différents serveurs.

Nous allons voir ensemble comment installer un serveur web sur notre raspberry et ainsi pouvoir développer des sites web en interne pour ensuite le déplacer sur un serveur plus gros pour le rendre accessible aux usagers d’internet.

Installation du serveur Web

1) Installation d’Apache

Tout d’abord il va falloir installer le package « Apache ».

Apache est le serveur web le plus utilisé dans le monde, très documenté visant son installation, son utilisation et sa sécurisation. Apache va nous permettre d’héberger des fichiers au format HTML afin qu’un navigateur web puisse les lire.

Afin d’installer Apache nous devons posséder les droits administrateurs, soit en vous connectant en root (vous pouvez retrouver comment activer cet utilisateur ici), soit par la commande sudo.

Pour commencer, écrivez la commande suivante afin d’installer le serveur Apache.

1
sudo apt-get install apache2

Arrivé ici, faites « Y »

Fenêtre d'installation d'Apache

Fenêtre d’installation d’Apache en ligne de commande

A présent apache est installé. Nous pouvons vérifier qu’Apache fonctionne correctement en vous connectant sur votre navigateur web et en entrant l’adresse IP locale du raspberry (192.168.1.21 pour ma part).

Vérification de fonctionnement d'Apache sur le navigateur web

Vérification de fonctionnement d’Apache sur le navigateur web

Vous devriez arriver sur cette page qui montre bien que le serveur fonctionne correctement.

Si vous souhaitez modifier la configuration d’Apache, rendez-vous dans le répertoire fraîchement créé :

1
cd /etc/apache2

Vous avez ici accès aux différents fichiers de configuration d’Apache.

Comme nous pouvons le voir, les fichiers .html se situent dans le répertoire /var/www/html. Nous pouvons modifier le répertoire où nous devons mettre les fichiers pour qu’ils soient lus. Pour cela, allez dans le répertoire « sites-enabled »:

1
cd /etc/apache2/sites-enabled

Puis il va nous falloir modifier le fichier « 000-default.conf ».

1
sudo nano 000-default.conf
Modification du répertoire pour la lecture des pages Web

Modification du répertoire pour la lecture des pages Web

Il faut modifier la ligne « DocumentRoot /var/www/html » en « DocumentRoot /var/www ». N’oubliez pas de sauvegarder à la fin de cette opération.

Puis redémarrez le service Apache.

1
2
/etc/init.d/apache2 restart
cd

Effectuons ensuite une rapide recherche de mises à jours et procédons à l’installation:

1
2
sudo apt-get update
sudo apt-get upgrade -y

 

2) Installation de PHP7.0

PHP : Hypertext Preprocessor, connu sous le sigle PHP est à la fois un langage de programmation principalement utilisé pour produire des pages web dynamiques via un serveur http et est aussi un interpréteur.

Afin que notre serveur puisse interpréter le langage PHP il va nous falloir l’installer via la commande suivante :

1
2
sudo apt-get install php7.0
cd

Nous allons à présent vérifier le bon fonctionnement de PHP. Commencez par accéder au répertoire suivant :

1
cd /var/www/html

Supprimez le fichier index.html

1
sudo rm index.html

Vous devriez vous trouver dans le répertoire « /var/www ». Si ce n’est pas le cas, faites tout simplement :

1
cd /var/www

Puis créez un fichier « index.php »

1
sudo nano index.php

A présent, entrez le code suivant :

1
<?php phpinfo(); ?>

Retournez dans votre navigateur à l’adresse de votre raspberry. Vous devriez avoir une page de ce type :

Vérification de fonctionnement de PHP sur le navigateur web

Vérification de fonctionnement de PHP sur le navigateur web

Cela montre que PHP fonctionne correctement.

 

3) Installation de MySQL

Tout serveur fonctionne avec des bases de données pour stocker les informations de votre site web ou de votre application. Nous allons donc installer un SGBD (Système de Gestion de Bases de Données) qui est MySQL. La SQL n’est pas un langage de programmation mais est bien plus ! C’est un outil incontournable permettant de vous aider considérablement dans le traitement de données.

Nous allons installer « mysql-server » et « php5-mysql » qui permet de faire le lien entre php et mysql.

1
2
cd
sudo apt-get install mysql-server

Lors de l’installation de MySQL il vous sera peut-être demandé un mot de passe pour le compte administrateur (root). Si tel est le cas, entrez votre mot de passe et appuyez sur « entrée ». Veillez à ne pas perdre ce mot de passe ! (Pour ma part je n’en mets pas, je le modifie une fois l’installation effectuée correctement).

Demande de mot de passe lors de l'installation de MySQL

Demande de mot de passe lors de l’installation de MySQL

Ensuite installons « php7.0-mysql »

1
2
cd
sudo apt-get install php7.0-mysql

A présent nous pouvons vérifier que MySQL fonctionne correctement. Lançons maintenant MySQL:

1
sudo mysql –u root –p votremotdepasse

NB: Si aucun mot de passe n’a été mis en place dans les manipulations précédentes, Lançons MySQL de la manière suivante:

1
sudo mysql –u root –p

ou encore par:

1
sudo mysql

Cette fenêtre devrait s’ouvrir. Grâce à cette invite de commande vous pouvez gérer toutes vos bases de données en ligne de commande.

Fenêtre montrant le bon fonctionnement de MySQL

Fenêtre montrant le bon fonctionnement de MySQL

Nous allons maintenant changer les privilèges de connexion afin de vous rendre super administrateur de MySQL.

1
2
3
4
use mysql;
update user set plugin='' where User='root';
flush privileges;
exit;

 

4) Installation de PHPMyAdmin

PHPMyAdmin est une application web qui fournit une interface graphique simplifiée pour MySQL. Grâce à cette application vous pouvez lire, modifier, manipuler toutes vos bases de données.

1
 sudo apt-get install phpmyadmin

Une fenêtre vous demandant de faire un choix entre deux serveurs web va s’afficher.

Cocher apache2 en appuyant sur "espace"

Cocher apache2 en appuyant sur « espace »

Il vous faut cocher « apache2 » en appuyant sur la barre espace. Une étoile (*) va s’afficher à côté de votre choix vous montrant qu’il a bien été pris en compte.

Image montrant qu'Apache 2 est coché

Image montrant qu’Apache 2 est coché

Rendez vous ensuite dans le répertoire phpmyadmin :

1
cd /etc/phpmyadmin

Il va falloir modifier le fichier « config.inc.php » de la façon suivante de telle sorte que  « $cfg[‘Servers’][$i][‘AllowNoPassword’] = TRUE; » soit décommentée. Cette ligne se trouve vers la fin du fichier.

1
sudo nano config.inc.php
Image montrant la ligne a décommenter

Image montrant la ligne a décommenter

Vous pouvez vous rendre sur votre navigateur web, et écrire l’adresse suivante XXX.XXX.X.XX/phpmyadmin (où XXX.XXX.X.XX est l’adresse locale de votre raspberry). Vous devriez tomber sur cette page :

Vérification du fonctionnement de PHPMyAdmin

Vérification du fonctionnement de PHPMyAdmin

Entrez « root » comme nom d’utilisateur et le mot de passe que vous avez enregistré lors de l’installation de MySQL.
 
Maintenant votre serveur web avec MySQL et PHPMyAdmin est complétement opérationnel ! Il ne vous reste plus qu’à apprendre les différents langages de programmations tels que le HTML et le PHP ainsi que le CSS et la SQL pour réaliser vos premières pages web afin de pourvoir gérer à distance vos pins GPIO du RaspberryPi par exemple.

Thomas A.

[Article mis à jour le 18/01/2018]
Photo de une du tutoriel "Installer Raspian et VNC"

Installer Raspian et VNC sur un raspberry

By | Débutant Raspberry Pi | No Comments

Bonjour à tous !

Eh oui ! Ca y est, la deuxième carte Pi 3 vient d’arriver ! Il est temps de la configurer. Dans un premier temps nous allons simplement installer Raspian afin de pouvoir l’utiliser.

 

Installation de Raspian

Il va vous falloir un peu de matériel :

  • Un raspberry Pi 3 (dans mon cas)
  • Une carte SD de 16 GB mini (32 GB pour moi)
  • Un adaptateur secteur/micro-USB

Dans un premier temps il va falloir préparer la carte SD et de graver Raspian dessus.

Afin de préparer cette carte SD il nous faut télécharger la dernière version de Raspian http://downloads.raspberrypi.org/raspbian_latest. Il s’agit de cette version que nous allons installer sur notre carte.

Il va aussi nous falloir télécharger le logiciel Win32DiskManager que nous pouvons retrouver ici https://sourceforge.net/projects/win32diskimager/files/latest/download. Je vous laisse l’installer.

Bien entendu il nous faut un port SD sur notre ordinateur pour pouvoir écrire dessus.

  • Décompressez l’archive de Raspian afin d’obtenir un « .img ».
  • Cliquez ensuite sur l’icône représentant un dossier bleu à droite de « Image File ».
  • Sélectionnez l’image de Raspian que vous venez de décompresser.
  • Dans l’onglet « Device » sélectionnez bien l’emplacement de votre carte SD. Faites bien attention à ne pas vous tromper !
Logiciel Win32DiskImager

Logiciel Win32DiskImager

  • Appuyez sur « Write » pour lancer l’écriture.
Ecriture de Raspian sur une carte SD

Ecriture de Raspian sur une carte SD

Une fois terminé, la fenêtre affiche « Write Successful ». Ejectez la carte. La voilà prête pour le raspberry !

N’ayant pas d’écran auxiliaire j’opte pour une installation sans !

Dans un premier temps insérez la carte SD dans le Raspberry puis connectez le à la box internet via un câble RJ45. Branchez ensuite l’alimentation du Raspberry.

Rendez-vous sur l’interface de la box internet http://192.168.1.254 (selon votre box).

Information connexion dur la box du raspberry

Information connexion sur la box du raspberry

L’adresse IP de mon Raspberry est 192.168.1.21.

A présent, lancez le logiciel Putty téléchargeable ici.

Fenêtre de connextion SSH via Putty

Fenêtre de connextion SSH via Putty

Entrez l’adresse IP de votre Raspberry et faites « Open ».

Une console va s’ouvrir.

Console de connexion de Putty

Console de connexion de Putty

Le login par défaut est « pi »et le mot de passe par défaut est « raspberry ». Utilisons-les pour nous connecter dessus.

Voici notre première connexion SSH sur notre Raspberry !

Première connexion en SSH sur le raspberry en profil Pi

Première connexion en SSH sur le raspberry en profil Pi

Continuons la configuration !

Ecrivez la ligne de commande

1
sudo raspi–config

Voici l’écran que vous devriez voir.

Fenêtre de configuration de Raspian

Fenêtre de configuration de Raspian

Faites « entrée » sur « Expand Filesystem » pour étendre la capacité de l’OS à toute la carte SD.

Nous pouvons améliorer la sécurité du profil « pi » du Raspberry en modifiant son mot de passe.

Pour cela, il vous suffit d’aller dans « Change User Password ». Une nouvelle fenêtre va s’ouvrir vous indiquant que vous allez modifier le mot de passe pour « pi ». Appuyez sur « entrée » puis entrez votre nouveau mot de passe. (Aucun caractère ne s’affichera ! Attention de ne pas vous tromper !). Faites « entrée ». Le menu se rouvrira vous indiquant que la modification s’est parfaitement déroulée.

 

Activation du profil « root »

Nous allons à présent activer le profil « root » qui correspond au super-utilisateur du Raspberry.

Commençons tout d’abord par nous connecter avec le profil « pi ».

Tapez :

1
cat /etc/ssh/sshd_config

Vous devriez avoir à l’écran ceci :

Modification à apporter pour autoriser le profil root

Modification à apporter pour autoriser le profil root

Nous pouvons voir la ligne

« PermitRootLogin without-password ». Nous devons la modifier en « PermitRootLogin yes ».
Afin de modifier le fichier nous devons taper

1
sudo nano /etc/ssh/sshd_config

Retrouvez la ligne à modifier puis effectuez le changement. Ensuite faites « ctrl+x » puis « y » puis « enter ».

1
sudo /etc/init.d/ssh restart

Maintenant reconnectez-vous avec le profil « pi ». Entrez cette commande :

1
sudo passwd root

et inscrivez le mot de passe du super utilisateur deux fois.

Faites un reboot, puis connectez-vous cette fois-ci avec le profil « root » et le mot de passe inscrit. A présent vous voilà super administrateur.

 

Installation de VNC

VNC (Virtual Network Connection) est un outil permettant de contrôler de façon graphique son raspberry sans écran annexe, mais en utilisant celui de votre ordinateur.

Dans un premier temps il vous faut installer VNC sur le raspberry grâce à la commande suivante :

1
2
3
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install tightvncserver

Une fois installé il vous faudra effectuer la commande :

1
vncserver :1 

Cette commande permet de lancer le serveur VNC. La première fois que vous le lancerez, vous devrez entrer un mot de passe. Il vous faudra entrer un mot de passe de 8 caractères. Si vous avez gardé votre mot de passe par défaut « raspberry » il faudra donc écrire « raspberr ».

Côté client il nous faut installer VNC client sur notre ordinateur. Nous pouvons nous le procurer ici http://www.realvnc.com/download/vnc/.

Une fois installé vous devriez voir ceci :

Fenêtre d’authentification côté client de VNC

Fenêtre d’authentification côté client de VNC, insertion de l’adresse IP

Dans le champ « VNC Server », entrez l’adresse de votre raspberry suivi de « :1 ». Ensuite cliquez sur « Connect ».

La fenêtre suivante doit s’ouvrir :

Fenêtre d’authentification côté client de VNC

Fenêtre d’authentification côté client de VNC

Entrez le mot de passe par défaut qui sera « raspberr » puis faites « OK ».

Si un message d’avertissement apparaît, faites « continuer ».

Le bureau de votre raspberry apparaît ici. Vous pouvez à présent contrôler votre raspberry grâce à votre souris et votre clavier à distance.

Interface graphique de Raspian avec VNC

Interface graphique de Raspian avec VNC

Il peut s’avérer utile de lancer le serveur VNC à chaque reboot automatique du raspberry. Pour réaliser cette séquence automatique, il faut écrire séparément et dans l’ordre les commandes suivantes :

1
2
3
4
5
cd /home/pi
cd .config
mkdir autostart
cd autostart
sudo nano tightvnc.desktop

Un fichier vide va s’ouvrir. Il suffit de copier-coller les lignes suivantes :

1
2
3
4
5
6
#!/bin/sh
[Desktop Entry]
Type=Application
Name=tightVNC
Exec=vncserver :1
StartupNotify=false

Ensuite sauvegarder en faisant « ctrl+x » puis « y » puis « enter ».

Redémarrez votre raspberry et tout devrait fonctionner.

Pour fermer la connexion il vous suffit d’écrire « exit » dans la console.

Vous savez à présent installer Raspian et utiliser son interface graphique. Vous pouvez retrouver la liste des commandes utiles lors de l’utilisation du raspberry en ligne de commande ici.

A bientôt

Thomas A.

Illustration Bien débuter avec le Raspberry Pi

Bien débuter avec le Raspberry Pi

By | Débutant Raspberry Pi | No Comments
  • Installation d’un système d’exploitation (OS : « Operating System » en anglais)

Je considère que vous avez déjà acheté une carte micro SD d’une capacité suffisante (4 Go minimum).
Rendez-vous sur le site de la fondation Raspberry afin de télécharger la version que vous souhaitez. Je vais faire le tutoriel en ayant téléchargé la version de RASPBIAN datant du 31/01/2015.
Téléchargez l’utilitaire win32diskimager à l’adresse suivante: Win32 Disk Imager.
Insérez la carte micro SD dans l’ordinateur, lancer le l’utilitaire Win32 Disk Imager, puis sélectionner l’image de RASPBIAN. Cliquez sur « write » et patientez quelques minutes.
Insérez la carte dans le Raspberry et branchez-le. Branchez également le câble ethernet.

Nous allons apprendre à nous servir du Raspberry sans avoir d’interface graphique, pour cela, nous allons devoir utiliser le logiciel « PuTTy » que vous pouvez télécharger ici.
Lancez PuTTy et entrez y l’adresse IP de votre Raspberry, cliquez ensuite sur « open ».
Une fenêtre devrait apparaître vous demandant vos login.
Pour la première utilisation, entrez :

1
sudo raspi–config

Vous voilà sur votre Raspberry. Sur PuTTy, il n’y a aucune interface graphique, c’est pourquoi il est nécessaire de connaitre un certain nombre de commandes permettant de parcourir les fichiers, créer des dossiers, ou simplement regarder les dossiers et fichiers contenus dans un dossier.
Vous allez voir, que ce n’est pas très difficile surtout que vous allez utiliser ces commandes tout le temps. Vous allez vite les apprivoiser sans vous en rendre compte.

  • Commandes basiques de gestion du répertoire

Le tableau ci-dessous reprend les principales commandes nécessaires au débutant sous un environnement Raspberry (qui sont aussi valable sur Linux).

Commande Description Exemple
mkdir Permet de créer un répertoire mkdir siteweb
Permet de créer un répertoire appelé « siteweb1 » dans le dossier « siteweb » mkdir siteweb/siteweb1
-m Permet de spécifier des droits à la création du répertoire mkdir –m 777 siteweb
-p Permet de créer des répertoires parents mkdir –p siteweb/siteweb1
cd Permet de se déplacer dans un dossier cd siteweb
cd .. Permet de se déplacer dans un dossier précédent
rmdir Permet de supprimer un dossier vide rmdir siteweb
rm -r Permet de supprimer un dossier non vide rm –r dossier
ls Permet de lister le contenu d’un répertoire ls
cp Permet de copier un fichier1 en un fichier nommé fichier2 cp fichier1 fichier2
mv Permet de renommer le fichier1 en fichier2 mv fichier1 fichier2

Désormais, vous connaissez les bases pour parcourir les dossiers de votre Raspberry.

 

  • Mise en place du profil « root »

Le profil « root » et l’équivalent du « super admninistrateur » sous windows.
Il va vous permettre de parcourir les fichiers cachés pour les utilisateurs ordinaires.

Connectez-vous sur votre raspberry :

1
cat /etc/ssh/sshd_config

Ensuite entrez la commande suivante :

1
sudo nano /etc/ssh/sshd_config

Suivez les instructions. Il faut taper un mot de passe.

Au prochain redémarrage de votre raspberry, lors de l’ouverture de la session sous puTTy, mettez :

1
sudo /etc/init.d/ssh restart

 

  • Accès au Raspberry direct ethernet / PC

Vous vous êtes surement demandé comment se connecter à son raspberry sans que ce dernier soit connecté au réseau de votre habitation.

Pour cela, il va valoir utiliser votre PC en serveur DHCP. Rien de très compliqué, il vous suffit de télécharger le logiciel Xming et de le lancer.

Ensuite, éjectez la carte SD de votre raspberry pour la mettre sur l’ordinateur. Vous devriez avoir un fichier nommé « cmdline.txt ». Ouvrez le, et modifiez le de la manière suivante :

Vous passez de :

1
sudo passwd root

en :

1
2
3
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install tightvncserver

ATTENTION : Ne sautez pas de ligne, et mettez le “IP=169.254.XXX.XXX” à la suite de “rootwait”

Remplacez bien sûr, les « XXX » par l’adresse IP que vous souhaitez attribuer à votre Raspberry Pi.

Une fois ce changement fait, sauvegardez, et remettez la carte SD dans le raspberry. Branchez le raspberry au PC via ethernet.
Ouvrez puTTy, cliquez sur X11, puis cocher « Enable X11 forwarding »

Configuration X11 Putty

Capture d’écran de Putty lors de la configuration du « X11 forwarding »

Retournez ensuite dans « Session » et entrez l’adresse IP que vous avez entré dans le fichier « cmdline.txt ».
Vous pouvez dès à présent, vous connecter sur votre raspberry depuis votre PC.

ATTENTION Configuré tel quel, votre Raspberry Pi ne pourra plus être utilisé sur un réseau « classique ». Pour revenir en arrière, il suffit d’effacer le « IP=169.254.XXX.XXX » que vous avez précédemment ajouté. Cela est lié à l’attribution d’une adresse IP « LAN » (169.254) au périphérique. Si vous souhaitez donner une IP fixe au Raspberry Pi directement relié à votre box, vous pouvez remplacer « 169.254.XXX.XXX » par « 192.168.XXX.XXX »

 

Grégoire A.

Illustration tutoriel utilisation du langage Python

Découvrez les bases du langage Python

By | Débutant Raspberry Pi | No Comments

Bonjour, nous allons aujourd’hui vous présenter le langage Python.

Python est un langage simple et complet qui va vous permettre de contrôler le Raspberry Pi. Si nous avons préféré ce langage au Java, c’est parce que c’est un langage qui n’a pas vraiment d’apriori, et aussi pour sa grande simplicité. Laissez nous vous présenter les bases.

Dans un premier temps, il faut comprendre que Python possède son propre Editeur et son propre interpréteur. Vous pouvez télécharger ces deux éléments sur le site suivant : https://www.python.org/downloads/ en cliquant sur  » download « 
Une fois Python installé, vous pourrez ouvrir IDLE (Python GUI), le logiciel qui vous permettra de créer vos programmes en Python. Là, on se retrouve face à un interpréteur Python. Ainsi, essayez d’écrire ceci :

 

1
2
login as : pi
password : raspberry

Maintenant, le fameux « Hello world ! » devrait s’écrire en bleu juste en dessous de la ligne où vous avez écrit. Vous venez d’exécuter votre première fonction Python. Rapidement, vous allez vous demander comment écrire de vrais programmes que vous pourrez rouvrir plus tard. En effet, l’interpréteur que vous avez devant les yeux ne vous permet pas d’enregistrer vos programmes. Ainsi, vous pouvez aller dans fichier puis new file. Cela aura pour effet d’ouvrir une nouvelle fenêtre de l’IDLE, vierge cette fois ci, dans laquelle vous pourrez écrire vos programmes. Pour les exécuter, la démarche est aussi simple puisqu’il suffit d’appuyer sur F5, d’enregistrer le programme et il s’exécutera ensuite.

A propos de l’enregistrement, n’oubliez pas de spécifier  » Python files (*.py,*.pyw)  » et d’ajouter .py à la fin du nom de votre programme.

Maintenant que vous savez créer et exécuter un programme, il nous reste à découvrir quelques fonctions utiles.
Avant de continuer, vous devez savoir que les commentaires dans les scripts Python sont toujours précédés d’un dièse. N’oubliez pas ce point car nous commenterons chaque ligne de code à partir de maintenant
Commençons par les variables. Sur ce point, c’est un langage vraiment simpliste. En effet, il n’est pas nécessaire de spécifier le type de variable utilisé comme cela se fait dans de nombreux autres langages. Ici, pour déclarer une variable, on a juste à écrire ceci :

1
2
login as : pi
password : raspberry

Exemple :

1
sudo passwd root

C’est là que Python est vraiment convaincant, plus aucun problème de type de variable n’est possible tant que les scripts ne sont pas trop complexes…

Pour récupérer ce que l’utilisateur va écrire, on utilise la fonction input() :

1
2
login as : root
password : "votre mot de passe"

Ce qu’il faut savoir c’est que cette fonction met le programme en pose tant que rien n’a été entré et validé par l’utilisateur.
En opposition avec cette fonction, il existe la fonction print() qui permet d’afficher une variable :
Print(Variable) #Affiche le contenu de la variable

Les conditions :

Au niveau des boucles de conditions, on utilise sensiblement les mêmes que les autres langages avec cependant des différences de syntaxe. Ainsi, voici la syntaxe d’une boucle if :

1
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Une alternative au else existe, c’est le elif qui correspond au if. Il s’utilise d’ailleurs de la même manière avec la même syntaxe. Vous remarquerez que Python ajoute automatiquement une indentation (un espace) puisque sans cette dernière, il ne serait pas en mesure de comprendre que l’action ne doit être exécutée que si la condition est vraie.
Dans la même idée, on a la boucle while qui exécute l’action tant que la condition est vraie. Sa syntaxe est la même que le if :

1
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait IP=169.254.XXX.XXX

Enfin, une boucle moins courante mais toujours utile existe, c’est la boucle for. Sa syntaxe est la suivante :

1
2
For x in " TEST " : #Pour chaque lettre dans TEST
	#Action

Il existe 6 opérateurs de comparaisons pour les conditions :
== (égal à) < (inférieur à) > (supérieur à) <= (inférieur ou égal à) >= (supérieur ou égal à) et != (différent de)
De plus, on a aussi deux mots clés pour les conditions : and (et) et or (ou)
Ainsi, si on écrit A == 1 and B != 6 or C <= 5 and D == 1 , cela signifie :
Si A égal à 1 et B différent de 6 ou si C inférieur ou égal à 5 et D égal à 1
Il existe aussi le mot clé not qui revient à l’opérateur !=
Vous connaissez désormais les variables, la récupération de saisie, l’affichage de variables et les boucles conditionnelles.

Voyons une dernière chose ensemble, les fonctions.
Les fonctions permettent de clarifier les programmes, de les rendre plus propres. On peut ainsi regrouper plusieurs actions en l’appel d’une seule fonction.
On déclare une fonction de la manière suivante :

1
2
def nom_de_la_fonction(paramètres) :
	#Action

Ainsi, on peut créer la fonction suivante :

1
2
def afficher(A)
	print(A)

qui aura le même effet que print(A) mais avec le nom afficher(A).
Pour appeler ou exécuter une fonction, il suffit d’entrer son nom et de spécifier les paramètres. Ainsi, on peut exécuter notre fonction de la manière suivante :

1
afficher(1) #Affichera 1

Voilà pour la théorie, vous avez désormais toutes les clés pour commencer à créer vos programmes en Python.
Voici un script final qui résume tout ce que vous avez appris aujourd’hui :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
print('Bonjour, quel est votre prenom ?')
prenom = raw_input() #Sous Python 2.x.x, input() devient raw_input()
print('Et votre age ?')
age = raw_input() #Sous Python 2.x.x, input() devient raw_input()
intage = int(age) #On convertit age (chaine de caractères) en variable de type "int" (nombre)
 
def affichage() :
    if majeur == 0 :
        print("Vous vous appellez " + prenom)
        print("Vous avez " + age + " ans")
        print("Vous n'etes pas majeur")
    elif majeur == 1 :
        print("Vous vous appellez " + prenom)
        print("Vous avez " + age + " ans")
        print("Vous etes majeur")
 
if intage < 18 :
     majeur = 0
elif intage >= 18 :
    majeur = 1
 
affichage()

Fabien Aubret

Raspberry Pi B+

By | Débutant Raspberry Pi | No Comments

Raspberry Pi B+

Il est là !! Sorti enfin et très attendu comme successeur du modèle B.

Le raspberry Pi modèle B+ est sorti un 14 Juillet, beau cadeau pour ce jour. Voici une photo de la bête:

raspberrypi_b+

Quelques modifications que nous relevons ici:

– Disparition de la Prise RCA qui rejoint la prise jack (audio + vidéo) 4 contacts

– La carte SD qui dépassait devient micro SD, cachée sous le raspberry, plus rien ne dépasse (plus propre/pratique/résistant)

– Les GPIO deviennent plus nombreux puisqu’on en retrouve 40 sur cette nouvelle version.

La RAM reste à 512 Mo, toujours trop peu pour ceux qui utilisent le raspberry comme un micro ordinateur.

Un client de Farnell avait laissé fuité des images d’un raspberry pi qu’il avait trouvé étrange, on pouvait déjà y lire le fameux « B+ »:

Raspberry_Pi-Model_B+1

Voilà pour l’actu !!

Ca promet pleins de nouveaux projets tout ça… On pourrait peut-être se passer de l’Arduino, même si on a toujours aucune entrée analogique.