Plateau de capteur environnemental à modes multiples avec MKR1000

À propos de ce projet

J'adore regarder la météo et je voulais essayer de la capturer et de la représenter graphiquement. Les stations météorologiques domestiques me permettent de voir les détails pour « maintenant », et parfois les décomptes pour l'heure ou le jour passé. Je voulais faire plus et utiliser un Arduino pour le travail. Tout le monde commence par la température et l'humidité, parfois la pression barométrique, mais je voulais plus ! La mesure de la vitesse du vent et de la pluie voulait chacune des entrées matérielles. Une fois que j'ai maîtrisé l'utilisation d'i2c, j'ai trouvé des choses comme le détecteur de foudre AS3935 ! Et puis la tristesse s'est installée... Je n'avais pas assez d'interruptions matérielles pour faire le travail avec votre Arduino de base. Sparkfun a même une carte de capteur météo pour le Photon, mais c'est encore limité. Je devrais choisir, et me passer de certains capteurs. :-(

Puis j'ai vu le MKR1000 , et j'ai repéré la MEILLEURE FONCTIONNALITÉ, elle a 8 interruptions matérielles ! Maintenant, je pourrais tout avoir !

Choisir vos capteurs

Les capteurs sont disponibles en trois saveurs de base ;

• Analogique :lumière (y compris IR et UV), direction du vent, gaz, capteurs de force...

• I2C :température, humidité, pression baro, accéléromètre, gyroscope...

• Interruptions  :basculeurs de pluie, vitesse du vent, éclairs, minuteries...(Les fonctionnalités telles que série, PWM, horloges, servos utilisent des interruptions de synchronisation)

Le MKR1000 a beaucoup d'E/S pour tout cela !

NOTEZ DE QUELLE TENSION VOUS AVEZ BESOIN POUR VOS E/S sur I2C et les interruptions ! Par exemple, le MKR1000, le Photon et de nombreuses variantes d'Arduino utilisent des E/S 3,3 v au lieu de 5 v. Si votre processeur et le ou les capteurs que vous souhaitez utilisent des tensions différentes, vous devrez également utiliser des décaleurs de niveau entre ces appareils.

Tous les capteurs que j'utilise sont assez courants, disponibles chez Adafruit, SparkFun, Element-14 et autres, et coûtent généralement entre 5 et 10 $ (US). Les capteurs de gaz coûtent généralement entre 10 et 20 dollars. Pour le détecteur de foudre (puce AS3935), j'ai choisi le MOD-1016 Embedded Adventures, qui coûte 26 $ (US) pour installer également l'antenne sur la carte. J'ai également acheté le Sparkfun Photon Weather Shield, puisque j'ai un Photon, et j'achèterai probablement leurs "météomètres" (instruments de vitesse et de direction du vent). Peut-être que j'ajouterai un capteur d'humidité du sol, une fois que j'aurai compris où je monterai le MKR1000. Certains capteurs n'aiment pas avoir de longs fils.

Attribuez vos capteurs à des broches

Une fois que vous savez quels capteurs vous voulez, vous saurez de quel type d'entrées vous aurez besoin, l'étape suivante consiste à décider quels capteurs iront sur quelles broches. Je commence sur papier, mais je vais aussi ajouter cette liste en bloc de commentaire dans mon code, pour rappel.

Voici les affectations de broches MKR1000 que j'ai faites pour mon deck de capteurs.

