🔈 🧙🏾 🎐 दो-अपने आप स्मार्ट प्वाइंट या "इंटरनेट चीज" 🧗 👨🏻‍🍳 👃🏼

इस लेख में मैं होम ऑटोमेशन और इंटरनेट ऑफ थिंग्स के क्षेत्र में समाधान बनाने के लिए एक कॉम्पैक्ट प्लेटफॉर्म के व्यावहारिक कार्यान्वयन की अवधारणा और उदाहरण का वर्णन करूंगा।

मैं बिल्ली के नीचे दिलचस्पी रखने वालों से पूछता हूं।

शुरू करने के बजाय

हाल ही में सूचना प्रौद्योगिकी के ऐसे क्षेत्र में जीवन के स्वचालन के रूप में बढ़ती रुचि का एक स्पष्ट चलन हुआ है। अपने आप में स्वचालन एक नई घटना से दूर है और दशकों से, अधिकांश औद्योगिक उद्यमों के लिए यह एक सनकी नहीं है, लेकिन एक आवश्यकता है, जिसके बिना व्यवसाय के लिए भयंकर प्रतिस्पर्धा के सामने जीवित रहने के लिए बस अकल्पनीय है। तो अब केवल हम इंटरनेट ऑफ थिंग्स, एम 2 एम (मशीन-टू-मशीन) संचार, और अन्य "स्मार्ट" प्रौद्योगिकियों के बारे में इतना क्यों सुनते हैं? शायद यही कारण है कि कई समान मामलों में, नवाचारों का एक निश्चित "महत्वपूर्ण द्रव्यमान" प्राप्त हुआ, जो आम जनता के लिए तत्व आधार की उपलब्धता के साथ मिलकर था। जिस तरह एक बार इंटरनेट के विकास और इंटरनेट प्रौद्योगिकियों की पहुंच ने सूचना परियोजनाओं की एक लहर को जन्म दिया, जो अब तक दुनिया को बदल रहे हैं, इसलिए अब हम देख रहे हैं कि प्रोग्रामिंग, माइक्रो-इलेक्ट्रॉनिक्स और इंटरनेट जैसी कितनी "ईंटें" बनती हैं दिलचस्प घरेलू उपाय। उनमें से सभी "बंद" नहीं करेंगे और यह बिल्कुल सामान्य है, लेकिन उनमें से कई वास्तव में आश्चर्यजनक कुछ के लिए आधार (या प्रेरणा) हो सकते हैं।

व्यक्तिगत रूप से, मुझे कई वर्षों से इसमें सक्रिय रूप से दिलचस्पी है, और शायद कुछ ने मेजरडोमो स्मार्ट होम ओपन प्रोजेक्ट के बारे में सुना है, जिसे बनाने और काम करने की खुशी है। लेकिन अब यह उसके बारे में नहीं है, लेकिन कुछ समानांतर परियोजना के बारे में, एक और प्रयोग, अगर आपको पसंद है, जो मुझे कुछ समय पहले दूर किया था और जिसके परिणाम मैं इस लेख में साझा करता हूं।

स्मार्ट होम प्लेटफ़ॉर्म की परियोजना "सामान" में होने के बाद, मैंने सोचा कि हालांकि यह उपयोग में बहुत लचीला है, बड़ी संख्या में संभावनाओं के लिए उपयुक्त उपकरण की आवश्यकता होती है, जो हमेशा सुविधाजनक और व्यावहारिक नहीं होता है। "छोटे" स्वचालन के कुछ कार्यों के लिए, आप एक माइक्रोकंट्रोलर से प्राप्त कर सकते हैं, लेकिन यहां हम पहले से ही लचीलापन खो रहे हैं और उपयोगकर्ता कौशल के लिए आवश्यकताओं को बढ़ा रहे हैं। मुझे यह स्पष्ट प्रतीत हुआ कि किसी प्रकार के मध्यवर्ती विकल्प की आवश्यकता थी - काफी कॉम्पैक्ट और ऊर्जा-कुशल, लेकिन एक ही समय में कॉन्फ़िगरेशन और उपयोग में लचीला। आइए इस विकल्प को "स्मार्ट प्वाइंट" या स्मार्टप्वाइंट पर काम करने का नाम दें। रास्ते के साथ, इस डिवाइस में प्राप्त होने वाली संभावनाओं पर इच्छाओं की एक पूरी सूची बनाई गई थी।

कार्य

तो, बोल से अभ्यास तक। स्मार्टपाइप डिवाइस के लिए यहां मूलभूत आवश्यकताएं हैं:

सेंसर से घटनाओं का जवाब देने के लिए नियमों की एक लचीली प्रणाली
मैनुअल नियंत्रण के लिए वेब इंटरफ़ेस
अधिक जटिल परिसर में एकीकरण के लिए HTTP एपीआई
ऑनलाइन संचालन - इंटरनेट के माध्यम से डिवाइस के वेब इंटरफेस तक पहुंच, एक स्थिर आईपी और राउटर पर पोर्ट अग्रेषण के बिना
ऑफ़लाइन ऑपरेशन - कॉन्फ़िगर डिवाइस का कामकाज इंटरनेट एक्सेस की उपलब्धता पर निर्भर नहीं होना चाहिए

डिवाइस के लिए अतिरिक्त (व्यावहारिक) इच्छाएं:

वाईफाई का काम
अंतर्निहित सेंसर और एक्ट्यूएटर मॉड्यूल की उपस्थिति (डिवाइस को "बॉक्स से बाहर" तुरंत व्यावहारिक उपयोग होना चाहिए, न कि "सिद्धांत रूप में")
सरल सेंसर / एक्ट्यूएटर्स के साथ बातचीत के लिए वायरलेस "स्थानीय" इंटरफ़ेस
डिवाइस के संचालन की स्थापना और निगरानी के लिए इंटरनेट सेवा (व्यक्तिगत खाता)

नियंत्रक, मेजबान, परिधीय

