Université des Sciences et d la Technologie Année universitaire : 2023/2024

Houari Boumediene Module : Systèmes à microcontrôleurs

Faculté de Génie Electrique Spécialité : M1 Electronique des
Département d’électronique Systèmes Embarqués

Examen final : Systèmes à microcontrôleurs

Exercice 1 (6 pts):

1. Caractéristique Principale d'une Architecture Harvard: L'architecture Harvard est caractérisée par des
mémoires séparées pour les instructions (code) et les données. Cela permet au microcontrôleur de lire une
instruction et une donnée simultanément, améliorant ainsi la vitesse d'exécution par rapport à l'architecture
Von Neumann, où la mémoire d'instructions et de données est commune. (0.5pt)
2. Puissance de Calcul en MIPS: La puissance de calcul de ce microcontrôleur est 4 MIPS (0.5pt)
3. Types d'Oscillateurs pour l'ATmega328P: Les oscillateurs qui peuvent être utilisés pour l'ATmega328P
incluent (1pt)

 Oscillateur à cristal : Utilise un cristal de quartz pour fournir une horloge précise.
 Horloge extérieur
 Oscillateur RC

 Les différences entre ces types d'oscillateurs résident principalement dans leur précision et coût

4. Utilisations Principales du Watchdog dans un Microcontrôleur ATmega328P: (1pt)

 Si le microcontrôleur (µC) est en fonctionnement normal, le WDT (Watchdog Timer) provoque un

RESET. Ceci permet d'éviter de rester planté en cas de blocage du microcontrôleur par un processus
indésirable non contrôlé.
 Si le µC est en mode SLEEP, le WDT provoque un WAKE-UP, l'exécution du programme continue
normalement là où elle s'est arrêtée avant de rentrer en mode SLEEP

5. Calcul du Pas de Quantification et Valeur de Tension pour N = FFh: (1pt)

Le pas de quantification (résolution) d'un convertisseur ADC 10 bits avec une tension de référence de 5V est
donné par 5V /210=5V/1024≈0.00488V par pas.

Si la sortie numérique du convertisseur est N = FFh (255 en décimal), la valeur de la tension analogique
équivalente est 255×0.00488V≈1.2444V.

6. Temps Maximal Programmable avec le Timer1 (1pt): Le Timer1 de l'ATmega328P est un timer 16 bits.
Avec une horloge de 4 MHz, le temps maximal qu'on peut programmer est déterminé par le nombre maximal
que le timer peut compter, soit 216−1=65535 cycles. Ainsi, le temps maximal est 65535/4 MHz≈16.384 ms.

Page 1|5
 7. (1pt): a. chaque case mémoire peut contenir 16 bits (puisque FFFF représente 4 hexadécimaux, chacun
représentant 4 bits).
b. Nombre de bits réservés à l'adressage : 2n=(256Mbits)/16 =28x220/24=224 doc n=24 bits

Exercice 2 (4.5 pts) :

1- un sketch (programme) Arduino qui permet de contrôler la LED. (1.5pt)

const int ledPin = 11; // Broche de la LED

const int ldrPin = A0; // Broche de la photorésistance

void setup() {
pinMode(ledPin, OUTPUT); // Configure la broche de la LED comme sortie
pinMode(ldrPin, INPUT); // Configure la broche de la LDR comme entrée
}

