English (en) - 中文 (zh-CN) - Français (fr) - Magyar (hu) - Türk (tr)

Version PDF: LittlevGL.pdf

Bienvenue dans la documentation de LittlevGL !

LittlevGL cover

LittlevGL est une bibliothèque graphique gratuite et à code source ouvert offrant tout ce dont vous avez besoin pour créer une interface graphique embarquée avec des éléments graphiques faciles à utiliser, de superbes effets visuels et une faible empreinte mémoire.

Site Internet   ·   GitHub   ·   Forum   ·   Démonstration en ligne   ·   Simulateur   ·   Blog

Points forts

  • Eléments de base évolués tels que boutons, graphiques, listes, curseurs, images, etc.

  • Graphiques avancés avec animations, anti-crénelage, opacité, défilement doux

  • Périphériques d’entrée variés tels que pavé tactile, souris, clavier, encodeur, etc.

  • Prise en charge multilingue avec encodage UTF-8

  • Prise en charge de plusieurs écrans, c-à-d utilisation simultanée d’un écran TFT et d’un écran monochrome

  • Eléments graphiques entièrement personnalisables

  • Indépendant du matériel : utilisable avec n’importe quel microcontrôleur ou écran

  • Adaptable pour fonctionner avec peu de mémoire (64 ko de mémoire Flash, 16 ko de MEV)

  • SE, mémoire externe et GPU pris en charge mais non requis

  • Fonctionne avec un seul tampon d’affichage même avec des effets graphiques avancés

  • Ecrit en C pour une compatibilité maximale (compatible C++)

  • Simulateur pour débuter sur PC la conception d’interface graphique embarquée sans le matériel embarqué

  • Tutoriels, exemples, thèmes pour une conception rapide

  • Documentation disponible en ligne et hors ligne

  • Gratuit et à code source ouvert, sous licence MIT

Eléments requis

  • Microcontrôleur ou processeur 16, 32 ou 64 bits

  • Une vitesse d’horloge supérieure à 16 MHz est recommandée

  • Flash/MEM : une taille supérieure à 64 ko pour les composants essentiels (une taille supérieure à 180 ko est recommandée)

  • MEV :

    • Utilisation de MEV statique : approximativement 8 à 16 ko en fonction des types d’objets et des fonctionnalités utilisés

    • Pile : taille supérieure à 2 ko (une taille supérieure à 4 ko est recommandée)

    • Données dynamiques (tas) : taille supérieure à 4 ko (une taille supérieure à 16 ko est recommandée si plusieurs objets sont utilisés). Défini par LV_MEM_SIZE dans lv_conf.h.

    • Tampon d’affichage : taille supérieure à “résolution horizontale” pixels (une taille supérieure à 10 × “résolution horizontale” est recommandée)

  • Compilateur conforme à C99 ou plus récent

  • Connaissances de bases en C (ou C++) : pointeurs, structures, fonctions de rappel.

Notez que l’utilisation de la mémoire peut varier en fonction de l’architecture, du compilateur et des options de compilation.

FAQ

Où commencer ?

  • Pour un aperçu général de LittlevGL, visitez littlevgl.com

  • Accédez à la section Démarrer pour essayer des démonstrations en ligne dans votre navigateur, en savoir plus sur le simulateur et les bases de LittlevGL.

  • Vous trouverez un guide de portage détaillé dans la section Portage.

  • Pour savoir comment LittlevGL fonctionne, accédez à Vue d’ensemble.

  • Pour lire des tutoriels ou partager vos propres expériences, accédez au Blog

  • Pour découvrir le code source de la bibliothèque, consultez-le sur GitHub : https://github.com/littlevgl/lvgl/.

Où puis-je poser des questions ?

Pour poser des questions sur le forum : https://forum.littlevgl.com/.

Nous utilisons le suivi des problèmes de GitHub pour les discussions relatives au développement. Vous ne devez donc l’utiliser que si votre question ou votre problème est étroitement lié au développement de la bibliothèque.

Est-ce que mon microcontrôleur/matériel est supporté ?

Chaque microcontrôleur capable de piloter un affichage via un port parallèle, SPI, une interface RVB ou autre, et conforme aux éléments requis, est pris en charge par LittlevGL.

Cela comprend :

  • Les microcontrôleurs “courants” tels que les STM32F, STM32H, NXP Kinetis, LPC, iMX, dsPIC33, PIC32, etc.

  • Les modules Bluetooth, GSM, WiFi tels que les Nordic NRF et Espressif ESP32

  • Le tampon de trame de Linux comme /dev/fb0 ce qui inclut également les ordinateurs monocartes comme le Raspberry Pi

  • Et tout ce qui possède un microcontrôleur suffisamment puissant et le nécessaire pour piloter un écran

Mon écran est-il supporté?

LittlevGL nécessite uniquement un simple pilote pour copier un tableau de pixels dans une zone donnée de l’affichage. Si vous pouvez le faire avec votre écran, vous pouvez utiliser cet écran avec LittlevGL.

Cela comprend :

  • Les TFT avec une profondeur de couleur de 16 ou 24 bits

  • Les moniteurs avec port HDMI

  • Les petits écrans monochromes

  • Les écrans à affichages en niveaux de gris

  • Les matrices LED

  • Ou tout autre affichage où vous pouvez contrôler la couleur/l’état des pixels

Consultez la section Portage pour en savoir plus.

