घरेलू घड़ियों के विषय पर, मैंने जारी रखने का वादा किया था, इसलिए आप यहाँ जाएँ। घर में बने एलईडी मैट्रिसेस पर घड़ी।
, और
ऐसा प्रति खंड 7*4*3=84+2=86 टुकड़ों में तीन एलईडी की दर से खंड घड़ियाँ बनाने का प्रयास करने के लिए किया गया था।
यह लगभग इस प्रकार है:
मैं अलग-अलग रंग और निश्चित रूप से चमकीले रंग आज़माना चाहता था (यह अन्यथा कैसे हो सकता है?)
इस कारण से, 100 टुकड़ों के बैच मेरे लिए काफी अनुकूल थे, खासकर जब से कीमत काफी उचित है, और मैंने उसी स्टोर से अलग-अलग रंगों में नंबर बनाने का भी ऑर्डर दिया ताकि मैं एक डिस्प्ले पर रंगों की तुलना कर सकूं - कौन सा और अधिक सुंदर होगा, इत्यादि - बस मजाक कर रहा हूँ... :)
उत्पाद का ऑर्डर दिया गया और उसका भुगतान किया गया 20 अगस्त 2016, और आ गया 15 सितंबर 2016, हमारे मानकों के अनुसार, बहुत जल्दी। लेकिन! लाल एल ई डी - नहीं पहुंचे! खरीदार की सुरक्षा अवधि के अंत में, एक विवाद खोला गया और विक्रेता ने पैसे वापस कर दिए। मेरा समय बर्बाद करना शर्म की बात थी...
उत्पाद एक मानक पीले बबल मेलिंग लिफाफे में आया था, एल ई डी स्वयं एक अलग प्लास्टिक बैग में पैक किए गए थे, नीले और हरे रंग में टुकड़ों की संख्या 100 से थोड़ी अधिक थी (मुझे अब बिल्कुल याद नहीं है, लेकिन मुझे याद है कि वहां 4-5 टुकड़े अधिक थे)
सभी कार्यशील (अर्थात् चमकते हुए)
जो बहुरंगी थे, उन्हें अलग-अलग थैलियों में पैक किया गया था, जिन पर रंग R G B W Y को एक मार्कर से चिह्नित किया गया था - रंग हर जगह मेल खाता था, और 2-3 अतिरिक्त भी - यह धारणा बनाई गई थी कि यह शायद सभी के लिए मामला था, लेकिन बाद में मुझे यकीन था कि हमेशा ऐसा नहीं होता, इसका उल्टा भी होता है...
यदि यह लाल जंब के लिए नहीं होता, तो विक्रेता को गैर-लालच के लिए मोटा A+ दिया जा सकता था।
दूसरी ओर, पैसा वापस कर दिया गया - समस्या समय बर्बाद हो गई है, और उसने एक पत्र भी भेजा जिसमें उसने लिखा कि वह अपना पैसा मुझे लौटा रहा है, और यदि माल आ गया, तो उसने मुझसे यह राशि उसे वापस करने के लिए कहा।
शब्दशः:
नमस्ते, मेरे दोस्त, मैं अब रिफंड कर रहा हूं, जब आपको कोई पैकेज मिले, तो कृपया मेरे पैसे वापस कर दें, कृपया मुझे पांच सितारा उच्च प्रशंसा दें।
जिस पर उन्हें एक पत्र लिखना पड़ा कि यह नहीं था उसकापैसा, लेकिन विवाद के परिणामस्वरूप वह इसे मुझे लौटा देता है मेरापैसा, क्योंकि मुझे उसका सामान कभी नहीं मिला और साथ ही उसके सामान के इंतजार में मेरा काफी समय बर्बाद हो गया
वैसे, जब 10 दिन बाद उनके बाकी सभी ऑर्डर आ गए, तो मैंने उन्हें पत्र लिखकर कहा कि मैं चिंतित हूं क्योंकि... यह अजीब है - हर कोई आया, लेकिन एक भी ऑर्डर नहीं आया
जिस पर उन्होंने बिना किसी "हैलो फ्रेंड" के शुष्क उत्तर दिया, "अभी 60 दिन नहीं हुए हैं"
और फिर अचानक वह एक "दोस्त" बन गया, और ऐसा लगा जैसे उसने उसके पैसे ले लिए हों...
लेकिन सामान्य तौर पर - विक्रेता अपने कर्तव्यों को पूरा करता है, पत्रों का जवाब देता है, भेजे गए सामान में केवल सकारात्मक भावनाएं होती हैं, जो नहीं भेजा गया उसके लिए उसने पैसे लौटा दिए - सब कुछ नियमों के अनुसार है
खैर, अब इसके बारे में कि इसे क्यों खरीदा गया था
होममेड एलईडी मैट्रिसेस पर घर में बनी घड़ियाँ
इलेक्ट्रॉनिक घड़ी को अपने हाथों से असेंबल करने के कई तरीके हैं: आरेख साहित्य और इंटरनेट पर व्यापक रूप से प्रस्तुत किए जाते हैं। अधिकांश आधुनिक कार्यान्वयन माइक्रोकंट्रोलर पर आधारित हैं। ऐसी परियोजनाओं के कार्यान्वयन के लिए अक्सर इलेक्ट्रॉनिक्स के क्षेत्र में व्यापक व्यावहारिक कौशल और सैद्धांतिक ज्ञान की आवश्यकता होती है: विशेष सॉफ़्टवेयर का उपयोग करने की क्षमता, घर पर निर्माण करना मुद्रित सर्किट बोर्डफेरिक क्लोराइड में नक़्क़ाशी विधि द्वारा, अच्छी सोल्डरिंग। आपके पास विभिन्न प्रकार के उपकरण और आपूर्तियाँ भी होनी चाहिए।
हालाँकि, घर पर अपने हाथों से इलेक्ट्रॉनिक घड़ी को असेंबल करने का एक सरल और किफायती तरीका है: Arduino प्लेटफ़ॉर्म का उपयोग करें। यह एक सॉफ्टवेयर और हार्डवेयर कॉम्प्लेक्स है जिसे विशेष रूप से प्रोग्रामिंग और इलेक्ट्रॉनिक्स की मूल बातें सिखाने के लिए डिज़ाइन किया गया है। सी Arduino का उपयोग करनाकोई भी, विशेष प्रारंभिक प्रशिक्षण के बिना भी, अपने हाथों से एक इलेक्ट्रॉनिक घड़ी बना सकता है: सर्किट आरेख, इंजीनियरिंग कार्यक्रम और यहां तक कि टांका लगाने वाले लोहे की भी आवश्यकता नहीं है!
सभी इलेक्ट्रॉनिक घटकों का कनेक्शन एक विशेष संपर्क ("सोल्डरलेस") ब्रेडबोर्ड पर किया जाता है, जो जलने, कटने और अन्य चोटों के जोखिम को समाप्त करता है - इसलिए, आप बच्चों के साथ Arduino डिज़ाइनर के साथ काम कर सकते हैं। सर्किट आरेख प्रस्तुत करने का एक दृश्य तरीका आपको डिवाइस को असेंबल करते समय गलतियाँ करने से बचने में मदद करेगा।
चरण 1. घटकों की सूची
एलईडी मैट्रिसेस पर एक साधारण घड़ी को असेंबल करने के लिए आपको केवल कुछ सस्ते घटकों की आवश्यकता होगी:
- अरुडिनो प्लेटफार्म. सबसे सरल मॉडल उपयुक्त होंगे - या माइक्रो;
- ब्रेडबोर्ड से संपर्क करें;
- ब्रेडबोर्ड के लिए कनेक्टिंग तार;
- Adafruit DS3231 रीयल-टाइम क्लॉक मॉड्यूल;
- एलईडी मैट्रिक्स मॉड्यूल 32x8 MAX7219;
- दो बटन.
नियंत्रण प्रोग्राम को मेमोरी में लोड करने के लिए आपको एक पर्सनल कंप्यूटर और एक यूएसबी-मिनी-यूएसबी केबल की भी आवश्यकता होगी। बस इतना ही - एक टांका लगाने वाला लोहा, इन्सुलेशन स्ट्रिपर्स, असेंबली चाकू और अन्य पेशेवर उपकरणों की आवश्यकता नहीं है: सभी ऑपरेशन हाथ से किए जाते हैं। शायद कुछ मामलों में चिमटी का उपयोग करना अधिक सुविधाजनक होता है, लेकिन आप इसके बिना भी काम चला सकते हैं।
चरण 2. इलेक्ट्रॉनिक सर्किट को असेंबल करना
योजना इलेक्ट्रॉनिक घड़ी Arduino का उपयोग करके एलईडी संकेत के साथ, अनुभवहीन रेडियो शौकीनों के लिए भी यह काफी सरल प्रतीत होगा। असेंबली के लिए केवल कुछ तारों की आवश्यकता होती है। कनेक्शन तालिका:
Arduino मॉड्यूल → 32x8 MAX7219 LED मैट्रिक्स
Arduino मॉड्यूल → Adafruit DS3231 वास्तविक समय घड़ी
Arduino मॉड्यूल → बटन
डी2 - बटन 1
डी3 - बटन 2
बटनों का दूसरा पिन GND से जुड़ा होता है।
आपको बस ध्यान देने और याद रखने की ज़रूरत है कि ब्रेडबोर्ड पर संपर्क छेद एक दूसरे से कैसे जुड़े हुए हैं। निम्नलिखित चित्र संपर्क छिद्रों के आंतरिक कनेक्शन की विधि को दर्शाता है:
दोनों तरफ दो पंक्तियाँ (1 और 4) क्षैतिज रूप से जुड़ी हुई हैं - इन्हें आमतौर पर +5 वी बिजली लाइन और जीएनडी ग्राउंड के रूप में उपयोग किया जाता है। सभी आंतरिक संपर्क (2 और 3) लंबवत रूप से बंद हैं। इस मामले में, सर्किट बोर्ड को लंबवत और क्षैतिज रूप से एक दूसरे से स्वतंत्र दो सममित भागों में विभाजित किया जाता है। यह, उदाहरण के लिए, एक बोर्ड पर दो अलग-अलग उपकरणों को इकट्ठा करने की अनुमति देता है।
एलईडी संकेत के साथ एक इलेक्ट्रॉनिक घड़ी का आरेख, साथ ही सर्किट बोर्ड पर तत्वों की व्यवस्था, चित्रण में दिखाई गई है:
सावधानीपूर्वक जांचें कि सभी कनेक्शन दिखाए गए आरेख का अनुपालन करते हैं। यह भी सुनिश्चित करें कि कंडक्टर सर्किट बोर्ड के संपर्क छिद्रों में अच्छी तरह से सुरक्षित हैं।
चरण 3. Arduino फ़र्मवेयर
एक बार सर्किट की असेंबली और परीक्षण पूरा हो जाने पर, आप नियंत्रण प्रोग्राम (या "फर्मवेयर") को Arduino मेमोरी में लोड करना शुरू कर सकते हैं।
ऐसा करने के लिए, आपको निःशुल्क आधिकारिक विकास वातावरण स्थापित करना होगा -। आपको प्रोजेक्ट के स्रोत कोड की भी आवश्यकता होगी, जिसे आप नीचे सभी पुस्तकालयों और एक स्केच के साथ संग्रह में डाउनलोड कर सकते हैं, और यदि आपको केवल एक स्केच की आवश्यकता है, तो आप इसे अलग से कॉपी कर सकते हैं:
// पुस्तकालय शामिल करें: # "LedControl.h" शामिल करें # शामिल करें
//फ़ॉन्ट लाइब्रेरी #शामिल // DS1307 घड़ी #शामिल "RTClib.h" // DS1307 घड़ी #शामिल // अलेक्जेंडर ब्रेविग द्वारा बटन लाइब्रेरी // सेटअप एलईडी मैट्रिक्स // पिन 12 डिस्प्ले पर डेटाइन से जुड़ा है // पिन 11 डिस्प्ले पर सीएलके से जुड़ा है // पिन 10 डिस्प्ले पर लोड से जुड़ा है LedControl lc = लेडकंट्रोल(6, 5, 4, 4); //3 पिनों को 12, 11 और 10 के रूप में सेट करता है और फिर 4 डिस्प्ले सेट करता है (अधिकतम 8 डिस्प्ले है) //वैश्विक चर बाइट तीव्रता = 7; // डिफ़ॉल्ट तीव्रता/चमक (0-15) बाइट क्लॉक_मोड = 0; // डिफ़ॉल्ट घड़ी मोड। डिफ़ॉल्ट = 0 (बेसिक_मोड) बूल रैंडम_मोड = 0; // रैंडम मोड को परिभाषित करें - हर कुछ घंटों में डिस्प्ले प्रकार बदलता है। डिफ़ॉल्ट = 0 (बंद) बाइट पुराना_मोड = क्लॉक_मोड; // पिछले क्लॉक मोड को संग्रहीत करता है, इसलिए यदि हम डेट पर जाते हैं या जो भी हो, हम जानते हैं कि उसके बाद किस मोड पर वापस जाना है। बूल एम्पम = 0; // 12 या 24 घंटे का समय परिभाषित करें। 0 = 24 घंटा. 1 = 12 घंटे की बाइट चेंज_मोड_टाइम = 0; // रैंडम मोड में क्लॉक मोड अगली बार बदलने पर घंटा होल्ड करता है। अहस्ताक्षरित लंबी देरी = 500; // हम हमेशा डिस्प्ले इंट आरटीसी के अपडेट के बीच थोड़ा इंतजार करते हैं; // वास्तविक समय घड़ी आउटपुट चार दिनों तक रखता है = ("रवि", "सोम", "मंगल", "बुध", "गुरु", "शुक्र", "शनि"); //डे एरे - स्लाइड, बेसिक_मोड और जंबल मोड में उपयोग किया जाता है (डीएस1307 सप्ताह के दिन के लिए 1-7 मान आउटपुट करता है) चार डेफुल = ( "रविवार", "सोमवार", "मंगलवार", "बुध", "गुरुवार ", "शुक्रवार शनिवार" ); चार प्रत्यय = ("सेंट", "एनडी", "आरडी", "वें"); // दिनांक प्रत्यय सरणी, स्लाइड, बेसिक_मोड और जंबल मोड में उपयोग की जाती है। e,g, पहला दूसरा... //स्थिरांक परिभाषित करें #NUM_DISPLAY_MODES 3 // संख्या प्रदर्शन मोड परिभाषित करें (पहले मोड के रूप में शून्य रखें) #NUM_SETTINGS_MODES 4 परिभाषित करें // संख्या सेटिंग्स मोड = 6 (पहले मोड के रूप में शून्य रखें) # SLIDE_DELAY 20 को परिभाषित करें // स्लाइड मोड में प्रति वर्ण स्लाइड प्रभाव के लिए मिलीसेकंड में समय। धीमे प्रभाव के लिए इसे उच्चतर बनाएं #define cls Clear_display // स्पष्ट डिस्प्ले RTC_DS1307 ds1307; // आरटीसी ऑब्जेक्ट बनाएं बटन बटनए = बटन(2, बटन_पुलअप); // सेटअप बटन ए (बटन लाइब्रेरी का उपयोग करके) बटन बटनबी = बटन(3, बटन_पुलअप); // सेटअप बटन बी (बटन लाइब्रेरी का उपयोग करके) शून्य सेटअप() (डिजिटलराइट (2, हाई); // पिन 2 डिजिटल राइट (3, हाई) पर बटन के लिए पुलअप रेसिस्टर चालू करें; // पिन पर बटन के लिए पुलअप रेसिस्टर चालू करें 3 डिजिटलराइट(4, हाई); // पिन 4 सीरियल.बेगिन (9600) पर बटन के लिए पुलअप रेसिस्टर चालू करें // सीरियल शुरू करें // 4 मैट्रिक्स पैनल को इनिशियलाइज़ करें // जब हमने बनाया था तो हमने पहले ही डिवाइस की संख्या निर्धारित कर दी थी LedControl int डिवाइस = lc.getDeviceCount(); //हमें (int एड्रेस = 0; एड्रेस) के लिए सभी डिवाइस को एक लूप में इनिट करना होगा< devices; address++) {
/*The MAX72XX is in power-saving mode on startup*/
lc.shutdown(3-address, false);
/* Set the brightness to a medium values */
lc.setIntensity(3-address, intensity);
/* and clear the display */
lc.clearDisplay(3-address);
}
//Setup DS1307 RTC
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino
#endif
ds1307.begin(); //start RTC Clock
if (! ds1307.isrunning()) {
Serial.println("RTC is NOT running!");
ds1307.adjust(DateTime(__DATE__, __TIME__)); // sets the RTC to the date & time this sketch was compiled
}
//Show software version & hello message
printver();
//enable red led
digitalWrite(13, HIGH);
}
void loop() {
//run the clock with whatever mode is set by clock_mode - the default is set at top of code.
switch (clock_mode){
case 0:
basic_mode();
break;
case 1:
small_mode();
break;
case 2:
slide();
break;
case 3:
word_clock();
break;
case 4:
setup_menu();
break;
}
}
//plot a point on the display
void plot (byte x, byte y, byte val) {
//select which matrix depending on the x coord
byte address;
if (x >= 0 && एक्स<= 7) {
address = 3;
}
if (x >= 8 && एक्स<= 15) {
address = 2;
x = x - 8;
}
if (x >= 16 && x<= 23) {
address = 1;
x = x - 16;
}
if (x >= 24 && x<= 31) {
address = 0;
x = x - 24;
}
if (val == 1) {
lc.setLed(address, y, x, true);
} else {
lc.setLed(address, y, x, false);
}
}
//clear screen
void clear_display() {
for (byte address = 0; address < 4; address++) {
lc.clearDisplay(address);
}
}
//fade screen down
void fade_down() {
//fade from global intensity to 1
for (byte i = intensity; i >0; i--) (के लिए (बाइट पता = 0; पता)।< 4; address++) {
lc.setIntensity(address, i);
}
delay(30); //change this to change fade down speed
}
clear_display(); //clear display completely (off)
//reset intentsity to global val
for (byte address = 0; address < 4; address++) {
lc.setIntensity(address, intensity);
}
}
//power up led test & display software version number
void printver() {
byte i = 0;
char ver_a = "MADE";
char ver_b = "IN";
char ver_c = "RUSSIA";
//test all leds.
for (byte x = 0; x <= 32; x++) {
for (byte y = 0; y <= 7; y++) {
plot(x, y, 1);
}
}
delay(300);
fade_down();
while (ver_a[i]) {
puttinychar((i * 4), 1, ver_a[i]);
delay(35);
i++;
}
delay(500);
fade_down();
i = 0;
while (ver_b[i]) {
puttinychar((i * 4), 1, ver_b[i]);
delay(35);
i++;
}
delay(500);
fade_down();
i = 0;
while (ver_c[i]) {
puttinychar((i * 4), 1, ver_c[i]);
delay(35);
i++;
}
delay(500);
fade_down();
}
// puttinychar
// Copy a 3x5 character glyph from the myfont data structure to display memory, with its upper left at the given coordinate
// This is unoptimized and simply uses plot() to draw each dot.
void puttinychar(byte x, byte y, char c)
{
byte dots;
if (c >= "ए" && सी<= "Z" || (c >= "ए" && सी<= "z")) {
c &= 0x1F; // A-Z maps to 1-26
}
else if (c >= "0" && सी<= "9") {
c = (c - "0") + 32;
}
else if (c == " ") {
c = 0; // space
}
else if (c == ".") {
c = 27; // full stop
}
else if (c == ":") {
c = 28; // colon
}
else if (c == "\"") {
c = 29; // single quote mark
}
else if (c == "!") {
c = 30; // single quote mark
}
else if (c == "?") {
c = 31; // single quote mark
}
for (byte col = 0; col < 3; col++) {
dots = pgm_read_byte_near(&mytinyfont[c]);
for (char row = 0; row < 5; row++) {
if (dots & (16 >> पंक्ति)) प्लॉट(x + col, y + पंक्ति, 1);<= "Z" || (c >= "ए" && सी<= "z")) {
// c &= 0x1F; // A-Z maps to 1-26
// }
if (c >= "ए" && सी<= "Z") {
c &= 0x1F; // A-Z maps to 1-26
}
else if (c >= "ए" && सी<= "z") {
c = (c - "a") + 41; // A-Z maps to 41-67
}
else if (c >= "0" && सी<= "9") {
c = (c - "0") + 31;
}
else if (c == " ") {
c = 0; // space
}
else if (c == ".") {
c = 27; // full stop
}
else if (c == "\"") {
c = 28; // single quote mark
}
else if (c == ":") {
c = 29; // clock_mode selector arrow
}
else if (c == ">अन्यथा प्लॉट(x + col, y + row, 0);<= -67) {
c *= -1;
}
for (char col = 0; col < 5; col++) {
dots = pgm_read_byte_near(&myfont[c]);
for (char row = 0; row < 7; row++) {
//check coords are on screen before trying to plot
//if ((x >) ) ) शून्य पुटनॉर्मलचार(बाइट एक्स, बाइट वाई, चार सी) (बाइट डॉट्स; // अगर (सी >= "ए" && सी<= 31) && (y >") (सी = 30; // क्लॉक_मोड चयनकर्ता तीर) अन्यथा यदि (सी >= -80 && सी<= 7)){
if (dots & (64 >= 0) && (x< 10) {
buffer = buffer;
buffer = "0";
}
puttinychar(20, 1, ":"); //seconds colon
puttinychar(24, 1, buffer); //seconds
puttinychar(28, 1, buffer); //seconds
old_secs = secs;
}
//if minute changes change time
if (mins != rtc) {
//reset these for comparison next time
mins = rtc;
byte hours = rtc;
if (hours > < 1) {
hours = hours + ampm * 12;
}
//byte dow = rtc; // the DS1307 outputs 0 - 6 where 0 = Sunday0 - 6 where 0 = Sunday.
//byte date = rtc;
//set characters
char buffer;
itoa(hours, buffer, 10);
//fix - as otherwise if num has leading zero, e.g. "03" hours, itoa coverts this to chars with space "3 ".
if (hours < 10) {
buffer = buffer;
//if we are in 12 hour mode blank the leading zero.
if (ampm) {
buffer = " ";
}
else {
buffer = "0";
}
}
//set hours chars
textchar = buffer;
textchar = buffer;
textchar = ":";
itoa (mins, buffer, 10);
if (mins < 10) {
buffer = buffer;
buffer = "0";
}
//set mins characters
textchar = buffer;
textchar = buffer;
//do seconds
textchar = ":";
buffer;
secs = rtc;
itoa(secs, buffer, 10);
//fix - as otherwise if num has leading zero, e.g. "03" secs, itoa coverts this to chars with space "3 ".
if (secs < 10) {
buffer = buffer;
buffer = "0";
}
//set seconds
textchar = buffer;
textchar = buffer;
byte x = 0;
byte y = 0;
//print each char
for (byte x = 0; x < 6 ; x++) {
puttinychar(x * 4, 1, textchar[x]);
}
}
delay(50);
}
fade_down();
}
// basic_mode()
// show the time in 5x7 characters
void basic_mode()
{
cls();
char buffer; //for int to char conversion to turn rtc values into chars we can print on screen
byte offset = 0; //used to offset the x postition of the digits and centre the display when we are in 12 hour mode and the clock shows only 3 digits. e.g. 3:21
byte x, y; //used to draw a clear box over = 0) && (y> पंक्ति)) ( //केवल 7 पंक्तियाँ। प्लॉट(x + col, y + पंक्ति, 1); ) अन्य (प्लॉट(x + col, y + पंक्ति, 0); ) //) ) ) ) //small_mode // सेकंड के साथ छोटे 3x5 अक्षरों में समय दिखाएं शून्य छोटा_मोड() (चार टेक्स्टचार; // डिस्प्ले पर 16 अक्षर बाइट मिनट = 100; // मिनट बाइट सेकंड = आरटीसी; // सेकंड बाइट पुराना_सेकंड = सेकंड; / /पुराने सेकंड का मान रखता है - पिछली बार से सेकंड अपडेट किए गए थे - यह जांचने के लिए उपयोग किया जाता है कि क्या सेकंड बदल गए हैं cls(); //जब तक run_mode सही रिटर्न देता है तब तक क्लॉक मेन लूप चलाएं जबकि (run_mode()) (get_time(); / /बटन की जांच करें यदि (buttonA.uniquePress()) ( Switch_mode(); return; ) यदि (buttonB.uniquePress()) (display_date(); return; ) दबाएं // यदि सेकंड बदल गए हैं तो उन्हें डिस्प्ले सेकंड पर अपडेट करें = आरटीसी; यदि (सेकंड! = पुराना_सेकंड) ( //सेकंड चार बफर; इटोआ(सेकेंड, बफर, 10); //ठीक करें - अन्यथा यदि संख्या में अग्रणी शून्य है, उदाहरण के लिए "03" सेकंड, इटोआ इसे स्थान के साथ वर्णों में कवर करता है "3"। यदि(सेकंड)< 1) {
hours = hours + ampm * 12;
}
//do offset conversion
if (ampm && hours < 10) {
offset = 2;
}
//set the next minute we show the date at
//set_next_date();
// initially set mins to value 100 - so it wll never equal rtc on the first loop of the clock, meaning we draw the clock display when we enter the function
byte secs = 100;
byte mins = 100;
int count = 0;
//run clock main loop as long as run_mode returns true
while (run_mode()) {
//get the time from the clock chip
get_time();
//check for button press
if (buttonA.uniquePress()) {
switch_mode();
return;
}
if (buttonB.uniquePress()) {
display_date();
return;
}
//check whether it"s time to automatically display the date
//check_show_date();
//draw the flashing: as on if the secs have changed.
if (secs != rtc) {
//update secs with new value
secs = rtc;
//draw:
plot (15 - offset, 2, 1); //top point
plot (15 - offset, 5, 1); //bottom point
count = 400;
}
//if count has run out, turn off the:
if (count == 0) {
plot (15 - offset, 2, 0); //top point
plot (15 - offset, 5, 0); //bottom point
}
else {
count--;
}
//re draw the display if button pressed or if mins != rtc i.e. if the time has changed from what we had stored in mins, (also trigggered on first entering function when mins is 100)
if (mins != rtc) {
//update mins and hours with छोड़ाजब हम 12:59 -> 1:00 पूर्वाह्न से 12 घंटे मोड में रोल करते हैं तो डिस्प्ले का "1" हाथ।< 1) {
hours = hours + ampm * 12;
}
itoa(hours, buffer, 10);
//if hours < 10 the num e.g. "3" hours, itoa coverts this to chars with space "3 " which we dont want
if (hours < 10) {
buffer = buffer;
buffer = "0";
}
//print hours
//if we in 12 hour mode and hours < 10, then don"t print the leading zero, and set the offset so we centre the display with 3 digits.
if (ampm && hours < 10) {
offset = 2;
//if the time is 1:00am clear the entire display as the offset changes at this time and we need to blank out the old 12:59
if ((hours == 1 && mins == 0)) {
cls();
}
}
else {
//else no offset and print hours tens digit
offset = 0;
//if the time is 10:00am clear the entire display as the offset changes at this time and we need to blank out the old 9:59
if (hours == 10 && mins == 0) {
cls();
}
putnormalchar(1, 0, buffer);
}
//print hours ones digit
putnormalchar(7 - offset, 0, buffer);
//print mins
//add leading zero if mins < 10
itoa (mins, buffer, 10);
if (mins < 10) {
buffer = buffer;
buffer = "0";
}
//print mins tens and ones digits
putnormalchar(19 - offset, 0, buffer);
putnormalchar(25 - offset, 0, buffer);
}
}
fade_down();
}
//like basic_mode but with slide effect
void slide() {
byte digits_old = {99, 99, 99, 99}; //old values we store time in. Set to somthing that will never match the time initially so all digits get drawn wnen the mode starts
byte digits_new; //new digits time will slide to reveal
byte digits_x_pos = {25, 19, 7, 1}; //x pos for which to draw each digit at
char old_char; //used when we use itoa to transpose the current digit (type byte) into a char to pass to the animation function
char new_char; //used when we use itoa to transpose the new digit (type byte) into a char to pass to the animation function
//old_chars - stores the 5 day and date suffix chars on the display. e.g. "mon" and "st". We feed these into the slide animation as the current char when these chars are updated.
//We sent them as A initially, which are used when the clocl enters the mode and no last chars are stored.
//char old_chars = "AAAAA";
//plot the clock colon on the display
cls();
putnormalchar(13, 0, ":");
byte old_secs = rtc; //store seconds in old_secs. We compare secs and old secs. WHen they are different we redraw the display
//run clock main loop as long as run_mode returns true
while (run_mode()) {
get_time();
//check for button press
if (buttonA.uniquePress()) {
switch_mode();
return;
}
if (buttonB.uniquePress()) {
display_date();
return;
}
//if secs have changed then update the display
if (rtc != old_secs) {
old_secs = rtc;
//do 12/24 hour conversion if ampm set to 1
byte hours = rtc;
if (hours >//यदि एएमपीएम 1 बाइट घंटे = आरटीसी पर सेट है तो 12/24 घंटे रूपांतरण करें;< 1) {
hours = hours + ampm * 12;
}
//split all date and time into individual digits - stick in digits_new array
//rtc = secs //array pos and digit stored
//digits_new = (rtc%10); //0 - secs ones
//digits_new = ((rtc/10)%10); //1 - secs tens
//rtc = mins
digits_new = (rtc % 10); //2 - mins ones
digits_new = ((rtc / 10) % 10); //3 - mins tens
//rtc = hours
digits_new = (hours % 10); //4 - hour ones
digits_new = ((hours / 10) % 10); //5 - hour tens
//rtc = date
//digits_new = (rtc%10); //6 - date ones
//digits_new = ((rtc/10)%10); //7 - date tens
//draw initial screen of all chars. After this we just draw the changes.
//compare digits 0 to 3 (mins and hours)
for (byte i = 0; i <= 3; i++) {
//see if digit has changed...
if (digits_old[i] != digits_new[i]) {
//run 9 step animation sequence for each in turn
for (byte seq = 0; seq <= 8 ; seq++) {
//convert digit to string
itoa(digits_old[i], old_char, 10);
itoa(digits_new[i], new_char, 10);
//if set to 12 hour mode and we"re on digit 2 (hours tens mode) then check to see if this is a zero. If it is, blank it instead so we get 2.00pm not 02.00pm
if (ampm && i == 3) {
if (digits_new == 0) {
new_char = " ";
}
if (digits_old == 0) {
old_char = " ";
}
}
//draw the animation frame for each digit
slideanim(digits_x_pos[i], 0, seq, old_char, new_char);
delay(SLIDE_DELAY);
}
}
}
/*
//compare date digit 6 (ones) and (7) tens - if either of these change we need to update the date line. We compare date tens as say from Jan 31 ->यदि (घंटे > 12) (घंटे = घंटे - एम्पम * 12; ) यदि (घंटे<=2 ; day_char++){
//run the anim sequence for each char
for (byte seq = 0; seq <=8 ; seq++){
//the day (0 - 6) Read this number into the days char array. the seconds number in the array 0-2 gets the 3 chars of the day name, e.g. m o n
slideanim(6*day_char,8,seq,old_chars,days); //6 x day_char gives us the x pos for the char
delay(SLIDE_DELAY);
}
//save the old day chars into the old_chars array at array pos 0-2. We use this next time we change the day and feed it to the animation as the current char. The updated char is fed in as the new char.
old_chars = days;
}
//change the date tens digit (if needed) and ones digit. (the date ones digit wil alwaus change, but putting this in the "if" loop makes it a bit neater code wise.)
for (byte i = 7; i >नई<=8 ; seq++){
itoa(digits_old[i],old_char,10);
itoa(digits_new[i],new_char,10);
slideanim(digits_x_pos[i],8,seq,old_char,new_char);
delay(SLIDE_DELAY);
}
}
}
//print the day suffix "nd" "rd" "th" etc. First work out date 2 letter suffix - eg st, nd, rd, th
byte s = 3; //the pos to read our suffix array from.
byte date = rtc;
if(date == 1 || date == 21 || date == 31) {
s = 0;
}
else if (date == 2 || date == 22) {
s = 1;
}
else if (date == 3 || date == 23) {
s = 2;
}
for (byte suffix_char = 0; suffix_char <=1 ; suffix_char++){
for (byte seq = 0; seq <=8 ; seq++){
slideanim((suffix_char*6)+36,8,seq,old_chars,suffix[s]); // we pass in the old_char array char as the current char and the suffix array as the new char
delay(SLIDE_DELAY);
}
//save the suffic char in the old chars array at array pos 3 and 5. We use these chars next time we change the suffix and feed it to the animation as the current char. The updated char is fed in as the new char.
old_chars = suffix[s];
}
}//end do date line
*/
//save digita array tol old for comparison next loop
for (byte i = 0; i <= 3; i++) {
digits_old[i] = digits_new[i];
}
}//secs/oldsecs
}//while loop
fade_down();
}
//called by slide
//this draws the animation of one char sliding on and the other sliding off. There are 8 steps in the animation, we call the function to draw one of the steps from 0-7
//inputs are are char x and y, animation frame sequence (0-7) and the current and new chars being drawn.
void slideanim(byte x, byte y, byte sequence, char current_c, char new_c) {
// To slide one char off and another on we need 9 steps or frames in sequence...
// seq# 0123456 <-rows of the display
// | |||||||
// seq0 0123456 START - all rows of the display 0-6 show the current characters rows 0-6
// seq1 012345 current char moves down one row on the display. We only see it"s rows 0-5. There are at display positions 1-6 There is a blank row inserted at the top
// seq2 6 01234 current char moves down 2 rows. we now only see rows 0-4 at display rows 2-6 on the display. Row 1 of the display is blank. Row 0 shows row 6 of the new char
// seq3 56 0123
// seq4 456 012 half old / half new char
// seq5 3456 01
// seq6 23456 0
// seq7 123456
// seq8 0123456 END - all rows show the new char
//from above we can see...
//currentchar runs 0-6 then 0-5 then 0-4 all the way to 0. starting Y position increases by 1 row each time.
//new char runs 6 then 5-6 then 4-6 then 3-6. starting Y position increases by 1 row each time.
//if sequence number is below 7, we need to draw the current char
if (sequence < 7) {
byte dots;
// if (current_c >मान मिनट = आरटीसी;<= "z")) {
// current_c &= 0x1F; // A-Z maps to 1-26
// }
if (current_c >घंटे = आरटीसी;<= "Z") {
current_c &= 0x1F; // A-Z maps to 1-26
}
else if (current_c >// ampm के घंटों को 12 घंटे मोड पर सेट करें यदि (घंटे > 12) (घंटे = घंटे - ampm * 12; ) यदि (घंटे<= "z") {
current_c = (current_c - "a") + 41; // A-Z maps to 41-67
}
else if (current_c >12) (घंटे = घंटे - ampm *12; ) यदि (घंटे<= "9") {
current_c = (current_c - "0") + 31;
}
else if (current_c == " ") {
current_c = 0; // space
}
else if (current_c == ".") {
current_c = 27; // full stop
}
else if (current_c == "\"") {
current_c = 28; // single quote mark
}
else if (current_c == ":") {
current_c = 29; //colon
}
else if (current_c == ">फरवरी 01 तो किसी का अंक नहीं बदलता यदि ((अंक_पुराना != अंक_नया) || (अंक_पुराना != अंक_नया)) ( //दिखाए गए दिन को बदल दें। नीचे दिया गया लूप बारी-बारी से 3 वर्णों में से प्रत्येक से होकर गुजरता है उदाहरण के लिए "MON" (बाइट दिन_चार = 0; दिन_चार<= curr_char_row_max; curr_char_row++) {
for (byte col = 0; col < 5; col++) {
dots = pgm_read_byte_near(&myfont);
if (dots & (64 >> curr_char_row)) प्लॉट(x + col, y +start_y, 1); //प्लॉट अन्य प्लॉट पर आगे बढ़ा(x + col, y +start_y, 0); //अन्यथा प्लॉट बंद हो गया) प्रारंभ_y++;//y में एक जोड़ें ताकि हम अगली पंक्ति एक नीचे खींच सकें)) //यदि अनुक्रम 1 और 7 के बीच है तो वर्णों के बीच एक रिक्त रेखा खींचें। यदि हम ऐसा नहीं करते हैं तो हमें मिलता है वर्तमान वर्णों के अवशेष प्रदर्शन पर अंतिम स्थिति में बचे हैं यदि (अनुक्रम >= 1 && अनुक्रम<= 8) {
for (byte col = 0; col < 5; col++) {
plot(x + col, y + (sequence - 1), 0); //the y position to draw the line is equivalent to the sequence number - 1
}
}
//if sequence is above 2, we also need to start drawing the new char
if (sequence >= 2) ( //चार बाइट डॉट्स पर काम करें; //यदि (new_c >= "A" && new_c<= "Z" || (new_c >= "a" && new_c<= "z")) {
// new_c &= 0x1F; // A-Z maps to 1-26
//}
if (new_c >= "ए" && new_c<= "Z") {
new_c &= 0x1F; // A-Z maps to 1-26
}
else if (new_c >= "a" && new_c<= "z") {
new_c = (new_c - "a") + 41; // A-Z maps to 41-67
}
else if (new_c >= "0" && new_c<= "9") {
new_c = (new_c - "0") + 31;
}
else if (new_c == " ") {
new_c = 0; // space
}
else if (new_c == ".") {
new_c = 27; // full stop
}
else if (new_c == "\"") {
new_c = 28; // single quote mark
}
else if (new_c == ":") {
new_c = 29; // clock_mode selector arrow
}
else if (new_c == ">") (new_c = 30; // क्लॉक_मोड चयनकर्ता तीर) बाइट newcharrowmin = 6 - (अनुक्रम - 2); // नए चार के लिए न्यूनतम पंक्ति संख्या - यह अनुक्रम संख्या 2-8 फीड करने पर 6 से 0 का आउटपुट उत्पन्न करता है यह नए चार बाइट के लिए तैयार की जाने वाली न्यूनतम पंक्ति है प्रारंभ_y = 0; //y स्थिति - अनुक्रम संख्या के समान है। हम इसे प्रत्येक पंक्ति में शामिल करते हैं // प्रत्येक पंक्ति को न्यूनतम पंक्ति से ऊपर प्लॉट करते हैं ) ) के लिए 6 तक (बाइट newcharrow = newcharrowmin; newcharrow<= 6; newcharrow++) {
for (byte col = 0; col < 5; col++) {
dots = pgm_read_byte_near(&myfont);
if (dots & (64 >> न्यूचेरो)) प्लॉट(x + col, y +start_y, 1); //प्लॉट अन्य प्लॉट पर आगे बढ़ा(x + col, y +start_y, 0); //अन्यथा प्लॉट बंद हो गया) प्रारंभ_y++;//y में एक जोड़ें ताकि हम अगली पंक्ति एक नीचे खींच सकें) ) ) //संख्याओं के बजाय शब्दों का उपयोग करके एक घड़ी प्रिंट करें शून्य शब्द_घड़ी() ( cls(); चार संख्याएँ = ( "एक ", "दो", "तीन", "चार", "पाँच", "छः", "सात", "आठ", "नौ", "दस", "ग्यारह", "बारह", "तेरह", "चौदह", "पंद्रह", "सोलह", "सत्रह", "अठारह", "उन्नीस" ); चार्टेंस संख्याएँ = ("दस", "बीस", "तीस", "चालीस", "पचास" ); // संभावित रूप से char str_a; char str_c प्रदर्शित करने के लिए 3 लाइनें; // घंटे और मिनट और घंटे और मिनट लाइनों के लिए स्थिति घंटे = rtc;< 1) {
hours = hours + ampm * 12;
}
get_time(); //get the time from the clock chip
byte old_mins = 100; //store mins in old_mins. We compare mins and old mins & when they are different we redraw the display. Set this to 100 initially so display is drawn when mode starts.
byte mins;
//run clock main loop as long as run_mode returns true
while (run_mode()) {
//check for button press
if (buttonA.uniquePress()) {
switch_mode();
return;
}
if (buttonB.uniquePress()) {
display_date();
}
get_time(); //get the time from the clock chip
mins = rtc; //get mins
//if mins is different from old_mins - redraw display
if (mins != old_mins) {
//update old_mins with current mins value
old_mins = mins;
//reset these for comparison next time
mins = rtc;
hours = rtc;
//make hours into 12 hour format
if (hours >12) (घंटे = घंटे - 12; ) यदि (घंटे == 0) ( घंटे = 12; ) // मिनट के मान को दो अलग-अलग अंकों में विभाजित करें int minsdigit = rtc % 10;<= 10 , then top line has to read "minsdigti past" and bottom line reads hours
if (mins < 10) {
strcpy (str_a, numbers);
strcpy (str_b, "PAST");
strcpy (str_c, numbers);
}
//if mins = 10, cant use minsdigit as above, so soecial case to print 10 past /n hour.
if (mins == 10) {
strcpy (str_a, numbers);
strcpy (str_b, " PAST");
strcpy (str_c, numbers);
}
//if time is not on the hour - i.e. both mins digits are not zero,
//then make first line read "hours" and 2 & 3rd lines read "minstens" "mins" e.g. "three /n twenty /n one"
else if (minsdigitten != 0 && minsdigit != 0) {
strcpy (str_a, numbers);
//if mins is in the teens, use teens from the numbers array for the 2nd line, e.g. "fifteen"
//if (mins >बाइट मिनटडिजिटन = (आरटीसी/10)% 10;<= 19) {
if (mins <= 19) {
strcpy (str_b, numbers);
}
else {
strcpy (str_b, numberstens);
strcpy (str_c, numbers);
}
}
// if mins digit is zero, don"t print it. read read "hours" "minstens" e.g. "three /n twenty"
else if (minsdigitten != 0 && minsdigit == 0) {
strcpy (str_a, numbers);
strcpy (str_b, numberstens);
strcpy (str_c, "");
}
//if both mins are zero, i.e. it is on the hour, the top line reads "hours" and bottom line reads "o"clock"
else if (minsdigitten == 0 && minsdigit == 0) {
strcpy (str_a, numbers);
strcpy (str_b, "O"CLOCK");
strcpy (str_c, "");
}
}//end worknig out time
//run in a loop
//print line a "twelve"
byte len = 0;
while (str_a) {
len++;
}; //get length of message
byte offset_top = (31 - ((len - 1) * 4)) / 2; //
//plot hours line
byte i = 0;
while (str_a[i]) {
puttinychar((i * 4) + offset_top, 1, str_a[i]);
i++;
}
//hold display but check for button presses
int counter = 1000;
while (counter >0)( //बटन दबाने की जांच करें यदि (बटनए.यूनिकप्रेस()) (स्विच_मोड(); वापसी; ) यदि (बटनबी.यूनिकप्रेस()) (डिस्प्ले_डेट(); ) विलंब(1); काउंटर--; ) फ़ेड_डाउन ();< 6; c++) {
putnormalchar(x[c],y,message[ chara[c] ]);
//draw a line of pixels turned off after each char,otherwise the gaps between the chars have pixels left in them from the previous char
for (byte yy = 0 ; yy < 8; yy ++) {
plot(x[c] + 5, yy, 0);
}
//take one off each chars position
x[c] = x[c] - 1;
}
//reset a char if it"s gone off screen
for (byte i = 0; i <= 5; i++) {
if (x[i] < -5) {
x[i] = 31;
chara[i] = p;
p++;
}
}
}
}
//display_date - print the day of week, date and month with a flashing cursor effect
void display_date()
{
cls();
//read the date from the DS1307
byte dow = rtc; // day of week 0 = Sunday
byte date = rtc;
byte month = rtc - 1;
//array of month names to print on the display. Some are shortened as we only have 8 characters across to play with
char monthnames = {
"January", "February", "March", "April", "May", "June", "July", "August", "Sept", "October", "November", "December"
};
//print the day name
//get length of text in pixels, that way we can centre it on the display by divindin the remaining pixels b2 and using that as an offset
byte len = 0;
while(daysfull) {
len++;
};
byte offset = (31 - ((len-1)*4)) / 2; //our offset to centre up the text
//print the name
int i = 0;
while(daysfull[i])
{
puttinychar((i*4) + offset , 1, daysfull[i]);
i++;
}
delay(1000);
fade_down();
cls();
// print date numerals
char buffer;
itoa(date,buffer,10);
offset = 10; //offset to centre text if 3 chars - e.g. 3rd
// first work out date 2 letter suffix - eg st, nd, rd, th etc
// char suffix={"st", "nd", "rd", "th" }; is defined at top of code
byte s = 3;
if(date == 1 || date == 21 || date == 31) {
s = 0;
}
else if (date == 2 || date == 22) {
s = 1;
}
else if (date == 3 || date == 23) {
s = 2;
}
//print the 1st date number
puttinychar(0+offset, 1, buffer);
//if date is under 10 - then we only have 1 digit so set positions of sufix etc one character nearer
byte suffixposx = 4;
//if date over 9 then print second number and set xpos of suffix to be 1 char further away
if (date >9)( प्रत्ययपोक्स = 8; पुट्टीनीचर(4+ऑफसेट, 1, बफर); ऑफसेट = 8; //4 वर्ण होने पर टेक्स्ट को केंद्र में लाने के लिए ऑफसेट) //2 प्रत्यय वर्ण पुट्टीनीचर(प्रत्ययपोक्स+ऑफसेट, 1, प्रत्यय[एस) प्रिंट करें ]);< 35 ; count++) {
//if user hits button, change the clock_mode
if (buttonA.uniquePress() || firstrun == 1) {
count = 0;
cls();
if (firstrun == 0) {
clock_mode++;
}
if (clock_mode >NUM_DISPLAY_MODES + 1) (क्लॉक_मोड = 0; ) //लाइन एक पर तीर और वर्तमान क्लॉक_मोड नाम प्रिंट करें और लाइन दो पर अगला क्लॉक_मोड नाम प्रिंट करें चार str_top;< 35 ; count++) {
//if user hits button, change the clock_mode
if(buttonA.uniquePress() || firstrun == 1){
count = 0;
cls();
if (firstrun == 0) {
setting_mode++;
}
if (setting_mode >NUM_SETTINGS_MODES) (सेटिंग_मोड = 0; ) //लाइन एक पर तीर और वर्तमान क्लॉक_मोड नाम प्रिंट करें और लाइन दो पर अगला क्लॉक_मोड नाम प्रिंट करें चार str_top;< 4; address++) {
lc.setIntensity(address, intensity);
}
delay(150);
}
}
}
// display a horizontal bar on the screen at offset xposr by ypos with height and width of xbar, ybar
void levelbar (byte xpos, byte ypos, byte xbar, byte ybar) {
for (byte x = 0; x < xbar; x++) {
for (byte y = 0; y <= ybar; y++) {
plot(x+xpos, y+ypos, 1);
}
}
}
//set time and date routine
void set_time() {
cls();
//fill settings with current clock values read from clock
get_time();
byte set_min = rtc;
byte set_hr = rtc;
byte set_date = rtc;
byte set_mnth = rtc;
int set_yr = rtc;
//Set function - we pass in: which "set" message to show at top, current value, reset value, and rollover limit.
set_date = set_value(2, set_date, 1, 31);
set_mnth = set_value(3, set_mnth, 1, 12);
set_yr = set_value(4, set_yr, 2013, 2099);
set_hr = set_value(1, set_hr, 0, 23);
set_min = set_value(0, set_min, 0, 59);
ds1307.adjust(DateTime(set_yr, set_mnth, set_date, set_hr, set_min));
cls();
}
//used to set min, hr, date, month, year values. pass
//message = which "set" message to print,
//current value = current value of property we are setting
//reset_value = what to reset value to if to rolls over. E.g. mins roll from 60 to 0, months from 12 to 1
//rollover limit = when value rolls over
int set_value(byte message, int current_value, int reset_value, int rollover_limit){
cls();
char messages = {
"Set Mins", "Set Hour", "Set Day", "Set Mnth", "Set Year"};
//Print "set xyz" top line
byte i = 0;
while(messages[i])
{
puttinychar(i*4 , 1, messages[i]);
i++;
}
delay(2000);
cls();
//print digits bottom line
char buffer = " ";
itoa(current_value,buffer,10);
puttinychar(0 , 1, buffer);
puttinychar(4 , 1, buffer);
puttinychar(8 , 1, buffer);
puttinychar(12, 1, buffer);
delay(300);
//wait for button input
while (!buttonA.uniquePress()) {
while (buttonB.isPressed()){
if(current_value < rollover_limit) {
current_value++;
}
else {
current_value = reset_value;
}
//print the new value
itoa(current_value, buffer ,10);
puttinychar(0 , 1, buffer);
puttinychar(4 , 1, buffer);
puttinychar(8 , 1, buffer);
puttinychar(12, 1, buffer);
delay(150);
}
}
return current_value;
}
void get_time()
{
//get time
DateTime now = ds1307.now();
//save time to array
rtc = now.year();
rtc = now.month();
rtc = now.day();
rtc = now.dayOfWeek(); //returns 0-6 where 0 = Sunday
rtc = now.hour();
rtc = now.minute();
rtc = now.second();
//flash arduino led on pin 13 every second
//if ((rtc % 2) == 0) {
// digitalWrite(13, HIGH);
//}
//else {
// digitalWrite(13, LOW);
//}
//print the time to the serial port - useful for debuging RTC issues
/*
Serial.print(rtc);
Serial.print(":");
Serial.print(rtc);
Serial.print(":");
Serial.println(rtc);
*/
}
strcpy(str_top, set_modes);
प्रोग्राम कोड को संकलित करने और इसे माइक्रोकंट्रोलर की मेमोरी में लोड करने में कुछ समय लगेगा, आमतौर पर एक मिनट से अधिक नहीं। ऑपरेशन के सफल समापन की सूचना Arduino IDE कंसोल में दी जाएगी। जिसके बाद डिवाइस पर रीसेट बटन का उपयोग करके Arduino को रीबूट करना बाकी है - एलईडी मैट्रिसेस पर एक साधारण घड़ी तैयार है!
Arduino पर तैयार घड़ी
घड़ी को दो बटनों का उपयोग करके सेट किया गया है। डिवाइस 12- और 24-घंटे के समय प्रारूपों का समर्थन करता है, सप्ताह की तारीख और दिन प्रदर्शित करता है, और सेकंड के साथ या उसके बिना समय प्रदर्शित करता है। एलईडी की चमक को बदलना भी संभव है।
आप शायद भविष्य में और अधिक सुविधाएँ जोड़ना चाहेंगे (उदाहरण के लिए, एक थर्मामीटर), या डिवाइस को अपने स्वयं के डिज़ाइन की बॉडी में स्थापित करना चाहेंगे - लेजर कटिंग मशीनों पर निर्माण करके अच्छे परिणाम प्राप्त किए जा सकते हैं। लेकिन अब आप सुरक्षित रूप से कह सकते हैं कि आपने अपने हाथों से एक पूर्ण इलेक्ट्रॉनिक घड़ी इकट्ठी कर ली है!
एलईडी मैट्रिसेस पर एक साधारण घड़ी। कई रेडियो शौकीन, शुरुआती और अन्य लोग, "पहिए को फिर से आविष्कार करना" पसंद करते हैं - अपनी खुद की इलेक्ट्रॉनिक घड़ियाँ बनाना। इस किस्मत ने मुझे भी नहीं छोड़ा. आज, बेशक, इंटरनेट पर बहुत सारी घड़ियों के डिज़ाइन मौजूद हैं, लेकिन किसी कारण से उनमें से एलईडी मैट्रिसेस पर केवल कुछ ही घड़ियाँ हैं। रूसी भाषी इंटरनेट पर मुझे केवल एक पूरी तरह से पूर्ण और वर्णित डिज़ाइन मिला। इसी समय, एलईडी मैट्रिसेस अब बहुत सस्ते हो गए हैं, और उनकी लागत समान आकार के सात-खंड संकेतकों की तुलना में अधिक या कम नहीं है। उदाहरण के लिए, मैंने 60x60 मिमी आकार वाला GNM23881AD 1.5 यूरो (3 संकेतकों की लागत 4.5 यूरो) में खरीदा था, इस पैसे के लिए आप समान आकार के चार सात-खंड संकेतक मुश्किल से खरीद सकते हैं। लेकिन मैट्रिक्स संकेतक पर बहुत अधिक जानकारी दी जा सकती है। संख्याओं के अलावा, वे किसी भी अक्षर, चिह्न और एक रेंगने वाली रेखा की सहायता से पाठ भी प्रदर्शित कर सकते हैं।
इसके आधार पर, एलईडी मैट्रिसेस पर एक घड़ी बनाने की इच्छा थी, लेकिन ताकि सर्किट सात-खंड वाले से अधिक जटिल न हो। मैं यह भी चाहता था कि यह काफी कार्यात्मक हो और दूसरों की तरह नहीं। इस प्रकार निम्नलिखित योजना का जन्म हुआ।
घड़ी की कार्यक्षमता इस प्रकार है:
- उलटी गिनती, कैलेंडर, सप्ताह का दिन। (लीप वर्ष को ध्यान में रखा जाता है, गर्मी/सर्दियों का समय नहीं बदला जाता है)।
- बाहरी शक्ति के नुकसान की स्थिति में घड़ी का संरक्षण (खपत 15 माइक्रोन है)।
- स्ट्रोक सुधार + - 59.9 सेकंड/दिन, 0.1 सेकंड की वृद्धि में। 9 अलार्म. जिनमें से 3 "एक बार" और 6 "स्थायी" हैं, जो सप्ताह के दिन के अनुसार व्यक्तिगत रूप से अनुकूलन योग्य हैं।
- प्रत्येक अलार्म के लिए ध्वनि संकेत की व्यक्तिगत रूप से समायोज्य अवधि (1-15 मिनट)।
- बटन दबाने की ध्वनि पुष्टि (अक्षम की जा सकती है)।
- प्रति घंटा बीप (अक्षम किया जा सकता है)।
- 00-00 से 08-00 तक कोई सिग्नल नहीं है।
- 1 या 2 तापमान सेंसर (सड़क और घर)।
- अनुकूलन योग्य टिकर, जिसके माध्यम से सभी जानकारी प्रदर्शित होती है (समय को छोड़कर)
- बैकअप पावर खो जाने पर भी स्ट्रोक सुधार मान और "रनिंग लाइन" सेटिंग्स सहेजी जाती हैं।
इसकी उपलब्धता, सस्तेपन और "वैधता" के कारण AtMega16A को घड़ी के "दिल" के रूप में चुना गया था। मैं सर्किट को यथासंभव सरल बनाना चाहता था, इसलिए जो कुछ भी संभव था वह नियंत्रक को सौंपा गया था। परिणामस्वरूप, हम केवल दो माइक्रो-सर्किट, एक नियंत्रक और एक TPIC6B595 रजिस्टर से काम चलाने में सफल रहे। यदि किसी के पास TPIC6B595 उपलब्ध नहीं है तो आप इसे 74HC595 + ULN2803 से बदल सकते हैं। दोनों विकल्प आज़माए गए हैं. आप TPIC6C595 का उपयोग करके भी देख सकते हैं, यह थोड़ा कमजोर है और थोड़ा गर्म हो गया है, लेकिन कुल मिलाकर इसने स्थिर रूप से काम किया। समय की गणना अतुल्यकालिक समय - T2 का उपयोग करके की जाती है। बिजली गुल होने पर भी घड़ी चलती रहती है। इस समय, अधिकांश सर्किट डी-एनर्जेटिक है, और नियंत्रक बैटरी, संचायक, या आयनिस्टर द्वारा संचालित होता है। मुझे आयनिस्टर के साथ "खेलने" में दिलचस्पी थी, इसलिए मैंने इसका इस्तेमाल किया। स्टैंडबाय मोड में घंटों की वर्तमान खपत 15 माइक्रोन है। 1F आयनिस्टर द्वारा संचालित होने पर, घड़ी चार दिनों तक "चलती" थी। बिजली कटौती के दौरान गति बनाए रखने के लिए यह काफी है। यदि आप CR2032 बैटरी का उपयोग करते हैं, तो सैद्धांतिक रूप से, गणना के अनुसार, चार्ज 1.5 साल के लिए पर्याप्त होना चाहिए। नियंत्रक पिन पीबी.3 के माध्यम से मुख्य वोल्टेज की उपस्थिति को "सुनता" है। यह पिन तुलनित्र का इनवर्टिंग इनपुट है। आपूर्ति वोल्टेज, विभक्त R2-R3 के माध्यम से, पिन PB.3 को आपूर्ति की जाती है, और सामान्य स्थिति में लगभग 1.5 V है। यदि बाहरी वोल्टेज 4.1 वोल्ट से नीचे चला जाता है, तो पिन आरवी.3 पर वोल्टेज 1.23 वोल्ट से कम हो जाएगा, और तुलनित्र से एक रुकावट उत्पन्न होगी, और रुकावट हैंडलर में नियंत्रक के सभी "अतिरिक्त" नोड्स चालू हो जाएंगे बंद हो जाएगा और नियंत्रक स्वयं सो जाएगा। इस मोड में, केवल T2 टाइमर काम करना जारी रखता है। जब बाहरी शक्ति प्रकट होती है, तो RV.3 पर वोल्टेज फिर से 1.23V से ऊपर बढ़ जाएगा, नियंत्रक इसे "देखकर" सभी नोड्स को काम करने की स्थिति में डाल देगा। यदि आयनिस्टर के बजाय CR2032 बैटरी का उपयोग किया जाता है, तो इसे डायोड (अधिमानतः शोट्की डायोड) के माध्यम से जोड़ा जाना चाहिए। डायोड का एनोड + बैटरी से और कैथोड कैथोड VD1 से जुड़ा होता है। सामान्य मोड में, स्क्रीन समय को घंटे-मिनट प्रारूप में प्रदर्शित करती है। टिकर एक मिनट के अंतराल पर चलने लगता है। रनिंग लाइन सप्ताह का दिन, तारीख, वर्ष, तापमान प्रदर्शित करती है। घर पर, और तापमान. सड़क पर। टिकर अनुकूलन योग्य है, अर्थात आप किसी भी तत्व के प्रदर्शन को चालू/बंद कर सकते हैं। (उदाहरण के लिए, मैं हमेशा वर्ष प्रदर्शन बंद कर देता हूं)। जब सभी तत्व बंद हो जाते हैं, तो टिकर प्रारंभ नहीं होता है और घड़ी लगातार वर्तमान समय प्रदर्शित करती है। 9 अलार्म घड़ियों को 3 डिस्पोजेबल और 6 पुन: प्रयोज्य में विभाजित किया गया है। जब आप अलार्म 1-3 चालू करते हैं, तो वे केवल एक बार बजते हैं। उन्हें फिर से काम करने के लिए, उन्हें फिर से मैन्युअल रूप से चालू करना होगा। और अलार्म घड़ियाँ 4-9 पुन: प्रयोज्य हैं, अर्थात्। वे प्रतिदिन निर्धारित समय पर कार्य करेंगे। इसके अलावा, इन अलार्मों को केवल सप्ताह के कुछ निश्चित दिनों में ही बंद करने के लिए सेट किया जा सकता है। यह सुविधाजनक है, उदाहरण के लिए, यदि आप नहीं चाहते कि सप्ताहांत में अलार्म आपको जगाए। या उदाहरण के लिए, आपको सप्ताह के दिनों में 7-00 बजे और गुरुवार को 8-00 बजे उठना होगा, और सप्ताहांत पर आपको अलार्म घड़ी की आवश्यकता नहीं है। फिर हम सोमवार-बुधवार और शुक्रवार को 7-00 बजे एक पुन: प्रयोज्य सेट करते हैं, और दूसरा गुरुवार को 8-00 बजे सेट करते हैं... इसके अलावा, सभी अलार्म घड़ियों में एक सिग्नल अवधि सेटिंग होती है, और यदि आप, क्रम में जागने के लिए, यदि आपके पास 1 मिनट तक पर्याप्त सिग्नल नहीं है, तो आप इसे 1 से 15 मिनट तक बढ़ा सकते हैं। पाठ्यक्रम को दिन में एक बार 00-00 बजे सही किया जाता है। यदि घड़ी तेज़ है, उदाहरण के लिए, प्रतिदिन 5 सेकंड, तो 00-00-00 पर समय 23-59-55 पर सेट हो जाएगा, लेकिन यदि घड़ी धीमी है, तो 00-00-00 पर समय सेट हो जाएगा 00-00-05 पर सेट किया जाएगा. सुधार चरण - 0.1 सेकंड। अधिकतम सुधार - 59.9 सेकंड/दिन। कार्यशील क्वार्ट्ज़ के साथ, आपको अधिक की आवश्यकता होने की संभावना नहीं है। बैटरी द्वारा संचालित होने पर सुधार स्टैंडबाय मोड में भी किया जाता है। एलईडी मैट्रिसेस एक सामान्य कैथोड के साथ किसी भी 8*8 एलईडी का उपयोग कर सकते हैं। जैसा कि पहले ही बताया गया है, मैंने GNM23881AD का उपयोग किया। सिद्धांत रूप में, आप अलग-अलग एलईडी से एक मैट्रिक्स को "इकट्ठा" कर सकते हैं। AtMega16a माइक्रोकंट्रोलर को L अक्षर वाले "पुराने" AtMega16 से बदला जा सकता है। साथ ही, सैद्धांतिक रूप से, बैटरी से वर्तमान खपत थोड़ी बढ़नी चाहिए। संभवतः केवल AtMega16 ही काम करेगा, लेकिन बैटरी पावर पर काम करते समय समस्याएँ उत्पन्न हो सकती हैं। डायोड डी1 - अधिमानतः कोई भी शोट्की डायोड। यह एक नियमित रेक्टिफायर के साथ भी काम करता है, लेकिन इस तथ्य से संबंधित विभिन्न गड़बड़ियों से खुद को बचाने के लिए कि सर्किट का एक हिस्सा "डायोड से पहले" और कुछ हिस्सा "डायोड के बाद" वोल्टेज द्वारा संचालित होता है, इसे देखना बेहतर है शोट्की वोल्टेज. ट्रांजिस्टर VT1 - कोई भी एन-पी-एन। घड़ी को दो बटनों द्वारा नियंत्रित किया जाता है। बटनों को छोड़कर किसी भी अन्य घटक को जोड़े बिना उनकी संख्या को 8 टुकड़ों तक बढ़ाया जा सकता था, लेकिन मैं केवल दो के साथ "बाहर निकलने" का प्रयास करना चाहता था। बटनों को पारंपरिक रूप से "ओके" और "स्टेप" नाम दिया गया है। "STEP" बटन आमतौर पर अगले मेनू आइटम पर चला जाता है, और "OK" बटन वर्तमान मेनू के मापदंडों को बदल देता है। ट्रिगर अलार्म के सिग्नल को "ओके" या "स्टेप" बटन का उपयोग करके भी बंद किया जा सकता है। अलार्म बजने के दौरान कोई भी बटन दबाने से वह बंद हो जाता है। नियंत्रण योजना इस प्रकार निकली:
सब कुछ कैसे काम करता है इसका वीडियो!
घरेलू घड़ियों के विषय पर, मैंने जारी रखने का वादा किया था, इसलिए आप यहाँ जाएँ। घर में बने एलईडी मैट्रिसेस पर घड़ी।
मेरे द्वारा मैट्रिस पर घड़ियाँ बनाने का निर्णय लेने से पहले ही इन एल ई डी का ऑर्डर दिया गया था
मैंने एक विक्रेता से तीन अलग-अलग रंगों की एलईडी का ऑर्डर दिया:, और
ऐसा प्रति खंड 7*4*3=84+2=86 टुकड़ों में तीन एलईडी की दर से खंड घड़ियाँ बनाने का प्रयास करने के लिए किया गया था।
यह लगभग इस प्रकार है:
मैं अलग-अलग रंग और निश्चित रूप से चमकीले रंग आज़माना चाहता था (यह अन्यथा कैसे हो सकता है?)
इस कारण से, 100 टुकड़ों के बैच मेरे लिए काफी अनुकूल थे, खासकर जब से कीमत काफी उचित है, और मैंने उसी स्टोर से अलग-अलग रंगों में नंबर बनाने का भी ऑर्डर दिया ताकि मैं एक डिस्प्ले पर रंगों की तुलना कर सकूं - कौन सा और अधिक सुंदर होगा, इत्यादि - बस मजाक कर रहा हूँ... :)
उत्पाद का ऑर्डर दिया गया और उसका भुगतान किया गया 20 अगस्त 2016, और आ गया 15 सितंबर 2016, हमारे मानकों के अनुसार, बहुत जल्दी। लेकिन! लाल एल ई डी - नहीं पहुंचे! खरीदार की सुरक्षा अवधि के अंत में, एक विवाद खोला गया और विक्रेता ने पैसे वापस कर दिए। मेरा समय बर्बाद करना शर्म की बात थी...
उत्पाद एक मानक पीले बबल मेलिंग लिफाफे में आया था, एल ई डी स्वयं एक अलग प्लास्टिक बैग में पैक किए गए थे, नीले और हरे रंग में टुकड़ों की संख्या 100 से थोड़ी अधिक थी (मुझे अब बिल्कुल याद नहीं है, लेकिन मुझे याद है कि वहां 4-5 टुकड़े अधिक थे)
सभी कार्यशील (अर्थात् चमकते हुए)
जो बहुरंगी थे, उन्हें अलग-अलग थैलियों में पैक किया गया था, जिन पर रंग R G B W Y को एक मार्कर से चिह्नित किया गया था - रंग हर जगह मेल खाता था, और 2-3 अतिरिक्त भी - यह धारणा बनाई गई थी कि यह शायद सभी के लिए मामला था, लेकिन बाद में मुझे यकीन था कि हमेशा ऐसा नहीं होता, इसका उल्टा भी होता है...
यदि यह लाल जंब के लिए नहीं होता, तो विक्रेता को उदारता के लिए मोटा A+ दिया जा सकता था।
दूसरी ओर, पैसा वापस कर दिया गया - समस्या केवल समय की बर्बादी और निराश उम्मीदों की है
और उसने एक पत्र भी भेजा जिसमें उसने लिखा था कि वह अपना पैसा मुझे लौटा रहा है, और यदि माल आ गया है, तो उसने मुझसे यह राशि उसे वापस करने के लिए कहा।
शब्दशः:
नमस्ते, मेरे दोस्त, मैं अब रिफंड कर रहा हूं, जब आपको कोई पैकेज मिले, तो कृपया मेरे पैसे वापस कर दें, कृपया मुझे पांच सितारा उच्च प्रशंसा दें।
जिस पर उन्हें एक पत्र लिखना पड़ा कि यह नहीं था उसकापैसा, लेकिन विवाद के परिणामस्वरूप वह इसे मुझे लौटा देता है मेरापैसा, क्योंकि मुझे उसका सामान कभी नहीं मिला और साथ ही उसके सामान के इंतजार में मेरा काफी समय बर्बाद हो गया वैसे, जब 10 दिन बाद उनके अन्य सभी ऑर्डर आ गए, तो मैंने उन्हें पत्र लिखकर कहा कि मैं चिंतित हूं, क्योंकि... यह अजीब है - हर कोई आया, लेकिन एक भी ऑर्डर नहीं आया
जिस पर उन्होंने बिना किसी "हैलो फ्रेंड" के शुष्क उत्तर दिया, "अभी 60 दिन नहीं हुए हैं"
और फिर अचानक वह एक "दोस्त" बन गया और ऐसा लगा कि उसने उसके पैसे ले लिए हैं...
लेकिन सामान्य तौर पर - विक्रेता अपने कर्तव्यों को पूरा करता है, पत्रों का जवाब देता है, भेजे गए सामान में केवल सकारात्मक भावनाएं होती हैं, जो नहीं भेजा गया उसके लिए उसने पैसे लौटा दिए - सब कुछ नियमों के अनुसार है
खैर, अब इसके बारे में कि इसे क्यों खरीदा गया था
