Démarrer avec l’affichage d’EVE4 – guide complet

L’utilisation d’un nouveau contrôleur d’écran EVE4 ne doit pas être complexe.

Dans ce guide, vous apprendrez à donner vie à un écran Riverdi EVE4 sur une carte d’évaluation STM32 – du premier câblage à l’affichage de l’image initiale.

Il s’agit d’un guide précis, mais qui va droit au but, conçu pour les ingénieurs qui souhaitent disposer d’une base solide pour de futurs projets basés sur EVE sans se perdre dans des détails inutiles : le câblage, l’ouverture du projet dans STM32CubeIDE, la construction et le flashage, la confirmation de l’affichage et du toucher, le tout centré sur l’essentiel ; un premier projet que vous pourrez réutiliser comme base pour de futures applications plus complexes.

Matériel

RiBUS

• Le raidisseur bleu du FFC fait généralement face au loquet du connecteur (en haut). Insérez-le à fond, puis refermez le loquet.
• Acheminez le câble en respectant un faible rayon de courbure – pas de plis brusques – et veillez à ce que le côté contact corresponde à l’empreinte du connecteur aux deux extrémités.
• N’alimentez pas la carte pendant que vous insérez/retirez le FFC.

Logiciel

• Installez STM32CubeIDE.
• (En option) Installez le STM32CubeProgrammer pour faciliter le flashage via ST-Link.
• (Facultatif) Installez Git (ou prévoyez de télécharger un ZIP).
• Windows uniquement : installez le pilote USB ST-Link (CubeProgrammer peut le faire).

Vous préférez un environnement différent (Keil/IAR/Make/PlatformIO) ? Ce n’est pas grave, ce guide utilise uniquement CubeIDE pour plus de clarté.

Téléchargez le projet sur GitHub

Option A

1. Ouvrez le dépôt : Riverdi EVE demo
2. Cliquez sur le code vert et copiez l’URL HTTPS (voir l’image ci-dessous).
   
3. Ouvrez un terminal dans le répertoire dans lequel vous souhaitez placer votre projet et tapez : git clone https://github.com/riverdi/riverdi-eve4-demo.git riverdi-eve-demo

Option B

1. Ouvrez le dépôt : Riverdi EVE demo
2. Cliquez sur le code vert et téléchargez le ZIP
3. Décompressez dans un dossier pratique (par exemple … C:\NUsers\NUser1 \Nriverdi-eve-demo)

Importez le projet dans STM32CubeIDE

Suivez ces étapes pour amener le repo cloné/dézippé dans CubeIDE.

1. Dans CubeIDE, allez dans Fichier → Nouveau → Makefile Project with Existing Code.
2. Emplacement du code existant : cliquez sur Parcourir… et sélectionnez votre dossier riverdi-eve.
3. Nom du projet : conservez le nom proposé ou saisissez le vôtre.
4. Langues : ne pas cocher les cases C et C++.
5. Toolchain for Indexer Settings (Chaîne d’outils pour l’indexeur) : sélectionnez MCU ARM GCC.
6. Cliquez sur Terminer. Le projet apparaît dans l’Explorateur de projets.

Si « MCU ARM GCC » ne figure pas dans la liste :

• Installez/réparez les composants de CubeIDE via Help → Manage Embedded Software Packages (ou réinstallez CubeIDE).
• Redémarrez CubeIDE et réessayez l’importation.

Configurer le projet

1. Choisissez la plateforme Makefile
   Le repo supporte plusieurs hôtes. Pour la carte d’évaluation Riverdi STM32 (F4), utilisez :
   • Makefile.stm32f4 (trouvé à la racine du projet)
2. Renommez-le pour qu’il devienne actif
   Rename Makefile.stm32f4 → Makefile (CubeIDE et make recherchent ce nom de fichier exact).
3. Définissez votre panneau/affichage
   Ouvrez le fichier Makefile nouvellement renommé et assurez-vous que les drapeaux suivants sont présents (décommentez/ajoutez si nécessaire) pour un module EVE4 IPS de 7 pouces :

# Génération EVE
DEFS += -DEVE_4
# EVE4 utilise généralement un oscillateur externe.
DEFS += -DEVE_4_EXTERNAL_OSC

# Sélection du panneau (7″ IPS)
DEFS += -DIPS_70

Vous utilisez un autre écran Riverdi EVE ?
Remplacez -DIPS_70 par la définition correspondante qui est commentée dans le Makefile (le bloc de synchronisation pour HSIZE/VSIZE/HCYCLE/VCYCLE etc. est lié à cette définition).
Vous n’avez généralement pas besoin de modifier quoi que ce soit d’autre – conservez les paramètres par défaut pour une première construction.

Structure du code principal

La démo riverdi-eve utilise un design en couches :

• host_layer – liens avec la plateforme (SPI, GPIO, timing) pour STM32, RPi, FT232H/Windows, etc.
• eve_layer – pilote EVE portable (accès aux registres et à la mémoire vive, FIFO de commande, commandes du coprocesseur).
• app_layer –aides et logique de l’application (DL/command buffering, touch handling, calibration, simple UI/sound).

En outre, riverdi_modules contient les définitions des panneaux (résolution, synchro, pclk, PWM par défaut), et riverdi-demo.c contient l’application d’exemple qui assemble les couches.

