Improve pdf rasterization and TLS.

5 files changed, 252 insertions, 45 deletions

diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt
index 62589d9..81b367e 100644
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -1,2 +1,3 @@
 idf_component_register(SRCS "main.c" "epd.c" "util.c"
+                       EMBED_TXTFILES git_srht_cert.pem
                        INCLUDE_DIRS ".")
diff --git a/main/epd.c b/main/epd.c
index 7398214..b59bf60 100644
--- a/main/epd.c
+++ b/main/epd.c
@@ -21,7 +21,7 @@
 #define EPD_MOSI_PIN   GPIO_NUM_23
 #define EPD_BUSY_PIN   GPIO_NUM_4
 
-static const char* TAG = "EPD";
+static const char* TAG = "epd";
 
 static spi_device_handle_t spi = NULL;
 
@@ -93,6 +93,7 @@ static void send_cmd(uint8_t cmd)
 	t.length = 8;
 	t.tx_buffer = &cmd;
 	t.user = (void*)0; 
+
 	ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t));
 }
 
@@ -104,6 +105,7 @@ static void send_data(uint8_t data)
 	t.length = 8;
 	t.tx_buffer = &data;
 	t.user = (void*)1; 
+
 	ESP_ERROR_CHECK(spi_device_polling_transmit(spi, &t));
 }
 
@@ -112,10 +114,12 @@ static inline void wait_until_idle(void)
 	int busy;
 
 	ESP_LOGI(TAG, "busy...");
+
 	do {
 		send_cmd(0x71);
 		busy = gpio_get_level(EPD_BUSY_PIN);
 	} while(busy == 0);
+
 	ESP_LOGI(TAG, "ready");
 	delay_ms(20);
 }
@@ -124,8 +128,10 @@ static inline void reset(void)
 {
 	ESP_ERROR_CHECK(gpio_set_level(EPD_RST_PIN, 1));
 	delay_ms(200);
+
 	ESP_ERROR_CHECK(gpio_set_level(EPD_RST_PIN, 0));
 	delay_ms(2);
+
 	ESP_ERROR_CHECK(gpio_set_level(EPD_RST_PIN, 1));
 	delay_ms(200);
 }
@@ -142,7 +148,9 @@ static inline void config_lut(uint8_t cmd, const uint8_t *lut)
 static inline void gpio_init(void)
 {
 	gpio_config_t io_cfg = {
-		.pin_bit_mask = ((1ULL << EPD_DC_PIN) | (1ULL << EPD_RST_PIN) | (1ULL << EPD_BUSY_PIN)),
+		.pin_bit_mask = ((1ULL << EPD_DC_PIN) |
+		                (1ULL << EPD_RST_PIN) |
+		                (1ULL << EPD_BUSY_PIN)),
 		.pull_up_en = true
 	};
 
@@ -150,6 +158,7 @@ static inline void gpio_init(void)
 	ESP_ERROR_CHECK(gpio_set_direction(EPD_DC_PIN, GPIO_MODE_OUTPUT));
 	ESP_ERROR_CHECK(gpio_set_direction(EPD_RST_PIN, GPIO_MODE_OUTPUT));
 	ESP_ERROR_CHECK(gpio_set_direction(EPD_BUSY_PIN, GPIO_MODE_INPUT));
+
 	delay_ms(500);
 }
 
@@ -163,7 +172,10 @@ static void spi_init(void)
 		.quadhd_io_num = -1,
 		.max_transfer_sz = 8
 	};
-	ESP_ERROR_CHECK(spi_bus_initialize(SPI2_HOST, &bus_cfg, SPI_DMA_CH_AUTO));
+
+	ESP_ERROR_CHECK(spi_bus_initialize(SPI2_HOST,
+	                                   &bus_cfg,
+	                                   SPI_DMA_CH_AUTO));
 
 	spi_device_interface_config_t dev_cfg = {
 		.clock_speed_hz = 10 * 1000 * 1000,
@@ -172,6 +184,7 @@ static void spi_init(void)
 		.queue_size = 1,
 		.pre_cb = spi_pre_cb_handler
 	};
+
 	ESP_ERROR_CHECK(spi_bus_add_device(SPI2_HOST, &dev_cfg, &spi));
 }
 
@@ -242,6 +255,7 @@ static inline void refresh()
 {
 	send_cmd(0x12);
 	delay_ms(100);
+
 	wait_until_idle();
 }
 
@@ -249,7 +263,9 @@ void epd_clear(void)
 {
 	uint16_t i, width, height;
 
-	width = (EPD_SCREEN_WIDTH % 8 == 0) ? (EPD_SCREEN_WIDTH / 8 ) : (EPD_SCREEN_WIDTH / 8 + 1);
+	width = (EPD_SCREEN_WIDTH % 8 == 0) ?
+	        (EPD_SCREEN_WIDTH / 8 ) :
+	        (EPD_SCREEN_WIDTH / 8 + 1);
 	height = EPD_SCREEN_HEIGHT;
 
 	send_cmd(0x10);
@@ -267,7 +283,9 @@ void epd_draw(const uint8_t pb[48000])
 {
 	uint32_t i, j, width, height;
 
-	width = (EPD_SCREEN_WIDTH % 8 == 0) ? (EPD_SCREEN_WIDTH / 8 ) : (EPD_SCREEN_WIDTH / 8 + 1);
+	width = (EPD_SCREEN_WIDTH % 8 == 0) ?
+	        (EPD_SCREEN_WIDTH / 8 ) :
+	        (EPD_SCREEN_WIDTH / 8 + 1);
 	height = EPD_SCREEN_HEIGHT;
 	
 	send_cmd(0x13);
@@ -282,7 +300,9 @@ void epd_draw(const uint8_t pb[48000])
 void epd_sleep(void)
 {
 	send_cmd(0x02);
+
 	wait_until_idle();
+
 	send_cmd(0x07);
 	send_data(0xA5);
 }
diff --git a/main/epd.h b/main/epd.h
index 1cd254f..fa124ab 100644
--- a/main/epd.h
+++ b/main/epd.h
@@ -6,4 +6,4 @@ void epd_clear(void);
 void epd_draw(const uint8_t pb[48000]);
 void epd_sleep(void);
 
-#endif
+#endif /* EPD_H */
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");
+	}
 }
 
diff --git a/main/util.h b/main/util.h
index 2a22daa..7156c8f 100644
--- a/main/util.h
+++ b/main/util.h
@@ -3,4 +3,4 @@
 
 void delay_ms(unsigned int t);
 
-#endif
+#endif /* EPD_UTIL_H */