बार-बार विचार करना, साथ ही साथ "विशलिस्ट" का एक बड़ा सेट, मैं इस निष्कर्ष पर पहुंचा कि एक माइक्रोकंट्रोलर के साथ प्रबंधन करना असंभव होगा। सबसे पहले, मुझे अभी भी नहीं पता है कि उन्हें इतनी अच्छी तरह से कैसे प्रोग्राम करना है कि मैं अपनी सभी योजनाओं को निम्न स्तर पर लागू कर सकता हूं, और दूसरी बात, प्रत्येक नियंत्रक इच्छाओं के लिए इस तरह की भूख नहीं बनाएगा। यह कम से कम प्रतिरोध का रास्ता लेने का निर्णय लिया गया - डिवाइस को दो तार्किक भागों में विभाजित करने के लिए: एक ("नियंत्रक") माइक्रोकंट्रोलर पर आधारित होगा और हार्डवेयर के साथ प्राथमिक बातचीत के लिए जिम्मेदार होगा, और दूसरा ("होस्ट") जो कि निर्मित लिनक्स पर आधारित है, अधिक के लिए जिम्मेदार होगा। उच्च स्तर (इंटरफ़ेस, नियमों की प्रणाली, एपीआई)। Arduino microcontroller को पहले ब्लॉक (अनुमान!) के रूप में चुना गया था, और OpenWRT फर्मवेयर के साथ टीपी-लिंक WR703N राउटर को दूसरे ब्लॉक के रूप में इस्तेमाल किया गया था (ध्यान दें: DLink Dir-320 राउटर पर इसी तरह के उपकरणों की एक जोड़ी सफलतापूर्वक इकट्ठी हुई थी)। धर्मी क्रोध को स्वीकार करते हुए, मैं आपको याद दिलाना चाहता हूं कि प्रोटोटाइप पर अवधारणा की व्यवहार्यता का परीक्षण करने के लिए सबसे पहले कार्य है, और एक वाणिज्यिक उपकरण को डिजाइन और इकट्ठा करने के लिए नहीं। इसके अलावा, इन घटकों का उपयोग डिवाइस पुनरावृत्ति की सुविधा देता है - लंबे समय तक खुला स्रोत! Arduino का उपयोग करने से आप हमारे डिवाइस पर कई प्रकार के सेंसर और एक्चुएटर्स को जोड़ने का अनुभव लागू कर सकते हैं।

टीपी-लिंक WR703N राउटर:

माइक्रोकंट्रोलर अरुडिनो नैनो:

निम्नलिखित तत्वों को बाह्य उपकरणों के प्रारंभिक सेट के रूप में चुना गया था:

बटन
मोशन सेंसर
DS18B20 तापमान सेंसर
433Mhz रिसीवर
नूलाइट लाइट कंट्रोल ट्रांसमीटर

बाह्य उपकरणों का सेट, जैसा कि आप समझते हैं, अलग हो सकता है, लेकिन इस उदाहरण में मैंने इसे "व्यावहारिक उपयोगिता" के सिद्धांत के आधार पर लिया है। इस प्रकार, हमारे साथ डिवाइस एक बटन के प्रेस पर प्रतिक्रिया करने, आंदोलन करने, तापमान में बदलाव के साथ-साथ बाहरी सेंसर से डेटा प्राप्त करने में सक्षम होगा (इस मामले में, हब पर पहले वर्णित प्रोटोकॉल का उपयोग किया गया था ) और Noolite सिस्टम के पावर मॉड्यूल को नियंत्रित करें (नियंत्रण मॉड्यूल के बारे में एक अलग कहानी है) और फोटोग्राफ मॉड्यूल की एक वाणिज्यिक प्रति नहीं है, लेकिन निर्माता से सबसे शुरुआती प्रोटोटाइप में से एक है, जो परीक्षण के लिए मेरे पास आया था)।

कार्यान्वयन ड्राफ्ट और प्रारंभिक आवश्यकताओं को मिलाकर, हमें डिवाइस के निम्नलिखित ब्लॉक आरेख मिलते हैं:

योजना के लिए स्पष्टीकरण:

डिवाइस में एक माइक्रोकंट्रोलर होता है जो वायर्ड / वायरलेस बाह्य उपकरणों के साथ इंटरैक्ट करता है, और इनपुट प्रोसेसिंग लॉजिक और इंटरफेस के लिए जिम्मेदार एक कोर है
बाहरी "टर्मिनलों" (कंप्यूटर, फोन आदि) से कमांड प्राप्त करने के लिए एक एपीआई और एक वेब इंटरफेस है।
नियमों को डाउनलोड करने, सूचनाएं भेजने और आदेश प्राप्त करने के लिए बाहरी सेवा के साथ संचार में एक उपकरण

माइक्रोकंट्रोलर तैयारी

माइक्रोकंट्रोलर के दो मुख्य कार्य होते हैं: पहला, बाहरी उपकरणों से कंसोल तक घटनाओं को आउटपुट करना, और दूसरा, कंसोल से कमांड को प्राप्त करने के लिए कनेक्टेड पेरिफेरल्स को ट्रांसमिशन के लिए प्राप्त करना।

नीचे स्केच का पाठ है, ऊपर सूचीबद्ध परिधीय की बारीकियों को ध्यान में रखते हुए। हमारे मामले में, बटन PIN4, गति संवेदक से PIN3, तापमान संवेदक से PIN9, रेडियो से PIN8 और नुलिट मॉड्यूल से पिन 10, 11 से जुड़ा है।

नियंत्रक के लिए स्केच

