स्थानीय स्वायत्त डेटा अधिग्रहण प्रणाली

// 12 328 बाइट्स (38%)

#include <Adafruit_GFX.h> // कोर ग्राफिक्स लाइब्रेरी
#include <Adafruit_ST7735.h> // हार्डवेयर-विशिष्ट पुस्तकालय
# किंकर्तव्यविमू <SPI.h>
# अलग करें <EEPROM.h>
#include <Wire.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 रेडियो (9, 10); // RF24 लाइब्रेरी के साथ काम करने के लिए रेडियो ऑब्जेक्ट,
// और पिन नंबर nRF24L01 + (CE, CSN)
#include <DS3231.h>
DS3231 आरटीसी (एसडीए, एससीएल);
समय टी;

// # TFT_CS को परिभाषित करें 10
#define TFT_CS 8
#define TFT_RST -1 // आप इसे Arduino रीसेट से भी जोड़ सकते हैं
// किस स्थिति में, इस # पिन पिन को -1 पर सेट करें!
// # TFT_DC को परिभाषित करें 9 // DC = RS = A0- आदेशों या डेटा के रजिस्टर के चुनाव के आउटपुट के लिए विकल्प।
#define TFT_DC 3

Adafruit_ST7735 tft = Adafruit_ST7735 (TFT_CS, TFT_DC, TFT_RST);

// विकल्प 2: किसी भी पिन का उपयोग करें लेकिन थोड़ा धीमा!
#define TFT_SCLK 13 // इन्हें सेट करें जो भी आपको पसंद हो!
#define TFT_MOSI 11 // इन्हें सेट करें जो भी आपको पसंद हो!
// Adafruit_ST7735 tft = Adafruit_ST7735 (TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
# अलग करना <avr / wdt.h>

बाइट शिफ्ट = 52;
बाइट pinState;
अहस्ताक्षरित लंबा पंप [4]; 4 सेकंड की गिनती के साथ सरणी
फ्लोट एम = 3600.0;
अहस्ताक्षरित int पता = 0;
int rc; काउंटरों के लिए चर
अहस्ताक्षरित लंबा सारांश = 0;
अहस्ताक्षरित लंबी sumsec = 0;
बाइट i = 0;
बाइट k = 34;
अहस्ताक्षरित int z = 0;
बाइट b = B00000001;
बाइट pumrcounter [4]; // ऑब्जेक्ट्स के स्टेट्स को स्टोर करने के लिए ऐरे, 1- ऑफ, 0- ऑन
int start = 0; //

