Document

### Schémas et Codes pour Divers Systèmes dans Proteus
#### 1. Onduleur Autonome
Un onduleur autonome convertit du courant continu (DC) en courant alternatif (AC). Les
composants principaux sont souvent des MOSFET ou des IGBT contrôlés par un
microcontrôleur comme Arduino.
**Schéma :**
1. **MOSFETs** : Utilisez des N-channel MOSFETs.
2. **Alimentation DC** : Source de tension DC.
3. **Microcontrôleur** : Arduino Uno.
![Onduleur Autonome][] *(Note : Replace with actual schematic image)***Code

Arduino :**```cppconst int mosfet1 = 3 ;const int mosfet2 = 5 ;const int mosfet3 =
6 ;const int mosfet4 = 9 ;void setup() { pinMode(mosfet1, OUTPUT) ; pinMode(mosfet2,
OUTPUT) ; pinMode(mosfet3, OUTPUT) ; pinMode(mosfet4, OUTPUT) ;}void loop() {
digitalWrite(mosfet1, HIGH) ; digitalWrite(mosfet2, LOW) ; digitalWrite(mosfet3,
HIGH) ; digitalWrite(mosfet4, LOW) ; delay(10) ; // Adjust delay for frequency control
digitalWrite(mosfet1, LOW) ; digitalWrite(mosfet2, HIGH) ; digitalWrite(mosfet3,

LOW) ; digitalWrite(mosfet4, HIGH) ; delay(10) ; // Adjust delay for frequency
control}```#### 2. GradateurUn gradateur contrôle la puissance délivrée à une charge,
souvent en utilisant un TRIAC ou un SCR.**Schéma :**1. **TRIAC** : Utilisez un
TRIAC.2. **Microcontrôleur** : Arduino Uno.3. **Potentiomètre** : Pour ajuster l’angle
de retard. ![Gradateur][] *(Note : Replace with actual schematic image)***Code
Arduino :**```cppconst int triacPin = 9 ;const int potPin = A0 ;void setup() {
pinMode(triacPin, OUTPUT) ;}void loop() { int potValue = analogRead(potPin) ; int
delayTime = map(potValue, 0, 1023, 0, 10) ; // Adjust the mapping as needed
delay(delayTime) ; digitalWrite(triacPin, HIGH) ; delay(1) ; digitalWrite(triacPin,
LOW) ;}```#### 3. Pont Mixte CommandéUn pont mixte commandé combine des
diodes et des SCRs pour redresser et contrôler une tension AC.**Schéma :**1.
**SCRs** : Utilisez des SCRs.2. **Diodes** : Utilisez des diodes de puissance.3.
**Microcontrôleur** : Arduino Uno. ![Pont Mixte Commandé][] *(Note : Replace with
actual schematic image)***Code Arduino :**```cppconst int scr1 = 3 ;const int scr2 =
5 ;void setup() { pinMode(scr1, OUTPUT) ; pinMode(scr2, OUTPUT) ;}void loop() {
digitalWrite(scr1, HIGH) ; delay(10) ; // Adjust for control digitalWrite(scr1, LOW) ;
digitalWrite(scr2, HIGH) ; delay(10) ; // Adjust for control digitalWrite(scr2,
LOW) ;}```#### 4. Redresseur CommandéUn redresseur commandé contrôle la
conversion d’AC en DC en utilisant des SCRs.**Schéma :**1. **SCRs** : Utilisez des
SCRs.2. **Microcontrôleur** : Arduino Uno. ![Redresseur Commandé][] *(Note :
Replace with actual schematic image)***Code Arduino :**```cppconst int scr1 =
3 ;const int scr2 = 5 ;void setup() { pinMode(scr1, OUTPUT) ; pinMode(scr2,
OUTPUT) ;}void loop() { digitalWrite(scr1, HIGH) ; delay(10) ; // Adjust for firing angle
digitalWrite(scr1, LOW) ; digitalWrite(scr2, HIGH) ; delay(10) ; // Adjust for firing angle
digitalWrite(scr2, LOW) ;}```### Configuration du Timer sur ArduinoPour configurer un
timer sur un microcontrôleur Arduino, utilisez les registres du timer.
Configurer un timer sur un microcontrôleur Arduino nécessite de manipuler directement

les registres de configuration du timer. Voici un guide pour configurer le Timer1 sur un
Arduino Uno, qui utilise un microcontrôleur ATmega328P.
### Exemple de Configuration du Timer1
L’exemple suivant configure le Timer1 pour générer une interruption toutes les 1
millisecondes :
```cpp
Void setup() {
// Configure Timer1
noInterrupts() ; // Disable all interrupts
TCCR1A = 0 ; // Clear Timer/Counter Control Register A
TCCR1B = 0 ; // Clear Timer/Counter Control Register B
TCNT1 = 0 ; // Initialize counter value to 0
// Set compare match register for 1ms increments
OCR1A = 15999 ; // (16 * 10^6) / (1000 * 1) – 1 (must be <65536)

// Turn on CTC mode
TCCR1B |= (1 << WGM12) ;
// Set CS10 and CS12 bits for 64 prescaler
TCCR1B |= (1 << CS11) | (1 << CS10) ;
// Enable timer compare interrupt
TIMSK1 |= (1 << OCIE1A) ;
Interrupts() ; // Enable all interrupts
ISR(TIMER1_COMPA_vect) {
// Timer1 interrupt service routine
// This code will be executed every 1ms
Void loop() {
// Main loop code
```
### Explication des Étapes
1. **Désactivation des Interruptions :**
```cpp
noInterrupts() ;
```
Cela empêche les interruptions pendant la configuration du timer.
2. **Réinitialisation des Registres :**
```cpp
TCCR1A = 0 ;
TCCR1B = 0 ;
TCNT1 = 0 ;
```
On réinitialise les registres de contrôle du Timer1 et le registre du compteur pour