void loop() {
int ldrValue = analogRead(ldrPin); // Lit la valeur de la LDR
int ledBrightness = map(ldrValue, 0, 1023, 0, 255); // Convertit la valeur LDR en intensité LED

analogWrite(ledPin, ledBrightness); // Ajuste l'intensité de la LED

2- Si les emplacements de la photorésistance (LDR) et de la résistance fixe (R2) étaient inversés dans le circuit,
c'est-à-dire si la LDR était connectée à VCC (5V) et la résistance fixe au GND, l'effet sur la tension de sortie
mesurée par la broche analogique de l'Arduino serait également inversé.
Dans le montage original (LDR au GND et R2 à VCC), la tension de sortie augmente avec l'obscurité. Avec
les emplacements inversés, la tension de sortie va diminuer avec l'obscurité. (1pt)
3-(1pt)

const int ledPin = 11; // Broche de la LED

const int ldrPin = A0; // Broche de la photorésistance

void setup() {
pinMode(ledPin, OUTPUT); // Configure la broche de la LED comme sortie
pinMode(ldrPin, INPUT); // Configure la broche de la LDR comme entrée
}

void loop() {
int ldrValue = analogRead(ldrPin); // Lit la valeur de la LDR
int ledBrightness = map(ldrValue, 0, 1023, 255, 0); // Convertit la valeur LDR en intensité LED

analogWrite(ledPin, ledBrightness); // Ajuste l'intensité de la LED

 Le microcontrôleur Atmega328P utilise le Timer2 pour générer le signal PWM. Lorsque vous utilisez
analogWrite() sur la broche 11, l'Arduino utilise le Timer2 pour générer le signal PWM. (1pt)

Page 2|5
Exercice 3 (4.5 pts) :
1-(2.5 pts)

// Définition des broches

const int pinTempSensor = A0; // Capteur de température sur la broche analogique A0
const int pinHumiditySensor = 2; // Capteur d'humidité sur la broche numérique 2
const int pinFan = 10; // Ventilateur sur la broche numérique 10 (PWM pour régler la vitesse)
const int pinPump = 4; // Pompe sur la broche numérique 4

void setup() {
pinMode(pinTempSensor, INPUT);
pinMode(pinHumiditySensor, INPUT);
pinMode(pinFan, OUTPUT);
pinMode(pinPump, OUTPUT);
Serial.begin(9600); // Démarrer la communication série
}

void loop() {
// Lecture de la température
int tempReading = analogRead(pinTempSensor);
float temperature = (tempReading * 5.0 / 1023.0 ) * 100.0; // Convertir en degrés Celsius

// Lecture de l'humidité
int humidityState = digitalRead(pinHumiditySensor);

// Contrôle du ventilateur
if (temperature >= 38) {
analogWrite(pinFan, 255); // Pleine vitesse
} else if (temperature >= 30) {
analogWrite(pinFan, 128); // Mi-vitesse
} else {
analogWrite(pinFan, 0); // Éteint
}
// Affichage sur le moniteur série
Serial.print("Température: ");
Serial.print(temperature);

// Contrôle de la pompe
if (humidityState == HIGH) {
digitalWrite(pinPump, HIGH); // Active la pompe
Serial.print(" Inférieur au seuil ");
} else {
digitalWrite(pinPump, LOW); // Désactive la pompe
Serial.print(" Supérieur au seuil ");

delay(1000); // Attendre une seconde

}

Page 3|5
2. Le microcontrôleur Atmega328P utilise une communication série UART (Universal Asynchronous
Receiver-Transmitter) pour envoyer des données au moniteur série de l'IDE Arduino. (1pt)

3 Le microcontrôleur Atmega328P utilise le Timer1 pour générer le signal PWM. Lorsque vous utilisez
analogWrite() sur la broche 10, l'Arduino utilise le Timer1 pour générer le signal PWM. (1pt)
Exercice 4 (5 pts) :

Programme pour l'Arduino Maître (1.5pt)

#include <Wire.h>

const int buttonPin = 8; // Le bouton est connecté à la broche 8

const int ledPin = 13; // LED intégrée connectée à la broche 13
int buttonState = 0; // État actuel du bouton

void setup() {
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
Wire.begin(); // Démarrage du bus I2C en tant que maître
}

void loop() {
buttonState = digitalRead(buttonPin);

if (buttonState == HIGH) {
Wire.beginTransmission(15); // Commence la transmission avec l'esclave (adresse 15)
Wire.write('1'); // Envoie le caractère '1' à l'esclave
Wire.endTransmission(); // Termine la transmission
delay(1000); // Attendre avant de lire la réponse
Wire.requestFrom(15, 1); // Demande un octet de l'esclave

while(Wire.available()) {
int c = Wire.read(); // Lit la réponse de l'esclave
// Traiter la réponse ici
if (c == '1') {
digitalWrite(ledPin, !digitalRead(ledPin)); // Change l'état de la LED
}
}
}
}

Page 4|5
 Programme pour l'Arduino Esclave(1.5pt)
#include <Wire.h>

const int ledPin = 13; // LED intégrée connectée à la broche 13

char receivedChar; // Variable pour stocker le caractère reçu

void setup() {
pinMode(ledPin, OUTPUT);
Wire.begin(15); // Démarrage du bus I2C avec l'adresse 15
Wire.onReceive(receiveEvent); // Fonction appelée lors de la réception d'un signal I2C
Wire.onRequest(requestEvent); // Fonction appelée lorsqu'une demande d'envoi de données est reçue
}

void loop() {
// Le traitement principal est géré dans receiveEvent et requestEvent
}
void receiveEvent(int howMany) {
while (1 <= Wire.available()) {
receivedChar = Wire.read(); // Reçoit un octet comme caractère
if (receivedChar == '1') {
digitalWrite(ledPin, !digitalRead(ledPin)); // Change l'état de la LED
}
}
}

void requestEvent() {
Wire.write(receivedChar); // Envoie le caractère reçu comme confirmation
}

3- Oui, (0.5pt) il est possible de remplacer le système de communication I2C entre deux cartes Arduino par
le système de communication SPI (Serial Peripheral Interface). Cependant, il y a des différences
significatives entre les deux protocoles. Voici quelques-unes des différences clés entre I2C et SPI :
Nombre d'esclaves: (0.5pt)
 I2C: Le bus I2C permet de connecter plusieurs périphériques esclaves au même bus.
 SPI: Les bus SPI peuvent prendre en charge un nombre limité de périphériques esclaves par rapport aux bus
i2c.
Nombre de Lignes de Communication: (0.25pt)
 I2C: Utilise deux lignes pour la communication - SDA (Data) et SCL (Clock).
 SPI: Utilise quatre lignes - MISO (Master In Slave Out), MOSI (Master Out Slave In), SCK (Clock) et
SS (Slave Select).
Vitesse de Transmission: (0.25pt)
 I2C: Généralement plus lent que SPI.
 SPI: Offre des vitesses de transmission plus élevées.
Contrôle de Flux: (0.25pt)
 I2C: Permet une communication bidirectionnelle sur la même ligne (SDA).
 SPI: Utilise des lignes séparées pour la transmission et la réception des données (MISO et MOSI).
Adressage: (0.25pt)
 I2C: Chaque esclave a une adresse unique.
 SPI: Utilise la ligne SS pour activer l'esclave désiré (pas d'adressage proprement dit).

Page 5|5