स्मार्ट होम: होम असिस्टेंट में पानी और बिजली की खपत का चार्ट बनाना

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

मैंने हाल ही में अपने स्मार्ट होम सिस्टम के रूप में होम असिस्टेंट पर स्विच किया है। इसका एक कारण विभिन्न प्रकार के ग्राफ़ को आसानी से बनाने की क्षमता के साथ बड़ी मात्रा में डेटा के संग्रह को व्यवस्थित करने का अवसर था।

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

समस्या का निरूपण

तो, आज के अभ्यास का लक्ष्य पानी और बिजली की खपत का सुंदर ग्राफ़ प्राप्त करना है:

• 2 दिनों के लिए प्रति घंटा
• 2 सप्ताह तक प्रतिदिन
• (वैकल्पिक) साप्ताहिक और मासिक

इसमें कुछ कठिनाइयाँ हैं:

• मानक चार्ट घटक काफी ख़राब होते हैं। ज़्यादा से ज़्यादा, आप बिंदुओं के आधार पर एक रेखा ग्राफ़ बना सकते हैं।

  यदि आप अच्छी तरह से खोजते हैं, तो आप तृतीय-पक्ष घटक पा सकते हैं जो मानक चार्ट की क्षमताओं का विस्तार करते हैं। घरेलू सहायक के लिए, सिद्धांत रूप में, एक अच्छा और सुंदर घटक मिनी ग्राफ कार्ड, लेकिन यह कुछ हद तक सीमित भी है:

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

  {"entity_id": "sensor.water_cold_hourly", "old_state": {"entity_id": "sensor.water_cold_hourly", "state": "3", "attributes": {"source": "sensor.water_meter_cold", "status": "collecting", "last_period": "29", "last_reset": "2020-02-23T21:00:00.022246+02:00", "meter_period": "hourly", "unit_of_measurement": "l", "friendly_name": "water_cold_hourly", "icon": "mdi:counter"}, "last_changed": "2020-02-23T19:05:06.897604+00:00", "last_updated": "2020-02-23T19:05:06.897604+00:00", "context": {"id": "aafc8ca305ba4e49ad4c97f0eddd8893", "parent_id": null, "user_id": null}}, "new_state": {"entity_id": "sensor.water_cold_hourly", "state": "4", "attributes": {"source": "sensor.water_meter_cold", "status": "collecting", "last_period": "29", "last_reset": "2020-02-23T21:00:00.022246+02:00", "meter_period": "hourly", "unit_of_measurement": "l", "friendly_name": "water_cold_hourly", "icon": "mdi:counter"}, "last_changed": "2020-02-23T19:11:11.251545+00:00", "last_updated": "2020-02-23T19:11:11.251545+00:00", "context": {"id": "0de64b8af6f14bb9a419dcf3b200ef56", "parent_id": null, "user_id": null}}}

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

• यदि आप भाग्यशाली हैं, तो आपका मीटर स्वयं खपत की गणना कर सकता है। आप किसी भी समय मीटर से संपर्क कर सकते हैं और पूछ सकते हैं कि संचित खपत मूल्य किस समय है। एक नियम के रूप में, डिजिटल इंटरफ़ेस (RS232/RS485/Modbus/Zigbee) वाले सभी बिजली मीटर ऐसा अवसर प्रदान करते हैं।

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

दृष्टिकोण 1

सबसे पहले, आइए देखें कि बॉक्स से बाहर कौन सा होम असिस्टेंट उपलब्ध कराया जाता है। एक अवधि में खपत को मापना एक अत्यधिक अनुरोधित कार्यक्षमता है। बेशक, इसे बहुत समय पहले एक विशेष घटक - यूटिलिटी_मीटर के रूप में लागू किया गया था।

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

utility_meter:
  water_cold_hour_um:
    source: sensor.water_meter_cold
    cycle: hourly
  water_cold_day_um:
    source: sensor.water_meter_cold
    cycle: daily

