# TDMA + EASMP final without Metrics

import threading
import time
from loraphy import LoRaPHY
from metrics import Metrics
class SDNController:
def __init__(self, cluster_heads, members, N_CLUSTERS, M_MEMBERS_PER_CLUSTER):
self.cluster_heads = cluster_heads
self.members = members
self.N_CLUSTERS = N_CLUSTERS
self.M_MEMBERS_PER_CLUSTER = M_MEMBERS_PER_CLUSTER
self.NumslotsMem = M_MEMBERS_PER_CLUSTER
self.NumslotsCH = N_CLUSTERS
self.tdma_schedule = {} # TDMA schedule dictionary {node_id: time_slot}
self.EASMP_schedule = {} # EASMP schedule dictionary {node_id: time_slot}
self.round = 1
self.loramodule = LoRaPHY()

self.metrics = Metrics()

self.usedMACAddress = "TDMA" # TDMA OR EASMP

# Define TDMA schedule initially

if (self.usedMACAddress == "TDMA"):
self.define_tdma_schedule()

# Start scheduling thread

self.schedule_thread = threading.Thread(target=self.schedule_transmissions)
self.schedule_thread.daemon = True
self.schedule_thread.start()

def define_tdma_schedule(self):
# Assign unique IDs to cluster heads and members
for i, cluster_head in enumerate(self.cluster_heads):
cluster_head.id = f"clusterHead_{i+1}"

memberCountTDMA = 0
CHnumber = 1
for i, member in enumerate(self.members):
member.id = f"member_{(memberCountTDMA) + 1}_CH{CHnumber}"

if(memberCountTDMA == (self.M_MEMBERS_PER_CLUSTER - 1) ):
memberCountTDMA = 0
CHnumber = CHnumber + 1
else:
memberCountTDMA = memberCountTDMA + 1

# Define TDMA schedule based on number of nodes and time slots

for i, node in enumerate(self.members):
self.tdma_schedule[node.id] = (i % self.M_MEMBERS_PER_CLUSTER) + 1

for i, node in enumerate(self.cluster_heads):

self.tdma_schedule[node.id] = (i % self.N_CLUSTERS) + 1 +
self.M_MEMBERS_PER_CLUSTER

print(self.tdma_schedule)
 def define_EASMP_schedule(self):

# Assign unique IDs to cluster heads and members

for i, cluster_head in enumerate(self.cluster_heads):

cluster_head.id = f"clusterHead_{i+1}"

memberCountTDMA = 0
CHnumber = 1
for i, member in enumerate(self.members):
member.id = f"member_{(memberCountTDMA) + 1}_CH{CHnumber}"

if(memberCountTDMA == (self.M_MEMBERS_PER_CLUSTER - 1) ):
memberCountTDMA = 0
CHnumber = CHnumber + 1
else:
memberCountTDMA = memberCountTDMA + 1

########################### Begin of the State collection Phase

###########################
miniSlots = (self.N_CLUSTERS * self.M_MEMBERS_PER_CLUSTER) # the number of
minislots for members
sizeRM = 6 + 6 # src MAC + Dist MAC
self.MinislotTime = self.loramodule.calculate_lora_airtime(sizeRM)/1000 #
for seconds
time.sleep(miniSlots * self.MinislotTime) # This is the time of the
minislots for members to send the RTSF

# Define EASMP schedule based on time slots and the availibility of data in
each member
chMembersHaveData = [False] * self.N_CLUSTERS
indexChMembersHaveData = 0
MaxNumberMembers = 0
memberCount = 0
slotNumber = 0
for i, node in enumerate(self.members):

if(node.HasDataToSend()):
slotNumber = slotNumber + 1
self.EASMP_schedule[node.id] = slotNumber
print("###################: slot: ", slotNumber, " ", node.id )
chMembersHaveData[indexChMembersHaveData] = True
if(slotNumber > MaxNumberMembers):
MaxNumberMembers = slotNumber

else:
print(" ############ Does not have data", slotNumber)
if(memberCount == (self.M_MEMBERS_PER_CLUSTER - 1) ):
memberCount = 0
slotNumber = 0
indexChMembersHaveData = indexChMembersHaveData + 1
else:
memberCount = memberCount + 1

self.NumslotsMem = MaxNumberMembers
slotsCHs= MaxNumberMembers + 1
 print("::::::::: ch have data :::::::: ", chMembersHaveData )
for i, node in enumerate(self.cluster_heads):
if(chMembersHaveData[i]):
self.EASMP_schedule[node.id] = slotsCHs
slotsCHs = slotsCHs + 1

sizeRSM = (6 + 2 ) * self.N_CLUSTERS * (self.M_MEMBERS_PER_CLUSTER + 1) #

SDN Scheduling Message
self.MinislotTime = self.loramodule.calculate_lora_airtime(sizeRSM)/1000 #
for second
time.sleep(self.MinislotTime) # This is the time that the SDN controller
to send the RSM message

############################ End of the State collection Phase

############################

print("EASMP_schedule 2:", self.EASMP_schedule)

def schedule_transmissions(self):
if self.usedMACAddress == "EASMP":
self.EASMP_schedule = {}
self.define_EASMP_schedule()

BeginTime = time.time()
current_time_slot = 1

while True:

if(current_time_slot >self.NumslotsMem):
DataSize = (4 * 2) * 1 # bytes # 4 bytes for tempurature and 4
for humidity and 1 is the aggregated data
slotTimeUsed =
self.loramodule.calculate_lora_airtime(DataSize)/1000 # for second
else:
DataSize = 4 * 2 # bytes # 4 bytes for tempurature and 4 for
humidity
slotTimeUsed =
self.loramodule.calculate_lora_airtime(DataSize)/1000 # for second

timeNow = time.time()

if( (timeNow < (BeginTime + slotTimeUsed)) and (timeNow >= BeginTime )

):
current_time_slot = current_time_slot
timeNow = time.time()
else:
timeNow = time.time()
BeginTime = timeNow

current_time_slot = current_time_slot + 1

if(current_time_slot > (self.NumslotsMem + self.NumslotsCH) ):

time.sleep(10/1000)
if(self.usedMACAddress == "EASMP"):
self.EASMP_schedule = {}
 self.define_EASMP_schedule()

timeNow = time.time()
BeginTime = timeNow
current_time_slot = 1
energy_consumption = self.metrics.calculate_energy_consumption()
data_rate = self.metrics.calculate_data_rate()
delay = self.metrics.calculate_delay()

# Print or log the calculated metrics

print("Energy Consumption:", energy_consumption)
print("Data Rate:", data_rate)
print("Delay:", delay)

# Optionally, clear the metrics list after displaying them

self.metrics.clear_metrics()
# Delay between slots
time.sleep(0.2)

#print("Corrunt Time Slot: ", current_time_slot)

if(self.usedMACAddress == "EASMP"):
nodes_to_transmit = [node for node, time_slot in
self.EASMP_schedule.items() if time_slot == (current_time_slot) ]
else:
nodes_to_transmit = [node for node, time_slot in
self.tdma_schedule.items() if time_slot == (current_time_slot) ]
#print(" Node to transmitt: ", nodes_to_transmit )

# Transmit data for each node

for node in nodes_to_transmit:
#print("node: ", node)
for Mnode in self.members:
if (str(Mnode.GetID()) == node):
#print("I am in")
Mnode.SDNClient()
for CHnode in self.cluster_heads:
if (str(CHnode.GetID()) == node):
#print("I am in")
CHnode.SDNClient()

µµµµµµµµµµµµµµµµ

class Metrics:
def __init__(self,lora_phy):

self.lora_phy = lora_phy
self.energy_consumption_list = []
self.data_rate_list = []
self.delay_list = []
 def calculate_energy_consumption(self):
airtime = self.lora_phy.calculate_lora_airtime(self.payload_size)
tx_power = self.lora_phy.calculate_transmission_power(self.transmit_power,
self.distance)
rx_power = self.lora_phy.calculate_reception_power(tx_power,
self.transmit_power, self.distance)
energy_consumption =
self.lora_phy.calculate_transmit_power_consumption(airtime, tx_power) + \

self.lora_phy.calculate_receive_power_consumption(airtime, rx_power) + \

self.lora_phy.calculate_sleep_power_consumption(self.sleep_time) + \

self.lora_phy.calculate_awake_idle_power_consumption(self.awake_time)
self.energy_consumption_list.append(energy_consumption)
return energy_consumption

def calculate_data_rate(self):
bits_per_symbol = 2 ** self.lora_phy.spreading_factor
airtime = self.lora_phy.calculate_lora_airtime(self.payload_size)
data_rate = (self.payload_size * 8) / (airtime * bits_per_symbol) #
Assuming payload_size is in bytes
self.data_rate_list.append(data_rate)
return data_rate

def calculate_delay(self):
airtime = self.lora_phy.calculate_lora_airtime(self.payload_size)
delay = airtime
self.delay_list.append(delay)
return delay

def display_metrics(self):
if self.energy_consumption_list:
print("Energy Consumption List:", self.energy_consumption_list)
if self.data_rate_list:
print("Data Rate List:", self.data_rate_list)
if self.delay_list:
print("Delay List:", self.delay_list)

def clear_metrics(self):
self.energy_consumption_list = []
self.data_rate_list = []
self.delay_list = []
µµµµµµµµµµµµµµµµµµµ
from cluster_head import ClusterHead
from member import Member
from data_center import DataCenter
from metrics import Metrics
from sdn_controller import SDNController

# Define parameters
N_CLUSTERS = 4 # Number of clusters
M_MEMBERS_PER_CLUSTER = 1 # Number of members per cluster

Distance = 1000 # 1km

# Create cluster heads, members, data center, and SDN controller instances
cluster_heads = [ClusterHead(f"clusterHead_{i+1}",i+1,M_MEMBERS_PER_CLUSTER,
Distance) for i in range(N_CLUSTERS)]
members = []
for i in range(N_CLUSTERS):
new_members = [Member(f"member_{j+1}_CH{i+1}", i+1, Distance) for j in
range( M_MEMBERS_PER_CLUSTER)]
members = members + new_members

#members = [Member(f"member_{i+1}") for i in range(N_CLUSTERS *

M_MEMBERS_PER_CLUSTER)]
data_center = DataCenter(N_CLUSTERS, Distance)
# Start data center
data_center.start()

sdn_controller = SDNController(cluster_heads, members, N_CLUSTERS,

M_MEMBERS_PER_CLUSTER )

try:
while True:
pass # Keep main thread alive
except KeyboardInterrupt:
print("Exiting...")
sdn_controller.metrics.display_metrics()