SHARE
TWEET

Untitled

a guest Aug 25th, 2019 82 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <SPI.h>
  2. #include <Ethernet.h>
  3. #include <OneWire.h>
  4. #include <DallasTemperature.h>
  5. #include <PubSubClient.h>
  6.  
  7. byte mac[]          = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
  8. byte ip[]           = { 192, 168, 0, 133 };
  9. byte dns[]          = { 8, 8, 8, 8 };
  10. byte gateway[]      = { 192, 168, 0, 1 };
  11. byte subnet[]       = { 255, 255, 255, 0 };
  12.  
  13. #define PIN_STATE_ON    1
  14. #define PIN_STATE_OFF   0
  15.  
  16. //KLAWISZE
  17. #define KEY_SSR         9         // Przycisk monostabilny SSR
  18. //PINY WEJSCIA
  19. #define PIN_ACS712      14        // ADC ANALOG
  20. #define PIN_SSR         16        // SSR
  21. #define PIN_OWB         2         // OneWire
  22. //PINY WYJSCIA
  23. #define LED_ETHERNET    5         // LED od LAN
  24. #define LED_MQTT        6         // LED od MQTT
  25. #define LED_SSR         7         // LED od SSR
  26.  
  27. #define TEMP_PRECISION  12        // Rozdzielczość czujnika temperatury
  28.  
  29. #define ARDUINO_CLIENT_ID "Gniazdko_Korytarz"                      // Client ID for Arduino pub/sub
  30. #define PUB_TEMP  "Gniazdko_Korytarz/sensor/temp"                  // MTTQ topic for temperature [C]
  31. #define PUB_WATS  "Gniazdko_Korytarz/sensor/wats"                  // MTTQ topic for wats
  32. #define PUB_SSR   "Gniazdko_Korytarz/sensor/ssr"                   // MTTQ topic for SSR
  33. #define SUB_STATE "Gniazdko_Korytarz/sensor/ssr"
  34. #define PUB_IP  "Gniazdko_Korytarz/ip"                  // MTTQ topic for temperature [C]
  35.  
  36. bool SSRstate = HIGH;
  37.  
  38. int     MQTT_SSR_STATE          = 0;
  39. int     ledArray []             = {5, 6, 7};
  40.  
  41. int     PIN_STATE               = LOW;         // Domyślny stan pinow - HIGH/LOW
  42. int     PIN_SSR_STATE           = HIGH;          // Domyślny stan pinow od SSR po uruchomieniu - HIGH/LOW
  43.  
  44. int     PIN_SSR_READING;
  45. int     PIN_SSR_PREVIOUS        = LOW;
  46.  
  47. int     PIN_ACS712_READING      = 0;
  48.  
  49. int     ETHERNET_LINK           = 0;
  50. String  ETHERNET_BOARD          = "";
  51.  
  52. int     MQTT_LINK               = 0;
  53. int     MQTT_STATUS             = 0;
  54.  
  55. int     ACS712_COUNTS           = 10;
  56. int     ACS712_VPA              = 108;          // 5A Version 1A: 185mV || 20A Version: 1A: 100mV || 30A Version 1A: 66mV
  57. float   ACS712_NP               = 2500;         // Domyślnie 2500
  58. float   ACS712_AVE_VAL          = 0.0;
  59. double  ACS712_VOLTAGE          = 0;
  60. double  ACS712_AMP              = 0;
  61.  
  62. float   DS_VAL                  = 0.0;
  63.  
  64. unsigned long TIME              = 0;
  65. unsigned long TIME_REGISTRED    = 0;
  66. unsigned long PIN_SSR_TIME      = 0;
  67. unsigned long PIN_SSR_DEBOUNCE  = 200;
  68.  
  69. OneWire oneWire(PIN_OWB);
  70. DallasTemperature temp_sensor(&oneWire);
  71.  
  72. IPAddress server(192, 168, 0, 54);
  73.  
  74. EthernetClient ethClient;
  75. PubSubClient mqttClient;
  76.  
  77. int mqtt_port = 1883;
  78. #define mqtt_login "darevil"
  79. #define mqtt_haslo "darevil"
  80.  
  81. void setup() {
  82.   //Ustawienia wejść, wyjść
  83.   pinMode(KEY_SSR,      INPUT_PULLUP);   // Podciagniecie programowe pinu
  84.   pinMode(PIN_ACS712,   INPUT);
  85.  
  86.   pinMode(PIN_SSR,      OUTPUT);
  87.  
  88.   pinMode(LED_ETHERNET, OUTPUT);
  89.   pinMode(LED_MQTT,     OUTPUT);
  90.   pinMode(LED_SSR,      OUTPUT);
  91.  
  92.   digitalWrite(PIN_SSR,       PIN_STATE);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  93.  
  94.   mqttClient.setClient(ethClient);
  95.   mqttClient.setServer(server, mqtt_port);
  96.   mqttClient.setCallback(callback);
  97.  
  98.   Ethernet.begin(mac, ip, dns, gateway, subnet);
  99.  
  100.   delay(1500); // Allow hardware to stabilize
  101.  
  102.   ETH_BOARD();
  103.   ETH_LINK_CHECK();
  104.  
  105.   startUpSeqence();
  106.  
  107.   digitalWrite(LED_ETHERNET,  PIN_STATE);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  108.   digitalWrite(LED_MQTT,      PIN_STATE);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  109.   digitalWrite(LED_SSR,       PIN_STATE);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  110.  
  111. if (!mqttClient.connected()) {
  112.     connectMQTT();
  113.   }
  114.  
  115.   if ( ! Serial.available()) {
  116.  
  117.     Serial.begin(115200);
  118.  
  119.     Serial.print("Nazwa       - ");
  120.     Serial.println(ARDUINO_CLIENT_ID);
  121.     Serial.println("-----------------------------------------------");
  122.     Serial.print("PŁYTA       - ");
  123.     Serial.println(ETHERNET_BOARD);
  124.     Serial.println("-----------------------------------------------");
  125.     Serial.print("Adres IP    - ");
  126.     Serial.println(Ethernet.localIP());
  127.     Serial.print("Netmask     - ");
  128.     Serial.println(Ethernet.subnetMask());
  129.     Serial.print("Brama       - ");
  130.     Serial.println(Ethernet.gatewayIP());
  131.     Serial.print("DNS         - ");
  132.     Serial.println(Ethernet.dnsServerIP());
  133.     Serial.println("-----------------------------------------------");
  134.     Serial.print("Ping        - ");
  135.     Serial.println(ETHERNET_LINK);
  136.     Serial.println("-----------------------------------------------");
  137.     Serial.print("Serwer MQTT - ");
  138.     Serial.println(server);
  139.     Serial.print("Port MQTT   - ");
  140.     Serial.println(mqtt_port);
  141.     Serial.print("Login MQTT  - ");
  142.     Serial.println(mqtt_login);
  143.     Serial.print("Hasło MQTT  - ");
  144.     Serial.println(mqtt_haslo);
  145.     Serial.print("Status MQTT - ");
  146.     Serial.println(MQTT_LINK);
  147.     Serial.println("-----------------------------------------------");
  148.  
  149.   }
  150.  
  151.   temp_sensor.begin();
  152.   temp_sensor.setResolution(TEMP_PRECISION);
  153.  
  154. //  mqttClient.publish(PUB_IP, Ethernet.localIP());
  155. }
  156.  
  157. void loop() {
  158.   TIME = millis();
  159.  
  160.   // Wywołanie funkcji do obsługi klawisza i przekaźnika SSR wraz z diodą LED informującą o stanie przekaźnika
  161.   SSR_KEY();
  162.  
  163.   // Wywalenie daley :) Aby nie blokować programu
  164.   if (TIME - TIME_REGISTRED >= 3000UL) {
  165.  
  166.     TIME_REGISTRED = millis();
  167.  
  168.     char tmpBuffer[20];
  169.  
  170.     ETH_LINK_CHECK();
  171.     ETH_BOARD();
  172.  
  173.     DS_TEMP();
  174.     ACS712_SENSOR();
  175.  
  176.     Serial.print("MQTT: ");
  177.     Serial.print(MQTT_LINK);
  178.     Serial.print(", SSR STATUS: ");
  179.     Serial.print(MQTT_SSR_STATE);
  180.     Serial.print(", Temperatura [C]: ");
  181.     Serial.print(DS_VAL);
  182.     Serial.print(", MOC: ");
  183.     Serial.print(ACS712_AVE_VAL);
  184.     Serial.print(", LINK ETH: ");
  185.     Serial.print(ETHERNET_LINK);
  186.  
  187.     mqttClient.publish(PUB_TEMP,  dtostrf(DS_VAL, 6, 2, tmpBuffer));
  188.     mqttClient.publish(PUB_WATS,  dtostrf(ACS712_AVE_VAL, 6, 2, tmpBuffer));
  189.     mqttClient.publish(PUB_SSR,   dtostrf(MQTT_SSR_STATE, 6, 2, tmpBuffer));
  190.  
  191.   SSRstate = digitalRead(PIN_SSR);
  192.   Serial.print(", Status przekaźnika SSR: ");
  193.   Serial.println((SSRstate == HIGH) ? "ON" : "OFF");
  194.   mqttClient.publish(SUB_STATE, (SSRstate == HIGH) ? "ON" : "OFF");
  195.   }
  196.  
  197.   if (!mqttClient.connected()) {
  198.     connectMQTT();
  199.   }
  200.  
  201.   mqttClient.loop();
  202. }
  203.  
  204. void DS_TEMP() {
  205.   temp_sensor.requestTemperatures();
  206.   float temp = temp_sensor.getTempCByIndex(0);
  207.  
  208.   if (temp != DEVICE_DISCONNECTED_C)
  209.   {
  210.     DS_VAL = temp;
  211.   } else {
  212.     DS_VAL = 0;
  213.   }
  214. }
  215.  
  216. void ETH_LINK_CHECK() {
  217.   if (Ethernet.linkStatus() == Unknown) {
  218.     if (TIME - TIME_REGISTRED >= 100UL) {
  219.       digitalWrite(LED_ETHERNET,  PIN_STATE_OFF);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  220.       ETHERNET_LINK = PIN_STATE_OFF;
  221.     }
  222.     if (TIME - TIME_REGISTRED >= 200UL) {
  223.       digitalWrite(LED_ETHERNET,  PIN_STATE_ON);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  224.       ETHERNET_LINK = PIN_STATE_ON;
  225.     }
  226.   }
  227.   else if (Ethernet.linkStatus() == LinkON) {
  228.     digitalWrite(LED_ETHERNET,  PIN_STATE_ON);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  229.     ETHERNET_LINK = PIN_STATE_ON;
  230.   }
  231.   else if (Ethernet.linkStatus() == LinkOFF) {
  232.     digitalWrite(LED_ETHERNET,  PIN_STATE_OFF);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  233.     ETHERNET_LINK = PIN_STATE_OFF;
  234.   }
  235.   else {
  236.     digitalWrite(LED_ETHERNET,  PIN_STATE_OFF);     // Ustawienie stanu pinu, aby po uruchomieniu miał stan HIGH / LOW
  237.     ETHERNET_LINK = PIN_STATE_OFF;
  238.   }
  239.  
  240.  
  241. }
  242.  
  243. void ETH_BOARD() {
  244.   if (Ethernet.hardwareStatus() == EthernetNoHardware) {
  245.     ETHERNET_BOARD = "Ethernet no Hardware";
  246.   }
  247.   else if (Ethernet.hardwareStatus() == EthernetW5100) {
  248.     ETHERNET_BOARD = "Ethernet W5100";
  249.   }
  250.   else if (Ethernet.hardwareStatus() == EthernetW5200) {
  251.     ETHERNET_BOARD = "Ethernet W5200";
  252.   }
  253.   else if (Ethernet.hardwareStatus() == EthernetW5500) {
  254.     ETHERNET_BOARD = "Ethernet W5500";
  255.   }
  256.   else {
  257.     ETHERNET_BOARD = "Unknow";
  258.   }
  259.  
  260. }
  261.  
  262. void ACS712_SENSOR() {
  263.   float averageVAL;
  264.   float TMP[10];
  265.   int p = 0;
  266.  
  267.   for ( p = 0 ; p < ACS712_COUNTS ; p++ ) {
  268.     PIN_ACS712_READING = analogRead(PIN_ACS712);
  269.     ACS712_VOLTAGE = (PIN_ACS712_READING / 1024.0) * 5000;
  270.     ACS712_AMP = ((ACS712_VOLTAGE - ACS712_NP) / ACS712_VPA);
  271.     TMP[p++] = ACS712_AMP;
  272.     ACS712_VAL_SORT(TMP, ACS712_COUNTS);
  273.   }
  274.   ACS712_AVE_VAL = (TMP[3] + TMP[4] + TMP[5] + TMP[6]) / 4;
  275. }
  276.  
  277. void ACS712_VAL_SORT(float a[], int size) {
  278.   for (int i = 0; i < (size - 1); i++) {
  279.     for (int o = 0; o < (size - (i + 1)); o++) {
  280.       if (a[o] > a[o + 1]) {
  281.         float t = a[o];
  282.         a[o] = a[o + 1];
  283.         a[o + 1] = t;
  284.       }
  285.     }
  286.   }
  287. }
  288.  
  289. //Funkcja do obsługi klawisza i przekaźnika SSR wraz z diodą LED informującą o stanie przekaźnika
  290. void SSR_KEY() {
  291.   PIN_SSR_READING = digitalRead(KEY_SSR);         // Odczyt stanu pinu
  292.  
  293.   // Funkcja sprawdzajaca czy przycisk zostal nacisniety, jaki byl ostatni stan przycisku, oraz zapobieganiu drgania stykow
  294.   if (PIN_SSR_READING == HIGH && PIN_SSR_PREVIOUS == LOW && millis() - PIN_SSR_TIME > PIN_SSR_DEBOUNCE) {
  295.     if (PIN_SSR_STATE == HIGH) {
  296.       PIN_SSR_STATE = LOW;      // Zapis stanu niskiego
  297.       MQTT_SSR_STATE = 0;
  298.     } else {
  299.       PIN_SSR_STATE = HIGH;     // Zapis stanu wysokiego
  300.       MQTT_SSR_STATE = 1;
  301.     }
  302.     PIN_SSR_TIME = millis();    // Zapis czasu ostatniego naciśniecia klawisza
  303.   }
  304.  
  305.   digitalWrite(PIN_SSR, PIN_SSR_STATE);     // Zmiana stanu pinu od SSR
  306.   digitalWrite(LED_SSR, PIN_SSR_STATE);     // Zmiana stanu pinu diody LED sygnalizujacą stan SSR
  307.  
  308.   PIN_SSR_PREVIOUS = PIN_SSR_READING;       // Zapis ostatniego odczytu do zmiennej
  309. }
  310.  
  311. //Sekwencja podczas startu programu
  312. void startUpSeqence()
  313. {
  314.   for (int i = 0; i <= 3; i++) {
  315.     digitalWrite(ledArray[i], PIN_STATE_ON);
  316.   }
  317.   delay(500);
  318.   for (int i = 0; i <= 3; i++) {
  319.     digitalWrite(ledArray[i], PIN_STATE_OFF);
  320.     delay(100);
  321.   }
  322.   for (int i = 0; i <= 3; i++) {
  323.     digitalWrite(ledArray[i], PIN_STATE_ON);
  324.     delay(100);
  325.   }
  326.   for (int i = 0; i <= 3; i++) {
  327.     digitalWrite(ledArray[i], PIN_STATE_OFF);
  328.     delay(100);
  329.   }
  330. }
  331.  
  332. void connectMQTT()
  333. {
  334.   while (!mqttClient.connected()) {
  335.     if (ETHERNET_LINK == PIN_STATE_ON) {
  336.       if (mqttClient.connect(ARDUINO_CLIENT_ID, mqtt_login, mqtt_haslo)) {
  337.  
  338.         digitalWrite(LED_MQTT,  PIN_STATE_ON);
  339.  
  340.         MQTT_LINK = PIN_STATE_ON;
  341.         MQTT_STATUS = mqttClient.state();
  342.  
  343.         mqttClient.subscribe(SUB_STATE);
  344.       } else {
  345.         digitalWrite(LED_MQTT,  PIN_STATE_OFF);
  346.  
  347.         MQTT_LINK = PIN_STATE_OFF;
  348.         MQTT_STATUS = PIN_STATE_OFF;
  349.       }
  350.     } else {
  351.  
  352.       digitalWrite(LED_MQTT,  PIN_STATE_OFF);
  353.  
  354.       MQTT_LINK = PIN_STATE_OFF;
  355.       MQTT_STATUS = PIN_STATE_OFF;
  356.     }
  357.   }
  358.   //if (ETHERNET_LINK == PIN_STATE_ON) {
  359.   //    if (mqttClient.connect(ARDUINO_CLIENT_ID)) {
  360.   //
  361.   //      digitalWrite(LED_MQTT,  PIN_STATE_ON);
  362.   //
  363.   //      MQTT_LINK = 1;
  364.   //      MQTT_STATUS = mqttClient.state();
  365.   //
  366.   //      mqttClient.subscribe(SUB_STATE);
  367.   //    } else {
  368.   //      digitalWrite(LED_MQTT,  PIN_STATE_OFF);
  369.   //
  370.   //      MQTT_LINK = 0;
  371.   //      MQTT_STATUS = mqttClient.state();
  372.   //    }
  373.   //  }
  374. }
  375.  
  376. //void callback(char* topic, byte* payload, unsigned int length) {
  377. //  Serial.print("Wiadomość dotarła [");
  378. //  Serial.print(topic);
  379. //  Serial.print("] ");
  380.  
  381. //  int i=0;
  382. //  for(i=0;i<length;i++) {
  383. //    Serial.print((char)payload[i]);
  384. //    message_buff[i] = payload[i];
  385. //  }
  386. //  message_buff[i] = '\0';
  387. //  String msgString = String(message_buff);
  388.  
  389. //  if(msgString.equals("ON")) {
  390. //      PIN_SSR_STATE = HIGH;      // Zapis stanu niskiego
  391. //      MQTT_SSR_STATE = 1;
  392. //    mqttClient.publish(SUB_STATE, "Przekaźnik włączony");
  393. //  }
  394. //  else if(msgString.equals("OFF")) {
  395. //      PIN_SSR_STATE = LOW;     // Zapis stanu wysokiego
  396. //      MQTT_SSR_STATE = 0;
  397. //    mqttClient.publish(SUB_STATE, "Przekaźnik wyłączony");
  398. //  }
  399. //  Serial.println("");
  400. //}
  401.  
  402. // sub callback function
  403. void callback(char* topic, byte * payload, unsigned int length)
  404. {
  405.   Serial.print("[sub: ");
  406.   Serial.print(topic);
  407.   Serial.print("] ");
  408.   char message[length + 1] = "";
  409.   for (int i = 0; i < length; i++)
  410.     message[i] = (char)payload[i];
  411.   message[length] = '\0';
  412. //Serial.println(message);
  413.  
  414.  
  415.   if (strcmp(topic, SUB_STATE) == 0)
  416.   {
  417.     if (strcmp(message, "1.00") == 0)
  418.       PIN_SSR_STATE = HIGH;     // Zmiana stanu pinu od SSR
  419.       MQTT_SSR_STATE = 1;
  420.     digitalWrite(LED_SSR, PIN_STATE_ON);     // Zmiana stanu pinu diody LED sygnalizujacą stan SSR
  421.     Serial.println(strcmp(message, "1.00"));
  422.     if (strcmp(message, "0.00") == 0)
  423.       PIN_SSR_STATE = LOW;     // Zmiana stanu pinu od SSR
  424.       MQTT_SSR_STATE = 0;
  425.     digitalWrite(LED_SSR, PIN_STATE_OFF);     // Zmiana stanu pinu diody LED sygnalizujacą stan SSR
  426.     Serial.println(strcmp(message, "0.00"));
  427.   }
  428. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top