Avec l’hiver et Noël qui approchent, l’idée m’est venue de mettre un peu d’ambiance sur le Mini Pi Dash Screen en faisant tomber de la neige en Python avec PyGame. En rajoutant simplement quelques lignes de code, il est très facile en Python de simuler des flocons de neiges tombant et s’amassant en bas de l’écran.

Je me suis inspiré d’un ancien soft que je faisais tourner sur mes machines il y a longtemps, Xsnow.

Pour implémenter ces flocon qui tombe sur l’écran, le principe est simpliste au possible. Il s’agit tout bêtement de créer une liste de points (représentant chacun un flocon de neige), de leur attribuer à une coordonnée en X et Y sur l’écran, et d’incrémenter de quelques pixels leurs position en Y. Procédons.

Commençons par définir les variables clés :

screen_w = 800 # largeur en px de l'écran
screen_h = 480 # hauteur en px de l'écran

snow_floor_h = 13 # hauteur en px de la couche de neige en bas de l'écran
snow_flakes = 100 # nombre de flocons affichés en même temps

On initialise ensuite PyGame :

pygame.init()

pygame.mouse.set_visible(False)
pygame.display.set_caption('Liberty')
size = [screen_w, screen_h]
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
screen.fill((0, 0, 0))
pygame.display.update()

start_time = 0
frame_count = 1
frame_rate = 10 # avec 10 images par secondes on obtient une chute de neige relativement fluide

On créé ensuite le tableau de flocons « snow_list », en leur attribuant à chacun des coordonnées aléatoires volontairement jusqu’à -10 et +10, par rapport à la largeur de l’écran) pour qu’ils apparaissent à peine en dehors de l’écran. En même temps on initialise un autre tableau « snow_floor » dans lequel on viendra placer les flocons qui tombent au moment où ils touchent le sol.

snow_list = []
snow_floor = []

for i in range(snow_flakes):
  x = random.randint(-10, screen_w+10)
  y = random.randint(-10, screen_h+10)
  snow_list.append([x, y])
  snow_floor.append([-10, -10])

Enfin, dans la boucle principale,

while True:

  # on remplit l'écran de noir
  screen.fill((0, 0, 0))

  # on dessine ensuite ce qui constitue la base de la couche de neige en bas de l'écran
  snow_floor_y=screen_h-snow_floor_h
  pygame.draw.rect(screen, WHITE, pygame.Rect(0, snow_floor_y, screen_w, snow_floor_h))
  
  # Ensuite, dessine les flocons un par un et on incrémente leurs coordonnées
  for i in range(len(snow_list)):
    
    # un simple cercle de 2px pour chaque flocons
    pygame.draw.circle(screen, WHITE, snow_list[i], 2)
    
    # les coordonnées en X sont aléatoirement modifiées entre -2 et +2 px pour éviter d'avoir une chute trop verticale.
    # si vous voulez ajouter un effet de vent latéral, vous pouvez par exemple modifier la coordonnées en X de -2 à +4 par exemple.
    snow_list[i][0] += random.randint(-2, 2)

    # les coordonnées en Y sont aléatoirement modifiées de +1 à +4 px pour avoir des vitesses de chute différentes et obtenir un rendu plus réaliste
    snow_list[i][1] += random.randint(1, 4)

    # si un flocon touche le sol, alors réinitialise s'est coordonnées pour qu'il reparte en haut de l'écran
    if snow_list[i][1] >= snow_floor_y:
      # coordonnée en X aléatoire sur toute la largeur de l'écran
      snow_list[i][0] = random.randint(-10, screen_w+10)
      # coordonnée en Y à -10 pour redémarrer à peine plus haut que le bord de l'écran
      snow_list[i][1] = -10
      # on copie les coordonnées du flocon dans la liste des flocons à afficher à la surface du sol
      snow_floor[i][0] = snow_list[i][0]
      snow_floor[i][1] = snow_list[i][1]
    # on dessine ensuite tous les flocon qui sont au sol
    pygame.draw.circle(screen, WHITE, snow_floor[i], 2)  

  frame_count += 1 
  clock.tick(frame_rate)
  pygame.display.flip()

Et voilà Il vous suffit d’implémenter ce morceau de code dans le celui du Mini Pi Dash Screen et le tour est joué !

Perso, j’aime beaucoup le résultat et je suis curieux de voir comment vous allez le tweaker et l’améliorer.

A très vite

L’article De la neige en Python sur votre Pi Mini Screen est apparu en premier sur MagdiBlog.

Quelques années après le Raspberry Pi Home Dash Screen j’ai eu envie d’explorer d’autres manières de réaliser un affichage simple sur de petits écrans. Dans cette article, j’explique pas à pas comment réaliser très simplement un écran d’affichage en utilisant un Raspberry Pi et la lib Python PyGame.

L’écran que vous voyez en photo est géré par un simple script en Python qui peut être adapté selon vos besoins.

Matériel utilisé

Cette fois ci, je n’ai utilisé que des éléments officiellement distribué par la fondation Raspberry Pi.

Pygame

Proposée à l’origine pour créer des jeux vidéos, la lib PyGame vous permet d’afficher très simplement texte, images et autres contenus, sans toutefois nécessiter un gestionnaire de fenêtre. Contrairement au Pi Home Dash screen qui repose sur un ensemble relativement lourd de middleware, l’utilisation de PyGame se suffit à lui même et peut fonctionner directement sur une Raspbian Lite.

Il vous faudra toutefois installer quelques paquets pour Python et Xplanet :

apt-get update
apt-get install python-pygame python-urllib3 xplanet imagemagick

Sur la screenshot ci-dessous, vous voyez plusieurs informations :

• La date et l’heure
• La température
• La terre et la lune

La date et l’heure sont simplement affichée en se basant sur l’heure du système. Inutile ici de chercher quelque chose de compliqué, Python dispose de base de tout ce qu’il faut.

Température

La température est fournis par le site OpenWeatherMap.

Pour utiliser ce service, vous devez créer un compte gratuit ici :

Rendez vous ensuite dans la section API pour récupérer votre clé API.

OpenWeatherMap fournis un paquet d’informations météorologiques disponibles via une API JSON. Pour récupérer ces informations, rien de plus simple en Python :

Vous pouvez choisir la localité qui vous convient, bien entendu. Ce lien vous permettra de trouver la ville la plus proche de chez vous : https://openweathermap.org/find?q=

Xplanet

L’image de la terre et de la lune sont elles générées par Xplanet, vous savez combien j’affectionne ce soft dont je parle en détails ici : Pi Home Dash Screen – Xplanet

Pour simplifier, j’ai créé deux services, un pour la terre et un pour la lune, qui vont chacun générer une nouvelle image à intervalles réguliers. Le script Python se contera ensuite de rafraîchir les images.

Si dessous, les scripts idoines ainsi que les script systemd permettant de lancer ces sous programmes au démarrage du Pi.

xplanet.conf : Le fichier de configuration de Xplanet

[default]

arc_color=white
arc_thickness=1
bump_scale=3
cloud_gamma=1
cloud_ssec=false 
cloud_threshold=90
color={255,255,255}
draw_orbit=false                
grid=false
grid1=6
grid2=15
magnify=1                      
marker_color=red
max_radius_for_label=3 
min_radius_for_label=.01
min_radius_for_markers=40
orbit={-.5,.5,2}
orbit_color={255,255,255}       # color for the orbit
random_origin=true           
random_target=true
shade=30                        # 0 = black, 100 = same as dayside
text_color={255,0,0}            # color for text (markers & body label)
twilight=6                      # blend the day and night images for
                                # pixels within this many degrees of
                                # the terminator 

