Exercices#

Systèmes sur puce et informatique embarquée

Usage de l’IA, indiqué sur chaque exercice : aucune ; en appui (déboguer, reformuler, vérifier ; la réponse finale est écrite et comprise par vous) ; l’exercice s’appuie sur une réponse d’IA. Voir la charte d’usage de l’IA.

Niveau : ★ échauffement, ★★ classique (niveau bac), ★★★ défi ; les coups de pouce et les corrigés se déplient sous chaque exercice.

★ Exercice 1 — Le bon vocabulaire #

• essentiel

Associer chaque terme à sa définition.

Coup de pouce

Commencer par les termes les plus simples : un capteur mesure, un actionneur agit. Pour les trois autres, se demander : tout est-il sur une seule puce ? Y a-t-il un système d’exploitation ? Les composants sont-ils séparés et remplaçables ?


(1) Système sur puce (SoC)	(a) composant qui agit sur le monde physique (moteur, LED…)
(2) Microcontrôleur	(b) composant qui mesure une grandeur physique (température…)
(3) Capteur	(c) un ordinateur complet intégré sur une seule puce
(4) Actionneur	(d) plaque où sont enfichés des composants séparés et remplaçables
(5) Carte mère	(e) mini-ordinateur sobre et bon marché, sans OS, pour l’embarqué

Corrigé

(1)–(c) ; (2)–(e) ; (3)–(b) ; (4)–(a) ; (5)–(d).

▷ Erreur fréquente. Inverser capteur et actionneur : le capteur mesure (il fournit une entrée au programme), l’actionneur agit (il exécute une commande de sortie).

★ Exercice 2 — SoC ou pas SoC ? #

• essentiel

Pour chacun de ces objets, dire s’il repose plutôt sur un microcontrôleur, un SoC de smartphone/tablette, ou une carte mère classique, et justifier en une ligne : (a) une carte bancaire ; (b) un smartphone ; (c) un PC de jeu que l’on fait évoluer ; (d) un thermostat connecté ; (e) une montre connectée.

Coup de pouce

Pour chaque objet, se demander s’il fait une seule tâche précise avec peu de ressources, s’il s’agit d’un ordinateur complet et polyvalent mais compact, ou si l’on veut pouvoir changer ses composants un par un.

Corrigé

(a) carte bancaire $\to$ microcontrôleur (une tâche précise, minuscule, sobre) ; (b) smartphone $\to$ SoC (ordinateur complet intégré) ; (c) PC de jeu évolutif $\to$ carte mère classique (on remplace/ajoute des composants) ; (d) thermostat connecté $\to$ microcontrôleur (embarqué, capteur $+$ actionneur) ; (e) montre connectée $\to$ SoC (petit, mais ordinateur complet avec OS).

▷ Erreur fréquente. Ranger la montre connectée parmi les microcontrôleurs parce qu’elle est petite : elle fait tourner un système d’exploitation et des applications ; c’est un ordinateur complet, donc un SoC.

★★ Exercice 3 — Microcontrôleur contre SoC #

Citer trois différences importantes entre un microcontrôleur et le SoC d’un smartphone.

Coup de pouce

Comparer point par point : puissance (fréquence), quantité de mémoire, consommation, prix, présence ou non d’un système d’exploitation.
Pourquoi n’installe-t-on en général pas de système d’exploitation complet sur un microcontrôleur ? Quel avantage cela donne-t-il pour une application à temps réel (par exemple un airbag) ?
Le SoC et le microcontrôleur ont pourtant un point commun essentiel. Lequel ?

Corrigé

Par exemple : puissance (quelques MHz contre plusieurs GHz multi-cœurs) ; mémoire (quelques Ko contre plusieurs Go) ; consommation (minuscule contre modérée) ; prix (quelques euros contre quelques dizaines) ; système d’exploitation (aucun contre un OS complet).
Un microcontrôleur est trop peu puissant et a trop peu de mémoire pour un OS ; sans OS, il exécute directement son programme, de façon prévisible. Pour un airbag, on veut une réponse garantie à temps : un OS pourrait interrompre le programme au mauvais moment.
Tous deux intègrent sur une seule puce tous les composants d’un ordinateur (processeur, mémoire, périphériques).

★★ Exercice 4 — La loi de Moore, chiffres en main #

En 1971, l’Intel 4004 comptait $2\,300$ transistors. La loi de Moore affirme que ce nombre double tous les deux ans.

Combien de « doublements » la loi prévoit-elle entre 1971 et 2021 (soit $50$ ans) ?
En déduire une estimation du nombre de transistors d’une puce en 2021. (On rappelle $2^{25}\approx 33{,}5$ millions ; on donnera un ordre de grandeur.)
La puce Apple A15 (2021) compte environ $15$ milliards de transistors. La loi de Moore est-elle une prédiction parfaite ? Commenter.
Les puces récentes sont gravées « en $3$ nm » (une appellation commerciale, qu’on prendra ici comme ordre de grandeur de la largeur d’un transistor). Un atome de silicium mesure environ $0{,}2$ nm. Combien d’atomes, environ, dans la largeur d’un transistor ? Que suggère ce résultat sur l’avenir de la loi de Moore ?

Coup de pouce

Combien de périodes de deux ans y a-t-il en $50$ ans ? Chaque doublement multiplie le nombre de transistors par $2$ : par combien est-il multiplié après tous ces doublements ?

Corrigé

$50 \div 2 = \mathbf{25}$ doublements.

▷ Erreur fréquente. Compter $50$ doublements en $50$ ans : la loi prévoit un doublement tous les deux ans.
$2\,300\times 2^{25}\approx 2\,300\times 33{,}5\text{ millions}\approx \mathbf{7{,}7\times 10^{10}}$, soit environ 80 milliards de transistors.
Non : la loi prévoit $\approx 80$ milliards, la réalité (A15, 2021) est $\approx 15$ milliards, soit environ $5$ fois moins. La loi de Moore donne le bon ordre de grandeur et la bonne tendance, mais elle a ralenti ces dernières années (elle reste une prédiction empirique, pas une loi physique).
$3 \div 0{,}2 = \mathbf{15}$ atomes environ : c’est un ordre de grandeur, car « 3 nm » est un nom commercial (les motifs réels sont un peu plus larges), mais on reste à quelques dizaines d’atomes au plus. On approche des limites physiques : on ne peut pas graver plus fin qu’un atome. La loi de Moore ne pourra donc pas continuer éternellement.

