de source
Le BP en inverseur de source est un dispositif qui permet de convertir le courant continu en courant alternatif et vice versa. Il est utilisé dans de nombreux domaines, notamment l’électronique, l’automatisation et l’énergie. Dans cet article, nous allons examiner en détail le fonctionnement et les avantages de ce dispositif, ainsi que les différentes applications possibles. Nous verrons également comment il peut être utilisé pour améliorer l’efficacité et la fiabilité des systèmes électriques.
Un BP en inverseur
1. Présentation
L’appui sur un bouton poussoir inverse l’état d’une LED
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.

2.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,

- des straps,

- une LED rouge 5mm,

- une résistance 1/4w de 200 Ohms environ,

- un bouton poussoir pour CI,

3. Instructions de montage
- Broche 2 : Un BP connecté au 0V
- Broche 3 : Une LED et sa résistance en série connectée au 0V
4. Le schéma théorique du montage
Le schéma théorique du montage (cliquer pour agrandir)
5. Le circuit du montage
Le schéma du montage à réaliser (cliquer pour agrandir)
6. Fonctionnement du programme
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme
7. Explication du programme
7.1 Au niveau de la partie déclarative :
- On déclare une variable de mémorisation de l’état de la LED
7.2 Au niveau de la fonction d’initialisation setup( ) :
- On configure la broche utilisée avec la LED en sortie
- On configure la broche utilisée avec le BP en entrée, et on active le pullup interne
7.3 Au niveau de la boucle principale, la fonction loop ( ) :
- En cas d’appui sur le BP, on inverse l’état de la variable etatLED
- Dans une seconde condition, on met la LED dans l’état de la variable.
8. Mise en oeuvre du programme
8.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
8.2 Fonctionnement
- L’appui sur le BP inverse l’état de la LED.
9. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur Arduino
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr
// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 16/1/2011.
// ——- Licence du code de ce programme —–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// //////////////////// PRESENTATION DU PROGRAMME ////////////////////
// ——– Que fait ce programme ? ———
/* L’appui sur un bouton poussoir inverse l’état d’une LED */
// — Fonctionnalités utilisées —
// ——– Circuit à réaliser ———
// Broche 2 : Un BP connecté au 0V
// Broche 3 : Une LED et sa résistance en série connectée au 0V
// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…
// — Déclaration des constantes —
// — Inclusion des librairies —
// — Déclaration des constantes utiles —
const int APPUI=LOW; // constante pour tester état BP
// — Déclaration des constantes des broches E/S numériques —
const int BP=2; // Constante pour la broche 2
const int LED=3; // Constante pour la broche 3
// — Déclaration des constantes des broches analogiques —
// — Déclaration des variables globales —
int etatLED=0; // variable d’état de la LED
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter 1 seule fois au démarrage du programme —
// ——- Initialisation fonctionnalités utilisées ——-
// ——- Broches en sorties numériques ——-
pinMode (LED,OUTPUT); // Broche LED configurée en sortie
// ——- Broches en entrées numériques ——-
pinMode (BP,INPUT); // Broche BP configurée en entrée
// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-
digitalWrite (BP,HIGH); // Rappel au + activé sur la broche BP configurée en entrée
// ——- Initialisation des variables utilisées ——-
} // fin de la fonction setup()
// ********************************************************************************
////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
if (digitalRead(BP)==APPUI) { // si appui sur le BP
if (etatLED==0) etatLED=1; else etatLED=0; // inverse la variable etatLED
delay(250); // pause anti-rebond
}
// met la LED dans l’état de la variable etatLED
if (etatLED==1) { // si la variable vaut 1
digitalWrite(LED,HIGH); // la LED est allumée
}
else { // sinon, càd si la variable vaut 0
digitalWrite(LED,LOW); // la LED est éteinte
}
// — ici instructions à exécuter par le programme principal —
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////
// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////
// ////////////////////////// Fin du programme ////////////////////
Articles Liés
- L'appui sur un BP allume une LED.
L'utilisation de la technologie pour créer des dispositifs innovants est devenue une pratique courante dans…
- L'appui sur 5 BP lance la lecture de 5 sons différents dans l'interface Processing
L'interface Processing est un outil puissant qui permet aux utilisateurs de créer des programmes informatiques…
- Allumer une LED à partir d'un bouton inverseur dans une interface Processing
L'utilisation d'un bouton inverseur pour allumer une LED est une méthode simple et efficace pour…