Overblog
Suivre ce blog
Administration Créer mon blog
31 mai 2016 2 31 /05 /mai /2016 20:30
Un Sonomètre connecté en OpenTSDB

Ayant fait l'acquisition d'un Sonomètre WENSN WS1361 j'ai rapidement cherché à en exploiter les mesures automatiquement.

Après une tentative infructueuse d'utiliser sa sortie analogique, au comportement instable et pour le moins étrange, j'ai préféré utiliser son port USB.

Dans ce monde merveilleux de l'open-source il se trouve que quelqu'un a eu la bonne idée de faire un reverse-engineering du protocole de ce sonomètre et de mettre gracieusement le script python à disposition.

OVH met gratuitement à disposition un serveur OpenTSDB ainsi que des exemples de code dans différents langages, dont Python.

Après quelques adaptations à Python 3 on a une API fonctionnelle de haut niveau, très simple à utiliser.

Le script envoie une mesure toutes les 5 minutes. C'est bien sûr paramétrable tel qu'indiqué dans le README.md du dépôt github.

Cette mesure est une moyenne mobile des 5 dernières minutes. Le capteur fournit, lui, une mesure toutes les 2s, qui est aussi une moyenne mobile sur 2s.

Le script est lancé au démarrage de l'ordinateur.

Il est possible que je l'installe un jour sur un Raspberry pi.

J'utilise Grafana pour afficher les métriques stockée dans OpenTDSB:

Published by breizhmakers
commenter cet article
14 mai 2016 6 14 /05 /mai /2016 20:50

Il commence à faire chaud dans mon bureau et dans mes combles et j'avais envie de pouvoir mesurer la température avec plus de précision que le bout de mon nez :)

 

L'ESP8266 est une solution remarquablement adaptée pour cela avec sa connectivité wifi (et HTTPS) intégrée et son faible coût.

J'utilise la version NodeMCU (programmée en C) car pour seulement quelques euros de plus j'ai un port USB et une alimentation 5V via l'USB.

Le capteur de température est un DHT22, bien plus précis qu'un DHT11 et pas beaucoup plus cher.

Carte NodeMCU et capteur DHT22Carte NodeMCU et capteur DHT22

Carte NodeMCU et capteur DHT22

Les broches D0 et Reset sont connectées entre elles afin de permettre à l'ESP8266 de se réveiller correctement après avoir été mis en deep-sleep.

Le DHT22 est connecté sur la broche D4 (GPIO02). Allez comprendre la numérotation des broches!

 

Concernant le stockage et la visualisation des données, j'ai cherché plusieurs solutions.

 

