MajorDoMo

Код: Выделить всё

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#define MQTT_VERSION MQTT_VERSION_3_1_1

// Wifi: SSID and password
const char*             WIFI_SSID         = "*****************";
const char*             WIFI_PASSWORD     = "***************";

// MQTT: ID, server IP, port, username and password
const PROGMEM char*     MQTT_CLIENT_ID    = "LED line";
const PROGMEM char*     MQTT_SERVER_IP    = "192.168.1.244";
const PROGMEM uint16_t  MQTT_SERVER_PORT  = 1883;
const PROGMEM char*     MQTT_USER         = "**********";
const PROGMEM char*     MQTT_PASSWORD     = "************";

// MQTT: topics
// state
const PROGMEM char*     MQTT_LINE_STATE_TOPIC               = "LED/line";
const PROGMEM char*     MQTT_LINE_COMMAND_TOPIC          = "LED/line/switch";
const PROGMEM char*     MQTT_LINE2_STATE_TOPIC              = "LED/line2";
const PROGMEM char*     MQTT_LINE2_COMMAND_TOPIC         = "LED/line2/switch";

// brightness
const PROGMEM char*     MQTT_LINE_BRIGHTNESS_STATE_TOPIC       = "LED/line/brightness";
const PROGMEM char*     MQTT_LINE_BRIGHTNESS_COMMAND_TOPIC = "LED/line/brightness/set";
const PROGMEM char*     MQTT_LINE2_BRIGHTNESS_STATE_TOPIC      = "LED/line2/brightness";
const PROGMEM char*     MQTT_LINE2_BRIGHTNESS_COMMAND_TOPIC = "LED/line2/brightness/set";

// payloads by default (on/off)
const PROGMEM char*     LINE_ON         = "1";
const PROGMEM char*     LINE_OFF        = "0";
const PROGMEM char*     LINE2_ON        = "1";
const PROGMEM char*     LINE2_OFF       = "0";

// variables used to store the state and the brightness of the line

boolean   m_line_state       = false;
uint8_t   m_line_brightness  = 255;
boolean   m_line2_state       = false;
uint8_t   m_line2_brightness  = 255;

// pin used for the led (PWM)
const PROGMEM uint8_t LINE_PIN = 4;
const PROGMEM uint8_t LINE2_PIN = 14;

// buffer used to send/receive data with MQTT
const uint8_t MSG_BUFFER_SIZE = 20;
char m_msg_buffer[MSG_BUFFER_SIZE]; 

WiFiClient wifiClient;
PubSubClient client(wifiClient);

// function called to adapt the brightness and the state of the led
void setLineState() {
  if (m_line_state){

    analogWrite(LINE_PIN, m_line_brightness);
    Serial.print("INFO: Brightness: ");
    Serial.println(m_line_brightness);
  } else {
    analogWrite(LINE_PIN, 0); 
    Serial.println("INFO: Turn line off");
  }
}

// function called to publish the state of the led (on/off)
void publishLineState(){

  if (m_line_state){

    client.publish(MQTT_LINE_STATE_TOPIC, LINE_ON, true);
  } else {
    client.publish(MQTT_LINE_STATE_TOPIC, LINE_OFF, true);
  }
}

// function called to publish the brightness of the led
void publishLineBrightness(){

  snprintf(m_msg_buffer, MSG_BUFFER_SIZE, "%d", m_line_brightness);
  client.publish(MQTT_LINE_BRIGHTNESS_STATE_TOPIC, m_msg_buffer, true);
}

// function called to adapt the brightness and the state of the led
void setLine2State(){

  if (m_line2_state){
    analogWrite(LINE2_PIN, m_line2_brightness);
    Serial.print("INFO: Brightness: ");
    Serial.println(m_line2_brightness);
  } else {
    analogWrite(LINE2_PIN, 0);
    Serial.println("INFO: Turn line2 off");
  }
}

// function called to publish the state of the led (on/off)
void publishLine2State(){

  if (m_line2_state) {
    client.publish(MQTT_LINE2_STATE_TOPIC, LINE2_ON, true);
  } else {
    client.publish(MQTT_LINE2_STATE_TOPIC, LINE2_OFF, true);
  }
}