• A0 (Je sauvegarde A0 au cas où j'aurais besoin du DAC plus tard...)

• A1 Capteur UV ML8511

• A2 capteur de lumière visible

• A3 Capteur de température local TMP36

• A4 Capteur de gaz MQ-9

• A5 capteur d'humidité

• A6 capteur de vitesse du vent ?

• 0 (HW INT) bouton-poussoir

• 1 (HW INT) AS Détecteur de foudre

• 2 (HW INT) anémomètre de vitesse du vent (interruption par rotation)

• 3 (HW INT) Benne à pluie…

• 4

• 5

• 6 (partagé avec la LED intégrée)

• 7 Sortie NeoPixel…

Pour commencer...

Pour les débutants parmi vous, je suggère de commencer par chaque capteur que vous allez utiliser, un à la fois, et de commencer par charger l'exemple de code et installer les bibliothèques nécessaires. N'oubliez pas de changer la broche du capteur pour qu'elle corresponde à l'affectation des broches de votre choix et enregistrez une copie du code de démonstration dans votre dossier de projet.

Lorsque vous pouvez exécuter le code de test et lire les résultats du moniteur série, vous êtes prêt à essayer d'en ajouter un autre. Et lorsque vous avez fini de tester chaque capteur, ils sont maintenant tous câblés et prêts à commencer à construire votre plus grand croquis !

Mon bricolage original avec les capteurs inclus à l'aide d'une horloge Reat-Time (RTC) basée sur i2c, afin que je puisse me connecter à une carte mémoire SD. Bien que le MKR1000 dispose de son propre RTC et d'une batterie, je n'ai pas réussi à obtenir l'horloge pour garder l'heure avec uniquement la batterie, donc je vais également garder le ChronoDot v2.1 i2c RTC.

En regardant la maquette de mon image ci-dessous, vous pouvez voir les différents cavaliers utilisés. L'orange correspond à l'alimentation 3,3 V de chaque capteur, je ne peux donc les brancher que lorsque je suis prêt à travailler avec eux. (Il est facile de désactiver un capteur en débranchant le cavalier orange.)

Une note sur les bibliothèques

J'ai constaté que certaines des bibliothèques que vous pouvez installer ne fonctionnent PAS parfaitement avec le MKR1000 et/ou avec Arduino.cc IDE version 1.6.7, et vous devrez peut-être effectuer quelques réglages, en fonction de l'âge de votre capteur. est. Un exemple de ceci est les anciennes macros ATOMIC_* dans l'ancienne libc AVR bibliothèque (ils ont été supprimés dans Arduino IDE 1.6.5), et il existe un excellent fil de discussion sur les problèmes et les solutions suggérées dans un fil de discussion sur Arduino.cc. Faire certaines des modifications suggérées est quelque chose pour un pirate Arduino intermédiaire, mais sera probablement intimidant pour les nouveaux pirates. Et, pour les bibliothèques légèrement plus anciennes, l'auteur original peut ne pas être là pour mettre à jour la bibliothèque et éliminer la dépendance.

Malheureusement, vous ne pourrez généralement pas savoir quelles bibliothèques doivent être réglées avant d'acheter vos capteurs et de les tester. À ce stade, je vous recommande de regarder les messages d'erreur qui apparaissent en orange lorsque vous essayez de télécharger votre croquis avec soin, pour voir si le problème est dans votre code, ou dans une bibliothèque, avant de commencer à modifier votre code. S'il se trouve dans la bibliothèque, effectuez une recherche sur le Web pour "arduino" et le message d'erreur. Si vous ne trouvez pas de solution, essayez d'envoyer un e-mail à l'auteur et informez-le de l'erreur, et peut-être qu'il mettra à jour la bibliothèque.

J'ai acheté des jetons individuels, essayant d'économiser de l'argent. J'ai décidé que, jusqu'à ce que je sois prêt et capable de fabriquer mes propres cartes de circuits imprimés (probablement en utilisant EagleCAD et OSHPark), il est plus facile d'acheter des modules de capteurs chez Adafruit et SparkFun, car ils sont très efficaces pour garder leurs bibliothèques corrigées.

Un peu sur le WiFi et le cryptage

J'ai aussi pensé au wifi pour faire rapporter mes capteurs météo sur un site web. Nous avons même un moteur de cryptage sur le MKR1000, pour aider à protéger nos données en transit sur Internet ! Mais, c'est plus que ce que je pourrai faire dans ce premier projet. C'est sur ma liste de choses à faire, car intégrer la sécurité des données dans votre conception est important pour l'Internet des objets, mais je manque de temps pour ajouter ma participation au concours MKR1000. Surveillez ma "version 2" de ce projet. Voici un schéma fonctionnel du module SAMD qui est le cœur de votre carte.

Je peux vous offrir un conseil pour démarrer avec le WiFi embarqué :Assurez-vous que vous utilisez la version la plus récente de la bibliothèque WiFi101 ! Si vous ne le faites pas, votre croquis ne reconnaîtra pas le module wifi, et vos croquis wifi ne le signaleront que s'il y a une vérification d'erreur sur les appels vers le module wifi.) Je dois remercier Charif Mahmoudi pour l'avoir souligné dans son excellent didacticiel "Getting Started with MKR1000" ici sur Hackster ! Au moment de mon piratage, vous pouviez trouver le WiFi101 Githuib ici.

Conseils pour les capteurs analogiques

La plupart des modules de capteur à "sortie analogique" produiront une simple sortie de tension analogique, et celle-ci est facilement lue à l'aide de analogRead de la broche du capteur. Mais alors, vous devez savoir ce que cela signifie. Normalement, vous devrez utiliser la carte commande, ou vous devrez peut-être effectuer un peu de mathématiques. Les éléments résistifs auront généralement besoin de circuits supplémentaires. Vous pouvez ajouter un potentiomètre pour "affiner" la tension.

Dans d'autres cas, vous aurez besoin d'équations pour transformer la tension de sortie en quelque chose que les humains comprendront. Le TMP36 Le capteur de température en est un exemple bien documenté. Cette partie a été conçue pour lire en degrés Celsius, vous devez donc mesurer la tension et faire quelques calculs pour obtenir C, et si vous voulez Fahrenheit, vous devrez convertir C en F. La lecture des fiches techniques des composants sera expliquez comment fonctionne la partie, mais il vous sera plus facile de suivre les traces de quelqu'un d'autre au fur et à mesure que vous développez votre expérience.

Pourtant, d'autres capteurs ont besoin d'un amplificateur, afin que les minuscules variations de tension soient suffisamment importantes pour que votre ADC obtienne une bonne plage de haut en bas. Ces types de capteurs (cellules de charge, humidité, accéléromètre) sont ceux où je trouve le mieux pour dépenser de l'argent et acheter un module qui a déjà un ampli et une bibliothèque pour aider à comprendre la plage de sortie.

Conseils d'utilisation des appareils I2C

I2C est parfois appelé "interface à deux fils", car vous avez besoin d'un signal d'horloge, ainsi que d'un signal de données. (Vous n'avez besoin que d'un seul fil de données, car le "maître" et les "esclaves" enverront des données à tour de rôle.) Bien sûr, vos capteurs I2C auront également besoin d'une masse et d'un câble d'alimentation, et cela Le fil de terre doit être relié à votre CPU.

