_C021_BLEDirect.py

#!/usr/bin/env python3
#############################################################################
################## BLE Direct controller for RPIEasy ########################
#############################################################################
#
# This controller is able to listen or send BLE messages to nearby devices
#
# Copyright (C) 2019 by Alexander Nagy - https://bitekmindenhol.blog.hu/
#
import controller
import misc
import rpieGlobals
import time
from rpieTime import *
import webserver
import commands
import Settings
from datetime import datetime
import lib.lib_p2pbuffer as p2pbuffer
from pybleno import *
from bluepy.btle import Peripheral
import os
import linux_os as OS
import base64

BLE_SERVICE_ID    = "5032505f-5250-4945-6173-795f424c455f"
BLE_RECEIVER_CHAR = "10000001-5250-4945-6173-795f424c455f"
BLE_INFO_CHAR     = "10000002-5250-4945-6173-795f424c455f"

class Controller(controller.ControllerProto):
 CONTROLLER_ID = 21
 CONTROLLER_NAME = "BLE Direct (EXPERIMENTAL)"

 def __init__(self,controllerindex):
  controller.ControllerProto.__init__(self,controllerindex)
  self.usesID = True
  self.onmsgcallbacksupported = False # use direct set_value() instead of generic callback to make sure that values setted anyway
  self.controllerport = 1
  self.bleserv = None
  self.bleclient = None
  self.timer30s = True
  self.duty = 0  # use 100%
  self.defaultdestination = ""
  self.defaultunit = 1
  self.lastsysinfo = 0
  self.sysinfoperiod = 1800 # seconds
  self.enablerec = True
  self.enablesend = False
  self.directsend = False

 def controller_init(self,enablecontroller=None):
  if enablecontroller != None:
   self.enabled = enablecontroller
  self.initialized = False
  if self.enabled:
   if int(Settings.Settings["Unit"])>0:
    self.controllerport = Settings.Settings["Unit"]
   self.lastsysinfo = 0
   if self.bleserv is not None:
    try:
     self.bleserv.stop()
     time.sleep(1)
    except:
     pass
   try:
    output = os.popen(OS.cmdline_rootcorrect("sudo systemctl stop bluetooth"))
    for l in output:
     pass
   except Exception as e:
    print(e)
   try:
    output = os.popen(OS.cmdline_rootcorrect("sudo hciconfig hci0 up"))
    for l in output:
     pass
   except Exception as e:
    print(e)
   try:
    self.bleclient = BLEClient(self.defaultdestination,self.duty)
    self.bleserv = BLEServer(Settings.Settings["Name"],self.pkt_receiver,self.getmode)
    if self.enablerec:
     self.bleserv.start()
    if self.enablesend==False:
     self.defaultdestination=""
    self.initialized = True
    time.sleep(1)
    misc.addLog(rpieGlobals.LOG_LEVEL_DEBUG,"BLE Direct initialized")
   except Exception as e:
    self.initialized = False
    misc.addLog(rpieGlobals.LOG_LEVEL_ERROR,"BLE Direct init error: "+str(e))
  else:
   if self.bleserv is not None:
    try:
     self.bleserv.stop()
    except:
     pass
  return True

 def controller_exit(self):
   if self.bleserv is not None:
    try:
     self.bleserv.stop()
    except:
     pass
 
 def webform_load(self):
  webserver.addFormNote("IP and Port parameter is not used!")
  webserver.addFormNote("<a href='https://github.com/enesbcs/ESPEasyRetro/blob/master/ESPEasyRetro/_C021.ino'>ESP32 reference controller</a>")

  webserver.addFormCheckBox("Enable Receiver Service","receiver",self.enablerec)
  webserver.addFormNote("Enable this for Gateway/Repeater unit, Disable if you only want to send data!")
  try:
   if self.bleserv is not None:
    webserver.addFormNote("Current Address: "+str(self.bleserv.getaddress()))
  except:
   pass
  webserver.addFormCheckBox("Enable Sending to Default Master Unit","sender",self.enablesend)
  webserver.addFormCheckBox("Enable Direct Sending to Units in P2P list","directsender",self.directsend)
  webserver.addFormNote("Please respect MASTER-SLAVE nature of BLE and do not create infinite loops!")
  webserver.addFormTextBox("Default BLE Master Unit address","masteraddress",self.defaultdestination,23)
  webserver.addFormNote("Enable bluetooth then <a href='blescanner'>scan RPIEasy BLE address</a> first.")
  webserver.addFormNumericBox("Default destination node index","defaultnode",self.defaultunit,0,255)
  webserver.addFormNote("Default node index for data sending, only used when Master Unit address is setted")
  return True

 def webform_save(self,params):
  try:
   self.enablerec = (webserver.arg("receiver",params)=="on")
   self.enablesend = (webserver.arg("sender",params)=="on")
   self.directsend = (webserver.arg("directsender",params)=="on")
   self.defaultdestination = str(webserver.arg("masteraddress",params)).strip()
   if len(self.defaultdestination)<13:
    self.defaultdestination = ""
   self.defaultunit = int(webserver.arg("defaultnode",params))
