automaticly updated release notes for mega-20180331

[Build ESP32] Fix for build issues between ESP32 and ESP8266

.github/issue_template.md

@@ -3,7 +3,7 @@
 ### Steps to reproduce
 How can we trigger this problem?
 
-Does the problem presist after powering off and on? (just resetting isnt enough sometimes)
+Does the problem persists after powering off and on? (just resetting isn't enough sometimes)
 
 ### Expected behavior
 Tell us what should happen?

.gitignore

@@ -1,7 +1,18 @@
+## OS Specific Hidden Files ####
+
+# MacOSX Finder *****
+.DS_Store
+
+# Fuse FileSystem ***
+.fuse_hidden*
+
+
+## PlatformIO ##################
 .pioenvs
 .clang_complete
 .gcc-flags.json
 .piolibdeps
 
+## Project #####################
 lib/readme.txt
 src/Custom.h

.travis.yml

@@ -27,7 +27,7 @@ install:
 script:
   # - cppcheck --enable=warning src/*.ino -q --force -I src --include=src/ESPEasy.ino --error-exitcode=1
   # - ./memanalyzer.py ~/.platformio/packages/toolchain-xtensa/bin/xtensa-lx106-elf-objdump
-  - PLATFORMIO_BUILD_FLAGS="-D CONTINUOUS_INTEGRATION" platformio run -s
+  - PLATFORMIO_BUILD_FLAGS="-D CONTINUOUS_INTEGRATION" platformio run 
 
   # patch platformio core libs for PUYA bug (https://github.com/letscontrolit/ESPEasy/issues/650)
   - cd patches; ./check_puya_patch; cd ..

before_deploy

@@ -12,11 +12,13 @@ for ENV in \
   normal_ESP8285_1024 \
   test_ESP8266_1024\
   test_ESP8266_4096\
+  test_ESP8266_4096_VCC\
   test_ESP8285_1024\
   dev_ESP8266_1024\
   dev_ESP8266_4096\
   dev_ESP8285_1024\
-  dev_ESP8266PUYA_1024;\
+  dev_ESP8266PUYA_1024\
+  dev_ESP8266PUYA_1024_VCC;\
 do
   echo
   echo "### Deploying environment $ENV for version $VERSION"

crc2.py

@@ -1,10 +1,12 @@
- 
 
 import sys
 import binascii
 import struct
 import md5
-MD5DUMMY = "MD5_MD5_MD5_MD5_BoundariesOfTheSegmentsGoHere..."
+import os
+MD5DUMMY      = "MD5_MD5_MD5_MD5_BoundariesOfTheSegmentsGoHere..." #48 chars
+FILENAMEDUMMY = "ThisIsTheDummyPlaceHolderForTheBinaryFilename..." #48 chars
+
 MemorySegmentStart,MemorySegmentEnd,MemoryContent=[],[],[]
  
 ##################################################################
@@ -14,12 +16,15 @@ def showSegments (fileContent,offset):
     global MemorySegmentStart, MemorySegmentEnd, MemoryContent
     header = struct.unpack("ii", fileContent[offset:offset+8])
     herestr =""
+    herestr2 =""
     MemorySegmentStart.append(struct.pack("I",header[0]))
     MemorySegmentEnd.append(struct.pack("I",header[0]+header[1])) 
     MemoryContent.append(fileContent[offset+8:offset+8+header[1]])
     if  fileContent.find( MD5DUMMY, offset+8, offset+8+header[1]) >0 :
         herestr= " <-- CRC is here."
-    print ("SEGMENT "+ str(len(MemorySegmentStart)-1)+ ": memory position: " + hex(header[0])+" to " + hex(header[0]+header[1]) +  " length: " + hex(header[1])+herestr)
+    if  fileContent.find( FILENAMEDUMMY, offset+8, offset+8+header[1]) >0 :
+        herestr2= " <-- filename is here."
+    print ("SEGMENT "+ str(len(MemorySegmentStart)-1)+ ": memory position: " + hex(header[0])+" to " + hex(header[0]+header[1]) +  " length: " + hex(header[1])+herestr+herestr2)
     #print ("first byte positoin in file: " + hex( offset+8))
     #print ("last byte postion in file: " + hex(offset+8+header[1]-1))
     return (8+offset+ header[1]); # return start of next segment
@@ -82,6 +87,17 @@ while len(startArray) < 16 :
 if (len(endArray) + len (startArray)) != 32 :
     print("ERROR: please make sure you add / remove padding if you change the semgents.") 
 
+BinaryFileName = "";
+if  fileContent.find( FILENAMEDUMMY) < 0:
+    print("ERROR: FILENAMEDUMMY dummy not found in binary")
+else:
+	BinaryFileName=os.path.basename(FileName) +"\0"
+	if len(BinaryFileName) >48:								# check that filename is <48 chars
+		BinaryFileName=BinaryFileName[0:48]					# truncate if necessary. 49th char in ESP is zero already
+	else:
+		BinaryFileName= BinaryFileName.ljust(48,'\0');		# pad with zeros. 	
+			
+
 if  fileContent.find( MD5DUMMY) < 0:
     print("ERROR: MD5 dummy not found in binary")
 else:
@@ -91,6 +107,10 @@ else:
     md5hash = m.digest()
     print("MD5 hash: "+ m.hexdigest())
     print("\nwriting output file:\n" + FileName)
+	
+    fileContent=fileContent.replace(MD5DUMMY,md5hash+startArray+endArray)
+    fileContent=fileContent.replace(FILENAMEDUMMY,BinaryFileName)
+
     with open(FileName, mode='wb') as file: # b is important -> binary
-      file.write(fileContent.replace(MD5DUMMY,md5hash+startArray+endArray))
+      file.write(fileContent)
 #k=input("press close to exit") 

dist/Release_notes.txt

@@ -1,3 +1,678 @@
+-------------------------------------------------
+Changes in release mega-20180331 (since mega-20180330)
+-------------------------------------------------
+
+Release date: Sat Mar 31 04:00:09 CEST 2018
+
+TD-er (2):
+      [Build ESP32] Fix for build issues between ESP32 and ESP8266
+      [ESP32] Build errors/warnings
+
+mvdbro (1):
+      ESP32: Fix Wifi Disconnect reason
+
+
+-------------------------------------------------
+Changes in release mega-20180330 (since mega-20180329)
+-------------------------------------------------
+
+Release date: Fri Mar 30 04:00:10 CEST 2018
+
+Gijs Noorlander (1):
+      Build issue with Arduino IDE
+
+
+-------------------------------------------------
+Changes in release mega-20180329 (since mega-20180328)
+-------------------------------------------------
+
+Release date: Thu Mar 29 04:00:11 CEST 2018
+
+TD-er (2):
+      [ESP32] Event driven WiFi for ESP32
+      [Arduino IDE] Revert changes in include paths
+
+
+-------------------------------------------------
+Changes in release mega-20180328 (since mega-20180327)
+-------------------------------------------------
+
+Release date: Wed Mar 28 04:00:09 CEST 2018
+
+TD-er (2):
+      [Build] Cleanup/split builds using defines
+      [build] Disabled a few PlatformIO profiles for now.
+
+mvdbro (1):
+      Fix nesting level check
+
+soif (1):
+      Initial re-organisation of plugin sets (#1019)
+
+
+-------------------------------------------------
+Changes in release mega-20180327 (since mega-20180326)
+-------------------------------------------------
+
+Release date: Tue Mar 27 04:00:09 CEST 2018
+
+TD-er (1):
+      [issue #1174] Show degree sign via external writes to LCD
+
+
+-------------------------------------------------
+Changes in release mega-20180326 (since mega-20180324)
+-------------------------------------------------
+
+Release date: Mon Mar 26 04:00:14 CEST 2018
+
+Bartlomiej Zimon (1):
+      - fix for #1170 - uservar not setted on encwrite
+
+Brian Setz (1):
+      [P1] Support for latest standard
+
+TD-er (3):
+      [Command] Parsing improvement for commands
+      [wifi] Event based connect/reconnect
+      [NTP] Speedup NTP again with async WiFi
+
+
+-------------------------------------------------
+Changes in release mega-20180324 (since mega-20180323)
+-------------------------------------------------
+
+Release date: Sat Mar 24 04:00:10 CET 2018
+
+TD-er (3):
+      [WiFi] Reverted those temp String uses for ssid/pass
+      [issue #1131] Add %unixtime%
+      [issue #1097] Call MQTTclient.loop() during deepsleep
+
+
+-------------------------------------------------
+Changes in release mega-20180323 (since mega-20180322)
+-------------------------------------------------
+
+Release date: Fri Mar 23 04:00:06 CET 2018
+
+mvdbro (1):
+      ESP32 fix
+
+
+-------------------------------------------------
+Changes in release mega-20180322 (since mega-20180321)
+-------------------------------------------------
+
+Release date: Thu Mar 22 04:00:11 CET 2018
+
+Bartlomiej Zimon (7):
+      - P012 fix command interpretation
+      - P023 fix command interpretation
+      - P035 move strings to flash
+      - P048 fetch params only when needed
+      - P012 fix command interpretation
+      - P023 fix command interpretation
+      - P048 fetch params only when needed
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180321
+
+Gijs Noorlander (1):
+      [merge issue] Forgotten #endif in merge
+
+TD-er (6):
+      [wifi] Make more robust checks and increase timeout
+      - P035 move strings to flash
+      [wifi] Make more robust checks and increase timeout
+      [Memory] parseTemplate did not check if markers were found
+      [WiFi] Take much more time for initial WiFi connect during setup
+      [WiFi] Take much more time for initial WiFi connect during setup
+
+Unknown (1):
+      [Memory] parseTemplate did not check if markers were found
+
+s0170071 (2):
+      Serial WD crash
+      Serial WD crash
+
+
+-------------------------------------------------
+Changes in release mega-20180321 (since mega-20180320)
+-------------------------------------------------
+
+Release date: Wed Mar 21 04:00:08 CET 2018
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180320
+
+Unknown (2):
+      [wifi] Setup with factory settings could not complete
+      [wifi] Setup with factory settings could not complete
+
+
+-------------------------------------------------
+Changes in release mega-20180320 (since mega-20180319)
+-------------------------------------------------
+
+Release date: Tue Mar 20 04:00:10 CET 2018
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180319
+
+Gijs Noorlander (1):
+      Revert "Merge pull request #1116 from TD-er/feature/allow_own_defaults"
+
+Unknown (3):
+      Revert "Merge pull request #1116 from TD-er/feature/allow_own_defaults"
+      [issue #1097] WiFi connect with deepsleep enabled trigger watchdog reset
+      [issue #1097] WiFi connect with deepsleep enabled trigger watchdog reset
+
+es-ka (2):
+      Fix wiring description for SN75176 transceiver
+      Fix wiring description for SN75176 transceiver
+
+
+-------------------------------------------------
+Changes in release mega-20180319 (since mega-20180316)
+-------------------------------------------------
+
+Release date: Mon Mar 19 04:00:11 CET 2018
+
+Bartlomiej Zimon (5):
+      Add download button for current rule set
+      - add encoder write #1086
+      - fix success setting
+      - fix P073 success setting in PLUGIN_WRITE callback
+      - initialize pointer in P073
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180316
+
+Gijs Noorlander (6):
+      Add download button for current rule set (#1102)
+      - add encoder write command #1086 (#1103)
+      Changed so that running all tasks immediately with deep sleep enabled… (#1110)
+      Merge pull request #1112 from uzi18/fix-p073
+      Merge pull request #1114 from TD-er/feature/wifi_details_json
+      Merge pull request #1118 from TD-er/bugfix/mqtt_publish_after_deep_sleep
+
+Panayotis Kouvarakis (1):
+      Changed so that running all tasks immediately with deep sleep enabled only happens on first iteration after wake up
+
+Unknown (11):
+      [WiFi] Try to minimize effect of WiFi interruptions
+      [Relaxed WiFi] Perform WiFi initialization in steps
+      [Travis error] Some #include test that wasn't meant to be included
+      [JSON] Add uint name (#1099) and WiFi information (PR #1113)
+      [issue #1007] Allow user specific data in separate file
+      #ifndef instead of #ifdef
+      [issue #1007] Add other defines as suggested by @uzi18
+      [issue #1097] MQTT publish after deep sleep
+      Merge pull request #1113 from TD-er/feature/reduce_impact_wifi_disconnect
+      Merge pull request #1116 from TD-er/feature/allow_own_defaults
+      [merge] MIssing #endif due to merging.
+
+s0170071 (2):
+      changed memory tracker to uint64_t for the ESP32
+      Keep uint. Just change the init value.
+
+
+-------------------------------------------------
+Changes in release mega-20180316 (since mega-20180315)
+-------------------------------------------------
+
+Release date: Fri Mar 16 04:00:11 CET 2018
+
+Bartlomiej Zimon (3):
+      - move all structs from ESPEasy.ino into header file     - add some fix for headers     - add const to rtttl notes array
+      Merge branch 'mega' of github.com:letscontrolit/ESPEasy into mega
+      Merge branch 'mega' of github.com:letscontrolit/ESPEasy into mega
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180313
+
+Gijs Noorlander (3):
+      MCP3221 allow values for calibration (#1073)
+      [issue #1066] Fix Webserver handle_control (#1079)
+      Fixed multi instance problem on SHT3x #433 (#1081)
+
+JK (1):
+      Fixed #433
+
+Unknown (9):
+      [issue #1066] Fix Webserver handle_control
+      - move all structs from ESPEasy.ino into header file
+      [v2.0 split globals] Base split on v2.0 version of ESPEasy.ino
+      [issue #1057] AM PM display issue
+      [issue #993] variable in MQTT subscribe topic
+      [issue #951] Changed System#Initialized  => System#Wake
+      [issue #1057] AM PM display issue
+      [issue #993] variable in MQTT subscribe topic
+      [issue #951] Changed System#Initialized  => System#Wake
+
+mvdbro (4):
+      #893 part1, send messages
+      Custom controller GUI option
+      #893, part 2 receiving
+      Rules fix
+
+sassod (1):
+      12bit ADC values acceted up to 4095
+
+
+-------------------------------------------------
+Changes in release mega-20180315 (since mega-20180314)
+-------------------------------------------------
+
+Release date: Thu Mar 15 04:00:08 CET 2018
+
+mvdbro (3):
+      Custom controller GUI option
+      #893, part 2 receiving
+      Rules fix
+
+
+-------------------------------------------------
+Changes in release mega-20180314 (since mega-20180313)
+-------------------------------------------------
+
+Release date: Wed Mar 14 04:00:11 CET 2018
+
+mvdbro (1):
+      #893 part1, send messages
+
+
+-------------------------------------------------
+Changes in release mega-20180313 (since mega-20180312)
+-------------------------------------------------
+
+Release date: Tue Mar 13 04:00:11 CET 2018
+
+Bartlomiej Zimon (4):
+      - fix for #1065
+      - remove double trimm()
+      - fix for #1065
+      - remove double trimm()
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180312
+
+Unknown (1):
+      Rule Engine minor fix and added dev debugging
+
+mvdbro (1):
+      ESP32 C010 fix
+
+
+-------------------------------------------------
+Changes in release mega-20180312 (since mega-20180311)
+-------------------------------------------------
+
+Release date: Mon Mar 12 04:00:07 CET 2018
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180311
+
+Unknown (4):
+      [issue #1039 ] Change CSS to show topmost SSID on large screens
+      [webserver] Improve chunked transfer
+      [issue #1039 ] Change CSS to show topmost SSID on large screens
+      [webserver] Improve chunked transfer
+
+mvdbro (1):
+      Rule Engine minor fix and added dev debugging
+
+
+-------------------------------------------------
+Changes in release mega-20180311 (since mega-20180310)
+-------------------------------------------------
+
+Release date: Sun Mar 11 04:00:06 CET 2018
+
+ESPEasy release bot (2):
+      automaticly updated release notes for v2.0-20180309
+      automaticly updated release notes for v2.0-20180310
+
+Unknown (19):
+      Move plugin init before WiFi init
+      [Conversions] Use more decimals in conversions and add AM/PM for time.
+      Update P07 Plugin
+      [AM/PM] Am/Pm notation doesn't have '0' hours
+      [P073] Remove tm1637_bitDelay()
+      Improve flash read performance
+      Add read buffer to rule processing to speedup parsing
+      Final ruleset speed-up
+      [AM/PM] Am/Pm notation doesn't have '0' hours
+      Update P07 Plugin
+      [P073] Remove tm1637_bitDelay()
+      [deepsleep] Make sure the 'shortcut' of running all services when sleep enabled
+      [OLED] fix drawProgressBar
+      [deepsleep] Make sure the 'shortcut' of running all services when sleep enabled
+      [OLED] fix drawProgressBar
+      [DNS lookup] Controllers sometimes try to connect to 0.0.0.0
+      [DNS lookup] Controllers sometimes try to connect to 0.0.0.0
+      [issue #1039] Topmost SSID are covered on mobile Browser
+      [issue #1039] Topmost SSID are covered on mobile Browser
+
+mvdbro (5):
+      Improve flash read performance
+      Rule Engine, stop waisting time on non matching rules
+      Add read buffer to rule processing to speedup parsing
+      Final ruleset speed-up
+      Rule Engine, stop waisting time on non matching rules
+
+
+-------------------------------------------------
+Changes in release mega-20180310 (since mega-20180309)
+-------------------------------------------------
+
+Release date: Sat Mar 10 04:00:07 CET 2018
+
+Unknown (2):
+      Move plugin init before WiFi init
+      [Conversions] Use more decimals in conversions and add AM/PM for time.
+
+
+-------------------------------------------------
+Changes in release mega-20180309 (since mega-20180308)
+-------------------------------------------------
+
+Release date: Fri Mar  9 04:00:11 CET 2018
+
+ESPEasy release bot (3):
+      automaticly updated release notes for v2.0-20180305
+      automaticly updated release notes for v2.0-20180306
+      automaticly updated release notes for v2.0-20180307
+
+Gijs Noorlander (2):
+      Fixes P073 plugin for latest TM1637 based 7 segments displays modules (#996) (#1022)
+      [CSS] Quick fix for smaller displays (#1026)
+
+Unknown (5):
+      [issue #1012] Removed Content-Length header + improved webserver speed
+      [Rule Events] Add a number of events to handle in rules and awake timer
+      [Rule Events] Add a number of events to handle in rules and awake timer
+      [issue #1015] Add other simple conversions like Celsius to Fahrenheit, etc.
+      [issue #1015] Add other simple conversions like Celsius to Fahrenheit, etc.
+
+
+-------------------------------------------------
+Changes in release mega-20180308 (since mega-20180307)
+-------------------------------------------------
+
+Release date: Thu Mar  8 04:00:08 CET 2018
+
+mvdbro (2):
+      First step towards port monitoring without tasks
+      Second step towards port monitoring without tasks
+
+
+-------------------------------------------------
+Changes in release mega-20180307 (since mega-20180305)
+-------------------------------------------------
+
+Release date: Wed Mar  7 04:00:09 CET 2018
+
+Unknown (2):
+      [CSS] Quick fix for smaller displays
+      [issue #1012] Removed Content-Length header + improved webserver speed
+
+
+-------------------------------------------------
+Changes in release mega-20180305 (since mega-20180304)
+-------------------------------------------------
+
+Release date: Mon Mar  5 04:00:08 CET 2018
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180304
+
+Edwin Eefting (2):
+      dont build in silent mode to prevent travis timeouts
+      automaticly updated release notes for v2.0-20180304b
+
+Unknown (3):
+      [Webserver] Factory Reset was present twice
+      [issue #528] Set DOUT flash mode for all 1M builds
+      [issue #1003 ] Add conversion of wind direction to string
+
+mvdbro (3):
+      ESP32 fix-2 for P020/P044
+      ESP32 - 32 Tasks
+      ESP32 - 32 Tasks -redo commit
+
+soif (2):
+      Add OS specific hidden files (#1005)
+      fixes typos in the issue template (#1006)
+
+
+-------------------------------------------------
+Changes in release mega-20180304 (since mega-20180303)
+-------------------------------------------------
+
+Release date: Sun Mar  4 04:00:08 CET 2018
+
+Bartlomiej Zimon (4):
+      - pcfgpio,port,2 sets pin as input     - fix for #222,#702 - we can mix inputs and outputs now
+      - extend conditions with AND/OR, now it is possible to simplify rules
+      - remove Serial print
+      - support for more comparisions in IF conditions: >=,<=,!=,<>,<,>,=       also fix extended conditions when first check is not >
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180303
+
+Gijs Noorlander (2):
+      Merge pull request #1000 from uzi18/test3  (more comparisions in IF condition)
+      _P072_HDC1080 allow to send values to the controllers (#999)
+
+Unknown (2):
+      [issue #993] Add %unit% variable in MQTT subscribe topic
+      [issue #892 ] Only use sensor type when really needed
+
+clumsy-stefan (1):
+      add success and break statement
+
+mvdbro (1):
+      ESP32 Dallas DS18B20 fix
+
+soif (1):
+      Fixes P073 plugin for latest TM1637 based 7 segments displays modules
+
+
+-------------------------------------------------
+Changes in release mega-20180303 (since mega-20180302)
+-------------------------------------------------
+
+Release date: Sat Mar  3 04:00:08 CET 2018
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180302
+
+Unknown (5):
+      revert json to non-chunking #988 from s0170071/mega
+      [issue #293] json output nan values not double quoted
+      Add Task device type to json by @s0170071
+      [Issue #827] MQTT not using proper case for %sysname% variable.
+      Add AND/OR to rules & prevent unwanted case changes in strings (#994)
+
+s0170071 (3):
+      revert json to non-chunking
+      Add git build and local time
+      make handle_json return void
+
+
+-------------------------------------------------
+Changes in release mega-20180302 (since mega-20180228)
+-------------------------------------------------
+
+Release date: Fri Mar  2 04:00:10 CET 2018
+
+Bartłomiej Zimoń (4):
+      provide System@Sleep event (#875)
+      add format #O to templates to show OFF/ON instead 0/1 (#949)
+      fix #964, add timeStringToSeconds and use it to compare time conditions (#965)
+      add format #O to templates to show OFF/ON instead 0/1 (#949)
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180228
+
+Gijs Noorlander (1):
+      Merge pull request #983 from kahvm/mega
+
+Unknown (4):
+      [issue #914] _P053_PMSx003 Dust Sensor looses sync
+      [issue #914] Check first 2 bytes of packet
+      [Build error fix] Must-keep-focus-when-pressing-buttons...
+      [webserver] Layout of code to improve readability
+
+kahvm (1):
+      Support for degree sign on LCD1602
+
+mvdbro (2):
+      Rule wildcard option on literal events
+      Rule wildcard option on literal events
+
+s0170071 (1):
+      Add Factory Reset button to web interface (#954)
+
+
+-------------------------------------------------
+Changes in release mega-20180228 (since mega-20180227)
+-------------------------------------------------
+
+Release date: Wed Feb 28 04:00:09 CET 2018
+
+Bartłomiej Zimoń (1):
+      fix #964, add timeStringToSeconds and use it to compare time conditions (#965)
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180227
+
+Gijs Noorlander (2):
+      [issue #966] Add %sysweekday% and  %sysweekday_s% (#973)
+      [issue #968] Use template parser for OLED commands (#974)
+
+
+-------------------------------------------------
+Changes in release mega-20180227 (since mega-20180226)
+-------------------------------------------------
+
+Release date: Tue Feb 27 04:00:11 CET 2018
+
+Bartłomiej Zimoń (1):
+      add format #O to templates to show OFF/ON instead 0/1 (#949)
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180226
+
+Edwin Eefting (2):
+      [test suite] changes from mega to 2.0
+      [test suite] changes from mega to 2.0
+
+Gijs Noorlander (2):
+      [BuildError] StreamingBuffer code cleanup + fix order member initialize (#961)
+      [build conflict] Renamed ESP32 version of ping (#963)
+
+mvdbro (1):
+      Fix ESP32 compile errors
+
+s0170071 (1):
+      Add Factory Reset button to web interface (#954)
+
+
+-------------------------------------------------
+Changes in release mega-20180226 (since mega-20180224)
+-------------------------------------------------
+
+Release date: Mon Feb 26 04:00:08 CET 2018
+
+Bartłomiej Zimoń (2):
+      provide System@Sleep event (#875) (#931)
+      - extend conditions with AND/OR, now it is possible to simplify rules (#932)
+
+ESPEasy release bot (1):
+      automaticly updated release notes for v2.0-20180221
+
+Edwin Eefting (1):
+      device page doesnt need next/previous page buttons anymore
+
+Gijs Noorlander (7):
+      [MQTT] LWT "Connected" message doesn't have the retained flag (#925)
+      [v2.0] Added Vcc-binaries to deploy process #933 (#935)
+      [v2.0 merge] 2kwebserver_merge_to_mega #929 (#934)
+      [v2.0] Use ESPeasySoftwareSerial (#936)
+      [Mega] rename SoftwareSerial lib #930 (#937)
+      [timeouts] Improve response when hosts are not reachable (#939)
+      [2k Webserver] Proper initialisation of StreamingBuffer members. (#941)
+
+Michael Schröder (1):
+      Added Vcc-binaries to deploy process (#933)
+
+Unknown (2):
+      [ping lib] Added ping library
+      [softwareSerial] Remove duplicate with only capilization as difference
+
+s0170071 (33):
+      Webserver min memory
+      Adjusted to min 7k free
+      Timeout 100ms
+      tcp_cleanup for LWIP1 & 2
+      Adapted timeout
+      trigger travis re-compile
+      try fix travis
+      Does Travis like extern "C" ?
+      Wait for memory be like before send chunked
+      "Content-Type","text/html"
+      Optimized memory usage
+      2k Webserver
+      fix travis
+      fix travis
+      Unused variable
+      navMenuIndex
+      fix download page
+      Add Ram usage debug message
+      fix Travis
+      Travis...
+      Cleanup and +1k Ram
+      4->12 Devices per page
+      Fix travis
+      Update .gitignore
+      Merge Webserver
+      Fixed String redeclaration
+      Merge into mega
+      fix travis
+      Removed double entry on info page
+      Fix compile error when SD card is enabled
+      Memtracker (#927)
+      V20 Webserver@LowMemory
+      Update WebServer.ino
+
+
+-------------------------------------------------
+Changes in release mega-20180224 (since mega-20180223)
+-------------------------------------------------
+
+Release date: Sat Feb 24 04:00:06 CET 2018
+
+mvdbro (2):
+      Fix ESP32 compile errors
+      ESP32 fixed P020 and P044
+
+
+-------------------------------------------------
+Changes in release mega-20180223 (since mega-20180221)
+-------------------------------------------------
+
+Release date: Fri Feb 23 04:00:07 CET 2018
+
+GHolli (1):
+      * BugFix: According to the data sheet, the offset for the detection range values (command byte 0x99) is 3..4 instead of 6..7 (#921)
+
+s0170071 (1):
+      Include name of binary file in crc2.py and sysinfo (#918)
+
+
 -------------------------------------------------
 Changes in release mega-20180221 (since mega-20180220)
 -------------------------------------------------

lib/ESP32_ping/PingTest/PingTest.ino

@@ -0,0 +1,74 @@
+/*
+ Name:		PingTest.ino
+ Created:	05/08/2017 10:20:19
+ Author:	pbecc
+*/
+#undef PROVA_
+
+
+#include <WiFi.h>
+#include  "esp32_ping.h"
+
+// the setup function runs once when you press reset or power the board
+const char ssid[] = "TP-LINK_C20B";  //  your network SSID (name)
+const char password[] = "paolo-48";       // your network password
+
+void setup() {
+
+	Serial.begin(115200);
+	Serial.print("Connecting t ");
+	Serial.println(ssid);
+	// WiFi.mode(WIFI_STA);
+
+	WiFi.begin(ssid, password);
+
+
+	while (WiFi.status() != WL_CONNECTED) {
+		delay(500);
+		Serial.print(".");
+
+
+	}
+	Serial.println("Pinging address: 192.168.1.1");
+}
+
+// the loop function runs over and over again until power down or reset
+void loop() {
+	int ia[4] = { 192,168,1,1 };
+	int  i = 0;
+	while (Serial.available()) {
+
+		char c = Serial.read();
+		delay(100);
+   	int  val = 0;
+		while (c != '.' &&  c != 10 && c!=255) {
+			if (c >= '0'&& c<='9') {
+				val = val*10+(c-'0');
+			}
+			c = Serial.read();
+		}
+
+			ia[i++] =val ;
+	}
+	IPAddress adr = IPAddress(ia[0], ia[1], ia[2], ia[3]);
+	Serial.printf("Ping : %d . %d . %d . %d ->", ia[0], ia[1], ia[2], ia[3]);
+	if (ping_start(adr, 4, 0, 0, 5))
+		Serial.println("OK");
+	else
+		Serial.println("FAILED");
+	delay(10000);
+
+}
+int readnu(char s) {
+	char c = Serial.read();
+	Serial.print(c);
+	int digit = 1,val=0;
+	while (c != s &&  c != 10&&c>0) {
+		if(c>'0') val += digit*(c - '0');
+		digit *= 10;
+		c=Serial.read();
+		Serial.print(int(c));
+	}
+	Serial.println(digit);
+	return digit;
+}

lib/ESP32_ping/README.md

@@ -0,0 +1,4 @@
+# ESP32_ping
+Ping library for ESP32
+
+WORK IN PROGRESS

lib/ESP32_ping/esp32_ping.cpp

@@ -0,0 +1,366 @@
+/*
+* ESP32 Ping library
+*
+* All rights reserved.
+*
+* Permission to use, copy, modify, and distribute this software
+* and its documentation for any purpose and without fee is hereby
+* granted, provided that the above copyright notice appear in all
+* copies and that both that the copyright notice and this
+* permission notice and warranty disclaimer appear in supporting
+* documentation, and that the name of the author not be used in
+* advertising or publicity pertaining to distribution of the
+* software without specific, written prior permission.
+*
+* The author disclaim all warranties with regard to this
+* software, including all implied warranties of merchantability
+* and fitness.  In no event shall the author be liable for any
+* special, indirect or consequential damages or any damages
+* whatsoever resulting from loss of use, data or profits, whether
+* in an action of contract, negligence or other tortious action,
+* arising out of or in connection with the use or performance of
+* this software.
+*
+* --------------------------------------------------------------------------------
+*  Ping Library is based on the following source code:
+*
+* Lua RTOS, ping utility
+*
+*
+* Author: Jaume Oliv� (jolive@iberoxarxa.com / jolive@whitecatboard.org)
+*
+* --------------------------------------------------------------------------------
+*
+* Redistribution and use in source and binary forms, with or without modification,
+* are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice,
+*    this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the documentation
+*    and/or other materials provided with the distribution.
+* 3. The name of the author may not be used to endorse or promote products
+*    derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+* OF SUCH DAMAGE.
+*
+* This file is part of the lwIP TCP/IP stack.
+*
+*/
+
+#ifdef ESP32
+
+#include <Arduino.h>
+
+#include <math.h>
+#include <float.h>
+#include <signal.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+
+#include "esp32_ping.h"
+
+#include "lwip/inet_chksum.h"
+#include "lwip/ip.h"
+#include "lwip/ip4.h"
+#include "lwip/err.h"
+#include "lwip/icmp.h"
+#include "lwip/sockets.h"
+#include "lwip/sys.h"
+#include "lwip/netdb.h"
+#include "lwip/dns.h"
+
+static uint16_t ping_seq_num;
+static uint8_t stopped = 0;
+
+/*
+* Statistics
+*/
+static uint32_t transmitted = 0;
+static uint32_t received = 0;
+static float min_time = 0;
+static float max_time = 0;
+static float mean_time = 0;
+static float last_mean_time = 0;
+static float var_time = 0;
+
+#define PING_ID 0xAFAF
+
+#define PING_DEFAULT_COUNT    10
+#define PING_DEFAULT_INTERVAL  1
+#define PING_DEFAULT_SIZE     32
+#define PING_DEFAULT_TIMEOUT   1
+
+/*
+* Helper functions
+*
+*/
+static void ping_prepare_echo(struct icmp_echo_hdr *iecho, uint16_t len) {
+	size_t i;
+	size_t data_len = len - sizeof(struct icmp_echo_hdr);
+
+	ICMPH_TYPE_SET(iecho, ICMP_ECHO);
+	ICMPH_CODE_SET(iecho, 0);
+	iecho->chksum = 0;
+	iecho->id = PING_ID;
+	iecho->seqno = htons(++ping_seq_num);
+
+	/* fill the additional data buffer with some data */
+	for (i = 0; i < data_len; i++) {
+		((char*)iecho)[sizeof(struct icmp_echo_hdr) + i] = (char)i;
+	}
+
+	iecho->chksum = inet_chksum(iecho, len);
+}
+
+static err_t ping_send(int s, ip4_addr_t *addr, int size) {
+	struct icmp_echo_hdr *iecho;
+	struct sockaddr_in to;
+	size_t ping_size = sizeof(struct icmp_echo_hdr) + size;
+	int err;
+
+	iecho = (struct icmp_echo_hdr *)mem_malloc((mem_size_t)ping_size);
+	if (!iecho) {
+		return ERR_MEM;
+	}
+
+	ping_prepare_echo(iecho, (uint16_t)ping_size);
+
+	to.sin_len = sizeof(to);
+	to.sin_family = AF_INET;
+	inet_addr_from_ipaddr(&to.sin_addr, addr);
+
+	if ((err = sendto(s, iecho, ping_size, 0, (struct sockaddr*)&to, sizeof(to)))) {
+		transmitted++;
+	}
+
+	return (err ? ERR_OK : ERR_VAL);
+}
+
+static void ping_recv(int s) {
+	char buf[64];
+	int fromlen, len;
+	struct sockaddr_in from;
+	struct ip_hdr *iphdr;
+	struct icmp_echo_hdr *iecho = NULL;
+	char ipa[16];
+	struct timeval begin;
+	struct timeval end;
+	uint64_t micros_begin;
+	uint64_t micros_end;
+	float elapsed;
+
+	// Register begin time
+	gettimeofday(&begin, NULL);
+
+	// Send
+	while ((len = recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr*)&from, (socklen_t*)&fromlen)) > 0) {
+		if (len >= (int)(sizeof(struct ip_hdr) + sizeof(struct icmp_echo_hdr))) {
+			// Register end time
+			gettimeofday(&end, NULL);
+
+			/// Get from IP address
+			ip4_addr_t fromaddr;
+			inet_addr_to_ipaddr(&fromaddr, &from.sin_addr);
+
+			strcpy(ipa, inet_ntoa(fromaddr));
+
+			// Get echo
+			iphdr = (struct ip_hdr *)buf;
+			iecho = (struct icmp_echo_hdr *)(buf + (IPH_HL(iphdr) * 4));
+
+			// Print ....
+			if ((iecho->id == PING_ID) && (iecho->seqno == htons(ping_seq_num))) {
+				received++;
+
+				// Get elapsed time in milliseconds
+				micros_begin = begin.tv_sec * 1000000;
+				micros_begin += begin.tv_usec;
+
+				micros_end = end.tv_sec * 1000000;
+				micros_end += end.tv_usec;
+
+				elapsed = (float)(micros_end - micros_begin) / (float)1000.0;
+
+				// Update statistics
+				// Mean and variance are computed in an incremental way
+				if (elapsed < min_time) {
+					min_time = elapsed;
+				}
+
+				if (elapsed > max_time) {
+					max_time = elapsed;
+				}
+
+				last_mean_time = mean_time;
+				mean_time = (((received - 1) * mean_time) + elapsed) / received;
+
+				if (received > 1) {
+					var_time = var_time + ((elapsed - last_mean_time) * (elapsed - mean_time));
+				}
+
+				// Print ...
+				log_d("%d bytes from %s: icmp_seq=%d time=%.3f ms\r\n", len, ipa,
+					ntohs(iecho->seqno), elapsed
+				);
+
+				return;
+			}
+			else {
+				// TODO
+			}
+		}
+	}
+
+	if (len < 0) {
+		log_d("Request timeout for icmp_seq %d\r\n", ping_seq_num);
+	}
+}
+/*
+static void stop_action(int i) {
+	signal(i, SIG_DFL);
+
+	stopped = 1;
+}
++/
+/*
+* Operation functions
+*
+*/
+void ping(const char *name, int count, int interval, int size, int timeout) {
+	// Resolve name
+	hostent * target = gethostbyname(name);
+	IPAddress adr = *target->h_addr_list[0];
+	if (target->h_length == 0) {
+		// TODO: error not found target?????
+		return;
+	}
+	ping_start(adr, count, interval, size, timeout);
+}
+bool ping_start(struct ping_option *ping_o) {
+
+
+	return ping_start(ping_o->ip,ping_o->count,0,0,0);
+
+}
+bool ping_start(IPAddress adr, int count=0, int interval=0, int size=0, int timeout=0) {
+//	driver_error_t *error;
+	struct sockaddr_in address;
+	ip4_addr_t ping_target;
+	int s;
+	// Get default values if argument are not provided
+	if (count == 0) {
+		count = PING_DEFAULT_COUNT;
+	}
+
+	if (interval == 0) {
+		interval = PING_DEFAULT_INTERVAL;
+	}
+
+	if (size == 0) {
+		size = PING_DEFAULT_SIZE;
+	}
+
+	if (timeout == 0) {
+		timeout = PING_DEFAULT_TIMEOUT;
+	}
+
+	// Create socket
+	if ((s = socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
+		// TODO: error
+		return false;
+	}
+
+
+	address.sin_addr.s_addr = adr;
+	ping_target.addr = address.sin_addr.s_addr;
+
+	// Setup socket
+	struct timeval tout;
+
+	// Timeout
+	tout.tv_sec = timeout;
+	tout.tv_usec = 0;
+
+	if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &tout, sizeof(tout)) < 0) {
+		closesocket(s);
+		// TODO: error
+		return false;
+	}
+
+	stopped = 0;
+	transmitted = 0;
+	received = 0;
+	min_time = 1.E+9;// FLT_MAX;
+	max_time = 0.0;
+	mean_time = 0.0;
+	var_time = 0.0;
+
+	// Register signal for stop ping
+	//signal(SIGINT, stop_action);
+
+	// Begin ping ...
+	char ipa[16];
+
+	strcpy(ipa, inet_ntoa(ping_target));
+	log_i("PING %s: %d data bytes\r\n",  ipa, size);
+
+	ping_seq_num = 0;
+
+	while ((ping_seq_num < count) && (!stopped)) {
+		if (ping_send(s, &ping_target, size) == ERR_OK) {
+			ping_recv(s);
+		}
+		delay( interval*1000L);
+	}
+
+	closesocket(s);
+
+	log_i("%d packets transmitted, %d packets received, %.1f%% packet loss\r\n",
+		transmitted,
+		received,
+		((((float)transmitted - (float)received) / (float)transmitted) * 100.0)
+	);
+
+	if (received) {
+		ping_resp pingresp;
+		log_i("round-trip min/avg/max/stddev = %.3f/%.3f/%.3f/%.3f ms\r\n", min_time, mean_time, max_time, sqrt(var_time / received));
+		pingresp.total_count = 10;
+		pingresp.timeout_count = 10;
+		pingresp.total_bytes = 1;
+		pingresp.total_time = mean_time;
+		pingresp.ping_err = 0;
+		return true;
+	//	ping_o->sent_function(ping_o, (uint8*)&pingresp);
+	}
+	return false;
+}
+
+bool ping_regist_recv(struct ping_option *ping_opt, ping_recv_function ping_recv)
+{
+	if (ping_opt == NULL)
+		return false;
+
+	ping_opt->recv_function = ping_recv;
+	return true;
+}
+
+bool ping_regist_sent(struct ping_option *ping_opt, ping_sent_function ping_sent)
+{
+	if (ping_opt == NULL)
+		return false;
+
+	ping_opt->sent_function = ping_sent;
+	return true;
+}
+#endif

lib/ESP32_ping/esp32_ping.h

@@ -0,0 +1,36 @@
+
+#ifndef _PING_
+#define _PING_
+#include <Arduino.h>
+
+#ifdef ESP32
+
+typedef void(*ping_recv_function)(void* arg, void *pdata);
+typedef void(*ping_sent_function)(void* arg, void *pdata);
+
+struct ping_option {
+	uint32_t count;
+	uint32_t ip;
+	uint32_t coarse_time;
+	ping_recv_function recv_function;
+	ping_sent_function sent_function;
+	void* reverse;
+};
+
+struct ping_resp {
+	uint32_t total_count;
+	uint32_t resp_time;
+	uint32_t seqno;
+	uint32_t timeout_count;
+	uint32_t bytes;
+	uint32_t total_bytes;
+	uint32_t total_time;
+	int8_t  ping_err;
+};
+
+bool ping_start(struct ping_option *ping_opt);
+void ping(const char *name, int count, int interval, int size, int timeout);
+bool ping_start(IPAddress adr, int count, int interval, int size, int timeout);
+
+#endif
+#endif

lib/ESPEasySoftwareSerial/README.md

@@ -1,4 +1,4 @@
-# EspESPeasySoftwareSerial
+# ESPeasySoftwareSerial
 
 Implementation of the Arduino software serial library for the ESP8266
 
@@ -7,5 +7,3 @@ Speed up to 115200 baud is supported. The constructor also has an optional input
 
 Please note that due to the fact that the ESP always have other activities ongoing, there will be some inexactness in interrupt
 timings. This may lead to bit errors when having heavy data traffic in high baud rates.
-
-

lib/ESPEasySoftwareSerial/library.json

@@ -1,5 +1,5 @@
 {
-    "name": "EspESPeasySoftwareSerial",
+    "name": "ESPeasySoftwareSerial",
     "version": "3.3.1",
     "keywords": [
       "serial", "io", "softwareserial"

lib/ESPEasy_ESP8266Ping/LICENSE

@@ -0,0 +1,456 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.

lib/ESPEasy_ESP8266Ping/README.md

@@ -0,0 +1,40 @@
+# ESP8266Ping
+Let the ESP8266 ping a remote machine.
+
+With this library an ESP8266 can ping a remote machine and know if it's reachable.
+It provide some basic measurements on ping messages (avg response time).
+
+## Usage
+
+First, include the library in your sketch along with WiFi library:
+
+```Arduino
+#include <ESP8266WiFi.h>
+#include <ESP8266Ping.h>
+```
+
+Next, simply call the `Ping.ping()` function
+
+```Arduino
+IPAddress ip (192, 168, 0, 1); // The remote ip to ping
+bool ret = Ping.ping(ip);
+```
+
+`ret` will be true if the remote responded to pings, false if not reachable.
+The library supports hostname too, just pass a string instead of the ip address:
+
+```Arduino
+bool ret = Ping.ping("www.google.com");
+```
+
+Additionally, the function accept a second integer parameter `count` that specify how many pings has to be sent:
+
+```Arduino
+bool ret = Ping.ping(ip_or_host, 10);
+```
+
+After `Ping.ping()` has been called, the average response time (in milliseconds) can be retrieved with
+
+```Arduino
+int avg_time_ms = Ping.averageTime();
+```

lib/ESPEasy_ESP8266Ping/examples/HostPing/HostPing.ino

@@ -0,0 +1,43 @@
+/*
+ * This example show how to ping a remote machine using it's hostname
+ */
+
+#include <ESP8266WiFi.h>
+#include <ESP8266Ping.h>
+
+const char* ssid     = "ssid";
+const char* password = "passphrase";
+
+const char* remote_host = "www.google.com";
+
+void setup() {
+  Serial.begin(115200);
+  delay(10);
+
+  // We start by connecting to a WiFi network
+
+  Serial.println();
+  Serial.println("Connecting to WiFi");
+  
+  WiFi.begin(ssid, password);
+  
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(100);
+    Serial.print(".");
+  }
+
+  Serial.println();
+  Serial.print("WiFi connected with ip ");  
+  Serial.println(WiFi.localIP());
+
+  Serial.print("Pinging host ");
+  Serial.println(remote_host);
+
+  if(Ping.ping(remote_host)) {
+    Serial.println("Success!!");
+  } else {
+    Serial.println("Error :(");
+  }
+}
+
+void loop() { }

lib/ESPEasy_ESP8266Ping/examples/SimplePing/SimplePing.ino

@@ -0,0 +1,44 @@
+/*
+ * With this library an ESP8266 can ping a remote machine and know if it's reachable. 
+ * It provides some basic measurements on ping messages (avg response time).
+ */
+
+#include <ESP8266WiFi.h>
+#include <ESP8266Ping.h>
+
+const char* ssid     = "ssid";
+const char* password = "passphrase";
+
+const IPAddress remote_ip(192, 168, 0, 1);
+
+void setup() {
+  Serial.begin(115200);
+  delay(10);
+
+  // We start by connecting to a WiFi network
+
+  Serial.println();
+  Serial.println("Connecting to WiFi");
+  
+  WiFi.begin(ssid, password);
+  
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(100);
+    Serial.print(".");
+  }
+
+  Serial.println();
+  Serial.print("WiFi connected with ip ");  
+  Serial.println(WiFi.localIP());
+
+  Serial.print("Pinging ip ");
+  Serial.println(remote_ip);
+
+  if(Ping.ping(remote_ip)) {
+    Serial.println("Success!!");
+  } else {
+    Serial.println("Error :(");
+  }
+}
+
+void loop() { }

lib/ESPEasy_ESP8266Ping/keywords.txt

@@ -0,0 +1,26 @@
+#######################################
+# Syntax Coloring Map For ESP8266Ping
+#######################################
+
+#######################################
+# Library (KEYWORD3)
+#######################################
+
+ESP8266Ping	KEYWORD3
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+Ping	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+ping	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

lib/ESPEasy_ESP8266Ping/library.properties

@@ -0,0 +1,9 @@
+name=ESPEasy_ESP8266Ping
+version=1.0
+author=Daniele Colanardi
+maintainer=Daniele Colanardi <dancol90@gmail.com>
+sentence=Let the ESP8266 ping a remote machine.
+paragraph=With this library an ESP8266 can ping a remote machine and know if it's reachable. It provide some basic measurements on ping messages (avg response time). Lib name renamed to avoid conflicts in Arduino IDE.
+category=Communication
+url=
+architectures=esp8266

lib/ESPEasy_ESP8266Ping/src/ESP8266Ping.h

@@ -0,0 +1,61 @@
+/*
+  ESP8266Ping - Ping library for ESP8266
+  Copyright (c) 2015 Daniele Colanardi. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef ESP8266Ping_H
+#define ESP8266Ping_H
+
+#if defined(ESP8266)
+#include <Arduino.h>
+#include <ESP8266WiFi.h>
+
+extern "C" {
+  #include <ping.h>
+}
+
+#ifdef ENABLE_DEBUG_PING
+  #define DEBUG_PING(...) Serial.printf(__VA_ARGS__)
+#else
+  #define DEBUG_PING(...)
+#endif
+
+class PingClass {
+  public:
+    PingClass();
+
+    bool ping(IPAddress dest,   byte count = 5);
+    bool ping(const char* host, byte count = 5);
+
+    int averageTime();
+
+  protected:
+    static void _ping_sent_cb(void *opt, void *pdata);
+    static void _ping_recv_cb(void *opt, void *pdata);
+
+    IPAddress _dest;
+    ping_option _options;
+
+    static byte _expected_count, _errors, _success;
+    static int _avg_time;
+};
+
+#include "ESP8266Ping.impl.h"
+PingClass Ping;
+
+#endif
+#endif

lib/ESPEasy_ESP8266Ping/src/ESP8266Ping.impl.h

@@ -0,0 +1,112 @@
+/*
+  ESP8266Ping - Ping library for ESP8266
+  Copyright (c) 2015 Daniele Colanardi. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+
+extern "C" void esp_schedule();
+extern "C" void esp_yield();
+
+PingClass::PingClass() {}
+
+bool PingClass::ping(IPAddress dest, byte count) {
+    _expected_count = count;
+    _errors = 0;
+    _success = 0;
+
+    _avg_time = 0;
+
+    memset(&_options, 0, sizeof(struct ping_option));
+
+    // Repeat count (how many time send a ping message to destination)
+    _options.count = count;
+    // Time interval between two ping (seconds??)
+    _options.coarse_time = 1;
+    // Destination machine
+    _options.ip = dest;
+
+    // Callbacks
+    _options.recv_function = reinterpret_cast<ping_recv_function>(&PingClass::_ping_recv_cb);
+    _options.sent_function = NULL; //reinterpret_cast<ping_sent_function>(&_ping_sent_cb);
+
+    // Let's go!
+    if(ping_start(&_options)) {
+        // Suspend till the process end
+        esp_yield();
+    }
+
+    return (_success > 0);
+}
+
+bool PingClass::ping(const char* host, byte count) {
+    IPAddress remote_addr;
+
+    if (WiFi.hostByName(host, remote_addr))
+        return ping(remote_addr, count);
+
+    return false;
+}
+
+int PingClass::averageTime() {
+    return _avg_time;
+}
+
+void PingClass::_ping_recv_cb(void *opt, void *resp) {
+    // Cast the parameters to get some usable info
+    ping_resp*   ping_resp = reinterpret_cast<struct ping_resp*>(resp);
+    //ping_option* ping_opt  = reinterpret_cast<struct ping_option*>(opt);
+
+    // Error or success?
+    if (ping_resp->ping_err == -1)
+        _errors++;
+    else {
+        _success++;
+        _avg_time += ping_resp->resp_time;
+    }
+
+    // Some debug info
+    DEBUG_PING(
+            "DEBUG: ping reply\n"
+            "\ttotal_count = %d \n"
+            "\tresp_time = %d \n"
+            "\tseqno = %d \n"
+            "\ttimeout_count = %d \n"
+            "\tbytes = %d \n"
+            "\ttotal_bytes = %d \n"
+            "\ttotal_time = %d \n"
+            "\tping_err = %d \n",
+            ping_resp->total_count, ping_resp->resp_time, ping_resp->seqno,
+            ping_resp->timeout_count, ping_resp->bytes, ping_resp->total_bytes,
+            ping_resp->total_time, ping_resp->ping_err
+    );
+
+    // Is it time to end?
+    // Don't using seqno because it does not increase on error
+    if (_success + _errors == _expected_count) {
+        _avg_time = _avg_time / _expected_count;
+
+        DEBUG_PING("Avg resp time %d ms\n", _avg_time);
+
+        // Done, return to main functiom
+        esp_schedule();
+    }
+}
+
+byte PingClass::_expected_count = 0;
+byte PingClass::_errors = 0;
+byte PingClass::_success = 0;
+int  PingClass::_avg_time = 0;

lib/SerialDevices/jkSDS011.h

@@ -31,6 +31,7 @@
 #include "SensorSerialBuffer.h"
 #include "ESPeasySoftwareSerial.h"
 
+
 class CjkSDS011
 {
 public:

lib/esp8266-oled-ssd1306/Dialog_Plain_12_font.h

@@ -22,6 +22,10 @@ SOFTWARE.
 
 See more at http://blog.squix.ch
 */
+
+#ifndef DIALOG_PLAIN_FONT_H
+#define DIALOG_PLAIN_FONT_H
+
 // OLED library version >= 3.0.0
 // Created by http://oleddisplay.squix.ch/ Consider a donation
 // In case of problems make sure that you are using the font file with the correct version!
@@ -481,3 +485,6 @@ const char Dialog_plain_12[] PROGMEM = {
 	0x00,0x00,0xFC,0x7F,0x40,0x04,0x20,0x08,0x20,0x08,0x60,0x0C,0xC0,0x07,	// 254
 	0x00,0x00,0xE0,0x40,0x04,0x47,0x00,0x38,0x84,0x07,0xE0	// 255
 };
+
+#endif
+

lib/esp8266-oled-ssd1306/OLEDDisplay.cpp

@@ -349,7 +349,7 @@ void OLEDDisplay::drawProgressBar(uint16_t x, uint16_t y, uint16_t width, uint16
   drawHorizontalLine(xRadius, y + height, width - doubleRadius + 1);
   drawCircleQuads(x + width - radius, yRadius, radius, 0b00001001);
 
-  uint16_t maxProgressWidth = (width - doubleRadius - 1) * progress / 100;
+  uint16_t maxProgressWidth = (width - doubleRadius + 1) * progress / 100;
 
   fillCircle(xRadius, yRadius, innerRadius);
   fillRect(xRadius + 1, y + 2, maxProgressWidth, height - 3);

lib/esp8266-oled-ssd1306/OLED_SSD1306_SH1106_images.h

@@ -1,3 +1,6 @@
+#ifndef OLED_SSD1306_SH1106_IMAGES_H
+#define OLED_SSD1306_SH1106_IMAGES_H
+
 #define espeasy_logo_width 36
 #define espeasy_logo_height 36
 const char espeasy_logo_bits[] PROGMEM= {
@@ -38,3 +41,5 @@ const char inactiveSymbole[] PROGMEM = {
     B00000000,
     B00000000
 };
+
+#endif

platformio.ini

@@ -7,11 +7,11 @@
 
 #minimal version for esps with 512K or less flash (only has minimal plugin set)
 ; [env:mini_512]
-; platform = espressif8266@1.5.0
-; framework = arduino
+; platform         = ${common.platform}
+; framework        = ${common.framework}
 ; board = esp01
-; upload_speed=460800
-; build_flags = !echo -Wl,-Tesp8266.flash.512k64.ld -D BUILD_GIT=\'\"$(git describe)\"\'
+; upload_speed     = ${common.upload_speed}
+; build_flags      = !echo -Wl,-Tesp8266.flash.512k64.ld -D BUILD_GIT=\'\"$(git describe)\"\'
 ; # upload_port = /dev/ttyUSB0
 
 # add these:
@@ -19,128 +19,498 @@
 #                    -Wmissing-include-dirs -Wnoexcept -Wold-style-cast -Woverloaded-virtual -Wredundant-decls -Wshadow -Wsign-promo -Wstrict-null-sentinel
 #                    -Wstrict-overflow=5 -Wundef -Wno-unused -Wno-variadic-macros -Wno-parentheses -fdiagnostics-show-option
 # thanks @chouffe103
+[compiler_warnings]
+build_flags =
+  -Wall -Wno-parentheses -fdiagnostics-show-option
+
+##########################################################################################
+
+###### Definition cheat sheet:
+# board_flash_mode in terms of performance: QIO > QOUT > DIO > DOUT
+# for lib_ldf_mode, see http://docs.platformio.org/en/latest/librarymanager/ldf.html#ldf
+
+###### Frequently used build flags:
+# Use custom.h file to override default settings for ESPeasy: -D USE_CUSTOM_H
+# Set VCC mode to measure Vcc of ESP chip :                   -D FEATURE_ADC_VCC=true
+
+[core_2_3_0]
+platform         = espressif8266@1.5.0
+
+[core_2_4_0]
+platform         = espressif8266@1.6.0
+
+[core_esp32]
+#platform         = espressif32@0.12.0
+platform         = https://github.com/platformio/platform-espressif32.git#feature/stage
+build_flags      = -D BUILD_GIT='"${env.TRAVIS_TAG}"'
+lib_ignore       = ESPeasySoftwareSerial, EspESPeasySoftwareSerial, AS_BH1750, ESP8266WiFi, ESP8266Ping, ESP8266WebServer, ESP8266HTTPUpdateServer, ESP8266mDNS, IRremoteESP8266, ESPEasy_ESP8266Ping, SerialSensors
+lib_deps         = ESP32WebServer
+
 
 [common]
-build_flags = -D BUILD_GIT='"${env.TRAVIS_TAG}"'
+build_flags      = -D BUILD_GIT='"${env.TRAVIS_TAG}"'  ; ${compiler_warnings.build_flags}
+lib_deps         = ""
+lib_ignore       = ESP32_ping, ESP32WebServer
+lib_ldf_mode     = chain
+upload_speed     = 460800
+framework        = arduino
+board            = esp12e
+platform         = ${core_2_3_0.platform}
 
 
-#normal version with stable plugins, 1024k version
-[env:normal_ESP8266_1024]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld
-# upload_port = /dev/ttyUSB0
-
-[env:normal_ESP8266_1024_DOUT]
-platform = espressif8266@1.5.0
+[esp8266_1M]
 board_flash_mode = dout
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld
-# upload_port = /dev/ttyUSB0
+build_flags      = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld
 
-#normal version with stable plugins, 4096k version
-[env:normal_ESP8266_4096]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.4m1m.ld
-# upload_port = /dev/ttyUSB0
+[esp8285_1M]
+board            = esp8285
+board_flash_mode = ${esp8266_1M.board_flash_mode}
+build_flags      = ${esp8266_1M.build_flags} -DESP8285
 
-#normal version with stable plugins, 4096k version for esp8285
+[Sonoff]
+board            = esp01_1m
+board_flash_mode = ${esp8266_1M.board_flash_mode}
+build_flags      = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld
+
+[espWroom2M]
+board_flash_mode = dout
+board            = esp_wroom_02
+build_flags      = ${common.build_flags} -Wl,-Tesp8266.flash.2m.ld
+
+[esp8266_4M]
+board_flash_mode = dio
+build_flags      = ${common.build_flags} -Wl,-Tesp8266.flash.4m1m.ld
+
+### ESP32 pre-alpha test build ###########################################################
+# Very limited build for ESP32, to start testing regular building for ESP32.             #
+# Will probably not work, not tested and guaranteed to take a few hours time of some     #
+# still trying to build the version without reading this warning.                        #
+##########################################################################################
+[env:esp32dev]
+platform         = ${core_esp32.platform}
+board            = esp32dev
+build_flags      = ${core_esp32.build_flags}  -DPLUGIN_SET_GENERIC_ESP32
+lib_deps         = ${core_esp32.lib_deps}
+lib_ignore       = ${core_esp32.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+
+### NORMAL (STABLE) ######################################################################
+# normal version with stable plugins                                                     #
+##########################################################################################
+
+# NORMAL: 1024k version --------------------------
+[env:normal_ESP8266_1024]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board            = ${common.board}
+board_flash_mode = ${esp8266_1M.board_flash_mode}
+build_flags      = ${esp8266_1M.build_flags}
+
+# NORMAL: 1024k for esp8285 ----------------------
 [env:normal_ESP8285_1024]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp8285
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld -DESP8285
-# upload_port = /dev/ttyUSB0
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board            = ${esp8285_1M.board}
+board_flash_mode = ${esp8285_1M.board_flash_mode}
+build_flags      = ${esp8285_1M.build_flags}
+
+# NORMAL: 2048k version --------------------------
+[env:normal_WROOM02_2048]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board            = ${espWroom2M.board}
+board_flash_mode = ${espWroom2M.board_flash_mode}
+build_flags      = ${espWroom2M.build_flags}
+
+# NORMAL: 4096k version --------------------------
+[env:normal_ESP8266_4096]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board            = ${common.board}
+board_flash_mode = ${esp8266_4M.board_flash_mode}
+build_flags      = ${esp8266_4M.build_flags}
 
 
-#version with additional plugins (and dependend code) that are in test-stadium 1024k
+
+### TESTING ##############################################################################
+# additional plugins (and dependend code) that are in test-stadium                       #
+##########################################################################################
+
+# TEST: 1024k version ----------------------------
 [env:test_ESP8266_1024]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld -D PLUGIN_BUILD_TESTING
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board            = ${common.board}
+board_flash_mode = ${esp8266_1M.board_flash_mode}
+build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_BUILD_TESTING
 
-#version with additional plugins (and dependend code) that are in test-stadium 4096k
-[env:test_ESP8266_4096]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.4m1m.ld -D PLUGIN_BUILD_TESTING
-
-[env:test_ESP8266_4096_VCC]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.4m1m.ld -D PLUGIN_BUILD_TESTING -D FEATURE_ADC_VCC=true
-
-#version with additional plugins (and dependend code) that are in test-stadium 4096k for esp8285
+# TEST: 1024k for esp8285 ------------------------
 [env:test_ESP8285_1024]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp8285
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld -D PLUGIN_BUILD_TESTING -DESP8285
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8285_1M.board_flash_mode}
+board            = ${esp8285_1M.board}
+build_flags      = ${esp8285_1M.build_flags} -D PLUGIN_BUILD_TESTING
+
+# TEST: 2048k version ----------------------------
+[env:test_WROOM02_2048]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${espWroom2M.board_flash_mode}
+board            = ${espWroom2M.board}
+build_flags      = ${espWroom2M.build_flags} -D PLUGIN_BUILD_TESTING
+
+# TEST: 4096k version ----------------------------
+[env:test_ESP8266_4096]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+board            = ${common.board}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8266_4M.board_flash_mode}
+build_flags      = ${esp8266_4M.build_flags} -D PLUGIN_BUILD_TESTING
+
+# TEST: 4096k version + FEATURE_ADC_VCC ----------
+[env:test_ESP8266_4096_VCC]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+board            = ${common.board}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8266_4M.board_flash_mode}
+build_flags      = ${esp8266_4M.build_flags} -D PLUGIN_BUILD_TESTING -D FEATURE_ADC_VCC=true
 
 
-#version with additional plugins (and dependend code) that is in development (probably broken or incomplete) 1024k
+
+### DEV ##################################################################################
+# additional plugins (and dependend code) that is in development (probably broken or incomplete)
+##########################################################################################
+
+# DEV : 1024k version ----------------------------
 [env:dev_ESP8266_1024]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld -D PLUGIN_BUILD_TESTING -D PLUGIN_BUILD_DEV
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8266_1M.board_flash_mode}
+board            = ${common.board}
+build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_BUILD_DEV
 
-#version with additional plugins (and dependend code) that is in development (probably broken or incomplete) 4096k
-[env:dev_ESP8266_4096]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.4m1m.ld -D PLUGIN_BUILD_TESTING -D PLUGIN_BUILD_DEV
-
-#version with additional plugins (and dependend code) that is in development (probably broken or incomplete) 4096k
-# Use latest ESP8266 core 2.4.0
-[env:dev_ESP8266_4096_core2_4_0]
-platform = espressif8266
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.4m1m.ld -D PLUGIN_BUILD_TESTING -D PLUGIN_BUILD_DEV
-
-
-#version with additional plugins (and dependend code) that is in development (probably broken or incomplete) 4096k for esp8285
+# DEV: 1024k for esp8285 -------------------------
 [env:dev_ESP8285_1024]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp8285
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld -D PLUGIN_BUILD_TESTING -D PLUGIN_BUILD_DEV -DESP8285
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8285_1M.board_flash_mode}
+board            = ${esp8285_1M.board}
+build_flags      = ${esp8285_1M.build_flags} -D PLUGIN_BUILD_DEV
+
+# DEV: 2048k version -----------------------------
+[env:dev_WROOM02_2048]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${espWroom2M.board_flash_mode}
+board            = ${espWroom2M.board}
+build_flags      = ${espWroom2M.build_flags} -D PLUGIN_BUILD_DEV
+
+# DEV : 4096k version ----------------------------
+[env:dev_ESP8266_4096]
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+board            = ${common.board}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8266_4M.board_flash_mode}
+build_flags      = ${esp8266_4M.build_flags} -D PLUGIN_BUILD_DEV
 
 
 
-#special patched version for PUYA flash chips, see https://github.com/letscontrolit/ESPEasy/issues/650
+### DEV + PUYA ###########################################################################
+# special patched version for PUYA flash chips, see issue #650 at Github                 #
+##########################################################################################
+
+# DEV+PUYA : 1024k version -----------------------
 [env:dev_ESP8266PUYA_1024]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld -D PLUGIN_BUILD_TESTING -D PLUGIN_BUILD_DEV -D FLASH_QUIRK_WRITE_0_TO_1
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+board            = ${common.board}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8266_1M.board_flash_mode}
+build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_BUILD_DEV -D FLASH_QUIRK_WRITE_0_TO_1
 
-#special patched version for PUYA flash chips, see https://github.com/letscontrolit/ESPEasy/issues/650
+# DEV+PUYA : 1024k version + FEATURE_ADC_VCC -----
 [env:dev_ESP8266PUYA_1024_VCC]
-platform = espressif8266@1.5.0
-framework = arduino
-board = esp12e
-upload_speed=460800
-build_flags = ${common.build_flags} -Wl,-Tesp8266.flash.1m128.ld -D PLUGIN_BUILD_TESTING -D PLUGIN_BUILD_DEV -D FLASH_QUIRK_WRITE_0_TO_1 -D FEATURE_ADC_VCC=true
+platform         = ${common.platform}
+lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+lib_ldf_mode     = ${common.lib_ldf_mode}
+framework        = ${common.framework}
+board            = ${common.board}
+upload_speed     = ${common.upload_speed}
+board_flash_mode = ${esp8266_1M.board_flash_mode}
+build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_BUILD_DEV -D FLASH_QUIRK_WRITE_0_TO_1 -D FEATURE_ADC_VCC=true
+
+
+
+
+### HARDWARE SPECIFIC VERSIONS ###########################################################
+# versions specially designed to fit, and contents only needed plugins for each hardware #
+##########################################################################################
+
+# ITEAD Products ################################
+
+# ITEAD / SONOFF BASIC version ------------------
+#[env:hard_SONOFF_BASIC]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${Sonoff.board_flash_mode}
+#board            = ${Sonoff.board}
+#build_flags      = ${Sonoff.build_flags} -D PLUGIN_SET_SONOFF_BASIC
+
+# ITEAD / SONOFF TH10 version -------------------
+#[env:hard_SONOFF_TH10]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${Sonoff.board_flash_mode}
+#board            = ${Sonoff.board}
+#build_flags      = ${Sonoff.build_flags} -D PLUGIN_SET_SONOFF_TH10
+
+# ITEAD / SONOFF TH16 version -------------------
+#[env:hard_SONOFF_TH16]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${Sonoff.board_flash_mode}
+#board            = ${Sonoff.board}
+#build_flags      = ${Sonoff.build_flags} -D PLUGIN_SET_SONOFF_TH16
+
+# ITEAD / SONOFF POW version --------------------
+#[env:hard_SONOFF_POW]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${Sonoff.board_flash_mode}
+#board            = ${Sonoff.board}
+#build_flags      = ${Sonoff.build_flags} -D PLUGIN_SET_SONOFF_POW
+
+# ITEAD / SONOFF S20 version --------------------
+#[env:hard_SONOFF_S20]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${Sonoff.board_flash_mode}
+#board            = ${Sonoff.board}
+#build_flags      = ${Sonoff.build_flags} -D PLUGIN_SET_SONOFF_S20
+
+# ITEAD / SONOFF 4CH version --------------------
+#[env:hard_SONOFF_4CH]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${Sonoff.board_flash_mode}
+#board            = ${Sonoff.board}
+#build_flags      = ${Sonoff.build_flags} -D PLUGIN_SET_SONOFF_4CH
+
+# ITEAD / SONOFF TOUCH version ------------------
+#[env:hard_SONOFF_TOUCH]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${Sonoff.board_flash_mode}
+#board            = ${Sonoff.board}
+#build_flags      = ${Sonoff.build_flags} -D PLUGIN_SET_SONOFF_TOUCH
+
+
+
+# LED Strips #####################################
+
+# Huacanxing / H801 ------------------------------
+#[env:hard_HUACANXING_H801]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_H801
+
+# MagicHome / Led Controller ---------------------
+#[env:hard_MAGICHOME]
+#upload_speed     = ${common.upload_speed}
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_MAGICHOME
+
+# MagicHome / Led Controller with IR -------------
+#[env:hard_MAGICHOME_IR]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_MAGICHOME_IR
+
+
+
+
+### EASY VERSIONS ########################################################################
+# versions specially designed to be small and cover a specific usage                     #
+##########################################################################################
+
+# Easy Temperature Sensor ------------------------
+#[env:easy_TEMP]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_EASY_TEMP
+
+
+# Easy Carbon Sensor -----------------------------
+#[env:easy_CARBON]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_EASY_CARBON
+
+## Easy Nextion ----------------------------------
+##PLUGIN_SET_EASY_NEXTION
+
+# Easy OLED Display v1 ---------------------------
+#[env:easy_OLED_V1]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_EASY_OLED1
+
+# Easy OLED Display v2 ---------------------------
+#[env:easy_OLED_V2]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_EASY_OLED2
+
+# Easy Relay Switch ------------------------------
+#[env:easy_OLED_V2]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_EASY_RELAY
+
+# Easy  Generic (1M) device ----------------------
+#[env:easy_GENERIC_1M]
+#upload_speed     = ${common.upload_speed}
+#framework        = ${common.framework}
+#platform         = ${common.platform}
+#lib_deps         = ${common.lib_deps}
+lib_ignore       = ${common.lib_ignore}
+#lib_ldf_mode     = ${common.lib_ldf_mode}
+#board_flash_mode = ${esp8266_1M.board_flash_mode}
+#board            = esp01_1m
+#build_flags      = ${esp8266_1M.build_flags} -D PLUGIN_SET_GENERIC_1M

src/Command.ino

@@ -38,30 +38,146 @@ bool safeReadStringUntil(Stream &input, String &str, char terminator, unsigned i
 
 }
 
-
 #define INPUT_COMMAND_SIZE          80
+Command commandStringToEnum(const char * cmd) {
+  String tmpcmd;
+  tmpcmd = cmd;
+  tmpcmd.toLowerCase();
+  char cmd_lc[INPUT_COMMAND_SIZE];
+  tmpcmd.toCharArray(cmd_lc, tmpcmd.length() + 1);
+  switch (cmd_lc[0]) {
+    case 'a': {
+           if (strcmp_P(cmd_lc, PSTR("accessinfo")            ) == 0) return cmd_accessinfo;
+      break;
+    }
+    case 'b': {
+           if (strcmp_P(cmd_lc, PSTR("background")            ) == 0) return cmd_background;
+      else if (strcmp_P(cmd_lc, PSTR("blynkget")              ) == 0) return cmd_BlynkGet;
+      else if (strcmp_P(cmd_lc, PSTR("build")                 ) == 0) return cmd_build;
+      break;
+    }
+    case 'c': {
+           if (strcmp_P(cmd_lc, PSTR("clearaccessblock")      ) == 0) return cmd_clearaccessblock;
+      else if (strcmp_P(cmd_lc, PSTR("clearrtcram")           ) == 0) return cmd_clearRTCRAM;
+      else if (strcmp_P(cmd_lc, PSTR("config")                ) == 0) return cmd_config;
+      break;
+    }
+    case 'd': {
+           if (strcmp_P(cmd_lc, PSTR("debug")                 ) == 0) return cmd_Debug;
+      else if (strcmp_P(cmd_lc, PSTR("delay")                 ) == 0) return cmd_Delay;
+      else if (strcmp_P(cmd_lc, PSTR("deepsleep")             ) == 0) return cmd_deepSleep;
+      break;
+    }
+    case 'e': {
+           if (strcmp_P(cmd_lc, PSTR("erase")                 ) == 0) return cmd_Erase;
+      else if (strcmp_P(cmd_lc, PSTR("event")                 ) == 0) return cmd_Event;
+      else if (strcmp_P(cmd_lc, PSTR("executerules")          ) == 0) return cmd_executeRules;
+      break;
+    }
+    case 'i': {
+           if (strcmp_P(cmd_lc, PSTR("i2cscanner")            ) == 0) return cmd_i2cscanner;
+      else if (strcmp_P(cmd_lc, PSTR("ip")                    ) == 0) return cmd_IP;
+      break;
+    }
+    case 'l': {
+           if (strcmp_P(cmd_lc, PSTR("load")                  ) == 0) return cmd_Load;
+      else if (strcmp_P(cmd_lc, PSTR("lowmem")                ) == 0) return cmd_lowmem;
+      break;
+    }
+    case 'm': {
+           if (strcmp_P(cmd_lc, PSTR("malloc")                ) == 0) return cmd_malloc;
+      else if (strcmp_P(cmd_lc, PSTR("meminfo")               ) == 0) return cmd_meminfo;
+      break;
+    }
+    case 'n': {
+           if (strcmp_P(cmd_lc, PSTR("name")                  ) == 0) return cmd_Name;
+      else if (strcmp_P(cmd_lc, PSTR("notify")                ) == 0) return cmd_notify;
+      else if (strcmp_P(cmd_lc, PSTR("nosleep")               ) == 0) return cmd_NoSleep;
+      break;
+    }
+    case 'p': {
+           if (strcmp_P(cmd_lc, PSTR("password")              ) == 0) return cmd_Password;
+      else if (strcmp_P(cmd_lc, PSTR("publish")               ) == 0) return cmd_Publish;
+      break;
+    }
+    case 'r': {
+           if (strcmp_P(cmd_lc, PSTR("reboot")                ) == 0) return cmd_Reboot;
+      else if (strcmp_P(cmd_lc, PSTR("reset")                 ) == 0) return cmd_Reset;
+      else if (strcmp_P(cmd_lc, PSTR("restart")               ) == 0) return cmd_Restart;
+      else if (strcmp_P(cmd_lc, PSTR("resetflashwritecounter")) == 0) return cmd_resetFlashWriteCounter;
+      else if (strcmp_P(cmd_lc, PSTR("rules")                 ) == 0) return cmd_Rules;
+      break;
+    }
+    case 's': {
+           if (strcmp_P(cmd_lc, PSTR("sdcard")                ) == 0) return cmd_sdcard;
+      else if (strcmp_P(cmd_lc, PSTR("sdremove")              ) == 0) return cmd_sdremove;
+      else if (strcmp_P(cmd_lc, PSTR("sysload")               ) == 0) return cmd_sysload;
+      else if (strcmp_P(cmd_lc, PSTR("save")                  ) == 0) return cmd_Save;
+      else if (strcmp_P(cmd_lc, PSTR("sendto")                ) == 0) return cmd_SendTo;
+      else if (strcmp_P(cmd_lc, PSTR("sendtohttp")            ) == 0) return cmd_SendToHTTP;
+      else if (strcmp_P(cmd_lc, PSTR("sendtoudp")             ) == 0) return cmd_SendToUDP;
+      else if (strcmp_P(cmd_lc, PSTR("serialfloat")           ) == 0) return cmd_SerialFloat;
+      else if (strcmp_P(cmd_lc, PSTR("settings")              ) == 0) return cmd_Settings;
+      break;
+    }
+    case 't': {
+           if (strcmp_P(cmd_lc, PSTR("taskclear")             ) == 0) return cmd_TaskClear;
+      else if (strcmp_P(cmd_lc, PSTR("taskclearall")          ) == 0) return cmd_TaskClearAll;
+      else if (strcmp_P(cmd_lc, PSTR("taskrun")               ) == 0) return cmd_TaskRun;
+      else if (strcmp_P(cmd_lc, PSTR("taskvalueset")          ) == 0) return cmd_TaskValueSet;
+      else if (strcmp_P(cmd_lc, PSTR("timerset")              ) == 0) return cmd_TimerSet;
+      break;
+    }
+    case 'u': {
+           if (strcmp_P(cmd_lc, PSTR("udptest")               ) == 0) return cmd_udptest;
+      else if (strcmp_P(cmd_lc, PSTR("unit")                  ) == 0) return cmd_Unit;
+      break;
+    }
+    case 'w': {
+           if (strcmp_P(cmd_lc, PSTR("wdconfig")              ) == 0) return cmd_wdconfig;
+      else if (strcmp_P(cmd_lc, PSTR("wdread")                ) == 0) return cmd_wdread;
+      else if (strcmp_P(cmd_lc, PSTR("wifiapmode")            ) == 0) return cmd_WifiAPMode;
+      else if (strcmp_P(cmd_lc, PSTR("wificonnect")           ) == 0) return cmd_WifiConnect;
+      else if (strcmp_P(cmd_lc, PSTR("wifidisconnect")        ) == 0) return cmd_WifiDisconnect;
+      else if (strcmp_P(cmd_lc, PSTR("wifikey2")              ) == 0) return cmd_WifiKey2;
+      else if (strcmp_P(cmd_lc, PSTR("wifikey")               ) == 0) return cmd_WifiKey;
+      else if (strcmp_P(cmd_lc, PSTR("wifissid2")             ) == 0) return cmd_WifiSSID2;
+      else if (strcmp_P(cmd_lc, PSTR("wifissid")              ) == 0) return cmd_WifiSSID;
+      else if (strcmp_P(cmd_lc, PSTR("wifiscan")              ) == 0) return cmd_WifiScan;
+      break;
+    }
+    default:
+      return cmd_Unknown;
+  }
+  return cmd_Unknown;
+}
+
 void ExecuteCommand(byte source, const char *Line)
 {
+  checkRAM(F("ExecuteCommand"));
   String status = "";
   boolean success = false;
-  char TmpStr1[80];
+  char TmpStr1[INPUT_COMMAND_SIZE];
   TmpStr1[0] = 0;
-  char Command[80];
-  Command[0] = 0;
+  char cmd[INPUT_COMMAND_SIZE];
+  cmd[0] = 0;
   int Par1 = 0;
   int Par2 = 0;
   int Par3 = 0;
 
-  GetArgv(Line, Command, 1);
+  GetArgv(Line, cmd, 1);
   if (GetArgv(Line, TmpStr1, 2)) Par1 = str2int(TmpStr1);
   if (GetArgv(Line, TmpStr1, 3)) Par2 = str2int(TmpStr1);
   if (GetArgv(Line, TmpStr1, 4)) Par3 = str2int(TmpStr1);
 
+  const Command cmd_enum = commandStringToEnum(cmd);
+  switch (cmd_enum) {
+
   // ****************************************
   // commands for debugging
   // ****************************************
 
-  if (strcasecmp_P(Command, PSTR("background")) == 0)
+  case cmd_background:
   {
     success = true;
     unsigned long timer = millis() + Par1;
@@ -69,9 +185,10 @@ void ExecuteCommand(byte source, const char *Line)
     while (!timeOutReached(timer))
       backgroundtasks();
     Serial.println("end");
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("executeRules")) == 0)
+  case cmd_executeRules:
   {
     success = true;
     if (GetArgv(Line, TmpStr1, 2))
@@ -80,15 +197,17 @@ void ExecuteCommand(byte source, const char *Line)
       String event = "";
       rulesProcessingFile(fileName, event);
     }
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("clearRTCRAM")) == 0)
+  case cmd_clearRTCRAM:
   {
     success = true;
     initRTC();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("notify")) == 0)
+  case cmd_notify:
   {
     success = true;
     String message = "";
@@ -109,15 +228,17 @@ void ExecuteCommand(byte source, const char *Line)
         }
       }
     }
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("resetFlashWriteCounter")) == 0)
+  case cmd_resetFlashWriteCounter:
   {
     success = true;
     RTC.flashDayCounter = 0;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("udptest")) == 0)
+  case cmd_udptest:
   {
     success = true;
     for (byte x = 0; x < Par2; x++)
@@ -126,18 +247,20 @@ void ExecuteCommand(byte source, const char *Line)
       event += x;
       SendUDPCommand(Par1, (char*)event.c_str(), event.length());
     }
+    break;
   }
 #ifdef FEATURE_SD
-  if (strcasecmp_P(Command, PSTR("sdcard")) == 0)
+  case cmd_sdcard:
   {
     success = true;
     File root = SD.open("/");
     root.rewindDirectory();
     printDirectory(root, 0);
     root.close();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("sdremove")) == 0)
+  case cmd_sdremove:
   {
     success = true;
     String fname = Line;
@@ -145,56 +268,63 @@ void ExecuteCommand(byte source, const char *Line)
     Serial.print(F("Removing:"));
     Serial.println(fname.c_str());
     SD.remove((char*)fname.c_str());
+    break;
   }
 #endif
 
-  if (strcasecmp_P(Command, PSTR("lowmem")) == 0)
+  case cmd_lowmem:
   {
     Serial.print(lowestRAM);
     Serial.print(F(" : "));
     Serial.println(lowestRAMfunction);
     success = true;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("malloc")) == 0)
+  case cmd_malloc:
   {
     ramtest = (char *)malloc(Par1);
     success = true;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("sysload")) == 0)
+  case cmd_sysload:
   {
     success = true;
     Serial.print(100 - (100 * loopCounterLast / loopCounterMax));
     Serial.print(F("% (LC="));
     Serial.print(int(loopCounterLast / 30));
     Serial.println(F(")"));
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("SerialFloat")) == 0)
+  case cmd_SerialFloat:
   {
     success = true;
     pinMode(1, INPUT);
     pinMode(3, INPUT);
     delay(60000);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("accessinfo")) == 0)
+  case cmd_accessinfo:
   {
     success = true;
     Serial.print(F("Allowed IP range : "));
     Serial.println(describeAllowedIPrange());
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("clearaccessblock")) == 0)
+  case cmd_clearaccessblock:
   {
     success = true;
     clearAccessBlock();
     Serial.print(F("Allowed IP range : "));
     Serial.println(describeAllowedIPrange());
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("meminfo")) == 0)
+  case cmd_meminfo:
   {
     success = true;
     Serial.print(F("SecurityStruct         : "));
@@ -205,32 +335,36 @@ void ExecuteCommand(byte source, const char *Line)
     Serial.println(sizeof(ExtraTaskSettings));
     Serial.print(F("DeviceStruct: "));
     Serial.println(sizeof(Device));
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("TaskClear")) == 0)
+  case cmd_TaskClear:
   {
     success = true;
     taskClear(Par1 - 1, true);
+    break;
   }
 
   //quickly clear all tasks, without saving (used by test suite)
-  if (strcasecmp_P(Command, PSTR("TaskClearAll")) == 0)
+  case cmd_TaskClearAll:
   {
     success = true;
     for (byte t=0; t<TASKS_MAX; t++)
       taskClear(t, false);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("wdconfig")) == 0)
+  case cmd_wdconfig:
   {
     success = true;
     Wire.beginTransmission(Par1);  // address
     Wire.write(Par2);              // command
     Wire.write(Par3);              // data
     Wire.endTransmission();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("wdread")) == 0)
+  case cmd_wdread:
   {
     success = true;
     Wire.beginTransmission(Par1);  // address
@@ -244,22 +378,25 @@ void ExecuteCommand(byte source, const char *Line)
       status = F("Reg value: ");
       status += value;
     }
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("build")) == 0)
+  case cmd_build:
   {
     success = true;
     Settings.Build = Par1;
     SaveSettings();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("NoSleep")) == 0)
+  case cmd_NoSleep:
   {
     success = true;
     Settings.deepSleep = 0;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("i2cscanner")) == 0)
+  case cmd_i2cscanner:
   {
     success = true;
 
@@ -279,28 +416,31 @@ void ExecuteCommand(byte source, const char *Line)
         Serial.println(String(address, HEX));
       }
     }
+    break;
   }
 
   // ****************************************
   // commands for rules
   // ****************************************
 
-  if (strcasecmp_P(Command, PSTR("config")) == 0)
+  case cmd_config:
   {
     success = true;
     struct EventStruct TempEvent;
     String request = Line;
     remoteConfig(&TempEvent, request);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("deepSleep")) == 0)
+  case cmd_deepSleep:
   {
     success = true;
     if (Par1 > 0)
       deepSleepStart(Par1); // call the second part of the function to avoid check and enable one-shot operation
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("TaskValueSet")) == 0)
+  case cmd_TaskValueSet:
   {
     success = true;
     if (GetArgv(Line, TmpStr1, 4))
@@ -309,15 +449,17 @@ void ExecuteCommand(byte source, const char *Line)
       Calculate(TmpStr1, &result);
       UserVar[(VARS_PER_TASK * (Par1 - 1)) + Par2 - 1] = result;
     }
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("TaskRun")) == 0)
+  case cmd_TaskRun:
   {
     success = true;
     SensorSendTask(Par1 - 1);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("TimerSet")) == 0)
+  case cmd_TimerSet:
   {
     if (Par1>=1 && Par1<=RULES_TIMER_MAX)
     {
@@ -333,24 +475,27 @@ void ExecuteCommand(byte source, const char *Line)
     {
       addLog(LOG_LEVEL_ERROR, F("TIMER: invalid timer number"));
     }
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Delay")) == 0)
+  case cmd_Delay:
   {
     success = true;
     delayBackground(Par1);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Rules")) == 0)
+  case cmd_Rules:
   {
     success = true;
     if (Par1 == 1)
       Settings.UseRules = true;
     else
       Settings.UseRules = false;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Event")) == 0)
+  case cmd_Event:
   {
     success = true;
     String event = Line;
@@ -358,9 +503,10 @@ void ExecuteCommand(byte source, const char *Line)
     event.replace("$", "#");
     if (Settings.UseRules)
       rulesProcessing(event);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("SendTo")) == 0)
+  case cmd_SendTo:
   {
     success = true;
     String event = Line;
@@ -371,78 +517,88 @@ void ExecuteCommand(byte source, const char *Line)
       event = event.substring(index + 1);
       SendUDPCommand(Par1, (char*)event.c_str(), event.length());
     }
+    break;
   }
-  if (strcasecmp_P(Command, PSTR("Publish")) == 0 && WiFi.status() == WL_CONNECTED)
+  case cmd_Publish:
   {
-    // ToDo TD-er: Not sure about this function, but at least it sends to an existing MQTTclient
-    int enabledMqttController = firstEnabledMQTTController();
-    if (enabledMqttController >= 0) {
+    if (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) {
+      // ToDo TD-er: Not sure about this function, but at least it sends to an existing MQTTclient
+      int enabledMqttController = firstEnabledMQTTController();
+      if (enabledMqttController >= 0) {
+        success = true;
+        String event = Line;
+        event = event.substring(8);
+        int index = event.indexOf(',');
+        if (index > 0)
+        {
+          String topic = event.substring(0, index);
+          String value = event.substring(index + 1);
+          MQTTpublish(enabledMqttController, topic.c_str(), value.c_str(), Settings.MQTTRetainFlag);
+        }
+      }
+    }
+    break;
+  }
+
+  case cmd_SendToUDP:
+  {
+    if (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) {
       success = true;
-      String event = Line;
-      event = event.substring(8);
-      int index = event.indexOf(',');
-      if (index > 0)
+      String strLine = Line;
+      String ip = parseString(strLine, 2);
+      String port = parseString(strLine, 3);
+      int msgpos = getParamStartPos(strLine, 4);
+      String message = strLine.substring(msgpos);
+      IPAddress UDP_IP;
+      if(UDP_IP.fromString(ip)) {
+        portUDP.beginPacket(UDP_IP, port.toInt());
+        #if defined(ESP8266)
+          portUDP.write(message.c_str(), message.length());
+        #endif
+        #if defined(ESP32)
+          portUDP.write((uint8_t*)message.c_str(), message.length());
+        #endif
+        portUDP.endPacket();
+      }
+    }
+    break;
+  }
+
+  case cmd_SendToHTTP:
+  {
+    if (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) {
+      success = true;
+      String strLine = Line;
+      String host = parseString(strLine, 2);
+      String port = parseString(strLine, 3);
+      int pathpos = getParamStartPos(strLine, 4);
+      String path = strLine.substring(pathpos);
+      WiFiClient client;
+      if (client.connect(host.c_str(), port.toInt()))
       {
-        String topic = event.substring(0, index);
-        String value = event.substring(index + 1);
-        MQTTpublish(enabledMqttController, topic.c_str(), value.c_str(), Settings.MQTTRetainFlag);
+        client.print(String("GET ") + path + " HTTP/1.1\r\n" +
+                     "Host: " + host + "\r\n" +
+                     "Connection: close\r\n\r\n");
+
+        unsigned long timer = millis() + 200;
+        while (!client.available() && !timeOutReached(timer))
+          delay(1);
+
+        while (client.available()) {
+          // String line = client.readStringUntil('\n');
+          String line;
+          safeReadStringUntil(client, line, '\n');
+
+
+          if (line.substring(0, 15) == F("HTTP/1.1 200 OK"))
+            addLog(LOG_LEVEL_DEBUG, line);
+          delay(1);
+        }
+        client.flush();
+        client.stop();
       }
     }
-  }
-
-  if (strcasecmp_P(Command, PSTR("SendToUDP")) == 0 && WiFi.status() == WL_CONNECTED)
-  {
-    success = true;
-    String strLine = Line;
-    String ip = parseString(strLine, 2);
-    String port = parseString(strLine, 3);
-    int msgpos = getParamStartPos(strLine, 4);
-    String message = strLine.substring(msgpos);
-    IPAddress UDP_IP;
-    if(UDP_IP.fromString(ip)) {
-      portUDP.beginPacket(UDP_IP, port.toInt());
-      #if defined(ESP8266)
-        portUDP.write(message.c_str(), message.length());
-      #endif
-      #if defined(ESP32)
-        portUDP.write((uint8_t*)message.c_str(), message.length());
-      #endif
-      portUDP.endPacket();
-    }
-  }
-
-  if (strcasecmp_P(Command, PSTR("SendToHTTP")) == 0 && WiFi.status() == WL_CONNECTED)
-  {
-    success = true;
-    String strLine = Line;
-    String host = parseString(strLine, 2);
-    String port = parseString(strLine, 3);
-    int pathpos = getParamStartPos(strLine, 4);
-    String path = strLine.substring(pathpos);
-    WiFiClient client;
-    if (client.connect(host.c_str(), port.toInt()))
-    {
-      client.print(String("GET ") + path + " HTTP/1.1\r\n" +
-                   "Host: " + host + "\r\n" +
-                   "Connection: close\r\n\r\n");
-
-      unsigned long timer = millis() + 200;
-      while (!client.available() && !timeOutReached(timer))
-        delay(1);
-
-      while (client.available()) {
-        // String line = client.readStringUntil('\n');
-        String line;
-        safeReadStringUntil(client, line, '\n');
-
-
-        if (line.substring(0, 15) == F("HTTP/1.1 200 OK"))
-          addLog(LOG_LEVEL_DEBUG, line);
-        delay(1);
-      }
-      client.flush();
-      client.stop();
-    }
+    break;
   }
 
   // ****************************************
@@ -451,7 +607,7 @@ void ExecuteCommand(byte source, const char *Line)
 
 #ifdef CPLUGIN_012
   //FIXME: this should go to PLUGIN_WRITE in _C012.ino
-  if (strcasecmp_P(Command, PSTR("BlynkGet")) == 0)
+  case cmd_BlynkGet:
   {
     byte first_enabled_blynk_controller = firstEnabledBlynkController();
     if (first_enabled_blynk_controller == -1) {
@@ -480,80 +636,91 @@ void ExecuteCommand(byte source, const char *Line)
         }
       }
     }
+    break;
   }
 #endif
 
   // ****************************************
   // configure settings commands
   // ****************************************
-  if (strcasecmp_P(Command, PSTR("WifiSSID")) == 0)
+  case cmd_WifiSSID:
   {
     success = true;
     strcpy(SecuritySettings.WifiSSID, Line + 9);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("WifiKey")) == 0)
+  case cmd_WifiKey:
   {
     success = true;
     strcpy(SecuritySettings.WifiKey, Line + 8);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("WifiSSID2")) == 0)
+  case cmd_WifiSSID2:
   {
     success = true;
     strcpy(SecuritySettings.WifiSSID2, Line + 10);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("WifiKey2")) == 0)
+  case cmd_WifiKey2:
   {
     success = true;
     strcpy(SecuritySettings.WifiKey2, Line + 9);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("WifiScan")) == 0)
+  case cmd_WifiScan:
   {
     success = true;
     WifiScan();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("WifiConnect")) == 0)
+  case cmd_WifiConnect:
   {
     success = true;
-    WifiConnect(1);
+    WiFiConnectRelaxed();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("WifiDisconnect")) == 0)
+  case cmd_WifiDisconnect:
   {
     success = true;
     WifiDisconnect();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("WifiAPMode")) == 0)
+  case cmd_WifiAPMode:
   {
     WifiAPMode(true);
     success = true;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Unit")) == 0)
+  case cmd_Unit:
   {
     success = true;
     Settings.Unit=Par1;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Name")) == 0)
+  case cmd_Name:
   {
     success = true;
     strcpy(Settings.Name, Line + 5);
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Password")) == 0)
+  case cmd_Password:
   {
     success = true;
     strcpy(SecuritySettings.Password, Line + 9);
+    break;
   }
 
-
-  if (strcasecmp_P(Command, PSTR("Reboot")) == 0)
+  case cmd_Reboot:
   {
     success = true;
     pinMode(0, INPUT);
@@ -565,55 +732,70 @@ void ExecuteCommand(byte source, const char *Line)
     #if defined(ESP32)
       ESP.restart();
     #endif
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Restart")) == 0)
+  case cmd_Restart:
   {
     success = true;
     ESP.restart();
+    break;
   }
-  if (strcasecmp_P(Command, PSTR("Erase")) == 0)
+
+  case cmd_Erase:
   {
     success = true;
     WiFi.persistent(true); // use SDK storage of SSID/WPA parameters
     WiFi.disconnect(); // this will store empty ssid/wpa into sdk storage
     WiFi.persistent(false); // Do not use SDK storage of SSID/WPA parameters
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Reset")) == 0)
+  case cmd_Reset:
   {
     success = true;
     ResetFactory();
+    #if defined(ESP8266)
+      ESP.reset();
+    #endif
+    #if defined(ESP32)
+      ESP.restart();
+    #endif
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Save")) == 0)
+  case cmd_Save:
   {
     success = true;
     SaveSettings();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Load")) == 0)
+  case cmd_Load:
   {
     success = true;
     LoadSettings();
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Debug")) == 0)
+  case cmd_Debug:
   {
     success = true;
     Settings.SerialLogLevel = Par1;
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("IP")) == 0)
+  case cmd_IP:
   {
     success = true;
     if (GetArgv(Line, TmpStr1, 2)) {
       if (!str2ip(TmpStr1, Settings.IP))
         Serial.println("?");
     }
+    break;
   }
 
-  if (strcasecmp_P(Command, PSTR("Settings")) == 0)
+  case cmd_Settings:
   {
     success = true;
     char str[20];
@@ -631,6 +813,10 @@ void ExecuteCommand(byte source, const char *Line)
     Serial.print(F("  WifiSSID2     : ")); Serial.println(SecuritySettings.WifiSSID2);
     Serial.print(F("  WifiKey2      : ")); Serial.println(SecuritySettings.WifiKey2);
     Serial.print(F("  Free mem      : ")); Serial.println(FreeMem());
+    break;
+  }
+  default:
+    success = false;
   }
 
   yield();

src/Controller.ino

@@ -3,13 +3,11 @@
 //********************************************************************************
 void sendData(struct EventStruct *event)
 {
-  LoadTaskSettings(event->TaskIndex);
+  checkRAM(F("sendData"));
+ LoadTaskSettings(event->TaskIndex);
   if (Settings.UseRules)
     createRuleEvents(event->TaskIndex);
 
-  if (Settings.GlobalSync && Settings.TaskDeviceGlobalSync[event->TaskIndex])
-    SendUDPTaskData(0, event->TaskIndex, event->TaskIndex);
-
   if (Settings.UseValueLogger && Settings.InitSPI && Settings.Pin_sd_cs >= 0)
     SendValueLogger(event->TaskIndex);
 
@@ -118,11 +116,12 @@ void callback(char* c_topic, byte* b_payload, unsigned int length) {
 \*********************************************************************************************/
 bool MQTTConnect(int controller_idx)
 {
-  if (!WiFiConnected(100)) return false;
-  if (MQTTclient.connected())
-    MQTTclient.disconnect();
   ControllerSettingsStruct ControllerSettings;
   LoadControllerSettings(controller_idx, (byte*)&ControllerSettings, sizeof(ControllerSettings));
+  if (!ControllerSettings.checkHostReachable(true))
+    return false;
+  if (MQTTclient.connected())
+    MQTTclient.disconnect();
   if (ControllerSettings.UseDNS) {
     MQTTclient.setServer(ControllerSettings.getHost().c_str(), ControllerSettings.Port);
   } else {
@@ -136,7 +135,7 @@ bool MQTTConnect(int controller_idx)
 
   String LWTTopic = ControllerSettings.Subscribe;
   LWTTopic.replace(F("/#"), F("/status"));
-  LWTTopic.replace(F("%sysname%"), Settings.Name);
+  parseSystemVariables(LWTTopic, false);
   LWTTopic += F("/LWT"); // Extend the topic for status updates of connected/disconnected status.
 
   boolean MQTTresult = false;
@@ -160,13 +159,18 @@ bool MQTTConnect(int controller_idx)
   log += clientid;
   addLog(LOG_LEVEL_INFO, log);
   String subscribeTo = ControllerSettings.Subscribe;
-  subscribeTo.replace(F("%sysname%"), Settings.Name);
+  parseSystemVariables(subscribeTo, false);
   MQTTclient.subscribe(subscribeTo.c_str());
   log = F("Subscribed to: ");
   log += subscribeTo;
   addLog(LOG_LEVEL_INFO, log);
 
-  if (MQTTclient.publish(LWTTopic.c_str(), "Connected")) {
+  if (MQTTclient.publish(LWTTopic.c_str(), "Connected", 1)) {
+    if (Settings.UseRules)
+    {
+      String event = F("MQTT#Connected");
+      rulesProcessing(event);
+    }
     statusLED(true);
     return true; // end loop if succesfull
   }
@@ -179,10 +183,12 @@ bool MQTTConnect(int controller_idx)
 \*********************************************************************************************/
 bool MQTTCheck(int controller_idx)
 {
+  if (!WiFiConnected(10))
+    return false;
   byte ProtocolIndex = getProtocolIndex(Settings.Protocol[controller_idx]);
   if (Protocol[ProtocolIndex].usesMQTT)
   {
-    if (MQTTclient_should_reconnect || !WiFiConnected(10) || !MQTTclient.connected())
+    if (MQTTclient_should_reconnect || !MQTTclient.connected())
     {
       if (MQTTclient_should_reconnect) {
         addLog(LOG_LEVEL_ERROR, F("MQTT : Intentional reconnect"));
@@ -226,7 +232,6 @@ boolean MQTTpublish(int controller_idx, const char* topic, const char* payload,
   if (MQTTclient.publish(topic, payload, retained))
     return true;
   addLog(LOG_LEVEL_DEBUG, F("MQTT : publish failed"));
-  MQTTConnect(controller_idx);
   return false;
 }
 
@@ -241,7 +246,7 @@ void MQTTStatus(String& status)
     LoadControllerSettings(enabledMqttController, (byte*)&ControllerSettings, sizeof(ControllerSettings));
     String pubname = ControllerSettings.Subscribe;
     pubname.replace(F("/#"), F("/status"));
-    pubname.replace(F("%sysname%"), Settings.Name);
+    parseSystemVariables(pubname, false);
     MQTTpublish(enabledMqttController, pubname.c_str(), status.c_str(),Settings.MQTTRetainFlag);
   }
 }

src/Convert.ino

@@ -0,0 +1,163 @@
+
+/*********************************************************************************************\
+   Convert bearing in degree to bearing string
+  \*********************************************************************************************/
+
+String getBearing(int degrees)
+{
+  const __FlashStringHelper* bearing[] = {
+    F("N"),
+    F("NNE"),
+    F("NE"),
+    F("ENE"),
+    F("E"),
+    F("ESE"),
+    F("SE"),
+    F("SSE"),
+    F("S"),
+    F("SSW"),
+    F("SW"),
+    F("WSW"),
+    F("W"),
+    F("WNW"),
+    F("NW"),
+    F("NNW")
+  };
+  int nr_directions = (int) (sizeof(bearing)/sizeof(bearing[0]));
+  float stepsize = (360.0 / nr_directions);
+  if (degrees < 0) { degrees += 360; } // Allow for bearing -360 .. 359
+  int bearing_idx=int((degrees + (stepsize / 2.0)) / stepsize) % nr_directions;
+  if (bearing_idx < 0)
+    return("");
+  else
+    return(bearing[bearing_idx]);
+}
+
+float CelsiusToFahrenheit(float celsius) {
+  return celsius * (9.0 / 5.0) + 32;
+}
+
+int m_secToBeaufort(float m_per_sec) {
+  if (m_per_sec < 0.3) return 0;
+  if (m_per_sec < 1.6) return 1;
+  if (m_per_sec < 3.4) return 2;
+  if (m_per_sec < 5.5) return 3;
+  if (m_per_sec < 8.0) return 4;
+  if (m_per_sec < 10.8) return 5;
+  if (m_per_sec < 13.9) return 6;
+  if (m_per_sec < 17.2) return 7;
+  if (m_per_sec < 20.8) return 8;
+  if (m_per_sec < 24.5) return 9;
+  if (m_per_sec < 28.5) return 10;
+  if (m_per_sec < 32.6) return 11;
+  return 12;
+}
+
+String centimeterToImperialLength(float cm) {
+  return millimeterToImperialLength(cm * 10.0);
+}
+
+String millimeterToImperialLength(float mm) {
+  float inches = mm / 25.4;
+  int feet = inches /12;
+  inches = inches - (feet * 12);
+  String result;
+  result.reserve(10);
+  if (feet != 0) {
+    result += feet;
+    result += '\'';
+  }
+  result += toString(inches,1);
+  result += '"';
+  return result;
+}
+
+float minutesToDay(int minutes) {
+  return minutes / 1440.0;
+}
+
+String minutesToDayHour(int minutes) {
+  int days = minutes / 1440;
+  int hours = (minutes % 1440) / 60;
+  char TimeString[6]; //5 digits plus the null char
+  sprintf_P(TimeString, PSTR("%d%c%02d%c"), days, 'd', hours, 'h');
+  return TimeString;
+}
+
+String minutesToHourMinute(int minutes) {
+  int hours = (minutes % 1440) / 60;
+  int mins = (minutes % 1440) % 60;
+  char TimeString[20];
+  sprintf_P(TimeString, PSTR("%d%c%02d%c"), hours, 'h', mins, 'm');
+  return TimeString;
+}
+
+String minutesToDayHourMinute(int minutes) {
+  int days = minutes / 1440;
+  int hours = (minutes % 1440) / 60;
+  int mins = (minutes % 1440) % 60;
+  char TimeString[20];
+  sprintf_P(TimeString, PSTR("%d%c%02d%c%02d%c"), days, 'd', hours, 'h', mins, 'm');
+  return TimeString;
+}
+
+String secondsToDayHourMinuteSecond(int seconds) {
+  int sec = seconds % 60;
+  int minutes = seconds / 60;
+  int days = minutes / 1440;
+  int hours = (minutes % 1440) / 60;
+  int mins = (minutes % 1440) % 60;
+  char TimeString[20];
+  sprintf_P(TimeString, PSTR("%d%c%02d%c%02d%c%02d"), days, 'd', hours, ':', mins, ':', sec);
+  return TimeString;
+}
+
+String format_msec_duration(long duration) {
+  String result;
+  if (duration < 0) {
+    result = "-";
+    duration = -1 * duration;
+  }
+  if (duration < 10000) {
+    result += duration;
+    result += F(" ms");
+    return result;
+  }
+  duration /= 1000;
+  if (duration < 3600) {
+    int sec = duration % 60;
+    int minutes = duration / 60;
+    if (minutes > 0) {
+      result += minutes;
+      result += F(" m ");
+    }
+    result += sec;
+    result += F(" s");
+    return result;
+  }
+  duration /= 60;
+  if (duration < 1440) return minutesToHourMinute(duration);
+  return minutesToDayHourMinute(duration);
+}
+
+
+/********************************************************************************************\
+  In memory convert float to long
+  \*********************************************************************************************/
+unsigned long float2ul(float f)
+{
+  unsigned long ul;
+  memcpy(&ul, &f, 4);
+  return ul;
+}
+
+
+/********************************************************************************************\
+  In memory convert long to float
+  \*********************************************************************************************/
+float ul2float(unsigned long ul)
+{
+  float f;
+  memcpy(&f, &ul, 4);
+  return f;
+}

src/ESPEasyTimeTypes.h

@@ -1,3 +1,6 @@
+#ifndef ESPEASY_TIMETYPES_H_
+#define ESPEASY_TIMETYPES_H_
+
 #include <stdint.h>
 
 struct  timeStruct {
@@ -59,3 +62,9 @@ struct TimeChangeRule {
 void applyTimeZone(uint32_t curTime = 0);
 void setTimeZone(const TimeChangeRule& dstStart, const TimeChangeRule& stdStart, uint32_t curTime = 0);
 uint32_t calcTimeChangeForRule(const TimeChangeRule& r, int yr);
+String getTimeString(char delimiter, bool show_seconds=true);
+String getTimeString_ampm(char delimiter, bool show_seconds=true);
+long timeDiff(unsigned long prev, unsigned long next);
+
+
+#endif /* ESPEASY_TIMETYPES_H_ */

src/ESPEasyWiFiEvent.h

@@ -0,0 +1,68 @@
+//********************************************************************************
+// Functions called on events.
+// Make sure not to call anything in these functions that result in delay() or yield()
+//********************************************************************************
+#ifdef ESP32
+void WiFiEvent(system_event_id_t event, system_event_info_t info) {
+  switch(event) {
+    case SYSTEM_EVENT_STA_CONNECTED:
+      lastConnectMoment = millis();
+      processedConnect = false;
+      wifiStatus = ESPEASY_WIFI_CONNECTED;
+      break;
+    case SYSTEM_EVENT_STA_DISCONNECTED:
+      lastDisconnectMoment = millis();
+      if (timeDiff(lastConnectMoment, last_wifi_connect_attempt_moment) > 0) {
+        // There was an unsuccessful connection attempt
+        lastConnectedDuration = timeDiff(last_wifi_connect_attempt_moment, lastDisconnectMoment);
+      } else {
+        lastConnectedDuration = timeDiff(lastConnectMoment, lastDisconnectMoment);
+      }
+      processedDisconnect = false;
+      lastDisconnectReason = static_cast<WiFiDisconnectReason>(info.disconnected.reason);
+      wifiStatus = ESPEASY_WIFI_DISCONNECTED;
+      break;
+    case SYSTEM_EVENT_STA_GOT_IP:
+      lastGetIPmoment = millis();
+      wifiStatus = ESPEASY_WIFI_GOT_IP;
+      processedGetIP = false;
+      break;
+    default:
+      break;
+  }
+}
+#else
+
+void onConnected(const WiFiEventStationModeConnected& event){
+  lastConnectMoment = millis();
+  processedConnect = false;
+  wifiStatus = ESPEASY_WIFI_CONNECTED;
+  last_channel = event.channel;
+  last_ssid = event.ssid;
+  bssid_changed = false;
+  for (byte i=0; i < 6; ++i) {
+    if (lastBSSID[i] != event.bssid[i]) {
+      bssid_changed = true;
+      lastBSSID[i] = event.bssid[i];
+    }
+  }
+}
+
+void onDisconnect(const WiFiEventStationModeDisconnected& event){
+  lastDisconnectMoment = millis();
+  if (timeDiff(lastConnectMoment, last_wifi_connect_attempt_moment) > 0) {
+    // There was an unsuccessful connection attempt
+    lastConnectedDuration = timeDiff(last_wifi_connect_attempt_moment, lastDisconnectMoment);
+  } else
+    lastConnectedDuration = timeDiff(lastConnectMoment, lastDisconnectMoment);
+  processedDisconnect = false;
+  lastDisconnectReason = event.reason;
+  wifiStatus = ESPEASY_WIFI_DISCONNECTED;
+}
+
+void onGotIP(const WiFiEventStationModeGotIP& event){
+  lastGetIPmoment = millis();
+  wifiStatus = ESPEASY_WIFI_GOT_IP;
+  processedGetIP = false;
+}
+#endif

src/ESPEasyWifi.ino

@@ -0,0 +1,513 @@
+
+
+//********************************************************************************
+// Functions to process the data gathered from the events.
+// These functions are called from Setup() or Loop() and thus may call delay() or yield()
+//********************************************************************************
+void processConnect() {
+  if (processedConnect) return;
+  if (wifiStatus < ESPEASY_WIFI_CONNECTED) return;
+
+  String log = F("WIFI : Connected! AP: ");
+  log += WiFi.SSID();
+  log += F(" (");
+  log += WiFi.BSSIDstr();
+  log += F(") Ch: ");
+  log += last_channel;
+  const long connect_duration = timeDiff(last_wifi_connect_attempt_moment, lastConnectMoment);
+  if (connect_duration > 0 && connect_duration < 30000) {
+    // Just log times when they make sense.
+    log += F(" Duration: ");
+    log += connect_duration;
+    log += F(" ms");
+  }
+  addLog(LOG_LEVEL_INFO, log);
+
+  if (Settings.UseRules && bssid_changed) {
+    String event = F("WiFi#ChangedAccesspoint");
+    rulesProcessing(event);
+  }
+  wifi_connect_attempt = 0;
+  processedConnect = true;
+}
+
+void processDisconnect() {
+  if (processedDisconnect) return;
+  if (Settings.UseRules) {
+    String event = F("WiFi#Disconnected");
+    rulesProcessing(event);
+  }
+  String log = F("WIFI : Disconnected! Reason: '");
+  log += getLastDisconnectReason();
+  log += F("'");
+  if (lastConnectedDuration > 0) {
+    log += F(" Connected for ");
+    log += format_msec_duration(lastConnectedDuration);
+  }
+  addLog(LOG_LEVEL_INFO, log);
+  processedDisconnect = true;
+
+  if (Settings.deepSleep && Settings.deepSleepOnFail) {
+    //only one attempt in deepsleep, to conserve battery
+    addLog(LOG_LEVEL_ERROR, F("SLEEP: Connection failed, going back to sleep."));
+    deepSleep(Settings.Delay);
+  }
+
+  if (!intent_to_reboot)
+    WiFiConnectRelaxed();
+}
+
+
+void processGotIP() {
+  if (processedGetIP)
+    return;
+  if (wifiStatus < ESPEASY_WIFI_GOT_IP)
+    return;
+  IPAddress ip = WiFi.localIP();
+  const IPAddress gw = WiFi.gatewayIP();
+  const IPAddress subnet = WiFi.subnetMask();
+  String log = F("WIFI : ");
+  if (useStaticIP()) {
+    log += F("Static IP: ");
+  } else {
+    log += F("DHCP IP: ");
+  }
+  log += formatIP(ip);
+  log += F(" (");
+  log += WifiGetHostname();
+  log += F(") GW: ");
+  log += formatIP(gw);
+  log += F(" SN: ");
+  log += formatIP(subnet);
+
+  const long dhcp_duration = timeDiff(lastConnectMoment, lastGetIPmoment);
+  if (dhcp_duration > 0 && dhcp_duration < 30000) {
+    // Just log times when they make sense.
+    log += F("   duration: ");
+    log += dhcp_duration;
+    log += F(" ms");
+  }
+  addLog(LOG_LEVEL_INFO, log);
+
+  // fix octet?
+  if (Settings.IP_Octet != 0 && Settings.IP_Octet != 255)
+  {
+    ip[3] = Settings.IP_Octet;
+    log = F("IP   : Fixed IP octet:");
+    log += formatIP(ip);
+    addLog(LOG_LEVEL_INFO, log);
+    WiFi.config(ip, gw, subnet);
+  }
+
+  #ifdef FEATURE_MDNS
+
+    log = F("WIFI : ");
+    if (MDNS.begin(WifiGetHostname().c_str(), WiFi.localIP())) {
+
+      log += F("mDNS started, with name: ");
+      log += WifiGetHostname();
+      log += F(".local");
+    }
+    else{
+      log += F("mDNS failed");
+    }
+    addLog(LOG_LEVEL_INFO, log);
+  #endif
+
+  // First try to get the time, since that may be used in logs
+  if (Settings.UseNTP) {
+    initTime();
+  }
+  if (Settings.UseRules)
+  {
+    String event = F("WiFi#Connected");
+    rulesProcessing(event);
+  }
+  statusLED(true);
+  wifiStatus = ESPEASY_WIFI_SERVICES_INITIALIZED;
+  processedGetIP = true;
+}
+
+
+
+
+//********************************************************************************
+// Determine Wifi AP name to set. (also used for mDNS)
+//********************************************************************************
+String WifiGetAPssid()
+{
+  String ssid(Settings.Name);
+  ssid+=F("-");
+  ssid+=Settings.Unit;
+  return (ssid);
+}
+
+//********************************************************************************
+// Determine hostname: basically WifiGetAPssid with spaces changed to -
+//********************************************************************************
+String WifiGetHostname()
+{
+  String hostname(WifiGetAPssid());
+  hostname.replace(F(" "), F("-"));
+  hostname.replace(F("_"), F("-")); // See RFC952
+  return (hostname);
+}
+
+
+//********************************************************************************
+// Set Wifi AP Mode config
+//********************************************************************************
+void WifiAPconfig()
+{
+  // create and store unique AP SSID/PW to prevent ESP from starting AP mode with default SSID and No password!
+  // setup ssid for AP Mode when needed
+
+  String softAPSSID=WifiGetAPssid();
+  String pwd = SecuritySettings.WifiAPKey;
+  WiFi.softAP(softAPSSID.c_str(),pwd.c_str());
+  // We start in STA mode
+  WifiAPMode(false);
+
+  String log("WIFI : AP Mode ssid will be ");
+  log=log+WifiGetAPssid();
+
+  log=log+F(" with address ");
+  log=log+apIP.toString();
+  addLog(LOG_LEVEL_INFO, log);
+}
+
+
+bool WifiIsAP()
+{
+  #if defined(ESP8266)
+    byte wifimode = wifi_get_opmode();
+  #endif
+  #if defined(ESP32)
+    byte wifimode = WiFi.getMode();
+  #endif
+  return(wifimode == 2 || wifimode == 3); //apmode is enabled
+}
+
+//********************************************************************************
+// Set Wifi AP Mode
+//********************************************************************************
+void WifiAPMode(boolean state)
+{
+  if (WifiIsAP())
+  {
+    //want to disable?
+    if (!state)
+    {
+      WiFi.mode(WIFI_STA);
+      addLog(LOG_LEVEL_INFO, F("WIFI : AP Mode disabled"));
+    }
+  }
+  else
+  {
+    //want to enable?
+    if (state)
+    {
+      WiFi.mode(WIFI_AP_STA);
+      addLog(LOG_LEVEL_INFO, F("WIFI : AP Mode enabled"));
+    }
+  }
+}
+
+bool useStaticIP() {
+  return (Settings.IP[0] != 0 && Settings.IP[0] != 255);
+}
+
+//********************************************************************************
+// Set Wifi config
+//********************************************************************************
+bool prepareWiFi() {
+  if (!selectValidWiFiSettings())
+    return false;
+
+  String log = "";
+  char hostname[40];
+  strncpy(hostname, WifiGetHostname().c_str(), sizeof(hostname));
+  #if defined(ESP8266)
+    wifi_station_set_hostname(hostname);
+  #endif
+  #if defined(ESP32)
+    WiFi.setHostname(hostname);
+  #endif
+
+  //use static ip?
+  if (useStaticIP())
+  {
+    const IPAddress ip = Settings.IP;
+    log = F("IP   : Static IP :");
+    log += ip;
+    addLog(LOG_LEVEL_INFO, log);
+    const IPAddress gw = Settings.Gateway;
+    const IPAddress subnet = Settings.Subnet;
+    const IPAddress dns = Settings.DNS;
+    WiFi.config(ip, gw, subnet, dns);
+  }
+  return true;
+}
+
+//********************************************************************************
+// Start connect to WiFi and check later to see if connected.
+//********************************************************************************
+void WiFiConnectRelaxed() {
+  if (prepareWiFi()) {
+    tryConnectWiFi();
+    return;
+  }
+  addLog(LOG_LEVEL_ERROR, F("WIFI : Could not connect to AP! (relaxed connect mode)"));
+  //everything failed, activate AP mode (will deactivate automatically after a while if its connected again)
+  WifiAPMode(true);
+}
+
+
+//********************************************************************************
+// Manage WiFi credentials
+//********************************************************************************
+const char* getLastWiFiSettingsSSID() {
+  return lastWiFiSettings == 0 ? SecuritySettings.WifiSSID : SecuritySettings.WifiSSID2;
+}
+
+const char* getLastWiFiSettingsPassphrase() {
+  return lastWiFiSettings == 0 ? SecuritySettings.WifiKey : SecuritySettings.WifiKey2;
+}
+
+bool selectNextWiFiSettings() {
+  uint8_t tmp = lastWiFiSettings;
+  lastWiFiSettings = (lastWiFiSettings + 1) % 2;
+  if (!wifiSettingsValid(getLastWiFiSettingsSSID(), getLastWiFiSettingsPassphrase())) {
+    // other settings are not correct, switch back.
+    lastWiFiSettings = tmp;
+    return false; // Nothing changed.
+  }
+  return true;
+}
+
+bool selectValidWiFiSettings() {
+  if (wifiSettingsValid(getLastWiFiSettingsSSID(), getLastWiFiSettingsPassphrase()))
+    return true;
+  return selectNextWiFiSettings();
+}
+
+bool wifiSettingsValid(const char* ssid, const char* pass) {
+  if (ssid[0] == 0 || (strcasecmp(ssid, "ssid") == 0)) {
+    return false;
+  }
+  if (pass[0] == 0) return false;
+  if (strlen(ssid) > 32) return false;
+  if (strlen(pass) > 64) return false;
+  return true;
+}
+
+bool wifiConnectTimeoutReached() {
+  if (wifi_connect_attempt == 0) return true;
+  if (timeDiff(last_wifi_connect_attempt_moment, lastDisconnectMoment) >0 ) {
+    // Connection attempt was already ended.
+    return true;
+  }
+  if (wifiSetupConnect) {
+    // Initial setup of WiFi, may take much longer since accesspoint is still active.
+    return timeOutReached(last_wifi_connect_attempt_moment + 20000);
+  }
+  // wait until it connects + add some device specific random offset to prevent
+  // all nodes overloading the accesspoint when turning on at the same time.
+  #if defined(ESP8266)
+  const unsigned int randomOffset_in_sec = wifi_connect_attempt == 1 ? 0 : 1000 * ((ESP.getChipId() & 0xF));
+  #endif
+  #if defined(ESP32)
+  const unsigned int randomOffset_in_sec = wifi_connect_attempt == 1 ? 0 : 1000 * ((ESP.getEfuseMac() & 0xF));
+  #endif
+  return timeOutReached(last_wifi_connect_attempt_moment + DEFAULT_WIFI_CONNECTION_TIMEOUT + randomOffset_in_sec);
+}
+
+//********************************************************************************
+// Simply start the WiFi connection sequence
+//********************************************************************************
+bool tryConnectWiFi() {
+  if (wifiSetup && !wifiSetupConnect)
+    return false;
+  if (wifiStatus != ESPEASY_WIFI_DISCONNECTED)
+    return(true);   //already connected, need to disconnect first
+  if (!wifiConnectTimeoutReached())
+    return true;    // timeout not reached yet, thus no need to retry again.
+  if (!selectValidWiFiSettings()) {
+    addLog(LOG_LEVEL_ERROR, F("WIFI : No valid WiFi settings!"));
+    return false;
+  }
+
+  if (wifi_connect_attempt != 0 && ((wifi_connect_attempt % 3) == 0)) {
+    // Change to other wifi settings.
+    if (selectNextWiFiSettings())
+      WiFi.disconnect();
+  }
+  if (wifi_connect_attempt > 6) {
+    //everything failed, activate AP mode (will deactivate automatically after a while if its connected again)
+    WifiAPMode(true);
+  }
+  const char* ssid = getLastWiFiSettingsSSID();
+  const char* passphrase = getLastWiFiSettingsPassphrase();
+  String log = F("WIFI : Connecting ");
+  log += ssid;
+  log += F(" attempt #");
+  log += wifi_connect_attempt;
+  addLog(LOG_LEVEL_INFO, log);
+
+  last_wifi_connect_attempt_moment = millis();
+  switch (wifi_connect_attempt) {
+    case 0:
+      if (lastBSSID[0] == 0)
+        WiFi.begin(ssid, passphrase);
+      else
+        WiFi.begin(ssid, passphrase, 0, &lastBSSID[0]);
+      break;
+    default:
+      WiFi.begin(ssid, passphrase);
+  }
+  ++wifi_connect_attempt;
+  switch (WiFi.status()) {
+    case WL_NO_SSID_AVAIL: {
+      log = F("WIFI : No SSID found matching: ");
+      log += ssid;
+      addLog(LOG_LEVEL_INFO, log);
+      return false;
+    }
+    case WL_CONNECT_FAILED: {
+      log = F("WIFI : Connection failed to: ");
+      log += ssid;
+      addLog(LOG_LEVEL_INFO, log);
+      return false;
+    }
+    default:
+     break;
+  }
+  return true; // Sent
+}
+
+//********************************************************************************
+// Disconnect from Wifi AP
+//********************************************************************************
+void WifiDisconnect()
+{
+  WiFi.disconnect();
+}
+
+
+//********************************************************************************
+// Scan all Wifi Access Points
+//********************************************************************************
+void WifiScan()
+{
+  // Direct Serial is allowed here, since this function will only be called from serial input.
+  Serial.println(F("WIFI : SSID Scan start"));
+  int n = WiFi.scanNetworks();
+  if (n == 0)
+    Serial.println(F("WIFI : No networks found"));
+  else
+  {
+    Serial.print(F("WIFI : "));
+    Serial.print(n);
+    Serial.println(F(" networks found"));
+    for (int i = 0; i < n; ++i)
+    {
+      // Print SSID and RSSI for each network found
+      Serial.print(F("WIFI : "));
+      Serial.print(i + 1);
+      Serial.print(": ");
+      Serial.print(WiFi.SSID(i));
+      Serial.print(" (");
+      Serial.print(WiFi.RSSI(i));
+      Serial.print(")");
+      Serial.println("");
+      delay(10);
+    }
+  }
+  Serial.println("");
+}
+
+
+//********************************************************************************
+// Check if we are still connected to a Wifi AP
+//********************************************************************************
+void WifiCheck()
+{
+  if(wifiSetup)
+    return;
+
+  if (wifiStatus == ESPEASY_WIFI_DISCONNECTED)
+  {
+    NC_Count++;
+    WiFiConnectRelaxed();
+  }
+  //connected
+  else
+  {
+    C_Count++;
+    NC_Count = 0;
+    if (C_Count > 2) // disable AP after timeout if a Wifi connection is established...
+    {
+      WifiAPMode(false);
+    }
+  }
+}
+
+//********************************************************************************
+// Return subnet range of WiFi.
+//********************************************************************************
+bool getSubnetRange(IPAddress& low, IPAddress& high)
+{
+  if (WifiIsAP()) {
+    // WiFi is active as accesspoint, do not check.
+    return false;
+  }
+  if (wifiStatus < ESPEASY_WIFI_GOT_IP) {
+    return false;
+  }
+  const IPAddress ip = WiFi.localIP();
+  const IPAddress subnet = WiFi.subnetMask();
+  low = ip;
+  high = ip;
+  // Compute subnet range.
+  for (byte i=0; i < 4; ++i) {
+    if (subnet[i] != 255) {
+      low[i] = low[i] & subnet[i];
+      high[i] = high[i] | ~subnet[i];
+    }
+  }
+  return true;
+}
+
+String getLastDisconnectReason() {
+  switch (lastDisconnectReason) {
+    case WIFI_DISCONNECT_REASON_UNSPECIFIED:                return F("Unspecified");
+    case WIFI_DISCONNECT_REASON_AUTH_EXPIRE:                return F("Auth expire");
+    case WIFI_DISCONNECT_REASON_AUTH_LEAVE:                 return F("Auth leave");
+    case WIFI_DISCONNECT_REASON_ASSOC_EXPIRE:               return F("Assoc expire");
+    case WIFI_DISCONNECT_REASON_ASSOC_TOOMANY:              return F("Assoc toomany");
+    case WIFI_DISCONNECT_REASON_NOT_AUTHED:                 return F("Not authed");
+    case WIFI_DISCONNECT_REASON_NOT_ASSOCED:                return F("Not assoced");
+    case WIFI_DISCONNECT_REASON_ASSOC_LEAVE:                return F("Assoc leave");
+    case WIFI_DISCONNECT_REASON_ASSOC_NOT_AUTHED:           return F("Assoc not authed");
+    case WIFI_DISCONNECT_REASON_DISASSOC_PWRCAP_BAD:        return F("Disassoc pwrcap bad");
+    case WIFI_DISCONNECT_REASON_DISASSOC_SUPCHAN_BAD:       return F("Disassoc supchan bad");
+    case WIFI_DISCONNECT_REASON_IE_INVALID:                 return F("IE invalid");
+    case WIFI_DISCONNECT_REASON_MIC_FAILURE:                return F("Mic failure");
+    case WIFI_DISCONNECT_REASON_4WAY_HANDSHAKE_TIMEOUT:     return F("4way handshake timeout");
+    case WIFI_DISCONNECT_REASON_GROUP_KEY_UPDATE_TIMEOUT:   return F("Group key update timeout");
+    case WIFI_DISCONNECT_REASON_IE_IN_4WAY_DIFFERS:         return F("IE in 4way differs");
+    case WIFI_DISCONNECT_REASON_GROUP_CIPHER_INVALID:       return F("Group cipher invalid");
+    case WIFI_DISCONNECT_REASON_PAIRWISE_CIPHER_INVALID:    return F("Pairwise cipher invalid");
+    case WIFI_DISCONNECT_REASON_AKMP_INVALID:               return F("AKMP invalid");
+    case WIFI_DISCONNECT_REASON_UNSUPP_RSN_IE_VERSION:      return F("Unsupp RSN IE version");
+    case WIFI_DISCONNECT_REASON_INVALID_RSN_IE_CAP:         return F("Invalid RSN IE cap");
+    case WIFI_DISCONNECT_REASON_802_1X_AUTH_FAILED:         return F("802 1X auth failed");
+    case WIFI_DISCONNECT_REASON_CIPHER_SUITE_REJECTED:      return F("Cipher suite rejected");
+    case WIFI_DISCONNECT_REASON_BEACON_TIMEOUT:             return F("Beacon timeout");
+    case WIFI_DISCONNECT_REASON_NO_AP_FOUND:                return F("No AP found");
+    case WIFI_DISCONNECT_REASON_AUTH_FAIL:                  return F("Auth fail");
+    case WIFI_DISCONNECT_REASON_ASSOC_FAIL:                 return F("Assoc fail");
+    case WIFI_DISCONNECT_REASON_HANDSHAKE_TIMEOUT:          return F("Handshake timeout");
+  }
+  return F("Unknown");
+}

src/Networking.ino

@@ -7,13 +7,12 @@
   #endif
 
 
-
 /*********************************************************************************************\
    Syslog client
   \*********************************************************************************************/
 void syslog(const char *message)
 {
-  if (Settings.Syslog_IP[0] != 0 && WiFi.status() == WL_CONNECTED)
+  if (Settings.Syslog_IP[0] != 0 && wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED)
   {
     IPAddress broadcastIP(Settings.Syslog_IP[0], Settings.Syslog_IP[1], Settings.Syslog_IP[2], Settings.Syslog_IP[3]);
     portUDP.beginPacket(broadcastIP, 514);
@@ -37,35 +36,6 @@ void syslog(const char *message)
 }
 
 
-/*********************************************************************************************\
-   Structs for UDP messaging
-  \*********************************************************************************************/
-struct infoStruct
-{
-  byte header = 255;
-  byte ID = 3;
-  byte sourcelUnit;
-  byte destUnit;
-  byte sourceTaskIndex;
-  byte destTaskIndex;
-  byte deviceNumber;
-  char taskName[26];
-  char ValueNames[VARS_PER_TASK][26];
-};
-
-struct dataStruct
-{
-  byte header = 255;
-  byte ID = 5;
-  byte sourcelUnit;
-  byte destUnit;
-  byte sourceTaskIndex;
-  byte destTaskIndex;
-  float Values[VARS_PER_TASK];
-};
-
-//TODO: add sysinfoStruct
-
 /*********************************************************************************************\
    Check UDP messages (ESPEasy propiertary protocol)
   \*********************************************************************************************/
@@ -109,22 +79,10 @@ void checkUDP()
     }
     else
     {
-      if (packetBuffer[1] > 1 && packetBuffer[1] < 6)
-      {
-        String log = (F("UDP  : Sensor msg "));
-        for (byte x = 1; x < 6; x++)
-        {
-          log += " ";
-          log += (int)packetBuffer[x];
-        }
-        addLog(LOG_LEVEL_DEBUG_MORE, log);
-      }
-
       // binary data!
       switch (packetBuffer[1])
       {
 
-        //TODO: use a nice struct for it
         case 1: // sysinfo message
           {
             byte mac[6];
@@ -161,70 +119,13 @@ void checkUDP()
             break;
           }
 
-        case 2: // sensor info pull request
-          {
-            SendUDPTaskInfo(packetBuffer[2], packetBuffer[5], packetBuffer[4]);
-            break;
-          }
-
-        case 3: // sensor info
-          {
-            if (Settings.GlobalSync)
-            {
-              struct infoStruct infoReply;
-              memcpy((byte*)&infoReply, (byte*)&packetBuffer, sizeof(infoStruct));
-
-              // to prevent flash wear out (bugs in communication?) we can only write to an empty task
-              // so it will write only once and has to be cleared manually through webgui
-              if (Settings.TaskDeviceNumber[infoReply.destTaskIndex] == 0)
-              {
-                Settings.TaskDeviceNumber[infoReply.destTaskIndex] = infoReply.deviceNumber;
-                Settings.TaskDeviceDataFeed[infoReply.destTaskIndex] = 1;  // remote feed
-                for (byte x=0; x < CONTROLLER_MAX; x++)
-                  Settings.TaskDeviceSendData[x][infoReply.destTaskIndex] = false;
-                strcpy(ExtraTaskSettings.TaskDeviceName, infoReply.taskName);
-                for (byte x = 0; x < VARS_PER_TASK; x++)
-                  strcpy( ExtraTaskSettings.TaskDeviceValueNames[x], infoReply.ValueNames[x]);
-                SaveTaskSettings(infoReply.destTaskIndex);
-                SaveSettings();
-              }
-            }
-            break;
-          }
-
-        case 4: // sensor data pull request
-          {
-            SendUDPTaskData(packetBuffer[2], packetBuffer[5], packetBuffer[4]);
-            break;
-          }
-
-        case 5: // sensor data
-          {
-            if (Settings.GlobalSync)
-            {
-              struct dataStruct dataReply;
-              memcpy((byte*)&dataReply, (byte*)&packetBuffer, sizeof(dataStruct));
-
-              // only if this task has a remote feed, update values
-              if (Settings.TaskDeviceDataFeed[dataReply.destTaskIndex] != 0)
-              {
-                for (byte x = 0; x < VARS_PER_TASK; x++)
-                {
-                  UserVar[dataReply.destTaskIndex * VARS_PER_TASK + x] = dataReply.Values[x];
-                }
-                if (Settings.UseRules)
-                  createRuleEvents(dataReply.destTaskIndex);
-              }
-            }
-            break;
-          }
-
         default:
           {
             struct EventStruct TempEvent;
             TempEvent.Data = (byte*)packetBuffer;
             TempEvent.Par1 = remoteIP[3];
             PluginCall(PLUGIN_UDP_IN, &TempEvent, dummyString);
+            CPluginCall(CPLUGIN_UDP_IN, &TempEvent);
             break;
           }
       }
@@ -237,73 +138,6 @@ void checkUDP()
 }
 
 
-/*********************************************************************************************\
-   Send task info using UDP message
-  \*********************************************************************************************/
-void SendUDPTaskInfo(byte destUnit, byte sourceTaskIndex, byte destTaskIndex)
-{
-  if (!WiFiConnected(100)) {
-    return;
-  }
-  struct infoStruct infoReply;
-  infoReply.sourcelUnit = Settings.Unit;
-  infoReply.sourceTaskIndex = sourceTaskIndex;
-  infoReply.destTaskIndex = destTaskIndex;
-  LoadTaskSettings(infoReply.sourceTaskIndex);
-  infoReply.deviceNumber = Settings.TaskDeviceNumber[infoReply.sourceTaskIndex];
-  strcpy(infoReply.taskName, ExtraTaskSettings.TaskDeviceName);
-  for (byte x = 0; x < VARS_PER_TASK; x++)
-    strcpy(infoReply.ValueNames[x], ExtraTaskSettings.TaskDeviceValueNames[x]);
-
-  byte firstUnit = 1;
-  byte lastUnit = UNIT_MAX - 1;
-  if (destUnit != 0)
-  {
-    firstUnit = destUnit;
-    lastUnit = destUnit;
-  }
-  for (byte x = firstUnit; x <= lastUnit; x++)
-  {
-    infoReply.destUnit = x;
-    sendUDP(x, (byte*)&infoReply, sizeof(infoStruct));
-    delay(10);
-  }
-  delay(50);
-}
-
-
-/*********************************************************************************************\
-   Send task data using UDP message
-  \*********************************************************************************************/
-void SendUDPTaskData(byte destUnit, byte sourceTaskIndex, byte destTaskIndex)
-{
-  if (!WiFiConnected(100)) {
-    return;
-  }
-  struct dataStruct dataReply;
-  dataReply.sourcelUnit = Settings.Unit;
-  dataReply.sourceTaskIndex = sourceTaskIndex;
-  dataReply.destTaskIndex = destTaskIndex;
-  for (byte x = 0; x < VARS_PER_TASK; x++)
-    dataReply.Values[x] = UserVar[dataReply.sourceTaskIndex * VARS_PER_TASK + x];
-
-  byte firstUnit = 1;
-  byte lastUnit = UNIT_MAX - 1;
-  if (destUnit != 0)
-  {
-    firstUnit = destUnit;
-    lastUnit = destUnit;
-  }
-  for (byte x = firstUnit; x <= lastUnit; x++)
-  {
-    dataReply.destUnit = x;
-    sendUDP(x, (byte*) &dataReply, sizeof(dataStruct));
-    delay(10);
-  }
-  delay(50);
-}
-
-
 /*********************************************************************************************\
    Send event using UDP message
   \*********************************************************************************************/
@@ -752,16 +586,20 @@ void SSDP_update() {
       _server->flush();
   }
 }
+#endif
 
-// Check WiFi connection. Maximum timeout 2000 msec.
+// Check WiFi connection. Maximum timeout 500 msec.
 bool WiFiConnected(uint32_t timeout_ms) {
-  uint32_t timer = millis() + (timeout_ms > 2000 ? 2000 : timeout_ms);
-  uint32_t min_delay = timeout_ms / 10;
+  uint32_t timer = millis() + (timeout_ms > 500 ? 500 : timeout_ms);
+  uint32_t min_delay = timeout_ms / 20;
   if (min_delay < 10) {
     yield(); // Allow at least once time for backgroundtasks
     min_delay = 10;
   }
-  while (WiFi.status() != WL_CONNECTED) {
+  // Apparently something needs network, perform check to see if it is ready now.
+//  if (!tryConnectWiFi())
+//    return false;
+  while (wifiStatus != ESPEASY_WIFI_SERVICES_INITIALIZED) {
     if (timeOutReached(timer)) {
       return false;
     }
@@ -769,4 +607,32 @@ bool WiFiConnected(uint32_t timeout_ms) {
   }
   return true;
 }
+
+bool hostReachable(const IPAddress& ip) {
+  // Only do 1 ping at a time to return early
+  byte retry = 3;
+  while (retry > 0) {
+#if defined(ESP8266)
+    if (Ping.ping(ip, 1)) return true;
 #endif
+#if defined(ESP32)
+  if (ping_start(ip, 4, 0, 0, 5)) return true;
+#endif
+    delay(50);
+    --retry;
+  }
+  String log = F("Host unreachable: ");
+  log += formatIP(ip);
+  addLog(LOG_LEVEL_ERROR, log);
+  return false;
+}
+
+bool hostReachable(const String& hostname) {
+  IPAddress remote_addr;
+  if (WiFi.hostByName(hostname.c_str(), remote_addr))
+    return hostReachable(remote_addr);
+  String log = F("Hostname cannot be resolved: ");
+  log += hostname;
+  addLog(LOG_LEVEL_ERROR, log);
+  return false;
+}

src/StringConverter.ino

@@ -37,7 +37,22 @@ boolean str2ip(const char *string, byte* IP)
   return false;
 }
 
+// Call this by first declaring a char array of size 20, like:
+//  char strIP[20];
+//  formatIP(ip, strIP);
+void formatIP(const IPAddress& ip, char (&strIP)[20]) {
+  sprintf_P(strIP, PSTR("%u.%u.%u.%u"), ip[0], ip[1], ip[2], ip[3]);
+}
 
+String formatIP(const IPAddress& ip) {
+  char strIP[20];
+  formatIP(ip, strIP);
+  return String(strIP);
+}
+
+void formatMAC(const uint8_t* mac, char (&strMAC)[20]) {
+  sprintf_P(strMAC, PSTR("%02X:%02X:%02X:%02X:%02X:%02X"), mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+}
 
 /*********************************************************************************************\
    Workaround for removing trailing white space when String() converts a float with 0 decimals
@@ -66,6 +81,35 @@ String formatUserVar(struct EventStruct *event, byte rel_index)
   return toString(f, ExtraTaskSettings.TaskDeviceValueDecimals[rel_index]);
 }
 
+/*********************************************************************************************\
+   Wrap a string with given pre- and postfix string.
+  \*********************************************************************************************/
+String wrap_String(const String& string, const String& wrap) {
+  String result;
+  result.reserve(string.length() + 2* wrap.length());
+  result = wrap;
+  result += string;
+  result += wrap;
+  return result;
+}
+
+/*********************************************************************************************\
+   Format an object value pair for use in JSON.
+  \*********************************************************************************************/
+String to_json_object_value(const String& object, const String& value) {
+  String result;
+  result.reserve(object.length() + value.length() + 6);
+  result = wrap_String(object, F("\""));
+  result += F(":");
+  if (value.length() == 0 || !isFloat(value)) {
+    result += wrap_String(value, F("\""));
+  } else {
+    result += value;
+  }
+  return result;
+}
+
+
 /*********************************************************************************************\
    Parse a string and get the xth command or parameter
   \*********************************************************************************************/
@@ -126,6 +170,13 @@ void htmlEscape(String & html)
 /********************************************************************************************\
   replace other system variables like %sysname%, %systime%, %ip%
   \*********************************************************************************************/
+void parseControllerVariables(String& s, struct EventStruct *event, boolean useURLencode) {
+  parseSystemVariables(s, useURLencode);
+  parseEventVariables(s, event, useURLencode);
+  parseStandardConversions(s, useURLencode);
+}
+
+
 void repl(const String& key, const String& val, String& s, boolean useURLencode)
 {
   if (useURLencode) {
@@ -227,15 +278,20 @@ void parseSystemVariables(String& s, boolean useURLencode)
   repl(F("%CR%"), F("\r"), s, useURLencode);
   repl(F("%LF%"), F("\n"), s, useURLencode);
   SMART_REPL(F("%ip%"),WiFi.localIP().toString())
-  SMART_REPL(F("%rssi%"), String((WiFi.status() == WL_CONNECTED) ? WiFi.RSSI() : 0))
-  SMART_REPL(F("%ssid%"), (WiFi.status() == WL_CONNECTED) ? WiFi.SSID() : F("--"))
+  SMART_REPL(F("%rssi%"), String((wifiStatus == ESPEASY_WIFI_DISCONNECTED) ? 0 : WiFi.RSSI()))
+  SMART_REPL(F("%ssid%"), (wifiStatus == ESPEASY_WIFI_DISCONNECTED) ? F("--") : WiFi.SSID())
   SMART_REPL(F("%unit%"), String(Settings.Unit))
   SMART_REPL(F("%mac%"), String(WiFi.macAddress()))
-  SMART_REPL(F("%mac_int%"), String(ESP.getChipId()))  // Last 24 bit of MAC address as integer, to be used in rules.
+  #if defined(ESP8266)
+    SMART_REPL(F("%mac_int%"), String(ESP.getChipId()))  // Last 24 bit of MAC address as integer, to be used in rules.
+  #endif
 
   if (s.indexOf(F("%sys")) != -1) {
     SMART_REPL(F("%sysload%"), String(100 - (100 * loopCounterLast / loopCounterMax)))
+    SMART_REPL(F("%systm_hm%"), getTimeString(':', false))
+    SMART_REPL(F("%systm_hm_am%"), getTimeString_ampm(':', false))
     SMART_REPL(F("%systime%"), getTimeString(':'))
+    SMART_REPL(F("%systime_am%"), getTimeString_ampm(':'))
     repl(F("%sysname%"), Settings.Name, s, useURLencode);
 
     // valueString is being used by the macro.
@@ -248,10 +304,14 @@ void parseSystemVariables(String& s, boolean useURLencode)
     SMART_REPL_TIME(F("%sysmonth%"),PSTR("%02d"), month())
     SMART_REPL_TIME(F("%sysyear%"), PSTR("%04d"), year())
     SMART_REPL_TIME(F("%sysyears%"),PSTR("%02d"), year()%100)
+    SMART_REPL(F("%sysweekday%"), String(weekday()))
+    SMART_REPL(F("%sysweekday_s%"), weekday_str())
     #undef SMART_REPL_TIME
   }
   SMART_REPL(F("%lcltime%"), getDateTimeString('-',':',' '))
+  SMART_REPL(F("%lcltime_am%"), getDateTimeString_ampm('-',':',' '))
   SMART_REPL(F("%uptime%"), String(wdcounter / 2))
+  SMART_REPL(F("%unixtime%"), String(getUnixTime()))
 
   repl(F("%tskname%"), ExtraTaskSettings.TaskDeviceName, s, useURLencode);
   if (s.indexOf("%vname") != -1) {
@@ -277,3 +337,48 @@ void parseEventVariables(String& s, struct EventStruct *event, boolean useURLenc
   }
 }
 #undef SMART_REPL
+
+bool getConvertArgument(const String& marker, const String& s, float& argument, int& startIndex, int& endIndex) {
+  startIndex = s.indexOf(marker);
+  if (startIndex == -1) return false;
+
+  int startIndexArgument = startIndex + marker.length();
+  if (s.charAt(startIndexArgument) != '(') {
+    return false;
+  }
+  ++startIndexArgument;
+  endIndex = s.indexOf(')', startIndexArgument);
+  if (endIndex == -1) return false;
+
+  String argumentString = s.substring(startIndexArgument, endIndex);
+  if (argumentString.length() == 0 || !isFloat(argumentString)) return false;
+
+  argument = argumentString.toFloat();
+  ++endIndex; // Must also strip ')' from the original string.
+  return true;
+}
+
+// Parse conversions marked with "%conv_marker%(float)"
+// Must be called last, since all sensor values must be converted, processed, etc.
+void parseStandardConversions(String& s, boolean useURLencode) {
+  if (s.indexOf(F("%c_")) == -1)
+    return; // Nothing to replace
+
+  float arg = 0.0;
+  int startIndex = 0;
+  int endIndex = 0;
+  // These replacements should be done in a while loop per marker,
+  // since they also replace the numerical parameter.
+  // The marker may occur more than once per string, but with different parameters.
+  #define SMART_CONV(T,FUN) while (getConvertArgument((T), s, arg, startIndex, endIndex)) { repl(s.substring(startIndex, endIndex), (FUN), s, useURLencode); }
+  SMART_CONV(F("%c_w_dir%"),  getBearing(arg))
+  SMART_CONV(F("%c_c2f%"),    toString(CelsiusToFahrenheit(arg), 1))
+  SMART_CONV(F("%c_ms2Bft%"), String(m_secToBeaufort(arg)))
+  SMART_CONV(F("%c_cm2imp%"), centimeterToImperialLength(arg))
+  SMART_CONV(F("%c_mm2imp%"), millimeterToImperialLength(arg))
+  SMART_CONV(F("%c_m2day%"),  toString(minutesToDay(arg), 2))
+  SMART_CONV(F("%c_m2dh%"),   minutesToDayHour(arg))
+  SMART_CONV(F("%c_m2dhm%"),  minutesToDayHourMinute(arg))
+  SMART_CONV(F("%c_s2dhms%"), secondsToDayHourMinuteSecond(arg))
+  #undef SMART_CONV
+}

src/TimeESPeasy.ino

@@ -72,8 +72,20 @@ void breakTime(unsigned long timeInput, struct timeStruct &tm) {
 
 void setTime(unsigned long t) {
   sysTime = (uint32_t)t;
+  applyTimeZone(t);
   nextSyncTime = (uint32_t)t + syncInterval;
   prevMillis = millis();  // restart counting from now (thanks to Korman for this fix)
+  if (Settings.UseRules)
+  {
+    static bool firstUpdate = true;
+    String event = firstUpdate ? F("Time#Initialized") : F("Time#Set");
+    firstUpdate = false;
+    rulesProcessing(event);
+  }
+}
+
+uint32_t getUnixTime() {
+  return sysTime;
 }
 
 unsigned long now() {
@@ -87,9 +99,6 @@ unsigned long now() {
     unsigned long  t = getNtpTime();
     if (t != 0) {
       setTime(t);
-      applyTimeZone(t);
-    } else {
-      nextSyncTime = sysTime + syncInterval;
     }
   }
   uint32_t localSystime = toLocal(sysTime);
@@ -141,11 +150,19 @@ byte second()
 	return tm.Second;
 }
 
+// day of week, sunday is day 1
 int weekday()
 {
   return tm.Wday;
 }
 
+String weekday_str()
+{
+  const int wday(weekday() - 1); // here: Count from Sunday = 0
+  const String weekDays = F("SunMonTueWedThuFriSat");
+  return weekDays.substring(wday * 3, wday * 3 + 3);
+}
+
 void initTime()
 {
   nextSyncTime = 0;
@@ -161,9 +178,10 @@ void checkTime()
     PrevMinutes = tm.Minute;
     if (Settings.UseRules)
     {
-      String weekDays = F("AllSunMonTueWedThuFriSat");
-      String event = F("Clock#Time=");
-      event += weekDays.substring(weekday() * 3, weekday() * 3 + 3);
+      String event;
+      event.reserve(21);
+      event = F("Clock#Time=");
+      event += weekday_str();
       event += ",";
       if (hour() < 10)
         event += "0";
@@ -180,68 +198,78 @@ void checkTime()
 
 unsigned long getNtpTime()
 {
-  if (!Settings.UseNTP || !WiFiConnected(100)) {
+  if (!Settings.UseNTP || !WiFiConnected(10)) {
     return 0;
   }
+  IPAddress timeServerIP;
+  String log = F("NTP  : NTP send to ");
+  if (Settings.NTPHost[0] != 0) {
+    WiFi.hostByName(Settings.NTPHost, timeServerIP);
+    log += Settings.NTPHost;
+    // When single set host fails, retry again in a minute
+    nextSyncTime = sysTime + 20;
+  }
+  else {
+    // Have to do a lookup eacht time, since the NTP pool always returns another IP
+    String ntpServerName = String(random(0, 3));
+    ntpServerName += F(".pool.ntp.org");
+    WiFi.hostByName(ntpServerName.c_str(), timeServerIP);
+    log += ntpServerName;
+    // When pool host fails, retry can be much sooner
+    nextSyncTime = sysTime + 5;
+  }
+
+  if (!hostReachable(timeServerIP)) {
+    return 0;
+  }
+
   WiFiUDP udp;
   udp.begin(123);
-  for (byte x = 1; x < 4; x++)
-  {
-    String log = F("NTP  : NTP sync request:");
-    log += x;
-    addLog(LOG_LEVEL_DEBUG_MORE, log);
 
-    const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
-    byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
+  const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
+  byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
 
-    IPAddress timeServerIP;
-    const char* ntpServerName = "pool.ntp.org";
+  log += F(" (");
+  log += timeServerIP.toString();
+  log += F(")");
+  addLog(LOG_LEVEL_DEBUG_MORE, log);
 
-    if (Settings.NTPHost[0] != 0)
-      WiFi.hostByName(Settings.NTPHost, timeServerIP);
-    else
-      WiFi.hostByName(ntpServerName, timeServerIP);
+  while (udp.parsePacket() > 0) ; // discard any previously received packets
 
-    log = F("NTP  : NTP send to ");
-    log += timeServerIP.toString();
-    addLog(LOG_LEVEL_DEBUG_MORE, log);
+  memset(packetBuffer, 0, NTP_PACKET_SIZE);
+  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
+  packetBuffer[1] = 0;     // Stratum, or type of clock
+  packetBuffer[2] = 6;     // Polling Interval
+  packetBuffer[3] = 0xEC;  // Peer Clock Precision
+  packetBuffer[12]  = 49;
+  packetBuffer[13]  = 0x4E;
+  packetBuffer[14]  = 49;
+  packetBuffer[15]  = 52;
+  udp.beginPacket(timeServerIP, 123); //NTP requests are to port 123
+  udp.write(packetBuffer, NTP_PACKET_SIZE);
+  udp.endPacket();
 
-    while (udp.parsePacket() > 0) ; // discard any previously received packets
-
-    memset(packetBuffer, 0, NTP_PACKET_SIZE);
-    packetBuffer[0] = 0b11100011;   // LI, Version, Mode
-    packetBuffer[1] = 0;     // Stratum, or type of clock
-    packetBuffer[2] = 6;     // Polling Interval
-    packetBuffer[3] = 0xEC;  // Peer Clock Precision
-    packetBuffer[12]  = 49;
-    packetBuffer[13]  = 0x4E;
-    packetBuffer[14]  = 49;
-    packetBuffer[15]  = 52;
-    udp.beginPacket(timeServerIP, 123); //NTP requests are to port 123
-    udp.write(packetBuffer, NTP_PACKET_SIZE);
-    udp.endPacket();
-
-    uint32_t beginWait = millis();
-    while (!timeOutReached(beginWait + 1000)) {
-      int size = udp.parsePacket();
-      if (size >= NTP_PACKET_SIZE) {
-        udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
-        unsigned long secsSince1900;
-        // convert four bytes starting at location 40 to a long integer
-        secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
-        secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
-        secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
-        secsSince1900 |= (unsigned long)packetBuffer[43];
-        log = F("NTP  : NTP replied: ");
-        log += timePassedSince(beginWait);
-        log += F(" mSec");
-        addLog(LOG_LEVEL_DEBUG_MORE, log);
-        return secsSince1900 - 2208988800UL;
-      }
+  uint32_t beginWait = millis();
+  while (!timeOutReached(beginWait + 1000)) {
+    int size = udp.parsePacket();
+    if (size >= NTP_PACKET_SIZE) {
+      udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
+      unsigned long secsSince1900;
+      // convert four bytes starting at location 40 to a long integer
+      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
+      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
+      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
+      secsSince1900 |= (unsigned long)packetBuffer[43];
+      log = F("NTP  : NTP replied: ");
+      log += timePassedSince(beginWait);
+      log += F(" mSec");
+      addLog(LOG_LEVEL_DEBUG_MORE, log);
+      return secsSince1900 - 2208988800UL;
     }
-    log = F("NTP  : No reply");
-    addLog(LOG_LEVEL_DEBUG_MORE, log);
+    delay(10);
   }
+  log = F("NTP  : No reply");
+  addLog(LOG_LEVEL_DEBUG_MORE, log);
   return 0;
 }
 
@@ -376,16 +404,40 @@ String getDateString()
 
 // returns the current Time separated by the given delimiter
 // time format example with ':' delimiter: 23:59:59 (HH:MM:SS)
-String getTimeString(const timeStruct& ts, char delimiter)
+String getTimeString(const timeStruct& ts, char delimiter, bool am_pm, bool show_seconds)
 {
   char TimeString[20]; //19 digits plus the null char
-  sprintf_P(TimeString, PSTR("%02d%c%02d%c%02d"), ts.Hour, delimiter, ts.Minute, delimiter, ts.Second);
+  if (am_pm) {
+    uint8_t hour(ts.Hour % 12);
+    if (hour == 0) { hour = 12; }
+    const char a_or_p = ts.Hour < 12 ? 'A' : 'P';
+    if (show_seconds) {
+      sprintf_P(TimeString, PSTR("%d%c%02d%c%02d %cM"),
+        hour, delimiter, ts.Minute, delimiter, ts.Second, a_or_p);
+    } else {
+      sprintf_P(TimeString, PSTR("%d%c%02d %cM"),
+        hour, delimiter, ts.Minute, a_or_p);
+    }
+  } else {
+    if (show_seconds) {
+      sprintf_P(TimeString, PSTR("%02d%c%02d%c%02d"),
+        ts.Hour, delimiter, ts.Minute, delimiter, ts.Second);
+    } else {
+      sprintf_P(TimeString, PSTR("%d%c%02d"),
+        ts.Hour, delimiter, ts.Minute);
+    }
+  }
   return TimeString;
 }
 
-String getTimeString(char delimiter)
+String getTimeString(char delimiter, bool show_seconds /*=true*/)
 {
-  return getTimeString(tm, delimiter);
+  return getTimeString(tm, delimiter, false, show_seconds);
+}
+
+String getTimeString_ampm(char delimiter, bool show_seconds /*=true*/)
+{
+  return getTimeString(tm, delimiter, true, show_seconds);
 }
 
 // returns the current Time without delimiter
@@ -395,26 +447,35 @@ String getTimeString()
 	return getTimeString('\0');
 }
 
+String getTimeString_ampm()
+{
+	return getTimeString_ampm('\0');
+}
+
 // returns the current Date and Time separated by the given delimiter
 // if called like this: getDateTimeString('\0', '\0', '\0');
 // it will give back this: 20161231235959  (YYYYMMDDHHMMSS)
-String getDateTimeString(const timeStruct& ts, char dateDelimiter, char timeDelimiter,  char dateTimeDelimiter)
+String getDateTimeString(const timeStruct& ts, char dateDelimiter, char timeDelimiter,  char dateTimeDelimiter, bool am_pm)
 {
 	String ret = getDateString(ts, dateDelimiter);
 	if (dateTimeDelimiter != '\0')
 		ret += dateTimeDelimiter;
-	ret += getTimeString(ts, timeDelimiter);
+	ret += getTimeString(ts, timeDelimiter, am_pm, true);
 	return ret;
 }
 
 String getDateTimeString(char dateDelimiter, char timeDelimiter,  char dateTimeDelimiter) {
-  return getDateTimeString(tm, dateDelimiter, timeDelimiter, dateTimeDelimiter);
+  return getDateTimeString(tm, dateDelimiter, timeDelimiter, dateTimeDelimiter, false);
+}
+
+String getDateTimeString_ampm(char dateDelimiter, char timeDelimiter,  char dateTimeDelimiter) {
+  return getDateTimeString(tm, dateDelimiter, timeDelimiter, dateTimeDelimiter, true);
 }
 
 /********************************************************************************************\
   Convert a string like "Sun,12:30" into a 32 bit integer
   \*********************************************************************************************/
-unsigned long string2TimeLong(String &str)
+unsigned long string2TimeLong(const String &str)
 {
   // format 0000WWWWAAAABBBBCCCCDDDD
   // WWWW=weekday, AAAA=hours tens digit, BBBB=hours, CCCC=minutes tens digit DDDD=minutes
@@ -423,8 +484,12 @@ unsigned long string2TimeLong(String &str)
   char TmpStr1[10];
   int w, x, y;
   unsigned long a;
-  str.toLowerCase();
-  str.toCharArray(command, 20);
+  {
+    // Within a scope so the tmpString is only used for copy.
+    String tmpString(str);
+    tmpString.toLowerCase();
+    tmpString.toCharArray(command, 20);
+  }
   unsigned long lngTime = 0;
 
   if (GetArgv(command, TmpStr1, 1))

src/TimeZoneESPeasy.ino

@@ -97,7 +97,7 @@ void logTimeZoneInfo() {
     if (m_dstLoc != 0) {
       timeStruct tmp;
       breakTime(m_dstLoc, tmp);
-      log += getDateTimeString(tmp, '-', ':', ' ');
+      log += getDateTimeString(tmp, '-', ':', ' ', false);
     }
     log += F(" offset: ");
     log += m_dst.offset;
@@ -108,7 +108,7 @@ void logTimeZoneInfo() {
   if (m_stdLoc != 0) {
     timeStruct tmp;
     breakTime(m_stdLoc, tmp);
-    log += getDateTimeString(tmp, '-', ':', ' ');
+    log += getDateTimeString(tmp, '-', ':', ' ', false);
   }
   log += F(" offset: ");
   log += m_std.offset;

src/Wifi.ino

@@ -1,330 +0,0 @@
-//********************************************************************************
-// Determine Wifi AP name to set. (also used for mDNS)
-//********************************************************************************
-String WifiGetAPssid()
-{
-  String ssid(Settings.Name);
-  ssid+=F("_");
-  ssid+=Settings.Unit;
-  return (ssid);
-}
-
-//********************************************************************************
-// Determine hostname: basically WifiGetAPssid with spaces changed to -
-//********************************************************************************
-String WifiGetHostname()
-{
-  String hostname(WifiGetAPssid());
-  hostname.replace(F(" "), F("-"));
-  return (hostname);
-}
-
-
-//********************************************************************************
-// Set Wifi AP Mode config
-//********************************************************************************
-void WifiAPconfig()
-{
-  // create and store unique AP SSID/PW to prevent ESP from starting AP mode with default SSID and No password!
-  // setup ssid for AP Mode when needed
-  WiFi.softAP(WifiGetAPssid().c_str(), SecuritySettings.WifiAPKey);
-  // We start in STA mode
-  WifiAPMode(false);
-
-  String log("WIFI : AP Mode ssid will be ");
-  log=log+WifiGetAPssid();
-
-  log=log+F(" with address ");
-  log=log+apIP.toString();
-  addLog(LOG_LEVEL_INFO, log);
-
-
-}
-
-
-bool WifiIsAP()
-{
-  #if defined(ESP8266)
-    byte wifimode = wifi_get_opmode();
-  #endif
-  #if defined(ESP32)
-    byte wifimode = WiFi.getMode();
-  #endif
-  return(wifimode == 2 || wifimode == 3); //apmode is enabled
-}
-
-//********************************************************************************
-// Set Wifi AP Mode
-//********************************************************************************
-void WifiAPMode(boolean state)
-{
-  if (WifiIsAP())
-  {
-    //want to disable?
-    if (!state)
-    {
-      WiFi.mode(WIFI_STA);
-      addLog(LOG_LEVEL_INFO, F("WIFI : AP Mode disabled"));
-    }
-  }
-  else
-  {
-    //want to enable?
-    if (state)
-    {
-      WiFi.mode(WIFI_AP_STA);
-      addLog(LOG_LEVEL_INFO, F("WIFI : AP Mode enabled"));
-    }
-  }
-}
-
-
-//********************************************************************************
-// Configure network and connect to Wifi SSID and SSID2
-//********************************************************************************
-boolean WifiConnect(byte connectAttempts)
-{
-  String log = "";
-  char hostname[40];
-  strncpy(hostname, WifiGetHostname().c_str(), sizeof(hostname));
-  #if defined(ESP8266)
-    wifi_station_set_hostname(hostname);
-  #endif
-  #if defined(ESP32)
-    WiFi.setHostname(hostname);
-  #endif
-
-  //use static ip?
-  if (Settings.IP[0] != 0 && Settings.IP[0] != 255)
-  {
-    const IPAddress ip = Settings.IP;
-    log = F("IP   : Static IP :");
-    log += ip;
-    addLog(LOG_LEVEL_INFO, log);
-    const IPAddress gw = Settings.Gateway;
-    const IPAddress subnet = Settings.Subnet;
-    const IPAddress dns = Settings.DNS;
-    WiFi.config(ip, gw, subnet, dns);
-  }
-
-  //try to connect to one of the access points
-  if (WifiConnectSSID(SecuritySettings.WifiSSID,  SecuritySettings.WifiKey,  connectAttempts) ||
-      WifiConnectSSID(SecuritySettings.WifiSSID2, SecuritySettings.WifiKey2, connectAttempts))
-  {
-    // fix octet?
-    if (Settings.IP_Octet != 0 && Settings.IP_Octet != 255)
-    {
-      IPAddress ip = WiFi.localIP();
-      IPAddress gw = WiFi.gatewayIP();
-      IPAddress subnet = WiFi.subnetMask();
-      ip[3] = Settings.IP_Octet;
-      log = F("IP   : Fixed IP octet:");
-      log += ip;
-      addLog(LOG_LEVEL_INFO, log);
-      WiFi.config(ip, gw, subnet);
-    }
-
-    #ifdef FEATURE_MDNS
-
-      String log = F("WIFI : ");
-      if (MDNS.begin(WifiGetHostname().c_str(), WiFi.localIP())) {
-
-        log += F("mDNS started, with name: ");
-        log += WifiGetHostname();
-        log += F(".local");
-      }
-      else{
-        log += F("mDNS failed");
-      }
-      addLog(LOG_LEVEL_INFO, log);
-    #endif
-
-    return(true);
-  }
-
-  addLog(LOG_LEVEL_ERROR, F("WIFI : Could not connect to AP!"));
-
-  //everything failed, activate AP mode (will deactivate automatically after a while if its connected again)
-  WifiAPMode(true);
-
-  return(false);
-}
-
-
-//********************************************************************************
-// Connect to Wifi specific SSID
-//********************************************************************************
-boolean WifiConnectSSID(char WifiSSID[], char WifiKey[], byte connectAttempts)
-{
-  String log;
-
-  //already connected, need to disconnect first
-  if (WiFi.status() == WL_CONNECTED)
-    return(true);
-
-  //no ssid specified
-  if ((WifiSSID[0] == 0)  || (strcasecmp(WifiSSID, "ssid") == 0))
-    return(false);
-
-  for (byte tryConnect = 1; tryConnect <= connectAttempts; tryConnect++)
-  {
-    log = F("WIFI : Connecting ");
-    log += WifiSSID;
-    log += F(" attempt #");
-    log += tryConnect;
-    addLog(LOG_LEVEL_INFO, log);
-
-    if (tryConnect == 1)
-      WiFi.begin(WifiSSID, WifiKey);
-    else
-      WiFi.begin();
-
-    //wait until it connects
-    for (byte x = 0; x < 200; x++)
-    {
-      if (!WiFiConnected(50))
-      {
-        statusLED(false);
-        // No delay needed, since the WiFi check has a delay
-      }
-      else
-        break;
-    }
-
-    if (WiFi.status() == WL_CONNECTED)
-    {
-      if (Settings.UseNTP) {
-        initTime();
-      }
-      log = F("WIFI : Connected! IP: ");
-      log += formatIP(WiFi.localIP());
-      log += F(" (");
-      log += WifiGetHostname();
-      log += F(")");
-
-      addLog(LOG_LEVEL_INFO, log);
-      statusLED(true);
-      return(true);
-    }
-    else
-    {
-      // log = F("WIFI : Disconnecting!");
-      // addLog(LOG_LEVEL_INFO, log);
-      #if defined(ESP8266)
-        ETS_UART_INTR_DISABLE();
-        wifi_station_disconnect();
-        ETS_UART_INTR_ENABLE();
-      #endif
-      for (byte x = 0; x < 20; x++)
-      {
-        statusLED(true);
-        delay(50);
-      }
-    }
-  }
-
-
-  return false;
-}
-
-
-//********************************************************************************
-// Disconnect from Wifi AP
-//********************************************************************************
-void WifiDisconnect()
-{
-  WiFi.disconnect();
-}
-
-
-//********************************************************************************
-// Scan all Wifi Access Points
-//********************************************************************************
-void WifiScan()
-{
-  // Direct Serial is allowed here, since this function will only be called from serial input.
-  Serial.println(F("WIFI : SSID Scan start"));
-  int n = WiFi.scanNetworks();
-  if (n == 0)
-    Serial.println(F("WIFI : No networks found"));
-  else
-  {
-    Serial.print(F("WIFI : "));
-    Serial.print(n);
-    Serial.println(F(" networks found"));
-    for (int i = 0; i < n; ++i)
-    {
-      // Print SSID and RSSI for each network found
-      Serial.print(F("WIFI : "));
-      Serial.print(i + 1);
-      Serial.print(": ");
-      Serial.print(WiFi.SSID(i));
-      Serial.print(" (");
-      Serial.print(WiFi.RSSI(i));
-      Serial.print(")");
-      Serial.println("");
-      delay(10);
-    }
-  }
-  Serial.println("");
-}
-
-
-//********************************************************************************
-// Check if we are still connected to a Wifi AP
-//********************************************************************************
-void WifiCheck()
-{
-
-  if(wifiSetup)
-    return;
-
-  if (WiFi.status() != WL_CONNECTED)
-  {
-    NC_Count++;
-    //give it time to automatically reconnect
-    if (NC_Count > 2)
-    {
-      WifiConnect(2);
-
-      C_Count=0;
-      NC_Count = 0;
-    }
-  }
-  //connected
-  else
-  {
-    C_Count++;
-    NC_Count = 0;
-    if (C_Count > 2) // disable AP after timeout if a Wifi connection is established...
-    {
-      WifiAPMode(false);
-    }
-  }
-}
-
-//********************************************************************************
-// Return subnet range of WiFi.
-//********************************************************************************
-bool getSubnetRange(IPAddress& low, IPAddress& high)
-{
-  if (WifiIsAP()) {
-    // WiFi is active as accesspoint, do not check.
-    return false;
-  }
-  if (WiFi.status() != WL_CONNECTED) {
-    return false;
-  }
-  const IPAddress ip = WiFi.localIP();
-  const IPAddress subnet = WiFi.subnetMask();
-  low = ip;
-  high = ip;
-  // Compute subnet range.
-  for (byte i=0; i < 4; ++i) {
-    if (subnet[i] != 255) {
-      low[i] = low[i] & subnet[i];
-      high[i] = high[i] | ~subnet[i];
-    }
-  }
-  return true;
-}

src/_C002.ino

@@ -135,14 +135,12 @@ boolean CPlugin_002(byte function, struct EventStruct *event, String& string)
       {
         if (event->idx != 0)
         {
-          if (!WiFiConnected(100)) {
+          ControllerSettingsStruct ControllerSettings;
+          LoadControllerSettings(event->ControllerIndex, (byte*)&ControllerSettings, sizeof(ControllerSettings));
+          if (!ControllerSettings.checkHostReachable(true)) {
             success = false;
             break;
           }
-
-          ControllerSettingsStruct ControllerSettings;
-          LoadControllerSettings(event->ControllerIndex, (byte*)&ControllerSettings, sizeof(ControllerSettings));
-
           StaticJsonBuffer<200> jsonBuffer;
 
           JsonObject& root = jsonBuffer.createObject();
@@ -191,8 +189,7 @@ boolean CPlugin_002(byte function, struct EventStruct *event, String& string)
           addLog(LOG_LEVEL_DEBUG, log);
 
           String pubname = ControllerSettings.Publish;
-          parseSystemVariables(pubname, false);
-          parseEventVariables(pubname, event, false);
+          parseControllerVariables(pubname, event, false);
           if (!MQTTpublish(event->ControllerIndex, pubname.c_str(), json.c_str(), Settings.MQTTRetainFlag))
           {
             connectionFailures++;

src/_C005.ino

@@ -95,8 +95,7 @@ boolean CPlugin_005(byte function, struct EventStruct *event, String& string)
           PluginCall(PLUGIN_GET_DEVICEVALUENAMES, event, dummyString);
 
         String pubname = ControllerSettings.Publish;
-        parseSystemVariables(pubname, false);
-        parseEventVariables(pubname, event, false);
+        parseControllerVariables(pubname, event, false);
 
         String value = "";
         // byte DeviceIndex = getDeviceIndex(Settings.TaskDeviceNumber[event->TaskIndex]);

src/_C006.ino

@@ -89,8 +89,7 @@ boolean CPlugin_006(byte function, struct EventStruct *event, String& string)
           PluginCall(PLUGIN_GET_DEVICEVALUENAMES, event, dummyString);
 
         String pubname = ControllerSettings.Publish;
-        parseSystemVariables(pubname, false);
-        parseEventVariables(pubname, event, false);
+        parseControllerVariables(pubname, event, false);
 
         String value = "";
         // byte DeviceIndex = getDeviceIndex(Settings.TaskDeviceNumber[event->TaskIndex]);

src/_C007.ino

@@ -35,6 +35,12 @@ boolean CPlugin_007(byte function, struct EventStruct *event, String& string)
           success = false;
           break;
         }
+        const byte valueCount = getValueCountFromSensorType(event->sensorType);
+        if (valueCount == 0 || valueCount > 3) {
+          addLog(LOG_LEVEL_ERROR, F("emoncms : Unknown sensortype or too many sensor values"));
+          break;
+        }
+
         ControllerSettingsStruct ControllerSettings;
         LoadControllerSettings(event->ControllerIndex, (byte*)&ControllerSettings, sizeof(ControllerSettings));
 
@@ -59,46 +65,14 @@ boolean CPlugin_007(byte function, struct EventStruct *event, String& string)
         postDataStr += Settings.Unit;
         postDataStr += F("&json=");
 
-        switch (event->sensorType)
-        {
-          case SENSOR_TYPE_SINGLE:                      // single value sensor, used for Dallas, BH1750, etc
-          case SENSOR_TYPE_SWITCH:                      // report switch state
-            postDataStr += F("{field");
-            postDataStr += event->idx;
-            postDataStr += ":";
-            postDataStr += formatUserVar(event, 0);
-            postDataStr += "}";
-            break;
-          case SENSOR_TYPE_TEMP_HUM:                      // dual value
-          case SENSOR_TYPE_TEMP_BARO:
-          case SENSOR_TYPE_DUAL:
-            postDataStr += F("{field");
-            postDataStr += event->idx;
-            postDataStr += ":";
-            postDataStr += formatUserVar(event, 0);
-            postDataStr += F(",field");
-            postDataStr += event->idx + 1;
-            postDataStr += ":";
-            postDataStr += formatUserVar(event, 1);
-            postDataStr += "}";
-            break;
-          case SENSOR_TYPE_TEMP_HUM_BARO:
-          case SENSOR_TYPE_TRIPLE:
-            postDataStr += F("{field");
-            postDataStr += event->idx;
-            postDataStr += ":";
-            postDataStr += formatUserVar(event, 0);
-            postDataStr += F(",field");
-            postDataStr += event->idx + 1;
-            postDataStr += ":";
-            postDataStr += formatUserVar(event, 1);
-            postDataStr += F(",field");
-            postDataStr += event->idx + 2;
-            postDataStr += ":";
-            postDataStr += formatUserVar(event, 2);
-            postDataStr += "}";
-            break;
+        for (byte i = 0; i < valueCount; ++i) {
+          postDataStr += (i == 0) ? F("{") : F(",");
+          postDataStr += F("field");
+          postDataStr += event->idx + i;
+          postDataStr += ":";
+          postDataStr += formatUserVar(event, i);
         }
+        postDataStr += "}";
         postDataStr += F("&apikey=");
         postDataStr += SecuritySettings.ControllerPassword[event->ControllerIndex]; // "0UDNN17RW6XAS2E5" // api key
 

src/_C008.ino

@@ -105,8 +105,7 @@ boolean HTTPSend(struct EventStruct *event, byte varIndex, float value, unsigned
 
   String url = "/";
   url += ControllerSettings.Publish;
-  parseSystemVariables(url, true);
-  parseEventVariables(url, event, true);
+  parseControllerVariables(url, event, true);
 
   url.replace(F("%valname%"), URLEncode(ExtraTaskSettings.TaskDeviceValueNames[varIndex]));
   if (longValue)

src/_C010.ino

@@ -80,20 +80,16 @@ void C010_Send(struct EventStruct *event, byte varIndex, float value, unsigned l
 
   String msg = "";
   msg += ControllerSettings.Publish;
-  parseSystemVariables(msg, false);
-  parseEventVariables(msg, event, false);
-  msg.replace(F("%sysname%"), Settings.Name);
-  msg.replace(F("%tskname%"), ExtraTaskSettings.TaskDeviceName);
-  msg.replace(F("%id%"), String(event->idx));
+  parseControllerVariables(msg, event, false);
   msg.replace(F("%valname%"), ExtraTaskSettings.TaskDeviceValueNames[varIndex]);
   if (longValue)
     msg.replace(F("%value%"), String(longValue));
   else
     msg.replace(F("%value%"), toString(value, ExtraTaskSettings.TaskDeviceValueDecimals[varIndex]));
 
-  if (WiFi.status() == WL_CONNECTED) {
+  if (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) {
     ControllerSettings.beginPacket(portUDP);
-    portUDP.write(msg.c_str());
+    portUDP.write((uint8_t*)msg.c_str(),msg.length());
     portUDP.endPacket();
   }
 

src/_C011.ino

@@ -270,44 +270,13 @@ void ReplaceTokenByValue(String& s, struct EventStruct *event)
 //	%1%%vname1%,Standort=%tskname% Wert=%val1%%/1%%2%%LF%%vname2%,Standort=%tskname% Wert=%val2%%/2%%3%%LF%%vname3%,Standort=%tskname% Wert=%val3%%/3%%4%%LF%%vname4%,Standort=%tskname% Wert=%val4%%/4%
 	addLog(LOG_LEVEL_DEBUG_MORE, F("HTTP before parsing: "));
 	addLog(LOG_LEVEL_DEBUG_MORE, s);
-
-	switch (event->sensorType)
-	{
-		case SENSOR_TYPE_SINGLE:
-		case SENSOR_TYPE_SWITCH:
-		case SENSOR_TYPE_DIMMER:
-		case SENSOR_TYPE_WIND:
-		case SENSOR_TYPE_LONG:
-		{
-			DeleteNotNeededValues(s,1);
-			break;
-		}
-		case SENSOR_TYPE_DUAL:
-		case SENSOR_TYPE_TEMP_HUM:
-		case SENSOR_TYPE_TEMP_BARO:
-		{
-			DeleteNotNeededValues(s,2);
-			break;
-		}
-		case SENSOR_TYPE_TRIPLE:
-		case SENSOR_TYPE_TEMP_HUM_BARO:
-		{
-			DeleteNotNeededValues(s,3);
-			break;
-		}
-		case SENSOR_TYPE_QUAD:
-		{
-			DeleteNotNeededValues(s,4);
-			break;
-		}
-	}
+  const byte valueCount = getValueCountFromSensorType(event->sensorType);
+  DeleteNotNeededValues(s,valueCount);
 
 	addLog(LOG_LEVEL_DEBUG_MORE, F("HTTP after parsing: "));
 	addLog(LOG_LEVEL_DEBUG_MORE, s);
 
-  //NOTE: cant we just call parseTemplate() for all the standard stuff??
-  parseSystemVariables(s, true);
-  parseEventVariables(s, event, true);
+  parseControllerVariables(s, event, true);
 
 	addLog(LOG_LEVEL_DEBUG_MORE, F("HTTP after replacements: "));
 	addLog(LOG_LEVEL_DEBUG_MORE, s);

src/_C012.ino

@@ -33,35 +33,14 @@ boolean CPlugin_012(byte function, struct EventStruct *event, String& string)
 
      case CPLUGIN_PROTOCOL_SEND:
       {
-        if (WiFi.status() != WL_CONNECTED) {
+        if (wifiStatus != ESPEASY_WIFI_SERVICES_INITIALIZED) {
           success = false;
           break;
         }
 
         String postDataStr = F("");
-
-        switch (event->sensorType)
-        {
-          case SENSOR_TYPE_SINGLE:                      // single value sensor, used for Dallas, BH1750, etc
-            success = CPlugin_012_send(event, 1);
-            break;
-          case SENSOR_TYPE_TEMP_HUM:                      // dual value
-          case SENSOR_TYPE_TEMP_BARO:
-          case SENSOR_TYPE_DUAL:
-            success = CPlugin_012_send(event, 2);
-            break;
-          case SENSOR_TYPE_TEMP_HUM_BARO:
-          case SENSOR_TYPE_TRIPLE:
-            success = CPlugin_012_send(event, 3);
-            break;
-          case SENSOR_TYPE_QUAD:
-            success = CPlugin_012_send(event, 4);
-            break;
-
-          case SENSOR_TYPE_SWITCH:
-            success = CPlugin_012_send(event, 1);
-            break;
-        }
+        const byte valueCount = getValueCountFromSensorType(event->sensorType);
+        success = CPlugin_012_send(event, valueCount);
         break;
       }
   }
@@ -84,7 +63,7 @@ boolean CPlugin_012_send(struct EventStruct *event, int nrValues) {
 
 boolean Blynk_get(const String& command, byte controllerIndex, float *data )
 {
-  if (WiFi.status() != WL_CONNECTED) {
+  if (wifiStatus != ESPEASY_WIFI_SERVICES_INITIALIZED) {
     return false;
   }
 

src/_C013.ino

@@ -0,0 +1,265 @@
+//#######################################################################################################
+//########################### Controller Plugin 013: ESPEasy P2P network ################################
+//#######################################################################################################
+
+#define CPLUGIN_013
+#define CPLUGIN_ID_013         13
+#define CPLUGIN_NAME_013       "ESPEasy P2P Networking"
+
+WiFiUDP C013_portUDP;
+
+struct infoStruct
+{
+  byte header = 255;
+  byte ID = 3;
+  byte sourcelUnit;
+  byte destUnit;
+  byte sourceTaskIndex;
+  byte destTaskIndex;
+  byte deviceNumber;
+  char taskName[26];
+  char ValueNames[VARS_PER_TASK][26];
+};
+
+struct dataStruct
+{
+  byte header = 255;
+  byte ID = 5;
+  byte sourcelUnit;
+  byte destUnit;
+  byte sourceTaskIndex;
+  byte destTaskIndex;
+  float Values[VARS_PER_TASK];
+};
+
+
+boolean CPlugin_013(byte function, struct EventStruct *event, String& string)
+{
+  boolean success = false;
+
+  switch (function)
+  {
+    case CPLUGIN_PROTOCOL_ADD:
+      {
+        Protocol[++protocolCount].Number = CPLUGIN_ID_013;
+        Protocol[protocolCount].usesMQTT = false;
+        Protocol[protocolCount].usesTemplate = false;
+        Protocol[protocolCount].usesAccount = false;
+        Protocol[protocolCount].usesPassword = false;
+        Protocol[protocolCount].defaultPort = 65501;
+        Protocol[protocolCount].usesID = false;
+        Protocol[protocolCount].Custom = true;
+        break;
+      }
+
+    case CPLUGIN_GET_DEVICENAME:
+      {
+        string = F(CPLUGIN_NAME_013);
+        break;
+      }
+
+    case CPLUGIN_PROTOCOL_TEMPLATE:
+      {
+        event->String1 = "";
+        event->String2 = "";
+        break;
+      }
+
+    case CPLUGIN_INIT:
+      {
+        //C013_portUDP.begin(Settings.UDPPort);
+        break;
+      }
+
+    case CPLUGIN_TASK_CHANGE_NOTIFICATION:
+      {
+        C013_SendUDPTaskInfo(0, event->TaskIndex, event->TaskIndex);
+        break;
+      }
+
+    case CPLUGIN_PROTOCOL_SEND:
+      {
+        C013_Send(event, 0, UserVar[event->BaseVarIndex], 0);
+        break;
+      }
+
+    case CPLUGIN_UDP_IN:
+      {
+        C013_Receive(event);
+        break;
+      }
+
+  }
+  return success;
+}
+
+
+//********************************************************************************
+// Generic UDP message
+//********************************************************************************
+void C013_Send(struct EventStruct *event, byte varIndex, float value, unsigned long longValue)
+{
+  ControllerSettingsStruct ControllerSettings;
+  LoadControllerSettings(event->ControllerIndex, (byte*)&ControllerSettings, sizeof(ControllerSettings));
+  statusLED(true);
+  C013_SendUDPTaskData(0, event->TaskIndex, event->TaskIndex);
+}
+
+void C013_SendUDPTaskInfo(byte destUnit, byte sourceTaskIndex, byte destTaskIndex)
+{
+  if (!WiFiConnected(100)) {
+    return;
+  }
+  struct infoStruct infoReply;
+  infoReply.sourcelUnit = Settings.Unit;
+  infoReply.sourceTaskIndex = sourceTaskIndex;
+  infoReply.destTaskIndex = destTaskIndex;
+  LoadTaskSettings(infoReply.sourceTaskIndex);
+  infoReply.deviceNumber = Settings.TaskDeviceNumber[infoReply.sourceTaskIndex];
+  strcpy(infoReply.taskName, ExtraTaskSettings.TaskDeviceName);
+  for (byte x = 0; x < VARS_PER_TASK; x++)
+    strcpy(infoReply.ValueNames[x], ExtraTaskSettings.TaskDeviceValueNames[x]);
+
+  byte firstUnit = 1;
+  byte lastUnit = UNIT_MAX - 1;
+  if (destUnit != 0)
+  {
+    firstUnit = destUnit;
+    lastUnit = destUnit;
+  }
+  for (byte x = firstUnit; x <= lastUnit; x++)
+  {
+    if (x != Settings.Unit){
+      infoReply.destUnit = x;
+      C013_sendUDP(x, (byte*)&infoReply, sizeof(infoStruct));
+      delay(10);
+    }
+  }
+  delay(50);
+}
+
+void C013_SendUDPTaskData(byte destUnit, byte sourceTaskIndex, byte destTaskIndex)
+{
+  if (!WiFiConnected(100)) {
+    return;
+  }
+  struct dataStruct dataReply;
+  dataReply.sourcelUnit = Settings.Unit;
+  dataReply.sourceTaskIndex = sourceTaskIndex;
+  dataReply.destTaskIndex = destTaskIndex;
+  for (byte x = 0; x < VARS_PER_TASK; x++)
+    dataReply.Values[x] = UserVar[dataReply.sourceTaskIndex * VARS_PER_TASK + x];
+
+  byte firstUnit = 1;
+  byte lastUnit = UNIT_MAX - 1;
+  if (destUnit != 0)
+  {
+    firstUnit = destUnit;
+    lastUnit = destUnit;
+  }
+  for (byte x = firstUnit; x <= lastUnit; x++)
+  {
+    if (x != Settings.Unit){
+      dataReply.destUnit = x;
+      C013_sendUDP(x, (byte*) &dataReply, sizeof(dataStruct));
+      delay(10);
+    }
+  }
+  delay(50);
+}
+
+/*********************************************************************************************\
+   Send UDP message (unit 255=broadcast)
+  \*********************************************************************************************/
+void C013_sendUDP(byte unit, byte* data, byte size)
+{
+  if (!WiFiConnected(100)) {
+    return;
+  }
+  if (unit != 255)
+    if (Nodes[unit].ip[0] == 0)
+      return;
+  String log = "C013 : Send UDP message to ";
+  log += unit;
+  addLog(LOG_LEVEL_DEBUG_MORE, log);
+
+  statusLED(true);
+
+  IPAddress remoteNodeIP;
+  if (unit == 255)
+    remoteNodeIP = {255, 255, 255, 255};
+  else
+    remoteNodeIP = Nodes[unit].ip;
+  C013_portUDP.beginPacket(remoteNodeIP, Settings.UDPPort);
+  C013_portUDP.write(data, size);
+  C013_portUDP.endPacket();
+}
+
+void C013_Receive(struct EventStruct *event) {
+
+  if (event->Data[1] > 1 && event->Data[1] < 6)
+  {
+    String log = (F("C013 : msg "));
+    for (byte x = 1; x < 6; x++)
+    {
+      log += " ";
+      log += (int)event->Data[x];
+    }
+    addLog(LOG_LEVEL_DEBUG_MORE, log);
+  }
+
+  switch (event->Data[1]) {
+    case 2: // sensor info pull request
+      {
+        //SendUDPTaskInfo(packetBuffer[2], packetBuffer[5], packetBuffer[4]);
+        break;
+      }
+
+    case 3: // sensor info
+      {
+        struct infoStruct infoReply;
+        memcpy((byte*)&infoReply, (byte*)event->Data, sizeof(infoStruct));
+
+        // to prevent flash wear out (bugs in communication?) we can only write to an empty task
+        // so it will write only once and has to be cleared manually through webgui
+        if (Settings.TaskDeviceNumber[infoReply.destTaskIndex] == 0)
+        {
+          Settings.TaskDeviceNumber[infoReply.destTaskIndex] = infoReply.deviceNumber;
+          Settings.TaskDeviceDataFeed[infoReply.destTaskIndex] = 1;  // remote feed
+          for (byte x = 0; x < CONTROLLER_MAX; x++)
+            Settings.TaskDeviceSendData[x][infoReply.destTaskIndex] = false;
+          strcpy(ExtraTaskSettings.TaskDeviceName, infoReply.taskName);
+          for (byte x = 0; x < VARS_PER_TASK; x++)
+            strcpy( ExtraTaskSettings.TaskDeviceValueNames[x], infoReply.ValueNames[x]);
+          SaveTaskSettings(infoReply.destTaskIndex);
+          SaveSettings();
+        }
+        break;
+      }
+
+    case 4: // sensor data pull request
+      {
+        //SendUDPTaskData(packetBuffer[2], packetBuffer[5], packetBuffer[4]);
+        break;
+      }
+
+    case 5: // sensor data
+      {
+        struct dataStruct dataReply;
+        memcpy((byte*)&dataReply, (byte*)event->Data, sizeof(dataStruct));
+
+        // only if this task has a remote feed, update values
+        if (Settings.TaskDeviceDataFeed[dataReply.destTaskIndex] != 0)
+        {
+          for (byte x = 0; x < VARS_PER_TASK; x++)
+          {
+            UserVar[dataReply.destTaskIndex * VARS_PER_TASK + x] = dataReply.Values[x];
+          }
+          if (Settings.UseRules)
+            createRuleEvents(dataReply.destTaskIndex);
+        }
+        break;
+      }
+  }
+}
+

src/_CPlugin_SensorTypeHelper.ino

@@ -0,0 +1,28 @@
+/*********************************************************************************************\
+   Get value count from sensor type
+  \*********************************************************************************************/
+
+byte getValueCountFromSensorType(byte sensorType)
+{
+  switch (sensorType)
+  {
+    case SENSOR_TYPE_SINGLE:                      // single value sensor, used for Dallas, BH1750, etc
+    case SENSOR_TYPE_SWITCH:
+    case SENSOR_TYPE_DIMMER:
+      return 1;
+    case SENSOR_TYPE_LONG:                      // single LONG value, stored in two floats (rfid tags)
+      return 1;
+    case SENSOR_TYPE_TEMP_HUM:
+    case SENSOR_TYPE_TEMP_BARO:
+    case SENSOR_TYPE_DUAL:
+      return 2;
+    case SENSOR_TYPE_TEMP_HUM_BARO:
+    case SENSOR_TYPE_TRIPLE:
+    case SENSOR_TYPE_WIND:
+      return 3;
+    case SENSOR_TYPE_QUAD:
+      return 4;
+  }
+  addLog(LOG_LEVEL_ERROR, F("getValueCountFromSensorType: Unknown sensortype"));
+  return 0;
+}

src/_N002_Buzzer.ino

@@ -46,7 +46,10 @@ boolean NPlugin_002(byte function, struct EventStruct *event, String& string)
         NotificationSettingsStruct NotificationSettings;
         LoadNotificationSettings(event->NotificationIndex, (byte*)&NotificationSettings, sizeof(NotificationSettings));
         //this reserves IRAM and uninitialized RAM
+        #ifndef ESP32
+        // Buzzer not compatible with ESP32 due to lack of tone command.
         tone(NotificationSettings.Pin1, 500, 500);
+        #endif
         success = true;
       }
 

src/_P001_Switch.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P001
 //#######################################################################################################
 //#################################### Plugin 001: Input Switch #########################################
 //#######################################################################################################
@@ -10,7 +11,7 @@
   Servo servo1;
   Servo servo2;
 #endif
-
+#define GPIO_MAX 17
 // Make sure the initial default is a switch (value 0)
 #define PLUGIN_001_TYPE_SWITCH 0
 #define PLUGIN_001_TYPE_DIMMER 3 // Due to some changes in previous versions, do not use 2.
@@ -27,6 +28,8 @@ boolean Plugin_001(byte function, struct EventStruct *event, String& string)
   boolean success = false;
   static boolean switchstate[TASKS_MAX];
   static boolean outputstate[TASKS_MAX];
+  static int8_t PinMonitor[GPIO_MAX];
+  static int8_t PinMonitorState[GPIO_MAX];
 
   switch (function)
   {
@@ -108,6 +111,11 @@ boolean Plugin_001(byte function, struct EventStruct *event, String& string)
 
     case PLUGIN_INIT:
       {
+        for (byte x=0; x < GPIO_MAX; x++){
+           PinMonitor[x] = 0;
+           PinMonitorState[x] = 0;
+          }
+
         if (Settings.TaskDevicePin1PullUp[event->TaskIndex])
           pinMode(Settings.TaskDevicePin1[event->TaskIndex], INPUT_PULLUP);
         else
@@ -128,6 +136,38 @@ boolean Plugin_001(byte function, struct EventStruct *event, String& string)
         break;
       }
 
+    case PLUGIN_REQUEST:
+      {
+        String device = parseString(string, 1);
+        String command = parseString(string, 2);
+        String strPar1 = parseString(string, 3);
+        int par1 = strPar1.toInt();
+        if (device == F("gpio") && command == F("pinstate"))
+        {
+          string = digitalRead(par1);
+          success = true;
+        }
+        break;
+      }
+      
+    case PLUGIN_UNCONDITIONAL_POLL:
+      {
+        // port monitoring, on request by rule command
+        for (byte x=0; x < GPIO_MAX; x++)
+           if (PinMonitor[x] != 0){
+             byte state = digitalRead(x);
+             if (PinMonitorState[x] != state){
+               String eventString = F("GPIO#");
+               eventString += x;
+               eventString += F("=");
+               eventString += state;
+               rulesProcessing(eventString);
+               PinMonitorState[x] = state;
+             }
+           }
+        break;
+      }
+
     case PLUGIN_TEN_PER_SECOND:
       {
         const boolean state = Plugin_001_read_switch_state(event);
@@ -332,6 +372,15 @@ boolean Plugin_001(byte function, struct EventStruct *event, String& string)
           }
         }
 
+        if (command == F("monitor"))
+        {
+          if (parseString(string, 2) == F("gpio"))
+          {
+            PinMonitor[event->Par2] = 1;
+            success = true;
+          }
+        }
+
         if (command == F("inputswitchstate"))
         {
           success = true;
@@ -432,3 +481,4 @@ byte P001_getSwitchType(struct EventStruct *event) {
   }
   return choice;
 }
+#endif // USES_P001

src/_P002_ADC.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P002
 //#######################################################################################################
 //#################################### Plugin 002: Analog ###############################################
 //#######################################################################################################
@@ -150,3 +151,4 @@ boolean Plugin_002(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P002

src/_P003_Pulse.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P003
 //#######################################################################################################
 //#################################### Plugin 003: Pulse  ###############################################
 //#######################################################################################################
@@ -267,3 +268,4 @@ bool Plugin_003_pulseinit(byte Par1, byte Index, byte Mode)
 
   return(true);
 }
+#endif // USES_P003

src/_P004_Dallas.ino

@@ -1,15 +1,21 @@
+#ifdef USES_P004
 // #######################################################################################################
 // #################################### Plugin 004: TempSensor Dallas DS18B20  ###########################
 // #######################################################################################################
 
 // Maxim Integrated (ex Dallas) DS18B20 datasheet : https://datasheets.maximintegrated.com/en/ds/DS18B20.pdf
 
+#if defined(ESP32)
+  #define ESP32noInterrupts() {portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;portENTER_CRITICAL(&mux)
+  #define ESP32interrupts() portEXIT_CRITICAL(&mux);}
+#endif
+
 #define PLUGIN_004
 #define PLUGIN_ID_004         4
 #define PLUGIN_NAME_004       "Environment - DS18b20"
 #define PLUGIN_VALUENAME1_004 "Temperature"
 
-uint8_t Plugin_004_DallasPin;
+int8_t Plugin_004_DallasPin;
 
 boolean Plugin_004(byte function, struct EventStruct * event, String& string)
 {
@@ -49,46 +55,46 @@ boolean Plugin_004(byte function, struct EventStruct * event, String& string)
         {
             uint8_t savedAddress[8];
             byte resolutionChoice = 0;
-
             // Scan the onewire bus and fill dropdown list with devicecount on this GPIO.
             Plugin_004_DallasPin = Settings.TaskDevicePin1[event->TaskIndex];
 
-            // get currently saved address
-            for (byte i = 0; i < 8; i++)
-                savedAddress[i] = ExtraTaskSettings.TaskDevicePluginConfigLong[i];
+            if (Plugin_004_DallasPin != -1){
+              // get currently saved address
+              for (byte i = 0; i < 8; i++)
+                  savedAddress[i] = ExtraTaskSettings.TaskDevicePluginConfigLong[i];
 
-            // find all suitable devices
-            addRowLabel(string, F("Device Address"));
-            addSelector_Head(string, F("plugin_004_dev"), false);
-            addSelector_Item(string, "", -1, false, false, F(""));
-            uint8_t tmpAddress[8];
-            byte count = 0;
-            Plugin_004_DS_reset();
-            Plugin_004_DS_reset_search();
-            while (Plugin_004_DS_search(tmpAddress))
-            {
-                String option = "";
-                for (byte j = 0; j < 8; j++)
-                {
-                    option += String(tmpAddress[j], HEX);
-                    if (j < 7) option += F("-");
-                }
-                bool selected = (memcmp(tmpAddress, savedAddress, 8) == 0) ? true : false;
-                addSelector_Item(string, option, count, selected, false, F(""));
-                count ++;
+              // find all suitable devices
+              addRowLabel(string, F("Device Address"));
+              addSelector_Head(string, F("plugin_004_dev"), false);
+              addSelector_Item(string, "", -1, false, false, F(""));
+              uint8_t tmpAddress[8];
+              byte count = 0;
+              Plugin_004_DS_reset();
+              Plugin_004_DS_reset_search();
+              while (Plugin_004_DS_search(tmpAddress))
+              {
+                  String option = "";
+                  for (byte j = 0; j < 8; j++)
+                  {
+                      option += String(tmpAddress[j], HEX);
+                      if (j < 7) option += F("-");
+                  }
+                  bool selected = (memcmp(tmpAddress, savedAddress, 8) == 0) ? true : false;
+                  addSelector_Item(string, option, count, selected, false, F(""));
+                  count ++;
+              }
+              addSelector_Foot(string);
+
+              // Device Resolution select
+              if (ExtraTaskSettings.TaskDevicePluginConfigLong[0] != 0)
+                  resolutionChoice = Plugin_004_DS_getResolution(savedAddress);
+              else
+                  resolutionChoice = 9;
+              String resultsOptions[4] = { "9", "10", "11", "12" };
+              int resultsOptionValues[4] = { 9, 10, 11, 12 };
+              addFormSelector(string, F("Device Resolution"), F("plugin_004_res"), 4, resultsOptions, resultsOptionValues, resolutionChoice);
+              string += F(" Bit");
             }
-            addSelector_Foot(string);
-
-            // Device Resolution select
-            if (ExtraTaskSettings.TaskDevicePluginConfigLong[0] != 0)
-                resolutionChoice = Plugin_004_DS_getResolution(savedAddress);
-            else
-                resolutionChoice = 9;
-            String resultsOptions[4] = { "9", "10", "11", "12" };
-            int resultsOptionValues[4] = { 9, 10, 11, 12 };
-            addFormSelector(string, F("Device Resolution"), F("plugin_004_res"), 4, resultsOptions, resultsOptionValues, resolutionChoice);
-            string += F(" Bit");
-
             success = true;
             break;
         }
@@ -100,13 +106,14 @@ boolean Plugin_004(byte function, struct EventStruct * event, String& string)
             // save the address for selected device and store into extra tasksettings
             Plugin_004_DallasPin = Settings.TaskDevicePin1[event->TaskIndex];
             // byte devCount =
-            Plugin_004_DS_scan(getFormItemInt(F("plugin_004_dev")), addr);
-            for (byte x = 0; x < 8; x++)
-                ExtraTaskSettings.TaskDevicePluginConfigLong[x] = addr[x];
-
-            Plugin_004_DS_setResolution(addr, getFormItemInt(F("plugin_004_res")));
-            Plugin_004_DS_startConvertion(addr);
+            if (Plugin_004_DallasPin != -1){
+              Plugin_004_DS_scan(getFormItemInt(F("plugin_004_dev")), addr);
+              for (byte x = 0; x < 8; x++)
+                  ExtraTaskSettings.TaskDevicePluginConfigLong[x] = addr[x];
 
+              Plugin_004_DS_setResolution(addr, getFormItemInt(F("plugin_004_res")));
+              Plugin_004_DS_startConvertion(addr);
+            }
             success = true;
             break;
         }
@@ -125,10 +132,12 @@ boolean Plugin_004(byte function, struct EventStruct * event, String& string)
         case PLUGIN_INIT:
         {
             Plugin_004_DallasPin = Settings.TaskDevicePin1[event->TaskIndex];
-            uint8_t addr[8];
-            Plugin_004_get_addr(addr, event->TaskIndex);
-            Plugin_004_DS_startConvertion(addr);
-            delay(800); //give it time to do intial conversion
+            if (Plugin_004_DallasPin != -1){
+              uint8_t addr[8];
+              Plugin_004_get_addr(addr, event->TaskIndex);
+              Plugin_004_DS_startConvertion(addr);
+              delay(800); //give it time to do intial conversion
+            }
             success = true;
             break;
         }
@@ -371,7 +380,9 @@ uint8_t Plugin_004_DS_reset()
 {
     uint8_t r;
     uint8_t retries = 125;
-    // noInterrupts();
+    #if defined(ESP32)
+      ESP32noInterrupts();
+    #endif
     pinMode(Plugin_004_DallasPin, INPUT);
     do // wait until the wire is high... just in case
     {
@@ -387,7 +398,9 @@ uint8_t Plugin_004_DS_reset()
     delayMicroseconds(40);
     r = !digitalRead(Plugin_004_DallasPin);
     delayMicroseconds(420);
-    // interrupts();
+    #if defined(ESP32)
+      ESP32interrupts();
+    #endif
     return r;
 }
 
@@ -569,14 +582,18 @@ uint8_t Plugin_004_DS_read_bit(void)
 {
     uint8_t r;
 
-    // noInterrupts();
+    #if defined(ESP32)
+       ESP32noInterrupts();
+    #endif
     pinMode(Plugin_004_DallasPin, OUTPUT);
     digitalWrite(Plugin_004_DallasPin, LOW);
     delayMicroseconds(3);
     pinMode(Plugin_004_DallasPin, INPUT); // let pin float, pull up will raise
     delayMicroseconds(10);
     r = digitalRead(Plugin_004_DallasPin);
-    // interrupts();
+    #if defined(ESP32)
+       ESP32interrupts();
+    #endif
     delayMicroseconds(53);
     return r;
 }
@@ -588,22 +605,30 @@ void Plugin_004_DS_write_bit(uint8_t v)
 {
     if (v & 1)
     {
-        // noInterrupts();
+        #if defined(ESP32)
+          ESP32noInterrupts();
+        #endif
         digitalWrite(Plugin_004_DallasPin, LOW);
         pinMode(Plugin_004_DallasPin, OUTPUT);
         delayMicroseconds(10);
         digitalWrite(Plugin_004_DallasPin, HIGH);
-        // interrupts();
+        #if defined(ESP32)
+          ESP32interrupts();
+        #endif
         delayMicroseconds(55);
     }
     else
     {
-        // noInterrupts();
+        #if defined(ESP32)
+          ESP32noInterrupts();
+        #endif
         digitalWrite(Plugin_004_DallasPin, LOW);
         pinMode(Plugin_004_DallasPin, OUTPUT);
         delayMicroseconds(65);
         digitalWrite(Plugin_004_DallasPin, HIGH);
-        // interrupts();
+        #if defined(ESP32)
+           ESP32interrupts();
+        #endif
         delayMicroseconds(5);
     }
 }
@@ -629,3 +654,4 @@ boolean Plugin_004_DS_crc8(uint8_t * addr)
     }
     return crc == *addr; // addr 8
 }
+#endif // USES_P004

src/_P005_DHT.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P005
 //#######################################################################################################
 //######################## Plugin 005: Temperature and Humidity sensor DHT 11/22 ########################
 //#######################################################################################################
@@ -219,3 +220,4 @@ int Plugin_005_read_dht_dat(void)
   }
   return result;
 }
+#endif // USES_P005

src/_P006_BMP085.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P006
 //#######################################################################################################
 //######################## Plugin 006 BMP0685 I2C Barometric Pressure Sensor  ###########################
 //#######################################################################################################
@@ -287,3 +288,4 @@ float Plugin_006_pressureElevation(float atmospheric, int altitude) {
 /*********************************************************************/
   return atmospheric / pow(1.0 - (altitude/44330.0), 5.255);
 }
+#endif // USES_P006

src/_P007_PCF8591.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P007
 //#######################################################################################################
 //#################################### Plugin 007: ExtWiredAnalog #######################################
 //#######################################################################################################
@@ -69,3 +70,4 @@ boolean Plugin_007(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P007

src/_P008_RFID.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P008
 //#######################################################################################################
 //################################# Plugin 008: Wiegand RFID Tag Reader #################################
 //#######################################################################################################
@@ -176,3 +177,4 @@ void Plugin_008_interrupt2()
   Plugin_008_keyBuffer = Plugin_008_keyBuffer << 1;     // Left shift the number (effectively multiplying by 2)
   Plugin_008_bitCount++;           // Increment the bit count
 }
+#endif // USES_P008

src/_P009_MCP.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P009
 //#######################################################################################################
 //#################################### Plugin 009: MCP23017 input #######################################
 //#######################################################################################################
@@ -306,3 +307,4 @@ void Plugin_009_Config(byte Par1, byte Par2)
     Wire.endTransmission();
   }
 }
+#endif // USES_P009

src/_P010_BH1750.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P010
 //#######################################################################################################
 //#################################### Plugin-010: LuxRead   ############################################
 //#######################################################################################################
@@ -124,3 +125,4 @@ boolean Plugin_010(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P010

src/_P011_PME.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P011
 //#######################################################################################################
 //#################################### Plugin 011: Pro Mini Extender ####################################
 //#######################################################################################################
@@ -211,3 +212,4 @@ void Plugin_011_Write(byte Par1, byte Par2)
   Wire.write((Par2 >> 8));
   Wire.endTransmission();
 }
+#endif // USES_P011

src/_P012_LCD.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P012
 //#######################################################################################################
 //#################################### Plugin 012: LCD ##################################################
 //#######################################################################################################
@@ -7,7 +8,7 @@
 //  DS Temp:[Dallas1#Temperature#R]
 //  Lux:[Lux#Lux#R]
 //  Baro:[Baro#Pressure#R]
-
+//  Pump:[Pump#on#O] -> ON/OFF
 #include <LiquidCrystal_I2C.h>
 
 LiquidCrystal_I2C *lcd=NULL;
@@ -202,7 +203,7 @@ boolean Plugin_012(byte function, struct EventStruct *event, String& string)
           String tmpString = deviceTemplate[x];
           if (lcd && tmpString.length())
           {
-            String newString = parseTemplate(tmpString, col);
+            String newString = P012_parseTemplate(tmpString, col);
             lcd->setCursor(0, x);
             lcd->print(newString);
           }
@@ -225,11 +226,27 @@ boolean Plugin_012(byte function, struct EventStruct *event, String& string)
         if (argIndex)
           tmpString = tmpString.substring(0, argIndex);
 
-        if (lcd && tmpString.equalsIgnoreCase(F("LCD")))
+        if (lcd && tmpString.equalsIgnoreCase(F("LCDCMD")))
         {
           success = true;
           argIndex = string.lastIndexOf(',');
           tmpString = string.substring(argIndex + 1);
+          if (tmpString.equalsIgnoreCase(F("Off"))){
+              lcd->noBacklight();
+          }
+          else if (tmpString.equalsIgnoreCase(F("On"))){
+              lcd->backlight();
+          }
+          else if (tmpString.equalsIgnoreCase(F("Clear"))){
+              lcd->clear();
+          }
+        }
+        else if (lcd && tmpString.equalsIgnoreCase(F("LCD")))
+        {
+          success = true;
+          tmpString = P012_parseTemplate(string, cols);
+          argIndex = tmpString.lastIndexOf(',');
+          tmpString = tmpString.substring(argIndex + 1);
 
           int colPos = event->Par2 - 1;
           int rowPos = event->Par1 - 1;
@@ -280,25 +297,20 @@ boolean Plugin_012(byte function, struct EventStruct *event, String& string)
           }
 
         }
-
-        if (lcd && tmpString.equalsIgnoreCase(F("LCDCMD")))
-        {
-          success = true;
-          argIndex = string.lastIndexOf(',');
-          tmpString = string.substring(argIndex + 1);
-          if (tmpString.equalsIgnoreCase(F("Off"))){
-              lcd->noBacklight();
-          }
-          else if (tmpString.equalsIgnoreCase(F("On"))){
-              lcd->backlight();
-          }
-          else if (tmpString.equalsIgnoreCase(F("Clear"))){
-              lcd->clear();
-          }
-        }
         break;
       }
 
   }
   return success;
 }
+
+// Perform some specific changes for LCD display
+// https://www.letscontrolit.com/forum/viewtopic.php?t=2368
+String P012_parseTemplate(String &tmpString, byte lineSize) {
+  String result = parseTemplate(tmpString, lineSize);
+  const char degree[3] = {0xc2, 0xb0, 0};  // Unicode degree symbol
+  const char degree_lcd[2] = {0xdf, 0};  // P012_LCD degree symbol
+  result.replace(degree, degree_lcd);
+  return result;
+}
+#endif // USES_P012

src/_P013_HCSR04.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P013
 //#######################################################################################################
 //#################################### Plugin 013: HC-SR04 ##############################################
 //#######################################################################################################
@@ -180,3 +181,4 @@ void Plugin_013_interrupt()
     Plugin_013_timer = micros() - Plugin_013_timer;
   }
 }
+#endif // USES_P013

src/_P014_SI7021.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P014
 //#######################################################################################################
 //######################## Plugin 014 SI7021 I2C Temperature Humidity Sensor  ###########################
 //#######################################################################################################
@@ -393,3 +394,4 @@ int8_t Plugin_014_si7021_setResolution(uint8_t res)
 
   return error;
 }
+#endif // USES_P014

src/_P015_TSL2561.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P015
 //#######################################################################################################
 //######################## Plugin 015 TSL2561 I2C Lux Sensor ############################################
 //#######################################################################################################
@@ -441,3 +442,4 @@ boolean Plugin_015(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P015

src/_P016_IR.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P016
 //#######################################################################################################
 //#################################### Plugin 016: Input IR #############################################
 //#######################################################################################################
@@ -93,3 +94,4 @@ boolean Plugin_016(byte function, struct EventStruct *event, String& string)
 }
 
 #endif
+#endif // USES_P016

src/_P017_PN532.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P017
 //#######################################################################################################
 //#################################### Plugin-017: PN532 RFID reader ####################################
 //#######################################################################################################
@@ -401,3 +402,4 @@ int8_t Plugin_017_readAckFrame()
 
   return 0;
 }
+#endif // USES_P017

src/_P018_Dust.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P018
 //#######################################################################################################
 //#################################### Plugin 018: GP2Y10 ###############################################
 //#######################################################################################################
@@ -82,3 +83,4 @@ boolean Plugin_018(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P018

src/_P019_PCF8574.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P019
 //#######################################################################################################
 //#################################### Plugin 019: PCF8574 ##############################################
 //#######################################################################################################
@@ -238,3 +239,4 @@ boolean Plugin_019_Write(byte Par1, byte Par2)
 
   return true;
 }
+#endif // USES_P019

src/_P020_Ser2Net.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P020
 //#######################################################################################################
 //#################################### Plugin 020: Ser2Net ##############################################
 //#######################################################################################################
@@ -96,12 +97,22 @@ boolean Plugin_020(byte function, struct EventStruct *event, String& string)
         LoadTaskSettings(event->TaskIndex);
         if ((ExtraTaskSettings.TaskDevicePluginConfigLong[0] != 0) && (ExtraTaskSettings.TaskDevicePluginConfigLong[1] != 0))
         {
-          byte serialconfig = 0x10;
+          #if defined(ESP8266)
+            byte serialconfig = 0x10;
+          #endif
+          #if defined(ESP32)
+            uint32_t serialconfig = 0x8000010;
+          #endif
           serialconfig += ExtraTaskSettings.TaskDevicePluginConfigLong[3];
           serialconfig += (ExtraTaskSettings.TaskDevicePluginConfigLong[2] - 5) << 2;
           if (ExtraTaskSettings.TaskDevicePluginConfigLong[4] == 2)
             serialconfig += 0x20;
-          Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], (SerialConfig)serialconfig);
+          #if defined(ESP8266)
+            Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], (SerialConfig)serialconfig);
+          #endif
+          #if defined(ESP32)
+            Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], serialconfig);
+          #endif
           ser2netServer = new WiFiServer(ExtraTaskSettings.TaskDevicePluginConfigLong[0]);
           ser2netServer->begin();
 
@@ -282,3 +293,4 @@ boolean Plugin_020(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P020

src/_P021_Level.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P021
 //#######################################################################################################
 //#################################### Plugin 021: Level Control ########################################
 //#######################################################################################################
@@ -137,3 +138,4 @@ boolean Plugin_021(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P021

src/_P022_PCA9685.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P022
 //#######################################################################################################
 //#################################### Plugin 022: PCA9685 ##############################################
 //#######################################################################################################
@@ -152,3 +153,4 @@ void Plugin_022_initialize()
   Plugin_022_writeRegister(PCA9685_MODE2, (byte)0x10); // set to output
   Plugin_022_init = true;
 }
+#endif // USES_P022

src/_P023_OLED.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P023
 //#######################################################################################################
 //#################################### Plugin 023: OLED SSD1306 display #################################
 //#######################################################################################################
@@ -208,13 +209,6 @@ boolean Plugin_023(byte function, struct EventStruct *event, String& string)
         int argIndex = tmpString.indexOf(',');
         if (argIndex)
           tmpString = tmpString.substring(0, argIndex);
-        if (tmpString.equalsIgnoreCase(F("OLED")))
-        {
-          success = true;
-          argIndex = string.lastIndexOf(',');
-          tmpString = string.substring(argIndex + 1);
-          Plugin_023_sendStrXY(tmpString.c_str(), event->Par1 - 1, event->Par2 - 1);
-        }
         if (tmpString.equalsIgnoreCase(F("OLEDCMD")))
         {
           success = true;
@@ -227,9 +221,16 @@ boolean Plugin_023(byte function, struct EventStruct *event, String& string)
           else if (tmpString.equalsIgnoreCase(F("Clear")))
             Plugin_023_clear_display();
         }
+        else if (tmpString.equalsIgnoreCase(F("OLED")))
+        {
+          success = true;
+          argIndex = string.lastIndexOf(',');
+          tmpString = string.substring(argIndex + 1);
+          String newString = P023_parseTemplate(tmpString, 16);
+          Plugin_023_sendStrXY(newString.c_str(), event->Par1 - 1, event->Par2 - 1);
+        }
         break;
       }
-
   }
   return success;
 }
@@ -443,7 +444,7 @@ const char Plugin_023_myFont[][8] PROGMEM = {
   {0x00, 0x02, 0x05, 0x05, 0x02, 0x00, 0x00, 0x00}   // DEL
 };
 
-static void Plugin_023_reset_display(void)
+void Plugin_023_reset_display(void)
 {
   Plugin_023_displayOff();
   Plugin_023_clear_display();
@@ -474,7 +475,7 @@ void Plugin_023_displayOff(void)
 }
 
 
-static void Plugin_023_clear_display(void)
+void Plugin_023_clear_display(void)
 {
   unsigned char i, k;
   for (k = 0; k < 8; k++)
@@ -491,7 +492,7 @@ static void Plugin_023_clear_display(void)
 
 
 // Actually this sends a byte, not a char to draw in the display.
-static void Plugin_023_SendChar(unsigned char data)
+void Plugin_023_SendChar(unsigned char data)
 {
   Wire.beginTransmission(Plugin_023_OLED_address);  // begin transmitting
   Wire.write(0x40);                      //data mode
@@ -502,7 +503,7 @@ static void Plugin_023_SendChar(unsigned char data)
 
 // Prints a display char (not just a byte) in coordinates X Y,
 //currently unused:
-// static void Plugin_023_sendCharXY(unsigned char data, int X, int Y)
+// void Plugin_023_sendCharXY(unsigned char data, int X, int Y)
 // {
 //   //if (interrupt && !doing_menu) return; // Stop printing only if interrupt is call but not in button functions
 //   Plugin_023_setXY(X, Y);
@@ -516,7 +517,7 @@ static void Plugin_023_SendChar(unsigned char data)
 // }
 
 
-static void Plugin_023_sendcommand(unsigned char com)
+void Plugin_023_sendcommand(unsigned char com)
 {
   Wire.beginTransmission(Plugin_023_OLED_address);     //begin transmitting
   Wire.write(0x80);                          //command mode
@@ -527,7 +528,7 @@ static void Plugin_023_sendcommand(unsigned char com)
 
 // Set the cursor position in a 16 COL * 8 ROW map (128x64 pixels)
 // or 8 COL * 5 ROW map (64x48 pixels)
-static void Plugin_023_setXY(unsigned char row, unsigned char col)
+void Plugin_023_setXY(unsigned char row, unsigned char col)
 {
   switch (Plugin_023_OLED_type)
   {
@@ -547,7 +548,7 @@ static void Plugin_023_setXY(unsigned char row, unsigned char col)
 
 // Prints a string regardless the cursor position.
 // unused:
-// static void Plugin_023_sendStr(unsigned char *string)
+// void Plugin_023_sendStr(unsigned char *string)
 // {
 //   unsigned char i = 0;
 //   while (*string)
@@ -563,7 +564,7 @@ static void Plugin_023_setXY(unsigned char row, unsigned char col)
 
 // Prints a string in coordinates X Y, being multiples of 8.
 // This means we have 16 COLS (0-15) and 8 ROWS (0-7).
-static void Plugin_023_sendStrXY(const char *string, int X, int Y)
+void Plugin_023_sendStrXY(const char *string, int X, int Y)
 {
   Plugin_023_setXY(X, Y);
   unsigned char i = 0;
@@ -589,7 +590,7 @@ static void Plugin_023_sendStrXY(const char *string, int X, int Y)
 }
 
 
-static void Plugin_023_init_OLED(void)
+void Plugin_023_init_OLED(void)
 {
   unsigned char multiplex;
   unsigned char compins;
@@ -635,3 +636,4 @@ static void Plugin_023_init_OLED(void)
   Plugin_023_sendcommand(0x00);            //Set Memory Addressing Mode ab Horizontal addressing mode
 
 }
+#endif // USES_P023

src/_P024_MLX90614.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P024
 //#######################################################################################################
 //#################################### Plugin 024: MLX90614 IR temperature I2C 0x5A)  ###############################################
 //#######################################################################################################
@@ -122,3 +123,4 @@ boolean Plugin_024(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P024

src/_P025_ADS1115.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P025
 //#######################################################################################################
 //#################################### Plugin 025: ADS1115 I2C 0x48)  ###############################################
 //#######################################################################################################
@@ -9,7 +10,7 @@
 
 boolean Plugin_025_init = false;
 
-static uint16_t readRegister025(uint8_t i2cAddress, uint8_t reg) {
+uint16_t readRegister025(uint8_t i2cAddress, uint8_t reg) {
   Wire.beginTransmission(i2cAddress);
   Wire.write((0x00));
   Wire.endTransmission();
@@ -202,3 +203,4 @@ boolean Plugin_025(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P025

src/_P026_Sysinfo.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P026
 //#######################################################################################################
 //#################################### Plugin 026: System Info ##########################################
 //#######################################################################################################
@@ -134,3 +135,4 @@ boolean Plugin_026(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P026

src/_P027_INA219.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P027
 //#######################################################################################################
 //######################### Plugin 027: INA219 DC Voltage/Current sensor ################################
 //#######################################################################################################
@@ -426,3 +427,4 @@ float Plugin_027_getCurrent_mA(uint8_t i2caddr) {
   valueDec /= _ina219_data[idx].currentDivider_mA;
   return valueDec;
 }
+#endif // USES_P027

src/_P028_BME280.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P028
 //#######################################################################################################
 //#################### Plugin 028 BME280 I2C Temp/Hum/Barometric Pressure Sensor  #######################
 //#######################################################################################################
@@ -667,3 +668,4 @@ float Plugin_028_readAltitude(float seaLevel)
 float Plugin_028_pressureElevation(float atmospheric, int altitude) {
   return atmospheric / pow(1.0 - (altitude/44330.0), 5.255);
 }
+#endif // USES_P028

src/_P029_Output.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P029
 //#######################################################################################################
 //#################################### Plugin 029: Output ###############################################
 //#######################################################################################################
@@ -65,3 +66,4 @@ boolean Plugin_029(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P029

src/_P030_BMP280.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P030
 //#######################################################################################################
 //#################### Plugin 030 BMP280 I2C Temp/Barometric Pressure Sensor      #######################
 //#######################################################################################################
@@ -394,3 +395,4 @@ float Plugin_030_readAltitude(float seaLevel)
 float Plugin_030_pressureElevation(float atmospheric, int altitude) {
   return atmospheric / pow(1.0 - (altitude/44330.0), 5.255);
 }
+#endif // USES_P030

src/_P031_SHT1X.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P031
 //#######################################################################################################
 //#################### Plugin 031: SHT10/SHT11/SHT15 Temp/Humidity Sensor ###############################
 //#######################################################################################################
@@ -242,3 +243,4 @@ int Plugin_031_readData(const int bits)
 
   return val;
 }
+#endif // USES_P031

src/_P032_MS5611.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P032
 //#######################################################################################################
 //################ Plugin 032 MS5611 (GY-63) I2C Temp/Barometric Pressure Sensor  #######################
 //#######################################################################################################
@@ -252,3 +253,4 @@ void Plugin_032_readout() {
 double Plugin_032_pressureElevation(double atmospheric, int altitude) {
   return atmospheric / pow(1.0 - (altitude/44330.0), 5.255);
 }
+#endif // USES_P032

src/_P033_Dummy.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P033
 //#######################################################################################################
 //#################################### Plugin 033: Dummy ################################################
 //#######################################################################################################
@@ -100,3 +101,4 @@ boolean Plugin_033(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P033

src/_P034_DHT12.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P034
 //#######################################################################################################
 //######################## Plugin 034: Temperature and Humidity sensor DHT 12 (I2C) #####################
 //#######################################################################################################
@@ -110,3 +111,4 @@ boolean Plugin_034(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P034

src/_P035_IRTX.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P035
 //#######################################################################################################
 //#################################### Plugin 035: Output IR ############################################
 //#######################################################################################################
@@ -204,14 +205,14 @@ boolean Plugin_035(byte function, struct EventStruct *event, String& string)
             if (GetArgv(command, TmpStr1, 5)) IrRepeat = str2int(TmpStr1);
             if (GetArgv(command, TmpStr1, 6)) IrSecondCode = strtoul(TmpStr1, NULL, 16);
 
-            if (IrType.equalsIgnoreCase("NEC")) Plugin_035_irSender->sendNEC(IrCode, IrBits);
-            if (IrType.equalsIgnoreCase("JVC")) Plugin_035_irSender->sendJVC(IrCode, IrBits, 2);
-            if (IrType.equalsIgnoreCase("RC5")) Plugin_035_irSender->sendRC5(IrCode, IrBits);
-            if (IrType.equalsIgnoreCase("RC6")) Plugin_035_irSender->sendRC6(IrCode, IrBits);
-            if (IrType.equalsIgnoreCase("SAMSUNG")) Plugin_035_irSender->sendSAMSUNG(IrCode, IrBits);
-            if (IrType.equalsIgnoreCase("SONY")) Plugin_035_irSender->sendSony(IrCode, IrBits);
-            if (IrType.equalsIgnoreCase("PANASONIC")) Plugin_035_irSender->sendPanasonic(IrBits, IrCode);
-            if (IrType.equalsIgnoreCase("PIONEER")) Plugin_035_irSender->sendPioneer(IrCode, IrBits, IrRepeat, IrSecondCode);
+            if (IrType.equalsIgnoreCase(F("NEC"))) Plugin_035_irSender->sendNEC(IrCode, IrBits);
+            if (IrType.equalsIgnoreCase(F("JVC"))) Plugin_035_irSender->sendJVC(IrCode, IrBits, 2);
+            if (IrType.equalsIgnoreCase(F("RC5"))) Plugin_035_irSender->sendRC5(IrCode, IrBits);
+            if (IrType.equalsIgnoreCase(F("RC6"))) Plugin_035_irSender->sendRC6(IrCode, IrBits);
+            if (IrType.equalsIgnoreCase(F("SAMSUNG"))) Plugin_035_irSender->sendSAMSUNG(IrCode, IrBits);
+            if (IrType.equalsIgnoreCase(F("SONY"))) Plugin_035_irSender->sendSony(IrCode, IrBits);
+            if (IrType.equalsIgnoreCase(F("PANASONIC"))) Plugin_035_irSender->sendPanasonic(IrBits, IrCode);
+            if (IrType.equalsIgnoreCase(F("PIONEER"))) Plugin_035_irSender->sendPioneer(IrCode, IrBits, IrRepeat, IrSecondCode);
           }
 
           addLog(LOG_LEVEL_INFO, F("IRTX :IR Code Sent"));
@@ -233,3 +234,4 @@ boolean Plugin_035(byte function, struct EventStruct *event, String& string)
 }
 
 #endif
+#endif // USES_P035

src/_P036_FrameOLED.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P036
 //#######################################################################################################
 //#################################### Plugin 036: OLED SSD1306 display #################################
 //
@@ -24,10 +25,11 @@
 #define P36_CONTRAST_MED  0xCF
 #define P36_CONTRAST_HIGH 0xFF
 
-#include "SSD1306.h"
-#include "SH1106Wire.h"
-#include "OLED_SSD1306_SH1106_images.h"
-#include "Dialog_Plain_12_font.h"
+
+#include "SSD1306.h" 
+#include "SH1106Wire.h" 
+#include "OLED_SSD1306_SH1106_images.h" 
+#include "Dialog_Plain_12_font.h" 
 
 #define P36_WIFI_STATE_UNSET          -2
 #define P36_WIFI_STATE_NOT_CONNECTED  -1
@@ -466,7 +468,7 @@ String P36_parseTemplate(String &tmpString, byte lineSize) {
 
 void display_header() {
   static boolean showWiFiName = true;
-  if (showWiFiName && (WiFi.status() == WL_CONNECTED) ) {
+  if (showWiFiName && (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) ) {
     String newString = WiFi.SSID();
     newString.trim();
     display_title(newString);
@@ -629,7 +631,7 @@ void display_scroll(String outString[], String inString[], int nlines, int scrol
 
 //Draw Signal Strength Bars, return true when there was an update.
 bool display_wifibars() {
-  const bool connected = WiFi.status() == WL_CONNECTED;
+  const bool connected = wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED;
   const int nbars_filled = (WiFi.RSSI() + 100) / 8;
   const int newState = connected ? nbars_filled : P36_WIFI_STATE_UNSET;
   if (newState == lastWiFiState)
@@ -651,7 +653,7 @@ bool display_wifibars() {
   display->setColor(BLACK);
   display->fillRect(x , y, size_x, size_y);
   display->setColor(WHITE);
-  if (WiFi.status() == WL_CONNECTED) {
+  if (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) {
     for (byte ibar = 0; ibar < nbars; ibar++) {
       int16_t height = size_y * (ibar + 1) / nbars;
       int16_t xpos = x + ibar * width;
@@ -670,3 +672,4 @@ bool display_wifibars() {
   }
   return true;
 }
+#endif // USES_P036

src/_P037_MQTTImport.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P037
 //#######################################################################################################
 //#################################### Plugin 037: MQTT Import ##########################################
 //#######################################################################################################
@@ -448,3 +449,4 @@ boolean MQTTCheckSubscription_037(String Topic, String Subscription) {
   }
   return false;
 }
+#endif // USES_P037

src/_P038_NeoPixel.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P038
 //#######################################################################################################
 //#################################### Plugin 038: NeoPixel Basic #######################################
 //#######################################################################################################
@@ -21,6 +22,7 @@
 // The NeoPixelLine command does not work for RGBW, cause espeasy currently only allows max. 5 parameters
 
 #include <Adafruit_NeoPixel.h>
+
 Adafruit_NeoPixel *Plugin_038_pixels;
 
 #define PLUGIN_038
@@ -159,3 +161,4 @@ boolean Plugin_038(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P038

src/_P039_Thermocouple.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P039
 //#######################################################################################################
 //######################## Plugin 039: Thermocouple (MAX6675 / MAX31855) ################################
 //#######################################################################################################
@@ -289,3 +290,4 @@ int Plugin_039_convert_two_complement(uint32_t value, int nr_bits) {
   }
   return nativeInt;
 }
+#endif // USES_P039

src/_P040_ID12.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P040
 //#######################################################################################################
 //#################################### Plugin 040: Serial RFID ID-12 ####################################
 //#######################################################################################################
@@ -133,3 +134,4 @@ boolean Plugin_040(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P040

src/_P041_NeoClock.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P041
 //#######################################################################################################
 //#################################### Plugin 041: NeoPixel clock #######################################
 //#######################################################################################################
@@ -429,3 +430,4 @@ void pushHOURE() {
   pushToStrip(103);
   pushToStrip(104);
 }
+#endif // USES_P041

src/_P042_Candle.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P042
 //#######################################################################################################
 //######################################## Plugin 042: NeoPixel Candle ##################################
 //#######################################################################################################
@@ -718,3 +719,4 @@ void RGBtoHSV(byte r, byte g, byte b, double hsv[3]) {
     hsv[1] = s * 255;
     hsv[2] = v * 255;
 }
+#endif // USES_P042

src/_P043_ClkOutput.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P043
 //#######################################################################################################
 //#################################### Plugin 043: Clock Output #########################################
 //#######################################################################################################
@@ -119,3 +120,4 @@ boolean Plugin_043(byte function, struct EventStruct *event, String& string)
   }
   return success;
 }
+#endif // USES_P043

src/_P044_P1WifiGateway.ino

@@ -1,3 +1,4 @@
+#ifdef USES_P044
 //#################################### Plugin 044: P1WifiGateway ########################################
 //
 //  based on P020 Ser2Net, extended by Ronald Leenes romix/-at-/macuser.nl
@@ -108,12 +109,22 @@ boolean Plugin_044(byte function, struct EventStruct *event, String& string)
         LoadTaskSettings(event->TaskIndex);
         if ((ExtraTaskSettings.TaskDevicePluginConfigLong[0] != 0) && (ExtraTaskSettings.TaskDevicePluginConfigLong[1] != 0))
         {
-          byte serialconfig = 0x10;
+          #if defined(ESP8266)
+            byte serialconfig = 0x10;
+          #endif
+          #if defined(ESP32)
+            uint32_t serialconfig = 0x8000010;
+          #endif
           serialconfig += ExtraTaskSettings.TaskDevicePluginConfigLong[3];
           serialconfig += (ExtraTaskSettings.TaskDevicePluginConfigLong[2] - 5) << 2;
           if (ExtraTaskSettings.TaskDevicePluginConfigLong[4] == 2)
             serialconfig += 0x20;
-          Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], (SerialConfig)serialconfig);
+          #if defined(ESP8266)
+            Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], (SerialConfig)serialconfig);
+          #endif
+          #if defined(ESP32)
+            Serial.begin(ExtraTaskSettings.TaskDevicePluginConfigLong[1], serialconfig);
+          #endif
           if (P1GatewayServer) P1GatewayServer->close();
           P1GatewayServer = new WiFiServer(ExtraTaskSettings.TaskDevicePluginConfigLong[0]);
           P1GatewayServer->begin();
@@ -337,7 +348,7 @@ void blinkLED() {
        checks whether the incoming character is a valid one for a P1 datagram. Returns false if not, which signals corrupt datagram
 */
 bool validP1char(char ch) {
-  if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '.') || (ch == '!') || (ch == 92) || (ch == 13) || (ch == '\n') || (ch == '(') || (ch == ')') || (ch == '-') || (ch == '*') || (ch == ':') )
+  if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '.') || (ch == '!') || (ch == ' ') || (ch == 92) || (ch == 13) || (ch == '\n') || (ch == '(') || (ch == ')') || (ch == '-') || (ch == '*') || (ch == ':') )
   {
     return true;
   } else {
@@ -426,3 +437,4 @@ bool checkDatagram(int len) {
   }
   return validCRCFound;
 }
+#endif // USES_P044