Je n’ai pas pu résister, ce module radar de surface me faisait vraiment trop triper

Au menu, de l’I2C pour le télémètre ultrason SRF02, du ServoBlaster pour le pilotage du servo moteur, du Python pour orchestrer tout ça, et beaucoup de JavaScript et d’HTML 5 (canvas) pour afficher un bel écran radar

Principe de fonctionnement

Un radar c’est quoi ? C’est un truc qui envoi des ondes (sonores, lumineuses, électromagnétiques) et qui attend un retour de cette onde. Si retour il y a, c’est que l’onde a rebondi sur un objet, en mesurant le temps de retour de l’onde, on en déduit à quelle distance se trouve l’objet. En répétant l’opération tout en faisant tourner le radar dans toutes les directions, on peut détecter tous les objets présents aux alentours et les représenter sur un écran

Donc, prenez un capteur à ultrason tel que le SRF02, faites le tourner sur lui même à l’aide d’un servo moteur, et vous avez votre radar

A chaque position d’angle du servo moteur, on note la distance mesurée par le télémètre, on enregistre tout ça dans un registre pour ensuite pouvoir l’afficher. On répète la manip à l’infinie pour avoir un balayage continu

Pour plus d’information sur les télémètres, je vous invite à lire cet article : GPIO – Télémètre à ultrason SRF02

Bien entendu, le temps de réponse et la qualité de mesure des télémètres à ultrason n’étant pas extra-ordinaires, il ne faut pas s’attendre à un haut niveau de précision. Mais, le résultat est, comme vous allez le voir, plus que satisfaisant De plus, il ne faut pas oublier que nous sommes ici pour apprendre et découvrir des principes de fonctionnement. Si votre budget vous le permet, vous pourrez remplacer le télémètre à ultrason par un télémètre laser, et là, vous aurez un radar de surface très précis

Matériel, GPIO et branchements

Au départ, je voulais utiliser le module PCA9685 de chez Adafruit pour piloter le servo moteur, comme dans cet article. Finalement, après avoir testé l’excellente lib ServoBlaster, j’ai décidé de me passer totalement de cette carte et de brancher le servo directement sur le Pi

Au final, j’utilise donc uniquement un télémètre SRF02 et un servo moteur Futaba en les branchant sur le GPIO d’un Pi A+, sans carte intermédiaire

Raspberry Pi A+	Télémètre SRF02	Servo Futaba

Niveau branchement, rien de plus simple, le télémètre se connecte sur les broches I2C du GPIO comme expliqué dans cet article : GPIO – Télémètre à ultrason SRF02

Pour le servo moteur, une seule broche suffit. Nous utiliserons une alimentation séparée pour le servo dont vous pouvez voir le convertisseur de tension sur la droite de la photo ci-dessous.

Pour info, j’utilise le nouvel écran officiel de la fondation Raspberry Pi. Pour le maquettage, c’est vraiment très pratique je trouve

Je ferai un article dédié à cet écran très prochainement

Logiciel, Scripts et affichage

L’architecture logicielle du Pi BOAt n’est pas encore définitive mais le principe général est le suivant :

1. Chaque module est piloté par un script Python dédié
2. Le script Python inscrit ou lit des données dans un registre au format JSON
3. Une page HTML est mise à disposition grâce à un mini serveur web en Python
4. Un script JavaScript lit ou écrit dans le registre et gère l’affichage dans la page web

Note : Pour info, à l’heure où je réalise ce prototype, j’utilise un Raspberry Pi A+ avec une Raspbian Lite Jessie (2015-11-21).

script Python radar.py : gestion du servo et du télémètre à ultrason

Pour piloter le servo moteur, nous utiliserons la lib ServoBlaster qui fonctionne très bien et très simplement

Pour l’installer, rien de plus simple, faites un clone du dépôt GIT suivi d’un make pour compiler les sources :

git clone https://github.com/richardghirst/PiBits
cd ./PiBits/ServoBlaster/user/
sudo make servod

Il convient enseuite d’activer l’I2C pour pouvoir utiliser le télémètre SRF02. Ceci se fait, à présent, très simplement via la commande raspi-config

Ci-dessous, le script python radar.py dont le rôle est de faire aller et venir le servo d’un extrême à l’autre en continu, tout en prenant les mesures de distance avec le télémètre. A chaque position du servo on associe une distance mesurée, et on enregistre le tout dans un fichier radar.json.

Il y a un paramètre set_pas que vous pouvez ajuster en fonction de la finesse des mesures que vous souhaitez réaliser et de la capacité de votre servo moteur. Pour ma part, le servo moteur dont je dispose n’a une course que de 200 degrés environ. Le pas est converti en pourcentage de cet angle. En choisissant un pas de 1, je prendrais donc 100 mesures sur 200 degrés, soit une mesure tous les 2 degrés d’angle.

Bien entendu, plus vous augmentez le nombre de mesures, plus le balayage sera lent. Après quelques essais, je pense qu’il vaut mieux prendre moins de mesures mais avoir un balayage plus rapide. Une mesure tous les 10 degrés d’angle est largement suffisante pour détecter les objets aux alentours et offre un balayage très rapide.

Ceci est d’autant plus vrai avec un télémètre à ultrason dont le cône de détection est relativement large (plus de 30 degré pour le SRF02). Avec un télémètre laser en revanche, il serait plus pertinent d’avoir un balayage plus fin pour avoir des mesures très précises.

#!/usr/bin/python

import RPi.GPIO as GPIO
import smbus, time, os, srf02

radar_data_file = "/home/pi/www/data/radar.json"

data = []
set_pas = 1

fo = open(radar_data_file, "w")
fo.write(str(data));
fo.close()

nb = int((100/set_pas)+1)
for num in range(0,nb):
  data.append(0);

# SRF02

s = srf02.srf02()

# SERVO

os.system("sudo /home/pi/PiBits/ServoBlaster/user/servod")

p_min = 0
p_mid = 50
p_max = 100

p = p_min
pas = set_pas

while True:
  try:
    if p >= p_max:
      pas = -set_pas
    if p <= p_min:
      pas = set_pas
    p = p + pas
    
    os.system("echo 0="+str(p)+"% > /dev/servoblaster")

    #time.sleep (0.1)

    dst = s.getValue()
    idx = int((100-p)/set_pas)

    print(str(p)+' - '+str(idx)+' - '+str(dst))

    data[idx]=dst

    fo = open(radar_data_file, "w")
    fo.write(str(data));
    fo.close()

  except KeyboardInterrupt:
    os.system("echo 0=50% > /dev/servoblaster")
    quit()