J'ai commencé par jeter un oeil à Thingspeak. C'est très simple à utiliser (un simple post HTTPS (voire HTTP mais c'est pas recommandé niveau sécu) et ça fournit une visualisation rudimentaire, extensible via différents moyens mais pas super bien documentée à mon goût (au choix via MathLab ou via HighCharts et un éditeur javascript/HTML intégré).

 

J'ai découvert il y a peu le PaaS IoT d'OVH (sur leur plateforme de "labs" Runabove).

Ils mettent à disposition un serveur OpenTDSB (protocole open-source de base de données temporelle). Il n'y a pas d'IHM de consultation, mais pour cela on peut utiliser Grafana, qu'il faut alors installer chez soi ou sur un cloud quelconque.

J'ai donc installé Grafana et j'y ai configuré un tableau de bord qui m'affiche des graphes et métriques de température et d'humidité de mes deux thermo-hygromètres connectés (un chez moi et un au boulot).

Voici ce que ça donne par exemple:

 

Le code source est disponible sur mon GitHub.

Il nécessite l'IDE Arduino avec la carte supplémentaire ESP8266.

 

La visualisation des données est faite avec Grafana, qui parle directement au PaaS IoT d'OVH avec le protocole OpenTSDB.

Grafana - Dashboard affichant les mesures de température et d'humidité

Grafana - Dashboard affichant les mesures de température et d'humidité

Published by breizhmakers - dans ESP8266
commenter cet article
8 avril 2016 5 08 /04 /avril /2016 16:45

Comme souvent je traînais sur un site de makers et je suis tombé sur la création d'un artiste, Lorenzo Bravi, qui est un séquenceur de percussions à base d'Arduino et Solénoïdes. L'idée étant ensuite de pouvoir changer facilement sur quoi les solénoïdes frappent afin d'en changer le son.

J'ai trouvé le concept sympa mais j'ai voulu faire quelque chose de plus versatile, pilotable via un vrai séquenceur MIDI (mais bien moins réussi niveau esthétique ;) )

 

J'ai commencé par faire un shield Arduino pour pouvoir commander les solénoïdes.

Version DYI bien sûr, c'est à dire sur une plaque à trous, au format shield Arduino.

6 MOSFET, quelques résistances, LED de contrôle et une poignée de connecteurs.

Comme souvent avec ce genre de montage, c'est pas très propre côté pistes, mais ça fonctionne.

MOSFET ShieldMOSFET Shield

MOSFET Shield

 

J'ai ensuite cherché un séquenceur MIDI pour Android, mais comme souvent dans le domaine de la musique, je n'ai trouvé mon bonheur que sur iPad. Le seul truc réellement utilisable par tous est Nord Beat 2, et gratuit en plus. Oui, le système est destiné à des enfants. J'aime bien faire des instruments d'éveil musical ludiques (voir le Mycophone par exemple).

 

Là s'est posé l'épineux problème de la connexion entre l'iPad et l'Arduino. Surtout que le Midi à la sauce Wifi Apple c'est comment dire....compliqué (doux euphémisme!...).

Après pas mal de recherches, j'ai opté pour l'excellent logiciel gratuit RTPMidi côté PC, que j'avais découvert en bricolant avec TouchDAW auparavant.

Donc après avoir installé RTPMidi et ce qui va avec (protocole "Bonjour"), et avoir lu attentivement la doc pas très claire, j'ai enfin vu mon iPad apparaître dans la liste des sessions Midi côté PC.

 

Restait à déterminer comment envoyer ces messages MIDI à l'Arduino.

C'est là qu'entre en jeu LoopBe1, un port midi virtuel et gratuit.

Ceci va en quelque sorte créer un câble MIDI virtuel entre les messages provenant de l'iPAD et...un programme Processing chargé de faire le relais entre le port MIDI virtuel et le port série sur lequel écoute l'Arduino.

J'ai opté pour un format de messsage entre Processing est l'Arduino qui n'est pas MIDI mais un format binaire ou chaque bit d'un octet correspond à un solénoïde à activer. Le tout transmis à 115200 bauds. C'est mon côté optimisateur fou :)

Le Sketch Processing transforme donc un message MIDI de type NoteOn en un bit à 1 et un NoteOff en un bit à 0.

Côté Arduino, un simple masque binaire permet de calculer l'état des sorties et d'utiliser les "fast I/O" pour les piloter.

Lors des premiers essais, des problèmes de latence sont vite apparus, le système était injouable dès que le tempo était un peu rapide.

La solution a été de passer par un réseau wifi pair-à-pair (mode ad-hoc) entre le PC et l'iPad. C'est une fonction wifi peu connue mais très pratique pour des échanges entre machines sans nécessiter un autre point d'accès.

Une fois le PC et l'iPad sur leur propre réseau wifi ad-hoc, la latence est retombée à quelques ms et le système a fonctionné à merveille.

 

Ma fille aime beaucoup et moi je m'amuse parfois à jouer de la basse avec ce type de boite à rythme.

J'ai ensuite cherché un séquenceur MIDI pour Android, mais comme souvent dans le domaine de la musique, je n'ai trouvé mon bonheur que sur iPad. Le seul truc réellement utilisable par tous est Nord Beat 2, et gratuit en plus. Oui, le système est destiné à des enfants. J'aime bien faire des instruments d'éveil musical ludiques (voir le Mycophone par exemple).

Là s'est posé l'épineux problème de la connexion entre l'iPad et l'Arduino. Surtout que le Midi à la sauce Wifi Appel c'est comment dire....compliqué (doux euphémisme!...).

Après pas mal de recherches, j'ai opté pour l'excellent logiciel gratuit RTPMidi côté PC, que j'avais découvert en bricolant avec TouchDAW auparavant.

Donc après avoir installé RTPMidi et ce qui va avec (protocole "Bonjour"), et avoir lu attentivement la doc pas très claire, j'ai enfin vu mon iPad apparaître dans la liste des sessions Midi côté PC.

Restait à déterminer comment envoyer ces messages MIDI à l'Arduino.

C'est là qu'entre en jeu LoopBe1, un port midi virtuel et gratuit.

Ceci va en quelque sorte créer un câble MIDI virtuel entre les messages provenant de l'iPAD et...un programme Processing chargé de faire le relais entre le port MIDI virtuel et le port série sur lequel écoute l'Arduino.

J'ai opté pour un format de messsage entre Processing est l'Arduino qui n'est pas MIDI mais un format binaire ou chaque bit d'un octet correspond à un solénoïde à activer. Le tout transmis à 115200 bauds. C'est mon côté optimisateur fou :)

Le Sketch Processing transforme donc un message MIDI de type NoteOn en un bit à 1 et un NoteOff en un bit à 0.

Côté Arduino, un simple masque binaire permet de calculer l'état des sorties et d'utiliser les "fast I/O" pour les piloter.

Lors des premiers essais, des problèmes de latence sont vite apparus, le système était injouable dès que le tempo était un peu rapide.

La solution a été de passer par un réseau wifi pair-à-pair (mode ad-hoc) entre le PC et l'iPad. C'est une fonction wifi peu connue mais très pratique pour des échanges entre machines sans nécessiter un autre point d'accès.

Une fois le PC et l'iPad sur leur propre réseau wifi ad-hoc, la latence est retombée à quelques ms et le système a fonctionné à merveille.

Ma fille aime beaucoup et moi je m'amuse parfois à jouer de la basse avec ce type de boite à rythme.

Démo avec ma fille

 

Le code source des sketches Arduino et Processing est disponible sur GitHub.

Published by breizhmakers - dans arduino
commenter cet article
24 mars 2016 4 24 /03 /mars /2016 21:22

On trouve peu d'exemples d'utilisation de l'Arduino/Genuino MKR1000.

Ci-dessous un exemple de sketch qui envoie les valeurs lues sur une entrée analogique vers un channel ThingSpeak, issus des exemples de la librairie Wifi101 ainsi que d'exemples d'utilisation de l'API ThingSpeak trouvés en ligne.

 

L'entrée analogique est configurée en 1V max / 12bits de résolution. 

Vous devez spécifier votre clé d'API ThingSpeak ainsi que votre SSID et mot de passe wifi.

 

J'ai utilisé ce code pour lire les valeurs issues d'un sonomètre et les poster sur mon channel Thingspeak.

#include <SPI.h>
#include <WiFi101.h>
#include <stdarg.h>


//analog input pin
#define ANALOG_PIN A1


//thinkgspeak API KEY
#define API_KEY "YOUR_WRITE_API_KEY"


#define WIFI_ENABLE
#define WIFI_NETWORK_NAME "your_wifi_ssid"
#define WIFI_PASSWORD "your_wifi_password"    


#define SERVER "api.thingspeak.com"  
#define SLEEP_TIME 15000

int status = WL_IDLE_STATUS;
char buffer[70];
WiFiSSLClient client;


void setup() {
  Serial.begin(9600);
  //set 12 bit analog resolution
  analogReadResolution(12);
  //set 1V analog reference
  analogReference(AR_INTERNAL1V0);


#ifdef WIFI_ENABLE
  // attempt to connect to Wifi network:
  while (status != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(WIFI_NETWORK_NAME);
    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
    status = WiFi.begin(WIFI_NETWORK_NAME, WIFI_PASSWORD);

    // wait 10 seconds for connection:
    delay(10000);
  }
  Serial.println("Connected to wifi");
  printWifiStatus();
#endif
}


//main loop
void loop() {
  int sensorValue = analogRead(ANALOG_PIN);
 

#ifdef WIFI_ENABLE
  //send data to thingSpeak
  sendData(sensorValue);
  
  while (client.available()) {
    char c = client.read();
    Serial.write(c);
  }
    delay(SLEEP_TIME);  
#else
  Serial.println(sensorValue);
  delay(SLEEP_TIME/50);
#endif
}


void sendData(int data){
  if (client.connect(SERVER, 443)) {
    Serial.print("connected to server to send data :");
    Serial.println(data);
    // Make a HTTP request:
    sprintf(buffer,"GET /update?api_key=%s&field1=%d HTTP/1.1",API_KEY,data); 
    Serial.println(buffer);
    client.println(buffer);
    client.print("Host: ");
    client.println(SERVER);
    client.println("Connection: close");
    client.println();
    Serial.println("data sent");
  }else{
    Serial.println("connection error");
  }
}


void printWifiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());


  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);


  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}