शून्य सेटअप () {

rtc.begin ();
Radio.begin (); // ऑपरेशन शुरू करें nRF24L01 +
Radio.setChannel (120); // डाटा ट्रांसमिशन चैनल (0 से 127 तक)।
Radio.setDataRate (RF24_250KBPS); // डाटा ट्रांसफर रेट (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS)।
Radio.setPALevel (RF24_PA_MAX); // ट्रांसमीटर पावर (RF24_PA_MIN = -18dBm, RF24_PA_LOW = -12dBm,
// RF24_PA_HIGH = -6dBm, RF24_PA_MAX = 0dBm)
Radio.openWritingPipe (0xAABBCCDD11LL); // डेटा ट्रांसफर के लिए पहचानकर्ता के साथ पाइप खोलें

// समय निर्धारित करने के लिए, आवश्यक लाइनों को अनइंस्टॉल करें
//rtc.setDOW(1); // सप्ताह का दिन
//rtc.setTime(21, 20, 0); // समय, 24 घंटे के प्रारूप में।
//rtc.setDate(29, 10, 2018); // दिनांक, 29 अक्टूबर, 2018

tft.initR (INITR_BLACKTAB); // ST7735S चिप, ब्लैक टैब को इनिशियलाइज़ करें
// यदि आप 1.44 "टीएफटी का उपयोग कर रहे हैं तो इस इनिशियलाइज़र (अप्रतिबंध) का उपयोग करें
//tft.initR(INITR_144GREENTAB); // ST7735S चिप, RED rcB टैब इनिशियलाइज़ करें
tft.setTextWrap (झूठी); // पाठ को दाहिने किनारे से चलाने की अनुमति दें
tft.setRotation (2); // BLACK PCB और RED tft.setRotation (0) या नहीं के लिए।
tft.fillScreen (ST7735_BLACK); // स्क्रीन को साफ़ करें

DDRD = DDRD | B00000000;
PORTD = PORTD | B11110000; // सॉफ्टवेयर कसने के काम, उच्च स्तर-
// मॉनिटर की गई वस्तुएं "काम नहीं करती हैं", "1" डी के सभी 4 वरिष्ठ बंदरगाहों को लिखा जाता है, खाता नहीं जाता है।

के लिए (आर सी = ०; आरसी <४; आरसी ++)
{
tft.setCursor (3, आरसी * 10 + शिफ्ट); // नियंत्रण की वस्तुओं के पदों की संख्या प्रदर्शित करता है
tft.print (rc + 1);
}

tft.setCursor (12, 0); // आउटपुट पाठ की 3 लाइनें
tft.println ("DEVELOPERS & BUILD"); // अपने प्रियजनों की प्रशंसा करने के लिए
tft.setCursor (24, 10); // या दुष्ट कॉपीराइट
tft.print ("DEVELOPER MM");
tft.setCursor (28, 20);
tft.print ("BUILD-ER DD");

// डाटा रिकवरी //////////////////////////////////////////////// ///////////

के लिए (z = 0; z <1023; z + = 16) {// अपने उद्योग की सभी कोशिकाओं पर निर्भर करता है
// और 4 चर पंप की सरणी को लिखता है, 4 प्रत्येक काउंटर को बाइट करता है, क्योंकि
// चर अहस्ताक्षरित लंबे। काउंटर 4, सभी 4 में से एक रिकॉर्ड 16 बाइट लेता है।
EEPROM.get (z, पंप [0]); // तो, लूप के बिना, कम मात्रा
EEPROM.get (z + 4, पंप [1]);
EEPROM.get (z + 8, पंप [2]);
EEPROM.get (z + 12, पंप [3]);

// 4-एक्स काउंटर के योग के एक नए अगले मूल्य का असाइनमेंट
sumprim = (पंप [0] + पंप [1] + पंप [2] + पंप [3]);

// चर के पिछले मूल्य के साथ चर समरूप में 4 काउंटरों के योग के नए मूल्य की तुलना करता है
// sumsec और यदि पिछली राशि नई राशि से कम या बराबर है, तो एक नया बड़ा या बराबर असाइन किया गया है
// sumsec मान।

अगर (sumsec <= sumprim) {
sumsec = sumprim; //

// और वर्तमान मान z को पता चर में सौंपा गया है, z 4 मूल्यों से 16 बाइट्स के ब्लॉक की शुरुआत का पता है
// काउंटर एक ही समय में रिकॉर्ड किए जाते हैं (क्योंकि पोर्ट को पोलिंग करते समय, इसके सभी 8 बिट्स एक साथ रिकॉर्ड किए जाते हैं
// पोर्ट डी के हमारे वांछित उच्च 4 बिट्स सहित)।
पता = z;
}
}

// एक बार फिर, ब्लॉक के शुरुआती पते पर epromprom मेमोरी तक पहुंच दर्ज किए गए काउंटरों के 4 मूल्यों से 16 बाइट्स है
// अंतिम, अर्थात मानों को बंद करने या हैंग होने के कारण रिबूट करने से पहले। पिछले रिकॉर्ड
// 4 चर पंप की एक सरणी के काउंटरों का मान।

EEPROM.get (पता, पंप [0]);
EEPROM.get (पता + 4, पंप [1]);
EEPROM.get (पता + 8, पंप [2]);
EEPROM.get (पता + 12, पंप [3]);

पता + = 16; // पिछले रिकॉर्ड के डेटा को अधिलेखित किए बिना अगले ब्लॉक को लिखने के लिए पता बढ़ाएं

// डेटा रिकवरी का अंत ///////////////////////////////////////////////// ///////////////////

संलग्नक (0, गिनती, RISING); // पिन डी 2, बाधित ऑपरेशन सक्षम करें, हर सेकंड वे आते हैं
// SQW आउटपुट से RTC DS3231 से दालें

wdt_enable (WDTO_8S); // वॉचडॉग टाइमर शुरू करें, हैंग होने की स्थिति में कंट्रोलर को रिबूट करता है,
// जिसके लिए आपको wdt_reset टाइमर रीसेट कमांड भेजने की आवश्यकता है (और सामान्य ऑपरेशन के दौरान रिबूट करने से बचें - 8 सेकंड।
// परीक्षणों के लिए, 8 सेकंड से कम समय के लिए मान सेट करने की अनुशंसा नहीं की जाती है। इस मामले में, टाइमर को पहले रीसेट किया जाता है
// खुदाई, और यह हर सेकंड।

}

