Overblog Suivre ce blog
Administration Créer mon blog
21 mai 2012 1 21 /05 /mai /2012 11:56

Juste pour donner une idée de comment l'allumage des LED est fait en fonction de l'heure, voici le code de calcul de la matrice (avec le cadrant V3):

 

//matrice calculée. Chaque byte est une ligne de la matrice.

//Chaque bit est une LED de la ligne.

byte row[8];

 

/*

* calcul de la matrice h: heures, m:minutes, s:secondes (inutilisé)

*/

void calcMatrix(byte h, byte m, byte s){
  boolean cha=false;
  for(byte r=0;r<8;r++){
     row[r]=0;
  }
 
  //dian (heure)
  if(!(m==0 && (h==0 || h==12))){
    row[2] |= B00001000;  
  }  
 
  //cha (moins)
  if(m==45 || m==50 || m==55){
    row[2] |= B00000001;
    h++;
    if(h==24){
        h=0;
    }        
    cha=true;
  }

  //yeli (la nuit)
  if(h>=1 && h < 5){
    row[0] |= B00000011;
  }
 
  //zaoshang (tôt le matin)
  if(h>=5 && h < 8){
    row[0] |= B10100000;
  }
  //shangwu (tard le matin)
if(h>=8 && h <= 11){
    row[0] |= B00100100;
  }  
  //zhongwu (midi)
  if(h>=12 && h<14){
    row[0] |= B00001100;
  }    
  //xiawu (après-midi)
  if(h>=14 && h<18){
    row[0] |= B00010100;
  }
  //wanshang (soir)
  if(h>18){
    row[0] |= B01100000;
  }
  //wuye (minuit)
  if(h==0){
    row[0] |= B00000110;
  }
  //10h
  if((h>=10 && h < 12) ||(h>=22)){
    row[1] |= B01000000;
  }
  //0h
  if(h==0){
    row[1] |= B10000000;
  }
  //1h
  if(h==1 || h==11 | h==13 || h == 23){
    row[1] |= B00010000;
  }
  //2h
  if(h==2 || h==14){
    row[1] |= B00001000;
  }
   //3h
  if(h==3 || h==15){
    row[1] |= B00000100;
  }
  //4h
  if(h==4 || h==16){
    row[1] |= B00000010;
  }
  //5h
  if(h==5 || h==17){
    row[1] |= B00000001;
  }
  //6h
  if(h==6 || h==18){
    row[2] |= B10000000;
  }
  //7h
  if(h==7 || h==19){
    row[2] |= B01000000;
  }
  //8h
  if(h==8 || h==20){
    row[2] |= B00100000;
  }
  //9h
  if(h==9 || h==21){
    row[2] |= B00010000;
  }
 
  //zhong (heure pile)
  if(m==0 && h!=0 && h!=12){
    row[2] |= B00000100;
  }
  //ban (demi-heure)
  if(m == 30){
    row[2] |= B00000010;
  }
 
  //minutes

  //shi (dizaines de minutes)
  if((m>=10 && m!=15 && m!=45 && m!=30 && m!=50 && m!=55) || (m==50 && cha)){
   row[3] |= B00000010;
  }
  //d1
  if(m==45 || m==15){
    row[3] |= B10000000;
  }
  //d2
  if(m>=20 && m<30){
    row[3] |= B01000000;
  }
  //d3
  if(m>=30 && m<40 && m!=30){
    row[3] |= B00100000;
  }  
  //d4
  if(m>=40 &&  m!=45 && m<50){
    row[3] |= B00001000;
  }
  //d5
  if(m>50 && m != 55){
    row[3] |= B00000100;
  }
 
  //ke (quart d'heure)
  if(m==15 || m==45){
    row[3] |= B00010000;
  }
  //1
  if(m%10 == 1){
    row[3] |= B00000001;
  }
  //2
  if(m%10 == 2){
    row[4] |= B10000000;
  }
  //3
  if(m%10 == 3){
    row[4] |= B01000000;
  }
  //4
  if(m%10 == 4 && m!=45){
    row[4] |= B00100000;
  }
  //5
  if((m%10 == 5 && m!=15 && m!=45 && m!=55) ||(m==55 && cha)){
    row[4] |= B00010000;
  }
  //6
  if(m%10 == 6){
    row[4] |= B00001000;
  }
  //7
  if(m%10 == 7){
    row[4] |= B00000100;
  }
  //8
  if(m%10 == 8){
    row[4] |= B00000010;
  }
  //9
  if(m%10 == 9){
    row[4] |= B00000001;
  }  
}

