-
Notifications
You must be signed in to change notification settings - Fork 67
/
SwitchBot-BLE2MQTT-ESP32.ino
4750 lines (4351 loc) · 187 KB
/
SwitchBot-BLE2MQTT-ESP32.ino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/** SwitchBot-MQTT-BLE-ESP32:
https://github.com/devWaves/SwitchBot-MQTT-BLE-ESP32
**does not use/require switchbot hub
Code can be installed using Arduino IDE OR using Visual Studio Code PlatformIO
-For Arduino IDE - Use only the SwitchBot-BLE2MQTT-ESP32.ino file
-For Visual Studio Code PlatformIO - Use the src/SwitchBot-BLE2MQTT-ESP32.cpp and platformio.ini files
Allows for "unlimited" switchbots devices to be controlled via MQTT sent to ESP32. ESP32 will send BLE commands to switchbots and return MQTT responses to the broker
** I do not know where performance will be affected by number of devices **
** This is an unofficial SwitchBot integration. User takes full responsibility with the use of this code **
v6.4-Alexa-alpha
Created: on Nov 11 2021
Author: devWaves
Contributions from:
HardcoreWR
based off of the work from https://github.com/combatistor/ESP32_BLE_Gateway
Notes:
- Supports Home Assistant MQTT Discovery
- Support bots, curtains, temp meters, contact sensors, and motion sensors
- It works for button press/on/off, set mode, set hold seconds
- It works for curtain open/close/pause/position(%)
- It can request status values (bots/curtain/meter/motion/contact: battery, mode, state, position, temp etc) using a "rescan" for all devices
- It can request individual device status values (bots/curtain/meter/motion/contact: battery, mode, state, position, temp etc) using a "requestInfo"
- Good for placing one ESP32 in a zone with 1 or more devices that has a bad bluetooth signal from your smart hub. MQTT will use Wifi to "boost" the bluetooth signal
- ESP32 bluetooth is pretty strong and one ESP32 can work for entire house. The code will try around 60 times to connect/push button. It should not need this many but it depends on ESP32 bluetooth signal to switchbots. If one alone doesn't work, get another esp32 and place it in the problem area
- OTA update added. Go to ESP32 IP address in browser. In Arduino IDE menu - Sketch / Export compile Binary . Upload the .bin file
- Supports passwords on bot
- Automatically rescan every X seconds
- Automatically requestInfo X seconds after successful control command
- Retry set/control command on busy response from bot/curtain until success
- Get settings from bot (firmware, holdSecs, inverted, number of timers)
- Add a defined delay between each set/control commands or per device
- ESP32 will collect hold time from bots and automatically wait holdSecs+defaultBotWaitTime until next command is sent to bot
- Retry on no response curtain or bot
- holdPress = set bot hold value, then call press (without disconnecting in between)
- Set/Control is prioritized over scanning. While scanning, if a set/control command is received scanning is stopped and resumed later
- ESP32 can simulate ON/OFF for devices when bot is in PRESS mode. (Cannot guarantee it will always be accurate)
- If you only have bots/curtain/meters the ESP32 will only scan when needed and requested. If you include motion or contact sensors the ESP32 will scan all the time
<ESPMQTTTopic> = <mqtt_main_topic>/<host>
- Default = switchbot/esp32
ESP32 will subscribe to MQTT 'set' topic for every configure device.
- <ESPMQTTTopic>/bot/<name>/set
- <ESPMQTTTopic>/curtain/<name>/set
- <ESPMQTTTopic>/meter/<name>/set
- <ESPMQTTTopic>/contact/<name>/set
- <ESPMQTTTopic>/motion/<name>/set
Send a payload to the 'set' topic of the device you want to control
Strings:
- "PRESS"
- "ON"
- "OFF"
- "OPEN"
- "CLOSE"
- "PAUSE"
- "STATEOFF" (Only for bots in simulated ON/OFF mode)
- "STATEON" (Only for bots in simulated ON/OFF mode)
Integer 0-100 (for curtain position) Example: 50
Integer 0-100 (for setting bot hold seconds) Example: 5 (for bot only) Does the same thing as <ESPMQTTTopic>/setHold
Strings:
- "REQUESTINFO" or "GETINFO" (for bot and curtain) Does the same thing as calling <ESPMQTTTopic>/requestInfo
- "REQUESTSETTINGS" or "GETSETTINGS" (for bot only) Does the same thing as calling <ESPMQTTTopic>/requestSettings requires getBotResponse = true
- "MODEPRESS", "MODESWITCH", "MODEPRESSINV", "MODESWITCHINV" (for bot only) Does the same thing as <ESPMQTTTopic>/setMode
ESP32 will respond with MQTT on 'status' topic for every configured device
- <ESPMQTTTopic>/bot/<name>/status
- <ESPMQTTTopic>/curtain/<name>/status
- <ESPMQTTTopic>/meter/<name>/status
Example payload:
- {"status":"connected", "command":"ON"}
- {"status":"errorConnect", "command":"ON"}
- {"status":"errorCommand", "command":"NOTVALID"}
- {"status":"commandSent", "command":"ON"}
- {"status":"busy", "value":3, "command":"ON"}
- {"status":"failed", "value":9, "command":"ON"}
- {"status":"success", "value":1, "command":"ON"}
- {"status":"success", "value":5, "command":"PRESS"}
- {"status":"success", "command":"REQUESTINFO"}
ESP32 will respond with MQTT on 'state' topic for every configured device
- <ESPMQTTTopic>/bot/<name>/state
- <ESPMQTTTopic>/curtain/<name>/state
Example payload:
- "ON"
- "OFF"
- "OPEN"
- "CLOSE"
ESP32 will respond with MQTT on 'position' topic for every configured device
- <ESPMQTTTopic>/curtain/<name>/position
Example payload:
- {"pos":0}
- {"pos":100}
- {"pos":50}
ESP32 will Subscribe to MQTT topic to rescan for all device information
- <ESPMQTTTopic>/rescan
send a JSON payload of how many seconds you want to rescan for
example payloads =
{"sec":30}
{"sec":"30"}
ESP32 will Subscribe to MQTT topic for device information
- <ESPMQTTTopic>/requestInfo
send a JSON payload of the device you want to requestInfo
example payloads =
{"id":"switchbotone"}
ESP32 will respond with MQTT on
- <ESPMQTTTopic>/#
Example attribute responses per device are detected:
- <ESPMQTTTopic>/bot/<name>/attributes
- <ESPMQTTTopic>/curtain/<name>/attributes
- <ESPMQTTTopic>/meter/<name>/attributes
- <ESPMQTTTopic>/contact/<name>/attributes
- <ESPMQTTTopic>/motion/<name>/attributes
Example response payloads:
- {"rssi":-78,"mode":"Press","state":"OFF","batt":94}
- {"rssi":-66,"calib":true,"batt":55,"pos":50,"state":"open","light":1}
- {"rssi":-66,"scale":"c","batt":55,"C":"21.5","F":"70.7","hum":"65"}
- {"rssi":-77,"batt":89,"motion":"NO MOTION","led":"OFF","sensedistance":"LONG","light":"DARK"}
- {"rssi":-76,"batt":91,"motion":"NO MOTION","contact":"CLOSED","light":"DARK","incount":1,"outcount":3,"buttoncount":4}
Example attribute responses per device are detected:
- <ESPMQTTTopic>/bot/<name>/state
- <ESPMQTTTopic>/curtain/<name>/state
- <ESPMQTTTopic>/meter/<name>/state
- <ESPMQTTTopic>/contact/<name>/state (contact sensor has motion and contact. state = contact)
- <ESPMQTTTopic>/motion/<name>/state
Example payload:
- "ON"
- "OFF"
- "OPEN"
- "CLOSE"
ESP32 will respond with MQTT on 'position' topic for every configured device
- <ESPMQTTTopic>/curtain/<name>/position
Example response payload:
- {"pos":0}
- {"pos":100}
- {"pos":50}
Example topic responses specific to motion/contact sensors:
- <ESPMQTTTopic>/motion/<name>/motion Example response payload: "MOTION", "NO MOTION"
- <ESPMQTTTopic>/motion/<name>/illuminance Example response payload: "LIGHT", "DARK"
- <ESPMQTTTopic>/contact/<name>/contact Example response payload: "OPEN", "CLOSED"
- <ESPMQTTTopic>/contact/<name>/motion Example response payload: "MOTION", "NO MOTION"
- <ESPMQTTTopic>/contact/<name>/illuminance Example response payload: "LIGHT", "DARK"
- <ESPMQTTTopic>/contact/<name>/in Example response payload: "IDLE", "ENTERED"
- <ESPMQTTTopic>/contact/<name>/out Example response payload: "IDLE", "EXITED"
- <ESPMQTTTopic>/contact/<name>/button Example response payload: "IDLE", "PUSHED"
Note: You can use the button on the contact sensor to trigger other non-switchbot devices from your smarthub
When <ESPMQTTTopic>/contact/<name>/button = "PUSHED"
// REQUESTSETTINGS WORKS FOR BOT ONLY - DOCUMENTATION NOT AVAILABLE ONLINE FOR CURTAIN
ESP32 will Subscribe to MQTT topic for device settings information (requires getBotResponse = true)
- <ESPMQTTTopic>/requestSettings
send a JSON payload of the device you want to requestSettings
example payloads =
{"id":"switchbotone"}
ESP32 will respond with MQTT on
- <ESPMQTTTopic>/#
Example responses per device are detected:
- <ESPMQTTTopic>/bot/<name>/settings
Example payloads:
- {"firmware":4.9,"timers":0,"inverted":false,"hold":5}
// SET HOLD TIME ON BOT
ESP32 will Subscribe to MQTT topic setting hold time on bots
- <ESPMQTTTopic>/setHold
send a JSON payload of the device you want to set hold
example payloads =
{"id":"switchbotone", "hold":5}
{"id":"switchbotone", "hold":"5"}
ESP32 will respond with MQTT on
- <ESPMQTTTopic>/#
ESP32 will respond with MQTT on 'status' topic for every configured device
- <ESPMQTTTopic>/bot/<name>/status
Example reponses:
- <ESPMQTTTopic>/bot/<name>/status
Example payload:
- {"status":"connected", "command":"5"}
- {"status":"errorConnect", "command":"5"}
- {"status":"errorCommand", "command":"NOTVALID"}
- {"status":"commandSent", "command":"5"}
- {"status":"busy", "value":3, "command":"5"}
- {"status":"failed", "value":9, "command":"5"}
- {"status":"success", "value":1, "command":"5"}
- {"status":"success", "value":5, "command":"5"}
- {"status":"success", "command":"REQUESTSETTINGS"}
// holdPress = set bot hold value, then call press on bot (without disconnecting in between)
ESP32 will Subscribe to MQTT topic to action a holdPress on bots
- <ESPMQTTTopic>/holdPress
send a JSON payload of the device you want to set hold then press
example payloads =
{"id":"switchbotone", "hold":5}
{"id":"switchbotone", "hold":"5"}
ESP32 will respond with MQTT on
- <ESPMQTTTopic>/#
ESP32 will respond with MQTT on 'status' topic for every configured device
- <ESPMQTTTopic>/bot/<name>/status
Example reponses:
- <ESPMQTTTopic>/bot/<name>/status
Example response payload:
- {"status":"connected", "command":"5"}
- {"status":"errorConnect", "command":"5"}
- {"status":"errorCommand", "command":"NOTVALID"}
- {"status":"commandSent", "command":"5"}
- {"status":"busy", "value":3, "command":"5"}
- {"status":"failed", "value":9, "command":"5"}
- {"status":"success", "value":1, "command":"5"}
- {"status":"success", "value":5, "command":"5"}
- {"status":"success", "command":"REQUESTSETTINGS"}
- {"status":"connected", "command":"PRESS"}
- {"status":"errorConnect", "command":"PRESS"}
- {"status":"commandSent", "command":"PRESS"}
- {"status":"busy", "value":3, "command":"PRESS"}
- {"status":"failed", "value":9, "command":"PRESS"}
- {"status":"success", "value":1, "command":"PRESS"}
- {"status":"success", "value":5, "command":"PRESS"}
// SET MODE ON BOT
ESP32 will Subscribe to MQTT topic setting mode for bots
- <ESPMQTTTopic>/setMode
send a JSON payload of the device you want to set mode
example payloads =
{"id":"switchbotone", "mode":"MODEPRESS"}
{"id":"switchbotone", "mode":"MODESWITCH"}
{"id":"switchbotone", "mode":"MODEPRESSINV"}
{"id":"switchbotone", "mode":"MODESWITCHINV"}
ESP32 will respond with MQTT on 'status' topic for every configured device
- <ESPMQTTTopic>/bot/<name>/status
Example reponses:
- <ESPMQTTTopic>/bot/<name>/status
Example payload:
- {"status":"connected", "command":"MODEPRESS"}
- {"status":"errorConnect", "command":"MODEPRESS"}
- {"status":"errorCommand", "command":"NOTVALID"}
- {"status":"commandSent", "command":"MODEPRESS"}
- {"status":"busy", "value":3, "command":"MODEPRESS"}
- {"status":"failed", "value":9, "command":"MODEPRESS"}
- {"status":"success", "value":1, "command":"MODEPRESS"}
- {"status":"success", "value":5, "command":"MODEPRESS"}
ESP32 will respond with MQTT on ESPMQTTTopic with ESP32 status
- <ESPMQTTTopic>
example payloads:
{status":"idle"}
{status":"scanning"}
{status":"boot"}
Errors that cannot be linked to a specific device will be published to
- <ESPMQTTTopic>
*/
#include <NimBLEDevice.h>
#include <ArduinoJson.h>
#include <WiFi.h>
#include <WiFiClient.h>
#include <EspMQTTClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include <Update.h>
#include <CRC32.h>
#include <ArduinoQueue.h>
#include <fauxmoESP.h>
fauxmoESP fauxmo;
/****************** CONFIGURATIONS TO CHANGE *******************/
/********** REQUIRED SETTINGS TO CHANGE **********/
/* Wifi Settings */
static const char* host = "esp32"; // Unique name for ESP32. The name detected by your router and MQTT. If you are using more then 1 ESPs to control different switchbots be sure to use unique hostnames. Host is the MQTT Client name and is used in MQTT topics
static const char* ssid = "SSID"; // WIFI SSID
static const char* password = "Password"; // WIFI Password
/* MQTT Settings */
/* MQTT Client name is set to WIFI host from Wifi Settings*/
static const char* mqtt_host = "192.168.0.1"; // MQTT Broker server ip
static const char* mqtt_user = "switchbot"; // MQTT Broker username. If empty or NULL, no authentication will be used
static const char* mqtt_pass = "switchbot"; // MQTT Broker password
static const int mqtt_port = 1883; // MQTT Port
static const std::string mqtt_main_topic = "switchbot"; // MQTT main topic
/* Switchbot Bot Settings */
static std::map<std::string, std::string> allBots = {
/*{ "switchbotone", "xX:xX:xX:xX:xX:xX" },
{ "switchbottwo", "yY:yY:yY:yY:yY:yY" }*/
};
/* Switchbot Curtain Settings */
static const int curtainClosedPosition = 10; // When 2 curtains are controlled (left -> right and right -> left) it's possible one of the curtains pushes one of the switchbots more open. Change this value to set a position where a curtain is still considered closed
static std::map<std::string, std::string> allCurtains = {
/*{ "curtainone", "xX:xX:xX:xX:xX:xX" },
{ "curtaintwo", "yY:yY:yY:yY:yY:yY" }*/
};
/* Switchbot Meter Settings */
static std::map<std::string, std::string> allMeters = {
/*{ "meterone", "xX:xX:xX:xX:xX:xX" },
{ "metertwo", "yY:yY:yY:yY:yY:yY" }*/
};
/* Switchbot Contact Sensor Settings */
static std::map<std::string, std::string> allContactSensors = {
/*{ "contactone", "xX:xX:xX:xX:xX:xX" },
{ "contacttwo", "yY:yY:yY:yY:yY:yY" }*/
};
/* Switchbot Motion Sensor Settings */
static std::map<std::string, std::string> allMotionSensors = {
/*{ "motionone", "xX:xX:xX:xX:xX:xX" },
{ "motiontwo", "yY:yY:yY:yY:yY:yY" }*/
};
/* Switchbot Bot Passwords */
static std::map<std::string, std::string> allPasswords = { // Set all the bot passwords (setup in app first). Ignore if passwords are not used
/*{ "switchbotone", "switchbotonePassword" },
{ "switchbottwo", "switchbottwoPassword" }*/
};
/*** Bots in PRESS mode to simulate ON/OFF - ESP32 will try to keep track of the ON/OFF state of your device while in PRESS mode***/
// Add bots while in PRESS mode that will simulate ON/OFF. Default state will be used if no MQTT retained on state topic
// false = default state = OFF
// true = default state = ON
// If the state is incorrect, call set STATEOFF or STATEON
static std::map<std::string, bool> botsSimulateONOFFinPRESSmode = {
/*{ "switchbotone", false },
{ "switchbottwo", false }*/
};
//Add bots OFF hold time for simulated ON/OFF, if not in list, the current hold value will be used. Device must be in botsSimulateONOFFinPRESSmode list
static std::map<std::string, int> botsSimulatedOFFHoldTimes = {
/*{ "switchbotone", 0 },
{ "switchbottwo", 10 }*/
};
//Add bots ON hold time for simulated ON/OFF, if not in list, the current hold value will be used. Device must be in botsSimulateONOFFinPRESSmode list
static std::map<std::string, int> botsSimulatedONHoldTimes = {
/*{ "switchbotone", 15 },
{ "switchbottwo", 1}*/
};
/********************************************/
/********** ADVANCED SETTINGS - ONLY NEED TO CHANGE IF YOU WANT TO TWEAK SETTINGS **********/
/* ESP32 LED Settings */
#define LED_PIN LED_BUILTIN // If your board doesn't have a defined LED_BUILTIN (You will get a compile error), comment this line out
//#define LED_PIN 2 // If your board doesn't have a defined LED_BUILTIN, uncomment this line out and replace 2 with the LED pin value
static const bool ledHighEqualsON = true; // ESP32 board LED ON=HIGH (Default). If your ESP32 LED is turning OFF on scanning and turning ON while IDLE, then set this value to false
static const bool ledOnBootScan = true; // Turn on LED during initial boot scan
static const bool ledOnScan = true; // Turn on LED while scanning (non-boot)
static const bool ledOnCommand = true; // Turn on LED while MQTT command is processing. If scanning, LED will blink after scan completes. You may not notice it, there is no delay after scan
/* Webserver Settings */
static const bool useLoginScreen = false; // use a basic login popup to avoid unwanted access
static const String otaUserId = "admin"; // user Id for OTA update. Ignore if useLoginScreen = false
static const String otaPass = "admin"; // password for OTA update. Ignore if useLoginScreen = false
static WebServer server(599); // default port 80
/* Home Assistant Settings */
static const bool home_assistant_mqtt_discovery = true; // Enable to publish Home Assistant MQTT Discovery config
static const std::string home_assistant_mqtt_prefix = "homeassistant"; // MQTT Home Assistant prefix
static const bool home_assistant_expose_seperate_curtain_position = true; // When enabled, a seperate sensor will be added that will expose the curtain position. This is useful when using the Prometheus integration to graph curtain positions. The cover entity doesn't expose the position for Prometheus
static const bool home_assistant_use_opt_mode = false; // For bots in switch mode assume on/off right away. Optimistic mode. (Icon will change in HA). If devices were already configured in HA, you need to delete them and reboot esp32
/* Switchbot General Settings */
static const int tryConnecting = 60; // How many times to try connecting to bot
static const int trySending = 30; // How many times to try sending command to bot
static const int initialScan = 120; // How many seconds to scan for bots on ESP reboot and autoRescan. Once all devices are found scan stops, so you can set this to a big number
static const int infoScanTime = 60; // How many seconds to scan for single device status updates
static const int rescanTime = 600; // Automatically rescan for device info of all devices every X seconds (default 10 min)
static const int queueSize = 50; // Max number of control/requestInfo/rescan MQTT commands stored in the queue. If you send more then queueSize, they will be ignored
static const int defaultBotWaitTime = 2; // wait at least X seconds between control command send to bots. ESP32 will detect if bot is in press mode with a hold time and will add hold time to this value per device
static const int defaultCurtainWaitTime = 0; // wait at least X seconds between control command send to curtains
static const int waitForResponseSec = 20; // How many seconds to wait for a bot/curtain response
static const int noResponseRetryAmount = 5; // How many times to retry if no response received
static const int defaultScanAfterControlSecs = 10; // Default How many seconds to wait for state/status update call after set/control command. *override with botScanTime list
static const int defaultMeterScanSecs = 60; // Default Scan/MQTT Update for meter temp sensors every X seconds. *override with botScanTime list
static const int defaultMotionScanSecs = 60; // Default Scan/MQTT Update for motion sensors every X seconds. *override with botScanTime list
static const int defaultContactScanSecs = 60; // Default Scan/MQTT Update for contact temp sensors every X seconds. *override with botScanTime list
static const int waitForMQTTRetainMessages = 5; // Only for bots in simulated ON/OFF: On boot ESP32 will look for retained MQTT state messages for X secs, otherwise default state is used
static const bool autoRescan = true; // perform automatic rescan (uses rescanTime and initialScan).
static const bool scanAfterControl = true; // perform requestInfo after successful control command (uses botScanTime).
static const bool waitBetweenControl = true; // wait between commands sent to bot/curtain (avoids sending while bot is busy)
static const bool getSettingsOnBoot = true; // Currently only works for bot (curtain documentation not available but can probably be reverse engineered easily). Get bot extra settings values like firmware, holdSecs, inverted, number of timers. ***If holdSecs is available it is used by waitBetweenControl
static const bool getBotResponse = true; // get a response from the bot devices. A response of "success" means the most recent command was successful. A response of "busy" means the bot was busy when the command was sent
static const bool getCurtainResponse = true; // get a response from the curtain devices. A response of "success" means the most recent command was successful. A response of "busy" means the bot was busy when the command was sent
static const bool retryBotOnBusy = true; // Requires getBotResponse = true. if bot responds with busy, the last control command will retry until success
static const bool retryCurtainOnBusy = true; // Requires getCurtainResponse = true. if curtain responds with busy, the last control command will retry until success
static const bool retryBotActionNoResponse = false; // Retry if bot doesn't send a response. Bot default is false because no response can still mean the bot triggered.
static const bool retryBotSetNoResponse = true; // Retry if bot doesn't send a response when requesting settings (hold, firwmare etc) or settings hold/mode
static const bool retryCurtainNoResponse = true; // Retry if curtain doesn't send a response. Default is true. It shouldn't matter if curtain receives the same command twice (or multiple times)
static const bool immediateBotStateUpdate = true; // ESP32 will send ON/OFF state update as soon as MQTT is received. You can set this = false if not using Home Assistant Discovery.
static const bool immediateCurtainStateUpdate = true; // ESP32 will send OPEN/CLOSE and Position state update as soon as MQTT is received. You can set this = false if not using Home Assistant Discovery.
static const bool assumeNoResponseMeansSuccess = true; // Only for bots in simulated ON/OFF: If the ESP32 does not receive a response after sending command (after noResponseRetryAmount reached and retryBotActionNoResponse = true) assume it worked and change state
static const bool printSerialOutputForDebugging = false; // Only set to true when you want to debug an issue from Arduino IDE. Lots of Serial output from scanning can crash the ESP32
/* Switchbot Bot/Meter/Curtain scan interval */
/* Meters don't support commands so will be scanned every <int> interval automatically if scanAfterControl = true */
/* Requires scanAfterControl = true */
static std::map<std::string, int> botScanTime = { // X seconds after a successful control command ESP32 will perform a requestInfo on the bot. If a "hold time" is set on the bot include that value + 5to10 secs. Hold time is auto added to default value. Default is 10+Hold sec if not in list
/*{ "switchbotone", 10 },
{ "switchbottwo", 10 },
{ "curtainone", 20 },
{ "curtaintwo", 20 },
{ "meterone", 60 },
{ "metertwo", 60 }*/
};
/* Requires waitBetweenControl = true. Switchbot Bot/Curtain wait between control commands - overrides defaults */
/* for Bots: if defaultBotWaitTime is greater, defaultBotWaitTime is used */
/* for Curtains: if defaultCurtainWaitTime is greater, defaultBotWaitTime is used */
/* The ESP32 will wait at least X seconds before sending the next command to each device. 2+ different Bots can still be controlled together */
/* The ESP32 will automatically collect hold Secs for bots and will wait at least that long */
static std::map<std::string, int> botWaitBetweenControlTimes = {
/*{ "switchbotone", 5 },
{ "switchbottwo", 5 },
{ "curtainone", 5 },
{ "curtaintwo", 5 }*/
};
/*************************************************************/
/* ANYTHING CHANGED BELOW THIS COMMENT MAY RESULT IN ISSUES - ALL SETTINGS TO CONFIGURE ARE ABOVE THIS LINE */
static const String versionNum = "v6.4-Alexa-alpha";
/*
Server Index Page
*/
static const String serverIndex =
"<link rel='stylesheet' href='https://code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css'>"
"<style> .ui-progressbar { position: relative; }"
".progress-label { position: absolute; width: 100%; text-align: center; top: 6px; font-weight: bold; text-shadow: 1px 1px 0 #fff; }</style>"
"<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"
"<script src='https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>"
"<script src='https://code.jquery.com/ui/1.12.1/jquery-ui.js'></script>"
"<script>"
"$( function() { var progressbar = $( \"#progressbar\" ), progressLabel = $( '.progress-label' );"
"progressbar.progressbar({ value: '0', change: function() {"
"progressLabel.text( progressbar.progressbar( 'value' ) + '%' );},"
"complete: function() { progressLabel.text( 'Uploaded!' ); } });"
"progressbar.find( '.ui-progressbar-value' ).css({'background': '#8fdbb2'});"
"$('form').submit(function(e){"
"e.preventDefault();"
"var form = $('#upload_form')[0];"
"var data = new FormData(form);"
" $.ajax({"
"url: '/update',"
"type: 'POST',"
"data: data,"
"contentType: false,"
"processData:false,"
"xhr: function() {"
"var xhr = new window.XMLHttpRequest();"
"xhr.upload.addEventListener('progress', function(evt) {"
"if (evt.lengthComputable) {"
"var per = evt.loaded / evt.total;"
"progressbar.progressbar( \"value\", Math.round(per*100) );"
"}"
"}, false);"
"return xhr;"
"},"
"success:function(d, s) {"
"console.log('success!')"
"},"
"error: function (a, b, c) {"
"}"
"});"
"});"
"});"
"</script>"
"<table bgcolor='A09F9F' align='center' style='top: 250px;position: relative;width: 30%;'>"
"<tr>"
"<td colspan=2>"
"<center><font size=5><b>SwitchBot ESP32 MQTT version: " + versionNum + "</b></font> <font size=1><b>(Unofficial)</b></font></center>"
"<center><font size=3>Hostname/MQTT Client Name: " + std::string(host).c_str() + "</font></center>"
"<center><font size=3>MQTT Main Topic: " + std::string(mqtt_main_topic).c_str() + "</font></center>"
"<br>"
"</td>"
"<br>"
"<br>"
"</tr>"
"<tr>"
"<td>Upload .bin file:</td>"
"<td><input type='file' name='update'></td>"
"</tr>"
"<tr>"
"<td colspan='2'><div id='progressbar'><div class='progress-label'>0%</div></div></td>"
"</tr>"
"<tr>"
"<td colspan='2' align='center'><input type='submit' value='Update'></td>"
"</tr>"
"</table>"
"</form>";
static EspMQTTClient client(
ssid,
password,
mqtt_host,
(mqtt_user == NULL || strlen(mqtt_user) < 1) ? NULL : mqtt_user,
(mqtt_user == NULL || strlen(mqtt_user) < 1) ? NULL : mqtt_pass,
host,
mqtt_port
);
static const uint16_t mqtt_packet_size = 1024;
static const bool home_assistant_discovery_set_up = false;
static const std::string manufacturer = "WonderLabs SwitchBot";
static const std::string curtainModel = "Curtain";
static const std::string curtainName = "WoCurtain";
static const std::string botModel = "Bot";
static const std::string botName = "WoHand";
static const std::string meterModel = "Meter";
static const std::string meterName = "WoSensorTH";
static const std::string contactModel = "Contact";
static const std::string contactName = "WoContact";
static const std::string motionModel = "Motion";
static const std::string motionName = "WoMotion";
static int ledONValue = HIGH;
static int ledOFFValue = LOW;
void scanEndedCB(NimBLEScanResults results);
void rescanEndedCB(NimBLEScanResults results);
void initialScanEndedCB(NimBLEScanResults results);
bool isBotDevice(std::string aDevice);
bool isMeterDevice(std::string aDevice);
bool isCurtainDevice(std::string aDevice);
bool isMotionDevice(std::string aDevice);
bool isContactDevice(std::string aDevice);
bool processQueue();
void startForeverScan();
void recurringMeterScan();
uint32_t getPassCRC(std::string aDevice);
bool is_number(const std::string & s);
bool controlMQTT(std::string device, std::string payload, bool disconnectAfter);
bool sendCommand(NimBLEAdvertisedDevice * advDeviceToUse, const char * type, int attempts, bool disconnectAfter);
bool sendToDevice(NimBLEAdvertisedDevice * advDevice, std::string aName, const char * command, std::string deviceTopic, bool disconnectAfter);
bool requestInfo(NimBLEAdvertisedDevice * advDeviceToUse);
bool connectToServer(NimBLEAdvertisedDevice * advDeviceToUse);
void rescanMQTT(std::string payload);
void requestInfoMQTT(std::string payload);
void recurringScan();
void recurringRescan();
void notifyCB(NimBLERemoteCharacteristic * pRemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify);
std::string getPass(std::string aDevice);
bool shouldMQTTUpdateForDevice(std::string anAddr);
static std::map<std::string, NimBLEAdvertisedDevice*> allSwitchbotsDev = {};
static std::map<std::string, NimBLEAdvertisedDevice*> allSwitchbotsScanned = {};
static std::map<std::string, long> rescanTimes = {};
static std::map<std::string, long> lastScanTimes = {};
static std::map<std::string, bool> botsSimulatedStates = {};
static std::map<std::string, std::string> motionStates = {};
static std::map<std::string, std::string> contactStates = {};
static std::map<std::string, std::string> illuminanceStates = {};
static std::map<std::string, std::string> ledStates = {};
static std::map<std::string, int> outCounts = {};
static std::map<std::string, int> entranceCounts = {};
static std::map<std::string, int> buttonCounts = {};
static std::map<std::string, std::string> lastCommandSentStrings = {};
static std::map<std::string, std::string> allSwitchbots;
static std::map<std::string, std::string> allSwitchbotsOpp;
static std::map<std::string, bool> discoveredDevices = {};
static std::map<std::string, bool> botsInPressMode = {};
static std::map<std::string, bool> botsToWaitFor = {};
static std::map<std::string, int> botHoldSecs = {};
static std::map<std::string, long> lastCommandSent = {};
static std::map<std::string, std::string> deviceTypes;
static NimBLEScan* pScan;
static bool isRescanning = false;
static bool processing = false;
static bool initialScanComplete = false;
static bool lastCommandWasBusy = false;
static bool deviceHasBooted = false;
static bool gotSettings = false;
static bool lastCommandSentPublished = false;
static bool forceRescan = false;
//static bool waitForDeviceCreation = false;
static bool overrideScan = false;
static char aBuffer[200];
static const std::string ESPMQTTTopic = mqtt_main_topic + "/" + std::string(host);
static const std::string esp32Topic = ESPMQTTTopic + "/esp32";
static const std::string rssiStdStr = esp32Topic + "/rssi";
static const std::string lastWillStr = ESPMQTTTopic + "/lastwill";
static const char* lastWill = lastWillStr.c_str();
static const std::string botTopic = ESPMQTTTopic + "/bot/";
static const std::string curtainTopic = ESPMQTTTopic + "/curtain/";
static const std::string meterTopic = ESPMQTTTopic + "/meter/";
static const std::string contactTopic = ESPMQTTTopic + "/contact/";
static const std::string motionTopic = ESPMQTTTopic + "/motion/";
static const std::string rescanStdStr = ESPMQTTTopic + "/rescan";
//static std::string controlStdStr = ESPMQTTTopic + "/control";
static const std::string controlStdStr = ESPMQTTTopic + "/#/#/set";
static const std::string requestInfoStdStr = ESPMQTTTopic + "/requestInfo";
static const std::string requestSettingsStdStr = ESPMQTTTopic + "/requestSettings";
static const std::string setModeStdStr = ESPMQTTTopic + "/setMode";
static const std::string setHoldStdStr = ESPMQTTTopic + "/setHold";
static const std::string holdPressStdStr = ESPMQTTTopic + "/holdPress";
static const String rescanTopic = rescanStdStr.c_str();
static const String controlTopic = controlStdStr.c_str();
static const String requestInfoTopic = requestInfoStdStr.c_str();
static const String requestSettingsTopic = requestSettingsStdStr.c_str();
static const String setModeTopic = setModeStdStr.c_str();
static const String setHoldTopic = setHoldStdStr.c_str();
static const String holdPressTopic = holdPressStdStr.c_str();
static byte bArrayPress[] = {0x57, 0x01};
static byte bArrayOn[] = {0x57, 0x01, 0x01};
static byte bArrayOff[] = {0x57, 0x01, 0x02};
static byte bArrayOpen[] = {0x57, 0x0F, 0x45, 0x01, 0x05, 0xFF, 0x00};
static byte bArrayClose[] = {0x57, 0x0F, 0x45, 0x01, 0x05, 0xFF, 0x64};
static byte bArrayPause[] = {0x57, 0x0F, 0x45, 0x01, 0x00, 0xFF};
static byte bArrayPos[] = {0x57, 0x0F, 0x45, 0x01, 0x05, 0xFF, NULL};
static byte bArrayGetSettings[] = {0x57, 0x02};
static byte bArrayHoldSecs[] = {0x57, 0x0F, 0x08, NULL };
static byte bArrayBotMode[] = {0x57, 0x03, 0x64, NULL, NULL};
static byte bArrayPressPass[] = {0x57, 0x11, NULL, NULL, NULL, NULL};
static byte bArrayOnPass[] = {0x57, 0x11, NULL , NULL, NULL, NULL, 0x01};
static byte bArrayOffPass[] = {0x57, 0x11, NULL, NULL, NULL, NULL, 0x02};
static byte bArrayGetSettingsPass[] = {0x57, 0x12, NULL, NULL, NULL, NULL};
static byte bArrayHoldSecsPass[] = {0x57, 0x1F, NULL, NULL, NULL, NULL, 0x08, NULL };
//static byte bArrayBotModePass[] = {0x57, 0x13, 0x64, NULL, NULL, NULL, NULL, NULL}; // Other github documentation shows this to be the array for setting mode with password (firmware 4.5, 4.6)
static byte bArrayBotModePass[] = {0x57, 0x13, NULL, NULL, NULL, NULL, 0x64, NULL}; // The proper array to use for setting mode with password (firmware 4.9)
struct to_lower {
int operator() ( int ch )
{
return std::tolower ( ch );
}
};
struct QueueCommand {
std::string payload;
std::string topic;
std::string device;
bool disconnectAfter;
bool priority;
int currentTry;
};
ArduinoQueue<QueueCommand> commandQueue(queueSize);
static long lastOnlinePublished = 0;
static long lastRescan = 0;
static long lastScanCheck = 0;
static bool noResponse = false;
static bool waitForResponse = false;
static std::string lastDeviceControlled = "";
void publishLastwillOnline() {
if ((millis() - lastOnlinePublished) > 30000) {
if (client.isConnected()) {
client.publish(lastWill, "online", true);
lastOnlinePublished = millis();
String rssi = String(WiFi.RSSI());
client.publish(rssiStdStr.c_str(), rssi.c_str());
}
}
}
void publishHomeAssistantDiscoveryESPConfig() {
String wifiMAC = String(WiFi.macAddress());
client.publish((home_assistant_mqtt_prefix + "/sensor/" + host + "/linkquality/config").c_str(), ("{\"~\":\"" + esp32Topic + "\"," +
+ "\"name\":\"" + host + " Linkquality\"," +
+ "\"device\": {\"identifiers\":[\"switchbotesp_" + host + "_" + wifiMAC.c_str() + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + "ESP32" + "\",\"name\": \"" + host + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbotesp_" + host + "_" + wifiMAC.c_str() + "_linkquality\"," +
+ "\"stat_t\":\"~/rssi\"," +
+ "\"icon\":\"mdi:signal\"," +
+ "\"unit_of_meas\": \"rssi\"}").c_str(), true);
}
void publishHomeAssistantDiscoveryBotConfig(std::string deviceName, std::string deviceMac, bool optimistic) {
std::transform(deviceMac.begin(), deviceMac.end(), deviceMac.begin(), ::toupper);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/battery/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Battery\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_battery\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"battery\"," +
+ "\"unit_of_meas\": \"%\", " +
+ "\"value_template\":\"{{ value_json.batt }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/linkquality/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Linkquality\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_linkquality\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"icon\":\"mdi:signal\"," +
+ "\"unit_of_meas\": \"rssi\", " +
+ "\"value_template\":\"{{ value_json.rssi }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/binary_sensor/" + deviceName + "/inverted/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Inverted\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "inverted\"," +
+ "\"stat_t\":\"~/settings\"," +
+ "\"icon\":\"mdi:cog\"," +
+ "\"pl_on\":true," +
+ "\"pl_off\":false," +
+ "\"value_template\":\"{{ value_json.inverted }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/mode/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Mode\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_mode\"," +
+ "\"icon\":\"mdi:cog\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"value_template\":\"{{ value_json.mode }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/firmware/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Firmware\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_firmware\"," +
+ "\"icon\":\"mdi:cog\"," +
+ "\"stat_t\":\"~/settings\"," +
+ "\"value_template\":\"{{ value_json.firmware }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/holdsecs/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " HoldSecs\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_holdsecs\"," +
+ "\"icon\":\"mdi:cog\"," +
+ "\"stat_t\":\"~/settings\"," +
+ "\"value_template\":\"{{ value_json.hold }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/timers/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Timers\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_timers\"," +
+ "\"icon\":\"mdi:cog\"," +
+ "\"stat_t\":\"~/settings\"," +
+ "\"value_template\":\"{{ value_json.timers }}\"}").c_str(), true);
std::string optiString;
if (optimistic) {
optiString = "true";
}
else {
optiString = "false";
}
client.publish((home_assistant_mqtt_prefix + "/switch/" + deviceName + "/config").c_str(), ("{\"~\":\"" + (botTopic + deviceName) + "\", " +
+ "\"name\":\"" + deviceName + " Switch\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + botModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "\", " +
+ "\"stat_t\":\"~/state\", " +
+ "\"opt\":" + optiString + ", " +
+ "\"cmd_t\": \"~/set\" }").c_str(), true);
}
void publishHomeAssistantDiscoveryCurtainConfig(std::string deviceName, std::string deviceMac) {
std::transform(deviceMac.begin(), deviceMac.end(), deviceMac.begin(), ::toupper);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/battery/config").c_str(), ("{\"~\":\"" + (curtainTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Battery\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + curtainModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_battery\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"battery\"," +
+ "\"unit_of_meas\": \"%\", " +
+ "\"value_template\":\"{{ value_json.batt }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/linkquality/config").c_str(), ("{\"~\":\"" + (curtainTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Linkquality\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + curtainModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_linkquality\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"icon\":\"mdi:signal\"," +
+ "\"unit_of_meas\": \"rssi\", " +
+ "\"value_template\":\"{{ value_json.rssi }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/illuminance/config").c_str(), ("{\"~\":\"" + (curtainTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Illuminance\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + curtainModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_illuminance\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"illuminance\"," +
+ "\"value_template\":\"{{ value_json.light }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/binary_sensor/" + deviceName + "/calibrated/config").c_str(), ("{\"~\":\"" + (curtainTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Calibrated\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + curtainModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_calibrated\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"icon\":\"mdi:cog\"," +
+ "\"pl_on\":true," +
+ "\"pl_off\":false," +
+ "\"value_template\":\"{{ value_json.calib }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/cover/" + deviceName + "/config").c_str(), ("{\"~\":\"" + (curtainTopic + deviceName) + "\", " +
+ "\"name\":\"" + deviceName + " Curtain\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + curtainModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "\", " +
+ "\"dev_cla\":\"curtain\", " +
+ "\"stat_t\":\"~/state\", " +
+ "\"stat_open\": \"OPEN\", " +
+ "\"stat_clsd\": \"CLOSE\", " +
+ "\"stat_stopped\": \"PAUSE\", " +
+ "\"pl_stop\":\"PAUSE\", " +
+ "\"pos_open\": 100, " +
+ "\"pos_clsd\": 0, " +
+ "\"cmd_t\": \"~/set\", " +
+ "\"pos_t\":\"~/position\", " +
+ "\"pos_tpl\":\"{{ value_json.pos }}\", " +
+ "\"set_pos_t\": \"~/set\", " +
+ "\"set_pos_tpl\": \"{{ position }}\" }").c_str(), true);
if (home_assistant_expose_seperate_curtain_position) {
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/position/config").c_str(), ("{\"~\":\"" + (curtainTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Position\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + curtainModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_position\"," +
+ "\"stat_t\":\"~/position\"," +
+ "\"unit_of_meas\": \"%\", " +
+ "\"value_template\":\"{{ value_json.pos }}\"}").c_str(), true);
}
}
void publishHomeAssistantDiscoveryMeterConfig(std::string deviceName, std::string deviceMac) {
std::transform(deviceMac.begin(), deviceMac.end(), deviceMac.begin(), ::toupper);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/battery/config").c_str(), ("{\"~\":\"" + (meterTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Battery\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + meterModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_battery\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"battery\"," +
+ "\"unit_of_meas\": \"%\", " +
+ "\"value_template\":\"{{ value_json.batt }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/linkquality/config").c_str(), ("{\"~\":\"" + (meterTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Linkquality\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + meterModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_linkquality\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"icon\":\"mdi:signal\"," +
+ "\"unit_of_meas\": \"rssi\", " +
+ "\"value_template\":\"{{ value_json.rssi }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/temperature/config").c_str(), ("{\"~\":\"" + (meterTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Temperature\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + meterModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_temperature\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"temperature\", " +
+ "\"unit_of_meas\": \"°C\", " +
+ "\"value_template\":\"{{ value_json.C }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/humidity/config").c_str(), ("{\"~\":\"" + (meterTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Humidity\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + meterModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_humidity\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"humidity\", " +
+ "\"unit_of_meas\": \"%\", " +
+ "\"value_template\":\"{{ value_json.hum }}\"}").c_str(), true);
}
void publishHomeAssistantDiscoveryContactConfig(std::string deviceName, std::string deviceMac) {
std::transform(deviceMac.begin(), deviceMac.end(), deviceMac.begin(), ::toupper);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/battery/config").c_str(), ("{\"~\":\"" + (contactTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Battery\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + contactModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_battery\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"battery\"," +
+ "\"unit_of_meas\": \"%\", " +
+ "\"value_template\":\"{{ value_json.batt }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/linkquality/config").c_str(), ("{\"~\":\"" + (contactTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Linkquality\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + contactModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_linkquality\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"icon\":\"mdi:signal\"," +
+ "\"unit_of_meas\": \"rssi\", " +
+ "\"value_template\":\"{{ value_json.rssi }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/sensor/" + deviceName + "/contact/config").c_str(), ("{\"~\":\"" + (contactTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Contact\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + contactModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_contact\"," +
+ "\"icon\":\"mdi:door\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"value_template\":\"{{ value_json.contact }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/binary_sensor/" + deviceName + "/motion/config").c_str(), ("{\"~\":\"" + (contactTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " Motion\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + contactModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_motion\"," +
+ "\"stat_t\":\"~/attributes\"," +
+ "\"dev_cla\":\"motion\"," +
+ "\"pl_on\":\"MOTION\"," +
+ "\"pl_off\":\"NO MOTION\"," +
+ "\"value_template\":\"{{ value_json.motion }}\"}").c_str(), true);
client.publish((home_assistant_mqtt_prefix + "/binary_sensor/" + deviceName + "/in/config").c_str(), ("{\"~\":\"" + (contactTopic + deviceName) + "\"," +
+ "\"name\":\"" + deviceName + " In\"," +
+ "\"device\": {\"identifiers\":[\"switchbot_" + deviceMac + "\"],\"manufacturer\":\"" + manufacturer + "\",\"model\":\"" + contactModel + "\",\"name\": \"" + deviceName + "\" }," +
+ "\"avty_t\": \"" + lastWill + "\"," +
+ "\"uniq_id\":\"switchbot_" + deviceMac + "_in\"," +
+ "\"icon\":\"mdi:motion-sensor\"," +
+ "\"stat_t\":\"~/in\"," +
+ "\"pl_on\":\"ENTERED\"," +