diff --git a/nodemcu8266_v1.2_e8_a7_84_e6_a0_bc_e4_b9_a6.pdf b/nodemcu8266_v1.2_e8_a7_84_e6_a0_bc_e4_b9_a6.pdf new file mode 100644 index 0000000..c58d938 Binary files /dev/null and b/nodemcu8266_v1.2_e8_a7_84_e6_a0_bc_e4_b9_a6.pdf differ diff --git a/projectIO/BaFa_lutai_switch/BaFa_lutai_switch.ino b/projectIO/BaFa_lutai_switch/BaFa_lutai_switch.ino new file mode 100644 index 0000000..ceafa5e --- /dev/null +++ b/projectIO/BaFa_lutai_switch/BaFa_lutai_switch.ino @@ -0,0 +1,134 @@ +/* + * @Author: dugulingping + * @Date: 2022-06-09 17:14:49 + * @LastEditTime: 2022-06-17 13:21:04 + * @LastEditors: dugulingping + * @Description: + * @FilePath: \project\BaFa_lutai_switch\BaFa_lutai_switch.ino + */ +#include +#include "PubSubClient.h" + +// 引脚定义 +#define LED_LOCAL 2 +#define SWITCH_PIN 0 + +void turnOn(); +void turnOff(); + +const char* ssid = "mdd520"; //修改，你的路由去WIFI名字 +const char* password = "mj1688888888"; //你的WIFI密码 +#define ID_MQTT "ba6c540974354e998818b47472a8407d" //用户私钥，控制台获取 +const char* topic = "lutaiValveSwitch006"; //主题名字 + +const char* mqtt_server = "bemfa.com"; //默认，MQTT服务器 +const int mqtt_server_port = 9501; //默认，MQTT服务器 + + +WiFiClient espClient; +PubSubClient client(espClient); + +void Bink_led(int ms){ + Serial.print(">"); + digitalWrite(LED_LOCAL, 0); + delay(ms); + digitalWrite(LED_LOCAL, 1); + delay(ms); +} + +void setup_wifi() { + delay(10); + Serial.println(); + Serial.print("Connecting to "); + Serial.println(ssid); + WiFi.begin(ssid, password); + while (WiFi.status() != WL_CONNECTED) { + Bink_led(100); + } + + Serial.println(""); + Serial.println("WiFi connected"); + Serial.println("IP address: "); + Serial.println(WiFi.localIP()); +} + +void callback(char* topic, byte* payload, unsigned int length) { + Serial.print("Topic:"); + Serial.println(topic); + String msg = ""; + for (int i = 0; i < length; i++) { + msg += (char)payload[i]; + } + Serial.print("Msg:"); + Serial.println(msg); + if (msg == "on") { //on + turnOn(); //开 + } else if (msg == "off") { //off + turnOff(); //关 + } + msg = ""; +} + +void reconnect() { + int num = 0; + // Loop until we're reconnected + while (!client.connected()) { + Serial.print("Attempting MQTT connection..."); + Bink_led(500); + // Attempt to connect + if (client.connect(ID_MQTT)) { + Serial.println("connected"); + Serial.print("subscribe:"); + Serial.println(topic); + //订阅主题，如果需要订阅多个主题， + //可发送多条订阅指令client.subscribe(topic2);client.subscribe(topic3); + client.subscribe(topic); + } + else if(num >= 100){ + delay(5000); + ESP.restart(); + } else { + Serial.print("failed, rc="); + Serial.print(client.state()); + Serial.println(" try again in 5 seconds"); + delay(5000); + } + num++; + } +} + +//开 +void turnOn() { + Serial.println("turn on swich"); + digitalWrite(SWITCH_PIN, LOW); +} +//关 +void turnOff() { + Serial.println("turn off swich"); + digitalWrite(SWITCH_PIN, HIGH); +} + + +void setup() { + Serial.begin(115200); + pinMode(LED_LOCAL, OUTPUT); + pinMode(SWITCH_PIN, OUTPUT); + delay(500); + turnOff(); // 关闭 + setup_wifi(); + client.setServer(mqtt_server, mqtt_server_port);//设置mqtt服务器 + client.setCallback(callback); //mqtt消息处理 + +} + +void loop() { + if (WiFi.status() != WL_CONNECTED) { + setup_wifi(); + reconnect(); + } + if (!client.connected()){ + reconnect(); + } + client.loop(); + +} \ No newline at end of file diff --git a/projectIO/BaFa_lutai_switch/PubSubClient.cpp b/projectIO/BaFa_lutai_switch/PubSubClient.cpp new file mode 100644 index 0000000..9658c4a --- /dev/null +++ b/projectIO/BaFa_lutai_switch/PubSubClient.cpp @@ -0,0 +1,590 @@ +/* + PubSubClient.cpp - A simple client for MQTT. + Nick O'Leary + http://knolleary.net +*/ + +#include "PubSubClient.h" +#include "Arduino.h" + +PubSubClient::PubSubClient() { + this->_state = MQTT_DISCONNECTED; + this->_client = NULL; + this->stream = NULL; + setCallback(NULL); +} + +PubSubClient::PubSubClient(Client& client) { + this->_state = MQTT_DISCONNECTED; + setClient(client); + this->stream = NULL; +} + +PubSubClient::PubSubClient(IPAddress addr, uint16_t port, Client& client) { + this->_state = MQTT_DISCONNECTED; + setServer(addr, port); + setClient(client); + this->stream = NULL; +} +PubSubClient::PubSubClient(IPAddress addr, uint16_t port, Client& client, Stream& stream) { + this->_state = MQTT_DISCONNECTED; + setServer(addr,port); + setClient(client); + setStream(stream); +} +PubSubClient::PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) { + this->_state = MQTT_DISCONNECTED; + setServer(addr, port); + setCallback(callback); + setClient(client); + this->stream = NULL; +} +PubSubClient::PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) { + this->_state = MQTT_DISCONNECTED; + setServer(addr,port); + setCallback(callback); + setClient(client); + setStream(stream); +} + +PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, Client& client) { + this->_state = MQTT_DISCONNECTED; + setServer(ip, port); + setClient(client); + this->stream = NULL; +} +PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, Client& client, Stream& stream) { + this->_state = MQTT_DISCONNECTED; + setServer(ip,port); + setClient(client); + setStream(stream); +} +PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) { + this->_state = MQTT_DISCONNECTED; + setServer(ip, port); + setCallback(callback); + setClient(client); + this->stream = NULL; +} +PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) { + this->_state = MQTT_DISCONNECTED; + setServer(ip,port); + setCallback(callback); + setClient(client); + setStream(stream); +} + +PubSubClient::PubSubClient(const char* domain, uint16_t port, Client& client) { + this->_state = MQTT_DISCONNECTED; + setServer(domain,port); + setClient(client); + this->stream = NULL; +} +PubSubClient::PubSubClient(const char* domain, uint16_t port, Client& client, Stream& stream) { + this->_state = MQTT_DISCONNECTED; + setServer(domain,port); + setClient(client); + setStream(stream); +} +PubSubClient::PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) { + this->_state = MQTT_DISCONNECTED; + setServer(domain,port); + setCallback(callback); + setClient(client); + this->stream = NULL; +} +PubSubClient::PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) { + this->_state = MQTT_DISCONNECTED; + setServer(domain,port); + setCallback(callback); + setClient(client); + setStream(stream); +} + +boolean PubSubClient::connect(const char *id) { + return connect(id,NULL,NULL,0,0,0,0); +} + +boolean PubSubClient::connect(const char *id, const char *user, const char *pass) { + return connect(id,user,pass,0,0,0,0); +} + +boolean PubSubClient::connect(const char *id, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage) { + return connect(id,NULL,NULL,willTopic,willQos,willRetain,willMessage); +} + +boolean PubSubClient::connect(const char *id, const char *user, const char *pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage) { + if (!connected()) { + int result = 0; + + if (domain != NULL) { + result = _client->connect(this->domain, this->port); + } else { + result = _client->connect(this->ip, this->port); + } + if (result == 1) { + nextMsgId = 1; + // Leave room in the buffer for header and variable length field + uint16_t length = 5; + unsigned int j; + +#if MQTT_VERSION == MQTT_VERSION_3_1 + uint8_t d[9] = {0x00,0x06,'M','Q','I','s','d','p', MQTT_VERSION}; +#define MQTT_HEADER_VERSION_LENGTH 9 +#elif MQTT_VERSION == MQTT_VERSION_3_1_1 + uint8_t d[7] = {0x00,0x04,'M','Q','T','T',MQTT_VERSION}; +#define MQTT_HEADER_VERSION_LENGTH 7 +#endif + for (j = 0;j>1); + } + } + + buffer[length++] = v; + + buffer[length++] = ((MQTT_KEEPALIVE) >> 8); + buffer[length++] = ((MQTT_KEEPALIVE) & 0xFF); + length = writeString(id,buffer,length); + if (willTopic) { + length = writeString(willTopic,buffer,length); + length = writeString(willMessage,buffer,length); + } + + if(user != NULL) { + length = writeString(user,buffer,length); + if(pass != NULL) { + length = writeString(pass,buffer,length); + } + } + + write(MQTTCONNECT,buffer,length-5); + + lastInActivity = lastOutActivity = millis(); + + while (!_client->available()) { + unsigned long t = millis(); + if (t-lastInActivity >= ((int32_t) MQTT_SOCKET_TIMEOUT*1000UL)) { + _state = MQTT_CONNECTION_TIMEOUT; + _client->stop(); + return false; + } + } + uint8_t llen; + uint16_t len = readPacket(&llen); + + if (len == 4) { + if (buffer[3] == 0) { + lastInActivity = millis(); + pingOutstanding = false; + _state = MQTT_CONNECTED; + return true; + } else { + _state = buffer[3]; + } + } + _client->stop(); + } else { + _state = MQTT_CONNECT_FAILED; + } + return false; + } + return true; +} + +// reads a byte into result +boolean PubSubClient::readByte(uint8_t * result) { + uint32_t previousMillis = millis(); + while(!_client->available()) { + uint32_t currentMillis = millis(); + if(currentMillis - previousMillis >= ((int32_t) MQTT_SOCKET_TIMEOUT * 1000)){ + return false; + } + } + *result = _client->read(); + return true; +} + +// reads a byte into result[*index] and increments index +boolean PubSubClient::readByte(uint8_t * result, uint16_t * index){ + uint16_t current_index = *index; + uint8_t * write_address = &(result[current_index]); + if(readByte(write_address)){ + *index = current_index + 1; + return true; + } + return false; +} + +uint16_t PubSubClient::readPacket(uint8_t* lengthLength) { + uint16_t len = 0; + if(!readByte(buffer, &len)) return 0; + bool isPublish = (buffer[0]&0xF0) == MQTTPUBLISH; + uint32_t multiplier = 1; + uint16_t length = 0; + uint8_t digit = 0; + uint16_t skip = 0; + uint8_t start = 0; + + do { + if(!readByte(&digit)) return 0; + buffer[len++] = digit; + length += (digit & 127) * multiplier; + multiplier *= 128; + } while ((digit & 128) != 0); + *lengthLength = len-1; + + if (isPublish) { + // Read in topic length to calculate bytes to skip over for Stream writing + if(!readByte(buffer, &len)) return 0; + if(!readByte(buffer, &len)) return 0; + skip = (buffer[*lengthLength+1]<<8)+buffer[*lengthLength+2]; + start = 2; + if (buffer[0]&MQTTQOS1) { + // skip message id + skip += 2; + } + } + + for (uint16_t i = start;istream) { + if (isPublish && len-*lengthLength-2>skip) { + this->stream->write(digit); + } + } + if (len < MQTT_MAX_PACKET_SIZE) { + buffer[len] = digit; + } + len++; + } + + if (!this->stream && len > MQTT_MAX_PACKET_SIZE) { + len = 0; // This will cause the packet to be ignored. + } + + return len; +} + +boolean PubSubClient::loop() { + if (connected()) { + unsigned long t = millis(); + if ((t - lastInActivity > MQTT_KEEPALIVE*1000UL) || (t - lastOutActivity > MQTT_KEEPALIVE*1000UL)) { + if (pingOutstanding) { + this->_state = MQTT_CONNECTION_TIMEOUT; + _client->stop(); + return false; + } else { + buffer[0] = MQTTPINGREQ; + buffer[1] = 0; + _client->write(buffer,2); + lastOutActivity = t; + lastInActivity = t; + pingOutstanding = true; + } + } + if (_client->available()) { + uint8_t llen; + uint16_t len = readPacket(&llen); + uint16_t msgId = 0; + uint8_t *payload; + if (len > 0) { + lastInActivity = t; + uint8_t type = buffer[0]&0xF0; + if (type == MQTTPUBLISH) { + if (callback) { + uint16_t tl = (buffer[llen+1]<<8)+buffer[llen+2]; + char topic[tl+1]; + for (uint16_t i=0;i0 + if ((buffer[0]&0x06) == MQTTQOS1) { + msgId = (buffer[llen+3+tl]<<8)+buffer[llen+3+tl+1]; + payload = buffer+llen+3+tl+2; + callback(topic,payload,len-llen-3-tl-2); + + buffer[0] = MQTTPUBACK; + buffer[1] = 2; + buffer[2] = (msgId >> 8); + buffer[3] = (msgId & 0xFF); + _client->write(buffer,4); + lastOutActivity = t; + + } else { + payload = buffer+llen+3+tl; + callback(topic,payload,len-llen-3-tl); + } + } + } else if (type == MQTTPINGREQ) { + buffer[0] = MQTTPINGRESP; + buffer[1] = 0; + _client->write(buffer,2); + } else if (type == MQTTPINGRESP) { + pingOutstanding = false; + } + } + } + return true; + } + return false; +} + +boolean PubSubClient::publish(const char* topic, const char* payload) { + return publish(topic,(const uint8_t*)payload,strlen(payload),false); +} + +boolean PubSubClient::publish(const char* topic, const char* payload, boolean retained) { + return publish(topic,(const uint8_t*)payload,strlen(payload),retained); +} + +boolean PubSubClient::publish(const char* topic, const uint8_t* payload, unsigned int plength) { + return publish(topic, payload, plength, false); +} + +boolean PubSubClient::publish(const char* topic, const uint8_t* payload, unsigned int plength, boolean retained) { + if (connected()) { + if (MQTT_MAX_PACKET_SIZE < 5 + 2+strlen(topic) + plength) { + // Too long + return false; + } + // Leave room in the buffer for header and variable length field + uint16_t length = 5; + length = writeString(topic,buffer,length); + uint16_t i; + for (i=0;i 0) { + digit |= 0x80; + } + buffer[pos++] = digit; + llen++; + } while(len>0); + + pos = writeString(topic,buffer,pos); + + rc += _client->write(buffer,pos); + + for (i=0;iwrite((char)pgm_read_byte_near(payload + i)); + } + + lastOutActivity = millis(); + + return rc == tlen + 4 + plength; +} + +boolean PubSubClient::write(uint8_t header, uint8_t* buf, uint16_t length) { + uint8_t lenBuf[4]; + uint8_t llen = 0; + uint8_t digit; + uint8_t pos = 0; + uint16_t rc; + uint16_t len = length; + do { + digit = len % 128; + len = len / 128; + if (len > 0) { + digit |= 0x80; + } + lenBuf[pos++] = digit; + llen++; + } while(len>0); + + buf[4-llen] = header; + for (int i=0;i 0) && result) { + bytesToWrite = (bytesRemaining > MQTT_MAX_TRANSFER_SIZE)?MQTT_MAX_TRANSFER_SIZE:bytesRemaining; + rc = _client->write(writeBuf,bytesToWrite); + result = (rc == bytesToWrite); + bytesRemaining -= rc; + writeBuf += rc; + } + return result; +#else + rc = _client->write(buf+(4-llen),length+1+llen); + lastOutActivity = millis(); + return (rc == 1+llen+length); +#endif +} + +boolean PubSubClient::subscribe(const char* topic) { + return subscribe(topic, 0); +} + +boolean PubSubClient::subscribe(const char* topic, uint8_t qos) { + if (qos < 0 || qos > 1) { + return false; + } + if (MQTT_MAX_PACKET_SIZE < 9 + strlen(topic)) { + // Too long + return false; + } + if (connected()) { + // Leave room in the buffer for header and variable length field + uint16_t length = 5; + nextMsgId++; + if (nextMsgId == 0) { + nextMsgId = 1; + } + buffer[length++] = (nextMsgId >> 8); + buffer[length++] = (nextMsgId & 0xFF); + length = writeString((char*)topic, buffer,length); + buffer[length++] = qos; + return write(MQTTSUBSCRIBE|MQTTQOS1,buffer,length-5); + } + return false; +} + +boolean PubSubClient::unsubscribe(const char* topic) { + if (MQTT_MAX_PACKET_SIZE < 9 + strlen(topic)) { + // Too long + return false; + } + if (connected()) { + uint16_t length = 5; + nextMsgId++; + if (nextMsgId == 0) { + nextMsgId = 1; + } + buffer[length++] = (nextMsgId >> 8); + buffer[length++] = (nextMsgId & 0xFF); + length = writeString(topic, buffer,length); + return write(MQTTUNSUBSCRIBE|MQTTQOS1,buffer,length-5); + } + return false; +} + +void PubSubClient::disconnect() { + buffer[0] = MQTTDISCONNECT; + buffer[1] = 0; + _client->write(buffer,2); + _state = MQTT_DISCONNECTED; + _client->stop(); + lastInActivity = lastOutActivity = millis(); +} + +uint16_t PubSubClient::writeString(const char* string, uint8_t* buf, uint16_t pos) { + const char* idp = string; + uint16_t i = 0; + pos += 2; + while (*idp) { + buf[pos++] = *idp++; + i++; + } + buf[pos-i-2] = (i >> 8); + buf[pos-i-1] = (i & 0xFF); + return pos; +} + + +boolean PubSubClient::connected() { + boolean rc; + if (_client == NULL ) { + rc = false; + } else { + rc = (int)_client->connected(); + if (!rc) { + if (this->_state == MQTT_CONNECTED) { + this->_state = MQTT_CONNECTION_LOST; + _client->flush(); + _client->stop(); + } + } + } + return rc; +} + +PubSubClient& PubSubClient::setServer(uint8_t * ip, uint16_t port) { + IPAddress addr(ip[0],ip[1],ip[2],ip[3]); + return setServer(addr,port); +} + +PubSubClient& PubSubClient::setServer(IPAddress ip, uint16_t port) { + this->ip = ip; + this->port = port; + this->domain = NULL; + return *this; +} + +PubSubClient& PubSubClient::setServer(const char * domain, uint16_t port) { + this->domain = domain; + this->port = port; + return *this; +} + +PubSubClient& PubSubClient::setCallback(MQTT_CALLBACK_SIGNATURE) { + this->callback = callback; + return *this; +} + +PubSubClient& PubSubClient::setClient(Client& client){ + this->_client = &client; + return *this; +} + +PubSubClient& PubSubClient::setStream(Stream& stream){ + this->stream = &stream; + return *this; +} + +int PubSubClient::state() { + return this->_state; +} diff --git a/projectIO/BaFa_lutai_switch/PubSubClient.h b/projectIO/BaFa_lutai_switch/PubSubClient.h new file mode 100644 index 0000000..be4bd67 --- /dev/null +++ b/projectIO/BaFa_lutai_switch/PubSubClient.h @@ -0,0 +1,144 @@ +/* + PubSubClient.h - A simple client for MQTT. + Nick O'Leary + http://knolleary.net +*/ + +#ifndef PubSubClient_h +#define PubSubClient_h + +#include +#include "IPAddress.h" +#include "Client.h" +#include "Stream.h" + +#define MQTT_VERSION_3_1 3 +#define MQTT_VERSION_3_1_1 4 + +// MQTT_VERSION : Pick the version +//#define MQTT_VERSION MQTT_VERSION_3_1 +#ifndef MQTT_VERSION +#define MQTT_VERSION MQTT_VERSION_3_1_1 +#endif + +// MQTT_MAX_PACKET_SIZE : Maximum packet size +#ifndef MQTT_MAX_PACKET_SIZE +#define MQTT_MAX_PACKET_SIZE 128 +#endif + +// MQTT_KEEPALIVE : keepAlive interval in Seconds +#ifndef MQTT_KEEPALIVE +#define MQTT_KEEPALIVE 15 +#endif + +// MQTT_SOCKET_TIMEOUT: socket timeout interval in Seconds +#ifndef MQTT_SOCKET_TIMEOUT +#define MQTT_SOCKET_TIMEOUT 15 +#endif + +// MQTT_MAX_TRANSFER_SIZE : limit how much data is passed to the network client +// in each write call. Needed for the Arduino Wifi Shield. Leave undefined to +// pass the entire MQTT packet in each write call. +//#define MQTT_MAX_TRANSFER_SIZE 80 + +// Possible values for client.state() +#define MQTT_CONNECTION_TIMEOUT -4 +#define MQTT_CONNECTION_LOST -3 +#define MQTT_CONNECT_FAILED -2 +#define MQTT_DISCONNECTED -1 +#define MQTT_CONNECTED 0 +#define MQTT_CONNECT_BAD_PROTOCOL 1 +#define MQTT_CONNECT_BAD_CLIENT_ID 2 +#define MQTT_CONNECT_UNAVAILABLE 3 +#define MQTT_CONNECT_BAD_CREDENTIALS 4 +#define MQTT_CONNECT_UNAUTHORIZED 5 + +#define MQTTCONNECT 1 << 4 // Client request to connect to Server +#define MQTTCONNACK 2 << 4 // Connect Acknowledgment +#define MQTTPUBLISH 3 << 4 // Publish message +#define MQTTPUBACK 4 << 4 // Publish Acknowledgment +#define MQTTPUBREC 5 << 4 // Publish Received (assured delivery part 1) +#define MQTTPUBREL 6 << 4 // Publish Release (assured delivery part 2) +#define MQTTPUBCOMP 7 << 4 // Publish Complete (assured delivery part 3) +#define MQTTSUBSCRIBE 8 << 4 // Client Subscribe request +#define MQTTSUBACK 9 << 4 // Subscribe Acknowledgment +#define MQTTUNSUBSCRIBE 10 << 4 // Client Unsubscribe request +#define MQTTUNSUBACK 11 << 4 // Unsubscribe Acknowledgment +#define MQTTPINGREQ 12 << 4 // PING Request +#define MQTTPINGRESP 13 << 4 // PING Response +#define MQTTDISCONNECT 14 << 4 // Client is Disconnecting +#define MQTTReserved 15 << 4 // Reserved + +#define MQTTQOS0 (0 << 1) +#define MQTTQOS1 (1 << 1) +#define MQTTQOS2 (2 << 1) + +#ifdef ESP8266 +#include +#define MQTT_CALLBACK_SIGNATURE std::function callback +#else +#define MQTT_CALLBACK_SIGNATURE void (*callback)(char*, uint8_t*, unsigned int) +#endif + +class PubSubClient { +private: + Client* _client; + uint8_t buffer[MQTT_MAX_PACKET_SIZE]; + uint16_t nextMsgId; + unsigned long lastOutActivity; + unsigned long lastInActivity; + bool pingOutstanding; + MQTT_CALLBACK_SIGNATURE; + uint16_t readPacket(uint8_t*); + boolean readByte(uint8_t * result); + boolean readByte(uint8_t * result, uint16_t * index); + boolean write(uint8_t header, uint8_t* buf, uint16_t length); + uint16_t writeString(const char* string, uint8_t* buf, uint16_t pos); + IPAddress ip; + const char* domain; + uint16_t port; + Stream* stream; + int _state; +public: + PubSubClient(); + PubSubClient(Client& client); + PubSubClient(IPAddress, uint16_t, Client& client); + PubSubClient(IPAddress, uint16_t, Client& client, Stream&); + PubSubClient(IPAddress, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client); + PubSubClient(IPAddress, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&); + PubSubClient(uint8_t *, uint16_t, Client& client); + PubSubClient(uint8_t *, uint16_t, Client& client, Stream&); + PubSubClient(uint8_t *, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client); + PubSubClient(uint8_t *, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&); + PubSubClient(const char*, uint16_t, Client& client); + PubSubClient(const char*, uint16_t, Client& client, Stream&); + PubSubClient(const char*, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client); + PubSubClient(const char*, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&); + + PubSubClient& setServer(IPAddress ip, uint16_t port); + PubSubClient& setServer(uint8_t * ip, uint16_t port); + PubSubClient& setServer(const char * domain, uint16_t port); + PubSubClient& setCallback(MQTT_CALLBACK_SIGNATURE); + PubSubClient& setClient(Client& client); + PubSubClient& setStream(Stream& stream); + + boolean connect(const char* id); + boolean connect(const char* id, const char* user, const char* pass); + boolean connect(const char* id, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage); + boolean connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage); + void disconnect(); + boolean publish(const char* topic, const char* payload); + boolean publish(const char* topic, const char* payload, boolean retained); + boolean publish(const char* topic, const uint8_t * payload, unsigned int plength); + boolean publish(const char* topic, const uint8_t * payload, unsigned int plength, boolean retained); + boolean publish_P(const char* topic, const uint8_t * payload, unsigned int plength, boolean retained); + boolean subscribe(const char* topic); + boolean subscribe(const char* topic, uint8_t qos); + boolean unsubscribe(const char* topic); + boolean loop(); + boolean connected(); + int state(); +}; + + +#endif diff --git a/projectIO/SmartConfigWIFI/.gitignore b/projectIO/SmartConfigWIFI/.gitignore new file mode 100644 index 0000000..89cc49c --- /dev/null +++ b/projectIO/SmartConfigWIFI/.gitignore @@ -0,0 +1,5 @@ +.pio +.vscode/.browse.c_cpp.db* +.vscode/c_cpp_properties.json +.vscode/launch.json +.vscode/ipch diff --git a/projectIO/SmartConfigWIFI/.vscode/extensions.json b/projectIO/SmartConfigWIFI/.vscode/extensions.json new file mode 100644 index 0000000..080e70d --- /dev/null +++ b/projectIO/SmartConfigWIFI/.vscode/extensions.json @@ -0,0 +1,10 @@ +{ + // See http://go.microsoft.com/fwlink/?LinkId=827846 + // for the documentation about the extensions.json format + "recommendations": [ + "platformio.platformio-ide" + ], + "unwantedRecommendations": [ + "ms-vscode.cpptools-extension-pack" + ] +} diff --git a/projectIO/SmartConfigWIFI/include/README b/projectIO/SmartConfigWIFI/include/README new file mode 100644 index 0000000..194dcd4 --- /dev/null +++ b/projectIO/SmartConfigWIFI/include/README @@ -0,0 +1,39 @@ + +This directory is intended for project header files. + +A header file is a file containing C declarations and macro definitions +to be shared between several project source files. You request the use of a +header file in your project source file (C, C++, etc) located in `src` folder +by including it, with the C preprocessing directive `#include'. + +```src/main.c + +#include "header.h" + +int main (void) +{ + ... +} +``` + +Including a header file produces the same results as copying the header file +into each source file that needs it. Such copying would be time-consuming +and error-prone. With a header file, the related declarations appear +in only one place. If they need to be changed, they can be changed in one +place, and programs that include the header file will automatically use the +new version when next recompiled. The header file eliminates the labor of +finding and changing all the copies as well as the risk that a failure to +find one copy will result in inconsistencies within a program. + +In C, the usual convention is to give header files names that end with `.h'. +It is most portable to use only letters, digits, dashes, and underscores in +header file names, and at most one dot. + +Read more about using header files in official GCC documentation: + +* Include Syntax +* Include Operation +* Once-Only Headers +* Computed Includes + +https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html diff --git a/projectIO/SmartConfigWIFI/lib/README b/projectIO/SmartConfigWIFI/lib/README new file mode 100644 index 0000000..6debab1 --- /dev/null +++ b/projectIO/SmartConfigWIFI/lib/README @@ -0,0 +1,46 @@ + +This directory is intended for project specific (private) libraries. +PlatformIO will compile them to static libraries and link into executable file. + +The source code of each library should be placed in a an own separate directory +("lib/your_library_name/[here are source files]"). + +For example, see a structure of the following two libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html +| | +| |--Foo +| | |- Foo.c +| | |- Foo.h +| | +| |- README --> THIS FILE +| +|- platformio.ini +|--src + |- main.c + +and a contents of `src/main.c`: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +PlatformIO Library Dependency Finder will find automatically dependent +libraries scanning project source files. + +More information about PlatformIO Library Dependency Finder +- https://docs.platformio.org/page/librarymanager/ldf.html diff --git a/projectIO/SmartConfigWIFI/platformio.ini b/projectIO/SmartConfigWIFI/platformio.ini new file mode 100644 index 0000000..45669d9 --- /dev/null +++ b/projectIO/SmartConfigWIFI/platformio.ini @@ -0,0 +1,15 @@ +; PlatformIO Project Configuration File +; +; Build options: build flags, source filter +; Upload options: custom upload port, speed and extra flags +; Library options: dependencies, extra library storages +; Advanced options: extra scripting +; +; Please visit documentation for the other options and examples +; https://docs.platformio.org/page/projectconf.html + +[env:nodemcuv2] +platform = espressif8266 +board = nodemcuv2 +framework = arduino +monitor_speed = 115200 \ No newline at end of file diff --git a/projectIO/SmartConfigWIFI/src/main.cpp b/projectIO/SmartConfigWIFI/src/main.cpp new file mode 100644 index 0000000..2167662 --- /dev/null +++ b/projectIO/SmartConfigWIFI/src/main.cpp @@ -0,0 +1,46 @@ +/* + * @Author: dugulingping + * @Date: 2022-06-09 17:14:49 + * @LastEditTime: 2022-06-15 22:03:52 + * @LastEditors: dugulingping + * @Description: + * @FilePath: \test\SmartComfigWIFI\SmartComfigWIFI.ino + */ +#include +void smartConfig() +{ + WiFi.mode(WIFI_STA); //设置WIFI模块为STA模式 + Serial.begin(115200); + Serial.println("\r\nWaiting for connection"); + //smartconfig进行初始化 + WiFi.beginSmartConfig(); + while (1) //等待连接成功 + { + Serial.print(">"); + digitalWrite(LED_BUILTIN, 0); + delay(100); + digitalWrite(LED_BUILTIN, 1); + delay(100); + //如果连接成功后就打印出连接的WIFI信息 + if (WiFi.smartConfigDone()) + { + Serial.println("SmartConfig Success"); + Serial.printf("SSID:%s", WiFi.SSID().c_str()); + Serial.printf("PW:%s", WiFi.psk().c_str());//打印出密码 + break; + } + } +} + + +void setup() { + pinMode(LED_BUILTIN, OUTPUT); + smartConfig(); +} + +void loop() { + digitalWrite(LED_BUILTIN, LOW); // Turn the LED on (Note that LOW is the voltage level + delay(1000); // Wait for a second + digitalWrite(LED_BUILTIN, HIGH); // Turn the LED off by making the voltage HIGH + delay(1000); // Wait for two seconds (to demonstrate the active low LED) +} \ No newline at end of file diff --git a/projectIO/SmartConfigWIFI/test/README b/projectIO/SmartConfigWIFI/test/README new file mode 100644 index 0000000..9b1e87b --- /dev/null +++ b/projectIO/SmartConfigWIFI/test/README @@ -0,0 +1,11 @@ + +This directory is intended for PlatformIO Test Runner and project tests. + +Unit Testing is a software testing method by which individual units of +source code, sets of one or more MCU program modules together with associated +control data, usage procedures, and operating procedures, are tested to +determine whether they are fit for use. Unit testing finds problems early +in the development cycle. + +More information about PlatformIO Unit Testing: +- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html diff --git a/projectIO/asd/asd.ino b/projectIO/asd/asd.ino new file mode 100644 index 0000000..d27fd17 --- /dev/null +++ b/projectIO/asd/asd.ino @@ -0,0 +1,116 @@ +/* + * @Author: dugulingping + * @Date: 2022-04-17 16:00:40 + * @LastEditTime: 2022-06-16 02:38:58 + * @LastEditors: dugulingping + * @Description: + * @FilePath: \project\asd\asd.ino + */ +#include "DHT.h" +// DHT11 +#define DHTPIN 4 +#define DHTTYPE DHT22 // DHT 11 +//LED +#define SCLK 14 +#define RCLK 13 +#define DIO 15 + +DHT dht(DHTPIN, DHTTYPE); +//定义字库 +unsigned char LED_0F[] = { + // 0 1 2 3 4 5 6 7 8 9 A b C d E F - + 0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x8C,0xBF,0xC6,0xA1,0x86,0xFF,0xbf +}; +//定义位 +unsigned char LED_BIT[] = { + // 1 2 3 4 1+2 3+4 1~4 + 0x01,0x02,0x04,0x08,0x03,0x0C,0x0F +}; + +//定义dht数据 +int dhtdata[3] = {0}; + +void setup() { + Serial.begin(115200); + dht.begin(); + //让三个脚都是输出状态 + pinMode(SCLK,OUTPUT); + pinMode(RCLK,OUTPUT); + pinMode(DIO,OUTPUT); + + +} +//定时 +int delay_date = 0; +void loop() { + if(delay_date < 2000){ + delay_date+=4; + }else{ + delay_date = 0; + DHT_Data(); + } + if(!dhtdata[1]||!dhtdata[2]){ + LED_display(LED_BIT[6], 0xBF); + return; + } + int num1 = dhtdata[0]%10; + int num2 = dhtdata[0]/10; + int num3 = dhtdata[2]%10; + int num4 = dhtdata[2]/10; + + LED_display(LED_BIT[2], LED_0F[num1]-128); + LED_display(LED_BIT[3], LED_0F[num2]); + LED_display(LED_BIT[0], LED_0F[num3]-128); + LED_display(LED_BIT[1], LED_0F[num4]); + + //LED_display(LED_BIT[2], LED_0F[data_split(dhtdata[0])[0]]-128); + //LED_display(LED_BIT[1], LED_0F[data_split(dhtdata[2])[1]]); + //LED_display(LED_BIT[0], LED_0F[data_split(dhtdata[2])[0]]); + +} + +void LED_display(unsigned char bit, unsigned char digit ){ + LED_OUT(digit); + LED_OUT(bit); + digitalWrite(RCLK,LOW); + digitalWrite(RCLK,HIGH); + delay(1); +} +void LED_OUT(unsigned char X){ + unsigned char i; + for(i=8;i>=1;i--) + { + if(X&0x80) + digitalWrite(DIO,HIGH); + else + digitalWrite(DIO,LOW); + X<<=1; + digitalWrite(SCLK,LOW); + digitalWrite(SCLK,HIGH); + } +} + +int * data_split(int num){ + int res[2] = {0}; + for(int i = 0; num > 0; i++){ + res[i] = num%10; + } + return res; +} +void DHT_Data(){ + float h = dht.readHumidity(); + float t = dht.readTemperature(false); + float hic = dht.computeHeatIndex(t, h, false); + + if (isnan(h) || isnan(t)){ + Serial.println(F("Failed to read from DHT sensor!")); + dhtdata[0] = 0; + dhtdata[1] = 0; + dhtdata[2] = 0; + return; + } + dhtdata[0] = h; + dhtdata[1] = t; + dhtdata[2] = hic; + Serial.println(h); +} \ No newline at end of file diff --git a/projectIO/test/test.ino b/projectIO/test/test.ino new file mode 100644 index 0000000..5b43830 --- /dev/null +++ b/projectIO/test/test.ino @@ -0,0 +1,21 @@ + +/* + * @Author: dugulingping + * @Date: 2022-04-13 03:06:22 + * @LastEditTime: 2022-06-16 17:48:41 + * @LastEditors: dugulingping + * @Description: testLED + * @FilePath: \project\test\test.ino + */ +int LED = 0; +void setup(){ + pinMode(LED,OUTPUT); + digitalWrite(LED,0); + +} +void loop(){ + digitalWrite(LED,1); + delay(1000); + digitalWrite(LED,0); + delay(1000); +} \ No newline at end of file