Comment EVE4 se réveille réellement (avec des miettes de code)

Lorsque vous réinitialisez la carte, la démo fait passer l’EVE4 par une séquence d’initialisation précise.

1. Mettre le MCU + HAL en ligne
   Avant qu’EVE puisse vous entendre, le STM32 doit avoir des horloges et des bus prêts.
   • App_Common_Init() – préparation de l’app/board.
   • Gpu_Hal_Init() – HAL Bridgetek pour SPI/GPIO/timers.
   • platform_init() – initialisation de l’horloge/du minuteur de bas niveau pour le STM32F4.
2. Câbler la liaison et prendre le contrôle
   Lier les broches de contrôle et garantir un démarrage propre.
   • Gpu_Hal_Open() – affecte CS, PD, INT ; maintient CS/PD à un niveau élevé.
   • Gpu_Hal_Powercycle() – active le PD pour un démarrage à froid.
3. Réveillez le GPU et vérifiez les communications
   Passez en mode actif et vérifiez la liaison.
   • Commande de l’hôte → ACTIVE – EVE passe en mode actif.
   • Clock config – programmez la fréquence cible (EVE4 utilise généralement l’oscillateur externe).
   • Readbacks – vérifiez le REG_ID du périphérique et l’état du moteur (coprocesseur, tactile, audio).
4. Programmer les horaires du panneau + le rétro-éclairage
   Décrivez votre verre au contrôleur.
   • Bloc de synchronisation de l’écriture : HSIZE/VSIZE/HCYCLE/VCYCLE, synchro, PCLK_POL, SWIZZLE, etc.
   • Configurez le PWM pour le rétroéclairage (REG_PWM_HZ, REG_PWM_DUTY).
   • Note (EVE4): vous réglerez également la source/fréquence de l’horloge de l’écran en même temps que le PWM pour que les temps correspondent à ceux du panneau.

   Cette « note EVE4 » est très bien d’un point de vue conceptuel – il suffit de préciser que vous réglez l’horloge du pixel et (le cas échéant) les registres d’horloge PLL/affichage utilisés par EVE4, puis que vous activez REG_PCLK en dernier lieu.

5. Première image : build → flush → swap
   La première image est une minuscule liste d’affichage.
   • CLEAR_COLOR_RGB(r,g,b) – couleur d’arrière-plan.
   • CLEAR(1,1,1) – efface la couleur/le pochoir/l’étiquette.
   • DISPLAY() – fin de DL.
   • Flush_DL_Buffer() – copie DL dans RAM_DL.
   • Gpu_Hal_DLSwap(…, DLSWAP_FRAME) – pour le rendre visible.

Liste d’affichage (DL) dans Bridgetek EVE

Liste d’affichage – quoi, pourquoi et pourquoi c’est bien

Une liste d’affichage est le script par image qui indique à EVE ce qu’il doit dessiner (couleur claire, formes/widgets/textes, images) et se termine par DISPLAY() plus un DLSWAP_FRAME pour le rendre visible. Nous en avons besoin car EVE effectue le rendu à partir d’une liste complète et ordonnée – sans cela, les mises à jour partielles vacilleraient et le timing serait imprévisible. C’est une bonne solution parce qu’elle regroupe les commandes (moins de transferts SPI), garde les images déterministes (même liste → mêmes pixels), et laisse le MCU construire l’image suivante pendant qu’EVE dessine l’image en cours – des interfaces fluides avec une charge CPU minimale.

Cycle typique

1. Construire: commandes de file d’attente (couleurs, formes, widgets, images).
2. Flush: écrire les octets dans RAM_DL.
3. Permutation: définissez DLSWAP_FRAME pour que la nouvelle liste soit visible.

Cela minimise le trafic MCU↔EVE et permet des mises à jour fluides, même pour les animations de l’interface utilisateur. Exemple :

App_WrDl_Buffer(phost, CLEAR_COLOR_RGB(0, 64, 128));
App_WrDl_Buffer(phost, CLEAR(1,1,1));
App_WrDl_Buffer(phost, DISPLAY());
App_Flush_DL_Buffer(phost);
Gpu_Hal_DLSwap(phost, DLSWAP_FRAME);


Pour plus de détails (jeu de commandes, carte des registres, comportement FIFO), consultez le Guide de programmation de Bridgetek pour la série BT81x.

Résumé

Vous avez maintenant terminé toutes les étapes essentielles pour mettre sous tension et vérifier votre écran Riverdi EVE4 sur STM32 – de laconfiguration du matériel au rendu de la première image en utilisant le moteur EVE de Bridgetek.

Avec ce projet de base, vous pouvez commencer à explorer les listes d’affichage personnalisées, les interactions tactiles avancées et le développement complet de l’interface utilisateur pour votre prochaine conception embarquée.

DÉCOUVREZ NOTRE

Livre blanc

Réalisez l’interaction parfaite entre l’utilisateur et l’écran avec le bon circuit intégré pour capteur tactile. Vous avez déjà été confronté à des problèmes d’événements tactiles fantômes ou de certification ? Boostez votre R&D comme un pro grâce à notre livre blanc !

Livre blanc

Consultez notre catalogue de produits et voyez comment vous pouvez économiser sur la qualité, et non sur la qualité.

Vérifier maintenant

Contactez-nous maintenant, économisez avec la qualité, pas sur la qualité.

Contactez-nous