#   self.controller_init()
  except Exception as e:
   misc.addLog(rpieGlobals.LOG_LEVEL_ERROR,"BLE parameter save: "+str(e))
  return True

 def nodesort(self,item):
  v = 0
  try:
   v = int(item["unitno"])
  except:
   v = 0
  return v

 def pkt_receiver(self,payload): # processing incoming packets
#  print(payload) # debug
  if self.enabled:
    dp = p2pbuffer.data_packet() 
    pbuf = list(payload)
    if pbuf[0]=='/' or pbuf[0]==47: # base64 encoded
     dp.buffer = base64.b64decode(payload.decode("utf-8"))
    else:               # otherwise plain data arrived
     dp.buffer = payload
    dp.decode()            # asking p2pbuffer library to decode it
#    print(dp.buffer) # debug
    if dp.pkgtype!=0:
        if dp.pkgtype==1: # info packet received
#         print(dp.infopacket)
         if int(dp.infopacket["unitno"]) == int(Settings.Settings["Unit"]): # skip own messages
          return False
         un = getunitordfromnum(dp.infopacket["unitno"]) # process incoming alive reports
         if un==-1:
          # CAPABILITIES byte: first bit 1 if able to send, second bit 1 if able to receive
          Settings.p2plist.append({"protocol":"BLE","unitno":dp.infopacket["unitno"],"name":dp.infopacket["name"],"build":dp.infopacket["build"],"type":dp.infopacket["type"],"mac":dp.infopacket["mac"],"lastseen":datetime.now(),"lastrssi":self.bleserv.getrssi(),"cap":dp.infopacket["cap"]})
          misc.addLog(rpieGlobals.LOG_LEVEL_INFO,"New BLE unit discovered: "+str(dp.infopacket["unitno"])+" "+str(dp.infopacket["name"]))
          Settings.p2plist.sort(reverse=False,key=self.nodesort)
         else:
          misc.addLog(rpieGlobals.LOG_LEVEL_DEBUG,"Unit alive: "+str(dp.infopacket["unitno"]))
          if Settings.p2plist[un]["type"]==0:
           Settings.p2plist[un]["name"] = dp.infopacket["name"]
           Settings.p2plist[un]["build"] = dp.infopacket["build"]
           Settings.p2plist[un]["type"] = dp.infopacket["type"]
           Settings.p2plist[un]["mac"] = dp.infopacket["mac"]
          Settings.p2plist[un]["cap"] = dp.infopacket["cap"]
          Settings.p2plist[un]["lastseen"] = datetime.now()
          Settings.p2plist[un]["lastrssi"] = self.bleserv.getrssi()

        elif dp.pkgtype==5:                          # process incoming data
          if int(dp.sensordata["sunit"])==int(Settings.Settings["Unit"]):
           return False
          un = getunitordfromnum(dp.sensordata["sunit"])
          if un>-1: # refresh lastseen data
           Settings.p2plist[un]["lastseen"] = datetime.now()
           Settings.p2plist[un]["lastrssi"] = self.bleserv.getrssi()
          else:
           Settings.p2plist.append({"protocol":"BLE","unitno":dp.sensordata["sunit"],"name":"","build":0,"type":0,"mac":"","lastseen":datetime.now(),"lastrssi":self.bleserv.getrssi(),"cap":1})

          if (int(Settings.Settings["Unit"])==int(dp.sensordata["dunit"])) or (0==int(dp.sensordata["dunit"])): # process only if we are the destination or broadcast
           ltaskindex = -1
           for x in range(0,len(Settings.Tasks)): # check if the sent IDX already exists?
             try:
              if (type(Settings.Tasks[x]) is not bool and Settings.Tasks[x]):
                if Settings.Tasks[x].controlleridx[self.controllerindex]==int(dp.sensordata["idx"]):
                 ltaskindex = x
                 break
             except Exception as e:
              print(e)
           dvaluecount = int(dp.sensordata["valuecount"])
           if rpieGlobals.VARS_PER_TASK<dvaluecount: # avoid possible buffer overflow
            dvaluecount = rpieGlobals.VARS_PER_TASK
           if ltaskindex < 0: # create new task if necessarry
            devtype = int(dp.sensordata["pluginid"])
            m = False
            try:
             for y in range(len(rpieGlobals.deviceselector)):
              if int(rpieGlobals.deviceselector[y][1]) == devtype:
               m = __import__(rpieGlobals.deviceselector[y][0])
               break
            except:
             m = False
            TempEvent = None
            if m:
             try: 
              TempEvent = m.Plugin(-1)
             except:
              TempEvent = None
            if True:
             ltaskindex = -1
             for x in range(0,len(Settings.Tasks)): # check if there are free TaskIndex slot exists
               try:
                if (type(Settings.Tasks[x]) is bool):
                 if Settings.Tasks[x]==False:
                  ltaskindex = x
                  break
               except:
                pass
             devtype = 33 # dummy device
             m = False
             try:
              for y in range(len(rpieGlobals.deviceselector)):
               if int(rpieGlobals.deviceselector[y][1]) == devtype:
                m = __import__(rpieGlobals.deviceselector[y][0])
                break
             except:
              m = False
             if m:
              if ltaskindex<0:
               ltaskindex = len(Settings.Tasks)
              try:
               Settings.Tasks[ltaskindex] = m.Plugin(ltaskindex)
              except:
               ltaskindex = len(Settings.Tasks)
               Settings.Tasks.append(m.Plugin(ltaskindex))  # add a new device
              Settings.Tasks[ltaskindex].plugin_init(True)
              Settings.Tasks[ltaskindex].remotefeed = True  # Mark that this task accepts incoming data updates!
              Settings.Tasks[ltaskindex].enabled  = True
              Settings.Tasks[ltaskindex].interval = 0
              Settings.Tasks[ltaskindex].senddataenabled[self.controllerindex]=True
              Settings.Tasks[ltaskindex].controlleridx[self.controllerindex]=int(dp.sensordata["idx"])
              if TempEvent is not None:
               Settings.Tasks[ltaskindex].taskname = TempEvent.PLUGIN_NAME.replace(" ","")
               for v in range(dvaluecount):
                Settings.Tasks[ltaskindex].valuenames[v] = TempEvent.valuenames[v]
               Settings.Tasks[ltaskindex].taskdevicepluginconfig[0] = TempEvent.vtype
               Settings.Tasks[ltaskindex].vtype = TempEvent.vtype
              else:
               Settings.Tasks[ltaskindex].taskname = Settings.Tasks[ltaskindex].PLUGIN_NAME.replace(" ","")
              Settings.Tasks[ltaskindex].valuecount = dvaluecount
              Settings.savetasks()
           if ltaskindex<0:
            return False
           misc.addLog(rpieGlobals.LOG_LEVEL_DEBUG,"Sensordata update arrived from unit "+str(dp.sensordata["sunit"])) # save received values
           if Settings.Tasks[ltaskindex].remotefeed:
            for v in range(dvaluecount):
             Settings.Tasks[ltaskindex].set_value(v+1,dp.sensordata["values"][v],False)
            Settings.Tasks[ltaskindex].plugin_senddata()
          elif (int(Settings.Settings["Unit"])!=int(dp.sensordata["dunit"])): # reroute if pkt is not for us
            if (self.defaultunit!=int(dp.sensordata["dunit"])) and (self.enablesend or self.directsend): # ... and not came from default target, and sending is enabled
             if self.directsend:
              un = getunitordfromnum(dp.sensordata["dunit"]) # try direct send only if instructed to do so
             else:
              un = -1
             self.bleclient.setdestination(self.defaultdestination)
             if un>-1:
              if (int(Settings.p2plist[un]["cap"]) & 2)==2: # try only if endpoint is able to receive
               self.bleclient.setdestination(Settings.p2plist[un]["mac"])
             success = self.bleclient.send(dp.buffer)
             if success==False and un>-1:
              self.bleclient.setdestination(self.defaultdestination)
              success = self.bleclient.send(dp.buffer)

        elif dp.pkgtype==7: # process incoming command
          if int(dp.cmdpacket["sunit"])==int(Settings.Settings["Unit"]):
           return False
          un = getunitordfromnum(dp.cmdpacket["sunit"])
          if un>-1: # refresh lastseen data
           Settings.p2plist[un]["lastseen"] = datetime.now()
           Settings.p2plist[un]["lastrssi"] = self.bleserv.getrssi()
          else:
           Settings.p2plist.append({"protocol":"BLE","unitno":dp.cmdpacket["sunit"],"name":"","build":0,"type":0,"mac":"","lastseen":datetime.now(),"lastrssi":self.bleserv.getrssi(),"cap":1})
          if (int(Settings.Settings["Unit"])==int(dp.cmdpacket["dunit"])) or (0==int(dp.cmdpacket["dunit"])): # process only if we are the destination or broadcast
           misc.addLog(rpieGlobals.LOG_LEVEL_INFO,"Command arrived from "+str(dp.cmdpacket["sunit"]))