En exécutant ce script, vous obtiendrez ce résultat :

script JavaScript et page HTML

C’est là que ça devient réellement fun car on va voir le résultat s’afficher à l’écran

Le principe est relativement simple puisque nous avons une simple page web radar.html qui contient deux canvas. Un pour dessiner le fond du radar et un pour afficher les points correspondant aux objets détectés.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">

    <title>Pi BOAt - Radar</title>
    
    <link rel="stylesheet" type="text/css" href="css/radar.css" />
    
    <script src="//code.jquery.com/jquery-1.12.0.min.js"></script>
    <script src="//code.jquery.com/jquery-migrate-1.2.1.min.js"></script>
    <script src="js/radar.js"></script>

  </head>
  <body>
  
    <div id="radar">
      <canvas id="radar_back" width="500" height="500"></canvas>
      <canvas id="radar_1" width="500" height="500"></canvas>
    </div>

  </body>
</html>

Ajoutons à cela une feuille de style radar.css, très basique, pour positionner et styliser les éléments principaux :

body {
  background-color : #FFF;
}

div#radar {
  position : relative;
  margin : 10px;
  width : 500px;
  height : 500px;
  border : solid 0px #555;
}

div#radar canvas {
  position:absolute;
  left:0px;
  top:0px;
}

canvas#radar_back {
  z-index : 1;
}

canvas#radar_1 {
  z-index : 2;
}

Enfin, le script le plus important, en JavaScript, radar.js.

Quelques explications s’imposent. Dans un premier temps, le script se charge de dessiner le fond du radar dans le premier canvas. Puis, une fonction appelée toutes les 500ms est chargée de lire le registre radar.json, d’en extraire les données et de dessiner les points correspondants sur le deuxième canvas.

Ce script contient quatre paramètres qu’il convient d’ajuster en fonction de vos besoins :

• radar_width : largeur et hauteur en pixel du radar affiché dans la page web
• max_range : distance maximale en centimètre affichable sur le radar (la distance maximale théorique du SRF02 est de 6 mètres, en pratique, 4 mètres soit 400 cm, c’est bien)
• grid_step : pas de la grille radar en centimètre (permet une meilleure lisibilité des distances)
• angle_range : largeur du balayage en degré (200 degrés dans mon cas)

/**********************/
/*     paramètres     */
/**********************/

var radar_width  = 500; // taille du radar en px
var max_range    = 400; // distance max en cm
var grid_step    = 50;  // pas de la grille en cm
var angle_range  = 200; // largeur du balayage en degré

/**********************/

Math.radians = function(degrees) {
  return degrees * Math.PI / 180;
};

var radar_timeout;

var radar_back, radar_back_ctx;
var radar_1, radar_1_ctx;

var radar_radius = radar_width/2; // rayon du radar en px
var range_ratio  = radar_radius/max_range; // ratio px/cm
var start_angle  = -Math.radians((angle_range/2)+90);
var end_angle    = -Math.radians(90-(angle_range/2));

function measureConvert (nb_measure, pos, dst) {
  if(dst > max_range) { dst = max_range; }
  var angle_deg  = -90-(angle_range/2)+Math.round((angle_range/(nb_measure-1))*pos);
  var angle_rad  = Math.radians(angle_deg);
  var dst_px     = Math.round(dst*range_ratio);
  var x          = Math.round(dst_px*Math.cos(angle_rad)+radar_radius);
  var y          = Math.round(dst_px*Math.sin(angle_rad)+radar_radius);
  var coor       = {x:x, y:y, angle:angle_deg}
  return coor;
}

$(function() {
  console.log( "radar ready !" );
  initRadar ();
  drawRadar ();
});

function getRadarData () {
  var data;
  
  $.ajax({
    async : false,
    type: "GET",
    url: 'data/radar.json',
    cache: false,
    dataType: "json",
    success: function (result) {
      data = result;
    }
  });
  
  return data;
}

function initRadar () {
  
  /**********************/
  /*  Radar Background  */
  /**********************/
  
  radar_back = document.getElementById("radar_back");
  radar_back_ctx = radar_back.getContext("2d");
  
  // background
  radar_back_ctx.beginPath();
  radar_back_ctx.arc(250,250,250,0,Math.PI*2,true);
  radar_back_ctx.fillStyle = "#000000";
  radar_back_ctx.fill();
  // center
  radar_back_ctx.fillStyle = "#FFFFFF";
  radar_back_ctx.fillRect(249,249,2,2);
  // grid
  radar_back_ctx.strokeStyle = "#888888";
  radar_back_ctx.lineWidth = 1;
  var grid_radius = grid_step;
  while(grid_radius < max_range) {
    var grid_radius_px = Math.round(grid_radius*range_ratio);
    radar_back_ctx.beginPath();
    radar_back_ctx.arc(250,250,grid_radius_px,start_angle,end_angle,false);
    radar_back_ctx.stroke();
    grid_radius = grid_radius+grid_step;
  }
  
  /**********************/
  /*  Radar Layer 1     */
  /**********************/
  
  radar_1 = document.getElementById("radar_1");
  radar_1_ctx = radar_1.getContext("2d");
  
}

function drawRadar () {
  console.log('drawRadar');
  
  var measures   = getRadarData();
  var nb_measure = measures.length;
  
  radar_1_ctx.clearRect(0, 0, radar_1.width, radar_1.height);

  radar_1_ctx.fillStyle = "#00FF00";
  radar_1_ctx.strokeStyle = "#00FF00";
  radar_1_ctx.lineWidth = 1;
  radar_1_ctx.beginPath();
  for(var i = 0; i < measures.length; i++) {
    var measure_px = Math.round(measures[i]*range_ratio);
    var coor = measureConvert (nb_measure, i, measures[i]);
    radar_1_ctx.fillRect(coor.x-1,coor.y-1,3,3);
    if(i==0) {
      radar_1_ctx.moveTo(coor.x,coor.y);
    }
    else{
      radar_1_ctx.lineTo(coor.x,coor.y);
    }
    //console.log (i+" - dst "+measures[i]+" - dst_px "+measure_px+" - x : "+coor.x+" - y : "+coor.y+" - angle : "+coor.angle);
  }
//  radar_1_ctx.stroke();
  
  radar_timeout = setTimeout("drawRadar()", 500);
}