यहां Sensor.water_meter_cold मीटर का वर्तमान मूल्य लीटर में है जो मुझे मिलता है सीधे लोहे के टुकड़े से mqtt द्वारा. डिज़ाइन 2 नए सेंसर वॉटर_कोल्ड_आवर_उम और वॉटर_कोल्ड_डे_उम बनाता है, जो प्रति घंटा और दैनिक रीडिंग जमा करते हैं, अवधि समाप्त होने के बाद उन्हें शून्य पर रीसेट कर देते हैं। यहां आधे दिन की प्रति घंटा बैटरी का ग्राफ दिया गया है।

लवलेस-यूआई के लिए प्रति घंटा और दैनिक चार्ट कोड इस तरह दिखता है:

      - type: history-graph
        title: 'Hourly water consumption using vars'
        hours_to_show: 48
        entities:
          - sensor.water_hour

      - type: history-graph
        title: 'Daily water consumption using vars'
        hours_to_show: 360
        entities:
          - sensor.water_day

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

इसके अलावा, उपयोगिता मीटर स्वयं समस्या का समाधान नहीं करता है। उपयोगिता मीटर प्लॉट एक नीरस रूप से बढ़ने वाला फ़ंक्शन है जो हर घंटे 0 पर रीसेट हो जाता है। हमें एक उपयोगकर्ता-अनुकूल उपभोग कार्यक्रम की भी आवश्यकता है, इस अवधि के दौरान कितने लीटर खाया गया। मानक इतिहास-ग्राफ़ घटक ऐसा नहीं करता है, लेकिन बाहरी मिनी-ग्राफ़-कार्ड घटक हमारी सहायता कर सकता है।

यह लवलेस-यूआई के लिए कार्ड कोड है:

      - aggregate_func: max
        entities:
          - color: var(--primary-color)
            entity: sensor.water_cold_hour_um
        group_by: hour
        hours_to_show: 48
        name: "Hourly water consumption aggregated by utility meter"
        points_per_hour: 1
        show:
          graph: bar
        type: 'custom:mini-graph-card'

सेंसर नाम, ग्राफ़ प्रकार, रंग (मुझे मानक नारंगी पसंद नहीं आया) जैसी मानक सेटिंग्स के अलावा, यहां 3 सेटिंग्स नोट करना महत्वपूर्ण है:

• ग्रुप_बाय:घंटा - ग्राफ़ घंटे की शुरुआत में संरेखित बार के साथ उत्पन्न होगा
• अंक_प्रति_घंटा: 1 - प्रति घंटा एक बार
• और सबसे महत्वपूर्ण बात, Aggregate_func: max प्रत्येक घंटे के भीतर अधिकतम मूल्य लेना है। यह वह पैरामीटर है जो सॉटूथ चार्ट को बार में बदल देता है।

बाईं ओर स्तंभों की पंक्ति पर ध्यान न दें - यदि कोई डेटा नहीं है तो यह घटक का मानक व्यवहार है। लेकिन कोई डेटा नहीं था - मैंने केवल इस लेख के लिए कुछ घंटे पहले उपयोगिता मीटर डेटा संग्रह चालू किया था (मैं नीचे अपने वर्तमान दृष्टिकोण का वर्णन करूंगा)।

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

सामान्य तौर पर, मैं इस दृष्टिकोण की प्रशंसनीयता हासिल करने में असमर्थ था - ग्राफ़ लगभग हमेशा किसी न किसी प्रकार का विधर्म दिखाता है।

दिन के समय सेंसर के लिए समान कोड।

      - aggregate_func: max
        entities:
          - color: var(--primary-color)
            entity: sensor.water_cold_day_um
        group_by: interval
        hours_to_show: 360
        name: "Daily water consumption aggregated by utility meter"
        points_per_hour: 0.0416666666
        show:
          graph: bar
        type: 'custom:mini-graph-card'