#           print(dp.cmdpacket["cmdline"]) # DEBUG
           commands.doExecuteCommand(dp.cmdpacket["cmdline"],True)


 def senddata(self,idx,sensortype,value,userssi=-1,usebattery=-1,tasknum=-1,changedvalue=-1): # called by plugin
  if self.enabled and self.initialized:
#   print(idx,value) # debug
   if tasknum is None:
    return False
   if int(idx)>0:
    if Settings.Tasks[tasknum].remotefeed==False or Settings.Tasks[tasknum].remotefeed==-1:  # do not republish received values
     dp2 = p2pbuffer.data_packet()
     dp2.sensordata["sunit"] = Settings.Settings["Unit"]
     dp2.sensordata["dunit"] = self.defaultunit
     dp2.sensordata["idx"] = idx
     if tasknum>-1:
      dp2.sensordata["pluginid"] = Settings.Tasks[tasknum].pluginid
     else:
      dp2.sensordata["pluginid"] = 33
     dp2.sensordata["valuecount"] = Settings.Tasks[tasknum].valuecount
     for u in range(Settings.Tasks[tasknum].valuecount):
      try:
       dp2.sensordata["values"][u] = Settings.Tasks[tasknum].uservar[u]
      except:
       dp2.sensordata["values"].append(Settings.Tasks[tasknum].uservar[u])
     dp2.encode(5)