Pour que la page HTML et le script JavaScript soient accessibles via un navigateur, il convient de les publier grâce à un serveur web (autrement appelé serveur de publication web). Inutile de sortir l’artillerie lourde en installant Apache, nous pouvons mettre en place un serveur web minimaliste grâce une petite commande Python :

python -m SimpleHTTPServer

Et voilà ce que ça donne :

J’ai fais ce test sur une table, sur des distances très courtes (moins de 1 mètre). On distingue bien les trois objets sur l’avant et la gauche du radar. Les points qui apparaissent tout à droite correspondent au dossier d’une chaise qui était contre la table

On observe quelques artefacts inhérents à ce type de télémètre à ultrason. Ce qui confirme l’intuition évoquée plus haut qui dit qu’il vaut mieux avoir un balayage plus rapide quitte à être moins précis

Avec un servo capable de faire un balayage à 360 degrés, ou un petit système de démultiplication, nous pourrions afficher un écran radar complet en modifiant le paramètre angle_range. Encore mieux, avec deux télémètres placés dos à dos sur le servo moteur, on pourrait faire un balayage rapide à 180 degrés tout en ayant une détection à 360 degrés C’est probablement ce que je ferai sur la version finale du Pi BOAt.

Voilà pour ce premier module du Pi BOAt qui expose un principe qui peut être utilisé dans de nombreux autres projets.

Retrouvez la liste de tous les modules du Pi BOAt : Pi BOAt – Description des modules

A très bientôt pour la suite

L’article Pi BOAt – Radar de surface est apparu en premier sur MagdiBlog.

Après l’annonce de ce nouveau projet Pi BOAt – Drone marin fin novembre, entrons aujourd’hui dans le vif du sujet

Le Pi BOAt est composé d’une multitude de modules (moteurs, gouvernails, caméra, radar…). Je ferai un article dédié pour chaque module, ce qui vous permettra d’utiliser les explications faites sur un module pour un autre projet. Je ferai également en sorte que l’ensemble reste fonctionnel même si tous les modules ne sont pas présents. De cette manière, vous pourrez reproduire le Pi BOAt chez vous, en ne sélectionnant que les modules qui vous intéressent

D’autres modules pourrons être ajoutés par la suite sans bouleverser le fonctionnement global du Pi BOAt.

Ci dessous, la liste des modules que je vais implémenter dans le Pi BOAt et qui feront chacun l’objet d’un article dédié. N’hésitez pas à soumettre vos idées et remarques

Moteurs

La propulsion du Pi BOAt sera assurée par deux moteurs DC pilotés par un circuit intégré L293D (pont H). Ce circuit intégré permet de gérer le sens et la vitesse des deux moteurs.

Gouvernails

Les gouvernails seront quand à eux animés par un servo moteur. Nous nous inspirerons du travail réalisé sur les servos moteurs détaillé dans cet article : MagdiBlog – GPIO et servos moteurs

Note : Nous utiliserons deux autres servos moteurs pour le pilotage de la caméra et du radar. Pour faciliter la gestion de plusieurs servos moteurs avec le Pi, nous utiliserons la carte PCA9685 de chez Adafruit.

Caméra

La caméra servira à piloter le Pi BOAt avec un retour d’image en temps réel. Nous pourrions nous limiter à l’utilisation du module Pi caméra fixe, mais nous allons y ajouters deux composants, un stabilisateur mécanique (pour stabiliser l’image) et un servo moteur pour pouvoir orienter la caméra à 360°.

Radar

Sans doute le module le plus fun à réaliser Nous utiliserons le télémètre à ultra-son SRF02, monté sur un servo moteur pour avoir un balayage à 360° et ainsi obtenir une « carte » des obstacles présents autours du bateau. Rien que d’en parler, ça m’éclate

Nous nous inspirerons du travail réalisé sur ce télémètre et détaillé dans cet article : MagdiBlog – GPIO Télémètre ultra-son SRF02

Lire l’article dédié à ce module : Pi BOAt – Radar de surface

Télémétrie

Après moultes réflexions, j’ai décidé que le lien radio se fera par WiFi, tout simplement. Il y a de nombreux pour et contre sur ce choix et je serai ravi d’en discuter avec vous. Pour ma part, le gros avantage du WiFi, c’est qu’on peut y faire passer toutes les infos nécessaires au pilotage du bateau (images temps réels, info de guidage, position, etc…). Le second gros avantage de ce choix est que le bateau pourra être piloté par n’importe quel device équipé d’une puce WiFi (PC portable, tablette, smartphone…).

Enfin, ce module pourra être facilement remplacé par un module 3G/4G si le coeur vous en dit

GPS

Parce qu’il est intéressant de pouvoir suivre l’évolution du bateau sur une carte et puisqu’il sera question de développer des fonctions de retour automatique au port, nous embarquerons un module GPS à bord du Pi BOAt

Nous utiliserons probablement l’excellent module Adafruit Ultimate GPS Breakout.

Gyroscope, accéléromètre et boussole

Ce module nous permettra de voir si le bateau tangue ou chavire pour éventuellement déclencher un système de sécurité (à méditer).

La boussole nous permettra de connaître le cap du bateau ce qui facilitera l’implémentation de la fonction de retour automatique au port.

Nous utiliserons probablement le module Pololu MinIMU-9 qui intègre un gyroscope, un accéléromètre et une boussole.

Température

Non indispensable au pilotage du bateau, la sonde de température pourra servir à faire des relevés de la température de l’eau par exemple.

Nous nous inspirerons du travail réalisé sur les sondes de températures et détaillé dans l’article : MagdiBlog – GPIO sondes de température

Capteur d’eau

Malgré tout le soin apporté à la confection de la coque du bateau, les voies d’eau sont toujours possibles. Pour éviter les catastrophes et ramener rapidement le bateau au port en cas d’infiltration d’eau, nous allons mettre en place un système très simple de détection d’eau.

Alimentation

Nous allons ici gérer l’alimentation des moteurs et servos moteurs ainsi que l’alimentation du Raspberry Pi qui pilotera l’ensemble.

