IOT123 - ASIMIMATE SENSOR HUB: ICOS10 CORS ვებ - კომპონენტები: 8 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-31 10:21

ASSIMILATE SENSOR/ACTOR Slaves ჩართავს მეტამონაცემებს, რომლებიც გამოიყენება კრუტონში ვიზუალიზაციის განსაზღვრისათვის. ეს აღნაგობა ოდნავ განსხვავდება წინა ნაგებობებისგან; არ არის აპარატურის ცვლილებები. პროგრამული უზრუნველყოფა ახლა მხარს უჭერს პერსონალურ (უფრო მდიდარ) რედაქტორებს, რომლებიც შეიძლება ინტეგრირებული იყოს AssimilateCrouton– ის უახლეს სტრუქტურაში. მეტი ყურადღება დაეთმობა ამ სტატიაში firmware და MQTT დაფის ახსნას.

WebComponents– ის მომსახურების ერთ – ერთი უპირატესობა მოწყობილობიდან, რომელსაც ისინი აკონტროლებენ, არის ის, რომ მოწყობილობის უფრო მოწინავე კონტროლი შემოიფარგლება იმ ქსელში, რომელთანაც დაკავშირებულია მოწყობილობა: თქვენი WiFi წვდომის წერტილი. მიუხედავად იმისა, რომ მას შემდეგ რაც გამოიყენებთ MQTT სერვერს ავტორიზაციით, დაცვის მსგავსება არსებობს, საზოგადოებრივ ქსელებში თუ ბრაუზერს მომენტალურად დატოვებთ (AssimilateCrouton ვებსაიტი) ვიღაცას შეუძლია შეხვიდეს და გააკონტროლოს თქვენი ავტომატიზაციის მოწყობილობები. ეს CORS ვებკომპონენტის ფუნქცია შესაძლებელს ხდის მხოლოდ კითხვის (ტემპერატურის, სინათლის დონე, ტენიანობის) საჯაროდ ჩვენებას და ბრძანების ფუნქციები (ჩართვა/გამორთვა, დაგეგმვა) მხოლოდ მოწყობილობის ქსელიდან.

მოწყობილობაზე, ვებ სერვერის ყველა მახასიათებელი ავთენტიფიკაციით და ჰოსტინგით SPIFFS– ში ჯერ კიდევ მხარდაჭერილია, მაგრამ განსაკუთრებული ყურადღება გამახვილებულია CORS (Cross Origin Resource Sharing) პოლიმერულ ვებკომპონენტებზე (Crouton იყენებს პოლიმერს 1.4.0).

AssimilateCrouton- ში (Crouton- ის ჩანგალი გამოიყენება IOT ქსელის ათვისებისთვის) ცვლილებები მოიცავს

• მოწყობილობის ბარათის (ასის-მოწყობილობის) მხარდაჭერა, რომელიც სხვა საკითხებთან ერთად აჩვენებს და მალავს, მომხმარებლისთვის მოწყობილობის ინდივიდუალურ ბარათებს
• ინფორმაციის თვისება ყველა ბარათზე, რომელიც აჩვენებს ბარათისთვის სასარგებლო კონტექსტური ინფორმაციის სადღეგრძელოს
• CORS ვებ კომპონენტების მხარდაჭერა, ამ შემთხვევაში განთავსებულია ვებ სერვერზე მოწყობილობაზე (ESP8266).

ნაბიჯი 1: CROUTON

Crouton არის დაფა, რომელიც გაძლევთ ვიზუალიზაციას და კონტროლს თქვენი IOT მოწყობილობების მინიმალური დაყენებით. არსებითად, ეს არის ყველაზე მარტივი დაფა, რომელიც უნდა შეიქმნას ნებისმიერი IOT ტექნიკის მოყვარულთათვის მხოლოდ MQTT და JSON გამოყენებით.

