1 files changed, 224 insertions, 38 deletions

diff --git a/main/main.c b/main/main.c
index 526a134..3201f00 100644
--- a/main/main.c
+++ b/main/main.c
@@ -1,21 +1,110 @@
 #include <freertos/FreeRTOS.h>
+#include <freertos/event_groups.h>
 #include <freertos/task.h>
 #include <freertos/queue.h>
 
-#include <driver/gpio.h>
 #include <esp_log.h>
+#include <esp_log.h>
+#include <esp_netif.h>
+#include <esp_system.h>
+#include <esp_wifi.h>
+#include <esp_tls.h>
+#include <esp_http_client.h>
+
+#include <nvs_flash.h>
+#include <sys/param.h>
+#include <driver/gpio.h>
 
 #include "epd.h"
 #include "util.h"
-#include "doc.h"
 
-#define IO_PG_PREV  GPIO_NUM_21
-#define IO_PG_NEXT  GPIO_NUM_22
-#define IO_INTR_FLAG_DEFAULT  0
+#define PAGE_LEN  3
+#define PAGE_SIZE 48000
+
+#define IO_PAGE_PREV  GPIO_NUM_21
+#define IO_PAGE_NEXT  GPIO_NUM_22
+#define IO_INTR_FLAG_DEFAULT    0
+
+#define WIFI_SSID       CONFIG_ESP_WIFI_SSID
+#define WIFI_PASSWORD   CONFIG_ESP_WIFI_PASSWORD
+#define WIFI_MAX_RETRY  CONFIG_ESP_MAXIMUM_RETRY
+
+#define WIFI_CONNECTED_BIT  BIT0
+#define WIFI_ERROR_BIT      BIT1
+
+#define HTTP_URL_BASE    CONFIG_HTTP_BASE_URL
+#define HTTP_URL_SUFFIX  ".ebm"
+
+extern const char git_srht_cert_pem_start[] asm("_binary_git_srht_cert_pem_start");
+extern const char git_srht_cert_pem_end[]   asm("_binary_git_srht_cert_pem_end");
 
 static const char* TAG = "app";
 
-static size_t page = 0;
+static size_t page_num = 0;
+static uint8_t *pages[PAGE_LEN];
+
+static int http_get_page(size_t page_n, char buf[PAGE_SIZE])
+{
+	int rc;
+	char *url;
+	esp_http_client_handle_t client;
+
+	rc = 0;
+	url = NULL;
+	client = NULL;
+
+	int url_len = strlen(HTTP_URL_BASE) +
+	                     snprintf(NULL, 0,"%02d", page_n) +
+	                     strlen(HTTP_URL_SUFFIX) + 1;
+
+	if ((url = malloc(sizeof(char) * url_len)) == NULL) {
+		ESP_LOGE(TAG, "malloc() failed for URL");
+		goto exit;
+	}
+
+	snprintf(url, url_len, "%s%02d%s", HTTP_URL_BASE, page_n,
+	         HTTP_URL_SUFFIX);
+
+	ESP_LOGI(TAG, "downloading, URL = %s", url);
+
+	esp_http_client_config_t config = {
+		.url = url,
+		.timeout_ms = 5000,
+		.disable_auto_redirect = true,
+		.max_authorization_retries = -1,
+		.cert_pem = git_srht_cert_pem_start
+	};
+
+	client = esp_http_client_init(&config);
+
+	esp_err_t err = esp_http_client_open(client, 0);
+	if (err != ESP_OK) {
+		ESP_LOGE(TAG, "HTTP connection error: %s", esp_err_to_name(err));
+		goto exit;
+	}
+
+	esp_http_client_fetch_headers(client);
+	
+	int read_len = esp_http_client_read(client, buf, PAGE_SIZE);
+	if (read_len <= 0) {
+		ESP_LOGE(TAG, "HTTP response read error");
+		goto exit;
+	}
+
+	ESP_LOGI(TAG, "HTTP response status = %d, content length = %" PRId64,
+	              esp_http_client_get_status_code(client),
+	              esp_http_client_get_content_length(client));
+
+	rc = read_len == PAGE_SIZE;
+
+exit:
+	free(url);
+	esp_http_client_close(client);
+	esp_http_client_cleanup(client);
+
+	return rc;
+}
+
 static QueueHandle_t gpio_evt_queue = NULL;
 
 static void gpio_task(void* arg)