★★ Exercice 5 — Dérouler un thermostat #

• essentiel

Un thermostat connecté maintient une pièce à la température consigne. Il dispose d’un capteur de température et peut commander un radiateur (l’allumer ou l’éteindre).

Identifier le capteur et l’actionneur de ce système.

Recopier et compléter la boucle de fonctionnement :

while True:
    t = ...                     # (a) lire la temperature
    if t < consigne:
        ...                      # (b) que faire ?
    else:
        ...                      # (c) que faire ?
    attendre(30)                 # on re-teste toutes les 30 s

Ce système présente-t-il une contrainte de temps réel aussi forte qu’un système de freinage ABS ? Justifier.

Coup de pouce

Question 2 : que doit faire le radiateur quand il fait trop froid ? quand la consigne est atteinte ? Question 3 : comparer les conséquences d’un retard de quelques secondes dans les deux systèmes.

Corrigé

Capteur : le capteur de température (entrée). Actionneur : le radiateur (sortie).
Démarche : un tour de boucle lit le capteur, décide (trop froid ou non), puis commande l’actionneur. (a) t = lire_temperature() ; (b) allumer_radiateur() ; (c) eteindre_radiateur().
Non : quelques secondes de retard sur un chauffage sont sans danger, alors qu’un freinage ABS doit réagir en quelques millisecondes. La contrainte de temps réel est bien plus faible ici (d’où le attendre(30)).

▷ Erreur fréquente. Confondre « temps réel » et « très rapide » : un système temps réel doit répondre dans un délai garanti, adapté à sa tâche ; pour un thermostat, ce délai peut être de plusieurs secondes.

★★ Exercice 6 — Von Neumann ou Harvard ? #

Dans le modèle de von Neumann, où sont rangés le programme et les données ? Et dans l’architecture de Harvard ?
L’architecture de Harvard utilise deux bus distincts. Quel avantage concret cela procure-t-il au processeur à chaque cycle ?
Un SoC de smartphone suit plutôt le modèle de von Neumann, un petit microcontrôleur plutôt Harvard. Proposer une explication.

Coup de pouce

Relire le schéma des deux architectures dans le cours : combien de mémoires, combien de bus ? Pour la question 3, se demander lequel des deux exécute toujours le même programme, et lequel doit pouvoir en charger de nouveaux.

Corrigé

Von Neumann : programme et données dans la même mémoire. Harvard : programme (mémoire morte, Flash) et données (mémoire vive, RAM) dans deux mémoires séparées.

▷ Erreur fréquente. Inverser les deux modèles : c’est l’architecture de von Neumann qui range programme et données dans une même mémoire ; celle de Harvard les sépare.
Avec deux bus, le processeur peut charger une instruction et une donnée en même temps (au même cycle), au lieu de faire deux accès successifs : c’est plus rapide.
Un microcontrôleur vise la simplicité et la vitesse sur une tâche fixe : Harvard (deux mémoires dédiées) y est efficace. Un SoC vise la polyvalence (exécuter n’importe quel programme, chargé en mémoire) : le modèle de von Neumann, plus souple, s’y prête mieux.

★★ Exercice 7 — Le prix de l’intégration #

• essentiel

Citer deux intérêts et deux limites d’un système sur puce par rapport à une carte mère classique.
La batterie du téléphone de Léa est usée, mais elle est soudée à la carte, tout comme le reste. Expliquer, avec le vocabulaire du cours, pourquoi c’est un problème — et à quel enjeu de société cela renvoie.
Pour aller plus loin. Pourquoi la faible consommation d’un SoC entraîne-t-elle aussi moins de chaleur et donc souvent l’absence de ventilateur ?

Coup de pouce

Reprendre les critères du cours : consommation, taille, coût, vitesse d’un côté ; réparation, évolution, déchets de l’autre. Pour la question 3, se demander ce que devient l’énergie électrique consommée par un circuit.

Corrigé

Intérêts (deux au choix) : faible consommation d’énergie, petite taille, faible coût, grande vitesse (courtes distances). Limites (deux au choix) : non réparable, non évolutif, obsolescence, déchets électroniques.
Tout étant intégré et soudé, on ne peut pas remplacer la seule batterie : il faut changer tout le téléphone (non réparable / non évolutif). Cela alimente la montagne de déchets électroniques et motive les lois sur le droit à la réparation et l’indice de réparabilité.
L’énergie consommée par un circuit finit en chaleur, dissipée dans les transistors et dans les connexions ; transporter des signaux sur de longs fils entre puces séparées en consomme beaucoup. En consommant peu (composants proches, sans long câblage), un SoC chauffe peu, donc n’a souvent pas besoin de ventilateur (il est aussi silencieux).

★★ Exercice 8 — Exercice d’entraînement — un microcontrôleur dans la voiture #

Une voiture moderne embarque des dizaines de calculateurs. On s’intéresse au régulateur de vitesse, piloté par un microcontrôleur.

Le microcontrôleur reçoit la vitesse du véhicule et commande l’accélération. Nommer le composant d’entrée et le composant de sortie, et préciser lequel est un capteur, lequel un actionneur.
Citer deux avantages d’utiliser un microcontrôleur (plutôt qu’un ordinateur classique avec carte mère) dans une voiture.
Expliquer pourquoi la contrainte de temps réel est ici une question de sécurité.
Voici le cœur du programme embarqué. Que se passe-t-il, concrètement, quand v vaut $120$ et consigne vaut $130$ ?

Coup de pouce

Entrée : ce qui mesure ; sortie : ce qui agit. Pour la question 4, dérouler un tour de boucle à la main avec les valeurs données.
```
while True:
    v = lire_capteur_vitesse()
    if v < consigne:
        accelerer()
    elif v > consigne:
        freiner()
    attendre(0.1)
```

Corrigé

Entrée : le capteur de vitesse (capteur). Sortie : le dispositif d’accélération/freinage (actionneur).
Par exemple : faible consommation (autonomie, peu de chaleur), faible coût (des dizaines par voiture), petite taille (s’intègre partout), fiabilité / temps réel (pas d’OS qui pourrait retarder la réponse). (Deux suffisent.)
Un régulateur ou un freinage doit réagir en une fraction de seconde : un retard mettrait en danger les passagers. La garantie de répondre à temps est donc une exigence de sécurité, pas seulement de confort.
v$=120 <$ consigne$=130$ : la condition v < consigne est vraie, donc le système accélère (accelerer()), puis attend $0{,}1$ s avant de re-mesurer.

