A stand-alone hardware watchdog with I2C comms, suitable as a shield (2.7 - 5.5V VCC) for Wemos D1 Mini, Arduino Uno...

attiny85_hardware_watchdog.ino

#include "TinyWireS.h"  //SDA/SCL PB0/PB2 5/7 //tws_delay(ms)
#include <EEPROM.h>

#define PIN_BITE 3
#define PIN_LED 1

#define BLINK_SHORT 250
#define BLINK_LONG 1000

#define EEPROM_VERSION 0


byte _i2cSlaveAddress = 8; // valid (verified) values 8 to 25
byte _interval = 20;

bool _enabled = true;

unsigned long _startTime;
unsigned long _elapsedTime;

char _i2cCmd = ' ';
byte _i2cParam = 0;


void setup() {
  getFromEeprom();
  pinMode(PIN_BITE, OUTPUT);
  digitalWrite(PIN_BITE, HIGH);     //avoid reset
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, LOW);     
  TinyWireS.begin(_i2cSlaveAddress);      
  TinyWireS.onReceive(receiveEvent);
  TinyWireS.onRequest(requestEvent);
  tws_delay(2000);
}

void loop() { // no delay in loop - TinyWireS sonstraint
  digitalWrite(PIN_LED, LOW);
  int delay = 1000;// 1 second
  digitalWrite(PIN_BITE, HIGH);     //avoid reset
  if (_enabled){
    _elapsedTime = millis() - _startTime;
    if (_elapsedTime > (_interval * 1000)){
      digitalWrite(PIN_BITE, LOW); 
      _startTime = millis();
      digitalWrite(PIN_LED, HIGH);
    }
  }
  TinyWireS_stop_check;
  tws_delay(delay);
}

void requestEvent()
{  
  TinyWireS.send(_i2cParam);
}

void receiveEvent(uint8_t howMany) {
  char c=' ';
  while (1 < TinyWireS.available()) { // loop through all but the last
    c = TinyWireS.receive();      // receive byte as a character
  }
  byte x = TinyWireS.receive();    // receive byte as an integer
  _i2cCmd = c;
  _i2cParam = x;
  switch (_i2cCmd) {
    case 'E': // ENABLE
      _i2cParam = 1;
      _enabled = true;
      break;
    case 'D': // DISABLE
      _i2cParam = 1;
      _enabled = false;
      break;
    case 'P': // PAT
      _i2cParam = 1;
      _startTime = millis();
      blinkFor(BLINK_SHORT);
      break;
    case 'G': 
      // param stays the same
      // param is index of getters
      switch (_i2cParam){
        case 0:
          _i2cParam = _i2cSlaveAddress;
          break;
        case 1:
          _i2cParam = _interval;
        break;
      }
      break;
    case 'A': // ADDRESS I2C FOR EEPROM
      // param is value
      _i2cSlaveAddress = _i2cParam;
      _i2cParam = _i2cSlaveAddress;
      EEPROM.update(0, _i2cSlaveAddress);
      break;
    case 'I': // INTERVAL FOR EEPROM
      // param is value
      _interval = _i2cParam;
      _i2cParam = _interval;
      EEPROM.update(1, _interval);
      break;
  }
}

void getFromEeprom(){
    // Writing default configuration in EEPROM
  if(
    EEPROM.read(3) != 'S' ||
    EEPROM.read(4) != '+' ||
    EEPROM.read(5) != 'W' ||
    EEPROM.read(6) != EEPROM_VERSION
  ) EEPROM_write_default_configuration();
  EEPROM_read_configuration();
}

void EEPROM_write_default_configuration(){
  // I2C ADDRESS
  EEPROM.update(0, _i2cSlaveAddress);
  // INTERVAL
  EEPROM.update(1, _interval);
  // VERSION
  EEPROM.update(2, EEPROM_VERSION);
  // Signature footprint
  EEPROM.update(3, 'S');
  EEPROM.update(4, '+');
  EEPROM.update(5, 'W');
  EEPROM.update(6, EEPROM_VERSION);
}

void EEPROM_read_configuration(){
  _i2cSlaveAddress = EEPROM.read(0);
  _i2cCmd = _i2cSlaveAddress;// forces set of variable??
  _interval = EEPROM.read(1);
  _i2cCmd = _interval;// forces set of variable??
}

void blinkFor(unsigned int x){
     digitalWrite(PIN_LED, HIGH);
     delay(x);
     digitalWrite(PIN_LED, LOW); 
}