ASSIMILATE SLAVES (სენსორები და მსახიობები) ჩართულია მეტამონაცემები და თვისებები, რომელსაც ოსტატი იყენებს მოწყობილობის შესაქმნელად Info json პაკეტი, რომელსაც Crouton იყენებს დაფის შესაქმნელად. შუამავალი ASSIMILATE NODES- სა და Crouton- ს შორის არის MQTT ბროკერი, რომელიც არის მეგობრული ვებსაიტებისთვის: Mosquito გამოიყენება დემო ვერსიისთვის.

როგორც ASSIMILATE MASTER ითხოვს თვისებებს, ის აყალიბებს საპასუხო მნიშვნელობებს საჭირო ფორმატში Crouton განახლებებისთვის. AssimilateCrouton ჩანგალი ამატებს ზოგიერთ მახასიათებელს, რომელიც საშუალებას მოგცემთ მოახდინოთ დეცენტრალიზაცია მოახდინოთ თქვენი მოწყობილობის მუშაობის წესებზე, ანუ IOT მოწყობილობას არ სჭირდება რაიმე ჩამონტაჟებული ბიზნეს წესი, ეს მხოლოდ მილსადენია MQTT/I2C კომუნიკაციისთვის უფრო ჭკვიან (კონტროლირებად) მონების მსახიობებთან და სენსორებთან. რა

ნაბიჯი 2: ასიმილაცია CROUTON

ცვლილებები CROUTON– ში

ცვლილებები გამოტოვებული ვერსიიდან მოიცავს:

• თუ საბოლოო წერტილს აქვს განსაზღვრული ბილიკის თვისება, ბარათის ვებკომპონენტი შეასრულებს HTML იმპორტს CORS რესურსისთვის (ვებ სერვერზე ESP8266 ამ მშენებლობაში).
• ნებისმიერი რესურსი CORS ვებკომპონენტიდან (დამოკიდებულებებისგან) მითითებულია, თითქოს ისინი მოწოდებულია Crouton– ის ვებ – გვერდიდან; როდესაც ისინი ვერ იტვირთება გამონაკლისი დამმუშავებელი rejigs ბილიკები და იტვირთება თუ ვებგვერდზე.
• ახლანდელი ადგილობრივი დრო ნაჩვენებია მარჯვნივ, რაც სასარგებლოა გადამოწმების დაგეგმვისთვის.

პოლიმერული დამოკიდებულებები და კორპუსები

პოლიმერული დამოკიდებულების ხის ფოთლები შეიძლება განთავსდეს CORS– ში. იმის გამო, რომ ძირეული დამოკიდებულებები შეიძლება გამოყენებულ იქნას რამდენჯერმე აპლიკაციაში, მათი მითითება შეუძლებელია 2 ადგილიდან (ვებსაიტიდან და მოწყობილობიდან), რადგან პოლიმერული მოდულის ჩამტვირთავი მათ განიხილავს როგორც 2 ცალკეულ რესურსს და მრავალჯერადი რეგისტრაციის შეცდომამ სწრაფად შეაფერხა აპლიკაცია.

ამ მიზეზით ვებკომპონენტი ბარათისთვის (HTML ფაილი 1.4.0) და მასთან დაკავშირებული CSS ფაილი არის ერთადერთი ფაილები, რომლებიც განთავსებულია მოწყობილობაზე. სხვა დამოკიდებულებებზე მითითებულია, თითქოს WebComponent განთავსებულია საწყის ვებსაიტზე "html" საქაღალდეში, რაც ამარტივებს WebComponents– ის შემუშავებას ამ საქაღალდიდან, სანამ არ იქნება მზად SPIFFS– ზე ატვირთვისთვის ESP8266– ზე. AssimilateCrouton შეიმუშავებს როგორ მივიღოთ სწორი ფაილები.

სამსახური

edfungus– ის ორიგინალური Crouton– ის შემქმნელმა დაწერა წყარო Pug/Less– ში და ჰქონდა NPM/Grunt ინსტრუმენტთა ქსელი. მე გადავიღე Pug/Less როგორც HTML/css და უბრალოდ შევცვალე/გავანაწილე რენდერირებული ფაილები. ამან დაარღვია NPM/Grunt ინსტრუმენტთა ქსელი. ამის გამოსწორება დაფარულია მომავლის განყოფილებაში.