★ Exercice 9 — Type bac — Plusieurs processeurs sur une puce (d’après Amérique du Nord 2026, jour 2) #

≈ 15 min

Un système d’exploitation permet d’exécuter plusieurs applications à la fois en donnant l’impression qu’elles fonctionnent simultanément. En réalité, le système répartit le temps de calcul du processeur entre les différents processus, de sorte qu’ils s’exécutent chacun à leur tour très rapidement. Même si un seul processus utilise réellement le processeur à un instant donné, cette alternance rapide donne l’impression que tout s’exécute en même temps.

Un smartphone dispose de plusieurs ressources, dont un processeur graphique (GPU), un microphone (MIC), une caméra (CAM) et un processeur dédié au calcul (CAL) ; chacune de ces ressources ne peut être utilisée que par un seul processus à la fois.

Expliquer l’intérêt d’utiliser une machine équipée de plusieurs processeurs plutôt qu’une machine équipée d’un seul processeur.
Décrire un avantage et un inconvénient des systèmes sur puces, tels que ceux utilisés dans les smartphones.

Coup de pouce

Question 1 : avec un seul processeur, deux processus peuvent-ils s’exécuter réellement au même instant ? Question 2 : relire dans le cours les intérêts et les limites de l’intégration sur une seule puce.

Corrigé

Barème indicatif (sur 2) : Q1 : 1 ; Q2 : 1

Avec un seul processeur, un seul processus s’exécute à un instant donné : le parallélisme n’est qu’apparent (alternance). Avec plusieurs processeurs (ou plusieurs cœurs), plusieurs processus s’exécutent réellement en même temps, un par processeur : plus de calculs sont réalisés par seconde, les processus attendent moins leur tour et la machine reste réactive même quand l’un d’eux calcule beaucoup (par exemple décoder de la musique pendant que l’interface répond à l’utilisateur).
Avantage (un seul suffit) : tous les composants (processeurs, GPU, mémoire, modules de communication) sont gravés sur une même puce, donc très proches : communications rapides, faible consommation (autonomie de la batterie) et peu de chaleur, faible encombrement, coût réduit en grande série.
Inconvénient (un seul suffit) : le SoC n’est ni réparable ni évolutif : si un composant tombe en panne ou devient insuffisant (mémoire par exemple), on ne peut pas le remplacer seul, il faut changer toute la puce, voire l’appareil ; sa conception est aussi très coûteuse.

★★★ Exercice 10 — Type bac — Choisir la puce d’une montre connectée (sujet maison, façon bac) #

≈ 45 min

Une entreprise conçoit une montre connectée destinée aux coureurs. La montre doit mesurer le rythme cardiaque en continu, afficher l’heure, et, de temps en temps, faire tourner de petites applications (carte, messages) sous un système d’exploitation. Sa batterie a une capacité de $300$ mAh. Les ingénieurs hésitent entre trois puces :

	Puce A	Puce B	Puce C
Fréquence	$64$ MHz	$4$ cœurs à $1{,}7$ GHz	$120$ MHz
Mémoire vive	$256$ Ko	$2$ Go	$1$ Mo
Système d’exploitation	aucun	oui	aucun
Consommation moyenne	$2$ mA	$20$ mA	$8$ mA
Prix	$2$ €	$35$ €	$5$ €

On admet que l’autonomie d’un appareil, en heures, est égale à la capacité de la batterie (en mAh) divisée par la consommation moyenne (en mA).

Parmi ces trois puces, lesquelles sont des microcontrôleurs ? Laquelle est un SoC de type smartphone ? Justifier à l’aide de deux lignes du tableau.
Rappeler pourquoi on dit d’un microcontrôleur comme d’un SoC qu’il est un « système sur puce ».
Calculer l’autonomie de la montre avec chacune des trois puces.
Le cahier des charges impose une autonomie d’au moins $24$ heures. Quelle(s) puce(s) conviennent ? Laquelle, pourtant, est la seule capable de faire tourner les applications prévues ? Pourquoi ?
Les puces sont décrites en Python par une liste de dictionnaires :
```
puces = [
    {"nom": "A", "frequence_MHz": 64, "os": False, "conso_mA": 2},
    {"nom": "B", "frequence_MHz": 1700, "os": True, "conso_mA": 20},
    {"nom": "C", "frequence_MHz": 120, "os": False, "conso_mA": 8},
]
```
Écrire une fonction autonomie(capacite_mAh, conso_mA) qui renvoie l’autonomie en heures, puis une fonction puces_compatibles(puces, capacite_mAh, heures_min) qui renvoie la liste des noms des puces offrant une autonomie d’au moins heures_min heures. Que renvoie puces_compatibles(puces, 300, 72) ?
Pour concilier les deux exigences, les ingénieurs retiennent deux puces : la puce A fonctionne en permanence ($24$ h sur $24$) pour lire le capteur cardiaque, et la puce B n’est réveillée que $2$ heures par jour au total. Calculer la charge consommée en une journée (en mAh), puis l’autonomie de la montre, en jours.
Le capteur cardiaque doit être lu toutes les $20$ millisecondes, sans jamais prendre de retard. Expliquer pourquoi cette tâche est confiée à la puce A plutôt qu’à la puce B.

Coup de pouce

Questions 1 et 4 : regarder les lignes « Fréquence », « Mémoire vive » et « Système d’exploitation » du tableau. Question 6 : calculer séparément la charge consommée par chaque puce en une journée (consommation multipliée par la durée de fonctionnement), puis additionner. Question 7 : penser au partage du processeur par un système d’exploitation.

Coup de pouce 2 (début de solution)

Question 5 : autonomie tient en une ligne (return d’une division). Pour puces_compatibles : partir de resultat = [], parcourir for puce in puces: et ajouter le nom de la puce quand autonomie(capacite_mAh, puce["conso_mA"]) est suffisante.

Corrigé

Barème indicatif (sur 6) : Q1 : 0,75 ; Q2 : 0,5 ; Q3 : 0,75 ; Q4 : 0,75 ; Q5 : 1,25 ; Q6 : 1,25 ; Q7 : 0,75

