def main(args):
# data = make_circles(100, shuffle=True)[0]
# data = ReadPlyFile('data/bun000.ply').get_data()
data = ReadPlyFile('data/drill_1.6mm_0_cyb.ply').get_data()
# data = ReadPlyFile('data/dragonStandRight_0.ply').get_data()
# print(len(data))
def filter_norm(point):
return np.linalg.norm(point - np.array(data).min(0))
def filter_x(point):
return point[0]
mapper = Mapper(data,
resolution=0.2,
overlap=0.4,
cluster_alg='kmeans',
max_clusters=5,
filter=filter_norm)
graph = mapper.run()
print(graph)
viz = Visualization(graph)
viz.draw(36, 3000)
persistence = Persistence(graph)
persistence.draw()
def __init__(self, logger=None):
self._rf = RF_Sender()
self._logger = logger
if self._logger == None:
self._logger = Logger('Pump', Logger.INFO,
"/home/pi/MVP/logs/obsv.log")
self._persist = Persistence(self._logger)
def test_request(self):
persistence = Persistence('test.db')
now = datetime.utcnow().replace(microsecond=0)
dt0 = now - timedelta(seconds=30)
persistence.store(dt0, 100.0, 100.0, 100.0, 100.0)
service = Service(persistence)
response = service.request(self.start_response)
self.assertEqual(
response.next(),
'data: {"dest": "archive", "items": [], "type": "preload"}\n\n')
self.assertEqual(
response.next(),
'data: {"dest": "recent", "items": [{"dt": "%sZ", "humidity": 100.0, "temperature": 100.0, "moisture": 100.0, "luminence": 100.0}], "type": "preload"}\n\n'
% dt0.isoformat())
dt1 = now
service.enqueue('recent', 'realtime', [{
'dt': dt1,
'moisture': 200.0,
'luminence': 200.0,
'temperature': 200.0,
'humidity': 200.0
}])
self.assertEqual(
response.next(),
'data: {"dest": "recent", "items": [{"dt": "%sZ", "humidity": 200.0, "temperature": 200.0, "moisture": 200.0, "luminence": 200.0}], "type": "realtime"}\n\n'
% dt1.isoformat())
def __init__(self, logger=None):
self._logger = logger
if self._logger == None:
self._logger = Logger('Light', Logger.INFO,
"/home/pi/MVP/logs/obsv.log")
self._logger.debug("Initialize RF Light")
self._rf = RF_Sender(self._logger)
self._persist = Persistence(self._logger)
def add_query():
query_name = request.form.get('query name')
query = request.form.get('query')
Persistence.add_query(query_name, query)
flash("Added query")
return redirect(url_for('display_statistics'))
def __init__(self):
'''Get distances for determining reservoir levels'''
self.res = {'full': full_ec, 'empty': empty_ec, 'timeout': timeout}
self._activity_type = 'Agronomic_Activity'
self._logger = Logger('LogReservoir', Logger.INFO)
self._persist = Persistence(self._logger)
self._logger.detail("Reservoir Initialized")
# flag for testing
self._test = False
def __init__(self, logger=None):
self._logger = logger
if logger == None:
self._logger = Logger("Relay", Logger.INFO)
self._logger.debug("initialize Fan object")
self._relay = Relay(self._logger)
self.fan_relay = FAN_PIN
self._persist = Persistence(self._logger)
# flag for testing
self._test = False
def update_query():
new_name = request.form.get('query name')
new_query = request.form.get('query')
old_name = request.form.get('orig query name')
old_query = request.form.get('orig query')
if old_name != new_name:
Persistence.update_query_name(old_name, new_name)
if old_query != new_query:
Persistence.update_query_query(new_name, new_query)
flash('Updated query')
return redirect(url_for('display_statistics'))
def __init__(self, lvl=Logger.INFO):
"""Record optional sensor data
Args:
lvl: Logging level
Returns:
None
Raises:
None
"""
self._logger = Logger("LogSensor-Extra",
lvl,
file="/home/pi/MVP/logs/obsv.log")
self._activity_type = "Environment_Observation"
self._test = False
self._persist = Persistence(self._logger)
def main():
persistence = Persistence()
env = BitEnvironment()
direct = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0],
[1, 1]]
terminal, step_count, e, success, = False, 0, 0, 0
obes = []
for i in range(0, 80):
obes.append([random.randint(0, 99), random.randint(0, 99)])
env.setObstacle(obes)
while True:
#direction = random.randint(0, 7)
# 包含两个，01方向减法，23上次速度
direction = env.getNextStep()
Position, move = env.step(direction)
env.preDirect = direct[direction]
print("行动否：{} 具体行动方向: {} 当前位置 {}".format(move, direct[direction],
Position))
dist, realDirect = env.distToTarget()
print("距离目标: {} 目标方位: {}".format(dist, realDirect))
if env.judgeCollision() or env.done():
terminal = True
step_count += 1
print("阶段 {} 完成, 总成功: {} 当轮步数: {}".format(e, success, step_count))
env.showimage()
if terminal:
if env.done():
success += 1
print(
"-----------------------------success----------------------------------"
)
elif env.judgeCollision():
print(
"-----------------------------发生碰撞----------------------------------"
)
step_count = 0
e += 1
infoShow = "time {}, episode {} finish, total success: {} step: {}".format(
time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())), e, success,
step_count)
persistence.saveTerminalRecord("GoInBitMap", infoShow)
env.reset([random.randint(0, 99), random.randint(0, 99)])
env.setObstacle(obes)
terminal = False
time.sleep(0.2)
def handler():
"""postfork hanlder, creates global domain object"""
global domain
persistence = Persistence('tve.db')
acquisition = Acquisition('/dev/ttyACM0')
service = Service(persistence)
domain = Domain(persistence, acquisition, service)
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s')
logging.info('Domain object initialized')
class Light(object):
def __init__(self, logger=None):
self._logger = logger
if self._logger == None:
self._logger = Logger('Light', Logger.INFO,
"/home/pi/MVP/logs/obsv.log")
self._logger.debug("Initialize RF Light")
self._rf = RF_Sender(self._logger)
self._persist = Persistence(self._logger)
def __del__(self):
self._rf.cleanup()
def set_on(self, test=False):
"Check state and turn on if needed"
self._rf.set_on(lightPin, )
self.log_state("On", test)
self._logger.debug('Light turned ON')
def set_off(self, test=False):
'''Check state and turn off if needed'''
self._rf.set_off(lightPin)
self.log_state("Off", test)
self._logger.debug('Light turned Off')
def log_state(self, value, test=False):
"""
Create Environment Observation
"""
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
self._persist.save([
'State_Change', '', 'Top', 'Lights', 'State', value, 'Boolean',
'Light', status_qualifier, ''
])
def check(self):
env = Environ(self._logger)
if env._state:
self.set_on(test)
else:
self.set_off(test)
class Pump(object):
def __init__(self, logger=None):
self._rf = RF_Sender()
self._logger = logger
if self._logger == None:
self._logger = Logger('Pump', Logger.INFO,
"/home/pi/MVP/logs/obsv.log")
self._persist = Persistence(self._logger)
def __del__(self):
'''
Don't call GPIO.cleanup() as need to leave pin state as is
'''
pass
def on(self, test=False):
"Check state and turn on if needed"
self._rf.set_on(pumpPin, )
self.log_state("On", test)
self._logger.debug('Pump turned ON')
def off(self, test=False):
'''Check state and turn off if needed'''
self._rf.set_off(pumpPin)
self.log_state("Off", test)
self._logger.debug('Pump turned Off')
def log_state(self, value, test=False):
"""
Create Environment Observation
"""
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
self._persist.save([
'State_Change', '', 'Reservoir', 'Pump', 'State', value, 'Pump',
'state', status_qualifier, ''
])
minR = 0.1e-9
maxR = 50e-9
fileBase = './'
outDir = './'
outFile = open(outDir + 'deformation.dat', 'w')
forceFile = open(outDir + 'force.dat', 'w')
restartFileName = outDir + 'restart.hdf5'
restartFileName = ''
saveFileName = outDir + 'checkpoint.hdf5'
if restartFileName != '':
print 'I am restarting......'
restartFile = Persistence(restartFileName, 'r')
else:
restartFile = None
solidCaseFile = fileBase + 'Gen5_beam_2D.cas'
fluidCaseFile = fileBase + 'fluid_electrode_dielectric.cas'
fluidReader = FluentCase(sys.argv[1])
solidReader = FluentCase(sys.argv[2])
fluidReader.read()
solidReader.read()
fluidMeshes = fluidReader.getMeshList()
fluidMeshesOrig = fluidMeshes
solidMeshes = solidReader.getMeshList()
def saveRestartFile(self, outDir, n):
saveFileName = outDir + 'checkpoint_' + str(n) + '.hdf5'
f = Persistence(saveFileName,'w')
f.saveAttribute('globalCount', self.globalCount)
f.saveAttribute('globalTime', self.globalTime)
ts = self.timeStep
tsN1 = self.poptions.timeStepN1
tsN2 = self.poptions.timeStepN2
f.saveAttribute('timeStep', ts)
f.saveAttribute('timeStepN1', tsN1)
f.saveAttribute('timeStepN2', tsN2)
f.saveFluidMeshes(self.fluidMeshes)
f.saveSolidMeshes(self.solidMeshes)
f.savePlateModel(self.plateFields,self.pmodel,self.solidMeshes)
f.saveElectricModel(self.elecFields,self.emodel,self.fluidMeshes)
f.close()
def saveRestartFile(self, outDir, n):
saveFileName = outDir + 'checkpoint_' + str(n) + '.hdf5'
f = Persistence(saveFileName,'w')
f.saveAttribute('globalCount', self.globalCount)
f.saveAttribute('globalTime', self.globalTime)
ts = self.timeStep
tsN1 = self.poptions.timeStepN1
tsN2 = self.poptions.timeStepN2
f.saveAttribute('timeStep', ts)
f.saveAttribute('timeStepN1', tsN1)
f.saveAttribute('timeStepN2', tsN2)
f.saveFluidMeshes(self.fluidMeshes)
f.saveSolidMeshes(self.solidMeshes)
f.savePlateModel(self.plateFields,self.pmodel,self.solidMeshes)
f.saveElectricModel(self.elecFields,self.emodel,self.fluidMeshes)
f.close()
def select_database(self, name):
Persistence.select_database(self, name)
self.init()
from Pesos import Pesos
from Atributos import Atributos
from Casos import Casos
from Persistence import Persistence
if __name__ == "__main__": # executar uma vez para popular o banco de dados, após seguir os passos do README
dbHandler: Persistence = Persistence()
dbHandler.createSchema()
pesos: Pesos = Pesos("pesos.csv")
atributos: Atributos = Atributos("atributos.csv")
casos: Casos = Casos("casos.csv")
pesos.persist()
atributos.persist()
casos.persist()
print(
"\x1b[1m\x1b[5m\x1b[32mO Banco de dados foi criado com sucesso!!!\x1b[0m"
)
class TestPersistence(unittest.TestCase):
def setUp(self):
self.persistence = Persistence('test.db')
def tearDown(self):
if os.path.exists('test.db'):
os.remove('test.db')
def test_init(self):
self.assertEqual(os.path.exists('test.db'), True)
def test_historical(self):
now = datetime.utcnow().replace(microsecond=0)
dt0 = now - timedelta(seconds=120)
dt1 = now - timedelta(seconds=30)
dt2 = now - timedelta(seconds=15)
self.persistence.store(dt0, 0.1, 0.1, 0.1, 0.1)
self.persistence.store(dt1, 0.2, 0.2, 0.2, 0.2)
self.persistence.store(dt2, 0.3, 0.3, 0.3, 0.3)
result = self.persistence.historical(60)
expected = [{
'dt': dt1,
'moisture': 0.2,
'luminence': 0.2,
'temperature': 0.2,
'humidity': 0.2
}, {
'dt': dt2,
'moisture': 0.3,
'luminence': 0.3,
'temperature': 0.3,
'humidity': 0.3
}]
self.assertEqual(result, expected)
def test_historical_archive(self):
now = datetime.utcnow().replace(minute=0, second=0, microsecond=0)
dt0 = now - timedelta(minutes=80)
dt1 = now - timedelta(minutes=70)
dt2 = now - timedelta(minutes=30)
self.persistence.store(dt0, 0.0, 0.0, 0.0, 0.0)
self.persistence.store(dt1, 0.2, 0.2, 0.2, 0.2)
self.persistence.store(dt2, 0.3, 0.3, 0.3, 0.3)
expected = [
{
'dt': dt1.replace(minute=0),
'moisture': 0.1,
'luminence': 0.1,
'temperature': 0.1,
'humidity': 0.1
},
{
'dt': dt2.replace(minute=0),
'moisture': 0.3,
'luminence': 0.3,
'temperature': 0.3,
'humidity': 0.3
},
]
self.persistence.archive()
result = self.persistence.historical_archive(3)
self.assertEqual(result, expected)
muref= 2.117e-5;
mu_w=0.81;
molecularWeight=39.9;
elif (gas == 'Nitrogen'):
Pr=3.0/4.0;
SpHeatRatio=7.0/5.0;
muref= 1.781e-5;
mu_w=0.74;
molecularWeight=28.0;
print ' Pr= ',Pr,' muref= ',muref
u_init=(2.0*8314.0*T_init/molecularWeight)**0.5
uwall=10.0/u_init;
if restartFileName != "":
restartFile = Persistence(restartFileName,'r')
else:
restartFile = None
# to test quadrature
import fvm.esbgk_atyped_double as esbgk
#facegroups
fgs = meshes[0].getBoundaryFaceGroups()
for fg in fgs:
#print fg.groupType
if fg.id == 4 or fg.id == 6:
fg.groupType = "realwall"
print fg.id," ",fg.groupType
#Quadrature
quad0=esbgk.QuadratureD(10,10,10,5.5,1.0) #cartesian
class Fan(object):
"""Code associated with the exhaust fan"""
ON = 1
OFF = 0
target_temp = 0
def __init__(self, logger=None):
self._logger = logger
if logger == None:
self._logger = Logger("Relay", Logger.INFO)
self._logger.debug("initialize Fan object")
self._relay = Relay(self._logger)
self.fan_relay = FAN_PIN
self._persist = Persistence(self._logger)
# flag for testing
self._test = False
def set(self, state):
"""Set the fan to state
Args:
state: condition from other source
Returns:
None
Raises:
None
"""
self._logger.debug("In set_state")
prior = self._relay.get_state(self.fan_relay)
self._relay.set_state(self.fan_relay, state)
current = self._relay.get_state(self.fan_relay)
if prior != current:
self.log_state(state)
def set_fan_on(self):
"""Turn the fan on
Args:
None
Returns:
None
Raises:
None
"""
self._logger.debug("In set_fan_on")
self.set(ON, test)
def set_fan_off(self):
"""Turn the fan off
Args:
None
Returns:
None
Raises:
None
"""
self._logger.debug("In set_fan_off")
self.set(OFF, test)
def log_state(self, value):
"""Send state change to database
Args:
value: state change (numeric value)
test: flag for testing
Returns:
None
Raises:
None
"""
state = 'Off'
if value > 0:
state = 'On'
status_qualifier = 'Success'
if self._test:
status_qualifier = 'Test'
self._persist.save([
'State_Change', '', 'Side', 'Fan', 'State', state, 'Boolean',
'Fan', status_qualifier, ''
])
self._logger.debug("{}, {:1}, {} {}".format(
"Fan State Change: Value: ", value, " Status Qualifier: ",
status_qualifier))
def getState(self):
return self._relay.get_state(self.fan_relay)
def main():
env = drone_env_heightcontrol(aim=None)
state = env.reset()
state_shape = 4
action_bound = 1
action_dim = 2
e, success, episode_reward, step_count = 0, 0, 0, 0
persistence = Persistence()
if choose == "1":
infoShow = "time {}, start new train, method{}".format(
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),
"DDPG")
persistence.saveTerminalRecord("DDPG", infoShow)
with tf.device("/gpu:0"):
config = tf.ConfigProto(
allow_soft_placement=True
) # tf.ConfigProto()函数用在创建session的时候，用来对session进行参数配置
config.gpu_options.allow_growth = True # 当allow_growth设置为True时，分配器将不会指定所有的GPU内存，而是根据需求增长
with tf.Session(config=config) as sess:
globe_episode = tf.Variable(
0, dtype=tf.int32, trainable=False, name='globe_episode'
) # 设定trainable=False 可以防止该变量被数据流图的 GraphKeys.TRAINABLE_VARIABLES 收集, # 这样我们就不会在训练的时候尝试更新它的值。
agent = DDPG_agent(sess, state_shape, action_bound, action_dim)
saver = tf.train.Saver(var_list=tf.global_variables())
print(DIR)
if not agent.load(saver, DIR):
sess.run(tf.global_variables_initializer())
if not os.path.exists(DIR):
os.mkdir(DIR)
else:
print("coninnue------------------")
if PREMODEL:
prepath = os.path.join(PATH, 'premodel\checkpoint')
ckpt = tf.train.get_checkpoint_state(
os.path.dirname(prepath))
if ckpt and ckpt.model_checkpoint_path:
saver.restore(agent.sess, ckpt.model_checkpoint_path)
agent.action_noise.reset()
print(
"------------pretrained model loaded-------------")
while True:
print(state[1])
action = agent.act(state)
next_state, reward, terminal, info = env.step(action)
episode_reward += reward
agent.observe(state, action, reward, next_state, terminal)
agent.train()
state = next_state
'''
if train%10==0:
print("total training episode: {}".format(train))
print("--------------------------------------------------------------------")
if train%10000==0:
nDir = os.path.join(PATH, "data/" + str(int(train // 10000)))
if not os.path.exists(nDir):
os.mkdir(nDir)
agent.save(saver, nDir)
print("save")
print("--------------------------------------------------------------------")
train+=1
'''
step_count += 1
print("aim height: {}".format(env.aim_height).ljust(
20, " "),
"reward: {:.5f}.".format(reward).ljust(20, " "),
"steps: {}".format(step_count).ljust(20, " "),
end="\r")
if terminal:
if info == "success":
success += 1
print(" " * 80, end="\r")
print(
"episode {} finish, average reward: {:.5f}, total success: {} result: {} step: {}"
.format(e, step_count).ljust(80, " "))
episode_reward = 0
step_count = 0
e += 1
total_episode = sess.run(globe_episode.assign_add(1))
if e % 10 == 0:
nDir = os.path.join(PATH,
"data/" + str(int(e // 10)))
if not os.path.exists(nDir):
os.mkdir(nDir)
agent.save(saver, nDir, DIR)
print("total training episode: {}".format(
total_episode))
infoShow = "time {}, episode {} finish, total success: {} step: {}".format(
time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())), e,
success, step_count)
persistence.saveTerminalRecord("DDPG", infoShow)
state = env.reset()
return
elif choose == "2":
agent = EnergyAgent(state_shape, action_bound, action_dim)
infoShow = "time {}, start new train, method{}".format(
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),
"EnergyAgent")
persistence.saveTerminalRecord("EnergyAgent", infoShow)
while True:
# 包含两个，01方向减法，23上次速度
print("目标相对位置，目前位移方向: {} ".format(state[1]))
action = agent.act(state)
print("具体方向: {} ".format(action))
next_state, reward, terminal, info = env.step(action)
state = next_state
step_count += 1
print("阶段 {} 完成, 总成功: {} 当轮步数: {}".format(e, success, step_count))
if terminal:
if info == "success":
success += 1
print(
"-----------------------------success----------------------------------"
)
step_count = 0
e += 1
infoShow = "time {}, episode {} finish, total success: {} step: {}".format(
time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())), e, success,
step_count)
persistence.saveTerminalRecord("EnergyAgent", infoShow)
state = env.reset()
else:
print("仿真结束")
return
def display_statistics():
queries = Persistence.get_statistics()
return render_template("statistics.html", queries=queries)
def __init__(self):
Persistence.__init__(self)
def get_ids(self, limit=-1, idx=0):
return Persistence.get_keys(self, limit, idx)
class Reservoir:
FULL = 0
EMPTY = 1
OK = 2
vol_per_mm = 0.3785 # estimate 1 gal per 10 mm, this is reservoir specific
vol_per_sec = 0.3785 # estimate 100 ml per sec, this is reservoir specific
def __init__(self):
'''Get distances for determining reservoir levels'''
self.res = {'full': full_ec, 'empty': empty_ec, 'timeout': timeout}
self._activity_type = 'Agronomic_Activity'
self._logger = Logger('LogReservoir', Logger.INFO)
self._persist = Persistence(self._logger)
self._logger.detail("Reservoir Initialized")
# flag for testing
self._test = False
def getStatus(self):
"Logic for calling the reservoir full"
self._logger.detail("In getStatus")
ec = self.getEC()
if ec <= full_ec:
self._logger.debug("{}, {}, {:10.1f}".format(
"Reservoir Full", EC, ec))
return Reservoir.FULL, ec
elif ec >= empty_ec:
self._logger.debug("{}, {}, {:10.1f}".format(
"Reservoir Empty", EC, ec))
return Reservoir.EMPTY, ec
else:
self._logger.debug("{}, {}, {:10.1f}".format(
"Reservoir not Empty", EC, ec))
return Reservoir.OK, ec
def isFull(self):
self._logger.detail("In isFull")
status, ec = self.getStatus()
if status == Reservoir.FULL:
return True
else:
return False
def getEC(self):
'''Get EC reading'''
self._logger.detail("In getEC")
snsr = EC(self._logger)
return snsr.getEC()
def fill(self, test=False):
''' Routine to control re-filling of the reservoir'''
self._logger.detail("{}".format("In Fill"))
start_ec = self.getEC()
start_t = time.time()
pump = Pump()
pump.on()
# Loop till filled or times out
while (not self.isFull()) and self.isFilling(start_t):
self._logger.detail("{}".format("In Fill Loop"))
self._logger.detail("{}".format("Exit Fill Loop, close solenoid"))
# Close valve
pump.off()
# Calculate amount filled
stop_t = time.time()
stop_ec = self.getEC()
dif_t = stop_t - start_t
volume = dif_t * self.vol_per_sec
self._logger.detail("{}".format("Exit Fill"))
return volume
def isFilling(self, start_time, test=False):
'''Check that actually filling: the distance is actually changing'''
start_ec = self.getEC()
self._logger.detail("{} {}".format("Filling, Start EC:", start_ec))
time.sleep(fill_time)
# Check for level change first, else will never get to this logic till timeout
end_ec = self.getEC()
change = start_ec - end_ec
if end_ec < start_ec: # need to see at least a 5mm change
self._logger.detail("{} {} {} {} {} {}".format(
"Still Filling, change:", change, "Start", start_ec, "End",
end_ec))
return True
else:
self._logger.detail("{} {} {} {} {} {}".format(
"Not Filling, no change:", change, "Start", start_ec, "End",
end_ec))
return False
# Check for timeout
stop_time = time.time()
if stop_time - start_time > self.res['timeout']:
self._logger.detail("{}".format("Timeout"))
return False
else:
return True
def checkReservoir(self):
'''Check condition of reservoir and fill if necessary'''
self._logger.detail("{}".format("Check Reservoir"))
status, ec = self.getStatus()
self._logger.debug("{} {} {} {}".format("Status:", status, "EC", ec))
# Is full, log state
if status == Reservoir.FULL:
self._logger.detail("{}".format("Status: Full"))
self._logger.info("{} {} {} {}".format("EC:", ec, "Full level:",
self.res['full'], "Empty:",
self.res['empty']))
return True
else:
# Needs filling
self._logger.debug("{}".format("Status: Filling"))
volume = self.fill()
if volume > 0:
# Filled, log volume
self.logState(volume, 'Success')
return True
else:
# Failure
self._logger.debug("{}".format("Status: Failure"))
level = 'Empty'
if status == '2':
level = 'Ok'
self._logger.error("{}".format("Failure to fill Reservoir"))
self._logger.error("{} {} {} {}".format(
"EC:", ec, "Full level:", self.res['full'], "Empty:",
self.res['empty']))
self.logState(volume, 'Failure')
return False
def logState(self, value, status_qualifier):
if self._test:
status_qualifier = 'Test'
txt = {
'Volume': value,
'full_level': self.res['full'],
'empty_level': self.res['empty'],
'status': 'Full'
}
self._persist.save([
'State_Change', '', 'Nutrient', 'Reservoir', 'Volume', value,
'Liter', 'Solenoid', status_qualifier, ''
])
self._logger.info(txt)
def update_database():
Persistence.update(session['id'])
flash("Database has been updated!")
return redirect(url_for('main'))
def main():
if 'id' in session:
Persistence.set_user(User.get(session['id']))
return render_template("main.html")
def __init__(self, filename: str):
self.filename: str = filename
self.dbHandler: Persistence = Persistence()
def fetchData(tablename: str) -> list:
dbHandler: Persistence = Persistence()
dbHandler.connect()
data: list = dbHandler.fetchAtributos(tablename)
dbHandler.closeConnection()
return data
def setUp(self):
self.persistence = Persistence('test.db')
class LogSensorsExtra(object):
def __init__(self, lvl=Logger.INFO):
"""Record optional sensor data
Args:
lvl: Logging level
Returns:
None
Raises:
None
"""
self._logger = Logger("LogSensor-Extra",
lvl,
file="/home/pi/MVP/logs/obsv.log")
self._activity_type = "Environment_Observation"
self._test = False
self._persist = Persistence(self._logger)
def getOneWire(self, test=False):
"""Loop OneWire temperature sensors
Assumes there are four
Args:
test: flag for testing
Returns:
None
Raises:
None
"""
self._logger.debug("In getOneWire")
from OneWireTemp import OneWireTemp
for sensor in OneWireTemp.one_temp:
self.logOneWire(sensor, OneWireTemp.one_temp[sensor])
def logOneWire(self, sensor, name, test=False):
"""Record OneWire temperature sensor
Args:
sensor: number of the sensor
name: name of the sensor
test: flag for testing
Returns:
None
Raises:
None
"""
self._logger.debug("In logOneWire")
from OneWireTemp import OneWireTemp
try:
ow = OneWireTemp()
temp = ow.getTempC(sensor)
status_qualifier = 'Success'
if self._test:
status_qualifier = 'Test'
rec = [
self._activity_type, '', name, 'Air', 'Temperature',
"{:10.1f}".format(temp), 'Centigrade',
'DS18B20-' + str(sensor), status_qualifier, ''
]
self._persist.save(rec)
self._logger.info("{}, {}, {:10.1f}".format(
name, status_qualifier, temp))
except Exception as e:
status_qualifier = 'Failure'
if test:
status_qualifier = 'Test'
rec = [
self._activity_type, '', name, 'Air', 'Temperature', '',
'Centigrade', 'DS18B20-' + str(sensor), status_qualifier,
str(e)
]
self._persist.save(rec)
self._logger.error("{}, {}, {}".format(name, status_qualifier, e))
def getLux(self, test=False):
"""Record LUX sensor (TSL2561)
Args:
test: flag for testing
Returns:
None
Raises:
None
"""
from TSL2561 import TSL2561
lx = TSL2561()
self._logger.info("TSL2561 - LUX")
try:
lux = lx.getLux()
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
rec = [
self._activity_type, '', 'Canopy', 'Light', 'LUX',
"{:3.1f}".format(lux), 'lux', 'TSL2561', status_qualifier, ''
]
self._persist.save(rec)
self._logger.info("{}, {}, {:10.1f}".format(
"LUX", status_qualifier, lux))
except Exception as e:
status_qualifier = 'Failure'
if test:
status_qualifier = 'Test'
rec = [
self._activity_type, '', 'Canopy', 'Light', 'LUX', '', 'lux',
'TSL2561', status_qualifier,
str(e)
]
self._persist.save(rec)
self._logger.error("{}, {}, {}".format("LUX", status_qualifier, e))
def getEC(self, test=False):
"""Record EC sensor (EC - ADC reading)
Args:
test: flag for testing
Returns:
None
Raises:
None
"""
from EC import EC
self._logger.info("EC")
try:
s = EC()
ec = s.getEC()
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
print("{}, {}, {:10.1f}".format("EC", status_qualifier, ec))
rec = [
self._activity_type, '', 'Reservoir', 'Nutrient', 'EC',
"{:3.1f}".format(ec), 'EC', 'EC', status_qualifier, ''
]
self._persist.save(rec)
self._logger.info("{}, {}, {:10.1f}".format(
"EC", status_qualifier, ec))
except Exception as e:
status_qualifier = 'Failure'
if test:
status_qualifier = 'Test'
print("{}, {}, {:10.1f}".format("EC", status_qualifier, ec))
rec = [
self._activity_type, '', 'Reservoir', 'Nutrient', 'EC', '',
'EC', 'EC', status_qualifier,
str(e)
]
self._persist.save(rec)
self._logger.error("{}, {}, {}".format("EC CCS811",
status_qualifier, e))
def getCO2_NDIR(self, test=False):
"""Record CO2 sensor (NDIR)
Args:
test: flag for testing
Returns:
None
Raises:
None
"""
from NDIR import Sensor
self._logger.info("CO2 - NDIR")
try:
sensor = Sensor()
sensor.begin()
co2 = sensor.getCO2()
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier,
co2))
rec = [
self._activity_type, '', 'Canopy', 'Air', 'CO2',
"{:3.1f}".format(co2), 'ppm', 'MH-Z16-NDIR', status_qualifier,
''
]
self._persist.save(rec)
self._logger.debug("{}, {}, {:10.1f}".format(
"CO2", status_qualifier, co2))
except Exception as e:
status_qualifier = 'Failure'
if test:
status_qualifier = 'Test'
print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier,
co2))
rec = [
self._activity_type, '', 'Canopy', 'Air', 'CO2', '', 'ppm',
'MH-Z16-NDIR', status_qualifier,
str(e)
]
self._persist.save(rec)
self._logger.error("{}, {}, {}".format("CO2 NDIR",
status_qualifier, e))
def getCO2_CCS811(self, test=False):
"""Record CO2 sensor (CCS811)
Args:
test: flag for testing
Returns:
None
Raises:
None
"""
from CCS811 import CCS811
self._logger.info("CO2 CCS811")
try:
sensor = CCS811(SLAVE)
co2 = sensor.get_co2()
status_qualifier = 'Success'
if test:
status_qualifier = 'Test'
print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier,
co2))
rec = [
self._activity_type, '', 'Canopy', 'Air', 'CO2',
"{:3.1f}".format(co2), 'ppm', 'CCS811',
str(e)
]
self._persist.save(rec)
self._logger.debug("{}, {}, {:10.1f}".format(
"CCS811 - CO2", status_qualifier, co2))
except Exception as e:
status_qualifier = 'Failure'
if test:
status_qualifier = 'Test'
print("{}, {}, {:10.1f}".format("CO2 Canopy", status_qualifier,
co2))
rec = [
self._activity_type, '', 'Canopy', 'Air', 'CO2', '', 'ppm',
'CCS811', status_qualifier,
str(e)
]
self._persist.save(rec)
self._logger.error("{}, {}, {}".format("CO2 CCS811",
status_qualifier, e))
def getSCD(self):
"""Record CO2 sensor (scd30)
Generates co2, temperature and relative humidity
Args:
None
Returns:
None
Raises:
None
"""
from scd30 import SCD30
self._scd = SCD30(self._logger)
self._logger.debug("In SCD30")
try:
co2, temp, rh = self._scd.get_data()
status = 'Success'
if self._test:
status = 'Test'
c_rec = [
'Environment_Observation', '', 'Top', 'Air', 'CO2',
"{:10.1f}".format(co2), 'ppm', 'scd30', status, ''
]
t_rec = [
'Environment_Observation', '', 'Top', 'Air', 'Temperature',
"{:10.1f}".format(temp), 'Centigrade', 'scd30', status, ''
]
h_rec = [
'Environment_Observation', '', 'Top', 'Air', 'Humidity',
"{:10.1f}".format(rh), 'Percent', 'scd30', status, ''
]
self._persist.save(c_rec)
self._persist.save(t_rec)
self._persist.save(h_rec)
self._logger.info("{} {:6.1f}, {} {:3.1f}, {} {:3.1f}".format(
"EnvObsv-CO2:", co2, "Temp", temp, "Humidity:", rh))
except Exception as e:
status = 'Failure'
if self._test:
status = 'Test'
c_rec = [
'Environment_Observation', '', 'Top', 'Air', 'CO2', '', 'ppm',
'scd30', status,
str(e)
]
t_rec = [
'Environment_Observation', '', 'Top', 'Air', 'Temperature', '',
'Centigrde', 'scd30', status, ''
]
h_rec = [
'Environment_Observation', '', 'Top', 'Air', 'Humidity', '',
'Percent', 'scd30', status, ''
]
self._persist.save(c_rec)
self._persist.save(t_rec)
self._persist.save(h_rec)
self._logger.debug("{} {}".format("EnvObsv-SCD30 Error:", e))
def log(self):
'''Log extra sensors
Uncomment desired sensors
Imports are in the function to avoid loading unnecessary code
'''
#self.getOneWire()
self.getLux()
self.getEC()
self.getCO2_NDIR()
#self.getCO2_CCS811()
self.getSCD()
import asyncio
from threading import Timer
from datetime import datetime
from Persistence import Persistence
news_and_anouncements = "https://community.blackdesertonline.com/index.php?forums/news-announcements.181/index.rss"
updates = "https://community.blackdesertonline.com/index.php?forums/patch-notes.5/index.rss"
refreshTimer = None
news_channel = None
update_channel = None
persistence = Persistence()
loop = asyncio.get_event_loop()
def check_for_updates():
newsParser = feedparser.parse(news_and_anouncements)
updateParser = feedparser.parse(updates)
print("update refresh\n")
global refreshTimer
refreshTimer = Timer(3600, check_for_updates)
refreshTimer.start()
new_news = list()
new_updates = list()
minR = 0.1e-9
maxR = 50e-9
fileBase = './'
outDir = './'
outFile = open(outDir + 'deformation.dat','w')
forceFile = open(outDir + 'force.dat', 'w')
restartFileName = outDir + 'restart.hdf5'
restartFileName = ''
saveFileName = outDir + 'checkpoint.hdf5'
if restartFileName != '':
print 'I am restarting......'
restartFile = Persistence(restartFileName,'r')
else:
restartFile = None
solidCaseFile = fileBase + 'Gen5_beam_2D.cas'
fluidCaseFile = fileBase + 'fluid_electrode_dielectric.cas'
fluidReader = FluentCase(sys.argv[1])
solidReader = FluentCase(sys.argv[2])
fluidReader.read()
solidReader.read()
fluidMeshes = fluidReader.getMeshList()
fluidMeshesOrig = fluidMeshes
solidMeshes = solidReader.getMeshList()