#include <OneWire.h> #include <DallasTemperature.h> #include <VirtualWire.h> #include <EasyTransferVirtualWire.h> #include <EEPROM.h> //Needed to access the eeprom read write functions #include <SoftwareSerial.h> #define PIN_LED (13) // INDICATOR #define PIN_PIR (3) // BUTTON #define PIN_BUTTON (4) // BUTTON #define PIN_LED_R (6) // INDICATOR RED #define PIN_LED_G (5) // INDICATOR GREEN #define PIN_LED_B (7) // INDICATOR BLUE #define PIN_RF_RECEIVE (8) // EASYRF RECEIVER #define PIN_TEMP (9) // TEMPERATURE SENSOR #define PIN_NOO_RX (10) // RX PIN (connect to TX on noolite controller) #define PIN_NOO_TX (11) // TX PIN (connect to RX on noolite controller) #define TEMP_ACC (0.3) // temperature accuracy #define PERIOD_READ_TEMP (20) // seconds #define PERIOD_SEND_TEMP (600) // seconds (10 minutes) #define PERIOD_SEND_UPTIME (300) // seconds (5 minutes) #define NOO_BUF_LEN (12) unsigned int unique_device_id = 0; long int uptime = 0; long int old_uptime = 0; float sent_temperature=0; int sent_pir=0; int sent_button=0; int sent_button_longlick=0; long int timeCheckedTemp=0; long int timeSentTemp=0; long int timeSentUptime=0; long int timeButtonPressed=0; String inData; //create objects SoftwareSerial mySerial(PIN_NOO_RX, PIN_NOO_TX); // RX, TX OneWire oneWire(PIN_TEMP); DallasTemperature sensors(&oneWire); EasyTransferVirtualWire ET; unsigned int last_packet_id = 0; struct SEND_DATA_STRUCTURE{ //put your variable definitions here for the data you want to send //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO //Struct can'e be bigger then 26 bytes for VirtualWire version unsigned int device_id; unsigned int destination_id; unsigned int packet_id; byte command; int data; }; //give a name to the group of data SEND_DATA_STRUCTURE mydata; //This function will write a 2 byte integer to the eeprom at the specified address and address + 1 void EEPROMWriteInt(int p_address, unsigned int p_value) { byte lowByte = ((p_value >> 0) & 0xFF); byte highByte = ((p_value >> 8) & 0xFF); EEPROM.write(p_address, lowByte); EEPROM.write(p_address + 1, highByte); } //This function will read a 2 byte integer from the eeprom at the specified address and address + 1 unsigned int EEPROMReadInt(int p_address) { byte lowByte = EEPROM.read(p_address); byte highByte = EEPROM.read(p_address + 1); return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00); } void nooSend(byte channel, byte buf[NOO_BUF_LEN]) { buf[0]=85; buf[1]=B01010000; // buf[4]=0; buf[5]=channel; buf[9]=0; int checkSum; for(byte i=0;i<(NOO_BUF_LEN-2);i++) { checkSum+=buf[i]; } buf[10]=lowByte(checkSum); buf[11]=170; Serial.print("Sending: "); for(byte i=0;i<(NOO_BUF_LEN);i++) { Serial.print(buf[i]); if (i!=(NOO_BUF_LEN-1)) { Serial.print('-'); } } Serial.println(""); for(byte i=0;i<(NOO_BUF_LEN);i++) { mySerial.write(buf[i]); } } void noolitePair(byte channel) { byte buf[NOO_BUF_LEN]; for(byte i=0;i<(NOO_BUF_LEN);i++) { buf[i]=0; } buf[2]=15; buf[3]=0; nooSend(channel,buf); } void nooliteUnPair(byte channel) { byte buf[NOO_BUF_LEN]; for(byte i=0;i<(NOO_BUF_LEN);i++) { buf[i]=0; } buf[2]=9; buf[3]=0; nooSend(channel,buf); } void nooliteTurnOn(byte channel) { byte buf[NOO_BUF_LEN]; for(byte i=0;i<(NOO_BUF_LEN);i++) { buf[i]=0; } buf[2]=2; buf[3]=0; nooSend(channel,buf); } void nooliteTurnOff(byte channel) { byte buf[NOO_BUF_LEN]; for(byte i=0;i<(NOO_BUF_LEN);i++) { buf[i]=0; } buf[2]=0; buf[3]=0; nooSend(channel,buf); } void nooliteSwitch(byte channel) { byte buf[NOO_BUF_LEN]; for(byte i=0;i<(NOO_BUF_LEN);i++) { buf[i]=0; } buf[2]=4; buf[3]=0; nooSend(channel,buf); } void nooliteLevel(byte channel,byte level) { byte buf[NOO_BUF_LEN]; for(byte i=0;i<(NOO_BUF_LEN);i++) { buf[i]=0; } buf[2]=6; buf[3]=1; buf[6]=level; nooSend(channel,buf); } void blinking(int count) { for(int i=0;i<count;i++) { digitalWrite(PIN_LED, HIGH); delay(200); digitalWrite(PIN_LED, LOW); delay(200); } } void setColor(int r,int g, int b) { digitalWrite(PIN_LED_R, r); digitalWrite(PIN_LED_G, g); digitalWrite(PIN_LED_B, b); } void setup() { randomSeed(analogRead(0)); pinMode(PIN_LED, OUTPUT); pinMode(PIN_LED_R, OUTPUT); pinMode(PIN_LED_G, OUTPUT); pinMode(PIN_LED_B, OUTPUT); pinMode(PIN_PIR, INPUT); pinMode(PIN_BUTTON, INPUT); Serial.begin(9600); // Debugging only ET.begin(details(mydata)); // Initialise the IO and ISR vw_set_rx_pin(PIN_RF_RECEIVE); vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running // Device ID Serial.print("Getting Device ID... "); unique_device_id=EEPROMReadInt(0); if (unique_device_id<10000 || unique_device_id>60000 || unique_device_id==26807) { Serial.print("N/A, updating... "); unique_device_id=random(10000, 60000); EEPROMWriteInt(0, unique_device_id); } Serial.println(unique_device_id); pinMode(PIN_NOO_RX, INPUT); pinMode(PIN_NOO_TX, OUTPUT); mySerial.begin(9600); } void loop() { uptime=round(millis()/1000); if (uptime!=old_uptime) { Serial.print("Up: "); Serial.println(uptime); old_uptime=uptime; if (((uptime-timeSentUptime)>PERIOD_SEND_UPTIME) || (timeSentUptime>uptime)) { timeSentUptime=uptime; Serial.print("P:"); Serial.print(random(65535)); Serial.print(";F:"); Serial.print("0"); Serial.print(";T:0;C:"); Serial.print("24"); Serial.print(";D:"); Serial.print(uptime); Serial.println(";"); } } int current_pir=digitalRead(PIN_PIR); if (current_pir!=sent_pir) { Serial.print(millis()/1000); Serial.print(" Motion sensor: "); Serial.println(current_pir); Serial.print("P:"); Serial.print(random(65535)); Serial.print(";F:"); Serial.print("0"); Serial.print(";T:0;C:"); Serial.print("12"); Serial.print(";D:"); Serial.print("1"); Serial.println(";"); sent_pir=(int)current_pir; } int current_button=digitalRead(PIN_BUTTON); if (current_button!=sent_button) { delay(50); int confirm_current_button=digitalRead(PIN_BUTTON); if (confirm_current_button==current_button) { if (current_button==1) { timeButtonPressed=millis(); sent_button_longlick=0; } if (current_button==0) { if (sent_button_longlick!=1) { Serial.print(millis()/1000); Serial.print(" Button press: "); Serial.println(current_button); Serial.print("P:"); Serial.print(random(65535)); Serial.print(";F:"); Serial.print("0"); Serial.print(";T:0;C:"); Serial.print("23"); Serial.print(";D:"); Serial.print("3"); Serial.println(";"); } } sent_button=(int)current_button; } } else { if (current_button==1) { int passed=millis()-timeButtonPressed; if ((passed>3000) && (sent_button_longlick!=1)) { sent_button_longlick=1; Serial.print(millis()/1000); Serial.print(" Button long press: "); Serial.println(current_button); Serial.print("P:"); Serial.print(random(65535)); Serial.print(";F:"); Serial.print("0"); Serial.print(";T:0;C:"); Serial.print("23"); Serial.print(";D:"); Serial.print("4"); Serial.println(";"); } } else { sent_button_longlick=0; } } if (((uptime-timeCheckedTemp)>PERIOD_READ_TEMP) || (timeCheckedTemp>uptime)) { // TEMP SENSOR 1 float current_temp=0; sensors.requestTemperatures(); current_temp=sensors.getTempCByIndex(0); if (current_temp>-100 && current_temp<50) { timeCheckedTemp=uptime; Serial.print("Temp sensor: "); Serial.println(current_temp); float diff=(float)sent_temperature-(float)current_temp; if ((abs(diff)>=TEMP_ACC) || ((uptime-timeSentTemp)>PERIOD_SEND_TEMP)) { // timeSentTemp=uptime; sent_temperature=(float)current_temp; Serial.print("P:"); Serial.print(random(65535)); Serial.print(";F:"); Serial.print("0"); Serial.print(";T:0;C:"); Serial.print("10"); Serial.print(";D:"); Serial.print((int)(current_temp*100)); Serial.println(";"); } } else { //Serial.print("Incorrect T: "); //Serial.println(current_temp); } } if (Serial.available()) { char c=Serial.read(); if (c == '\n' || c == ';') { Serial.println(inData); int commandProcessed=0; if (inData.equals("blink")) { Serial.println("BLINKING!"); blinking(3); commandProcessed=1; } if (inData.startsWith("pair")) { commandProcessed=1; inData.replace("pair",""); noolitePair(inData.toInt()); } if (inData.startsWith("on")) { commandProcessed=1; inData.replace("on",""); nooliteTurnOn(inData.toInt()); } if (inData.startsWith("off")) { commandProcessed=1; inData.replace("off",""); nooliteTurnOff(inData.toInt()); } if (inData.startsWith("switch")) { commandProcessed=1; inData.replace("switch",""); nooliteSwitch(inData.toInt()); } if (inData.startsWith("level")) { commandProcessed=1; inData.replace("level",""); int splitPosition; splitPosition=inData.indexOf('-'); if(splitPosition != -1) { String paramString=inData.substring(0,splitPosition); int channel=paramString.toInt(); inData=inData.substring(splitPosition+1,inData.length()); nooliteLevel(channel,inData.toInt()); } } if (inData.startsWith("unpair")) { commandProcessed=1; inData.replace("unpair",""); nooliteUnPair(inData.toInt()); } if (inData.startsWith("color-")) { commandProcessed=1; inData.replace("color-",""); if (inData.equalsIgnoreCase("r")) { setColor(255,0,0); } if (inData.equalsIgnoreCase("g")) { setColor(0,255,0); } if (inData.equalsIgnoreCase("b")) { setColor(0,0,255); } if (inData.equalsIgnoreCase("w")) { setColor(255,255,255); } if (inData.equalsIgnoreCase("off")) { setColor(0,0,0); } } if (commandProcessed==0) { Serial.print("Unknown command: "); Serial.println(inData); } inData=""; Serial.flush(); } else { inData += (c); } } if(ET.receiveData()) { digitalWrite(PIN_LED, HIGH); if (last_packet_id!=(int)mydata.packet_id) { Serial.print("P:"); Serial.print(mydata.packet_id); Serial.print(";F:"); Serial.print(mydata.device_id); Serial.print(";T:"); Serial.print(mydata.destination_id); Serial.print(";C:"); Serial.print(mydata.command); Serial.print(";D:"); Serial.print(mydata.data); Serial.println(";"); last_packet_id=(int)mydata.packet_id; } digitalWrite(PIN_LED, LOW); } if (mySerial.available()) Serial.write(mySerial.read()); }