A et C sont des microcontrôleurs : fréquence de quelques dizaines à une centaine de MHz, mémoire de quelques centaines de Ko à $1$ Mo, aucun système d’exploitation, consommation et prix très faibles. B est un SoC de type smartphone : plusieurs cœurs à plus d’un GHz, $2$ Go de mémoire, un système d’exploitation.
Dans les deux cas, tous les composants d’un ordinateur (processeur, mémoire, entrées-sorties) sont intégrés sur un seul circuit intégré.
Puce A : $300 \div 2 = \mathbf{150}$ h ; puce B : $300 \div 20 = \mathbf{15}$ h ; puce C : $300 \div 8 = \mathbf{37{,}5}$ h.
Les puces A et C tiennent au moins $24$ h (la puce B seulement $15$ h). Pourtant, seule la puce B peut faire tourner les applications : elles nécessitent un système d’exploitation, et beaucoup de mémoire et de puissance, ce qu’un microcontrôleur n’a pas.

Par exemple :

def autonomie(capacite_mAh, conso_mA):
    return capacite_mAh / conso_mA

def puces_compatibles(puces, capacite_mAh, heures_min):
    return [puce["nom"] for puce in puces
            if autonomie(capacite_mAh, puce["conso_mA"]) >= heures_min]

Autre méthode : une boucle qui ajoute le nom de chaque puce assez autonome.

def puces_compatibles(puces, capacite_mAh, heures_min):
    resultat = []
    for puce in puces:
        if autonomie(capacite_mAh, puce["conso_mA"]) >= heures_min:
            resultat.append(puce["nom"])
    return resultat

puces_compatibles(puces, 300, 72) renvoie ["A"] (seule la puce A dépasse $72$ h ; la puce C n’atteint que $37{,}5$ h).

Puce A : $2 \times 24 = 48$ mAh ; puce B : $20 \times 2 = 40$ mAh ; total $\mathbf{88}$ mAh par jour. Autonomie : $300 \div 88 \approx \mathbf{3{,}4}$ jours (environ $3$ jours complets).
C’est une contrainte de temps réel : la mesure doit être faite à intervalle régulier, sans retard. Le microcontrôleur, sans système d’exploitation, exécute directement son programme de façon prévisible, alors que l’OS de la puce B partage le processeur entre de nombreux processus et pourrait retarder la lecture. De plus, la puce A consomme $10$ fois moins, ce qui compte pour une tâche permanente.

★★★ Exercice 11 — Type bac — Une station météo au lycée (sujet maison, façon bac) #

≈ 45 min

Le club de sciences du lycée installe sur le toit une station météo. Elle est pilotée par un microcontrôleur d’architecture de Harvard, qui dispose de $32$ Ko de mémoire Flash et de $2$ Ko ($2\,048$ octets) de mémoire vive. Toutes les $10$ minutes, il lit trois capteurs (température, humidité, vitesse du vent) ; si la température passe sous $0$ ° C, il allume une LED rouge d’alerte « gel » sur le boîtier.

Citer les capteurs et l’actionneur de ce système embarqué.
Dans quelle mémoire est stocké le programme du microcontrôleur ? Dans laquelle sont stockées les mesures ? Pourquoi le programme n’est-il pas perdu lorsqu’on coupe l’alimentation ?
Le capteur de température délivre une tension, transformée par un convertisseur analogique-numérique en un entier codé sur $10$ bits. Combien de valeurs différentes ce convertisseur peut-il produire ? Quelles sont la plus petite et la plus grande ?
La documentation du capteur indique la formule de conversion suivante : $$\text{température (en ° C)} = \text{valeur} \times 0{,}1 - 40.$$ Écrire une fonction convertir(valeur) qui renvoie la température correspondant à une valeur lue. Que renvoie convertir(512) ? Quelle est la plus haute température mesurable ?
Écrire une fonction alerte_gel(mesures) qui prend en paramètre une liste (non vide) de valeurs brutes lues sur le convertisseur et qui renvoie True si l’une d’elles correspond à une température strictement négative, False sinon. Que renvoie alerte_gel([412, 405, 398, 401, 420]) ?

Recopier et compléter la boucle principale du programme :

mesures = []
while True:
    valeur = ...                     # (a) lire le capteur de temperature
    mesures.append(valeur)
    if ...:                          # (b) faut-il donner l'alerte ?
        allumer_led()
    else:
        ...                          # (c)
    attendre(600)                    # 600 s = 10 minutes

Dans le programme complet, les trois capteurs sont lus toutes les $10$ minutes et chaque mesure est rangée en mémoire vive sur $2$ octets. Combien de mesures la station enregistre-t-elle par jour ? Combien d’octets cela représente-t-il ? Combien de jours complets de mesures la mémoire vive peut-elle conserver au maximum ? Quel défaut de la boucle précédente cela révèle-t-il ?
Quel avantage l’architecture de Harvard apporte-t-elle par rapport au modèle de von Neumann ? Pourquoi ce type de système n’a-t-il pas besoin de système d’exploitation ?

Coup de pouce

Question 3 : combien de nombres différents peut-on écrire avec $10$ bits ? Question 5 : réutiliser convertir. Question 7 : compter les relevés par heure, puis par jour, avant de multiplier par le nombre de capteurs et d’octets ; comparer ensuite à la taille de la mémoire vive.

Coup de pouce 2 (début de solution)

Question 5 :
def alerte_gel(mesures):
for valeur in mesures:
if convertir(valeur) < 0:
Que renvoyer dans ce cas ? Et que renvoyer après la boucle ?

Corrigé

Barème indicatif (sur 6) : Q1 : 0,5 ; Q2 : 0,75 ; Q3 : 0,5 ; Q4 : 0,75 ; Q5 : 1 ; Q6 : 1 ; Q7 : 0,75 ; Q8 : 0,75

Capteurs : température, humidité, vitesse du vent (anémomètre). Actionneur : la LED rouge d’alerte.
Le programme est dans la mémoire Flash (mémoire morte) ; les mesures (données) sont dans la mémoire vive (RAM). La mémoire Flash est non volatile : elle conserve son contenu sans alimentation, contrairement à la RAM.
Sur $10$ bits : $2^{10} = \mathbf{1\,024}$ valeurs, de $\mathbf{0}$ à $\mathbf{1\,023}$.
Par exemple :
```
def convertir(valeur):
    return valeur * 0.1 - 40
```
convertir(512) renvoie $51{,}2 - 40 = \mathbf{11{,}2}$ ° C (Python affiche une valeur approchée, comme 11.200000000000003, à cause du codage des flottants). Plus haute température mesurable : $1\,023 \times 0{,}1 - 40 = \mathbf{62{,}3}$ ° C.