Chaque périphérique I2C aura une adresse hexadécimale sur le bus. Il est préférable d'éviter d'utiliser plusieurs appareils avec la même adresse. (Si vous voulez en avoir plusieurs, vous devez les gérer avec des circuits supplémentaires, afin d'"activer" celui avec lequel vous souhaitez communiquer, puis le désactiver lorsque vous avez terminé, avant d'en activer un autre pour la communication.)  La documentation devrait vous dire quelle(s) adresse(s) un appareil peut être. (REMARQUE :Si vous avez deux appareils sur le bus I2C avec la même adresse, et que les deux ont une broche "Enable" ou "Shutdown", vous pourrez désactiver l'un pendant que l'autre est éveillé. Cependant, vous ne pouvez pas simplement couper l'alimentation de la broche vdd, car les capteurs peuvent capter une partie de l'alimentation des broches SDA et SCL, ce qui entraînera de mauvaises lectures pour cette adresse. La vérification des erreurs pour I2C n'est pas assez bonne pour détecter/corriger ce cas. )

Les spécifications I2C nous indiquent que nous devrions avoir une résistance de rappel "forte" à la fois sur l'horloge et les câbles de données, sur le capteur le plus éloigné du fil. Pour cette raison, certains modules de capteurs ont déjà des résistances intégrées, et vous devrez peut-être simplement ajouter quelques cavaliers, alors assurez-vous de lire la documentation du ou des modules.

En plus des "résistances de terminaison de bus", j'ai également trouvé un indice d'un pirate informatique il y a longtemps, pour ajouter une résistance en ligne à la fois sur les fils de données (SDA) et d'horloge (SCL). Cela a considérablement amélioré la fiabilité des lectures de données à partir de quelques capteurs. Avec le MKR1000, en utilisant la signalisation 3.3v, j'utilise des résistances de 220 ohms. Sur un processeur 5 v, vous voudrez peut-être essayer 330 ohms. Voir le schéma ci-dessous pour voir la différence dans les emplacements.

Que ferez-vous des données ?

En ce moment, je l'envoie juste au moniteur série. Vous pouvez ajouter un écran LCD. J'allais ajouter une carte SD, mais maintenant que j'ai le wifi intégré, je veux télécharger les données sur un nuage... imaginez avoir quelques-uns de ces ponts de capteurs autour, connaître leur latitude et longitude, et pouvoir pour trianguler un coup de foudre en comparant les lectures de puissance de chaque station pour un coup de foudre donné !

À PART :2017-11-29; Je n'ai pas réussi à faire fonctionner les interruptions matérielles sur le MKR1000. Je prends des notes et des expériences de capteurs pour une classe de 9e année (13-14 ans), et peut-être que vous trouverez les croquis intéressants. La classe est construite autour de la carte Adalogger M0 et enregistre les données sur une carte SD, et il y a encore beaucoup de broches pour un module WiFi. http://arduinoclass.pbworks.com

Pendant que je travaillais sur les capteurs, j'ai également repéré le luminaire SODERSVIK chez IKEA (voir l'image ci-dessous.). Imaginez remplacer les LED blanches à l'intérieur de cette lampe par 20 néopixels et ajouter un récepteur à distance IR. Le vent qui souffle pourrait ressembler à des nuages ​​qui défilent, et la couleur pourrait indiquer la température. La télécommande peut également choisir d'afficher momentanément d'autres informations, comme le changement de température au cours des 12 dernières heures.

Que voulez-vous surveiller et afficher ?

Code

• L'ensemble du croquis de surveillance
• Prendre une lecture analogique moyenne
• Scanner de bus I2C
• Code de démonstration ML8511

L'ensemble du croquis de surveillanceArduino