बाह्य उपकरणों के साथ नियंत्रक के संचालन को होस्ट मॉड्यूल से कनेक्ट किए बिना चेक किया जा सकता है, लेकिन बस फर्मवेयर लॉन्च करने के बाद, पोर्ट मॉनिटर शुरू करें और देखें कि कंसोल में क्या प्रदर्शित होता है। यह डेटा स्ट्रीम है जो होस्ट मॉड्यूल को प्राप्त होगा, केवल यह अभी भी स्थापित नियमों के अनुसार इसका जवाब दे सकता है।

होस्ट मॉड्यूल तैयार करना (राउटर)

मैं इस लेख के ढांचे के भीतर OpenWRT सिस्टम और बाद के कॉन्फ़िगरेशन के साथ राउटर के फर्मवेयर पर ध्यान केंद्रित नहीं करूंगा - इसके बारे में जानकारी वेब पर ढूंढना आसान है। नतीजतन, हमारे पास इंटरनेट एक्सेस के साथ एक स्थानीय वाईफाई नेटवर्क के क्लाइंट मोड में एक राउटर होना चाहिए, और एक COM पोर्ट के रूप में कनेक्टेड माइक्रोकंट्रोलर को भी सही ढंग से पहचानना चाहिए।

अगला चरण हमारे राउटर का एक होस्ट मॉड्यूल में परिवर्तन है। मैंने होस्ट मॉड्यूल स्क्रिप्ट लिखने के लिए बैश दुभाषिया का उपयोग किया, जैसा कि यह मुझे काफी सुविधाजनक और सार्वभौमिक लग रहा था, अर्थात्। होस्ट मॉड्यूल प्लेटफ़ॉर्म को किसी भी विशिष्ट "आयरन" कार्यान्वयन के लिए बाध्य नहीं करना - ओपनडब्ल्यूआरटी के साथ एक राउटर के बजाय, अंतर्निहित लिनक्स के साथ कोई भी उपकरण हो सकता है, यदि केवल बैश और ड्राइवरों को माइक्रोकंट्रोलर कनेक्ट करने के लिए होगा।