LittlevGL est-il libre ? Comment puis-je l’utiliser dans un produit commercial ?

LittlevGL est fourni sous licence MIT, ce qui signifie que vous pouvez le télécharger et l’utiliser à vos fins sans obligation.

Rien ne se passe, mon pilote d’affichage n’est pas appelé. Qu’est-ce que j’ai raté ?

Assurez-vous que vous appelez lv_tick_inc(x) dans une interruption et lv_task_handler () dans votre boucle principale while (1).

Apprenez-en plus dans les sections Tic et Gestionnaire de tâche.

Pourquoi le pilote d’affichage n’est appelé qu’une seule fois ? Seule la partie supérieure de l’écran est actualisée.

Assurez-vous que vous appelez lv_disp_flush_ready(drv) à la fin de votre fonction de rappel du pilote d’affichage.

Pourquoi je ne vois que des parasites à l’écran?

Il y a probablement un bogue dans votre pilote d’affichage. Essayez le code suivant sans utiliser LittlevGL :

#define BUF_W 20
#define BUF_H 10
lv_color_t buf[BUF_W * BUF_H];
lv_color_t * buf_p = buf;
uint16_t x, y;
for(y = 0; y < BUF_H; y++) {
    lv_color_t c = lv_color_mix(LV_COLOR_BLUE, LV_COLOR_RED, (y * 255) / BUF_H);
    for(x = 0; x < BUF_W; x++){
        (*buf_p) =  c;
        buf_p++;
    }
}

lv_area_t a;
a.x1 = 10;
a.y1 = 40;
a.x2 = a.x1 + BUF_W - 1;
a.y2 = a.y1 + BUF_H - 1;
my_flush_cb(NULL, &a, buf);

Pourquoi vois-je des couleurs incorrectes à l’écran ?

Le format de couleur de LittlevGL n’est probablement pas compatible avec le format de couleur de votre écran. Vérifiez LV_COLOR_DEPTH dans lv_conf.h.

Si vous utilisez des couleurs 16 bits avec SPI (ou toute autre interface orientée octets), vous devez probablement définir LV_COLOR_16_SWAP 1 dans lv_conf.h. Les octets supérieurs et inférieurs des pixels seront échangés.

Comment accélérer mon interface utilisateur ?

  • Activez les optimisations du compilateur

  • Augmentez la taille du tampon d’affichage

  • Utilisez 2 tampons d’affichage et transférez le tampon en DMA (ou une technique similaire) en arrière-plan

  • Augmentez la vitesse de fonctionnement des ports SPI ou parallèle si vous les utilisez pour piloter l’affichage

  • Si votre écran dispose d’un port SPI, envisagez de passer à un modèle avec port parallèle, car son débit est beaucoup plus élevé.

  • Conservez le tampon d’affichage dans la MEV interne (pas dans la SRAM externe) car LittlevGL l’utilise intensivement ce qui implique un temps d’accès minimal.

Comment réduire l’utilisation de mémoire flash/MEM ?

Vous pouvez désactiver toutes les fonctionnalités (animations, système de fichiers, GPU, etc.) et les types d’objet non utilisés dans lv_conf.h.

Si vous utilisez GCC, vous pouvez ajouter

  • -fdata-sections -ffunction-sections aux options du compilateur

  • --gc-sections aux options de l’éditeur de liens

pour supprimer les fonctions et variables inutilisées.

Comment réduire l’utilisation de la MEV

  • Réduisez la taille du tampon d’affichage

  • Réduisez LV_MEM_SIZE dans lv_conf.h. Cette mémoire est utilisée lorsque vous créez des objets tels que des boutons, des étiquettes, etc.

  • Pour travailler avec un LV_MEM_SIZE réduit, vous pouvez créer les objets uniquement à l’utilisation et les supprimer lorsqu’ils ne sont plus nécessaires.

Comment travailler avec un système d’exploitation ?

Pour travailler avec un système d’exploitation où les tâches peuvent s’interrompre, vous devez protéger les appels de fonctions liés à LittlevGL avec un mutex. Consultez la section Système d’exploitation et interruption pour en savoir plus.

Comment contribuer à LittlevGL ?

Il y a plusieurs façons de contribuer à LittlevGL :

  • Ecrivez quelques lignes sur votre projet pour inspirer les autres

  • Répondez aux questions des autres

  • Signalez et/ou corrigez des bogues

  • Suggérez et/ou implémentez de nouvelles fonctionnalités

  • Améliorez et/ou traduisez la documentation

  • Ecrivez un article de blog sur vos expériences

Pour en savoir plus, consultez le Guide de contribution

Comment LittlevGL est-il versionné ?

LittlevGL suit les règles de gestion sémantique de version :

  • Versions majeures pour les modifications incompatibles de l’API. P.ex. 5.0.0, 6.0.0

  • Versions mineures pour des fonctionnalités nouvelles mais compatibles avec les versions antérieures. P.ex. 6.1.0, 6.2.0

  • Versions correctives pour les corrections de bogues à compatibilité ascendante. P.ex. 6.1.1, 6.1.2

Les nouvelles versions sont développées dans les branches dev-X.Y sur GitHub. Elles peuvent être clonées pour tester les fonctionnalités les plus récentes. Cependant, tout peut être modifié dans ces branches.

Les corrections de bogues sont ajoutées directement à la branche master sur GitHub et une version de correction de bogues est créée chaque mois.