[sun]
"Sun"
color={255,255,166}
map=/root/img/sunmap.jpg
max_radius_for_label=0
shade=100

[earth]
"Earth"
color={28, 82, 110}
map=/root/img/land_ocean_ice_2048.jpg
night_map=/root/img/night-dark.jpg
cloud_map=/root/xplanet_clouds.jpg
min_radius_for_label=0

[moon]
"Moon"
color={100, 100, 100}
map=/root/img/moonmap2k.jpg

xplanet_earth.sh : pour la planète terre

#!/bin/bash

xplanet -conf /root/xplanet.conf -wait 600 -transpng /root/xplanet_earth.png -body earth -latitude 20 -longitude 10 -geometry 400x400

/etc/systemd/system/xplanetEarth.service

[Unit]
Description=xPlanet
After=network.target
After=syslog.target

[Install]
WantedBy=default.target

[Service]
ExecStart=/root/xplanet_earth.sh
StandardOutput=journal+console
User=root
Group=root
Restart=always

xplanet_moon.sh : pour la lune

#!/bin/bash

xplanet -conf /root/xplanet.conf -transpng /root/xplanet_moon.png -wait 3600 -body moon -geometry 160x160

/etc/systemd/system/xplanetMoon.service

[Unit]
Description=xPlanet
After=network.target
After=syslog.target

[Install]
WantedBy=default.target

[Service]
ExecStart=/root/xplanet_moon.sh
StandardOutput=journal+console
User=root
Group=root
Restart=always

Il vous suffira ensuite d’exécuter ces deux commandes pour lancer ces scripts au démarrage du système.

systemctl enable xplanetEarth.service
systemctl enable xplanetMoon.service

Script Python

Voyons maintenant le contenu du script principal : pi_mini_screen.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

import json
import urllib3
import sys
import threading
import datetime
import time
import pygame
import signal
import random
from pygame.locals import *

###########################

screen_w = 800 # largeur en pixel de l'écran
screen_h = 480 # hauteur en pixel de l'écran

# XXX à remplacer par vos ids
openweathermap_localid = "XXXXX"
openweathermap_appid = "XXXXXXXXXXXXX"

###########################

temp = ''

def getWeather():
  global temp
  while True:
    http = urllib3.PoolManager()
    weather = http.request('GET', 'https://api.openweathermap.org/data/2.5/weather?id='+openweathermap_localid+'&units=metric&appid='+openweathermap_appid)
    weather_json = json.loads(weather.data.decode('UTF-8'))
    temp = str("%.1f" % float(weather_json['main']['temp']))
    time.sleep(60)

thread = threading.Thread(target=getWeather)
thread.daemon = True
thread.start()

def dont_quit(signal, frame):
  print 'Catch signal: {}'.format(signal)

signal.signal(signal.SIGHUP, dont_quit)

pygame.init()

pygame.mouse.set_visible(False)
pygame.display.set_caption('Liberty')
size = [screen_w, screen_h]
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
screen.fill((0, 0, 0))
pygame.display.update()

screen_width = screen.get_width()
screen_height = screen.get_height()
screen_centerx = screen.get_rect().centerx
screen_centery = screen.get_rect().centery

start_time = 0
frame_count = 1000
frame_rate = 20

bg_color = (0, 0, 0)

hour_font = pygame.font.SysFont(None, 150)
hour_color = (190, 190, 190)
date_font = pygame.font.SysFont(None, 80)
date_color = (190, 190, 190)

temp_font = pygame.font.SysFont(None, 100)
temp_color = (190, 190, 190)
degre_font = pygame.font.SysFont(None, 50)

while True:
  for event in pygame.event.get():
    if event.type == pygame.QUIT: 
      pygame.quit()
      sys.exit()

  screen.fill((0, 0, 0))

  # EARTH
  try:
    xplanet_earth = pygame.image.load(('/root/xplanet_earth.png'))
  except pygame.error, message:
    print 'Cannot load image xplanet_earth.png'
    time.sleep(1)
    continue

  xp_earth_rect = xplanet_earth.get_rect()
  xp_earth_rect.centerx = screen_centerx
  xp_earth_rect.centery = screen_centery
  screen.blit(xplanet_earth, xp_earth_rect)

  # MOON

  xplanet_moon = pygame.image.load(('/root/xplanet_moon.png'))
  xp_moon_rect = xplanet_moon.get_rect()
  xp_moon_rect.centerx = screen_width-80
  xp_moon_rect.centery = screen_height-80
  screen.blit(xplanet_moon, xp_moon_rect)

  # DATE

  now = str(time.strftime("%a %d %b"))
  dt = date_font.render(now, 1, date_color, None)
  dt_rect = dt.get_rect()
  dt_rect.x = 0
  dt_rect.y = screen_height-dt.get_height()
  screen.blit(dt, dt_rect)

  # HOUR

  now = str(time.strftime("%H:%M"))
  hour = hour_font.render(now, 1, hour_color, None)
  hour_rect = hour.get_rect()
  hour_rect.x = 0
  hour_rect.y = 0
  screen.blit(hour, hour_rect)

  # TEMP

  d = degre_font.render('°C'.decode('utf-8'), 1, temp_color, None)
  drect = d.get_rect()
  drect.x = screen_width-d.get_width()
  drect.y = 0
  screen.blit(d, drect)

  t = temp_font.render(temp.decode('utf-8'), 1, temp_color, None)
  trect = t.get_rect()
  trect.x = screen_width-t.get_width()-d.get_width()
  trect.y = 0
  screen.blit(t, trect)

  # END

  frame_count += 1 
  clock.tick(frame_rate)
  pygame.display.flip()

pygame.quit()
quit()

Lancer le script au démarrage du système

La manière la plus propre de lancer ce petit script est de laisser le système d’exploitation le gérer comme un service. Sous Raspbian, nous utilisons donc systemd et la commande systemctl comme vu précédemment pour les scripts Xplanet.

/etc/systemd/system/piMiniScreen.service

[Unit]
Description=Liberty Display
After=network.target
After=syslog.target

[Install]
WantedBy=multi-user.target

[Service]
ExecStart=/usr/bin/python -u /root/pi_mini_screen.py
StandardOutput=journal+console
User=root
Group=root
Restart=always

Sans oublier ensuite d’activer le service au démarrage du système :

systemctl enable piMiniScreen.service

Il ne vous reste plus qu’à rebooter votre Pi

Dans le prochain article je vous montrerai comment faire tomber de la neige sur cet écran en rajoutant quelques lignes de code, à très vite !

L’article Mini Pi Dash Screen est apparu en premier sur MagdiBlog.

MàJ déc 2016 : changement de nom de domaine pour le projet qui devient www.cam-aero.eu

Il fait beau et chaud, les vacances d’été ne sont plus très loin. Le temps parfait pour les activités de plein air. Ca tombe bien, aujourd’hui je vais vous présenter un projet réalisé pour le site www.cam-aero.eu, en partenariat avec MagdiBlog.fr, qui ravira les amateurs d’aéronautique de loisir

L’objectif de ce projet est de doter tous les aérodromes d’un module caméra qui prend des photos de la piste et de la météo ambiante à intervalles réguliers tout en incrustant la date, l’heure et les informations météorologiques locales (telles que METAR, TAF, SIGMET) dans l’image.

Voici un aperçu d’une image d’un aérodrome dans la région de Brest :

L’ensemble des images de tous les aérodromes équipés sont collectées et stockées sur un serveur central. Toutes les images et informations météorologiques locales sont ensuite consultables par tous les membres ; ce qui leur permet de mieux préparer leurs vols, par exemple, en connaissant l’état de l’aérodrome de destination.