s’assurer qu’aucune configuration précédente n’interfère.
3. **Définition du Registre de Comparaison :**
```cpp
OCR1A = 15999 ;
```
Le registre ÒCR1A` est défini pour atteindre une comparaison toutes les 1
milliseconde. Le calcul est basé sur la fréquence du microcontrôleur (16 MHz) divisée
par le prescaler et la fréquence désirée :
\[
OCR1A = \frac{16 \text{ MHz}}{64 \times 1000} – 1 = 15999
\]
4. **Configuration du Mode CTC (Clear Timer on Compare Match) :**
```cpp
TCCR1B |= (1 << WGM12) ;
```
On active le mode CTC pour que le timer se réinitialise automatiquement lorsque le

compteur atteint la valeur du registre ÒCR1A`.
5. **Configuration du Prescaler :**
```cpp
TCCR1B |= (1 << CS11) | (1 << CS10) ;
```
On configure le prescaler à 64. Les bits `CS11` et `CS10` dans `TCCR1B` doivent
être mis à 1 pour obtenir un prescaler de 64.
6. **Activation de l’Interruption de Comparaison :**
```cpp
TIMSK1 |= (1 << OCIE1A) ;
```
On active l’interruption de comparaison en mettant le bit ÒCIE1A` dans le registre

`TIMSK1`.
7. **Réactivation des Interruptions Globales :**
```cpp
Interrupts() ;
```
On réactive les interruptions globales après avoir configuré le timer.
8. **Définition de la Routine d’Interruption :**
```cpp
ISR(TIMER1_COMPA_vect) {
// Code à exécuter toutes les 1 ms
```
La routine d’interruption ÌSR(TIMER1_COMPA_vect)` est appelée chaque fois que le

timer atteint la valeur définie dans ÒCR1A`.
### Utilisation dans le Code
Ce code configure le Timer1 pour générer une interruption toutes les 1 milliseconde, où
vous pouvez exécuter des tâches périodiques. Insérez votre logique dans la fonction
ÌSR(TIMER1_COMPA_vect)` pour qu’elle soit exécutée à chaque interruption.
Pour d’autres timers ou configurations, vous pouvez consulter la [documentation

officielle d’Atmel du
ATmega328P](http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42735-8-bit-
AVR-Microcontroller-ATmega328-328P_Datasheet.pdf) pour des détails spécifiques sur
les registres et les

Document

Transféré par

Droits d'auteur :

Formats disponibles

Document

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Document

Transféré par

Droits d'auteur :

Formats disponibles

### Schémas et Codes pour Divers Systèmes dans Proteus

#### 1. Onduleur Autonome

1. **MOSFETs** : Utilisez des N-channel MOSFETs.

2. **Alimentation DC** : Source de tension DC.

3. **Microcontrôleur** : Arduino Uno.

![Onduleur Autonome][] *(Note : Replace with actual schematic image)***Code

digitalWrite(mosfet1, LOW) ; digitalWrite(mosfet2, HIGH) ; digitalWrite(mosfet3,

Configurer un timer sur un microcontrôleur Arduino nécessite de manipuler directement

### Exemple de Configuration du Timer1

noInterrupts() ; // Disable all interrupts

TCCR1A = 0 ; // Clear Timer/Counter Control Register A

TCCR1B = 0 ; // Clear Timer/Counter Control Register B

TCNT1 = 0 ; // Initialize counter value to 0

// Set compare match register for 1ms increments

OCR1A = 15999 ; // (16 * 10^6) / (1000 * 1) – 1 (must be <65536)

TCCR1B |= (1 << WGM12) ;

// Set CS10 and CS12 bits for 64 prescaler

TCCR1B |= (1 << CS11) | (1 << CS10) ;

// Enable timer compare interrupt

TIMSK1 |= (1 << OCIE1A) ;

Interrupts() ; // Enable all interrupts

// Timer1 interrupt service routine

// This code will be executed every 1ms

// Main loop code

### Explication des Étapes

1. **Désactivation des Interruptions :**

2. **Réinitialisation des Registres :**

On réinitialise les registres de contrôle du Timer1 et le registre du compteur pour

3. **Définition du Registre de Comparaison :**

OCR1A = \frac{16 \text{ MHz}}{64 \times 1000} – 1 = 15999

4. **Configuration du Mode CTC (Clear Timer on Compare Match) :**

TCCR1B |= (1 << WGM12) ;

On active le mode CTC pour que le timer se réinitialise automatiquement lorsque le

TCCR1B |= (1 << CS11) | (1 << CS10) ;

6. **Activation de l’Interruption de Comparaison :**

TIMSK1 |= (1 << OCIE1A) ;

On active l’interruption de comparaison en mettant le bit `OCIE1A` dans le registre

7. **Réactivation des Interruptions Globales :**

On réactive les interruptions globales après avoir configuré le timer.

8. **Définition de la Routine d’Interruption :**

// Code à exécuter toutes les 1 ms

La routine d’interruption `ISR(TIMER1_COMPA_vect)` est appelée chaque fois que le

Pour d’autres timers ou configurations, vous pouvez consulter la [documentation

Vous aimerez peut-être aussi

1. MOSFETs : Utilisez des N-channel MOSFETs.

2. Alimentation DC : Source de tension DC.

3. Microcontrôleur : Arduino Uno.

1. Désactivation des Interruptions :

2. Réinitialisation des Registres :

3. Définition du Registre de Comparaison :

4. Configuration du Mode CTC (Clear Timer on Compare Match) :

6. Activation de l’Interruption de Comparaison :

7. Réactivation des Interruptions Globales :

8. Définition de la Routine d’Interruption :