A l’heure actuelle, je pense faire deux circuits d’alimentation différents, un pour les moteurs et un pour le Pi. Je pense également mettre en place un système d’alimentation de secours afin d’éviter de sortir les palmes pour aller chercher le bateau au milieu d’un lac

Pour les moteurs nous utiliserons probablement un petit accu plomb. Pour le Pi, nous utiliserons certainement une batterie Li-Ion 5V. A voir quelle sera la capacité d’emport du bateau en terme de poids.

Pour en savoir plus sur les batteries, rendez vous ici : MagdiBlog – Comment alimenter votre Raspberry Pi avec une batterie

Raspberry Pi

La partie la plus importante du projet, le Raspberry Pi, dont le rôle sera de faire fonctionner tous les autres modules ensembles et piloter le bateau.

Je ne suis pas encore fixer sur certains aspects, j’hésite encore à utiliser un Pi 2 B (le plus performant) pour gérer tous les modules, ou utiliser plusieurs Pi Zero (un pour les moteurs et le gouvernail, un pour les systèmes radar, gps, gyro, température, détecteur d’eau et un Pi A+ pour la caméra et la télémétrie.

Je ferai un test avec un Pi 2 B pour voir si il peut gérer l’ensemble des modules sans saturer.

Coque et structure

Une fois que tous les modules seront opérationnels, j’attaquerai la construction de la coque et de la structure du bateau. Je suis totalement novice dans ce domaine et même si je me documente sur le sujet depuis plusieurs mois maintenant, je lance un appel à l’aide à tous ceux qui peuvent m’aider ou me donner des conseils

Je suis notamment à la recherche de plans de coque, pour un bateau d’environ 1m à 1m20 de long

Pour l’instant, la taille et l’allure générale du Pi BOAt ne sont pas encore définies. Cependant, j’aimerai approcher quelque chose qui ressemble au design des frégates FREMM : https://fr.wikipedia.org/wiki/Classe_Aquitaine

La suite

Dans le prochain article, je détaillerai l’architecture logicielle mise au point pour donner vie au Pi BOAt puis j’attaquerai un par un l’ensemble des modules pré-cités.

N’hésitez pas à soumettre vos idées de modules et à donner votre avis sur les modules existants, leur fonction et leur conception.

Merci à tous et à très bientôt pour la suite

L’article Pi BOAt – description des modules est apparu en premier sur MagdiBlog.

Deux ans après la présentation du projet Pi BOA Drone – Un avion drone autonome longue distance (qui reste d’actualité), force est de constater que les problématiques logistiques et législatives autour d’un tel projet ont largement freiné son avancement.

En effet, outre le fait qu’il est quasiment impossible d’obtenir une autorisation pour faire voler un engin de près de trois mètres d’envergure en toute autonomie, le matériel et les locaux nécessaires à sa construction ne sont, pour le moment, pas à ma portée.

Rassurez vous, le projet n’est pas abandonné, il me faut simplement trouver les bons partenaires et sponsors pour le mener à bien ainsi que de quoi le financer

Un projet intermédiaire

Tout ceci m’amène à vous présenter un nouveau projet, ô combien plus accessible, le Pi BOAt, un drone marin !

Alors oui, hors de question ici de faire un Lille-Metz (quoi que ?!), mais comme vous allez le voir, les problématiques de navigation et de contrôle entre un avion et un bateau sont relativement similaires. Si si !

Sur un bateau comme sur un avion, il faut gérer des moteurs et des ailerons (ou gouvernails), une position, une direction, une vitesse, la télémétrie, etc… La seule différence finalement, outre les questions de flottaison/aéronautique, c’est qu’un bateau navigue dans un plan, en deux dimensions donc, alors qu’un avion évolue dans un espace en trois dimensions. Voyez, c’est tout pareil

De plus, un bateau coûte beaucoup moins cher en crash-test ! Au pire, un bateau, il faudra aller le chercher à la nage, alors qu’un avion ça a tendance à se vautrer lamentablement en éparpillant des morceaux sur cinquante mètres…

Pour finir, personne n’ira m’embêter avec un bateau, la chasse aux sorcières étant focalisée sur les drones volants

Présentation : Pi BOAt, un drone marin

L’objectif principal de ce projet est le même que pour le Pi BOA Drone et l’ensemble des projets présentés sur MagdiBlog : se confronter à différentes problématiques techniques afin d’étendre nos connaissances

L’objectif secondaire de ce projet est de réaliser une plateforme de drone marin qui pourra servir de base pour une multitude de projets.

Je vais découper le projet en lots techniques que je détaillerai dans des articles dédiés au fur et à mesure de mes avancées. De cette manière, nous pourrons étudier les différents sujets un par un et chaque morceau pourra servir indépendamment à d’autres projets.

Voici les lots techniques que j’ai identifié pour le moment :

• gestion des moteurs (PWM)
• contrôle des gouvernails (servos moteurs)
• télémétrie (WiFi ou 433Mhz)
• gestion de la caméra embarquée (module pi caméra avec stabilisateur)
• position GPS
• position dans l’espace (gyroscope, accéléromètre et boussole)
• sonde radar (télémètre à ultra-son)
• sonde température
• architecture logicielle (Python)
• IHM de pilotage (web PHP)
• construction du navire (en bois)

Un beau programme donc, qui fait intervenir une multitude de technologies

La construction du navire (la coque et la structure) sera la dernière étape de ce projet.

Deux valent mieux qu’un !

En m’imaginant piloter mon bateau sur un grand lac, il me vint une idée, ou plutôt une angoisse : comment récupérer mon bateau s’il ne répond plus ou qu’une panne survient au beau milieu du lac ?

La réponse : faire un deuxième bateau, plus simple, plus petit, qui pourra accompagner le premier.

Nous fabriquerons donc deux bateaux, sur le même modèle, l’un pouvant venir au secours de l’autre en cas de problème. J’imagine déjà un petit système d’aimants à l’avant et l’arrière… que dis-je !? A la proue et à la poupe des deux bateaux

A suivre

L’article Pi BOAt – Drone marin est apparu en premier sur MagdiBlog.

Il y a quelques temps j’ai été contacté par Tim, un lecteur de MagdiBlog, pour son projet de bateau piloté par un Raspberry Pi

Après plusieurs échanges de mails, et quelques semaines (mois ?) de travail, Tim est arrivé au bout de son projet :

Son projet, très complet, aborde plusieurs problématiques entre la gestion des moteurs et servos moteurs, le pilotage à distance via WiFi, la capture d’image, etc…

C’est pour moi le parfait exemple de tout ce qu’il est possible de faire avec un Raspberry Pi, en croisant plusieurs idées et principes, dont certains ont été détaillés ici

Tim a trouvé le courage d’expliquer très en détail toute la réalisation de son BateauRaspberry, et je l’en remercie car c’est un gros boulot et que cela nous permettra à tous d’apprendre des choses Voici l’adresse de son blog : http://bateauraspberry.blogspot.fr/

Note : Suite à problème d’hébergement, j’ai proposé à Tim de relayer le contenu complet de son article. Vous pouvez le consulter ici : http://www.magdiblog.fr/divers/bateauraspberry-bateau-pilote-avec-un-pi-par-tim/

Au menu de ce projet :

• L’inventaire détaillé du matériel nécessaire
• La connexion réseau WiFi avec retour d’expérience sur connexion 3G
• Création du point d’accès WiFi sur smartphone
• Commande des servos moteurs et utilisation de ServoBlaster
• Pilotage de la webcam pour récupérer des images en temps réel
• Envoie des images sur serveur distant
• Conception d’une interface de pilotage sur smartphone
• Pilotage d’un projecteur LED pour la vision sous-marine <= j’adore

 

Le tout est illustré de schémas d’explication, de photos et de vidéos. Tim partage également l’intégralité de son code source

Un grand bravo à Tim pour son travail et pour l’encourager à poursuivre

Merci à toi Tim

L’article BateauRaspberry : un bateau entièrement fait main, piloté par un Pi (màj) est apparu en premier sur MagdiBlog.

Dans mon précédent article « transformez votre Raspberry Pi en serveur domotique Z-Wave », je vous présentais le module Razberry de Z-Wave.me. Aujourd’hui, nous allons voir en détail comment utiliser cette carte d’extension pour contrôler l’allumage et l’extinction de lampes.

Module prise de courant On/Off : Everspring AN157-6

Parmi les nombreux modules Z-Wave existants, nous allons ici utiliser un module très basique qui se branche sur une prise de courant 220V standard. Doté d’une simple fonction On/Off, ce module Everspring AN157-6 est disponible presque partout : http://www.amazon.fr/gp/product/B00DMXQRJA/ref=as_li_tl?ie=UTF8&camp=1642&creative=6746&creativeASIN=B00DMXQRJA&linkCode=as2&tag=magdiblog-21&linkId=NY6FEVP5E6JTQIKV

D’une excellente qualité de fabrication et capable de supporter jusqu’à 3500W sur 16A, vous pourrez utiliser ce module pour piloter tous les appareils (ou presque) de votre maison (lampe, petit électroménager, appareil multimédia,…). Sur la face avant, il y a un bouton qui sert d’interrupteur manuel doté d’un témoin lumineux rouge qui s’allume lorsque la prise est en position « On« .

Bien que le boitier semble volumineux, il reste relativement discret comme vous pouvez le constater sur les photos ci-contre et ci-dessous.

A l’heure où j’écris cet article, je dispose de cinq de ces modules : lampe de la cuisine, lampe du bureau, lampe du séjour, lampes autour de la télé, et un pour le sapin de Noël

Razberry et Z-Way

Revenons en au module Razberry. Une fois enfiché sur le port GPIO du Pi, il ne vous reste plus qu’à booter et installer Z-Way, le soft proposé par Z-Wave.me.

Note : Z-Way est encore en béta, son aspect n’est donc pas aussi travaillé que ce dont on a l’habitude de nos jours, et les fonctionnalités restent limitées. Toujours est-il que les manques fonctionnels actuels peuvent être contournés facilement grâce à une API JSON

Vous pouvez acheter le module Razberry directement sur Amazon :

L’installation de Z-Way sur Raspbian se fait très simplement grâce au script mis à disposition sur le site du fabricant :

wget -q -O - razberry.z-wave.me/install | sudo bash

A la fin de l’installation, il suffit de rebooter le Pi. L’interface web de Z-Way est alors disponible directement sur le port TCP/8083 En vous connectant avec votre navigateur web, vous aurez le choix entre quatre interfaces.

Pour continuer, nous choisirons l’interface « Expert » qui est la plus complète (les autres interfaces étant plus des démonstrations, pour montrer le potentiel de Z-Way).

Association des modules

La première chose à faire, est d’associer (ou d’inclure pour coller ay langage Z-Wave ) nos modules « prise de courant » à notre contrôleur Z-Wave Razberry afin de créer un réseau Z-Wave. Pour cela, il suffit de se rendre dans le menu « Network->Network management » et de cliquer sur le bouton « include device« .

A ce moment là, Z-Way est à l’écoute d’un module désirant entrer dans le réseau. Sur les modules Everspring AN157-6, rien de bien compliqué, il suffit de maintenir le bouton appuyé quelques secondes jusqu’à ce que le témoin lumineux clignote (ce qui indique que le module est en mode « inclusion« ). Au besoin, voici le mode d’emploi du module : everspring_an157_doc.pdf

Note : Pour vous familiariser la technologie Z-Wave et son jargon, je vous propose de lire cet article http://domotique-info.fr/technologies-domotique/zwave/

Une fois les modules correctement ajoutés dans le réseau Z-Wave, on peut voir l’état de chacun d’eux, et les tester grâce aux boutons « On/Off » (notez bien les numéros ID des modules, nous en aurons besoin un peu plus tard)Jour ! Nuit ! Jour ! Nuit ! Jour ! Nuit ! Je vous vois rigoler, mais je vous garantis que vous ferez la même chose

Vous en conviendrez, cette interface web, bien que tout à fait fonctionnelle, n’est pas très sexy…

Nous allons maintenant créer notre propre interface web adaptée à un affichage sur smartphone

Prendre le contrôle grâce à l’API web de Z-Way

Je vous conseille de lire cette article très complet sur le sujet : http://www.openremote.org/display/docs/OpenRemote+2.0+How+To+-+Z-Wave+with+Razberry

Maintenant que vous savez tout à propos de cette fameuse API, nous allons créer une petite application web en HTML/PHP5/JavaScript.

Et voilà le résultat final sur mon smartphone

Note : Vous pouvez construire cette l’application web, soit directement sur le Pi qui détient le module Razberry, soit sur n’importe quelle autre machine Pour ma part, l’application web est exécutée sur un serveur tier

La première étape consiste à installer et configurer un serveur web Apache et PHP5. Je vous propose de suivre la procédure décrite dans cette article : PiHomeDashScreen – Installation et configuration

Une fois votre serveur web opérationnel, vous pouvez créer un répertoire « z-way » dans le répertoire par défaut d’Apache « /var/www », et y placer les fichiers décrits ci-après. L’idée est simple, il s’agit d’une simple page web qui représente chaque module par une image en forme d’ampoule (allumée ou éteinte). Lorsqu’on clique sur une ampoule, on envoie une requête AJAX qui enverra à son tour la requête HTTP GET à l’API Z-Way pour répercuter l’ordre donné

index.php

<?php
  header('Content-type: text/html; charset=utf-8');
  require_once('conf.php');
?>

<!DOCTYPE html>
<html>
  <head>
    <title>Z-Way - BOAs</title>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
    <meta http-equiv="Content-Language" content="Fr">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" type="text/css" media="screen" href="style.css">
  </head>
  <body>

    <?php foreach ($devices as $device_name => $device_id) { ?>
      <div onClick="zWave_AN157_set('<?php echo $device_id; ?>');">
        <img id="light_<?php echo $device_id; ?>" src="light_off.png">
        <p><?php echo $device_name; ?></p>
        <input style="width : 50px;" type="hidden" value="" id="status_<?php echo $device_id; ?>">
      </div>
    <?php } ?>

    <div onClick="zWave_AN157_set_all('on');">
      <img id="light_all_on" src="light_on.png">
      <p>All ON</p>
    </div>

    <div onClick="zWave_AN157_set_all('off');">
      <img id="light_all_off" src="light_off.png">
      <p>All OFF</p>
    </div>

    <script type="text/javascript" src="jquery-1.10.2.min.js"></script>
    <script type="text/javascript" src="main.js"></script>
    <script>
      $( document ).ready(function() {
        console.log( "ready!" );
        updateStatus ();
      });
    </script>

  </body>
</html>

 conf.php

<?php

// nom des modules ainsi que leur ID que vous trouverez dans l'interface web z-way

$devices = array(
                      'Cuisine' => 3,
                      'Salon'   => 6,
                      'Télé'    => 5,
                      'Bureau'  => 2,
                      'Sapin'   => 4
                  );

// adresse IP du Pi sur lequel Z-Way est installé

$pi_zway = "1.2.3.4";

?>

ajax.php

<?php

  header('Content-type: text/html; charset=utf-8');
  require_once('conf.php');

  function httpGet ($url) {
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    $return = curl_exec($curl);
    curl_close($curl);
    return $return;
  }

  $cmd        = $_REQUEST['cmd'];
  $val        = $_REQUEST['val'];
  $device_id  = $_REQUEST['device_id'];
  if($val == 'on'){$val = 255;}else {$val = 0;}

  // permet de changer l'état d'un module
  if($cmd == 'set'){
    $url = "http://".$pi_zway.":8083/ZWaveAPI/Run/devices[".$device_id."].instances[0].commandClasses[0x25].Set(".$val.")";
    echo httpGet ($url);
  }

  // permet de récupérer l'état d'un module
  else if($cmd == 'get'){
    $url = "http://".$pi_zway.":8083/ZWaveAPI/Run/devices[".$device_id."].instances[0].commandClasses[37].Get()";
    echo httpGet ($url);
  }

  // permet de modifier l'état de  tous les modules
  else if($cmd == 'set_all'){
    foreach($devices as $device_name => $device_id) {
      $url = "http://".$pi_zway.":8083/ZWaveAPI/Run/devices[".$device_id."].instances[0].commandClasses[0x25].Set(".$val.")";
      echo httpGet ($url);
    }
  }

  // recupère le dernier statut
  else if($cmd == 'status'){
    $url = "http://".$pi_zway.":8083/ZWaveAPI/Data/".time();
    echo httpGet ($url);
  }

  // default
  else{
    return "";
  }

?>

main.js

Note : N’oubliez pas de télécharger la dernière version de jQuery

var status_timeout;

/* Z-Way */

function zWave_AN157_set_all (val) {
  $.ajax({
    async : false,
    type: "POST",
    url: "ajax.php",
    data: "cmd=set_all&val="+val,
    success: function(html){
      zWay_status_all ();
    }
  });
}

function zWave_AN157_set (device_id) {
  var status = $("#status_"+device_id).val();
  if(status == '255'){
    var val = 'off';
  }
  else{
    var val = 'on';
  }
  $.ajax({
    async : false,
    type: "POST",
    url: "ajax.php",
    data: "cmd=set&device_id="+device_id+"&val="+val,
    success: function(html){
      zWave_AN157_get (device_id);
    }
  });
}

function zWave_AN157_get (device_id) {
  $.ajax({
    async : false,
    type: "POST",
    url: "ajax.php",
    data: "cmd=get&device_id="+device_id,
    success: function(html){
      zWay_status (device_id);
    }
  });
}

function zWay_status (device_id) {
  $.ajax({
    async : false,
    dataType: "json",
    type: "POST",
    url: "ajax.php",
    data: "cmd=status",
    success: function(html){
      var updatetime = html['updateTime'];

      if(typeof html['devices.'+device_id+'.instances.0.commandClasses.37.data.level'] != 'undefined'){
        var level      = html['devices.'+device_id+'.instances.0.commandClasses.37.data.level']['value'];
        if(level == '255'){
          $("#light_"+device_id).attr('src', 'light_on.png');
        }
        else{
          $("#light_"+device_id).attr('src', 'light_off.png');
        }
        $("#status_"+device_id).val(level);
      }

      $("#status").html(updatetime);
    }
  });
}

function zWay_status_all () {
  $(".device_status").each(function (index) {
    var ds_id = $(this).attr('id').split("_");
    var d_id  = ds_id[1];
    zWave_AN157_get (d_id);
  });
}

function updateStatus () {
  zWay_status_all ();
  status_timeout = setTimeout("updateStatus()", 10000);
}

style.css

body {
  padding : 20px 5px;
  font-family : Arial, Helvetica;
  font-size : 14px;
  text-align : center;
  background-color : #000;
  color : #EEE;
}

div.dev {
  border : solid 1px #000;
  display : inline-block;
  text-align : center;
  padding : 5px;
  margin : 5px;
}

div.dev:active {
  border : solid 1px rgba(255,255,255,0.3);
}

div.dev:hover {
  cursor : pointer;
}

img.light {
  width : 100px;
  height : 100px;
  border : 0;
}

p.device_name {
  font-weight : bold;
  text-align : center;
}

 Enfin, voici les deux images d’ampoules utilisées :

Avertissement

Le code source ci-dessus est créer dans le cadre d’un exemple simple, il peut et doit être optimisé et sécurisé

Si vous souhaitez avoir accès à cette application web depuis l’extérieur de votre réseau local, je vous conseille fortement de mettre en place un contrôle d’accès afin d’éviter que n’importe qui ne prenne le contrôle de votre maison

Dans un prochain article, je décortiquerai une installation complète et sécurisé à double authentification : certificat client et mot de passe.

Programmer l’allumage et l’extinction des lumières à heure fixe

Il peut être intéressant de programmer l’allumage et l’extinction des lumières (ou tout autre appareil) à heure fixe. Pour cela, rien de plus simple, il suffit de lancer les requêtes HTTP GET à Z-Way en utilisant CRON

Voici ma crontab qui allume les lumières de mon séjour du lundi au vendredi de 7h à 8h, puis de 19h à 1h tous les jours de la semaine

# m h  dom mon dow   command

#########################
#  LIGHTS
#########################

 0  7 * * 1-5    /root/z-way_lights.sh on
 0  0 * * 1-5    /root/z-way_lights.sh off
 0 19 * * *      /root/z-way_lights.sh on
 0  1 * * *      /root/z-way_lights.sh off

Et voici le contenu du script /root/z-way_lights.sh :

#!/bin/bash

devices="2 3 5 6"

if [[ $# -eq 0 ]] ; then
  exit 1;
fi

if [ $1 == "off" ] ; then
  val=0
elif [ $1 == "on" ] ; then
  val=255
else
  exit 1;
fi

for n in $devices ; do
  wget -o ./z-way.api -O ./z-way.api http://127.0.0.1:8083/ZWaveAPI/Run/devices%5B$n%5D.instances%5B0%5D.commandClasses%5B0x25%5D.Set%28$val%29 
done

exit 0;

Tout cela fonctionne très bien depuis maintenant quelques semaines Il me tarde de faire l’acquisition d’autres modules Z-Wave Je pense notamment à des prises avec variateur telles que les Everspring AD142-6, pour allumer la lumière progressivement le matin dans la chambre lorsque le réveil sonne

Dans mon prochain article, je parlerai de vidéo surveillance A suivre…

L’article Contrôle de l’éclairage avec le module Z-Wave Razberry est apparu en premier sur MagdiBlog.

Je vous souhaite à toutes et à tous une excellente nouvelle année

Bonheur, amour, joie, partage et pleine réussite dans tous vos projets

Je profite également de ces voeux pour vous remercier tous pour vos encouragements qui maintiennent ma motivation au top

En 2014, je vais attaquer un nouveau sujet très vaste, toujours avec des Raspberry Pi : la domotique

A très bientôt,

Olivier

Retrospective 2013

• Pi Home Dash Screen : Un dashboard domestique dans votre salon

 

 

 

 

 

• Pi TimeLapse : Un dispositif timelapse autonome pendant 10 jours avec connexion 3G

 

 

 

 

 

 

• Pi Car JukeBox : Un jukebox dans votre voiture, piloté par votre smartphone

 

 

 

 

 

 

• Pi BOA Drone : Un projet de drone avion longue distance avec auto pilote, GPS et connexion 3G

 

 

 

 

 

 

• GPIO : Electronique, capteur de température, télémètre ultrason, accéléromètre/gyroscope, servo moteur…

 

 

 

 

 

 

• Batterie : Tout ce qu’il faut savoir pour faire fonctionner votre Raspberry Pi sur batterie

L’article Bonne année 2014 ! est apparu en premier sur MagdiBlog.

Parmi les capteurs les plus usités on trouve les télémètres : des senseurs capables de mesurer les distances. Plusieurs technologies peuvent être mises en oeuvre pour mesurer les distances par télémétrie. On trouve ainsi des télémètres optiques (utilisant la lumière, comme les télémètres laser, très précis), des radars (utilisant les ondes radio), des sonar (utilisant les ondes sonores), etc…

Le principe est toujours le même : Il s’agit d’envoyer un signal (lumineux, radio ou sonore) et de mesurer en combien de temps ce signal revient à son point d’origine après avoir « rebondit » sur un obstacle. Lorsqu’on connait la vitesse de propagation de la lumière ou des ondes sonores, on peut déterminer à quelle distance se trouve un objet grâce à la formule connue de tous : vitesse = distance / temps, soit distance = vitesse x temps.

Dans cette article nous allons nous intéresser en particulier aux télémètres à ultrason. Nous allons voir quels modèles choisir et comment les utiliser avec nos Raspberry PI

La mesure du temps

Comme vu précédemment, mesurer une distance par télémétrie, consiste à mesurer le « temps » que met un signal pour aller et revenir. La précision du calcul de la distance dépend donc fortement de la précision de la mesure du « temps« .

Prenons un exemple : Un capteur à ultrason émet un signal sonore qui se propage (dans l’air) à une vitesse de 321 m/s, vers un objet se trouvant à 10 mètres. Le temps que va mettre le signal pour aller et revenir est donc de : 2 x 10 (m) / 321 (m/s) = 0,062 (s) = 62 millisecondes

Il s’agit de « temps » très courts, de l’ordre du millième de seconde. Pour les télémètres laser on parles de nanosecondes (un milliardième de seconde), c’est très rapide :).

Dans notre exemple, si on introduit une erreur de l’ordre de 5% dans la mesure du temps, on obtiendra une distance entre 9,5m et 10,5m, soit 1m d’erreur possible pour un objet positionné à 10m (l’erreur augmentant proportionnellement à la distance). Ce qui est énorme, vous en conviendrez Il est donc impératif d’avoir une mesure du « temps » très précise entre l’émission et la réception du signal.

Temps réel et temps partagé

Dans le cas d’un circuit électronique dit « temps réel« , chaque opération ou calcul réalisé se fait dans un lapse de temps contrôlé et bien déterminé. Dans le cas d’un télémètre, cela signifie qu’entre le moment où le circuit envoie le signal, et le moment où il le reçoit, il est possible de mesurer très précisément le temps qui s’est écoulé en additionnant le temps « utilisé » par toutes les opérations réalisées par le circuit pendant ce lapse de temps.

Dans le cas du Raspberry Pi, qui fonctionne sous Linux (Rasbian par exemple) nous sommes sur un système dit « à temps partagé« . En effet, pour que votre Pi puisse exécuter plusieurs programmes en même temps (ou du moins pour que vous en ayez l’impression), le système d’exploitation « alloue » un certain temps processeur à chaque programme. Quelques microsecondes pour votre navigateur Internet, puis quelques microsecondes pour gérer la souris, puis quelques microsecondes pour votre lecteur de musique, puis à nouveaux quelques microsecondes pour votre navigateur Internet… et ainsi de suite… Ces opérations s’enchaînent tellement rapidement que vous avez l’impression que tout fonctionne en même temps, magique

Le problème avec la télémétrie sur un système à « temps partagé« , c’est qu’entre le moment où le système envoie le signal et le moment où il le reçoit, le système d’exploitation peut décider d’allouer des ressources à d’autres programmes. Le système ne traitera la réception du signal de retour, que lorsqu’il aura terminé toutes les opérations qu’il a entrepris de réaliser entre temps. Le problème, c’est que pendant ce temps, l’horloge continue de tourner, ce qui peut fausser la mesure du temps, et par conséquent, le calcul de la distance

Le choix du télémètre à ultrason

Grâce à l’essor des cartes Arduino, Raspberry Pi et autres BeagleBone, on peut trouver de nombreux télémètres à ultrason, permettant avec plus ou moins de précision, de mesurer des distances jusqu’à une dizaine de mètres. On trouve également des télémètres infrarouge qui fonctionnent sur le même principe, mais leur portée et leur précision son généralement moins bonnes. Ils sont généralement utilisés pour détecter objets très proches, voire détecter un contacte avec un objet.

Pour éviter les problèmes de précision des systèmes à « temps partagé » détaillés précédemment, il convient de choisir des modules dotés de circuits intégrés qui réalisent eux même les calculs de distances. Pour pouvoir l’utiliser directement sur votre Raspberry Pi, vous devrez également veillez à ce qu’il utilise un bus ou un protocole supporté par le GPIO du Pi (I2C, SPI, etc,…).

Le télémètre à ultrason SRF02 répond parfaitement à ce cahier des charges et est disponible pour une vingtaine d’Euros sur Amazon :

SRF02

Ce module « autonome » est parfaitement adapté au Rapsberry Pi. Alimenté en 5V il ne consomme que 4mA et il dispose d’un bus I2C. Le SRF02 permet de mesurer des distances de 16cm à 6m avec une précision de l’ordre de 1 à 2 cm. L’ensemble est très petit (24x20x17 mm), et ne nécessite pas de calibration

Voici les spécifications techniques détaillées de ce module : SRF02_Technical_Specification.pdf

Le cône de détection est relativement large ce qui, selon l’usage, peut être un avantage ou un défaut. A noter qu’il existe des télémètres beaucoup plus directifs.

Branchement et configuration du GPIO du Raspberry Pi

Comme pour tous les périphériques I2C, le branchement se fait sur les broches SDA et SCL du GPIO du Pi :

Une fois les branchements effectués, il convient d’activer le support de l’I2C sur le Raspberry Pi. Ceci se fait en deux étapes :

1 – Editez le fichier /etc/modules et ajoutez les deux lignes suivantes :

i2c-bcm2708
i2c-dev

2 – Editez ensuite le fichier /etc/modprobe.d/raspi-blacklist.conf et commentez les deux lignes suivantes (en ajoutant # au début de ces deux lignes) :

# blacklist spi-bcm2708
# blacklist i2c-bcm2708

Pour finir, installez l’outil i2c-tools et redémarrez le Pi :

apt-get install i2c-tools
shutdown -r now

Pour vérifer que la carte est bien reconnue par le Pi, lancez la commande suivante :

i2cdetect -y 1 # pour la révision 2 du Pi

ou

i2cdetect -y 0 # pour la première version du Pi

Vous devriez obtenir ce résultat :

root@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: 70 -- -- -- -- -- -- --

Le module SRF02 est ici détecté à l’adresse 0x70 Si vous utilisez plusieurs périphériques I2C, vous pouvez changer cette adresse en suivant la procédure décrite dans ce document : SRF02_Technical_Specification.pdf

Il ne reste plus qu’à installer les lib Python nécessaires :

apt-get install python-dev python-rpi.gpio python-smbus

Script en Python

Puisque le SRF02 se charge tout seul de prendre les mesures et de réaliser les calculs, le code est élémentaire, il suffit de lire la valeur retournée par le module dans l’unité de notre choix

Note : D’après le document SRF02_Technical_Specification.pdf, vous pouvez directement extraire la valeur en centimètres, en inches ou en microsecondes

Voici donc un petit script en Python, distance_SRF02.py, qui affiche la distance mesurée en centimètres, toutes les secondes :

#!/usr/bin/python

import smbus, time
i2c = smbus.SMBus(1)

adresse = 0x70
mode    = 81      # centimetres

while True:
  try:
    i2c.write_byte_data(adresse, 0, mode) # lance un "ping" en centimetre
    dst = i2c.read_word_data(adresse, 2) / 255 # lit le "mot" de données à partir du registre 2 et divise par 255 pour obtenir un entier (Cf doc technique)
    print(dst)
    time.sleep(1)
  except KeyboardInterrupt:
    quit()

Très simple d’utilisation, ce petit module trouvera sa place dans mon drone PiBOADrone en tant qu’altimètre sol basse altitude

Exemples d’utilisations

• Altimètre sol basse altitude pour drone
• Radar de recul pour voiture OU radar d’avancement pour parking/garage
• Détection d’obstacle pour robot
• Détection de passage/mouvement
• Mesurer la taille des pièces d’une maison ^^

L’article GPIO – Télémètre à ultrason SRF02 est apparu en premier sur MagdiBlog.