Un système collaboratif simple, économique, à la porté de tous (Le module s’installe sur une fenêtre avec une ventouse et nécessite une simple connexion Internet. L’installation du logiciel et sa configuration se font en une seule ligne de commande), qui permettra à tous les aérodromes de partager une vue de leur piste et leurs informations METAR facilement

Le système complet est réalisé avec des Raspberry Pi, sans composants particuliers :

• Raspberry Pi (2, B, B+ ou A+)
• RaspiCam 5MP (ou version NoIR)
• Boitier avec emplacement pour le module caméra
• Carte SD
• Alimentation
• Dongle WiFi USB

N’hésitez pas à partager l’info et à promouvoir ce projet autour de vous

Je vous laisse découvrir le projet sur le site officiel : www.cam-aero.eu

L’article RaspiCamAero : Aéronautique de loisir, caméra sur piste et informations METAR (màj déc 2016) est apparu en premier sur MagdiBlog.

CanardPC vient de sortir un numéro spécial dédié au Raspberry Pi et Arduino et à l’électronique en général. Je vous invite à le choper tant qu’il est toujours dispo chez votre libraire

Voici l’édito : http://www.canardpc.com/cpc-hardware-hs-n7-special-electronique-disponible.html

Le dernier article de ce numéro est consacré à la téléinfo EDF avec une mention spéciale à l’article de MagdiBlog : Téléinfo EDF – Suivi conso de votre compteur électrique

Etant moi même un grand fan de CanardPC depuis de nombreuses années, c’est pour moi une véritable consécration

L’article MagdiBlog dans le CanardPC Hardware Hors Série n°7 spécial électronique est apparu en premier sur MagdiBlog.

L’ère de la robotique, j’ai hâte !

Nous y sommes presque

#LilleMakerFair

L’article Lille Maker Fair est apparu en premier sur MagdiBlog.

Bonjour à toutes à et à tous,

Je viens de changer de serveur d’hébergement pour MagdiBlog.fr, aussi, veuillez m’excuser pour les coupures qui ont pu avoir lieux ces dernières 24h. Il se peut également que certains commentaires aient été perdus lors de la migration, mais c’est pour la bonne cause, le site devrait être beaucoup réactif à présent

Je profite de ce billet pour vous annoncer que le projet Pi BOAt n’est pas mort, les articles paraitront à partir de la rentrée

En outre, je prépare un article sur la partie vidéo, l’utilisation d’objectifs sur la Pi Camera ainsi que sur les différentes manières d’utiliser le module caméra sur le Pi

Profitez bien des quelques jours d’août qu’il nous reste,

A très bientôt,

Olivier

L’article Migration de serveur est apparu en premier sur MagdiBlog.

MAJ août 2016 : Depuis la parution de cet article en septembre 2014 (bientôt 2 ans Oo), de nombreuses évolutions ont été faites sur les Raspberry Pi et Raspbian. Grâce aux retours d’expériences de plusieurs lecteurs et à leur participation, cet article est aujourd’hui mis à jour Un gros merci à Arnaud (qui se reconnaîtra) qui m’a notamment envoyé de nombreuses informations sur les modifcations relatives à Raspbian Jessie et au RPi3

Vous pouvez notamment télécharger les versions revues et corrigées des scripts PHP par Arnaud, ici : teleinfo.zip

A l’ère de la domotique et des économies d’énergie, le suivi de la consommation d’électricité dans nos maison devient un point incontournable. Détecter les appareils électriques gourmands, optimiser sa consommation en jouant sur les tarifs heures creuses/pleines, opter pour des ampoules à économie d’énergie et couper ses équipements multimédia lorsqu’on ne s’en sert pas : autant de gestes qui prennent sens à partir du moment où l’on peut en mesurer l’effet sur sa facture EDF.

Dans cet article, nous allons explorer une méthode très simple pour collecter et analyser les informations de notre compteur EDF et les représenter sur un graphique. Comme toujours sur magdiblog.fr, nous utiliserons un Raspberry Pi pour construire ce petit système

Téléinfo EDF, qu’est ce que c’est ?

Depuis quelques années, EDF a ajouté à ses compteurs électriques domestiques la possibilité de lire à distance les informations enregistrées (consommation heures creuses/pleines, consommation instantanée, intensité max, etc…). Ceci permet, entre autre, de renvoyer les informations vers votre coffret EDF extérieur afin que les agents EDF puissent effectuer le relevé de consommation (et donc établir une facture) sans avoir à accéder à votre compteur à l’intérieur de votre maison. Les compteurs compatibles disposent de deux bornes I1 et I2, permettant de récupérer directement les informations sur un bus UART-TTL

Pour plus d’informations sur la téléinfo EDF et son mode de fonctionnement, vous pouvez consulter le document « Sorties de télé-information client des appareils de comptage électroniques utilisés par ERDF« , publié par EDF et disponible ici : ERDF-NOI-CPT_02E.pdf

GPIO et optocoupleur

La première étape consiste à créer le petit circuit électronique qui fera l’interface entre le GPIO du Raspberry Pi et le compteur EDF. Il s’agit simplement de « démoduler » le signal sortant des bornes I1 et I2 du compteur,  à l’aide d’un optocoupleur et d’une paire de résistances. Le circuit est ensuite relié a la broche UART du GPIO du Raspberry Pi ce qui nous permettra de récupérer les trames de données du compteur EDF.

Pour cette partie, je me suis largement inspiré de cet article très synthétique : http://lhuet.github.io/blog/2014/01/montage-teleinfo.html

Matériel nécessaire

• optocoupleur SFH620A
• résistance 1.2 kΩ
• résistance 3.3 kΩ
• une carte d’expérimentation ou « breadbord »
• des câbles « wire jumper »
• une plaque epoxy

Montage et branchement

Voici un schéma électronique du circuit qui est très répandu sur la toile :

Ce qui nous donne un montage très simple à réaliser :

Voici ce que ça donne avec un petit bout d’epoxy :

Le branchement sur le port GPIO du Pi est également très simple. On utilise l’alimentation 3,3V du GPIO (fil rouge), la masse du GPIO (fil noir) et la broche 15 RXD (fil jaune).

Pour plus de détails sur le port GPIO du Pi, je vous invite à consulter cet article : http://www.magdiblog.fr/gpio/gpio-entree-en-matiere/

Il ne reste qu’à connecter les deux fils bleus (ou blanc et bleu, que vous pouvez utiliser dans n’importe quel sens) aux bornes I1 et I2 du compteur EDF (généralement en bas à droite) :

Et voilà A ce stade, votre Raspberry Pi est bombardé en continu par les infos envoyées par votre compteur EDF

Récupération des données

MAJ août 2016 : Depuis la parution de Raspbian Jessie :

Dans le fichier /boot/cmdline.txt :

- supprimer la ligne :
console=serial0,115200
- ajouter la ligne : 
enable_uart=1

Inutile de modifier le fichier /etc/inittab.

Sur Raspberry Pi3, l’UART PL011 (full UART) du BCM2837 a été ré-alloué au WLAN/BT combo. Et le mini UART est mis à disposition des utilisateurs (sous le nom de /dev/ttyS0).

Il faut donc configurer /dev/ttyS0 (à la place de /dev/ttyAMA0) et remplacer /dev/ttyAMA0 par /dev/ttyS0 à la ligne 10 de teleinfo_func.php. (voir plus bas)

Pour plus d’information sur ces changements : http://spellfoundry.com/2016/05/29/configuring-gpio-serial-port-raspbian-jessie-including-pi-3/

Pour les anciennes versions de Raspbian :