होस्ट मॉड्यूल ऑपरेशन एल्गोरिथ्म को निम्नलिखित बिंदुओं द्वारा दर्शाया जा सकता है:

प्रारंभिककरण - एक बाहरी वेब सेवा (यदि उपलब्ध हो) से इस उपकरण के ऑपरेटिंग नियमों को डाउनलोड करना, साथ ही साथ एक माइक्रोबॉलर के साथ संचार चैनल स्थापित करना
नियंत्रक से डेटा प्राप्त करना और लोड किए गए नियमों के अनुसार उन्हें संसाधित करना

स्रोत कोड स्तर पर, यह इस तरह दिखता है:

सेटिंग फ़ाइल (/ect/master/settings.sh)

 MASTER_ID="AAAA-BBBB-CCCC-DDDD" ARDUINO_PORT=/dev/ttyACM0 ARDUINO_PORT_SPEED=9600 UPDATES_URL="http://connect.smartliving.ru/rules/" DATA_PATH="/etc/master/data" WEB_PATH="/www" ONLINE_CHECK_HOST="8.8.8.8" LOCAL_BASE_URL="http://connect.dev"

मुख्य प्रसंस्करण स्क्रिप्ट फ़ाइल (/etc/master/cycle.sh)

 #!/bin/bash # settings . /etc/master/settings.sh # STEP 0 # wait to be online COUNTER=0 while [ $COUNTER -lt 5 ]; do ping -c 1 $ONLINE_CHECK_HOST if [[ $? = 0 ]]; then echo Network available. break; else echo Network not available. Waiting... sleep 5 fi let COUNTER=COUNTER+1 done #--------------------------------------------------------------------------- # START if [ ! -d "$DATA_PATH" ]; then mkdir $DATA_PATH chmod 0666 $DATA_PATH fi while : do #--------------------------------------------------------------------------- # Downloading the latest rules from the web echo Getting rules from $UPDATES_URL?id=$MASTER_ID wget -O $DATA_PATH/rules_set.tmp $UPDATES_URL?id=$MASTER_ID if grep -Fq "Rules set" $DATA_PATH/rules_set.tmp then mv $DATA_PATH/rules_set.tmp $DATA_PATH/rules_set.sh else echo Incorrect rules file fi #--------------------------------------------------------------------------- # Reading all data and sending to the web ALL_DATA_FILE=$DATA_PATH/all_data.txt rm -f $ALL_DATA_FILE echo -n id=$MASTER_ID>>$ALL_DATA_FILE echo -n "&data=">>$ALL_DATA_FILE FILES=$DATA_PATH/*.dat for f in $FILES do #echo "Processing $f file..." OLD_DATA=`cat $f` fname=${f##*/} PARAM=${fname/.dat/} echo -n "$PARAM|$OLD_DATA;">>$ALL_DATA_FILE done ALL_DATA=`cat $ALL_DATA_FILE` echo Posting: $UPDATES_URL?$ALL_DATA wget -O $DATA_PATH/data_post.tmp $UPDATES_URL?$ALL_DATA rm -f $DATA_PATH/*.dat #--------------------------------------------------------------------------- # Downloading the latest menu from the web echo Getting menu from $UPDATES_URL/menu2.php?download=1\&id=$MASTER_ID wget -O $DATA_PATH/menu.tmp $UPDATES_URL/menu2.php?download=1\&id=$MASTER_ID if grep -Fq "stylesheet" $DATA_PATH/menu.tmp then mv $DATA_PATH/menu.tmp $WEB_PATH/menu.html else echo Incorrect menu file fi #--------------------------------------------------------------------------- START_TIME="$(date +%s)" # main cycle stty -F $ARDUINO_PORT ispeed $ARDUINO_PORT_SPEED ospeed $ARDUINO_PORT_SPEED cs8 ignbrk -brkint -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts #--------------------------------------------------------------------------- while read LINE; do echo $LINE PASSED_TIME="$(($(date +%s)-START_TIME))" # Processing incoming URLs from controller REGEX='^GET (.+)$' if [[ $LINE =~ $REGEX ]] then URL=$LOCAL_BASE_URL${BASH_REMATCH[1]} #-URL=$LOCAL_BASE_URL wget -O $DATA_PATH/http.tmp $URL echo Getting URL echo $URL fi PACKET_ID="" DATA_FROM="" DATA_TO="" DATA_COMMAND="" DATA_VALUE="" REGEX='^P:([0-9]+);F:([0-9]+);T:([0-9]+);C:([0-9]+);D:([0-9]+);$' if [[ $LINE =~ $REGEX ]] then PACKET_ID=${BASH_REMATCH[1]} DATA_FROM=${BASH_REMATCH[2]} DATA_TO=${BASH_REMATCH[3]} DATA_COMMAND=${BASH_REMATCH[4]} DATA_VALUE=${BASH_REMATCH[5]} DATA_FILE=$DATA_PATH/$DATA_FROM-$DATA_COMMAND.dat echo -n $DATA_VALUE>$DATA_FILE fi if [ -f $DATA_PATH/incoming_data.txt ]; then echo "New incoming data:"; echo `cat $DATA_PATH/incoming_data.txt` cat $DATA_PATH/incoming_data.txt>$ARDUINO_PORT rm -f $DATA_PATH/incoming_data.txt fi ACTION_RECEIVED="" if [ -f $DATA_PATH/incoming_action.txt ]; then ACTION_RECEIVED=`cat $DATA_PATH/incoming_action.txt` echo "New incoming action: $ACTION_RECEIVED" rm -f $DATA_PATH/incoming_action.txt fi . $DATA_PATH/rules_set.sh if [ -f $DATA_PATH/reboot ]; then echo "REBOOT FLAG" rm -f $DATA_PATH/reboot break; fi done < $ARDUINO_PORT done #--------------------------------------------------------------------------- echo Cycle stopped.

सेटिंग्स में आप देख सकते हैं कि डिवाइस में एक विशिष्ट पहचानकर्ता (MASTER_ID) है, जिसका उपयोग वेब सेवा के साथ बातचीत करने के लिए किया जाता है (मुझे याद है कि इसके लिए स्थायी कनेक्शन होना आवश्यक नहीं है)।

