A propos de ce blog ...

Mon installation domotique évolue un peu ... suite à des problèmes avec l'API Python pour Google, j'ai décidé de migrer tous les échanges entre mon installation et internet vers Google Calendar ... Voici ce que ça donne en live ...

J'ai donc remplacé toute la gestion des données en entrée/sortie Web de mon Arduino (récupération des consignes de thermostats hébergées sous Google Calendar, envoi des données de température vers mon site web) précédemment réalisées sous Python par des scripts Google.
Le but final est de rendre mon installation 100% autonome, sans scripts Python, donc sans PC. Cette migration ultime arrivera courant février: je suis en attente de mon shield Ethernet ...

En attendant, voici quelques explications sur les scripts Google, dans une toute nouvelle rubrique (Google, of course) !

Bonne lecture... pour toute question, n'hésitez-pas à me contacter !

Bonne année 2014 !

Shield Ethernet: C'est pour bientôt !

J'attends impatiemment de la recevoir ...

Google Services: Calendar, Scripts, Drive, Sites

Utiliser les services Google avec son Arduino (ou tout autre chose ...)
Comme je l'ai écrit au travers de ce post, j'utilise désormais les services Google pour héberger les données de température et récupérer les consignes de thermostat en provenance de Calendar.
Auparavent, j'utilisais:

• la librairie ftp Python pour sauvegarder les données de température et générer la page web des courbes. Je sauvegardais ces données sur mon FTP perso Free, ce qui ne plaisait guère à mon fournisseur d'accès (qui m'a fermé mon accès)
• la librairie google Python pour lire les données de Calendar (étudié ici). Soit celle-ci était bugguée, soit je ne savais pas m'en servir (je penche pour la 2nde solution) car j'avais des soucis avec (les plaquettes supprimées était quand même lues par l'API par exemple)

Ces problèmes sont désormais réglés car:

• Google Script me permet de récupérer cycliquement les données de Calendar pour les mettre dans un format lisible facilement par un sketch Arduino (un spreadsheet Drive, autrement dit une feuille de calcul Excell à la sauce Google) via la librairie gspread
• La librairie gspread permet de sauvegarder tout aussi facilement des données de température dans une feuille de calcul
• Les différents indicateurs (courbes ...) peuvent être générés directement dans la feuille de calcul sous Drive, comme on le fait par exemple avec Excel
• Sites me permet de générer une page web avec une simplicité extrème, en allant directement récupérer les données graphiques depuis la feuille de calcul

Le résultat est visible ici....

Voici en quelques lignes comment accéder à son agenda, extraire les données qui y sont sauvegardées, et générer une feuille de calcul. Ce post ne fait que donner quelques indications sur l'utilisation et l'écriture de scripts. Les tutoriaux Google Script sont nombreux, je vous invite à les parcourir ...

Accéder à Calendar

Le but est de récupérer l'ID de l'agenda afin de pouvoir y accéder depuis les scripts Google. La manipulation a déjà été expliquée dans ce post. Je vous laisse aller y faire un tour...

Accéder à la feuille de calcul

Comme pour Calendar, le but est de récupérer l'ID de la feuille de calcul.

Pour ce faire, créez une feuille vide dans Drive puis ouvrez là, ou ouvrez une feuille existante. Dans l'URL, l'ID est tout ce qui est placé entre les parties rouges:

https://docs.google.com/spreadsheet/ccc?key=xxxxxxxxxxxxxxxxxxxxxxxxxx&usp=drive_web#gid=0

Créer un script

Dans Drive, créez un nouveau document de type Script.

Si Script n'est pas disponible, cliquez sur "Connecter plus d'applications", puis sélectionnez "Script in Google Drive". 

Sélectionnez ensuite un projet vide

Premier script

Les scripts sous Drive sont écrits en Javascript.

Ils se déclinent en une succession de functions pouvant ensuite être déclenchées automatiquement et cycliquement. Il est donc important de faire des fonctions modulaires.

Le script suivant permet de:

• Accéder à Calendar
• Accéder à la feuille de calcul
• Lire toutes les données du jour dans Calendar
• Ecrire toutes ces données dans la feuille de calcul

Le script est disponible ici (je n'arrive pas à le coller dans ce post :( )

Dans ce script:

• Je force le fuseau au fuseau local, car les évènements sont décalés d'une heure sinon,
• La ligne var events = cal.getEventsForDay(today); permet de récupérer les évènements de la journée. La ligne var events = cal.getEvents(today,tomorrow); permet de les récupérer entre 2 dates. tomorrow est défini par: var tomorrow=new Date(today.getTime()+ (36 * 60 * 60 * 1000)); chez moi (ce qui fait un peu plus de 24h, mais je voulais assurer...)
• En fin de script, il ne faut pas oublier de réaffecter le fuseau d'origine

Voilà en ce qui concerne la récupération d'évènements Calendar dans Spreadsheet.

Prochainement, j'aborderai la lecture des données Spreadsheet depuis Arduino, et l'écriture de données dans un Spreadsheet depuis Arduino.

Domotique: Profiter des services Google ...

Utiliser Google Script pour s'interfacer avec le web
J'ai depuis un (trop) long moment de sérieux problèmes avec Google Calendar: il n'est pas rare (ça arrive au moins une fois par jour) qu'un RDV déclaré dans Google Calendar ne soit pas récupéré par l'API Python. je suis obligé de modifier ce RDV pour qu'il soit de nouveau détecté. Même problème si je supprime un RDV: celui-ci est toujours rapatrié par l'API Python, ce qui est gênant car il n'y a alors aucune solution pour rectifier le tir ...

J'ai décidé de prendre le problème à bras le corps: supprimer cette partie un peu faiblarde de mon installation pour la remplacer par une solution que je pense plus pérène à plusieurs égards, en profitant des services Google pour:
- récupérer les infos depuis Calendar,
- les mettre en forme, près à être traités par mon script Python,
- effectuer la remontée vers le site web pour suivre les évolutions de mon chauffage (j'ai aussi traité mon alarme, mais je préfère ne pas trop échanger à ce propos ...)

La solution est d'utiliser Google Script, pour récupérer les infos de Google Calendar, les stocker dans un tableur de Google Drive, que je viens lire avec un script Python. Résultat: une bonne partie de la charge de travail (lecture de Google Calendar pour les consignes de chauffage et de l'alarme) sont désormais dédiés à Google, plus à mon installation.
De même, je gérais autrefois l'historisation des courbes de températures et la génération de la page web. C'est désormais Google qui gère tout ça, au travers de l'exploitation directe des graphiques du tableur dans une page web de Google Sites.

L'idée derrière tout ceci est que je compte très prochainement modifier toute mon installation afin de la rendre 100% autonome, en rajoutant une carte Ethernet à mon Arduino. L'exploitation des données de Google se fera directement depuis le sketch de l'Arduino. Exit le PC qui tourne sous Python !

Logique des échanges
Le but de ce passage sous Google Script est de:

• Lire cycliquement les données de Google Calendar de la journée courante, puis les copier dans un tableur Google. Google Script permettant de le faire toutes les minutes, je ne me suis pas privé: ça rend les prises en comptes plus rapides lors de changements, et la charge est chez Google ...
• Depuis le script Python, lire cycliquement le contenu de ce tableur Google. Je n'ai pas changé le taux qui j'avais dans mon ancienne version (de l'ordre de 5mn)
• Depuis le script Python, envoyer cycliquement les températures des sondes, l'état de commande de chauffage (en route ou pas), la valeur de la température de consigne. Dans l'ancienne version, ces lectures étaient stockées toutes les 5mn, et envoyées vers le site web toutes les demi-heures, ce qui faisait que ce n'était guère exploitable sur le coup. Désormais, j'envoie ces données dans un autre tableur Google toutes les 3mn
• Générer les indicateurs (températures courantes) et les historiques. Les indicateurs et les courbes que l'on peut générer dans le tableur Google sont directement exploitables dans des pages web d'un Google site. Les historiques sont établis par Google script à partir des données sauvegardées toutes les 3 minutes: le script me fait des moyennes des mesures toutes les 15mn pour m'afficher un historique sur 4 heures, et des moyennes toutes les heures pour un historique à 48h

Le résultat...

Rendez-vous sur le site pour voir ce que ça donne !

Les scripts

Concernant Google Script, vous trouverez une approche dans ce post.

Côté Python, c'est ici qu'il faut aller voir ... un post arrive prochainement

Domotique: Echanger des SMS avec son Arduino

Mon Arduino m'envoie des SMS (et je le lui rends bien ...)
J'ai récemment complété mon installation domotique existante (une commande de chauffage décrite dans ce blog, ainsi qu'un système d'alarme ... pas décrit ...) avec un système de commandes (et de retours de la part de mon installation) par SMS interposés.
Plutôt que d'investir dans un shield officiel (qui tourne autour de 50 euros, ce que je trouve hors de prix), j'ai préféré la réutilisation d'un ancien téléphone portable qui trainait dans un de mes tiroirs: un Sagem MyX4.
Avantage: ce téléphone a encore un port série, et se branchait sur un port DB9 de PC.
En interfaçant mon Arduino sur le câble série d'origine, moyennant le passage par un adaptateur MAX232 acheté sur e-bay, il est très simple de communiquer avec lui.

Certains téléphones GSM sont en effet équipés d'un modem, et acceptent les commandes AT.
Le protocole AT permet, au moyen d'une simple ligne de commande, d'envoyer ou lire un SMS.

Compatibilité AT
Tous les téléphones GSM n'étant pas équipés d'un modem, un petit test préliminaire (depuis un PC) s'impose.
Tout d'abord, il faut relier le téléphone à un port série du PC, puis configurer (si possible, ce qui est normalement le cas des anciens téléphones se branchant sur port série) la vitesse du port série. Le MyX4 permet par exemple de faire des échanges à une vitesse maxi de 38400bd.
Lancer ensuite un hyper terminal sous Windows, en choisissant la configuration suivante:

Dans le terminal, saisir ensuite (attention, il va falloir suivre, c'est complexe !):
AT puis appuyer sur Entrée

Si le téléphone est compatible, il va répondre:
OK

Vous pouvez prendre une pause bien méritée ...

Format des SMS
Saisir ensuite AT+CMGF?
Si le téléphone répond 1, c'est gagné, vous pourrez envoyer des SMS au format texte. Attention cependant, le format texte implique des envois avec du texte simple sans caractères accentués.
Si le téléphone répond 0:
Saisir AT+CMGF=1 pour tenter de forcer le mode texte.
Si le téléphone répond ERROR, votre tel n'acceptera d'envoyer / recevoir des SMS qu'au format PDU. Allez donc faire un petit tour sur cette page ...

Envoyer un SMS
Tapez AT+CMGS="num_tel_cible" puis Entrée
Un prompt > s'affiche
Tapez le contenu du SMS, puis CTRL-Z pour envoyer
Le téléphone va vous répondre quelque chose du genre: +CMGS:01

Après quelques secondes, votre destinataire va recevoir votre SMS

Recevoir un SMS
Il va falloir déterminer où sont stockés vos SMS reçus. C'est normalement configurable dans le téléphone, mais une commande AT va vous permettre de vous aider. Les SMS peuvent être soit stockés dans la mémoire du téléphone (ME), soit sur la sim (SM).
Si vous lisez à un endroit où il n'y a pas de SMS, le téléphone ne vous répondra rien lors de vos demandes de lecture.
Choisissez tout d'abord la zone de stockage. Par exemple, pour lire la mémoire du téléphone, tapez:
AT+CPMS="ME"

Pour lire les SMS, tapez ensuite AT+CGML="ALL"
Si un/des SMS se trouvent dans la zone choisie, vous aurez droit à une réponse du genre:
+CGML:900,"REC UNREAD",+336xxxxxxxx",,12/02/13,19/99/99+02"
CONTENU DU SMS

Effacer les SMS
Pour supprimer un SMS, il suffit (normalement) de saisir:
AT+CGMD=Indice_du_SMS
Il se trouve que cette commande ne fonctionne pas sur mon tel. Par contre la commande suivante fonctionne sans problème:
AT+CGMD=1,4
J'ai trouvé cette astuce je ne sais plus trop où. En gros elle doit supprimer tous les SMS reçus, ou au moins les 4 premiers. Toujours est-il que cette commande fonctionne.

Via Arduino
L'envoi ou la réception depuis l'Arduino est somme toute très simple: il suffit de fixer la vitesse du port série à la même vitesse que celui du téléphone, puis de communiquer via Serial.print ou Serial.read.
Pour ma part les commandes implémentées sont assez simples: Th20 pour fixer le chauffage à 20°, ou ThOff pour l'éteindre. Même chose pour l'alarme: AlaOn ou AlaOff.

Mon installation domotique me répond à toute mes commandes pour m'indique si elle a bien pris en compte. De même, je suis prévenu si l'alarme se déclenche ...

Sans trop investir, il est donc possible de s'ouvrir pas mal de possibilités. Et merci à Free, qui permet de faire tout ça pour 2€ par mois !

Une solution alternative, 2 euros moins cher !

Moyennant quelques restrictions, vous n'aurez besoin ni d'abonnement Free, ni même de modem !

Il y a quand même 4 (plus ou moins grosses) limites:
- seul votre Arduino pourra vous sms-er
- il faudra éviter les surconsommation sous peines de blocages (temporaires), mais cette limitation est contournable si vous avez les data actives sur votre téléphone (pour recevoir les notifications de l'agenda Google)
- seul le titulaire de l'agenda Google sera prévenu
- il faut que votre Arduino puisse communiquer avec un PC (via la liaison série par exemple)


Il suffit pour cela de détourner un peu l'utilisation de base de Google Calendar.

A chaque fois que vous créez une tâche dans l'agenda Google, il est possible de paramétrer cette tâche afin d'être prévenu par SMS, alerte ou e-mail.
Il suffit donc de faire un petit script pour qu'il crée une tâche avec demande de SMS et/ou de notification, et vous recevrez ce SMS et cette notif après quelques secondes. Après essais d'une 20aine de tâches (sur une courte période, il s'avère que les SMS ne passent plus (Google doit faire un blocage) mais ça revient très vite, et ça ne coupe même jamais si on n'abuse pas.
Dans tous les cas, les notifications, elles passent toujours (mais il faut garder les data actives sur le téléphone récepteur)

Côté Arduino
En partant du principe que votre Installation Arduino détecte l'évènement à notifier par SMS, et que le PC fait le traitement de création de tâche, autant dire que la notification Arduino->PC est plutôt simple: un simple Serial.Println d'une chaine de caractères quelconque fera l'affaire.

Côté PC
Google fournit une API permettant de créer des évènements (ou de les lire, comme dans mon installation de commande de chauffage) avec Calendar.
Pour ma part j'ai choisi de m'interfacer avec Calendar via des scripts Python.

Voici donc le script permettant de créer ces évènements:

try:
    from xml.etree import ElementTree
except ImportError:
    from elementtree import ElementTree
import gdata.calendar.service
import gdata.service
import atom.service
import gdata.calendar
import atom
import base64
import time

def send_sms(message_text):
    cal_client = gdata.calendar.service.CalendarService()
    cal_client.email = "identifiant GMAIL"
    cal_client.password = "mot de passe GMAIL"
    cal_client.source = 'calendar-sms-misuse-1.0'
    cal_client.ProgrammaticLogin()

    event = gdata.calendar.CalendarEventEntry()
    event.title = atom.Title(text=message_text)
    event.content = atom.Content(text="")

    
    # Les notifs par SMS ne fonctionnent pas si elles ne sont pas programmées pour être déclenchées
    #  au moins 5mn avant le début de la tâche
    # On crée donc une tache commencant dans 6mn, d'une durée de 1mn
    start_time = time.strftime('%Y-%m-%dT%H:%M:%S.000Z', time.gmtime(time.time()+(6*60)))
    end_time = time.strftime('%Y-%m-%dT%H:%M:%S.000Z', time.gmtime(time.time() + 7*60))
    when = gdata.calendar.When(start_time=start_time, end_time=end_time)
    # On crée une alerte à 5mn:

    # Dans le cas où on veut être alerté par tous les moyens possibles
        reminder = gdata.calendar.Reminder(minutes=5, extension_attributes={"method":"all"})
    # Dans le cas où une notif suffit
        reminder = gdata.calendar.Reminder(minutes=5, extension_attributes={"method":"alert"})
    # et dans le cas d'un SMS
        reminder = gdata.calendar.Reminder(minutes=5, extension_attributes={"method":"alert"})
        
    when.reminder.append(reminder)
    event.when.append(when)

    cal_client.InsertEvent(event, '/calendar/feeds/default/private/full')



send_sms("contenu du SMS")

En espérant que ces 2 méthodes vous soient utiles !

Domotique - Température: Commander le thermostat depuis un PC

Afin de compléter les possibilités de commande de mon thermostat, j'ai développé une petite interface tournant sous Windows.
Cette interface est codée en Visual Basic.
Je fournis l'exécutable, et le code source pour les courageux.

L'utilisation directe de l'exécutable est possible tel quel: il suffit de mettre à jour le fichier de configuration joint (répertoire Dropbox, référence des sondes) et c'est parti !
Seule limitation: je n'ai que 3 sondes, donc seules 3 sondes apparaîttront, c'est codé en dur !

Si bien-sûr vous voulez des modifications (pas trop lourdes !), je suis dispo à vous les faire et les livrer, il suffit de me contacter
.
La modification du code source est simple: il suffit de télécharger Microsoft Visaul Basic Studio Express qui est gratuit.

Interface

Le but de ce petit programme (déguisé en widget sur le bureau Windows) est de permettre de consulter la température courante délivrée par les différentes sondes, ainsi que l'état du thermostat, et de pouvoir modifier la programmation courante.
Une modification de la programmation courante sera prioritaire sur ce qui est programmé sous Google Calendar.

Il est ainsi possible de modifier ponctuellement l'état du chauffage sans avoir à rajouter/modifier ou supprimer  une plage de programmation au travers l'agenda. C'est pratique et rapide !

J'ai volontairement limité le choix des déclenchements afin que ce soit au plus simple et au plus rapide (pour répondre à une demande pressante de ma femme ...). Il est ainsi possible de:

• forcer une température, de 17° à 22°, par pas de 1°
• forcer l'extinction du chauffage, sans condition de température
• forcer la mise en marche du chauffage, sans condition de température
• revenir au mode Automatique (contrôlé par l'agenda)

Ces consignes peuvent être déclenchées sur 30mn, 1h, 1h30, 2h, sauf le forçage de la mise en marche, qui par sécurité est bloquée à 30mn.

Voilà !

C'est tout simple, mais on s'en sert tous les jours !

Fonctionnement

Je voulais une interface avec un taux de mise à jour plus élevé que ce que me fournie la page web.
Autant la page web est conçue pour visualiser une tendance et avoir un aperçu de l'historique, autant le panneau de commande Windows se doit d'être à jour, car le besoin est immédiat.
Afin de ne pas avoir des accès web trop fréquents (mes craintes ne sont peut-être pas justifiées, mais bon ...), j'ai choisi une synchronisation des données dans un répertoire partagé: le PC récupérant les données de l'Arduino sauvegarde une trame toutes les minutes dans un répertoire partagé, que le panneau va interroger sur les autres PC.
L'écriture du fichier est effectuée par le prog Python (le même que celui qui met le répertoire Dropbox à jour).

Une petite capture d'écran pour finir en images ...

Fichiers

Exécutable

• Dézipper le fichier joint
• Installer l'exécutable (setup.exe)
• Dézipper le fichier de configuration dans un répertoire c:\controle_th
• Modifier le contenu du fichier de configuration avec vos données

Exécutable

Dézipper le fichier joint.

Bonnes modifs !

Je suis d'ailleurs preneur des évolutions !

Domotique - Surveillance vidéo

Je viens de faire l'acquisition d'une caméra pour un prix super compétitif, surtout en regard de ses capacités.

Tout d'abord, je précise que cette caméra n'a besoin d'aucun autre équipement pour fonctionner, et donc pas d'un Arduino, mais l'interfacer avec celui-ci dans certaines réalisations (comme ajouter un canal vidéo sur un robot, ou faire une alarme maison) permettra d'en tirer le meilleur sans trop se prendre la tête avec la transmission vidéo, ou le pilotage de cette caméra.

J'ai donc acheté cette caméra sur e-abay, chez ce vendeur, pour moins de 50 euros fdp.

En farfouillant un peu le web, j'ai aussi découvert que cette marque (Tenvis) était assez bien documentée sur un site dédié, quand ce site marche (il arrive que ça ne réponde pas, et quand ça répond, le téléchargement des docs et softs prend du temps ... mais pas de soucis, j'ai téléchargé tout ce qui pouvait y être téléchargé !).

Présentation de la caméra

La boite. On ne peut pas dire que ça ne fait pas sérieux

La caméra, posée sur ma Freebox, histoire d'avoir un rendu de la taille

Les caractéristiques sont alléchantes: caméra wifi, voies jour et nuit, 300.000 pixels, télécommandable depuis un navigateur internet, sur réseau local ou via le web, mais aussi depuis un smartphone Android ou I-Phone. De plus, cette caméra à une fonction permettant de générer des alarmes sur détection de mouvement ou écart de luminosité (comme un éclairage de lampe en pleine nuit), entraînant l'envoi d'un e-mail avec photo, d'upload de photos sur serveur FTP, et/ou enregistrement d'une vidéo en local.
Pour finir, le soft livré avec (ou tout du moins téléchargeable sur le site cité plus haut) permet de commander plusieurs de ces caméras toujours par l'interface du navigateur internet.
La caméra à aussi une sortie directe, permettant de commander un autre appareil (un Arduino ? ;) ) sur alarme, mais je dois dire que je n'ai pas trop regardé: l'accès est masqué ce qui me laisse malheureusement penser que mon modèle ne l'a pas :(

D'après mes premiers essais, cette caméra fait bien son taf: la vidéo est bien de nuit comme en plein jour mais attention: elle fait 300.000 pixels, il ne faut pas s'attendre non plus à du HD !

Caractéristiques détaillées
Caméra
- connexion internet RJ45 100base-Tx
- connexion wifi b/g avec clé WEP/WPA
- caméra 300000 pixels
- résolution 640x480, 320x240, 25 img/secondes
- télécommandable en pan/tilt
- Alarme sur détection de mouvement, avec notification par e-mail ou FTP et enregistrement possible de la séquence video en local, via le logiciel de surveillance

Logiciel de télésurveillance sur PC
le logiciel est un client web, qiu peut fonctionner avec divers plugins:
- sous IE, via ActiveX
- sous tous navigateurs, via VLC ou en mode push

Le client ActiveX est le mieux intégré, talloné de peu par celui sous VLC. Seul bémol sur le client ActiveX: il ne permet pas de zoomer la caméra.
Parmi les possibilités offertes par le logiciel:
- afficher la video en provenance de plusieurs caméras
- diriger la caméra en pan/tilt
- changer la résolution de la caméra
- tourner l'image de 180° et en miroir
- activer le retour audio
- effectuer un enregistrement manuel
- effectuer un enregistrement auto si le mode Alarm de la caméra est activé
- de prendre une photo
- configurer la caméra (mail, FTP, wifi ...)

Logiciel de télésurveillance Android
Il permet:
- de diriger la caméra, manuellement ou en continu (balayage droite-gauche, haut-bas, combinés ou non)
- de prendre une capture d'écran

Il existe aussi une version pour I-Phone, qui doit fournir les mêmes prestations

Mise en route et Configuration


Le soft permet de créer plusieurs utilisateurs avec 3 profils possibles:

Sur la partie gauche se trouve la liste de tout ce qui peut être configuré. Voici ci-dessous les IHM des principaux paramètres. Si vous désirez en voir d'autres, demandez, je posterai les captures d'écran.

L'adresse IP peut être affectée soit à partir d'un serveur DHCP, soit en statique. J'ai tout d'abord configuré le soft afin d'obtenir une IP dynamique, puis reconfiguré ensuite afin d'avoir une IP statique. Cette manip permet de récupérer les autres paramètres (gateway ...) sans avoir à trop se prendre la tête, tout en étant sûr de conserver la même IP par la suite

La conf Wifi est on ne peut plus simple: il suffit de scanner le réseau, puis de sélectionner le réseau dans la liste, et enfin de rentrer les params d'identification

La conf mail m'a posé quelques soucis. Pas trop à cause du soft de la caméra, mais surtout car (sous Gmail en tout cas) il faut aller dans les params de votre compte autoriser les connexions SMTP.

Voici un aperçu de la configuration des alarmes. Le niveau de sensibilité peut être réglé. Au dessus de 5, la caméra a tendance à balancer des alarmes au moindre changement de luminosité (un rayon de soleil par exemple).
Le triger level sur low est inutilisable ou je n'ai pas trop compris comment l'exploiter: il me génère des alarmes permanentes.
Le scheduler est bien fait: inutile de cliquer sur toutes les petites cases: un double clic dans une tranche horaire permet de sélectionner la tranche horaire complète. Pouvoir enregistrer plusieurs profils aurait été sympa, de même que ne pas perdre la configuration lorsqu'on décoche/recoche la case Scheduler !

Pour en finir avec la configuration, il est même possible de configurer la caméra pour quelle se place en position centrée au démarrage, ou qu'elle garde sa position courante. Cette option peut être utile en cas de couplage de la caméra avec un système de mise sous tension (afin de pouvoir faire un scheduler externe par exemple)
Il est aussi possible de régler les vitesses de déplacement en pan et tilt.

Fichiers disponibles sur Tenvis.com
J'ai à peu près tout essayé au niveau des softs.
Ils sont disponibles ici. Pour certains je n'arrive rien à en tirer, ils ont l'air pourtant pas mal (DVSImageCenter par exemple).
Au final, aucun soft n'est nécessaire à partir du moment où vous connaissez l'IP de la caméra: un simple navigateur suffit.


Conclusion
Cette caméra est donc un très bon produit, surtout pour ce prix défiant toute concurrence ... Son utilisation ne se limite pas seulement à de la vidéo surveillance: en mettant en oeuvre le fichier jar, il devrait être possible de commander cette caméra au travers d'un programme "maison", permettant par exemple de l'intégrer parfaitement dans une IHM de commande de robot.
Il est aussi peut-être possible de récupérer le signal vidéo au travers d'autres logiciels de streaming. C'est à étudier, mais mes connaissances dans le domaine sont tout de même très limtiées.

Sous peu, je joindrai à ce post quelques vidéos de jour et de nuit.

Domotique - Température: Thermostat on the www, Google Calendar est mon ami

Suite à la mise en oeuvre du DS18B20, je m'étais fait une petite page web (en complément de celle présentant les courbes) permettant de régler la température désirée, ainsi que le capteur sur lequel étaient réalisés les contrôles.
Le côté pratique de cette page est vite apparu: il était possible de modifier la température de n'importe où dans le monde, que ce soit à la maison ou ailleurs, du moment qu'un accès web était présent.

D'un autre côté, il n'était pas possible de programmer la température désirée sur le long terme, et transformer ladite page web pour en faire un point d'entrée de thermostat d'ambiance me freinait à plusieurs niveaux:

• faire une IHM au format html (ou autre) permettant de facilement programmer plusieurs plages de températures sur plusieurs jours (et sans se limiter, comme sur certains thermostats, à 2 niveau de chauffe possibles et des plages découpées à la demi-heure) est mission impossible ou presque (et je n'ai pas que ça à faire)
• il fallait ensuite envoyer l'info à mon serveur à la maison pour que ça finisse d'une manière ou d'une autre dans mon Arduino
• il fallait enfin modifier le sketch de l'Arduino afin que lui aussi gère toutes ces données, et cette mission me paraissait aussi plaisante que celle du premier point

J'ai donc cherché sur le web des solutions clés en main, sachant que l'aspect graphique devait être pré-maché au maximum: j'ai réalisé cette installation pour l'aspect Arduino, pas pour passer des heures à faire des pages web.

Je suis donc rapidement tombé sur le seul candidat potentiel: le calendrier de Google, d'autant que j'ai vite vu que Python est l'ami de Google, et que des librairies de mise en oeuvre sont existantes.

Google Calendar permet de s'affranchir de tout l'aspect graphique, est utilisable partout car il n'y a pas de client à installer, et marche même dans l'univers Android. On peut donc même faire chauffer la maison quand on est dans le train, histoire qu'il fasse bon quand on arrive à la maison !

Pré-requis
Pour pouvoir mettre en oeuvre cette interface entre Google Calendar et Arduino, il faut:

• Un accès Gmail
• L'id du calendrier
• un PC faisant l'interface entre Arduino et le www, hébergeant un script python qui va récupérer les données dans Google Calendat

Accéder à Google Calendar

Sous Google Calendar, afin de ne pas trop polluer mon planning utilisé pour la vie courante, j'ai créé un nouvel agenda en cliquant sur la liste déroulante située à coté de Mes agendas

Il faut ensuite récupérer l'ID de cet agenda, il nous sera utile pour y accéder depuis le code Python.

Cliquer sur la liste déroulante située à côté de l'agenda créé (Thermostat dans mon cas), puis sur Propriétés

L'ID de l'agenda est visible au niveau de l'URL.

Attention à ne pas récupérer l'adresse dispo au niveau de la zone d'insertion du planning: ça risque de ne pas fonctionner

Thermostat d'ambiance

L'avantage indéniable de l'utilisation d'un agenda est de pouvoir définir des plages de chauffe précises, répétables facilement, et dans lesquelles il est possible de définir une température précise.

Mon choix s'est porté sur la synthaxe suivante:

Th_nom-sonde:température-désirée

En complément, j'ai défini une synthaxe simplifiée:

Th_nom-sonde, ou même Th_

Dans ce cas, la température appliquée est une température définie en configuration (par l'intermédiaire d'une page web).

Afin de ne pas avoir à tapisser tout le planning de plaquettes, une absence de plaquette entraîne l'application  automatique d'une autre température de consigne, telle que la température hors gel qu'on trouve sur les thermostats habituels

Il est donc toujours possible d'utiliser le thermostat à minima:

• pas de plaquette = température hors gel
• plaquette sans consigne = température de consigne

Google Calendar est interrogé toutes les 5mn. Par l'intermédiaire d'une séquence spécifique, il est possible de forcer une interrogation immédiate de l'agenda

Paramètres par défaut

En complément des 2 températures une valeur de delta (écart de température à atteindre pendant le cycle de chauffe avant l'arrêt du chauffage) est définie, ainsi qu'un capteur de température.

Ces paramètres sont modifiables par l'intermédiaire d'une page web sécurisée, et récupérés toutes les 10mn par le script Python.

Par l'intermédiaire d'une séquence spécifique, il est possible de forcer une prise en compte immédiate de ces valeurs

Zoom sur les échanges de données

Ci-dessous, un résumé (un peu succinct) des échanges entre les modules principaux: web, PC, Arduino:

Récupérer les données de Google Calendar
Le code Python permettant de récupérer les données de Calendar est simple. Il récupère la liste des évènements de la journée, puis contrôle si des évènements sont actifs au temps courant.
Si un évènement est actif, le titre de la tâche est récupéré puis traitée pour être transmise à l'Arduino

Connexion à Google Calendar sur la plage désirée (la journée courante):

import gdata.calendar.service
import gdata.calendar
import datetime

cal_client = gdata.calendar.service.CalendarService()
cal_client.email = "VOTRE_LOGIN"
cal_client.password = "VOTRE_PASSWORD"
cal_client.source = 'Google-Calendar_Python_Sample-1.0'
cal_client.ProgrammaticLogin()

query = gdata.calendar.service.CalendarEventQuery('ID_CALENDAR@group.calendar.google.com', 'private', 'full')
auj=str(datetime.date.today())
query.start_min = auj
dem=str(datetime.date.today()+datetime.timedelta(1))
query.start_max = dem
feed = cal_client.CalendarQuery(query)

Contrôle des heures début/fin des consignes:

for event in feed.entry:
    for a_when in event.when:
        str_date_deb=a_when.start_time
        # Passage du format str au format datetime, pour pouvoir contrôler ensuite les heures de début/fin avec l'heure courante:
        date_deb = datetime.datetime(int(str_date_deb[0:4]) , int(str_date_deb[5:7]), int(str_date_deb[8:10]), int(str_date_deb[11:13]), int(str_date_deb[14:16]), int(str_date_deb[17:19]), int(str_date_deb[20:22]))
        str_date_deb=a_when.end_time
        date_fin = datetime.datetime(int(str_date_deb[0:4]) , int(str_date_deb[5:7]), int(str_date_deb[8:10]), int(str_date_deb[11:13]), int(str_date_deb[14:16]), int(str_date_deb[17:19]), int(str_date_deb[20:22]))
   
        if ((date_deb<=datetime.datetime.now()) and (date_fin>=datetime.datetime.now())):
              print "Cons.:",event.title.text  
              print "Debut:",date_deb
              print "Fin:",date_fin

Voilà !
Vous avez normalement tous les outils vous permettant de lire le contenu de Google Calendar. Google permet aussi bien d'autres actions, comme créer de nouvelles entrées par exemple.

PS: Merci à Code 18 pour cette modif permettant d'insérer du code proprement dans blogspot !

Domotique - Température: Le traitement des trames côté PC

Le traitement des trames côté PC est effectué à l'aide d'un script écrit en Python.
Le script lit les trames sur le port série et les enregistre toutes les 5mn dans un fichier (ce qui donne une précision correcte). Toutes les 10mn, le script envoie le contenu du fichier au serveur web.


Lors de la lecture d'une trame sur le port série, le script Python ajoute une info de datage car l'Arduino ne le permet pas (à moins de l'équiper d'un DTC1307).


Accessoirement, le script fait, toutes les 24 heures, le ménage dans le fichier émis pour ne pas que celui-ci grossisse de trop.
Les données supprimées du fichier sont sauvegardées dans un fichier d'historique, avec une précision de 2 heures.
Ce fichier est lui aussi envoyé vers le serveur pour un affichage ultérieur.

Explications du script, dans les grandes lignes:

Déclaration du port série et lecture du port:
Nota: La lecture du port série nécessite d'installer la librairie pyserial.

import serial
ser = serial.Serial('COM4',9600) # Le num de port est à récupérer sous Windows. La vitesse doit être cohérente de celle configurée sur l'Arduino
line = ser.readline() # Lecture d'une trame sur le port série

Connexion à un serveur ftp et envoi de fichier:
connect = ftp.FTP(host,user,password) # on se connecte au serveur ftp

                                                            # host: adresse du serveur FTP
                                                            # user: votre identifiant
                                                            # password: votre mot de passe

a = open('TempsData.txt', 'rb') # On ouvre le fichier à envoyer en binaire
connect.storbinary('STOR TempsData.txt',a) # On envoie le fichier de données
a.close()


Le script Python est téléchargeable ici.

A bientôt pour la partie PHP (mais ça ne va pas être pour tout de suite, il faut que je fasse un peu de ménage dans le script)

Domotique - Température: Le résultat en courbes

Avant de mettre le sketch et les scripts Python et PHP en ligne, je vous invite à visualiser les courbes de températures comme si vous y étiez !
Ce sont les vraies, issues des capteurs !

Pour info, j'habite Vauréal. Vous pourrez donc à partir d'aujourd'hui connaitre la température extérieure ;)

Le tout est visible ici

Il reste quelques affinages à faire sur le dessin des courbes, notamment l'historique complet, et l'échelle verticale lorsque la sonde extérieure n'est pas sélectionnée.

Domotique - Température: Trame Arduino et sketch

Désirant pouvoir mettre en oeuvre un système permettant de rajouter / d'enlever des capteurs de température en ayant un minimum de mises à jours à effectuer, il était nécessaire de définir une trame d'envoi de données permettant de contrôler certains paramètres, tels que la présence d'une sonde par exemple.

La trame émise par l'Arduino a donc la forme suivante:

nb_capteurs;ref_capt1;Temp_capt1;ref_capt2;Temp_capt2;ref_capt3;Temp_capt3.....

En cas de retrait du capteur 2 par exemple, on se retrouve avec une trame du genre:

nb_capteurs;ref_capt1;Temp_capt1;ref_capt3;Temp_capt3.....

Les modules placés en aval seront donc aptes à connaître le nombre de capteurs branchés, et surtout d'associer les données de température aux bons capteurs.

Il est donc nécessaire de connaître le nombre de capteurs branchés à l'Arduino avant même d'envoyer des données sur le port série. En One-wire il n'y a pas, à ma connaissance, de moyen d'interroger la ligne afin d'avoir un retour du nombre de modules qui y seraient branchés.

Dans la pratique, le sketch Arduino effectue un reset de la ligne One-wire, puis interroge séquentiellement tous les capteurs de la ligne.

Lorsqu'aucun capteur ne répond plus, toute la chaîne a été parcourue, il faut refaire un reset pour réinitialiser la séquence de récupération de données. C'est donc lorsque toute la chaîne est parcourue que l'on connait le nombre de capteurs.

Il faut donc, à l'issue de la récupération de toutes les valeurs, envoyer le tout sur le port série.

Pour faciliter le stockage, j'ai choisi de travailler avec des chaines au format String, largement plus pratique que les tableaux de chaînes. Les classes String, non documentées dans le référentiel Arduino français le sont par contre dans la version anglaise de l'aide officielle

Génération de la trame:

Séquentiellement, les données vont être récupérées comme suit:

La trame finale:

3;4e87;19.9;c172;20.0;4574;18.5;
3;4e87;19.9;c172;20.1;4574;18.3;
3;4e87;19.9;c172;20.0;4574;18.1;

Les valeurs des 3 capteurs, référencés 4e87, C172, 4574 sont récupérées et envoyées sur la trame.
Ces références sont directement issues des ref 64 bits des composants.


Le sketch
Comme je l'ai déjà indiqué, ce sketch est tiré directement de l'excellent exemple de mise en oeuvre du DS18B20 sur le site mon-club-elec.fr, ici-même.
Les principales modifications concernent:
- la possibilité de mettre en oeuvre plusieurs capteurs
- la génération de la trame à l'issue de la lecture de tous les capteurs

Le sketch est disponible ici

Domotique - Température: Les modules de traitement

N'ayant pas de shield éthernet sous la main, j'ai attaqué ce projet en traitant les données par l'intermédiaire d'un PC.

Dans la pratique, la platine Arduino récupère les infos des capteurs de température, génère une trame avec toutes les données, et diffuse cette trame sur la liaison série.

Le PC récupère cette trame, et l'enregistre périodiquement dans un fichier de log.

Cycliquement, le fichier de log est envoyé sur le serveur Web.

La page web est générée sur le serveur web, au moyen d'un script PHP.

Côté PC, le traitement est effectué en Python.

Alternatives possibles:

La première d'entre elle est bien sûr de mettre en place un shield éthernet pour pouvoir se passer d'un PC.

Une autre alternative possible (si on reste dans le cas de l'utilisation d'un PC) est de se passer d'un serveur web. Il suffit de sauvegarder les données sur un service éthernet permettant de partager des fichiers, tel que Dropbox.com. Le service Dropbox s'utilise comme un répertoire local. Il suffit d'y sauvegarder un fichier pour le retrouver quelques secondes plus tard (pour des tailles de fichier raisonnables) sur tous les autres PC connectés au même compte Dropbox.

Domotique - Température: cahier des charges

Voici, dans les grandes lignes, ce à quoi doit répondre mon installation ... A noter que cette liste peut évoluer à tout instant en fonction des mes envies !

- Contrôler la température dans plusieurs pièces de la maison et en extérieur.
- Etre en mesure de pouvoir rajouter/retirer des capteurs sans à avoir à tout reprendre au niveau de la programmation, ni sans avoir à tout redémarrer
- Pouvoir visualiser la température à l'instant courant, mais aussi les variations sur les x dernières heures, x pouvant être modifié
- Pouvoir effectuer cette visualisation depuis n'importe quel ordinateur connecté à internet


Je pense pouvoir dire que ces critères sont remplis, même s'il reste des choses à faire au niveau de la gestion de l'affichage.

Avant d'aborder les aspects logiciels et matériels, voici un petit aperçu de relevés sur 3 capteurs ...

Domotique - Température: le DS18B20

Dans le cadre d'un de mes projets, je recherchais un moyen de mesurer une température, sans avoir à me prendre la tête à faire des montages complexes pour étalonner le capteur, convertir les mesures en numérique et j'en passe.

Je suis rapidement tombé sur un capteur répondant à mes critères: le DS1820.
Ce capteur a même 2 autres atouts, qui m'ont amené à initier mon projet de domotique:
- sa techno one-wire, qui, comme son nom ne l'indique pas, permet de mettre en oeuvre ce composant avec 2 fils seulement, et surtout permet d'utiliser plusieurs capteurs sur ces 2 mêmes fils !
- sa résolution. J'ai jeté mon dévolu sur le DS18B20 qui a une résolution de 0.0625°. Je me dis qu'avec une telle précision, il doit être fiable ;) A noter qu'il existe le DS18S20, qui a une résolution plus faible

Autre atout, et de taille: le web regorge d'exemples de mise en oeuvre avec l'Arduino. Je n'ai donc pas réinventé la poudre et je me suis largement inspiré de ce qui est très bien présenté sur le site mon-club-elec

J'ai cependant retouché le sketch car il ne répondait pas vraiment à mon cahier des charges, à savoir:
- permettre de relier plusieurs capteurs de température: dans sa version d'origine, et malgré ce que j'ai cru comprendre dans les explications, le sketch ne permet d'interroger qu'un seul capteur
- ne pas limiter l'installation domotique à un nombre de capteurs fixe, ce qui nécessiterait des retouches trop complexes en cas de modifications (ajout/retrait) de capteurs. Le sketch modifié envoie, en plus des valeurs mesurées, les ref des capteurs ainsi que le nombre de capteurs détectés

/Flash: Après le proto ...

Après pas mal de km parcourus, et surtout avant les km à parcourir pour les vacances, il était temps de passer sur un avertisseur un peu plus facile à intégrer dans la voiture, en passant sur un modèle avec un ATMega 328 en stand alone.
Toutes les fonctions logicielles développées sur le proto sont présentes, par contre les sketchs en V0.x ne sont pas compatibles.

Le schéma

Le PCB est composé de 2 cartes: une partie dans le compartiment moteur, une seconde (encadrement orange) dans l'habitacle. La carte SD, le bouton poussoir permettant l'enregistrement de nouveaux radar, le buzzer (avec un inter permettant de le faire taire au cas où), restent à portée de main et d'oreille ...

Le sketch vient prochainement, le temps de faire un peu de ménage dedans ...

GrandRoue: Ca se termine !

Edit du 22/06: Ajout d'un mode d'emploi un peu plus graphique ...

Mon horloge a fonctionné pendant quelques jours, et quelques mises à jour se sont faites sentir pour diversifier les modes d'affichage possibles ...

Modes d'affichage:
Il y a désormais 4 modes d'affichages possibles, et chacun de ces mode peut être associé à un des 3 niveaux de luminosité pré-définis: en obscurité totale, en luminosité maximale, et en luminosité normale.

Les 4 modes d'affichage sont:

• Minimal:
• Heures sur 2 LED
• Minutes sur 1 LED
• Pas de secondes
• sans trotteuse:
• Heures sur 3 LED
• Minutes sur 2 LED
• Pas de secondes
• Normal:
• Heures sur 3 LED
• Minutes sur 2 LED
• Secondes sur 1 LED
• Video inverse:
• L'affichage des LED est inversé par rapport au mode normal: les aiguilles sont représentées par des LED éteintes, le reste de la roue étant allumé

Ces modes permettent d'adapter l'affichage à la luminosité ambiante: en complément de l'intensité d'éclairement des LED qui était déjà implémenté, la vidéo inverse permet par exemple d'avoir un max de luminosité tandis que l'affichage minimal permet d'alléger au max cet affichage tout en permettant de connaitre l'heure (idéal dans une chambre par exemple).

Des photos arriveront bientôt pour illustrer tout ça, mais prendre des LED en photo n'est pas facile, surtout quand il ne fait pas très jour ...

Sauvegarde des paramètres:

Les mode d'affichage sont configurables sans reprogrammation, avec les interrupteurs. Les valeurs sont sauvegardées automatiquement, ce qui permet de les conserver en cas de coupure (et de les réappliquer au démarrage suivant)

Réglages:

1. Appui de 5 secondes sur le bouton Enter
• les minutes et secondes s'effacent pour permettre le réglage des heures (par appui sur '+' & '-')
2. Appui sur le bouton Enter
• Les heures sont enregistrées
• Les heures sont effacées, les minutes sont affichées pour permettre leur réglage
3. Appui sur le bouton Enter
• Les minutes sont enregistrées
• Les secondes sont passées à 0
• Les 3 LED du haut (59, 0, 1 minute) s'allume pendant 5 secondes:
• Si pas de nouvelle action pendant ces 5 secondes: fin des réglages
• Si appui: Les réglages continuent pour affecter les modes d'affichages:
4. Appui sur le bouton Enter en moins de 5 secondes:
• La LED 0 s'allume pendant quelques secondes: réglage du mode de luminosité normal
• puis 4 groupes de 3 LED s'allument:
• bas gauche=mode mini
• haut gauche=mode sans trotteuse
• haut droit=mode normal
• bas droit=vidéo inverse
• Le mode sélectionné est représenté par l'extinction de la LED du centre dans un des groupes. Le changement de mode se fait par les boutons '+' & '-'
5. Appui sur le bouton Enter
• La LED 15 s'allume pendant quelques secondes:réglage du mode de luminosité max
• Même procédure que précédemment
6. Appui sur le bouton Enter
• La LED 15 s'allume pendant quelques secondes:réglage du mode de luminosité max
1. Même procédure que précédemment
7. Appui sur le bouton Enter: Fin des réglages

Comme un dessin vaut mieux qu'un long discours, voici un mode d'emploi un peu plus graphique, téléchargeable ici ...

GrandRoue: Le sketch

Dernière version disponible: Version 03, intégrant les dernières fonctionnalités en terme de gestion de l'affichage


Merci tout de même de citer vos sources en cas d'exploitation ...

MAX7219: Piloter des LED ...

Le MAX7219 permet de contrôler des matrices de LED, mais aussi des afficheurs 7 segments, bargraphs...

Je ne traiterai que le cas que j'ai moi-même mis en oeuvre dans mon horloge: le driver de LED.


Son utilisation est assez simple: une librairie MATRIX existe pour en faciliter l'usage.

Cette librairie se résume (vue de l'extérieur) à une ligne de déclaration et 3 commandes:

• Déclaration:
• Matrix led_clock = Matrix(DIN, CLK, LOAD, nb_MAX);
  Les variables DIN, CLK, LOAD correpondent aux  num de pins Arduino reliées à ces signaux
  La variable nb_MAX correspond au nombre de MAX7219 mis en cascade. Jusqu'à 8 chips peuvent être mis en cascade
• Commandes:
• led_clock.setBrightness(taux);Permet de régler la luminosité, de 0 à 15. Le réglage se fait malheureusement pour toutes les LED de façon globale
• led_clock.clear();
  Eteint toutes les LED
• led_clock.write(col,rang,valeur);
  Affecte la valeur LOW ou HIGH à la LED située aux coordonnées x,y

Matrice de LED:

Brochage MAX7219:

Din, Load, Clock sont à relier à l'Arduino

Dout n'est utilisé qu'en cas d'utilisation en cascade de plusieurs MAX7219

Iset doit être relié au +5v par l'intermédiaire d'une résistance.

La valeur de cette résistance est à choisir avec précaution car le driver peut surchauffer en cas de mauvais dimensionnement. Un tableau de dimensionnement est disponible dans la datasheet, page 11. Voici son extract:

La datasheet indique d'autre part le positionnement d'une capa de 0.1µF entre la pin 19 et la masse

Sketch:

La mise en oeuvre du MAX7219 est on ne peut plus simple avec ces 4 instructions.

Tout se jouera sur l'imagination du développeur pour faire des animations recherchées.

Il suffit d'allumer/éteindre la LED visée. L'adressage se fait LED à LED (pas de traitement de groupe avec cette librairie)

GrandRoue: Horloge murale

Je vous présente ma dernière "création": une horloge murale (qui essaie d'être) design: GrandRoue

Elle est basée sur:

• un Arduino (bien-sûr !) , pour le moment c'est un Duemilanove mais ce sera une version Standalone dans la version finale de cette horloge
• un DS1307 RTC, pour lequel j'avais déjà fait une première approche dans ce billet
• un MAX7219, driver de LED, permettant de piloter jusqu'à 64 LED. Ca tombre bien: j'en ai 60 dans mon horloge ... sa mise en oeuvre est décrite ici

Les 60 LED sont dispatchées sur le pourtour de la "roue", et représentent chacune un 60ième d'heure.

Pour distinguer l'aiguille de l'heure des minutes et secondes, j'ai choisi le concept suivant:

• l'aiguille des heures est représentée par 3 LED allumées
• l'aiguille des minutes par 2 LED allumées
• l'aiguille des secondes par 1 LED

Fonctionnalités offertes:

Et bien elle donne l'heure !

Ni plus (pour le moment) ni moins ...

Il est bien-sûr possible de régler cette heure, et l'heure courante est conservée en cas de coupure de courant par la pile du module DS1307

Ajout en Version 02: la luminosité des aiguilles est ajustée en fonction de la luminosité ambiante.

Je pensais aussi rajouter une fonction minuterie (pour cuire les oeufs ;) ), voire une fonction réveil, mais je ne sais pas si je vais m'y pencher ...

Je rajouterai aussi certainement des petits effets lumineux qui tourneront toutes les heures, histoire de rendre le tout vraiment original

La GrandRoue en photos, et vidéo:

Pas facile de prendre des photos quand il fait sombre ...

Cette version est juste un test pour voir ce que pouvait donner une horloge avec ce design: elle fait 50cm, les LED sont "plantées" par l'arrière, dans de l'Isorel. Elles sont soudées sur de petites platines d'essais.

Dans la version finale, les LED seront sur des PCB par groupe de 8, et une plaque de plexi opaque couvrira les LED pour mieux diffuser la lumière (les plaques de plexi sont vendues en 50cm de côté, d'où la taille retenue ...)

Explications techniques:

Le sketch peut être décomposé en 2 grandes fonctions:

• La gestion du DS1307, comprenant la récupération de l'heure courante, le réglage, l'enregistrement d'une nouvelle heure. Le tout est déjà expliqué ici
• L'affichage de l'heure sur le cercle de LED. Cette fonction est gérée par le MAX7219.

Le MAX7219 gérant les LED sous forme de matrice de 8x8 éléments, j'ai numéroté mes LED comme suit:


C 1  2  3  4  5  6  7  8
R -----------------------
1 0  1  2  3  4  5  6  7
2 8  9  10 11 12 13 14 15
3 16 17 18 19 20 21 22 23
4 24 25 26 27 28 29 30 31
5 32 33 34 35 36 37 38 39
6 40 41 42 43 44 45 46 47
7 48 49 50 51 52 53 54 55
8 56 57 58 59


Il y a donc dans le sketch une petite moulinette permettant de passer d'un adressage matriciel à un adressage linéraire ...