Dans un premier temps il convient d’activer le port série du Raspberry Pi :

Dans le fichier /boot/cmdline.txt :

- supprimer les paramètres suivants :
console=ttyAMA0,115200 kgdboc=ttyAMA0,115200

Puis dans le fichier /etc/inittab :

- commentez la ligne suivante (tout en bas du fichier) en ajoutant un # devant :
#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Redémarrer votre Raspberry Pi :

shutdown -r now

Enfin, pour créer un périphérique idoine et configurer le port série de manière à récupérer correctement les informations  :

stty -F /dev/ttyAMA0 1200 sane evenp parenb cs7 -crtscts

A ce stade, vous devriez avoir un périphérique /dev/ttyAMA0 qui renvoi l’ensemble des données émises par votre compteur EDF.
En faisant un cat sur ce fichier, vous devriez voir défiler vos données de consommation EDF

cat /dev/ttyAMA0

Note : Si vous n’avez que des lignes du type ADCO 012345678945 ?, il se peut que la téléinfo ne soit pas activée sur votre compteur. Il vous suffit normalement de faire une demande à EDF pour l’activer.

Données de la téléinfo EDF

Comme indiqué dans le document « Sorties de télé-information client des appareils de comptage électroniques utilisés par ERDF« , publié par EDF et disponible ici : ERDF-NOI-CPT_02E.pdf, et selon votre type d’abonnement EDF, vous pouvez récupérer les informations suivantes :

• ADCO : Identifiant du compteur
• OPTARIF : Option tarifaire (type d’abonnement)
• ISOUSC : Intensité souscrite
• BASE : Index si option = base (en Wh)
• HCHC : Index heures creuses si option = heures creuses (en Wh)
• HCHP : Index heures pleines si option = heures creuses (en Wh)
• EJP HN : Index heures normales si option = EJP (en Wh)
• EJP HPM : Index heures de pointe mobile si option = EJP (en Wh)
• BBR HC JB : Index heures creuses jours bleus si option = tempo (en Wh)
• BBR HP JB : Index heures pleines jours bleus si option = tempo (en Wh)
• BBR HC JW : Index heures creuses jours blancs si option = tempo (en Wh)
• BBR HC JW : Index heures pleines jours blancs si option = tempo (en Wh)
• BBR HC JR : Index heures creuses jours rouges si option = tempo  (en Wh)
• BBR HP JR : Index heures pleines jours rouges si option = tempo (en Wh)
• PEJP : Préavis EJP si option = EJP 30mn avant période EJP
• PTEC : Période tarifaire en cours
• DEMAIN : Couleur du lendemain si option = tempo
• IINST : Intensité instantanée (en ampères)
• ADPS : Avertissement de dépassement de puissance souscrite (en ampères)
• IMAX : Intensité maximale (en ampères)
• PAPP : Puissance apparente (en Volt.ampères)
• HHPHC : Groupe horaire si option = heures creuses ou tempo
• MOTDETAT : Mot d’état (autocontrôle)

Une trame commence toujours par l’étiquette ADCO et se termine par le MOTDETAT.

Chaque message, ou ligne, d’une trame est formé de la manière suivante :

ETIQUETTE espace VALEUR espace CHECKSUM

Seules l’ETIQUETTE et la VALEUR nous seront utiles. La CHEKSUM, ou somme de contrôle sert uniquement à vérifier l’intégrité que la trame.

Données utiles

Avant d’aller plus loin, il convient de faire le point sur les données récupérées. AMHA, seules deux informations sont réellement intéressantes à observer :

• la puissance instantanée en Watts (permet de voir sa consommation de « courant » au cours de la journée)
• la consommation d’électricité en Wh servant d’élément de facturation à EDF (permet de voir sa consommation global par jour/mois/année en fonction des périodes tarifaires)

Petit détail technique, ces informations ne sont pas directement disponibles ; il va falloir les déduire des données remontées par la téléinfo. Et c’est là que j’en profite pour remercier mon cher cousin Vincent pour m’avoir éclairé sur la subtilité de la chose. Merci Vincent

En effet, la téléinfo ne vous montre que la puissance apparente en Volt.Ampère (étiquette PAPP dans la trame). Rien à voir avec la puissance active en Watts ! Non monsieur ! Enfin presque ! Nous connaissons tous cette formule de puissance :

P = U x I (puissance en watt = tension en Volt X intensité en Ampère)

Seulement voilà, cette formule n’est valable qu’en courant continu… En courant alternatif, tel que délivré par EDF/ERDF, il faut multiplier ce résultat par un facteur de puissance appelé cos phi… Le problème, c’est que ce facteur de puissance est variable en fonction des appareils électriques qui consomment du courant dans votre maison… Rapport à un problème de phase d’après les experts… ^^ Pour les plus courageux d’entre vous, je vous conseille cet article qui explique très bien le pourquoi du comment de la chose : http://www.energieplus-lesite.be/index.php?id=11495

M’enfin bref, revenons à notre téléinfo. Nous n’avons donc pas directement la puissance active en Watt, mais, nous avons l’intensité instantanée en Ampère ! Il nous suffira donc de multiplier ce nombre par 230V (ou 220V, ou 240V, selon que vous soyez proche ou non du transformateur) pour avoir une puissance instantanée en Watt Nous aurons ainsi une idée approximative de la puissance instantanée consommée par tous les appareils de notre maison, ce qui nous permettra par exemple de constater que le chauffe eau fonctionne de telle heure à telle heure, que télé éteinte, on consomme 250W de moins, et que « Oh mon Dieu !!! » une plaque de cuisson ça consomme à MOOOOOOOOORRRRRTTT, 6000 W !!!

En ce qui concerne la consommation quotidienne de courant en Wh, nous devrons également ruser car la téléinfo ne donne que le nombre total de Wh consommés depuis l’installation de votre compteur. Pour avoir la consommation sur une journée, il va donc falloir faire la différence entre le nombre total de Wh consommées ce jour et le nombre total de Wh consommés la veille. Rien de bien méchant donc

Voyons maintenant comment procéder pour récupérer et traiter ces données à l’aide de scripts PHP et d’une base de données SQLite. Nous utiliserons ensuite la librairie graphique Google Chart pour tracer de jolies courbes de notre consommation d’électricité

Traitement des données et création d’un graphique de suivi

Le principe général est simple : un script PHP est exécuté à intervalles réguliers (toutes les minutes pour la puissance instantanée, et une fois par jour pour la consommation quotidienne en Wh), récupère les données de la téléinfo puis les stocks dans une base de données SQLite. Dans un second temps, une page web PHP/HTML lit les infos dans la base de données SQLite et affiche les graphiques.

• teleinfo_func.php : script PHP qui contient les fonctions nécessaires aux différents scripts.