/* RTC-Weather-Sensors_v6_MKR1000 par Zonker Harris Printemps 2016 * Hourra ! Une petite carte, avec plus de 2 interruptions matérielles ! * Plus WiFi, *et* crypto (TRÈS nécessaire pour les applications IoT !) * * Note aux nouveaux hackers :j'ai mis BEAUCOUP de commentaires dans mon code, comme vous le voyez. * Lorsque vous cliquez sur télécharger, *les commentaires sont IGNORÉS* et ne mangent pas de mémoire ! * Je vous recommande également d'ajouter de nombreux commentaires lorsque vous apportez des modifications * et des ajouts, pour vous aider à vous rappeler POURQUOI vous avez fait ce que vous avez fait il y a des mois. * Ils aideront aussi ceux qui viendront après vous, à apprendre une chose ou deux. * * Désormais, les bibliothèques *FONT* comptent dans la mémoire de votre programme... */#include #include #include #include // Y compris les néopixels comme espace réservé, mais le vecteur d'interruption de la bibliothèque doit être mis à jour.// Inclut la bibliothèque Adafruit_NeoPixel https://github.com/adafruit/Adafruit_NeoPixel//#include  //const int numLeds =1; // Combien de néopixels dans la chaîne ? utilisé pour définir la bibliothèque NeoPixel // Paramètre 1 =nombre de pixels dans la bande // Paramètre 2 =numéro de broche (la plupart sont valides) // Paramètre 3 =drapeaux de type de pixel, additionnez-les au besoin :// NEO_RGB Les pixels sont câblés pour RVB bitstream // NEO_GRB Les pixels sont câblés pour GRB bitstream // NEO_KHZ400 400 KHz bitstream (par exemple pixels FLORA) // NEO_KHZ800 800 KHz bitstream (par exemple bande LED haute densité)//Adafruit_NeoPixel bande =Adafruit_NeoPixel(numLeds, 6, NEO_GRBZ800 + NEO); /* Le pilote BMP085_U utilise la bibliothèque de capteurs unifiés Adafruit (Adafruit_Sensor), qui fournit un « type » commun pour les données des capteurs et certaines fonctions d'assistance. (Le BMP180 est compatible avec cette bibliothèque et donne la même sortie, mais la bibliothèque identifiera le BMP180 comme un BMP085.) Pour utiliser ce pilote, vous devrez également télécharger la bibliothèque Adafruit_Sensor et l'inclure dans votre dossier de bibliothèques. Vous devez également attribuer un ID unique à ce capteur à utiliser avec l'API du capteur Adafruit afin que vous puissiez identifier ce capteur particulier dans n'importe quel journal de données, etc. Pour attribuer un ID unique, fournissez simplement une valeur appropriée dans le constructeur ci-dessous (12345 est utilisé par défaut dans cet exemple). */Adafruit_BMP085_Unified bmp =Adafruit_BMP085_Unified (10180);/* Ce croquis est également conçu pour fonctionner avec le capteur HTU21D-F d'Adafruit ----> https://www.adafruit.com/products/1899 */Adafruit_HTU21DF htu =Adafruit_HTU21DF ();/* Horloge en temps réel (RTC) à batterie Macetech Chronodot v2.1... http://docs.macetech.com/doku.php/chronodot (parce que la batterie de mon MKR1000 ne semble pas garder le RTC embarqué en vie) Informations sur la bibliothèque de l'horloge en temps réel (RTC) Adafruit https://learn.adafruit.com/adafruit-data-logger-shield/using-the-real-time-clock Analog Devices TMP36 analogique capteur de température calibré. Cela nécessite quelques mathématiques https://learn.adafruit.com/tmp36-temperature-sensor http://www.analog.com/media/en/technical-documentation/data-sheets/TMP35_36_37.pdf Capteur UV ML8511... Ce capteur détecte plus efficacement la lumière de 280 à 390 nm. Ceci est classé dans le spectre UVB (rayons brûlants) et la plupart du spectre UVA (rayons bronzants). MOD-1016 (capteur de foudre AS3935) adresse i2c 0x03 - capteur de foudre AS3935 Adafruit dispose d'un anémomètre qui fournit une tension continue (0,4 à 2,0 v) https://www.adafruit.com/products/1733 http://www. instructables.com/id/Breezefinder-Citizen-Science-Windpower-Tool/step2/Build-the-housing/ Le détecteur d'humidité du sol (capteur YL-69 ou similaire) nécessite une entrée analogique... http://www.instructables.com /id/Arduino-LCD-Soil-Moisture-Sensor/step3/Connect-moisture-sensor/ Mes connexions MKR1000 (Tous les capteurs doivent être en signalisation 3.3v !) ===========*/int UVOUT =A1 ; // Sortie du capteur UV MV8511int lightOut =A2; // Sortie du capteur de lumière visible TEMT6000int tmp36out =A3; // Sortie du capteur de température local TMP36int mq9out =A4; // Sortie du DFrobot MQ-9 Capteur CO/Gs combustible/* Capteur d'humidité A5 Capteur de vitesse du vent A6 ? 0 (HW INT) bouton-poussoir 1 (HW INT) AS Détecteur de foudre 2 (HW INT) anémomètre de vitesse du vent ? (interruption par rotation) 3 (HW INT) Rain Tipper… 4 5 */int sounderPin =6; // Sortie Piezo Sounder (partagée avec la LED embarquée)// (Vous pouvez utiliser un cavalier pour désactiver la sirène, mais la LED embarquée clignotera) int neopixelPin =7; // Sortie NeoPixel, pour la visualisation à l'aide de LED basées sur un registre à décalage/*11 i2c SDA 12 i2c SCL */ // Variables de décalcomanie pour le Chronodot i2c RTC...int addrRTC =(0x68); // RTC i2c addressint secondes; //BCD combiné du RTC (00h)int seconds1 ; //0-9int secondes10 ; //-5int minutes ; //BCD combiné du RTC (01h)int minutes1 ; //-9int minutes10 ; //-6int heures ; //BCD combiné du RTC (02h)int heures1 ; //0-9 int heures10 ; //-2int jour ; //1-7 (03h) date int; //01-31 (04h)int mois ; //01-12 (05h) années int; //-99 ; (06h)int a1secs; // (07h) obtient l'alarme 1 secondesint a1mins; // (08h) obtenir l'alarme 1 minutesint a1hrs ; // (09h) obtient l'alarme 1 heuresint a1daydate; // (0Ah) obtient le jour et la date de l'alarme 1 bitsint a2mins ; // (0Bh) obtient l'alarme 2 minutesint a2hrs ; // (0Ch) obtient l'alarme 2 heuresint a2daydate; // (0Dh) obtient le jour et la date de l'alarme 2 bitsint rtcstatus ; // (0Eh) obtient l'état RTC bitsintaginginfo ; // (0Fh) obtient les informations de décalage de vieillissement// qu'est-ce que 10h?int temprtc; //BCD combiné du RTC (11h)int tempfrtc; //BCD combiné du RTC (12h)/****************************************** ************************************** /// Fonction de configuration Arduino (appelée automatiquement au démarrage)/** ******************************************************** **********************/void setup(void) { Serial.begin(9600); retard(1000); Serial.println("i2c Sensor Deck");// N'oubliez pas de configurer vos broches d'entrée et de sortie ! pinMode(UVOUT, INPUT); // le capteur UV ML8511 pinMode (lightOut, INPUT); // le capteur de lumière visible TEMT6000 pinMode (tmp36out, INPUT); // le capteur de température Analog Devices TMP36 pinMode(sounderPin, OUTPUT); // HIGH provoquera l'émission de bruit par le sondeur pinMode(neopixelPin, OUTPUT); // Utilisez une résistance de 220 ohms en ligne avec la bande /* Initialisez le capteur BMP085/BMP180 */ if(!bmp.begin()) { /* Il y a eu un problème de détection du BMP085/180 ... vérifiez votre connexions */ Serial.print("Oups, aucun BMP085/180 détecté... Vérifiez votre câblage ou I2C ADDR!"); tandis que (1); } /* Affiche des informations de base sur ce capteur, BMP180 rapporte comme BMP085 */ displaySensorDetails();/* Initialise le capteur HTU21D */ if (!htu.begin()) { Serial.println("Impossible de trouver le HTU21 -Capteur DF !"); tandis que (1) ; }// Initialiser l'horloge Chronodot RTC//(changer les valeurs, décommenter, puis télécharger pour régler l'heure, puis commenter à nouveau) /* secondes =0; minutes =41 ; heures =20 ; jour =7 ; date =3 ; mois =1 ; ans =16 ; initChrono();*/}void loop(void) { bip (50, 2); // annonce le début de la boucle sur le sondeur // Fixe le néopixel à Teal... //int red =0; vert entier =45 ; bleu int =30; //strip.setPixelColor(0, (rouge, vert, bleu)); //strip.show();/************************************************ *******************************//* Tirez l'info Chronot adresse i2c 0x68 - DS1307 RTC *//* Info carte :http ://docs.macetech.com/doku.php/chronodot *//* Fiche technique DS3231 :http://datasheets.maxim-ic.com/en/ds/DS3231.pdf *//******* ******************************************************** *************/ int temprtc; /* Obtenir un nouvel horodatage */ Wire.beginTransmission(0x68); // 0x68 est l'adresse du périphérique DS3231 Wire.write((byte)0) ; // commence au registre 0 Wire.endTransmission(); Wire.requestFrom (0x68, 13); // demande 19 octets (le nombre d'octets DEC ou HEX ?) // (secondes, minutes, heures, jour, date, mois, heures, // a1secs, a1mins, a1hrs // a1secs, a1mins, a1hrs // Vieillissement offset, Temp integer, temp fraction) while(Wire.available()) { seconds =Wire.read(); // (00h) obtient les secondes minutes =Wire.read(); // (01h) obtient les minutes heures =Wire.read(); // (02h) obtient les heures jour =Wire.read(); // (03h) obtient le jour de la semaine date =Wire.read(); // (04h) obtient la date du mois mois =Wire.read(); // (05h) récupère le mois et le siècle bits années =Wire.read(); // (06h) récupère l'année int a1secs =Wire.read(); // (07h) get Alarm 1 seconds int a1mins =Wire.read(); // (08h) get Alarm 1 minutes int a1hrs =Wire.read(); // (09h) get Alarm 1 hours int a1daydate =Wire.read(); // (0Ah) obtient les bits du jour et de la date de l'alarme 1 int a2mins =Wire.read(); // (0Bh) obtient l'alarme 2 minutes int a2hrs =Wire.read(); // (0Ch) obtient l'alarme 2 heures int a2daydate =Wire.read(); // (0Dh) obtient les bits du jour et de la date de l'alarme 2 int rtcstatus =Wire.read(); // (0Eh) obtient les bits d'état RTC intaginginfo =Wire.read(); // (0Fh) récupère les informations de décalage de vieillissement temprtc =Wire.read(); // (11h) récupère la partie entière du temp et signe tempfrtc =Wire.read(); // (12h) récupère la partie fractionnaire du temp // Lisez nos bits et normalisez les données avec un remplissage de zéro de début // REMARQUE :Le Chronodot ne connaît pas l'heure d'été, devriez-vous votre code ? secondes10 =((secondes &0b11110000)>>4) ; secondes1 =((secondes &0b00001111)); // convertir BCD en minutes décimales10 =((minutes &0b11110000)>>4) ; minutes1 =(minutes &0b00001111) ; // convertir BCD en heures décimales10 =(((heures &0b00100000)>>5)*2 + ((heures &0b00010000)>>4)*1) ; heures1 =(heures &0b00001111) ; // convertir le BCD en décimal (en supposant le mode 24 heures) années =(années + 2000); temprtc =((temprtc &0b01111111) + (((tempfrtc &0b11000000)>>6)*0.25)); } avoir un rendez-vous(); // C'est un endroit où vous pouvez ajouter des décisions Dayligh Savings Time pour modifier les heures... Serial.print("ChronoDot - "); Serial.print(hours10) ; Serial.print(hours1) ; Serial.print(":"); Serial.print(minutes10) ; Serial.print(minutes1) ; Serial.print(":"); Serial.print(seconds10) ; Serial.print(seconds1) ; Serial.print(" 20"); Serial.print(ans); Serial.print(" "); Serial.print(mois); Serial.print(" "); Serial.print(date); Serial.print(" \t"); Serial.print(temprtc); Serial.println(" C"); retard (100); // donc cela finira l'impression, au cas où le prochain capteur serait bloqué /************************************ ************************************//* Get BMP180 data i2c address 0x77 - BMP180 Baro Pres and Temp *//* data:http://www.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf *//******************* ************************************************** */ sensors_event_t event; bmp.getEvent(&event); /* First we get the current temperature from the BMP085/BMP180 */ float BMPtemperature; bmp.getTemperature(&BMPtemperature); float BMPtempF =(BMPtemperature * 1.8 + 32); Serial.print("Temp:"); Serial.print(BMPtemperature); Serial.print(" C ("); Serial.print(BMPtempF); Serial.print(" F) \t"); /* Display the results (barometric pressure is measure in hPa) */ if (event.pressure) { /* Display atmospheric pressue in hPa */ Serial.print("BMP180 - Pres:"); Serial.print(event.pressure); Serial.print(" hPa\t"); /* Calculating altitude with reasonable accuracy requires pressure * * sea level pressure for your position at the moment the data is * * converted, as well as the ambient temperature in degress * * celcius. If you don't have these values, a 'generic' value of * * 1013.25 hPa can be used (defined as SENSORS_PRESSURE_SEALEVELHPA * * in sensors.h), but this isn't ideal and will give variable * * results from one day to the next. * * * * You can usually find the current SLP value by looking at weather * * websites or from environmental information centers near any major * * airport. * * * * convert inches-mercury http://www.csgnetwork.com/pressinmbcvt.html * * * For example, for Paris, France you can check the current mean * * pressure and sea level at:http://bit.ly/16Au8ol */ /* Then convert the atmospheric pressure, and SLP to altitude */ /* Update this next line with the current SLP for better results */ float seaLevelPressure =SENSORS_PRESSURE_SEALEVELHPA; Serial.print("Alt:"); Serial.print(bmp.pressureToAltitude(seaLevelPressure, event.pressure)); Serial.println(" m"); retard (100); // so this will finish printing, in case the next sensor is stalled } else { Serial.println("Sensor error"); } /**********************************************************************/* Get HTU21-DF data i2c address 0x40 - Humidity and Temp Sensor */* Then convert the atmospheric pressure, and SLP to altitude */* Update this next line with the current SLP for better results */* https://learn.adafruit.com/adafruit-htu21d-f-temperature-humidity-sensor/overview/**********************************************************************/ float HTUtemperature =htu.readTemperature(); float HTUtempF =(HTUtemperature * 1.8 + 32); Serial.print("HTU21-DF - Temp:"); Serial.print(HTUtemperature); Serial.print(" C ("); Serial.print(HTUtempF); Serial.print(" F)\tHum:"); Serial.print(htu.readHumidity()); Serial.println("%"); retard (100); // so this will finish printing, in case the next sensor is stalled/**********************************************************************/* Analog Devices venerable TMP36 precision temperature sensor/* this requires a bit of math after reading the output.../* https://learn.adafruit.com/tmp36-temperature-sensor/using-a-temp-sensor/**********************************************************************/ //getting the voltage reading from the temperature sensor int reading =averageAnalogRead(tmp36out); // 0.0032258064516129 are the DAC unit for 3.3v float tmp36voltage =0.0032258064516129 * reading; // print out the voltage Serial.print("TMP36 - temp:"); float tmp36temperatureC =(tmp36voltage - 0.5) * 100; //converting from 10 mv per degree with 500 mV offset to degrees ((voltage - 500mV) times 100) Serial.print(tmp36temperatureC); Serial.print(" C \t"); // now convert to Fahrenheit float tmp36temperatureF =(tmp36temperatureC * 9.0 / 5.0) + 32.0; Serial.print(tmp36temperatureF); Serial.print(" F, out:"); Serial.print(tmp36voltage); Serial.println("v"); retard (100); // so this will finish printing, in case the next sensor is stalled/********************************************************************** * Vishay TEMT6000 Visible Light sensor - analog reading * https://www.sparkfun.com/products/8688/**********************************************************************/ int vLevel =averageAnalogRead(lightOut); // 0.0032258064516129 is (3.3v (the DAC ref voltage) \ 1023 * uvLevel) float newVOutVolts =0.0032258064516129 * vLevel; Serial.print("TEMT6000 out:"); Serial.println(vLevel); retard (100); // so this will finish printing, in case the next sensor is stalled /********************************************************************** * ML8511 UV Sensor - analog reading * https://learn.sparkfun.com/tutorials/ml8511-uv-sensor-hookup-guide */**********************************************************************/ int uvLevel =averageAnalogRead(UVOUT); // 0.0032258064516129 is (3.3v (the DAC ref voltage) \ 1023 * uvLevel) float newOutVolts =0.0032258064516129 * uvLevel; //Convert the voltage to a UV intensity level float uvIntensity =mapfloat(newOutVolts, 0.99, 2.8, 0.0, 15.0); Serial.print("ML8511 UV out:"); Serial.print(uvLevel); Serial.print(" / UV Intensity (mW/cm^2):"); Serial.println(uvIntensity); retard (100); // so this will finish printing, in case the next sensor is stalled/********************************************************************** * DFrobot MQ-9 CO/Combustable Gas sensor - analog reading * http://www.dfrobot.com/wiki/index.php/Analog_Gas_Sensor(MQ9)_(SKU:SEN0134) * https://www.pololu.com/category/83/gas-sensors There are many available * But, deciphering what the output levels mean is an exercise for the buyer. :-(/**********************************************************************/ int MQ9volts =analogRead(mq9out); // Read Gas value from the MQ-9 sensor Serial.print("MQ-9 Gas:"); Serial.println(MQ9volts,DEC); delay(100); // so this will finish printing, in case the next sensor is stalled Serial.println(""); delay(3500); // looking to time the loop at about 5 seconds... // End of the main loop...}/**************************************************************************//* The code below are supporting subroutines */**************************************************************************//* Chronodot-related subroutines * * initChrono, set_date, get_date, set_time, get_time, get_temp, * * setHour, SetMinutes, decToBcd, bcdToDec *//**************************************************************************/void initChrono(){ set_time(); set_date();}void set_date(){ Wire.beginTransmission(104); Wire.write(4); Wire.write(decToBcd(day)); Wire.write(decToBcd(date)); Wire.write(decToBcd(mont h)); Wire.write(decToBcd(years)); Wire.endTransmission();}void get_date(){ Wire.beginTransmission(104); Wire.write(3);//set register to 3 (day) Wire.endTransmission(); Wire.requestFrom(104, 4); //get 4 bytes(day,date,month,year); day =bcdToDec(Wire.read()); date =bcdToDec(Wire.read()); mois =bcdToDec(Wire.read()); years =bcdToDec(Wire.read());}void set_time(){ Wire.beginTransmission(104); Wire.write((byte)0); Wire.write(decToBcd(seconds)); Wire.write(decToBcd(minutes)); Wire.write(decToBcd(hours)); Wire.endTransmission();}void get_time(){ Wire.beginTransmission(104); Wire.write((byte)0);//set register to 0 Wire.endTransmission(); Wire.requestFrom(104, 3);//get 3 bytes (seconds,minutes,hours); seconds =bcdToDec(Wire.read() &0x7f); minutes =bcdToDec(Wire.read()); hours =bcdToDec(Wire.read() &0x3f);}void get_temp(){ Wire.beginTransmission(104); Wire.write((byte)0); //set register to 0 Wire.endTransmission(); Wire.requestFrom(104, 3);//get 3 bytes (seconds,minutes,hours); seconds =bcdToDec(Wire.read() &0x7f); minutes =bcdToDec(Wire.read()); hours =bcdToDec(Wire.read() &0x3f);}void setHour(){ hours++; if (hours> 23) { hours =0; seconds =0; minutes =0; } set_time();}void setMinutes(){ minutes++; if (minutes> 59) { minutes =0; } seconds =0; set_time();}byte decToBcd(byte val){ return ( (val / 10 * 16) + (val % 10) );}byte bcdToDec(byte val){ return ( (val / 16 * 10) + (val % 16) );}/**************************************************************************//* Displays some basic information on this sensor from the unified sensor API sensor_t type (see Adafruit_Sensor for more information) *//**************************************************************************/void displaySensorDetails(void){ sensor_t sensor;// bmp.getSensor(&sensor); Serial.println("------------------------------------"); Serial.print ("Sensor:"); Serial.println(sensor.name); Serial.print ("Driver Ver:"); Serial.println(sensor.version); Serial.print ("Unique ID:"); Serial.println(sensor.sensor_id); Serial.print ("Max Value:"); Serial.print(sensor.max_value); Serial.println(" hPa"); Serial.print ("Min Value:"); Serial.print(sensor.min_value); Serial.println(" hPa"); Serial.print ("Resolution:"); Serial.print(sensor.resolution); Serial.println(" hPa"); Serial.println("------------------------------------"); Serial.println(""); delay(500);}/**************************************************************************//* Takes an average of readings on a given pin, Returns the average */* used for the TMP36 and ML8511 UV Sensor readings./**************************************************************************/int averageAnalogRead(int pinToRead){ byte numberOfReadings =8; unsigned int runningValue =0; for(int x =0; x  
Taking an Average Analog ReadingArduino 
 This was a clever hack I found in the SparkFun library for the ML8511 UV Sensor, but I'm calling it out specifically, since you can use it for any analog read! If you ever meet Nathan Seidl, please buy him a beer (it's a Beerware license.)