Repost 0
Published by breizhmakers - dans horloge
commenter cet article
20 mai 2012 7 20 /05 /mai /2012 22:50

J'ai profité d'une semaine de 3 jours de boulot pour bien avancer l'horloge.

J'avais hâte d'essayer l'afffichage.

J'ai dû commencer par déterminer le brochage de la mini-matrice BL-M07C881 car manifestement il ne correspond pas à la datasheet!

Comme je l'ai indiqué sur le forum d'Adafruit, le brochage déterminé manuellement  est, avec la matrice (LED) faisant face à l'utilisateur:

Cx: colonne x

Lx: ligne x

 

C8 C7 L2 C1 L4 C6 C4 L1


L5 L7 C2 C3 L8 C5 L6 L3
(face imprimée en bas)

J'ai câblé cette matrice sur une autre breadboard et sorti 2 connecteurs pour respectivement les colonnes et les lignes (cathodes).

Restait plus qu'à câbler le Max7219

 

Aujourd'hui j'ai passé une bonne partie de la journée à développer le code qui tranforme une heure en une série de LED allumées.

Pour cela j'utilise la fantastique librairie LedControl.

Le plus gros du travail consiste alors à déterminer les règles d'allumage de chaque LED.

J'initialise un tableau de 8 bytes (même si je n'utlise que 5 lignes sur 8 pour mon horloge).

Chaque byte est une ligne de la matrice.

Mes règles d'affichage font des OR pour mettre à 1 les bits correspondants aux LED à allumer selon l'heure.

Une fois la matrice calculée j'ai une boucle qui pour chaque ligne appelle la fonction setRow(0,row,value) de LedControl.

Simple!

 

D'ailleurs c'est en codant mes règles d'allumage de LED que je me suis aperçu que mon cadrant avait un problème: il y manquait 'minuit'! J'ai donc remplacé les 2 caractères inutilisés qui indiquaient le nom de l'horloge, par ceux utilisés pour dire minuit (les 2 premiers caractères de la seconde ligne, et ça se lit 'banne yé', littérallement, "le milieu de la nuit').

 

L'intégration du code de pilotage de la matrice de LED au reste du code de l'horloge est en cours et j'ai pas mal de changements par rapports à mes projets initiaux, mais ça commence à fonctionner.

Voici par exemple une photo prise à 9h37 du soir.

La première ligne indique "il est, le soir", la troisième "9 heures", la quatrième "30" et la cinquième "7":

P1060974.JPG

 

Le Max7219 brouille complètement la réception DCF77!

Je vais voir de combien je dois éloigner le circuit pour que ça fonctionne.

Sinon, comme me l'a suggéré une personne rencontrée sur le forum Arduino dont j'aurai certainement l'occasion de reparler je n'activerais la réception DCF77 que lorsque l'horloge sera en mode veille.

 

Je pilote l'intensité des LED depuis l'info de luminosité captée par la LDR.

L'étalonnage a l'air pas trop mal. Faudra affiner une fois la vraie matrice construite et en condition d'éclairage réelles (c'est à dire dans mon salon).

 

J'ai aussi intégré le détecteur de mouvement à infra-rouge.

Il permet d'éteindre l'horloge (et plus tard de mettre le micro-contrôleur en sommeil) quand aucun mouvement n'a été détecté dans la pièce pendant un certain temps.

 

J'ai fait une petite vidéo pour montrer l'affichage en action.

C'est avec la première version du mini-cadrant, celle qui m' a permis de détecter qu'il y manquait 'minuit'.

La vidéo montre à une cadence accélérée (.5s pour 1s) les heures entre 12h et 13h:

http://www.youtube.com/watch?v=2WQThQBpPCY


 
Repost 0
Published by breizhmakers - dans horloge
commenter cet article
17 mai 2012 4 17 /05 /mai /2012 22:12

Aujourd'hui j'ai assemblé le kit d'horloge RTC reçu de chez Adafruit.

