class EventSpiSensor(SpiSensorConf, EventDrivenIo, SensorException):
"""This class is for the event driven sensors"""
def __init__(self, device=0, bus=0):
super().__init__(device, bus)
self.event_handlers = EventHandler()
def add_event_handler(self, event, handler):
# This method is for add event handler.
# eventを指定して、そのイベントにメソッドを追加する
self.event_handlers.add(event, handler)
def run(self):
self.sensor_thread = threading.Thread(target=self.sensor_method, args())
def sensor_thread(self, user_method):
while True:
# ポーリングで特定のレジスタを読んでくる
# センサーで読み取ってくる値 = イベントの値
# ここでの問題は計算式に入れる前の値をセンサーはとってくるので、イベントをしっかり設定する必要あり
assert read_method is not None, 'Please gave sensing method.'
self.sensor_value = sensor_method() # ユーザ定義のセンシングメソッドを実行
if self.sensor_value in self.event_handlers.events.keys():
# keyの中に取得してきた値があれば、そのキーに対応したメソッドをよぶ
self.event_handlers(self.sensor_value)
else:
# それ以外の場合otherをキーとするメソッドを呼ぶ
self.event_handlers('other')
def read(self, addr, byte=1):
return self.spi.readByte(addr, byte)
def write(self, addr, byte=1, values, mode='byte'):
if mode == 'byte':
self.spi.writeBytes(addr, values)
elif mode == 'xfer'
return self.xfer2(values)
def remove_event_handler(self, event):
self.event_handlers.remove()
def user_method(self):
# 値を取得するセンシングメソッドを記述
pass
def exception_method(self):
self.event_handlers.remove()
self.spi.close()
class EventSmbusSensor(SmbusSensorConf, EventDrivenIo, SensorException):
"""This class is for the event driven sensors"""
def __init__(self, address=None, bus=1):
assert address is not None, 'Please select address.'
super().__init__(address, bus)
self.event_handlers = EventHandler()
def add_event_handler(self, event, handler):
# eventを指定して、そのイベントにメソッドを追加する
self.event_handlers.add(event, handler)
def run(self):
self.sensor_thread = threading.Thread(target=self.sensor_method,
args())
def sensor_method(self, user_method):
# センシングメソッドを与える, 与えたメソッドを呼ぶ得られた値がイベントとしてあるか調べる
while True:
# ポーリングで特定のレジスタを読んでくる
# センサーで読み取ってくる値 = イベントの値
assert read_method is not None, 'Please gave sensing method.'
self.sensor_value = sensor_method() # ユーザ定義のセンシングメソッドを実行
if self.sensor_value in event_handler.events.keys():
# keyの中に取得してきた値があれば、そのキーに対応したメソッドをよぶ
self.event_handlers(self.sensor_value)
else:
# それ以外の場合otherをキーとするメソッドを呼ぶ
self.event_handlers('other')
def read(self, mode='byte', cmd=None, *blocks):
if mode == 'byte':
return self.i2c.read_byte(self.address)
elif mode == 'byte' and cmd != None:
return self.i2c.read_byte_data(self.address, cmd)
elif mode == 'block' and cmd != None:
return self.i2c.read_block_data(self.address, cmd, blocks[0])
else:
print('Not Supported data.')
return False
def write(value, mode='byte', cmd=None):
if mode == 'byte':
self.i2c.write_byte(self.address, value)
elif mode == 'byte' and cmd != None:
self.i2c.write_byte_data(self.address, cmd, value)
elif mode == 'word' and cmd != None:
self.i2c.write_word_data(self.address, cmd, value)
elif mode == 'process' and cmd != None:
return self.i2c.process_call(self.address, cmd, value)
else:
return False
def remove_event_handler(self, event):
self.event_handlers.remove()
def user_method(self):
# 値を取得するセンシングメソッドを記述
pass
def exception_method(self):
self.event_handlers.remove()
class MMCC:
""" Simulation object tasked with conducting the MMCC system
Params:
- total_servers :: The number of servers that can handle clients at
any one instance.
- total_arrival :: The total number of clients that can be handled
within the simulation.
"""
def __init__(self, total_servers, total_arrival):
""" Initialise the values for the MMCC """
self.total_servers = total_servers
self.total_arrival = total_arrival
def run(self):
""" Begin the simulation of a MMCC system. Process the information until
termination criteria is meet.
"""
# Initialise the beginning parameters of the simulation
servers = Servers(self.total_servers) # Set up server handler
self.event_handler = EventHandler() # Set up the event handler
start_event = Event("arrival", 0) # Construct the first event object
start_event.departure_time -= start_event.arrival_time # Reset times
start_event.arrival_time = 0 # Reset times
self.event_handler.add(start_event) # Create the first event
# Begin iteration of events, record arrivals for checking
self.count_arrival = 0
while self.count_arrival < self.total_arrival:
# Collect next event from the event handler
current_event = self.event_handler.next()
# Update simulation time
self.sim_time = current_event.time()
if current_event.type == "arrival":
# Create new arrival event
self.event_handler.add(Event('arrival', current_event.time()))
# Record number of arrivals
self.count_arrival += 1
# Check if any server is available
if not servers.is_free():
self.event_handler.block(current_event)
continue
# Begin serving the client.
current_event.served_by(servers.allocate())
# All event handler to manage departure
self.event_handler.add(current_event)
else:
# Departure event received
servers.deallocate(current_event.served_by())
self.event_handler.depart(current_event)
def block_probability(self):
""" Calculate the blocking probability for the previous simulation run.
Returns:
- float :: Probability of blocking
"""
return len(self.event_handler.blocked) / self.count_arrival
def server_utilization(self):
""" Calculate the server utilisation for the previous simulation run.
Returns:
- float :: Server utilisation value
"""
return sum([e.service_time() for e in self.event_handler.departed
]) / (self.sim_time * self.total_servers)
def report(self):
""" Display the results of the simulation is a readible fashion. """
print("\tTotal servers:", self.total_servers)
print("\tEvents handled:")
print("\t\tArrival:", self.count_arrival)
print("\t\tDeparture:", len(self.event_handler.departed))
print("\t\tBlocked:", len(self.event_handler.blocked))
incomplete = self.count_arrival - (len(self.event_handler.departed) +
len(self.event_handler.blocked))
print("\t\tIncomplete events:", incomplete)
print("\tBlocking rate:", self.block_probability())
print("\tServer utilization:", round(self.server_utilization(), 4))
return