कृपया ध्यान दें कि ग्रुप_बाय पैरामीटर अंतराल पर सेट है, और पॉइंट_पर_आवर पैरामीटर सब कुछ नियंत्रित करता है। और इसमें इस घटक के साथ एक और समस्या है - पॉइंट_पर_आवर एक घंटे या उससे कम के चार्ट पर अच्छा काम करता है, लेकिन यह बड़े अंतराल पर बेकार है। इसलिए एक दिन में एक कॉलम प्राप्त करने के लिए, मुझे मान 1/24=0.04166666 दर्ज करना होगा। मैं साप्ताहिक और मासिक चार्ट के बारे में भी बात नहीं कर रहा हूँ।

दृष्टिकोण 2

गृह सहायक का पता लगाने के दौरान ही मेरी नजर इस वीडियो पर पड़ी:

एक मित्र कई प्रकार के Xiaomi सॉकेट से उपभोग डेटा एकत्र करता है। उनका कार्य थोड़ा सरल है - बस आज, कल और महीने के लिए उपभोग मूल्य प्रदर्शित करें। किसी शेड्यूल की आवश्यकता नहीं है.

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

वीडियो से, हम एक अवधि के लिए मैन्युअल रूप से खपत की गणना करने का विचार लेंगे। एक आदमी के लिए, केवल आज और कल के मूल्यों पर विचार किया जाता है, लेकिन हम और आगे बढ़ेंगे और एक ग्राफ बनाने का प्रयास करेंगे। मेरे मामले में प्रस्तावित पद्धति का सार इस प्रकार है।

हम एक वेरिएबल value_at_the_beginning_of_hour बनाएंगे, जिसमें हम वर्तमान काउंटर रीडिंग लिखेंगे
टाइमर का उपयोग करके, घंटे के अंत में (या अगले की शुरुआत में) हम वर्तमान रीडिंग और घंटे की शुरुआत में संग्रहीत रीडिंग के बीच अंतर की गणना करते हैं। यह अंतर वर्तमान घंटे के लिए खपत होगा - हम मूल्य को सेंसर में सहेजेंगे, और भविष्य में हम इस मूल्य के आधार पर एक ग्राफ बनाएंगे।
आपको वहां काउंटर का वर्तमान मान लिखकर वैरिएबल value_at_beginning_of_hour को "रीसेट" करने की भी आवश्यकता है।

यह सब गृह सहायक के माध्यम से ही किया जा सकता है।

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

- platform: mqtt
  state_topic: "test/water/hour"
  name: water_hour
  unit_of_measurement: l

- platform: mqtt
  state_topic: "test/water/hour_begin"
  name: water_hour_begin
  unit_of_measurement: l

- platform: mqtt
  state_topic: "test/water/day"
  name: water_day
  unit_of_measurement: l

- platform: mqtt
  state_topic: "test/water/day_begin"
  name: water_day_begin
  unit_of_measurement: l

सारा जादू स्वचालन में होता है, जो क्रमशः हर घंटे और हर रात चलता है।

- id: water_new_hour
  alias: water_new_hour
  initial_state: true
  trigger:
    - platform: time_pattern
      minutes: 0
  action:
    - service: mqtt.publish
      data:
        topic: "test/water/hour"
        payload_template: >
          {{ (states.sensor.water_meter_cold.state|int) - (states.sensor.water_hour_begin.state|int) }}
        retain: true
    - service: mqtt.publish
      data:
        topic: "test/water/hour_begin"
        payload_template: >
          {{ states.sensor.water_meter_cold.state }}
        retain: true

- id: water_new_day
  alias: water_new_day
  initial_state: true
  trigger:
    - platform: time
      at: "00:00:00"
  action:
    - service: mqtt.publish
      data:
        topic: "test/water/day"
        payload_template: >
          {{ (states.sensor.water_meter_cold.state|int) - (states.sensor.water_day_begin.state|int) }}
        retain: true
    - service: mqtt.publish
      data:
        topic: "test/water/day_begin"
        payload_template: >
          {{ states.sensor.water_meter_cold.state }}
        retain: true

दोनों ऑटोमेशन 2 काम करते हैं:

• आरंभ और अंत मान के बीच अंतर के रूप में प्रति अंतराल मान की गणना करें
• अगले अंतराल के लिए आधार मान अपडेट करें

