diff --git a/.gitignore b/.gitignore
index 9025edaa0..70ec5cfc7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,4 +6,3 @@
 platformio.ini
 lib/readme.txt
 .travis.yml
-*.py
\ No newline at end of file
diff --git a/checkcode.py b/checkcode.py
index 3e381bb66..53da63054 100644
--- a/checkcode.py
+++ b/checkcode.py
@@ -3,7 +3,6 @@ from subprocess import call
 import os
 Import("env")
 
-
 def code_check(source, target, env):
     print("\n** Starting cppcheck...")
     call(["cppcheck", os.getcwd()+"/.", "--force", "--enable=all"])
@@ -18,7 +17,6 @@ def code_check(source, target, env):
 # print defines
 # print env.Dump()
 
-
 #  built in targets: (buildprog, size, upload, program, buildfs, uploadfs, uploadfsota)
 env.AddPreAction("buildprog", code_check)
 # env.AddPostAction(.....)
diff --git a/clean_fw.py b/clean_fw.py
index c380f00ac..140f23ee4 100644
--- a/clean_fw.py
+++ b/clean_fw.py
@@ -9,16 +9,6 @@ def clean(source, target, env):
     call(["esptool.py", "-p COM6", "write_flash 0x00000",  os.getcwd()+"../firmware/*.bin"])
     print("\n** Finished clean.")
 
-#my_flags = env.ParseFlags(env['BUILD_FLAGS'])
-#defines = {k: v for (k, v) in my_flags.get("CPPDEFINES")}
-# print defines
-# print env.Dump()
-
-
 #  built in targets: (buildprog, size, upload, program, buildfs, uploadfs, uploadfsota)
 env.AddPreAction("buildprog", clean)
-# env.AddPostAction(.....)
 
