def start_monitoring_local(self):
# monitoring lokal in thread starten
if self.monitor is None:
self.monitor = Monitoring()
self.monitor.start()
return True
else:
return False
def startMon(self):
print('Starting Mon')
self.monitor = Monitoring(self.mon_controller, '6666', self.exp_path,
self.iot, self.edge, self.tcpdump_if,
self.tcpdump_port, self.receiver)
self.monitor.init()
self.monitor.set_consumer_pid(self.consumer_PID)
self.monitor.start_components()
self.monitor.start_monitoring()
def run(self, gen: Generator):
#print("********************* %s ********************\n" % (gen,))
for ct in self.controllers:
ct.setSLA(self.sla)
m = Monitoring(self.window)
ct.setMonitoring(m)
a = Application(self.sla)
s = Simulation(self.horizon, a, gen, m, ct)
# print(ct)
s.run()
self.simulations.append(s)
ct.reset()
def foodSense():
print('Starting Food Sense')
# Begin initializing necessary components)
fb = Firebase()
detect = Detect(fb)
monitor = Monitoring(fb)
scale = Scale()
# Set scale calibration
scale.setReferenceUnit(-25.725)
scale.reset()
scale.tare()
### START DEBUG ###
### END DEBUG ###
### MAIN LOOP ###
while True:
while monitor.powerOn:
print('Power is on')
time.sleep(1)
while monitor.doorClosed():
print('Door is closed')
monitor.checkTemp()
time.sleep(1)
if monitor.doorOpen():
print('Door was opened')
monitor.startDoorTimer()
while monitor.doorOpen():
print('Waiting for door to close')
monitor.checkDoorTimer()
monitor.checkTemp()
time.sleep(1)
else:
print('Door was closed')
scale.getWeight()
detect.getImage()
detect.detectItem()
detect.parseResponse(scale.weight)
else:
pass
else:
print('Door must be closed on program startup')
else:
monitor.powerSave()
else:
pass
def main():
# global data
database = Data()
database.debug_flag = False
"""
test from keyboard input
"""
#database.debug_flag = True
# sensor data
data_source = Source(database)
lidar_source_thread = threading.Thread(
target=data_source.lidar_stream_main)
left_cam_source_thread = threading.Thread(
target=data_source.left_cam_stream_main)
right_cam_source_thread = threading.Thread(
target=data_source.right_cam_stream_main)
mid_cam_source_thread = threading.Thread(
target=data_source.mid_cam_stream_main)
lidar_source_thread.start()
left_cam_source_thread.start()
right_cam_source_thread.start()
mid_cam_source_thread.start()
# Subroutines
monitoring = Monitoring(data_source, database)
platform = CarPlatform('COM5', database) # PLEASE CHECK YOUR COMPORT
sign_cam = SignCam(data_source, database)
planner = MotionPlanner(data_source, database)
control = Control(database)
monitoring_thread = threading.Thread(target=monitoring.main)
platform_thread = threading.Thread(target=platform.main)
sign_cam_thread = threading.Thread(target=sign_cam.main)
planner_thread = threading.Thread(target=planner.main)
control_thread = threading.Thread(target=control.main)
monitoring_thread.start()
platform_thread.start()
sign_cam_thread.start()
planner_thread.start()
control_thread.start()
while True:
time.sleep(0.1)
if database.is_all_system_stop():
break
time.sleep(2)
return 0
def run(self, gen: Generator):
#print("********************* %s ********************\n" % (gen,))
for ct in self.controllers:
ct.setSLA(self.sla)
if self.genMonitoring:
m = self.genMonitoring(self.window, self.sla)
else:
m = Monitoring(self.window, self.sla)
ct.setMonitoring(m)
ct.setGenerator(gen)
a = self.app
s = Simulation(self.horizon, a, gen, m, ct)
# print(ct)
s.run()
self.simulations.append(s)
ct.reset()
a.reset()
async def on_start(self):
self.terminate = False
self.SUCCESS = False
self.verbose = False
# Initialization
self.beliefs = WorldModel() # B := B0; Initial Beliefs
self.goals = self.beliefs.current_world_model.goals
self.intentions = self.beliefs.current_world_model.goals # I := I0; Initial Intentions
self.htn_planner = HierarchicalTaskNetworkPlanner(self.beliefs)
self.perception = Perception(self.beliefs)
self.coordination = Coordination(self.beliefs)
self.monitoring = Monitoring()
self.what, self.why, self.how_well, self.what_else, self.why_failed = "", "", "", "", ""
self.plans = []
self.selected_plan = []
self.percept = {}
self.action = ""
self.start_time = datetime.datetime.now()
async def on_start(self):
self.terminate = False
self.SUCCESS = False
self.verbose = False
# Initialization
self.htn_planner = HierarchicalTaskNetworkPlanner()
self.goal = [('transfer_target_object_to_container', 'arm',
'target_object', 'table', 'container')]
self.intentions = self.goal # I := I0; Initial Intentions
self.beliefs = WorldModel() # B := B0; Initial Beliefs
self.monitoring = Monitoring()
self.perception = Perception()
self.coordination = Coordination()
# Disable all 3 coordination switches for testing
self.coordination.control.send_requests = True
self.coordination.control.center_init = False
self.coordination.control.detect_last_position = True
self.what, self.why, self.how_well, self.what_else, self.why_failed = "", "", "", "", ""
self.plans = []
self.start_time = datetime.datetime.now()
from flask import Flask, request
from flask_restful import Resource, Api
from monitoring import Monitoring
app = Flask(__name__)
api = Api(app)
host = 'debuggerbasedmonitoring.appspot.com'
basePath = '/api/v1'
monitoring = Monitoring()
class Breakpoint(Resource):
def get(self, user_id, project_id):
ret, content = monitoring.getBreakpoints(user_id, project_id)
if not ret:
return None, 400
return content, 200
def post(self, user_id, project_id):
if request.is_json:
body = request.get_json()
else:
return None, 409
if 'content' not in body:
return None, 409
content = body['content']
try:
file, line = content.split(':')
async def request():
async with aiohttp.ClientSession() as session:
try:
async with session.get('http://127.0.0.1:80') as response:
return await response.text()
except Exception:
return False
def request_by_count(count: int):
return asyncio.run(asyncio.gather(*[
request() for _ in range(count)
]))
if __name__ == '__main__':
pidfile = sys.argv[1]
request_count = int(sys.argv[2])
monitoring = Monitoring(pidfile)
with ThreadPoolExecutor() as executor:
future = executor.submit(monitoring.measure_resource, .1)
start_time = timer()
result = request_by_count(request_count)
print(f"Latency: {timer() - start_time}")
print(f"Errors: {result.count(False)}")
monitoring.stop()
print(f"Report: {future.result()}")
from monitoring import Monitoring
from records import Records
# name = input("Please Enter name: ")
# weight= int(input("Please Enter your weight in kg: "))
# calories=int(input("Please Enter your burned calory in kcal: "))
M1 = Monitoring("yuxuan", "female", 22, 174, 55, 1778)
M1.new_weight(55)
M1.new_calory(1893)
M1.new_weight(56.4)
M1.new_calory(1993)
M1.new_weight(57.4)
M1.new_calory(1893)
M1.new_weight(58.4)
M1.new_calory(1893)
M1.new_weight(58.4)
M1.weight_calory_plot()
def readdata(self, gpio):
m = Monitoring()
m.run()
m.read(self.ser, gpio)
m.store()
import bottle
import json
import time
from bottle import route, run, request, default_app, template, HTTPError
from docopt import docopt
from engine import ReconcileEngine
from suggest import SuggestEngine
from monitoring import Monitoring
from config import *
reconcile = ReconcileEngine(redis_client)
suggest = SuggestEngine(redis_client)
monitoring = Monitoring(redis_client)
def jsonp(view):
def wrapped(*posargs, **kwargs):
args = {}
# if we access the args via get(),
# we can get encoding errors…
for k in request.forms:
args[k] = getattr(request.forms, k)
for k in request.query:
args[k] = getattr(request.query, k)
callback = args.get('callback')
try:
result = view(args, *posargs, **kwargs)
except (ValueError, AttributeError, KeyError) as e:
result = {
def start_monitoring():
monitoring = Monitoring()
monitoring.call()
from control import Control
from car_platform import CarPlatform
from monitoring import Monitoring
testDT = Data()
"""
test code
특정 미션 번호에서 시작하도록 함
"""
testDT.current_mode = 1
testDS = Source(testDT)
car = CarPlatform('COM5', testDT)
testMP = MotionPlanner(testDS, testDT)
test_control = Control(testDT)
monitor = Monitoring(testDS, testDT)
lidar_source_thread = threading.Thread(target=testDS.lidar_stream_main)
left_cam_source_thread = threading.Thread(
target=testDS.left_cam_stream_main)
right_cam_source_thread = threading.Thread(
target=testDS.right_cam_stream_main)
mid_cam_source_thread = threading.Thread(target=testDS.mid_cam_stream_main)
planner_thread = threading.Thread(target=testMP.main)
control_thread = threading.Thread(target=test_control.main)
car_thread = threading.Thread(target=car.main)
monitoring_thread = threading.Thread(target=monitor.main)
lidar_source_thread.start()
planner_thread.start()
time.sleep(3)
def run(self):
# Set up LED pin
LED = 27
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED, GPIO.OUT)
# Initialize objects
f = Firebase(self.q)
d = Detect(f, self.q)
m = Monitoring(f, self.q)
s = Scale(self.q)
# Set scale calibration
s.setReferenceUnit(-25.725)
s.reset()
s.tare()
self.q.put('Ready')
# Loop until stop event is set
while not self.event.is_set():
# Loop while RPi is on AC power
while m.powerOn:
# Check if stop has been set
if self.event.is_set():
break
# Loop while fridge door is closed
while m.doorClosed():
if not m.powerOn():
break
m.checkTemp()
# Check if stop hsa been set
if self.event.is_set():
break
else:
print('Door was opened')
self.q.put('Door opened')
GPIO.output(LED, True)
m.startDoorTimer()
while m.doorOpen():
print('Waiting for door to close')
m.checkDoorTimer()
m.checkTemp()
else:
print('Door closed')
self.q.put('Door closed')
s.getWeight()
d.getImage()
d.detectItem()
d.parseResponse(s.weight)
s.tare()
GPIO.output(LED, False)
print('Done')
self.q.put('Done')
else:
m.powerSave()
f.close(
) # Firebase app must be closed before we can create another instance
def handler():
device_name = argv[1]
CURRENT_TIME = str(int(time.time() * 1000))
monitoring = Monitoring()
process = monitoring.get_running_process()
dimensions = [{
'Name': 'script',
'Value': process['name']
}, {
'Name': 'device_id',
'Value': device_name
}, {
'Name': 'user',
'Value': process['username']
}, {
'Name': 'process_id',
'Value': str(process['pid'])
}]
common_attributes = {'Dimensions': dimensions, 'Time': CURRENT_TIME}
record = {
'cpu_usage': monitoring.get_cpu_usage_pct(),
'cpu_freq': monitoring.get_cpu_frequency(),
'cpu_temp': monitoring.get_cpu_temp(),
'ram_usage': int(monitoring.get_ram_usage() / 1024 / 1024),
'ram_total': int(monitoring.get_ram_total() / 1024 / 1024),
}
print("\n")
# print(dimensions)
# print(record)
print("\n")
# Output current CPU load as a percentage.
print('System CPU load is {} %'.format(monitoring.get_cpu_usage_pct()))
# Output current CPU frequency in MHz.
print('CPU frequency is {} MHz'.format(monitoring.get_cpu_frequency()))
# Output current CPU temperature in degrees Celsius
print('CPU temperature is {} degC'.format(monitoring.get_cpu_temp()))
# Output current RAM usage in MB
print('RAM usage is {} MB'.format(
int(monitoring.get_ram_usage() / 1024 / 1024)))
# Output total RAM in MB
print('RAM total is {} MB'.format(
int(monitoring.get_ram_total() / 1024 / 1024)))
# Output current RAM usage as a percentage.
print('RAM usage is {} %'.format(monitoring.get_ram_usage_pct()))
session = boto3.Session()
write_client = session.client('timestream-write', region_name='eu-west-1')
response = write_client.write_records(
DatabaseName=DB_NAME,
TableName=TABLE_NAME,
Records=monitoring.get_write_records(),
CommonAttributes=common_attributes)
print(response)
query_client = session.client('timestream-query', region_name='eu-west-1')
query = Query(query_client)
print("\n")
query.run_query_with_multiple_pages(20)
def main():
while True:
print('Init Monitoring')
mevents = Monitoring()
mevents.monitoring_events()
c1 = CTControllerScaleXNode(1, initCores, maxCores, BC=3, DC=15)
c2 = OPTCTRL(monitoringWindow,
init_cores=initCores,
st=0.8,
stime=[1 / stimes[i] for i in range(appsCount)],
maxCores=maxCores)
c2.setName("OPTCTRL")
c2.reset()
runner = Runner(
horizon, [c2, c1],
monitoringWindow,
app,
lambda window, sla: MultiMonitoring(
[Monitoring(monitoringWindow, appsSLA[i]) for i in range(appsCount)]),
name=name)
g = MultiGenerator([SP2, RP2])
runner.run(g)
g = MultiGenerator([RP2, SP2])
runner.run(g)
g = MultiGenerator([SN2, SP2])
runner.run(g)
g = MultiGenerator([SP2, SN2])
runner.run(g)
g = MultiGenerator([SN2, RP2])
runner.run(g)
# flake8: noqa
from flask import Flask, render_template
from monitoring import Monitoring
app = Flask(__name__)
monitor = Monitoring(backend=False)
@app.route('/')
def main_page():
return "Your monitor is started"
def run_webmonitor():
app.run()
if __name__ == "__main__":
run_webmonitor()
horizon = 300
monitoringWindow = 1
ctPeriod = 1
maxCores = 200000
Names=[f'App{i}' for i in range(1, appsCount+1)]
srateAvg=[1.0/stime for stime in stimes]
initCores=[1 for _ in stimes]
app=AppsCluster(appNames=Names,srateAvg=srateAvg,initCores=initCores,isDeterministic=False)
AppsCluster.sla=appsSLA
c1 = CTControllerScaleXNode(1, initCores, maxCores, BCs=3, DCs=15)
c2 = OPTCTRL(monitoringWindow, init_cores=initCores, st=0.8, stime=[1/stimes[i] for i in range(appsCount)],maxCores=maxCores)
c2.setName("OPTCTRL")
c2.reset()
runner = Runner(horizon, [c2], monitoringWindow, app, lambda window, sla: MultiMonitoring([Monitoring(monitoringWindow, appsSLA[i]) for i in range(appsCount)]), name=name)
g = MultiGenerator([RP1, RP1])
runner.run(g)
# g = MultiGenerator([SN1, SN1])
# runner.run(g)
#
# g = MultiGenerator([SP1, SP1])
# runner.run(g)
runner.log()
runner.plot()
def main():
global monitor
monitor = Monitoring()
monitor.start()
app.run(debug=True, use_reloader=False)