मुख्य स्क्रिप्ट के काम के दौरान, लोड किए गए नियम कोड को संग्रहीत करने के लिए निर्देशिका / आदि / मास्टर / डेटा / का उपयोग किया जाता है, नवीनतम सेंसर रीडिंग के मूल्यों के साथ-साथ नियम प्रणाली के कुछ निर्माणों पर काम करने के लिए (उदाहरण के लिए, टाइमर)।

इस लिंक पर फाइलों का एक पूरा सेट डाउनलोड किया जा सकता है।

नियम व्यवस्था

नियम प्रणाली को सामान्य शब्दों में ऊपर उल्लिखित किया गया था, इसलिए यहां मैं इसे थोड़ा और विस्तार से बताऊंगा। वास्तव में, प्रत्येक नियम बैश निर्देशों का एक सेट है। इस सेट का पहला भाग, चलो इसे एक्टिवेटर कहते हैं, इस नियम के अनुपालन के लिए आने वाले डेटा की जांच करता है, और दूसरा भाग (ठेकेदार) सीधे कुछ कार्य करता है।

नियम को सक्रिय करने की संभावित शर्तें:

माइक्रोकंट्रोलर से एक विशिष्ट प्रारूप की एक स्ट्रिंग प्राप्त करना
आंतरिक (बटन, गति, तापमान) या बाहरी (वायरलेस) सेंसर से एक निश्चित प्रारूप की एक कमांड प्राप्त करना
एपीआई या किसी अन्य नियम के माध्यम से "मैनुअल" सक्रियण (स्क्रिप्ट चलाना)

संभावित क्रियाएं:

एक वैरिएबल मान सेट करना
सेंसर कंट्रोलर के लिए एक लाइन / कमांड भेजना (आंतरिक प्रसंस्करण के लिए या किसी बाहरी डिवाइस के लिए)
HTTP एक बाहरी वेब सिस्टम से अनुरोध करता है
रनिंग शेल कमांड (लिनक्स)
स्क्रिप्ट रन
विलंबित टाइमर कार्रवाई

नियम स्रोत कोड उदाहरण

 # RULE 2 Forwarder RCSwitch (regex) MATCHED_RULE2='0' REGEX='^RCSwitch:(.+)$' if [[ $LINE =~ $REGEX ]] then MATCHED_RULE2="1" fi # RULE 2 ACTIONS if [[ "$MATCHED_RULE2" == "1" ]] then #Action 2.1 (http) echo "HTTP request: http://192.168.0.17/objects/?script=RCSwitch&rcswitch=${BASH_REMATCH[1]}" wget -O $DATA_PATH/http.tmp http://192.168.0.17/objects/?script=RCSwitch\&rcswitch=${BASH_REMATCH[1]} fi

वेब सिस्टम में डिवाइस को पंजीकृत करने के बाद उपयोगकर्ता के व्यक्तिगत खाते के माध्यम से नियमों को कॉन्फ़िगर किया गया है (अब पूरे सर्वर घटक को connect.smartliving.ru परियोजना के हिस्से के रूप में लागू किया गया है)। आपको इस मामले में प्रोग्राम करने की आवश्यकता नहीं है, वेब सिस्टम स्वयं उपयोगकर्ता-परिभाषित नियमों को बैश कमांड में परिवर्तित करता है। उपयोगकर्ता पक्ष पर, कॉन्फ़िगरेशन इंटरफ़ेस कुछ इस तरह दिखता है:

इंटरफ़ेस और एपीआई

सिद्धांत रूप में, उपरोक्त एक स्वायत्त मॉड्यूल बनाने के लिए पर्याप्त है, हालांकि, इच्छा सूची लंबी थी, जैसा कि कार्यान्वयन का मार्ग था। अगला कदम एक वेब इंटरफेस और एपीआई बनाना था। यह कदम पिछले वाले की तुलना में पर्याप्त जटिल नहीं है, और इसे एक समान सिद्धांत के अनुसार लागू किया गया था। होस्ट डिवाइस पर पहले से ही एक वेब सर्वर है, इसलिए एपीआई को लागू करने के लिए एक और बैश स्क्रिप्ट बनाई गई और / www / cgi-bin / मास्टर में रखी गई

स्क्रिप्ट स्रोत कोड / www / cgi-bin / मास्टर

 #!/bin/bash DATA_PATH="/etc/master/data" echo "Content-type: text/plain" echo "" # Save the old internal field separator. OIFS="$IFS" # Set the field separator to & and parse the QUERY_STRING at the ampersand. IFS="${IFS}&" set $QUERY_STRING Args="$*" IFS="$OIFS" # Next parse the individual "name=value" tokens. ARG_VALUE="" ARG_VAR="" ARG_OP="" ARG_LINE="" for i in $Args ;do # Set the field separator to = IFS="${OIFS}=" set $i IFS="${OIFS}" case $1 in # Don't allow "/" changed to " ". Prevent hacker problems. var) ARG_VAR="`echo -n $2 | sed 's|[\]||g' | sed 's|%20| |g'`" ;; # value) ARG_VALUE=$2 ;; line) ARG_LINE=$2 ;; op) ARG_OP=$2 ;; *) echo "<hr>Warning:"\ "<br>Unrecognized variable \'$1\' passed.<hr>" ;; esac done # Set value #ARG_OP="set" #echo $ARG_OP if [[ "$ARG_OP" == "set" ]] then # echo "Set operation<br>" echo -n "$ARG_VALUE">$DATA_PATH/$ARG_VAR.dat echo "OK" fi if [[ "$ARG_OP" == "get" ]] then # echo "Get operation<br>" cat $DATA_PATH/$ARG_VAR.dat fi if [[ "$ARG_OP" == "send" ]] then # echo "Send<br>" echo -n $ARG_LINE>>$DATA_PATH/incoming_data.txt echo "OK" fi if [[ "$ARG_OP" == "action" ]] then # echo "Action<br>" echo -n $ARG_LINE>>$DATA_PATH/incoming_action.txt echo "OK" fi if [[ "$ARG_OP" == "refresh" ]] then # echo "Send<br>" echo "Web">$DATA_PATH/reboot echo "OK" fi if [[ "$ARG_OP" == "run" ]] then # echo "Run<br>" echo `$ARG_LINE` fi

यह स्क्रिप्ट निम्नलिखित एपीआई आदेश प्रदान करती है:

एक वैरिएबल मान सेट करना

_/cgi-bin/master?op=set&var=Variable1&value=Value1

