15 novembre
Tableau de contrôle

Émuler les systèmes Linux embarqués avec QEMU

Émuler les systèmes Linux embarqués avec QEMU

 

1. Introduction

Le développement de logiciels embarqués repose sur des périphériques matériels embarqués, tels que des cartes de développement, des modules externes, etc., mais si le travail de débogage n'a rien à voir avec les périphériques, seul le débogage du noyau peut être simulé à l'aide de QEMU sans acheter de matériel.

Il est disponible pour les hôtes Linux et Windows et les cibles émulées PowerPC, ARM, MIPS et SPARC. QEMU adopte l'approche de fournir une couche de traduction minimale entre l'hôte et le processeur cible. Le processeur hôte est celui qui exécute l'émulateur et le processeur cible est celui qui est émulé.

Ce qui suit est une introduction détaillée au processus de configuration de l'environnement de développement QEMU.

 

2. Milieu

2.1 Environnement utilisé

* Ubuntu-18.04.1

OU:

*PC：Windows10

* Machine virtuelle：VirtualBox-5.18

* OS virtuel：Ubuntu-18.04.1

* Carte de développement simulée : vexpres

2.2 Outils utilisés lors de la configuration de l'environnement

* qemu-4.2.0

* linux-4.14.172 (noyau Linux)

* u-boot-2017.05

*boîte occupée-1.31.1

* arm-linux-gnueabi-gcc

Mettez tous les fichiers associés dans /home/joe/qemu

3. Installer des outils de compilation croisée

# sudo apt install gcc-arm-linux-gnueabi

 

Vérifiez si l'installation est réussie

$ arm-linux-gnueabi-gcc -v

Utilisation des spécifications intégrées.

COLLECT_GCC=arm-linux-gnueabi-gcc

COLLECT_LTO_WRAPPER=/usr/lib/gcc-cross/arm-linux-gnueabi/7/lto-wrapper

Cible: arm-linux-gnueabi

Configuré avec : ../src/configure -v –with-pkgversion='Ubuntu/Linaro 7.5.0-3ubuntu1~18.04′–with-bugurl=file:///usr

Modèle de fil: posix

gcc version 7.5.0 (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04)

 

4. Configurer et compiler le noyau Linux

4.1 Télécharger le noyau Linux

Téléchargez la version du noyau requise sur www.kernel.org.

Ici, je télécharge la version relativement récente du noyau pris en charge à long terme linux-4.4.157

wget https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.4.157.tar.xz  dans le répertoire /qemu

4.2 Décompressez le noyau Linux

# tar xvJf linux-4.4.157.tar.xz

4.3 Compiler le noyau Linux

// Entrer le répertoire du fichier source du noyau

#cd linux-4.4.157

make CROSS_COMPILE=arm-linux-gnueabi-ARCH=arm vexpress_defconfig

make CROSS_COMPILE=arm-linux-gnueabi-ARCH=arm menuconfig

Si l'exécution de menuconfig montre que le package ncurses est manquant, exécutez simplement la commande suivante pour l'installer)

$ sudo apt-get install libncurses5-dev

Entrez dans le menu de configuration et effectuez les réglages suivants

Compiler avec la chaîne d'outils croisée

Après une compilation réussie, générez un fichier image du noyau sous le répertoire

arch/arm/boot, zImage et dtb peuvent être copiés dans un dossier séparé pour une utilisation pratique

 

5. Installer les outils QEMU

5.1 Installer QEMU

* wget https://download.qemu.org/qemu-4.2.0.tar.xz

* tar xvJf qemu-4.2.0.tar.xz

* cdqemu-4.2.0

5.2 Installer les packages dépendants avant de configurer QEMU

# apt installer zlib1g-dev
# apt installer libglib2.0-0 libglib2.0-dev
# apt installer libsdl1.2-dev
# apt installer libpixman-1-dev libfdt-dev

Afin d'éviter que les fichiers ne soient désordonnés après la compilation, créez le répertoire du générateur comme chemin cible intermédiaire pour la compilation.

Configurer, compiler et installer QEMU.

5.3 Configurer QEMU pour prendre en charge toutes les cartes sous l'architecture arm

