Lines Matching full:the
11 data type that represents a single display panel --- the hardware that displays
12 LVGL-rendered pixels on your device. During system initialization, you must do the
32 - Have two large TFT displays: one for a customer and one for the shop assistant.
34 If you set up LVGL to use more than one display, be aware that some functions use the
49 Once created, a Display object remembers the characteristics of the display hardware
60 - The :ref:`draw_buffers` assigned to it
61 - The :ref:`flush_callback` function that moves pixels from :ref:`draw_buffers` to Display hardware
62 - What areas of the display have been updated (made "dirty") so rendering logic can
80 1, 3 and 4 are independent of the :ref:`active_screen` and they will be shown (if
81 they contain anything that is visible) regardless of which screen is the
86 For the bottom layer to be visible, the Active Screen's background has to be
89 You can get pointers to each of these screens on the :ref:`default_display` by using
105 To set a Screen you create to be the :ref:`active_screen`, call
113 LVGL uses the Top Layer and System Layer two empower you to ensure that certain
116 You can add "pop-up windows" to the *Top Layer* freely. The Top Layer was meant to
118 the *System Layer* is intended for system-level things (e.g. mouse cursor will be
125 While the Top Layer and System Layer are created by their owning :ref:`display`
126 as not scroll-able and not click-able, these behaviors can be overridden the same
130 If the :cpp:enumerator:`LV_OBJ_FLAG_CLICKABLE` flag is set on the Top Layer, then it will
142 Similar to the Top- and System Layers, the Bottom Layer is also the full size of the
143 Display, but it is located below the :ref:`active_screen`. It's visible only if the
156 If you added ``user_data`` to the Display, you can retrieve it in an event like this:
165 The following events are sent:
169 variable with the coordinates of the area to be invalidated. The area can
170 be freely modified if needed to adopt it the special requirement of the
175 …NT_REFR_READY`: Sent when refreshing is ready (after rendering and calling the :ref:`flush_callbac…
177 - :cpp:enumerator:`LV_EVENT_RENDER_READY`: Sent when rendering is ready (before calling the :ref:`f…
178 - :cpp:enumerator:`LV_EVENT_FLUSH_START`: Sent before the :ref:`flush_callback` is called.
179 - :cpp:enumerator:`LV_EVENT_FLUSH_READY`: Sent when the :ref:`flush_callback` returned.
180 - :cpp:enumerator:`LV_EVENT_RESOLUTION_CHANGED`: Sent when the resolution changes due
214 When the first :ref:`display` object is created, it becomes the Default Display. If
215 other Display Objects are created (to service additional Display Panels), the Default
216 Display remains the first one created.
218 To set another :ref:`display` as the Default Display, call :cpp:func:`lv_display_set_default`.
222 For many ``lv_display_...()`` functions, passing NULL for the ``disp`` argument will
223 cause the function to target the Default Display. Check the API documentation for
224 the function you are calling to be sure.
242 - ``render_mode`` is one of the following:
244 - :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_PARTIAL` Use the buffer(s) to render
245 to the display using buffers smaller than the size of the display. Use of
246 buffers at least 1/10 display size is recommended. In :ref:`flush_callback` the rendered
247 images needs to be copied to the given area of the display. In this mode if a
248 button is pressed only the button's area will be redrawn.
249 - :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_DIRECT` The buffer size(es) must match
250 the size of the display. LVGL will render into the correct location of the
251 buffer. Using this method the buffer(s) always contain the whole display image.
252 If two buffer are used, the rendered areas are automatically copied to the
255 only the button's area will be redrawn.
256 - :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_FULL` The buffer size(es) must match
257 the size of the display. LVGL will always redraw the whole screen even if only
260 the :ref:`flush_callback` callback only has to update the address of the frame buffer to
261 the ``px_map`` parameter.
278 If only one buffer is used, LVGL draws the content of the screen into
279 that draw buffer and sends it to the display via the :ref:`flush_callback`. LVGL
281 (that is, the content of the buffer has been sent to the
287 If two buffers are used LVGL can draw into one buffer while the content
288 of the other buffer is sent to the display in the background. DMA or
289 other hardware should be used to transfer data to the display so the MCU
290 can continue drawing. Doing so allows *rendering* and *refreshing* the
299 Draw buffer(s) are simple array(s) that LVGL uses to render the display's
300 content. Once rendering is has been completed, the content of the draw buffer is
301 sent to the display using a Flush Callback function.
309 /* The most simple case (also the slowest) to send all rendered pixels to the
326 rendered pixel-buffers to a particular display by doing the following:
332 Note that which display is targeted is passed to the function, so you can use the
339 complete to inform LVGL that the buffer is available again to render new content
342 LVGL might render the screen in multiple chunks and therefore call your Flush
343 Callback multiple times. To see whether the current call is for the last chunk being
355 To set the resolution of the display after creation use
358 It's not mandatory to use the whole display for LVGL, however in some
359 cases the physical resolution is important. For example the touchpad
360 still sees the whole resolution and the values needs to be converted to
361 the active LVGL display area. So the physical resolution and the offset
362 of the active area can be set with
373 However with the help of :cpp:func:`lv_display_set_flush_wait_cb` a custom
375 or anything else to optimize waiting for the flush to be completed.
384 LVGL supports rotation of the display in 90 degree increments.
386 The orientation of the display can be changed with
388 0, 90, 180 or 270. This will swap the horizontal and vertical resolutions internally
389 according to the set degree, however it will not perform the actual rotation.
390 When changing the rotation, the :cpp:enumerator:`LV_EVENT_SIZE_CHANGED` event is
393 rotate the buffer in the :ref:`flush_callback` function.
395 :cpp:expr:`lv_display_rotate_area(display, &area)` rotates the rendered area
396 according to the current rotation settings of the display.
398 Note that in :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_DIRECT` the small changed areas
399 are rendered directly in the frame buffer so they cannot be
400 rotated later. Therefore in direct mode only the whole frame buffer can be rotated.
401 The same is true for :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_FULL`.
403 In the case of :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_PARTIAL` the small rendered areas
404 can be rotated on their own before flushing to the frame buffer.
406 Below is an example for rotating when the rendering mode is
407 :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_PARTIAL` and the rotated image should be sent to a
419 /*Calculate the position of the rotated area*/
422 /*Calculate the source stride (bytes in a line) from the width of the area*/
424 /*Calculate the stride of the destination (rotated) area too*/
426 /*Have a buffer to store the rotated area and perform the rotation*/
431 /*Use the rotated area and rotated buffer from now on*/
439 Below is an example for rotating when the rendering mode is
440 :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_PARTIAL` and the image can be rotated directly
441 into a **frame buffer of the LCD peripheral**.
445 /*Rotate a partially rendered area to the frame buffer*/
450 /*Calculate the position of the rotated area*/
453 /*Calculate the properties of the source buffer*/
457 /*Calculate the properties of the frame buffer*/
478 The default color format of the display is set according to :c:macro:`LV_COLOR_DEPTH`
487 The ``color_format`` can be changed with
489 Besides the default value :c:macro:`LV_COLOR_FORMAT_ARGB8888` can be
492 It's very important that draw buffer(s) should be large enough for the
499 In case of RGB565 color format it might be required to swap the 2 bytes
500 because the SPI, I2C or 8 bit parallel port periphery sends them in the wrong order.
502 The ideal solution is configure the hardware to handle the 16 bit data with different byte order,
504 can be called in the :ref:`flush_callback` to swap the bytes.
507 the fastest possible byte swapping.
509 Note that this is not about swapping the Red and Blue channel but converting
526 The :cpp:expr:`LV_COLOR_FORMAT_I1` format assumes that bytes are mapped to rows (i.e., the bits of …
527 The order of bits is MSB first, which means:
534 are represented on the display as:
541 Ensure that the LCD controller is configured accordingly.
543 Internally, LVGL rounds the redrawn areas to byte boundaries. Therefore, updated areas will:
548 When setting up the buffers for rendering (:cpp:func:`lv_display_set_buffers`), make the buffer 8 b…
549 This is necessary because LVGL reserves 2 x 4 bytes in the buffer, as these are assumed to be used …
551 To skip the palette, include the following line in your :ref:`flush_callback` function: ``px_map +=…
554 In full and direct modes, the buffer size should be large enough for the whole screen,
556 As LVGL can not handle fractional width make sure to round the horizontal resolution
559 The :cpp:func:`lv_draw_sw_i1_convert_to_vtiled` function is used to convert a draw
562 different draw buffer mapping. The function assumes that the buffer width and height
563 are rounded to a multiple of 8. The bit order of the resulting vtiled buffer can be
564 specified using the `bit_order_lsb` parameter.
566 For more details, refer to the implementation in
569 To ensure that the redrawn areas start and end on byte boundaries, you can add a
570 rounder callback to your display driver. This callback will round the width and
571 height to the nearest multiple of 8.
581 /* Round the height to the nearest multiple of 8 */
588 In this example, the `my_rounder_cb` function rounds the coordinates of the redrawn
589 area to the nearest multiple of 8. The `x1` and `y1` coordinates are rounded down,
590 while the `x2` and `y2` coordinates are rounded up. This ensures that the width and
591 height of the redrawn area are always multiples of 8.
596 Some display controllers have specific requirements for the window area where the rendered image ca…
599 In the case of monochrome displays, `x1` must be `Nx8`, and `x2` must be `Nx8 - 1`.
600 (If the display uses `LV_COLOR_FORMAT_I1`, LVGL automatically applies this rounding. See :ref:`mono…
602 The size of the invalidated (redrawn) area can be controlled as follows:
624 …cores, one core can draw the screen's background while the other 3 must wait until it is finished.…
630 … tiles and 4 cores, there will always be an independent area for each core within one of the tiles.
632 The maximum number of tiles can be set using the function :cpp:expr:`lv_display_set_tile_cnt(disp, …
634 …e not further divided into smaller tiles because the overhead of spinning up 4 cores would outweig…
636 The ideal tile size is calculated as ``ideal_tile_size = draw_buf_size / tile_cnt``. For example, i…
646 …rator:`LV_DISPLAY_RENDER_MODE_DIRECT`, the screen-sized draw buffer is divided by the tile count t…
648 …n :cpp:enumerator:`LV_DISPLAY_RENDER_MODE_FULL`, the maximum number of tiles is always created whe…
650 …the partial buffer is divided into tiles. For example, if the draw buffer is 1/10th the size of th…
652 …affects the rendering process, and the :ref:`flush_callback` is called once for each invalidated a…
655 Decoupling the Display Refresh Timer
658 Normally the dirty (a.k.a invalid) areas are checked and redrawn in
660 However, in some cases you might need more control on when the display
662 the TE signal.
664 You can do this in the following way:
671 /* Call this to refresh dirty (changed) areas of the display. */
675 select the display to refresh before :cpp:expr:`_lv_display_refr_timer(NULL)`.
678 .. note:: :cpp:func:`lv_timer_handler` and :cpp:func:`_lv_display_refr_timer` must not run at the s…
681 If the performance monitor is enabled, the value of :c:macro:`LV_DEF_REFR_PERIOD` needs to be set t…
682 consistent with the refresh period of the display to ensure that the statistical results are correc…
688 Normally the invalidated areas (marked for redrawing) are rendered in
690 However, by using :cpp:expr:`lv_refr_now(display)` you can ask LVGL to redraw the
691 invalid areas immediately. The refreshing will happen in :cpp:func:`lv_refr_now`
694 The parameter of :cpp:func:`lv_refr_now` is a display to refresh. If ``NULL`` is set
695 the :ref:`default_display` will be updated.
701 To mirror the image of a display to another display, you don't need to use
702 multi-display support. Just transfer the buffer received in the first display's
703 :ref:`flush_callback` to the other display as well.
712 1. setting the resolution of the displays to the large display's resolution;
713 2. in :ref:`flush_callback`, truncate and modify the ``area`` parameter for each display; and
714 3. send the buffer's content to each real display with the truncated area.
733 Every use of an :ref:`Input Device <indev>` (if :ref:`associated with the display
734 <indev_other_features>`) counts as an activity. To get time elapsed since the last
736 passed, the lowest inactivity time among all displays will be returned (in this case
737 NULL does *not* mean the :ref:`default_display`).
740 :cpp:expr:`lv_display_trigger_activity(display1)`. If ``display1`` is ``NULL``, the