Variable1 के मान को मान 1 पर सेट करता है

एक चर का मूल्य प्राप्त करना

_/cgi-bin/master?op=get&var=Variable1

Variable1 का मान लौटाता है

नियंत्रक को डेटा भेजना

_/cgi-bin/master?op=send&line=SomeData

जुड़े नियंत्रक के लिए SomeData स्ट्रिंग भेजता है

क्रिया सक्रियण

_/cgi-bin/master?op=action&line=SomeAction

नियमों में वर्णित SomeAction कार्रवाई को प्रारंभ करता है (प्रकार "सक्रिय क्रियाएँ")

नियमों का बल अद्यतन

_/cgi-bin/master?op=refresh

डिवाइस को रिबूट किए बिना नियमों और वेब इंटरफेस के अपडेट (डाउनलोडिंग) को मजबूर करता है

सिस्टम टीम

_/cgi-bin/master?op=run&line=SomeCommand

सिस्टम शेल में SomeCommand के निष्पादन को प्रारंभ करता है (उदाहरण के लिए, "रिबूट" का उपयोग करके डिवाइस को पुनरारंभ किया जाएगा)

एपीआई के बाद एक वेब इंटरफेस था। उसके साथ उसी तरह से व्यवहार किया गया जैसे कि नियमों के साथ - हम इसे वेब सेवा पर कॉन्फ़िगर करते हैं और इसे उसी आरंभीकरण चरण में डिवाइस पर अपडेट करते हैं। यहाँ एक उपकरण के लिए एक नियंत्रण मेनू बनाने के लिए इंटरफ़ेस है:

पहिया को सुदृढ़ नहीं करने के लिए, हल्के क्रैकन फ्रंटेंड फ्रेमवर्क को / www / क्रैकन-मास्टर फ़ोल्डर में गिरा दिया गया था। आरंभीकरण के बाद, menu.html फ़ाइल / www / फ़ोल्डर में दिखाई देती है और, तदनुसार, आप हमारे कॉन्फ़िगर किए गए वेब इंटरफ़ेस तक पहुंच सकते हैं _/menu.html

_/menu.html

इस प्रकार का पता संयोग से नहीं चुना गया था, लेकिन मेजरड्रोइड मोबाइल एप्लिकेशन (एंड्रॉइड प्लेटफॉर्म के लिए) के साथ संगतता के लिए यह एक छोटा सा विवरण है, लेकिन मैं सार्वभौमिकता और सब कुछ और सब कुछ की अनुकूलता के लिए हूं, इसलिए नहीं।

ऑनलाइन कार्य

"उह, ठीक है, और प्रणाली बदल जाती है और यह सब नहीं है?" - आप पूछते हैं। खैर, लगभग, बस थोड़ा रह गया। अधिक सटीक रूप से, उपयोगकर्ता के लिए एक "छोटा", लेकिन डेवलपर के लिए एक बड़ा मंच (जैसा कि अक्सर होता है)। अर्थात् - इंटरनेट के माध्यम से डिवाइस के साथ काम करते हैं। ऐसा लगता है कि राउटर पर एक वेब इंटरफेस, फॉरवर्ड पोर्ट हैं और आपके स्वास्थ्य का आनंद लेते हैं। लेकिन ये हमारे तरीके नहीं हैं, हमारे तरीके दूसरों के जीवन को सरल बनाने में हैं (और खुद को उलझाना)। मान लीजिए कि सबसे खराब है - राउटर की सेटिंग्स को बदलने और आगे पोर्ट बनाने का कोई तरीका नहीं है। या यह एक ही नेटवर्क पर कई समान उपकरणों का उपयोग करना चाहिए और प्रत्येक (काल्पनिक रूप से) बाहर से पहुंच बनाने में सक्षम होना चाहता है। समाधान यह था कि डेटा और आदेशों के आदान-प्रदान के लिए डिवाइस को स्वयं एक बाहरी सर्वर के साथ एक चैनल शुरू करना चाहिए और उसे बनाए रखना चाहिए, जबकि बाहरी सर्वर ने एक विशेष उपकरण के लिए निर्दिष्ट वेब इंटरफ़ेस को दोहराया और इस चैनल के माध्यम से उपयोगकर्ता से आदेशों के हस्तांतरण का आयोजन किया। एक चैनल एक सॉकेट कनेक्शन है, जो एक तरफ (डिवाइस पर) एक अलग बैश स्क्रिप्ट बनाता है और दूसरी तरफ (सर्वर पर) एक सॉकेट सर्वर।

डिवाइस पर, स्क्रिप्ट / etc / master / socket_client में स्थित है