თქვენ შეგიძლიათ შეამოწმოთ დაფა ადგილობრივად თქვენს DEV ყუთში:

• საწყისი საქაღალდის სარდლობის ხაზიდან
• npm დაწყება
• lite-server გაშლილია https:// localhost: 10001

განათავსეთ სტატიკური ვებ სერვერზე:

• დააკოპირეთ ყველა საქაღალდე, გარდა node_modules
• კოპირება index.html (და შესაძლოა web.config)

მომავალი

ერთ -ერთი მთავარი მიზანია პოლიმერ 3 -ზე გადასვლა და პოლიმერული CLI- დან მუშაობა. მოწინავე რედაქტორებისა და ჩარჩოს დამატება IOT დეველოპერებისთვის საკუთარი თავის განვითარებისათვის არის მაღალი პრიორიტეტი. საბოლოოდ, მოწინავე ავტომატური სისტემა გაშვებული იქნება მთლიანად MQTT კლიენტებისგან, როგორიცაა AssimilateCrouton.

აპარატის მაგალითი, რომელიც გამოიყენება AssimilateCrouton– ისთვის:

{

"deviceInfo": {

"endPoints": {

"CC_device": {

"მოწყობილობის_სახელი": "ash_mezz_A3",

"card-type": "assim-device",

"ssid": "Corelines_2",

"ip_addr": "192.168.8.104",

"საბოლოო წერტილები": [

{

"title": "გაიზარდე შუქები",

"card-type": "crouton-simple-toggle",

"endpoint": "გადართვა"

},

{

"title": "Planter Lights",

"card-type": "crouton-assim-weekview",

"საბოლოო წერტილი": "CC_switch"

}

]

},

"CC_switch": {

"card-type": "assim-weekview",

"info": "განათების ჩართვა ან გამორთვა 15 წუთიან სლოტში",

"გზა": "https://192.168.8.104/cors",

"title": "Planter Lights",

"ინტერვალი_წთ": 15,

"ღირებულებები": {

"მნიშვნელობა": ""

}

},

"გადართვა": {

"title": "გაიზარდე შუქები",

"card-type": "crouton-simple-toggle",

"info": "განათების ჩართვა ან გამორთვა დროებით",

"ეტიკეტები": {

"false": "OFF",

"true": "ON"

},

"ხატები": {

"ყალბი": "მზე-ო",

"ჭეშმარიტი": "მზე-ო"

},

"ღირებულებები": {

"მნიშვნელობა": 0

}

}

},

"სტატუსი": "კარგი",

"name": "ash_mezz_A3",

"description": "ოფისი აშმორში, ანტრესოლი, ტერიტორია A2",

"ფერი": "#4D90FE"

}

}

rawdeviceInfo.json– ის ნახვა GitHub– ით

ნაბიჯი 3: მოწყობილობის შეკრება

რადგან არ არსებობს აპარატურის ცვლილებები, აქ მოცემულია შესაბამისი ინფორმაციის ბმულები:

• შელის ასამბლეა
• მასალები და ინსტრუმენტები
• MCU მომზადება
• MCU საბინაო მომზადება
• მონების მშენებლობა დაბალი მხარის გადამრთველი/გადატვირთვა ქალიშვილი დაფა
• ძირითადი კომპონენტების შეკრება

ნაბიჯი 4: FIRMWARE

ძირითადი ცვლილებები ამ შენობაში

იმისათვის, რომ AssimilateCrouton აპლიკაციამ შეძლოს გამოიყენოს CORS რესურსი მოწყობილობიდან, საპასუხოდ სათაურები უნდა იყოს კონფიგურირებული კონკრეტული გზით. ეს განხორციელდა firmware– ის ამ ვერსიაში (static_server.ino => server_file_read ()).

ასევე პოლიმერის ძირითადი დამოკიდებულების გრაფიკი უნდა იყოს ერთი წარმოშობისგან. სტრატეგია იქნა გამოყენებული SPIFFS CORS ფაილებისათვის onerror დამუშავების (corsLinkOnError) დასამატებლად რესურსების ასატვირთად AssimilateCrouton ვებ – გვერდიდან, როდესაც ისინი არ მოიძებნება მოწყობილობაზე.

