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

इस साइट पर प्रारंभ करें по ссылке.
स्टार्टर को चालू करने के बारे में जानकारी प्राप्त करने के लिए सबसे सुविधाजनक विकल्प PC817 ऑप्टोकॉप्लर वाला विकल्प निकला। सर्किट आरेखबोर्ड में तीन समान सर्किट होते हैं, सब कुछ एबीएस प्लास्टिक बक्से में रखा जाता है, आकार 100x100 मिमी। ऑप्टोकॉप्लर्स का फोटो जब सेमीकंडक्टर वाल्व के साथ स्टार्टिंग डिवाइस से कनेक्ट किया जाता है, तो उनका लीकेज करंट PC817 को खोलने के लिए पर्याप्त होता है और काउंटर गलत तरीके से चालू हो जाएगा। ऐसी स्थिति को दूर करने के लिए ऑप्टोकॉप्लर एलईडी और ऑपरेशन इंडिकेशन एलईडी के सर्किट में श्रृंखला में एक और जोड़ा जाता है। ऐसा करने के लिए, जम्पर J1 खोला जाता है और एक अतिरिक्त LED LED1 को सोल्डर किया जाता है।
प्राप्त करने वाला भाग बना हुआ है पक्ष 1पक्ष 2विकास बोर्ड ARDUINO MEGA 2560 से जुड़ा है। इसके लिए अंत में एक डबल-पंक्ति कनेक्टर का उपयोग किया जाता है। 240x400 के रिज़ॉल्यूशन वाली एक स्क्रीन, जिसमें एक प्रतिरोधक टचस्क्रीन और एक तापमान सेंसर होता है, का उपयोग सूचना प्रदर्शन उपकरण के रूप में किया जाता है। HX8352B. इसके अलावा, स्क्रीन बोर्ड पर आईसीएसपी का कनेक्टर हटा दिया गया है और माइक्रो एसडी स्लॉट का उपयोग नहीं किया गया है। तथ्य यह है कि एसपीआई बस में विरोध के कारण "देशी" एसडी सॉकेट का उपयोग नहीं किया जा सकता है। फ़्लैश कार्ड के लिए, एक अलग कार्ड रीडर का उपयोग किया गया था, जिसमें एक 3,3V स्टेबलाइजर और तीन आउटपुट स्टेट्स 74LVS125A के साथ एक बफर चिप शामिल था। यहीं पर रेक मेरा इंतजार कर रहा था। एक तीन-स्टेट बफ़र, लेकिन या तो E01-ML01DP5 या कार्ड रीडर ने काम किया। लाइब्रेरी टिप्पणियों में, SdFat ने अन्य उपकरणों के साथ असंगति के बारे में एक चेतावनी देखी। TXS0108E पर लेवल कनवर्टर को हटा दिया गया और जंपर्स से बदल दिया गया, क्योंकि E01-ML01DP5 5V सिग्नल के प्रति सहनशील है - इससे कोई मदद नहीं मिली। ऑसिलोस्कोप का उपयोग करते हुए, कार्ड रीडर कनेक्ट होने पर एमआईएसओ लाइन पर सिग्नल हानि का पता चला। सावधानीपूर्वक जांच करने पर, यह पाया गया कि 4LVS74A के OE 125 चैनलों के सक्षम संकेतों के इनपुट को केवल एक सामान्य तार से जोड़ा गया था और किसी तीसरे राज्य की कोई बात नहीं हो सकती थी। बफर चिप का उपयोग सिग्नल लाइनों के साथ श्रृंखला में जुड़े 5 KΩ प्रतिरोधों का उपयोग करके 3.3V से 3,3V तक एक आदिम स्तर कनवर्टर के रूप में किया गया था। MISO लाइन को छोड़कर। इसका आउटपुट बॉटम स्विच संभवतः सिग्नलों को जमीनी स्तर तक आकर्षित करता है। यह निर्धारित करने के बाद कि एमआईएसओ लाइन का सक्षम सिग्नल पिन 13 था, इसे ट्रैक से हटा दिया गयासोल्डर किया हुआ9LVS74A CS डिवाइस के बीच इनपुट पिन (125) और टर्मिनेशन रेसिस्टर का चयन करें। अब, यदि मेमोरी कार्ड तक पहुंच नहीं है, तो MISO बफ़र अक्षम है और किसी अन्य डिवाइस के संचालन में हस्तक्षेप नहीं करता है।विकास बोर्ड आरेखरिसीवर प्रचालन में हैDS3231 घड़ी को जोड़ने के लिए एक सॉफ्टवेयर I2C बस (TWI) का उपयोग करता है।
Arduino आईडीई प्रोग्राम// महत्वपूर्ण: Adafruit_TFTLCD लाइब्रेरी विशेष रूप से होनी चाहिए
// टीएफटी शील्ड या ब्रेकआउट बोर्ड के लिए कॉन्फ़िगर किया गया।
// सेटअप के लिए Adafruit_TFTLCD.h में प्रासंगिक टिप्पणियाँ देखें।
//ओपन-स्मार्ट टीम और कैटालेक्स टीम द्वारा
//[ईमेल संरक्षित]
//इकट्ठा करना: dx.com
// open-smart.aliexpress.com/store/1199788
//डेमो फ़ंक्शन: ग्राफिक्स, वर्ण प्रदर्शित करें
//अरुडिनो आईडीई: 1.6.5
// बोर्ड: अरुडिनो यूएनओ आर3, अरुडिनो मेगा2560, अरुडिनो लियोनार्डो