Par exemple :

def alerte_gel(mesures):
    for valeur in mesures:
        if convertir(valeur) < 0:
            return True
    return False

Les températures sont $1{,}2$ ; $0{,}5$ ; $-0{,}2$ ; $0{,}1$ ; $2{,}0$ ° C : la valeur $398$ donne $-0{,}2$ ° C, donc la fonction renvoie True.

(a) valeur = lire_capteur_temperature() ; (b) convertir(valeur) < 0 ; (c) eteindre_led().
$6$ relevés par heure $\times\ 24$ h $\times\ 3$ capteurs $= \mathbf{432}$ mesures par jour, soit $432 \times 2 = \mathbf{864}$ octets. $2\,048 \div 864 \approx 2{,}37$ : la RAM peut conserver au plus $2$ jours complets de mesures. Or la liste mesures grossit sans fin (while True) : au bout de quelques jours, la mémoire est saturée. Il faut régulièrement transmettre les mesures (par exemple au serveur du club) puis les effacer, ou ne garder que les plus récentes.
Avec deux mémoires et deux bus, le processeur lit une instruction et une donnée en même temps, ce qui est plus rapide. Pas besoin d’OS : le microcontrôleur exécute une seule tâche, toujours la même, directement dès la mise sous tension ; un OS n’apporterait rien et ne tiendrait d’ailleurs pas dans $2$ Ko de RAM.

★★ Exercice 12 — Type bac — Une salle informatique à renouveler (sujet maison, façon bac) #

≈ 45 min

Le lycée doit renouveler les $30$ ordinateurs d’une salle. Deux solutions sont étudiées :

solution 1 : des ordinateurs « tour » classiques, construits autour d’une carte mère (processeur, barrettes de mémoire, carte graphique, carte Wi-Fi enfichés séparément), avec ventilateurs ; puissance moyenne $150$ W ;
solution 2 : des mini-PC de la taille d’un livre, construits autour d’un système sur puce, sans ventilateur ; puissance moyenne $15$ W.

La salle est utilisée $8$ heures par jour, $160$ jours par an. On rappelle que l’énergie (en Wh) est égale à la puissance (en W) multipliée par la durée (en h), et que $1$ kWh $= 1\,000$ Wh.

Parmi les éléments suivants, indiquer ceux qui sont intégrés sur la puce d’un système sur puce : processeur (CPU), processeur graphique (GPU), contrôleur Wi-Fi, mémoire vive, alimentation électrique, ventilateur.
Expliquer pourquoi le fait de rapprocher tous les composants sur une même puce permet à la fois de réduire la consommation et de se passer de ventilateur. Quel autre avantage cela présente-t-il dans une salle de classe ?
Calculer, en kWh, l’énergie consommée en un an par la salle avec chacune des deux solutions, puis l’économie réalisée par la solution 2. Le prix de l’électricité est de $0{,}20$ € par kWh : quelle économie annuelle, en euros, cela représente-t-il ?
Pendant la transition, la salle mélange des tours et des mini-PC. On la représente par une liste, et les puissances par un dictionnaire :
```
puissances = {"tour": 150, "mini": 15}
salle = ["tour", "mini", "mini", "tour", "mini"]
```
Écrire une fonction energie_salle(postes, puissances, heures) qui renvoie l’énergie, en kWh, consommée par tous les postes de la liste postes pendant heures heures. Que renvoie energie_salle(["mini", "tour", "mini"], puissances, 10) ?
Dans trois ans, les logiciels utilisés demanderont deux fois plus de mémoire vive. Expliquer ce que l’on pourra faire avec la solution 1, et ce qu’il faudra faire avec la solution 2.
Un mini-PC tombe en panne à cause d’un seul transistor défectueux de sa puce. Peut-on le réparer ? Quelle conséquence environnementale cela a-t-il, et quelle réponse la société tente-t-elle d’y apporter ?
Rédiger, en quelques lignes, une recommandation argumentée pour le proviseur (deux arguments au moins pour chaque solution).

Coup de pouce

Question 3 : énergie d’un poste en un an $=$ puissance $\times$ heures par jour $\times$ jours par an ; multiplier ensuite par le nombre de postes. Question 4 : accumuler, poste par poste, l’énergie consommée. Questions 5 et 6 : se demander ce qui est enfiché et ce qui est gravé sur la puce.

Coup de pouce 2 (début de solution)

Question 4 : commencer par total = 0, puis for poste in postes: ; la puissance d’un poste se lit avec puissances[poste]. Ne pas oublier de convertir le total en kWh avant de le renvoyer.

Corrigé

Barème indicatif (sur 6) : Q1 : 0,5 ; Q2 : 0,75 ; Q3 : 1 ; Q4 : 1,25 ; Q5 : 0,75 ; Q6 : 0,75 ; Q7 : 1

Sont intégrés sur la puce : le CPU, le GPU, le contrôleur Wi-Fi et la mémoire vive. L’alimentation électrique n’est pas sur la puce, et il n’y a pas de ventilateur.
Les signaux parcourent de très courtes distances, sans longs fils de cuivre : il faut moins d’énergie, donc il se dégage moins de chaleur, et un ventilateur devient inutile. Autre avantage : la machine est silencieuse (et beaucoup plus petite).
Solution 1 : $150 \times 30 \times 8 \times 160 = 5\,760\,000$ Wh $= \mathbf{5\,760}$ kWh. Solution 2 : $15 \times 30 \times 8 \times 160 = 576\,000$ Wh $= \mathbf{576}$ kWh. Économie : $5\,760 - 576 = \mathbf{5\,184}$ kWh, soit $5\,184 \times 0{,}20 = \mathbf{1\,036{,}80}$ € par an.

Par exemple :

def energie_salle(postes, puissances, heures):
    total = 0
    for poste in postes:
        total = total + puissances[poste] * heures   # en Wh
    return total / 1000                               # en kWh

energie_salle(["mini", "tour", "mini"], puissances, 10) : $(15 + 150 + 15) \times 10 = 1\,800$ Wh, la fonction renvoie 1.8 (kWh).