SPIFFS ფაილურ სისტემას დაემატა 2 ახალი კონვენცია საბოლოო წერტილების პერსონალურად შესაქმნელად, რომელიც შექმნილია deviceInfo– ში, რომელსაც AssimilateCrouton იყენებს დაფის ბარათების შესაქმნელად:

• /config/user_card_base.json საბოლოო წერტილის განსაზღვრება გაშვების ცვლადით, რომელიც პირველად იცვლება:,,. ეს არის, როგორც წესი, სადაც დაემატება ასის მოწყობილობის ბარათი. ეს არ უკავშირდება მოწყობილობას.
• /config/user_card_#.json საბოლოო წერტილის განსაზღვრება გაშვების ცვლადითა პირველი ცვლის:,,. ეს ჩვეულებრივ ხდება იქ, სადაც მდიდარი რედაქტორები, როგორიცაა assim-weekview ბარათი, დაემატება I2C მონას (მსახიობს/სენსორს), რომელიც ეხება #-ს.

ესკიზი/ბიბლიოთეკები

ამ ეტაპზე პროექტი შეფუთულია როგორც მაგალითი AssimilateBus Arduino ბიბლიოთეკისთვის. ეს ძირითადად იმისთვის ხდება, რომ ყველა საჭირო ფაილი ადვილად იყოს წვდომა Arduino IDE– დან. ძირითადი კოდის არტეფაქტებია:

• mqtt_crouton_esp8266_cors_webcomponents.ino - მთავარი შესასვლელი წერტილი.
• assimilate_bus.h/assimilate_bus.cpp - ბიბლიოთეკა, რომელიც ამუშავებს I2C კომუნიკაციას მონათა სენსორთან/მსახიობებთან
• VizJson.h/VizJson.cpp - ბიბლიოთეკა, რომელიც აფორმებს/აგებს ნებისმიერ JSON- ს, რომელიც გამოქვეყნებულია MQTT- ის საშუალებით
• config.h/config.cpp - ბიბლიოთეკა, რომელიც კითხულობს/ყუთებს/წერს კონფიგურაციის ფაილებს SPIFFS- ზე
• static_i2c_callbacks.ino - I2C გამოძახება ქონების მისაღებად და მონების მოთხოვნათა სრული ციკლი static_mqtt.ino - MQTT ფუნქციები
• static_server.ino - ვებ სერვერის ფუნქციები
• static_utility.ino - დამხმარე ფუნქციები

სტატიკური INO ფუნქციები გამოიყენებოდა (ბიბლიოთეკების ნაცვლად) სხვადასხვა მიზეზის გამო, მაგრამ ძირითადად ისე, რომ ვებ სერვერისა და MQTT ფუნქციები კარგად თამაშობდნენ.

SPIFFS რესურსები

SPIFFS ფაილების დეტალური ახსნა შეგიძლიათ იხილოთ აქ.

• favicon.ico - რესურსი, რომელსაც იყენებს ტუზი რედაქტორი

• კონფიგურაცია

  • device.json - მოწყობილობის კონფიგურაცია (Wifi, MQTT…)
  • slave_metas _#. json - გენერირდება გაშვების დროს თითოეული მონა მისამართის ნომრისთვის (#)
  • user_card _#. json - პერსონალური საბოლოო წერტილი, რომელიც უნდა იყოს ინტეგრირებული მოწყობილობაში Info თითოეული მონა მისამართის ნომრისთვის (#)
  • user_card_base.json - პერსონალური საბოლოო წერტილი, რომელიც უნდა იყოს ინტეგრირებული მოწყობილობის ინფორმაცია მოწყობილობისთვის
  • user_meta _#. json - პერსონალური მეტამონაცემები გადალახავს მონების თითოეულ მონა მისამართის ნომერს (#)
  • user_props.json - მორგებული თვისებების სახელები მონების მეტამონაცემებში გადასაყენებლად

