Planet RaspFR

Bienvenue sur ce planet dédié au Raspberry Pi
mais aussi autres micro-ordinateurs et aux imprimantes 3D de type DIY.

Si vous voulez ajouter votre blog, n'hésitez pas à nous contacter.
Nous vous donnons rendez-vous sur le forum RaspFR

Moto pilotée par un Raspberry Pi

motopi_250pxDemain les voitures seront pilotées par des intelligences artificielles. Remarquez, quand on voit certains comportement d’humains au volant on regrette que ce ne soit pas déjà le cas 😀
Après les voitures ce sera le tour des motos et pourquoi pas des vélos
En attendant, il faut explorer les possibilités offertes par la technologie dont nous disposons. C’est ce qu’a fait Eric, un étudiant de l’École Polytechnique Fédérale de Lausanne.

Moto radiocommandée pilotée par Raspberry Pi

motopi2

L’annonce de départ

twitt_epfl_600px

Twitt original de l’EPFL (École Polytechnique Fédérale de Lausanne)

C’est ce twitt qui est le point de départ de cet article, retwitté plusieurs fois sur Twitter, cette réalisation m’a été également rappelée sur Facebook par David 🙂

L’objectif de la réalisation

Après les courses de voitures électriques (la formule E), les combats ou les courses de robots, on peut envisager des courses de véhicules électriques autonomes qui seront pilotées par des intelligences artificielles. Eric imagine cette course en utilisant un modèle réduit de moto. Il voudrait battre un pilote humain pilotant une moto radiocommandée, avec une moto pilotée par un Raspberry Pi.

Comment ça marche ?

navio2_600pxC’est une carte NAVIO2 qu’Eric a choisie comme co-pilote de la moto. La carte NAVIO comporte des capteurs qui permettent au logiciel de maintenir l’équilibre de la moto et de de contrôler sa direction. Dans l’état d’avancement du projet, il piloter la moto avec une radiocommande, mais à terme le but est qu’elle soit totalement autonome.motopi3_600px

Avec ce genre de matériel, il devrait être possible à terme d’affronter des pilotes humains et même de les battre, comme AlphaGo a battu le champion du monde de Go en mars dernier. Mais bon, il y a encore de nombreux paramètres à gérer 🙂 Un pilote humain est imprévisible, parfois fourbe et il peut prendre des risques insensé sur une moto, surtout lorsqu’il la pilote… depuis une télécommande !

navio2

Il n’y a donc pas que l’équilibre et les trajectoires de la moto à gérer avec le Raspberry Pi, il faut aussi éviter les obstacles, les queues de poisson des concurrents, les poussettes, et autres joyeusetés qui se produisent sur une piste.

motopi4_600px

Le but est bien entendu de gagner sachant que la moto peut rouler à 60 Km/h, que la trajectoire idéale peut être occupée par un concurrent. Mais tout cela ne semble pas effrayer Eric !

motopi_600px

Et après ?

J’imagine bien que comme sur les drones, les motos embarquent des caméras et retransmettent les images 🙂 Du « FPV » moto ? Ça ne vous dit pas ?

velo_autonomeBon, si on va plus loin pourquoi ne pas imaginer un vélo autonome qui roule tout seul ? Non… ça c’est un peu trop tôt et juste le poisson d’avril 2016 de Google Pays-bas 🙂

Vidéo

Conclusion

Avec cette réalisation , Eric montre que les utilisations du Raspberry Pi sont vraiment variées et que la puissance de calcul d’un Raspberry Pi 3 est suffisante pour gérer des véhicules instables, comme une moto.

Sources

« Python pour le Raspberry Pi » publié aux Éditions ENI

python_raspi_250pxDans Raspberry Pi, le Pi c’est pour Python. Python est le langage « par défaut » choisi par les concepteurs du Raspberry Pi.
Même si certains (oui, moi 🙁 ) ont assimilé le PI à … 3,14 mais c’était trop tentant, non ?
Il n’y avait pas jusqu’alors de livre consacré exclusivement à Python sur notre framboise ! Vous en rêviez ? Patrice l’a fait 😀

Python pour le Raspberry Pi : Apprenez à développer sur votre nano-ordinateur

Pourquoi Python ?

pythonlogo_200px

Source Wikipedia

Parce qu’il est conçu pour optimiser la productivité des programmeurs en offrant des outils de haut niveau et une syntaxe simple à utiliser.

Il est également apprécié par de nombreux enseignants qui y voient un langage où la syntaxe, clairement séparée des mécanismes de bas niveau, permet une initiation aisée aux concepts de base de la programmation.

Python est un langage qui peut s’utiliser dans de nombreux contextes et s’adapter à tout type d’utilisation grâce à d’innombrables bibliothèques spécialisées. Il est cependant particulièrement utilisé comme langage de script pour automatiser des tâches simples mais fastidieuses, comme un script qui récupérerait la météo sur Internet ou qui s’intégrerait dans un logiciel de conception assistée par ordinateur afin d’automatiser certains enchaînements d’actions répétitives. On l’utilise également comme langage de développement de prototype lorsqu’on a besoin d’une application fonctionnelle avant de l’optimiser avec un langage de plus bas niveau. Il est particulièrement répandu dans le monde scientifique, et possède de nombreuses extensions destinées aux applications numériques.

Toutes ces raisons ont amené les créateurs du Raspberry Pi à recommander Python comme langage de base sur le Raspberry Pi.

L’auteur : Patrice CLEMENT

patrice_clement_photo_250pxPatrice est un expert en systèmes d’information et passionné de logiciels libres. Il est développeur et membre actif de la communauté Gentoo depuis 8 ans sous le pseudo monsieurp. Il participe à de nombreux projets comme Java ou Gentoo Perl Project comme développeur, et il est membre de plusieurs groupes par exemple Proxy Maintainers, Python

Après plusieurs expériences dans diverses entreprises à l’international et en France, il a décidé de transmettre son expertise du langage Python et sa curiosité pour la plateforme embarquée Raspberry Pi à travers la rédaction de ce livre.

Le livre : Python et Raspberry Pi

Si vous avez suivi les chemins de la framboise, vous avez forcément croisé Python à un moment ou à un autre.

panneau_framboise_python

Il est parfois difficile de trouver de l’information pour utiliser de façon pratique le langage Python sur le Raspberry Pi. Les cours Python qu’on trouve sont généraux et s’appliquent à divers OS. Ici l’intérêt c’est que le livre a été fait pour utiliser Python sur notre framboise 🙂

eni_stock

Dans les rayons chez ENI, les deux livres sont voisins : au premier plan mon livre Raspberry Pi 2, au second plan le livre de Patrice 🙂

Dans ce livre vous découvrirez d’abord en détail les types de base (entiers, flottants, booléens…) afin de pouvoir les utiliser à bon escient dans vos programmes.

Vous explorerez les structures utilisées par le langage (listes, tuples, dictionnaires…), les instructions et les boucles et enfin les opérateurs.

Dans les concepts avancés vous apprendrez comment définir une fonction ou utiliser des modules.

Les outils de documentation et de test des scripts viennent ensuite.

Après ces « mises-en-bouche », on attaque le sujet avec l’administration du Raspberry Pi en Python. Ici c’est l’utilisation du système à travers Python : Manipulation des fichiers et du système de fichiers du RasPi, lancement de commandes shell depuis Python ou encore écriture de scripts.

En mode console (texte) vous écrirez des programmes de menu interactif, de calculatrice et un jeu de… serpent ! Bin oui… en Python 😀

En mode graphique c’est tkinter qui est mis à contribution pour un « Hello world » quasiment obligatoire quand on découvre un langage. Suivent une visionneuse d’image et un éditeur de texte.

Tous ces programmes sont décrits pas à pas et les programmes sont détaillés et disponibles en téléchargement sur le site du livre (comme pour tous les programmes du livre, d’ailleurs).

screenshot

Suivent deux chapitres qui vous emmènent dans les environnements multimédia (créer des images, dessiner des figures géométriques ou contrôler les E/S audio) et Web (manipuler des pages web, exécuter des scripts côté serveur HTTP ou envoyer des mails).

Si vous devez stocker ou traiter des données les formats CSV et XML n’auront plus de secrets pour vous.

lcd

On termine avec un projet plus « hard » qui consiste à connecter un écran LCD (2 lignes de 16 caractères de chez Adafruit) sur le GPIO du Raspberry Pi et à le gérer… en Python 🙂 avec RPi.GPIO en mode texte et même en mode graphique avec tkinter.

La table des matières

  • Environnement de programmation
  • Introduction à Python
  • Concepts avancés du langage Python
  • Documenter et tester ses scripts en Python
  • Administration du Raspberry Pi en Python
  • Le Raspberry Pi en console avec curses
  • Programmation d’interfaces graphiques avec tkinter
  • Multimédia et audio sur le Raspberry Pi
  • À l’assaut du Web avec le Raspberry Pi
  • Persistance de données sur le Raspberry Pi
  • Raspberry Pi et GPIO

Conclusion

Si vous souhaitez aller plus loin avec Python sur votre framboise, ce livre paru en septembre 2016 est fait pour vous. C’est un livre broché mesurant 17 x 21 cm et comportant 331 pages. Il est destiné à des utilisateurs de niveau initié à confirmé. Les programmes sont développés en Python 3 car Python 2 avance doucement vers sa mise à la retraite… Réalisés sur un Raspberry Pi 1, tous les programmes fonctionnent également sur les modèles suivants B+, 2, 3 et Zero du fait de la compatibilité des GPIO en particulier.

Vous pouvez le commander directement chez ENI, en version numérique (accessible en ligne au format HTML) ou en version papier (dans ce cas la version numérique est offerte). Vous pouvez aussi le commander dans une librairie ou centre culturel en précisant le titre et le N° ISBN : 978-2-4090-0332-5.

python_raspi_fb

Sources

Elektor d’octobre 2016 : Raspberry Pi inside

elektor_201609_250pxVoilà un bon moment que je ne vous avais pas parlé d’Elektor. Le numéro d’octobre 2016 embarque du Raspberry Pi et de l’Arduino, il peut donc intéresser certains d’entre vous…
Il y a plusieurs montages à base de Raspberry Pi, tout d’abord une carte de commande pour les moteurs Lego®, capable de piloter 4 de ces moteurs et donc d’automatiser vos réalisations.
On trouve aussi un judas connecté équipé d’une caméra et capable de vous envoyer les images de celui/celle qui sonne à la porte.
Enfin au chapitre Arduino j’ai noté le pilotage d’un écran e-paper qui pourra aussi déboucher sur des applications intéressantes.

Elektor N°460 – Octobre 2016

elektor_201609_couverture

Carte de commande Lego sur un Raspberry Pi

elektor_201609_0002Baptisée carte HAT (à tort à mon avis car la carte HAT doit présenter un facteur de forme donné et comporter une EEPROM – en particulier des encoches sont prévues pour le passage des câbles plats des caméras) , cette carte se connecte sur les ports GPIO.

carte_hat

Elle comporte 4 sorties pour les moteurs LEGO EV3 avec signaux de tachymétrie. Deux sorties sont en PWM.
On trouve également 16 E/S bufferisées (MCP23008) sur le bus I2C et embarque une alimentation à découpage 9v => 5v qui alimente également le Raspberry Pi.

Judas connecté avec Raspberry Pi

elektor_201609_0003

Alors là… Une sonnette qui filme votre visiteur et vous envoie un MMS pour que vous puissiez le voir. La carte doit être équipée d’une carte SIM pour assurer ce service. Un micro et un haut-parleur permettent de dialoguer avec votre visiteur et vous pourrez même lui ouvrir la porte. Gros déploiement de technologie (et d’euros) pour cette application basique , mais on se dit que ça peut servir pour d’autres choses…