# ../configure –target-list=arm-softmmu –audio-drv-list=

Si pixman est manquant lorsque l'invite suivante apparaît,

utilisez sudo apt-get install libpixman-1-dev pour l'installer.

5.4 Afficher la version QEMU

5.5 Afficher les cartes de développement prises en charge par QEMU

5.6 Exécuter QEMU

# qemu-system-arm -M vexpress-a9 -m 512M -kernel ./zImage -dtb ./vexpress-v2p-ca9.dtb -nographic -append "console=ttyAMA0"

OU:

$pwd

/accueil/joe/qemu

# qemu-system-arm -M vexpress-a9 -m 512M -kernel linux-.4.157/arch/arm/boot/zImage -dtb linux-4.4.157/arch/arm/boot/dts/vexpress-v2p-ca9. dtb -nographic -append "console=ttyAMA0"

Afin de mieux tester et démarrer qemu, vous pouvez créer le script de démarrage start.sh et autoriser le script à exécuter chmod +x start.sh

 

#! / Bin / bash

 

qemu-système-bras \

-M vexpress-a9 \

-m 512M\

-kernel /home/joe/jemu/linux-4.4.157/arch/arm/boot/zImage\

-dtb /home/joe/jemu/linux-4.4.157/arch/arm/boot/dts/vexpress-v2p-ca9.dtb \

-nographique \

-ajouter "console=ttyAMA0"

 

6. Créez un système de fichiers racine

Utilisez busybox pour créer un système de fichiers racine simple.

6.1 Télécharger l'outil busybox

Téléchargez busybox depuis https://busybox.net/downloads/

# wget https://busybox.net/downloads/busybox-1.31.1.tar.bz2

# tar xjvf occupébox-1.31.1.tar.bz2

# cdboîte occupée-1.31.1

# faire defconfig

# faire CROSS_COMPILE=arm-linux-gnueabi-

# make install CROSS_COMPILE=arm-linux-gnueabi-

Les informations suivantes s'affichent, indiquant que l'installation a réussi.

Une fois l'installation terminée, le fichier cible généré se trouve par défaut dans le répertoire ./_install.

 

6.2 Générer le système de fichiers racine

6.2.1 compiler et installer busybox

# mkdir racinefs

# sudo cp -r _install/* rootfs/

6.2.2 Ajouter la bibliothèque glibc, ajouter le chargeur et la bibliothèque dynamique dans le système de fichiers racine

# sudo cp -r _install/* rootfs/

# sudo cp -p /usr/arm-linux-gnueabi/lib/* rootfs/lib/

6.2.3 Créer 4 périphériques terminaux tty (c signifie périphérique de caractère, 4 est le numéro de périphérique principal et 1 ~ 4 sont respectivement les numéros de périphérique mineurs)

 

6.3 Créer une image du système de fichiers de la carte SD

6.3.1 Générer une image de carte SD vide

# dd if=/dev/zero of=rootfs.ext3 bs=1M count=32

6.3.2 Formater la carte SD en tant que système de fichiers exts

# mkfs.ext3 rootfs.ext3

6.3.3 Graver rootfs sur une carte SD

# sudo mount -t ext3 rootfs.ext3 /mnt -o boucle

# sudo cp -rf rootfs/* /mnt/

# sudo umount /mnt

 

7. Vérifiez

7.1 Démarrer Qemu

Exécutez la commande suivante pour tester, vérifiez si le noyau compilé peut s'exécuter avec succès

# sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel ~/qemu/zImage –dtb ~/qemu/vexpress-v2p-ca9.dtb -nographic -append "console=ttyAMA0"

Ou en utilisant Script :

 

Dans le test ci-dessus, le noyau signalera une panique, suggérant que nous manquons du système de fichiers racine.

Le problème ci-dessus est dû à l'outil busybox généré dans l'environnement x86.

Nous avons utilisé make install lors de l'installation de busybox, vous devez donc utiliser

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-install

 

L'outil de compilation génère l'outil busybox utilisé par la plateforme arm

# fichier rootfs/bin/busybox

rootfs/bin/busybox : exécutable LSB 32 bits, ARM, EABI5 version 1 (SYSV), lié dynamiquement, interpréteur /lib/ld-, pour GNU/Linux 3.2.0, BuildID[sha1]=cbcd33b8d6c946cb19408a5e8e714de554c87f52, supprimé

 

