dejvino
/
lilybook
espelhamento de https://github.com/Dejvino/lilybook
1
0
Fork 0
Código Issues 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
2 Commits
1 Branch
616 KiB
 
 
 
Tag: a286a6a791
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de a286a6a791
${ noResults }
lilybook/main/ePaper.c

690 linhas
19 KiB
Original Anotar Histórico 

  1. /* ePaper demo

  2.  *

  3.  *  Author: LoBo (loboris@gmail.com, loboris.github)

  4. */

  5. 

  6. #include <time.h>

  7. #include <errno.h>

  8. #include <sys/fcntl.h>

  9. #include <stdio.h>

  10. #include <time.h>

  11. #include <stdlib.h>

  12. #include <string.h>

  13. #include "freertos/FreeRTOS.h"

  14. #include "freertos/task.h"

  15. #include "esp_system.h"

  16. #include "driver/gpio.h"

  17. #include "esp_system.h"

  18. #include "esp_heap_alloc_caps.h"

  19. #include "spiffs_vfs.h"

  20. #include "esp_log.h"

  21. 

  22. #ifdef CONFIG_EXAMPLE_USE_WIFI

  23. 

  24. #include "esp_wifi.h"

  25. #include "esp_system.h"

  26. #include "esp_event.h"

  27. #include "esp_event_loop.h"

  28. #include "freertos/event_groups.h"

  29. #include "esp_attr.h"

  30. #include <sys/time.h>

  31. #include <unistd.h>

  32. #include "lwip/err.h"

  33. #include "apps/sntp/sntp.h"

  34. #include "nvs_flash.h"

  35. 

  36. #endif

  37. 

  38. 

  39. #include "spi_master_lobo.h"

  40. #include "img1.h"

  41. #include "img2.h"

  42. #include "img3.h"

  43. #include "img_hacking.c"

  44. #include "EPD.h"

  45. //#include "EPDspi.h"

  46. 

  47. #define DELAYTIME 1500

  48. 

  49. 

  50. 

  51. static struct tm* tm_info;

  52. static char tmp_buff[128];

  53. static time_t time_now, time_last = 0;

  54. static const char *file_fonts[3] = {"/spiffs/fonts/DotMatrix_M.fon", "/spiffs/fonts/Ubuntu.fon", "/spiffs/fonts/Grotesk24x48.fon"};

  55. static const char tag[] = "[Eink Demo]";

  56. 

  57. //==================================================================================

  58. #ifdef CONFIG_EXAMPLE_USE_WIFI

  59. 

  60. 

  61. /* FreeRTOS event group to signal when we are connected & ready to make a request */

  62. static EventGroupHandle_t wifi_event_group;

  63. 

  64. /* The event group allows multiple bits for each event,

  65.    but we only care about one event - are we connected

  66.    to the AP with an IP? */

  67. const int CONNECTED_BIT = 0x00000001;

  68. 

  69. //------------------------------------------------------------

  70. static esp_err_t event_handler(void *ctx, system_event_t *event)

  71. {

  72.     switch(event->event_id) {

  73.     case SYSTEM_EVENT_STA_START:

  74.         esp_wifi_connect();

  75.         break;

  76.     case SYSTEM_EVENT_STA_GOT_IP:

  77.         xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);

  78.         break;

  79.     case SYSTEM_EVENT_STA_DISCONNECTED:

  80.         /* This is a workaround as ESP32 WiFi libs don't currently

  81.            auto-reassociate. */

  82.         esp_wifi_connect();

  83.         xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);

  84.         break;

  85.     default:

  86.         break;

  87.     }

  88.     return ESP_OK;

  89. }

  90. 

  91. //-------------------------------

  92. static void initialise_wifi(void)

  93. {

  94.     tcpip_adapter_init();

  95.     wifi_event_group = xEventGroupCreate();

  96.     ESP_ERROR_CHECK( esp_event_loop_init(event_handler, NULL) );

  97.     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

  98.     ESP_ERROR_CHECK( esp_wifi_init(&cfg) );

  99.     ESP_ERROR_CHECK( esp_wifi_set_storage(WIFI_STORAGE_RAM) );

  100.     wifi_config_t wifi_config = {

  101.         .sta = {

  102.             .ssid = CONFIG_WIFI_SSID,

  103.             .password = CONFIG_WIFI_PASSWORD,

  104.         },

  105.     };

  106.     ESP_LOGI(tag, "Setting WiFi configuration SSID %s...", wifi_config.sta.ssid);

  107.     ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );

  108.     ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );

  109.     ESP_ERROR_CHECK( esp_wifi_start() );

  110. }

  111. 

  112. //-------------------------------

  113. static void initialize_sntp(void)

  114. {

  115.     ESP_LOGI(tag, "Initializing SNTP");

  116.     sntp_setoperatingmode(SNTP_OPMODE_POLL);

  117.     sntp_setservername(0, "pool.ntp.org");

  118.     sntp_init();

  119. }

  120. 

  121. //--------------------------

  122. static int obtain_time(void)

  123. {

  124. 	int res = 1;

  125.     initialise_wifi();

  126.     xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);

  127. 

  128.     initialize_sntp();

  129. 

  130.     // wait for time to be set

  131.     int retry = 0;

  132.     const int retry_count = 20;

  133. 

  134.     time(&time_now);

  135. 	tm_info = localtime(&time_now);

  136. 

  137.     while(tm_info->tm_year < (2016 - 1900) && ++retry < retry_count) {

  138.         //ESP_LOGI(tag, "Waiting for system time to be set... (%d/%d)", retry, retry_count);

  139. 		vTaskDelay(500 / portTICK_RATE_MS);

  140.         time(&time_now);

  141.     	tm_info = localtime(&time_now);

  142.     }

  143.     if (tm_info->tm_year < (2016 - 1900)) {

  144.     	ESP_LOGI(tag, "System time NOT set.");

  145.     	res = 0;

  146.     }

  147.     else {

  148.     	ESP_LOGI(tag, "System time is set.");

  149.     }

  150. 

  151.     ESP_ERROR_CHECK( esp_wifi_stop() );

  152.     return res;

  153. }

  154. 

  155. #endif  //CONFIG_EXAMPLE_USE_WIFI

  156. //==================================================================================

  157. 

  158. 

  159. //=============

  160. void app_main()

  161. {

  162. 

  163.     // ========  PREPARE DISPLAY INITIALIZATION  =========

  164. 

  165.     esp_err_t ret;

  166. 

  167. 	disp_buffer = pvPortMallocCaps(EPD_DISPLAY_WIDTH * (EPD_DISPLAY_HEIGHT/8), MALLOC_CAP_DMA);

  168. 	assert(disp_buffer);

  169. 	drawBuff = disp_buffer;

  170. 

  171. 	gs_disp_buffer = pvPortMallocCaps(EPD_DISPLAY_WIDTH * EPD_DISPLAY_HEIGHT, MALLOC_CAP_DMA);

  172. 	assert(gs_disp_buffer);

  173. 	gs_drawBuff = gs_disp_buffer;

  174. 

  175. 	// ====  CONFIGURE SPI DEVICES(s)  ====================================================================================

  176. 

  177. 	gpio_set_direction(DC_Pin, GPIO_MODE_OUTPUT);

  178. 	gpio_set_level(DC_Pin, 1);

  179. 	gpio_set_direction(RST_Pin, GPIO_MODE_OUTPUT);

  180. 	gpio_set_level(RST_Pin, 0);

  181. 	gpio_set_direction(BUSY_Pin, GPIO_MODE_INPUT);

  182.     gpio_set_pull_mode(BUSY_Pin, GPIO_PULLUP_ONLY);

  183. 

  184. #if POWER_Pin

  185. 	gpio_set_direction(POWER_Pin, GPIO_MODE_OUTPUT);

  186. 	gpio_set_level(POWER_Pin, 1);

  187. #endif

  188. 

  189.     spi_lobo_bus_config_t buscfg={

  190.         .miso_io_num = -1,				// set SPI MISO pin

  191.         .mosi_io_num = MOSI_Pin,		// set SPI MOSI pin

  192.         .sclk_io_num = SCK_Pin,			// set SPI CLK pin

  193.         .quadwp_io_num=-1,

  194.         .quadhd_io_num=-1,

  195. 		.max_transfer_sz = 5*1024,		// max transfer size is 4736 bytes

  196.     };

  197.     spi_lobo_device_interface_config_t devcfg={

  198.         .clock_speed_hz=40000000,		// SPI clock is 40 MHz

  199.         .mode=0,						// SPI mode 0

  200.         .spics_io_num=-1,				// we will use external CS pin

  201. 		.spics_ext_io_num = CS_Pin,		// external CS pin

  202. 		.flags=SPI_DEVICE_HALFDUPLEX,	// ALWAYS SET  to HALF DUPLEX MODE for display spi !!

  203.     };

  204. 

  205.     // ====================================================================================================================

  206. 

  207. 

  208. 	vTaskDelay(500 / portTICK_RATE_MS);

  209. 	printf("\r\n=================================\r\n");

  210.     printf("ePaper display DEMO, LoBo 06/2017\r\n");

  211. 	printf("=================================\r\n\r\n");

  212. 

  213. 	// ==================================================================

  214. 	// ==== Initialize the SPI bus and attach the EPD to the SPI bus ====

  215. 

  216. 	ret=spi_lobo_bus_add_device(SPI_BUS, &buscfg, &devcfg, &disp_spi);

  217.     assert(ret==ESP_OK);

  218. 	printf("SPI: display device added to spi bus\r\n");

  219. 

  220. 	// ==== Test select/deselect ====

  221. 	ret = spi_lobo_device_select(disp_spi, 1);

  222.     assert(ret==ESP_OK);

  223. 	ret = spi_lobo_device_deselect(disp_spi);

  224.     assert(ret==ESP_OK);

  225. 

  226. 	printf("SPI: attached display device, speed=%u\r\n", spi_lobo_get_speed(disp_spi));

  227. 	printf("SPI: bus uses native pins: %s\r\n", spi_lobo_uses_native_pins(disp_spi) ? "true" : "false");

  228. 

  229. 	printf("\r\n-------------------\r\n");

  230. 	printf("ePaper demo started\r\n");

  231. 	printf("-------------------\r\n");

  232. 

  233. 

  234. 	EPD_DisplayClearFull();

  235. 

  236. #ifdef CONFIG_EXAMPLE_USE_WIFI

  237. 

  238.     ESP_ERROR_CHECK( nvs_flash_init() );

  239. 

  240.     EPD_DisplayClearPart();

  241. 	EPD_fillScreen(_bg);

  242. 	EPD_setFont(DEFAULT_FONT, NULL);

  243. 	sprintf(tmp_buff, "Waiting for NTP time...");

  244. 	EPD_print(tmp_buff, CENTER, CENTER);

  245. 	EPD_drawRect(10,10,274,108, EPD_BLACK);

  246. 	EPD_drawRect(12,12,270,104, EPD_BLACK);

  247. 	EPD_UpdateScreen();

  248. 

  249. 	// ===== Set time zone ======

  250. 	setenv("TZ", "CET-1CEST", 0);

  251. 	tzset();

  252. 	// ==========================

  253. 

  254.     time(&time_now);

  255. 	tm_info = localtime(&time_now);

  256. 

  257. 	// Is time set? If not, tm_year will be (1970 - 1900).

  258.     if (tm_info->tm_year < (2016 - 1900)) {

  259.         ESP_LOGI(tag, "Time is not set yet. Connecting to WiFi and getting time over NTP.");

  260.         if (obtain_time()) {

  261.         }

  262.         else {

  263.         }

  264.         time(&time_now);

  265.     }

  266. #endif

  267. 

  268.     // ==== Initialize the file system ====

  269.     printf("\r\n\n");

  270. 	vfs_spiffs_register();

  271.     if (spiffs_is_mounted) {

  272.         ESP_LOGI(tag, "File system mounted.");

  273.     }

  274.     else {

  275.         ESP_LOGE(tag, "Error mounting file system.");

  276.     }

  277. 

  278. 	//=========

  279.     // Run demo

  280.     //=========

  281. 

  282. 	/*

  283. 	EPD_DisplayClearFull();

  284.     EPD_DisplayClearPart();

  285. 	EPD_fillScreen(_bg);

  286. 	//EPD_DisplaySetPart(0x00);

  287. 	//EPD_DisplaySetPart(0xFF);

  288. 

  289. 

  290.     uint8_t LUTTest1[31]	= {0x32, 0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x0F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

  291.     uint8_t LUTTest2[31]	= {0x32, 0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x0F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

  292. 	_gs = 0;

  293. 	_fg = 1;

  294. 	_bg = 0;

  295. 	int n = 0;

  296. 	while (1) {

  297. 		//EPD_DisplayClearFull();

  298. 		EPD_fillRect(14, 14, 100, 100, ((n&1) ? 0 : 1));

  299. 		EPD_fillRect(_width/2+14, 14, 100, 100, ((n&1) ? 1 : 0));

  300. 		//LUT_part = LUTTest1;

  301. 		EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  302. 		//EPD_wait(2000);

  303. 		//LUT_part = LUTTest2;

  304. 		//EPD_DisplayFull(disp_buffer);

  305. 		printf("Updated\r\n");

  306. 		EPD_wait(4000);

  307. 		n++;

  308. 

  309. 

  310. 		n = 0;

  311. 		printf("\r\n==== FULL UPDATE TEST ====\r\n\n");

  312. 		EPD_DisplayClearFull();

  313. 		while (n < 2) {

  314. 			EPD_fillScreen(_bg);

  315. 			printf("Black\r\n");

  316. 			EPD_fillRect(0,0,_width/2,_height-1, EPD_BLACK);

  317. 

  318. 			EPD_fillRect(20,20,_width/2-40,_height-1-40, EPD_WHITE);

  319. 			EPD_DisplayFull(disp_buffer);

  320. 			EPD_wait(4000);

  321. 

  322. 			printf("White\r\n");

  323. 			EPD_fillRect(0,0,_width/2,_height-1, EPD_WHITE);

  324. 			EPD_DisplayFull(disp_buffer);

  325. 			EPD_wait(2000);

  326. 			n++;

  327. 		}

  328. 

  329. 		printf("\r\n==== PARTIAL UPDATE TEST ====\r\n\n");

  330. 		EPD_DisplayClearFull();

  331. 		n = 0;

  332. 		while (n < 2) {

  333. 			EPD_fillScreen(_bg);

  334. 			printf("Black\r\n");

  335. 			EPD_fillRect(0,0,_width/2,_height-1, EPD_BLACK);

  336. 

  337. 			EPD_fillRect(20,20,_width/2-40,_height-1-40, EPD_WHITE);

  338. 			EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  339. 			EPD_wait(4000);

  340. 

  341. 			printf("White\r\n");

  342. 			EPD_fillRect(0,0,_width/2,_height-1, EPD_WHITE);

  343. 			EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  344. 			EPD_wait(2000);

  345. 			n++;

  346. 		}

  347. 

  348. 		printf("\r\n==== PARTIAL UPDATE TEST - gray scale ====\r\n\n");

  349. 		EPD_DisplayClearFull();

  350. 		n = 0;

  351. 		while (n < 3) {

  352. 			EPD_fillScreen(_bg);

  353. 			LUT_part = LUT_gs;

  354. 			for (uint8_t sh=1; sh<16; sh++) {

  355. 				LUT_gs[21] = sh;

  356. 				printf("Black (%d)\r\n", LUT_gs[21]);

  357. 				EPD_fillRect((sh-1)*19,0,19,_height, EPD_BLACK);

  358. 				EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  359. 			}

  360. 			EPD_wait(4000);

  361. 

  362. 			//LUT_part = LUTDefault_part;

  363. 			printf("White\r\n");

  364. 			//EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  365. 			//EPD_DisplaySetPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, 0xFF);

  366. 			LUT_gs[21] = 15;

  367. 			LUT_gs[1] = 0x28;

  368. 			EPD_fillRect(190,0,76,_height, EPD_WHITE);

  369. 			EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  370. 			EPD_wait(2000);

  371. 

  372. 			EPD_fillRect(0,0,_width,_height, EPD_WHITE);

  373. 			EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  374. 			LUT_gs[1] = 0x18;

  375. 			EPD_wait(2000);

  376. 			n++;

  377. 		}

  378. 		LUT_part = LUTDefault_part;

  379. 	}

  380. */

  381. 

  382. 

  383. 	printf("==== START ====\r\n\n");

  384. 

  385. 	_gs = 1;

  386. 	uint32_t tstart;

  387. 	int pass = 0, ftype = 9;

  388.     while (1) {

  389.     	ftype++;

  390.     	if (ftype > 10) {

  391.     		ftype = 1;

  392.     		for (int t=40; t>0; t--) {

  393. 				printf("Wait %d seconds ...  \r", t);

  394. 				fflush(stdout);

  395. 				EPD_wait(100);

  396.     		}

  397. 			printf("                      \r");

  398. 			fflush(stdout);

  399. 			_gs ^= 1;

  400.     	}

  401.     	printf("\r\n-- Test %d\r\n", ftype);

  402.     	EPD_DisplayClearPart();

  403. 

  404.     	//EPD_Cls(0);

  405. 		EPD_fillScreen(_bg);

  406. 		_fg = 15;

  407. 		_bg = 0;

  408. 

  409. 		EPD_drawRect(1,1,294,126, EPD_BLACK);

  410. 

  411. 		int y = 4;

  412. 		tstart = clock();

  413. 		if (ftype == 1) {

  414. 			for (int f=0; f<4; f++) {

  415. 				if (f == 0) _fg = 15;

  416. 				else if (f == 1) _fg = 9;

  417. 				else if (f == 2) _fg = 5;

  418. 				else if (f == 2) _fg = 3;

  419. 				EPD_setFont(f, NULL);

  420. 				if (f == 3) {

  421. 					EPD_print("Welcome to ", 4, y);

  422. 					font_rotate = 90;

  423. 					EPD_print("ESP32", EPD_getStringWidth("Welcome to ")+EPD_getfontheight()+4, y);

  424. 					font_rotate = 0;

  425. 				}

  426. 				else if (f == 1) {

  427. 					EPD_print("HR chars: \xA6\xA8\xB4\xB5\xB0", 4, y);

  428. 				}

  429. 				else {

  430. 					EPD_print("Welcome to ESP32", 4, y);

  431. 				}

  432. 				y += EPD_getfontheight() + 2;

  433. 			}

  434. 			font_rotate = 45;

  435. 			EPD_print("ESP32", LASTX+8, LASTY);

  436. 			font_rotate = 0;

  437. 			_fg = 15;

  438. 

  439. 			EPD_setFont(DEFAULT_FONT, NULL);

  440. 			sprintf(tmp_buff, "Pass: %d", pass+1);

  441. 			EPD_print(tmp_buff, 4, 128-EPD_getfontheight()-2);

  442. 			EPD_UpdateScreen();

  443. 		}

  444. 		else if (ftype == 2) {

  445. 			orientation = LANDSCAPE_180;

  446. 			for (int f=4; f<FONT_7SEG; f++) {

  447. 				if (f == 4) _fg = 15;

  448. 				else if (f == 5) _fg = 9;

  449. 				else if (f == 6) _fg = 5;

  450. 				else if (f == 7) _fg = 3;

  451. 				EPD_setFont(f, NULL);

  452. 				EPD_print("Welcome to ESP32", 4, y);

  453. 				y += EPD_getfontheight() + 1;

  454. 			}

  455. 			_fg = 15;

  456. 			EPD_setFont(DEFAULT_FONT, NULL);

  457. 			sprintf(tmp_buff, "Pass: %d (rotated 180)", pass+1);

  458. 			EPD_print(tmp_buff, 4, 128-EPD_getfontheight()-2);

  459. 			orientation = LANDSCAPE_0;

  460. 			EPD_UpdateScreen();

  461. 		}

  462. 		else if (ftype == 3) {

  463. 			for (int f=0; f<3; f++) {

  464. 				if (f == 0) _fg = 15;

  465. 				else if (f == 1) _fg = 9;

  466. 				else if (f == 2) _fg = 5;

  467. 				EPD_setFont(USER_FONT, file_fonts[f]);

  468. 				if (f == 0) font_line_space = 4;

  469. 				EPD_print("Welcome to ESP32", 4, y);

  470. 				font_line_space = 0;

  471. 				y += EPD_getfontheight() + 2;

  472. 			}

  473. 			_fg = 15;

  474. 			EPD_setFont(DEFAULT_FONT, NULL);

  475. 			sprintf(tmp_buff, "Pass: %d (Fonts from file)", pass+1);

  476. 			EPD_print(tmp_buff, 4, 128-EPD_getfontheight()-2);

  477. 			EPD_UpdateScreen();

  478. 		}

  479. 		else if (ftype == 4) {

  480. 			y = 16;

  481. 			time(&time_now);

  482. 			tm_info = localtime(&time_now);

  483. 			int _sec = -1, y2, _day = -1;

  484. 

  485. 			EPD_setFont(FONT_7SEG, NULL);

  486. 			set_7seg_font_atrib(10, 2, 0, 15);

  487. 			y2 = y + EPD_getfontheight() + 10;

  488. 

  489. 			for (int t=0; t<100; t++) {

  490. 				time(&time_now);

  491. 				tm_info = localtime(&time_now);

  492. 				if (tm_info->tm_sec != _sec) {

  493. 					_sec = tm_info->tm_sec;

  494. 					sprintf(tmp_buff, "%02d:%02d:%02d", tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec);

  495. 					_fg = 15;							// fill = 15

  496. 					set_7seg_font_atrib(10, 2, 0, 15);	// outline = 15

  497. 					EPD_print(tmp_buff, CENTER, y);

  498. 					_fg = 15;

  499. 					if (tm_info->tm_mday != _day) {

  500. 						sprintf(tmp_buff, "%02d.%02d.%04d", tm_info->tm_mday, tm_info->tm_mon + 1, tm_info->tm_year+1900);

  501. 						_fg = 7;							// fill = 7

  502. 						set_7seg_font_atrib(8, 2, 1, 15);	// outline = 15

  503. 						EPD_print(tmp_buff, CENTER, y2);

  504. 						_fg = 15;

  505. 					}

  506. 					EPD_UpdateScreen();

  507. 				}

  508. 				EPD_wait(100);

  509. 			}

  510. 			tstart = clock();

  511. 			_fg = 15;

  512. 			EPD_setFont(DEFAULT_FONT, NULL);

  513. 			font_rotate = 90;

  514. 			sprintf(tmp_buff, "%02d:%02d:%02d %02d/%02d", tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, tm_info->tm_mday, tm_info->tm_mon + 1);

  515. 			EPD_print(tmp_buff, 20, 4);

  516. 			font_rotate = 0;

  517. 			sprintf(tmp_buff, "Pass: %d", pass+1);

  518. 			EPD_print(tmp_buff, 4, 128-EPD_getfontheight()-2);

  519. 			EPD_UpdateScreen();

  520. 		}

  521. 		else if (ftype == 5) {

  522. 			uint8_t old_gs = _gs;

  523. 			_gs = 1;

  524. 			EPD_drawRect(4,4,20,20, 15);

  525. 

  526. 			EPD_fillRect(27,5,18,18, 1);

  527. 			EPD_drawRect(26,4,20,20, 15);

  528. 

  529. 			EPD_drawCircle(66,16,10, 15);

  530. 

  531. 			EPD_fillCircle(92,16,10, 2);

  532. 			EPD_drawCircle(92,16,11, 15);

  533. 

  534. 			EPD_fillRect(185,4,80,80, 3);

  535. 			EPD_drawRect(185,4,80,80, 15);

  536. 

  537. 			EPD_fillCircle(225,44,35, 0);

  538. 			EPD_drawCircle(225,44,35, 15);

  539. 			EPD_fillCircle(225,44,35, 5);

  540. 

  541. 			EPD_fillCircle(225,44,20, 0);

  542. 			EPD_drawCircle(225,44,20, 15);

  543. 

  544. 			orientation = LANDSCAPE_180;

  545. 			EPD_drawRect(4,4,20,20, 15);

  546. 

  547. 			EPD_fillRect(27,5,18,18, 1);

  548. 			EPD_drawRect(26,4,20,20, 15);

  549. 

  550. 			EPD_drawCircle(66,16,10, 15);

  551. 

  552. 			EPD_fillCircle(92,16,10, 2);

  553. 			EPD_drawCircle(92,16,11, 15);

  554. 

  555. 			EPD_fillRect(185,4,80,80, 3);

  556. 			EPD_drawRect(185,4,80,80, 15);

  557. 

  558. 			EPD_fillCircle(225,44,35, 0);

  559. 			EPD_drawCircle(225,44,35, 15);

  560. 			EPD_fillCircle(225,44,35, 5);

  561. 

  562. 			EPD_fillCircle(225,44,20, 0);

  563. 			EPD_drawCircle(225,44,20, 15);

  564. 			orientation = LANDSCAPE_0;

  565. 

  566. 			EPD_setFont(DEFAULT_FONT, NULL);

  567. 			font_rotate = 90;

  568. 			sprintf(tmp_buff, "Pass: %d", pass+1);

  569. 			EPD_print("Gray scale demo", _width/2+EPD_getfontheight()+2, 4);

  570. 			EPD_print(tmp_buff, _width/2, 4);

  571. 			font_rotate = 0;

  572. 

  573. 			EPD_UpdateScreen();

  574. 			_gs = old_gs;

  575. 		}

  576. 		else if (ftype == 6) {

  577. 			uint8_t old_gs = _gs;

  578. 			_gs = 0;

  579. 			memcpy(disp_buffer, (unsigned char *)gImage_img1, sizeof(gImage_img1));

  580. 

  581. 			EPD_setFont(DEFAULT_FONT, NULL);

  582. 			sprintf(tmp_buff, "Pass: %d", pass+1);

  583. 			EPD_print(tmp_buff, 4, 128-EPD_getfontheight()-2);

  584. 

  585. 			EPD_UpdateScreen();

  586. 			_gs = old_gs;

  587. 		}

  588. 		else if (ftype == 7) {

  589. 			uint8_t old_gs = _gs;

  590. 			_gs = 0;

  591. 			memcpy(disp_buffer, (unsigned char *)gImage_img3, sizeof(gImage_img3));

  592. 

  593. 			EPD_setFont(DEFAULT_FONT, NULL);

  594. 			_fg = 0;

  595. 			_bg = 1;

  596. 			sprintf(tmp_buff, "Pass: %d", pass+1);

  597. 			EPD_print(tmp_buff, 4, 128-EPD_getfontheight()-2);

  598. 

  599. 			EPD_UpdateScreen();

  600. 			_fg = 15;

  601. 			_bg = 0;

  602. 			_gs = old_gs;

  603. 		}

  604. 		else if (ftype == 8) {

  605. 			uint8_t old_gs = _gs;

  606. 			_gs = 1;

  607. 			int i, x, y;

  608. 	        uint8_t last_lvl = 0;

  609. 		    for (i=0; i<16; i++) {

  610. 		        for (x = 0; x < EPD_DISPLAY_WIDTH; x++) {

  611. 		          for (y = 0; y < EPD_DISPLAY_HEIGHT; y++) {

  612. 		        	  uint8_t pix = img_hacking[(x * EPD_DISPLAY_HEIGHT) + (EPD_DISPLAY_HEIGHT-y-1)];

  613. 		        	  if ((pix > last_lvl) && (pix <= lvl_buf[i])) {

  614. 		        		  gs_disp_buffer[(y * EPD_DISPLAY_WIDTH) + x] = i;

  615. 		        		  gs_used_shades |= (1 << i);

  616. 		        	  }

  617. 		          }

  618. 		        }

  619. 		        last_lvl = lvl_buf[i];

  620. 		    }

  621. 

  622. 			EPD_setFont(DEFAULT_FONT, NULL);

  623. 			sprintf(tmp_buff, "Pass: %d (Gray scale image)", pass+1);

  624. 			EPD_print(tmp_buff, 4, 128-EPD_getfontheight()-2);

  625. 

  626. 			EPD_UpdateScreen();

  627. 			_gs = old_gs;

  628. 		}

  629. 		else if (ftype == 9) {

  630. 			uint8_t old_gs = _gs;

  631. 			_gs = 0;

  632. 			memcpy(disp_buffer, gImage_img2, sizeof(gImage_img2));

  633. 

  634. 			EPD_setFont(DEFAULT_FONT, NULL);

  635. 			sprintf(tmp_buff, "Pass: %d", pass+1);

  636. 			EPD_print(tmp_buff, 4, 4);

  637. 

  638. 			EPD_UpdateScreen();

  639. 			_gs = old_gs;

  640. 		}

  641. 		else if (ftype == 10) {

  642. 			if (spiffs_is_mounted) {

  643. 				// ** Show scaled (1/8, 1/4, 1/2 size) JPG images

  644. 					uint8_t old_gs = _gs;

  645. 					_gs = 1;

  646. 					EPD_Cls();

  647. 					EPD_jpg_image(CENTER, CENTER, 0, SPIFFS_BASE_PATH"/images/evolution-of-human.jpg", NULL, 0);

  648. 					EPD_UpdateScreen();

  649. 					EPD_wait(5000);

  650. 

  651. 					EPD_Cls();

  652. 					EPD_jpg_image(CENTER, CENTER, 0, SPIFFS_BASE_PATH"/images/people_silhouettes.jpg", NULL, 0);

  653. 					EPD_UpdateScreen();

  654. 					EPD_wait(5000);

  655. 

  656. 					EPD_Cls();

  657. 					EPD_jpg_image(CENTER, CENTER, 0, SPIFFS_BASE_PATH"/images/silhouettes-dancing.jpg", NULL, 0);

  658. 					EPD_UpdateScreen();

  659. 					EPD_wait(5000);

  660. 

  661. 					EPD_Cls();

  662. 					EPD_jpg_image(CENTER, CENTER, 0, SPIFFS_BASE_PATH"/images/girl_silhouettes.jpg", NULL, 0);

  663. 					EPD_UpdateScreen();

  664. 					EPD_wait(5000);

  665. 

  666. 					EPD_Cls();

  667. 					EPD_jpg_image(CENTER, CENTER, 0, SPIFFS_BASE_PATH"/images/animal-silhouettes.jpg", NULL, 0);

  668. 					EPD_UpdateScreen();

  669. 					EPD_wait(5000);

  670. 

  671. 					EPD_Cls();

  672. 					EPD_jpg_image(CENTER, CENTER, 0, SPIFFS_BASE_PATH"/images/Flintstones.jpg", NULL, 0);

  673. 					EPD_UpdateScreen();

  674. 					EPD_wait(5000);

  675. 

  676. 					_gs = old_gs;

  677. 			}

  678. 		}

  679. 

  680. 		//EPD_DisplayPart(0, EPD_DISPLAY_WIDTH-1, 0, EPD_DISPLAY_HEIGHT-1, disp_buffer);

  681. 		tstart = clock() - tstart;

  682. 		pass++;

  683.     	printf("-- Type: %d Pass: %d Time: %u ms\r\n", ftype, pass, tstart);

  684. 

  685.     	EPD_PowerOff();

  686. 		EPD_wait(8000);

  687.     }

  688. 

  689. }