J'utilise la librairie RTClib recommandée, et ça marche tout seul.

 

Restait à utiliser l'heure reçue via le module DCF77 pour mettre à l'heure l'horloge.

Ca n'a pas posé trop de problème, si ce n'est des includes et symboles à définir pour le compilateur C (les mêmes que pour le compilateur C++) car la librairie RTCLib utilise Wire, qui elle-même dépend d'un morceau écrit en C.

 

Il me faut maintenant modifier le logiciel pour affiner tout ça, et en particulier ajouter une source d'interruption toutes les secondes (via le Timer 2) qui va gérer la mise à jour de l'affichage et la synchro de l'horloge.

 

La breadboard se remplit peu à peu:

2012 05 17 4198

Repost 0
Published by breizhmakers - dans horloge
commenter cet article
16 mai 2012 3 16 /05 /mai /2012 22:11

Un récepteur DCF77 se trouve pour une dizaine d'euros, plus frais de port.

J'avais lu quelque part qu'on peut trouver chez les soldeurs des horloges radio-pilotées pour moins cher que ça et en récupérer le récepteur DCF77.

 

Je suis donc passé chez un soldeur et j'y ai trouvé une "station météo", enfin une horloge-thermomètre radio-pilotée, pour 7€, soit moins que le prix d'un récepteur DCF77!

Bon je dirais "thermomètre" avec des guillemets car il y a 1° d'écart entre la sonde intérieure et extérieure quand elles sont côte à côte, et autant avec un autre thermomètre de référence... Bref un truc qui vaut le prix qu'il coûte!

 

J'ai donc ouvert la chose et:

 

2012 05 15 4016

Je ne pouvais espérer mieux. Le récepteur DCF77 est sur une breakout-board et le brochage est même indiqué sur le circuit imprimé!

 

Un petit coup de pompe à dessouder plus tard, et le circuit est sur ma breadboard:

 

2012 05 16 4015

C'est là que les choses se compliquent.

 

Après avoir essayé 3 librairies de décodage du signal DCF77 j'opte pour Funkurh.

Elle a l'avantage d'utiliser les interruptions (mais pas tout à fait comme je le souhaiterais).

J'essaie différents trucs, rien à faire...

Heureusement je trouve cet article qui propose un mini-oscilloscope pour vérifier la réception du signal DCF77.

Je vois que la réception est effectivement très dépendante de l'oritentation de l'antenne!

Après avoir trouvé le bon réglage et fait quelques modification à la librairie Funkurh, j'obtiens enfin l'heure transmise!

Il faut plusieurs minutes pour recevoir une trame correcte, mais ça marche.

 