7.2 Vérifier à nouveau

Maintenant, Qemu a démarré le noyau Linux et monté le système de fichiers avec succès, et peut interagir avec le système avec des fonctions simples via le terminal série. Le problème de ne pas pouvoir exécuter /etc/init.d/rcS dans le processus d'impression, il vous suffit d'ajouter le fichier /etc/init.d/rcS. Le contenu du fichier peut être une instruction d'invite.

 

7.3 Quitter QEMU

Deux façons de quitter qemu

* Dans une autre entrée de terminal : kill all qemu-system-arm

* En entrée Qemu : Ctrl+A ; X

QEMU : terminé

 

8. Démarrez le noyau Linux via u-boot

Le système embarqué comprend généralement : u-boot, kernel, rootfs et appfs. La relation de position de ces pièces sur la carte de développement ARM illustrée dans la figure ci-dessous

 

Chargeur de démarrage Paramètres de démarrage Noyau Racines Applications

 

Rootfs peut fonctionner en carte ou en PC

 

8.1 Préparer le U-boot

8.1.1 Télécharger u-boot

http://ftp.denx.de/pub/u-boot/, nous utilisons : u-boot-2021.01.tar.bz2

# tar -jxvf u-boot-2018.09.tar.bz2

8.1.2 Compiler u-boot

# Makefile vim

CROSS_COMPILE = arm-linux-gnueabi-

# vim config.mk

ARCH = bras

# make vexpress_ca9x4_defconfig, erreur

Besoin : sudo apt install bison

sudo apt installer flex

alors : # make -j4 error

Besoin : export CROSS_COMPILE=arm-linux-gnueabi-

exporter ARCH=bras

encore : # make vexpress_ca9x4_defconfig

# make -j4

 

 8.1.3 Tester, démarrer u-boot

$ sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel u-boot-2021.01/u-boot –nographic

 

8.2 Compilation de la configuration du noyau

Utilisez u-boot pour démarrer l'image du noyau :

Besoin de compiler le noyau au format uImage,

Besoin de spécifier l'adresse de chargement de uImage en mémoire

Spécifiez lors de la compilation du noyau : make LOADADDR=? uImage -j4

 

# cd /home/joe/qemu/linux-4.4.157

# faire LOADADDR=0x60003000 uImage -j4

 

Une fois la compilation u-boot terminée, un fichier mkimage sera généré dans le dossier de l'outil, copiez ce fichier dans le dossier bin sous le répertoire du compilateur croisé.

$cdqemu/linux-4.4.157

Erreur:

$ sudo apt installer u-boot-tools

Obtenir uImage

9. Paramètres de la fonction réseau QEMU

Lorsque la machine virtuelle Qemu démarre sur u-boot, uImage doit être chargé dans la mémoire et uImage peut être téléchargé à l'adresse spécifiée dans la mémoire via le serveur TFTP.

9.1 Vérifiez si le noyau hôte prend en charge le module tun/tap

// Installer les deux outils dont dépend le réseau ponté

# sudo apt install uml-utilities bridge-utils

Créer un fichier de périphérique tun : /dev/net/tun (généralement créé automatiquement)

Modifier le /etc/network/interfaces (configurer le réseau, redémarrer pour prendre effet)

# sudo vim /etc/network/interfaces

auto loiface lo inet loopbackauto enp0s3 // nom de la carte réseau virtuelleauto br0iface br0 inet dhcpbridge_ports enp0s3

 

JAMAIS redémarrer

# redémarrer

Vérifiez ensuite l'environnement réseau de Qemu

Le port réseau virtuel br0 est le port réseau pour la communication entre la machine virtuelle Qemu et l'hôte Linux.

 

10. Installer le serveur TFTP

Créez un serveur TFTP pour télécharger uImage dans la mémoire lors du lancement de uImage pour la carte de développement de simulation Qemu

 

10.1 Installer l'outil tftp

 

$ apt-get install tftp-hpa tftpd-hpa xinetd

 

10.2 Modifier le fichier de configuration et définir le répertoire du serveur TFTP