Papier électronique et Arduino

elektor_201609_0004

Le papier électronique a la particularité de ne plus consommer d’énergie une fois que l’affichage est réalisé. Seule la modification entraîne une nouvelle consommation d’énergie.

Dans cet article vous apprendrez à gérer un module EPA20-A depuis un Arduino. Avec une résolution de 172×72 pixels et une alimentation de 3,3v ce module pourra servir pour des affichages plutôt fixes, lisibles sans problème en plein soleil.

Dans ce numéro vous trouverez aussi une page sur MQTT et un article sur les convertisseurs A/N de type sigma-delta.

Nantes : Conférence Raspberry Pi, visite des Éditions ENI et… tourisme

conference_250pxA l’invitation des Éditions ENI et dans le cadre de la Nantes Digital Week, j’ai animé une conférence sur le Raspberry Pi lundi 19 septembre.
J’ai ensuite visité les Editions ENI pour découvrir les étapes de fabrication d’un livre d’informatique, depuis la mise en forme en PAO jusqu’à l’expédition.
Enfin parce que j’ai résidé à Guérande pendant ce week-end nantais, je vous propose quelques images de ce séjour qui se voulait également touristique 🙂 .

La conférence sur le Raspberry Pi

Des images de la conférence étaient envoyées en temps réel sur le compte twitter des Éditions ENI, je vous propose ces images ainsi que d’autres, réalisées lors de la conférence sous forme d’une galerie à parcourir…

La conférence était annoncée depuis plusieurs semaines sur Facebook Descriptif de l'événement sur Facebook Dans le Hub Creatic, la salle est indiquée par un écran couleur framboise :) La salle est encore vide... 40 chaises et un vidéo projecteur pendu au plafond... Une infographie sympa et humoristique présente le Raspberry Pi 3 en chiffres Les choses sérieuses commencent ! Préparation du diaporama pour la conférence Les premiers participants sont arrivés. Une première occasion de faire connaissance. La salle se remplit petit à petit Finalement pratiquement toutes les places sont occupées. Dans le fond de la salle de la documentation, des autocollants ENI, Kubii et... framboise314 ainsi que quelques boissons et gâteaux pour accueillir les participants :) Antoine commence par une présentation d'ENI, organisateur de la conférence Et c'est parti, on commence par le programme de cette conférence. Présentation du matériel conference_07 Le Raspberry Pi 3, un poids plume ;) Le port Ethernet... Un tour sur le GPIO et ses possibilités Une des applications évoquées, Domadoo et Jeedom utilisés par l'Education Nationale pour la formation à la domotique On retrouve aussi la framboise et Scratch pendant les TAPS (temps d'activités périscolaire)

A la fin de la conférence, deux personnes qui avaient déposé un papier portant leur nom dans une corbeille ont gagné mon livre (dédicacé) pour l’un et un kit de démarrage Raspberry Pi pour l’autre 🙂 . Élaboré par Kubii, spécialiste du Raspberry Pi, ce Kit contient la carte Raspberry Pi 3 Modèle B 1Go avec WIFI et BLUETOOTH intégré, le nouveau boîtier officiel de la fondation, une carte NOOBS micro SD 16Go et une alimentation 5V 2,5A.

Merci à tous ceux qui se sont déplacés pour assister à cette conférence.

Visite des Editions ENI

Le voyage à Nantes était l’occasion de visiter les Éditions ENI et de rencontrer les personnes avec lesquelles je suis en relation pour l’édition de mes livres depuis plusieurs années, sans les avoir jamais rencontrées.

Je vous invite à une visite d’ENI, de nouveau sous forme d’une galerie d’images…

On vient de se garer sur le parking :) ENI est réparti sur plusieurs bâtiments. Les Editions sont plus loin.. Ah cette fois on y est Dans le fond c'est la machine qui imprime les livres... Elle produit des livres par 4 exemplaires comme ceux qu'on peut voir au premier plan. Les livres avant massicotage et reliure Ah ici c'est un livre pour Editiones ENI, la version espagnle d'ENI La machine chargée de relier les ouvrages. Après un rainurage des feuilles, la couverture est encollée et les pages collées sur la couverture. Toutes ces opérations sont automatiques. Un opérateur alimente la machine et surveille son bon fonctionnement. Une fois collés, les livres sont empilés pour le stockage. Le temps de séchage complet de la colle est de 24 heures pendant lesquelles le livre ne sera pas ouvert. Des couvertures de Linux LCP1 en attente d'utilisation Ecran de contrôle de la machine à relier Au premier plan mon livre Raspberry Pi 2 en attente d'expédition. Au second plan c'est le livre de Patrice CLEMENT : Python et Raspberry Une belle étagère :-D Des packs Linux LCP en attente d'expédition Le studio d'enregistrement des vidéos n'était pas utilisé... Voici à quoi il ressemble en cours de tournage

J’avais eu quelques retours sur le blog de personnes qui après un usage intensif de leur livre, avaient constaté que des pages pouvaient se décoller. Cela a été corrigé avec la mise en service de la nouvelle machine à relier qui prépare le paquet de feuilles avant encollage en pratiquant des rainures. Cela améliore la tenue de la colle qui a été également remplacée par un produit plus performant qui garantit une bonne tenue dans le temps.

Cette visite a été l’occasion de rencontrer toute l’équipe qui s’occupe des livres informatiques chez ENI. Dans tous les services l’accueil a été de qualité 🙂 .

Voilà, la partie « technique » de cet article s’arrête ici. Je vais vous proposer quelques images de la région de Guérande réalisées à l’occasion de ce séjour Nantais. Vous les regarderez si cela vous intéresse 😉

Visite touristique

cote_sauvageLe séjour en région nantaise a aussi été l’occasion de visiter la région de Guérande :

Guérande - Porte Saint-Michel Pen Bron - La plage Le Croisic depuis Pen Bron Plage de Pen bron Guérande - Marais salants Guérande - Marais salants Guérande - Marais salants Guérande - Marais salants Le Croisic - Batz sur Mer - La Côte Sauvage Le Croisic - Batz sur Mer - La Côte Sauvage Le Croisic - Batz sur Mer - La Côte Sauvage Le Croisic - Batz sur Mer - La Côte Sauvage

Le Micro:bit Comment l’utiliser ?

code-1076533_1280L’utilisation du Micro:bit s’avère en réalité d’une immense simplicité. En fait, il ne suffit que de trois grandes étapes pour réussir

  1. Création du code
  2. Compilation du code
  3. Transfert du code sur le Micro:bit

Et voilà le tour est joué ! Rien de plus simple.

NIVEAU_debutant

Cliquez pour avoir une définition de ces niveaux

Comment utiliser le Micro:bit

La Création du code, comment s’effectue-t-elle ?

Contrairement à un grand nombre de codes, celui-ci ne s’écrit pas sur un logiciel dédié (ex : Notepad++) mais bien sur un navigateur Web ou une application sur smartphone.

L’utilisation sur PC

Rendez-vous à cette adresse et sélectionnez l’éditeur que vous souhaiter parmi la liste suivante : Ici JavaScript >> New Project

microbit_choixcode_600px

  • Code Kingdoms JavaScript

Code Kingdoms est un éditeur JavaScript simple, visuel, intuitif, compréhensible… Il dispose d’une interface dédiée dite Drag and Drop le rendant accessible aux débutants. Disponible également en mode texte.

  • Microsoft Block Editor

Le Microsoft Block Editor est un éditeur également visuel. Technique de glisser-déposer pour placer les blocs de codage.

  • Microsoft Touch Develop

Avec son interface tactile, Touch Develop a été conçu principalement pour les appareils mobiles. Il peut également être utilisé avec un ordinateur disposant d’un clavier et d’une souris.

  • Python

MicroPython est un éditeur entièrement basé sur ligne de commande, parfait pour ceux qui veulent pousser leurs compétences de codage au maximum.

Pour un débutant il serait donc conseillé d’utiliser le JavaScript simple et intuitif. Pour un utilisateur sur tablette le Touch Develop de Microsoft reste préférable mais pour un utilisateur expérimenté qui n’a pas peur de se salir les mains avec du code le Micro Python sera de loin le meilleur et le plus perfectionné.

Notre première création

Ce projet est assez simple même pour une personne qui n’a jamais touché au codage de sa vie. Pour ce faire nous allons utiliser du JavaScript. Mais tout d’abord nous allons voir les principales fonctions, actions, etc. dont nous aurons besoin :

  • draw(Pattern) : permet de dessiner ou de choisir parmi quelques modèles proposés les formes à effectuer sur la matrice LED.
  • wait(milliseconde) : permet de marquer une pause de x milliseconde ;
  • function onStart() : effectue l’action ou les actions au démarrage du micro:bit ;
  • function onShake() : effectue l’action ou les actions lorsqu’on secoue le micro:bit ;
  • function onPressA() : effectue l’action ou les actions lorsqu’on presse le bouton A ;
  • function onPressB() : effectue l’action ou les actions lorsqu’on presse le bouton B ;
  • function onPressAandB() : effectue l’action ou les actions lorsqu’on presse simultanément les boutons A et B ;
  • function onReleaseA() : effectue l’action ou les actions lorsqu’on relâche le bouton A ;
  • function onReleaseB() : effectue l’action ou les actions lorsqu’on relâche le bouton A ;

 Bon maintenant que vous connaissez les principales fonctions nous allons pouvoir passer à la partie pratique !

Pour dessiner une image sur la matrice quand le Micro:bit est sous tension, faites glisser un drawbloc dans la zone de code (à gauche) à l’ intérieur de l’événement onStart. En cas d’erreur, vous pouvez faire glisser le bloc dans la poubelle. Maintenant que le bloc de code est placé au bon endroit il ne reste plus qu’à choisir l’image qui sera affichée sur la matrice, pour cela cliquez sur la flèche à côté de pattern, vous pouvez maintenant choisir une image à afficher, ou même dessiner la vôtre.

microbit_ecranprog_600px

Pour tester votre code, cliquez sur « Exécuter » ou « Run » dans le menu en bas de l’écran. Vous devriez voir votre matrice personnalisé sur le Micro:bit à droite de l’éditeur.

microbit_test

Vous pouvez également tester votre code directement sur le Micro:bit en le compilant ! Pour ce faire, rien de plus simple, cliquez sur le bouton « compiler » ou « compile » dans le menu en bas à gauche de l’écran. Une fenêtre apparaitra puis vous aurez accès au téléchargement de votre fichier au format .hex. Une fois ce dernier téléchargé, copiez le sur votre Micro:bit comme si vous transfériez un fichier vers une clé USB standard. Votre programme devrait se lancer (Remarque : si le programme ne se lance pas, un petit coup de Reset ne fait pas de mal !). Vous pouvez dès à présent retirer l’alimentation via µUSB et brancher la batterie.

Remarques :

Il est possible de mettre plusieurs images à la suite les unes des autres mais il faudra placer un wait entre chaque draw.

Il est également possible de suivre ce tuto mais de remplacer la fonction onStart par une autre fonction.

Exemple de programme réalisable à partir de ce tuto :

function onPressA(  ) {
microbit.draw(Pattern("01010.01010.00000.10001.01110"));
}

function onPressB(  ) {
microbit.draw(Pattern("01010.01010.00000.10001.01110"));
wait(250);
microbit.draw(Pattern("01010.01010.00000.00000.11111"));
wait(250);
microbit.draw(Pattern("01010.01010.00000.01110.10001"));
}

function onShake(  ) {
microbit.draw(Pattern("00000.00001.00010.10100.01000"));
}

function onPressAandB(  ) {
microbit.draw(Pattern("01010.10101.01010.10101.01010"));
}

function onReleaseA(  ) {
microbit.draw(Pattern("01010.11111.11111.01110.00100"));
}