इस मामले में ग्राफ़ का निर्माण सामान्य इतिहास-ग्राफ़ द्वारा हल किया जाता है:

      - type: history-graph
        title: 'Hourly water consumption using vars'
        hours_to_show: 48
        entities:
          - sensor.water_hour

      - type: history-graph
        title: 'Daily water consumption using vars'
        hours_to_show: 360
        entities:
          - sensor.water_day

ऐसा लगता है:

सिद्धांत रूप में, यह पहले से ही आवश्यक है। इस पद्धति का लाभ यह है कि डेटा प्रति अंतराल में एक बार उत्पन्न होता है। वे। एक घंटे के चार्ट के लिए प्रति दिन केवल 24 रिकॉर्ड।

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

दृष्टिकोण 3

सौभाग्य से, स्मार्ट लोगों ने InfluxDB डेटाबेस लिखकर पहले ही इस समस्या को हल कर लिया है। यह डेटाबेस समय-आधारित डेटा संग्रहीत करने के लिए विशेष रूप से अनुकूलित है और विभिन्न सेंसर के मूल्यों को संग्रहीत करने के लिए आदर्श है। सिस्टम एक SQL-जैसी क्वेरी भाषा भी प्रदान करता है जो आपको डेटाबेस से मान निकालने और फिर उन्हें विभिन्न तरीकों से एकत्रित करने की अनुमति देता है। अंततः, अलग-अलग डेटा को अलग-अलग समय के लिए संग्रहीत किया जा सकता है। उदाहरण के लिए, तापमान या आर्द्रता जैसी बार-बार बदलती रीडिंग को केवल कुछ हफ्तों के लिए संग्रहीत किया जा सकता है, जबकि दैनिक पानी की खपत की रीडिंग को पूरे वर्ष के लिए संग्रहीत किया जा सकता है।

InfluxDB के अलावा, स्मार्ट लोगों ने Grafana का भी आविष्कार किया, जो InfluxDB के डेटा के आधार पर ग्राफ़ बनाने की एक प्रणाली है। ग्राफाना विभिन्न प्रकार के ग्राफ़ बना सकता है, उन्हें विस्तार से कस्टमाइज़ कर सकता है, और, सबसे महत्वपूर्ण बात यह है कि इन ग्राफ़ को लवलेस-यूआई होम असिस्टेंट पर "प्लग" किया जा सकता है।

प्रेरित होना यहां и यहां. आलेखों में InfluxDB और Grafana को होम असिस्टेंट में स्थापित करने और कनेक्ट करने की प्रक्रिया का विस्तार से वर्णन किया गया है। मैं अपनी विशिष्ट समस्या को हल करने पर ध्यान केंद्रित करूंगा।

तो, सबसे पहले, आइए influxDB में काउंटर वैल्यू जोड़ना शुरू करें। गृह सहायक विन्यास का एक टुकड़ा (इस उदाहरण में, मैं न केवल ठंडे, बल्कि गर्म पानी का भी आनंद लूंगा):

influxdb:
  host: localhost
  max_retries: 3
  default_measurement: state
  database: homeassistant
  include:
    entities:
      - sensor.water_meter_hot
      - sensor.water_meter_cold

आइए होम असिस्टेंट आंतरिक डेटाबेस में उसी डेटा की बचत को अक्षम करें, ताकि इसे एक बार फिर से न बढ़ाया जाए:

recorder:
  purge_keep_days: 10
  purge_interval: 1
  exclude:
    entities:
      - sensor.water_meter_hot
      - sensor.water_meter_cold

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

CREATE RETENTION POLICY "month" ON "homeassistant" DURATION 30d REPLICATION 1
CREATE RETENTION POLICY "year" ON "homeassistant" DURATION 52w REPLICATION 1
CREATE RETENTION POLICY "infinite" ON "homeassistant" DURATION INF REPLICATION 1

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