शून्य लूप () {
// खाली चक्र, यहां इलेक्ट्रिक मोटर के आउट-ऑफ-फेज ऑपरेशन मोड पर नियंत्रण होगा
}

शून्य गणना () {

tft.setTextColor (ST7735_WHITE); // फ़ॉन्ट रंग सेट करें
t = rtc.getTime (); // समय पढ़ें
tft.setCursor (5, 120); // सेट कर्सर स्थिति
tft.fillRect (5, 120, 50, 7, ST7735_BLACK); // स्पष्ट समय आउटपुट क्षेत्र
tft.print (rtc.getTimeStr ()); // प्रदर्शन के घंटे

wdt_reset (); // हर चक्र को वॉचडॉग टाइमर रीसेट करें, यानी एक सेकंड

के लिए (आरसी = 0; आरसी <4; आरसी ++) // इनपुट की स्थिति की जांच के लिए लूप की शुरुआत
// बंदरगाह बिट्स के पिछले पढ़ने की स्थिति के लिए पोर्ट बिट्स
{
pinState = (PIND >> 4) & (b << rc);

अगर (pumrcounter [rc]! = pinState) {// और अगर यह मेल नहीं खाता है, तो
pumrcounter [rc] = pinState; // नए मान 1/0 को पोर्ट बिट स्थिति चर असाइन करें
}
// रंग नियंत्रण की वस्तुओं की स्थिति का संकेत
// BLUE मौजूदा स्क्रीन (या लाइब्रेरी?) की एक छोटी सी गड़बड़ है, RGB और BGR मिश्रित हैं।
अगर (pinState == (b << rc)) {
tft.fillRect (15, (आरसी * 10 + शिफ्ट)), 7, 7, ST7735_BLUE); // निम्न-स्तरीय खातों के लिए, GREEN को BLUE में बदलें
} {
tft.fillRect (15, (rc * 10 + शिफ्ट)), 7, 7, ST7735_GENEN); // निम्न स्तर के खाते के लिए, BLUE को GREEN में बदलें
पंप [आरसी] + = १; // रनटाइम काउंटर में 1 सेकंड जोड़ें
}
}

के ++;
अगर (k == 36) {
k 0 है;

tft.fillRect (30, पारी, 97, 40, ST7735_BLACK); // रनटाइम आउटपुट क्षेत्र को साफ़ करें
tft.fillRect (60, 120, 73, 7, ST7735_BLACK); // और तिथियां

tft.setCursor (60, 120); // सेट कर्सर स्थिति
tft.print (rtc.getDateStr ()); // एलसीडी स्क्रीन पर दिनांक प्रदर्शित करें

(rc = 0; rc <4; rc ++) // आउटपुट ऑपरेटिंग टाइम रीडिंग इन पूर्णांक, दहाई और
{
tft.setCursor (30, आरसी * 10 + शिफ्ट); // स्क्रीन के नीचे 10 पिक्सल की शिफ्ट के साथ एक घंटे का सौवां भाग
tft.println (पंप [आरसी] / एम);
}

// रिकॉर्ड "रॉ" ऑपरेटिंग समय मान (सेकंड में) EEPROM ////////////////////////////////

के लिए (आर सी = ०; आरसी <४; आरसी ++)
{
EEPROM.put (पता, पंप [आरसी]);
पता + = आकार (फ्लोट); // रिकॉर्ड पता चर बढ़ाना
}
}

// हवा से डेटा भेजें डेटा से संकेत मिलता है कि कितने बाइट भेजना है।
if ((k == 6) || (k == 18) || ((k == 30)) {

अहस्ताक्षरित लंबा डेटा;

Radio.write (& start, sizeof (start));

के लिए (i = 0; मैं <4; मैं ++) {
data = पंप [i];
Radio.write (& data, sizeof (data));
}
}
}