Solution 1 : on ajoute ou remplace des barrettes de mémoire sur la carte mère (composants séparés, évolutifs). Solution 2 : la mémoire est intégrée à la puce, impossible d’en ajouter : il faudra remplacer les mini-PC entiers.
Non : le SoC est non réparable, toute la puce est perdue (et en pratique tout le mini-PC). Cela alimente la montagne de déchets électroniques ; la société y répond par le droit à la réparation et l’indice de réparabilité.
Exemple. Solution 2 : consommation divisée par $10$ (environ $1\,000$ € économisés par an), silence, faible encombrement, faible chaleur dans la salle. Solution 1 : machines réparables et évolutives (mémoire, carte graphique), donc durée de vie potentiellement plus longue et moins de déchets. Une recommandation raisonnable : la solution 2 pour un usage bureautique courant, en surveillant sa durée de vie ; la solution 1 si la salle sert à des usages exigeants appelés à évoluer. (Une recommandation argumentée dans l’autre sens est aussi correcte.)

★★★ Exercice 13 — Type bac — Au cœur d’un smartphone (sujet maison, façon bac) #

≈ 45 min

Le schéma ci-dessous décrit la puce Azur X1 (fictive) d’un smartphone sorti en 2025. Elle compte $16$ milliards de transistors.

Partie A — Architecture.

Justifier que l’Azur X1 est un système sur puce et non un simple microcontrôleur (deux arguments).
Classer les six blocs du schéma selon les trois éléments du modèle de von Neumann : unité de calcul, mémoire, entrées-sorties.
Le processeur comporte deux sortes de cœurs : $2$ cœurs rapides et $6$ cœurs économes. Proposer, pour chacune des deux situations suivantes, le type de cœur le plus adapté, en justifiant : (a) lire de la musique, écran éteint ; (b) faire tourner un jeu en 3D.
(Rappel du chapitre sur les processus.) Quel logiciel décide, à chaque instant, quel processus s’exécute sur quel cœur ? Quel est l’intérêt d’avoir $8$ cœurs plutôt qu’un seul ?
Pourquoi intégrer des processeurs spécialisés (GPU, NPU, module cryptographique) plutôt que de tout confier au CPU ?

Partie B — Loi de Moore.

L’ancêtre de l’Azur X1, sorti en 2015, comptait $1$ milliard de transistors. Selon la loi de Moore, combien de transistors l’Azur X1 aurait-il dû compter en 2025 ? Comparer à la valeur réelle et commenter.
On souhaite écrire une fonction annee_prevue(transistors, annee, objectif) qui, partant d’une puce de transistors transistors sortie l’année annee, renvoie l’année à partir de laquelle la loi de Moore prévoit au moins objectif transistors. Recopier et compléter :
```
def annee_prevue(transistors, annee, objectif):
    while ...:
        transistors = ...
        annee = ...
    return annee
```
Que renvoie annee_prevue(10**9, 2015, 16 * 10**9) ? Avec combien d’années de retard sur la prévision l’Azur X1 est-il arrivé ?
Que renvoie annee_prevue(2300, 1971, 10**9) (on part de l’Intel 4004) ? Justifier par un calcul, sachant que $2^{18} = 262\,144$ et $2^{19} = 524\,288$.

Coup de pouce

Question 2 : pour chaque bloc, se demander s’il calcule, s’il retient des données ou s’il échange avec l’extérieur. Question 6 : combien de périodes de deux ans entre 2015 et 2025 ? Question 9 : chercher le plus petit nombre de doublements qui fait dépasser $10^9 \div 2\,300$.

Coup de pouce 2 (début de solution)

Question 7 : la boucle tourne tant que l’objectif n’est pas atteint, while transistors < objectif: ; que deviennent transistors et annee à chaque période de deux ans ?

Corrigé

Barème indicatif (sur 6) : Q1 : 0,5 ; Q2 : 0,75 ; Q3 : 0,5 ; Q4 : 0,5 ; Q5 : 0,5 ; Q6 : 0,75 ; Q7 : 1,25 ; Q8 : 0,5 ; Q9 : 0,75

Partie A.

C’est un ordinateur complet et puissant sur une seule puce : processeur multi-cœur à plusieurs GHz, $8$ Go de mémoire (et non quelques Ko), GPU, processeurs spécialisés, modules de communication ; il fait tourner un système d’exploitation complet, ce qu’un microcontrôleur ne fait pas.
Unité de calcul : CPU, GPU, NPU, module cryptographique. Mémoire : RAM. Entrées-sorties : modem 5G, Wi-Fi, GPS. (Le bus relie le tout.)
(a) Musique écran éteint : tâche légère et longue $\to$ un cœur économe (il suffit largement et préserve la batterie). (b) Jeu 3D : tâche lourde $\to$ les cœurs rapides (avec le GPU pour l’affichage), quitte à consommer davantage.
C’est le système d’exploitation (son ordonnanceur). Avec $8$ cœurs, jusqu’à $8$ processus s’exécutent réellement en même temps (au lieu d’une simple alternance) : le téléphone reste réactif et fait plus de calculs par seconde.
Un processeur spécialisé réalise sa tâche (graphisme, calcul d’IA, chiffrement des données) beaucoup plus vite et en consommant moins qu’un CPU généraliste ; il libère en outre le CPU pour le reste.

Partie B.

De 2015 à 2025 : $10$ ans, soit $5$ doublements : $1 \times 2^5 = \mathbf{32}$ milliards prévus. Réalité : $16$ milliards, soit deux fois moins. La tendance (croissance exponentielle) reste juste, mais la loi de Moore ralentit : c’est une observation empirique, et l’on approche des limites physiques de la gravure.

Par exemple :

def annee_prevue(transistors, annee, objectif):
    while transistors < objectif:
        transistors = transistors * 2
        annee = annee + 2
    return annee

Il faut passer de $1$ à $16$ milliards : $16 = 2^4$, soit $4$ doublements, donc $8$ ans : la fonction renvoie 2023. L’Azur X1 (2025) arrive avec $2$ ans de retard sur la prévision.
$10^9 \div 2\,300 \approx 434\,783$. Or $2^{18} = 262\,144 < 434\,783 \le 2^{19} = 524\,288$ : il faut $19$ doublements, soit $38$ ans. La fonction renvoie $1971 + 38 = \texttt{2009}$.

★ Exercice 14 — L’informatique invisible #

Des dizaines de milliards d’objets connectés (IoT) nous entourent, chacun avec sa puce.

Donner trois exemples d’objets connectés de la vie courante.
Chaque objet connecté est à la fois une porte d’entrée sur un réseau et un capteur du monde. En quoi cela pose-t-il, respectivement, un problème de sécurité et de vie privée ?

Coup de pouce