@@ -24,65 +113,162 @@ static void gpio_task(void* arg)
 
 	for(;;) {
 		if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) {
-			if (io_num == IO_PG_NEXT) {
-				if (page < data_len - 1) {
-					epd_draw(data[++page]);
-					gpio_intr_enable(IO_PG_NEXT);
-					gpio_intr_enable(IO_PG_PREV);
-				} else {
-					epd_clear();
-					epd_sleep();
+			if (io_num == IO_PAGE_NEXT) {
+				page_num++;
+				//epd_draw(pages[page_num % PAGE_LEN]);
+				if(!http_get_page(page_num + 2,
+				                  (char *) pages[(page_num + 1) % PAGE_LEN])) {
+					page_num--;
 				}
 			}
-			else if (io_num == IO_PG_PREV) {
-				if (page > 0) {
-					epd_draw(data[--page]);
-					gpio_intr_enable(IO_PG_NEXT);
-					gpio_intr_enable(IO_PG_PREV);
-				} else {
-					epd_clear();
-					epd_sleep();
+			else if (io_num == IO_PAGE_PREV && page_num > 0) {
+				page_num--;
+				//epd_draw(pages[page_num % PAGE_LEN]);
+				if(!http_get_page(page_num + 1,
+					                (char *) pages[(page_num - 1) % PAGE_LEN])) {
+					page_num++;
 				}
 			}
-			else {
+			else
 				delay_ms(500);
-				gpio_intr_enable(IO_PG_NEXT);
-				gpio_intr_enable(IO_PG_PREV);
-			}
+
+			gpio_intr_enable(IO_PAGE_NEXT);
+			gpio_intr_enable(IO_PAGE_PREV);
 		}
 	}
 }
 
 static void gpio_isr_handler(void *arg)
 {
-	gpio_intr_disable(IO_PG_PREV);
-	gpio_intr_disable(IO_PG_NEXT);
+	gpio_intr_disable(IO_PAGE_PREV);
+	gpio_intr_disable(IO_PAGE_NEXT);
+
 	uint32_t gpio_num = (uint32_t) arg;
 	xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
 }
 
+static int wifi_retry_num = 0;
+static EventGroupHandle_t wifi_evt_group;
+
+static void wifi_evt_handler(void *arg,
+                             esp_event_base_t eb, int32_t id,
+                             void *data)
+{
+	if (eb == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
+		if (wifi_retry_num < WIFI_MAX_RETRY) {
+			esp_wifi_connect();
+			wifi_retry_num++;
+			ESP_LOGI(TAG, "trying to connect to AP...");
+		} else {
+			ESP_LOGE(TAG,"connection to AP failed");
+			xEventGroupSetBits(wifi_evt_group, WIFI_ERROR_BIT);
+		}
+	} else if (eb == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
+		ip_event_got_ip_t* evt = (ip_event_got_ip_t*) data;
+		ESP_LOGI(TAG, "connected to AP with ip:" IPSTR, IP2STR(&evt->ip_info.ip));
+		wifi_retry_num = 0;
+		xEventGroupSetBits(wifi_evt_group, WIFI_CONNECTED_BIT);
+	}
+}
+
+static inline void wifi_connect(void)
+{
+	wifi_evt_group = xEventGroupCreate();
+	esp_netif_create_default_wifi_sta();
+
+	wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+	ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+
+	esp_event_handler_instance_t any_id;
+	ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
+	                                                    ESP_EVENT_ANY_ID,
+	                                                    &wifi_evt_handler,
+	                                                    NULL,
+	                                                    &any_id));
+
+	esp_event_handler_instance_t got_ip;
+	ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
+	                                                    IP_EVENT_STA_GOT_IP,
+	                                                    &wifi_evt_handler,
+	                                                    NULL,
+	                                                    &got_ip));
+
+	wifi_config_t wifi_config = {
+		.sta = {
+			.ssid = WIFI_SSID,
+			.password = WIFI_PASSWORD,
+			.threshold.authmode = WIFI_AUTH_WPA2_PSK
+		},
+	};
+
+	ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+	ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );
+
+	ESP_ERROR_CHECK(esp_wifi_start());
+	ESP_ERROR_CHECK(esp_wifi_connect());
+
+	xEventGroupWaitBits(wifi_evt_group,
+	                    WIFI_CONNECTED_BIT | WIFI_ERROR_BIT,
+	                    pdFALSE,
+	                    pdFALSE,
+	                    portMAX_DELAY);
+
+	ESP_LOGI(TAG, "wifi station initialized");
+}
+
 void app_main(void)
 {
-	epd_init();
-	ESP_LOGI(TAG, "initialized e-paper display");
+	esp_err_t rc = nvs_flash_init();
+	if (rc == ESP_ERR_NVS_NO_FREE_PAGES || rc == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+		ESP_ERROR_CHECK(nvs_flash_erase());
+		ESP_ERROR_CHECK(nvs_flash_init());
+	}
+
+	ESP_ERROR_CHECK(esp_event_loop_create_default());
+	ESP_ERROR_CHECK(esp_netif_init());
 
 	gpio_config_t io_cfg = {
-		.pin_bit_mask = ((1ULL << IO_PG_PREV) | (1ULL << IO_PG_NEXT)),
+		.pin_bit_mask = ((1ULL << IO_PAGE_PREV) | (1ULL << IO_PAGE_NEXT)),
 		.mode = GPIO_MODE_INPUT,
 		.pull_up_en = true,
 		.intr_type = GPIO_INTR_NEGEDGE
 	};
+
 	ESP_ERROR_CHECK(gpio_config(&io_cfg));
 
 	gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));
