API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 25th, 2019
128
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.11 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!