• კორსები

  • card -webcomponent.css - სტილის ფურცელი სხვადასხვა საბაჟო ბარათებისთვის
  • card -webcomponent.html - ვებ კომპონენტი სხვადასხვა საბაჟო ბარათებისთვის

• რედაქტორი

  • assimilate -logo-p.webp" />
  • edit.htm.gz - gzip of Ace Editor HTML
  • edit.htm.src - ტუზის რედაქტორის ორიგინალური HTML
  • favicon -32x32-p.webp" />

FIRMWARE- ის გადატვირთვა

• კოდის საცავი შეგიძლიათ იხილოთ აქ (ფოტო).
• ბიბლიოთეკის ZIP შეგიძლიათ იხილოთ აქ (სურათი).
• ინსტრუქცია "ZIP ბიბლიოთეკის იმპორტი" აქ.
• ბიბლიოთეკის დაყენების შემდეგ შეგიძლიათ გახსნათ მაგალითი "mqtt_crouton_esp8266_cors_webcomponents".
• ინსტრუქცია Arduino– ს დაყენებისათვის Wemos D1 Mini– სთვის აქ.
• დამოკიდებულებები: ArduinoJson, TimeLib, PubSubClient, NeoTimer (იხილეთ დანართები საცავებში ცვლილებების დარღვევის შემთხვევაში).

აიტვირთეთ SPIFFS– ზე

მას შემდეგ რაც კოდი ჩაიტვირთება Arduino IDE- ში, გახსენით device.json მონაცემების/კონფიგურაციის საქაღალდეში:

• შეცვალეთ wifi_ssid მნიშვნელობა თქვენი WiFi SSID– ით.
• შეცვალეთ wifi_key- ის მნიშვნელობა თქვენი WiFi გასაღებით.
• შეცვალეთ mqtt_device_name მნიშვნელობა სასურველი მოწყობილობის იდენტიფიკაციით (შეერთება არ არის საჭირო).
• შეცვალეთ mqtt_device_description- ის მნიშვნელობა თქვენი სასურველი მოწყობილობის აღწერით (კრუტონში).
• შეინახეთ მოწყობილობა. Json.
• ატვირთეთ მონაცემთა ფაილები SPIFFS– ში.

მთავარი შესვლის წერტილი AssimilateBus მაგალითისთვის:

/*

*

*თქვენი მოწყობილობის ბიზნეს წესები არის მოსალოდნელი, რომ იქნება კონტროლირებადი MQTT– ის საშუალებით - არ არის გამომცხვარი ამ FIRMWARE– ში

*

* ამ ფაილში დაყენების და მარყუჟის გარდა

* მნიშვნელოვანი მოძრავი ნაწილებია

* on_bus_received და on_bus_complete in static_i2c_callbacks.ino

* და

* mqtt_publish და mqtt_callback in static_mqtt.ino

*

*/

#მოიცავს "types.h"

#მოიცავს "VizJson.h"

#მოიცავს "ათვისება_ავტობუსს.ჰ"

#მოიცავს "debug.h"

#მოიცავს "config.h"

#ჩართეთ

#ჩართეთ // დააყენეთ MQTT_MAX_PACKET_SIZE 3000 ფუნტად (ან თქვენი საჭიროებები მოწყობილობის ინფორმაციის json)

#ჩართეთ

#ჩართეთ

#ჩართეთ

#ჩართეთ

#ჩართეთ

// --------------------------------- მეხსიერების დეკლარაციები

// ---------------------------------------------------- - განსაზღვრავს

#defineDBG_OUTPUT_FLAG2 // 0, 1, 2 MINIMUMUM, გამოშვება, სრული

#define_mqtt_pub_topic "outbox" // CROUTON CONVENTIONS

#განსაზღვრეთ_mqtt_sub_topic "შემოსულები"

// ---------------------------------------------------- - კლასის საგნები

გამოსწორება _ გაფუჭება (DBG_OUTPUT_FLAG);

AssimilateBus _assimilate_bus;

ვიზჯსონი _viz_json;

კონფიგურაცია _config_data;

WiFiClient _esp_client;

PubSubClient _client (_esp_client);

WiFiUDP Udp;

ESP8266WebServer _ სერვერი (80);