#     print(dp2.buffer) # debug
     if self.directsend:
      un = getunitordfromnum(self.defaultunit) # try direct send only if instructed to do so
     else:
      un = -1
     self.bleclient.setdestination(self.defaultdestination)
     if un>-1:
      if (int(Settings.p2plist[un]["cap"]) & 2)==2: # try only if endpoint is able to receive
       self.bleclient.setdestination(Settings.p2plist[un]["mac"])
#       print("a2:",Settings.p2plist[un]["mac"])
     success = self.bleclient.send(dp2.buffer)
     if success==False and un>-1:
#      print("retry",success,un) # debug
      self.bleclient.setdestination(self.defaultdestination)
      success = self.bleclient.send(dp2.buffer)
     return success

 def sendcommand(self,unitno,commandstr):
     dpc = p2pbuffer.data_packet()
     dpc.cmdpacket["sunit"] = Settings.Settings["Unit"]
     dpc.cmdpacket["dunit"] = unitno
     dpc.cmdpacket["cmdline"] = commandstr
     dpc.encode(7)
     un = getunitordfromnum(unitno) # try direct send anyway
     if un==-1:
      self.bleclient.setdestination(self.defaultdestination)
     else:
      self.bleclient.setdestination(Settings.p2plist[un]["mac"])
     success = self.bleclient.send(dpc.buffer)
     if success==False and un>-1:
      self.bleclient.setdestination(self.defaultdestination)
      success = self.bleclient.send(dpc.buffer)
     return success

 def timer_thirty_second(self):
  if self.enabled and self.initialized:
   if self.defaultdestination!="" and ((time.time()-self.lastsysinfo) >self.sysinfoperiod):
    dp = p2pbuffer.data_packet()
    try:
     dp.infopacket["mac"] = self.bleserv.getaddress()
    except Exception as e:
     dp.infopacket["mac"] = "00:00:00:00:00:00"
    dp.infopacket["unitno"] = int(Settings.Settings["Unit"])
    dp.infopacket["build"] = int(rpieGlobals.BUILD)
    dp.infopacket["name"] = Settings.Settings["Name"]
    dp.infopacket["type"] = int(rpieGlobals.NODE_TYPE_ID_RPI_EASY_STD)
    # CAPABILITIES byte: first bit 1 if able to send, second bit 1 if able to receive
    dp.infopacket["cap"] = self.getmode()
    dp.encode(1)
    self.bleclient.setdestination(self.defaultdestination)
    misc.addLog(rpieGlobals.LOG_LEVEL_DEBUG,"Sending infopacket")
    success = False
    if self.bleclient.connect():
        success = self.bleclient.writepayload(dp.buffer)
        reply = self.bleclient.readpayload() # read remote infos
        self.bleclient.disconnect()
        if reply:
#         print("repl",reply) # debug
         self.pkt_receiver(reply) # handle received infos
    self.lastsysinfo = time.time()
#    if success:
#     self.lastsysinfo = time.time()
#    else:
#     self.lastsysinfo = (time.time()-self.sysinfoperiod)+10 # retry in 10sec
  return True

 def getmode(self):
    wm = 0
    if self.enablesend or self.directsend:
     wm = 1
    if self.enablerec:
     wm += 2
    return wm

class InfoCharacteristic(Characteristic):
    def __init__(self,addressfunc=None,modefunc=None):
        Characteristic.__init__(self, {
            'uuid': BLE_INFO_CHAR,
            'properties': ['read'],
            'descriptors': [
                    Descriptor({
                        "uuid" : "2901",
                        "value" : array.array('B',[73, 110, 102, 111, 32, 112, 97, 99, 107, 101, 116])}
                    )],
            'value': None
          })
        self._value = []
        self.addressfunc=addressfunc
        self.modefunc=modefunc

    def onReadRequest(self, offset, callback):
      dp = p2pbuffer.data_packet()
      try:
       dp.infopacket["mac"] = self.addressfunc()
      except Exception as e:
       dp.infopacket["mac"] = "00:00:00:00:00:00"
      dp.infopacket["unitno"] = int(Settings.Settings["Unit"])
      dp.infopacket["build"] = int(rpieGlobals.BUILD)
      dp.infopacket["name"] = Settings.Settings["Name"]
      dp.infopacket["type"] = int(rpieGlobals.NODE_TYPE_ID_RPI_EASY_STD)
      # CAPABILITIES byte: first bit 1 if able to send, second bit 1 if able to receive
      dp.infopacket["cap"] = self.modefunc()
      dp.encode(1)
#      data = array.array('B',[0]*64)
      data = list(base64.b64encode(dp.buffer[offset:]))
#      print(offset,data[offset:])
      callback(Characteristic.RESULT_SUCCESS, data)

class ReceiverCharacteristic(Characteristic):
    def __init__(self, updateValueCallback=None):
        Characteristic.__init__(self, {
            'uuid': BLE_RECEIVER_CHAR,
            'properties': ['write'],
            'descriptors': [
                    Descriptor({
                        "uuid" : '2901',
                        "value" : array.array('B',[80, 50, 80, 32, 109, 101, 115, 115, 97, 103, 101, 32, 113, 117, 101, 117, 101])}
                    )],
            'value': None
          })
        self._value = []
        self._updateValueCallback = updateValueCallback

    def onWriteRequest(self, data, offset, withoutResponse, callback):
        self._value = data
#        print('EchoCharacteristic - %s - onWriteRequest: value = %s' % (self['uuid'], [hex(c) for c in self._value]))
        if self._updateValueCallback:
            self._updateValueCallback(self._value)
        callback(Characteristic.RESULT_SUCCESS)

class RPIBLEService(BlenoPrimaryService):
    def __init__(self,s_updateValueCallback=None,nameval="",addrfunc=None,mfunc=None):
        BlenoPrimaryService.__init__(self, {
          'uuid': BLE_SERVICE_ID,
          'characteristics': [
              ReceiverCharacteristic(updateValueCallback=s_updateValueCallback),
              InfoCharacteristic(addressfunc=addrfunc,modefunc=mfunc)
          ]})