<?php

  $sqlite = 'teleinfo.sqlite';

  //
  //  renvoie une trame teleinfo complete sous forme d'array
  //
  function getTeleinfo () {

    $handle = fopen ('/dev/ttyACM0', "r"); // ouverture du flux

    while (fread($handle, 1) != chr(2)); // on attend la fin d'une trame pour commencer a avec la trame suivante

    $char  = '';
    $trame = '';
    $datas = '';

    while ($char != chr(2)) { // on lit tous les caracteres jusqu'a la fin de la trame
      $char = fread($handle, 1);
      if ($char != chr(2)){
        $trame .= $char;
      }
    }

    fclose ($handle); // on ferme le flux

    $trame = chop(substr($trame,1,-1)); // on supprime les caracteres de debut et fin de trame

    $messages = explode(chr(10), $trame); // on separe les messages de la trame

    foreach ($messages as $key => $message) {
      $message = explode (' ', $message, 3); // on separe l'etiquette, la valeur et la somme de controle de chaque message
      if(!empty($message[0]) && !empty($message[1])) {
        $etiquette = $message[0];
        $valeur    = $message[1];
        $datas[$etiquette] = $valeur; // on stock les etiquettes et les valeurs de l'array datas
      }
    }

    return $datas;

  }

  //
  //  enregistre la puissance instantanée en V.A et en W
  //
  function handlePuissance () {
    global $sqlite;
    $db = new SQLite3($sqlite);
    $db->exec('CREATE TABLE IF NOT EXISTS puissance (timestamp INTEGER, hchp TEXT, va REAL, iinst REAL, watt REAL);'); // cree la table puissance si elle n'existe pas

    $trame = getTeleinfo (); // recupere une trame teleinfo

    $datas = array();
    $datas['timestamp'] = time();
    $datas['hchp']      = substr($trame['PTEC'],0,2); // indicateur heure pleine/creuse, on garde seulement les carateres HP (heure pleine) et HC (heure creuse)
    $datas['va']        = preg_replace('`^[0]*`','',$trame['PAPP']); // puissance en V.A, on supprime les 0 en debut de chaine
    $datas['iinst']     = preg_replace('`^[0]*`','',$trame['IINST']); // intensité instantanée en A, on supprime les 0 en debut de chaine
    $datas['watt']      = $datas['iinst']*220; // intensite en A X 220 V

    if($db->busyTimeout(5000)){ // stock les donnees
      $db->exec("INSERT INTO puissance (timestamp, hchp, va, iinst, watt) VALUES (".$datas['timestamp'].", '".$datas['hchp']."', ".$datas['va'].", ".$datas['iinst'].", ".$datas['watt'].");");
    }

    return 1;
  }

  //
  //  enregistre la consommation en Wh
  //
  function handleConso () {
    global $sqlite;
    $db = new SQLite3($sqlite);
    $db->exec('CREATE TABLE IF NOT EXISTS conso (timestamp INTEGER, total_hc INTEGER, total_hp INTEGER, daily_hc REAL, daily_hp REAL);'); // cree la table conso si elle n'existe pas

    $trame     = getTeleinfo (); // recupere une trame teleinfo

    $today     = strtotime('today 00:00:00');
    $yesterday = strtotime("-1 day 00:00:00");

    // recupere la conso totale enregistree la veille pour pouvoir calculer la difference et obtenir la conso du jour
    if($db->busyTimeout(5000)){
      $previous = $db->query("SELECT * FROM conso WHERE timestamp = '".$yesterday."';")->fetchArray(SQLITE3_ASSOC);
    }
    if(empty($previous)){
      $previous = array();
      $previous['timestamp'] = $yesterday;
      $previous['total_hc']  = 0;
      $previous['total_hp']  = 0;
      $previous['daily_hc']  = 0;
      $previous['daily_hp']  = 0;
    }

    $datas = array();
    $datas['query']     = 'hchp';
    $datas['timestamp'] = $today;
    $datas['total_hc']  = preg_replace('`^[0]*`','',$trame['HCHC']); // conso total en Wh heure creuse, on supprime les 0 en debut de chaine
    $datas['total_hp']  = preg_replace('`^[0]*`','',$trame['HCHP']); // conso total en Wh heure pleine, on supprime les 0 en debut de chaine

    if($previous['total_hc'] == 0){
      $datas['daily_hc'] = 0;
    }
    else{
      $datas['daily_hc']  = ($datas['total_hc']-$previous['total_hc'])/1000; // conso du jour heure creuse = total aujourd'hui - total hier, on divise par 1000 pour avec un resultat en kWh
    }

    if($previous['total_hp'] == 0){
      $datas['daily_hp'] = 0;
    }
    else{
      $datas['daily_hp']  = ($datas['total_hp']-$previous['total_hp'])/1000; // conso du jour heure pleine = total aujourd'hui - total hier, on divise par 1000 pour avec un resultat en kWh
    }

    if($db->busyTimeout(5000)){ // stock les donnees
      $db->exec("INSERT INTO conso (timestamp, total_hc, total_hp, daily_hc, daily_hp) VALUES (".$datas['timestamp'].", ".$datas['total_hc'].", ".$datas['total_hp'].", ".$datas['daily_hc'].", ".$datas['daily_hp'].");");
    }
  }

  //
  //  recupere les donnees de puissance des $nb_days derniers jours et les met en forme pour les affichers sur le graphique
  //
  function getDatasPuissance ($nb_days) {
    global $sqlite;
    $months    = array('01' => 'janv', '02' => 'fev', '03' => 'mars', '04' => 'avril', '05' => 'mai', '06' => 'juin', '07' => 'juil', '08' => 'aout', '09' => 'sept', '10' => 'oct', '11' => 'nov', '12' => 'dec');
    $now  = time();
    $past = strtotime("-$nb_days day", $now);

    $db = new SQLite3($sqlite);
    $results = $db->query("SELECT * FROM puissance WHERE timestamp > $past ORDER BY timestamp ASC;");

    $sums = array();
    $days = array();
    $datas = array();

    while($row = $results->fetchArray(SQLITE3_ASSOC)){
      $year   = date("Y", $row['timestamp']);
      $month  = date("n", $row['timestamp']-1);
      $day    = date("j", $row['timestamp']);
      $hour   = date("G", $row['timestamp']);
      $minute = date("i", $row['timestamp']);
      $second = date("s", $row['timestamp']);
      $datas[] = "[{v:new Date($year, $month, $day, $hour, $minute, $second), f:'".date("j", $row['timestamp'])." ".$months[date("m", $row['timestamp'])]." ".date("H\hi", $row['timestamp'])."'}, {v:".$row['va'].", f:'".$row['va']." V.A'}, {v:".$row['watt'].", f:'".$row['watt']." kW'}]";

    }

    return implode(', ', $datas);
  }

  //
  //  recupere les donnees de consommation des $nb_days derniers jours et les met en forme pour les affichers sur le graphique
  //
  function getDatasConso ($nb_days) {
    global $sqlite;
    $months    = array('01' => 'janv', '02' => 'fev', '03' => 'mars', '04' => 'avril', '05' => 'mai', '06' => 'juin', '07' => 'juil', '08' => 'aout', '09' => 'sept', '10' => 'oct', '11' => 'nov', '12' => 'dec');
    $now  = time();
    $past = strtotime("-$nb_days day", $now);

    $db = new SQLite3($sqlite);
    $results = $db->query("SELECT * FROM conso WHERE timestamp > $past ORDER BY timestamp ASC;");

    $datas = array();

    while($row = $results->fetchArray(SQLITE3_ASSOC)){
      $day    = date("j", $row['timestamp'])." ".$months[date("m", $row['timestamp'])];
      $datas[] = "['".$day."', {v:".$row['daily_hp'].", f:'".$row['daily_hp']." kWh'}, {v:".$row['daily_hc'].", f:'".$row['daily_hc']." kWh'}]";
    }

    return implode(', ', $datas);
  }

?>

• • teleinfo_puissance.php : script PHP exécuté toutes les minutes pour enregistrer la puissance instantanée en V.A et en W.

#!/usr/bin/php5
<?php

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

require_once('/root/teleinfo/teleinfo_func.php');

handlePuissance();

?>

• teleinfo_conso.php : script PHP exécuté tous les jours juste avant minuit pour enregistrer la consommation en Wh.

#!/usr/bin/php5
<?php

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

require_once('/root/teleinfo/teleinfo_func.php');

handleConso();

?>

• teleinfo_graph.php : page PHP/HTML qui permet d’afficher les deux graphiques

