arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-06-06 05:21:22 +03:00
Code

emulation on host: missing mock functions, improve host interface handling (#7404)

Browse Source
This commit is contained in:
david gauchard 2020-06-24 19:05:57 +02:00 committed by GitHub
parent b26388812a
commit 5d60c55fb2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 411 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
tests/host/common/MockEsp.cpp
View File

@ -108,6 +108,11 @@ uint32_t EspClass::getFreeHeap()
return 30000;
}
uint16_t EspClass::getMaxFreeBlockSize()
{
return 20000;
}
String EspClass::getResetReason()
{
return "Power on";

5
tests/host/common/MockWiFiServerSocket.cpp
View File

@ -145,3 +145,8 @@ void WiFiServer::close ()
::close(pcb2int(_listen_pcb));
_listen_pcb = int2pcb(-1);
}
void WiFiServer::stop ()
{
close();
}

395
tests/host/common/user_interface.cpp
View File

@ -46,38 +46,38 @@ extern "C"
#include <user_interface.h>
#include <lwip/netif.h>
uint8 wifi_get_opmode(void)
{
uint8 wifi_get_opmode(void)
{
return STATION_MODE;
}
}
phy_mode_t wifi_get_phy_mode(void)
{
phy_mode_t wifi_get_phy_mode(void)
{
return PHY_MODE_11N;
}
}
uint8 wifi_get_channel (void)
{
uint8 wifi_get_channel(void)
{
return 1;
}
}
uint8 wifi_station_get_current_ap_id (void)
{
uint8 wifi_station_get_current_ap_id(void)
{
return 0;
}
}
station_status_t wifi_station_get_connect_status (void)
{
station_status_t wifi_station_get_connect_status(void)
{
return STATION_GOT_IP;
}
}
uint8 wifi_station_get_auto_connect (void)
{
uint8 wifi_station_get_auto_connect(void)
{
return 1;
}
}
bool wifi_station_get_config (struct station_config *config)
{
bool wifi_station_get_config(struct station_config *config)
{
strcpy((char*)config->ssid, "emulated-ssid");
strcpy((char*)config->password, "emulated-ssid-password");
config->bssid_set = 0;
@ -89,38 +89,38 @@ bool wifi_station_get_config (struct station_config *config)
config->open_and_wep_mode_disable = true;
#endif
return true;
}
}
void wifi_fpm_close(void)
{
}
void wifi_fpm_close(void)
{
}
sint8 wifi_fpm_do_sleep (uint32 sleep_time_in_us)
{
sint8 wifi_fpm_do_sleep(uint32 sleep_time_in_us)
{
usleep(sleep_time_in_us);
return 1;
}
}
void wifi_fpm_do_wakeup (void)
{
}
void wifi_fpm_do_wakeup(void)
{
}
void wifi_fpm_open (void)
{
}
void wifi_fpm_open(void)
{
}
void wifi_fpm_set_sleep_type (sleep_type_t type)
{
void wifi_fpm_set_sleep_type(sleep_type_t type)
{
(void)type;
}
}
uint32_t global_ipv4_netfmt = 0; // global binding
uint32_t global_ipv4_netfmt = 0; // global binding
netif netif0;
uint32_t global_source_address = INADDR_ANY;
netif netif0;
uint32_t global_source_address = INADDR_ANY;
bool wifi_get_ip_info (uint8 if_index, struct ip_info *info)
{
bool wifi_get_ip_info(uint8 if_index, struct ip_info *info)
{
// emulate wifi_get_ip_info()
// ignore if_index
// use global option -i (host_interface) to select bound interface/address
@ -135,18 +135,17 @@ bool wifi_get_ip_info (uint8 if_index, struct ip_info *info)
perror("getifaddrs");
exit(EXIT_FAILURE);
}
if (host_interface)
mockverbose("host: looking for interface '%s':\n", host_interface);
else
mockverbose("host: looking the first for non-local IPv4 interface:\n");
for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next)
{
mockverbose("host: interface: %s", ifa->ifa_name);
if ( ifa->ifa_addr
if (ifa->ifa_addr
&& ifa->ifa_addr->sa_family == AF_INET // ip_info is IPv4 only
)
{
auto test_ipv4 = lwip_ntohl(*(uint32_t*)&((struct sockaddr_in*)ifa->ifa_addr)->sin_addr);
auto test_ipv4 = lwip_ntohl(*(uint32_t*) & ((struct sockaddr_in*)ifa->ifa_addr)->sin_addr);
mockverbose(" IPV4 (0x%08lx)", test_ipv4);
if ((test_ipv4 & 0xff000000) == 0x7f000000)
// 127./8
@ -156,9 +155,10 @@ bool wifi_get_ip_info (uint8 if_index, struct ip_info *info)
if (!host_interface || (host_interface && strcmp(ifa->ifa_name, host_interface) == 0))
{
// use the first non-local interface, or, if specified, the one selected by user on cmdline
ipv4 = *(uint32_t*)&((struct sockaddr_in*)ifa->ifa_addr)->sin_addr;
mask = *(uint32_t*)&((struct sockaddr_in*)ifa->ifa_netmask)->sin_addr;
ipv4 = *(uint32_t*) & ((struct sockaddr_in*)ifa->ifa_addr)->sin_addr;
mask = *(uint32_t*) & ((struct sockaddr_in*)ifa->ifa_netmask)->sin_addr;
mockverbose(" (selected)\n");
if (host_interface)
global_source_address = ntohl(ipv4);
break;
}
@ -166,6 +166,7 @@ bool wifi_get_ip_info (uint8 if_index, struct ip_info *info)
}
mockverbose("\n");
}
if (ifAddrStruct != NULL)
freeifaddrs(ifAddrStruct);
@ -190,15 +191,15 @@ bool wifi_get_ip_info (uint8 if_index, struct ip_info *info)
}
return true;
}
}
uint8 wifi_get_listen_interval (void)
{
uint8 wifi_get_listen_interval(void)
{
return 1;
}
}
bool wifi_get_macaddr(uint8 if_index, uint8 *macaddr)
{
bool wifi_get_macaddr(uint8 if_index, uint8 *macaddr)
{
(void)if_index;
macaddr[0] = 0xde;
macaddr[1] = 0xba;
@ -207,177 +208,177 @@ bool wifi_get_macaddr(uint8 if_index, uint8 *macaddr)
macaddr[4] = 0xe0;
macaddr[5] = 0x42;
return true;
}
}
uint8 wifi_get_opmode_default (void)
{
uint8 wifi_get_opmode_default(void)
{
return STATION_MODE;
}
}
#ifdef NONOSDK3V0
sleep_level_t wifi_get_sleep_level (void)
{
sleep_level_t wifi_get_sleep_level(void)
{
return MIN_SLEEP_T;
}
}
#endif // nonos-sdk-pre-3
sleep_type_t wifi_get_sleep_type (void)
{
sleep_type_t wifi_get_sleep_type(void)
{
return NONE_SLEEP_T;
}
}
bool wifi_set_channel (uint8 channel)
{
bool wifi_set_channel(uint8 channel)
{
(void)channel;
return true;
}
}
wifi_event_handler_cb_t wifi_event_handler_cb_emu = nullptr;
void wifi_set_event_handler_cb (wifi_event_handler_cb_t cb)
{
wifi_event_handler_cb_t wifi_event_handler_cb_emu = nullptr;
void wifi_set_event_handler_cb(wifi_event_handler_cb_t cb)
{
wifi_event_handler_cb_emu = cb;
mockverbose("TODO: wifi_set_event_handler_cb set\n");
}
}
bool wifi_set_ip_info (uint8 if_index, struct ip_info *info)
{
bool wifi_set_ip_info(uint8 if_index, struct ip_info *info)
{
(void)if_index;
(void)info;
return false;
}
}
bool wifi_set_listen_interval (uint8 interval)
{
bool wifi_set_listen_interval(uint8 interval)
{
(void)interval;
return true;
}
}
bool wifi_set_opmode (uint8 opmode)
{
bool wifi_set_opmode(uint8 opmode)
{
return opmode == STATION_MODE || opmode == STATIONAP_MODE;
}
}
bool wifi_set_opmode_current (uint8 opmode)
{
bool wifi_set_opmode_current(uint8 opmode)
{
return opmode == STATION_MODE || opmode == STATIONAP_MODE;
}
}
bool wifi_set_phy_mode (phy_mode_t mode)
{
bool wifi_set_phy_mode(phy_mode_t mode)
{
(void)mode;
return true;
}
}
#ifdef NONOSDK3V0
bool wifi_set_sleep_level (sleep_level_t level)
{
bool wifi_set_sleep_level(sleep_level_t level)
{
(void)level;
return true;
}
}
#endif
bool wifi_set_sleep_type (sleep_type_t type)
{
bool wifi_set_sleep_type(sleep_type_t type)
{
(void)type;
return true;
}
}
bool wifi_station_connect (void)
{
bool wifi_station_connect(void)
{
return true;
}
}
bool wifi_station_dhcpc_start (void)
{
bool wifi_station_dhcpc_start(void)
{
return true;
}
}
bool wifi_station_dhcpc_stop (void)
{
bool wifi_station_dhcpc_stop(void)
{
return true;
}
}
bool wifi_station_disconnect (void)
{
bool wifi_station_disconnect(void)
{
return true;
}
}
bool wifi_station_get_config_default (struct station_config *config)
{
bool wifi_station_get_config_default(struct station_config *config)
{
return wifi_station_get_config(config);
}
}
char wifi_station_get_hostname_str [128];
const char* wifi_station_get_hostname (void)
{
char wifi_station_get_hostname_str [128];
const char* wifi_station_get_hostname(void)
{
return strcpy(wifi_station_get_hostname_str, "esposix");
}
}
bool wifi_station_get_reconnect_policy ()
{
bool wifi_station_get_reconnect_policy()
{
return true;
}
}
sint8 wifi_station_get_rssi (void)
{
sint8 wifi_station_get_rssi(void)
{
return 5;
}
}
bool wifi_station_set_auto_connect (uint8 set)
{
bool wifi_station_set_auto_connect(uint8 set)
{
return set != 0;
}
}
bool wifi_station_set_config (struct station_config *config)
{
bool wifi_station_set_config(struct station_config *config)
{
(void)config;
return true;
}
}
bool wifi_station_set_config_current (struct station_config *config)
{
bool wifi_station_set_config_current(struct station_config *config)
{
(void)config;
return true;
}
}
bool wifi_station_set_hostname (const char *name)
{
bool wifi_station_set_hostname(const char *name)
{
(void)name;
return true;
}
}
bool wifi_station_set_reconnect_policy (bool set)
{
bool wifi_station_set_reconnect_policy(bool set)
{
(void)set;
return true;
}
}
void system_phy_set_max_tpw (uint8 max_tpw)
{
void system_phy_set_max_tpw(uint8 max_tpw)
{
(void)max_tpw;
}
}
bool wifi_softap_dhcps_start(void)
{
bool wifi_softap_dhcps_start(void)
{
return true;
}
}
enum dhcp_status wifi_softap_dhcps_status(void)
{
enum dhcp_status wifi_softap_dhcps_status(void)
{
return DHCP_STARTED;
}
}
bool wifi_softap_dhcps_stop(void)
{
bool wifi_softap_dhcps_stop(void)
{
return true;
}
}
bool wifi_softap_get_config(struct softap_config *config)
{
bool wifi_softap_get_config(struct softap_config *config)
{
strcpy((char*)config->ssid, "apssid");
strcpy((char*)config->password, "appasswd");
config->ssid_len = strlen("appasswd");
@ -387,105 +388,105 @@ bool wifi_softap_get_config(struct softap_config *config)
config->max_connection = 4;
config->beacon_interval = 100;
return true;
}
}
bool wifi_softap_get_config_default(struct softap_config *config)
{
bool wifi_softap_get_config_default(struct softap_config *config)
{
return wifi_softap_get_config(config);
}
}
uint8 wifi_softap_get_station_num(void)
{
uint8 wifi_softap_get_station_num(void)
{
return 2;
}
}
bool wifi_softap_set_config(struct softap_config *config)
{
bool wifi_softap_set_config(struct softap_config *config)
{
(void)config;
return true;
}
}
bool wifi_softap_set_config_current(struct softap_config *config)
{
bool wifi_softap_set_config_current(struct softap_config *config)
{
(void)config;
return true;
}
}
bool wifi_softap_set_dhcps_lease(struct dhcps_lease *please)
{
bool wifi_softap_set_dhcps_lease(struct dhcps_lease *please)
{
(void)please;
return true;
}
}
bool wifi_softap_set_dhcps_lease_time(uint32 minute)
{
bool wifi_softap_set_dhcps_lease_time(uint32 minute)
{
(void)minute;
return true;
}
}
bool wifi_softap_set_dhcps_offer_option(uint8 level, void* optarg)
{
bool wifi_softap_set_dhcps_offer_option(uint8 level, void* optarg)
{
(void)level;
(void)optarg;
return true;
}
}
bool wifi_station_scan(struct scan_config *config, scan_done_cb_t cb)
{
bool wifi_station_scan(struct scan_config *config, scan_done_cb_t cb)
{
(void)config;
cb(nullptr, FAIL);
return false;
}
}
uint32_t core_version = 1;
uint32_t core_version = 1;
///////////////////////////////////////
// not user_interface
///////////////////////////////////////
// not user_interface
void ets_isr_mask (int intr)
{
void ets_isr_mask(int intr)
{
(void)intr;
}
}
void ets_isr_unmask (int intr)
{
void ets_isr_unmask(int intr)
{
(void)intr;
}
}
void esp_schedule (void)
{
}
void esp_schedule(void)
{
}
void dns_setserver (u8_t numdns, ip_addr_t *dnsserver)
{
void dns_setserver(u8_t numdns, ip_addr_t *dnsserver)
{
(void)numdns;
(void)dnsserver;
}
}
ip_addr_t dns_getserver (u8_t numdns)
{
ip_addr_t dns_getserver(u8_t numdns)
{
(void)numdns;
ip_addr_t addr = { 0x7f000001 };
return addr;
}
}
#include <smartconfig.h>
bool smartconfig_start (sc_callback_t cb, ...)
{
bool smartconfig_start(sc_callback_t cb, ...)
{
//XXXFIXME ... -> ptr
cb(SC_STATUS_LINK, NULL);
return true;
}
}
bool smartconfig_stop (void)
{
bool smartconfig_stop(void)
{
return true;
}
}
sleep_type_t wifi_fpm_get_sleep_type(void)
{
sleep_type_t wifi_fpm_get_sleep_type(void)
{
return NONE_SLEEP_T;
}
}
} // extern "C"

14
tests/restyle.sh
View File

@ -8,23 +8,35 @@ pwd
test -d cores/esp8266
test -d libraries
#all="cores/esp8266 libraries"
# should be: all="cores/esp8266 libraries"
all="
libraries/ESP8266mDNS
libraries/Wire
cores/esp8266/core_esp8266_si2c.cpp
"
# core
for d in $all; do
if [ -d "$d" ]; then
echo "-------- directory $d:"
for e in c cpp h; do
find $d -name "*.$e" -exec \
astyle \
--suffix=none \
--options=${org}/astyle_core.conf {} \;
done
else
echo "-------- file $d:"
astyle --suffix=none --options=${org}/astyle_core.conf "$d"
fi
done
# examples
for d in libraries; do
echo "-------- examples in $d:"
find $d -name "*.ino" -exec \
astyle \
--suffix=none \