# sudo vim /etc/default/tftpd-hpa

......

TFTP_DIRECTORY="/home/joe/tftpboot"

......

10.3 Créer un répertoire tftp sur l'hôte Linux

# mkdir /home/joe/tftpboot

# chmod 777 /home/joe/tftpboot

 

10.4 Redémarrer le service tftp

# sudo /etc/init.d/tftpd-hpa redémarrer

 

10.5 Définir les paramètres de démarrage du noyau dans u-boot

copiez uImage et cexpress-v2p-ca9.dtb dans tftpboot

Démarrez Qemu pour vérifier

 

$ sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel u-boot-2021.01/u-boot –nographic -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 -sd rootfs. poste3

 

Maintenant, le répertoire rootfs est un simple système de fichiers racine, qui peut être transformé en un fichier miroir, et le fichier miroir peut être gravé sur la carte de développement, ou le noyau Linux peut être démarré par u-boot dans Qemu et monté sur le fichier miroir. Il peut également être configuré pour démarrer via le système de fichiers réseau NFS.

 

11. Monter le système de fichiers NFS

11.1 Installer et configurer le service NFS

Installation de 11.1.1

$ sudo apt installer le serveur nfs-kernel

 

11.1.2 Configuration

$ sudo mkdir /home/joe/qemu/rootfs

$ sudo chown personne:nogroup /home/joe/qemu/rootfs

$ sudo chmod 777 /home/joe/qemu/rootfs

$ sudo nano /etc/exports

Ajouter : /home/joe/qemu/rootfs *(rw,sync,no_root_squash)

 

Redémarrez le serveur nfs :

$ sudo /etc/init.d/nfs-kernel-server restart

Ou : $systemctl restart nfs-kernel-server

 

Vérifiez si le répertoire partagé NFS est créé

$ sudo showmount –e

Lors de l'utilisation du système de fichiers réseau NFS, l'hôte Linux doit fermer le pare-feu du système, sinon des anomalies se produiront lors de l'exécution du système.

 

Conclusion

J'espère qu'avec l'aide de ce blog, vous en saurez plus sur QEMU. Toutes les techniques démontrées ci-dessus ont été utilisées dans diverses soumissions à notre programme. Il n'y a pas un seul moyen fixe d'émuler avec QEMU. Explorez différentes techniques et voyez ce qui fonctionne pour vous. Familiarisez-vous avec les connaissances et vous serez surpris de voir comment cela peut vous aider de manière inattendue.

15 Sep
Tableau de contrôle

Présentation du projet Orient Display Embedded

Présentation du projet Orient Display Embedded

Orient Display est l'un des principaux écrans au monde Fabricants d'écrans LCD qui a été fondée en 1996 par des dirigeants de plus de 25 ans d'expérience en R&D et en production. Outre l'affichage, Orient Display s'est également concentré sur les technologies embarquées qui incluent l'architecture ARM et a accumulé une riche expérience dans les produits embarqués.

Désormais, les services techniques d'Orient Display incluent le matériel, les logiciels et le conseil.

 

NOTRE Équipe de matériel réaliser des prototypes dans les plus brefs délais selon vos idées et exigences de conception. Nous nous spécialisons dans la conception de cartes économiques ou complexes hautes performances pour répondre à votre exigence de fiabilité élevée dans un cycle de développement court.

– Conception schématique

– Disposition PCB

– Personnalisation des produits de l'industrie

 

NOTRE Équipe logiciel se spécialise dans Linux Conceptions ARM®, Processeur PowerPC et x86, pour n'en nommer que quelques-uns. En tant que fournisseur de solutions complètes pour Linux, Android et WinCE dans les systèmes embarqués, nous pouvons résoudre de bout en bout les problèmes liés au système de vos produits.

– Migration, optimisation et personnalisation du système

– Piloter le développement

– Personnalisation du noyau

– Porter LINUX KERNEL vers ARM, PPC ou x86 Board