<?php require_once('teleinfo_func.php'); ?>

<script type="text/javascript" src="https://www.google.com/jsapi"></script>

<div id="puissance">
  <div id="chart_div"></div>
  <div id="filter_div"></div>
</div>
<div id="conso"></div>


<script type="text/javascript">
  google.load('visualization', '1.0', {'packages':['controls']});
  google.setOnLoadCallback(drawDashboard);
  
  function drawDashboard() {

    var data = new google.visualization.DataTable();
        data.addColumn('date', 'Date');
        data.addColumn('number', 'V.A');
        data.addColumn('number', 'kW');
        data.addRows([<?php echo getDatasPuissance (5); ?>]);

    var dashboard = new google.visualization.Dashboard(
            document.getElementById('puissance'));

    var rangeSlider = new google.visualization.ControlWrapper({
          'controlType': 'ChartRangeFilter',
          'containerId': 'filter_div',
          'options': {
             filterColumnLabel : 'Date',
             ui : {chartType: 'LineChart', chartOptions: {
                             height : 80,
                             backgroundColor: '#FFF',
                             colors : ['#375D81', '#ABC8E2'],
                             curveType : 'function',
                             focusTarget : 'category',
                             lineWidth : '1',
                             'legend': {'position': 'none'},
                             'hAxis': {'textPosition': 'in'},
                             'vAxis': {
                               'textPosition': 'none',
                               'gridlines': {'color': 'none'}
                             }
                 }}
          }
        });
        
    var lineChart = new google.visualization.ChartWrapper({
          'chartType': 'LineChart',
          'containerId': 'chart_div',
          'options': {
                             title: '',
                             height : 400,
                             backgroundColor: '#FFF',
                             colors : ['#375D81', '#ABC8E2'],
                             curveType : 'function',
                             focusTarget : 'category',
                             lineWidth : '1',
                             legend : {position: 'bottom',  alignment: 'center', textStyle: {color: '#333', fontSize: 16}},
                             vAxis : {textStyle : {color : '#555', fontSize : '16'}, gridlines : {color: '#CCC', count: 'auto'}, baselineColor : '#AAA', minValue : 0},
                             hAxis : {textStyle : {color : '#555'}, gridlines : {color: '#DDD'}}
          }
        });

    dashboard.bind(rangeSlider, lineChart);
    dashboard.draw(data);

  }
  
  google.load("visualization", "1", {packages:["corechart"]});
  google.setOnLoadCallback(drawChart);
  
  function drawChart() {
    var data = new google.visualization.DataTable();
    data.addColumn('string', 'Date');
    data.addColumn('number', 'Heures pleines');
    data.addColumn('number', 'Heures creuses');
    data.addRows([<?php echo getDatasConso (365); ?>]);
    var options = {
                   title: '',
                   height : 200,
                   backgroundColor: '#FFF',
                   colors : ['#375D81', '#ABC8E2'],
                   curveType : 'function',
                   focusTarget : 'category',
                   lineWidth : '1',
                   isStacked: true,
                   legend : {position: 'bottom',  alignment: 'center', textStyle: {color: '#333', fontSize: 16}},
                   vAxis : {textStyle : {color : '#555', fontSize : '16'}, gridlines : {color: '#CCC', count: 'auto'}, baselineColor : '#AAA', minValue : 0},
                   hAxis : {textStyle : {color : '#555'}, gridlines : {color: '#DDD'}}
              };
    var chart = new google.visualization.ColumnChart(document.getElementById("conso"));
    chart.draw(data, options);
  }


</script>

Pour 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. Vous pourrez ensuite afficher cette page PHP/HTML dans votre navigateur.

Résultat

Et voici le résultat pour la puissance instantanée en V.A et W :

Et le résultat pour la consommation quotidienne heures pleines/creuses en kWh :

Comme toujours, les idées d’amélioration, les remarques et toutes les questions sont les bienvenues en commentaire de cet article

Dans mon prochain article « RaspberryPi + Razberry + Domoticz : Le combo parfait ! » je vous montrerai comment créer un système domotique complet et à moindre frais pour gérer efficacement votre maison

MàJ : Un micro module USB prêt à l’emploi est disponible ici : http://hallard.me/teleinfo/. Je ne l’ai pas encore tester, mais cela semble être une solution idéale, quoi que beaucoup plus cher qu’un petit optocoupleur

L’article Téléinfo EDF – Suivi conso de votre compteur électrique (màj 08/2016) est apparu en premier sur MagdiBlog.

Résultats du concours :

Vous avez été près de 400 participants à ce concours organisé à l’occasion des 3 ans de magdiblog.fr !

Félicitations à Philippe alias ay15ho11 qui a été tiré au sort grâce au plugin Comment Contest

Philippe, je vous invite à me contacter en utilisant la page contact du site pour que je puisse vous faire parvenir vos cadeaux

Merci à toutes et à tous pour votre participation Je vous souhaite un excellent week end et un très bon été à venir !

Olivier

MàJ du 18 mai 2016 :

Plus que 48 heures pour participer

On est passé de 190 à plus de 270 participants dans les dernières 24h !

Bonne chance à toutes et à tous

MàJ du 10 mai 2016 :

Le tirage aura lieu le vendredi 20 mai à 12h00 !

Plus de 160 participants à l’heure actuelle !

Bonne chance à toutes et à tous

Bonjour à toutes et à tous,

Comme annoncé le mois dernier, à l’occasion des 3 ans du blog et du million de pages vues, j’ai le grand plaisir d’ouvrir le jeu concours organisé pour fêter l’événement !

A gagner ?

J’apprécie énormément votre soutien, aussi, j’ai le plaisir de vous offrir un Raspberry Pi 3 que vous pouvez découvrir ici : Raspberry Pi 3 – Let’s rock !

Mais ce n’est pas tout, Kubii.fr distributeur Raspberry Pi français, se joint à moi et vous offre un module caméra ainsi que le boitier officiel du Raspberry Pi 3.

Le gagnant remportera le lot entier

Comment participer ?

Pour participer c’est très simple, il vous suffit de poster un commentaire sur cet article.

Le gagnant sera tiré au sort parmi les auteurs de commentaire de cet article, résident en France, le vendredi 20 mai à 12h00 (midi).

N’oubliez pas de bien vérifier votre adresse email afin que je puisse vous contacter si vous êtes tiré au sort.

Inscrivez vous à la newsletter (en haut à droite du site) pour vous tenir informé des résultats du concours, de la suite du projet Pi BOAt ainsi que des projets à venir

Bonne chance à toutes et à tous !

L’article Jeu concours pour les 3 ans de MagdiBlog – MàJ – Résultats du concours ! est apparu en premier sur MagdiBlog.

Le 29 février 2016, soit exactement quatre ans après la sortie du tout premier Raspberry Pi A, la fondation annonce le Raspberry Pi 3. Ils aiment bien les années bissextiles à la fondation Raspberry Pi, c’est comme ça !

Grâce à mon partenaire Kubii.fr, j’ai pu tester ce dernier modèle qui, n’ayons pas peur des mots, commence sérieusement à envoyer du lourd ! J’en profite pour envoyer une bise à Julie de l’équipe Kubii.fr

La même base

La fondation Raspberry Pi semble porter une attention particulière à la rétro-compatibilité des nouveaux modèles avec les accessoires destinés aux RPi plus anciens et on apprécie !

Aussi, le PCB est strictement identique à celui du Raspberry Pi 2. Le GPIO de 40 broches est également le même que sur les modèles B+, 2, A+ et Zero assurant ainsi la compatibilité avec la plupart des cartes filles existantes et que vous pouvez trouver dans la rubrique cartes d’extensions sur Kubii.fr.

