display.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400
  1. /*
  2. * (c) Philippe G. 2019, philippe_44@outlook.com
  3. *
  4. * This software is released under the MIT License.
  5. * https://opensource.org/licenses/MIT
  6. *
  7. */
  8. #include <string.h>
  9. #include <ctype.h>
  10. #include <stdint.h>
  11. #include <arpa/inet.h>
  12. #include "esp_log.h"
  13. #include "globdefs.h"
  14. #include "platform_config.h"
  15. #include "tools.h"
  16. #include "display.h"
  17. #include "gds.h"
  18. #include "gds_default_if.h"
  19. #include "gds_draw.h"
  20. #include "gds_text.h"
  21. #include "gds_font.h"
  22. static const char *TAG = "display";
  23. #define min(a,b) (((a) < (b)) ? (a) : (b))
  24. #define max(a,b) (((a) > (b)) ? (a) : (b))
  25. #define DISPLAYER_STACK_SIZE (3*1024)
  26. #define SCROLLABLE_SIZE 384
  27. #define HEADER_SIZE 64
  28. #define DEFAULT_SLEEP 3600
  29. static EXT_RAM_ATTR struct {
  30. TaskHandle_t task;
  31. SemaphoreHandle_t mutex;
  32. int pause, speed, by;
  33. enum { DISPLAYER_DOWN, DISPLAYER_IDLE, DISPLAYER_ACTIVE } state;
  34. char header[HEADER_SIZE + 1];
  35. char string[SCROLLABLE_SIZE + 1];
  36. int offset, boundary;
  37. char *metadata_config;
  38. bool timer, refresh;
  39. uint32_t elapsed, duration;
  40. TickType_t tick;
  41. } displayer;
  42. static const char *known_drivers[] = {"SH1106",
  43. "SSD1306",
  44. "SSD1322",
  45. "SSD1326",
  46. "SSD1327",
  47. "SSD1675",
  48. "SSD1351",
  49. "ST77xx",
  50. "ILI9341",
  51. NULL
  52. };
  53. static void displayer_task(void *args);
  54. struct GDS_Device *display;
  55. extern GDS_DetectFunc SSD1306_Detect, SSD132x_Detect, SH1106_Detect, SSD1675_Detect, SSD1322_Detect, SSD1351_Detect, ST77xx_Detect, ILI9341_Detect;
  56. GDS_DetectFunc *drivers[] = { SH1106_Detect, SSD1306_Detect, SSD132x_Detect, SSD1675_Detect, SSD1322_Detect, SSD1351_Detect, ST77xx_Detect, ILI9341_Detect, NULL };
  57. /****************************************************************************************
  58. *
  59. */
  60. void display_init(char *welcome) {
  61. bool init = false;
  62. char *config = config_alloc_get(NVS_TYPE_STR, "display_config");
  63. if (!config) {
  64. ESP_LOGI(TAG, "no display");
  65. return;
  66. }
  67. int width = -1, height = -1, backlight_pin = -1;
  68. char *p, *drivername = strstr(config, "driver");
  69. if ((p = strcasestr(config, "width")) != NULL) width = atoi(strchr(p, '=') + 1);
  70. if ((p = strcasestr(config, "height")) != NULL) height = atoi(strchr(p, '=') + 1);
  71. if ((p = strcasestr(config, "back")) != NULL) backlight_pin = atoi(strchr(p, '=') + 1);
  72. // query drivers to see if we have a match
  73. ESP_LOGI(TAG, "Trying to configure display with %s", config);
  74. if (backlight_pin >= 0) {
  75. struct GDS_BacklightPWM PWMConfig = { .Channel = pwm_system.base_channel++, .Timer = pwm_system.timer, .Max = pwm_system.max, .Init = false };
  76. display = GDS_AutoDetect(drivername, drivers, &PWMConfig);
  77. } else {
  78. display = GDS_AutoDetect(drivername, drivers, NULL);
  79. }
  80. // so far so good
  81. if (display && width > 0 && height > 0) {
  82. int RST_pin = -1;
  83. if ((p = strcasestr(config, "reset")) != NULL) RST_pin = atoi(strchr(p, '=') + 1);
  84. // Detect driver interface
  85. if (strstr(config, "I2C") && i2c_system_port != -1) {
  86. int address = 0x3C;
  87. if ((p = strcasestr(config, "address")) != NULL) address = atoi(strchr(p, '=') + 1);
  88. init = true;
  89. GDS_I2CInit( i2c_system_port, -1, -1, i2c_system_speed ) ;
  90. GDS_I2CAttachDevice( display, width, height, address, RST_pin, backlight_pin );
  91. ESP_LOGI(TAG, "Display is I2C on port %u", address);
  92. } else if (strstr(config, "SPI") && spi_system_host != -1) {
  93. int CS_pin = -1, speed = 0;
  94. if ((p = strcasestr(config, "cs")) != NULL) CS_pin = atoi(strchr(p, '=') + 1);
  95. if ((p = strcasestr(config, "speed")) != NULL) speed = atoi(strchr(p, '=') + 1);
  96. init = true;
  97. GDS_SPIInit( spi_system_host, spi_system_dc_gpio );
  98. GDS_SPIAttachDevice( display, width, height, CS_pin, RST_pin, backlight_pin, speed );
  99. ESP_LOGI(TAG, "Display is SPI host %u with cs:%d", spi_system_host, CS_pin);
  100. } else {
  101. display = NULL;
  102. ESP_LOGI(TAG, "Unsupported display interface or serial link not configured");
  103. }
  104. } else {
  105. display = NULL;
  106. ESP_LOGW(TAG, "No display driver");
  107. }
  108. if (init) {
  109. static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4)));
  110. static EXT_RAM_ATTR StackType_t xStack[DISPLAYER_STACK_SIZE] __attribute__ ((aligned (4)));
  111. GDS_SetHFlip(display, strcasestr(config, "HFlip") ? true : false);
  112. GDS_SetVFlip(display, strcasestr(config, "VFlip") ? true : false);
  113. GDS_SetFont(display, &Font_droid_sans_fallback_15x17 );
  114. GDS_TextPos(display, GDS_FONT_MEDIUM, GDS_TEXT_CENTERED, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, welcome);
  115. // start the task that will handle scrolling & counting
  116. displayer.mutex = xSemaphoreCreateMutex();
  117. displayer.by = 2;
  118. displayer.pause = 3600;
  119. displayer.speed = 33;
  120. displayer.task = xTaskCreateStatic( (TaskFunction_t) displayer_task, "displayer_thread", DISPLAYER_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
  121. // set lines for "fixed" text mode
  122. GDS_TextSetFontAuto(display, 1, GDS_FONT_LINE_1, -3);
  123. GDS_TextSetFontAuto(display, 2, GDS_FONT_LINE_2, -3);
  124. displayer.metadata_config = config_alloc_get(NVS_TYPE_STR, "metadata_config");
  125. }
  126. free(config);
  127. }
  128. /****************************************************************************************
  129. * This is not thread-safe as displayer_task might be in the middle of line drawing
  130. * but it won't crash (I think) and making it thread-safe would be complicated for a
  131. * feature which is secondary (the LMS version of scrolling is thread-safe)
  132. */
  133. static void displayer_task(void *args) {
  134. int scroll_sleep = 0, timer_sleep;
  135. while (1) {
  136. // suspend ourselves if nothing to do
  137. if (displayer.state < DISPLAYER_ACTIVE) {
  138. if (displayer.state == DISPLAYER_IDLE) GDS_TextLine(display, 2, 0, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, displayer.string);
  139. vTaskSuspend(NULL);
  140. scroll_sleep = 0;
  141. GDS_ClearExt(display, true);
  142. GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_UPDATE, displayer.header);
  143. } else if (displayer.refresh) {
  144. // little trick when switching master while in IDLE and missing it
  145. GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, displayer.header);
  146. displayer.refresh = false;
  147. }
  148. // we have been waken up before our requested time
  149. if (scroll_sleep <= 10) {
  150. // something to scroll (or we'll wake-up every pause ms ... no big deal)
  151. if (*displayer.string && displayer.state == DISPLAYER_ACTIVE) {
  152. xSemaphoreTake(displayer.mutex, portMAX_DELAY);
  153. // need to work with local copies as we don't want to suspend caller
  154. int offset = -displayer.offset;
  155. char *string = strdup(displayer.string);
  156. scroll_sleep = displayer.offset ? displayer.speed : displayer.pause;
  157. displayer.offset = displayer.offset >= displayer.boundary ? 0 : (displayer.offset + min(displayer.by, displayer.boundary - displayer.offset));
  158. xSemaphoreGive(displayer.mutex);
  159. // now display using safe copies, can be lengthy
  160. GDS_TextLine(display, 2, offset, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, string);
  161. free(string);
  162. } else {
  163. scroll_sleep = DEFAULT_SLEEP;
  164. }
  165. }
  166. // handler elapsed track time
  167. if (displayer.timer && displayer.state == DISPLAYER_ACTIVE) {
  168. char counter[16];
  169. TickType_t tick = xTaskGetTickCount();
  170. uint32_t elapsed = (tick - displayer.tick) * portTICK_PERIOD_MS;
  171. if (elapsed >= 1000) {
  172. xSemaphoreTake(displayer.mutex, portMAX_DELAY);
  173. displayer.tick = tick;
  174. displayer.elapsed += elapsed / 1000;
  175. xSemaphoreGive(displayer.mutex);
  176. if (displayer.elapsed < 3600) snprintf(counter, 16, "%5u:%02u", displayer.elapsed / 60, displayer.elapsed % 60);
  177. else snprintf(counter, 16, "%2u:%02u:%02u", displayer.elapsed / 3600, (displayer.elapsed % 3600) / 60, displayer.elapsed % 60);
  178. GDS_TextLine(display, 1, GDS_TEXT_RIGHT, (GDS_TEXT_CLEAR | GDS_TEXT_CLEAR_EOL) | GDS_TEXT_UPDATE, counter);
  179. timer_sleep = 1000;
  180. } else timer_sleep = max(1000 - elapsed, 0);
  181. } else timer_sleep = DEFAULT_SLEEP;
  182. // then sleep the min amount of time
  183. int sleep = min(scroll_sleep, timer_sleep);
  184. ESP_LOGD(TAG, "timers s:%d t:%d", scroll_sleep, timer_sleep);
  185. scroll_sleep -= sleep;
  186. vTaskDelay(sleep / portTICK_PERIOD_MS);
  187. }
  188. }
  189. /****************************************************************************************
  190. *
  191. */
  192. void displayer_metadata(char *artist, char *album, char *title) {
  193. char *string = displayer.string, *p;
  194. int len = SCROLLABLE_SIZE;
  195. // need a display!
  196. if (!display) return;
  197. // just do title if there is no config set
  198. if (!displayer.metadata_config) {
  199. strncpy(displayer.string, title ? title : "", SCROLLABLE_SIZE);
  200. return;
  201. }
  202. xSemaphoreTake(displayer.mutex, portMAX_DELAY);
  203. // format metadata parameters and write them directly
  204. if ((p = strcasestr(displayer.metadata_config, "format")) != NULL) {
  205. char token[16], *q;
  206. int space = len;
  207. bool skip = false;
  208. displayer.string[0] = '\0';
  209. p = strchr(displayer.metadata_config, '=');
  210. while (p++) {
  211. // find token and copy what's after when reaching last one
  212. if (sscanf(p, "%*[^%%]%%%[^%]%%", token) < 0) {
  213. q = strchr(p, ',');
  214. strncat(string, p, q ? min(q - p, space) : space);
  215. break;
  216. }
  217. // copy what's before token (be safe)
  218. if ((q = strchr(p, '%')) == NULL) break;
  219. // skip whatever is after a token if this token is empty
  220. if (!skip) {
  221. strncat(string, p, min(q - p, space));
  222. space = len - strlen(string);
  223. }
  224. // then copy token's content
  225. if (!strncasecmp(q + 1, "artist", 6) && artist) strncat(string, p = artist, space);
  226. else if (!strncasecmp(q + 1, "album", 5) && album) strncat(string, p = album, space);
  227. else if (!strncasecmp(q + 1, "title", 5) && title) strncat(string, p = title, space);
  228. space = len - strlen(string);
  229. // flag to skip the data following an empty field
  230. if (*p) skip = false;
  231. else skip = true;
  232. // advance to next separator
  233. p = strchr(q + 1, '%');
  234. }
  235. } else {
  236. strncpy(string, title ? title : "", SCROLLABLE_SIZE);
  237. }
  238. // get optional scroll speed & pause
  239. if ((p = strcasestr(displayer.metadata_config, "speed")) != NULL) sscanf(p, "%*[^=]=%d", &displayer.speed);
  240. if ((p = strcasestr(displayer.metadata_config, "pause")) != NULL) sscanf(p, "%*[^=]=%d", &displayer.pause);
  241. displayer.offset = 0;
  242. utf8_decode(displayer.string);
  243. ESP_LOGI(TAG, "playing %s", displayer.string);
  244. displayer.boundary = GDS_TextStretch(display, 2, displayer.string, SCROLLABLE_SIZE);
  245. xSemaphoreGive(displayer.mutex);
  246. }
  247. /****************************************************************************************
  248. *
  249. */
  250. void displayer_scroll(char *string, int speed, int pause) {
  251. // need a display!
  252. if (!display) return;
  253. xSemaphoreTake(displayer.mutex, portMAX_DELAY);
  254. if (speed) displayer.speed = speed;
  255. if (pause) displayer.pause = pause;
  256. displayer.offset = 0;
  257. strncpy(displayer.string, string, SCROLLABLE_SIZE);
  258. displayer.string[SCROLLABLE_SIZE] = '\0';
  259. displayer.boundary = GDS_TextStretch(display, 2, displayer.string, SCROLLABLE_SIZE);
  260. xSemaphoreGive(displayer.mutex);
  261. }
  262. /****************************************************************************************
  263. *
  264. */
  265. void displayer_timer(enum displayer_time_e mode, int elapsed, int duration) {
  266. // need a display!
  267. if (!display) return;
  268. xSemaphoreTake(displayer.mutex, portMAX_DELAY);
  269. if (elapsed >= 0) displayer.elapsed = elapsed / 1000;
  270. if (duration >= 0) displayer.duration = duration / 1000;
  271. if (displayer.timer) displayer.tick = xTaskGetTickCount();
  272. xSemaphoreGive(displayer.mutex);
  273. }
  274. /****************************************************************************************
  275. * See above comment
  276. */
  277. void displayer_control(enum displayer_cmd_e cmd, ...) {
  278. va_list args;
  279. if (!display) return;
  280. va_start(args, cmd);
  281. xSemaphoreTake(displayer.mutex, portMAX_DELAY);
  282. switch(cmd) {
  283. case DISPLAYER_ACTIVATE: {
  284. char *header = va_arg(args, char*);
  285. strncpy(displayer.header, header, HEADER_SIZE);
  286. displayer.header[HEADER_SIZE] = '\0';
  287. displayer.state = DISPLAYER_ACTIVE;
  288. displayer.timer = false;
  289. displayer.refresh = true;
  290. displayer.string[0] = '\0';
  291. displayer.elapsed = displayer.duration = 0;
  292. displayer.offset = displayer.boundary = 0;
  293. display_bus(&displayer, DISPLAY_BUS_TAKE);
  294. vTaskResume(displayer.task);
  295. break;
  296. }
  297. case DISPLAYER_SUSPEND:
  298. // task will display the line 2 from beginning and suspend
  299. displayer.state = DISPLAYER_IDLE;
  300. display_bus(&displayer, DISPLAY_BUS_GIVE);
  301. break;
  302. case DISPLAYER_SHUTDOWN:
  303. // let the task self-suspend (we might be doing i2c_write)
  304. displayer.state = DISPLAYER_DOWN;
  305. display_bus(&displayer, DISPLAY_BUS_GIVE);
  306. break;
  307. case DISPLAYER_TIMER_RUN:
  308. if (!displayer.timer) {
  309. display_bus(&displayer, DISPLAY_BUS_TAKE);
  310. displayer.timer = true;
  311. displayer.tick = xTaskGetTickCount();
  312. }
  313. break;
  314. case DISPLAYER_TIMER_PAUSE:
  315. displayer.timer = false;
  316. break;
  317. default:
  318. break;
  319. }
  320. xSemaphoreGive(displayer.mutex);
  321. va_end(args);
  322. }
  323. /****************************************************************************************
  324. *
  325. */
  326. bool display_is_valid_driver(char * driver){
  327. return display_conf_get_driver_name(driver)!=NULL;
  328. }
  329. char * display_conf_get_driver_name(char * driver){
  330. for(uint8_t i=0;known_drivers[i]!=NULL && strlen(known_drivers[i])>0;i++ ){
  331. if(strcasestr(driver,known_drivers[i])){
  332. return known_drivers[i];
  333. }
  334. }
  335. return NULL;
  336. }