function onReleaseB(  ) {
microbit.draw(Pattern("11111.11111.11111.11111.11111"));</code>
}

Vidéo d’aide

Le Micro:bit Qu’est ce que c’est ?!

microbitLa BBC (British Broadcasting Corporation) et 29 autres partenaires nous l’ont dévoilé le 6 juillet 2015 : le Micro:bit. C’est un ordinateur à carte unique équipé d’un processeur ARM. Il est destiné à être offert aux écoliers britanniques de 11 et 12 ans pour qu’ils se familiarisent avec le codage et la programmation. Déjà plus d’1 million de cartes ont été offertes !

Le Micro:bit

Ce qu’en dit le créateur

La BBC déclare : « Le Micro:bit est un ordinateur de poche que vous pouvez programmer, personnaliser et contrôler afin de rendre concrets vos idées numériques, des jeux et des applications. Mesurant 4 cm par 5 cm, il est conçu pour être amusant et facile à utiliser ; les utilisateurs peuvent créer toutes sortes de choses, que ce soient des jeux, des animations ou des messages défilants aussi bien à l’école, à la maison qu’en déplacement. Tout ce dont vous avez besoin est de l’imagination et de la créativité. Le BBC Micro:bit est entièrement programmable. Cela signifie que chacune de ses diodes électroluminescentes peut être programmée individuellement comme peuvent également l’être les boutons, les entrées et sorties, l’accéléromètre, le magnétomètre et la connexion Bluetooth. »

Programmer le Micro:bit

Le Micro:bit se programme de façon simple dans un environnement d’édition simple via un site Web. Les langages utilisés par les éditeurs sont : Le javaScript, Microsoft Block, Microsoft Touch Develop et Python.

L’utilisateur crée et écrit le programme sur l’éditeur de son choix. Il l’envoi à un serveur distant qui se chargera de le compiler pour être ensuite téléchargeable par l’utilisateur et transféré sur le Micro:bit. Point fort de cette innovation, la programmation via Android et IOS par Bluetooth.

Les principaux composants :

  • Microcontrôleur Nordic nRF51822
  • Processeur Cortex ARM-M0 (architecture ARMv6-M) RISC 32-bits à 16 MHz
  • Mémoire RAM : 256kB flash
  • Mémoire statique : 16kB
  • Connectique bluetooth 4.0 basse énergie/2.4 GHz maître/esclave ;
  • Un connecteur pour piles ;
  • Un porte-piles (2 LR03/AAA) ;
  • Une prise femelle micro-USB (permet l’alimentation du Micro:bit ainsi que le transfert des codes);
  • Un bouton de ré-initialisation, libellé « R » pour « Reset » ;
  • Une LED jaune du système ;
  • Deux boutons programmables, libellés « A » et « B » sur la carte ;
  • Une matrice carrée de 25 LED (5 x 5) rouges programmables pouvant servir d’affichage, notamment pour des motifs animés, du texte alphanumérique déroulant ;
  • Un capteur de mouvement 3D Freescale MMA8652 via le bus I2C ;
  • Un magnétomètre 3D Freescale MAG3110 via le bus I2C ;
  • 5 ports d’entrée-sortie en forme d’anneau. Chacune des 5 E/S est programmable, pour être traitée soit en analogique, soit en numérique. Les anneaux sont compatibles avec des prises crocodile ou des fiches banane 4mm :
  • 2 ports : Puissance référencé « PWR » & masse référencé « GND » fournissant 3 Volts, éventuellement pour alimenter un autre appareil, libellés « 3V » et « GND » sur la carte ;
  • et 3 autres, référencés « Pins » P1 à P3, libellés « 1 », « 2 », « 3 » sur la carte ;
  • Un connecteur latéral à 20 broches, à connexion standard, référencés « Pins » P3 à P22. Ceci permet de connecter à un appareil, comme un Arduino, Galileo, Kano et Raspberry Pi

Source

Wikipedia

I2C, plus de 30 ans et toujours d’actualité.

figureI2C01Episode 1 – Dans le domaine des bus de transmission série (SPI, 1Wire et autres), le bus I2C est certainement le plus connu. Il se décline sous différentes appellations (I2C, SmBus, 2Wire ou TWI) et, sur le fond, ils se ressemblent tous à quelques variantes près (fréquences ou niveaux de tension). Ces variantes existent principalement pour échapper à la licence I2C et de la redevance associée.

NIVEAU_debutant

Introduction

Le bus I2C (Inter Integrated Circuit) a été créé dans le début des années 80 par la société Philips (actuellement I2C est pris en charge par NXP). On trouve des centaines de boîtiers différents avec une interface I2C.
On peut classer ces circuits en trois grandes familles (les applications grands publics, les applications professionnelles et les applications à usages généraux).

Quelques exemples de circuits disponibles dans ces domaines :

  • contrôles de tonalité, contrôles de volume, sélecteurs de sources,

  • convertisseurs A/D, convertisseurs D/A,

  • commandes d’amplificateur, fading, compact disc,

  • synthétiseurs de fréquences, PLL, circuits de FI,

  • décodeurs stéréo, RDS,

  • décodeurs PAL / SECAM / NTSC,

  • circuits de réception TV,

  • générateurs DTMF, générateurs de mélodie,

  • mémoires RAM et E2PROM,

  • expandeurs d’entrées / sorties,

  • commandes d’afficheurs LED, LCD, etc…

  • horloges temps réel,

  • etc…

Pour mener à bien notre expérimentation, il nous fallait des composants I2C et de préférence des circuits faciles à mettre en œuvre. Un petit tour dans l’atelier et dans le tiroir circuits intégrés I2C, il n’y avait que l’embarras du choix. Nous avons retenu les candidats suivants :

– une RAM (Random Access Memory) PCF8570,
– une E2PROM (
Electrically-Erasable Programmable Read-Only Memory) PCF8582,
– un capteur de température DS1621.

Vous pouvez utiliser tout ou partie des composants I2C (cela vous donne 7 possibilités).

Le Bus I2C

Nous allons pas vous présenter le BUS I2C, d’autres l’ont très bien fait. En effet, on trouve sur la toile des centaines de pages sur le sujet et il existe des ouvrages entiers consacrés au bus i2c.
Vous pourrez, par exemple, lire l’article WikiPedia, ou bien, l’article du site de Christian Tavernier.

Nota : Pourquoi le site de CT ?
Car c’est à travers ces articles de la presse électronique que j’aie découvert le monde des micro-processeurs (6800, 6809 et autres 68000 de Motorola). A l’époque le clavier était composé d’une vingtaine de boutons poussoirs et de six afficheurs 7 segments (2 pour les données et 4 pour les adresses) et le reste c’était de l’assembleur. Séquence nostalgie !

La figure ci-dessous représente le synoptique de notre base d’expérimentation.

figureI2C02 Figure 2 : Synoptique

Rappel :
Le bus i2c est un bus de type série, synchrone et half-duplex. Il est composé de trois fils, à savoir :
SDA (Serial Data Line), transmission des données dans les deux sens,
SCL (Serial Clock Line), signal d’horloge pour la synchronisation,
GND (Ground), il faut bien une référence.

Les informations transitent sur un même fil mais jamais en même temps.
Toutes les transmissions (écriture ou lecture) sont initiées par le maître et adressées à un esclave via sont adresse.

C’est un bus lent, à l’origine la fréquence de transmission était fixée à 100 kbits/s (standard mode). Depuis d’autres fréquences de fonctionnement sont apparues 400 kbits/s (fast mode), 1 Mbits/s (fast mode +), 3.4 Mbits/s (high-speed mode) et 5 Mbits/s (Ultra-fast mode). Le mode ultra-fast n’est plus bidirectionnel, le maître ne fait que des écritures.

Configurer le bus I2C

Généralités

En préparant cet article, nous avons consulté nos notes et des sites web pour définir les procédures de configuration du bus i2c. On constate que l’on trouve tout et même parfois n’importe quoi !
Pour clarifier la situation, nous avons utilisé une nouvelle installation de raspbian (2016-05-27-raspbian-jessie.img) sur notre Raspberry Pi et nous avons examiné les différentes étapes de l’installation. Après création de la carte SD, démarrage, paramétrages (extension du fichier système, localisation, fuseau horaire, clavier, région WiFi et accès réseau) et les re-démarrages correspondants, nous avons un système propre et vierge de toutes autres installations et mises à jour.

Si l’on examine les fichiers etc/modules et etc/modprobe.d/raspi-blacklist.conf, nous constatons que le premier contient la ligne :

i2c-dev

Le second est vide (pas d’interdiction de chargement de modules noyau).

En exécutant la commande console :

lsmod

Nous obtenons la liste des modules actifs du noyau :

Module   Size   Used by
...
i2c_dev  5859   0 
...

Le module i2c_dev gère les accès /dev/entries.

On peut obtenir plus d’informations sur le module par la commande :

modinfo i2c_dev

Activation I2C

Mode graphique

Pour activer l’interface i2c, il suffit de faire les opérations suivantes à la souris :

Menu → Préférences → Configuration du Raspberry Pi

Dans la fenêtre affichée, il faut se rendre dans l’onglet Interfaces et cliquer sur le bouton radio «Activé» de la ligne I2C puis sur le bouton Valider.

Pour terminer l’opération, il faut rebooter le Raspberry Pi.

Mode console

Pour activer l’interface i2c, il suffit de saisir dans la console Linux :

sudo raspi-config

Puis il faut sélectionner l’option 9 (Advanced Options) puis A6 (I2C) puis <Oui> et <Ok>. Pour sortir de l’application utilisée <Finish>.

Pour terminer l’opération, il faut rebooter le Raspberry Pi.

Contrôle

Si l’on examine les fichiers etc/modules et etc/modprobe.d/raspi-blacklist.conf, nous constatons que le premier contient la ligne :

i2c-dev

Le second est vide (pas d’interdiction de chargement de modules noyau).
Le contenu des deux fichiers n’a pas changé par rapport à la situation précédente.

En exécutant la commande console :

lsmod

Nous obtenons la liste des modules actifs du noyau :

Module       Size   Used by
...
i2c_bcm2708  4770   0
...
i2c_dev      5859 0 
...

Le module i2c_bcm2708 est le pilote de bas niveau du bus i2c.

On peut obtenir plus d’informations sur le module par la commande :

modinfo i2c_bcm2708

Si l’on regarde les messages du noyau avec la commande :

dmesg | grep i2c

On obtient les informations suivantes :

[ 5.580941] i2c /dev entries driver
[ 9.097842] bcm2708_i2c 20804000.i2c: BSC1 Controller at 0x20804000 (irq 77)
            (baudrate 100000)

On voit que le bus i2c est disponible à la fréquence standard de 100 kbits/s.

Une autre information utile est disponible par la commande :

ls -l /dev/i2c*

On obtient l’information suivante :

crw-rw---- 1 root i2c 89, 1 sept. 2 15:57 /dev/i2c-1

Dans la suite, on se servira du chiffre 1 de /dev/i2c-1 pour l’accès au bus i2c.

Compléments

Vous pouvez ajouter ou retirer des modules du noyau avec les commandes :

sudo modprobe -a [nom_module]
sudo modprobe -r [nom_module]

(a comme add et r comme remove).
Ces modifications restent actives tant que le système n’a pas été redémarré ou éteint.

La liste des modules à charger au démarrage se trouve dans le fichier /etc/modules. Chaque ligne représente un module à charger, sauf les lignes vides ou les lignes précédées par un #.
Attention : les modules sont chargés dans l’ordre dans lequel ils sont listés.

Il existe également une liste de modules que le noyau n’a pas le droit de charger qui sont listés dans le fichier /etc/modprobe.d/blacklist.

Nota :
Si l’on explore, un peu, la liste des fichiers de Linux, on constate que pour activer ou désactiver l’interface i2c, il suffit de modifier le fichier /boot/config.txt.