Question 1 : penser aux objets de la maison, du poignet, de la voiture. Question 2 : un objet relié à un réseau peut être joint à distance, par n’importe qui ; un capteur enregistre des informations sur son utilisateur : qui peut y accéder ?

Corrigé

Par exemple : montre connectée, ampoule connectée, thermostat, enceinte vocale, caméra de surveillance, voiture connectée.
Sécurité : chaque objet connecté est une machine sur le réseau, donc une porte d’entrée potentielle pour un attaquant (souvent mal protégée). Vie privée : chaque objet est un capteur qui collecte des données sur nous (déplacements, habitudes, voix…), qui peuvent être exploitées.

★★ Exercice 15 — Le système sur puce expliqué par un assistant d’IA #

Un élève demande à un assistant d’IA : « Qu’est-ce qu’un système sur puce, et qu’est-ce qui l’a rendu possible ? » Voici la réponse obtenue :

Réponse de l’assistant

« Un système sur puce (SoC, System on a Chip) regroupe sur un seul circuit intégré tous les composants d’un ordinateur : processeur, processeur graphique, mémoire vive, contrôleurs d’entrées-sorties et modules de communication (Wi-Fi, Bluetooth…). Ses avantages : composants très proches donc communications rapides, faible consommation et peu de chaleur (souvent sans ventilateur), encombrement et coût réduits ; son inconvénient : il n’est ni réparable ni évolutif. Cette intégration a été rendue possible par la miniaturisation des transistors, décrite par la loi de Moore : selon cette loi, la fréquence d’horloge des processeurs double environ tous les deux ans, ce qui a permis de passer des $2\,300$ transistors de l’Intel 4004 (1971) aux dizaines de milliards d’aujourd’hui. Les SoC équipent les smartphones, les tablettes, les objets connectés et de plus en plus d’ordinateurs portables. »

La réponse est-elle correcte ? Pour le vérifier, faire un calcul d’ordre de grandeur : si la fréquence d’horloge avait doublé tous les deux ans depuis 1971 (le 4004 tournait à environ $0{,}7$ MHz), quelle fréquence aurait un processeur de 2021 ? Est-ce réaliste (un processeur actuel tourne entre $2$ et $5$ GHz) ?
Localiser et corriger la phrase erronée.
Quelle vérification simple, faite avant de faire confiance à la réponse, aurait suffi à détecter l’erreur ?

Coup de pouce

Question 1 : compter les doublements en $50$ ans, multiplier la fréquence de départ par $2$ autant de fois, puis convertir en GHz ($1$ GHz $= 1\,000$ MHz) et comparer.

Corrigé

Non. $50$ ans $= 25$ doublements ; $0{,}7\ \text{MHz} \times 2^{25} \approx 0{,}7 \times 33{,}5\ \text{millions de MHz} \approx 2{,}3 \times 10^{7}$ MHz, soit environ $23\,000$ GHz ($23$ THz). C’est plusieurs milliers de fois la fréquence réelle d’un processeur actuel ($2$ à $5$ GHz) : la loi telle qu’énoncée par l’assistant est fausse.
La phrase fautive est « la fréquence d’horloge des processeurs double environ tous les deux ans ». Le cours : « le nombre de transistors sur une puce double environ tous les deux ans ». C’est le nombre de transistors qui suit la loi de Moore ; la fréquence a certes augmenté grâce à la miniaturisation, mais beaucoup moins vite, et elle plafonne depuis les années 2000 (chaleur, consommation). La fin de la phrase (« passer de $2\,300$ transistors… aux dizaines de milliards ») parle d’ailleurs bien de transistors, ce qui trahit l’incohérence. Le reste de la réponse (composants d’un SoC, avantages, inconvénient, usages) est exact.
Faire un calcul d’ordre de grandeur sur toute affirmation chiffrée : une croissance exponentielle sur cinquante ans donne des nombres énormes, qu’il suffit de confronter à une valeur connue (quelques GHz). Relire aussi la phrase pour vérifier qu’elle est cohérente avec elle-même (fréquence annoncée, transistors comptés).

★★ Exercice 16 — Expliquer en deux minutes #

Au Grand Oral comme devant l’examinateur de l’épreuve pratique, il faut savoir expliquer une notion clairement, sans lire ses notes. Choisir l’un des sujets suivants (ou le tirer au sort) :

Expliquer à un parent ce qu’est un système sur puce et pourquoi son smartphone en contient un.
Expliquer la différence entre un microcontrôleur (dans un thermostat, un airbag) et le SoC d’un smartphone.
Expliquer ce que dit la loi de Moore, ce qu’elle ne dit pas, et ses limites.

Préparation (5 min, seul). Noter au brouillon trois idées et un exemple, rien de plus : comme au Grand Oral, ces notes servent d’aide-mémoire. Exposé (2 min, chronométré). Debout, face à un camarade, sans lire ses notes et sans rien écrire : tout passe par la parole. Retour (2 min). Le camarade pose une question de relance (on peut alors s’aider d’un schéma), remplit la grille ci-dessous et donne un conseil ; puis on échange les rôles. Cette grille reprend les critères d’évaluation du Grand Oral.

Coup de pouce

Structurer chaque explication en trois temps : une définition en une phrase, un exemple petit et concret déroulé à voix haute, puis le piège (l’erreur que l’auditeur risque de faire). Finir par une phrase qui répond à la question posée. Partir d’un objet que l’auditeur a en main (son téléphone, sa carte bancaire) et dire ce qu’il y a dedans avant de nommer la notion. Sujet 3 : qu’est-ce qui double, exactement ?

Grille entre camarades	Oui	En partie	Pas encore
Clair — audible, posé ; chaque mot technique est expliqué	▫	▫	▫
Juste — c’est exact, et l’exemple montre vraiment l’idée	▫	▫	▫
Construit — un fil conducteur, tenu en deux minutes, sans lire	▫	▫	▫
Un conseil pour la prochaine fois :

Corrigé

Pas de texte à apprendre par cœur : voici les éléments attendus pour chaque sujet. L’ordre, les mots et l’exemple peuvent être différents ; l’explication est réussie si ces idées y sont, justes et reliées entre elles.

Sujet 1.

Un SoC regroupe sur un seul circuit intégré processeur(s), processeur graphique, mémoire, contrôleurs d’entrées-sorties et modules de communication (Wi-Fi, Bluetooth, réseau mobile).
Avantages : composants très proches donc échanges rapides, faible consommation (autonomie, souvent sans ventilateur), petite taille, coût réduit en grande série.
Exemple : un smartphone doit être fin, léger et tenir une journée sur batterie : impossible avec des composants séparés.
Limites : ni réparable ni évolutif (on ne change pas la mémoire), ce qui pose la question de l’obsolescence.