Published by breizhmakers - dans arduino mkr1000
commenter cet article
18 décembre 2015 5 18 /12 /décembre /2015 20:51

J'aime terminer un projet, et celui-là est vraiment sympa puisqu'il s'agit d'animer un tableau de Je Peins Des Aliens.
J'ai encore plein d'idées pour donner vie à ces créatures

Voilà ce que ça donne:

Published by breizhmakers - dans arduino
commenter cet article
21 juin 2015 7 21 /06 /juin /2015 22:03
Cadeau de fête des pères

Cadeau de fête des pères:

Poscope Mega 1 Bundle: oscilloscope 2x20MHz analyseur logique 16 voies :-)

Published by breizhmakers
commenter cet article
21 mai 2015 4 21 /05 /mai /2015 10:49

Pour des raisons d'économie (d'argent mais aussi et surtout de place) je voulais utiliser un ATMega328P sans quartz externe, en utilisant simplement son oscillateur interne à 8MHz.

 

J'ai cherché un peu comment faire mais je n'ai trouvé aucune doc vraiment claire.

Voici comment faire en détail:

 

Tout d'abord, la majorité des ATMega328P sont pré-configurés pour utiliser un quartz externe, et beaucoup son pré-chargés avec un bootloader compatible Arduino. Certains sont livrés bruts et semble-t-il préconfigurés pour utiliser l'oscillateur interne.

 