...
# Uncomment some or all of these to enable the optional hardware interfaces
dtparam=i2c_arm=on
#dtparam=i2s=on
#dtparam=spi=on
...
dtparam=i2c_arm=on   #active l'interface i2c
dtparam=i2c_arm=off  #désactive l'interface i2c

Il faudra rebooter pour que la modification soit prise en compte. Cette procédure est une alternative à la modification via l’interface graphique ou via sudo raspi-config.

On pourra également changer la fréquence du bus i2c en ajoutant dans /boot/config.txt la ligne ci-dessous :

...
# Uncomment some or all of these to enable the optional hardware interfaces
dtparam=i2c_arm=on
dtparam=i2c_baudrate=400000
#dtparam=i2s=on
#dtparam=spi=on
...

Avec cette modification, la fréquence du bus devient 400 kbits/s.

Outils

Pour utiliser notre interface i2c, il nous faut des outils que l’on peut installer par les commandes suivantes :

sudo apt-get update
sudo apt-get install i2c-tools

On a, maintenant, à notre disposition des commandes pour explorer le bus i2c.

i2cdetect

Syntaxe :

i2cdetect
Usage: i2cdetect [-y] [-a] [-q|-r] I2CBUS [FIRST LAST]
       i2cdetect -F I2CBUS
       i2cdetect -l
  I2CBUS is an integer or an I2C bus name
  If provided, FIRST and LAST limit the probing range.

La première commande que nous utiliserons est i2cdetect avec la syntaxe i2cdetect -y 1.

Pour plus de détail sur la commande, vous pouvez consulter la page i2cdetect

pi@raspberrypi:~ $ i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- -- 

La commande n’a pas détecter d’adresses i2c sur le bus, ce qui est normal, car nous n’avons pas implanter de composants pour l’instant. On constate, également, que la commande n’a pas balayé l’ensemble des adresses du bus (0x03 à 0x77).

En effet, la norme i2c prévoit que certaines adresses sont réservées :
0x00 à 0x02 : appel général, CBUS et autres bus
0x78 à 0x7B : adressage sur 10 bits
0x7C à 0x7F : device ID

Nous disposons ainsi de 117 adresses utilisables pour notre bus i2c donc conforme avec notre plage de balayage de i2cdetect..

Nota :
L’adresse 0x03 (utilisation future) devrait également faire partie des adresses réservées.
Les adresses 0x4 à 0x07 sont utilisées par des composants hautes vitesses.

Si l’on veut scruter l’ensemble des adresses, il faudra utiliser la commande i2cdetect -a 1.

pi@raspberrypi:~ $ i2cdetect -a 1
WARNING! This program can confuse your I2C bus, cause data loss and worse!
I will probe file /dev/i2c-1.
I will probe address range 0x00-0x7f.
Continue? [Y/n] 
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 

Avertissement : Certaines options de i2cdetec sont à utiliser avec précautions.

On peut, également, obtenir la liste des bus disponibles par i2cdetect -l

pi@rasp10:~ $ i2cdetect -l
i2c-1 i2c         20804000.i2c                   I2C adapter

Ou, sur les fonctionnalités implémentées par i2cdetect -F 1.

pi@rasp10:~ $ i2cdetect -F 1
Functionalities implemented by /dev/i2c-1:
I2C                              yes
SMBus Quick Command              yes
SMBus Send Byte                  yes
SMBus Receive Byte               yes
SMBus Write Byte                 yes
SMBus Read Byte                  yes
SMBus Write Word                 yes
SMBus Read Word                  yes
SMBus Process Call               yes
SMBus Block Write                yes
SMBus Block Read                 no
SMBus Block Process Call         no
SMBus PEC                        yes
I2C Block Write                  yes
I2C Block Read                   yes

Mais i2cdetect n’est pas la seule commande disponible, elle est venue avec quelques copines. Nous n’utiliserons que les commandes ci-dessous pour nos tests.

i2cdump

Affiche le contenu d’une zone.

Syntaxe :

i2cdump
Usage: i2cdump [-f] [-y] [-r first-last] I2CBUS ADDRESS [MODE [BANK [BANKREG]]]
  I2CBUS is an integer or an I2C bus name
  ADDRESS is an integer (0x03 - 0x77)
  MODE is one of:
    b (byte, default)
    w (word)
    W (word on even register addresses)
    s (SMBus block)
    i (I2C block)
    c (consecutive byte)
    Append p for SMBus PEC

Pour plus de détail sur la commande, vous pouvez consulter la page i2cdump

i2cget

Lecture d’une adresse.

Syntaxe :

i2cget
Usage: i2cget [-f] [-y] I2CBUS CHIP-ADDRESS [DATA-ADDRESS [MODE]]
   I2CBUS is an integer or an I2C bus name
   ADDRESS is an integer (0x03 - 0x77)
   MODE is one of:
     b (read byte data, default)
     w (read word data)
     c (write byte/read byte)
     Append p for SMBus PEC

Pour plus de détail sur la commande, vous pouvez consulter la page i2cget

i2cset

Ecriture à une adresse.

Syntaxe :

i2cset
Usage: i2cset [-f] [-y] [-m MASK] [-r] I2CBUS CHIP-ADDRESS DATA-ADDRESS [VALUE] ... [MODE]
  I2CBUS is an integer or an I2C bus name
  ADDRESS is an integer (0x03 - 0x77)
  MODE is one of:
    c (byte, no value)
    b (byte data, default)
    w (word data)
    i (I2C block data)
    s (SMBus block data)
    Append p for SMBus PEC

Pour plus de détail sur la commande, vous pouvez consulter la page i2cset

Base d’expérimentation

Schéma électronique

figurei2c03Nous avons un schéma un peu plus touffu que les fois précédentes mais rien de bien compliqué.
Toutes les pins SDA et SCL des composants i2c sont reliées à la broche SDA ou SCL de notre Raspberry PI. L’alimentation est également prélevée sur la carte et pour finir toutes les broches gnd sont reliées entre-elles.

Remarque 1 : Les deux résistances de soutirage, entre l’alimentation et les lignes SDA et SCL (ET câblé), nécessaires au fonctionnement du bus ne sont pas prévues sur le schéma car implantées sur la carte Raspberry Pi.

Remarque 2 : Pour éviter d’avoir des phénomènes d’oscillations avec les circuits intégrés numériques, il est préférable de prévoir un condensateur de découplage (100 nF) sur la broche d’alimentation (câblage à faire au plus près du circuit intégré).

Câblage

figurei2c04Pour réaliser notre base d’expérimentation, il nous faut :
– un Raspberry Pi,
– un cobbler avec sa nappe,
– une plaque de prototypage rapide,
– un PCF8570 (RAM),
– un PCF 8582 (E2PROM),
– un DS 1621 (température),
– trois condensateurs 100 nF,
– des fils de liaison mâle/mâle.

Nota : Pour le câblage des adresses des circuits i2c, il faut consulter la documentation technique des composants. Les trois fiches techniques (datasheets) sont jointes dans le zip des sources.

Tests

Il n’y a pas de secret pour exploiter nos composants connectés au bus i2c, il faudra lire et relire des fiches techniques (FT).

Nota :
Il ne faut jamais se contenter de la première page de la datasheet car souvent cela ressemble plus à un publicité, pas toujours très réaliste, qu’à un document technique. Mais c’est juste mon avis !

Composants

DS1621

Le DS1621 est un thermomètre digital et un thermostat permettant des mesures de température dans la plage -55°C et +125°C avec une précision de mesure de 0.5°C (on peut améliorer l’affichage par calcul).
L’alimentation électrique peut se faire dans la plage 2.7V à 5.5V ce qui est dans la plage d’utilisation de notre carte (3.3V).
Les fréquences d’utilisation sont de 100 kHz (standard mode) ou 400 kHz (fast mode) voir FT page 15.
L’adresse sur 7 bits du composant est 1001A2A1A0 soit 0x48 à 0x4F (FT page 8).

Nota :
Pour l’exploitation du composant, on utilise une adresse sur 8 bits sous la forme 1001A2A1A0S (S=0 pour l’écriture ou S=1 pour la lecture).

Information : La fiche technique donne également la procédure et les chronogrammes i2c pour sa mise en œuvre .

PCF8570

Le PCF8570 est une mémoire volatile (RAM) de 256 octets (8 bits).
L’alimentation électrique se fait dans la plage 2.5V et 6.0V.
La fréquence d’utilisation se limite au standard mode, c’est à dire 100 kHz (FT page 10).
L’adresse sur 7 bits du composant est 1010A2A1A0 soit 0x50 à 0x57 (FT page 12).

Information : La fiche technique donne également la procédure et les chronogrammes i2c pour sa mise en œuvre

PCF8582

Le PCF8582 est une mémoire non volatile effaçable et programmable électriquement (EEPROM ou E2PROM) de 256 octets (8 bits).
L’alimentation électrique se fait dans la plage 2.5V et 6.0V.
La fréquence d’utilisation se limite au standard mode, c’est à dire 100 kHz (FT page 11).
L’adresse sur 7 bits du composant est 1010A2A1A0 soit 0x50 à 0x57 (FT page 7).

Avertissement :
Le nombre de cycle écriture / effacement est limité à 1.000.000 de cycle (valeur théorique). Cela peut paraître énorme mais dans une boucle infinie cette limite peut être atteinte très rapidement. Alors attention !

Information :La fiche technique donne également la procédure et les chronogrammes i2c pour sa mise en œuvre.

Remarque : Le PCF8570 et PCF8582 ont la même plage d’adressage

i2cdetect

La commande i2cdetect -y 1 nous donne :

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00: -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- -- 
50: 50 51 -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --

La recherche nous donne trois adresses de composants en hexadécimal 0x48, 0x50 et 0x51. Mais qui est qui ?

Pour le DS1621, nous avons pour A2 = 0 (grd), A1 = 0 et A0 = 0 ce qui nous donne une adresse 0b1001000 = 0x48.
Pour le PCF8570, nous avons pour A2 = 0, A1 = 0 et A0 = 0 ce qui nous donne une adresse 0b1010000 = 0x50.
Pour le PCF8582, nous avons pour A2 = 0, A1 = 0 et A0 = 1 (+3.3V) ce qui nous donne une adresse 0b1010001 = 0x51.

Si l’on fait la même manipulation en fixant la vitesse du bus à 400 kbits/sec, nous obtenons le résultat suivant :

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00: -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- -- 
50: -- 51 -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --

Notre mémoire E2PROM (ad : 0x50) n’est plus détectée. Malgré une vitesse de 400 kbits/s notre RAM est toujours détectée. Par contre, les écritures et les lectures de la RAM s’avèrent être des plus aléatoires.
Pour le capteur de température (DS1621) tout est normal car prévu pour fonctionner à cette vitesse.

i2cdump

La commande i2cdump permet d’afficher le contenu mémoire du composant.

PCF8570

Pour afficher l’ensemble des données de notre RAM, on utilise la commande :

i2cdump -y 1 0x50 b

