arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-04-19 23:22:16 +03:00
Code

code style

Browse Source
This commit is contained in:
Markus Sattler 2015-12-28 16:36:55 +01:00
parent 4b90db41fe
commit 09a7940006
2 changed files with 511 additions and 608 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

359
libraries/ESP8266WiFi/src/ESP8266WiFi.cpp
View File

@ -17,7 +17,7 @@
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "ESP8266WiFi.h" #include "ESP8266WiFi.h"
@ -41,27 +41,20 @@ extern "C" {
extern "C" void esp_schedule(); extern "C" void esp_schedule();
extern "C" void esp_yield(); extern "C" void esp_yield();
ESP8266WiFiClass::ESP8266WiFiClass() ESP8266WiFiClass::ESP8266WiFiClass() :
: _smartConfigStarted(false) _smartConfigStarted(false), _smartConfigDone(false), _useStaticIp(false), _persistent(true) {
, _smartConfigDone(false)
, _useStaticIp(false)
, _persistent(true)
{
uint8 m = wifi_get_opmode(); uint8 m = wifi_get_opmode();
_useClientMode = (m & WIFI_STA); _useClientMode = (m & WIFI_STA);
_useApMode = (m & WIFI_AP); _useApMode = (m & WIFI_AP);
wifi_set_event_handler_cb((wifi_event_handler_cb_t)&ESP8266WiFiClass::_eventCallback); wifi_set_event_handler_cb((wifi_event_handler_cb_t) &ESP8266WiFiClass::_eventCallback);
} }
void ESP8266WiFiClass::persistent(bool persistent) void ESP8266WiFiClass::persistent(bool persistent) {
{
_persistent = persistent; _persistent = persistent;
} }
void ESP8266WiFiClass::mode(WiFiMode m) {
void ESP8266WiFiClass::mode(WiFiMode m) if(wifi_get_opmode() == (uint8) m) {
{
if(wifi_get_opmode() == (uint8)m) {
return; return;
} }
@ -80,19 +73,17 @@ void ESP8266WiFiClass::mode(WiFiMode m)
_mode(m); _mode(m);
} }
WiFiMode ESP8266WiFiClass::getMode() WiFiMode ESP8266WiFiClass::getMode() {
{ return (WiFiMode) wifi_get_opmode();
return (WiFiMode)wifi_get_opmode();
} }
void ESP8266WiFiClass::_mode(WiFiMode m) void ESP8266WiFiClass::_mode(WiFiMode m) {
{ if(wifi_get_opmode() == (uint8) m) {
if(wifi_get_opmode() == (uint8)m) {
return; return;
} }
ETS_UART_INTR_DISABLE(); ETS_UART_INTR_DISABLE();
if (_persistent) if(_persistent)
wifi_set_opmode(m); wifi_set_opmode(m);
else else
wifi_set_opmode_current(m); wifi_set_opmode_current(m);
@ -100,36 +91,32 @@ void ESP8266WiFiClass::_mode(WiFiMode m)
} }
static bool sta_config_equal(const station_config& lhs, const station_config& rhs) static bool sta_config_equal(const station_config& lhs, const station_config& rhs) {
{ if(strcmp(reinterpret_cast<const char*>(lhs.ssid), reinterpret_cast<const char*>(rhs.ssid)) != 0)
if (strcmp(reinterpret_cast<const char*>(lhs.ssid), reinterpret_cast<const char*>(rhs.ssid)) != 0)
return false; return false;
if (strcmp(reinterpret_cast<const char*>(lhs.password), reinterpret_cast<const char*>(rhs.password)) != 0) if(strcmp(reinterpret_cast<const char*>(lhs.password), reinterpret_cast<const char*>(rhs.password)) != 0)
return false; return false;
if (lhs.bssid_set) { if(lhs.bssid_set) {
if (!rhs.bssid_set) if(!rhs.bssid_set)
return false; return false;
if (memcmp(lhs.bssid, rhs.bssid, 6) != 0) if(memcmp(lhs.bssid, rhs.bssid, 6) != 0)
return false; return false;
} } else {
else { if(rhs.bssid_set)
if (rhs.bssid_set)
return false; return false;
} }
return true; return true;
} }
int ESP8266WiFiClass::begin(char* ssid, char *passphrase, int32_t channel, const uint8_t* bssid) int ESP8266WiFiClass::begin(char* ssid, char *passphrase, int32_t channel, const uint8_t* bssid) {
{
return begin((const char*) ssid, (const char*) passphrase, channel, bssid); return begin((const char*) ssid, (const char*) passphrase, channel, bssid);
} }
int ESP8266WiFiClass::begin(const char* ssid, const char *passphrase, int32_t channel, const uint8_t* bssid) int ESP8266WiFiClass::begin(const char* ssid, const char *passphrase, int32_t channel, const uint8_t* bssid) {
{
_useClientMode = true; _useClientMode = true;
if(_useApMode) { if(_useApMode) {
@ -153,13 +140,13 @@ int ESP8266WiFiClass::begin(const char* ssid, const char *passphrase, int32_t ch
struct station_config conf; struct station_config conf;
strcpy(reinterpret_cast<char*>(conf.ssid), ssid); strcpy(reinterpret_cast<char*>(conf.ssid), ssid);
if (passphrase) { if(passphrase) {
strcpy(reinterpret_cast<char*>(conf.password), passphrase); strcpy(reinterpret_cast<char*>(conf.password), passphrase);
} else { } else {
*conf.password = 0; *conf.password = 0;
} }
if (bssid) { if(bssid) {
conf.bssid_set = 1; conf.bssid_set = 1;
memcpy((void *) &conf.bssid[0], (void *) bssid, 6); memcpy((void *) &conf.bssid[0], (void *) bssid, 6);
} else { } else {
@ -168,13 +155,13 @@ int ESP8266WiFiClass::begin(const char* ssid, const char *passphrase, int32_t ch
struct station_config current_conf; struct station_config current_conf;
wifi_station_get_config(&current_conf); wifi_station_get_config(&current_conf);
if (sta_config_equal(current_conf, conf)) { if(sta_config_equal(current_conf, conf)) {
DEBUGV("sta config unchanged"); DEBUGV("sta config unchanged");
return status(); return status();
} }
ETS_UART_INTR_DISABLE(); ETS_UART_INTR_DISABLE();
if (_persistent) if(_persistent)
wifi_station_set_config(&conf); wifi_station_set_config(&conf);
else else
wifi_station_set_config_current(&conf); wifi_station_set_config_current(&conf);
@ -190,8 +177,7 @@ int ESP8266WiFiClass::begin(const char* ssid, const char *passphrase, int32_t ch
return status(); return status();
} }
int ESP8266WiFiClass::begin() int ESP8266WiFiClass::begin() {
{
ETS_UART_INTR_DISABLE(); ETS_UART_INTR_DISABLE();
wifi_station_connect(); wifi_station_connect();
ETS_UART_INTR_ENABLE(); ETS_UART_INTR_ENABLE();
@ -201,18 +187,16 @@ int ESP8266WiFiClass::begin()
return status(); return status();
} }
uint8_t ESP8266WiFiClass::waitForConnectResult(){ uint8_t ESP8266WiFiClass::waitForConnectResult() {
if ((wifi_get_opmode() & 1) == 0)//1 and 3 have STA enabled if((wifi_get_opmode() & 1) == 0) //1 and 3 have STA enabled
return WL_DISCONNECTED; return WL_DISCONNECTED;
while (status() == WL_DISCONNECTED) while(status() == WL_DISCONNECTED)
delay(100); delay(100);
return status(); return status();
} }
// You will have to set the DNS-Server manually later since this will not enable DHCP2 // You will have to set the DNS-Server manually later since this will not enable DHCP2
void ESP8266WiFiClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subnet) void ESP8266WiFiClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subnet) {
{
struct ip_info info; struct ip_info info;
info.ip.addr = static_cast<uint32_t>(local_ip); info.ip.addr = static_cast<uint32_t>(local_ip);
info.gw.addr = static_cast<uint32_t>(gateway); info.gw.addr = static_cast<uint32_t>(gateway);
@ -224,8 +208,7 @@ void ESP8266WiFiClass::config(IPAddress local_ip, IPAddress gateway, IPAddress s
_useStaticIp = true; _useStaticIp = true;
} }
void ESP8266WiFiClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns) void ESP8266WiFiClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns) {
{
struct ip_info info; struct ip_info info;
info.ip.addr = static_cast<uint32_t>(local_ip); info.ip.addr = static_cast<uint32_t>(local_ip);
info.gw.addr = static_cast<uint32_t>(gateway); info.gw.addr = static_cast<uint32_t>(gateway);
@ -237,18 +220,17 @@ void ESP8266WiFiClass::config(IPAddress local_ip, IPAddress gateway, IPAddress s
// Set DNS-Server // Set DNS-Server
ip_addr_t d; ip_addr_t d;
d.addr = static_cast<uint32_t>(dns); d.addr = static_cast<uint32_t>(dns);
dns_setserver(0,&d); dns_setserver(0, &d);
_useStaticIp = true; _useStaticIp = true;
} }
int ESP8266WiFiClass::softAPdisconnect(bool wifioff) int ESP8266WiFiClass::softAPdisconnect(bool wifioff) {
{
struct softap_config conf; struct softap_config conf;
*conf.ssid = 0; *conf.ssid = 0;
*conf.password = 0; *conf.password = 0;
ETS_UART_INTR_DISABLE(); ETS_UART_INTR_DISABLE();
if (_persistent) if(_persistent)
wifi_softap_set_config(&conf); wifi_softap_set_config(&conf);
else else
wifi_softap_set_config_current(&conf); wifi_softap_set_config_current(&conf);
@ -257,7 +239,7 @@ int ESP8266WiFiClass::softAPdisconnect(bool wifioff)
if(wifioff) { if(wifioff) {
_useApMode = false; _useApMode = false;
if( _useClientMode) { if(_useClientMode) {
// turn on STA // turn on STA
_mode(WIFI_STA); _mode(WIFI_STA);
} else { } else {
@ -269,13 +251,12 @@ int ESP8266WiFiClass::softAPdisconnect(bool wifioff)
return 0; return 0;
} }
int ESP8266WiFiClass::disconnect(bool wifioff) int ESP8266WiFiClass::disconnect(bool wifioff) {
{
struct station_config conf; struct station_config conf;
*conf.ssid = 0; *conf.ssid = 0;
*conf.password = 0; *conf.password = 0;
ETS_UART_INTR_DISABLE(); ETS_UART_INTR_DISABLE();
if (_persistent) if(_persistent)
wifi_station_set_config(&conf); wifi_station_set_config(&conf);
else else
wifi_station_set_config_current(&conf); wifi_station_set_config_current(&conf);
@ -297,28 +278,23 @@ int ESP8266WiFiClass::disconnect(bool wifioff)
return 0; return 0;
} }
static bool softap_config_equal(const softap_config& lhs, const softap_config& rhs) static bool softap_config_equal(const softap_config& lhs, const softap_config& rhs) {
{ if(strcmp(reinterpret_cast<const char*>(lhs.ssid), reinterpret_cast<const char*>(rhs.ssid)) != 0)
if (strcmp(reinterpret_cast<const char*>(lhs.ssid), reinterpret_cast<const char*>(rhs.ssid)) != 0)
return false; return false;
if (strcmp(reinterpret_cast<const char*>(lhs.password), reinterpret_cast<const char*>(rhs.password)) != 0) if(strcmp(reinterpret_cast<const char*>(lhs.password), reinterpret_cast<const char*>(rhs.password)) != 0)
return false; return false;
if (lhs.channel != rhs.channel) if(lhs.channel != rhs.channel)
return false; return false;
if (lhs.ssid_hidden != rhs.ssid_hidden) if(lhs.ssid_hidden != rhs.ssid_hidden)
return false; return false;
return true; return true;
} }
void ESP8266WiFiClass::softAP(const char* ssid) {
void ESP8266WiFiClass::softAP(const char* ssid)
{
softAP(ssid, 0); softAP(ssid, 0);
} }
void ESP8266WiFiClass::softAP(const char* ssid, const char* passphrase, int channel, int ssid_hidden) {
void ESP8266WiFiClass::softAP(const char* ssid, const char* passphrase, int channel, int ssid_hidden)
{
_useApMode = true; _useApMode = true;
if(_useClientMode) { if(_useClientMode) {
// turn on AP+STA mode // turn on AP+STA mode
@ -347,35 +323,30 @@ void ESP8266WiFiClass::softAP(const char* ssid, const char* passphrase, int chan
conf.max_connection = 4; conf.max_connection = 4;
conf.beacon_interval = 100; conf.beacon_interval = 100;
if (!passphrase || strlen(passphrase) == 0) if(!passphrase || strlen(passphrase) == 0) {
{
conf.authmode = AUTH_OPEN; conf.authmode = AUTH_OPEN;
*conf.password = 0; *conf.password = 0;
} } else {
else
{
conf.authmode = AUTH_WPA2_PSK; conf.authmode = AUTH_WPA2_PSK;
strcpy(reinterpret_cast<char*>(conf.password), passphrase); strcpy(reinterpret_cast<char*>(conf.password), passphrase);
} }
struct softap_config conf_current; struct softap_config conf_current;
wifi_softap_get_config(&conf_current); wifi_softap_get_config(&conf_current);
if (softap_config_equal(conf, conf_current)) if(softap_config_equal(conf, conf_current)) {
{
DEBUGV("softap config unchanged"); DEBUGV("softap config unchanged");
return; return;
} }
ETS_UART_INTR_DISABLE(); ETS_UART_INTR_DISABLE();
if (_persistent) if(_persistent)
wifi_softap_set_config(&conf); wifi_softap_set_config(&conf);
else else
wifi_softap_set_config_current(&conf); wifi_softap_set_config_current(&conf);
ETS_UART_INTR_ENABLE(); ETS_UART_INTR_ENABLE();
} }
void ESP8266WiFiClass::softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet) void ESP8266WiFiClass::softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet) {
{
struct ip_info info; struct ip_info info;
info.ip.addr = static_cast<uint32_t>(local_ip); info.ip.addr = static_cast<uint32_t>(local_ip);
info.gw.addr = static_cast<uint32_t>(gateway); info.gw.addr = static_cast<uint32_t>(gateway);
@ -385,142 +356,120 @@ void ESP8266WiFiClass::softAPConfig(IPAddress local_ip, IPAddress gateway, IPAdd
wifi_softap_dhcps_start(); wifi_softap_dhcps_start();
} }
uint8_t* ESP8266WiFiClass::macAddress(uint8_t* mac) uint8_t* ESP8266WiFiClass::macAddress(uint8_t* mac) {
{
wifi_get_macaddr(STATION_IF, mac); wifi_get_macaddr(STATION_IF, mac);
return mac; return mac;
} }
String ESP8266WiFiClass::macAddress(void) String ESP8266WiFiClass::macAddress(void) {
{
uint8_t mac[6]; uint8_t mac[6];
char macStr[18] = {0}; char macStr[18] = { 0 };
wifi_get_macaddr(STATION_IF, mac); wifi_get_macaddr(STATION_IF, mac);
sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
return String(macStr); return String(macStr);
} }
uint8_t* ESP8266WiFiClass::softAPmacAddress(uint8_t* mac) uint8_t* ESP8266WiFiClass::softAPmacAddress(uint8_t* mac) {
{
wifi_get_macaddr(SOFTAP_IF, mac); wifi_get_macaddr(SOFTAP_IF, mac);
return mac; return mac;
} }
String ESP8266WiFiClass::softAPmacAddress(void) String ESP8266WiFiClass::softAPmacAddress(void) {
{
uint8_t mac[6]; uint8_t mac[6];
char macStr[18] = {0}; char macStr[18] = { 0 };
wifi_get_macaddr(SOFTAP_IF, mac); wifi_get_macaddr(SOFTAP_IF, mac);
sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
return String(macStr); return String(macStr);
} }
IPAddress ESP8266WiFiClass::localIP() IPAddress ESP8266WiFiClass::localIP() {
{
struct ip_info ip; struct ip_info ip;
wifi_get_ip_info(STATION_IF, &ip); wifi_get_ip_info(STATION_IF, &ip);
return IPAddress(ip.ip.addr); return IPAddress(ip.ip.addr);
} }
IPAddress ESP8266WiFiClass::softAPIP() IPAddress ESP8266WiFiClass::softAPIP() {
{
struct ip_info ip; struct ip_info ip;
wifi_get_ip_info(SOFTAP_IF, &ip); wifi_get_ip_info(SOFTAP_IF, &ip);
return IPAddress(ip.ip.addr); return IPAddress(ip.ip.addr);
} }
IPAddress ESP8266WiFiClass::subnetMask() IPAddress ESP8266WiFiClass::subnetMask() {
{
struct ip_info ip; struct ip_info ip;
wifi_get_ip_info(STATION_IF, &ip); wifi_get_ip_info(STATION_IF, &ip);
return IPAddress(ip.netmask.addr); return IPAddress(ip.netmask.addr);
} }
IPAddress ESP8266WiFiClass::gatewayIP() IPAddress ESP8266WiFiClass::gatewayIP() {
{
struct ip_info ip; struct ip_info ip;
wifi_get_ip_info(STATION_IF, &ip); wifi_get_ip_info(STATION_IF, &ip);
return IPAddress(ip.gw.addr); return IPAddress(ip.gw.addr);
} }
IPAddress ESP8266WiFiClass::dnsIP(int dns_no) IPAddress ESP8266WiFiClass::dnsIP(int dns_no) {
{
ip_addr_t dns_ip = dns_getserver(dns_no); ip_addr_t dns_ip = dns_getserver(dns_no);
return IPAddress(dns_ip.addr); return IPAddress(dns_ip.addr);
} }
String ESP8266WiFiClass::SSID() const String ESP8266WiFiClass::SSID() const {
{
static struct station_config conf; static struct station_config conf;
wifi_station_get_config(&conf); wifi_station_get_config(&conf);
return String(reinterpret_cast<char*>(conf.ssid)); return String(reinterpret_cast<char*>(conf.ssid));
} }
String ESP8266WiFiClass::psk() const String ESP8266WiFiClass::psk() const {
{
static struct station_config conf; static struct station_config conf;
wifi_station_get_config(&conf); wifi_station_get_config(&conf);
return String(reinterpret_cast<char*>(conf.password)); return String(reinterpret_cast<char*>(conf.password));
} }
uint8_t* ESP8266WiFiClass::BSSID(void) uint8_t* ESP8266WiFiClass::BSSID(void) {
{
static struct station_config conf; static struct station_config conf;
wifi_station_get_config(&conf); wifi_station_get_config(&conf);
return reinterpret_cast<uint8_t*>(conf.bssid); return reinterpret_cast<uint8_t*>(conf.bssid);
} }
String ESP8266WiFiClass::BSSIDstr(void) String ESP8266WiFiClass::BSSIDstr(void) {
{
static struct station_config conf; static struct station_config conf;
char mac[18] = {0}; char mac[18] = { 0 };
wifi_station_get_config(&conf); wifi_station_get_config(&conf);
sprintf(mac,"%02X:%02X:%02X:%02X:%02X:%02X", conf.bssid[0], conf.bssid[1], conf.bssid[2], conf.bssid[3], conf.bssid[4], conf.bssid[5]); sprintf(mac, "%02X:%02X:%02X:%02X:%02X:%02X", conf.bssid[0], conf.bssid[1], conf.bssid[2], conf.bssid[3], conf.bssid[4], conf.bssid[5]);
return String(mac); return String(mac);
} }
int32_t ESP8266WiFiClass::channel(void) { int32_t ESP8266WiFiClass::channel(void) {
return wifi_get_channel(); return wifi_get_channel();
} }
int32_t ESP8266WiFiClass::RSSI(void) { int32_t ESP8266WiFiClass::RSSI(void) {
return wifi_station_get_rssi(); return wifi_station_get_rssi();
} }
extern "C" extern "C" {
{ typedef STAILQ_HEAD(, bss_info)
typedef STAILQ_HEAD(, bss_info) bss_info_head_t; bss_info_head_t;
} }
void ESP8266WiFiClass::_scanDone(void* result, int status) void ESP8266WiFiClass::_scanDone(void* result, int status) {
{ if(status != OK) {
if (status != OK)
{
ESP8266WiFiClass::_scanCount = 0; ESP8266WiFiClass::_scanCount = 0;
ESP8266WiFiClass::_scanResult = 0; ESP8266WiFiClass::_scanResult = 0;
} } else {
else
{
int i = 0; int i = 0;
bss_info_head_t* head = reinterpret_cast<bss_info_head_t*>(result); bss_info_head_t* head = reinterpret_cast<bss_info_head_t*>(result);
for (bss_info* it = STAILQ_FIRST(head); it; it = STAILQ_NEXT(it, next), ++i); for(bss_info* it = STAILQ_FIRST(head); it; it = STAILQ_NEXT(it, next), ++i)
;
ESP8266WiFiClass::_scanCount = i; ESP8266WiFiClass::_scanCount = i;
if (i == 0) if(i == 0) {
{
ESP8266WiFiClass::_scanResult = 0; ESP8266WiFiClass::_scanResult = 0;
} } else {
else
{
bss_info* copied_info = new bss_info[i]; bss_info* copied_info = new bss_info[i];
i = 0; i = 0;
for (bss_info* it = STAILQ_FIRST(head); it; it = STAILQ_NEXT(it, next), ++i) for(bss_info* it = STAILQ_FIRST(head); it; it = STAILQ_NEXT(it, next), ++i) {
{
memcpy(copied_info + i, it, sizeof(bss_info)); memcpy(copied_info + i, it, sizeof(bss_info));
} }
@ -550,10 +499,8 @@ int8_t ESP8266WiFiClass::scanComplete() {
return WIFI_SCAN_FAILED; return WIFI_SCAN_FAILED;
} }
void ESP8266WiFiClass::scanDelete() void ESP8266WiFiClass::scanDelete() {
{ if(ESP8266WiFiClass::_scanResult) {
if (ESP8266WiFiClass::_scanResult)
{
delete[] reinterpret_cast<bss_info*>(ESP8266WiFiClass::_scanResult); delete[] reinterpret_cast<bss_info*>(ESP8266WiFiClass::_scanResult);
ESP8266WiFiClass::_scanResult = 0; ESP8266WiFiClass::_scanResult = 0;
ESP8266WiFiClass::_scanCount = 0; ESP8266WiFiClass::_scanCount = 0;
@ -561,8 +508,7 @@ void ESP8266WiFiClass::scanDelete()
_scanComplete = false; _scanComplete = false;
} }
int8_t ESP8266WiFiClass::scanNetworks(bool async, bool show_hidden) int8_t ESP8266WiFiClass::scanNetworks(bool async, bool show_hidden) {
{
if(ESP8266WiFiClass::_scanStarted) { if(ESP8266WiFiClass::_scanStarted) {
return WIFI_SCAN_RUNNING; return WIFI_SCAN_RUNNING;
} }
@ -578,8 +524,7 @@ int8_t ESP8266WiFiClass::scanNetworks(bool async, bool show_hidden)
} }
int status = wifi_station_get_connect_status(); int status = wifi_station_get_connect_status();
if (status != STATION_GOT_IP && status != STATION_IDLE) if(status != STATION_GOT_IP && status != STATION_IDLE) {
{
disconnect(); disconnect();
} }
@ -607,70 +552,62 @@ int8_t ESP8266WiFiClass::scanNetworks(bool async, bool show_hidden)
} }
void * ESP8266WiFiClass::_getScanInfoByIndex(int i) void * ESP8266WiFiClass::_getScanInfoByIndex(int i) {
{ if(!ESP8266WiFiClass::_scanResult || (size_t) i > ESP8266WiFiClass::_scanCount) {
if (!ESP8266WiFiClass::_scanResult || (size_t)i > ESP8266WiFiClass::_scanCount)
{
return 0; return 0;
} }
return reinterpret_cast<bss_info*>(ESP8266WiFiClass::_scanResult) + i; return reinterpret_cast<bss_info*>(ESP8266WiFiClass::_scanResult) + i;
} }
String ESP8266WiFiClass::SSID(uint8_t i) String ESP8266WiFiClass::SSID(uint8_t i) {
{
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return ""; return "";
return String(reinterpret_cast<const char*>(it->ssid)); return String(reinterpret_cast<const char*>(it->ssid));
} }
uint8_t * ESP8266WiFiClass::BSSID(uint8_t i) uint8_t * ESP8266WiFiClass::BSSID(uint8_t i) {
{
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return 0; return 0;
return it->bssid; return it->bssid;
} }
String ESP8266WiFiClass::BSSIDstr(uint8_t i) String ESP8266WiFiClass::BSSIDstr(uint8_t i) {
{ char mac[18] = { 0 };
char mac[18] = {0};
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return String(""); return String("");
sprintf(mac,"%02X:%02X:%02X:%02X:%02X:%02X", it->bssid[0], it->bssid[1], it->bssid[2], it->bssid[3], it->bssid[4], it->bssid[5]); sprintf(mac, "%02X:%02X:%02X:%02X:%02X:%02X", it->bssid[0], it->bssid[1], it->bssid[2], it->bssid[3], it->bssid[4], it->bssid[5]);
return String(mac); return String(mac);
} }
int32_t ESP8266WiFiClass::channel(uint8_t i) int32_t ESP8266WiFiClass::channel(uint8_t i) {
{
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return 0; return 0;
return it->channel; return it->channel;
} }
bool ESP8266WiFiClass::isHidden(uint8_t i) bool ESP8266WiFiClass::isHidden(uint8_t i) {
{
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return false; return false;
return (it->is_hidden != 0); return (it->is_hidden != 0);
} }
bool ESP8266WiFiClass::getNetworkInfo(uint8_t i, String &ssid, uint8_t &encType, int32_t &rssi, uint8_t* &bssid, int32_t &channel, bool &isHidden) bool ESP8266WiFiClass::getNetworkInfo(uint8_t i, String &ssid, uint8_t &encType, int32_t &rssi, uint8_t* &bssid, int32_t &channel, bool &isHidden) {
{
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return false; return false;
ssid = (const char*)it->ssid; ssid = (const char*) it->ssid;
encType = encryptionType(i); encType = encryptionType(i);
rssi = it->rssi; rssi = it->rssi;
bssid = it->bssid; // move ptr bssid = it->bssid; // move ptr
@ -680,69 +617,61 @@ bool ESP8266WiFiClass::getNetworkInfo(uint8_t i, String &ssid, uint8_t &encType,
return true; return true;
} }
int32_t ESP8266WiFiClass::RSSI(uint8_t i) int32_t ESP8266WiFiClass::RSSI(uint8_t i) {
{
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return 0; return 0;
return it->rssi; return it->rssi;
} }
uint8_t ESP8266WiFiClass::encryptionType(uint8_t i) uint8_t ESP8266WiFiClass::encryptionType(uint8_t i) {
{
struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i)); struct bss_info* it = reinterpret_cast<struct bss_info*>(_getScanInfoByIndex(i));
if (!it) if(!it)
return -1; return -1;
int authmode = it->authmode; int authmode = it->authmode;
if (authmode == AUTH_OPEN) if(authmode == AUTH_OPEN)
return ENC_TYPE_NONE; return ENC_TYPE_NONE;
if (authmode == AUTH_WEP) if(authmode == AUTH_WEP)
return ENC_TYPE_WEP; return ENC_TYPE_WEP;
if (authmode == AUTH_WPA_PSK) if(authmode == AUTH_WPA_PSK)
return ENC_TYPE_TKIP; return ENC_TYPE_TKIP;
if (authmode == AUTH_WPA2_PSK) if(authmode == AUTH_WPA2_PSK)
return ENC_TYPE_CCMP; return ENC_TYPE_CCMP;
if (authmode == AUTH_WPA_WPA2_PSK) if(authmode == AUTH_WPA_WPA2_PSK)
return ENC_TYPE_AUTO; return ENC_TYPE_AUTO;
return -1; return -1;
} }
wl_status_t ESP8266WiFiClass::status() wl_status_t ESP8266WiFiClass::status() {
{
int status = wifi_station_get_connect_status(); int status = wifi_station_get_connect_status();
if (status == STATION_GOT_IP) if(status == STATION_GOT_IP)
return WL_CONNECTED; return WL_CONNECTED;
else if (status == STATION_NO_AP_FOUND) else if(status == STATION_NO_AP_FOUND)
return WL_NO_SSID_AVAIL; return WL_NO_SSID_AVAIL;
else if (status == STATION_CONNECT_FAIL || status == STATION_WRONG_PASSWORD) else if(status == STATION_CONNECT_FAIL || status == STATION_WRONG_PASSWORD)
return WL_CONNECT_FAILED; return WL_CONNECT_FAILED;
else if (status == STATION_IDLE) else if(status == STATION_IDLE)
return WL_IDLE_STATUS; return WL_IDLE_STATUS;
else else
return WL_DISCONNECTED; return WL_DISCONNECTED;
} }
void wifi_dns_found_callback(const char *name, ip_addr_t *ipaddr, void *callback_arg) void wifi_dns_found_callback(const char *name, ip_addr_t *ipaddr, void *callback_arg) {
{ if(ipaddr)
if (ipaddr)
(*reinterpret_cast<IPAddress*>(callback_arg)) = ipaddr->addr; (*reinterpret_cast<IPAddress*>(callback_arg)) = ipaddr->addr;
esp_schedule(); // resume the hostByName function esp_schedule(); // resume the hostByName function
} }
int ESP8266WiFiClass::hostByName(const char* aHostname, IPAddress& aResult) int ESP8266WiFiClass::hostByName(const char* aHostname, IPAddress& aResult) {
{
ip_addr_t addr; ip_addr_t addr;
aResult = static_cast<uint32_t>(0); aResult = static_cast<uint32_t>(0);
err_t err = dns_gethostbyname(aHostname, &addr, &wifi_dns_found_callback, &aResult); err_t err = dns_gethostbyname(aHostname, &addr, &wifi_dns_found_callback, &aResult);
if (err == ERR_OK) if(err == ERR_OK) {
{
aResult = addr.addr; aResult = addr.addr;
} } else if(err == ERR_INPROGRESS) {
else if (err == ERR_INPROGRESS)
{
esp_yield(); esp_yield();
// will return here when dns_found_callback fires // will return here when dns_found_callback fires
} }
@ -771,10 +700,9 @@ bool ESP8266WiFiClass::hostname(String aHostname) {
//-------------------------------------------------------------- //--------------------------------------------------------------
void wifi_wps_status_cb(wps_cb_status status) void wifi_wps_status_cb(wps_cb_status status) {
{
DEBUGV("wps cb status: %d\r\n", status); DEBUGV("wps cb status: %d\r\n", status);
switch (status) { switch(status) {
case WPS_CB_ST_SUCCESS: case WPS_CB_ST_SUCCESS:
if(!wifi_wps_disable()) { if(!wifi_wps_disable()) {
DEBUGV("wps disable failed\n"); DEBUGV("wps disable failed\n");
@ -841,11 +769,8 @@ bool ESP8266WiFiClass::beginWPSConfig(void) {
//-------------------------------------------------------------- //--------------------------------------------------------------
void ESP8266WiFiClass::beginSmartConfig() {
if(_smartConfigStarted)
void ESP8266WiFiClass::beginSmartConfig()
{
if (_smartConfigStarted)
return; return;
if(_useApMode) { if(_useApMode) {
@ -863,27 +788,24 @@ void ESP8266WiFiClass::beginSmartConfig()
smartconfig_start(reinterpret_cast<sc_callback_t>(&ESP8266WiFiClass::_smartConfigCallback), 1); smartconfig_start(reinterpret_cast<sc_callback_t>(&ESP8266WiFiClass::_smartConfigCallback), 1);
} }
void ESP8266WiFiClass::stopSmartConfig() void ESP8266WiFiClass::stopSmartConfig() {
{ if(!_smartConfigStarted)
if (!_smartConfigStarted)
return; return;
smartconfig_stop(); smartconfig_stop();
_smartConfigStarted = false; _smartConfigStarted = false;
} }
bool ESP8266WiFiClass::smartConfigDone() bool ESP8266WiFiClass::smartConfigDone() {
{ if(!_smartConfigStarted)
if (!_smartConfigStarted)
return false; return false;
return _smartConfigDone; return _smartConfigDone;
} }
void ESP8266WiFiClass::_smartConfigCallback(uint32_t st, void* result) void ESP8266WiFiClass::_smartConfigCallback(uint32_t st, void* result) {
{
sc_status status = (sc_status) st; sc_status status = (sc_status) st;
if (status == SC_STATUS_LINK) { if(status == SC_STATUS_LINK) {
station_config* sta_conf = reinterpret_cast<station_config*>(result); station_config* sta_conf = reinterpret_cast<station_config*>(result);
wifi_station_set_config(sta_conf); wifi_station_set_config(sta_conf);
@ -891,13 +813,11 @@ void ESP8266WiFiClass::_smartConfigCallback(uint32_t st, void* result)
wifi_station_connect(); wifi_station_connect();
WiFi._smartConfigDone = true; WiFi._smartConfigDone = true;
} } else if(status == SC_STATUS_LINK_OVER) {
else if (status == SC_STATUS_LINK_OVER) {
WiFi.stopSmartConfig(); WiFi.stopSmartConfig();
} }
} }
//-------------------------------------------------------------- //--------------------------------------------------------------
/** /**
@ -906,7 +826,7 @@ void ESP8266WiFiClass::_smartConfigCallback(uint32_t st, void* result)
* @return bool * @return bool
*/ */
bool ESP8266WiFiClass::setSleepMode(WiFiSleepType_t type) { bool ESP8266WiFiClass::setSleepMode(WiFiSleepType_t type) {
return wifi_set_sleep_type((sleep_type_t)type); return wifi_set_sleep_type((sleep_type_t) type);
} }
/** /**
@ -914,7 +834,7 @@ bool ESP8266WiFiClass::setSleepMode(WiFiSleepType_t type) {
* @return sleep_type_t * @return sleep_type_t
*/ */
WiFiSleepType_t ESP8266WiFiClass::getSleepMode() { WiFiSleepType_t ESP8266WiFiClass::getSleepMode() {
return (WiFiSleepType_t)wifi_get_sleep_type(); return (WiFiSleepType_t) wifi_get_sleep_type();
} }
/** /**
@ -923,7 +843,7 @@ WiFiSleepType_t ESP8266WiFiClass::getSleepMode() {
* @return bool * @return bool
*/ */
bool ESP8266WiFiClass::setPhyMode(WiFiPhyMode_t mode) { bool ESP8266WiFiClass::setPhyMode(WiFiPhyMode_t mode) {
return wifi_set_phy_mode((phy_mode_t)mode); return wifi_set_phy_mode((phy_mode_t) mode);
} }
/** /**
@ -931,28 +851,26 @@ bool ESP8266WiFiClass::setPhyMode(WiFiPhyMode_t mode) {
* @return phy_mode_t * @return phy_mode_t
*/ */
WiFiPhyMode_t ESP8266WiFiClass::getPhyMode() { WiFiPhyMode_t ESP8266WiFiClass::getPhyMode() {
return (WiFiPhyMode_t)wifi_get_phy_mode(); return (WiFiPhyMode_t) wifi_get_phy_mode();
} }
//-------------------------------------------------------------- //--------------------------------------------------------------
void ESP8266WiFiClass::_eventCallback(void* arg) void ESP8266WiFiClass::_eventCallback(void* arg) {
{
System_Event_t* event = reinterpret_cast<System_Event_t*>(arg); System_Event_t* event = reinterpret_cast<System_Event_t*>(arg);
DEBUGV("wifi evt: %d\r\n", event->event); DEBUGV("wifi evt: %d\r\n", event->event);
if (event->event == EVENT_STAMODE_DISCONNECTED) { if(event->event == EVENT_STAMODE_DISCONNECTED) {
WiFiClient::stopAll(); WiFiClient::stopAll();
} }
} }
void ESP8266WiFiClass::printDiag(Print& p) void ESP8266WiFiClass::printDiag(Print& p) {
{ const char* modes[] = { "NULL", "STA", "AP", "STA+AP" };
const char* modes[] = {"NULL", "STA", "AP", "STA+AP"};
p.print("Mode: "); p.print("Mode: ");
p.println(modes[wifi_get_opmode()]); p.println(modes[wifi_get_opmode()]);
const char* phymodes[] = {"", "B", "G", "N"}; const char* phymodes[] = { "", "B", "G", "N" };
p.print("PHY mode: "); p.print("PHY mode: ");
p.println(phymodes[(int) wifi_get_phy_mode()]); p.println(phymodes[(int) wifi_get_phy_mode()]);
@ -995,5 +913,4 @@ bool ESP8266WiFiClass::_scanComplete = false;
size_t ESP8266WiFiClass::_scanCount = 0; size_t ESP8266WiFiClass::_scanCount = 0;
void* ESP8266WiFiClass::_scanResult = 0; void* ESP8266WiFiClass::_scanResult = 0;
ESP8266WiFiClass WiFi; ESP8266WiFiClass WiFi;

36
libraries/ESP8266WiFi/src/ESP8266WiFi.h
View File

@ -17,7 +17,7 @@
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#ifndef WiFi_h #ifndef WiFi_h
#define WiFi_h #define WiFi_h
@ -25,7 +25,7 @@
#include <stdint.h> #include <stdint.h>
extern "C" { extern "C" {
#include "include/wl_definitions.h" #include "include/wl_definitions.h"
} }
#include "IPAddress.h" #include "IPAddress.h"
@ -36,11 +36,12 @@ extern "C" {
#define WIFI_SCAN_RUNNING (-1) #define WIFI_SCAN_RUNNING (-1)
#define WIFI_SCAN_FAILED (-2) #define WIFI_SCAN_FAILED (-2)
// Note: // Note:
// this enums need to be in sync with the SDK! // this enums need to be in sync with the SDK!
enum WiFiMode { WIFI_OFF = 0, WIFI_STA = 1, WIFI_AP = 2, WIFI_AP_STA = 3 }; enum WiFiMode {
WIFI_OFF = 0, WIFI_STA = 1, WIFI_AP = 2, WIFI_AP_STA = 3
};
typedef enum { typedef enum {
WIFI_PHY_MODE_11B = 1, WIFI_PHY_MODE_11G = 2, WIFI_PHY_MODE_11N = 3 WIFI_PHY_MODE_11B = 1, WIFI_PHY_MODE_11G = 2, WIFI_PHY_MODE_11N = 3
@ -50,10 +51,8 @@ typedef enum {
WIFI_NONE_SLEEP = 0, WIFI_LIGHT_SLEEP = 2, WIFI_MODEM_SLEEP = 3 WIFI_NONE_SLEEP = 0, WIFI_LIGHT_SLEEP = 2, WIFI_MODEM_SLEEP = 3
} WiFiSleepType_t; } WiFiSleepType_t;
class ESP8266WiFiClass {
class ESP8266WiFiClass public:
{
public:
ESP8266WiFiClass(); ESP8266WiFiClass();
@ -77,7 +76,6 @@ public:
// Use sdk config to connect. // Use sdk config to connect.
int begin(); int begin();
/* Wait for Wifi connection to reach a result /* Wait for Wifi connection to reach a result
* returns the status reached or disconnect if STA is off * returns the status reached or disconnect if STA is off
*/ */
@ -89,7 +87,6 @@ public:
*/ */
void softAP(const char* ssid); void softAP(const char* ssid);
/* Set up a WPA2-secured access point /* Set up a WPA2-secured access point
* *
* param ssid: Pointer to the SSID string. * param ssid: Pointer to the SSID string.
@ -234,7 +231,6 @@ public:
int32_t RSSI(); int32_t RSSI();
/* /*
* called to get the scan state in Async mode * called to get the scan state in Async mode
* *
@ -282,7 +278,6 @@ public:
*/ */
int32_t RSSI(uint8_t networkItem); int32_t RSSI(uint8_t networkItem);
/** /**
* return MAC / BSSID of scanned wifi * return MAC / BSSID of scanned wifi
* @param networkItem specify from which network item want to get the information * @param networkItem specify from which network item want to get the information
@ -324,7 +319,6 @@ public:
*/ */
bool getNetworkInfo(uint8_t networkItem, String &ssid, uint8_t &encryptionType, int32_t &RSSI, uint8_t* &BSSID, int32_t &channel, bool &isHidden); bool getNetworkInfo(uint8_t networkItem, String &ssid, uint8_t &encryptionType, int32_t &RSSI, uint8_t* &BSSID, int32_t &channel, bool &isHidden);
/* /*
* Return Connection status. * Return Connection status.
* *
@ -350,10 +344,7 @@ public:
* Set ESP8266 station DHCP hostname * Set ESP8266 station DHCP hostname
* hostname, max length:32 * hostname, max length:32
*/ */
bool hostname(char* aHostname); bool hostname(char* aHostname);bool hostname(const char* aHostname);bool hostname(String aHostname);
bool hostname(const char* aHostname);
bool hostname(String aHostname);
/** /**
* WPS config * WPS config
@ -414,19 +405,14 @@ public:
*/ */
WiFiPhyMode_t getPhyMode(); WiFiPhyMode_t getPhyMode();
protected: protected:
void _mode(WiFiMode); void _mode(WiFiMode);
static void _scanDone(void* result, int status); static void _scanDone(void* result, int status);
void * _getScanInfoByIndex(int i); void * _getScanInfoByIndex(int i);
static void _smartConfigCallback(uint32_t status, void* result); static void _smartConfigCallback(uint32_t status, void* result);
static void _eventCallback(void *event); static void _eventCallback(void *event);bool _smartConfigStarted;bool _smartConfigDone;
bool _smartConfigStarted;
bool _smartConfigDone;
bool _useApMode; bool _useApMode;bool _useClientMode;bool _useStaticIp;bool _persistent;
bool _useClientMode;
bool _useStaticIp;
bool _persistent;
static bool _scanAsync; static bool _scanAsync;
static bool _scanStarted; static bool _scanStarted;