// बोर्ड: ओपन-स्मार्ट यूएनओ आर3 5वी / 3.3वी, अरुडिनो यूएनओ आर3, अरुडिनो मेगा2560
//3.2 इंच टीएफटी:
// www.aliexpress.com/store/product/3-2-TFT-LCD-Display-module-Touch-Screen-Shield-board-onboard-temperature-sensor-w-Touch-Pen/1199788_32755473754.html?spm=2114.12010615.0.0.bXDdc3
//ओपन-स्मार्ट UNO R3 5V / 3.3V:
// www.aliexpress.com/store/product/OPEN-SMART-5V-3-3V-Compatible-UNO-R3-CH340G-ATMEGA328P-Development-Board-with-USB-Cable-for/1199788_32758607490.html?spm=2114.12010615.0.0.ckMTaN

#शामिल करना // कोर ग्राफिक्स लाइब्रेरी
//#शामिल करना // हार्डवेयर-विशिष्ट लाइब्रेरी
#शामिल करना
MCUFRIEND_kbv tft;
#शामिल "SdFat.h" // SdFat लाइब्रेरी का उपयोग करें
एसडीफ़ैट एसडी;
एसडीफ़ाइल फ़ाइल;
माईफाइल फाइल करें;
#एसडी_सीएस_पिन एसएस को परिभाषित करें

#शामिल करना // एसपीआई बस के साथ काम करने के लिए लाइब्रेरी को कनेक्ट करें
#शामिल करना // RF24 लाइब्रेरी से सेटिंग्स फ़ाइल कनेक्ट करें
#शामिल करना // nRF24L24+ के साथ काम करने के लिए लाइब्रेरी को कनेक्ट करें
आरएफ24 रेडियो(47, 49);

#शामिल

डीएस3231 आरटीसी(27, 25);
समय टी;

uint16_t r = 6000;
uint32_t k = 0;

अस्थिर अहस्ताक्षरित लंबा डेटा;
फ्लोट लेब_1;
फ्लोट लेब_2;
फ्लोट लेब_3;
फ्लोट लेब_4;

uint8_t पाइप;
पूर्णांक आरसी = 0;

uint8_t time_sec_prev;
uint8_t समय_दिन_पिछला;

//******************************************** ****************/ /
// यदि आप ओपन-स्मार्ट टीएफटी ब्रेकआउट बोर्ड का उपयोग करते हैं //
// आपको 5V-3.3V लेवल कन्वर्टिंग सर्किट जोड़ने की सलाह देता हूं।
// बेशक आप 5V/3.3V पावर स्विच के साथ ओपन-स्मार्ट UNO ब्लैक संस्करण का उपयोग कर सकते हैं,
// आपको बस 3.3V पर स्विच करने की आवश्यकता है।
// एलसीडी के लिए नियंत्रण पिन किसी भी डिजिटल या को सौंपा जा सकता है
//एनालॉग पिन...लेकिन हम एनालॉग पिन का उपयोग करेंगे क्योंकि यह हमें इसकी अनुमति देता है
//————————————-|
// टीएफटी ब्रेकआउट - अरुडिनो यूएनओ / मेगा2560 / ओपन-स्मार्ट यूएनओ ब्लैक
// जीएनडी - जीएनडी
// 3वी3 - 3.3वी
//सीएस - ए3
// आरएस - ए2
// डब्ल्यूआर - ए1
// आरडी - ए0
// आरएसटी - रीसेट
// एलईडी - जीएनडी
// डीबी0 - 8
// डीबी1 - 9
// डीबी2 - 10
// डीबी3 - 11
// डीबी4 - 4
// डीबी5 - 13
// डीबी6 - 6
// डीबी7 - 7