// function called to publish the brightness of the led
void publishLine2Brightness(){
  snprintf(m_msg_buffer, MSG_BUFFER_SIZE, "%d", m_line2_brightness);
  client.publish(MQTT_LINE2_BRIGHTNESS_STATE_TOPIC, m_msg_buffer, true);
}

// function called when a MQTT message arrived
void callback(char* p_topic, byte* p_payload, unsigned int p_length){
  // concat the payload into a string
  String payload;
  for (uint8_t i = 0; i < p_length; i++){
    payload.concat((char)p_payload[i]);
  }

  // handle message topic

  if (String(MQTT_LINE_COMMAND_TOPIC).equals(p_topic)){

    // test if the payload is equal to "ON" or "OFF"
    if (payload.equals(String(LINE_ON))){
      if (m_line_state != true){
        m_line_state = true;
        setLineState();
        publishLineState();
      }
    } else if (payload.equals(String(LINE_OFF))){
      if (m_line_state != false){

        m_line_state = false;
        setLineState();
        publishLineState();
      }
    }
  } else if (String(MQTT_LINE_BRIGHTNESS_COMMAND_TOPIC).equals(p_topic)){

    uint8_t brightness = payload.toInt();
    if (brightness < 0 || brightness > 255){
      // do nothing...
      return;
    }else{
      m_line_brightness = brightness;
      setLineState();
      publishLineBrightness();
    }
  }
  if (String(MQTT_LINE2_COMMAND_TOPIC).equals(p_topic)){

    // test if the payload is equal to "ON" or "OFF"
    if (payload.equals(String(LINE2_ON))){

      if (m_line2_state != true){

        m_line2_state = true;
        setLine2State();
        publishLine2State();
      }
    } else if (payload.equals(String(LINE2_OFF))){

      if (m_line2_state != false){

        m_line2_state = false;
        setLine2State();
        publishLine2State();
      }
    }
  } else if (String(MQTT_LINE2_BRIGHTNESS_COMMAND_TOPIC).equals(p_topic)){

     uint8_t brightness = payload.toInt();
    if (brightness < 0 || brightness > 255) 
{    

// do nothing...
      return;
    }else{
      m_line2_brightness = brightness;
      setLine2State();
      publishLine2Brightness();
    }
  }
}

void reconnect(){

  // Loop until we're reconnected
  while (!client.connected()){

    Serial.print("INFO: Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASSWORD)){

      Serial.println("\nINFO: connected");

      // Once connected, publish an announcement...
      // publish the initial values
      publishLineState();
      publishLineBrightness();
      publishLine2State();
      publishLine2Brightness();

// ... and resubscribe
      client.subscribe(MQTT_LINE_COMMAND_TOPIC);
      client.subscribe(MQTT_LINE_BRIGHTNESS_COMMAND_TOPIC);
      client.subscribe(MQTT_LINE2_COMMAND_TOPIC);
      client.subscribe(MQTT_LINE2_BRIGHTNESS_COMMAND_TOPIC);

} else {
      Serial.print("ERROR: failed, rc=");
      Serial.print(client.state());
      Serial.println("DEBUG: try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void setup(){

  // init the serial
  Serial.begin(115200);

  // init the led
  pinMode(LINE_PIN, OUTPUT);
  analogWriteRange(255);
  setLineState();
  
 pinMode(LINE2_PIN, OUTPUT);
  analogWriteRange(255);
  setLine2State();

// init the WiFi connection
  Serial.println();
  Serial.println();
  Serial.print("INFO: Connecting to ");
  WiFi.mode(WIFI_STA);
  Serial.println(WIFI_SSID);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  while (WiFi.status() != WL_CONNECTED){
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("INFO: WiFi connected");
  Serial.print("INFO: IP address: ");
  Serial.println(WiFi.localIP());

// init the MQTT connection
  client.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);
  client.setCallback(callback);
}
 
void loop(){

  if (!client.connected()){
    reconnect();
  }
  client.loop();
}