Le Raspberry Pi 3 est, comme sont prédécesseur, doté des ports série caméra et écran, respectivement CSI et DSI, de quatre ports USB, d’un port Ethernet, HDMI et jack. Le format micro-SD est également conservé pour la carte système. Pas de bouleversement de ce côté là, donc.

Comme vous pouvez le voir sur les deux photos ci-dessous, à l’œil nu, difficile de différencier un RPi 3 d’un RPi 2.

Un processeur boosté

En revanche, côté processeur, on passe du Cortex-A7 quad-core cadencé à 900MHz qui équipe le RPi 2, à un ARMv8 quad-core 64-bit qui ronronne à 1.2GHz. L’écart peut paraître faible présenté comme ça, mais le Raspberry Pi 3 est beaucoup plus réactif que le RPi 2 avec un gain effectif de l’ordre de 50%. Le passage au 64-bit n’apporte en soit pas grand chose.

Sous Kodi, on gagne en réactivité (même si c’était déjà très fluide avec le RPi 2). L’écart de réactivité se sent également sur une utilisation desktop.

Alors bon… à 1,2GHz dans un boîtier fermé et sans ventilo, ça commence sérieusement à chauffer. L’installation d’un petit dissipateur thermique sur le SoC est presque indispensable. En outre, n’espérez pas faire de l’overclocking sans prévoir une solution de refroidissement adéquate. Je vous laisse découvrir l’article dédié à ce sujet publié sur minimachines.net.

Précisons également que la bête consomme également plus d’énergie (ah bah oui, on n’a rien sans rien !). La fondation préconise l’utilisation d’une alimentation pouvant délivrer 2,5A sur 5V. J’insiste toujours sur ce point, la qualité de votre alimentation joue un rôle très important sur la durée de vie du RPi et de la carte SD, qui est TRES sensible. La plupart des problèmes rencontrés sur les RPi viennent d’une alimentation de piètre qualité. N’hésitez pas à investir dans un bon transfo et à viser toujours un plus haut que les préconisations. Pour le RPi 3 on choisira donc une alim Aukru de 3A, marque dont la réputation n’est plus à faire.

Le GPU reste cependant le même que sur tous les autres Raspberry PI, à savoir un Broadcom VideoCore IV. Dommage car on aurait aimé pouvoir visionner des vidéos en 4K ou au moins pouvoir profiter du h265, ce qui aurait fait du Raspberry Pi 3 le média tank le plus puissant et le plus polyvalent du marché. Ce sera sans doute pour la prochaine fois

Note : J’ai testé pour vous la lecture d’une vidéo en 4K avec la dernière mouture de Kodi… Écran noir, le RPi freeze, bref… va falloir se contenter du 1080p/h264 encore quelques temps…

Niveau mémoire vive, on reste également sur 1GB de RAM. Ils auraient pu pousser à 2GB pour plus de confort sur une utilisation desktop, mais la fondation respecte les contraintes de coût de fabrication qu’elle s’est fixée, lui permettant ainsi de proposer le RPi 3 au même prix que le RPi 2 à sa sortie.

Du WiFi et du Bluetooth

Outre un processeur plus véloce, le RPi 3 arrive avec deux caractéristiques vraiment, VRAIMENT, intéressantes ! Effet, le RPi 3 embarque sur son PCB une puce WiFi 802.11n et une puce Bluetooth 4.1.

Plus besoin, donc, d’acheter un dongle USB qui faisait grimper l’addition d’une quinzaine d’euros, et ça, c’est cool ! En plus, ça libère un port USB, top !

Faut il acheter le Raspberry Pi 3 ?

Oui, et pour deux raisons. La première étant que le Raspberry Pi 3 est le modèle le plus puissant à ce jour et c’est toujours appréciable de profiter d’une réactivité accrue.

La seconde est que je vous encourage à soutenir la fondation Raspberry Pi pour qu’ils puissent continuer leur travail et proposer des Pi toujours plus puissants et complets pour moins de 50€. Bravo et merci à eux !

L’article Raspberry Pi 3 – Let’s rock ! est apparu en premier sur MagdiBlog.

Bonjour à tous les amateurs de framboises !

Aujourd’hui, MagdiBlog.fr fête ses 3 ans d’existence. Lancé en mars de 2013 avec les projets PiTimeLapse, PiCarJukeBox et PiHomeDashScreen le blog a atteint en mars 2016  le million de pages vues !

Je tiens à vous remercier lectrices (si si, il y en a !) et lecteurs de MagdiBlog.fr pour votre soutien, votre bonne humeur et votre enthousiasme ! J’espère vous voir encore nombreux à suivre l’actualité du Raspberry Pi et les nombreux projets à venir tels que le Pi BOAt.

Pour fêter l’événement et parce que je vous aime bien, il y aura très bientôt un tirage au sort avec un Raspberry Pi 3 à gagner !

Dans l’attente, profitez du soleil et inscrivez vous à la newsletter pour ne pas rater le tirage au sort.

Olivier

L’article MagdiBlog fête ses 3 ans, 1 000 000 de pages vues et vous offre un Raspberry Pi 3 est apparu en premier sur MagdiBlog.

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.

Guillaume, à l’initiative du Diskio Pi, m’a contacté il y a quelques temps pour me présenter son projet et le moins que je puisse dire, c’est que j’ai été impressionné par son ambition !

Une « plateforme » sous forme de tablette qui peut accueillir un Raspberry Pi 2 ou un Odroid XU4, et qui dispose de tout ce qu’il faut pour l’exploiter : un écran tactile HD, un ampli audio et des hauts parleurs, une batterie, un hub USB. Du plug’n’play pour nos Raspberry Pi

Il s’agit d’un projet open-source hardware qui promet une ouverture sur une infinité de possibilités, et ça, c’est cool

Voici une vidéo de présentation du concept :

A l’origine, le prototype a été réalisé avec une carte Orange Pi. Un écran 17′ a été utilisé pour permettre un rapport épaisseur/surface le plus petit possible, ainsi qu’une surface de travail agréable pour un usage « desktop ». Un indicateur de batterie est présent, avec 5 leds et un bouton pour tester.

Le Raspberry Pi est placé dans un compartiment amovible qui permet l’accès aux différentes entrées/sorties (HDMI, audio, USB, Ethernet…).

Cerise sur le gâteau, le port GPIO reste accessible, et le hub USB intégré permet de brancher facilement des périphériques externes comme un clavier, une sourie ou un disque dur.
L’idée est de viser une compatibilité avec un maximum de cartes et la possibilité d’intégrer des shields annexes tels que des accéléromètres, capteurs de températures, etc…

Pour les fan de domotique, pour qui le DiskioPi peut être un excellent contrôleur, Guillaume prévoit un support mural et une alimentation en POE+ J’ai envie de l’ambrasser

Pour le moment, ce projet n’est pas encore financé, mais de nombreux indicateurs montrent que la demande est là, surtout auprès de la communauté de la domotique libre.
Le porteur du projet, Guillaume, attend avec impatience vos retours du songage qui est actuellement disponible à cette adresse : http://goo.gl/forms/nzDF3fRlBN

Dès qu’un second prototype sera prêt, un crowfunding sera mis en place courant 2016.

Pour plus de détails : www.diskiopi.com

Un grand Bravo pour Guillaume et on lui souhaite de pouvoir mener ce projet jusqu’au bout

L’article Diskio Pi : un nouveau concept de machine hybride est apparu en premier sur MagdiBlog.

Bonjour à toutes et à tous,

