Sterowanie urządzeniami

[SunRiver]

W książce pozwoliłem sobie na uproszczenie i napisanie kodu w Arduino
który wygląda tak:

Code: [Zaznacz cały] [Expand/Collapse] [Download] (Untitled.cpp)

1. #include <ESP8266WiFi.h>
2. #include <PubSubClient.h>
3.  
4. // Ustawienia Wi-Fi
5. const char* ssid = "Nazwa sieci";
6. const char* password = "Hasło sieci";
7.  
8. // Ustawienia MQTT
9. const char* mqtt_server = "adres IP serwera MQTT";  
10. const int   mqtt_port = 1883;
11. const char* mqtt_user = "Nazwa użytkownika MQTT";
12. const char* mqtt_password = "Hasło MQTT";
13. const char* mqtt_topic_pk1 =   "wlacznik/przekaznik1";
14. const char* mqtt_topic_pk2 =   "wlacznik/przekaznik2";
15. const char* mqtt_topic_s_pk1 = "wlacznik/przekaznik1/status";
16. const char* mqtt_topic_s_pk2 = "wlacznik/przekaznik2/status";
17.  
18. // Piny podłączenia przekaźników
19. const int przekaznik1 = 12;  // Pin przekaźnika 1
20. const int przekaznik2 = 13;  // Pin przekaźnika 2
21.  
22. // Inicjalizacja klienta Wi-Fi
23. WiFiClient espClient;
24. PubSubClient client(espClient);
25.  
26. // Funkcja obsługująca otrzymane wiadomości MQTT
27. void callback(char* topic, byte* payload, unsigned int length)
28. {
29.     // Konwertuj payload na string
30.     String message = "";
31.     for (int i = 0; i < length; i++)
32.     {
33.         message += (char)payload[i];
34.     }
35.  
36.     // Sprawdź, czy otrzymano wiadomość dla przekaźnika 1
37.     if (String(topic) == mqtt_topic_pk1)
38.     {
39.         if (message == "ON")
40.         {
41.             digitalWrite(przekaznik1, HIGH);  // Włącz przekaźnik 1
42.             client.publish(mqtt_topic_s_pk1, "ON");
43.         }
44.         else if (message == "OFF")
45.         {
46.             digitalWrite(przekaznik1, LOW);  // Wyłącz przekaźnik 1
47.             client.publish(mqtt_topic_s_pk1, "OFF");
48.         }
49.     }
50.  
51.     // Sprawdź, czy otrzymano wiadomość dla przekaźnika 2
52.     else if (String(topic) == mqtt_topic_pk2)
53.     {
54.         if (message == "ON")
55.         {
56.             digitalWrite(przekaznik2, HIGH);  // Włącz przekaźnik 2
57.             client.publish(mqtt_topic_s_pk2, "ON");
58.         }
59.         else if (message == "OFF")
60.         {
61.             digitalWrite(przekaznik2, LOW);  // Wyłącz przekaźnik 2
62.             client.publish(mqtt_topic_s_pk2, "OFF");
63.         }
64.     }
65. }
66.  
67. void setup()
68. {
69.     Serial.begin(115200);
70.     // Inicjalizacja pinów przekaźników
71.     pinMode(przekaznik1, OUTPUT);
72.     pinMode(przekaznik2, OUTPUT);
73.  
74.     // Inicjalizacja połączenia Wi-Fi
75.     WiFi.begin(ssid, password);
76.     while (WiFi.status() != WL_CONNECTED) {
77.         delay(1000);
78.         Serial.println("Laczenie z WiFi...");
79.     }
80.     Serial.println("Polaczono");
81.  
82.     // Inicjalizacja klienta MQTT
83.     client.setServer(mqtt_server, mqtt_port);
84.     client.setCallback(callback);
85. }
86.  
87. void reconnect()
88. {
89.     // Pętla czekająca na ponowne połączenie z brokerem MQTT
90.     while (!client.connected())
91.     {
92.         Serial.println("Nawiazuje polaczenie z Brokerem MQTT...");
93.         // Proba połączenia z klientem MQTT
94.         if (client.connect("ESP8266Client", mqtt_user, mqtt_password))
95.         {
96.             Serial.println("Polaczono.");
97.             // Subskrybuj tematy przekaźników
98.             client.subscribe(mqtt_topic_pk1);
99.             client.subscribe(mqtt_topic_pk2);                      
100.         }
101.         else
102.         {
103.             Serial.print("Blad, rc=");
104.             Serial.print(client.state());
105.             Serial.println(" Ponowna proba za 5sek...");
106.             delay(5000);
107.         }
108.     }
109. }
110.  
111. void loop() {
112.     // Sprawdź, czy klient MQTT jest połączony
113.     if (!client.connected())
114.     {
115.         reconnect();
116.     }
117.     // Obsługa komunikacji MQTT
118.     client.loop();
119. }
120.  