// कुछ सामान्य 16-बिट रंग मानों को मानव-पठनीय नाम निर्दिष्ट करें:
#ब्लैक 0x0000 को परिभाषित करें
#नीले 0x001F को परिभाषित करें
#लाल 0xF800 को परिभाषित करें
#हरे रंग को परिभाषित करें 0x07E0
#CYAN 0x07FF को परिभाषित करें
#मैजेंटा 0xF81F को परिभाषित करें
#पीले को परिभाषित करें 0xFFE0
#सफेद परिभाषित करें 0xFFFF
#ग्रे को परिभाषित करें 0x8C51
#GRAYD 0x39E7 को परिभाषित करें

//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// यदि शील्ड का उपयोग किया जाता है, तो सभी नियंत्रण और डेटा लाइनें ठीक हो जाती हैं, और
// वैकल्पिक रूप से एक सरल घोषणा का उपयोग किया जा सकता है:
// Adafruit_TFTLCD tft;
uint16_t g_identifier;

स्ट्रिंग डेटास्ट्रिंग;
//स्ट्रिंग numfileMonth = "1.txt";
चार पर्व [] = {"2.txt"};
//स्ट्रिंग *numfileMonth='1.txt' (आकार (numfileMonth));
////////////////////////////////////////////// /////////////////

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

rtc.begin();

// समय निर्धारित करने के लिए, आवश्यक पंक्तियों को अनटिप्पणी करें
//rtc.setDOW(6); // सप्ताह का दिन
//rtc.setTime(22, 04, 0); // समय, 24 घंटे के प्रारूप में।
//rtc.setDate(4, 5, 2019); //दिनांक, 29 अक्टूबर 2018

Serial.begin (2000000);
//////// स्क्रीन आरंभीकरण
tft.begin(0x65);
tft.reset();
tft.setRotation(0);
tft.cp437(सही);
//////////////////नाम, उपकरण सहायक उपकरण, संगठन का नाम का आउटपुट
tft.fillScreen(काला);
tft.setTextColor(सफ़ेद);
tft.setTextSize(2);
tft.setCursor(8, 0);
tft.println('डेवलपर्स और निर्माण');
tft.setCursor(30, 20);
tft.print (utf8rus('कन्स्ट्रक्टर वी.वी.' ));
tft.setCursor(40, 40);
tft.print (utf8rus('टर्नर I.I.' ));
देरी (2000);

रेडियो.शुरू(); // कार्य प्रारंभ करें nRF24L01+
रेडियो.सेटचैनल(120); // डेटा रिसेप्शन चैनल निर्दिष्ट करें (0 से 127 तक)
Radio.setDataRate(RF24_250KBPS); // डेटा अंतरण दर निर्दिष्ट करें (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Mbit/s
Radio.setPALevel(RF24_PA_MAX); // ट्रांसमीटर पावर निर्दिष्ट करें (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
Radio.openReadingPipe(1, 0xAABBCCDD11LL); // डेटा प्राप्त करने के लिए 1 ट्रांसमीटर 1xAABBCCDD0 के पहचानकर्ता के साथ 11 पाइप खोलें
// डेटा प्राप्त करने के लिए ट्रांसमीटर आईडी 2xAABBCCDD2 के साथ पाइप 0 खोलें
रेडियो.स्टार्टलिसनिंग(); // रिसीवर चालू करें, खुले पाइपों को सुनना शुरू करें
//रेडियो.सुनना बंद करो();
////////सेवा जानकारी का आउटपुट
tft.fillScreen(काला);
tft.setCursor(8, 0);
tft.setTextSize(1);
////////एसडी कार्ड प्रारंभ करना प्रारंभ करें
सीरियल.प्रिंटएलएन ("प्रारंभिक एसडी कार्ड");
tft.println('प्रारंभिक एसडी कार्ड');
tft.setCursor(8, 10);
////////कार्ड प्रारंभ करना
यदि (!SD.begin(SD_CS_PIN)) {
Serial.println('प्रारंभिक विफल!');
tft.fillRect(8, 10, 85, 7, लाल);
tft.setTextColor(काला);
tft.println('प्रारंभिक विफल!');
वापसी;
}
tft.setTextColor(सफ़ेद);
Serial.println('प्रारंभिकरण हो गया');
tft.println('प्रारंभ हो गया');
देरी (2000);
////////समय और तारीख पढ़ना और उन्हें वेरिएबल्स में निर्दिष्ट करना
टी = rtc.getTime();
time_sec_prev = t.sec;
time_day_prev = t.date;
//////// दिनांक को जबरन आउटपुट करें ताकि प्रदर्शन के लिए दिनांक बदलने की प्रतीक्षा न करनी पड़े
tft.setCursor(180, 0); // कर्सर की स्थिति निर्धारित करना
tft.fillRect(178, 0, 65, 7, ग्रे); // समय आउटपुट क्षेत्र को साफ़ करना
tft.setTextSize(1);
tft.print(rtc.getDateStr());
////////नियंत्रण वस्तुओं का नाम आउटपुट करें
tft.setTextSize(2);
tft.setCursor(60, 25);
tft.println (utf8rus('Winches I'));
////////एक लॉग फ़ाइल बनाना और निर्माण प्रयास के परिणाम को आउटपुट करना
tft.setTextSize(1);
tft.setCursor(130); // यदि लॉग फ़ाइल 10.txt बनाई गई है, तो फ़ाइल पर लिखना जारी रहेगा
यदि (SD.exists(perv)) {
//tft.setCursor(0, 90);
tft.println(perv);
सीरियल.प्रिंटएलएन(पर्व);
और} {
myFile = SD.open(perv, FILE_WRITE); // यदि फ़ाइल 2.txt मौजूद नहीं है, तो इसे बनाया जाएगा
myFile.close ();
tft.println(perv);
सीरियल.प्रिंटएलएन(पर्व);
}
}