class BLEServer():
    def __init__(self, name="",receiverfunc=None,pmodefunc=None):
        self.receiverfunc=receiverfunc
        self.name    = name
        self.bleno   = None
        self.service = None
        self.initialized = False
        self.address = ""
        self.modefunc=pmodefunc

    def start(self):
        self.address = ""
        self.bleno = Bleno()
        self.service = RPIBLEService(self.receiverfunc,self.name,self.getaddress,self.modefunc)
        self.bleno.on('stateChange', self.onStateChange)
        self.bleno.on('advertisingStart', self.onAdvertisingStart)
        self.bleno.start()
        self.initialized = True

    def getrssi(self):
        return self.bleno.rssi

    def getaddress(self):
        if self.bleno is None:
         self.bleno = Bleno()
        if self.bleno is not None:
         if self.address == "":
          try:
            if self.bleno.address is not None and self.bleno.address != "" and self.bleno.address != "unknown":
             self.address = self.bleno.address
            else:
             self.bleno._bindings._hci.init()
             self.bleno._bindings._hci.readBdAddr() # force read BT address cmd
             time.sleep(0.5)
             self.address = self.bleno._bindings._hci.address
            aa = self.address.split(":")
            self.address = ""
            for l in reversed(range(len(aa))):
             self.address += aa[l]+":"
            self.address = self.address[:-1]
          except Exception as e:
            print(e)
         return self.address
        else:
         return ""

    def onStateChange(self,state):
#      print('on -> stateChange: ' + state);
      if (state == 'poweredOn'):
       self.bleno.startAdvertising(self.name, [BLE_SERVICE_ID]);
       misc.addLog(rpieGlobals.LOG_LEVEL_INFO,"BLE Service started at: "+str(self.getaddress()))
      else:
       self.bleno.stopAdvertising();

    def onAdvertisingStart(self,error):
#     print('on -> advertisingStart: ' + ('error ' + error if error else 'success'));
     if not error:
        def on_setServiceError(error):
          if error:
             misc.addLog(rpieGlobals.LOG_LEVEL_ERROR,"BLE service start: "+str(error))
#            print('setServices: %s'  % ('error ' + error if error else 'success'))
        self.bleno.setServices([
            self.service
        ], on_setServiceError)
     else:
       misc.addLog(rpieGlobals.LOG_LEVEL_ERROR,"BLE advertising result: "+str(error))

    def stop(self):
     self.bleno.stopAdvertising()
     self.bleno.disconnect()

class BLEClient():
    def __init__(self,address="",duty=0):
        self.address=address
        self.tx_active = False
        self.tx_start  = 0
        self.tx_end    = 0
        self.nexttransmit = 0
        self.duty=duty
        self.service = None
        self.periph  = None

    def setdestination(self,address):
        self.address=address.lower().strip() # only lower case address is supported by BluePy!!

    def connect(self):
       if self.tx_active or self.address=="":
        return False
       self.tx_start = millis()
       if self.tx_start<self.nexttransmit:
        print("Next possible transmit ",self.nexttransmit)
        return False
       self.tx_active = True
       try:
        self.periph = Peripheral(self.address)
       except Exception as e: 
#        print("connect error",e)
        self.tx_active = False
        self.tx_end = millis()
        return False
       try:
        self.service = self.periph.getServiceByUUID(BLE_SERVICE_ID)
       except Exception as e:
#        print("service error ",e)
        self.tx_active = False
        self.tx_end = millis()
        return False
       return True

    def writepayload(self,apayload):
       try:
        ch = self.service.getCharacteristics(BLE_RECEIVER_CHAR)[0]
#        print(ch,apayload,len(apayload))
        ch.write(base64.b64encode(apayload), True)
       except Exception as e:
#        print("write error ",e)
        return False
       return True

    def readpayload(self):
       payload = []
       try:
        ch = self.service.getCharacteristics(BLE_INFO_CHAR)[0]
        payload = ch.read()
        payload = base64.b64decode(payload.decode("utf-8"))
       except Exception as e:
#        print("read error ",e)
        pass
       return payload

    def disconnect(self):
       try:
        self.periph.disconnect()
       except:
        return False
       self.tx_active = False
       self.tx_end = millis()
       if self.duty>0:
        self.nexttransmit = ((self.tx_end-self.tx_start)*self.duty)+self.tx_end
       return True

    def send(self,spayload):
       if self.connect():
        self.writepayload(spayload)
        self.disconnect()

# Helper functions

def getunitordfromnum(unitno):
  for n in range(len(Settings.p2plist)):
   if int(Settings.p2plist[n]["unitno"]) == int(unitno) and str(Settings.p2plist[n]["protocol"]) == "BLE":
    return n
  return -1