स्क्रिप्ट स्रोत कोड / आदि / मास्टर / सॉकेट_क्लियर

 #!/bin/bash # settings . /etc/master/settings.sh # STEP 0 # wait to be online COUNTER=0 while [ $COUNTER -lt 5 ]; do ping -c 1 $ONLINE_CHECK_HOST if [[ $? = 0 ]]; then echo Network available. break; else echo Network not available. Waiting... sleep 5 fi let COUNTER=COUNTER+1 done #--------------------------------------------------------------------------- # START if [ ! -d "$DATA_PATH" ]; then mkdir $DATA_PATH chmod 0666 $DATA_PATH fi while : do TEST_FILE=$DATA_PATH/data_sent.txt touch $TEST_FILE SOCKET_HOST=connect.smartliving.ru SOCKET_PORT=11444 exec 3<>/dev/tcp/$SOCKET_HOST/$SOCKET_PORT NOW=$(date +"%H:%M:%S") echo -n $NOW echo " Sending: Hello!" echo "Hello!">&3 read -t 60 ok <&3 NOW=$(date +"%H:%M:%S") echo -n $NOW echo -n " Received: " echo "$ok"; REGEX='^Please' if [[ ! $ok =~ $REGEX ]] then NOW=$(date +"%H:%M:%S") echo -n $NOW echo " Connection failed!" continue fi NOW=$(date +"%H:%M:%S") echo -n $NOW echo " Sending: auth:$MASTER_ID" echo "auth:$MASTER_ID">&3 read -t 60 ok <&3 NOW=$(date +"%H:%M:%S") echo -n $NOW echo -n " Received: " echo "$ok"; REGEX='^Authorized' if [[ ! $ok =~ $REGEX ]] then NOW=$(date +"%H:%M:%S") echo -n $NOW echo " Authorization failed!" exit 0 fi NOW=$(date +"%H:%M:%S") echo -n $NOW echo " Sending: Hello again!" echo "Hello again!">&3 read -t 60 ok <&3 NOW=$(date +"%H:%M:%S") echo -n $NOW echo -n " Received: " echo "$ok"; while read -t 120 LINE; do NOW=$(date +"%H:%M:%S") echo -n $NOW echo -n " Got line: " echo $LINE # Ping reply REGEX='^PING' if [[ $LINE =~ $REGEX ]] then echo -n $NOW echo " Sending: PONG!" echo PONG!>&3 fi # Run action REGEX='^ACTION:(.+)$' if [[ $LINE =~ $REGEX ]] then DATA_RECEIVED=${BASH_REMATCH[1]} NOW=$(date +"%H:%M:%S") echo -n $NOW echo -n " Action received: " echo $DATA_RECEIVED echo -n $DATA_RECEIVED>>$DATA_PATH/incoming_action.txt fi # Pass data REGEX='^DATA:(.+)$' if [[ $LINE =~ $REGEX ]] then DATA_RECEIVED=${BASH_REMATCH[1]} echo -n $NOW echo -n " Data received: " echo $DATA_RECEIVED echo -n $DATA_RECEIVED>>$DATA_PATH/incoming_data.txt fi # Pass data REGEX='^URL:(.+)$' if [[ $LINE =~ $REGEX ]] then DATA_RECEIVED=${BASH_REMATCH[1]} echo -n $NOW echo -n " URL received: " echo wget -O $DATA_PATH/data_post.tmp http://localhost$DATA_RECEIVED fi # Check files modified FILES=$DATA_PATH/*.dat for f in $FILES do if [ $f -nt $TEST_FILE ]; then echo "Processing $f ..." FNAME=${f##*/} PARAM=${FNAME/.dat/} CONTENT=`cat $f` echo -n $NOW echo " Sending: DATA:$PARAM|$CONTENT;" echo "data:$PARAM|$CONTENT;">&3 fi done touch $TEST_FILE done <&3 done #--------------------------------------------------------------------------- echo Cycle stopped.

डिवाइस के साथ काम करने के लिए एक लिंक और एक QR कोड उसके खाते से उपयोगकर्ता के लिए उपलब्ध है। नीचे एक परीक्षण मामला:

भविष्य की चुनौतियां

संपूर्ण वर्णित निर्माण काफी महत्वपूर्ण रूप से काम करता है - शायद लॉन्च होने के कुछ महीने पहले ही हो चुके हैं और जिस समय मैंने लेख लिखने का फैसला किया है, और डिवाइस ठीक से काम कर रहा है। हालांकि, सब कुछ लागू किया जाता है, जैसा कि वे कहते हैं, बिना तामझाम के। अवधारणा को सत्यापित करने के लिए, यह पर्याप्त है, लेकिन इस (या समान) मंच पर उपकरणों के बड़े पैमाने पर परिचय के लिए, मैं निम्नलिखित क्षेत्रों में काम करूंगा:

सुरक्षा (एन्क्रिप्शन, इंटरफेस के लिए पासवर्ड, आदि)
सर्वर साइड पर प्रदर्शन (हालांकि अभी तक कोई समस्या नहीं थी, लेकिन एक घर-निर्मित सॉकेट सर्वर सर्वोत्तम कार्यान्वयन विकल्प से बहुत दूर है)
यूआई / यूएक्स (डिवाइस के लिए और व्यक्तिगत खाते के लिए दोनों)
आयरन ("अरुडिनो! राउटर! मैं आपसे विनती करता हूं ...")

निष्कर्ष

सभी ट्यूनिंग विवरणों को लेख में वर्णित नहीं किया गया है और कुछ चीजें, जैसे कि ऑटोरुन स्क्रिप्ट सेटिंग्स, मैं जानबूझकर छोड़ा गया, मुख्य विशेषताओं और अवधारणा का सार बताने की कोशिश कर रहा हूं।

विशेष रूप से, यह उपकरण और इसके निर्माण की पूरी प्रक्रिया व्यक्तिगत घटकों और प्रौद्योगिकियों के संचालन का परीक्षण करने के लिए एक प्रयोग था। इस प्रक्रिया में, विचार उत्पन्न हुए और अन्य उपकरणों और प्रणालियों में सन्निहित हुए, और कुछ इस परियोजना के लिए बाहर से चले गए, इसलिए सामान्य तौर पर यह समय कुछ भी नहीं था। मुझे खुशी होगी अगर मेरा कार्यान्वयन अनुभव उपयोगी है।

यदि हम अवधारणा के व्यावसायिक अनुप्रयोग के विषय को विकसित करते हैं, तो हम कम सार्वभौमिक के बारे में बात कर सकते हैं, बल्कि, लागू किए गए कार्यान्वयन। उदाहरण के लिए:

घर का चौकीदार - मालिक को सूचित करता है कि कोई घर आ गया है और कमरे का तापमान
प्रकाश नियंत्रक - अनुसूचित / घटना प्रकाश नियंत्रण
जलवायु नियंत्रण - बाहरी तापमान / आर्द्रता सेंसर से जानकारी प्राप्त करना और एक्ट्यूएटर्स को नियंत्रित करना
कल्याण नियंत्रण - जब आप "अलार्म" बटन दबाते हैं या लंबे समय तक आंदोलन की अनुपस्थिति में एक अधिसूचना भेजते हैं

इस प्रकार, एक ही आधार होने से, आप उच्च स्तर पर सूचना प्रणालियों के साथ समान "इंटरनेट चीजों" को एकीकृत करके कई "बॉक्सिंग" समाधान बना सकते हैं।

पुनश्च मैंने लंबे समय से सोचा था कि परिणामी डिवाइस का "लाइव" फोटो अपलोड करना है, लेकिन मैंने पहले ही पूरे उपक्रम की प्रायोगिक प्रकृति के बारे में चेतावनी दी है, इसलिए कार्डबोर्ड मामला (या यदि आप चाहें तो इसका लेआउट) काफी सुसंगत है:

पीपीएस I लगभग भूल गया, सभी सूचीबद्ध घटकों के साथ इस उपकरण की लागत $ 60 के आसपास आती है, खर्च किया गया समय अमूल्य है।

दो-अपने आप स्मार्ट प्वाइंट या "इंटरनेट चीज"