Étape 6: Module1 - Arduino/RTC - Test Code
S’il vous plaît être conscient que tout le code pour ce projet a été écrit en 0022 Arduino. Je n’ai pas encore essayé de 1.0.
Je n’ai pas été en mesure de télécharger n’importe quel code sous forme de fichiers .pde. Je ne sais pas pourquoi. J’ai renommé eux comme .txt, que vous pouvez ouvrir dans WordPad et copiez/collez dans l’IDE, ou vous pouvez les renommer .pde lorsque vous avez téléchargé.
TÉLÉCHARGEMENT :
Ce petit mes ' n’est pas dotées d’un circuit de réinitialisation automatique fantaisie. Ainsi, nous avons besoin d’appuyer sur l’interrupteur de réinitialisation pour le moment correct. J’ai vu un certain nombre de moyens proposés pour ce calendrier, mais celui-ci fonctionne bien pour moi :
1) - connecter les broches Tx et Rx de votre convertisseur USB pour les en-têtes sur les broches 2 et 3 de la puce (D0 et D1).
2) - alimenter votre Conseil d’administration (de l’USB si possible - dans le cas contraire s’assurer que les connexions à la terre sont rejoints mais le + 5V ne sont pas!).
3) - Assurez-vous de sélectionner "Duemilanove/Tiny avec 328" comme votre tableau cible.
4) - cliquez sur le bouton Télécharger dans l’IDE.
5) - pendant que votre code compile, regarder la ligne d’État en bas de la fenêtre de l’IDE.
6) - dès que la petite fenêtre en bas de l’IDE vous indique la taille de votre croquis compilés, appuyer sur reset.
(7) - les lumières de Tx/Rx sur votre convertisseur USB doivent clignoter pendant un certain temps.
Si pour quelque raison il ne fonctionne pas première fois, elle n’expire après que environ 30 secondes et vous pouvez essayer à nouveau. Il est très rare pour qu’il prenne plus de deux tentatives.
Le code attaché sera initialement régler l’heure et puis afficher le temps dans la fenêtre de Serial Monitor de l’IDE. Dans la routine « setup » vous pouvez l’envoyer un caractère de « R » pour remettre de l’époque, donc vous pouvez re-régler l’horloge de chaque fois que vous réinitialisez votre 328.
Il va vous demander ensuite progressivement moins importants aspects de la date et l’heure et enfin afficher les nouveaux paramètres pour que vous confirmiez. Il n’est pas très sophistiquée, donc s’il vous plaît n’oubliez pas :
À chaque entrée numérique, il faut deux chiffres décimaux, alors pour le jour 2 (mardi) Entrez « 02 » dans le moniteur de la série.
Lorsqu’est demandée confirmation etc, c’est des cas spécifiques, pour régler l’horloge, seulement un « Y » vais faire comme la réponse finale.
Une fois que le temps est définie ou que vous « Q » de la routine de réglage puis il affichera l’heure du CCF sur le moniteur série chaque seconde.
Évidemment, une fois que le CCF est mis sa batterie gardera en marche même lorsque vous arrêt votre mes ' vous pouvez maintenant exécuter vos propres croquis et fouetter juste quelques fonctions de ce croquis pour obtenir l’heure quand vous en avez besoin. Pour l’horloge fini nous placerons le temps directe de la mes ' mais nous avons besoin de certains intrants et un écran pour cela ! Temps de passer à un autre module...
****************
Aube-lumière alarme horloge croquis de l’UGI.
Croquis de Test de CCF
Licence MIT
UGI déc 2012
Écrite pour Arduino 022 fonctionnant sur ATmega328.
nécessite la bibliothèque de fils
Connexions des broches de l’Arduino :
A4 - 1307 (données I2C)
A5 - 1307 (horloge I2C)
Paramètres de l’horloge générales :
#include < Wire.h > - / / analogique usees pins A4 (SDA - pin 27) et A5 (SCL-broche 28) pour les données de 2 fils.
const byte DS1307_Address = 0x68 ;
secondes octets = 45, oldseconds = 0, minutes = 52, hours = 23, date = 8 mois = 12, jour = 4, année = 11, protéger = 0 ; par défaut, juste bien commencer quelque part.
octet NEWseconds = 45, NEWminutes = 52, NEWhours = 23, Nouvelle_date = 8, NEWmonth = 12, NEWday = 4, nouvel an = 11 ; Ce sont pour le réglage.
void setup() {}
Serial.Begin(9600) ; Serial.println ("RTC DS1307 fonction horloge - Ugi 2012") ;
Delay(2000) ; Donner des CCF quelques temps à s’installer.
Wire.Begin() ; Nécessité de CCF
RTCsetFromSerial() ; Possibilité de régler l’heure de la série chaque réinitialisation. Pourrait permettre un délai d’attente.
}
void loop() {}
RTCread() ;
RTCprintTime() ; envoie de temps à la série.
Delay(1000) ;
} / / Fin de boucle principale
Lu fois CCF dans des variables de temps.
void RTCread() {}
octet de données [11] = {0,0,0,0,0,0,0,0,0,0,0} ;
Wire.beginTransmission(DS1307_Address) ;
Wire.Send(0) ; Set de Registre au début
Wire.endTransmission() ;
Wire.requestFrom (DS1307_Address, (octet) 10) ; demander 7 octets de RTC dans buffer.
pour (byte vannes_ouvertes.Elements = 0; vannes_ouvertes.Elements < 10 ; vannes_ouvertes.Elements ++) {}
Data[_loop]=(Wire.Receive()) ;
}
secondes = (((data [0] & B01110000) >> 4) * 10) + (data [0] & B00001111) ;
minutes = (((données [1] & B01110000) >> 4) * 10) + (données [1] & B00001111) ;
heures = (((données [2] & B00110000) >> 4) * 10) + (données [2] & B00001111) ;
jour = (données [3] & B00000111) ;
Date = (((données [4] & B00110000) >> 4) * 10) + (données [4] & B00001111) ;
mois = (((données [5] & B00010000) >> 4) * 10) + (données [5] et B00001111) ;
an = (((données [6] & B11110000) >> 4) * 10) + (données [6] & B00001111) ;
}
Écrire l’heure actuelle au CCF
void RTCwrite() {/ / écrit toutes les données actuelles CCF - si vous voulez seulement écrire un paramètre puis juste commencez par lire l’horloge !
octet de données [7] ;
Data [0] = (secondes % 10) + ((seconds/10) << 4) ;
données [1] = (% de minutes 10) + ((minutes/10) << 4) ;
données [2] = (% heures 10) + ((hours/10) << 4) ;
données [3] = jour ;
données [4] = (date courante% 10) + ((date/10) << 4) ;
données [5] = (% de mois 10) + ((month/10) << 4) ;
données [6] = (10 % de l’année) + ((year/10) << 4) ;
Wire.beginTransmission(DS1307_Address) ;
Wire.Send(0) ; Set de Registre au début
pour (byte vannes_ouvertes.Elements = 0; vannes_ouvertes.Elements < 7; vannes_ouvertes.Elements ++) {}
Wire.Send(Data[_loop]) ;
}
Wire.endTransmission() ;
oldseconds = secondes ;
} / / Fin de fonction RTC Write
Imprimer l’heure actuelle pour la série...
void RTCprintTime() {}
RTCread() ;
Serial.Print ("Time =") ; Serial.Print (heures, DEC) ; Serial.Print(":") ; Serial.Print (minutes, DEC) ; Serial.Print(":") ; Serial.println (secondes, DEC) ;
Serial.Print ("Date =") ; Serial.Print (date, DEC) ; Serial.Print("/") ; Serial.Print (mois, DEC) ; Serial.Print("/20") ; Serial.Print (année, DEC) ;
}
octet RTCgetSerial (octet _val, String _Str) {}
Serial.println("") ;
Serial.println ("*** « + _Str + » ***") ;
Serial.Print ("valeur actuelle =") ; Serial.Print (_val, DEC) ; Serial.println ("" + _Str) ;
Serial.println ("entrez la nouvelle valeur (deux chiffres par exemple « 01 »):") ;
Serial.Flush() ;
octet NEW_val = -1 ;
tandis que (Serial.available() < 2) {}
Delay(50);}
NEW_val = ((Serial.read()-48)*10) ;
NEW_val = NEW_val + (Serial.read()-48) ;
Serial.Flush() ;
Serial.Print ("nouvelle valeur =") ; Serial.Print (NEW_val, DEC) ; Serial.println ("" + _Str) ; Serial.println("") ;
Si (NEW_val > = 0) {return NEW_val;}
else {return _val;}
}
Boolean RTCconfirm() {}
Serial.println("") ;
Serial.println("currently:") ;
RTCprintTime() ;
Serial.Flush() ;
Serial.println("") ;
Serial.println (« changement à ? (Y/N): ") ;
Serial.Print ("temps =") ; Serial.Print (NEWhours, DEC) ; Serial.Print(":") ; Serial.Print (NEWminutes, DEC) ; Serial.Print(":") ; Serial.println (NEWseconds, DEC) ;
Serial.Print ("date =") ; Serial.Print (Nouvelle_date, DEC) ; Serial.Print("/") ; Serial.Print (NEWmonth, DEC) ; Serial.Print("/20") ; Serial.Print (nouvel an, DEC) ;
char _conf = -1 ;
tandis que (Serial.available() < 1) {}
Delay(50);}
_conf = Serial.read() ;
Serial.Flush() ;
Serial.Print ("confirmer les chiffres =") ; Serial.println(_conf) ;
if(_conf=='Y') {return true;}
else {return false;}
}
Boolean RTCsetFromSerial() {}
Téléchargez le nouveau réglage de l’heure depuis le port série
Serial.Flush() ; éviter des données aléatoires dans la mémoire tampon.
Voir si nous voulons mettre à jour
char _input = « X » ;
tandis que (_input! = « R » & & _input! = « Q ») {}
tandis que (Serial.available() < 1) {}
RTCprintTime() ; Nous allons garder l’affichage de l’heure actuelle et voir si elle doit être mise à jour.
Serial.println ("Enter « R » par une entrée série pour re-définir") ou Q pour quitter le réglage de routine ;
Serial.println("") ;
Delay(1000) ;
}
_Input = Serial.read() ;
Serial.Flush() ;
}
Si (_input! = ' R'){Serial.println("") ; Serial.println ("*** abandon ***") ; Serial.println("") ; return false;}
Serial.println("") ;
Serial.println ("*** réinitialisation RTC ***") ;
Serial.println("") ;
RTCprintTime() ;
Nouvel an = RTCgetSerial (year, « ans ») ;
RTCprintTime() ;
NEWday = RTCgetSerial (jour, « jour de la semaine ») ;
RTCprintTime() ;
NEWmonth = RTCgetSerial (mois, « mois ») ;
RTCprintTime() ;
Nouvelle_date = RTCgetSerial (date, « les jours du mois ») ;
RTCprintTime() ;
NEWhours = RTCgetSerial (heures, « Heures ») ;
RTCprintTime() ;
NEWminutes = RTCgetSerial (minutes, « Minutes ») ;
RTCprintTime() ;
NEWseconds = RTCgetSerial (secondes, « Secondes ») ;
Si (RTCconfirm()) {}
secondes = NEWseconds ;
minutes = NEWminutes ;
heures = NEWhours ;
Date = Nouvelle_date ;
mois = NEWmonth ;
jour = NEWday ;
année = nouvel an ;
RTCwrite() ;
Serial.println ("") ;
Serial.println ("*** CCF mise à jour ***") ;
retourne la valeur true ;
}
else {}
Serial.println ("*** mise à jour annulée ***") ;
}
retourne la valeur false ;
}