def run(self):
# Create timers for each Arduino
timers = [
multitimer.MultiTimer(interval=60, function=self.rtd_thermometer),
multitimer.MultiTimer(interval=60,
function=self.air_quality_readings),
multitimer.MultiTimer(interval=60,
function=self.pressure_readings),
#other_timer = multitimer.MultiTimer(interval=seconds, function=other_function),
]
# Start all timers and enter while-true
self.logger.info("Starting Arduino Data Timers")
for timer in timers:
timer.start()
while True:
pass
def run(self):
mqcards = sysv_ipc.MessageQueue(100)
mqverif = sysv_ipc.MessageQueue(self.numero) # Message queue key numero joueur, sert à recevoir TRUE ou FALSE
mqtouchejouee = sysv_ipc.MessageQueue(200 + self.numero)
mqhandsize = sysv_ipc.MessageQueue(300)
mqaffichage = sysv_ipc.MessageQueue(400)
threadaffichage = threading.Thread(target=self.affichageforce, args=(mqaffichage, ))
threadaffichage.start()
while len(self.cartesmain) != 0 and not self.deck.empty():
timer = multitimer.MultiTimer(interval=10, function=self.pioche, kwargs={"mqaffichage": mqaffichage}, runonstart=False)
timer.start()
erreur = True
numcarte = 0
while erreur:
try:
bnumcarte, t = mqtouchejouee.receive()
numcarte = int(bnumcarte.decode())
mqcards.send(dumps(self.cartesmain[numcarte - 1]))
erreur = False
except IndexError:
print("Joueur : " + str(self.numero) + " | Veuillez entrer une touche valide")
timer.stop()
blebool, t = mqverif.receive()
lebool = blebool.decode() == 'True'
if lebool:
self.removecard(self.cartesmain[numcarte - 1])
mqhandsize.send((str(len(self.cartesmain))).encode())
else:
self.pioche(mqaffichage)
threadaffichage.join()
def main():
# enter here the ID of your device. On windows, VISA you can easily find it in the VISA interface.
Device = pyvisascope.MSO1000('USB::0x1AB1::0x0515::MS5A230800492::INSTR')
Device.myScope.timeout = None
# set a timer that records every minute for in total 4 times
timer = multitimer.MultiTimer(interval=5, function=measure, kwargs={'myDevice': Device}, count=20, runonstart=True)
timer.start()
def jouer(j):
z = multitimer.MultiTimer(interval=10,
function=piocher,
kwargs={"j": j},
runonstart=False)
z.start()
m, t = mq.receive(type=4 + j.identifiant)
z.stop()
numero = int(m.decode())
if numero < len(j.main):
carte = j.main[numero]
message = str(j.identifiant) + ":" + str(carte.valeur) + ":" + str(
carte.couleur)
msg = str(message).encode()
mutexQueue.acquire()
mq.send(msg, type=1)
m, t = mq.receive(type=1 + j.identifiant)
mutexQueue.release()
b = int(m.decode())
if b == 1:
j.main.remove(carte)
else:
piocher(j)
if (len(j.main) == 0):
msg = str(j.identifiant)
msg = msg.encode()
mq.send(msg, type=4)
afficherMain(j)
def start(self, filename, redis_keys, logger_period=1):
'''
Starts the logger by spinning off a thread. If the logger is
already running, this call is ignored.
:param filename: A string containing the filename to write keys to.
:param redis_keys: A list of strings containing keys to poll Redis.
:param logger_period: A float containing how often to poll Redis, in seconds.
Default is 1 second.
:returns: True if thread started, False if already running or failure.
'''
if self.running:
return False
self.filename = filename
self.redis_keys = redis_keys
self.logger_period = logger_period
# start the timer
self.running = True
self.file_fd = open(filename, 'w+')
context = { 'header_written': False }
self.periodic_timer = multitimer.MultiTimer(
logger_period,
function=self._logger_loop,
kwargs={'ctx': context}
)
self.periodic_timer.start()
return True
def main():
# enter here the ID of your device. On windows, VISA you can easily find it in the VISA interface.
Device = pyvisascope.TDS2000('USB::0x0699::0x0368::C100942::INSTR')
Device.myScope.timeout = None
# set a timer that records every minute for in total 4 times
timer = multitimer.MultiTimer(interval=60, function=measure, kwargs={'myDevice': Device}, count=3, runonstart=True)
timer.start()
def main():
# enter here the ID of your device. On windows, VISA you can easily find it in the VISA interface.
Device = pyvisascope.SDS_1104X_E('USB0::62700::60984::SDSMMEBD2R5477::0::INSTR')
Device.myScope.timeout = None
# set a timer that records every minute for in total 4 times
#timer = multitimer.MultiTimer(interval=5, function=measure, kwargs={'myDevice': Device}, count=10, runonstart=True)
timer = multitimer.MultiTimer(interval=60, function=measure, kwargs={'myDevice': Device}, count=1440, runonstart=True)
timer.start()
def main():
# enter here the ID of your device. On windows, VISA you can easily find it in the VISA interface.
Device = pyvisascope.DS1000Z('USB0::0x1AB1::0x04CE::DS1ZA191806462::INSTR')
Device.myScope.timeout = None
# set a timer that records every minute for in total 4 times
timer = multitimer.MultiTimer(interval=3,
function=measure,
kwargs={'myDevice': Device},
count=10,
runonstart=True)
timer.start()
def __init__(self,
interval_s,
count=-1,
runonstart=True,
task_func=None,
**kwargs):
super().__init__(**kwargs)
self._interval_s = interval_s
if task_func: # Important
self._task_func = task_func
self._multitimer = multitimer.MultiTimer(
interval=interval_s,
function=self._offloaded_run_task,
count=count,
runonstart=runonstart)
def __init__(self,
redis_client,
refresh_rate=0.0333,
keys=[],
key_patterns=[],
key_refresh_cycles=10):
self.refresh_rate = refresh_rate
self.redis_client = redis_client
self.refresh_keys = threading.Event()
self.key_refresh_cycles = key_refresh_cycles
self.pipe_keys = keys
self.key_patterns = key_patterns
self.key_cache = {}
self.running = False
ctx = {'first_run': True, 'refresh_counter': 0}
self.periodic_timer = multitimer.MultiTimer(
refresh_rate, function=self._update_cache, kwargs={'ctx': ctx})
if not keys and not key_patterns:
self.key_patterns = ['*']
def loop_snap(self, idT):
print("loop Snapshot " + str(idT))
if self.opMenuVar.get() != "":
if str(self.loopCapture['text']).find('Loop Capture') != -1:
self.loopCapture.configure(text="Stop " + str(self.loops))
self.opMenu.configure(state=DISABLED)
#self.snap_timer = threading.Timer(2,self.get_snap,args=None,kwargs=None)
self.snap_timer = multitimer.MultiTimer(interval=2,
function=self.get_snap,
count=int(self.loops) +
1)
self.snap_timer.start()
else:
print("cancel timer")
self.read_ini()
self.loopCapture.configure(text="Loop Capture " +
str(self.loops))
self.opMenu.configure(state=NORMAL)
self.snap_timer.stop()
if temp >= set_temp:
set_alarm_t = 1
self.label_temp_os.setText("Temperature Overshoot !!!")
else:
set_alarm_t = 0
self.label_temp_os.setText("")
if hum >= set_humidity:
set_alarm_h = 1
self.label_humidity_os.setText("Humidity Overshoot !!!")
else:
set_alarm_h = 0
self.label_humidity_os.setText("")
if set_alarm_t or set_alarm_h:
self.label_alert.setText("ALARM !!!")
else:
self.label_alert.setText("")
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
ui = Ui()
# Timer initialization
timer = multitimer.MultiTimer(15,
read_data,
args=None,
kwargs=None,
count=30,
runonstart=True)
timer.start()
sys.exit(app.exec_())
def changeStates():
global timerCount
global currentTimerCount
global CURRENT_STATE
global NEXT_STATE
global LAST_STATE
currentTimerCount += 1
if currentTimerCount == timerCount:
LAST_STATE = CURRENT_STATE
CURRENT_STATE = NEXT_STATE
currentTimerCount = 0
timer = multitimer.MultiTimer(timerLength, changeStates)
timer.start()
while True:
while sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
line = sys.stdin.readline()
if line:
if 'l' in line:
currentTimerCount = currentTimerCount - 1
elif 'p' in line:
currentTimerCount = timerCount - 1
else:
continue
if CURRENT_STATE == RED_RED_STATE:
rfidID = RFIDread(reader1)
if determineMessage(rfidID, '0') != -1:
## initialing variables
x = y = 0
running = 1
screen = pygame.display.set_mode((800, 540))
p = (x, y)
timer_on = False
distracted = False
monitor = False
os.system('cls')
# define timer t and vibration function
print("Give the time inverval in seconds: ")
interval = input()
def vibration():
print("seat and wheel vibration created")
t = mt.MultiTimer(3, vibration, runonstart=False)
os.system('cls')
while running:
# background image displayed
event = pygame.event.poll()
image = pygame.image.load("chenei.jpg")
if event.type == pygame.QUIT:
running = 0
# get the mouse position
elif event.type == pygame.MOUSEMOTION:
p = event.pos
# show the mouse pos by click
elif event.type == pygame.MOUSEBUTTONDOWN:
print(event.pos)
def send_file(file_name, server_addr, port_no, pkt_size):
##MAIN
# if len(sys.argv) != 5:
# print("Invalid usage\nUsage: python send.py file_name.ext server_address port_number packet_size\n\nThis scripts sends the filename given input to the server on the server running port by creating a UDP connection with reliability to send file to server.")
# os._exit(0)
# else:
# filename = sys.argv[1]
# SERVER = sys.argv[2]
# PORT = int(sys.argv[3])
# size = int(sys.argv[4])
# MSG_SIZE = size
# print(filename, SERVER, PORT, size)
# ADDR = (SERVER, PORT)
global MSG_SIZE
global PORT
global SERVER
global FORMAT
global DISCONNECT_MESSAGE
global latest_start
global disconnect
global hello
global timers
filename = file_name
SERVER = server_addr
PORT = port_no
MSG_SIZE = pkt_size
size = pkt_size
global received
global running
global yet_to_be_started
global timers_lock
global received_lock
global running_lock
with open(filename, "rb") as file:
encoded_string = file.read()
#encoded_string=""
count = 0
timers = {}
#CREATE TIMER OBJECTS
arr = {}
#for i in range(0, len(encoded_string), size-):
i = 0
# print(len(encoded_string))
msgs = []
while i < len(encoded_string):
#1024 = (indx;)+(data)+(;)
var = str(count)
var += ";"
msg = bytes(var, FORMAT)
end = bytes(";", FORMAT)
inext = i + size - len(msg) - len(end)
msg += encoded_string[i:inext]
msg += end
msgs.append(msg)
arr[i] = count
timers[count] = multitimer.MultiTimer(interval=0.01,
function=send,
kwargs={'msg': msg})
count += 1
i = inext
disconnect = multitimer.MultiTimer(
interval=0.01,
function=send,
kwargs={'msg': f"-1;{DISCONNECT_MESSAGE};"})
hello = multitimer.MultiTimer(
interval=0.01,
function=send,
kwargs={
'msg': bytes(f'-1;{HELLO};{filename};{count};{MSG_SIZE};', FORMAT)
})
# killer = multitimer.MultiTimer(interval=0.001, function=kill_proc)
# print(sizeof_fmt(len(encoded_string)), len(timers), len(msgs), len(arr))
##START SENDING
latest_start = 0
t = threading.Thread(target=start_and_end)
t.start()
shift_to_beijing_time).tm_hour) == 21:
# writeResultYnu('今日没有更新最新招生公告' + time.ctime())
with open('setting.json', 'r', encoding='utf-8') as settingFile:
setting_obj = FakeBunch(json.loads(settingFile.read()))
settingFile.close()
if setting_obj.sendMailCount < 1:
sendMail('今日没有更新最新招生公告' + time.strftime(
'%Y-%m-%d %H:%M:%S',
time.gmtime(time.time() + shift_to_beijing_time)))
setting_obj.sendMailCount = 1
with open('setting.json', 'w', encoding='utf-8') as settingFile:
settingFile.write(setting_obj.unbunch())
settingFile.close()
else:
pass
else:
with open('setting.json', 'r', encoding='utf-8') as settingFile:
setting_obj = FakeBunch(json.loads(settingFile.read()))
settingFile.close()
setting_obj.sendMailCount = 0
with open('setting.json', 'w', encoding='utf-8') as settingFile:
settingFile.write(setting_obj.unbunch())
settingFile.close()
print(
'今日暂无新消息',
time.strftime('%Y-%m-%d %H:%M:%S',
time.gmtime(time.time() + shift_to_beijing_time)))
timer = multitimer.MultiTimer(interval=5, function=main)
timer.start()
#http_code = c.getinfo(pycurl.HTTP_CODE)
#http_conn_time = c.getinfo(pycurl.CONNECT_TIME)
#http_pre_tran = c.getinfo(pycurl.PRETRANSFER_TIME)
#http_start_tran = c.getinfo(pycurl.STARTTRANSFER_TIME)
#http_total_time = c.getinfo(pycurl.TOTAL_TIME)
#http_size = c.getinfo(pycurl.SIZE_DOWNLOAD)
# HTTP response code, e.g. 200.
print('Status: %d' % c.getinfo(c.RESPONSE_CODE))
# Elapsed time for the transfer.
#print('Transfer Time: %f' % c.getinfo(c.CONNECT_TIME))
# Elapsed time for the transfer.
total_time = c.getinfo(c.TOTAL_TIME)
print('Total Time: %f' % total_time)
df2 = pd.DataFrame({"resp_time": [float(total_time)]})
df1 = df1.append(df2, ignore_index=True)
#print(df1, "\n")
# saving the dataframe
df1.to_csv(filename, sep=';')
# This timer will run job() five times, one second apart
timer = multitimer.MultiTimer(interval=2, function=job, count=10)
# Also, this timer would run indefinitely...
timer.start()
# getinfo must be called before close.
#c.close()
# In[ ]:
print(text)
words = text.split() # Why didn't you use split?
for word in words:
total_words.append(word)
if counter == 12:
analysis_input_text(total_words)
total_words.clear()
counter = 0
fh.write(text)
fh.close()
except:
print('Whatever you said was gibberish to me!')
t = multitimer.MultiTimer(rec_sec - 0.01,
function=save_and_recognize,
kwargs={'recording': rec},
runonstart=False)
#t2 = multitimer.MultiTimer(120, function=analysis_input_text, kwargs={'all_words_in_two_min': total_words}, runonstart=False)
t.start()
#t2.start()
while True:
for i in range(math.ceil(Rate / chunk * rec_sec)):
data = stream.read(chunk)
rec.append(data)
rec.clear()
'''
try:
with speech_recognition.AudioFile('sound.wav') as source:
audio = r.record(source)
text = r.recognize_wit(audio, key="HTDCCKGTKR5P6WTEG7MEFQ4NSE36KKBU")
while GPIO.input(echo) == 1:
pass
stop = time.time()
distance = (stop - start) * 17000
return distance
def timer3_handler():
global ACTIVE_TIMER, timer3
print('timer3_handler: timer3 expired')
db.child('geyser').update({'vigilant': 'yes'})
ACTIVE_TIMER = 0
timer3 = multitimer.MultiTimer(interval=60,
function=timer3_handler,
count=1,
runonstart=False)
def timer2_handler():
print('timer2_handler: timer2 expired')
db.child('geyser').update({'notify': 'OFF'})
timer2 = multitimer.MultiTimer(interval=60,
function=timer2_handler,
count=1,
runonstart=False)
def timer1_handler():
offsets = [t % interval for t in intervals]
print('Intervals:')
pprint(intervals)
print('\nOffsets from ideal intervals:')
pprint(offsets)
#%%
result = []
def increment_func():
sleep(2)
result.append(42)
rpt = multitimer.MultiTimer(interval=1, function=increment_func, runonstart=True)
rpt.join() # Does nothing
rpt.start()
try:
rpt.join()
except AssertionError:
pass
else:
raise RuntimeError("should have failed")
rpt.stop()
assert len(result) == 0
rpt.join()
assert len(result) == 1
#data = which server has max window load
# Minimum Response Time Algorithm
def job1MinRT():
#Publish data to MQTT Broker
min_RspTime = respon_time.index(min(respon_time)) + 1
msg = min_RspTime
print("Server dg min Respon Time =", msg)
client.publish(topic="sdn/serverno", payload=msg, qos=0, retain=False)
#client.publish(topic="sdn/cpumem01", payload=msg, qos=1, retain=False)
#client.publish(topic="sdn/rsptm03", payload=rsp_tm_s3, qos=0, retain=False)
# This timer will run job() five times, one second apart
timer1 = multitimer.MultiTimer(interval=1, function=job1Fuzzy, count=-1)
# Also, this timer would run indefinitely...
timer1.start()
#Start getting Server Response From Here
def job2():
#global time01
global alamat_ip
global respon_time
for i in range(lengths):
c = pycurl.Curl()
buffer = BytesIO()
#c.setopt(c.URL, 'http://pycurl.io/')
now1 = datetime.datetime.now() # time object
#print("now =", now1)
#data = which server has max window load
# Minimum Response Time Algorithm
def job1MinRT():
#Publish data to MQTT Broker
min_RspTime = respon_time.index(min(respon_time)) + 1
msg = min_RspTime
print("Server dg min Respon Time =", msg)
client.publish(topic="sdn/serverno", payload=msg, qos=0, retain=False)
#client.publish(topic="sdn/cpumem01", payload=msg, qos=1, retain=False)
#client.publish(topic="sdn/rsptm03", payload=rsp_tm_s3, qos=0, retain=False)
# This timer will run job() five times, one second apart
timer1 = multitimer.MultiTimer(interval=2, function=job1Fuzzy, count=-1)
# Also, this timer would run indefinitely...
timer1.start()
#Start getting Server Response From Here
def job2():
#global time01
global alamat_ip
global respon_time
for i in range(lengths):
c = pycurl.Curl()
buffer = BytesIO()
#c.setopt(c.URL, 'http://pycurl.io/')
#now1 = datetime.datetime.now() # time object
#print("now =", now1)
print("now =", now1)
print("do curl")
c.setopt(c.URL, add01)
c.setopt(c.WRITEDATA, buffer)
c.perform()
c.close()
now2 = datetime.datetime.now() # time object
selisih = now2 - now1
#print("selisih :", selisih)
#hasil dalam seconds
hasil = selisih.seconds + (selisih.microseconds/1000000)
print("Server1 Respons time =", hasil)
time01 = float(hasil)
# This timer will run job() five times, one second apart
timer1 = multitimer.MultiTimer(interval=10, function=job1, count=-1)
# Also, this timer would run indefinitely...
timer1.start()
#Start getting Server Response From Here
def job2():
global time02
global add02
c = pycurl.Curl()
buffer = BytesIO()
#c.setopt(c.URL, 'http://pycurl.io/')
now1 = datetime.datetime.now() # time object
print("now =", now1)
print("do curl")
c.setopt(c.URL, add02)
c.setopt(c.WRITEDATA, buffer)
print(f"url: {url}")
print(f"frequency: {frequency}s")
print(f"remove html tags and comments: {removeTagsAndComments}\n")
def check():
global previous
with urllib.request.urlopen(url) as response:
html = response.read().decode('utf-8')
if removeTagsAndComments:
html = htmlTagRegex.sub("", html)
html = commentRegex.sub("", html)
if previous != html and previous != "":
print(f"SITE HAS CHANGED ({datetime.now()})")
print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n")
playsound(song)
previous = html
t1 = multitimer.MultiTimer(frequency, check)
t1.start()
s = ""
while s.lower() != "stop":
try:
s = input("Enter stop to stop (duh)\n\n")
except KeyboardInterrupt:
s = "stop"
if s == "play":
playsound(song)
t1.stop()
"CREATE TABLE IF NOT EXISTS {} (id INT AUTO_INCREMENT PRIMARY KEY, Humidity FLOAT, Temperature FLOAT, Timestamp VARCHAR(30))"
.format(table_name))
"""
TO ALTER THE CONTENTS OF THE TABLE
mycursor.execute("ALTER TABLE {} MODIFY COLUMN Timestamp VARCHAR(30)".format(table_name))
#TO VIEW THE CONTENTS OF THE TABLE
mycursor.execute("SELECT * FROM {}".format(table_name))
for i in mycursor:
print(i)
"""
#CONFIGURING THE TIMER
timer = multitimer.MultiTimer(interval=15,
function=timer_15,
args=None,
kwargs=None,
count=30,
runonstart=True)
timer.start()
# Form implementation generated from reading ui file 'sensor_reading_gui.ui'
# Created by: PyQt5 UI code generator 5.11.3
class Ui_gui(object):
def setupUi(self, gui):
gui.setObjectName("gui")
gui.resize(811, 621)
gui.setStyleSheet("background-color: rgb(255, 170, 127);\n"
"background-color: rgb(170, 170, 255);")
self.centralwidget = QtWidgets.QWidget(gui)
cv.imshow("video", frame)
if recorder is not None:
recorder.write_frame(frame)
if cv.waitKey(1) & 0xFF == ord('q'):
break
vcap.release()
timer.stop()
recorder.close_stream(full_stop=True)
cv.destroyAllWindows()
vcap = cv.VideoCapture("udp://192.168.0.32:5000/")
recorder = None
# How often the stream should be saved to harddrive (mins)
time_interval = 20
timer = multitimer.RepeatingTimer(time_interval, recorder.close_stream, count=-1, runonstart=False) # timer that repeats every interval
timer_rec = multitimer.MultiTimer(8, start_recorder, kwargs=dict(recorder), runonstart=False)
if vcap.isOpened():
timer.start()
timer_rec.start()
main_loop()
import json
import pandas as pd
import paho.mqtt.client as mqtt
from time import sleep
import multitimer
import time
from datetime import datetime
df = pd.read_csv('periodic_data.csv')
mqttHost = '10.1.17.111'
mqttPort = 1883
mqttclient = mqtt.Client('c1', False)
mqttclient.connect(host=mqttHost, port=mqttPort) # connect to broker
mqttclient.loop_start()
def hello():
print(datetime.now())
for i in range(len(df.index)):
# print(df.loc[i].topic, '\t', df.loc[i].tag, '\t', df.loc[i].value, '\t', df.loc[i].rate)
buff = json.dumps({df.loc[i].tag: df.loc[i].value})
ret = mqttclient.publish(df.loc[i].topic, payload=buff, qos=1)
ret.wait_for_publish()
t = multitimer.MultiTimer(interval=2, function=hello)
t.start()
def start_scheduler():
timer = multitimer.MultiTimer(1, check_time_to_send)
timer.start()
#!/usr/bin/env python3
import paho.mqtt.client as mqtt
import multitimer
import time
from psutil import cpu_percent, cpu_count, virtual_memory
#MQTT connection
broker_url = "localhost"
broker_port = 1883
client = mqtt.Client()
# edit code for passwords
print("setting password")
client.username_pw_set(username="******",password="******")
client.connect(broker_url, broker_port)
time.sleep( 5 )
def job():
# message you send to server
msg = str(cpu_percent()) + ';' + str(virtual_memory().percent)
print("Publish Cpu/Ram data", msg)
#client.publish(topic="sdn/cpumem01", payload=msg, qos=1, retain=False)
client.publish(topic="sdn/cpumem01", payload=msg, qos=0, retain=False)
# This timer will run job() five times, one second apart
timer = multitimer.MultiTimer(interval=1, function=job, count=-1)
# Also, this timer would run indefinitely...
timer.start()
# Change the setpoint
settings['thermostat']['tolerance'] = tol
# Write settings back
with open('static/settings.json', mode='w') as file:
file.write(json.dumps(settings,
indent=4)) # indent setting makes it pretty
# Recalculate thermostat actions
thermostat.run_thermostat(tol=tol)
# Success! :)
return "Temperature tolerance set to plus or minus %d degrees F." % tol
@app.route('/getJSON/<hours_ago>')
def get_json(hours_ago):
"""Return JSON system status data from the past x hours."""
return data_collector.get_json(hours_ago)
if __name__ == '__main__':
timer = multitimer.MultiTimer(interval=60,
function=data_collector.collect_data,
count=-1,
runonstart=True)
timer.start()
app.run(debug=True, host='0.0.0.0')