शून्य लूप(शून्य) {
////////COM पोर्ट मॉनीटर पर लॉग आउटपुट करने के अनुरोध के अस्तित्व की जाँच करना
यदि (Serial.available() > 0) {
यदि (1 == सीरियल.पढ़ें());
////////और यदि "1" स्वीकार किया जाता है, तो आउटपुट
फ़ाइल myFile = SD.open(perv);
// यदि फ़ाइल उपलब्ध है, तो उसे लिखें:
अगर (मायफाइल) {
जबकि (myFile.available()) {
सीरियल.राइट(myFile.read());
}
myFile.close ();
}
और {
Serial.println('त्रुटि खोलने में .txt');
}
}
////////पढ़ने का समय
टी = rtc.getTime();
tft.setTextColor(सफ़ेद);
////////यदि समय बदल गया है, तो नई घड़ी की रीडिंग प्रदर्शित करें
यदि (time_sec_prev != t.sec) {
tft.setCursor(120, 0); // कर्सर की स्थिति निर्धारित करना
tft.fillRect(118, 0, 50, 7, ग्रे); // समय आउटपुट क्षेत्र को साफ़ करना
tft.setTextSize(1);
tft.print(rtc.getTimeStr()); // आउटपुट क्लॉक रीडिंग
time_sec_prev = t.sec;
}
////////यदि तिथि बदल गई है तो नई तिथि प्रदर्शित करें
यदि (time_day_prev != t.date) {
tft.setCursor(180, 0); // कर्सर की स्थिति निर्धारित करना
tft.fillRect(178, 0, 65, 7, ग्रे); // दिनांक प्रदर्शन क्षेत्र साफ़ करें
tft.setTextSize(1);
tft.print(rtc.getDateStr()); // दिनांक रीडिंग प्रदर्शित करें
time_day_prev = t.date;
}
////////यदि रेडियो रिसेप्शन उपलब्ध है, तो
यदि (रेडियो.उपलब्ध(&पाइप)) {
////////जाँच कर रहा है कि प्राप्त बफ़र भरा हुआ है या नहीं,
Radio.read(&data, sizeof(data));
////////यदि आवश्यक ट्रांसमीटर पता उपलब्ध है, तो
अगर (पाइप == 1) {
////////निर्धारित करने के लिए शून्य के सिंक्रनाइज़िंग अनुक्रम की प्रतीक्षा की जा रही है
// डेटा ब्लॉक की शुरुआत
अगर (डेटा == 0000) {
आरसी = 0;
और} {
आरसी++;
}
////////काउंटर मानों को रिकॉर्ड करना और एक घंटे के 10वें और 100वें हिस्से में उनकी गणना करना
अगर (आरसी == 1) {
लेब_1 = डेटा / 3600.0;
}

अगर (आरसी == 2) {
लेब_2 = डेटा / 3600.0;
}

अगर (आरसी == 3) {
लेब_3 = डेटा / 3600.0;
}

अगर (आरसी == 4) {
लेब_4 = डेटा / 3600.0;
}
}
}
आर++;
के++; //सिर्फ एक काउंटर
//////// एक निश्चित आवधिकता के साथ डेटा अद्यतन
यदि ( आर >= 6500) {
tft.setTextSize(2);
tft.fillRect(0, 41, 180, 64, GRAYD);
Serial.println('लेबेडकी I');
tft.setCursor(0, 41);
tft.println(leb_1);
सीरियल.प्रिंटएलएन(leb_1);
tft.println(leb_2);
सीरियल.प्रिंटएलएन(leb_2);
tft.println(leb_3);
सीरियल.प्रिंटएलएन(leb_3);
tft.println(leb_4);
सीरियल.प्रिंटएलएन(leb_4);
सीरियल.प्रिंटएलएन(के);
आर = 0;
}
////////हर 10 मिनट में एसडी पर लॉग में डेटा लिखें।
यदि ((t.min % 10 == 0) && ( t.sec == 0)) {
tft.setTextSize(1);
tft.setCursor(200, 10);
tft.setTextColor(काला);
////////.csv प्रारूप में एक स्ट्रिंग बनाना
स्ट्रिंग डेटास्ट्रिंग = स्ट्रिंग (rtc.getDateStr()) + ", "+(rtc.getTimeStr()) + ", " + (leb_1) + ", " + (leb_2)
+ ", " + (leb_3) + ", " + (leb_4) + ", ";
////////एक फ़ाइल में लिखें और लेखन प्रक्रिया के परिणामों को आउटपुट करें
myFile = SD.open(perv, FILE_WRITE); // यदि "2.txt" नाम की कोई फ़ाइल नहीं है, तो इसे बनाया जाएगा।
अगर (मायफाइल) {
myFile.println(डेटास्ट्रिंग);
myFile.close ();
tft.fillRect(198, 8, 42, 10, हरा);
tft.println('एसडी ओके');
सीरियल.प्रिंटएलएन('एसडी ओके');
विलंब(900); // विलंब, अन्यथा एक सेकंड बीतने तक 13 समान रीडिंग रिकॉर्ड करता है
और} {
tft.fillRect(198, 8, 42, 10, लाल);
tft.println('एसडी ईआरआर');
सीरियल.प्रिंटएलएन('एसडी ईआरआर');
}
}
}चरित्र रूपांतरण कार्यक्रम/* रूसी फ़ॉन्ट को UTF-8 से Windows-1251 में पुनः कोड करें */