ნეოტიმერი _timer_property_request = ნეოტიმერი (5000);

// ---------------------------------------------------- - მონაცემთა სტრუქტურა / ცვლადი

RuntimeDeviceData _runtime_device_data;

PropertyDto _dto_props [50]; // მაქს 10 მონა x max 5 თვისება

// ---------------------------------------------------- - ნაკადის კონტროლი

volatilebool _sent_device_info = false;

ბაიტი _dto_props_index = 0;

bool _fatal_error = false;

// --------------------------------- ფუნქციის სფეროს დეკლარაციები

// ---------------------------------------------------- - static_i2c_callbacks.ino

voidon_bus_received (byte slave_address, byte prop_index, Role role, char name [16], char value [16]);

voidon_bus_complete ();

// ---------------------------------------------------- - static_mqtt.ino

voidmqtt_callback (char* თემა, byte* payload, unsignedint length);

voidmqtt_loop ();

int8_tmqtt_get_topic_index (char* თემა);

voidmqtt_init (constchar* wifi_ssid, constchar* wifi_password, constchar* mqtt_broker, int mqtt_port);

voidmqtt_create_subscriptions ();

voidmqtt_publish (char *root_topic, char *deviceName, char *endpoint, constchar *payload);

boolmqtt_ensure_connect ();

voidmqtt_subscribe (char *root_topic, char *deviceName, char *endpoint);

voidi2c_set_and_get (ბაიტის მისამართი, ბაიტის კოდი, constchar *param);

// ---------------------------------------------------- - static_server.ino

სიმებიანი server_content_type_get (სიმებიანი ფაილის სახელი);

boolserver_path_in_auth_exclusion (სიმებიანი გზა);

boolserver_auth_read (სიმებიანი გზა);

boolserver_file_read (სიმებიანი გზა);

voidserver_file_upload ();

voidserver_file_delete ();

voidserver_file_create ();

voidserver_file_list ();

voidserver_init ();

voidtime_services_init (char *ntp_server_name, byte time_zone);

time_tget_ntp_time ();

voidsend_ntp_packet (IPAddress & address);

char *time_stamp_get ();

// ---------------------------------------------------- - static_utility.ino

სიმებიანი spiffs_file_list_build (სიმებიანი გზა);

voidreport_deserialize_error ();

voidreport_spiffs_error ();

boolcheck_fatal_error ();

boolget_json_card_type (byte slave_address, byte prop_index, char *card_type);

boolget_struct_card_type (byte slave_address, byte prop_index, char *card_type);

boolget_json_is_series (byte slave_address, byte prop_index);

voidstr_replace (char *src, constchar *oldchars, char *newchars);

byte get_prop_dto_idx (byte slave_address, byte prop_index);

// --------------------------------- მთავარი

voidsetup () {

DBG_OUTPUT_PORT. დასაწყისი (115200);

SetupDeviceData device_data;

Serial.println (); Serial.println (); // ზღვარი კონსოლის ნაგვისთვის

დაგვიანება (5000);

if (DBG_OUTPUT_FLAG == 2) DBG_OUTPUT_PORT.setDebugOutput (ჭეშმარიტი);

_debug.out_fla (F ("კონფიგურაცია"), ჭეშმარიტი, 2);

// მიიღეთ საჭირო კონფიგურაცია

if (SPIFFS.begin ()) {

_debug.out_str (spiffs_file_list_build ("/"), true, 2);

თუ (! _config_data.get_device_data (device_data, _runtime_device_data)) {

report_deserialize_error ();

დაბრუნების;

}

} სხვა {

report_spiffs_error ();

დაბრუნების;

}

// გამოიყენეთ ტაიმერის მნიშვნელობა მითითებული მოწყობილობაში. json

_timer_property_request.set (device_data.sensor_interval);

mqtt_init (device_data.wifi_ssid, device_data.wifi_key, device_data.mqtt_broker, device_data.mqtt_port);

time_services_init (device_data.ntp_server_name, device_data.time_zone);

server_init ();

// დაიწყეთ მეტამონაცემების კოლექცია

_assimilate_bus.get_metadata ();

_assimilate_bus.print_metadata_details ();

mqtt_ensure_connect ();

// სჭირდება სენსორის თვისება (სახელები) მეტამონაცემების შეგროვების დასასრულებლად

_ ათვისება_ავტობუსს.გამოიტანეთ_წარმოება (ავტობუსში მიიღება, ავტობუსში_მთავარია);

_timer_property_request.reset (); // შეიძლება გავიდეს შესამჩნევი დრო ამ მომენტამდე, ასე რომ თავიდან დაიწყეთ

}