Le paramètre b signifie que l’affichage se fait sous la forme d’octets.

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 0123456789abcdef
00: 00 00 04 00 06 00 00 00 82 00 40 00 80 00 04 00 ..?.?...?.@.?.?.
10: 80 00 00 04 00 00 02 00 00 00 00 00 00 01 00 01 ?..?..?......?.?
20: 10 88 00 00 00 00 00 00 00 08 42 00 10 00 00 00 ??.......?B.?...
30: 00 09 00 02 00 80 00 04 00 41 00 00 08 00 00 08 .?.?.?.?.A..?..?
40: 00 00 80 00 00 08 00 00 00 00 00 10 00 00 00 80 ..?..?.....?...?
50: 80 02 00 80 02 00 00 02 00 00 20 00 00 10 09 80 ??.??..?.. ..???
60: 20 10 20 00 00 00 00 00 00 00 00 00 80 00 00 01 ? .........?..?
70: 00 00 10 20 10 00 00 8c 00 00 20 01 00 10 00 00 ..? ?..?.. ?.?..
80: 00 04 02 00 00 01 04 00 00 00 01 00 10 00 00 08 .??..??...?.?..?
90: 50 04 00 20 30 00 08 00 00 01 01 00 00 02 00 80 P?. 0.?..??..?.?
a0: 00 00 10 00 10 00 00 04 20 01 02 00 08 00 00 00 ..?.?..? ??.?...
b0: 02 00 00 00 00 00 00 01 00 02 00 00 28 00 00 00 ?......?.?..(...
c0: 40 00 00 00 00 a0 00 00 80 20 00 00 99 00 08 00 @....?..? ..?.?.
d0: 10 20 80 00 02 00 00 00 00 10 40 08 00 00 00 10 ? ?.?....?@?...?
e0: 00 00 00 02 00 80 00 08 00 00 00 08 30 28 00 10 ...?.?.?...?0(.?
f0: 04 00 02 00 22 00 00 80 80 00 00 00 00 20 00 00 ?.?."..??.... ..

A la mise sous tension, le contenu de la RAM est complètement aléatoire.

Pour afficher l’ensemble des données de notre RAM au format word (2 octets), on utilise la commande :

i2cdump -y 1 0x50 w

Le paramètre w signifie que l’affichage se fait sous la forme de word (2 octets).

     0,8  1,9  2,a  3,b  4,c  5,d  6,e  7,f
00: 0000 0400 0004 0600 0006 0000 0000 8200 
08: 0082 4000 0040 8000 0080 0400 0004 8000 
10: 0080 0000 0400 0004 0000 0200 0002 0000 
18: 0000 0000 0000 0000 0100 0001 0100 1001 
20: 8810 0088 0000 0000 0000 0000 0000 0000 
28: 0800 4208 0042 1000 0010 0000 0000 0000 
30: 0900 0009 0200 0002 8000 0080 0400 0004 
38: 4100 0041 0000 0800 0008 0000 0800 0008 
40: 0000 8000 0080 0000 0800 0008 0000 0000 
48: 0000 0000 1000 0010 0000 0000 8000 8080 
50: 0280 0002 8000 0280 0002 0000 0200 0002 
58: 0000 2000 0020 0000 1000 0910 8009 2080 
60: 1020 2010 0020 0000 0000 0000 0000 0000 
68: 0000 0000 0000 8000 0080 0000 0100 0001 
70: 0000 1000 2010 1020 0010 0000 8c00 008c 
78: 0000 2000 0120 0001 1000 0010 0000 0000 
80: 0400 0204 0002 0000 0100 0401 0004 0000 
88: 0000 0100 0001 1000 0010 0000 0800 5008 
90: 0450 0004 2000 3020 0030 0800 0008 0000 
98: 0100 0101 0001 0000 0200 0002 8000 0080 
a0: 0000 1000 0010 1000 0010 0000 0400 2004 
a8: 0120 0201 0002 0800 0008 0000 0000 0200 
b0: 0002 0000 0000 0000 0000 0000 0100 0001 
b8: 0200 0002 0000 2800 0028 0000 0000 4000 
c0: 0040 0000 0000 0000 a000 00a0 0000 8000 
c8: 2080 0020 0000 9900 0099 0800 0008 1000 
d0: 2010 8020 0080 0200 0002 0000 0000 0000 
d8: 1000 4010 0840 0008 0000 0000 1000 0010 
e0: 0000 0000 0200 0002 8000 0080 0800 0008 
e8: 0000 0000 0800 3008 2830 0028 1000 0410 
f0: 0004 0200 0002 2200 0022 0000 8000 8080 
f8: 0080 0000 0000 0000 2000 0020 0000 0000

On peut également afficher une partie du plan mémoire avec la commande :

i2cdump -y -r 0x06-0x2b 1 0x50 b
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 0123456789abcdef
00: 00 00 82 00 40 00 80 00 04 00                   ..?.@.?.?.
10: 80 00 00 04 00 00 02 00 00 00 00 00 00 01 00 01 ?..?..?......?.?
20: 10 88 00 00 00 00 00 00 00 08 42 00             ??.......?B.

PCF8582

Pour afficher l’ensemble des données de notre EEPROM, on utilise la commande :

i2cdump -y 1 0x51 b

Le paramètre b signifie que l’affichage se fait sous la forme d’octets.

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 0123456789abcdef
00: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
10: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
20: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
30: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
40: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
50: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
60: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
70: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
80: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
90: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
a0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
b0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
c0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
d0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
e0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
f0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................

Nota :
Une mémoire EPROM ou EEPROM est considérée comme vierge lorsque tous ces octets sont à 0xff (tous les bits sont à 1).

DS1621

La même commande pour le capteur de température, vous donnera n’importe quoi car elle n’a pas de signification physique.

i2cset

La commande i2cset permet d’écrire une donnée vers le composant.

PCF8570

Pour écrire une données (octet) 0x46 (caractère F en ascii) à l’adresse mémoire 0x00 du composant 0x50, on utilise la commande :

i2cset -y 1 0x50 0x00 0x46 b

On peut vérifier le résultat avec de l’écriture avec la commande :

i2cdump -y -r 0x00-0x0f 1 0x50 b

Affichage de la plage 0x00 à 0x0f de notre RAM.

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 0123456789abcdef
00: 46 00 04 00 06 00 00 00 82 00 40 00 80 00 04 00 F.?.?...?.@.?.?.

On retrouve bien notre F dans le dump dans les colonnes de droite.

On peut utiliser d’autres bases de numérotation :

i2cset -y 1 0x50 0x01 0162 b

Ecrit en octal à l’adresse 0x01.

i2cset -y 1 0x50 0x02 97 b

Ecrit en décimal à l’adresse 0x02.

De même, il est possible d’écrire plusieurs octets à la suite avec la commande :

i2cset -y 1 0x50 0x03 0x6d 0142 111 0x69 0x73 0x65 0x33 0x31 i

Attention : Il y a un mélange de décimal, d’octal et d’hexadécimal.

Cette commande envoie les octets 0x6d, 0142, 111, 0x69, 0x73, 0x65, 0x33 et 0x31 à partir de l’adresse mémoire 0x03 de la RAM (ad : 0x50). Le caractère i précise que l’on transmet un bloc de données selon le format i2c.
Ce type d’écriture de données est limité à 8 octets.

Une dernière écriture avec la commande :

i2cset -y 1 0x50 0x0b 0x34 b

On peut vérifier le résultat avec i2cdump -y -r 0x00-0x0f 1 0x50 b (affiche la plage 0x00 à 0x0f de notre RAM).

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 0123456789abcdef
00: 46 72 61 6d 62 6f 69 73 65 33 31 34 80 00 04 00 Framboise314?.?.

Avec toutes ces manipulations, nous venons d’écrire Framboise314 (en ascii) dans notre mémoire RAM.

Il est possible d’écrire directement des données sur 2 octets (word au sens i2c) par la commande :

i2cset -y 1 0x50 0x10 0x1680 w
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 0123456789abcdef
00: 46 72 61 6d 62 6f 69 73 65 33 31 34 80 00 04 00 Framboise314?.?.
10: 80 16 00 04 00 00 02 00 00 00 00 00 00 01 00 01 ??.?..?......?.?

On retrouve nos données aux adresses 0x11 et 0x10

Remarque : Si l’on coupe l’alimentation de la RAM toutes les données seront perdues.

Nota :
Vous pouvez stocker en mémoire des valeurs numériques (int, short int ou float) mais il vous faudra décoder la valeur et faire une sauvegarde des différents octets qui composent la valeur. De même, il faudra recomposer les valeurs numériques à partir de ces octets.

PCF8582

Il suffit de faire les mêmes opérations pour l’EEPROM que celles de la RAM en changeant l’adresse 0x50 par 0x51.
On aura finalement dans l’EEPROM les données suivantes :

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 0123456789abcdef
00: 46 72 61 6d 62 6f 69 73 65 20 33 31 34 ff ff ff Framboise 314...
10: 80 16 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ??..............

Par contre, une coupure de l’alimentation ne fera pas perdre les informations.

DS1621

Avant d’envoyer des données vers le DS1621 (thermomètre + thermostat), il faut savoir quoi et où ?
La documentation technique viendra de nouveau à notre secours (page 10) et vous trouverez également page 9 les chronogrammes des différentes lectures / écritures correspondant au DS1621.

Les différents registres

Vous trouverez les différents registres avec leurs descriptions page 10 de la documentation. Les commandes dont nous aurons besoin sont les suivantes :

Red Temperature (ad : 0xaa) : Registre à lecture seule. Il contient le résultat de la dernière conversion de température. (utilisé dans le paragraphe suivant)
Access Config (ad : 0xac) : Registre à lecture / écriture. Il définit les conditions de fonctionnement et de contrôle du circuit.
La signification de l’octet à joindre à cette adresse est décrite page 5 de la documentation techniques.
Le seul bit qui nous intéresse est le bit0 ou lsb qui permet la conversion de température en continue ou en coup par coup (0=continue et 1=coup par coup).

Pour nos tests, nous fixerons cet octet de configuration à 0x00.

Read Counter (ad : 0xa8) : Registre à lecture seule. Il lit la valeur de Count_Remain. Cette valeur est utilisée dans le calcul de la température donnant une approximation supérieur au 1/2 degré.
Read Slope (ad : 0xa9) : Registre à lecture seule. Il lit la valeur de Count_Per_C. Cette valeur est utilisée dans le calcul de la température donnant une approximation supérieur au 1/2 degré.
Start Convert T (ad:0xee) : Registre à lecture /écriture. Il déclenche la conversion de la température.

Le temps de conversion de la température est de 750 ms (page 15).

Information : Dans notre application, nous n’utiliserons pas la fonction thermostat.

Commandes

Pour configurer notre thermomètre, il suffit d’envoyer la commande :

i2cset -y 1 0x48 0xac 0x00 b

On écrit 0x00 (mesure en continue) dans le registre 0xac (accès configuration) à l’adresse du composant 0x48.

Pour démarrer les mesure :

i2cset -y 1 0x48 0xee

Nous exploiterons la lecture des données du capteur de température dans le chapitre suivant.

i2cget

La commande i2cget permet de lire une donnée du composant.

DS1621

Comme nous venons de mettre en service notre capteur de température, il ne nous reste plus qu’à lire les données. On obtient la valeur de la température par la commande :

i2cget – y 1 0x48 0xaa w

Un exemple de réponse du DS1621 :

pi@rasp10:~/dev/sagaI2C_01/bash $ i2cget -y 1 0x48 0xaa w
0x8013

A quoi correspondant cette donnée ?
Comme d’habitude nous trouvons la réponse dans la documentation technique page 4. La température est codée sur deux octets. L’octet de poids fort représente la température entière et l’octet de poids faible la température décimale.

0x8013: 0x13 octet poids fort et 0x80 octet poids faible
  Octet poids fort                 Octet poids faible
S  2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰       2-¹ 2-2 2-3 2-4 2-5 2-6 2-7 2-8
0  0  0  1  0  0  1  1         1   0   0   0   0   0   0   0
^
Bit de signe 0 = positif ou 1 = négatif

Température entière  = 2⁴ + 2¹ + 2⁰ = 19°C 
Température décimale = 2-¹ = 0.5°C 
Température lue = 19.5°C

Si S = 1, les bits 2⁶ à 2⁰ de l’octet de poids fort représentent la valeur de la température en complément à 2.
Le complément à 2 correspond au complément à 1 + 1.

Exemple :

0x00ff: 0xff octet poids fort et 0x00 octet poids faible
Octet poids fort = 11111111
Complément à 1   = 00000000
Complément à 2   = 00000000 + 00000001 = 00000001
Soit -1°C

Autres lectures de température :
Température positive

i2cget – y 1 0x48 0xaa w   #température
i2cget – y 1 0x48 0xa8 b   #Count_Remain
i2cget – y 1 0x48 0xa9 b   #Count_Per_C

Résultats des lectures :

0X8012   #Température 18.5°C
0x07     #Count_Remain soit 7 en décimal
0x10     #Count_Per_C sit 16 en décimal

Avec Count_Remain et Count_Per_C, on peut obtenir température calculée plus fine par la formule :

                                                        (Count_Per_C - Count_Remain)
Température calculée = température entière lue - 0.25 + ----------------------------
                                                                Count_Per_C

Soit une température calculée de 18.3125°C. Tous les chiffres inférieures au dixième de degré n’ont pas de signification physique.
Pour ces mesures, nous retiendrons les valeurs suivantes :

Température lue      = 18.5°C
Température calculée = 18.3°C

Température négative

i2cget – y 1 0x48 0xaa w #température
i2cget – y 1 0x48 0xa8 b #Count_Remain
i2cget – y 1 0x48 0xa9 b #Count_Per_C

Résultats des lectures :

0X80e2   #Température -29.5°C
0x01     #Count_Remain soit 1 en décimal
0x10     #Count_Per_C sit 16 en décimal
Température lue      = -29.5°C
Température calculée = -29.3°C

PCF8570

Avec tout ce que l’on a vu précédemment, nous avons oublié nos deux mémoires.
Pour lire un octet dans la RAM, on peut utiliser la commande :

i2cget -y 1 0x50 0x00 b

Ce qui nous donne :

0x46   #F de Framboise314

PCF8582

Pour lire un octet dans l’EEPROM, on peut utiliser la commande :

i2cget -y 1 0x51 0x00 b

Ce qui nous donne :

0x46   #F de Framboise314

Commentaire

Avec tout ce que nous venons de voir et si vous disposez de la datasheet du composant, vous pouvez exploiter tous les périphériques i2c existants.

I2C et bash

Pour illustrer tout ce que nous venons de voir, nous vous proposons un script bash qui lit la température du DS1621 toutes les secondes et affiche dans la console la température lue ainsi que la température calculée.

Programme

Pour saisir ce programme, il faut saisir dans la console :

nano i2c01.sh

Cette commande ouvre un fichier teste vide appelé i2c01.sh (pour la sauvegarde faire ctrl-o et pour sortir ctrl-x).
Le contenu du programme et ses commentaires sont représentés ci-dessous.

#!/bin/bash
#Programme lecture capteur de température DS1621 via bus i2c
#nom programme       : i2c01.sh
#logiciel            : bash
#cible               : raspberry Pi
#date de création    : 06/09/2016
#date de mise à jour : 08/09/2016
#version             : 1.0
#auteur              : icarePetibles
#référence           :
#Remarques           : Pour fonctionner, il faut être sous super utilisateur
#                      Il faut rendre le fichier exécutable avec
#                      sudo chmod +x i2c01.sh
#                      exécution : ./i2c01.sh
#
ATTENTE=1                                           #attente entre 2 mesures
                                                    #temps de conversion du DS1621
                                                    #750 ms
LC_NUMERIC=C                                        #définit le séparateur décimal
                                                    #en . au lieu de , car printf
                                                    #utilise les paramètres régionaux
#Procédure de netoyage et sortie
cleanup()                                           #sortie
{
    echo
    echo Fin script                                 #message de fin
    exit                                            #sortie
}

#programme principal
echo Début du script                                #IHM
echo Mesure de température avec capteur DS1621      #IHM
echo ctrl-c pour sortir de la boucle                #IHM
echo

#Setup pin et direction - Cature Control-C SIGHUP SIGKILL
trap "cleanup" SIGHUP SIGINT SIGTERM                #capture SIGNAL et lance la
                                                    #la procédure cleanup
#initialisation DS1621
i2cset -y 1 0x48 0xac 0x00                          #configuration
i2cset -y 1 0x48 0xee                               #démarre la converssion
#traitement des mesures
while true                                          #boucle infinie
    do                                              #faire
#lecure des registres du DS1621
        lecture=`i2cget -y 1 0x48 0xaa w`           #lecture température
        lecture=$(($lecture))                       #pour permettre le calcul
        counter=`i2cget -y 1 0x48 0xa8 b`           #lecture Count_Remain
        counter=$(($counter))                       #pour les calcul
        slope=`i2cget -y 1 0x48 0xa9 b`             #lecture Count_Per_C
        slope=$(($slope))                           #pour le calcul
        corr=$(echo "scale=3; -0.25+($slope/1-$counter/1)/($slope/1)" | bc -l)
                                                    #correction pour le calcul
#octets de poids faible et valeur décimale de la température
        lsb=$((($lecture>>8)/128))                  #extraction bit 2^7
        if [ $lsb -eq 1 ]                           #si bit poids fort = 1
        then
            decimal=0.5                             #partie décimale = 0.5°C
        else
            decimal=0.0                             #partie décimale = 0.0°C
        fi
#octet de poids fort, test >0 ou <0 et valeur entière de la température
        entier=$(($lecture&0x00ff))                 #pour le calcul
        signe=$(($entier/128))                      #extraction bit 2^7
        if [ $signe -eq 1 ]                         #si = 1 alors température <0
        then
            entier=$(($entier^0xff))                #complément à 1 par xor
            entier=$(echo "scale=0; ($entier+1)*(-1)" | bc -l)
                                                    #complément à 2
        fi
        temp_lue=$(echo "scale=1; $entier/1+$decimal/1" | bc -l)
                                                    #calcul température lue
#calcul la valeur de la température à partir de |temp_lue|, counter et slope
        if [ $entier -eq 0 ]                        #température = 0
        then
            temp_cal=0                              #init
            temp_cal=$(($temp_cal))                 #pour le calcul
            temp_cal=${temp_cal/.*}                 #conversion float to int
        else                                        #température <> 0
            if [ $lecture -eq 33023 ]               #cas particulier de 0x80FF
            then                                    #pb de float to int
                temp_cal=0                          #init
                temp_cal=$(($temp_cal))             #pour le calcul
                temp_cal=${temp_cal%.*}             #float to int
            else                                    #tous les autres cas
                temp_cal=${temp_lue%.*}             #valeur entière de temp_lue
            fi
        fi
        temp_cal=$(echo "scale=1; $temp_cal/1+$corr/1" | bc -l)
                                                    #température corrigée par calcul
#affichage des données
        printf "Température lue      : %.1f °C\n" $temp_lue
        printf "Température calculée : %.1f °C\n" $temp_cal
                                                    #nécessaire pour afficher
                                                    #correctement les nbres entre
                                                    #-0.9 et 0.9
        echo                                        #saut de ligne
        sleep $ATTENTE                              #attente
    done                                            #fin do
#Fin du script

Les commentaires du script sont auto-suffisants à la compréhension.

Exécution du programme

Pour exécuter ce script bash, il faut le rendre exécutable avec la commande :

sudo chmod +x i2c01.sh

Et pour l’exécuter :

./i2c01.sh

Pour sortir de la boucle de mesure, il suffit de faire ctrl-c au clavier.

Quelques copies d’écrans

figurei2c05 figurei2c06

Un peu d’habillage

Tous les programmes de la série « saga » affichaient leurs résultats dans la console Linux en mode texte. Ce type d’affichage n’est pas très « sexy », pour remédier à cette situation nous allons mettre en œuvre tput qui est disponible par défaut dans la distribution Raspbian.

tput

Programme

Pour saisir ce programme, il faut saisir dans la console :

nano i2c06.sh

Cette commande ouvre un fichier teste vide appelé i2c06.sh (pour la sauvegarde faire ctrl-o et pour sortir ctrl-x).
Le contenu du programme et ses commentaires sont représentés ci-dessous.

#!/bin/bash
#Programme lecture capteur de température DS1621 via bus i2c
#nom programme       : i2c06.sh
#logiciel            : bash
#cible               : raspberry Pi
#date de création    : 06/09/2016
#date de mise à jour : 08/09/2016
#version             : 1.0
#auteur              : icarePetibles
#référence           :
#Remarques           : Pour fonctionner, il faut être sous super utilisateur
#                      Il faut rendre le fichier exécutable avec
#                      sudo chmod +x i2c06.sh
#                      exécution : ./i2c06.sh
#
echo -e "\e[8;12;40t"                               #fenêtre terminal 12x40
ATTENTE=1                                           #attente entre 2 mesures
                                                    #temps de conversion du DS1621
                                                    #750 ms
#
LC_NUMERIC=C                                        #définit le séparateur décimal
                                                    # en . au lieu de , car printf
                                                    #utilise les paramètres régionaux
#affichage écran
tput smcup                                          #sauve screen
clear                                               #efface écran
tput civis                                          #curseur invisible
tput cup 1 5                                        #curseur lig 1 col 6
tput setaf 4                                        #écrire en bleu
tput bold                                           #écrire en gras
echo "MESURE TEMPERATURE AVEC DS1621"               #IHM
tput sgr0                                           #annule attributs
tput cup 4 5                                        #lig 4 col 5
echo -e "Température lue      : \c"                 #IHM
tput cup 5 5                                        #lig 5 col 5
echo -e "Température calculée : \c"                 #IHM
tput cup 8 10                                       #lig 8 col 10
echo -e "Tapez \c"                                  #IHM
tput setaf 5                                        #écrire en magnenta
tput bold                                           #écrire en gras
echo -e "q\c"                                       #IHM
tput sgr0                                           #annule les attributs
tput setaf 0                                        #écrire en noir
echo -e " pour quitter\c"                           #IHM
#initialisation DS1621
i2cset -y 1 0x48 0xac 0x00                          #configuration
i2cset -y 1 0x48 0xee                               #démarre la converssion
#traitement des mesures
while true                                          #boucle infinie
    do                                              #faire
#lecure des registres du DS1621
        lecture=`i2cget -y 1 0x48 0xaa w`           #lecture température
        lecture=$(($lecture))                       #pour permettre le calcul
        counter=`i2cget -y 1 0x48 0xa8 b`           #lecture Count_Remain
        counter=$(($counter))                       #pour le calcul
        slope=`i2cget -y 1 0x48 0xa9 b`             #lecture Count_Per_C
        slope=$(($slope))                           #pour le calcul
        corr=$(echo "scale=3; -0.25+($slope/1-$counter/1)/($slope/1)" | bc -l)
                                                    #correction pour le calcul
#octets de poids faible et valeur décimale de la température
        lsb=$((($lecture>>8)/128))                  #pour le calcul
        if [ $lsb -eq 1 ]                           #si bit poids fort = 1
        then
            decimal=0.5                             #partie décimale = 0.5°C
        else
            decimal=0.0                             #partie décimale = 0.0°C
        fi
#octet de poids fort, test >0 ou <0 et valeur entière de la température
        entier=$(($lecture&0x00ff))                 #pour le calcul
        signe=$(($entier/128))                      #extraction bit 2^7
        if [ $signe -eq 1 ]                         #si = 1 alors température <0
        then
            entier=$(($entier^0xff))                #complément à 1 par xor
            entier=$(echo "scale=0; ($entier+1)*(-1)" | bc -l)
                                                    #complément à 2
        fi
        temp_lue=$(echo "scale=1; $entier/1+$decimal/1" | bc -l)
                                                    #calcul température lue
#calcul la valeur de la température à partir de |temp_lue|, counter et slope
        if [ $entier -eq 0 ]                        #température = 0
        then
            temp_cal=0                              #init
            temp_cal=$(($trmp_cal))                 #pour le calcul
            temp_cal=${temp_cal/.*}                 #conversion float to int
        else                                        #température <> 0
            if [ $lecture -eq 33023 ]               #cas particulier de 0x80FF
            then                                    #pb de float to int
                temp_cal=0                          #init
                temp_cal=$(($temp_cal))             #pour le calcul
                temp_cal=${temp_cal%.*}             #float to int
            else                                    #tous les autres cas
                temp_cal=${temp_lue%.*}             #valeur entière de temp_lue
            fi
        fi
        temp_cal=$(echo "scale=1; $temp_cal/1+$corr/1" | bc -l)
                                                    #température corrigée par calcul
        tput cup 4 28                               #lig 4 col 28
        tput setaf 1                                #écrire en rouge
        tput bold                                   #gras
        printf '%.1f' $temp_lue                     #affiche temp_lue avec format
                                                    #nécessaire pour afficher
                                                    #correctement les nbres entre
                                                    #-0.9 et 0.9
        tput sgr0                                   #annule attributs
        tput el                                     #efface jusqu'à la fin de ligne
        tput cup 4 33                               #curseur lig 4 col 33
        echo -e " °C\c"                             #IHM
        tput cup 5 28                               #lig 5 col 28
        tput setab 7                                #fond blanc
        printf "%.1f" $temp_cal                     #affiche temp_cal avec format
        tput sgr0                                   #annule attributs
        tput el                                     #efface jusqu'à la fin de ligne
        tput cup 5 33                               #curseur lig 5 col 33
        echo -e " °C\c"                             #IHM
        tput cup 8 0                                #curseur lig 8 col 0
        read -n 1 -t $ATTENTE -s saisie             #saisie clavier 1 carc, time out
#             ^    ^           ^                     et non visible
#             |    |           n'affiche pas le caractère saisie
#             |    time out en cas de non saisie, utiliser pour l'attente entre
#             |    2 mesures du DS1621
#             saisie 1 caractère
        if [ "$saisie" = "q" ]                      #si q
        then
            break                                   #sortie boucle infinie
        fi
    done                                            #fin do
echo
tput cnorm                                          #curseur visible
tput rmcup                                          #restaure screen
echo -e "\e[8;25;90t"                               #taille fenêtre 25x90
                                                    #à adapter à votre taille de
                                                    #fenêtre terminal console
echo                                                #saut de ligne
#Fin du script

Le programme de lecture et de calcul est le même que dans l’exemple précédent, les modifications portent uniquement sur l’affichage.

Exécution

Pour exécuter ce script bash, il faut le rendre exécutable avec la commande :

sudo chmod +x i2c06.sh

Et pour l’exécuter :

./i2c06.sh

Pour sortir de la boucle de mesure, il suffit de faire q au clavier.

Quelques copies d’écrans

figurei2c07 figurei2c08

Ne juger pas le côté design des fenêtres, mais elles montrent juste quelques possibilités de gestion semi-graphique de tput. Pour plus d’informations sur le programme tput, une recherche sur la toile avec votre butineur favori vous fournira toutes les options possibles.

tput et banner

Une autre possibilité d’affichage de nos résultats de mesure peut se faire par l’utilisation du logiciel banner. Banner affiche le texte passé en paramètre sous forme de bannière.
Le logiciel banner n’est pas présent dans la distribution Raspbian. Dans cette distribution, il s’appelle sysvbanner et pour l’installer il faut faire :

sudo apt-get update
sudo apt-get install sysvbanner

Programme

Pour saisir ce programme, il faut saisir dans la console :

nano i2c08.sh

Cette commande ouvre un fichier teste vide appelé i2c08.sh (pour la sauvegarde faire ctrl-o et pour sortir ctrl-x).
Le contenu du programme et ses commentaires sont représentés ci-dessous.

#!/bin/bash
#Programme lecture capteur de température DS1621 via bus i2c
#nom programme       : i2c08.sh
#logiciel            : bash
#cible               : raspberry Pi
#date de création    : 06/09/2016
#date de mise à jour : 08/09/2016
#version             : 1.0
#auteur              : icarePetibles
#référence           :
#Remarques           : Pour fonctionner, il faut être sous super utilisateur
#                      Il faut rendre le fichier exécutable avec
#                      sudo chmod +x i2c08.sh
#                      exécution : ./i2c08.sh
#
echo -e "\e[8;25;90t"                               #taille écran 25x90
ATTENTE=10                                          #attente entre 2 mesures
                                                    #temps de conversion du DS1621
                                                    #750 ms
LC_NUMERIC=C                                        #définit le séparateur décimal
                                                    #en . au lieu de , car printf
                                                    #utilise les paramètres régionaux
mesure(){                                           #lecture data DS1621
#lecure des registres du DS1621
        lecture=`i2cget -y 1 0x48 0xaa w`           #lecture température
        lecture=$(($lecture))                       #pour permettre le calcul
        counter=`i2cget -y 1 0x48 0xa8 b`           #lecture Count_Remain
        counter=$(($counter))                       #pour les calcul
        slope=`i2cget -y 1 0x48 0xa9 b`             #lecture Count_Per_C
        slope=$(($slope))                           #pour le calcul
        corr=$(echo "scale=3; -0.25+($slope/1-$counter/1)/($slope/1)" | bc -l)
                                                    #correction pour le calcul
#octets de poids faible et valeur décimale de la température
        lsb=$((($lecture>>8)/128))                  #extraction bit 2^7
        if [ $lsb -eq 1 ]                           #si bit poids fort = 1
        then
            decimal=0.5                             #partie décimale = 0.5°C
        else
            decimal=0.0                             #partie décimale = 0.0°C
        fi
#octet de poids fort, test >0 ou <0 et valeur entière de la température
        entier=$(($lecture&0x00ff))                 #pour le calcul
        signe=$(($entier/128))                      #extraction bit 2^7
        if [ $signe -eq 1 ]                         #si = 1 alors température <0
        then
            entier=$(($entier^0xff))                #complément à 1 par xor
            entier=$(echo "scale=0; ($entier+1)*(-1)" | bc -l)
                                                    #complément à 2
        fi
        temp_lue=$(echo "scale=1; $entier/1+$decimal/1" | bc -l)
                                                    #calcul température lue
#calcul la valeur de la température à partir de |temp_lue|, counter et slope
        if [ $entier -eq 0 ]                        #température = 0
        then
            temp_cal=0                              #init
            temp_cal=$(($temp_cal))                 #pour le calcul
            temp_cal=${temp_cal/.*}                 #conversion float to int
        else                                        #température <> 0
            if [ $lecture -eq 33023 ]               #cas particulier de 0x80FF
            then                                    #pb de float to int
                temp_cal=0                          #init
                temp_cal=$(($temp_cal))             #pour le calcul
                temp_cal=${temp_cal%.*}             #float to int
            else                                    #tous les autres cas
                temp_cal=${temp_lue%.*}             #valeur entière de temp_lue
            fi
        fi
        temp_cal=$(echo "scale=1; $temp_cal/1+$corr/1" | bc -l)
                                                    #température corrigée par calcul
}

BG_BLUE="$(tput setab 4)"               #commande couleur arrière plan
FG_WHITE="$(tput setaf 7)"              #commande couleur écriture

#lit la taille de la fenêtre terminal
terminal_size(){
    terminal_cols="$(tput cols)"        #nbre col fenêtre terminal
    terminal_rows="$(tput lines)"       #nbre lig fenêtre terminal
}

#calcul la taille de la bannière (banner)
banner_size(){
    banner_cols=0                       #initialisation
    banner rows=0                       #initialisation
    while read
    do
        [[ ${#REPLY} -gt $banner_cols ]] && banner_cols=${#REPLY}
#               ^     ^                      REPLY = contenu de read si l'on
#               |     >(supérieur)           affecte pas la valeur saisie à une
#               nbre de caractères de REPLY  variable
        ((++banner_rows))               #incrémente banner_rows
    done < <(banner "100.0^C")          #structure type de la température
#        ^ ^
#        | envoie résultat du processus
#        redirection
}

#affiche la température à l'écran
display_temp(){
    local row=$temp_row                 #variable locale
    while read
    do
        tput cup $row $temp_col         #coordonnées du curseur
        echo -n "$REPLY"                #affiche le contenu de REPLY
#             ^
#             sans retour à la ligne
        ((++row))                       #incrémente row
    done < <(banner "$temp_ban")        #différentes lignes de la température
#        ^ ^
#        | envoie résultat du processus
#        redirection
}

#efface l'écran par remplissage de blancs
clear_screen(){
    tput home                           #curseur position 0, 0 (haut gauche)
    echo -n "$blank_screen"             #rempli l'écran avec des spaces
}
#calcul de la colonne d'affichage
cal_coord(){
    if [[ ${#temp_ban} -eq 7 ]]         #si nbre carac de température = 7
    then
        temp_col=$(($temp_colB))        #valeur pour la structure type
        tput cup $temp_row $temp_col    #position curseur
    elif [[ ${#temp_ban} -eq 6 ]]       #si nbre carac de température = 6
    then
        temp_col=$(($temp_colB + 4))    #correction car < à la tructure de base
        tput cup $temp_row $temp_col    #position curseur
    elif [[ ${#temp_ban} -eq 5 ]]       #si nbre carac de température = 5
    then
        temp_col=$(($temp_colB + 8))    #correction car < à la structure de base
        tput cup $temp_row $temp_col    #position curseur
    fi                                  #ces corrections permettent d'avoir un
}                                       #affichage centré

#sortie de la boucle infinie par ctrl-c
trap 'tput sgr0; tput cnorm; tput rmcup || clear; exit 0' SIGINT
#           ^           ^           ^        ^              ^
#           |           |           |        efface écran   Ctrl-c
#           |           |           restaure contenu écran
#           |           curseur normal
#           désactive tous les attributs

#sauve le contenu de l'écran et rend le curseur invisible
tput smcup; tput civis
#      ^           ^
#      |           curseur invisible
#      sauve contenu écran
terminal_size                           #lit taille fenêtre terminal
banner_size                             #calcul taille banner
temp_row=$(((terminal_rows - banner_rows) / 2))
                                        #centrage pour les lignes
temp_colB=$(((terminal_cols - banner_cols) / 2))
                                        #centrage pour les colonnes
blank_screen=''                         #création variable
for ((i=0; i < (terminal_cols * terminal_rows); ++i))
do
    blank_screen+=" "                   #espace pour remplir l'écran
done

echo -n ${BG_BLUE}${FG_WHITE}           #fixe couleurs avant et arrière plan

#programme principal
#initialisation DS1621
i2cset -y 1 0x48 0xac 0x00                          #configuration
i2cset -y 1 0x48 0xee                               #démarre la converssion
#boucle infinie
while true
    do
        mesure                                      #lit et calcul les températures
        clear_screen                                #efface écran
        tput cup 1 38                               #curseur lig 1 col 38
        echo -n "Capteur DS1621"                    #IHM
        temp_ban=$(printf "%.1f^C" $temp_cal)       #température à afficher en
                                                    #bannière via banner
        cal_coord                                   #position bannière
        display_temp                                #affiche la température
                                                    #calculée en bannière
        tput cup 23 1
        printf "Température mesurée : %.1f°C" $temp_lue
        tput cup 23 69
        echo -n "<ctrl-c pour sortir>"
        sleep $ATTENTE                              #attente
    done                                            #fin do
#Fin du script

Le programme de lecture et de calcul est le même que dans l’exemple précédent mais il est regroupé dans un sous-programme mesure(). Certaines subtilités utilisées dans le script sont commentées dans le programme.

Exécution

Pour exécuter ce script bash, il faut le rendre exécutable avec la commande :

sudo chmod +x i2c08.sh

Et pour l’exécuter :

./i2c08.sh

Pour sortir de la boucle de mesure, il suffit de faire ctrl-c au clavier.

Quelques copies d’écrans

figurei2c09 figurei2c10

Banner n’est pas en mesure d’afficher le signe ° (il n’est pas dans les caractères de base du code ASCII), nous avons utilisé le symbole ^ pour palier à ce petit défaut. Il existe d’autres logiciels similaires à banner mais nous n’avons pas fait de tests avec ceux-ci.

Conclusion

figure13Nous arrivons à la fin de l’épisode 1 de la saga I2C qui portait sur la découverte du bus I2C, son activation ainsi que la mise en œuvre d’un capteur de température, d’une RAM et d’une EEPROM. La mise en forme de l’affichage sous forme semi-graphique nous a permis d’avoir une présentation plus agréable des résultats.
Le prochain épisode portera sur l’utilisation du capteur DS1621 sous une forme similaire mais avec les langages Python et C/C++.

A tous présents et à venir. Salut !

Sources

Vous pouvez télécharger les sources et la documentation :
http://psl.ibidouille.net/Images_forum/raspberryPi/sagaI2C_01.zip

Liens

Bus I2C
Manuel de l’utilisateur i2c

Autres articles de la série saga

Saga Blink – saison 1
Saga Blink – saison 2
Saga Push Button

Nantes Digital Week Conférence Raspberry Pi le 19 septembre 2016

conf20160919_250pxA l’occasion de Nantes Digital Week et à l’invitation des Editions ENI, j’animerai une conférence sur… le Raspberry Pi 😉 (vous aviez deviné ?).
La conférence aura lieu le Lundi 19 septembre 2016 au Hub Créatic de Nantes.
La conférence devrait débuter à 17h, toutefois si l’heure venait à évoluer, vous en seriez informé(e)s ici.

digital_week_transparent2

Du 15 au 25 septembre 2016

Toutes les cultures numériques ont rendez-vous à la troisième édition de la Nantes Digital Week, une semaine portée par l’ensemble des acteurs de l’écosystème numérique nantais rassemblant de multiples manifestations et événements variés.

Conférence Raspberry Pi

Dans le cadre de la Nantes Digital Week j’animerai une conférence sur le Raspberry Pi, sa technologie et ses applications à l’invitation des Editions ENI.

hub-creatic_600px

Hub Creatic – Nantes

Le lieu : le Hub Creatic 6 Rue Rose Dieng-Kuntz, 44300 Nantes. Le Hub Creatic est installé au cœur du parc d’innovations de La Chantrerie à Nantes. Cet immeuble de nouvelle génération accueille des entreprises TIC, en incubateur, pépinière ou hôtel d’entreprises.

La conférence aura lieu le 19 septembre 2016 à partir de 17h (si changement d’heure ce sera annoncé ici).

Ça parle de quoi ?

Après une présentation technique du Raspberry Pi 3 et du Raspberry Pi Zero (bin oui il y a des personnes qui ne savent pas forcément ce que c’est) je présenterai des utilisations du Raspberry Pi dans le monde des geek mais aussi dans l’industrie ou les SSII.

Vous êtes sur Nantes ou sa région ?

Ce sera un plaisir de vous rencontrer et d’échanger à l’occasion de cette visite à Nantes !

L’événement est géré sur https://www.facebook.com/events/1018225298291159/ mais l’inscription n’est pas obligatoire (donc pas besoin d’avoir Facebook ou Twitter). Envoyez simplement un mail (contact@framboise314.fr) pour qu’on puisse estimer le nombre de participants 🙂

Sources

Transformer un Raspberry Pi en hotspot Wi-Fi facilement grâce à un script

Si vous souhaitez configurer un Raspberry Pi en hotspot pour offrir un accès Internet vous avez peut être tenté plusieurs solutions avec plus ou moins de succès dont celle proposée ici même. Pour vous simplifier toute cette configuration, je vous propose un script à exécuter.

WiFI-Hotspot-Raspberry Pi

Combiner les installations et configurations des différents outils pour un portail captif n’est pas forcément facile. Alors quoi de plus simple qu’un script qui une fois configuré va (en théorie) tout faire pour vous.

Ce qui est important à préciser c’est que j’ai fait ce script à partir d’une installation propre de minibian qui est une version « serveur » de Raspbian donc sans de nombreux paquets qui ne nous intéressent pas. N’oubliez pas d’agrandir la partition principale avant de démarrer : lisez cette méthode.

Ensuite installez git puis clonez le projet

apt-get install git
git clone https://github.com/pihomeserver/Pi-Hotspot.git

Il vous reste à exécuter le script

cd Pi-Hotspot
chmod +x pihotspot.sh
./pihotspot.sh

N’oubliez pas que vous pouvez modifier certains paramètres pour personnaliser l’installation comme l’adresse IP du hotspot, le réseau, le SSID ou le mot de passe root de MySQL. Tout se fait dans les premières lignes du script.

A la fin de l’installation, connectez vous à l’adresse indiquée par le script pour accéder à l’interface graphique de Daloradius et créer vos utilisateurs (plus d’information à la fin de cet article)

Pour toutes vos questions, utilisez l’espace dans Git

 

Cet article Transformer un Raspberry Pi en hotspot Wi-Fi facilement grâce à un script est apparu en premier sur Raspberry Pi Home Server.

Interdire l’écran noir de Jessie Lite

noir_250pxS’il y a un truc qui m’agace (pas vous ?) lorsque je travaille m’amuse avec Raspbian Jessie, c’est que systématiquement au bout de 10 minutes l’écran devient noir 🙁
Oui, je sais, vous me direz il fait encore son « papy ronchon » mais quoi ? je suis sur le Raspberry Pi, je vais lire une doc sur le PC, boire une bière un café, et au retour BIM! l’écran est devenu noir…

Supprimer l’Écran noir avec Jessie Lite

NIVEAU_debutant

Cliquez pour avoir une définition de ces niveaux

Oh il y a plein de bonnes raisons pour éteindre l’écran… Diminuer la consommation de l’écran, ne pas abîmer les cristaux liquides à la longue (avant on nous disait que c’était pour ne pas marquer le tube cathodique 🙂 ). Et alors, c’est mon écran, je fais ce que je veux avec et si ça me plait à moi que les cristaux liquides soient abîmés ? D’abord ils n’ont qu’à faire des écrans plus solides.

Ctrl Alt DelEt puis ça me gonfle à chaque fois que je reviens sur le RasPi de devoir appuyer sur la touche CTRL… Ah oui tiens au passage si vous faisiez ESPACE ou ENTRÉE ce sont des touches qui ont une action et selon ce que vous étiez en train de faire avant que cette %$#!@& d’écran passe en veille ça peut avoir une interaction, pas toujours souhaitée. Alors que la touche CTRL rallume l’écran et ne provoque rien, puisque ce n’est pas un caractère 😉

Mais bon, on n’est pas là pour ça

Donc pour calmer la mauvaise habitude de Jessie, voici ce que je vous propose :

Si vous venez de créer votre carte avec win32DiskImager sous Windows, ouvrez le dossier correspondant à votre carte micro SD. Dans ce dossier, ouvrez le fichier cmdline.txt (voir encadré ci-dessous) et ajoutez à la fin de la ligne : consoleblank=0 et… c’est tout. Au prochain redémarrage Jessie laissera l’écran allumé tout le temps que vous le souhaitez.

 

N'utilisez pas n'importe quel éditeur de texte !
Pour éditer cmdline.txt sous Windows, n’utilisez surtout pas un traitement de texte ou le bloc note. Ces programmes modifient ou ajoutent les codes ASCII et votre fichier sera inutilisable sur le Raspberry Pi. Préférez des programmes respectueux des codes 😉 . J’utilise NotePad++ mais chacun fera selon ses habitudes.

Et puis si votre carte micro SD est déjà en fonction sur un Raspberry Pi, passez par nano et ajoutez de même consoleblank=0 à la fin du fichier cmdline.txt.

pi@raspberrypi:~ $ sudo nano /boot/cmdline.txt

Conclusion

Voilà vous savez maintenant comment contrer la fâcheuse habitude qu’à Raspbian Jessie d’éteindre votre écran.

Bon… En fait ça me fait tout drôle de finir un article aussi court 😀 j’ai pas l’habitude…
Du coup je vous propose un petit bonus ? Allez chiche !

Activer Num Lock au démarrage avec Jessie Lite

num_lockDans la même série des trucs qui me font ch…aque fois enrager, il y a le pavé numérique ! Mais pourquoi tant de haine ? Ils ne peuvent pas le mettre systématiquement en route ? Trois fois sur quatre je me fais b…ien avoir ! Je tape une adresse IP et zou le curseur est parti se promener (ou pas).

On va arranger ça. Ouvrez le fichier /etc/kbd/config pour lui apporter une (toute petite) modification.

pi@raspberrypi:~ $ sudo nano /etc/kbd/config

Cherchez les lignes ci-dessous et enlevez le signe dièse # qui est devant LEDS=+num. Au prochain démarrage le pavé numérique de votre clavier sera activé.

# Turn on numlock by default
LEDS=+num

Conclusion 2

Voili voilou… Mais ça me semble toujours un peu… Lite allez je vous en remets une tranche et c’est gratuit ma bonne dame !

T’as pas l’heure ?

Pas que ce soit une obsession, mais j’aime bien savoir l’heure qu’il est. Des fois ça sert quand on doit déclencher une action, vérifier qu’une machine est à l’heure…

Afficher l’heure dans le terminal de Jessie Lite

Pendant que vous êtes en train de modifier le fichier /etc/kbd/config on va lui apporter une autre modification. Ah… vous avez déjà refermé nano, tant pis pour vous, y a plus qu’à le rouvrir. Bah avec la flèche vers le haut ça va tout seul 🙂 sauf… si la flèche est sur le pavé numérique et que vous l’avez activé au démarrage 😀 Faisez gaffe quand même ! (oui je sais…)

Cherchez les lignes ci-dessous et enlevez le signe dièse # qui est devant DO_VCSTIME=yes. Au prochain démarrage l’heure s’affichera dans le coin supérieur droit de l’écran.

# Display a clock in the right upper corner of the console by running vcstime
DO_VCSTIME=yes

horloge_600pxet au prochain démarrage, l’heure s’affiche 🙂

Conclusion 3

Cette fois on dit que c’est fini ! Vous avez ces possibilités à disposition, à vous de voir si elles serviront dans votre cas, ou pas.

Empêcher les messages de s’afficher au démarrage

Bon, on va en rajouter un peu dans cmdline.txt à la demande de David : « Il me reste une petite chose qui m’agace encore, ce sont les lignes de code qui défilent au démarrage du pi, une solution Docteur ? ^^« 

console=tty3   =>  La console utilisée pour la sortie des message devient la console tty3 😉 du coup les messages sont envoyés vers cette console qui n’est pas affichée (c’est tty1 qu’on voit au démarrage). du coup, si vous basculez sur la console 3 (CTRL  ALT  F3) vous verrez, le temps que le login s’affiche, les messages qui ont été envoyés à tty3.

loglevel=3  =>  Supprime les messages non critiques

vt.global_cursor_default=0 =>  Cache le curseur

logo.nologo =>  Cache la ou les framboises affichées au démarrage

Votre cmdline.txt devrait ressembler à ceci :

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty3 loglevel=3 vt.global_cursor_default=0 logo.nologo root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline

Bon… Quand on a des années de Raspi derrière soi, ça fait tout bizarre de ne rien voir sur l’écran quand ça démarre 😀

Si vous voulez vous rassurer faites afficher l’heure dans le coin de l’écran comme ci-dessus et vous verrez déjà l’heure apparaître… ouf ça démarre 🙂