-# see http://docs.platformio.org/en/latest/projectconf/advanced_scripting.html#before-pre-and-after-post-actions
-# env.Replace(PROGNAME="firmware_%s" % defines.get("VERSION"))
-# env.Replace(PROGNAME="firmware_%s" % env['BOARD'])
diff --git a/debug.py b/debug.py
new file mode 100644
index 000000000..5c8a66030
--- /dev/null
+++ b/debug.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+from subprocess import call
+import os
+
+# python decoder.py -p ESP8266 -t C:\Users\Paul\.platformio\packages\toolchain-xtensa -e .pioenvs/nodemcuv2/firmware.elf stackdmp.txt
+# java -jar .\EspStackTraceDecoder.jar C:\Users\Paul\.platformio\packages\toolchain-xtensa\bin\xtensa-lx106-elf-addr2line.exe .pioenvs/nodemcuv2/firmware.elf stackdmp.txt
+
+# example stackdmp.txt would contain text like below copied & pasted from a 'crash dump' command
+# >>>stack>>>
+# 3fffff20: 3fff32f0 00000003 3fff3028 402101b2
+# 3fffff30: 3fffdad0 3fff3280 0000000d 402148aa
+# 3fffff40: 3fffdad0 3fff3280 3fff326c 3fff32f0
+# 3fffff50: 0000000d 3fff326c 3fff3028 402103bd
+# 3fffff60: 0000000d 3fff34cc 40211de4 3fff34cc
+# 3fffff70: 3fff3028 3fff14c4 3fff301c 3fff34cc
+# 3fffff80: 3fffdad0 3fff14c4 3fff3028 40210493
+# 3fffff90: 3fffdad0 00000000 3fff14c4 4020a738
+# 3fffffa0: 3fffdad0 00000000 3fff349c 40211e90
+# 3fffffb0: feefeffe feefeffe 3ffe8558 40100b01
+# <<<stack<<<
+
+call(['python', 'decoder.py ', '-s', '-e', os.getcwd()+"/.pioenvs/d1_mini/firmware_d1_mini.elf", 'stackdmp.txt'])
diff --git a/decoder.py b/decoder.py
new file mode 100644
index 000000000..a86ea655c
--- /dev/null
+++ b/decoder.py
@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+
+"""ESP Exception Decoder
+
+github:  https://github.com/janLo/EspArduinoExceptionDecoder
+license: GPL v3
+author:  Jan Losinski
+"""
+
+import argparse
+import re
+import subprocess
+from collections import namedtuple
+
+import sys
+
+import os
+
+EXCEPTIONS = [
+    "Illegal instruction",
+    "SYSCALL instruction",
+    "InstructionFetchError: Processor internal physical address or data error during instruction fetch",
+    "LoadStoreError: Processor internal physical address or data error during load or store",
+    "Level1Interrupt: Level-1 interrupt as indicated by set level-1 bits in the INTERRUPT register",
+    "Alloca: MOVSP instruction, if caller's registers are not in the register file",
+    "IntegerDivideByZero: QUOS, QUOU, REMS, or REMU divisor operand is zero",
+    "reserved",
+    "Privileged: Attempt to execute a privileged operation when CRING ? 0",
+    "LoadStoreAlignmentCause: Load or store to an unaligned address",
+    "reserved",
+    "reserved",
+    "InstrPIFDataError: PIF data error during instruction fetch",
+    "LoadStorePIFDataError: Synchronous PIF data error during LoadStore access",
+    "InstrPIFAddrError: PIF address error during instruction fetch",
+    "LoadStorePIFAddrError: Synchronous PIF address error during LoadStore access",
+    "InstTLBMiss: Error during Instruction TLB refill",
+    "InstTLBMultiHit: Multiple instruction TLB entries matched",
+    "InstFetchPrivilege: An instruction fetch referenced a virtual address at a ring level less than CRING",
+    "reserved",
+    "InstFetchProhibited: An instruction fetch referenced a page mapped with an attribute that does not permit instruction fetch",
+    "reserved",
+    "reserved",
+    "reserved",
+    "LoadStoreTLBMiss: Error during TLB refill for a load or store",
+    "LoadStoreTLBMultiHit: Multiple TLB entries matched for a load or store",
+    "LoadStorePrivilege: A load or store referenced a virtual address at a ring level less than CRING",
+    "reserved",
+    "LoadProhibited: A load referenced a page mapped with an attribute that does not permit loads",
+    "StoreProhibited: A store referenced a page mapped with an attribute that does not permit stores"
+]
+
+PLATFORMS = {
+    "ESP8266": "lx106",
+    "ESP32": "esp32"
+}
+
+EXCEPTION_REGEX = re.compile("^Exception \\((?P<exc>[0-9]*)\\):$")
+COUNTER_REGEX = re.compile('^epc1=(?P<epc1>0x[0-9a-f]+) epc2=(?P<epc2>0x[0-9a-f]+) epc3=(?P<epc3>0x[0-9a-f]+) '
+                           'excvaddr=(?P<excvaddr>0x[0-9a-f]+) depc=(?P<depc>0x[0-9a-f]+)$')
+CTX_REGEX = re.compile("^ctx: (?P<ctx>.+)$")
+POINTER_REGEX = re.compile('^sp: (?P<sp>[0-9a-f]+) end: (?P<end>[0-9a-f]+) offset: (?P<offset>[0-9a-f]+)$')
+STACK_BEGIN = '>>>stack>>>'
+STACK_END = '<<<stack<<<'
+STACK_REGEX = re.compile(
+    '^(?P<off>[0-9a-f]+):\W+(?P<c1>[0-9a-f]+) (?P<c2>[0-9a-f]+) (?P<c3>[0-9a-f]+) (?P<c4>[0-9a-f]+)(\W.*)?$')
+
+StackLine = namedtuple("StackLine", ["offset", "content"])
+
+
+class ExceptionDataParser(object):
+    def __init__(self):
+        self.exception = None
+
+        self.epc1 = None
+        self.epc2 = None
+        self.epc3 = None
+        self.excvaddr = None
+        self.depc = None
+
+        self.ctx = None
+
+        self.sp = None
+        self.end = None
+        self.offset = None
+
+        self.stack = []
+
+    def _parse_exception(self, line):
+        match = EXCEPTION_REGEX.match(line)
+        if match is not None:
+            self.exception = int(match.group('exc'))
+            return self._parse_counters
+        return self._parse_exception
+
+    def _parse_counters(self, line):
+        match = COUNTER_REGEX.match(line)
+        if match is not None:
+            self.epc1 = match.group("epc1")
+            self.epc2 = match.group("epc2")
+            self.epc3 = match.group("epc3")
+            self.excvaddr = match.group("excvaddr")
+            self.depc = match.group("depc")
+            return self._parse_ctx
+        return self._parse_counters
+
+    def _parse_ctx(self, line):
+        match = CTX_REGEX.match(line)
+        if match is not None:
+            self.ctx = match.group("ctx")
+            return self._parse_pointers
+        return self._parse_ctx
+
+    def _parse_pointers(self, line):
+        match = POINTER_REGEX.match(line)
+        if match is not None:
+            self.sp = match.group("sp")
+            self.end = match.group("end")
+            self.offset = match.group("offset")
+            return self._parse_stack_begin
+        return self._parse_pointers
+
+    def _parse_stack_begin(self, line):
+        if line == STACK_BEGIN:
+            return self._parse_stack_line
+        return self._parse_stack_begin
+
+    def _parse_stack_line(self, line):
+        if line != STACK_END:
+            match = STACK_REGEX.match(line)
+            if match is not None:
+                self.stack.append(StackLine(offset=match.group("off"),
+                                            content=(match.group("c1"), match.group("c2"), match.group("c3"),
+                                                     match.group("c4"))))
+            return self._parse_stack_line
+        return None
+
+    def parse_file(self, file, stack_only=False):
+        func = self._parse_exception
+        if stack_only:
+            func = self._parse_stack_begin
+
+        for line in file:
+            func = func(line.strip())
+            if func is None:
+                break
+
+        if func is not None:
+            print("ERROR: Parser not complete!")
+            sys.exit(1)
+
+
+class AddressResolver(object):
+    def __init__(self, tool_path, elf_path):
+        self._tool = tool_path
+        self._elf = elf_path
+        self._address_map = {}
+
+    def _lookup(self, addresses):
+        cmd = [self._tool, "-aipfC", "-e", self._elf] + [addr for addr in addresses if addr is not None]
+
+        if sys.version_info[0] < 3:
+            output = subprocess.check_output(cmd)
+        else:
+            output = subprocess.check_output(cmd, encoding="utf-8")
+
+        line_regex = re.compile("^(?P<addr>[0-9a-fx]+): (?P<result>.+)$")
+
+        last = None
+        for line in output.splitlines():
+            line = line.strip()
+            match = line_regex.match(line)
+
+            if match is None:
+                if last is not None and line.startswith('(inlined by)'):
+                    line = line [12:].strip()
+                    self._address_map[last] += ("\n  \-> inlined by: " + line)
+                continue
+
+            if match.group("result") == '?? ??:0':
+                continue
+
+            self._address_map[match.group("addr")] = match.group("result")
+            last = match.group("addr")
+
+    def fill(self, parser):
+        addresses = [parser.epc1, parser.epc2, parser.epc3, parser.excvaddr, parser.sp, parser.end, parser.offset]
+        for line in parser.stack:
+            addresses.extend(line.content)
+
+        self._lookup(addresses)
+
+    def _sanitize_addr(self, addr):
+        if addr.startswith("0x"):
+            addr = addr[2:]
+
+        fill = "0" * (8 - len(addr))
+        return "0x" + fill + addr
+
+    def resolve_addr(self, addr):
+        out = self._sanitize_addr(addr)
+
+        if out in self._address_map:
+            out += ": " + self._address_map[out]
+
+        return out
+
+    def resolve_stack_addr(self, addr, full=True):
+        addr = self._sanitize_addr(addr)
+        if addr in self._address_map:
+            return addr + ": " + self._address_map[addr]
+
+        if full:
+            return "[DATA (0x" + addr + ")]"
+
+        return None
+
+
+def print_addr(name, value, resolver):
+    print("{}:{} {}".format(name, " " * (8 - len(name)), resolver.resolve_addr(value)))
+
+
+def print_stack_full(lines, resolver):
+    print("stack:")
+    for line in lines:
+        print(line.offset + ":")
+        for content in line.content:
+            print("  " + resolver.resolve_stack_addr(content))
+
+
+def print_stack(lines, resolver):
+    print("stack:")
+    for line in lines:
+        for content in line.content:
+            out = resolver.resolve_stack_addr(content, full=False)
+            if out is None:
+                continue
+            print(out)
+
+
+def print_result(parser, resolver, full=True, stack_only=False):
+    if not stack_only:
+        print('Exception: {} ({})'.format(parser.exception, EXCEPTIONS[parser.exception]))
+
+        print("")
+        print_addr("epc1", parser.epc1, resolver)
+        print_addr("epc2", parser.epc2, resolver)
+        print_addr("epc3", parser.epc3, resolver)
+        print_addr("excvaddr", parser.excvaddr, resolver)
+        print_addr("depc", parser.depc, resolver)
+
+        print("")
+        print("ctx: " + parser.ctx)
+
+        print("")
+        print_addr("sp", parser.sp, resolver)
+        print_addr("end", parser.end, resolver)
+        print_addr("offset", parser.offset, resolver)
+
+        print("")
+    if full:
+        print_stack_full(parser.stack, resolver)
+    else:
+        print_stack(parser.stack, resolver)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="decode ESP Stacktraces.")
+
+    parser.add_argument("-p", "--platform", help="The platform to decode from", choices=PLATFORMS.keys(),
+                        default="ESP8266")
+    parser.add_argument("-t", "--tool", help="Path to the xtensa toolchain",
+                        default="~/.platformio/packages/toolchain-xtensa/")
+    parser.add_argument("-e", "--elf", help="path to elf file", required=True)
+    parser.add_argument("-f", "--full", help="Print full stack dump", action="store_true")
+    parser.add_argument("-s", "--stack_only", help="Decode only a stractrace", action="store_true")
+    parser.add_argument("file", help="The file to read the exception data from ('-' for STDIN)", default="-")
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    if args.file == "-":
+        file = sys.stdin
+    else:
+        if not os.path.exists(args.file):
+            print("ERROR: file " + args.file + " not found")
+            sys.exit(1)
+        file = open(args.file, "r")
+
+    addr2line = os.path.join(os.path.abspath(os.path.expanduser(args.tool)),
+                             "bin/xtensa-" + PLATFORMS[args.platform] + "-elf-addr2line.exe")
+    if not os.path.exists(addr2line):
+        print("ERROR: addr2line not found (" + addr2line + ")")
+
+    elf_file = os.path.abspath(os.path.expanduser(args.elf))
+    if not os.path.exists(elf_file):
+        print("ERROR: elf file not found (" + elf_file + ")")
+
+    parser = ExceptionDataParser()
+    resolver = AddressResolver(addr2line, elf_file)
+
+    parser.parse_file(file, args.stack_only)
+    resolver.fill(parser)
+
+    print_result(parser, resolver, args.full, args.stack_only)
diff --git a/platformio.ini-example b/platformio.ini-example
index fdbbeb257..b381c389d 100644
--- a/platformio.ini-example
+++ b/platformio.ini-example
@@ -4,8 +4,11 @@ env_default = d1_mini
 [common]
 platform = espressif8266
 flash_mode = dout