//Takes an average of readings on a given pin//Returns the averageint averageAnalogRead(int pinToRead){ byte numberOfReadings =8; unsigned int runningValue =0; for(int x =0; x  
I2C bus scannerArduino 
 If you don't know the base address for your i2c devices, use this to scan the range of valid addresses. It knows about the sensors that I've been working with. You can add sections for your other sensors.
// --------------------------------------// i2c_scanner//// Found at http://playground.arduino.cc/Main/I2cScanner?action=sourceblock&num=1// 26 OCT 2015//// Version 1// This program (or code that looks like it)// can be found in many places.// For example on the Arduino.cc forum.// The original author is not know.// Version 2, Juni 2012, Using Arduino 1.0.1// Adapted to be as simple as possible by Arduino.cc user Krodal// Version 3, Feb 26 2013// V3 by louarnold// Version 4, March 3, 2013, Using Arduino 1.0.3// by Arduino.cc user Krodal.// Changes by louarnold removed.// Scanning addresses changed from 0...127 to 1...119,// according to the i2c scanner by Nick Gammon// http://www.gammon.com.au/forum/?id=10896// Version 5, March 28, 2013// As version 4, but address scans now to 127.// A sensor seems to use address 120.//// This sketch tests the standard 7-bit addresses// Devices with higher bit address might not be seen properly.//// Zonk er Harris added device descriptions, comments. OCT 10 2015// #include void setup(){ Wire.begin(); Serial.begin(9600); Serial.println("\nI2C Scanner");}void loop(){ byte error, address; int nDevices; Serial.println("Scanning..."); nDevices =0; for(address =1; address <127; address++ ) { // The i2c_scanner uses the return value of // the Write.endTransmisstion to see if // a device did acknowledge to the address. Wire.beginTransmission(address); error =Wire.endTransmission(); if (error ==0) { Serial.print("I2C device found at address 0x"); if (address<16) Serial.print("0"); Serial.print(address,HEX); // Serial.print(address); If needed, print the address in decimal // // Now, detail sensors that we know about or expect... if (address ==3) { // DEC 3 =0x03 HEX =AS3935 Lightning Sensor Serial.print(" - AS3935 Lightning Sensor"); } if (address ==64) { // DEC 64 =0x40 HEX =HTU21D Humidity and Temp Sensor Serial.print(" - HTU21D Humidity and Temp Sensor"); } if (address ==104) { // DEC 104 =0x68 HEX =DS1307 (Chrono-Dot?) RTC Serial.print(" - DS1307 RTC (Chrono-Dot?)"); } if (address ==119) { // DEC 119 =0x77 HEX =BMP180 Barometric Pressure and Tem Sensor Serial.print(" - BMP180 Barometric Pressure and Tem Sensor"); } Serial.println(" "); nDevices++; } else if (error==4) { Serial.print("Unknow error at address 0x"); if (address<16) Serial.print("0"); Serial.println(address,HEX); if (address ==3) { // DEC 3 =0x03 HEX =AS3935 Lightning Sensor Serial.print(" - AS3935 Lightning Sensor"); } if (address ==64) { // DEC 64 =0x40 HEX =HTU21D Humidity and Temp Sensor Serial.print(" - HTU21D Humidity and Temp Sensor"); } if (address ==104) { // DEC 104 =0x68 HEX =DS1307 (Chrono-Dot?) RTC Serial.print(" - DS1307 RTC (Chrono-Dot?)"); } if (address ==119) { // DEC 119 =0x77 HEX =BMP180 Barometric Pressure and Tem Sensor Serial.print(" - BMP180 Barometric Pressure and Tem Sensor"); } } } if (nDevices ==0) Serial.println("No I2C devices found\n"); else Serial.println("done\n"); retard (5000); // wait 5 seconds for next scan}/* The output looks like this... * * Scanning... * I2C device found at address 0x03 - AS3935 Lightning Sensor * I2C device found at address 0x40 - HTU21D Humidity and Temp Sensor * I2C device found at address 0x68 - DS1307 RTC (Chrono-Dot?) * I2C device found at address 0x77 - BMP180 Barometric Pressure and Tem Sensor * done * */
 