Nous allons utiliser l'IDE Arduino et un programmateur ISP ou bien le sketch ArduinoISP (c'est ce que j'ai utilisé).

Il n'existe pas de définition de "board" pour un Uno avec oscillateur interne, nous allons donc la créer. Pour ce faire, il faut commencer par ouvrir avec un éditeur de texte le fichier boards.txt qui se trouve dans le dossier <Arduino_home>\hardware\arduino\avr et y dupliquer l'entrée concernant le Uno pour y apporter les modifications suivantes:

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


uno_internal_osc.name=Arduino Uno (internal 8 MHz oscillator, prescaler: 8)


uno_internal_osc.vid.0=0x2341
uno_internal_osc.pid.0=0x0043
uno_internal_osc.vid.1=0x2341
uno_internal_osc.pid.1=0x0001
uno_internal_osc.vid.2=0x2A03
uno_internal_osc.pid.2=0x0043


uno_internal_osc.vid.0x2A03.warning=Uncertified


uno_internal_osc.upload.tool=avrdude
uno_internal_osc.upload.protocol=arduino
uno_internal_osc.upload.maximum_size=32256
uno_internal_osc.upload.maximum_data_size=2048
uno_internal_osc.upload.speed=115200


uno_internal_osc.bootloader.tool=avrdude
uno_internal_osc.bootloader.low_fuses=0x62
uno_internal_osc.bootloader.high_fuses=0xDE
uno_internal_osc.bootloader.extended_fuses=0x07
uno_internal_osc.bootloader.unlock_bits=0x3F
uno_internal_osc.bootloader.lock_bits=0x0F
uno_internal_osc.bootloader.file=optiboot/optiboot_atmega328.hex


uno_internal_osc.build.mcu=atmega328p
uno_internal_osc.build.f_cpu=1000000L
uno_internal_osc.build.board=AVR_UNO
uno_internal_osc.build.core=arduino
uno_internal_osc.build.variant=standard

 

Remarquez les points suivants:

  • Le préfixe des entrées de configuration: uno_internal. Il doit être unique pour chaque carte définie.
  • Le nom de l'entrée: Arduino Uno (internal 8 MHz oscillator, prescaler: 8)
  • Les fusibles et en particulier le low_fuses= 0x62 qui indique d'utiliser l'oscillateur interne à 8 MHz avec le prescaler à 8, ce qui fait une horloge CPU à 1 MHz (vous pouvez désactiver le prescaler en utilisant la valeur 0xE2 si vous souhaitez un CPU à 8MHz)
  • La fréquence CPU f_cpu positionnée à 1000000L (à mettre à 8000000L si vous désactivez le prescaler). Cette entrée est importante pour assurer une durée d'exécution correcte des fonctions telles que delay() par exemple.

Changement des fusibles de l'ATMega328P

Le changement des fusibles de l'ATMega328P s'effectue via AVRDude:

Ouvrir une ligne de commande et se placer dans le dossier <Arduino_Home>\\hardware\tools\avr\bin

Afficher les valeurs actuelles des fusibles avec une commande de ce genre (adapter le port COM utilisé):

avrdude -v  -C ..\etc\avrdude.conf -p atmega328 -c STK500v1 -P\\.\COM8\ -b 19200 -n -F

 

AVRDude doit vous répondre entre autres quelque chose comme ceci:

avrdude: safemode: lfuse reads as 62
avrdude: safemode: hfuse reads as DE
avrdude: safemode: efuse reads as 7
avrdude: safemode: Fuses OK (H:07, E:DE, L:62)

 

Il ne reste plus qu'à programmer les fusibles avec les valeurs souhaitées, en l'occurence ceci pour un ATMega328P programmé via ArduinoISP, avec une horloge interne à 8MHz et un prescaler à 8:

avrdude  -C ..\etc\avrdude.conf -p atmega328 -c STK500v1 -P\\.\COM8\ -b 19200  -F -U lfuse:w:0x62:m -U hfuse:w:0xDE:m -U efuse:w:0x07:m

 

Tout ceci peut parraître abscons mais fort heureusement il existe de nombreux outils pour aider à calculer les valeurs des bits des différents fusibles. J'utilise souvent ce site.

 

