Fork of the espurna firmware for `mhsw` switches
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

654 lines
18 KiB

8 years ago
7 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
6 years ago
6 years ago
  1. /*
  2. WIFI MODULE
  3. Copyright (C) 2016-2018 by Xose Pérez <xose dot perez at gmail dot com>
  4. */
  5. #include "JustWifi.h"
  6. #include <Ticker.h>
  7. uint32_t _wifi_scan_client_id = 0;
  8. bool _wifi_wps_running = false;
  9. bool _wifi_smartconfig_running = false;
  10. uint8_t _wifi_ap_mode = WIFI_AP_FALLBACK;
  11. // -----------------------------------------------------------------------------
  12. // PRIVATE
  13. // -----------------------------------------------------------------------------
  14. void _wifiCheckAP() {
  15. if ((WIFI_AP_FALLBACK == _wifi_ap_mode) &&
  16. (jw.connected()) &&
  17. ((WiFi.getMode() & WIFI_AP) > 0) &&
  18. (WiFi.softAPgetStationNum() == 0)
  19. ) {
  20. jw.enableAP(false);
  21. }
  22. }
  23. void _wifiConfigure() {
  24. jw.setHostname(getSetting("hostname").c_str());
  25. #if USE_PASSWORD
  26. jw.setSoftAP(getSetting("hostname").c_str(), getSetting("adminPass", ADMIN_PASS).c_str());
  27. #else
  28. jw.setSoftAP(getSetting("hostname").c_str());
  29. #endif
  30. jw.setConnectTimeout(WIFI_CONNECT_TIMEOUT);
  31. wifiReconnectCheck();
  32. jw.enableAPFallback(true);
  33. jw.cleanNetworks();
  34. _wifi_ap_mode = getSetting("apmode", WIFI_AP_FALLBACK).toInt();
  35. // If system is flagged unstable we do not init wifi networks
  36. #if SYSTEM_CHECK_ENABLED
  37. if (!systemCheck()) return;
  38. #endif
  39. // Clean settings
  40. _wifiClean(WIFI_MAX_NETWORKS);
  41. int i;
  42. for (i = 0; i< WIFI_MAX_NETWORKS; i++) {
  43. if (getSetting("ssid" + String(i)).length() == 0) break;
  44. if (getSetting("ip" + String(i)).length() == 0) {
  45. jw.addNetwork(
  46. getSetting("ssid" + String(i)).c_str(),
  47. getSetting("pass" + String(i)).c_str()
  48. );
  49. } else {
  50. jw.addNetwork(
  51. getSetting("ssid" + String(i)).c_str(),
  52. getSetting("pass" + String(i)).c_str(),
  53. getSetting("ip" + String(i)).c_str(),
  54. getSetting("gw" + String(i)).c_str(),
  55. getSetting("mask" + String(i)).c_str(),
  56. getSetting("dns" + String(i)).c_str()
  57. );
  58. }
  59. }
  60. jw.enableScan(getSetting("wifiScan", WIFI_SCAN_NETWORKS).toInt() == 1);
  61. }
  62. void _wifiScan(uint32_t client_id = 0) {
  63. DEBUG_MSG_P(PSTR("[WIFI] Start scanning\n"));
  64. #if WEB_SUPPORT
  65. String output;
  66. #endif
  67. unsigned char result = WiFi.scanNetworks();
  68. if (result == WIFI_SCAN_FAILED) {
  69. DEBUG_MSG_P(PSTR("[WIFI] Scan failed\n"));
  70. #if WEB_SUPPORT
  71. output = String("Failed scan");
  72. #endif
  73. } else if (result == 0) {
  74. DEBUG_MSG_P(PSTR("[WIFI] No networks found\n"));
  75. #if WEB_SUPPORT
  76. output = String("No networks found");
  77. #endif
  78. } else {
  79. DEBUG_MSG_P(PSTR("[WIFI] %d networks found:\n"), result);
  80. // Populate defined networks with scan data
  81. for (int8_t i = 0; i < result; ++i) {
  82. String ssid_scan;
  83. int32_t rssi_scan;
  84. uint8_t sec_scan;
  85. uint8_t* BSSID_scan;
  86. int32_t chan_scan;
  87. bool hidden_scan;
  88. char buffer[128];
  89. WiFi.getNetworkInfo(i, ssid_scan, sec_scan, rssi_scan, BSSID_scan, chan_scan, hidden_scan);
  90. snprintf_P(buffer, sizeof(buffer),
  91. PSTR("BSSID: %02X:%02X:%02X:%02X:%02X:%02X SEC: %s RSSI: %3d CH: %2d SSID: %s"),
  92. BSSID_scan[1], BSSID_scan[2], BSSID_scan[3], BSSID_scan[4], BSSID_scan[5], BSSID_scan[6],
  93. (sec_scan != ENC_TYPE_NONE ? "YES" : "NO "),
  94. rssi_scan,
  95. chan_scan,
  96. (char *) ssid_scan.c_str()
  97. );
  98. DEBUG_MSG_P(PSTR("[WIFI] > %s\n"), buffer);
  99. #if WEB_SUPPORT
  100. if (client_id > 0) output = output + String(buffer) + String("<br />");
  101. #endif
  102. }
  103. }
  104. #if WEB_SUPPORT
  105. if (client_id > 0) {
  106. output = String("{\"scanResult\": \"") + output + String("\"}");
  107. wsSend(client_id, output.c_str());
  108. }
  109. #endif
  110. WiFi.scanDelete();
  111. }
  112. bool _wifiClean(unsigned char num) {
  113. bool changed = false;
  114. int i = 0;
  115. // Clean defined settings
  116. while (i < num) {
  117. // Skip on first non-defined setting
  118. if (!hasSetting("ssid", i)) {
  119. delSetting("ssid", i);
  120. break;
  121. }
  122. // Delete empty values
  123. if (!hasSetting("pass", i)) delSetting("pass", i);
  124. if (!hasSetting("ip", i)) delSetting("ip", i);
  125. if (!hasSetting("gw", i)) delSetting("gw", i);
  126. if (!hasSetting("mask", i)) delSetting("mask", i);
  127. if (!hasSetting("dns", i)) delSetting("dns", i);
  128. ++i;
  129. }
  130. // Delete all other settings
  131. while (i < WIFI_MAX_NETWORKS) {
  132. changed = hasSetting("ssid", i);
  133. delSetting("ssid", i);
  134. delSetting("pass", i);
  135. delSetting("ip", i);
  136. delSetting("gw", i);
  137. delSetting("mask", i);
  138. delSetting("dns", i);
  139. ++i;
  140. }
  141. return changed;
  142. }
  143. // Inject hardcoded networks
  144. void _wifiInject() {
  145. if (strlen(WIFI1_SSID)) {
  146. if (!hasSetting("ssid", 0)) {
  147. setSetting("ssid", 0, WIFI1_SSID);
  148. setSetting("pass", 0, WIFI1_PASS);
  149. setSetting("ip", 0, WIFI1_IP);
  150. setSetting("gw", 0, WIFI1_GW);
  151. setSetting("mask", 0, WIFI1_MASK);
  152. setSetting("dns", 0, WIFI1_DNS);
  153. }
  154. if (strlen(WIFI2_SSID)) {
  155. if (!hasSetting("ssid", 1)) {
  156. setSetting("ssid", 1, WIFI2_SSID);
  157. setSetting("pass", 1, WIFI2_PASS);
  158. setSetting("ip", 1, WIFI2_IP);
  159. setSetting("gw", 1, WIFI2_GW);
  160. setSetting("mask", 1, WIFI2_MASK);
  161. setSetting("dns", 1, WIFI2_DNS);
  162. }
  163. }
  164. }
  165. }
  166. void _wifiCallback(justwifi_messages_t code, char * parameter) {
  167. if (MESSAGE_WPS_START == code) {
  168. _wifi_wps_running = true;
  169. }
  170. if (MESSAGE_SMARTCONFIG_START == code) {
  171. _wifi_smartconfig_running = true;
  172. }
  173. if (MESSAGE_WPS_ERROR == code || MESSAGE_SMARTCONFIG_ERROR == code) {
  174. _wifi_wps_running = false;
  175. _wifi_smartconfig_running = false;
  176. jw.enableAP(true);
  177. }
  178. if (MESSAGE_WPS_SUCCESS == code || MESSAGE_SMARTCONFIG_SUCCESS == code) {
  179. String ssid = WiFi.SSID();
  180. String pass = WiFi.psk();
  181. // Look for the same SSID
  182. uint8_t count = 0;
  183. while (count < WIFI_MAX_NETWORKS) {
  184. if (!hasSetting("ssid", count)) break;
  185. if (ssid.equals(getSetting("ssid", count, ""))) break;
  186. count++;
  187. }
  188. // If we have reached the max we overwrite the first one
  189. if (WIFI_MAX_NETWORKS == count) count = 0;
  190. setSetting("ssid", count, ssid);
  191. setSetting("pass", count, pass);
  192. _wifi_wps_running = false;
  193. _wifi_smartconfig_running = false;
  194. jw.enableAP(true);
  195. }
  196. }
  197. #if WIFI_AP_CAPTIVE
  198. #include "DNSServer.h"
  199. DNSServer _wifi_dnsServer;
  200. void _wifiCaptivePortal(justwifi_messages_t code, char * parameter) {
  201. if (MESSAGE_ACCESSPOINT_CREATED == code) {
  202. _wifi_dnsServer.setErrorReplyCode(DNSReplyCode::NoError);
  203. _wifi_dnsServer.start(53, "*", WiFi.softAPIP());
  204. DEBUG_MSG_P(PSTR("[WIFI] Captive portal enabled\n"));
  205. }
  206. if (MESSAGE_CONNECTED == code) {
  207. _wifi_dnsServer.stop();
  208. DEBUG_MSG_P(PSTR("[WIFI] Captive portal disabled\n"));
  209. }
  210. }
  211. #endif // WIFI_AP_CAPTIVE
  212. #if DEBUG_SUPPORT
  213. void _wifiDebugCallback(justwifi_messages_t code, char * parameter) {
  214. // -------------------------------------------------------------------------
  215. if (code == MESSAGE_SCANNING) {
  216. DEBUG_MSG_P(PSTR("[WIFI] Scanning\n"));
  217. }
  218. if (code == MESSAGE_SCAN_FAILED) {
  219. DEBUG_MSG_P(PSTR("[WIFI] Scan failed\n"));
  220. }
  221. if (code == MESSAGE_NO_NETWORKS) {
  222. DEBUG_MSG_P(PSTR("[WIFI] No networks found\n"));
  223. }
  224. if (code == MESSAGE_NO_KNOWN_NETWORKS) {
  225. DEBUG_MSG_P(PSTR("[WIFI] No known networks found\n"));
  226. }
  227. if (code == MESSAGE_FOUND_NETWORK) {
  228. DEBUG_MSG_P(PSTR("[WIFI] %s\n"), parameter);
  229. }
  230. // -------------------------------------------------------------------------
  231. if (code == MESSAGE_CONNECTING) {
  232. DEBUG_MSG_P(PSTR("[WIFI] Connecting to %s\n"), parameter);
  233. }
  234. if (code == MESSAGE_CONNECT_WAITING) {
  235. // too much noise
  236. }
  237. if (code == MESSAGE_CONNECT_FAILED) {
  238. DEBUG_MSG_P(PSTR("[WIFI] Could not connect to %s\n"), parameter);
  239. }
  240. if (code == MESSAGE_CONNECTED) {
  241. wifiDebug(WIFI_STA);
  242. }
  243. if (code == MESSAGE_DISCONNECTED) {
  244. DEBUG_MSG_P(PSTR("[WIFI] Disconnected\n"));
  245. }
  246. // -------------------------------------------------------------------------
  247. if (code == MESSAGE_ACCESSPOINT_CREATING) {
  248. DEBUG_MSG_P(PSTR("[WIFI] Creating access point\n"));
  249. }
  250. if (code == MESSAGE_ACCESSPOINT_CREATED) {
  251. wifiDebug(WIFI_AP);
  252. }
  253. if (code == MESSAGE_ACCESSPOINT_FAILED) {
  254. DEBUG_MSG_P(PSTR("[WIFI] Could not create access point\n"));
  255. }
  256. if (code == MESSAGE_ACCESSPOINT_DESTROYED) {
  257. DEBUG_MSG_P(PSTR("[WIFI] Access point destroyed\n"));
  258. }
  259. // -------------------------------------------------------------------------
  260. if (code == MESSAGE_WPS_START) {
  261. DEBUG_MSG_P(PSTR("[WIFI] WPS started\n"));
  262. }
  263. if (code == MESSAGE_WPS_SUCCESS) {
  264. DEBUG_MSG_P(PSTR("[WIFI] WPS succeded!\n"));
  265. }
  266. if (code == MESSAGE_WPS_ERROR) {
  267. DEBUG_MSG_P(PSTR("[WIFI] WPS failed\n"));
  268. }
  269. // ------------------------------------------------------------------------
  270. if (code == MESSAGE_SMARTCONFIG_START) {
  271. DEBUG_MSG_P(PSTR("[WIFI] Smart Config started\n"));
  272. }
  273. if (code == MESSAGE_SMARTCONFIG_SUCCESS) {
  274. DEBUG_MSG_P(PSTR("[WIFI] Smart Config succeded!\n"));
  275. }
  276. if (code == MESSAGE_SMARTCONFIG_ERROR) {
  277. DEBUG_MSG_P(PSTR("[WIFI] Smart Config failed\n"));
  278. }
  279. }
  280. #endif // DEBUG_SUPPORT
  281. // -----------------------------------------------------------------------------
  282. // SETTINGS
  283. // -----------------------------------------------------------------------------
  284. #if TERMINAL_SUPPORT
  285. void _wifiInitCommands() {
  286. settingsRegisterCommand(F("WIFI.RESET"), [](Embedis* e) {
  287. _wifiConfigure();
  288. wifiDisconnect();
  289. DEBUG_MSG_P(PSTR("+OK\n"));
  290. });
  291. settingsRegisterCommand(F("WIFI.AP"), [](Embedis* e) {
  292. wifiStartAP();
  293. DEBUG_MSG_P(PSTR("+OK\n"));
  294. });
  295. #if defined(JUSTWIFI_ENABLE_WPS)
  296. settingsRegisterCommand(F("WIFI.WPS"), [](Embedis* e) {
  297. wifiStartWPS();
  298. DEBUG_MSG_P(PSTR("+OK\n"));
  299. });
  300. #endif // defined(JUSTWIFI_ENABLE_WPS)
  301. #if defined(JUSTWIFI_ENABLE_SMARTCONFIG)
  302. settingsRegisterCommand(F("WIFI.SMARTCONFIG"), [](Embedis* e) {
  303. wifiStartSmartConfig();
  304. DEBUG_MSG_P(PSTR("+OK\n"));
  305. });
  306. #endif // defined(JUSTWIFI_ENABLE_SMARTCONFIG)
  307. settingsRegisterCommand(F("WIFI.SCAN"), [](Embedis* e) {
  308. _wifiScan();
  309. DEBUG_MSG_P(PSTR("+OK\n"));
  310. });
  311. }
  312. #endif
  313. // -----------------------------------------------------------------------------
  314. // WEB
  315. // -----------------------------------------------------------------------------
  316. #if WEB_SUPPORT
  317. bool _wifiWebSocketOnReceive(const char * key, JsonVariant& value) {
  318. if (strncmp(key, "wifi", 4) == 0) return true;
  319. if (strncmp(key, "ssid", 4) == 0) return true;
  320. if (strncmp(key, "pass", 4) == 0) return true;
  321. if (strncmp(key, "ip", 2) == 0) return true;
  322. if (strncmp(key, "gw", 2) == 0) return true;
  323. if (strncmp(key, "mask", 4) == 0) return true;
  324. if (strncmp(key, "dns", 3) == 0) return true;
  325. return false;
  326. }
  327. void _wifiWebSocketOnSend(JsonObject& root) {
  328. root["maxNetworks"] = WIFI_MAX_NETWORKS;
  329. root["wifiScan"] = getSetting("wifiScan", WIFI_SCAN_NETWORKS).toInt() == 1;
  330. JsonArray& wifi = root.createNestedArray("wifi");
  331. for (byte i=0; i<WIFI_MAX_NETWORKS; i++) {
  332. if (!hasSetting("ssid", i)) break;
  333. JsonObject& network = wifi.createNestedObject();
  334. network["ssid"] = getSetting("ssid", i, "");
  335. network["pass"] = getSetting("pass", i, "");
  336. network["ip"] = getSetting("ip", i, "");
  337. network["gw"] = getSetting("gw", i, "");
  338. network["mask"] = getSetting("mask", i, "");
  339. network["dns"] = getSetting("dns", i, "");
  340. }
  341. }
  342. void _wifiWebSocketOnAction(uint32_t client_id, const char * action, JsonObject& data) {
  343. if (strcmp(action, "scan") == 0) _wifi_scan_client_id = client_id;
  344. }
  345. #endif
  346. // -----------------------------------------------------------------------------
  347. // INFO
  348. // -----------------------------------------------------------------------------
  349. void wifiDebug(WiFiMode_t modes) {
  350. bool footer = false;
  351. if (((modes & WIFI_STA) > 0) && ((WiFi.getMode() & WIFI_STA) > 0)) {
  352. uint8_t * bssid = WiFi.BSSID();
  353. DEBUG_MSG_P(PSTR("[WIFI] ------------------------------------- MODE STA\n"));
  354. DEBUG_MSG_P(PSTR("[WIFI] SSID %s\n"), WiFi.SSID().c_str());
  355. DEBUG_MSG_P(PSTR("[WIFI] IP %s\n"), WiFi.localIP().toString().c_str());
  356. DEBUG_MSG_P(PSTR("[WIFI] MAC %s\n"), WiFi.macAddress().c_str());
  357. DEBUG_MSG_P(PSTR("[WIFI] GW %s\n"), WiFi.gatewayIP().toString().c_str());
  358. DEBUG_MSG_P(PSTR("[WIFI] DNS %s\n"), WiFi.dnsIP().toString().c_str());
  359. DEBUG_MSG_P(PSTR("[WIFI] MASK %s\n"), WiFi.subnetMask().toString().c_str());
  360. DEBUG_MSG_P(PSTR("[WIFI] HOST http://%s.local\n"), WiFi.hostname().c_str());
  361. DEBUG_MSG_P(PSTR("[WIFI] BSSID %02X:%02X:%02X:%02X:%02X:%02X\n"),
  362. bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5], bssid[6]
  363. );
  364. DEBUG_MSG_P(PSTR("[WIFI] CH %d\n"), WiFi.channel());
  365. DEBUG_MSG_P(PSTR("[WIFI] RSSI %d\n"), WiFi.RSSI());
  366. footer = true;
  367. }
  368. if (((modes & WIFI_AP) > 0) && ((WiFi.getMode() & WIFI_AP) > 0)) {
  369. DEBUG_MSG_P(PSTR("[WIFI] -------------------------------------- MODE AP\n"));
  370. DEBUG_MSG_P(PSTR("[WIFI] SSID %s\n"), getSetting("hostname").c_str());
  371. DEBUG_MSG_P(PSTR("[WIFI] PASS %s\n"), getSetting("adminPass", ADMIN_PASS).c_str());
  372. DEBUG_MSG_P(PSTR("[WIFI] IP %s\n"), WiFi.softAPIP().toString().c_str());
  373. DEBUG_MSG_P(PSTR("[WIFI] MAC %s\n"), WiFi.softAPmacAddress().c_str());
  374. footer = true;
  375. }
  376. if (WiFi.getMode() == 0) {
  377. DEBUG_MSG_P(PSTR("[WIFI] ------------------------------------- MODE OFF\n"));
  378. DEBUG_MSG_P(PSTR("[WIFI] No connection\n"));
  379. footer = true;
  380. }
  381. if (footer) {
  382. DEBUG_MSG_P(PSTR("[WIFI] ----------------------------------------------\n"));
  383. }
  384. }
  385. void wifiDebug() {
  386. wifiDebug(WIFI_AP_STA);
  387. }
  388. // -----------------------------------------------------------------------------
  389. // API
  390. // -----------------------------------------------------------------------------
  391. String getIP() {
  392. if (WiFi.getMode() == WIFI_AP) {
  393. return WiFi.softAPIP().toString();
  394. }
  395. return WiFi.localIP().toString();
  396. }
  397. String getNetwork() {
  398. if (WiFi.getMode() == WIFI_AP) {
  399. return jw.getAPSSID();
  400. }
  401. return WiFi.SSID();
  402. }
  403. bool wifiConnected() {
  404. return jw.connected();
  405. }
  406. void wifiDisconnect() {
  407. jw.disconnect();
  408. }
  409. void wifiStartAP(bool only) {
  410. if (only) {
  411. jw.enableSTA(false);
  412. jw.disconnect();
  413. jw.resetReconnectTimeout();
  414. }
  415. jw.enableAP(true);
  416. }
  417. void wifiStartAP() {
  418. wifiStartAP(true);
  419. }
  420. #if defined(JUSTWIFI_ENABLE_WPS)
  421. void wifiStartWPS() {
  422. jw.enableAP(false);
  423. jw.disconnect();
  424. jw.startWPS();
  425. }
  426. #endif // defined(JUSTWIFI_ENABLE_WPS)
  427. #if defined(JUSTWIFI_ENABLE_SMARTCONFIG)
  428. void wifiStartSmartConfig() {
  429. jw.enableAP(false);
  430. jw.disconnect();
  431. jw.startSmartConfig();
  432. }
  433. #endif // defined(JUSTWIFI_ENABLE_SMARTCONFIG)
  434. void wifiReconnectCheck() {
  435. bool connected = false;
  436. #if WEB_SUPPORT
  437. if (wsConnected()) connected = true;
  438. #endif
  439. #if TELNET_SUPPORT
  440. if (telnetConnected()) connected = true;
  441. #endif
  442. jw.setReconnectTimeout(connected ? 0 : WIFI_RECONNECT_INTERVAL);
  443. }
  444. uint8_t wifiState() {
  445. uint8_t state = 0;
  446. if (jw.connected()) state += WIFI_STATE_STA;
  447. if (jw.connectable()) state += WIFI_STATE_AP;
  448. if (_wifi_wps_running) state += WIFI_STATE_WPS;
  449. if (_wifi_smartconfig_running) state += WIFI_STATE_SMARTCONFIG;
  450. return state;
  451. }
  452. void wifiRegister(wifi_callback_f callback) {
  453. jw.subscribe(callback);
  454. }
  455. // -----------------------------------------------------------------------------
  456. // INITIALIZATION
  457. // -----------------------------------------------------------------------------
  458. void wifiSetup() {
  459. WiFi.setSleepMode(WIFI_SLEEP_MODE);
  460. _wifiInject();
  461. _wifiConfigure();
  462. // Message callbacks
  463. wifiRegister(_wifiCallback);
  464. #if WIFI_AP_CAPTIVE
  465. wifiRegister(_wifiCaptivePortal);
  466. #endif
  467. #if DEBUG_SUPPORT
  468. wifiRegister(_wifiDebugCallback);
  469. #endif
  470. #if WEB_SUPPORT
  471. wsOnSendRegister(_wifiWebSocketOnSend);
  472. wsOnReceiveRegister(_wifiWebSocketOnReceive);
  473. wsOnActionRegister(_wifiWebSocketOnAction);
  474. #endif
  475. #if TERMINAL_SUPPORT
  476. _wifiInitCommands();
  477. #endif
  478. // Main callbacks
  479. espurnaRegisterLoop(wifiLoop);
  480. espurnaRegisterReload(_wifiConfigure);
  481. }
  482. void wifiLoop() {
  483. // Main wifi loop
  484. jw.loop();
  485. // Process captrive portal DNS queries if in AP mode only
  486. #if WIFI_AP_CAPTIVE
  487. if ((WiFi.getMode() & WIFI_AP) == WIFI_AP) {
  488. _wifi_dnsServer.processNextRequest();
  489. }
  490. #endif
  491. // Do we have a pending scan?
  492. if (_wifi_scan_client_id > 0) {
  493. _wifiScan(_wifi_scan_client_id);
  494. _wifi_scan_client_id = 0;
  495. }
  496. // Check if we should disable AP
  497. static unsigned long last = 0;
  498. if (millis() - last > 60000) {
  499. last = millis();
  500. _wifiCheckAP();
  501. }
  502. }