302 lines
9.0 KiB
C++
302 lines
9.0 KiB
C++
#include <Arduino.h>
|
|
#include <ArduinoOTA.h>
|
|
#include <Ticker.h>
|
|
#include <AsyncMqttClient.h>
|
|
#include <SoftwareSerial.h>
|
|
|
|
//#define LED_WF (14)
|
|
//#define LED_MQ (12)
|
|
//#define LED_WRK (13)
|
|
|
|
#define TUYA_OPEN "55aa000600056604000100"
|
|
#define TUYA_CLOSE "55aa000600056604000101"
|
|
#define TUYA_STOP "55aa000600056604000102"
|
|
// set position percentage
|
|
#define TUYA_SET_POSITION "55aa0006000865020004000000" // and 1 byte (0x00-0x64)
|
|
|
|
// enable/disable reversed motor direction
|
|
#define TUYA_DISABLE_REVERSING "55aa000600056700000100"
|
|
#define TUYA_ENABLE_REVERSING "55aa000600056700000101"
|
|
#define CURT_CLOSING (1)
|
|
#define CURT_OPENING (2)
|
|
#define CURT_IDLE (0)
|
|
|
|
const char* ssid = "wf-home";
|
|
const char* password = "0ndthnrf";
|
|
const char* mqtt_server = "192.168.1.250";
|
|
unsigned long cRun = millis();
|
|
double curr;
|
|
int nSec, nSampl;
|
|
uint8_t buffer[1024];
|
|
bool reversed, curtOpened, curtClosed;
|
|
float position;
|
|
uint8_t offset;
|
|
uint8_t cur_operation;
|
|
uint8_t crc;
|
|
|
|
AsyncMqttClient mqttClient;
|
|
Ticker mqttReconnectTimer;
|
|
|
|
WiFiEventHandler wifiConnectHandler;
|
|
WiFiEventHandler wifiDisconnectHandler;
|
|
Ticker wifiReconnectTimer;
|
|
|
|
SoftwareSerial softSer(D7, D8);
|
|
|
|
void connectToWifi();
|
|
void connectToMqtt();
|
|
void onWifiConnect(const WiFiEventStationModeGotIP& event);
|
|
void onWifiDisconnect(const WiFiEventStationModeDisconnected& event);
|
|
void onMqttConnect(bool sessionPresent);
|
|
void onMqttDisconnect(AsyncMqttClientDisconnectReason reason);
|
|
void onMqttSubscribe(uint16_t packetId, uint8_t qos);
|
|
void onMqttMessage(char* topic, char* payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total);
|
|
void readByte(uint8_t data);
|
|
void writeByte(uint8_t data);
|
|
void writeHex(std::string data);
|
|
|
|
void setup(){
|
|
Serial.begin(9600);
|
|
pinMode(D7, INPUT);
|
|
pinMode(D8, OUTPUT);
|
|
softSer.begin(9600);//, SWSERIAL_8N1, D5, D6, false);
|
|
WiFi.mode(WIFI_STA);
|
|
WiFi.hostname("Cur-MidRoom");
|
|
|
|
ArduinoOTA.onStart([]() {
|
|
Serial1.println("Start Update"); // "Начало OTA-апдейта"
|
|
});
|
|
ArduinoOTA.onEnd([]() {
|
|
Serial1.println("\nEnd Update"); // "Завершение OTA-апдейта"
|
|
});
|
|
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
|
|
//Serial1.printf("Progress: %u%%\r", (progress / (total / 100)));
|
|
});
|
|
ArduinoOTA.onError([](ota_error_t error) {
|
|
Serial1.printf("Error[%u]: ", error);
|
|
if (error == OTA_AUTH_ERROR) Serial1.println("Auth Failed");
|
|
// "Ошибка при аутентификации"
|
|
else if (error == OTA_BEGIN_ERROR) Serial1.println("Begin Failed");
|
|
// "Ошибка при начале OTA-апдейта"
|
|
else if (error == OTA_CONNECT_ERROR) Serial1.println("Connect Failed");
|
|
// "Ошибка при подключении"
|
|
else if (error == OTA_RECEIVE_ERROR) Serial1.println("Receive Failed");
|
|
// "Ошибка при получении данных"
|
|
else if (error == OTA_END_ERROR) Serial1.println("End Failed");
|
|
// "Ошибка при завершении OTA-апдейта"
|
|
});
|
|
ArduinoOTA.begin();
|
|
wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
|
|
wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);
|
|
|
|
mqttClient.onConnect(onMqttConnect);
|
|
mqttClient.onDisconnect(onMqttDisconnect);
|
|
mqttClient.onSubscribe(onMqttSubscribe);
|
|
mqttClient.onMessage(onMqttMessage);
|
|
mqttClient.setServer(mqtt_server, 1883);
|
|
mqttClient.setClientId("Cur_MidRoom");
|
|
|
|
//pinMode(LED_WF, OUTPUT);
|
|
//pinMode(LED_MQ, OUTPUT);
|
|
//pinMode(LED_WRK, OUTPUT);
|
|
//pinMode(5, INPUT_PULLUP);
|
|
//digitalWrite(LED_WF, LOW);
|
|
//digitalWrite(LED_MQ, LOW);
|
|
//digitalWrite(LED_WRK, LOW);
|
|
connectToWifi();
|
|
nSec = 0;
|
|
curr = -1;
|
|
nSampl = 0;
|
|
Serial.println("Start");
|
|
}
|
|
|
|
void loop(){
|
|
static bool led_wrk = false;
|
|
uint8_t in_b;
|
|
|
|
ArduinoOTA.handle();
|
|
crc = 0;
|
|
offset = 0;
|
|
while(softSer.available()){
|
|
in_b = softSer.read();
|
|
Serial.print(in_b, 16);
|
|
//readByte(in_b);
|
|
}
|
|
if(cRun + 999 < millis()){
|
|
cRun = millis();
|
|
if(WiFi.isConnected()){
|
|
led_wrk = !led_wrk;
|
|
//digitalWrite(LED_WRK, led_wrk);
|
|
nSampl++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void connectToWifi() {
|
|
Serial.println("Connecting to Wi-Fi...");
|
|
WiFi.begin(ssid, password);
|
|
}
|
|
|
|
void connectToMqtt() {
|
|
Serial.println("Connecting to MQTT...");
|
|
//mqttClient.connect();
|
|
}
|
|
|
|
void onWifiConnect(const WiFiEventStationModeGotIP& event) {
|
|
Serial.println("Connected to Wi-Fi.");
|
|
Serial.print("IP: ");
|
|
Serial.println(WiFi.localIP());
|
|
connectToMqtt();
|
|
//digitalWrite(LED_WF, HIGH);
|
|
}
|
|
|
|
void onWifiDisconnect(const WiFiEventStationModeDisconnected& event) {
|
|
Serial.println("Disconnected from Wi-Fi.");
|
|
mqttReconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
|
|
wifiReconnectTimer.once(2, connectToWifi);
|
|
//digitalWrite(LED_WF, LOW);
|
|
}
|
|
|
|
void onMqttConnect(bool sessionPresent) {
|
|
Serial.println("Connected to MQTT.");
|
|
Serial.print("Session present: ");
|
|
Serial.println(sessionPresent);
|
|
mqttClient.subscribe("/home/midroom/curtpos_set", 0);
|
|
//digitalWrite(LED_MQ, HIGH);
|
|
}
|
|
|
|
void onMqttDisconnect(AsyncMqttClientDisconnectReason reason) {
|
|
//Serial.println("Disconnected from MQTT.");
|
|
|
|
if (WiFi.isConnected()) {
|
|
mqttReconnectTimer.once(2, connectToMqtt);
|
|
}
|
|
//digitalWrite(LED_MQ, LOW);
|
|
}
|
|
|
|
void onMqttSubscribe(uint16_t packetId, uint8_t qos) {
|
|
Serial.println("Subscribe acknowledged.");
|
|
Serial.print(" packetId: ");
|
|
Serial.println(packetId);
|
|
Serial.print(" qos: ");
|
|
Serial.println(qos);
|
|
}
|
|
|
|
void onMqttMessage(char* topic, char* payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total) {
|
|
if(strcmp("/home/midroom/curtcmd", topic) == 0){
|
|
crc = 0;
|
|
switch(atoi(payload)){
|
|
case 1:
|
|
writeHex(TUYA_CLOSE);
|
|
writeByte(crc);
|
|
break;
|
|
case 2:
|
|
writeHex(TUYA_OPEN);
|
|
writeByte(crc);
|
|
break;
|
|
case 3:
|
|
writeHex(TUYA_STOP);
|
|
writeByte(crc);
|
|
break;
|
|
}
|
|
mqttClient.publish("/home/midroom/curtcmd", 0, false, "0");
|
|
}
|
|
else if(strcmp("/home/midroom/curtpos_set", topic) == 0){
|
|
int pos = atoi(payload);
|
|
crc = 0;
|
|
if(pos == 100){
|
|
writeHex(TUYA_CLOSE);
|
|
writeByte(crc);
|
|
}
|
|
else if(pos == 0){
|
|
writeHex(TUYA_OPEN);
|
|
writeByte(crc);
|
|
}
|
|
else if (pos > 0 && pos < 100){
|
|
writeHex(TUYA_SET_POSITION);
|
|
writeByte(100 - pos);
|
|
writeByte(crc);
|
|
}
|
|
}
|
|
}
|
|
|
|
void readByte(uint8_t data) {
|
|
if ((offset == 0 && data == 0x55) || (offset == 1 && data == 0xAA) || offset) {
|
|
buffer[offset++] = data;
|
|
if (offset > 6) {
|
|
int len = buffer[4] << 8 | buffer[5];
|
|
if (7 + len == offset) {
|
|
uint8_t crc = buffer[offset - 1];
|
|
uint8_t sum = 0;
|
|
for (int i = 0; i < offset - 1; i++) sum += buffer[i];
|
|
if (sum == crc) {
|
|
uint8_t cmd_type = buffer[3];
|
|
uint8_t data_id = buffer[6];
|
|
//uint8_t data_size = buffer[9]; // only 1byte or 4bytes values
|
|
switch (cmd_type) {
|
|
case 0x07: {
|
|
switch (data_id) {
|
|
// Motor reversing state
|
|
case 0x67: {
|
|
reversed = !!buffer[10];
|
|
break;
|
|
}
|
|
// Operation mode state
|
|
case 0x66: {
|
|
switch (buffer[10]) {
|
|
case 0x00:
|
|
cur_operation = CURT_CLOSING;
|
|
break;
|
|
case 0x02:
|
|
cur_operation = CURT_IDLE;
|
|
break;
|
|
case 0x01:
|
|
cur_operation = CURT_OPENING;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
// Position report during operation
|
|
// Max value is 0x64 so the last byte is good enough
|
|
case 0x68: {
|
|
position = buffer[13] / 100.0f;
|
|
curtOpened = !!position;
|
|
break;
|
|
}
|
|
// Position report after operation
|
|
case 0x65: {
|
|
position = 1 - (buffer[13] / 100.0f);
|
|
if (position > 0.95) position = 1;
|
|
if (position < 0.05) position = 0;
|
|
curtOpened = !!position;
|
|
cur_operation = CURT_IDLE;
|
|
break;
|
|
}
|
|
}
|
|
Serial.println();
|
|
Serial.println(cur_operation);
|
|
//publish_state();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
offset = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void writeByte(uint8_t data) {
|
|
softSer.write(data);
|
|
crc += data;
|
|
}
|
|
|
|
void writeHex(std::string data) {
|
|
uint16_t i = 0;
|
|
while (i < data.length()) {
|
|
const char hex[2] = {data[i++], data[i++]};
|
|
uint8_t d = strtoul(hex, NULL, 16);
|
|
writeByte(d);
|
|
}
|
|
}
|