Téléverser un Sketch dans l'ATMega328P modifié

  • Relancer si nécessaire l'IDE Arduino, charger votre sketch (Blink par exemple, il vous permettra de vérifier facilement que votre ATMega continue de fonctionner sans quartz) et changer le type de carte à "Arduino Uno (internal 8 MHz oscillator, prescaler: 8)"
  • Utiliser votre programmeur favori pour uploader le sketch (j'utilise un autre Arduino comme ISP tel que décrit ici) via le menu "Téléverser avec un programmateur"
  • Débrancher l'alimentation électrique enlever le quartz et rebrancher l'alimentation électrique, votre sketch doit continuer de s'exécuter normalement.
  • Relancer si nécessaire l'IDE Arduino, charger votre sketch (Blink par exemple, il vous permettra de vérifier facilement que votre ATMega continue de fonctionner sans quartz) et changer le type de carte à "Arduino Uno (internal 8 MHz oscillator, prescaler: 8)"
  • Utiliser votre programmeur favori pour uploader le sketch (j'utilise un autre Arduino comme ISP tel que décrit ici) via le menu "Téléverser avec un programmateur"
  • Débrancher l'alimentation électrique enlever le quartz et rebrancher l'alimentation électrique, votre sketch doit continuer de s'exécuter normalement.
Published by breizhmakers - dans arduino
commenter cet article
28 avril 2015 2 28 /04 /avril /2015 21:28

Votre Arduino Nano V3 Chinois cloné n'est pas reconnu? La solution est ici: https://www.youtube.com/watch?v=SPdSKT6KdF8

Ca m'a sauvé la soirée!

Mon Nano V3 commandé chez dx.com est maintenant parfaitement reconnu sous Windows 7.

Published by breizhmakers - dans arduino
commenter cet article
24 avril 2015 5 24 /04 /avril /2015 12:30

On m'a confié une horloge de gare de marque Bodet dans le but de la ranimer. Ce type d'horloge dispose d'une sorte de moteur pas à pas qui s'alimente avec des impulsions, au rythme d'une impulsion toute les 30s, chaque impulsion étant de polarité inversée par rapport à la précédente, et d'une durée d'environ 500 ms.

Une recherche avec la référence inscrite sur le moteur de l'horloge m'a permis de trouver que ces impulsions doivent être de 0.9V/65mA aux bornes du moteur. L'impédance du moteur étant de 15 Ohms.

Après avoir fait le tour des solutions disponibles sur le marché, je me suis dit qu'ont peut faire bien moins cher, probablement mieux, et surtout bien plus fun!

Les objectifs fixés sont:

  • Faible coût
  • Alimentation 9V (requis pour piloter l'horloge)
  • Application automatique des changements d'heure.
  • Très bonne stabilité de l'horloge (2 ppm soit environ 1 minute/an)
  • Interrupteur Marche/Arrêt
  • Interrupteur de mise en mode avance rapide pour mise à l'heure.

Le micro-contrôleur:

J'avais initialement pensé à un ATTiny 85 pour contrôler le tout, mais malheureusement il me manque une broche.

J'ai voulu essayer l'ATTiny 2313 mais il est difficilement trouvable chez mes fournisseurs habituels, alors j'ai finalement opté pour le bon vieil ATMega328P, en mode horloge interne à 1 MHz, c'est déjà très largement surdimensionné pour la tâche, mais à 3 Euros à peine le circuit ça ne vaut pas la peine de s'en priver.

Le pilotage du moteur:

Le moteur de l'horloge est piloté par un pont en H de type SN 754410.

L'horloge RTC:

Et pour avoir une grande stabilité j'utilise une horloge RTC thermo-compensée de type DS3231.

Je n'ai pas besoin de lire l'heure car tout ce que je peux envoyer au moteur de l'horloge sont une série d'impulsions pour faire avancer les aiguilles, mais je vais quand même me servir de l'heure dans l'horloge RTC pour savoir quand changer d'heure.

Le choix du DS3231 s'explique aussi par le fait qu'il a un générateur d'impulsions programmable.

Je vais le programmer pour générer des impulsions à la fréquence de 1Hz, qui vont me servir à réveiller l'ATMega qui entre chaque impulsion sera dans un état de sommeil profond pour peu consommer (sleep-mode POWER_OFF).

Changement d'heure:

Quant au changement d'heure, eh bien j'ai déjà une fonction qui me calcule l'offset en minutes à appliquer à l'heure UTC pour obtenir l'heure locale. Je vais utiliser les variations de cet offset pour savoir quand changer d'heure.

Et pour appliquer le changement d'heure à une horloge qui ne peut aller que dans un seul sens par pas de 30s je vais simplement mettre l'horloge en marche "rapide" pour avancer d'une heure, et la mettre en pause pendant 1h pour retarder d'1h. Simple non ;)

Je vais aussi y ajouter un port ICSP pour pouvoir la reprogrammer facilement si nécessaire.

Schéma:

Schéma

Schéma

Vue Breadboard de Fritzing du premier PoC

Vue Breadboard de Fritzing du premier PoC

Pour faire le schéma et le circuit imprimé, j'ai utilisé l'excellent logiciel Kicad, open-source.

C'est vraiment très bien fait et bien documenté. Je n'ai pas eu de mal à faire les composants spécifiques dont j'avais besoin (connecteur ICSP et connecteur pour l'horloge RTC).

Je voulais une carte au format Arduino, afin de tenir facilement dans un boitier tout fait.

Voici le circuit routé:

Circuit routé avec PcbNew (KiCad)

Circuit routé avec PcbNew (KiCad)

Et comme je suis sympa le code, les fichiers KiCad et le typon au format PDF sont disponibles sous Licence GPL sur GitHub.

Une fois le typon prêt et vérifié, j'ai essayé par 4 fois de le transférer sur du cuivre par la méthode d'impression laser + fer à repasser, mas j'ai finalement renoncé tellement le transfert était mauvais.

J'ai cherché quelle entreprise pouvait me faire le circuit imprimé pour un prix modique (malheureusement le fablab local ne propose par de réaliser des CI), et je suis finalement passé par circuit-électronique.fr Eh bien pour 23 euros port compris, en quelques jours j'ai eu mon circuit réalisé par un pro, étamé et percé, même avec les trous oblongs du connecteur d'alim!

J'ai été vraiment très agréablement surpris et je vous recommande leur service.

Pour le boîtier, j'ai choisi un boîtier acrylique pour Arduino. J'ai dû bricoler pour pouvoir le fermer car mon circuit est trop épais avec l'horloge RTC par dessus, mais ça m'a tout de même évité de faire mon propre boîtier.

Boîtier

Boîtier

Il ne reste plus qu'à intégrer le tout dans l'horloge et admirer le travail :)

Démo de l'horloge en mode avance rapide pour mise à l'heure:

Published by breizhmakers - dans HorlogeBodet
commenter cet article
1 septembre 2014 1 01 /09 /septembre /2014 11:43

L'horloge Chinoise V2 est maintenant chez sa nouvelle propriétaire: au restaurant le Tanghulu, 21 rue de Redon à Rennes. Un authentique restaurant Chinois que je vous recommande vivement!

horloge_livree.jpg

Encore merci à toi Jean-Marie pour l'aide que tu m'as apportée dans la réalisation du circuit imprimé!

Published by breizhmakers - dans horloge v2 horloge
commenter cet article