– Développement APP (application, Linux QT, Linux C/++）

 

NOTRE EAF équipe vous fournir également une gamme complète de technologies pour vos produits ou produits semi-finis.

– Nous fournissons des conseils sur les ressources logicielles et matérielles de nos produits ;

– Nous résolvons les problèmes rencontrés lors de l'utilisation des manuels logiciels et matériels de nos produits ;

– Support technique après-vente OEM et ODM ;

– Maintenance et mise à jour des données ;

– Les produits Orient Display sont soutenus par notre Garantie du prix le plus bas.

 

Séquence de développement

 

1. Analyse des exigences du système

* Tâches de conception, objectifs, spécifications

– Ceci fourni par nos clients

* Exigence fonctionnelle et non fonctionnelle

– Inclure les performances du système, le coût, la consommation d'énergie, le volume, le poids et d'autres facteurs

 

2. Conception architecturale

Une bonne architecture est la clé du succès de la conception. Dans cette étape, il est souvent nécessaire de faire les choses suivantes :

  • Sélectionnez la puce principale :

— ARM Cortex A, R ou M, ou PowerPc ou ColdFire

  • Déterminez le RTOS :

— Linux, uClinux, Vxworks, freeRTOS, WinCE

  • Sélectionnez Affichage :

- Panneau TFT, TFT lisible au soleil, Panneaux de verre LCD, LCD graphique,  OLED, Touchez Panneaux, Écran LCD intégré or Affichage sur mesure by Orienter l'affichage

  • Langage de programmation:

— c/c++, python, Java

  • Outils de développement:

u-boot, busybox, QT, Ubuntu, stm32CubeIde, studio visuel, studio Android, keil uVision, studio RT-Tread

 

3. Co-conception matérielle et logicielle

Afin de raccourcir le cycle de développement du produit :

matériel:  Nous commençons généralement le projet à partir d'un tableau d'évaluation tel que l'affichage d'orientation AIY-A002M, AIY-A003M ainsi que AIY-A005M. Plus tard, le tableau personnalisé pour s'adapter au projet, jettera les pièces qui n'en ont pas besoin.

Séquence de développement logiciel :

  • Nous choisissons généralement u-boot comme Bootloader, il 1) init le processeur à l'état connu 2) init la mémoire 3) init interruption 4) init clock 5) charge le noyau à l'adresse d'exécution
  • Configurer le noyau :

1) configurer le système du noyau : *gestion de la mémoire, *systèmes de fichiers, *pilote de périphérique, *pile réseau, *Systèmes d'E/S

2) écrire le pilote de périphérique d'E/S * pilote de périphérique char, * pilote de périphérique de bloc, * pilote de périphérique net

  • Sélectionnez les applications :

*Sélectionnez une bibliothèque utilisateur *Créez une application utilisateur *Configurez le processus d'initialisation *Créez le FS racine

 

4. SIntégration du système

Intégrez les logiciels, le matériel et les dispositifs d'exécution du système, déboguez, recherchez et améliorez les erreurs dans le processus de conception de l'unité.

 

5. Test du système

Testez le système conçu pour voir s'il répond aux exigences fonctionnelles indiquées dans la spécification. La principale caractéristique du modèle de développement de systèmes embarqués est le développement complet de logiciels et de matériel.

 

En conclusion

Orient Display dispose d'une équipe incroyable d'experts talentueux possédant l'expérience et les capacités nécessaires pour créer un module d'affichage intégré, du concept à la production.

Si vous avez des questions, veuillez contacter nos ingénieurs à : tech@orientdisplay.com.

14 Sep
Tableau de contrôle

Comment sélectionner les processeurs ARM

Comment sélectionner les processeurs ARM

Introduction

La plus large gamme de microprocesseur noyaux pour presque tous les marchés d'applications. Explorer BRAS. Exigences de performances, de puissance et de coût pour presque tous les marchés d'applications, les processeurs sont cruciaux. Les performances du système dépendent fortement de son matériel ; cet article vous guidera à travers une étude du processeur ARM et sera d'une grande aide dans votre prise de décision.

 

Une brève introduction à ARM

Figure 1. Feuille de route des processeurs ARM

 