CREATE CONTINUOUS QUERY cq_water_hourly ON homeassistant 
BEGIN 
  SELECT max(value) AS value 
  INTO homeassistant.month.water_meter_hour 
  FROM homeassistant.autogen.l 
  GROUP BY time(1h), entity_id fill(previous) 
END

यह आदेश:

• होमअसिस्टेंट डेटाबेस में cq_water_cold_hourly नामक एक सतत क्वेरी बनाता है
• क्वेरी हर घंटे निष्पादित की जाएगी (समय(1 घंटा))
• क्वेरी ठंडे और गर्म पानी की रीडिंग सहित होमअसिस्टेंट.ऑटोजन.एल (लीटर) के माप से सारा डेटा निकाल लेगी।
• एकत्रित डेटा को इकाई_आईडी द्वारा समूहीकृत किया जाएगा, जो ठंडे और गर्म पानी के लिए अलग-अलग मान बनाएगा।
• चूंकि लीटर काउंटर प्रत्येक घंटे के भीतर एक नीरस रूप से बढ़ता क्रम है, इसलिए अधिकतम मूल्य लेना आवश्यक होगा, इसलिए एकत्रीकरण फ़ंक्शन अधिकतम (मान) द्वारा किया जाएगा।
• नया मान Homeassistant.month.water_meter_hour पर लिखा जाएगा, जहां महीना एक महीने की अवधारण अवधि के साथ प्रतिधारण नीति का नाम है। इसके अलावा, ठंडे और गर्म पानी पर डेटा को संबंधित इकाई_आईडी और मूल्य फ़ील्ड में मान के साथ अलग-अलग रिकॉर्ड में बिखरा दिया जाएगा

रात में या जब घर पर कोई नहीं होता है, तो पानी की खपत नहीं होती है, और इसलिएhomeassistant.autogen.l में कोई नई प्रविष्टियाँ नहीं होती हैं। नियमित प्रश्नों में गुम मानों से बचने के लिए, आप भरण (पिछला) का उपयोग कर सकते हैं। यह InfluxDB को अंतिम घंटे के मूल्य का उपयोग करने के लिए बाध्य करेगा।

दुर्भाग्य से, निरंतर क्वेरी में एक ख़ासियत होती है: भरण (पिछली) युक्ति काम नहीं करती है और रिकॉर्ड आसानी से नहीं बनाए जाते हैं। इसके अलावा, यह किसी प्रकार की दुर्गम समस्या है, जो कई वर्षों से चर्चा हो रही है. हम इस समस्या से बाद में निपटेंगे, और निरंतर क्वेरी में fill(पिछला) को रहने देंगे - यह हस्तक्षेप नहीं करता है।

आइए देखें कि क्या हुआ (बेशक, आपको कुछ घंटे इंतजार करना होगा):

> select * from homeassistant.month.water_meter_hour group by entity_id
...
name: water_meter_hour
tags: entity_id=water_meter_cold
time                 value
----                 -----
...
2020-03-08T01:00:00Z 370511
2020-03-08T02:00:00Z 370513
2020-03-08T05:00:00Z 370527
2020-03-08T06:00:00Z 370605
2020-03-08T07:00:00Z 370635
2020-03-08T08:00:00Z 370699
2020-03-08T09:00:00Z 370761
2020-03-08T10:00:00Z 370767
2020-03-08T11:00:00Z 370810
2020-03-08T12:00:00Z 370818
2020-03-08T13:00:00Z 370827
2020-03-08T14:00:00Z 370849
2020-03-08T15:00:00Z 370921

ध्यान दें कि डेटाबेस में मान UTC में संग्रहीत हैं, इसलिए यह सूची 3 घंटे अलग है - InfluxDB आउटपुट में सुबह 7 बजे के मान उपरोक्त चार्ट में सुबह 10 बजे के मान से मेल खाते हैं। यह भी ध्यान दें कि सुबह 2 से 5 बजे के बीच कोई रिकॉर्ड नहीं होता है - यह निरंतर क्वेरी की विशेषता है।

