autoexec.be

import mqtt
import json
import persist
import util
import mesh
import string
import re

var collected_sensor_data = []
var remaining_awake_nodes = 0
var wifi_used = tasmota.cmd('Wifi')['Wifi'] == 'ON'
var deepsleep_time = int(persist.find('deepsleep_interval', 15)) # todo: set time to 1 hour
var additional_deepsleep_time = int(persist.find('additional_deepsleep_time', 0))

def set_deepsleep_interval(cmd, idx, payload)
  if re.match('^[0-9]*$', payload) != nil && (int(payload) > 10 || int(payload) == 0)
    persist.deepsleep_interval = payload
    persist.save()
    
    tasmota.resp_cmnd_done()
  else
    tasmota.resp_cmnd_failed()
  end
end

def set_additional_deepsleep_time(cmd, idx, payload)
  if re.match('^[0-9]*$', payload) != nil && int(payload) > 0
    persist.additional_deepsleep_time = payload
    persist.save()
    
    tasmota.resp_cmnd_done()
  else
    tasmota.resp_cmnd_failed()
  end
end

def check_nodes_asleep()
  if remaining_awake_nodes > 0
    tasmota.set_timer(100, check_nodes_asleep)
  else
    tasmota.cmd('Time ' + str(1688598000)) # set time to 00:00:00
    tasmota.cmd('DeepSleepTime ' + str(deepsleep_time + additional_deepsleep_time))
  end
end

def sleep_acknowledge_received()
  remaining_awake_nodes -= 1
end

def put_sensor_network_to_sleep()
  if deepsleep_time > 0
    remaining_awake_nodes = size(mesh.get_peers())
    mesh.broadcast(json.dump({'action': 'DEEP_SLEEP', 'time': str(deepsleep_time)}))

    tasmota.set_timer(100, check_nodes_asleep)
  end
end

def publish_sensor_data()
  var sensor_data = json.load(tasmota.read_sensors())

  var moisture = util.calc_soil_moisture(sensor_data['ANALOG']['A1'])
  var battery = util.calc_battery_level(sensor_data['ANALOG']['A2'])
  # var temperature = sensor_data['BME680']['Temperature']

  var mac = string.tolower(string.split(mesh.info()['MAC'], ':').concat())

  collected_sensor_data.push({'mac': mac, 'values': {'battery': battery, 'moisture': moisture}})

  var base_topic = util.get_base_topic()

  for data : collected_sensor_data
    mqtt.publish(string.format(base_topic, data['mac']) + 'moisture', str(data['values']['moisture']))
    mqtt.publish(string.format(base_topic, data['mac']) + 'battery', str(data['values']['battery']))
    # mqtt.publish(base_topic + 'temperature', str(temperature))
  end

  put_sensor_network_to_sleep()
end

def sensor_data_received(sender, payload)
  var recieved_data = json.load(payload)
  var mac = string.tolower(string.split(sender, ':').concat())

  collected_sensor_data.push({'mac': mac, 'values': recieved_data})
end

def callback(sender, payload)
  var recieved_data = json.load(payload)

  if recieved_data != nil && recieved_data.contains('action')
    var action = recieved_data['action']
    
    if action == 'SEND_SENSOR_DATA'
      sensor_data_received(sender, payload)
    elif action == 'DEEP_SLEEP'
      sleep_acknowledge_received()
    end
  end
end

def collect_sensor_data()
  mesh.broadcast(json.dump({'action': 'SEND_SENSOR_DATA'}))

  tasmota.set_timer(3000, publish_sensor_data)
end

def disable_deepsleep()
  tasmota.cmd('DeepSleepTime 0')
end

def mesh_init()
  mesh.start()
  mesh.register_callback(callback)
end

def mesh_pre_init()
  mesh.init_soft_ap_mode(1)   
  
  tasmota.set_timer(50, mesh_init)
end

def wait_otaconf_finished()
  if !otaconf_finished
    tasmota.set_timer(1000, wait_otaconf_finished)
    tasmota.yield()
    return
  end

  if !wifi_used
    mesh_pre_init()
  else 
    mesh_init()
  end

  collect_sensor_data()
end

def wakeup_task()
  disable_deepsleep()
  util.set_wakeup_led(1)
  wait_otaconf_finished()
end

if !wifi_used
  tasmota.add_rule('system#init', wakeup_task)
else
  tasmota.add_rule('system#boot', wakeup_task)
end

tasmota.add_cmd('DeepSleepInterval', set_deepsleep_interval)
tasmota.add_cmd('AdditionalDeepSleepTime', set_additional_deepsleep_time)