Comme vous le savez, je soutiens les initiatives françaises autour des nouvelles technologies Iziproto est une startup strasbourgeoise qui a développé un driver software permettant d’interfacer nombre de capteurs et de faire fonctionner les modèles de régulation sur Raspberry Pi sans effort.

À l’occasion du lancement du projet, Iziproto organise un concours de projet Raspberry Pi à poster sur le groupe facebook Iziproto, avec à la clef une imprimante 3D.

Moi je dis, bravo !Gagnez une imprimante 3D avec Iziproto !

Iziproto organise un concours Raspberry Pi sur sa page Facebook : https://www.facebook.com/groups/iziproto/

Pour gagner, il faut vous inscrire sur le groupe Facebook et poster votre meilleur projet Raspberry Pi – vidéo ou tuto – , et le projet le plus commenté gagnera une imprimante 3D xyz Da Vinci 1.0 ! Une licence Matlab Home ainsi que des licences Iziproto sont également en jeu.

Pour information, Iziproto est une plateforme de management de Raspberry Pi, qui permet d’interfacer les capteurs Adafruit et de déployer les modèles C ou Python sur la Raspberry Pi facilement,  sans commandes Linux. Pour plus d’infos : www.iziproto.com.

Bonne chance à tous !

L’article Concours de Projets Raspberry Pi, gagnez une imprimante 3D avec Iziproto ! est apparu en premier sur MagdiBlog.

Il y a quelque temps je vous présentais la plateforme Oui Are Makers qui permet aux makers de proposer des projets/tutos.

En décembre 2015, Oui Are Makers organisait un jeu concours dont le but était d’élire les 3 meilleurs projets/tutos.

Le deuxième prix à été remporté par un certain Chapao qui a littéralement pompé le projet Pi HomeDashScreen , du concept au code source, sans même prendre la peine de le restyler…  Voici la page des résultats du concours : http://ouiaremakers.com/blog/resultats-du-concours-raspberry-pi/

M. Chapao, dont le slogan commence par « Je réfléchis beaucoup, je concrétise… autant que faire se peut ! »,  devrait songer à réfléchir par lui même et à concrétiser ses propres projets.

Alors que j’encourage la reprise de mon travail et que celui ci serve d’inspiration, je trouve vraiment moyen que ce monsieur se permette de pomper tel quel le contenu de mon projet.

Mais ce que je trouve vraiment inadmissible, c’est qu’il se permette de participer à concours avec le travail d’un autre, quand bien même la source serait citée !

Aux partenaires de ce concours que sont OuiAreMakers.com, Framboise314.fr et Kubii.fr, je souhaite exprimer ma déception et mon indignation. Ce concours devrait récompenser l’originalité, l’inventivité et le travail des porteurs de projet, vous auriez pu filtrer ce plagiat au lieu de lui décerner un prix…

L’article Petit coup de gueule ! Avis à ceux qui s’approprient le travail des autres ! 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.

Je vous souhaite à toutes et à tous une excellente nouvelle année 2016, pleine de projets

A très vite

Olivier

L’article Bonne Année 2016 est apparu en premier sur MagdiBlog.

Je vous souhaite à toutes et à tous d’excellentes fêtes de fin d’année

Bises, Olivier

L’article Joyeux Noël 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.

Framboise314.fr, Kubii.fr et OuiAreMakers.com organisent un concours de projets autour du Raspberry Pi.

Je n’avais d’autre choix que de relayer l’info !

Vous ne connaissez peut être pas OuiAreMakers.com. Dans ce cas, je vous invite à lire l’excellent article de présentation réalisé par François de Framboise314.fr : http://www.framboise314.fr/ouiaremakers-cest-parti/

Pour participer à ce concours et peut être gagner l’un des nombreux lots en jeu, il vous suffit de vous inscrire sur la plateforme OuiAreMakers.com et d’y publier le tutoriels complet de votre projet.

A gagner, un écran tactile officiel 7 pouces pour Raspberry Pi (sur lequel je publierai bientôt un article), une carte d’extension PiFace Control & Display pour Raspberry Pi, un module caméra pour Raspberry Pi, le livre dédicacé par Francois Mocq Raspberry Pi 2, “Exploitez tout le potentiel de votre nano-ordinateur”.

Votre projet devra être basé sur un Raspberry Pi

Le concours est déjà ouvert depuis le 21 octobre et vous avez jusqu’au 14 Décembre 2015 à 15h pour soumettre votre projet.

Pour plus d’information sur les modalités du concours, les lots et le règlement, rendez-vous ici : http://ouiaremakers.com/blog/reglement-du-concours-raspberry/

Pour participer, rendez-vous sur la page du concours : http://ouiaremakers.com/concours-raspberry-pi/

J’en profite pour saluer amicalement Julie de Kubii.fr, François de Framboise314.fr et toute l’équipe de OuiAreMakers.com.

Bonne chance à toutes et à tous

L’article Concours de projets autour du Raspberry Pi avec Framboise314.fr, Kubii.fr et OuiAreMakers.com est apparu en premier sur MagdiBlog.

La vidéosurveillance est un sujet qui intéresse beaucoup de monde. Alors que les solutions « clé-en-main » vendues sur le marché nécessitent un budget élevé, de nombreux projets plus abordables ont vu le jour avec l’avènement du Raspberry Pi.

Dans l’article Système de vidéo-surveillance abordable avec des Raspberry Pi je vous expliquais comment réaliser un système de vidéosurveillance sur mesure avec plusieurs Raspberry Pi. Dans l’article Raspberry Pi Camera – 5 façons de faire du streaming je comparais plusieurs manières de diffuser un flux vidéo avec le module caméra du Pi.

Pour ceux qui souhaitait une solution un peu plus « packagée » et avec la détection de mouvement (élément essentiel de la vidéosurveillance), il restait Motion, un logiciel de vidéosurveillance sous Linux dont le support sur Raspberry Pi n’était pas évident (très gourmand en ressources, support du module caméra du Pi non immédiat…).

Aujourd’hui, je vous présente Kerberos.io qui est un logiciel de vidéosurveillance spécifiquement développé pour le Raspberry Pi Près à l’emploi, il suffit de télécharger l’image disponible sur le site et de la calquer sur une carte SD (exactement comme pour Raspbian) et ainsi transformer un Pi en caméra de surveillance (A noté qu’il n’existe pas, pour l’instant de paquet .deb près à l’emploi).

Optimisé pour le Pi et parfaitement compatible avec le module caméra du Pi, Kerberos.io est LA vidéosurveillance clé-en-main pour Raspberry Pi !

Kerberos.io est doté d’une interface web totalement responsive (compatible avec les smartphones et tablettes), épurée et moderne.

Une démo en ligne est disponible à cette adresse : https://demo.kerberos.io/

Cette interface web vous permettra bien entendu d’avoir les images en temps réel, mais vous présentera également un ensemble de statistiques concernant les événements détectés. Vous pourrez ainsi avoir une trace d’une activité détectées par la caméra.

Il est également possible de déclencher un certain nombre d’opérations lorsqu’un mouvement est détecté comme sauvegarder les images, agir sur le port GPIO, envoyer des requêtes, etc… Enfin, vous pouvez visualiser plusieurs caméras sur une interface web grâce à la fonctionnalité « cloud ».

Pour plus d’info sur kerberos.io, je vous invite à consulter le site officiel : https://kerberos.io/

Voici le lien directe vers la documentation (en anglais) : https://doc.kerberos.io/

N’hésitez pas à partagez vos impressions sur ce soft dans les commentaires

L’article Kerberos.io : la vidéosurveillance pour Raspberry Pi est apparu en premier sur MagdiBlog.