Sujet 2.

Microcontrôleur : mini-ordinateur minuscule, sobre et bon marché, conçu pour une tâche précise dans un système embarqué ; quelques dizaines de MHz, quelques Ko de mémoire, en général pas de système d’exploitation complet.
SoC de smartphone : plusieurs cœurs à plusieurs GHz, des Go de mémoire, un système d’exploitation complet ; c’est un ordinateur polyvalent.
Exemple : un régulateur de vitesse répète sans fin « lire les capteurs $\to$ décider $\to$ commander les actionneurs ».
Piège : « plus petit, donc moins bien » ; le microcontrôleur est choisi pour sa sobriété et pour le temps réel (un airbag ne peut pas attendre).

Sujet 3.

Énoncé : le nombre de transistors sur une puce double environ tous les deux ans (Gordon Moore prévoit en 1965 un doublement chaque année, puis révise en 1975 : tous les deux ans) ; c’est une prédiction empirique, pas une loi physique.
Chiffres : $2\,300$ transistors pour l’Intel 4004 (1971), des dizaines de milliards aujourd’hui.
Piège : ce n’est pas la fréquence d’horloge qui double ; elle plafonne à quelques GHz.
Limites : la taille des atomes (gravure à quelques nanomètres), la chaleur, le coût des usines ; on multiplie désormais les cœurs et les processeurs spécialisés.

Entraînement#

Des séries courtes pour rendre une méthode automatique : même consigne, données différentes. Les réponses sont brèves dans le corrigé.

★ Exercice 17 — Systèmes embarqués en série #

• essentiel

Pour chacun des trois systèmes embarqués ci-dessous, nommer le capteur et l’actionneur, puis dérouler la boucle sur la suite de mesures donnée : pour chaque tour, indiquer la commande envoyée (ou l’absence de commande) et l’état de l’actionneur à la fin du tour. Au départ, tous les actionneurs sont à l’arrêt.

Coup de pouce

Un tour de boucle suit toujours le même schéma : lire le capteur, décider avec les tests, commander l’actionneur. Faire un tableau avec une ligne par mesure : valeur lue, test vrai, commande envoyée, état de l’actionneur. Si aucun test n’est vrai, aucune commande n’est envoyée : l’actionneur reste dans son état.

Éclairage d’un couloir. Mesures successives (en lux) : $120$, $60$, $40$, $35$, $80$.

while True:
    lum = lire_luminosite()        # en lux
    if lum < 50:
        allumer_lampe()
    else:
        eteindre_lampe()
    attendre(1)

Arrosage d’un jardin. Mesures successives (humidité du sol, en %) : $45$, $28$, $35$, $62$, $50$.

while True:
    h = lire_humidite()            # en pourcentage
    if h < 30:
        demarrer_pompe()
    elif h > 60:
        arreter_pompe()
    attendre(600)

Ventilation d’un boîtier. Mesures successives (en ° C) : $45$, $55$, $72$, $68$, $49$.

while True:
    t = lire_temperature()         # en degres C
    if t >= 70:
        ventiler(2)                # vitesse rapide
    elif t >= 50:
        ventiler(1)                # vitesse lente
    else:
        ventiler(0)                # arret
    attendre(5)

Corrigé

a) Capteur : capteur de luminosité ; actionneur : la lampe. Tours : $120$ $\to$ eteindre_lampe() ; $60$ $\to$ eteindre_lampe() ; $40$ $\to$ allumer_lampe() ; $35$ $\to$ allumer_lampe() ; $80$ $\to$ eteindre_lampe(). La lampe est donc successivement éteinte, éteinte, allumée, allumée, éteinte (une commande est envoyée à chaque tour, même si l’état ne change pas).

b) Capteur : capteur d’humidité du sol ; actionneur : la pompe. Tours : $45$ $\to$ aucune commande, pompe arrêtée ; $28$ $\to$ demarrer_pompe(), en marche ; $35$ $\to$ aucune commande, la pompe reste en marche ; $62$ $\to$ arreter_pompe(), arrêtée ; $50$ $\to$ aucune commande, arrêtée.

▷ Erreur fréquente. En b), considérer que la pompe s’arrête à $35$ % parce que l’humidité dépasse $30$ % : entre $30$ et $60$, aucun test n’est vrai, aucune commande n’est envoyée, et la pompe continue de tourner jusqu’à dépasser $60$ %.

c) Capteur : capteur de température ; actionneur : le ventilateur. Tours : $45$ $\to$ ventiler(0), arrêt ; $55$ $\to$ ventiler(1), lent ; $72$ $\to$ ventiler(2), rapide ; $68$ $\to$ ventiler(1), lent ; $49$ $\to$ ventiler(0), arrêt.

★ Exercice 18 — La loi de Moore en série #

• essentiel

On admet la loi de Moore : le nombre de transistors d’une puce double tous les deux ans. Estimer le nombre de transistors prévu :

Coup de pouce

Commencer par compter les périodes de deux ans, c’est-à-dire le nombre de doublements $d$. Le nombre de transistors est alors multiplié par $2^d$. On rappelle $2^{10} = 1\,024 \approx 1\,000$.

pour une puce de $5\,000$ transistors, $10$ ans plus tard ;
pour une puce d’un million de transistors, $20$ ans plus tard ;
pour une puce de $3$ milliards de transistors, $6$ ans plus tard.

Corrigé

a) $10$ ans $= 5$ doublements : $5\,000 \times 2^5 = 5\,000 \times 32 = \mathbf{160\,000}$ transistors.
b) $20$ ans $= 10$ doublements : $10^6 \times 2^{10} = 1\,024 \times 10^6$, soit environ un milliard de transistors.
c) $6$ ans $= 3$ doublements : $3 \times 2^3 = \mathbf{24}$ milliards de transistors.

	Puce A	Puce B	Puce C
Fréquence	\(64\) MHz	\(4\) cœurs à \(1{,}7\) GHz	\(120\) MHz
Mémoire vive	\(256\) Ko	\(2\) Go	\(1\) Mo
Système d’exploitation	aucun	oui	aucun
Consommation moyenne	\(2\) mA	\(20\) mA	\(8\) mA
Prix	\(2\) €	\(35\) €	\(5\) €