simply-static domain was triggered too early. This is usually an indicator for some code in the plugin or theme running too early. Translations should be loaded at the init action or later. Please see Debugging in WordPress for more information. (This message was added in version 6.7.0.) in /var/www/html/wp-includes/functions.php on line 6121sudo find /etc/php/7.4/apache2/ -name 'php.ini' | xargs sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 50000M/g'
sudo find /etc/php/7.4/apache2/ -name 'php.ini' | xargs sed -i 's/post_max_size = 8M/post_max_size = 50000M/g'https://blog.csdn.net/qq_38329197/article/details/104961972
对于上传文件大于20G的需要安装插件Big File Uploads
from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)#以BCM模式使用引脚
GPIO.setwarnings(False)# 去除GPIO警告
def setServoAngle(servo, angle):#此函数将角度转换为占空比
pwm = GPIO.PWM(servo, 50)#设置pwm波为50Hz，也就是20ms一周期
pwm.start(8)#启动pwm
dutyCycle = angle / 18. + 3.#此公式由舵机调零推算得出（+3是偏移量）（占空比=%2.5+（目标角度/180°）*（%12.5-%2.5））
pwm.ChangeDutyCycle(dutyCycle)#调整pwm占空比
sleep(0.3)
pwm.stop()#关闭pwm
if __name__ == '__main__':
import sys
servo = int(sys.argv[1])#外部输入参数
GPIO.setup(servo, GPIO.OUT)#设置指定的引脚为输出模式
setServoAngle(servo, int(sys.argv[2]))
GPIO.cleanup()#清除引脚占用python3 文件名 舵机引脚 舵机角度
硬件连接部分：
舵机为MG90S型号，由三根线控制，棕色为负，红色为正，橙色是信号线
此舵机可以由树莓派直接供电，不需要外接电源
棕色GND
红色VCC
橙色GPIO
舵机接线后一定要检查连接是否正确再上电！！！否则可能会烧坏树莓派！可以在舵机和树莓派之间接一10k电阻。保护树莓派。
此引脚图为网口对着自己时
舵机调零：
舵机旋转角度是绝对位置，每一个位置对应固定的角度（类似于tab缩进，光标在屏幕上有固定的位置，当按下tab键时，光标跳到固定位置而不是固定缩进多少格），mg90s的旋转角度为0°~180°。
舵机调零是指当代码控制舵机在某一位置时（例如0度），舵机臂有可能不在0°位置，此时要通过改变舵机臂的固定位置，使舵机臂物理上处于0°位置。
舵机控制原理：（引用于此秒懂舵机角度控制原理 – 八色木）
舵机内部的控制电路，电位计（可变电阻器）和电机均被连接到电路板上，如内部结构图的右边部分。控制电路通过电位计可监控舵机的当前角度。
如果轴的位置与控制信号相符，那么电机就会关闭。如果控制电路发现这个角度不正确，它就会控制马达转动，直到它达到指定的角度。舵机角度根据制造商的不同而有所不同。比如，一个180度的舵机，它可以在0度至180度之间运动。由于限位装置被安装在主输出装置上，超出这个范围机械结构就不能再转动了。
舵机的输出功率与它所需要转动的距离成正比。如果输出轴需要转动很长的距离，马达就会全速运转，如果它只需要短距离转动，马达就会以较慢的速度运行，这叫做速度比例控制。
控制线用于传输角度控制信号。这个角度是由控制信号脉冲的持续时间决定的，这叫做脉冲编码调制（PCM）。舵机的控制一般需要一个20ms左右的时基脉冲，该脉冲的高电平部分一般为0.5ms-2.5ms范围，总间隔为2ms。脉冲的宽度将决定马达转动的距离。例如：1.5毫秒的脉冲，电机将转向90度的位置（通常称为中立位置，对于180°舵机来说，就是90°位置）。如果脉冲宽度小于1.5毫秒，那么电机轴向朝向0度方向。如果脉冲宽度大于1.5毫秒，轴向就朝向180度方向。以180度舵机为例，对应的控制关系是这样的：
0.5ms———— 0度；
1.0ms———— 45度；
1.5ms———— 90度；
2.0ms———– 135度；
2.5ms———– 180度；
占空比是指在一个脉冲循环内，通电时间相对于总时间所占的比例。占空比(Duty Ratio)在电信领域中有如下含义：例如：脉冲宽度1μs，信号周期4μs的脉冲序列占空比为0.25。
舵机代码中是以占空比来进行舵机旋转角度的控制，而占空比和角度的变化是线性，所以可以得到计算公式为：
占空比 = (0.5ms/20ms) + (旋转角度/180°）((2.5ms/20ms) – (0.5ms/20ms))
20ms是一个脉冲循环的周期，由设置的pwm波的频率为50Hz计算得到。
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
signal = 18
GPIO.setup(signal, GPIO.OUT)
frequency = 50
pwm = GPIO.PWM(signal, frequency)
def get_duty(direction):
duty = (1/18)*direction + 2.5
return duty
if __name__ == '__main__':
try:
pwm.start(0)
while True:
direction = float(input("Please input a direction between 0 and 180:"))
duty = get_duty(direction)
pwm.ChangeDutyCycle(duty)
except Exception as e:
print('An exception has happened',e)
finally:
pwm.stop()
GPIO.cleanup()
# Complete project details at https://RandomNerdTutorials.com
def sub_cb(topic, msg):
print((topic, msg))
if topic == b'notification' and msg == b'received':
print('ESP received hello message')
def connect_and_subscribe():
global client_id, mqtt_server, topic_sub
client = MQTTClient(client_id, mqtt_server,port=21892,user='roown',password='Chinaone',keepalive=60)
client.set_callback(sub_cb)
client.connect()
client.subscribe(topic_sub)
print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
return client
def restart_and_reconnect():
print('Failed to connect to MQTT broker. Reconnecting...')
time.sleep(10)
machine.reset()
try:
client = connect_and_subscribe()
except OSError as e:
restart_and_reconnect()
while True:
try:
client.check_msg()
if (time.time() - last_message) > message_interval:
msg = b'Hello #%d' % counter
client.publish(topic_pub, msg)
last_message = time.time()
counter += 1
except OSError as e:
restart_and_reconnect()
# This file is executed on every boot (including wake-boot from deepsleep)
#import esp
#esp.osdebug(None)
#import webrepl
#webrepl.start()
# Complete project details at https://RandomNerdTutorials.com
import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
esp.osdebug(None)
import gc
gc.collect()
ssid = '2312-1'
password = 'onlychina1'
mqtt_server = 'mqtt.roown.com'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.144'
client_id = ubinascii.hexlify(machine.unique_id())
topic_sub = b'notification'
topic_pub = b'hello'
last_message = 0
message_interval = 5
counter = 0
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
mosquitto_pub -h mqtt.roown.com -p 21892 -u roown -P Chinaone -t "notification" -m "received"测试服务器
mosquitto_sub -h mqtt.roown.com -p 21892 -u roown -P Chinaone -t "esp"mosquitto_pub -h mqtt.roown.com -p 21892 -u roown -P Chinaone -t "esp" -m "测试"ssh pi@192.168.1.15https://zhuanlan.zhihu.com/p/359395794
pi@raspberrypi:~ $ ping www.baidu.com
如果网络不通
Win10找到这个设置界面：
先去掉勾选，确定，再重新如勾选，确定。
再测试：
网通了。
sudo apt-get update
apt search mqtt
MQTT分为服务器和客户端两部分。有很多MQTT软件包可选，我们选择比较流行的mosquitto。
sudo apt-get install mosquitto mosquitto-clients
说明：
mosquitto – the MQTT broker(MQTT代理，即MQTT服务)
mosquitto-clients – 命令行客户端，在调试时很有用。
dpkg -l mosquitto
在使用Mosquitto之前，我们需要修改配置文件。配置文件位于/etc/mosquito。
cat /etc/mosquitto/mosquitto.conf
注释中说：
1) 将本地配置放在/etc/mosquitto/conf.d/目录中。
我们看看/etc/mosquitto/conf.d/目录：
里面有一个说明文件，打开看看：
放置在该目录中的任何扩展名为.conf的文件都会被代理作为配置文件加载，用作本地配置。
2) 有一个完全的配置文件说明在：/usr/share/doc/mosquitto/examples/
sudo cp /usr/share/doc/mosquitto/examples/mosquitto.conf.gz /etc/mosquitto/conf.d/
sudo gzip -d mosquitto.conf.gz
sudo nano /etc/mosquitto/conf.d/mosquitto.conf
这是一个很大的文件，有800多行，所有的行都被#符号注释掉了。
我们修改下面几处，去掉注释符号，修改默认值：
user mosquitto
max_queued_messages 200
message_size_limit 0
allow_zero_length_clientid true
allow_duplicate_messages false
port 1883
autosave_interval 900
autosave_on_changes false
persistence true
persistence_file mosquitto.db
allow_anonymous false
Password_file /etc/mosquitto/passwd.conf
下面两种方法选一种。
sudo Mosquitto_passwd -c /etc/mosquitto/passwd.conf 用户名
输入两遍密码
我们的用户名为ct
sudo mosquitto_passwd -c /etc/mosquitto/passwd.conf ct
sudo Mosquitto_passwd -b /etc/mosquitto/passwd.conf 用户名 密码
我们不用明文账户。
mosquitto -h
需要开3个终端。
mosquitto -c /etc/mosquitto/mosquitto.conf -v
-v记录所有类型的日志，因为我们在调试。以后正式使用mosquitto就不需要记录日志了，因为会占用存储空间。
上面提示日志文件mosquitto.log的权限不够：
ls -l /var/log/mosquitto/mosquitto.log
修改权限：
sudo chmod 666 /var/log/mosquitto/mosquitto.log
再执行：
mosquitto -c /etc/mosquitto/mosquitto.conf -v
服务运行，终端窗口被占用。
再打开两个终端：
1) 一个终端执行：
mosquitto_sub -p 1883 -u ct -P xxxxxx -t “test”
订阅subscribe主题Topic：test，等待接收消息。
2) 另一个终端执行：
mosquitto_pub -p 1883 -u ct -P xxxxxx -t test -m “Hello!”
发布主题为test的消息Hello!
3) 订阅窗口显示接收到的消息
4) 查看日志
sudo cat /var/log/mosquitto/mosquitto.log
sudo reboot
ps -ef | grep mosquitto
mosquitto已经在后台启动。
MQTT是一个专为IoT设计的OASIS标准的Pub/Sub消息协议，已经被广泛应用在汽车工业、制造业、电信业、石油和天然气业等场景。主要特点：超轻量级（内存开销约为6MB）、传输带宽小、消息可靠传输。
MQTT 架构的核心组件是代理（Broker）和客户端（Client）。Broker的负责在不同的Client之间分发消息。Client有两种角色：发布者（Publisher）和订阅者（Subscriber）。向Broker发布消息的Client是Publisher，向Broker订阅消息的Client是Subscriber。一个Client可以同时既是Publisher也是Subscriber。Client只与Broker建立连接，Client之间不直接相连。这种的好处是Client之间的通信不要求双方同时在线，即使一方离线，消息也可以临时存储在Broker中，等到Client重新上线，Broker再将消息发送给它。每个消息都有一个主题（Topic），Broker正是根据Topic来决策这条消息应该发送给哪些Subscriber。
Broker能够缓冲暂时无法分发到Client的消息。这个特点很适合网络不稳定的场景，例如IoT。除此之外，为了支持可靠的消息传递，MQTT支持 3 种不同类型QoS的消息：0 – 最多一次（at most once），1 – 至少一次（at least once），2 – 恰好一次（exactly once）。具体下文会介绍。
目前MQTT协议有两个版本：MQTT 3.1.1 和 MQTT 5。大多数商业 MQTT Broker现在都支持 MQTT 5，但许多物联网托管云服务仅支持 MQTT 3.1.1。相比MQTT 3.11，MQTT 5具有更强大的系统和云原生可扩展性。
Topic
在MQTT中，Topic指的一个UTF-8编码的字符串，Broker根据Topic为每个Client过滤它应该获取的消息。每个Topic由一个或多个主题级别构成，正斜杠“/”是主题级别分隔符。下图就是一个Topic的例子，可以看到，它是一个四级的Topic。通过使用“/”，可以让Topic的含义更加清晰和便于理解，下图表达的是“我家一楼客厅的温度”这一主题。MQTT的Topic非常轻量级，Client在发布或者订阅它之前不需要专门创建。Broker会接受每一个符合规则的Topic。
每个Topic必须至少包含一个字符，允许空格（但是不推荐包含空格），大小写敏感（例如“myhome/firstfloor”和“Myhome/firstfloor”是两个不同的Topic）。注意：不要以$符号开头设置Topic，因为以$符号开头的topic保留给Broker的内部统计。
Topic在匹配时支持通配符，MQTT支持两种通配符：单级的通配符“+”，多级的通配符“#”。注意：多级通配符必须作为主题的最后一个字符放置，并在前面加上正斜杠。
单级通配符举例：
多级通配符举例：
定义Topic的几大原则：
Client
Client指连接Broker的客户端。一个Client可以是Publisher，也可以是Subscriber，还可以两个身份都拥有。是Publisher还是Subscriber主要由Client的行为定义，发布消息的称之为Publisher，订阅消息的称之为Subscriber。
一个MQTT Client可以是任何设备（从微控制器到完整的服务器），只要它运行了MQTT库并且通过网络连上了Broker。
Broker
与Client对应的是Broker，它负责接收所有消息，过滤消息，确定订阅了消息的Client，并将消息发送给这些订阅的Client。除此之外，Broker还要负责管理和保存Client的持久会话的数据、对Client的身份认证和授权等等。
MQTT连接
MQTT协议基于TCP/IP，因此Client和Broker都需要一个TCP/IP协议栈。除此之外，MQTT也支持Websocket协议，当然，Websocket也是基于TCP的。目的是使得浏览器可以使用MQTT协议，因为浏览器无法直接操控TCP会话，但是可以操作Websocket会话。
MQTT连接只会在Client和Broker之间建立。Client之间不会直接建立连接。要创建连接，Client先向Broker发送CONNECT消息，Broker以CONNACK消息和状态代码进行响应。一旦连接建立，Broker将其保持打开，直到Client发送断开连接命令或连接中断。
QoS保障是指消息发送方和消息接收方之间（既指消息从Client到Broker，也指消息从Broker到Client），用于定义特定消息的交付保证。消息从Client到Broker的QoS级别，由Client在发送消息时定义。消息从Broker到Client的QoS级别，由Client在订阅过程中定义。MQTT设置了三个级别：
该级别只保证best-effort的消息发送。消息接收方不会确认收到消息，发送方也不会存储和重新发送消息。消息只会被发送方发送一次，称之为“即发即忘”。
At least once
该级别保证消息至少发送一次。消息发送方发送完消息后，会等待消息接收方返回的PUBACK数据包，用来确认消息接收方确实收到了消息。如果消息发送方在一段时间内没有收到消息接收方的PUBACK包，它会再次发送这个消息，直到收到PUBACK包。注意：这可能会导致消息的重复发送，因此需要信息的订阅者自己处理重复消息。
Exactly once
该级别保证消息会且仅会被收到一次。这个级别的QoS是最安全的，也是最慢的，因为它需要两个请求/响应往返。消息发送方在发送完消息后，会等待消息接收方返回的PUBREC包。一旦消息发送方收到PUBREC包，它会丢弃原始的消息，保存收到的PUBREC包，并发送PUBREL数据包给消息接收方和等待返回的PUBCOMP包。消息的接收者直到发送PUBCOMP之后，才会确认一开始收到的消息的ID。这样做的目的是防止处理重复的消息。最终，消息的发送者和接收者都确认了消息已经成功发送。
在非持久会话中，如果Client在订阅过程中因为种种原因掉线了，那么所有的未被接收的消息都会丢失。为了避免上述问题，Client在与Broker创建连接时，可以设置持久会话，这样Client在重新连上后，掉线期间的消息（QoS 1和QoS 2）将不会丢失并可以被正确获取。
Client在和Broker创建连接时，通过设置cleanSession标志位来告诉Broker创建哪种会话：
保留消息指的是retained标志位被置为true的普通消息。Broker会保留最后一条收到的保留消息，这样新订阅的Client可以在它们订阅主题后立刻获得一条消息。
保留消息的主要应用在Client想要在订阅主题后就需要立刻获取消息的场景。如果没有保留消息，Client就需要等待消息发布者发布下一条消息，才能知道消息发布者的状态。由于消息发布者的发布频率是不确定的，在某些特殊场景，Client很可能要等待很久才能获取到第一条消息。
Client可以使用遗嘱功能在自己异常离线后通知其他Client。遗嘱消息是一条普通的MQTT消息，带有一个Topic、Retained message标志位、QoS标志位和有效负载。遗嘱消息在Client与Broker创建连接时发送给Broker。Broker会存储遗嘱消息，当发现Client异常离线后，将这条遗嘱消息发送给订阅了遗嘱消息Topic的所有Client。如果Client使用DISCONNECT消息正常断开连接，那么Broker将会丢弃存储的遗嘱消息。
MQTT的名字中含有MQ，但是其实与消息队列无关。通常可以看到MQTT与传统消息队列存在以下区别：
import network,time,os
import usocket as socket # 引用socket模块
from machine import UART
import select,json
from umqtt.simple import MQTTClient
def sub_cb(topic, msg):
global statemqtt
print((topic, msg)) #打印收到信息
if msg == b"on":
lcdmain.my_text_out("mqtt"+":on",0,32)#单片机显示接收的信息
statemqtt = 1
elif msg == b"off":
lcdmain.my_text_out("mqtt"+":off",0,32)
statemqtt = 0
elif msg == b"toggle":
# LED is inversed, so setting it to current state
# value will make it toggle
lcdmain.my_text_out("mqtt"+":tog",0,32)
statemqtt = 1 - statemqtt
def main():
c = MQTTClient("umqtt_client", "1.tcp.vip.cpolar.cn",20257)
#建立一个MQTT客户端
c.set_callback(sub_cb) #设置回调函数
c.connect() #建立连接
c.subscribe(b"mqtt/mypi") #监控ledctl这个通道，接收控制命令
if __name__ == '__main__':
while True:
main()
安装mosquitto
sudo apt-get update
sudo apt-get -y upgrade
sudo apt-get -y full-upgrade
sudo apt-get -y install mosquitto mosquitto-clients修改配置文件
sudo nano /etc/mosquitto/mosquitto.conf
Start the systemd service.
systemctl start mosquitto
Enable the systemd service to run on boot.
systemctl enable mosquitto安装python库
pip3 install paho-mqtt
sudo nano a.py
import paho.mqtt.client as mqtt
client=mqtt.Client("RPi2")
client.connect("192.168.1.8",port=1883,keepalive=60)
client.publish("mqtt/mypi","Off")# =================================================================
# General configuration
# =================================================================
# 客户端心跳的间隔时间
#retry_interval 20
# 系统状态的刷新时间
#sys_interval 10
# 系统资源的回收时间，0表示尽快处理
#store_clean_interval 10
# 服务进程的PID
#pid_file /var/run/mosquitto.pid
# 服务进程的系统用户
#user mosquitto
# 客户端心跳消息的最大并发数
#max_inflight_messages 10
# 客户端心跳消息缓存队列
#max_queued_messages 100
# 用于设置客户端长连接的过期时间，默认永不过期
#persistent_client_expiration
# =================================================================
# Default listener
# =================================================================
# 服务绑定的IP地址
#bind_address
# 服务绑定的端口号
#port 1883
# 允许的最大连接数，-1表示没有限制
#max_connections -1
# cafile：CA证书文件
# capath：CA证书目录
# certfile：PEM证书文件
# keyfile：PEM密钥文件
#cafile
#capath
#certfile
#keyfile
# 必须提供证书以保证数据安全性
#require_certificate false
# 若require_certificate值为true，use_identity_as_username也必须为true
#use_identity_as_username false
# 启用PSK（Pre-shared-key）支持
#psk_hint
# SSL/TSL加密算法，可以使用“openssl ciphers”命令获取
# as the output of that command.
#ciphers
# =================================================================
# Persistence
# =================================================================
# 消息自动保存的间隔时间
#autosave_interval 1800
# 消息自动保存功能的开关
#autosave_on_changes false
# 持久化功能的开关
persistence true
# 持久化DB文件
#persistence_file mosquitto.db
# 持久化DB文件目录
#persistence_location /var/lib/mosquitto/
# =================================================================
# Logging
# =================================================================
# 4种日志模式：stdout、stderr、syslog、topic
# none 则表示不记日志，此配置可以提升些许性能
log_dest none
# 选择日志的级别（可设置多项）
#log_type error
#log_type warning
#log_type notice
#log_type information
# 是否记录客户端连接信息
#connection_messages true
# 是否记录日志时间
#log_timestamp true
# =================================================================
# Security
# =================================================================
# 客户端ID的前缀限制，可用于保证安全性
#clientid_prefixes
# 允许匿名用户
#allow_anonymous true
# 用户/密码文件，默认格式：username:password
#password_file
# PSK格式密码文件，默认格式：identity:key
#psk_file
# pattern write sensor/%u/data
# ACL权限配置，常用语法如下：
# 用户限制：user <username>
# 话题限制：topic [read|write] <topic>
# 正则限制：pattern write sensor/%u/data
#acl_file
# =================================================================
# Bridges
# =================================================================
# 允许服务之间使用“桥接”模式（可用于分布式部署）
#connection <name>
#address <host>[:<port>]
#topic <topic> [[[out | in | both] qos-level] local-prefix remote-prefix]
# 设置桥接的客户端ID
#clientid
# 桥接断开时，是否清除远程服务器中的消息
#cleansession false
# 是否发布桥接的状态信息
#notifications true
# 设置桥接模式下，消息将会发布到的话题地址
# $SYS/broker/connection/<clientid>/state
#notification_topic
# 设置桥接的keepalive数值
#keepalive_interval 60
# 桥接模式，目前有三种：automatic、lazy、once
#start_type automatic
# 桥接模式automatic的超时时间
#restart_timeout 30
# 桥接模式lazy的超时时间
#idle_timeout 60
# 桥接客户端的用户名
#username
# 桥接客户端的密码
#password
# bridge_cafile：桥接客户端的CA证书文件
# bridge_capath：桥接客户端的CA证书目录
# bridge_certfile：桥接客户端的PEM证书文件
# bridge_keyfile：桥接客户端的PEM密钥文件
#bridge_cafile
#bridge_capath
#bridge_certfile
#bridge_keyfile
import sys
import os
import time
import paho.mqtt.client as mqtt
sys.path.append(os.path.abspath(os.path.dirname(__file__) + '/' + '..'))
sys.path.append("..")
REPORT_TOPIC = 'mqtt/mypi' # 主题
def on_connect(client, userdata, flags, rc):
print('connected to mqtt with resurt code ', rc)
client.subscribe(REPORT_TOPIC) # 订阅主题
def on_message(client, userdata, msg):
message = msg.payload.decode()
print(message)
def server_conenet(client):
client.on_connect = on_connect # 启用订阅模式
client.on_message = on_message # 接收消息
client.connect("1.tcp.vip.cpolar.cn", 20257, 60) # 链接
# client.loop_start() # 以start方式运行，需要启动一个守护线程，让服务端运行，否则会随主线程死亡
client.loop_forever() # 以forever方式阻塞运行。
def server_stop(client):
client.loop_stop() # 停止服务端
sys.exit(0)
def server_main():
client_id = time.strftime('%Y%m%d%H%M%S', time.localtime(time.time()))
client = mqtt.Client(client_id, transport='tcp')
server_conenet(client)
if __name__ == '__main__':
# 启动监听
server_main()
import paho.mqtt.client as mqtt
client = mqtt.Client()
# 参数有 Client(client_id="", clean_session=True, userdata=None, protocol=MQTTv311, transport="tcp")
client.connect("1.tcp.vip.cpolar.cn", 20257, 60) # 连接服务器,端口为1883,维持心跳为60秒
client.publish('mqtt/mypi', 'test string',1)import upip
upip.install('micropython-umqtt.simple')from umqtt.simple import MQTTClient
import time
SERVER = '1.tcp.vip.cpolar.cn'
CLIENT_ID = 'PYESPCAR_A0' # 客户端的ID
TOPIC = b'mqtt/mypi' # TOPIC的ID
client = MQTTClient(CLIENT_ID,SERVER,user=None,port=20257,keepalive=60)
client.connect()
while True:
client.publish(TOPIC, 'helloworld')
time.sleep(1)参考
https://mpython.readthedocs.io/en/master/library/mPython/umqtt.simple.html
from umqtt.simple import MQTTClient
import time
SERVER = '1.tcp.vip.cpolar.cn'
CLIENT_ID = 'PYESPCAR_A0' # 客户端的ID
TOPIC = b'mqtt/mypi' # TOPIC的ID
client = MQTTClient(CLIENT_ID,SERVER,user=None,port=20257,keepalive=60)
client.connect()
while True:
# client.publish(TOPIC, b'你好')
client.publish(TOPIC,str(time.localtime()))
time.sleep(1)收（命令行测试）
mosquitto_sub -h 1.tcp.vip.cpolar.cn -p 20257 -t "mqtt/mypi"import network
import time
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect("1210", "onlychina")
station.isconnected()
time.sleep(5)
#import dht11
from umqtt.simple import MQTTClient
from machine import Pin
led = Pin(4,Pin.OUT)#led引脚输出模式
client_id='PYESPCAR_A0' #设备的ID
server = '1.tcp.vip.cpolar.cn' #onenet地址
port =20257 #连接的端口
# Publish test messages e.g. with:
# mosquitto_pub -t foo_topic -m hello
# Received messages from subscriptions will be delivered to this callback
c = MQTTClient(client_id, server,port,keepalive=60) #(self, client_id, server, port=0, user=None, password=None, keepalive=0,ssl=False, ssl_params={}):
def sub_cb(topic, msg):
print((topic, msg))
msg_str = msg.decode()#消息转换为二进制转换字符串
if(msg_str == "TurnOn"):
led.value(1)
topic_str = topic.decode() #二进制转换字符串,转换"request","response"变成消息
#b'$sys/449990/pc_esp32/cmd/request/90651f67-14fc-431c-97b7-6321911728ed'
#b'$sys/449990/pc_esp32/cmd/response/90651f67-14fc-431c-97b7-6321911728ed'
topic = topic_str.replace("request","response").encode()
if(led.value()):c.publish(topic,b"light is turn on")
if(msg_str == "TurnOff"):
led.value(0)
topic_str = topic.decode() #二进制转换字符串,转换"request","response"变成消息
topic = topic_str.replace("request","response").encode()
if(led.value() == 0):c.publish(topic,b"light is turn off")
def main(): # test server : iot.eclipse.org
c.set_callback(sub_cb)
c.connect()
c.subscribe(b'mqtt/mypi')# subscribe foo_topic tipic
while True:
try:#防止dht11读取错误异常退出（leb灯打开后会有超时情况：File "dht.py", line 17, in measure -->> OSError: [Errno 116] ETIMEDOUT）
# _,temperature,Humidity = dht11.dht11(15)#传入引脚号
#print(temperature,Humidity)
c.publish(b'mqtt/mypi', "{ 'id': 123, 'dp': { 'temperatrue': 22,'humidity': [{ 'v':" + str(33) +", }]}}")#发送数据
except OSError:
print(OSError)
# Non-blocking wait for message
c.check_msg()
# Then need to sleep to avoid 100% CPU usage (in a real
# app other useful actions would be performed instead)
time.sleep(6)
c.disconnect()
if __name__ == "__main__":
main()
参考链接
https://www.bilibili.com/read/cv12453670
#coding:utf-8
import network
import time
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect("1210", "onlychina")
station.isconnected()
time.sleep(5)
#import dht11
from umqtt.simple import MQTTClient
from machine import Pin
led = Pin(4,Pin.OUT)#led引脚输出模式
client_id='PYESPCAR_A0' #设备的ID
server = '1.tcp.vip.cpolar.cn' #onenet地址
port =20257 #连接的端口
# Publish test messages e.g. with:
# mosquitto_pub -t foo_topic -m hello
# Received messages from subscriptions will be delivered to this callback
c = MQTTClient(client_id, server,port,keepalive=60) #(self, client_id, server, port=0, user=None, password=None, keepalive=0,ssl=False, ssl_params={}):
def sub_cb(topic, msg):
print((topic, msg))
msg_str = msg.decode()#消息转换为二进制转换字符串
if(msg_str == "TurnOn"):
led.value(1)
topic_str = topic.decode() #二进制转换字符串,转换"request","response"变成消息
#b'$sys/449990/pc_esp32/cmd/request/90651f67-14fc-431c-97b7-6321911728ed'
#b'$sys/449990/pc_esp32/cmd/response/90651f67-14fc-431c-97b7-6321911728ed'
topic = topic_str.replace("request","response").encode()
if(led.value()):c.publish(topic,b"开灯")
if(msg_str == "TurnOff"):
led.value(0)
topic_str = topic.decode() #二进制转换字符串,转换"request","response"变成消息
topic = topic_str.replace("request","response").encode()
if(led.value() == 0):c.publish(topic,b"关灯")
def main(): # test server : iot.eclipse.org
c.set_callback(sub_cb)
c.connect()
c.subscribe(b'mqtt/mypi')# subscribe foo_topic tipic
while True:
try:#防止dht11读取错误异常退出（leb灯打开后会有超时情况：File "dht.py", line 17, in measure -->> OSError: [Errno 116] ETIMEDOUT）
# _,temperature,Humidity = dht11.dht11(15)#传入引脚号
#print(temperature,Humidity)
c.publish(b'mqtt/mypi','TurnOff')#发送数据
except OSError:
print(OSError)
# Non-blocking wait for message
c.check_msg()
# Then need to sleep to avoid 100% CPU usage (in a real
# app other useful actions would be performed instead)
time.sleep(6)
c.disconnect()
if __name__ == "__main__":
main()
try:
import usocket as socket
except:
import socket
import ustruct as struct
from ubinascii import hexlify
class MQTTException(Exception):
pass
class MQTTClient:
def __init__(self, client_id, server, port=0, user=None, password=None, keepalive=0,
ssl=False, ssl_params={}):
if port == 0:
port = 8883 if ssl else 1883
self.client_id = client_id
self.sock = None
self.server = server
self.port = port
self.ssl = ssl
self.ssl_params = ssl_params
self.pid = 0
self.cb = None
self.user = user
self.pswd = password
self.keepalive = keepalive
self.lw_topic = None
self.lw_msg = None
self.lw_qos = 0
self.lw_retain = False
def _send_str(self, s):
self.sock.write(struct.pack("!H", len(s)))
self.sock.write(s)
def _recv_len(self):
n = 0
sh = 0
while 1:
b = self.sock.read(1)[0]
n |= (b & 0x7f) << sh
if not b & 0x80:
return n
sh += 7
def set_callback(self, f):
self.cb = f
def set_last_will(self, topic, msg, retain=False, qos=0):
assert 0 <= qos <= 2
assert topic
self.lw_topic = topic
self.lw_msg = msg
self.lw_qos = qos
self.lw_retain = retain
def connect(self, clean_session=True):
self.sock = socket.socket()
addr = socket.getaddrinfo(self.server, self.port)[0][-1]
self.sock.connect(addr)
if self.ssl:
import ussl
self.sock = ussl.wrap_socket(self.sock, **self.ssl_params)
premsg = bytearray(b"\x10\0\0\0\0\0")
msg = bytearray(b"\x04MQTT\x04\x02\0\0")
sz = 10 + 2 + len(self.client_id)
msg[6] = clean_session << 1
if self.user is not None:
sz += 2 + len(self.user) + 2 + len(self.pswd)
msg[6] |= 0xC0
if self.keepalive:
assert self.keepalive < 65536
msg[7] |= self.keepalive >> 8
msg[8] |= self.keepalive & 0x00FF
if self.lw_topic:
sz += 2 + len(self.lw_topic) + 2 + len(self.lw_msg)
msg[6] |= 0x4 | (self.lw_qos & 0x1) << 3 | (self.lw_qos & 0x2) << 3
msg[6] |= self.lw_retain << 5
i = 1
while sz > 0x7f:
premsg[i] = (sz & 0x7f) | 0x80
sz >>= 7
i += 1
premsg[i] = sz
self.sock.write(premsg, i + 2)
self.sock.write(msg)
#print(hex(len(msg)), hexlify(msg, ":"))
self._send_str(self.client_id)
if self.lw_topic:
self._send_str(self.lw_topic)
self._send_str(self.lw_msg)
if self.user is not None:
self._send_str(self.user)
self._send_str(self.pswd)
resp = self.sock.read(4)
assert resp[0] == 0x20 and resp[1] == 0x02
if resp[3] != 0:
raise MQTTException(resp[3])
return resp[2] & 1
def disconnect(self):
self.sock.write(b"\xe0\0")
self.sock.close()
def ping(self):
self.sock.write(b"\xc0\0")
def publish(self, topic, msg, retain=False, qos=0):
pkt = bytearray(b"\x30\0\0\0")
pkt[0] |= qos << 1 | retain
sz = 2 + len(topic) + len(msg)
if qos > 0:
sz += 2
assert sz < 2097152
i = 1
while sz > 0x7f:
pkt[i] = (sz & 0x7f) | 0x80
sz >>= 7
i += 1
pkt[i] = sz
#print(hex(len(pkt)), hexlify(pkt, ":"))
self.sock.write(pkt, i + 1)
self._send_str(topic)
if qos > 0:
self.pid += 1
pid = self.pid
struct.pack_into("!H", pkt, 0, pid)
self.sock.write(pkt, 2)
self.sock.write(msg)
if qos == 1:
while 1:
op = self.wait_msg()
if op == 0x40:
sz = self.sock.read(1)
assert sz == b"\x02"
rcv_pid = self.sock.read(2)
rcv_pid = rcv_pid[0] << 8 | rcv_pid[1]
if pid == rcv_pid:
return
elif qos == 2:
assert 0
def subscribe(self, topic, qos=0):
assert self.cb is not None, "Subscribe callback is not set"
pkt = bytearray(b"\x82\0\0\0")
self.pid += 1
struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, self.pid)
#print(hex(len(pkt)), hexlify(pkt, ":"))
self.sock.write(pkt)
self._send_str(topic)
self.sock.write(qos.to_bytes(1, "little"))
while 1:
op = self.wait_msg()
if op == 0x90:
resp = self.sock.read(4)
#print(resp)
assert resp[1] == pkt[2] and resp[2] == pkt[3]
if resp[3] == 0x80:
raise MQTTException(resp[3])
return
# Wait for a single incoming MQTT message and process it.
# Subscribed messages are delivered to a callback previously
# set by .set_callback() method. Other (internal) MQTT
# messages processed internally.
def wait_msg(self):
res = self.sock.read(1)
self.sock.setblocking(True)
if res is None:
return None
if res == b"":
raise OSError(-1)
if res == b"\xd0": # PINGRESP
sz = self.sock.read(1)[0]
assert sz == 0
return None
op = res[0]
if op & 0xf0 != 0x30:
return op
sz = self._recv_len()
topic_len = self.sock.read(2)
topic_len = (topic_len[0] << 8) | topic_len[1]
topic = self.sock.read(topic_len)
sz -= topic_len + 2
if op & 6:
pid = self.sock.read(2)
pid = pid[0] << 8 | pid[1]
sz -= 2
msg = self.sock.read(sz)
self.cb(topic, msg)
if op & 6 == 2:
pkt = bytearray(b"\x40\x02\0\0")
struct.pack_into("!H", pkt, 2, pid)
self.sock.write(pkt)
elif op & 6 == 4:
assert 0
# Checks whether a pending message from server is available.
# If not, returns immediately with None. Otherwise, does
# the same processing as wait_msg.
def check_msg(self):
self.sock.setblocking(False)
return self.wait_msg()
主程序（main.py）
# Complete project details at https://RandomNerdTutorials.com/micropython-mqtt-publish-ds18b10-esp32-esp8266/
import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin
import onewire
import ds18x20
esp.osdebug(None)
import gc
gc.collect()
ssid = '1210'
password = 'onlychina'
mqtt_server = '1.tcp.vip.cpolar.cn'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.106'
client_id = ubinascii.hexlify(machine.unique_id())
topic_pub_temp = b'esp/ds18b20/temperature'
last_message = 0
message_interval = 5
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
def connect_mqtt():
global client_id, mqtt_server
client = MQTTClient(client_id, mqtt_server,port=20257,keepalive=60)
#client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return client
def restart_and_reconnect():
print('Failed to connect to MQTT broker. Reconnecting...')
time.sleep(10)
machine.reset()
def read_sensor():
try:
roms = ds_sensor.scan()
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
# uncomment for Fahrenheit
temp = temp * (9/5) + 32.0
if (isinstance(temp, float) or (isinstance(temp, int))):
temp = (b'{0:3.1f},'.format(temp))
return temp
else:
return('Invalid sensor readings.')
except OSError as e:
return('Failed to read sensor.')
try:
client = connect_mqtt()
except OSError as e:
restart_and_reconnect()
while True:
try:
if (time.time() - last_message) > message_interval:
# temp = read_sensor() #zjg
temp = str(time.localtime())
print(temp)
client.publish(topic_pub_temp, temp)
last_message = time.time()
except OSError as e:
restart_and_reconnect()
#coding:utf-8
# Complete project details at https://RandomNerdTutorials.com/micropython-mqtt-publish-ds18b10-esp32-esp8266/
import time,ntptime
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin,RTC
import onewire
import ds18x20
rtc = RTC()
led1=Pin(12,Pin.OUT)
def set_ntptime():
print("正在从NTP时间服务器获取时间，并校时到ESP8266/ESP32中（多次网络校时会出错OSError: -202，请断开串口连接再重试即可）：")
print(" A.网络校时前本地时间：%s" %str(time.localtime()))
ntptime.NTP_DELTA = 3155644800 # 设置 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选ntp服务器为阿里云服务器，默认是"pool.ntp.org"
ntptime.settime() # 从NTP服务器获取时间，并写入到ESP8266/ESP32设备中，到这就已经设置好了
print(" B.网络校时后本地时间：%s" %str(time.localtime()))
def sync_ntp():
ntptime.NTP_DELTA = 3155644800 # 可选 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选，ntp服务器，默认是"pool.ntp.org"
ntptime.settime() # 修改设备时间,到这就已经设置好了
esp.osdebug(None)
import gc
gc.collect()
ssid = '1210'
password = 'onlychina'
mqtt_server = 'mqtt.begair.com'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.106'
client_id = ubinascii.hexlify(machine.unique_id())
topic_pub_temp = b'esp1'
last_message = 0
message_interval = 5
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
def connect_mqtt():
global client_id, mqtt_server
client = MQTTClient(client_id, mqtt_server,port=20257,keepalive=60)
#client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return client
def restart_and_reconnect():
print('Failed to connect to MQTT broker. Reconnecting...')
time.sleep(10)
machine.reset()
def read_sensor():
try:
roms = ds_sensor.scan()
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
# uncomment for Fahrenheit
temp = temp * (9/5) + 32.0
if (isinstance(temp, float) or (isinstance(temp, int))):
temp = (b'{0:3.1f},'.format(temp))
return temp
else:
return('Invalid sensor readings.')
except OSError as e:
return('Failed to read sensor.')
# 同步时间
def sync_ntp():
ntptime.NTP_DELTA = 3155644800 # 可选 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选，ntp服务器，默认是"pool.ntp.org"
try:
ntptime.settime() # 修改设备时间,到这就已经设置好了
except:
for i in range(6):
led1.value(1) #turn off 0是亮
time.sleep(0.1)
led1.value(0)
time.sleep(0.1)
print('同步失败')
try:
client = connect_mqtt()
except OSError as e:
restart_and_reconnect()
while True:
for i in range(5):
sync_ntp()
time.sleep(1)
while True:
dt=time.localtime()
try:
if (time.time() - last_message) > message_interval:
# temp = read_sensor() #zjg
temp = str(dt)
print(temp)
client.publish(topic_pub_temp, b'真可以了')
client.publish(topic_pub_temp, temp)
last_message = time.time()
except OSError as e:
restart_and_reconnect()
#coding:utf-8
# Complete project details at https://RandomNerdTutorials.com/micropython-mqtt-publish-ds18b10-esp32-esp8266/
import time,ntptime
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin,RTC
import onewire
import ds18x20
rtc = RTC()
led1=Pin(12,Pin.OUT)
def set_ntptime():
print("正在从NTP时间服务器获取时间，并校时到ESP8266/ESP32中（多次网络校时会出错OSError: -202，请断开串口连接再重试即可）：")
print(" A.网络校时前本地时间：%s" %str(time.localtime()))
ntptime.NTP_DELTA = 3155644800 # 设置 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选ntp服务器为阿里云服务器，默认是"pool.ntp.org"
ntptime.settime() # 从NTP服务器获取时间，并写入到ESP8266/ESP32设备中，到这就已经设置好了
print(" B.网络校时后本地时间：%s" %str(time.localtime()))
esp.osdebug(None)
import gc
gc.collect()
ssid = '1210'
password = 'onlychina'
mqtt_server = 'mqtt.begair.com'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.106'
client_id = ubinascii.hexlify(machine.unique_id())
topic_pub_temp = b'begair'
last_message = 0
message_interval = 5
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
def connect_mqtt():
global client_id, mqtt_server
client = MQTTClient(client_id, mqtt_server,port=20257,user='getair',password='raspberry',keepalive=60)
#client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return client
def restart_and_reconnect():
print('Failed to connect to MQTT broker. Reconnecting...')
time.sleep(10)
machine.reset()
def read_sensor():
try:
roms = ds_sensor.scan()
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
# uncomment for Fahrenheit
temp = temp * (9/5) + 32.0
if (isinstance(temp, float) or (isinstance(temp, int))):
temp = (b'{0:3.1f},'.format(temp))
return temp
else:
return('Invalid sensor readings.')
except OSError as e:
return('Failed to read sensor.')
# 同步时间
def sync_ntp():
ntptime.NTP_DELTA = 3155644800 # 可选 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选，ntp服务器，默认是"pool.ntp.org"
try:
ntptime.settime() # 修改设备时间,到这就已经设置好了
except:
for i in range(6):
led1.value(1) #turn off 0是亮
time.sleep(0.1)
led1.value(0)
time.sleep(0.1)
print('同步失败')
try:
client = connect_mqtt()
except OSError as e:
restart_and_reconnect()
while True:
for i in range(5):
sync_ntp()
time.sleep(1)
while True:
dt=time.localtime()
try:
if (time.time() - last_message) > message_interval:
# temp = read_sensor() #zjg
temp = str(dt)
print(temp)
client.publish(topic_pub_temp, b'真可以了')
client.publish(topic_pub_temp, temp)
last_message = time.time()
except OSError as e:
restart_and_reconnect()
https://zhuanlan.zhihu.com/p/383708520
#coding:utf-8
# Complete project details at https://RandomNerdTutorials.com/micropython-mqtt-publish-ds18b10-esp32-esp8266/
import time,ntptime
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin,RTC
import onewire
import ds18x20
rtc = RTC()
led = machine.Pin(13,machine.Pin.OUT) #定义led为输出
sw = machine.Pin(0,machine.Pin.IN) #定义sw为输入
led1=Pin(12,Pin.OUT)
def set_ntptime():
print("正在从NTP时间服务器获取时间，并校时到ESP8266/ESP32中（多次网络校时会出错OSError: -202，请断开串口连接再重试即可）：")
print(" A.网络校时前本地时间：%s" %str(time.localtime()))
ntptime.NTP_DELTA = 3155644800 # 设置 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选ntp服务器为阿里云服务器，默认是"pool.ntp.org"
ntptime.settime() # 从NTP服务器获取时间，并写入到ESP8266/ESP32设备中，到这就已经设置好了
print(" B.网络校时后本地时间：%s" %str(time.localtime()))
esp.osdebug(None)
import gc
gc.collect()
ssid = '1210'
password = 'onlychina'
mqtt_server = 'mqtt.begair.com'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.106'
client_id = ubinascii.hexlify(machine.unique_id())
topic_pub_temp = b'beg'
last_message = 0
message_interval = 5
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
def connect_mqtt():
global client_id, mqtt_server
client = MQTTClient(client_id, mqtt_server,port=20257,user='getair',password='raspberry',keepalive=60)
#client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return client
def restart_and_reconnect():
print('Failed to connect to MQTT broker. Reconnecting...')
time.sleep(10)
machine.reset()
def read_sensor():
try:
roms = ds_sensor.scan()
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
# uncomment for Fahrenheit
temp = temp * (9/5) + 32.0
if (isinstance(temp, float) or (isinstance(temp, int))):
temp = (b'{0:3.1f},'.format(temp))
return temp
else:
return('Invalid sensor readings.')
except OSError as e:
return('Failed to read sensor.')
# 同步时间
def sync_ntp():
ntptime.NTP_DELTA = 3155644800 # 可选 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选，ntp服务器，默认是"pool.ntp.org"
try:
ntptime.settime() # 修改设备时间,到这就已经设置好了
except:
for i in range(6):
led1.value(1) #turn off 0是亮
time.sleep(0.1)
led1.value(0)
time.sleep(0.1)
print('同步失败')
try:
client = connect_mqtt()
except OSError as e:
restart_and_reconnect()
while True:
for i in range(5):
sync_ntp()
time.sleep(1)
while True:
sw = machine.Pin(0,machine.Pin.IN) #定义sw为输入
dt=time.localtime()
try:
if (time.time() - last_message) > message_interval:
# temp = read_sensor() #zjg
temp = str(dt)
# print(temp)
if (sw.value() == 1):
client.publish(topic_pub_temp, b'真可以了')
led.on()
else:
client.publish(topic_pub_temp, temp)
led.off()
last_message = time.time()
except OSError as e:
restart_and_reconnect()
#coding:utf-8
# Complete project details at https://RandomNerdTutorials.com/micropython-mqtt-publish-ds18b10-esp32-esp8266/
import time,ntptime
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin,RTC
import onewire
import ds18x20
import wifimgr
rtc = RTC()
led = machine.Pin(13,machine.Pin.OUT) #定义led为输出
sw = machine.Pin(0,machine.Pin.IN) #定义sw为输入
led1=Pin(12,Pin.OUT)
def set_ntptime():
print("正在从NTP时间服务器获取时间，并校时到ESP8266/ESP32中（多次网络校时会出错OSError: -202，请断开串口连接再重试即可）：")
print(" A.网络校时前本地时间：%s" %str(time.localtime()))
ntptime.NTP_DELTA = 3155644800 # 设置 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选ntp服务器为阿里云服务器，默认是"pool.ntp.org"
ntptime.settime() # 从NTP服务器获取时间，并写入到ESP8266/ESP32设备中，到这就已经设置好了
print(" B.网络校时后本地时间：%s" %str(time.localtime()))
esp.osdebug(None)
import gc
gc.collect()
mqtt_server = 'mqtt.roown.com'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.106'
client_id = ubinascii.hexlify(machine.unique_id())
topic_pub_temp = b'beg'
last_message = 0
message_interval = 0.002
led1.value(1)
try:
wlan = wifimgr.get_connection()
if wlan is None:
print("Could not initialize the network connection.")
led1.value(1)
time.sleep(1)
led1.value(0)
print('Connection successful')
except:
print('连接 wifi 失败')
machine.reset()
led1.value(1)
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
def connect_mqtt():
global client_id, mqtt_server
client = MQTTClient(client_id, mqtt_server,port=21892,user='roown',password='Chinaone',keepalive=60)
#client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return client
def restart_and_reconnect():
print('Failed to connect to MQTT broker. Reconnecting...')
time.sleep(10)
machine.reset()
def read_sensor():
try:
roms = ds_sensor.scan()
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
# uncomment for Fahrenheit
temp = temp * (9/5) + 32.0
if (isinstance(temp, float) or (isinstance(temp, int))):
temp = (b'{0:3.1f},'.format(temp))
return temp
else:
return('Invalid sensor readings.')
except OSError as e:
return('Failed to read sensor.')
# 同步时间
def sync_ntp():
ntptime.NTP_DELTA = 3155644800 # 可选 UTC+8偏移时间（秒），不设置就是UTC0
ntptime.host = 'ntp1.aliyun.com' # 可选，ntp服务器，默认是"pool.ntp.org"
try:
ntptime.settime() # 修改设备时间,到这就已经设置好了
except:
for i in range(6):
led1.value(1) #turn off 0是亮
time.sleep(0.1)
led1.value(0)
time.sleep(0.1)
print('同步失败')
try:
client = connect_mqtt()
except OSError as e:
restart_and_reconnect()
while True:
for i in range(5):
sync_ntp()
time.sleep(1)
while True:
sw = machine.Pin(0,machine.Pin.IN) #定义sw为输入
dt=time.localtime()
ws=sw.value()
try:
if (time.time() - last_message) > message_interval: #zjg
# temp = read_sensor() #zjg
temp = str(dt)
# print(temp)
if (ws == 1):
led.on()
client.publish(topic_pub_temp, b'真可以了')
else:
led.off()
client.publish(topic_pub_temp, temp)
last_message = time.time()
except OSError as e:
restart_and_reconnect()