-	xTaskCreate(gpio_task, "gpio_task", 2048, NULL, 10, NULL);
+	xTaskCreate(gpio_task, "gpio_task", 4096, NULL, 10, NULL);
+
+	ESP_ERROR_CHECK(gpio_set_direction(IO_PAGE_PREV, GPIO_MODE_INPUT));
+	ESP_ERROR_CHECK(gpio_set_direction(IO_PAGE_NEXT, GPIO_MODE_INPUT));
 
-	gpio_install_isr_service(IO_INTR_FLAG_DEFAULT);
-	gpio_isr_handler_add(IO_PG_PREV, gpio_isr_handler, (void *) IO_PG_PREV);
-	gpio_isr_handler_add(IO_PG_NEXT, gpio_isr_handler, (void *) IO_PG_NEXT);
+	wifi_connect();
 
-	epd_clear();
-	delay_ms(500);
-	epd_draw(data[0]);
+	//epd_init();
+	//epd_clear();
+	//delay_ms(500);
+
+	pages[0] = malloc(sizeof(uint8_t) * PAGE_SIZE);
+	pages[1] = malloc(sizeof(uint8_t) * PAGE_SIZE);
+	pages[2] = malloc(sizeof(uint8_t) * PAGE_SIZE);
+
+	if (pages[0] && pages[1] && pages[2]) {
+		if (http_get_page(page_num + 1,
+		                  (char *) pages[page_num % PAGE_LEN])) {
+			//epd_draw(pages[page_num % PAGE_LEN]);
+			if (!http_get_page(page_num + 2,
+			                   (char *) pages[(page_num + 1) % PAGE_LEN])) {
+				page_num = -1;
+			}
+
+			gpio_install_isr_service(IO_INTR_FLAG_DEFAULT);
+			gpio_isr_handler_add(IO_PAGE_PREV, gpio_isr_handler, (void *) IO_PAGE_PREV);
+			gpio_isr_handler_add(IO_PAGE_NEXT, gpio_isr_handler, (void *) IO_PAGE_NEXT);
+
+			ESP_LOGI(TAG, "GPIO for user input initialized");
+		}
+	} else {
+		ESP_LOGE(TAG, "malloc() failed for pages");
+	}
 }