Avant 2003, il existe des processeurs ARM classiques, notamment ARM7 (architecture ARMv4), ARM9 (architecture ARMv5), ARM11 (architecture ARMv6). ARM7 n'a pas de MMU (unité de gestion de mémoire), ne peut pas exécuter un système multi-processus multi-utilisateurs tel que Linux et WinCE. Seuls peuvent exécuter des systèmes tels que ucOS et ucLinux qui n'ont pas besoin de MMU. ARM9 et ARM11 sont des processeurs intégrés avec MMU, qui peuvent exécuter Linux.

Après 2003, en ce qui concerne l'architecture ARMv7, elle a été nommée d'après Cortex et divisée en trois séries : Cortex-A, Cortex-R et Cortex-M.

  • Cortex-A — cœurs de processeur d'application pour les systèmes à hautes performances
  • Cortex-R – des cœurs hautes performances pour les applications temps réel
  • Cortex-M – cœurs de microcontrôleurs pour une large gamme d'applications embarquées

En termes simples, Cortex-A sont adaptées aux applications qui ont des exigences informatiques élevées, exécutent des systèmes d'exploitation riches et offrent une expérience multimédia et graphique interactive. Cortex-R sont adaptés à ceux qui nécessitent fiabilité, haute disponibilité, tolérance aux pannes, maintenabilité et réponse en temps réel. Cortex-M Les séries sont destinées aux MCU et aux applications finales sensibles au coût et à l'alimentation.

 

Cortex-A contre Cortex-R contre Cortex-M

Cortex-A

La catégorie de processeurs Cortex-A est dédiée aux appareils Linux et Android. Tous les appareils - à partir des montres intelligentes et des tablettes et en continuant avec les équipements de réseau - peuvent être pris en charge par les processeurs Cortex-A.

  • Les processeurs Cortex-A (A5, A7, A8, A9, A12, A15 et A17) sont basés sur l'architecture ARMv7-A
  • L'ensemble de fonctionnalités communes pour les processeurs A comprend un moteur de traitement multimédia (NEON), un outil à des fins de sécurité (Trustzone) et divers jeux d'instructions pris en charge (ARM, Thumb, DSP, etc.)
  • Les principales caractéristiques des processeurs Cortex-A sont des performances optimales et une efficacité énergétique brillante étroitement regroupées pour fournir aux utilisateurs le meilleur service possible

Les principales caractéristiques du processeur Cortex-A :

Cortex-A5: Le Cortex A5 est le membre le plus petit et le moins puissant de la série Cortex A, mais il peut toujours démontrer des performances multicœurs, il est compatible avec les processeurs A9 et A15.

Cortex-A7: La consommation électrique de l'A7 est presque la même que celle de l'A5, mais les performances fournies par l'A7 sont 20% supérieures à celles de l'A5 ainsi qu'une compatibilité architecturale totale avec Cortex-A15 et Cortex-A17. Le Cortex-A7 est un choix idéal pour les implémentations de smartphones et de tablettes sensibles aux coûts.

Contrex-A15 : Le Cortex-A15 est le membre le plus performant de cette série, offrant deux fois plus de performances que l'A9. A15 trouve son application dans les appareils haut de gamme, les serveurs basse consommation et les infrastructures sans fil. Il s'agit du premier processeur pris en charge pour les solutions de gestion des données et d'environnement virtuel.

Contrex-A17 : Le Cortex-A17 affiche des performances 60 % supérieures à celles de l'A9. L'objectif principal est de satisfaire les besoins des appareils haut de gamme.

Contrex-A50: Contrex-A50, la dernière série, sont construits sur l'architecture ARMv8 et prennent en charge Arch64-bit, un système économe en énergie. Une raison évidente du passage au 64 bits est la prise en charge de plus de 4 Go de mémoire physique, ce qui est déjà réalisé sur Cortex-A15 et Cortex-A7.

 

Cortex-R

Les processeurs Cortex-R ciblent les applications en temps réel hautes performances telles que les contrôleurs de disque dur, les lecteurs multimédias d'équipement de réseau et d'autres appareils similaires.

Cortex-R4 :  Cortex-R4 est bien adapté aux applications automobiles. Il peut être cadencé jusqu'à 600 MHz, possède un pipeline à 8 étages avec double problème, prélecture et un système d'interruption à faible latence, ce qui le rend idéal pour les systèmes critiques pour la sécurité.

