def MQTT_Init():
# 创建一个mqtt实例
c = MQTTClient(client_id=CLIENT_ID,
server=SERVER,
port=PORT,
user=USER,
password=PASSWORD,
keepalive=30) # 必须要 keepalive=30 ,否则连接不上
# 设置消息回调
c.set_callback(sub_cb)
# 建立连接
try:
c.connect()
except Exception as e:
print('!!!,e=%s' % e)
return
# c.connect()
# 订阅主题
c.subscribe(SUB_TOPIC.format(IMEI))
# 发布消息
Payload = '{"DeviceName":"{}","msg":"test publish"}'.format(IMEI)
c.publish(PUB_TOPIC.format(IMEI), Payload)
while True:
c.wait_msg()
if state == 1:
break
# 关闭连接
c.disconnect()
def envioMQTT(server=SERVER, topic="/foo", dato=None):
try:
c = MQTTClient(CLIENT_ID, server)
c.connect()
c.publish(topic, dato)
sleep_ms(200)
c.disconnect()
#led.value(1)
except Exception as e:
pass
def envioMQTT(server=SERVER, topic="/foo", dato=None):
try:
c = MQTTClient(CLIENT_ID, server)
c.connect()
c.publish(topic, dato)
sleep_ms(200)
c.disconnect()
#led.value(1)
except Exception as e:
pass
class MqttClient():
'''
mqtt init
'''
def __init__(self, clientid, server, port, pw):
self.clientid = clientid
self.pw = pw
self.server = server
self.port = port
self.uasename = clientid
self.client = None
def connect(self):
self.client = MQTTClient(self.clientid, self.server, self.port, self.uasename, self.pw, keepalive=300)
self.client.set_callback(self.sub_cb)
self.client.connect()
def sub_cb(self, topic, msg):
print("Subscribe Recv: %s, %s" % (topic.decode(), msg.decode()))
def subscribe(self, topic, qos=0):
self.client.subscribe(topic, qos)
def publish(self, topic, msg, qos=0):
self.client.publish(topic, msg, qos)
def disconnect(self):
self.disconnect()
def __loop_forever(self, t):
# print("loop_forever")
try:
self.client.ping()
except:
return -1
def __listen(self):
while True:
try:
self.client.wait_msg()
except OSError as e:
return -1
def start(self):
_thread.start_new_thread(self.__listen, ())
t = Timer(1)
t.start(period=20000, mode=t.PERIODIC, callback=self.__loop_forever)
class Mqtt_Class():
def __init__(self):
# 创建一个mqtt实例
self.client_id = "868540051778302"
self.downtopic = "quec/868540051778302/down"
self.uptopic = "quec/868540051778302/up"
self.mqttserver = "southbound.quectel.com"
self.mqttport = 1883
self.uername = "868540051778302"
self.passwd = "d40332b8211097ffbb0e2645c2efec95"
self.mqtt_client = MQTTClient(self.client_id, self.mqttserver,
self.mqttport, self.uername, self.passwd)
def mqtt_recv_callback(self, topic, msg):
print("Subscribe Recv: Topic={},Msg={}".format(topic.decode(),
msg.decode()))
q_recv_thread.recv_thread.recv_callback(topic, msg.decode())
def mqtt_set_recv_callback(self):
# 设置消息回调
self.mqtt_client.set_callback(self.mqtt_recv_callback)
def connect(self):
#建立连接
self.mqtt_client.connect()
def sub_topic(self, topic):
# 订阅主题
self.mqtt_client.subscribe(topic)
def put_msg(self, msg, qos=0):
# 发布消息
self.mqtt_client.publish(self.uptopic, msg, qos)
def wait_msg(self):
self.mqtt_client.wait_msg()
def disconnect(self):
# 关闭连接
self.mqtt_client.disconnect()
def sendmq(msg):
UNIQUE_ID = ubinascii.hexlify(machine.unique_id())
MQTT_BROKER = "192.168.2.68"
MQTT_PORT = 1883
MQTT_TOPIC = "iot-2/type/lopy/id/" + "buhardilla" + "/evt/presence1/fmt/json"
print(MQTT_TOPIC)
mqtt_client = MQTTClient(UNIQUE_ID, MQTT_BROKER, port=MQTT_PORT)
mqtt_client.settimeout = settimeout
mqtt_client.set_callback(t3_publication)
mqtt_client.connect()
result = mqtt_client.publish(MQTT_TOPIC, json.dumps(msg))
mqtt_client.disconnect()
return result
def MQTT_Init():
# 创建一个mqtt实例
c = MQTTClient(client_id=CLIENT_ID,
server=SERVER,
port=PORT,
user=USER,
password=PASSWORD,
keepalive=30) # 必须要 keepalive=30 ,否则连接不上
# 设置消息回调
c.set_callback(sub_cb)
# 建立连接
c.connect()
# 订阅主题
c.subscribe('$oc/devices/{}/sys/messages/down'.format(DEVICE_ID))
msg = b'''{
"services": [{
"service_id": "WaterMeterControl",
"properties": {
"state": "T:15c, H: 85% "
},
"event_time": "20151212T121212Z"
}
]
}'''
# 发布消息
c.publish('$oc/devices/{}/sys/properties/report'.format(DEVICE_ID), msg)
while True:
c.wait_msg()
if state == 1:
break
# 关闭连接
c.disconnect()
def main():
client = MQTTClient(AIO_CLIENT_ID, AIO_SERVER, AIO_PORT, AIO_USER, AIO_KEY)
client.connect()
for ao, vcc in zip(ao_pins, vcc_pins):
feed = "feed_id" + ao
print(feed)
volts = (moist_sensor(ao, vcc) / 4.096)
client.publish(feed, str(volts))
time.sleep(1)
humid = int(humid_temp_sensor(True)[1])
client.publish(AIO_HUMIDITY_FEED, str(humid))
temp = int(humid_temp_sensor(True)[0])
client.publish(AIO_TEMPERATURE_FEED, str(temp))
client.disconnect()
def sense(self):
print('Temperature Sensing and Reporting via MQtt')
client = MQTTClient("beersense", "mqtt.dynamicdevices.co.uk", port=1883)
client.connect()
client.publish("sensors/brewing/status/1", "Running")
d=DS18X20(Pin('G17', mode=Pin.OUT))
while(1):
result=d.read_temps()
if(len(result) == 0):
print("Error Reading from DS18X20")
client.publish("sensors/brewing/status/1", "Sensor Error")
else:
if(result[0] > 100.0):
print("Temp: Read Error")
client.publish("sensors/brewing/status/1", "Sensor Error")
else:
print("Temp: " + str(result[0]) + " C")
client.publish("sensors/brewing/temp/1", str(result[0]))
time.sleep(10)
class BluestoneMqtt(object):
inst = None
def __init__(self, client_id, server, port, user, password, sub_topic,
pub_topic):
BluestoneMqtt.inst = self
self.bs_config = None
self.bs_gpio = None
self.bs_pwm = None
self.bs_fota = None
self.bs_uart = None
self.sn = bluestone_common.BluestoneCommon.get_sn()
self.client_id = client_id
self.server = server
self.port = port
self.user = user
self.password = password
self.subscribe_topic = sub_topic
self.publish_topic = pub_topic
self.client = None
self._is_sub_callback_running = False
self._is_message_published = False
def _init_mqtt(self):
self.bs_config = bluestone_config.BluestoneConfig(
'bluestone_config.json')
self.bs_data_config = bluestone_config.BluestoneConfig(
'bluestone_data.json')
self.bs_gpio = bluestone_gpio.BluestoneGPIO()
self.bs_pwm = bluestone_pwm.BluestonePWM()
self.bs_fota = bluestone_fota.BluestoneFOTA()
self.bs_uart = bluestone_uart.BlueStoneUart(None)
# 创建一个MQTT实例
self.client = MQTTClient(client_id=self.client_id,
server=self.server,
port=self.port,
user=self.user,
password=self.password,
keepalive=30)
_mqtt_log.info(
"Start a new mqtt client, id:{}, server:{}, port:{}".format(
self.client_id, self.server, self.port))
self.client.set_callback(self._sub_callback) # 设置消息回调
self.client.connect() # 建立连接
#sub_topic = self.subscribe_topic.format(self.sn)
_mqtt_log.info("Subscribe topic is {}".format(self.subscribe_topic))
self.client.subscribe(self.subscribe_topic) # 订阅主题
def _update_gpio_status(self, io_level_list):
try:
self.bs_data_config.update_config('gpio', io_level_list)
message = {}
message['gpio'] = io_level_list
_mqtt_log.info("Data configuration is {}".format(message))
self.publish(message)
except Exception as err:
_mqtt_log.error(
"Cannot update gpio level list, the error is {}".format(err))
def _handle_callback(self, key, config):
result = False
try:
if key.startswith('uart'):
# first payload then config
payload = self.bs_config.get_value(config, "payload")
if payload:
self.bs_uart.uart_write(key, ujson.dumps(payload))
uart_config = self.bs_config.get_value(config, "config")
if uart_config:
self.bs_config.update_config(key, uart_config)
self.bs_data_config.update_config(key, uart_config)
result = True
elif key.startswith('pwm'):
id = self.bs_pwm.get_id_by_name(key)
is_breathe = self.bs_config.get_int_value(config, "breathe")
frequency = self.bs_config.get_int_value(config, "frequency")
duty = self.bs_config.get_float_value(config, "duty")
if is_breathe:
self.bs_pwm.start_breathe(id, frequency)
else:
self.bs_pwm.start_once(id, frequency, duty)
elif key.startswith('timer'):
self.bs_config.update_config(key, config)
self.bs_data_config.update_config(key, config)
result = True
elif key == 'gpio':
io_level_list = self.bs_gpio.read_all()
io_name_list = self.bs_gpio.get_io_name_list()
for gpio_key in config.keys():
if gpio_key not in io_name_list:
continue
level = self.bs_config.get_int_value(config, gpio_key)
if level is not None:
id = self.bs_gpio.get_id_by_name(gpio_key)
self.bs_gpio.write(id, level)
io_level_list[gpio_key] = level
self._update_gpio_status(io_level_list)
elif key == 'fota':
mode = self.bs_config.get_int_value(config, "mode")
if mode == 0:
url_list = self.bs_config.get_value(config, "url")
self.bs_fota.start_fota_app(url_list)
elif mode == 1:
url = self.bs_config.get_value(config, "url")
self.bs_fota.start_fota_firmware(url)
result = True
except Exception as err:
_mqtt_log.error(
"Cannot handle callback for mqtt, the error is {}".format(err))
return result
def _sub_callback_internal(self, topic, msg):
try:
message = msg.decode()
_mqtt_log.info("Subscribe received, topic={}, message={}".format(
topic.decode(), message))
restart = False
config_setting = ujson.loads(message)
config_keys = config_setting.keys()
for key in config_setting:
config = config_setting[key]
key_exist = self.bs_config.check_key_exist(key)
if key_exist:
if not restart:
restart = self.bs_config.mqtt_check_key_restart(key)
result = self._handle_callback(key, config)
if result:
restart = True
if restart:
restart = False
_mqtt_log.info(
"New configuration was received from mqtt, restarting system to take effect"
)
Power.powerRestart()
except Exception as err:
_mqtt_log.error(
"Cannot handle subscribe callback for mqtt, the error is {}".
format(err))
finally:
self._is_sub_callback_running = False
# 云端消息响应回调函数
def _sub_callback(self, topic, msg):
if self._is_sub_callback_running:
_mqtt_log.error(
"Subscribe callback function is running, skipping the new request"
)
return
self._is_sub_callback_running = True
_thread.start_new_thread(self._sub_callback_internal, (topic, msg))
def _mqtt_publish(self, message):
#pub_topic = self.publish_topic.format(self.sn)
#message = {"Config":{},"message":"MQTT hello from Bluestone"}
if self.client is not None:
self.client.publish(self.publish_topic, message)
self._is_message_published = True
_mqtt_log.info("Publish topic is {}, message is {}".format(
self.publish_topic, message))
def _wait_msg(self):
while True:
if self.client is not None:
self.client.wait_msg()
utime.sleep_ms(300)
def is_message_published(self):
return self._is_message_published
def start(self):
self._init_mqtt()
_thread.start_new_thread(self._wait_msg, ())
def publish(self, message):
network_state = bluestone_common.BluestoneCommon.get_network_state()
if network_state != 1:
_mqtt_log.error(
"Cannot publish mqtt message, the network state is {}".format(
network_state))
return
#_mqtt_log.info("Publish message is {}".format(message))
#self._mqtt_publish(ujson.dumps(message))
self._is_message_published = False
_thread.start_new_thread(self._mqtt_publish, ([ujson.dumps(message)]))
def connect(self):
if self.client is not None:
self.client.connect()
_mqtt_log.info("MQTT connected")
def disconnect(self):
if self.client is not None:
self.client.disconnect()
_mqtt_log.info("MQTT disconnected")
def close(self):
self.disconnect()
self.client = None
_mqtt_log.info("MQTT closed")
class Game():
def __init__(self, playerName, computerName): #初始化
#网络设定
#WiFi名称和密码
self.wifi_name = "NEUI"
self.wifi_SSID = "NEUI3187"
#MQTT服务端信息
SERVER = "112.125.89.85" #MQTT服务器地址
SERVER_PORT = 3881 #MQTT服务器端口
DEVICE_ID = "wc001" #设备ID
TOPIC1 = b"/cloud-skids/online/dev/" + DEVICE_ID
self.TOPIC2 = b"/cloud-skids/message/server/" + DEVICE_ID
CLIENT_ID = "f25410646a8348f8a1726a3890ad8f82"
#设备状态
ON = "1"
OFF = "0"
#对方的选择
self.d = ["1", "2", "3"]
self.choose = 0
self.mark = 0
#启动网络连接
self.do_connect()
gc.collect()
self.client = MQTTClient(CLIENT_ID, SERVER, SERVER_PORT)
self.client.set_callback(self.sub_cb) #设置回调
self.client.connect()
print("连接到服务器：%s" % SERVER)
self.client.publish(TOPIC1, ON) #发布“1”到TOPIC1
self.client.subscribe(self.TOPIC2) #订阅TOPIC
#游戏设定
self.gameStart = False
self.playerName = playerName
self.computerName = computerName
self.playerScore = 0
self.computerScore = 0
self.equalNum = 0
self.playerStatus = 0
self.playerMessage = ""
self.computerStatus = 0
self.computerMessage = ""
for p in pins:
keys.append(Pin(p, Pin.IN))
self.displayInit()
def do_connect(self):
sta_if = network.WLAN(network.STA_IF) #STA模式
ap_if = network.WLAN(network.AP_IF) #AP模式
if ap_if.active():
ap_if.active(False) #关闭AP
if not sta_if.isconnected():
print('Connecting to network...')
sta_if.active(True) #激活STA
sta_if.connect(self.wifi_name, self.wifi_SSID) #WiFi的SSID和密码
while not sta_if.isconnected():
pass
print('Network config:', sta_if.ifconfig())
def sub_cb(self, topic, message):
message = message.decode()
print("choose is :", self.choose)
self.choose = int(message)
print("mark is :", self.mark)
if self.choose > 20: #来自2号自己的信息，不判断
print("对方尚未选择出拳")
return
else:
self.mark = self.mark + 1
print("player1 choose is :", self.choose)
self.computerStatus = self.choose - 10
if (self.computerStatus == 1):
self.computerMessage = "%s出拳为：剪刀" % self.computerName
bmp_jiandao.draw(150, 140)
if (self.computerStatus == 2):
self.computerMessage = "%s出拳为：石头" % self.computerName
bmp_shitou.draw(150, 140)
if (self.computerStatus == 3):
self.computerMessage = "%s出拳为：布 " % self.computerName
bmp_bu.draw(150, 140)
#显示电脑和玩家的出拳信息
text.draw(self.playerMessage, 20, 84, 0x000000, 0xffffff)
text.draw(self.computerMessage, 20, 100, 0x000000, 0xffffff)
#判断胜负并显示结果
if self.mark % 2 == 0: #如果双方都完成选择
resultMessage = " 平局 "
if self.computerStatus == 0:
return
elif (self.playerStatus == self.computerStatus):
self.equalNum += 1
elif (self.playerStatus == 1 and self.computerStatus == 3):
resultMessage = "%s胜出" % self.playerName
self.playerScore += 1
elif (self.playerStatus == 2 and self.computerStatus == 1):
resultMessage = "%s胜出" % self.playerName
self.playerScore += 1
elif (self.playerStatus == 3 and self.computerStatus == 2):
resultMessage = "%s胜出" % self.playerName
self.playerScore += 1
elif (self.computerStatus == 1 and self.playerStatus == 3):
resultMessage = "%s胜出" % self.computerName
self.computerScore += 1
elif (self.computerStatus == 2 and self.playerStatus == 1):
resultMessage = "%s胜出" % self.computerName
self.computerScore += 1
elif (self.computerStatus == 3 and self.playerStatus == 2):
resultMessage = "%s胜出" % self.computerName
self.computerScore += 1
text.draw(resultMessage, 90, 210, 0x000000, 0xffffff)
self.updateTotolArea()
def displayInit(self, x=10, y=10, w=222, h=303):
#显示游戏规则信息
mentionStr1 = "游戏规则："
mentionStr2 = "按键1.剪刀 按键2.石头"
mentionStr3 = "按键3.布 按键4.结束"
text.draw(mentionStr1, 20, 20, 0x000000, 0xffffff)
text.draw(mentionStr2, 20, 36, 0x000000, 0xffffff)
text.draw(mentionStr3, 20, 52, 0x000000, 0xffffff)
text.draw("-------------", 20, 68, 0x000000, 0xffffff)
self.updateTotolArea()
#设置游戏运行状态
self.gameStart = True
def pressKeyboardEvent(self, key):
keymatch = ["Key1", "Key2", "Key3", "Key4"]
#游戏还未开始，不必处理键盘输入
if (self.gameStart == False):
return
print(keymatch[key])
self.mark = self.mark + 1
if (keymatch[key] == "Key1"):
self.playerStatus = 1
self.playerMessage = "%s出拳为：剪刀" % self.playerName
self.client.publish(self.TOPIC2,
"2" + self.d[self.playerStatus - 1])
bmp_jiandao.draw(40, 140)
elif (keymatch[key] == "Key2"):
self.playerStatus = 2
self.playerMessage = "%s出拳为：石头" % self.playerName
self.client.publish(self.TOPIC2,
"2" + self.d[self.playerStatus - 1])
bmp_shitou.draw(40, 140)
elif (keymatch[key] == "Key3"):
self.playerStatus = 3
self.playerMessage = "%s出拳为：布 " % self.playerName
self.client.publish(self.TOPIC2,
"2" + self.d[self.playerStatus - 1])
bmp_bu.draw(40, 140)
else:
text.draw("游戏结束", 90, 210, 0x000000, 0xffffff)
#设置游戏运行状态
self.gameStart = False
return
#电脑的出拳为一个随机值
#二号玩家收到11-13
print("choose is :", self.choose)
if (self.choose > 20 or self.mark % 2 == 1):
print("对方尚未选择出拳")
return
else:
self.computerStatus = self.choose - 10
if (self.computerStatus == 1):
self.computerMessage = "%s出拳为：剪刀" % self.computerName
bmp_jiandao.draw(150, 140)
if (self.computerStatus == 2):
self.computerMessage = "%s出拳为：石头" % self.computerName
bmp_shitou.draw(150, 140)
if (self.computerStatus == 3):
self.computerMessage = "%s出拳为：布 " % self.computerName
bmp_bu.draw(150, 140)
#显示电脑和玩家的出拳信息
text.draw(self.playerMessage, 20, 84, 0x000000, 0xffffff)
text.draw(self.computerMessage, 20, 100, 0x000000, 0xffffff)
#判断胜负并显示结果
resultMessage = " 平局 "
if self.computerStatus == 0:
return
elif (self.playerStatus == self.computerStatus):
self.equalNum += 1
elif (self.playerStatus == 1 and self.computerStatus == 3):
resultMessage = "%s胜出" % self.playerName
self.playerScore += 1
elif (self.playerStatus == 2 and self.computerStatus == 1):
resultMessage = "%s胜出" % self.playerName
self.playerScore += 1
elif (self.playerStatus == 3 and self.computerStatus == 2):
resultMessage = "%s胜出" % self.playerName
self.playerScore += 1
elif (self.computerStatus == 1 and self.playerStatus == 3):
resultMessage = "%s胜出" % self.computerName
self.computerScore += 1
elif (self.computerStatus == 2 and self.playerStatus == 1):
resultMessage = "%s胜出" % self.computerName
self.computerScore += 1
elif (self.computerStatus == 3 and self.playerStatus == 2):
resultMessage = "%s胜出" % self.computerName
self.computerScore += 1
text.draw(resultMessage, 90, 210, 0x000000, 0xffffff)
self.updateTotolArea()
def startGame(self):
print("-------猜拳游戏开始-------")
while True:
self.client.check_msg()
i = 0
j = -1
for k in keys:
if (k.value() == 0):
if i != j:
j = i
self.client.check_msg()
self.pressKeyboardEvent(i)
self.client.check_msg()
i = i + 1
if (i > 3):
i = 0
time.sleep_ms(100) #按键防抖
def updateTotolArea(self):
#汇总区域用于显示电脑和玩家的胜平负次数
print("-------更新汇总区域-------")
playerTotal = "%s赢了%d局" % (self.playerName, self.playerScore)
computerTotal = "%s赢了%d局" % (self.computerName, self.computerScore)
equalTotal = "平局%d次" % self.equalNum
text.draw("-------------", 20, 240, 0x000000, 0xffffff)
text.draw(playerTotal, 20, 256, 0x000000, 0xffffff)
text.draw(computerTotal, 20, 272, 0x000000, 0xffffff)
text.draw(equalTotal, 20, 288, 0x000000, 0xffffff)
否则无法从CDC口看到下面的 poweron_print_once() 中打印的信息
'''
utime.sleep(5)
checknet.poweron_print_once()
'''
如果用户程序包含网络相关代码，必须执行 wait_network_connected() 等待网络就绪（拨号成功）；
如果是网络无关代码，可以屏蔽 wait_network_connected()
【本例程必须保留下面这一行！】
'''
checknet.wait_network_connected()
# 创建一个mqtt实例
c = MQTTClient("umqtt_client", "mq.tongxinmao.com", 18830)
# 设置消息回调
c.set_callback(sub_cb)
#建立连接
c.connect()
# 订阅主题
c.subscribe(b"/public/TEST/quecpython")
mqtt_log.info("Connected to mq.tongxinmao.com, subscribed to /public/TEST/quecpython topic" )
# 发布消息
c.publish(b"/public/TEST/quecpython", b"my name is Quecpython!")
mqtt_log.info("Publish topic: /public/TEST/quecpython, msg: my name is Quecpython")
while True:
c.wait_msg() # 阻塞函数，监听消息
if state == 1:
break
# 关闭连接
c.disconnect()
class MQTT:
def __init__(self, led_control, device_name):
"""
Constructor
"""
self.led_control = led_control
self.topic = mqtt_config['topic']
self.resp_topic = mqtt_config['resp_topic']
self.device_name = device_name
def start(self):
"""
Initialize MQTT Connection
"""
print ("Creating client")
self.client = MQTTClient(
client_id = self.device_name,
server = mqtt_config['address'],
user = mqtt_config['username'],
password = mqtt_config['user_key'],
port = mqtt_config['port'])
print ("Setting timeout")
self.client.settimeout = self.set_timeout
print ("Setting callback")
self.client.set_callback(self.sub_cb)
print ("Connecting mqtt", mqtt_config['address'], mqtt_config['username'], mqtt_config['user_key'], mqtt_config['port'])
res = self.client.connect()
if (res == -1):
print ("Failed to connect")
pycom.rgbled(0xB900B9)
return
print ("Subscribing")
self.client.subscribe(topic=self.topic)
self.client.set_last_will(self.resp_topic, "Bye")
print ("Listening")
pycom.rgbled(0x00ff00)
Timer.Alarm(self.check_new_messages, 0.0075, periodic=True)
gc.collect()
def stop(self):
"""
Disconnect and stop listening
"""
self.client.disconnect()
def send_data(self, data):
self.client.publish(topic=self.resp_topic, msg=data)
def sub_cb(self, topic, message):
"""
"""
if message is None: return
else: self.parse_input_data(message)
def set_timeout(duration):
"""
"""
pass
def parse_input_data(self, data):
"""
Chooses correct response for new characteristic value
"""
decoded = data.decode('utf-8')
#Echo data back to MQTT backend
if "status" in decoded:
resp_data = self.led_control.compose_status_response()
self.send_data("resp:" + resp_data)
return
# print (decoded)
self.send_data("resp:" + decoded)
if ";" in decoded:
self.led_control.set_route(decoded)
return
if ("," not in decoded): return
data = decoded.split(",")
#print (data)
size = len(data)
if (size == 0):
print ("bad input")
return
if (size == 1):
self.led_control.turn_off_leds()
elif (size == 2):
self.led_control.set_new_data((data[0], data[1], data[1], data[1]))
elif (size == 4):
self.led_control.set_new_data((data[0], data[1], data[2], data[3]))
def check_new_messages(self, alarm):
self.client.check_msg()
# Use the MQTT protocol to connect to Bluemix
print("Try to connect to IBM iot")
myiotorg="5q6gu4"
client = MQTTClient("d:"+myiotorg+":playbulb:playbulb30", myiotorg+".messaging.internetofthings.ibmcloud.com",port=1883,user="******", password="******")
#client = MQTTClient(“d:<ORG Id>:<Device Type>:<Device Id>“, “<ORG Id>.messaging.internetofthings.ibmcloud.com”,user=”use-token-auth”, password=”<TOKEN>“, port=1883)
#print(client)
# Subscribed messages will be delivered to this callback
client.set_callback(sub_cb)
client.connect()
#client.subscribe(AIO_CONTROL_FEED)
#print("Connected to %s, subscribed to %s topic" % (AIO_SERVER, AIO_CONTROL_FEED))
print("Connected to Bluemix")
pycom.rgbled(0x00f000) # Status green: online to Bluemix
#Publish a Hallo
print("Send a Hello to Bluemix")
client.publish(topic="iot-2/evt/random/fmt/json", msg='{"id":'+ubinascii.hexlify(network.LoRa().mac()).decode("utf-8")+',"value":"hello","type":"GW","msgid": -1}' )
#client.publish(topic="iot-2/evt/random/fmt/json", msg='{"id": 0, "h": 0, "t": 0, "ot":0, "w":0, "ts":0, "type":"GW","msgid": -1}' )
try:
while (True):
pycom.rgbled(0x000000)
# Since the maximum body size in the protocol is 255 the request is limited to 512 bytes
recv_pkg = lora_sock.recv(512)
if (len(recv_pkg) >4 and len(recv_pkg) < 160):
print("Received message FROM PI, length = %d" % len(recv_pkg))
#print(recv_pkg.decode("utf-8"))
#a = bytearray(recv_pkg)
#print(len(a))
#Remove the byte pakc unpack could be used 2
b= recv_pkg[4:]
print("Received a message: %s" % b)
db=b.decode("utf-8")
print("Temperatura ", s_dht.temperature()) # Debug
print("Temperatura ", s_dht.humidity()) # Debug
# Config
SERVER = "192.168.31.16"
CLIENT_ID = hexlify(unique_id())
TOPIC1 = b"/cultivo/temp"
TOPIC2 = b"/cultivo/hum"
TOPIC3 = b"/sensor1/set/temp"
TOPIC4 = b"/sensor1/set/hum"
TOPIC5 = b"/cultivo/alarma"
state = 0
client_mqtt = MQTTClient(CLIENT_ID, SERVER)
# Envio
client_mqtt.connect()
client_mqtt.publish(TOPIC1, str(s_dht.temperature()))
client_mqtt.publish(TOPIC2, str(s_dht.humidity()))
sleep_ms(200)
client_mqtt.disconnect()
# Recepcion
def sub_cb(topic, msg):
global state
print((topic, msg))
if msg == b"on":
led.value(0)
state = 1
elif msg == b"off":
led.value(1)
state = 0
class Game():
def __init__(self, playerName, computerName): #初始化
#网络设定
#WiFi名称和密码
self.wifi_name = "NEUI"
self.wifi_SSID = "NEUI3187"
#MQTT服务端信息
SERVER = "112.125.89.85" #MQTT服务器地址
SERVER_PORT = 3881 #MQTT服务器端口
DEVICE_ID = "wc001" #设备ID
TOPIC1 = b"/cloud-skids/online/dev/" + DEVICE_ID
self.TOPIC2 = b"/cloud-skids/message/server/" + DEVICE_ID
CLIENT_ID = "f25410646a8348f8a1726a3890ad8f81"
#设备状态
ON = "1"
OFF = "0"
#对方的选择
self.d = ["1", "2", "3"]
self.choose = 0
self.mark = 0
#启动网络连接
self.do_connect()
gc.collect()
self.client = MQTTClient(CLIENT_ID, SERVER, SERVER_PORT)
self.client.set_callback(self.sub_cb) #设置回调
self.client.connect()
print("连接到服务器：%s" % SERVER)
self.client.publish(TOPIC1, ON) #发布“1”到TOPIC1
self.client.subscribe(self.TOPIC2) #订阅TOPIC
#游戏设定
self.gameStart = False
self.playerName = playerName
self.computerName = computerName
self.playerScore = 0
self.computerScore = 0
self.equalNum = 0
self.playerStatus = 0
self.computerStatus = 0
for p in pins:
keys.append(Pin(p, Pin.IN))
self.displayInit()
def do_connect(self):
sta_if = network.WLAN(network.STA_IF) #STA模式
ap_if = network.WLAN(network.AP_IF) #AP模式
if ap_if.active():
ap_if.active(False) #关闭AP
if not sta_if.isconnected():
print('Connecting to network...')
sta_if.active(True) #激活STA
sta_if.connect(self.wifi_name, self.wifi_SSID) #WiFi的SSID和密码
while not sta_if.isconnected():
pass
print('Network config:', sta_if.ifconfig())
def sub_cb(self, topic, message):
message = message.decode()
print("mark is :", self.mark)
#赋值给choose
self.choose = int(message)
if (self.choose < 20): #来自1号自己的信息，不判断
print("对方尚未选择")
return
elif (self.choose > 20):
self.mark = self.mark + 1 #修改标志，代表一方已完成选择
print("player1 get choose is :", self.choose)
#处理所得信息
self.computerStatus = self.choose - 20
#显示对方结果
text.draw(str(self.computerStatus), 172, 152, 0x000000, 0xffffff)
#判断胜负并显示结果
if self.mark % 2 == 0: #如果双方都完成选择
resultMessage = " 平局 "
if self.computerStatus == 0:
return
elif (self.playerStatus == self.computerStatus):
self.equalNum += 1
elif (self.playerStatus > self.computerStatus):
self.playerScore += 1
resultMessage = "%s胜出" % self.playerName
elif (self.playerStatus < self.computerStatus):
self.computerScore += 1
resultMessage = "%s胜出" % self.computerName
text.draw(resultMessage, 90, 210, 0x000000, 0xffffff)
self.updateTotolArea()
def displayInit(self, x=10, y=10, w=222, h=303):
#显示游戏规则信息
mentionStr1 = "游戏规则："
mentionStr2 = "双方随机生成1-6的数"
mentionStr3 = "按键1-3选择 按键4停止"
text.draw(mentionStr1, 20, 20, 0x000000, 0xffffff)
text.draw(mentionStr2, 20, 36, 0x000000, 0xffffff)
text.draw(mentionStr3, 20, 52, 0x000000, 0xffffff)
text.draw("-------------", 20, 68, 0x000000, 0xffffff)
self.updateTotolArea()
#设置游戏运行状态
self.gameStart = True
def roll(self):
#获得随机数并更新显示
result1 = randint(1, 6)
text.draw(str(result1), 52, 152, 0x000000, 0xffffff)
self.playerStatus = result1
def pressKeyboardEvent(self, key):
keymatch = ["Key1", "Key2", "Key3", "Key4"]
#游戏还未开始，不必处理键盘输入
if (self.gameStart == False):
return
#处理按键
print(keymatch[key])
self.mark = self.mark + 1
if (keymatch[key] == "Key1"):
self.roll()
self.client.publish(self.TOPIC2, "1" + str(self.playerStatus))
text.draw(str(self.playerStatus), 52, 168, 0x000000, 0xffffff)
elif (keymatch[key] == "Key2"):
self.roll()
self.client.publish(self.TOPIC2, "1" + str(self.playerStatus))
text.draw(str(self.playerStatus), 52, 168, 0x000000, 0xffffff)
elif (keymatch[key] == "Key3"):
self.roll()
self.client.publish(self.TOPIC2, "1" + str(self.playerStatus))
text.draw(str(self.playerStatus), 52, 168, 0x000000, 0xffffff)
else:
text.draw("游戏结束", 90, 210, 0x000000, 0xffffff)
#设置游戏运行状态
self.gameStart = False
return
#对方玩家选择
#一号玩家收到21-26
print("choose is :", self.choose)
if (self.choose < 20): #来自1号自己的信息，不判断
print("对方尚未选择")
return
elif (self.choose > 20):
print("player1 get choose is :", self.choose)
#处理所得信息
self.computerStatus = self.choose - 20
#显示对方结果
text.draw(str(self.computerStatus), 172, 152, 0x000000, 0xffffff)
#判断胜负并显示结果
if self.mark % 2 == 0: #如果双方都完成选择
resultMessage = " 平局 "
if self.computerStatus == 0:
return
elif (self.playerStatus == self.computerStatus):
self.equalNum += 1
elif (self.playerStatus > self.computerStatus):
self.playerScore += 1
resultMessage = "%s胜出" % self.playerName
elif (self.playerStatus < self.computerStatus):
self.computerScore += 1
resultMessage = "%s胜出" % self.computerName
text.draw(resultMessage, 90, 210, 0x000000, 0xffffff)
self.updateTotolArea()
def startGame(self):
print("-------骰子游戏开始-------")
while True:
self.client.check_msg()
self.roll()
#print(gc.mem_free())
i = 0
j = -1
for k in keys:
if (k.value() == 0):
if i != j:
j = i
self.pressKeyboardEvent(i)
self.client.check_msg()
i = i + 1
if (i > 3):
i = 0
time.sleep_ms(100) #按键防抖
def updateTotolArea(self):
#汇总区域用于显示电脑和玩家的胜平负次数
print("-------更新汇总区域-------")
playerTotal = "%s赢了%d局" % (self.playerName, self.playerScore)
computerTotal = "%s赢了%d局" % (self.computerName, self.computerScore)
equalTotal = "平局%d次" % self.equalNum
text.draw("-------------", 20, 240, 0x000000, 0xffffff)
text.draw(playerTotal, 20, 256, 0x000000, 0xffffff)
text.draw(computerTotal, 20, 272, 0x000000, 0xffffff)
text.draw(equalTotal, 20, 288, 0x000000, 0xffffff)
def mqtt_send(topic, message):
client = MQTTClient('iot-envsensor', 'MQTT_SERVER_HOSTNAME')
client.connect()
client.publish(topic, message)
client.disconnect()
adc = machine.ADC() # create an ADC object
apin = adc.channel(pin='P16') # create an analog pin on P16 & connect TMP36
def getTemperature():
value = apin()
temp = ((value * 1100) / 1024 - 500) / 10
print("Temperature = %5.1f grdC" % (temp))
return temp
def settimeout(duration):
pass
wlan = WLAN(mode=WLAN.STA)
wlan.antenna(WLAN.INT_ANT)
wlan.connect(SSID, auth=(WLAN.WPA2, KEY), timeout=5000)
while not wlan.isconnected():
machine.idle()
print("Connected to Wifi\n")
# client_id, server, port=0, user=None, password=None, keepalive=0,
client = MQTTClient(BRUSER, BROKER, BRPORT, user=BRUSER, password=BRPWD)
client.settimeout = settimeout
client.connect()
while True:
client.publish("TMP36", str(round(getTemperature(), 1)))
time.sleep(60)
import time
from umqtt import MQTTClient
import machine, ubinascii, gc, json
from machine import I2C
from machine import Pin
from machine import DHT
CLIENT_ID = ubinascii.hexlify(machine.unique_id())
gc.collect()
d = DHT(Pin(17), DHT.DHT2X)
client = MQTTClient(CLIENT_ID, 'q.emqtt.com')
client.connect()
time.sleep(2)
while True:
try:
result, t, h = d.read()
if result:
msg = json.dumps({
'heap': gc.mem_free(),
'Type': 7,
'Id': CLIENT_ID,
'temperature': '{0:.2f}'.format(t),
'humidity': '{0:.2f}'.format(h)
})
print(msg)
client.publish('micro/python/temperature', msg)
time.sleep(5)
except OSError as e:
print(e)
pycom.rgbled(0xff00)
UNIQUE_ID = machine.unique_id()
MQTT_BROKER = "192.168.2.68"
MQTT_PORT = 1883
MQTT_TOPIC = "iot-2/type/lopy/id/lopy2/evt/evento1/fmt/json"
mqtt_client = MQTTClient(UNIQUE_ID, MQTT_BROKER, port=MQTT_PORT)
mqtt_client.settimeout = settimeout
mqtt_client.set_callback(t3_publication)
mqtt_client.connect()
_LORA_PKG_ACK_FORMAT = "BBB"
_LORA_PKG_FORMAT = "BB%ds"
lora = LoRa(mode=LoRa.LORA, rx_iq=True)
lora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
lora_sock.setblocking(False)
print("NANO GATEWAY RUNNING!!!")
while (True):
recv_pkg = lora_sock.recv(512)
print(recv_pkg)
time.sleep(5)
if (len(recv_pkg) > 2):
recv_pkg_len = recv_pkg[1]
device_id, pkg_len, msg = struct.unpack(_LORA_PKG_FORMAT % recv_pkg_len, recv_pkg)
print(msg)
#mqtt_client.publish("lopytopic", json.dumps(msg))
mqtt_client.publish(MQTT_TOPIC, json.dumps(msg))
ack_pkg = struct.pack(_LORA_PKG_ACK_FORMAT, device_id, 1, 200)
lora_sock.send(ack_pkg)
from umqtt import MQTTClient
import machine, ubinascii
import time
import network
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect('HUAWEI', '0000000000')
while not wlan.isconnected():
print('Wait connection')
time.sleep(1)
CLIENT_ID = ubinascii.hexlify(machine.unique_id())
client = MQTTClient(CLIENT_ID, 'iot.eclipse.org', port=1883)
client.connect()
while True:
client.publish('micro/python/test', 'Hello World')
time.sleep(5)
class GOES():
def __init__(self):
self.screen_width = 200
self.screen_height = 280
self.keys = [Pin(p, Pin.IN) for p in [35, 36, 39, 34]]
self.keymatch = ["Key1", "Key2", "Key3", "Key4"]
self.board = [[[20, 20, 0], [40, 20, 0], [60, 20, 0], [80, 20, 0],
[100, 20, 0], [120, 20, 0], [140, 20, 0], [160, 20, 0],
[180, 20, 0], [200, 20, 0], [220, 20, 0]],
[[20, 40, 0], [40, 40, 0], [60, 40, 0], [80, 40, 0],
[100, 40, 0], [120, 40, 0], [140, 40, 0], [160, 40, 0],
[180, 40, 0], [200, 40, 0], [220, 40, 0]],
[[20, 60, 0], [40, 60, 0], [60, 60, 0], [80, 60, 0],
[100, 60, 0], [120, 60, 0], [140, 60, 0], [160, 60, 0],
[180, 60, 0], [200, 60, 0], [220, 60, 0]],
[[20, 80, 0], [40, 80, 0], [60, 80, 0], [80, 80, 0],
[100, 80, 0], [120, 80, 0], [140, 80, 0], [160, 80, 0],
[180, 80, 0], [200, 80, 0], [220, 80, 0]],
[[20, 100, 0], [40, 100, 0], [60, 100, 0], [80, 100, 0],
[100, 100, 0], [120, 100, 0], [140, 100, 0],
[160, 100, 0], [180, 100, 0], [200, 100, 0],
[220, 100, 0]],
[[20, 120, 0], [40, 120, 0], [60, 120, 0], [80, 120, 0],
[100, 120, 0], [120, 120, 0], [140, 120, 0],
[160, 120, 0], [180, 120, 0], [200, 120, 0],
[220, 120, 0]],
[[20, 140, 0], [40, 140, 0], [60, 140, 0], [80, 140, 0],
[100, 140, 0], [120, 140, 0], [140, 140, 0],
[160, 140, 0], [180, 140, 0], [200, 140, 0],
[220, 140, 0]],
[[20, 160, 0], [40, 160, 0], [60, 160, 0], [80, 160, 0],
[100, 160, 0], [120, 160, 0], [140, 160, 0],
[160, 160, 0], [180, 160, 0], [200, 160, 0],
[220, 160, 0]],
[[20, 180, 0], [40, 180, 0], [60, 180, 0], [80, 180, 0],
[100, 180, 0], [120, 180, 0], [140, 180, 0],
[160, 180, 0], [180, 180, 0], [200, 180, 0],
[220, 180, 0]],
[[20, 200, 0], [40, 200, 0], [60, 200, 0], [80, 200, 0],
[100, 200, 0], [120, 200, 0], [140, 200, 0],
[160, 200, 0], [180, 200, 0], [200, 200, 0],
[220, 200, 0]],
[[20, 220, 0], [40, 220, 0], [60, 220, 0], [80, 220, 0],
[100, 220, 0], [120, 220, 0], [140, 220, 0],
[160, 220, 0], [180, 220, 0], [200, 220, 0],
[220, 220, 0]]] #初始化棋子坐标（x坐标，y坐标，颜色）
self.startX = 20
self.startY = 20
self.selectXi = 5
self.selectYi = 5
self.displayInit()
self.color = 0x00ff00 #player2棋子颜色为绿色
self.wifi_name = "NEUI"
self.wifi_SSID = "NEUI3187"
#MQTT服务端信息
self.SERVER = "112.125.89.85" #MQTT服务器地址
self.SERVER_PORT = 3881 #MQTT服务器端口
self.DEVICE_ID = "wc001" #设备ID
self.TOPIC1 = b"/cloud-skids/online/dev/" + self.DEVICE_ID
self.TOPIC2 = b"/cloud-skids/message/server/" + self.DEVICE_ID
self.CLIENT_ID = "f25410646a8348f8a1726a3890ad8f73"
self.uart = UART(1,
baudrate=115200,
bits=8,
parity=0,
rx=18,
tx=19,
stop=1)
#设备状态
self.ON = "1"
self.OFF = "0"
self.d = " "
self.c = MQTTClient(self.CLIENT_ID, self.SERVER, self.SERVER_PORT)
def drawcross(self, x, y, lineColor): # 画选择位置的框
screen.drawline(x - 10, y - 10, x - 5, y - 10, 3, lineColor)
screen.drawline(x - 10, y - 10, x - 10, y - 5, 3, lineColor)
screen.drawline(x + 10, y - 10, x + 5, y - 10, 3, lineColor)
screen.drawline(x + 10, y - 10, x + 10, y - 5, 3, lineColor)
screen.drawline(x - 10, y + 10, x - 5, y + 10, 3, lineColor)
screen.drawline(x - 10, y + 10, x - 10, y + 5, 3, lineColor)
screen.drawline(x + 10, y + 10, x + 5, y + 10, 3, lineColor)
screen.drawline(x + 10, y + 10, x + 10, y + 5, 3, lineColor)
#画棋盘网格
def grid(self):
x = 20
y = 20
for i in range(11):
screen.drawline(x, 20, x, 220, 3, 0x000000)
x += 20
for j in range(11):
screen.drawline(20, y, 220, y, 3, 0x000000)
y += 20
def do_connect(self):
sta_if = network.WLAN(network.STA_IF) #STA模式
ap_if = network.WLAN(network.AP_IF) #AP模式
if ap_if.active():
ap_if.active(False) #关闭AP
if not sta_if.isconnected():
print('Connecting to network...')
sta_if.active(True) #激活STA
sta_if.connect(self.wifi_name, self.wifi_SSID) #WiFi的SSID和密码
while not sta_if.isconnected():
pass
print('Network config:', sta_if.ifconfig())
gc.collect()
def esp(self):
self.c.set_callback(self.sub_cb) #设置回调
self.c.connect()
print("连接到服务器：%s" % self.SERVER)
self.c.publish(self.TOPIC1, self.ON) #发布“1”到TOPIC1
self.c.subscribe(self.TOPIC2) #订阅TOPIC
#display.text("从微信取得信息", 20, 20, 0xf000, 0xffff)
def sub_cb(self, topic, message): #从服务器接受信息
message = message.decode()
print("服务器发来信息：%s" % message)
#global count
t = int(message) #根据接收到的信息解析棋子位置
j = t // 11
i = t % 11
x = self.board[j][i][0]
y = self.board[j][i][1]
if self.board[j][i][2] == 0:
self.put_circle_back(x, y, 10, 0x000000) #在解析出的位置上画黑色棋子
self.board[j][i][2] = 2 #将棋子标记为黑色
self.is_win(i, j, self.board[j][i][2]) #判断胜负
def put_circle_back(self, x, y, r, color): #画圆形棋子
a = 0 #选定原点距离圆心距离
b = r #在原点所画交叉线长度
di = 3 - (r << 1) #辅助判断画圆是否结束
while (a <= b): #选定原点画交叉线
screen.drawline(x - b, y - a, x + b, y - a, 3, color)
screen.drawline(x - a, y, x - a, y + b, 3, color)
screen.drawline(x - b, y - a, x, y - a, 3, color)
screen.drawline(x - a, y - b, x - a, y, 3, color)
screen.drawline(x, y + a, x + b, y + a, 3, color)
screen.drawline(x + a, y - b, x + a, y, 3, color)
screen.drawline(x + a, y, x + a, y + b, 3, color)
screen.drawline(x - b, y + a, x, y + a, 3, color)
a += 1 #改变原点位置
if (di < 0): #辅助判断画圆是否结束，计算下一步所画交叉线长度
di += 4 * a + 6
else:
di += 10 + 4 * (a - b)
b -= 1
screen.drawline(x + a, y, x + a, y + b, 3, color)
def selectInit(self): #选择初始化
# 变量初始化
self.selectXi = 5
self.selectYi = 5
x = self.board[self.selectYi][self.selectXi][0]
y = self.board[self.selectYi][self.selectXi][1]
# 选择初始化
self.drawcross(x, y, 0xff0000)
# 界面初始化
def displayInit(self): #开始游戏初始化
screen.clear()
self.grid()
for self.selectYi in range(11):
for self.selectXi in range(11):
self.board[self.selectYi][self.selectXi][2] = 0
self.selectInit()
def is_win(self, i, j, k): #判断胜负
start_y = 0
end_y = 10
if j - 4 >= 0:
start_y = j - 4
if j + 4 <= 10:
end_y = j + 4
count = 0
for pos_y in range(start_y, end_y + 1): #判断纵向胜负
if self.board[pos_y][i][2] == k and k == 1:
count += 1
if count >= 5:
text.draw("绿色方胜", 88, 160, 0xff0000)
else:
count = 0
for pos_y in range(start_y, end_y + 1):
if self.board[pos_y][i][2] == k and k == 2:
count += 1
if count >= 5:
text.draw("黑色方胜", 88, 160, 0xff0000)
else:
count = 0
start_x = 0
end_x = 10
if i - 4 >= 0:
start_x = i - 4
if i + 4 <= 10:
end_x = i + 4
count = 0
for pos_x in range(start_x, end_x + 1): #判断横向胜负
if self.board[j][pos_x][2] == k and k == 1:
count += 1
if count >= 5:
text.draw("绿色方胜", 88, 160, 0xff0000)
else:
count = 0
for pos_x in range(start_x, end_x + 1):
if self.board[j][pos_x][2] == k and k == 2:
count += 1
if count >= 5:
text.draw("黑色方胜", 88, 160, 0xff0000)
else:
count = 0
count = 0
s = j - i
start = start_y
end = end_x + s
if j > i:
start = start_x + s
end = end_y
for index in range(start, end + 1): #判断斜方向胜负（左上右下）
if self.board[index][index - s][2] == k and k == 1:
count += 1
if count >= 5:
text.draw("绿色方胜", 88, 160, 0xff0000)
else:
count = 0
for index in range(start, end + 1):
if self.board[index][index - s][2] == k and k == 2:
count += 1
if count >= 5:
text.draw("黑色方胜", 88, 160, 0xff0000)
else:
count = 0
count = 0
s = j + i
if j + i <= 10:
start = start_y
end = s - start_x
if j + i > 10:
start = s - 10
end = 10
if s >= 4 and s <= 16:
for index in range(start, end + 1): #判断斜方向胜负（左下右上）
if self.board[index][s - index][2] == k and k == 1:
count += 1
if count >= 5:
text.draw("绿色方胜", 88, 160, 0xff0000)
else:
count = 0
for index in range(start, end + 1):
if self.board[index][s - index][2] == k and k == 2:
count += 1
if count >= 5:
text.draw("黑色方胜", 88, 160, 0xff0000)
else:
count = 0
def keyboardEvent(self, key):
# 右移选择键
if self.keymatch[key] == "Key1":
# 取消前一个选择
x = self.board[self.selectYi][self.selectXi][0]
y = self.board[self.selectYi][self.selectXi][1]
self.drawcross(x, y, 0xffffff)
# 选择右边一个
self.selectXi = (self.selectXi + 1) % 11
x = self.board[self.selectYi][self.selectXi][0]
y = self.board[self.selectYi][self.selectXi][1]
self.drawcross(x, y, 0xff0000)
# 纵向移动键
elif self.keymatch[key] == "Key2":
# 取消前一个选择
x = self.board[self.selectYi][self.selectXi][0]
y = self.board[self.selectYi][self.selectXi][1]
self.drawcross(x, y, 0xffffff)
# 选择下边一个
self.selectYi = (self.selectYi + 1) % 11
x = self.board[self.selectYi][self.selectXi][0]
y = self.board[self.selectYi][self.selectXi][1]
self.drawcross(x, y, 0xff0000)
# 确认键
elif self.keymatch[key] == "Key3":
x = self.board[self.selectYi][self.selectXi][0]
y = self.board[self.selectYi][self.selectXi][1]
if self.board[self.selectYi][self.selectXi][2] == 0:
self.put_circle_back(x, y, 10, self.color) #画绿色棋子
self.board[self.selectYi][self.selectXi][2] = 1 #将棋子标记为绿色
s = (self.selectYi) * 11 + (self.selectXi)
self.d = str(s)
self.c.publish(self.TOPIC2, self.d) #向服务器发送棋子位置信息
self.is_win(self.selectXi, self.selectYi,
self.board[self.selectYi][self.selectXi][2])
elif self.keymatch[key] == "Key4":
self.displayInit()
def start(self):
try:
while True:
self.c.check_msg() #检查是否收到信息
i = 0 #用来辅助判断那个按键被按下
j = -1
for k in self.keys:
if (k.value() == 0): #如果按键被按下
if i != j:
j = i
self.keyboardEvent(i) #触发相应按键对应事件
i = i + 1
if (i > 3):
i = 0
time.sleep_ms(200) # 按键去抖
finally:
self.c.disconnect()
print("MQTT连接断开")
# elif start + 45 > end >= start + 40:
# pycom.rgbled(color_list_for_intensity[7])
# elif start + 50 > end >= start + 45:
# pycom.rgbled(color_list_for_intensity[8])
# elif start + 55 > end >= start + 50:
# pycom.rgbled(color_list_for_intensity[9])
# elif start + 60 > end >= start + 55:
# pycom.rgbled(color_list_for_intensity[10])
# elif start + 65 > end >= start + 60:
# pycom.rgbled(color_list_for_intensity[11])
# elif start + 70 > end >= start + 65:
# pycom.rgbled(color_list_for_intensity[12])
# elif start + 75 > end >= start + 70:
# pycom.rgbled(color_list_for_intensity[13])
# elif start + 80 > end >= start + 75:
# pycom.rgbled(color_list_for_intensity[14])
# elif start + 85 > end >= start + 80:
# pycom.rgbled(color_list_for_intensity[15])
# else:
# pass
if end >= start + 21:
pycom.rgbled(color_list_for_intensity[15])
time.sleep(0.5)
light_level = lt.light()[0]
message = {
"light": str(light_level),
}
mqtt_client.publish(topic=topic, msg=ujson.dumps(message))
machine.freq(160000000)
CLIENT_ID = ubinascii.hexlify(machine.unique_id())
gc.collect()
scl = Pin(22)
sda = Pin(21)
i2c = I2C(scl=scl, sda=sda, freq=100000)
oled = SSD1306_I2C(128, 64, i2c)
d = dht.DHT22(Pin(17))
client = MQTTClient(CLIENT_ID, 'q.emqtt.com')
client.connect()
while True:
d.measure()
oled.fill(0)
oled.text('ESP8266', 35, 5)
oled.text('MicroPython', 20, 20)
oled.text('T:{0:.2f}'.format(d.temperature()), 3, 35)
oled.text('H:{0:.2f}'.format(d.humidity()), 3, 50)
oled.show()
msg = json.dumps({
'heap': gc.mem_free(),
'Type': 7,
'Id': CLIENT_ID,
'temperature': '{0:.2f}'.format(d.temperature()),
'humidity': '{0:.2f}'.format(d.humidity())
})
print(msg)
client.publish('micro/python/temperature', msg)
time.sleep(5)
class Monitoreo():
"Clase padre, Monitoreo del dispositivo para micropython: "
def __init__(self, pin_dht=4, sensor="DHT22"):
self.pin_DHT = pin_dht
self.sensor_type = sensor
self.alarm_state = 0
self.pin_alarma = machine.Pin(
16, machine.Pin.OUT) # Configure Pin: Alarma (OUT)
self.pin_stopAlarm = machine.Pin(
5, machine.Pin.OUT) # Configure Pin: Stop Alarm (IN)
self.count_alarma = 0
self.alarma = 0
self.time_active = 0
self.dataWrite = 0 # Almacena los datos, On:1 | Off:0
self.break_loop = 1 # variable para romper el loop
self.interrupt_mode = 0 # interrupciones: On:1 | Off:0
self.debug_mode = 0 # Debug On:1 | Off:0
self.sensorConected()
def sensorConected(self, sensor="DHT22"):
"Conmuta entre los diferentes sensores: DHT11/DHT22"
if self.sensor_type == "DHT22":
self.s_dht = dht.DHT22(machine.Pin(self.pin_DHT))
elif self.sensor_type == "DHT11":
self.s_dht = dht.DHT11(machine.Pin(self.pin_DHT))
else:
if self.debug_mode == 1:
print(
"Sensor inadecuado, elija entre las opciones: DHT11 o DHT22"
) # debug
self.pin_led_debug.value(
not self.pin_led_debug.value()) # Debug visual
def pinEndUp(self):
"Rompe el loop por hardware, Pin:[High = break]"
pass
def debugMode(self, mode=0):
"Activa/Desactiva El debug visual y de consola, On:1 | Off:0"
self.debug_mode = mode
if self.debug_mode == 1:
esp.osdebug(1) # turn on/off vendor O/S debugging messages
self.pin_led_debug = machine.Pin(2,
machine.Pin.OUT) # Debug visual
else:
esp.osdebug(0)
def saveData(self, mode=0):
"Guarda los datos en un archivo, On:1 | Off:0"
self.dataWrite = mode
if self.dataWrite == 1:
self.dataWrite = 2
self.file = open('data.txt', 'w')
self.file.write("TEMP, HUM\n")
elif self.dataWrite == 2:
self.file.write(
str(self.s_dht.temperature()) + ", \
" + str(self.s_dht.humidity()) + "\n")
elif self.dataWrite == 0:
self.dataWrite = 3
self.file = open('data.txt', 'w')
self.file.write("Data storage off\n")
self.file.close()
def readData(self):
"Obtiene de lso sensores los datos de Temperatura/Humedad"
self.s_dht.measure()
if self.debug_mode == 1:
print("Temperatura ", self.s_dht.temperature()) # Debug
print("Humedad ", self.s_dht.humidity()) # Debug
self.pin_led_debug.value(
not self.pin_led_debug.value()) # Debug visual
def actuators(self):
"Activa la logica de los Actuadores"
# if self.pin_stopAlarm.value() == 1: # MQTT Or Pin
# self.alarma = 0
if self.s_dht.temperature() == 3 and self.s_dht.humidity() >= 85:
self.alarma = 1
self.time_active = 60
elif self.s_dht.temperature() == 1 and self.s_dht.humidity() >= 92:
self.pin_alarma = 1
self.time_active = 300
if self.alarma == 1 and self.count_alarma <= self.time_active:
self.pin_alarma.high()
self.count_alarma += 1
if self.count_alarma == self.time_active:
self.pin_alarma.low()
self.count_alarma = 0
if self.debug_mode == 1:
print("Estado del actuador en: " + self.value(16) + " Pin No.",
self.pin_alarma)
self.pin_led_debug.value(
not self.pin_led_debug.value()) # Debug visual
else:
self.count_alarma = 0
def sleepMode(self):
" Duerme el dispositivo"
pass
def wifi(self, mode=1):
"Activa/Desactiva el Wifi "
self.wifi_switch = mode
if self.wifi_switch == 1:
self.configWifi()
self.wifiStation()
elif self.wifi_switch == 1:
self.sta_if.active(False)
def configWifi(self):
"Metodo usado para configurar los parametros de la Red Wifi: SSID y PASSWORD"
pass
def wifiAP(self):
"Crea un punto de acceso wifi, actua como anfitri?n"
pass
def wifiStation(self):
"Hace de estaci?n (wifi) y se conecta con a un servidor u otro dispositivo"
import network
# Config
WIFISSID = "Cultivo_pi" # <-----------------CONFIGURE: SDID de Red wifi
WIFIPASS = "******" # <-----------------CONFIGURE: PASSWORD de Red wifi
self.sta_if = network.WLAN(network.STA_IF)
if not self.sta_if.isconnected():
print('connecting to network...')
self.sta_if.active(True)
self.sta_if.connect(WIFISSID, WIFIPASS)
while not self.sta_if.isconnected():
print('network config:', self.sta_if.ifconfig())
def MQTTclient(self):
"Protocolo MQTT en modo cliente, Configuración"
from ubinascii import hexlify
from machine import unique_id
from umqtt import MQTTClient # import socket library (umqtt)
# Config
SERVER = "172.24.1.1" # <----------------------------CONFIGURE: BROKER
CLIENT_ID = hexlify(unique_id())
self.TOPIC1 = b"/cultivo/temp"
self.TOPIC2 = b"/cultivo/hum"
self.TOPIC3 = b"/sensor1/set/temp"
self.TOPIC4 = b"/sensor1/set/hum"
self.TOPIC5 = b"/sensor1/alarma"
self.client_mqtt = MQTTClient(CLIENT_ID, SERVER)
def MQTTSend(self):
"Envio Datos mediante el protocolo MQTT"
try:
self.client_mqtt.connect()
self.client_mqtt.publish(self.TOPIC1,
str(self.s_dht.temperature()))
self.client_mqtt.publish(self.TOPIC2, str(self.s_dht.humidity()))
time.sleep_ms(200)
self.client_mqtt.disconnect()
except Exception as e:
pass
def MQTTReceive(self):
"Metodo que recibe datos enviados a traves del protocolo MQTT"
self.alarm_state = 1 - self.alarm_state
# Subscribed messages will be delivered to this callback
self.client_mqtt.set_callback(self.sub_cb)
self.client_mqtt.connect()
self.client_mqtt.subscribe(self.TOPIC5)
def sub_cb(self, topic, msg):
"Recepcion MQTT"
print((topic, msg))
if msg == b"on":
self.pin_led_debug.value(0)
self.alarm_state = 1
elif msg == b"off":
self.pin_led_debug.value(1)
self.alarm_state = 0
elif msg == b"toggle":
self.pin_led_debug.value(self.alarm_state)
def interruptMode(self, mode=0):
"Activa/Desactiva las interrupciones, por tiempo y por cambio de flanco, On:1 | Off:0"
self.interrupt_mode = mode
if self.interrupt_mode == 1:
self.p_interrupt = machine.Pin(
3, machine.Pin.IN) # Interupt por cambio de flanco
# Flanco de bajada y flanco de subida rising and falling edge()
self.p_interrupt.irq(trigger=machine.Pin.IRQ_RISING
| machine.Pin.IRQ_FALLING,
handler=self.callback)
def callback(self, p):
"Metodo que se ejecuta una vez ocurrida la interrupci?n"
# print('pin change', p)
self.break_loop = 0
def loop(self):
"Bucle principal infinito"
while True: # beak: interrupt, Pin change
# Sleep Off
self.readData() # Lectura de sensores
# self.saveData() # si esta activa, almacena datos
self.MQTTSend() # Enviar datos mediante el protocolo MQTT
# self.client_mqtt.wait_msg() # Recibe datos mediante el Protocolo MQTT
# self.actuators()
# Sleep On
time.sleep(1)
# self.pinEndUp()
# micropython.mem_info()
self.saveData()
state = 0
def sub_cb(topic, msg):
global state
print("subscribe recv:")
print(topic, msg)
state = 1
#创建一个 mqtt 实例
c = MQTTClient("umqtt_client", "mq.tongxinmao.com", '18830')
#设置消息回调
c.set_callback(sub_cb)
#建立连接
c.connect()
#订阅主题
c.subscribe(b"/public/TEST/quecpython")
print(
"Connected to mq.tongxinmao.com, subscribed to /public/TEST/quecpython topic"
)
#发布消息
c.publish(b"/public/TEST/quecpython", b"my name is Kingka!")
print("Publish topic: /public/TEST/quecpython, msg: my name is Quecpython")
while True:
c.wait_msg() #阻塞函数，监听消息
if state == 1:
break
#关闭连接
c.disconnect()
f.close()
#write count as 0
with open('count.txt', 'w') as f:
f.write('0')
count = 0
while True:
if not subscribed:
try:
mqtt.subscribe('test/message')
subscribed = True
except:
subscribed = False
mqtt.check_msg()
if not wlan.isconnected():
boot.wlanConnect()
#if not connected to broker try again, if cant wait 2 seconds
if not isConnected:
isConnected = tryConnect()
if button() == 0 & isConnected:
reset()
#if input from radar and is connected to broker
if P2() == 1 & isConnected & subscribed:
count += 1
#publish count
mqtt.publish('test/message', str(count))
f = open('count.txt', 'w')
f.write(str(count))
f.close()
time.sleep(2.1)
# Subscribed messages will be delivered to this callback
client.set_callback(sub_cb)
client.connect()
#client.subscribe(AIO_CONTROL_FEED)
#print("Connected to %s, subscribed to %s topic" % (AIO_SERVER, AIO_CONTROL_FEED))
print("Connected to Bluemix")
pycom.rgbled(0x00f000) # Status green: online to Bluemix
#Publish a Hallo
#msg={"id":'+ubinascii.hexlify(network.LoRa().mac()).decode("utf-8")+',"value":"hello","type":"GW","msgid":0}
#o = json.loads(msg)
#o['type']="GW"
#o['gwid']=ubinascii.hexlify(network.LoRa().mac()).decode("utf-8")
#print(o)
#c=json.dumps(o)
print("Send a Hello to Bluemix")
client.publish(topic="iot-2/evt/hello/fmt/json",
msg='{"value":"hello","type":"GW","msgid":0}')
#client.publish(topic="iot-2/evt/random/fmt/json", msg='{"id": 0, "h": 0, "t": 0, "ot":0, "w":0, "ts":0, "type":"GW","msgid": -1}' )
try:
while (True):
pycom.rgbled(0x000000)
# Since the maximum body size in the protocol is 255 the request is limited to 512 bytes
recv_pkg = lora_sock.recv(512)
if (len(recv_pkg) > 4):
print(recv_pkg.decode("utf-8"))
if (len(recv_pkg) > 4 and len(recv_pkg) < 160):
print("Received message FROM PI, length = %d" % len(recv_pkg))
#print(recv_pkg.decode("utf-8"))
#a = bytearray(recv_pkg)
#print(len(a))
#Remove the byte pakc unpack could be used 2
b = recv_pkg[4:]
localclient = MQTTClient("", localmqttHost, port=1883)
localclient.settimeout = settimeout
try:
localclient.connect()
except Exception as err:
print("local exception", err)
remoteclient = MQTTClient(
"somethingrandom341", mqttHost, user=mqttUsername,
password=mqttAPIKey) # port=80 is not working, but 0=1883 is ok
remoteclient.settimeout = settimeout2
try:
remoteclient.connect()
except Exception as err:
print("remote exception", err)
remotetopic = b"channels/" + channelID + b"/publish/" + writeAPIKey
while True:
print("publishing via MQTT")
payload = str(adc0.read()) # read ADC value
localclient.publish("test/orchid", payload) # publish locally
payload = b"field1=" + payload # build payload for ThingSpeak
remoteclient.publish(remotetopic, payload) # publish to ThingSpeak
time.sleep(5)
print("deepsleep", dsSeconds, "seconds")
if not debug:
rtc.alarm(rtc.ALARM0, dsSeconds * 1000) # set the RTC alarm
machine.deepsleep() # let board deepsleep
class pics():
def __init__(self):
self.keys = [Pin(p, Pin.IN) for p in [35, 36, 39, 34]]
self.keymatch = ["Key1", "Key2", "Key3", "Key4"]
self.select = 1
self.displayInit()
self.wifi_name = "NEUI"
self.wifi_SSID = "NEUI3187"
#MQTT服务端信息
self.SERVER = "192.168.5.121" #MQTT服务器地址
self.SERVER_PORT = 1883 #MQTT服务器端口
self.contentEVICE_ID = "wc001" #设备ID
self.TOPIC1 = b"/cloud-skids/online/dev/" + self.contentEVICE_ID
self.TOPIC2 = b"/cloud-skids/message/server/" + self.contentEVICE_ID
self.CLIENT_ID = "7e035cd4-15b4-4d4b-a706-abdb8151c57d"
self.uart = UART(1,
baudrate=115200,
bits=8,
parity=0,
rx=18,
tx=19,
stop=1)
#设备状态
self.ON = "1"
self.OFF = "0"
self.content = " " #初始化要发送的信息
self.client = MQTTClient(self.CLIENT_ID, self.SERVER,
self.SERVER_PORT) #定义一个mqtt实例
def drawInterface(self): #界面初始化
bmp1 = ubitmap.BitmapFromFile("pic/boy")
bmp2 = ubitmap.BitmapFromFile("pic/girl")
bmp1.draw(20, 200) #显示boy图片
bmp2.draw(140, 200) #显示girl图片
screen.drawline(0, 160, 240, 160, 2, 0xff0000)
def do_connect(self):
sta_if = network.WLAN(network.STA_IF) #STA模式
ap_if = network.WLAN(network.AP_IF) #AP模式
if ap_if.active():
ap_if.active(False) #关闭AP
if not sta_if.isconnected():
print('Connecting to network...')
sta_if.active(True) #激活STA
sta_if.connect(self.wifi_name, self.wifi_SSID) #WiFi的SSID和密码
while not sta_if.isconnected():
pass
print('Network config:', sta_if.ifconfig())
gc.collect()
def selectInit(self): #选择表情初始化
screen.drawline(20, 200, 92, 200, 2, 0xff0000)
screen.drawline(92, 200, 92, 272, 2, 0xff0000)
screen.drawline(92, 272, 20, 272, 2, 0xff0000)
screen.drawline(20, 272, 20, 200, 2, 0xff0000)
def displayInit(self): #初始化
screen.clear()
self.drawInterface()
self.selectInit()
def esp(self):
self.client.set_callback(self.sub_cb) #设置回调
self.client.connect()
print("连接到服务器：%s" % self.SERVER)
self.client.publish(self.TOPIC1, self.ON) #发布“1”到TOPIC1
self.client.subscribe(self.TOPIC2) #订阅TOPIC
#display.text("从微信取得信息", 20, 20, 0xf000, 0xffff)
def keyboardEvent(self, key):
if self.keymatch[key] == "Key1": #右移键，选择要发送的表情
if self.select % 2 == 1: #用红色框选中boy表情
screen.drawline(20, 200, 92, 200, 2, 0xffffff)
screen.drawline(92, 200, 92, 272, 2, 0xffffff)
screen.drawline(92, 272, 20, 272, 2, 0xffffff)
screen.drawline(20, 272, 20, 200, 2, 0xffffff)
screen.drawline(140, 200, 212, 200, 2, 0xff0000)
screen.drawline(212, 200, 212, 272, 2, 0xff0000)
screen.drawline(212, 272, 140, 272, 2, 0xff0000)
screen.drawline(140, 272, 140, 200, 2, 0xff0000)
self.select += 1
else: #用红色框选中girl表情
screen.drawline(140, 200, 212, 200, 2, 0xffffff)
screen.drawline(212, 200, 212, 272, 2, 0xffffff)
screen.drawline(212, 272, 140, 272, 2, 0xffffff)
screen.drawline(140, 272, 140, 200, 2, 0xffffff)
screen.drawline(20, 200, 92, 200, 2, 0xff0000)
screen.drawline(92, 200, 92, 272, 2, 0xff0000)
screen.drawline(92, 272, 20, 272, 2, 0xff0000)
screen.drawline(20, 272, 20, 200, 2, 0xff0000)
self.select += 1
if self.keymatch[key] == "Key3": #发送表情按键
if self.select % 2 == 1: #显示已发送boy表情
bmp1 = ubitmap.BitmapFromFile("pic/boy")
bmp1.draw(140, 40)
self.content = "001"
self.client.publish(self.TOPIC2, self.content) #给服务器发送boy表情的号码
else: #显示已发送girl表情
bmp2 = ubitmap.BitmapFromFile("pic/girl")
bmp2.draw(140, 40)
self.content = "002"
self.client.publish(self.TOPIC2,
self.content) #给服务器发送girl表情的号码
def sub_cb(self, topic, message): #从服务器接受信息
message = message.decode()
print("服务器发来信息：%s" % message)
#global count
if message == "001": #收到boy表情号码显示boy表情
bmp1 = ubitmap.BitmapFromFile("pic/boy")
bmp1.draw(140, 40)
elif message == "002": #收到girl表情号码显示girl表情
bmp1 = ubitmap.BitmapFromFile("pic/girl")
bmp1.draw(140, 40)
def start(self):
try:
while True:
self.client.check_msg() #检查是否收到信息
i = 0 #用来辅助判断那个按键被按下
j = -1
for k in self.keys: #检查按键是否被按下
if (k.value() == 0): ##如果按键被按下
if i != j:
j = i
self.keyboardEvent(i) #触发相应按键对应事件
i = i + 1
if (i > 3):
i = 0
time.sleep_ms(130)
finally:
self.client.disconnect()
print("MQTT连接断开")
class Device(object):
"""
Losant MQTT Device class
Used to communicate as a particular device over MQTT to Losant
and report device state and receive commands.
"""
mqtt_endpoint = "broker.losant.com"
def __init__(self, device_id, key, secret):
self._device_id = device_id
self._key = key
self._secret = secret
self._mqtt_client = None
self._initial_connect = False
def is_connected(self):
""" Returns if the client is currently connected to Losant """
# pylint: disable=W0212
return self._mqtt_client and self._mqtt_client.sock
def connect(self):
""" Attempts to establish a connection to Losant.
Will be blocking or non-blocking depending on the value of
the 'blocking' argument. When non-blocking, the 'loop' function
must be called to perform network activity.
"""
if self._mqtt_client:
return
self._initial_connect = True
port = 1883
self._mqtt_client = MQTTClient(self._device_id, self.mqtt_endpoint,
port, self._key, self._secret)
print("Connecting to Losant as {}".format(self._device_id))
resp = self._mqtt_client.connect()
self._cb_client_connect(resp)
def close(self):
""" Closes the connection to Losant """
if self._mqtt_client:
self._mqtt_client.disconnect()
def send_state(self, state):
""" Reports the given state to Losant for this device """
print("Sending state for {}".format(self._device_id))
if not self._mqtt_client:
return False
payload = json.dumps({"data": state})
self._mqtt_client.publish(self._state_topic(), payload)
# ============================================================
# Private functions
# ============================================================
def _command_topic(self):
return "losant/{0}/command".format(self._device_id)
def _state_topic(self):
return "losant/{0}/state".format(self._device_id)
def _cb_client_connect(self, response_code):
if response_code == 0:
return
print("{} failed to connect, with mqtt error {}".format(
self._device_id, response_code))
if response_code in (1, 2, 4, 5):
raise Exception(
"Invalid Losant credentials - error code {0}".format(
response_code))