ale oczywiście nic nie sto i na przeszkodzie by napisać ten kod z użyciem ESP-IDF co może wyglądać tak,
niemniej wydało mi się że do tak prostego zadania Arduino`wystarczy.

Code: [Zaznacz cały] [Expand/Collapse] [Download] (Untitled.cpp)

1.  
2. #include <stdio.h>
3. #include <string.h>
4. #include "freertos/FreeRTOS.h"
5. #include "freertos/task.h"
6. #include "freertos/event_groups.h"
7. #include "esp_wifi.h"
8. #include "esp_event.h"
9. #include "esp_log.h"
10. #include "nvs_flash.h"
11. #include "mqtt_client.h"
12. #include "driver/gpio.h"
13.  
14. // Ustawienia Wi-Fi
15. #define WIFI_SSID "Nazwa sieci"
16. #define WIFI_PASS "Hasło sieci"
17. #define WIFI_MAX_RETRY 5
18.  
19. // Ustawienia MQTT
20. #define MQTT_BROKER_URI "mqtt://adres_IP_serwera_MQTT"
21. #define MQTT_USERNAME "Nazwa użytkownika MQTT"
22. #define MQTT_PASSWORD "Hasło MQTT"
23. #define MQTT_TOPIC_PK1 "wlacznik/przekaznik1"
24. #define MQTT_TOPIC_PK2 "wlacznik/przekaznik2"
25. #define MQTT_TOPIC_S_PK1 "wlacznik/przekaznik1/status"
26. #define MQTT_TOPIC_S_PK2 "wlacznik/przekaznik2/status"
27.  
28. // Piny GPIO
29. #define GPIO_RELAY1 12
30. #define GPIO_RELAY2 13
31.  
32. // Log tag
33. static const char *TAG = "MQTT_RELAY";
34.  
35. // Wi-Fi event group
36. static EventGroupHandle_t s_wifi_event_group;
37. #define WIFI_CONNECTED_BIT BIT0
38. #define WIFI_FAIL_BIT BIT1
39.  
40. static int s_retry_num = 0;
41. esp_mqtt_client_handle_t mqtt_client = NULL;
42.  
43. // Funkcja obsługi zdarzeń Wi-Fi
44. static void wifi_event_handler(void* arg, esp_event_base_t event_base,
45.                                int32_t event_id, void* event_data) {
46.     if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
47.         esp_wifi_connect();
48.     } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
49.         if (s_retry_num < WIFI_MAX_RETRY) {
50.             esp_wifi_connect();
51.             s_retry_num++;
52.             ESP_LOGI(TAG, "Ponowne laczenie do sieci Wi-Fi...");
53.         } else {
54.             xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
55.         }
56.     } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
57.         ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
58.         ESP_LOGI(TAG, "Uzyskano adres IP: %s", ip4addr_ntoa(&event->ip_info.ip));
59.         s_retry_num = 0;
60.         xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
61.     }
62. }
63.  
64. // Inicjalizacja Wi-Fi
65. void wifi_init_sta(void) {
66.     s_wifi_event_group = xEventGroupCreate();
67.  
68.     ESP_ERROR_CHECK(esp_netif_init());
69.     ESP_ERROR_CHECK(esp_event_loop_create_default());
70.     esp_netif_create_default_wifi_sta();
71.  
72.     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
73.     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
74.  
75.     esp_event_handler_instance_t instance_any_id;
76.     esp_event_handler_instance_t instance_got_ip;
77.     ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
78.                                                         ESP_EVENT_ANY_ID,
79.                                                         &wifi_event_handler,
80.                                                         NULL,
81.                                                         &instance_any_id));
82.     ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
83.                                                         IP_EVENT_STA_GOT_IP,
84.                                                         &wifi_event_handler,
85.                                                         NULL,
86.                                                         &instance_got_ip));
87.  
88.     wifi_config_t wifi_config = {
89.         .sta = {
90.             .ssid = WIFI_SSID,
91.             .password = WIFI_PASS,
92.         },
93.     };
94.     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
95.     ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
96.     ESP_ERROR_CHECK(esp_wifi_start());
97.  
98.     ESP_LOGI(TAG, "Inicjalizacja Wi-Fi zakończona.");
99.  
100.     EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
101.                                            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
102.                                            pdFALSE,
103.                                            pdFALSE,
104.                                            portMAX_DELAY);
105.  
106.     if (bits & WIFI_CONNECTED_BIT) {
107.         ESP_LOGI(TAG, "Polaczono z Wi-Fi: %s", WIFI_SSID);
108.     } else if (bits & WIFI_FAIL_BIT) {
109.         ESP_LOGE(TAG, "Nie udalo sie polaczyc z Wi-Fi.");
110.     } else {
111.         ESP_LOGE(TAG, "Nieznany blad podczas laczenia z Wi-Fi.");
112.     }
113. }
114.  
115. // Funkcja obsługi wiadomości MQTT
116. static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
117.     esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t) event_data;
118.     switch ((esp_mqtt_event_id_t)event_id) {
119.         case MQTT_EVENT_CONNECTED:
120.             ESP_LOGI(TAG, "Polaczono z MQTT brokerem");
121.             esp_mqtt_client_subscribe(mqtt_client, MQTT_TOPIC_PK1, 0);
122.             esp_mqtt_client_subscribe(mqtt_client, MQTT_TOPIC_PK2, 0);
123.             break;
124.         case MQTT_EVENT_DISCONNECTED:
125.             ESP_LOGI(TAG, "Rozlaczono z MQTT brokerem");
126.             break;
127.         case MQTT_EVENT_DATA:
128.             ESP_LOGI(TAG, "Otrzymano dane z MQTT: topic=%.*s, data=%.*s",
129.                      event->topic_len, event->topic, event->data_len, event->data);
130.  
131.             if (strncmp(event->topic, MQTT_TOPIC_PK1, event->topic_len) == 0) {
132.                 if (strncmp(event->data, "ON", event->data_len) == 0) {
133.                     gpio_set_level(GPIO_RELAY1, 1);
134.                     esp_mqtt_client_publish(mqtt_client, MQTT_TOPIC_S_PK1, "ON", 0, 0, 0);
135.                 } else if (strncmp(event->data, "OFF", event->data_len) == 0) {
136.                     gpio_set_level(GPIO_RELAY1, 0);
137.                     esp_mqtt_client_publish(mqtt_client, MQTT_TOPIC_S_PK1, "OFF", 0, 0, 0);
138.                 }
139.             } else if (strncmp(event->topic, MQTT_TOPIC_PK2, event->topic_len) == 0) {
140.                 if (strncmp(event->data, "ON", event->data_len) == 0) {
141.                     gpio_set_level(GPIO_RELAY2, 1);
142.                     esp_mqtt_client_publish(mqtt_client, MQTT_TOPIC_S_PK2, "ON", 0, 0, 0);
143.                 } else if (strncmp(event->data, "OFF", event->data_len) == 0) {
144.                     gpio_set_level(GPIO_RELAY2, 0);
145.                     esp_mqtt_client_publish(mqtt_client, MQTT_TOPIC_S_PK2, "OFF", 0, 0, 0);
146.                 }
147.             }
148.             break;
149.         default:
150.             break;
151.     }
152. }
153.  
154. // Inicjalizacja MQTT
155. void mqtt_app_start(void) {
156.     esp_mqtt_client_config_t mqtt_cfg = {
157.         .uri = MQTT_BROKER_URI,
158.         .username = MQTT_USERNAME,
159.         .password = MQTT_PASSWORD,
160.     };
161.     mqtt_client = esp_mqtt_client_init(&mqtt_cfg);
162.     esp_mqtt_client_register_event(mqtt_client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
163.     esp_mqtt_client_start(mqtt_client);
164. }
165.  
166. // Funkcja glówna
167. void app_main(void) {
168.     // Inicjalizacja NVS
169.     esp_err_t ret = nvs_flash_init();
170.     if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
171.         ESP_ERROR_CHECK(nvs_flash_erase());
172.         ret = nvs_flash_init();
173.     }
174.     ESP_ERROR_CHECK(ret);
175.  
176.     // Inicjalizacja GPIO
177.     gpio_config_t io_conf = {
178.         .pin_bit_mask = (1ULL << GPIO_RELAY1) | (1ULL << GPIO_RELAY2),
179.         .mode = GPIO_MODE_OUTPUT,
180.         .pull_up_en = GPIO_PULLUP_ENABLE,
181.         .pull_down_en = GPIO_PULLDOWN_DISABLE,
182.         .intr_type = GPIO_INTR_DISABLE
183.     };
184.     gpio_config(&io_conf);
185.  
186.     // Uruchomienie Wi-Fi i MQTT
187.     wifi_init_sta();
188.     mqtt_app_start();
189. }
190.