Mercurial > co2meter / file comparison

comparison: main/task_wifi.c

main/task_wifi.c

changeset 47
1ab1f4a8c328
parent 44
e52d11b8f252
child 48
d43ea0c916de
equal deleted inserted replaced
46:2cf4b15895f2 47:1ab1f4a8c328
32 32
33 33
34 const int TASK_WIFI_REQUEST_WIFI_SCAN = BIT0; ///< When set, means a client requested to scan wireless networks. 34 const int TASK_WIFI_REQUEST_WIFI_SCAN = BIT0; ///< When set, means a client requested to scan wireless networks.
35 const int TASK_WIFI_REQUEST_STA_DISCONNECT = BIT1; ///< When set, means a client requested to disconnect from currently connected AP. 35 const int TASK_WIFI_REQUEST_STA_DISCONNECT = BIT1; ///< When set, means a client requested to disconnect from currently connected AP.
36 const int TASK_WIFI_REQUEST_STA_CONNECT = BIT2; ///< When set, means a client requested to connect to an access point. 36 const int TASK_WIFI_REQUEST_STA_CONNECT = BIT2; ///< When set, means a client requested to connect to an access point.
37 const int TASK_WIFI_REQUEST_STA_STATUS = BIT8;
37 38
38 const int TASK_WIFI_HAS_IP = BIT3; ///< Indicate that we have an IP address 39 const int TASK_WIFI_HAS_IP = BIT3; ///< Indicate that we have an IP address
39 const int TASK_WIFI_STA_FAILED = BIT4; ///< Indicate that we could not get a connection to AP as station. 40 const int TASK_WIFI_STA_FAILED = BIT4; ///< Indicate that we could not get a connection to AP as station.
40 const int TASK_WIFI_STA_DISCONNECTED = BIT5; ///< Indicate that we are disconnected from an ap station. 41 const int TASK_WIFI_STA_DISCONNECTED = BIT5; ///< Indicate that we are disconnected from an ap station.
41 const int TASK_WIFI_STA_CONNECTED = BIT6; ///< Indicate that we are connected to AP as station, flip of BIT6. 42 const int TASK_WIFI_STA_CONNECTED = BIT6; ///< Indicate that we are connected to AP as station, flip of BIT6.
42 43
43 const int TASK_WIFI_REQUEST_SYSTEM = BIT8; ///< The system needs a connection
44 const int TASK_WIFI_REQUEST_USER = BIT9; ///< The user needs a connection
45 44
46 45
47 /** 46 /**
48 * @brief Array with AP security names 47 * @brief Array with AP security names
49 */ 48 */
51 50
52 51
53 /****************************************************************************/ 52 /****************************************************************************/
54 53
55 54
56
57 void requestWiFi_system(bool state)
58 {
59 if (state)
60 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_SYSTEM);
61 else
62 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_REQUEST_SYSTEM);
63
64 if (xEventGroupGetBits(xEventGroupWifi) & (TASK_WIFI_REQUEST_SYSTEM | TASK_WIFI_REQUEST_USER))
65 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT);
66 else
67 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_DISCONNECT);
68 }
69
70
71
72 void requestWiFi_user(bool state)
73 {
74 if (state)
75 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_USER);
76 else
77 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_REQUEST_USER);
78
79 if (xEventGroupGetBits(xEventGroupWifi) & (TASK_WIFI_REQUEST_SYSTEM | TASK_WIFI_REQUEST_USER))
80 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT);
81 else
82 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_DISCONNECT);
83 }
84
85
86
87 bool ready_WiFi(void) 55 bool ready_WiFi(void)
88 { 56 {
89 if (wifi_state->STA_connected && wifi_state->STA_online) 57 if (wifi_state->STA_connected && wifi_state->STA_online)
90 return true; 58 return true;
91 return false; 59 return false;
60 }
61
62
63
64 void status_WiFi(void)
65 {
66 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_STATUS);
92 } 67 }
93 68
94 69
95 70
96 static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) 71 static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
103 _wifi_Scanned = ap_num; 78 _wifi_Scanned = ap_num;
104 _wifi_ScanDone = true; 79 _wifi_ScanDone = true;
105 break; 80 break;
106 81
107 case WIFI_EVENT_STA_START: 82 case WIFI_EVENT_STA_START:
108 ESP_LOGI(TAG, "Event wifi START"); 83 ESP_LOGI(TAG, "Event wifi START");
109 // Set the configured hostname for the dhcp client. 84 // Set the configured hostname for the dhcp client.
110 ESP_ERROR_CHECK(tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, config.hostname)); 85 ESP_ERROR_CHECK(tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, config.hostname));
111 esp_wifi_connect(); 86 esp_wifi_connect();
112 break; 87 break;
113 88
114 case WIFI_EVENT_STA_CONNECTED: 89 case WIFI_EVENT_STA_CONNECTED:
115 { 90 {
116 wifi_event_sta_connected_t* event = (wifi_event_sta_connected_t*) event_data; 91 wifi_event_sta_connected_t* event = (wifi_event_sta_connected_t*) event_data;
117 wifi_ap_record_t ap_info; 92 wifi_ap_record_t ap_info;
143 wifi_state->STA_rssi = 0; 118 wifi_state->STA_rssi = 0;
144 xSemaphoreGive(xSemaphoreWiFi); 119 xSemaphoreGive(xSemaphoreWiFi);
145 } else { 120 } else {
146 ESP_LOGE(TAG, "wifi_event_handler() lock error WIFI_EVENT_STA_DISCONNECTED"); 121 ESP_LOGE(TAG, "wifi_event_handler() lock error WIFI_EVENT_STA_DISCONNECTED");
147 } 122 }
123 connect_mqtt(false);
148 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_STA_CONNECTED); 124 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_STA_CONNECTED);
149 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_STA_DISCONNECTED); 125 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_STA_DISCONNECTED);
126
127 //if (disconnected->reason == WIFI_REASON_NO_AP_FOUND && ! _wifi_ScanAPs) {
128 // ESP_LOGI(TAG, "Request scan for another AP");
129 // _wifi_ScanAPs = true;
130 // _wifi_ScanDone = false;
131 // ap_num = MAX_AP_NUM;
132 // ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_config, false));
133 // xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT); // Keep looping active.
134 // break;
135 //}
136
137 //if (disconnected->reason == WIFI_REASON_NO_AP_FOUND && _wifi_ScanAPs && _wifi_ScanDone) {
138 // ESP_LOGD(TAG, "Scan completed, look for another AP, found:%d", _wifi_Scanned);
139 // _wifi_ScanAPs = false;
140 // _wifi_ScanDone = false;
141 // for (int i = 0; i < _wifi_Scanned; i++) {
142 // ap = accessp_records[i];
143 // if ((read_station(ap.ssid) != -1)) {
144 // if (wifiStation.hide) {
145 // continue; // Blacklisted.
146 // }
147 /* We know this one */
148 // wifi_config_t* config = task_wifi_ConfigSTA;
149 // memset(config, 0x00, sizeof(wifi_config_t));
150 // memcpy(config->sta.ssid, wifiStation.SSID, strlen(wifiStation.SSID));
151 // memcpy(config->sta.password, wifiStation.Password, strlen(wifiStation.Password));
152 // ESP_LOGD(TAG, "new AP %s %s", wifiStation.SSID, wifiStation.Password);
153 // xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT);
154 // break;
155 // }
156 // }
157 // break;
158 //}
159
160 /*
161 * Reconnect previous AP.
162 */
163 //if (FetchStaConfig()) {
164 // xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT);
165 //}
150 break; 166 break;
151 } 167 }
152 168
153 default: 169 default:
154 ESP_LOGW(TAG, "Unknown WiFi event %d", event_id); 170 ESP_LOGW(TAG, "Unknown WiFi event %d", event_id);
161 static void got_ip_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) 177 static void got_ip_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
162 { 178 {
163 switch (event_id) { 179 switch (event_id) {
164 180
165 case IP_EVENT_STA_GOT_IP: 181 case IP_EVENT_STA_GOT_IP:
166 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_HAS_IP); 182 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_HAS_IP);
167 ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data; 183 ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
168 if (xSemaphoreTake(xSemaphoreWiFi, 25) == pdTRUE) { 184 if (xSemaphoreTake(xSemaphoreWiFi, 25) == pdTRUE) {
169 wifi_state->STA_online = true; 185 wifi_state->STA_online = true;
170 snprintf(wifi_state->STA_ip, 16, "%s", ip4addr_ntoa(&event->ip_info.ip)); 186 snprintf(wifi_state->STA_ip, 16, "%s", ip4addr_ntoa(&event->ip_info.ip));
171 snprintf(wifi_state->STA_nm, 16, "%s", ip4addr_ntoa(&event->ip_info.netmask)); 187 snprintf(wifi_state->STA_nm, 16, "%s", ip4addr_ntoa(&event->ip_info.netmask));
172 snprintf(wifi_state->STA_gw, 16, "%s", ip4addr_ntoa(&event->ip_info.gw)); 188 snprintf(wifi_state->STA_gw, 16, "%s", ip4addr_ntoa(&event->ip_info.gw));
173 xSemaphoreGive(xSemaphoreWiFi); 189 xSemaphoreGive(xSemaphoreWiFi);
174 } else { 190 } else {
175 ESP_LOGE(TAG, "got_ip_event_handler() lock error IP_EVENT_STA_GOT_IP"); 191 ESP_LOGE(TAG, "got_ip_event_handler() lock error IP_EVENT_STA_GOT_IP");
176 } 192 }
177 break; 193 connect_mqtt(true);
194 break;
178 195
179 case IP_EVENT_STA_LOST_IP: 196 case IP_EVENT_STA_LOST_IP:
180 ESP_LOGW(TAG, "Lost IP address"); 197 ESP_LOGW(TAG, "Lost IP address");
181 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_HAS_IP); 198 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_HAS_IP);
182 if (xSemaphoreTake(xSemaphoreWiFi, 25) == pdTRUE) { 199 if (xSemaphoreTake(xSemaphoreWiFi, 25) == pdTRUE) {
183 wifi_state->STA_ip[0] = '\0'; 200 wifi_state->STA_ip[0] = '\0';
184 wifi_state->STA_nm[0] = '\0'; 201 wifi_state->STA_nm[0] = '\0';
185 wifi_state->STA_gw[0] = '\0'; 202 wifi_state->STA_gw[0] = '\0';
186 wifi_state->STA_online = false; 203 wifi_state->STA_online = false;
187 xSemaphoreGive(xSemaphoreWiFi); 204 xSemaphoreGive(xSemaphoreWiFi);
188 } else { 205 } else {
189 ESP_LOGE(TAG, "got_ip_event_handler() lock error IP_EVENT_STA_LOST_IP"); 206 ESP_LOGE(TAG, "got_ip_event_handler() lock error IP_EVENT_STA_LOST_IP");
190 } 207 }
191 break; 208 connect_mqtt(false);
209 break;
210
211 case IP_EVENT_AP_STAIPASSIGNED:
212 ESP_LOGI(TAG, "IP_EVENT_AP_STAIPASSIGNED");
213 break;
192 214
193 default: 215 default:
194 ESP_LOGW(TAG, "Unknown IP event %d", event_id); 216 ESP_LOGW(TAG, "Unknown IP event %d", event_id);
195 break; 217 break;
196 } 218 }
197 } 219 }
198 220
199 221
200 222
228 */ 250 */
229 wifi_init_config_t wifi_init_config = WIFI_INIT_CONFIG_DEFAULT(); 251 wifi_init_config_t wifi_init_config = WIFI_INIT_CONFIG_DEFAULT();
230 ESP_ERROR_CHECK(esp_wifi_init(&wifi_init_config)); 252 ESP_ERROR_CHECK(esp_wifi_init(&wifi_init_config));
231 253
232 ESP_ERROR_CHECK( esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL) ); 254 ESP_ERROR_CHECK( esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL) );
233 ESP_ERROR_CHECK( esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &got_ip_event_handler, NULL) ); 255 ESP_ERROR_CHECK( esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, &got_ip_event_handler, NULL) );
234 256
235 ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM)); 257 ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
236 ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); 258 ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
237 ESP_ERROR_CHECK(esp_wifi_start()); 259 ESP_ERROR_CHECK(esp_wifi_start());
238 260
261 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT);
239 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_STA_DISCONNECTED); 262 xEventGroupSetBits(xEventGroupWifi, TASK_WIFI_STA_DISCONNECTED);
240 EventBits_t uxBits; 263 EventBits_t uxBits;
241 264
242 for(;;) { 265 for(;;) {
243 266
244 /* actions that can trigger: request a connection, a scan, or a disconnection */ 267 /* actions that can trigger: request a connection, a scan, or a disconnection */
245 uxBits = xEventGroupWaitBits(xEventGroupWifi, 268 uxBits = xEventGroupWaitBits(xEventGroupWifi,
246 TASK_WIFI_REQUEST_STA_CONNECT | TASK_WIFI_REQUEST_WIFI_SCAN | TASK_WIFI_REQUEST_STA_DISCONNECT, 269 TASK_WIFI_REQUEST_STA_CONNECT | TASK_WIFI_REQUEST_WIFI_SCAN | TASK_WIFI_REQUEST_STA_DISCONNECT | TASK_WIFI_REQUEST_STA_STATUS,
247 pdFALSE, pdFALSE, portMAX_DELAY ); 270 pdFALSE, pdFALSE, portMAX_DELAY );
248 271
249 if (uxBits & TASK_WIFI_REQUEST_STA_DISCONNECT) { 272 if (uxBits & TASK_WIFI_REQUEST_STA_DISCONNECT) {
250 /* 273 /*
251 * user requested a disconnect, this will in effect disconnect the wifi 274 * user requested a disconnect, this will in effect disconnect the wifi
252 */ 275 */
276 connect_mqtt(false);
253 ESP_LOGD(TAG, "Request STA disconnect"); 277 ESP_LOGD(TAG, "Request STA disconnect");
254 ESP_ERROR_CHECK(esp_wifi_disconnect()); 278 ESP_ERROR_CHECK(esp_wifi_disconnect());
255 xEventGroupWaitBits(xEventGroupWifi, TASK_WIFI_STA_DISCONNECTED, pdFALSE, pdTRUE, portMAX_DELAY ); 279 xEventGroupWaitBits(xEventGroupWifi, TASK_WIFI_STA_DISCONNECTED, pdFALSE, pdTRUE, portMAX_DELAY );
256 280
257 /* finally: release the scan request bit */ 281 /* finally: release the scan request bit */
303 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT); // Only clear when connected. 327 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_CONNECT); // Only clear when connected.
304 } else { 328 } else {
305 ESP_LOGI(TAG, "No known AP found, scan again"); 329 ESP_LOGI(TAG, "No known AP found, scan again");
306 vTaskDelay(3000 / portTICK_PERIOD_MS); 330 vTaskDelay(3000 / portTICK_PERIOD_MS);
307 } 331 }
332 } else if (uxBits & TASK_WIFI_REQUEST_STA_STATUS) {
333 /*
334 * Request WiFi update status, refresh the rssi.
335 */
336 xEventGroupClearBits(xEventGroupWifi, TASK_WIFI_REQUEST_STA_STATUS);
337 wifi_ap_record_t ap_info;
338 esp_wifi_sta_get_ap_info(&ap_info);
339 ESP_LOGI(TAG, "Event STA status, ssid:%s, bssid:" MACSTR ", rssi: %d", ap_info.ssid, MAC2STR(ap_info.bssid), ap_info.rssi);
340 if (xSemaphoreTake(xSemaphoreWiFi, 35) == pdTRUE) {
341 wifi_state->STA_rssi = ap_info.rssi;
342 xSemaphoreGive(xSemaphoreWiFi);
343 } else {
344 ESP_LOGE(TAG, "lock error TASK_WIFI_REQUEST_STA_STATUS");
345 }
346 user_refresh();
308 } 347 }
309 348
310 } /* for(;;) */ 349 } /* for(;;) */
311 vTaskDelay(10 / portTICK_PERIOD_MS); 350 vTaskDelay(10 / portTICK_PERIOD_MS);
312 } 351 }

Mercurial Repository: co2meter

mercurial