ML8511 Demo CodeArduino 
 Modified for use with a 3.3v-native CPU (for DAC reference units).
/* * From https://learn.sparkfun.com/tutorials/ml8511-uv-sensor-hookup-guide 19 MAR 2016 * (Adapted for MKR1000 by Zonker Harris, MAR 2016) ML8511 UV Sensor Read Example By:Nathan Seidle SparkFun Electronics Date:January 15th, 2014 License:This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license). The ML8511 UV Sensor outputs an analog signal in relation to the amount of UV light it detects. Connect the following ML8511 breakout board to Arduino:3.3V =3.3V OUT =A1 GND =GND EN =3.3V * The Sparkfun demo presumes 5v VCC, but the MKR1000 is 3.3v native. * Because of this, the second reference voltage value will always be "1023". * As a result of testing, I cut that part out... -Z- Test your sensor by shining daylight or a UV LED:https://www.sparkfun.com/products/8662 This sensor detects 280-390nm light most effectively. This is categorized as part of the UVB (burning rays) spectrum and most of the UVA (tanning rays) spectrum. There's lots of good UV radiation reading out there:http://www.ccohs.ca/oshanswers/phys_agents/ultravioletradiation.html https://www.iuva.org/uv-faqs *///Hardware pin definitionsint UVOUT =A1; //Output from the sensorvoid setup(){ Serial.begin(9600); pinMode(UVOUT, INPUT); Serial.println("ML8511 example");}void loop(){ int uvLevel =averageAnalogRead(UVOUT); float newOutVolts =0.0032258064516129 * uvLevel; // This is 3.3v \ 1023 * uvLevel float uvIntensity =mapfloat(newOutVolts, 0.99, 2.8, 0.0, 15.0); //Convert the voltage to a UV intensity level Serial.print("ML8511 out:"); Serial.print(uvLevel); Serial.print(" / UV Intensity (mW/cm^2):"); Serial.print(uvIntensity); Serial.println(); delay(100);}//Takes an average of readings on a given pin//Returns the averageint averageAnalogRead(int pinToRead){ byte numberOfReadings =8; unsigned int runningValue =0; for(int x =0; x  

Schémas