LWS_VISIBLE int
lws_get_random(struct lws_context *context, void *buf, int len)
{
+ uint8_t *pb = buf;
+
while (len) {
uint32_t r = esp_random();
- uint8_t *p = (uint8_t *)&r, *pb = buf;
+ uint8_t *p = (uint8_t *)&r;
int b = 4;
if (len < b)
*pb++ = p[b];
}
- return 0;
+ return pb - (uint8_t *)buf;
}
LWS_VISIBLE int
return 1;
pt = &context->pt[tsi];
+ lws_stats_atomic_bump(context, pt, LWSSTATS_C_SERVICE_ENTRY, 1);
if (timeout_ms < 0)
goto faked_service;
return inet_ntop(af, src, dst, cnt);
}
+LWS_VISIBLE int
+lws_plat_inet_pton(int af, const char *src, void *dst)
+{
+ return 1; // inet_pton(af, src, dst);
+}
+
LWS_VISIBLE lws_fop_fd_t IRAM_ATTR
_lws_plat_file_open(const struct lws_plat_file_ops *fops, const char *filename,
const char *vpath, lws_fop_flags_t *flags)
#include <tcpip_adapter.h>
#include <esp_image_format.h>
#include <esp_task_wdt.h>
+#include "soc/ledc_reg.h"
+#include "driver/ledc.h"
struct lws_esp32 lws_esp32 = {
.model = CONFIG_LWS_MODEL_NAME,
.region = WIFI_COUNTRY_US, // default to safest option
};
+/*
+ * Group AP / Station State
+ */
+
+enum lws_gapss {
+ LWS_GAPSS_INITIAL, /* just started up, init and move to LWS_GAPSS_SCAN */
+ LWS_GAPSS_SCAN, /*
+ * Unconnected, scanning: AP known in one of the config
+ * slots -> configure it, start timeout + LWS_GAPSS_STAT,
+ * if no AP already up in same group with lower MAC,
+ * after a random period start up our AP (LWS_GAPSS_AP)
+ */
+ LWS_GAPSS_AP, /*
+ * Trying to be the group AP... periodically do a scan
+ * LWS_GAPSS_AP_SCAN, faster and then slower
+ */
+ LWS_GAPSS_AP_SCAN, /*
+ * doing a scan while trying to be the group AP... if
+ * we see a lower MAC being the AP for the same group
+ * AP, abandon being an AP and join that AP as a
+ * station
+ */
+ LWS_GAPSS_STAT_GRP_AP, /*
+ * We have decided to join another group member who is
+ * being the AP, as its MAC is lower than ours. This
+ * is a stable state, but we still do periodic scans
+ * (LWS_GAPSS_STAT_GRP_AP_SCAN) and will always prefer
+ * an AP configured in a slot.
+ */
+ LWS_GAPSS_STAT_GRP_AP_SCAN,
+ /*
+ * We have joined a group member who is doing the AP
+ * job... we want to check every now and then if a
+ * configured AP has appeared that we should better
+ * use instead. Otherwise stay in LWS_GAPSS_STAT_GRP_AP
+ */
+ LWS_GAPSS_STAT, /*
+ * trying to connect to another non-group AP. If we
+ * don't get an IP within a timeout and retries,
+ * blacklist it and go back
+ */
+ LWS_GAPSS_STAT_HAPPY,
+};
+
+static const char *gapss_str[] = {
+ "LWS_GAPSS_INITIAL",
+ "LWS_GAPSS_SCAN",
+ "LWS_GAPSS_AP",
+ "LWS_GAPSS_AP_SCAN",
+ "LWS_GAPSS_STAT_GRP_AP",
+ "LWS_GAPSS_STAT_GRP_AP_SCAN",
+ "LWS_GAPSS_STAT",
+ "LWS_GAPSS_STAT_HAPPY",
+};
+
static romfs_t lws_esp32_romfs;
+static TimerHandle_t leds_timer, scan_timer, debounce_timer
+#if !defined(CONFIG_LWS_IS_FACTORY_APPLICATION)
+, mdns_timer
+#endif
+;
+static enum lws_gapss gapss = LWS_GAPSS_INITIAL;
+static char bdown;
+
+#define GPIO_SW 14
struct esp32_file {
const struct inode *i;
};
+static void lws_gapss_to(enum lws_gapss to)
+{
+ lwsl_notice("gapss from %s to %s\n", gapss_str[gapss], gapss_str[to]);
+ gapss = to;
+}
+
uint32_t lws_esp32_get_reboot_type(void)
{
uint32_t *p = (uint32_t *)LWS_MAGIC_REBOOT_TYPE_ADS, val = *p;
int n = 0;
ESP_ERROR_CHECK(nvs_open("lws-station", NVS_READWRITE, &nvh));
- if (nvs_get_blob(nvh, "ssl-pub.der", NULL, &s) == ESP_OK)
+ if (nvs_get_blob(nvh, "ssl-pub.pem", NULL, &s) == ESP_OK)
n = 1;
- if (nvs_get_blob(nvh, "ssl-pri.der", NULL, &s) == ESP_OK)
+ if (nvs_get_blob(nvh, "ssl-pri.pem", NULL, &s) == ESP_OK)
n |= 2;
nvs_close(nvh);
esp_restart();
}
-esp_err_t lws_esp32_event_passthru(void *ctx, system_event_t *event)
+/*
+ * esp-idf goes crazy with zero length str nvs. Use this as a workaround
+ * to delete the key in that case.
+ */
+
+esp_err_t lws_nvs_set_str(nvs_handle handle, const char* key, const char* value)
{
- switch(event->event_id) {
- case SYSTEM_EVENT_STA_START:
+ if (*value)
+ return nvs_set_str(handle, key, value);
+
+ return nvs_erase_key(handle, key);
+}
+
+static wifi_scan_config_t scan_config = {
+ .ssid = 0,
+ .bssid = 0,
+ .channel = 0,
+ .show_hidden = true
+};
+
+static char scan_ongoing = 0, scan_timer_exists = 0;
+static int try_slot = -1;
+
+static wifi_config_t config = {
+ .ap = {
+ .channel = 6,
+ .authmode = WIFI_AUTH_OPEN,
+ .max_connection = 1,
+ } }, sta_config = {
+ .sta = {
+ .bssid_set = 0,
+ } };
+
+static void lws_esp32_scan_timer_cb(TimerHandle_t th)
+{
+ int n;
+
+ lwsl_notice("%s\n", __func__);
+ scan_ongoing = 0;
+ n = esp_wifi_scan_start(&scan_config, false);
+ if (n != ESP_OK)
+ lwsl_err("scan start failed %d\n", n);
+}
+
+#if !defined(CONFIG_LWS_IS_FACTORY_APPLICATION)
+
+void __attribute__(( weak ))
+lws_group_member_event(int e, void *p)
+{
+}
+
+void __attribute__(( weak ))
+lws_get_iframe_size(int *w, int *h)
+{
+ *w = 320;
+ *h = 160;
+}
+
+void lws_group_member_event_call(int e, void *p)
+{
+ lws_group_member_event(e, p);
+}
+
+static int
+get_txt_param(const char *txt, const char *param, char *result, int len)
+{
+ const char *p;
+
+again:
+ p = strstr(txt, param);
+ if (!p) {
+ *result = '\0';
+ return 1;
+ }
+
+ p += strlen(param);
+ if (*p != '=') {
+ txt = p;
+ goto again;
+ }
+ p++;
+ while (*p && *p != '&' && --len)
+ *result++ = *p++;
+
+ *result = '\0';
+
+ return 0;
+}
+
+void __attribute__(( weak ))
+lws_esp32_button(int down)
+{
+}
+
+void IRAM_ATTR
+gpio_irq(void *arg)
+{
+ bdown ^= 1;
+ gpio_set_intr_type(GPIO_SW, GPIO_INTR_DISABLE);
+ xTimerStart(debounce_timer, 0);
+
+ lws_esp32_button(bdown);
+}
+
+static void lws_esp32_debounce_timer_cb(TimerHandle_t th)
+{
+ if (bdown)
+ gpio_set_intr_type(GPIO_SW, GPIO_INTR_POSEDGE);
+ else
+ gpio_set_intr_type(GPIO_SW, GPIO_INTR_NEGEDGE);
+}
+
+static void lws_esp32_mdns_timer_cb(TimerHandle_t th)
+{
+ uint64_t now = time_in_microseconds();
+ struct lws_group_member *p, **p1;
+ const mdns_result_t *r;
+ int n, m;
+
+ if (!lws_esp32.mdns)
+ return;
+ n = mdns_query_end(lws_esp32.mdns);
+
+ for (m = 0; m < n; m++) {
+ char ch = 0, group[16];
+
+ r = mdns_result_get(lws_esp32.mdns, m);
+
+ get_txt_param(r->txt, "group", group, sizeof(group));
+ if (strcmp(group, lws_esp32.group)) /* not our group */ {
+ lwsl_notice("group %s vs %s %s\n",
+ group, lws_esp32.group, r->txt);
+ continue;
+ }
+
+ p = lws_esp32.first;
+ while (p) {
+ if (strcmp(r->host, p->host))
+ goto next;
+ if (memcmp(&r->addr, &p->addr, sizeof(r->addr)))
+ goto next;
+
+ p->last_seen = now;
+ break;
+next:
+ p = p->next;
+ }
+ if (!p) { /* did not find */
+ char temp[8];
+ p = malloc(sizeof(*p));
+ if (!p)
+ continue;
+ strncpy(p->host, r->host, sizeof(p->host) - 1);
+ p->host[sizeof(p->host) - 1] = '\0';
+
+ get_txt_param(r->txt, "model", p->model, sizeof(p->model));
+ get_txt_param(r->txt, "role", p->role, sizeof(p->role));
+ get_txt_param(r->txt, "mac", p->mac, sizeof(p->mac));
+ get_txt_param(r->txt, "width", temp, sizeof(temp));
+ p->width = atoi(temp);
+ get_txt_param(r->txt, "height", temp, sizeof(temp));
+ p->height = atoi(temp);
+
+ memcpy(&p->addr, &r->addr, sizeof(p->addr));
+ memcpy(&p->addrv6, &r->addrv6, sizeof(p->addrv6));
+ p->last_seen = now;
+ p->flags = 0;
+ p->next = lws_esp32.first;
+ lws_esp32.first = p;
+ lws_esp32.extant_group_members++;
+
+ lws_group_member_event_call(LWS_SYSTEM_GROUP_MEMBER_ADD, p);
+ } else {
+ if (memcmp(&p->addr, &r->addr, sizeof(p->addr))) {
+ memcpy(&p->addr, &r->addr, sizeof(p->addr));
+ ch = 1;
+ }
+ if (memcmp(&p->addrv6, &r->addrv6, sizeof(p->addrv6))) {
+ memcpy(&p->addrv6, &r->addrv6, sizeof(p->addrv6));
+ ch = 1;
+ }
+ if (ch)
+ lws_group_member_event_call(LWS_SYSTEM_GROUP_MEMBER_CHANGE, p);
+ }
+ }
+
+ mdns_result_free(lws_esp32.mdns);
+
+ /* garbage-collect group members not seen for too long */
+ p1 = &lws_esp32.first;
+ while (*p1) {
+ p = *p1;
+ if (!(p->flags & LWS_GROUP_FLAG_SELF) &&
+ now - p->last_seen > 60000000) {
+ lws_esp32.extant_group_members--;
+ *p1 = p->next;
+
+ lws_group_member_event_call(LWS_SYSTEM_GROUP_MEMBER_REMOVE, p);
+ free(p);
+ continue;
+ }
+ p1 = &(*p1)->next;
+ }
+
+ mdns_query(lws_esp32.mdns, "_lwsgrmem", "_tcp", 0);
+ xTimerStart(mdns_timer, 0);
+}
+#endif
+
+static int
+start_scan()
+{
+ /* if no APs configured, no point... */
+
+ if (!lws_esp32.ssid[0][0] &&
+ !lws_esp32.ssid[1][0] &&
+ !lws_esp32.ssid[2][0] &&
+ !lws_esp32.ssid[3][0])
+ return 0;
+
+ if (scan_timer_exists && !scan_ongoing) {
+ // lwsl_notice("Starting scan timer...\n");
+ scan_ongoing = 1;
+ xTimerStart(scan_timer, 0);
+ }
+
+ return 0;
+}
+
+
+
+static void
+end_scan()
+{
+ wifi_ap_record_t ap_records[10];
+ uint16_t count_ap_records;
+ int n, m;
+
+ count_ap_records = ARRAY_SIZE(ap_records);
+ if (esp_wifi_scan_get_ap_records(&count_ap_records, ap_records) != ESP_OK) {
+ lwsl_err("%s: failed\n", __func__);
+ return;
+ }
+
+ if (!count_ap_records)
+ goto passthru;
+
+ if (gapss != LWS_GAPSS_SCAN) {
+ lwsl_notice("ignoring scan as gapss %s\n", gapss_str[gapss]);
+ goto passthru;
+ }
+
+ /* no point if no APs set up */
+ if (!lws_esp32.ssid[0][0] &&
+ !lws_esp32.ssid[1][0] &&
+ !lws_esp32.ssid[2][0] &&
+ !lws_esp32.ssid[3][0])
+ goto passthru;
+
+ lwsl_notice("checking %d scan records\n", count_ap_records);
+
+ for (n = 0; n < 4; n++) {
+
+ if (!lws_esp32.ssid[(n + try_slot + 1) & 3][0])
+ continue;
+
+ lwsl_notice("looking for %s\n", lws_esp32.ssid[(n + try_slot + 1) & 3]);
+
+ /* this ssid appears in scan results? */
+
+ for (m = 0; m < count_ap_records; m++) {
+ // lwsl_notice(" %s\n", ap_records[m].ssid);
+ if (strcmp((char *)ap_records[m].ssid, lws_esp32.ssid[(n + try_slot + 1) & 3]) == 0)
+ goto hit;
+ }
+
+ continue;
+
+hit:
+ m = (n + try_slot + 1) & 3;
+ try_slot = m;
+ lwsl_notice("Attempting connection with slot %d: %s:\n", m,
+ lws_esp32.ssid[m]);
+ /* set the ssid we last tried to connect to */
+ strncpy(lws_esp32.active_ssid, lws_esp32.ssid[m],
+ sizeof(lws_esp32.active_ssid) - 1);
+ lws_esp32.active_ssid[sizeof(lws_esp32.active_ssid) - 1] = '\0';
+
+ strncpy((char *)sta_config.sta.ssid, lws_esp32.ssid[m], sizeof(sta_config.sta.ssid) - 1);
+ strncpy((char *)sta_config.sta.password, lws_esp32.password[m], sizeof(sta_config.sta.password) - 1);
+
+ tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, (const char *)&config.ap.ssid[7]);
+ lws_gapss_to(LWS_GAPSS_STAT);
+
+ esp_wifi_set_config(WIFI_IF_STA, &sta_config);
esp_wifi_connect();
break;
+ }
+
+ if (n == 4)
+ start_scan();
+
+passthru:
+ if (lws_esp32.scan_consumer)
+ lws_esp32.scan_consumer(count_ap_records, ap_records, lws_esp32.scan_consumer_arg);
+
+}
+
+static void
+lws_set_genled(int n)
+{
+ lws_esp32.genled_t = time_in_microseconds();
+ lws_esp32.genled = n;
+}
+
+int
+lws_esp32_leds_network_indication(void)
+{
+ uint64_t us, r;
+ int n, fadein = 100, speed = 1199, div = 1, base = 0;
+
+ r = time_in_microseconds();
+ us = r - lws_esp32.genled_t;
+
+ switch (lws_esp32.genled) {
+ case LWSESP32_GENLED__INIT:
+ lws_esp32.genled = LWSESP32_GENLED__LOST_NETWORK;
+ /* fallthru */
+ case LWSESP32_GENLED__LOST_NETWORK:
+ fadein = us / 10000; /* 100 steps in 1s */
+ if (fadein > 100) {
+ fadein = 100;
+ lws_esp32.genled = LWSESP32_GENLED__NO_NETWORK;
+ }
+ /* fallthru */
+ case LWSESP32_GENLED__NO_NETWORK:
+ break;
+ case LWSESP32_GENLED__CONN_AP:
+ base = 4096;
+ speed = 933;
+ div = 2;
+ break;
+ case LWSESP32_GENLED__GOT_IP:
+ fadein = us / 10000; /* 100 steps in 1s */
+ if (fadein > 100) {
+ fadein = 100;
+ lws_esp32.genled = LWSESP32_GENLED__OK;
+ }
+ fadein = 100 - fadein; /* we are fading out */
+ /* fallthru */
+ case LWSESP32_GENLED__OK:
+ if (lws_esp32.genled == LWSESP32_GENLED__OK)
+ return 0;
+
+ base = 4096;
+ speed = 766;
+ div = 3;
+ break;
+ }
+
+ n = base + (lws_esp32_sine_interp(r / speed) / div);
+ return (n * fadein) / 100;
+}
+
+esp_err_t lws_esp32_event_passthru(void *ctx, system_event_t *event)
+{
+#if !defined(CONFIG_LWS_IS_FACTORY_APPLICATION)
+ struct lws_group_member *mem;
+ int n;
+#endif
+ char slot[8];
+ nvs_handle nvh;
+ uint32_t use;
+
+ switch((int)event->event_id) {
+ case SYSTEM_EVENT_STA_START:
+ //esp_wifi_connect();
+// break;
+ /* fallthru */
case SYSTEM_EVENT_STA_DISCONNECTED:
+ lwsl_notice("SYSTEM_EVENT_STA_DISCONNECTED\n");
+ lws_esp32.conn_ap = 0;
lws_esp32.inet = 0;
+ lws_esp32.sta_ip[0] = '\0';
+ lws_esp32.sta_mask[0] = '\0';
+ lws_esp32.sta_gw[0] = '\0';
+ lws_gapss_to(LWS_GAPSS_SCAN);
+ if (lws_esp32.mdns)
+ mdns_service_remove_all(lws_esp32.mdns);
+ mdns_free(lws_esp32.mdns);
+ lws_esp32.mdns = NULL;
+ lws_set_genled(LWSESP32_GENLED__LOST_NETWORK);
+ start_scan();
esp_wifi_connect();
break;
+
+ case SYSTEM_EVENT_STA_CONNECTED:
+ lws_esp32.conn_ap = 1;
+ lws_set_genled(LWSESP32_GENLED__CONN_AP);
+ break;
+
case SYSTEM_EVENT_STA_GOT_IP:
+ lwsl_notice("SYSTEM_EVENT_STA_GOT_IP\n");
+
lws_esp32.inet = 1;
- render_ip(lws_esp32.sta_ip, sizeof(lws_esp32.sta_ip) - 1, (uint8_t *)&event->event_info.got_ip.ip_info.ip);
- render_ip(lws_esp32.sta_mask, sizeof(lws_esp32.sta_mask) - 1, (uint8_t *)&event->event_info.got_ip.ip_info.netmask);
- render_ip(lws_esp32.sta_gw, sizeof(lws_esp32.sta_gw) - 1, (uint8_t *)&event->event_info.got_ip.ip_info.gw);
+ lws_set_genled(LWSESP32_GENLED__GOT_IP);
+
+ render_ip(lws_esp32.sta_ip, sizeof(lws_esp32.sta_ip) - 1,
+ (uint8_t *)&event->event_info.got_ip.ip_info.ip);
+ render_ip(lws_esp32.sta_mask, sizeof(lws_esp32.sta_mask) - 1,
+ (uint8_t *)&event->event_info.got_ip.ip_info.netmask);
+ render_ip(lws_esp32.sta_gw, sizeof(lws_esp32.sta_gw) - 1,
+ (uint8_t *)&event->event_info.got_ip.ip_info.gw);
+
+ if (!nvs_open("lws-station", NVS_READWRITE, &nvh)) {
+ lws_snprintf(slot, sizeof(slot) - 1, "%duse", try_slot);
+ use = 0;
+ nvs_get_u32(nvh, slot, &use);
+ nvs_set_u32(nvh, slot, use + 1);
+ nvs_commit(nvh);
+ nvs_close(nvh);
+ }
+
+ lws_gapss_to(LWS_GAPSS_STAT_HAPPY);
+
+#if !defined(CONFIG_LWS_IS_FACTORY_APPLICATION)
+ n = mdns_init(TCPIP_ADAPTER_IF_STA, &lws_esp32.mdns);
+ if (!n) {
+ static char *txta[6];
+ int w, h;
+
+ mdns_set_hostname(lws_esp32.mdns, lws_esp32.hostname);
+ mdns_set_instance(lws_esp32.mdns, lws_esp32.group);
+ mdns_service_add(lws_esp32.mdns, "_lwsgrmem", "_tcp", 443);
+ if (txta[0])
+ free(txta[0]);
+ txta[0] = malloc(32 * ARRAY_SIZE(txta));
+ if (!txta[0]) {
+ lwsl_notice("mdns OOM\n");
+ break;
+ }
+ txta[1] = &txta[0][32];
+ txta[2] = &txta[1][32];
+ txta[3] = &txta[2][32];
+ txta[4] = &txta[3][32];
+ txta[5] = &txta[4][32];
+
+ lws_get_iframe_size(&w, &h);
+
+ lws_snprintf(txta[0], 31, "model=%s", lws_esp32.model);
+ lws_snprintf(txta[1], 31, "group=%s", lws_esp32.group);
+ lws_snprintf(txta[2], 31, "role=%s", lws_esp32.role);
+ lws_snprintf(txta[3], 31, "mac=%s", lws_esp32.mac);
+ lws_snprintf(txta[4], 31, "width=%d", w);
+ lws_snprintf(txta[5], 31, "height=%d", h);
+
+ mem = lws_esp32.first;
+ while (mem) {
+ if (mem->flags & 1)
+ break;
+ mem = mem->next;
+ }
+
+ if (!mem) {
+ struct lws_group_member *mem = malloc(sizeof(*mem));
+ if (mem) {
+ mem->last_seen = ~(uint64_t)0;
+ strcpy(mem->model, lws_esp32.model);
+ strcpy(mem->role, lws_esp32.role);
+ strcpy(mem->host, lws_esp32.hostname);
+ strcpy(mem->mac, lws_esp32.mac);
+ mem->flags = LWS_GROUP_FLAG_SELF;
+ lws_get_iframe_size(&mem->width, &mem->height);
+ memcpy(&mem->addr, &event->event_info.got_ip.ip_info.ip,
+ sizeof(mem->addr));
+ memcpy(&mem->addrv6, &event->event_info.got_ip6.ip6_info.ip,
+ sizeof(mem->addrv6));
+ mem->next = lws_esp32.first;
+ lws_esp32.first = mem;
+ lws_esp32.extant_group_members++;
+
+ lws_group_member_event_call(LWS_SYSTEM_GROUP_MEMBER_ADD, mem);
+ }
+ } else { /* update our IP */
+ memcpy(&mem->addr, &event->event_info.got_ip.ip_info.ip,
+ sizeof(mem->addr));
+ memcpy(&mem->addrv6, &event->event_info.got_ip6.ip6_info.ip,
+ sizeof(mem->addrv6));
+ lws_group_member_event_call(LWS_SYSTEM_GROUP_MEMBER_CHANGE, mem);
+ }
+
+
+ if (mdns_service_txt_set(lws_esp32.mdns, "_lwsgrmem", "_tcp", ARRAY_SIZE(txta),
+ (const char **)txta))
+ lwsl_notice("txt set failed\n");
+ } else
+ lwsl_err("unable to init mdns on STA: %d\n", n);
+
+ mdns_query(lws_esp32.mdns, "_lwsgrmem", "_tcp", 0);
+ xTimerStart(mdns_timer, 0);
+#endif
+
+ lwsl_notice(" --- Got IP %s\n", lws_esp32.sta_ip);
break;
+
+ case SYSTEM_EVENT_SCAN_DONE:
+ lwsl_notice("SYSTEM_EVENT_SCAN_DONE\n");
+ end_scan();
+ break;
+
default:
break;
}
.LWS_FOP_SEEK_CUR = esp32_lws_fops_seek_cur,
};
-static wifi_config_t config = {
- .ap = {
- .channel = 6,
- .authmode = WIFI_AUTH_OPEN,
- .max_connection = 1,
- } }, sta_config = {
- .sta = {
- .bssid_set = 0,
- } };
-
int
lws_esp32_wlan_nvs_get(int retry)
{
nvs_handle nvh;
- char r[2], lws_esp32_force_ap = 0;
+ char r[2], lws_esp32_force_ap = 0, slot[12];
size_t s;
uint8_t mac[6];
+ int n;
- esp_efuse_read_mac(mac);
+ esp_efuse_mac_get_default(mac);
mac[5] |= 1; /* match the AP MAC */
snprintf(lws_esp32.serial, sizeof(lws_esp32.serial) - 1, "%02X%02X%02X", mac[3], mac[4], mac[5]);
+ snprintf(lws_esp32.mac, sizeof(lws_esp32.mac) - 1, "%02X%02X%02X%02X%02X%02X", mac[0],
+ mac[1], mac[2], mac[3], mac[4], mac[5]);
ESP_ERROR_CHECK(nvs_open("lws-station", NVS_READWRITE, &nvh));
- s = sizeof(config.sta.ssid) - 1;
- if (nvs_get_str(nvh, "ssid", (char *)sta_config.sta.ssid, &s) != ESP_OK)
- lws_esp32_force_ap = 1;
- s = sizeof(config.sta.password) - 1;
- if (nvs_get_str(nvh, "password", (char *)sta_config.sta.password, &s) != ESP_OK)
- lws_esp32_force_ap = 1;
+ config.sta.ssid[0] = '\0';
+ config.sta.password[0] = '\0';
+
+ for (n = 0; n < 4; n++) {
+ lws_snprintf(slot, sizeof(slot) - 1, "%dssid", n);
+ s = sizeof(lws_esp32.ssid[0]) - 1;
+ lws_esp32.ssid[n][0] = '\0';
+ nvs_get_str(nvh, slot, lws_esp32.ssid[n], &s);
+
+ lws_snprintf(slot, sizeof(slot) - 1, "%dpassword", n);
+ s = sizeof(lws_esp32.password[0]) - 1;
+ lws_esp32.password[n][0] = '\0';
+ nvs_get_str(nvh, slot, lws_esp32.password[n], &s);
+ }
+
s = sizeof(lws_esp32.serial) - 1;
if (nvs_get_str(nvh, "serial", lws_esp32.serial, &s) != ESP_OK)
lws_esp32_force_ap = 1;
lws_esp32.access_pw[0] = '\0';
nvs_get_str(nvh, "access_pw", lws_esp32.access_pw, &s);
- nvs_close(nvh);
+ lws_esp32.group[0] = '\0';
+ s = sizeof(lws_esp32.group);
+ nvs_get_str(nvh, "group", lws_esp32.group, &s);
- if (retry && sta_config.sta.ssid[0]) {
- tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, (const char *)&config.ap.ssid[7]);
- ESP_ERROR_CHECK( esp_wifi_set_config(WIFI_IF_STA, &sta_config));
- ESP_ERROR_CHECK( esp_wifi_connect());
+ lws_esp32.role[0] = '\0';
+ s = sizeof(lws_esp32.role);
+ nvs_get_str(nvh, "role", lws_esp32.role, &s);
- ESP_ERROR_CHECK(mdns_init(TCPIP_ADAPTER_IF_STA, &lws_esp32.mdns));
- mdns_set_hostname(lws_esp32.mdns, (const char *)&config.ap.ssid[7]);
- mdns_set_instance(lws_esp32.mdns, "instance");
- }
+ /* if group and role defined: group-role */
+ if (lws_esp32.group[0] && lws_esp32.role[0])
+ lws_snprintf(lws_esp32.hostname, sizeof(lws_esp32.hostname) - 1,
+ "%s-%s", lws_esp32.group, lws_esp32.role);
+ else /* otherwise model-serial */
+ lws_snprintf(lws_esp32.hostname, sizeof(lws_esp32.hostname) - 1,
+ "%s-%s", lws_esp32.model, lws_esp32.serial);
+
+ nvs_close(nvh);
+
+ lws_gapss_to(LWS_GAPSS_SCAN);
+ start_scan();
return lws_esp32_force_ap;
}
+
void
lws_esp32_wlan_config(void)
{
+ ledc_timer_config_t ledc_timer = {
+ .bit_num = LEDC_TIMER_13_BIT,
+ .freq_hz = 5000,
+ .speed_mode = LEDC_HIGH_SPEED_MODE,
+ .timer_num = LEDC_TIMER_0
+ };
+ int n;
+
+ ledc_timer_config(&ledc_timer);
+
+ lws_set_genled(LWSESP32_GENLED__INIT);
+
+ /* user code needs to provide lws_esp32_leds_timer_cb */
+
+ leds_timer = xTimerCreate("lws_leds", pdMS_TO_TICKS(25), 1, NULL,
+ (TimerCallbackFunction_t)lws_esp32_leds_timer_cb);
+ scan_timer = xTimerCreate("lws_scan", pdMS_TO_TICKS(10000), 0, NULL,
+ (TimerCallbackFunction_t)lws_esp32_scan_timer_cb);
+ debounce_timer = xTimerCreate("lws_db", pdMS_TO_TICKS(100), 0, NULL,
+ (TimerCallbackFunction_t)lws_esp32_debounce_timer_cb);
+
+#if !defined(CONFIG_LWS_IS_FACTORY_APPLICATION)
+ mdns_timer = xTimerCreate("lws_mdns", pdMS_TO_TICKS(5000), 0, NULL,
+ (TimerCallbackFunction_t)lws_esp32_mdns_timer_cb);
+#endif
+ scan_timer_exists = 1;
+ xTimerStart(leds_timer, 0);
+
+ *(volatile uint32_t *)PERIPHS_IO_MUX_MTMS_U = FUNC_MTMS_GPIO14;
+
+ gpio_output_set(0, 0, 0, (1 << GPIO_SW));
+
+ n = gpio_install_isr_service(0);
+ if (!n) {
+ gpio_config_t c;
+
+ c.intr_type = GPIO_INTR_NEGEDGE;
+ c.mode = GPIO_MODE_INPUT;
+ c.pin_bit_mask = 1 << GPIO_SW;
+ c.pull_down_en = 0;
+ c.pull_up_en = 0;
+ gpio_config(&c);
+
+ if (gpio_isr_handler_add(GPIO_SW, gpio_irq, NULL))
+ lwsl_notice("isr handler add for 14 failed\n");
+ } else
+ lwsl_notice("failed to install gpio isr service: %d\n", n);
+
lws_esp32_wlan_nvs_get(0);
tcpip_adapter_init();
}
ESP_ERROR_CHECK( esp_wifi_set_config(WIFI_IF_STA, &sta_config));
ESP_ERROR_CHECK( esp_wifi_start());
+ esp_wifi_scan_start(&scan_config, false);
+
if (sta_config.sta.ssid[0]) {
tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, (const char *)&config.ap.ssid[7]);
esp_wifi_set_auto_connect(1);
esp_wifi_set_auto_connect(1);
ESP_ERROR_CHECK( esp_wifi_connect());
- ESP_ERROR_CHECK(mdns_init(TCPIP_ADAPTER_IF_STA, &lws_esp32.mdns));
- mdns_set_hostname(lws_esp32.mdns, (const char *)&config.ap.ssid[7]);
- mdns_set_instance(lws_esp32.mdns, "instance");
+ lws_esp32_scan_timer_cb(NULL);
}
const esp_partition_t *
info->port = 443;
info->fd_limit_per_thread = 30;
- info->max_http_header_pool = 2;
+ info->max_http_header_pool = 3;
info->max_http_header_data = 1024;
info->pt_serv_buf_size = 4096;
- info->keepalive_timeout = 5;
- info->simultaneous_ssl_restriction = 2;
+ info->keepalive_timeout = 30;
+ info->timeout_secs = 30;
+ info->simultaneous_ssl_restriction = 3;
info->options = LWS_SERVER_OPTION_EXPLICIT_VHOSTS |
LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
- info->ssl_cert_filepath = "ssl-pub.der";
- info->ssl_private_key_filepath = "ssl-pri.der";
+ info->ssl_cert_filepath = "ssl-pub.pem";
+ info->ssl_private_key_filepath = "ssl-pri.pem";
}
int
ESP_ERROR_CHECK(nvs_open("lws-station", NVS_READWRITE, &nvh));
n = 0;
s = 1;
- if (nvs_get_blob(nvh, "ssl-pub.der", NULL, &s) == ESP_OK)
+ if (nvs_get_blob(nvh, "ssl-pub.pem", NULL, &s) == ESP_OK)
n = 1;
s = 1;
- if (nvs_get_blob(nvh, "ssl-pri.der", NULL, &s) == ESP_OK)
+ if (nvs_get_blob(nvh, "ssl-pri.pem", NULL, &s) == ESP_OK)
n |= 2;
nvs_close(nvh);
return context;
}
+
+static const uint16_t sineq16[] = {
+ 0x0000, 0x0191, 0x031e, 0x04a4, 0x061e, 0x0789, 0x08e2, 0x0a24,
+ 0x0b4e, 0x0c5c, 0x0d4b, 0x0e1a, 0x0ec6, 0x0f4d, 0x0faf, 0x0fea,
+};
+
+static uint16_t sine_lu(int n)
+{
+ switch ((n >> 4) & 3) {
+ case 1:
+ return 4096 + sineq16[n & 15];
+ case 2:
+ return 4096 + sineq16[15 - (n & 15)];
+ case 3:
+ return 4096 - sineq16[n & 15];
+ default:
+ return 4096 - sineq16[15 - (n & 15)];
+ }
+}
+
+/* useful for sine led fade patterns */
+
+uint16_t lws_esp32_sine_interp(int n)
+{
+ /*
+ * 2: quadrant
+ * 4: table entry in quadrant
+ * 4: interp (LSB)
+ *
+ * total 10 bits / 1024 steps per cycle
+ *
+ * + 0: 0
+ * + 256: 4096
+ * + 512: 8192
+ * + 768: 4096
+ * +1023: 0
+ */
+
+ return (sine_lu(n >> 4) * (15 - (n & 15)) +
+ sine_lu((n >> 4) + 1) * (n & 15)) / 15;
+}
+
projects / platform / upstream / libwebsockets.git / blobdiff