स्ट्रिंग utf8rus (स्ट्रिंग स्रोत)
{
int i,k;
स्ट्रिंग लक्ष्य;
अहस्ताक्षरित चार एन;
चार एम[2] = { '0', '' };

k = स्रोत.लंबाई(); मैं = 0;

जबकि (i < k) {
n = स्रोत[i]; मैं++;

यदि (n >= 0xC0) {
स्विच (एन) {
केस 0xD0: {
n = स्रोत[i]; मैं++;
यदि (n == 0x81) { n = 0xA8; तोड़ना; }
यदि (n >= 0x90 && n <= 0xBF) n = n + 0x30;//0x2F
तोड़;
}
केस 0xD1: {
n = स्रोत[i]; मैं++;
यदि (n == 0x91) { n = 0xB8; तोड़ना; }
यदि (n >= 0x80 && n <= 0x8F) n = n + 0x70;//0x6F
तोड़;
}
}
}
एम[0] = एन; लक्ष्य = लक्ष्य + स्ट्रिंग (एम);
}
वापसी लक्ष्य;
}Adafruit_GFX लाइब्रेरी का उपयोग करके सिरिलिक आउटपुट के लिए कैरेक्टर ट्रांसकोडिंग प्रोग्राम को मुख्य प्रोग्राम के साथ एक ही फ़ोल्डर में रखा गया है। आपको Adafruit_GFX में glcdfont.c फ़ाइल को किसी भिन्न फ़ॉन्ट से बदलने की भी आवश्यकता है। यहां आवश्यक प्रतिस्थापन के साथ पुस्तकालय. रूसीकरण के बारे में अधिक जानकारी इंटरनेट पर आसानी से पाई जा सकती है।
संक्षेप में, मैं कहूंगा कि सिस्टम उम्मीदों पर खरा उतरा, उपकरण के संचालन समय की निगरानी करना आसान हो गया है। भले ही सब कुछ ब्रेडबोर्ड पर इकट्ठा किया गया हो, काम के बारे में तत्काल कोई शिकायत नहीं है। पहले तत्व छह महीने से अधिक समय से काम कर रहे हैं और सर्दी से बचे हुए हैं। नवीनतम डिज़ाइन यह 9 मार्च से 5 नियंत्रित इकाइयों के लिए चल रहा है और इसका उपयोग करके परिचालन समय को आधिकारिक तौर पर पंजीकृत किया जा रहा है।

स्रोत: www.habr.com