-build_flags = -g -w
-;build_flags = -g -w -DBUILD_TIME=$UNIX_TIME
+
+build_flags_debug = -ggdb3 -Wall -Wextra -Werror -Wno-missing-field-initializers -Wno-unused-parameter -Wno-unused-variable
+;build_flags_prod = -Os -DBUILD_TIME=$UNIX_TIME
+
+build_flags = ${common.build_flags_debug}
 
 wifi_settings =
 ; hard code if you prefer. Recommendation is to set from within the app when in Serial or AP mode
@@ -17,7 +20,6 @@ lib_deps =
   JustWifi
   AsyncMqttClient
   ArduinoJson
-;  https://github.com/bblanchon/ArduinoJson#v5.13.5
   OneWire
 
 [env:d1_mini]
@@ -33,5 +35,6 @@ monitor_speed = 115200
 ; for OTA comment out these sections
 ;upload_protocol = espota
 ;upload_port = ems-esp.local
+;upload_port = <the IP address...>
 
 
diff --git a/rename_fw.py b/rename_fw.py
index aad993d99..7b4d42299 100644
--- a/rename_fw.py
+++ b/rename_fw.py
@@ -3,11 +3,6 @@ from subprocess import call
 import os
 Import("env")
 
-#my_flags = env.ParseFlags(env['BUILD_FLAGS'])
-#defines = {k: v for (k, v) in my_flags.get("CPPDEFINES")}
-# print defines
-# print env.Dump()
-
 # see http://docs.platformio.org/en/latest/projectconf/advanced_scripting.html#before-pre-and-after-post-actions
 # env.Replace(PROGNAME="firmware_%s" % defines.get("VERSION"))
 env.Replace(PROGNAME="firmware_%s" % env['BOARD'])