voidloop () {

თუ (! check_fatal_error ()) დაბრუნდება;

mqtt_loop ();

_server.handleClient ();

თუ (_timer_property_request.repeat ()) {

_ ათვისება_ავტობუსს.გადაიღეთ_საქონლები (ავტობუსში_მიღებულია,_ავტობუსში_სრული);

}

}

rawmqtt_crouton_esp8266_cors_webcomponents.ino ნახვა hosted with GitHub

ნაბიჯი 5: მოწყობილობის ბარათი

მოწყობილობის ბარათი (ბარათის ტიპი: assim-device) განთავსებულია ვებგვერდზე და არ არის აუცილებელი მისი მომსახურება მოწყობილობიდან (CORS).

მისი ნაგულისხმევი გვერდი ჩამოთვლილია:

• MQTT თემები მოწყობილობაზე კითხვისა და წერისთვის
• წვდომის წერტილი, რომელთანაც მოწყობილობა არის დაკავშირებული
• ბმული SPIFFS ფაილის რედაქტორზე, რომელიც განთავსებულია მოწყობილობაზე ACE EDITOR– ის გამოყენებით
• თვალის ხატი, რომელიც ავლენს ჩვენების/დამალვის ბარათის გვერდს.

ბარათის ჩვენების/დამალვის გვერდების სია:

• თითოეული ბარათი ცალკე ელემენტია
• მუქი ლურჯი შრიფტი ჩვენებისას
• დამალვისას შავი ნორმალური შრიფტი
• ბარათის ტიპის ამსახველი ხატი.

ბარათის დამალვა შესაძლებელია ბარათებზე დამალვის ღილაკის დაჭერით, ან სიაში ლურჯ-თამამი შრიფტის ერთეულზე დაჭერით. ბარათების ჩვენება შესაძლებელია სიაში შავი-ნორმალური შრიფტის ერთეულზე დაჭერით.

ამ ფუნქციასთან სუსტად არის დაკავშირებული სადღეგრძელოები. თუ მოწყობილობის ინფოს რომელიმე ბოლო წერტილს აქვს ინფორმაციის თვისება მინიჭებული, ბარათის დამალვის ღილაკის გვერდით გამოჩნდება ინფორმაციის ღილაკი. როდესაც დააწკაპუნებთ, კონტექსტური ინფორმაცია, რომელიც განსაზღვრულია ბოლო წერტილში, იქნება "შემწვარი" ფანჯარაში.

თუ მოწყობილობის ბარათი არ არის განსაზღვრული, დამალვის ღილაკები არ გამოჩნდება ბარათებზე. ეს იმიტომ ხდება, რომ ერთხელ დაფარული აღარ არსებობს მათი ჩვენების საშუალება.

იხილეთ ENDPOINT CUSTOMIZATION დაწვრილებით, თუ როგორ შეიძლება ასიმი მოწყობილობის ბარათის დამატება SPIFFS ფაილების მეშვეობით ESP8266.

AssimilateCrouton ვებკომპონენტი

რკინის სიგნალები>

div>

აჩვენეთ დამალული ხატი

i> span>

მოწყობილობის ფორმა

MQTT TOPICSdiv>