Cortex-R5 : Cortex-R5 étend les fonctionnalités offertes par R4 et ajoute une efficacité et une fiabilité accrues et améliore la gestion des erreurs. L'implémentation dual-core permet de construire des systèmes très puissants et flexibles avec des réponses en temps réel.

Cortex-R7 : Le Cortex-R7 étend considérablement les performances. Ils disposent d'un pipeline à 11 étapes et permettent à la fois une exécution dans le désordre et une prédiction de branche de haut niveau. Des outils peuvent être implémentés pour le multitraitement à pas de verrouillage, symétrique et asymétrique. Le contrôleur d'interruption générique est une autre caractéristique importante qui doit être mentionnée.

 

Cortex-M

Cortex-M conçu spécifiquement pour cibler le marché des MCU. La série Cortex-M est construite sur l'architecture ARMv7-M (utilisée pour Cortex-M3 et Cortex-M4), et la plus petite Cortex-M0+ est construite sur l'architecture ARMv6-M. Il est sûr de dire que le Cortex-M est devenu pour le monde 32 bits ce que le 8051 est pour le 8 bits – un cœur standard fourni par de nombreux fournisseurs. La série Cortex-M peut être implémentée en tant que noyau souple dans un FPGA, par exemple, mais il est beaucoup plus courant de les trouver implémentées en tant que MCU avec des mémoires, des horloges et des périphériques intégrés. Certains sont optimisés pour l'efficacité énergétique, certains pour des performances élevées et certains sont adaptés à un segment de marché spécifique tel que les compteurs intelligents

Pour les applications particulièrement sensibles aux coûts ou qui migrent de 8 bits à 32 bits, le plus petit membre de la série Cortex-M peut être le meilleur choix.

Cortex-M0 : Le Cortex-M0+ utilise le jeu d'instructions Thumb-2 et possède un pipeline en 2 étapes. Les caractéristiques importantes sont le bus pour GPIO à cycle unique et le tampon de micro-trace.

Cortex-M3 et M4 :  Le Cortex-M3 et le Cortex-M4 sont des noyaux très similaires. Chacun offre un pipeline à 3 étages, plusieurs bus 32 bits, des vitesses d'horloge jusqu'à 200 MHz et des options de débogage très efficaces. La différence significative est la capacité du noyau Cortex-M4 pour le DSP. Le Cortex-M3 et le Cortex-M4 partagent la même architecture et le même jeu d'instructions (Thumb-2). Si votre application nécessite des calculs en virgule flottante, vous le ferez beaucoup plus rapidement sur un Cortex-M4 que sur un Cortex-M3. Cela dit, pour une application qui n'utilise pas les capacités DSP ou FPU du Cortex-M4, vous verrez le même niveau de performances et de consommation d'énergie sur un Cortex-M3. En d'autres termes, si vous avez besoin de fonctionnalités DSP, optez pour un Cortex-M4. Sinon, le Cortex-M3 fera le travail.

 

Conclusion

Figure 2. Aperçu du cortex

 

Les processeurs ARM offrent une variété de capacités à des fins différentes. Avec un peu de réflexion et d'investigation, vous serez en mesure de trouver le bon processeur qui convient aux besoins de votre application. que ce soit pour une tablette haut de gamme ou un nœud de capteur sans fil ultra-faible coût.

C'est un défi de faire le bon choix de noyau Cortex et de transformer l'idée en réalité. Mais une équipe de professionnels expérimentés peut prendre en charge tous les problèmes et mettre en œuvre des concepts de toute complexité.

Orient Display se concentre sur les technologies liées aux processeurs ARM depuis de nombreuses années et a accumulé une riche expérience dans le développement et la mise en œuvre de produits d'architecture ARM. Tout en lançant en permanence des plates-formes de développement et un core board qui répondent aux besoins généraux du marché, il répond également aux besoins de projets individuels des clients. Fournir des services personnalisés.

Notre équipe de matériel peut produire des prototypes dans les plus brefs délais en fonction de vos idées de conception et de vos besoins. Notre équipe logicielle peut vous aider à personnaliser toutes les fonctions de la couche du pilote de découpe.

Nous contacter et nous vous aiderons à faire vos plans de l'idée initiale au produit final.