J'ai dû modifier la librairie pour ne pas inverser le signal d'entrée (le récepteur utilisé par le développeur de la librairie nécessite un transistor pour amplifier le signal de sortie, ce qui l'inverse au passage).

 

Je l'ai aussi modifiée pour:

-Utiliser l'interruption INT0 non seulement pour détecter les fronts du signal reçu, mais aussi pour le décoder. Ce décodage est inialement fait dans la fonction getTime et je ne souhaite l'appeler que quand j'en ai besoin, et non toutes les millisecondes ou presque.

-J'ai aussi supprimé l'utilisation du TIMER 2 car d'une part j'ai besoin de ce timer pour un autre usage, et d'autre part je n'ai pas besoin de connaitre les secondes (et si j'en ai besoin j'ai une horloge RTC).

 

Voilà pour le radio-pilotage.

Prochaine étape, l'intégration de l'horloge RTC.

Repost 0
Published by breizhmakers - dans horloge
commenter cet article
8 mai 2012 2 08 /05 /mai /2012 21:28

L'horloge a pas mal avancé depuis deux jours.

J'ai fait des essais de capteurs capacitifs sans contact, très concluants, qui feront l'objet d'un billet plus tard.

 

J'ai aussi reçu les leds, commandées en gros pour pas cher du tout sur ebay, et avant de construire la matrice j'ai voulu faire un essai pour voir ce que ça donnait, avec une seule cellule de la future matrice. Et bien m'en a pris.

 

Ces leds sont très lumineuses, mais hélas bien trop directrices, et le résultat n'est pas vraiment joli avec un point rouge très lumineux:

 

2012 05 08 4011

 

J'ai essayé plusieurs couches de papier calque, en vain. Reste une solution: rendre les leds diffusantes en les dépolissant.

Direction la perceuse à colonne:

2012 05 08 4013C'est très efficace et en y allant doucement en une petite minute on arrive à une led couleur d'opale.

 

Le résultat est infiniment mieux, avec une lumière bien plus homogène:

2012 05 08 4012

Bien! Plus que 39 leds à dépolir.

 

J'ai dû mettre 3 couches de transparent pour avoir un fond noir suffisamment opaque, mais une impression par un pro devrait me permettre de n'avoir qu'une ou deux couches.

 

Y'a plus qu'à terminer le traçage de la matrice de leds et entammer la construction.

Repost 0
Published by breizhmakers - dans horloge
commenter cet article
7 mai 2012 1 07 /05 /mai /2012 23:04

Il était temps de trier et ranger les composants qui trainaient depuis plusieurs dizaines d'années (déjà!) et ceux achetés récemment avec le kit Arduino.

 

En bon bricoleur j'ai converti une caisse à vin en Makers' Box, ainsi on peut bricoler dans le garage, dans la salle à manger, ou même peut-être bientôt au lab fab' .

 

Je ne suis pas trop mécontent du résultat:

 

2012 05 07 4004

 

On a deux étages de composants, avec ceux utilisés le plus souvent sur l'état du dessus:

2012 05 07 4005

 

Y'a la place de ranger l'arduino, ici avec un prototype de capteur sans contact posé dessus.

2012 05 07 4006

Repost 0
Published by breizhmakers
commenter cet article
4 mai 2012 5 04 /05 /mai /2012 23:14

J'ai créé un tutoriel expliquant comment développer pour l'Arduino avec AVR Studio 5.1.

Ce tutoriel est une traduction et adaptation de cet excellent tutoriel en anglais.

Il s'adresse à ceux qui comme moi trouvent l'environnement de développement Arduino un peu trop rudimentaire et qui souhaiteraient profiter de tous les avantages d'un vrai IDE avec leur Arduino.

 

Il est disponible ici.

 
Repost 0
Published by breizhmakers - dans Arduino
commenter cet article
4 mai 2012 5 04 /05 /mai /2012 21:25

Hervé (mon fils de 10 ans) est tellement enthousiaste qu'on ne va pas attendre d'avoir terminé l'horloge pour commencer la transformation de ce camion de pompier télécommandé:

2012 05 04 4003

en un robot autonome capable de:

  • Détecter et localiser un feu dans un rayon de quelques mètres autour de lui
  • Se diriger sur le feu en se plaçant face à lui
  • Eteindre le feu avec sa lance

Il m'en parle tous les jours, y réfléchit la nuit (il a de qui tenir... )

 

Du côté matériel ça sera à base d'Arduino, motor-shield, servos additionnels, capteurs infra-rouge et à ultra-sons.

 

Le défi est intéressant et j'ai bon espoir que ça fonctionne.

Je sens qu'on va bien s'amuser!

Repost 0
Published by breizhmakers - dans robot
commenter cet article
1 mai 2012 2 01 /05 /mai /2012 21:55

L'Arduino est une carte construite autour d'un micro-contrôleur ATMega d'ATMEL, qui se programme en C.

 

L'environnement de développement Arduino est une version très simplifiée des environnements de développement que connaissent les informaticiens (comme moi).

 

De plus l'Arduino dispose de librairies qui facilitent le développement en permettant de s'affranchir en particulier des calculs booléens sur les masques de bits propres aux entrées/sorties avec les micro-contrôleurs (mais on y a toujours accès si on le souhaite).

 

Mais bon, l'IDE de l'Arduino est extrèmement pauvre, du moins à mon sens. J'ai donc vite cherché des alternatives.

Bon y'a Eclipse, mais bon... je passe mes journées à pester contre Eclipse alors j'avais pas trop envie de le retrouver à la maison le soir.

Il y a aussi AVRStudio, fourni gratuitement par ATMEL pour développer avec leurs micro-contrôleurs.

C'est basé sur MS Visual Studio, avec bien sûr du code-assist, et même un émulateur et un débuggueur.

Bon ça ne simule pas ce qu'il y a autour du micro-contrôleur mais on peut en voir l'état de tous les registres et des ports d'entrée/sortie.

Il faut cependant configurer AVRStudio pour fonctionner avec un Arduino (en particulier trouver les librairies, configurer le programme de transfert du code dans l'Arduino, etc...) c'est pas tout simple mais heureusement on trouve un très bon tutoriel.

 

Il me reste à configurer le transfert dans l'Arduino, parce que je n'aurai mon Arduino que... demain!

 

Mais bon, j'ai pu tester un exemple dans l'émulateur.

On trouve aussi un émulateur open-source capable d'émuler quelques composants hardware, Emulare. Malheureusement ce projet semble en sommeil depuis 2010. Ca fonctionne, mais les composants disponibles sont très limités.

 

Je vais donc en rester aux tests dans AVRStudio et aux bons vieux logs envoyés via le port série.

 

A noter qu'il est possible de débugguer un ATMega in-situ mais ça nécessite une carte AVR Dragon par exemple qui ajoute encore plusieurs dizaines d'euros au coût de l'ensemble. Mais si on développe de nombreux projets c'est certainement intéressant d'investir dans ce genre de chose.

Repost 0
Published by breizhmakers - dans horloge
commenter cet article
1 mai 2012 2 01 /05 /mai /2012 21:41

Après de longues heures de cogitations voici le schéma initial de l'horloge, les versions successives sont indiquées plus bas:

 

Arduino Sketch - Max7219 1.2

 

Le récepteur DCF-77 n'est pas disponible dans Fritzing. C'est un composant additionnel que j'ai fait et que je soumettrai à la communauté dès qu'il sera complètement terminé.

 

J'ai dû opter pour un contrôleur de LED MAX7219 car je n'avais pas assez d'entrées/sorties disponibles sur l'Arduino.

Le MAX7219 peut piloter une matrice de 8*8 LED, et on peut en chaîner plusieurs facilement.

 

L'horloge RTC est nécessaire car la réception DCF77 n'est pas toujours très fiable. On n'est pas sûr de forcément capter le signal, et on n'est pas sûr de recevoir une trame complète correcte par minute.

De plus  à la mise sous tension  il faut au moins 2 minutes pour recevoir l'heure.

On doit donc recourir à une horloge RTC qu'on remet à l'heure précise régulièrement avec l'heure reçue par DCF-77.

Après avoir comparé les prix des composants seuls et de la breakout board chez Adafruit Industries, j'ai opté pour celle-ci, on a un kit complet pour moins cher que les composants achetés en France (environ 15 euros).

 

On a aussi :

  • un capteur de lumière à base d'une LDR qui va servir à ajuster la luminosité de l'horloge en fonction de la luminosité ambiante.
  • Un capteur de présence infrarouge pour allumer/éteindre l'affichage en fonction de la présence de personnes à proximité
  • Un système de capteurs sans contact qui sera expliqué plus loin, pour régler l'heure.

 

Bref elle n'est pas aussi simple que ça cette horloge en fait! (ce qui n'est pas pour me déplaire).

 

 

Version 1.5:

Le schéma ci-dessous apporte les changements suivants:

  • Horloge RTC sous forme de breakout-board
  • Alimentation de l'horloge RTC et du récepteur DCF77 via la pin 12 (pour gestion du mode économie d'énergie quand l'écran est éteint).
  • Note: l'alim du récepteur DCF77 sera probablement passée en 3.3v quand j'ai trouvé ses spécifications exactes.

 

cibiao 1.5

 

 

Version 1.6:

Le schéma ci-dessous apporte les changements suivants:

  • Alimentation du module DCF77 en 3.3v
  • Ajout d'une led témoin de non-synchronisation DCF77
  • Changement pin d'alimentation de l'horloge RTCcibiao_1.6.png

Version 2.0:

Suite à une trop grande instabilité des capteurs capacitifs, je les ai remplacé par de simples poussoirs placés sur le dos de l'horloge. C'est simple, efficace et ça allège le circuit de quelques composants.

Le schéma final de l'horloge est donc:

Arduino Sketch final - V2.0

Repost 0
Published by breizhmakers - dans horloge
commenter cet article