जैसा कि आप देख सकते हैं, एकत्रित मूल्य भी एक नीरस रूप से बढ़ता क्रम है, केवल प्रविष्टियाँ कम बार होती हैं - एक घंटे में एक बार। लेकिन यह कोई समस्या नहीं है - हम एक और क्वेरी लिख सकते हैं जो चार्ट के लिए सही डेटा निकालेगी।

SELECT difference(max(value)) 
FROM homeassistant.month.water_meter_hour 
WHERE entity_id='water_meter_cold' and time >= now() -24h 
GROUP BY time(1h), entity_id 
fill(previous)

मैं डिक्रिप्ट करूंगा:

• Homeassistant.month.water_meter_hour डेटाबेस से, हम अंतिम दिन (time >= now() -24h) के लिए element_id='water_meter_cold' के लिए डेटा निकालेंगे।
• जैसा कि मैंने पहले ही उल्लेख किया है, कुछ प्रविष्टियाँhomeassistant.month.water_meter_hour अनुक्रम में गायब हो सकती हैं। हम GROUP BY time(1h) के साथ एक क्वेरी चलाकर इस डेटा को पुन: उत्पन्न करेंगे। इस बार fill(पिछला) अपेक्षा के अनुरूप काम करेगा, लापता डेटा उत्पन्न करेगा (फ़ंक्शन पिछला मान लेगा)
• इस क्वेरी में सबसे महत्वपूर्ण बात अंतर फ़ंक्शन है, जो घंटे के निशान के बीच अंतर की गणना करेगा। अपने आप में, यह काम नहीं करता है और इसके लिए एक एकत्रीकरण फ़ंक्शन की आवश्यकता होती है। मान लीजिए कि यह पहले इस्तेमाल किया गया max() है।

निष्पादन परिणाम इस प्रकार दिखता है

name: water_meter_hour
tags: entity_id=water_meter_cold
time                 difference
----                 ----------
...
2020-03-08T02:00:00Z 2
2020-03-08T03:00:00Z 0
2020-03-08T04:00:00Z 0
2020-03-08T05:00:00Z 14
2020-03-08T06:00:00Z 78
2020-03-08T07:00:00Z 30
2020-03-08T08:00:00Z 64
2020-03-08T09:00:00Z 62
2020-03-08T10:00:00Z 6
2020-03-08T11:00:00Z 43
2020-03-08T12:00:00Z 8
2020-03-08T13:00:00Z 9
2020-03-08T14:00:00Z 22
2020-03-08T15:00:00Z 72

रात 2 बजे से सुबह 5 बजे तक (UTC) कोई खपत नहीं हुई। फिर भी, क्वेरी भरने (पिछला) के कारण समान उपभोग मूल्य लौटा देगी, और अंतर फ़ंक्शन इस मान को स्वयं से घटा देगा और आउटपुट पर 0 प्राप्त करेगा, जो वास्तव में आवश्यक है।

अब केवल एक ही काम करना बाकी रह गया है और वह है ग्राफ़ बनाना। ऐसा करने के लिए, ग्राफाना खोलें, कुछ मौजूदा (या एक नया) डैशबोर्ड खोलें, एक नया पैनल बनाएं। चार्ट सेटिंग इस प्रकार होंगी.

मैं ठंडे और गर्म पानी का डेटा एक ही ग्राफ़ पर प्रदर्शित करूंगा। अनुरोध बिल्कुल वैसा ही है जैसा मैंने ऊपर वर्णित किया है।

प्रदर्शन पैरामीटर निम्नानुसार सेट किए गए हैं। मेरे लिए यह रेखाओं वाला एक ग्राफ़ होगा, जो चरणों (सीढ़ियों) में चलता है। मैं नीचे स्टैक पैरामीटर समझाऊंगा। नीचे कुछ और प्रदर्शन विकल्प हैं, लेकिन वे उतने दिलचस्प नहीं हैं।

परिणामी ग्राफ़ को होम असिस्टेंट में जोड़ने के लिए, आपको यह करना होगा:

• चार्ट संपादन मोड से बाहर निकलें. किसी कारण से, सही चार्ट साझाकरण सेटिंग्स केवल डैशबोर्ड पृष्ठ से ही पेश की जाती हैं
• चार्ट नाम के आगे त्रिकोण पर क्लिक करें, मेनू से शेयर चुनें
• खुलने वाली विंडो में एंबेड टैब पर जाएं
• वर्तमान समय सीमा को अनचेक करें - हम URL के माध्यम से समय सीमा निर्धारित करेंगे
• आवश्यक विषय का चयन करें. मेरे मामले में यह हल्का है
• परिणामी यूआरएल को लवलेस-यूआई सेटिंग्स कार्ड पर कॉपी करें

      - type: iframe
        id: graf_water_hourly
        url: "http://192.168.10.200:3000/d-solo/rZARemQWk/water?orgId=1&panelId=2&from=now-2d&to=now&theme=light"

कृपया ध्यान दें कि समय सीमा (अंतिम 2 दिन) यहां सेट की गई है, डैशबोर्ड सेटिंग्स में नहीं।

चार्ट इस तरह दिखता है. मैंने पिछले 2 दिनों में गर्म पानी का उपयोग नहीं किया है, इसलिए केवल ठंडे पानी का ग्राफ खींचा गया है।

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

यह चार्ट इस प्रकार दिखता है:

तो, स्टैक पैरामीटर के बारे में। इस ग्राफ़ में, एक गर्म पट्टी के ऊपर ठंडे पानी की एक पट्टी खींची गई है। कुल ऊंचाई अवधि के लिए ठंडे और गर्म पानी की कुल खपत से मेल खाती है।

दिखाए गए सभी ग्राफ़ गतिशील हैं। आप माउस को रुचि के बिंदु पर ले जा सकते हैं और किसी विशेष बिंदु पर विवरण और मूल्य देख सकते हैं।

दुर्भाग्य से, यह मरहम में कुछ मक्खियों के बिना नहीं था। बार चार्ट पर (चरण रेखाओं वाले ग्राफ़ के विपरीत), बार का मध्य दिन के मध्य में नहीं, बल्कि 00:00 बजे होता है। वे। बार का बायां आधा हिस्सा पिछले दिन के स्थान पर खींचा गया है। इसलिए शनिवार और रविवार के चार्ट नीले क्षेत्र के थोड़ा बाईं ओर बनाए गए हैं। जब तक मुझे पता नहीं चला कि इसे कैसे जीतना है।

एक अन्य समस्या मासिक अंतराल के साथ सही ढंग से काम करने में असमर्थता है। तथ्य यह है कि घंटे/दिन/सप्ताह की लंबाई निश्चित है, लेकिन महीने की लंबाई हर बार अलग होती है। InfluxDB केवल समान अंतराल के साथ काम कर सकता है। अब तक, मेरा दिमाग 30 दिनों का एक निश्चित अंतराल निर्धारित करने के लिए पर्याप्त है। हां, चार्ट वर्ष के दौरान थोड़ा-थोड़ा तैरता रहेगा और बार बिल्कुल महीनों के अनुरूप नहीं होंगे। लेकिन चूँकि यह चीज़ मेरे लिए केवल एक डिस्प्ले मीटर के रूप में दिलचस्प है, इसलिए मुझे इससे कोई आपत्ति नहीं है।

मुझे कम से कम दो समाधान दिखाई देते हैं:

• मासिक चार्ट पर स्कोर करना और अपने आप को साप्ताहिक चार्ट तक सीमित रखना। एक वर्ष में 52 साप्ताहिक बार बहुत अच्छे लगते हैं
• मासिक खपत को ही विधि संख्या 2 मानें, और ग्राफाना का उपयोग केवल सुंदर ग्राफ़ के लिए करें। यह काफी सटीक समाधान है. आप तुलना के लिए पिछले वर्ष के चार्ट भी ओवरले कर सकते हैं - ग्राफाना ऐसा कर सकता है।

निष्कर्ष

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

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

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

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

स्रोत: www.habr.com