def testCode5Case2(self):
"""subscribe same topic twice"""
try:
print('Code5Case2')
print("run helper...")
code = str(51)
args = ['python', 'helper.py', code]
p = subprocess.Popen(args, cwd=(helper_dir))
time.sleep(connect_worst_timeout)
client.create(self.gearkey, self.gearsecret, self.appid)
client.subscribe(self.topic)
client.subscribe(self.topic)
client.on_connect = MagicMock()
client.on_message = MagicMock()
client.connect()
time.sleep(connect_timeout)
self.assertTrue(client.on_connect.called)
self.connected = True
self.assertEqual(client.on_connect.call_count, 1)
time.sleep(message_timeout)
self.assertTrue(client.on_message.called)
client.on_message.assert_called_with(self.expectedTopic, self.expectedMessage)
p.kill()
#if fails due to assertion error
except Exception as e:
p.kill()
raise Exception(e.args)
def testCode5Case6x2(self):
"""subscribe invalid topic - no slash"""
try:
print('Code5Case6x2')
print("run helper...")
code = str(53)
args = ['python', 'helper.py', code]
p = subprocess.Popen(args, cwd=(helper_dir))
time.sleep(connect_worst_timeout)
self.topic = "firstTopic"
client.create(self.gearkey, self.gearsecret, self.appid)
client.subscribe(self.topic)
client.on_connect = MagicMock()
client.on_message = MagicMock()
client.connect()
time.sleep(connect_timeout)
self.assertTrue(client.on_connect.called)
self.connected = True
self.assertEqual(client.on_connect.call_count, 1)
time.sleep(message_timeout)
self.assertFalse(client.on_message.called)
p.kill()
#if fails due to assertion error
except Exception as e:
p.kill()
raise Exception(e.args)
def testCode6Case1(self):
"""unsubscribe the subscribed topic"""
print('Code6Case1')
try:
print("run helper...")
code = str(51)
args = ['python', 'helper.py', code]
p = subprocess.Popen(args, cwd=(helper_dir))
time.sleep(connect_worst_timeout)
client.create(self.gearkey, self.gearsecret, self.appid)
client.on_connect = MagicMock()
client.on_message = MagicMock()
client.connect()
time.sleep(connect_timeout)
self.assertTrue(client.on_connect.called)
self.connected = True
self.assertEqual(client.on_connect.call_count, 1)
client.subscribe(self.topic)
time.sleep(message_timeout)
self.assertTrue(client.on_message.called)
client.unsubscribe(self.topic)
client.on_message.reset_mock()
self.assertFalse(client.on_message.called)
time.sleep(message_timeout)
self.assertFalse(client.on_message.called)
p.kill()
#if fails due to assertion error
except Exception as e:
p.kill()
raise Exception(e.args)
def testCode6Case2(self):
"""unsubscribe the topic before subscribe"""
print('Code6Case2')
print(microgear.gearkey)
try:
print("run helper...")
code = str(51)
args = ['python', 'helper.py', code]
p = subprocess.Popen(args, cwd=(helper_dir))
time.sleep(connect_worst_timeout)
print(microgear.gearkey)
client.create(self.gearkey, self.gearsecret, self.appid)
client.on_connect = MagicMock()
client.on_message = MagicMock()
client.connect()
time.sleep(connect_timeout)
self.assertTrue(client.on_connect.called)
self.connected = True
self.assertEqual(client.on_connect.call_count, 1)
self.assertFalse(client.on_message.called)
client.unsubscribe(self.topic)
self.assertFalse(client.on_message.called)
client.subscribe(self.topic)
time.sleep(message_timeout)
self.assertTrue(client.on_message.called)
client.on_message.assert_called_with(self.expectedTopic, self.expectedMessage)
p.kill()
except Exception as e:
p.kill()
raise Exception(e.args)
def __init__(self):
QtGui.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.peano_flag =None
self.sensor = Sensor()
self.setupUi(self)
self.config = None
self.capture = Capture(self)
self.fileDiag = QFileDialog()
self.img_path = None
self.live_flag = None
# self.thread_2 = self.v2_sl.value()
# self.thread_1 = self.v1_sl.value()
# self.tableWidget.setColumnCount(3)
# self.tableWidget.resizeColumnsToContents()
# self.tableWidget.resizeRowsToContents()
self.start_cam_btn.clicked.connect(self.capture.startCapture)
self.stop_cam_btn.clicked.connect(self.capture.endCapture)
self.snap_btn.clicked.connect(self.snap_handler)
self.exit_btn.clicked.connect(exit_handler)
self.pick_btn.clicked.connect(self.get_file)
self.detect_btn.clicked.connect(self.detect_api)
self.detect_btn.setDisabled(True)
# self.v1_sl.valueChanged.connect(self.v1_changed)
# self.v2_sl.valueChanged.connect(self.v2_changed)
# self.measure_btn.clicked.connect(self.measure)
# self.count_btn.clicked.connect(self.count)
self.circle_radio.toggled.connect(lambda: self.btnstate(self.circle_radio))
self.unknow_radio.toggled.connect(lambda: self.btnstate(self.unknow_radio))
self.livepreview.toggled.connect(lambda: self.btnstate(self.livepreview))
self.peano_chk.toggled.connect(lambda: self.btnstate(self.peano_chk))
self.object_type = None
self.label.setAutoFillBackground(True)
self.label.setText("Wait for Connection ..")
self.label.setStyleSheet('color: blue')
self.Timer = QTimer()
self.Timer.timeout.connect(self.check_status)
self.Timer.start(15000)
self.gearkey = 'liLGrIH0WZdAKT0' # key
self.gearsecret = 'OfFLXs2NlqL3ecjkaClXhEUli' # secret
self.appid = 'ImageRaspi'
try: # TODO : comment if don't need netpie.
client.create(self.gearkey, self.gearsecret, self.appid, {'debugmode': True})
client.on_connect = self.callback_connect
client.setalias("doraemon")
client.on_message = self.callback_message
client.on_error = self.callback_error
client.subscribe("/mails")
client.connect()
except Exception as e:
pass
def start_connect(self):
self.mySignal.emit('load')
client.setname("remote")
client.setalias("pyqt")
client.on_connect = self.connection
client.on_message = self.subscription
client.on_disconnect = self.disconnect
client.subscribe("/remote")
client.connect()
def testCreateNetPieScopeR():
gearkey = "ExhoyeQoTyJS5Ac"
gearsecret = "gzDawaaHRe1KvQhepAw3WYuuGHjBsh"
appid = "p107microgear"
client.create(gearkey , gearsecret, appid, {'debugmode': True, 'scope': "r:/LetsShare,w:/LetsShare"})
client.setname("Python ja")
#client.subscribe("/LetsShare")
client.subscribe("/LetsPlay")
client.connect()
def receive_message(topic, message):
print topic + " " + message
while True:
time.sleep(3)
client.on_message = receive_message
def testCode5Case4(self):
"""subscribe the topic that it publishes"""
print('Code5Case4')
client.create(self.gearkey, self.gearsecret, self.appid)
client.subscribe(self.topic)
client.on_connect = MagicMock()
client.on_message = MagicMock()
client.connect()
time.sleep(connect_timeout)
self.assertTrue(client.on_connect.called)
self.connected = True
self.assertEqual(client.on_connect.call_count, 1)
client.publish(self.topic, self.message)
time.sleep(message_timeout)
self.assertTrue(client.on_message.called)
client.on_message.assert_called_with(self.expectedTopic, self.expectedMessage)
def testCode6Case5x1(self):
"""unsubscribe the invalid topic - no slash"""
try:
print("run helper...")
code = str(51)
args = ['python', 'helper.py', code]
p = subprocess.Popen(args, cwd=(helper_dir))
time.sleep(connect_worst_timeout)
self.invalidStr = "firstTopic"
client.create(self.gearkey, self.gearsecret, self.appid)
client.on_connect = MagicMock()
client.on_message = MagicMock()
client.connect()
time.sleep(connect_timeout)
self.assertTrue(client.on_connect.called)
self.connected = True
self.assertEqual(client.on_connect.call_count, 1)
self.assertFalse(client.on_message.called)
client.subscribe(self.topic)
time.sleep(message_timeout)
self.assertTrue(client.on_message.called)
client.on_message.assert_called_with(self.expectedTopic, self.expectedMessage)
client.on_message.reset_mock()
self.assertFalse(client.on_message.called)
client.unsubscribe(self.invalidStr)
time.sleep(connect_timeout)
self.assertTrue(client.on_message.called)
client.on_message.assert_called_with(self.expectedTopic, self.expectedMessage)
p.kill()
except Exception as e:
p.kill()
raise Exception(e.args)
logging.info("disconnected")
def writefeed():
data = int(time.time()) % 10
feeddat = {
"var1": data,
"var2": (data - 1) * 10,
"var3": (data + 5) * 20,
}
microgear.writeFeed("feed0001", feeddat, feedkey=netpiefeedkey)
microgear.setalias(aliasmy)
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/mails", qos=0)
microgear.connect(False)
while True:
if (microgear.connected == False):
time.sleep(0.5)
continue
microgear.chat(aliasmy, "Hello world." + str(int(time.time())))
microgear.publish('/mails', "Halo")
writefeed()
time.sleep(3)
# rospy.loginfo(hello_str)
# pub.publish(hello_str)
# rate.sleep()
#//////////////////////Netpie///////////////////////////////////
appid = "HappyIoT Naja"
gearkey = "HappyIoT Naja"
gearsecret = "HappyIoT Naja"
client.create(gearkey,gearsecret,appid,{'debugmode': True})
def connection():
print "Now I am connected with netpie"
def subscription(topic,message):
pub.publish(message)
print topic+" "+message
client.setname("doraemon")
client.on_connect = connection
client.on_message = subscription
client.subscribe("/mails")
client.connect(True)
#//////////////////////////////////////////////////////////////
#if __name__ == '__main__':
# try:
# talker()
# except rospy.ROSInterruptException:
# pass
print "Calibrate" + message
ser.write(message + "\r\n")
if topic == "/PudzaSOI/gearname/uno":
GPIO.output(relays[int(message[0])], int(message[1]))
def disconnect():
print "disconnect is work"
microgear.setalias("uno")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/cmd")
microgear.subscribe("/data")
microgear.subscribe("/eccalmsg")
microgear.connect(False)
while True:
y, m, d, h, mi, s, wd, wy, isd = time.localtime()
msg = ser.readline()
datalist = msg.split(',')
# print msg
if len(datalist) == 4:
temp = datalist[0]
ec = datalist[1]
x = datalist[2]
appid = "ekaratnida"
gearkey = 'jtD9ag08syPtqiK' # key
gearsecret = 'vDEEIuw9Ssj4OvbrBHmM4hZfa' # secret
client.create(gearkey, gearsecret, appid,
{'debugmode': True}) # สร้างข้อมูลสำหรับใช้เชื่อมต่อ
client.setalias("ekarat") # ตั้งชื่้อ
def callback_connect():
print("Now I am connected with netpie")
def callback_message(topic, message):
print(topic, ": ", message)
def callback_error(msg):
print("error", msg)
client.on_connect = callback_connect # แสดงข้อความเมื่อเชื่อมต่อกับ netpie สำเร็จ
client.on_message = callback_message # ให้ทำการแสดงข้อความที่ส่งมาให้
client.on_error = callback_error # หากมีข้อผิดพลาดให้แสดง
client.subscribe(
"/test"
) # ชื่อช่องทางส่งข้อมูล ต้องมี / นำหน้า และต้องใช้ช่องทางเดียวกันจึงจะรับส่งข้อมูลระหว่างกันได้
client.connect(
True
) # เชื่อมต่อ ถ้าใช้ True เป็นการค้างการเชื่อมต่อclient.on_message= callback_message # ให้ทำการแสดงข้อความที่ส่งมาให้
import microgear.client as client
import time
gearkey = "3Pz59oJzsIRox0g"
gearsecret = "DqOZKONNM0Hk9HZOwqc1e96FTzRIHs"
appid = "motatocity"
client.create(gearkey,gearsecret,appid,{'debugmode': True})
def connection():
print ("Now, I am connected with netpie")
def subscription(topic,message):
print (topic+" "+message)
def callback_message(topic, message) :
print ("I got message from ", topic, ": ", message)
client.setname("doraemon")
client.on_connect = connection
client.on_message = subscription
client.on_message= callback_message
client.subscribe("/chat")
client.connect()
while True:
#client.chat("doraemon","Hello world. "+str(int(time.time())))
client.on_message= callback_message
time.sleep(2)
def right():
myMotor.run(Adafruit_MotorHAT.BACKWARD)
for i in range(255):
print "RIGHT" + str(i)
myMotor.setSpeed(i)
time.sleep(0.001)
def left():
myMotor.run(Adafruit_MotorHAT.FORWARD)
for i in range(255):
print "LEFT" + str(i)
myMotor.setSpeed(i)
time.sleep(0.001)
def stop():
mode = 0
turnOffMotors()
client.setname("remote")
client.setalias("raspberrypi")
client.on_connect = connection
client.on_message = subscription
client.subscribe("/remote2")
client.connect(True)
if topic == "/PUDZAHydro/tempauto":
print "get auto"
with open("tempauto.txt", "w") as f:
f.write(message)
def disconnect():
print "disconnect is work"
microgear.setalias("reporter")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/nodemcu")
microgear.subscribe("/uno/amptemp")
microgear.subscribe("/uno/amphum")
microgear.subscribe("/uno/wtrtemp")
microgear.subscribe("/uno/flow")
microgear.subscribe("/uno/soilhum")
microgear.subscribe("/uno/rain")
microgear.subscribe("/uno/ec")
microgear.subscribe("/reporter")
microgear.subscribe("/sptemp")
microgear.subscribe("/sptempf")
microgear.subscribe("/tempauto")
microgear.connect(False)
alrain = 1
def callback_error(msg) :
#print(msg)
def callback_reject(msg) :
# print (msg)
#print ("Script exited")
exit(0)
def encode_base64(img_data):
encoded = None
try:
#compress it first.
compressed_data = zlib.compress(img_data.getvalue(),9)
#encode it to base64 string
encoded = base64.b64encode(compressed_data)
except:
pass
return encoded
def decode_base64(compressed_b64str=None,save_to_file=None):
try :
#firstly, decode it
decoded = base64.decodestring(compressed_b64str)
decompr = zlib.decompress(decoded)
#save it if is needed.
if save_to_file is not None:
with open(save_to_file,"wb") as fh:
fh.write(decompr)
else:
#just display on screen
w,h = 640,480
image = Image.open(BytesIO(decompr))
image.save('C:\\Users\\TO_MANG\\Documents\\testproject\\public\\test_snap.jpg')
#image.show()
except:
pass
this_name = 'n3a1'
those_name = 'n3a2'
this_role = 'receiver'
running = True
ready_to_receive = False
netpie.setname(this_name)
netpie.on_reject = callback_reject
netpie.on_connect = connection
netpie.on_message = subscription
netpie.on_error = callback_error
netpie.subscribe("/test")
netpie.connect(False)
if this_role == 'receiver' :
while running:
# print ("**** Search on receiver ****")
time.sleep(2)
pass
#print ("End")
else :
running = False
key = 'application/key'
secret = 'application/secret'
app = 'application/name/appid'
netpie.create(key, secret, app, {'debugmode': True})
def connection():
print "Now I am connected with netpie"
def subscription(topic, message):
print topic + " " + message
netpie.setname("RPi")
netpie.on_connect = connection
netpie.on_message = subscription
netpie.subscribe("/mails")
netpie.connect()
# random.randint(0,100) instead of temperature
# random.randint(0,50) instead of Humidity
while True:
netpie.chat("RPi",
str(random.randint(0, 100)) + "," + str(random.randint(0, 50)))
time.sleep(2)
def subscription(topic, message):
logging.info(topic + " " + message)
LED_State(message)
def disconnect():
logging.info("disconnected")
microgear.setalias("RaspiTUP")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/Led")
microgear.connect()
def LED_State(message):
print(message)
if message == "b'ON'":
GPIO.output(Red_LED, 1)
GPIO.output(Green_LED, 1)
GPIO.output(Blue_LED, 1)
LED_State = 1
microgear.chat("LED-Status", LED_State)
elif message == "b'OFF'":
GPIO.output(Red_LED, 0)
GPIO.output(Green_LED, 0)
GPIO.output(Blue_LED, 0)
def helper(createx=[], setaliasx=[], chatx=[], publishx=[], subscribex=[]):
print(createx, setaliasx,chatx,publishx,subscribex)
message = "hello"
received = False
if(len(createx) > 0):
print(microgear.gearkey)
client.create(createx[0],createx[1],createx[2],{'debugmode': True})
def on_connected():
print("connect")
def on_disconnected():
print("disconnected")
def on_message(topic, message):
print("message")
time.sleep(2)
ack = open(os.path.join(os.getcwd(),"../receiver.txt"), "w")
print(ack)
ack.write(message)
ack.close()
def on_present(gearkey):
print("present")
def on_absent(gearkey):
print("absent")
def on_warning(msg):
print("reject")
def on_info(msg):
print("info")
def on_error(msg):
print("error")
client.on_connect = on_connected
client.on_disconnect = on_disconnected
client.on_message = on_message
client.on_present = on_present
client.on_absent = on_absent
client.on_warning = on_warning
client.on_info = on_info
client.on_error = on_error
if(len(setaliasx) > 0):
client.setalias(setaliasx[0])
if(len(subscribex) > 0):
client.subscribe(subscribex[0])
client.resettoken()
client.connect(False)
if(len(chatx) > 0):
while True:
client.chat(chatx[0], message)
print('chitchat')
time.sleep(2)
if(len(publishx) > 0) :
while True:
client.publish(publishx[0], message)
print('pubpush')
time.sleep(2)
print("in helper file")
print(os.path.join(os.getcwd(),"microgear.cache"))
while True:
pass
print('Connection lost please connect module1 USB0')
try:
ser2 = serial.Serial('/dev/ttyUSB1',115200) # Sensor Elbow
except:
print('Connection lost please connect module2 USB1')
try:
ser3 = serial.Serial('/dev/ttyUSB2',115200) # Sensor wrist
except:
print('Connection lost please connect module3 USB2')
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
microgear.create(gearkey,gearsecret,appid,{'debugmode': True})
def connection():
print(' ')
def subscription(topic,message):
print(message)
def disconnect():
print(' ')
microgear.setalias("VisualStudio")
#microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/Topics")
microgear.connect(False)
while True:
if(microgear.connected):
microgear.chat("VisualStudio",ser1.readline()+','+ser2.readline()+','+ser3.readline())
print "Now I am connected with netpie"
def subscription(topic, message):
print topic + "=" + message
if topic == "/PudzaSOI/test_cmd":
print "Recv:" + message
def disconnect():
print "disconnect is work"
microgear.setalias("test")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/test_data")
microgear.subscribe("/test_cmd")
microgear.connect(False)
i = 0
while True:
i = i + 1
d = 't=' + str(i) + ',ec=' + str(i + 1) + ',' + str(i +
2) + ',ph=' + str(i +
3)
microgear.publish("/test_data", d, {"retain": True})
time.sleep(1)
print topic+"="+message
if topic == "/MELON/cmd" :
if message[1] == "1":
rset = True
else:
rset = False
GPIO.output(relays[int(message[0])], rset)
def disconnect():
print "disconnect is work"
microgear.setalias("PCU1")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/msg");
microgear.subscribe("/cmd");
microgear.connect(False)
while True:
y,m,d,h,mi,s,wd,wy,isd = time.localtime()
msg = ser.readline()
datalist = msg.split(',')
if len(datalist) == 3:
temp = datalist[0]
hh = datalist[1]
ec = datalist[2].rstrip()
data = {"ec": ec ,"temp":temp}
microgear.writeFeed("MelonFeed",data)
gearsecret = "DqOZKONNM0Hk9HZOwqc1e96FTzRIHs"
appid = "motatocity"
client.create(gearkey, gearsecret, appid, {'debugmode': True})
def connection():
print("Now, I am connected with netpie")
def subscription(topic, message):
print(topic + " " + message)
def callback_message(topic, message):
print("I got message from ", topic, ": ", message)
client.setname("doraemon")
client.on_connect = connection
client.on_message = subscription
client.on_message = callback_message
client.subscribe("/chat")
client.connect()
while True:
#client.chat("doraemon","Hello world. "+str(int(time.time())))
client.on_message = callback_message
time.sleep(2)
class StartWindows(QMainWindow):
def __init__(self, camera=None, parent=None):
super(StartWindows, self).__init__(parent=parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.detections = None
self.frame = None
self.files = []
self.tmp = []
self.start = 0
self.update_timer = QTimer()
self.update_timer.timeout.connect(self.update)
#User
self.Qr_User = ""
self.Point = 0
#button
self.ui.pushButton_2.clicked.connect(self.yolo_tiny)
self.ui.pushButton.clicked.connect(self.stop)
#camera
self.camera = cv2.VideoCapture(0)
self.update_timer.start(30)
#qr
self.qr = cv2.QRCodeDetector()
'''
def update2(self):
self.update_timer2.start(30)
ret,self.frame =self.camera.read()
self.frame=cv2.flip(self.frame,1)
cv2.imshow("img", img)
'''
def connection():
print("Now I am connected with netpie")
def subscription(topic, message):
logging.info(topic + " " + message)
def disconnect():
logging.debug("disconnect is work")
appid = "ProjectOs"
gearkey = "B0r3CNqaRtDjDf0"
gearsecret = "qRjL4WFFGCZqXY6hkpHFKkLIx"
client.create(gearkey, gearsecret, appid, {'debugmode': True})
client.setname("doraemon")
client.on_connect = connection
client.on_message = subscription
client.subscribe("/mails")
client.connect()
def yolo_tiny(self):
self.start = 1
self.execution_path = os.getcwd()
self.detector = ObjectDetection()
self.detector.setModelTypeAsTinyYOLOv3()
self.detector.setModelPath(
os.path.join(self.execution_path, "yolo-tiny.h5"))
self.detector.loadModel(detection_speed="flash")
print("###you are use yolo_tiny model###")
def update(self):
if (self.start == 0):
print("QR")
ret, self.frame = self.camera.read()
decodedObjects = pyzbar.decode(self.frame)
for obj in decodedObjects:
if obj.data:
self.Qr_User = str(obj.data)
self.Qr_User = self.Qr_User[2:len(self.Qr_User) - 1]
print(self.Qr_User)
self.frame = cv2.flip(self.frame, 1)
self.frame = cv2.resize(self.frame, (891, 501))
height, width, channel = self.frame.shape
bytesPerLine = 3 * width
qImg = QImage(self.frame.data, width, height, bytesPerLine,
QImage.Format_RGB888).rgbSwapped()
pixmap01 = QPixmap.fromImage(qImg)
pixmap_image = QPixmap(pixmap01)
self.ui.label.setPixmap(pixmap_image)
self.ui.user_id.setText(self.Qr_User)
self.ui.label.show()
if (self.start == 1):
ret, self.frame = self.camera.read()
self.frame = cv2.flip(self.frame, 1)
#detected
custom_objects = self.detector.CustomObjects(bottle=True)
detected_image_array, self.detections = self.detector.detectCustomObjectsFromImage(
custom_objects=custom_objects,
input_type="array",
input_image=self.frame,
output_type="array")
for eachObject in self.detections:
print(eachObject["name"], " : ",
(eachObject["percentage_probability"]), " : ",
eachObject["box_points"])
if int(eachObject["percentage_probability"]) >= 50:
self.Point += 1
time.sleep(0.5)
print(self.Point)
#resize
detected_image_array = cv2.resize(detected_image_array, (891, 501))
height, width, channel = detected_image_array.shape
bytesPerLine = 3 * width
qImg = QImage(detected_image_array.data, width, height,
bytesPerLine, QImage.Format_RGB888).rgbSwapped()
pixmap01 = QPixmap.fromImage(qImg)
pixmap_image = QPixmap(pixmap01)
self.ui.label.setPixmap(pixmap_image)
self.ui.user_id.setText(self.Qr_User)
self.ui.user_point.setText(str(self.Point))
self.ui.label.show()
'''
def score():
d=self.detections
for eachObject in d:
if int(eachObject["percentage_probability"]) >=50 :
self.Point+=1
print(self.Point)
'''
def stop(self):
#ส่งข้อมูลช่วงนี้ก่อนแล้วเคลียค่า
print(self.Qr_User)
print(self.Point)
client.publish("/Point2", str(self.Point))
client.publish("/Name", str(self.Qr_User))
client.publish("/Mix", (str(self.Qr_User) + "," + str(self.Point)))
self.start = 0
self.Qr_User = ""
self.Point = 0
self.ui.user_point.setText(str(self.Point))
print(self.Qr_User)
print(self.Point)
def start(self):
self.update_timer.start(30)
def disconnect():
logging.debug("disconnect is work")
microgear.setalias("VisualStudio")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/Topic")
microgear.connect(False)
if __name__ == '__main__':
import sys, getopt
print(__doc__)
args, video_src = getopt.getopt(sys.argv[1:], '',
['cascade=', 'nested-cascade='])
try:
video_src = video_src[0]
except:
video_src = 0
args = dict(args)
cascade_fn = args.get(
dbx.files_upload(f.read(), '/cam/' + filename)
def callback_error(msg):
print(msg)
def callback_reject(msg):
print(msg)
print("Script exited")
exit(0)
imageWidth = 1280
imageHeight = 720
camera_index = 0
this_name = 'CAMERA'
running = True
ready_to_send = False
netpie.setname(this_name)
netpie.on_reject = callback_reject
netpie.on_connect = connection
netpie.on_message = subscription
netpie.on_error = callback_error
netpie.subscribe("/camera")
netpie.connect(False)
while True:
pass
def connection():
print "Now I am connected with netpie"
def subscription(topic,message):
# print topic+"="+message
if topic == "/PUDZAHydro/eccal" :
ser.write("1"+message)
def disconnect():
print "disconnect is work"
microgear.setalias("raspiPython")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/eccal");
microgear.subscribe("/eccalmsg");
microgear.subscribe("/uno/amptemp");
microgear.subscribe("/uno/amphum");
microgear.subscribe("/uno/wtrtemp");
microgear.subscribe("/uno/flow");
microgear.subscribe("/uno/soilhum");
microgear.subscribe("/uno/rain");
microgear.subscribe("/uno/ec");
microgear.connect(False)
while True:
msg = ser.readline()
# print msg
# microgear.chat("htmlgear",msg)
def disconnect():
print "disconnect is work"
def callback_present(gearkey):
print gearkey + " become online."
def callback_absent(gearkey):
print gearkey + " become offline."
microgear.setalias("Client")
microgear.on_present = callback_present
microgear.on_absent = callback_absent
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/data")
os.system('rm microgear.cache')
#client.connect()
microgear.connect()
a = "E46F1361640A,-55,E46F13612900,-79,84C9B2A4DC59,-89,6C198F0CF97A,-90,6C198F0CF8FE,-84,48EE0C409820,-83,D4612E8A41C8,-88,048D388B78A3,-92,84C9B2A4DC58,-90,EC086B9BF001,-57,94FBB270D170,-37,A42BB0FD1059,-79,C83A350C8FB8,-84,28285DCFFDE8,-91,EC086B9C2172,-88,14D64D8E6DDC,-79,"
# a = "aaaaaa,-55,bbbbbb,-43,cccccc,-43,dddddd,-53,cccccc,-60,eeeeee,-49,ffffff,-50,gggggg,-39,hhhhhh,-45"
while (True):
# microgear.publish("/data",a)
time.sleep(10)
microgear.create(GEARKEY, GEARSECRET, APPID, {'debugmode': True})
def connection():
logging.info("Now I am connected with netpie")
def subscription(topic, message):
logging.info(topic + " " + message)
def disconnect():
logging.info("disconnected")
microgear.setalias("bot")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/botcmd")
microgear.connect()
### SETUP BOARD ###
IO.setmode(IO.BOARD)
solenoid_pin = 32
ledMatrix_cs_pin = 8
proximity_pin = 22
motor_pins = [38, 40, 35, 37]
### SETUP PERIPHERALS ###
IO.setup(solenoid_pin, IO.OUT) # solenoid
IO.setup(proximity_pin, IO.IN) # proximity
mat = LEDMatrix(ledMatrix_cs_pin) # LED Matrix
if topic == "/PUDZAHydro/nodemcu":
data = message.split(',')
lux = data[0]
temp = data[1]
y, m, d, h, mi, s, wd, wy, isd = time.gmtime()
if s % 15 == 0:
payload = {'api_key': api_key, 'field1': str(message)}
r = requests.post(urlThingspeak, params=payload, verify=False)
print r.text
if mi == 56 and s == 0:
print "@%s send to line" % mi
payload = {
'value1':
'Report<br>Light = ' + lux + ' lux<br>' + 'Temp = ' + temp + ' C'
}
r = requests.post(url, data=payload)
def disconnect():
print "disconnect is work"
microgear.setalias("reporter")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/nodemcu")
microgear.connect(True)
def callback_present(gearkey):
print gearkey + " become online."
def callback_absent(gearkey):
print gearkey + " become offline."
microgear.setalias("Server")
microgear.on_present = callback_present
microgear.on_absent = callback_absent
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/data/1")
microgear.subscribe("/data/2")
microgear.subscribe("/data/3")
microgear.subscribe("/data/4")
microgear.subscribe("/Station_data/1")
microgear.subscribe("/Station_data/2")
microgear.subscribe("/Station_data/3")
microgear.subscribe("/Station_data/4")
microgear.subscribe("/dataControl")
# microgear.subscribe("/web")
os.system('rm microgear.cache')
#client.connect()
microgear.connect()
count_reset = 0
count_Notify = 0
def onConnection():
microgear.setalias("Raaspbery Pi - Python")
microgear.on_connect = connection
microgear.on_disconnect = disconnect
microgear.on_message = subscription
microgear.on_present = present
microgear.on_absent = absent
microgear.on_warning = warning
microgear.on_info = info
microgear.on_error = error
microgear.subscribe("/token")
microgear.subscribe("/refresh")
microgear.subscribe("/settingStandard")
microgear.subscribe("/settingDetails")
microgear.subscribe("/controlDevices")
microgear.subscribe("/alarm")
microgear.connect()
left()
elif message=="RIGHT":
right()
def right():
myMotor.run(Adafruit_MotorHAT.BACKWARD)
for i in range(255):
print "RIGHT"+str(i)
myMotor.setSpeed(i)
time.sleep(0.001)
def left():
myMotor.run(Adafruit_MotorHAT.FORWARD)
for i in range(255):
print "LEFT"+str(i)
myMotor.setSpeed(i)
time.sleep(0.001)
def stop():
mode = 0
turnOffMotors()
client.setname("remote")
client.setalias("raspberrypi")
client.on_connect = connection
client.on_message = subscription
client.subscribe("/remote2")
client.connect(True)
import sys
if len(sys.argv) > 1:
# NETPIE appid and apikeys
appid = "SKHOME"
gearkey = "VXM0JO7qieJFU4u"
gearsecret = "tB9D6qn9poYC2FEgFexxjMIDD"
microgear.create(gearkey, gearsecret, appid, {'debugmode': False})
def connection():
print "Now I am connected with netpie"
def subscription(topic, message):
print topic + "=" + message
def disconnect():
print "disconnect is work"
microgear.setalias("strw_test")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/strawberry_watering")
microgear.connect(False)
delaytime = sys.argv[1]
microgear.publish("/strawberry_watering", delaytime)
else:
print "Please enter delay time.!!"
microgear.chat("outdoor/temp", json.dumps(itemlist))
time.sleep(5)
def connection():
logging.info("Now I am connected with netpie")
def subscription(topic, message):
logging.info(topic + " " + message)
def disconnect():
logging.debug("disconnect is work")
if __name__ == "__main__":
microgear.setalias("MyRaspberryPI")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/mails")
microgear.connect(False)
if (microgear.connected):
itemlist, itemlist_key, CustomerAddress = RetreiveData()
microgear.chat("outdoor/temp", json.dumps(itemlist))
while True:
ActivateCamera()
cache_file.close()
time.sleep(6)
client.create(gearkey,gearsecret,appid,{'debugmode': True})
def connection():
print("Now I am connected with netpie")
def subscription(topic,message):
print(topic+" "+message)
client.unsubscribe("/secondTopic")
# client.chat("mainPython","Hey guy."+str(int(time.time())))
# client.setalias("doraemon2")
client.subscribe("/firstTopic")
print("shoud")
client.on_connect = connection
client.on_message = subscription
# client.subscribe("/mails")
# client.subscribe("/firstTopic")
client.connect(False)
#client.chat("","Hello world."+str(int(time.time())))
#need delay
while(True):
pass
print("end")
#os.remove(os.path.join(os.getcwd()+"/receiver.txt"))
import json
import microgear.client as client
import time
gearkey = "Djmh3H2yte6CIrW"
gearsecret = "43J9u4sJmMe34omGvLdu51JF74prLT"
appid = "NSC2016SEAH"
client.create(gearkey, gearsecret, appid)
def connection():
print "Now I am connected with netpie"
def subscription(topic, message):
print topic + " " + message
with open('data.json', 'w') as outfile:
data = '{\"value1\":" + float(message) +",\"value2\":300}'
json.dump(data, outfile)
client.setalias("server")
client.on_connect = connection
client.on_message = subscription
client.subscribe("/Value")
client.connect(True)
import microgear.client as microgear
import time
import logging
appid = <appid>
gearkey = <gearkey>
gearsecret = <gearsecret>
microgear.create(gearkey,gearsecret,appid,{'debugmode': True})
def connection():
logging.debug("Now I am connected with netpie")
def subscription(topic,message):
logging.debug(topic+" "+message)
def disconnect():
logging.debug("disconnect is work")
microgear.setalias("doraemon")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/mails")
microgear.connect(False)
while True:
microgear.chat("doraemon","Hello world."+str(int(time.time())))
time.sleep(3)
camera = PiCamera()
camera.resolution=(640,480)
this_name = 'n3a2'
those_name = 'n3a1'
this_role = 'sender'
running = True
ready_to_send = False
netpie.setname(this_name)
netpie.on_reject = callback_reject
netpie.on_connect = connection
netpie.on_message = subscription
netpie.on_error = callback_error
netpie.subscribe("/test")
netpie.connect(False)
if this_role=='sender':
while not ready_to_send :
netpie.chat(those_name,'ruok')
time.sleep(2)
snap_shot = snap()
b64 = encode_base64(snap_shot)
netpie.chat(those_name,b64)
time.sleep(2)
else :
def disconnect():
print "disconnect is work"
def callback_present(gearkey) :
print gearkey+" become online."
def callback_absent(gearkey) :
print gearkey+" become offline."
microgear.setalias("Server")
microgear.on_present = callback_present
microgear.on_absent = callback_absent
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/data")
microgear.subscribe("/Station_data")
os.system('rm microgear.cache')
#client.connect()
microgear.connect()
count_reset = 0
count_Notify = 0
while(True):
# microgear.publish("/data","test")
# optimize.trilateration(2.22478863989/5,7.89384797649/5,3.5261/5)
# optimize.trilateration(5/5,7/5,5/5)
# send = input("what word to send esp8266:")
# microgear.chat("esp8266",send)
# microgear.chat("client_station",send)
# print(c)
if t != 0 and h != 0 and c != 0:
LINE_ACCESS_TOKEN = "EQLOgdnKBxTHyeWMqcm5ISg9vFPWE5BCKEDubnJC2PD"
url = "https://notify-api.line.me/api/notify"
mes = "Temperature1 = " + t + "\n"
mes += "Humid = " + h + "\n"
mes += "Temperature2 = " + c + "\n"
data = ({'message': mes})
# data = ("t,h,c"}
LINE_HEADERS = {"Authorization": "Bearer " + LINE_ACCESS_TOKEN}
session = requests.Session()
session.post(url, headers=LINE_HEADERS, data=data)
print(t, h, c)
exit()
def disconnect():
print("disconnect is work")
microgear.setalias("LineNotify")
microgear.on_connect = connection
microgear.on_message = subscription
microgear.on_disconnect = disconnect
microgear.subscribe("/station1/#")
microgear.connect(True)
import json
import microgear.client as client
import time
gearkey = "Djmh3H2yte6CIrW"
gearsecret = "43J9u4sJmMe34omGvLdu51JF74prLT"
appid = "NSC2016SEAH"
client.create(gearkey,gearsecret,appid)
def connection():
print "Now I am connected with netpie"
def subscription(topic,message):
print topic+" "+message
with open('data.json', 'w') as outfile:
data = '{\"value1\":" + float(message) +",\"value2\":300}'
json.dump(data, outfile)
client.setalias("server")
client.on_connect = connection
client.on_message = subscription
client.subscribe("/Value")
client.connect(True)
