def send(self):
for i in range(len(self.ports)):
if len(self.port_information[i]) == 0:
self.port_origin[i] = ""
self.port_mac[i] = ""
self.state[i] = 0
continue
elif self.state[i] == 1:
continue
empty = 0
sent = False
find = False
for j in range(len(self.ports)):
if self.port_mac[i] in self.macs[j]:
find = True
wire = self.consultDevice.fire(
self.consultDeviceMap.fire(
get_device_port(self.ports[j])[0]))
if wire is None:
self.macs[j].remove(self.port_mac[i])
continue
if self.cable_send[j]:
if wire.red is None:
wire.red = self.port_information[i][0]
sent = True
else:
if wire.blue is None:
wire.blue = self.port_information[i][0]
sent = True
if sent:
self.resend_bit(wire, i, j)
if not find:
for j in range(len(self.ports)):
if self.ports[j] == "" or i == j:
empty += 1
continue
wire = self.consultDevice.fire(
self.consultDeviceMap.fire(
get_device_port(self.ports[j])[0]))
if wire is None:
continue
if self.cable_send[j]:
if wire.red is None:
wire.red = self.port_information[i][0]
sent = True
else:
if wire.blue is None:
wire.blue = self.port_information[i][0]
sent = True
if sent:
self.resend_bit(wire, i, j)
if sent or empty == len(self.ports):
self.time_sending[i] -= 1
if (empty == len(self.ports)
or sent) and self.time_sending[i] == 0:
self.port_information[i].popleft()
self.time_sending[i] = self.askSignalTime.fire()
def _send(self, bit):
if self.ports[0] is "":
self.report_send_ok(bit)
return True
wire = self.consultDevice.fire(
self.consultDeviceMap.fire(get_device_port(self.ports[0])[0]))
if self.cable_send[0]:
wire.red = bit
else:
wire.blue = bit
wd = self.consultDevice.fire(
self.consultDeviceMap.fire(
get_device_port(wire.ports[1])[0] if wire.ports[0] ==
self.name + "_" +
str(1) else get_device_port(wire.ports[0])[0]))
if isinstance(wd, Resender):
wdp = wire.name + "_" + str(2) if wire.ports[
0] == self.name + "_" + str(1) else wire.name + "_" + str(1)
if wd.resend(bit, wdp) is "COLLISION":
self.report_collision(bit)
return False
else:
wd.resend(bit, wdp, True)
wd.read_value[wd.ports.index(wdp)] = bit
elif type(wd) is Host:
wd.read_value[0] = bit
self.report_send_ok(bit)
return True
def find_root(self, port_name):
device_name,port = get_device_port(port_name)
port=int(port)-1
component = Storage_Device_Singleton.instance().get_device_with(device_name)
while True:
if isinstance(component,Host):
return component
elif isinstance(component,Wire):
port_name=component.ports[1] if port==0 else component.ports[0]
else:
port_name=component.internal_port_connection[port]
device_name,port=get_device_port(port_name)
port=int(port)-1
component = Storage_Device_Singleton.instance().get_device_with(device_name)
def can_send(self, i):
for j in range(len(self.ports)):
if self.ports[j] == "" or i == j:
continue
wire = self.consultDevice.fire(
self.consultDeviceMap.fire(get_device_port(self.ports[j])[0]))
if self.cable_send[j]:
if not wire.red is None:
return False
else:
if not wire.blue is None:
return False
return True
def resend_bit(self, wire, i, j):
bit = self.port_information[i][0]
wd = self.consultDevice.fire(
self.consultDeviceMap.fire(
get_device_port(wire.ports[1])[0] if wire.ports[0] ==
self.name + "_" +
str(j + 1) else get_device_port(wire.ports[0])[0]))
# si el dispositivo es un resender entonces dile que reenvie
if isinstance(wd, Resender):
# dame el puerto del cable que esta conectado al Resender
wdp = wire.name + "_" + str(2) if wire.ports[
0] == self.name + "_" + str(j +
1) else wire.name + "_" + str(1)
# revisa si el resender da colision
if wd.resend(bit, wdp) is "COLLISION":
self.report_collision()
return "COLLISION"
else:
# si no hubo colision entonces pon el valor
wd.resend(bit, wdp, True)
wd.read_value[wd.ports.index(wdp)] = bit
elif type(wd) is Host:
wd.read_value[0] = bit
def execute(self, instruction):
index_1=Storage_Device_Singleton.instance().get_index(instruction.device_1)
device = Storage_Device_Singleton.instance().get_device_with(instruction.device_1)
if device.ports[instruction.port_1]=='':
print('Unconnected port. Ignored action')
else:
name_wire, port_wire = get_device_port(device.ports[instruction.port_1])
port_wire = int(port_wire) - 1
wire = Storage_Device_Singleton.instance().get_device_with(name_wire)
name_2, port_2 = get_device_port(wire.ports[1-port_wire])
port_2 = int(port_2) - 1
device.ports[instruction.port_1] = ""
device_2 = Storage_Device_Singleton.instance().get_device_with(name_2)
device_2.ports[port_2] = ""
if isinstance(device, Switch):
device.clean_port(port_wire)
if isinstance(device_2, Switch):
device_2.clean_port(port_2)
return True
def resend(self, bit, port_name, write=False):
if write:
self.read_value[self.ports.index(port_name)] = bit
# lista de puertos por donde reenvio
list_port = []
# puerto del hub por donde recibio la info
from_value = self.name + "_" + str(self.ports.index(port_name) + 1)
# si hay que escribir el valor en el txt
if write:
self.report_receive_ok(bit, from_value)
# por cada puerto reenvia
for i in range(len(self.ports)):
# toma el valor del puerto (esto es el puerto de un cable que esta conectado a ti)
port = self.ports[i]
# si el puerto es vacio o el puerto es por el mismo que recibes
if port == "" or port == port_name:
continue
# dame el cable que esta conectado en el puerto
wire = self.consultDevice.fire(
self.consultDeviceMap.fire(get_device_port(port)[0]))
# si envias por el rojo
if self.cable_send[i]:
# si el rojo no esta vacio entonces hay colision
if not wire.red is None:
self.report_collision()
return "COLLISION"
# si hay que escribir entonces pon el valor en el cable rojo
if write:
wire.red = bit
else:
# revisa si hay colision en el azul
if not wire.blue is None:
self.report_collision()
return "COLLISION"
# si hay que escribir entonces pon el valor en el cable azul
if write:
wire.blue = bit
# agrega este indice a la lista
list_port.append(i)
# dispositivo con el que esta conectado a traves del cable
wd = self.consultDevice.fire(
self.consultDeviceMap.fire(
get_device_port(wire.ports[1])[0] if wire.ports[0] ==
self.name + "_" +
str(i + 1) else get_device_port(wire.ports[0])[0]))
# si el dispositivo es un resender entonces dile que reenvie
if isinstance(wd, Resender):
# dame el puerto del cable que esta conectado al Resender
wdp = wire.name + "_" + str(
2) if wire.ports[0] == self.name + "_" + str(
i + 1) else wire.name + "_" + str(1)
# revisa si el resender da colision
if wd.resend(bit, wdp) is "COLLISION":
self.report_collision()
return "COLLISION"
else:
# si no hubo colision entonces pon el valor
wd.resend(bit, wdp, True)
wd.read_value[wd.ports.index(wdp)] = bit
elif type(wd) is Host:
wd.read_value[0] = bit
# reporta que renviaste si tienes que escribir
if write:
self.report_resend(bit, from_value)
return list_port
def read(self, report):
if self.ports[0] == "":
return
wire = self.consultDevice.fire(
self.consultDeviceMap.fire(get_device_port(self.ports[0])[0]))
#rd = wire.red if not self.cable_send[0] else wire.blue
rd = self.read_value[0]
if report:
self.report_receive_ok(rd, f"{self.name}_1")
if self.receiving == 0 and rd == INIT_FRAME_BIT:
self.transition_receive()
elif self.receiving == 1:
if rd == None:
return
elif rd == INIT_FRAME_BIT:
self.clean_receive()
self.receiving = 1
return
if self.receive_time == 0:
self.receive_MAC_1 += str(rd)
if self.check_size(self.receive_MAC_1, 16):
if self.receive_MAC_1 == self.MAC or self.receive_MAC_1 == "1" * 16:
self.transition_receive()
else:
self.receiving = 0
self.clean_receive()
elif self.receiving == 2:
if rd == None:
return
elif rd == INIT_FRAME_BIT:
self.clean_receive()
self.receiving = 1
return
if self.receive_time == 0:
self.receive_MAC_2 += str(rd)
if self.check_size(self.receive_MAC_2, 16):
self.transition_receive()
elif self.receiving == 3:
if rd == None:
return
elif rd == INIT_FRAME_BIT:
self.clean_receive()
self.receiving = 1
return
if self.receive_time == 0:
self.receive_size += str(rd)
if self.check_size(self.receive_size, 8):
self.transition_receive()
elif self.receiving == 4:
if rd == None:
return
elif rd == INIT_FRAME_BIT:
self.clean_receive()
self.receiving = 1
return
if self.receive_time == 0:
self.receive_off += str(rd)
if self.check_size(self.receive_off, 8):
self.transition_receive()
elif self.receiving == 5:
if rd == None:
return
elif rd == INIT_FRAME_BIT:
self.clean_receive()
self.receiving = 1
return
if self.receive_time == 0:
self.receive_data += str(rd)
if self.check_size(self.receive_data,
8 * int(self.receive_size, 2)):
self.transition_receive()
elif self.receiving == 6:
if rd == None:
return
elif rd == INIT_FRAME_BIT:
self.clean_receive()
self.receiving = 1
return
if self.receive_time == 0:
self.receive_detect += str(rd)
if self.check_size(self.receive_detect,
8 * int(self.receive_off, 2)):
detect = str()
if not self.detection.check("".join([
INIT_FRAME_BIT, self.receive_MAC_1,
self.receive_MAC_2, self.receive_size,
self.receive_off, self.receive_data,
self.receive_detect
])):
detect += "ERROR"
self.data_logger.write(
f"{bin_hex(self.receive_MAC_2)} {bin_hex(self.receive_data)} {detect}"
)
self.clean_receive()
if self.receive_time < self.askSignalTime.fire() - 1:
self.receive_time += 1
else:
self.receive_time = 0