/outbox/{{endPointJson.device_name}}/*div>

/inbox/{{endPointJson.device_name}}/*div>

WIFI SSIDdiv>

{{endPointJson.ssid}} div>

IP ADDRESSdiv>

{{endPointJson.ip_addr}} a> div>

div>

ჩვენების დამალვა

ელემენტი>ქაღალდის ელემენტი>

შაბლონი>

paper-listbox>

div>

კრუტონ-ბარათი>

შაბლონი>

dom-module>

rawassim-device.html- ის ნახვა GitHub– ით

ნაბიჯი 6: კვირის ბარათი

Weekview ბარათი (ბარათის ტიპი: assim-weekview) განთავსებულია მოწყობილობაზე (cors საქაღალდე). ის შეყვანილია AssimilateCrouton– ისთვის გამოქვეყნებულ მოწყობილობის ინფორმაციის პაკეტში, ფაილის კონფიგურაციის/user_card _#. Json– ის დამატებით SPIFFS– ში (ამ შემთხვევაში user_card_9.json).

მიმოხილვა

სამუშაო დღეები წარმოდგენილია დროის მონაკვეთების სიების სახით. დროის მონაკვეთის სიზუსტე მითითებულია კონფიგურაციაში/user_card _#. Json თვისებით "ინტერვალი_წთ". ის უნდა იყოს საათის ფრაქცია ან საათის ჯერადი მაგ. 10, 15, 20, 30, 60, 120, 360. დროის სლოტზე დაწკაპუნებით უზრუნველყოს ჩართული მდგომარეობის ბრძანება დაკავშირებული მოწყობილობისთვის იმ დროს. თუ დროის მონაკვეთი არის ახლა, ბრძანება დაუყოვნებლივ იგზავნება (გამოქვეყნდება) მოწყობილობისთვის. ჩვეულებრივ, მდგომარეობა შემოწმებულია/ქვეყნდება ყოველ წუთში. შერჩევა ინახება LocalStorage– ში, ამიტომ დრო განახლდება ბრაუზერის განახლებით.

გამოყენების შემთხვევები

მისი ამჟამინდელი მდგომარეობით, კვირის ხედი შესაფერისია იმ მოწყობილობებისთვის, რომლებსაც შეუძლიათ გამოიყენონ გადამრთველი გადამრთველი თავიანთი მდგომარეობის ვიზუალიზაციისათვის, ანუ ისინი ან ჩართულია ან გამორთულია და დაყენების შემდეგ რჩება ამ მდგომარეობაში. შუქები, ვენტილატორები და წყლის გამაცხელებლები კარგი კანდიდატები არიან.

შეზღუდვები/გამოქვაბულები

• ინტერვალი_წთ უნდა იყოს ზემოთ ნახსენები მნიშვნელობებიდან
• კვირის ხედი მხარს არ უჭერს მომენტალურ ქმედებებს, რომლებიც ასევე დაგეგმილია, მაგალითად, ონკანის მოკლედ ჩართვა (5 წამი) დღეში ორჯერ.

მომავალი

• მოსალოდნელია, რომ მომენტალური ქმედებები იქნება მხარდაჭერილი.
• განიხილება სინქრონიზებული შენახვა მოწყობილობებზე, გრაფიკის შერჩევისთვის.

ნაბიჯი 7: ENDPOINT მორგება

როგორც მოკლედ არის ნათქვამი FIRMWARE– ში, SPIFFS ფაილურ სისტემას ემატება 2 ახალი კონვენცია საბოლოო წერტილების მორგებისთვის. JSON ფაილები არის ფრაგმენტები, რომლებიც ემატება საბოლოო წერტილის თვისებას მოწყობილობის Info პაკეტში განთავსებული MQTT ბროკერზე, რომელიც ხდება დაფის განმარტება.

საბოლოო წერტილების გასაღებები წარმოიქმნება firmware– ში:

• CC_device (საბაჟო ბარათი) user_card_base.json– ისთვის
• CC_SLAVE_ENDPOINT NAME მომხმარებლის ბარათი _#. Json (# არის მონა მისამართი)

როგორც უკვე აღვნიშნეთ, არსებობს ცვლადები, რომლებიც იცვლება მნიშვნელობებით გაშვების დროს:

• mqtt_device_name
• wifi_ssid
• local_ip

user_card_base.json

Მაგალითი:

მომხმარებლის_ ბარათი _#. json

Მაგალითი:

ნაბიჯი 8: ვიდეო