Archives de catégorie : Non classé

Électricité Résidentielle : Montages & Tutoriels

Cette page est spécialement conçue pour les amateurs désireux de comprendre et de réaliser des installations électriques dans des maisons individuelles et des bâtiments tertiaires. Elle se distingue par sa collection de tutoriels vidéo, offrant des explications claires, des schémas détaillés et des conseils pratiques pour aider les débutants à démarrer et à progresser en électricité du bâtiment.

Sommaire :

Va-et-vient : Guide complet de montage pour débutants
Retour au menu Amélioration de l’habitat

Va-et-vient : Guide complet de montage pour débutants

Mise à jour : 05/11/2023

Le principe du va-et-vient en électricité est relativement simple. Il s’agit d’un système de câblage utilisé pour contrôler une source de lumière (ou un autre appareil électrique) à partir de deux endroits différents. Ce système est couramment utilisé dans les maisons, par exemple, pour contrôler l’éclairage d’un couloir depuis les deux extrémités de celui-ci.

Voici comment cela fonctionne :

Deux Interrupteurs: Le montage va-et-vient implique deux interrupteurs. Ces interrupteurs ne sont pas des interrupteurs ordinaires mais des interrupteurs va-et-vient, chacun ayant trois bornes : une borne d’entrée (ou « phase ») et deux bornes de sortie.
Câblage:
- La « phase » (l’arrivée du courant) est connectée à l’une des bornes de l’un des interrupteurs.
- Les deux autres bornes de chaque interrupteur sont reliées entre elles par deux fils, appelés « navettes ».
- La borne restante de l’autre interrupteur est connectée à la lampe (ou à l’appareil à contrôler), qui est ensuite reliée au neutre pour compléter le circuit.

Retour au sommaire

Amélioration de l’habitat

Explorez le Monde de l’Électricité et de la Domotique : Une Ressource Complète pour les Amateurs et les Professionnels.

Bienvenue sur notre page dédiée à l’univers de l’électricité résidentielle, la domotique, et la gestion optimisée de l’énergie. Nous offrons une série de playlists qui vous guideront à travers :

Domotique pour Tous : Découvrez les merveilles de la domotique avec des vidéos qui vous présentent divers matériels, expliquent les principes fondamentaux et vous guident dans leur installation et câblage.
Survivalisme Technologique : Apprenez à faire face aux coupures d’électricité et à économiser de l’énergie grâce à nos astuces pratiques, mises à jour régulièrement pour s’adapter à un monde en constante évolution.
Électricité Résidentielle : Plongez dans des tutoriels détaillés sur les installations électriques courantes, de l’installation simple d’un interrupteur aux circuits plus complexes, adaptés à tous les niveaux.


Domotique	Optimisation de la maison	Électricité Résidentielle

Les servomoteurs et leurs accessoires en vidéo

Sommaire :

2022-04-05- Les servomoteur a alimentation séparée
2022-03-13- La création d’un retour d’information
2022-01-09- Arduino , augmenter le nombre de sorties PWM
Retour au menu Vidéo

2022-04-05- Les servomoteur a alimentation séparée

Dans cette nouvelle vidéo nous allons voir comment travailler avec des servomoteurs qui possèdent des alimentations séparées. Contrairement au servomoteur que l’on utilise en général et qui possède trois fils eux en possède 5 et ce sont de très gros servo. Nous allons étudier le câblage et le code Arduino . Pour illustrer le fonctionnement de ce type de servomoteur, nous l’avons intégré dans une application. Le but de cette appli est de piloter ce matériel avec simplement un joystick.

Retour au sommaire

2022-03-13- La création d’un retour d’information

Ce tuto vous explique comment un servomoteur standard peut être transformé en servomoteur possédant une rétroaction.
Vous pouvez peut-être vous poser la question suivante, qu’est-ce qu’une rétroaction ? Une rétroaction, retour d’information, feedback, ces termes définissent la même fonction pour connaître la position du servomoteur par l’intermédiaire d’un capteur qui est le reflet de la position exacte du servomoteur ou de l’actionneur en question Ces informations sont très utiles puisque cela nous permet d’améliorer la stabilité d’un système, ou bien utiliser cette fonction pour pouvoir enregistrer les positions de mouvement de l’actionneur en question.

Retour au sommaire

2022-01-09- Arduino , augmenter le nombre de sortie PWM

Ce tuto traite d’une carte de commande qui vous permet d’augmenter le nombre de sorties pwm quand votre carte Arduino devient trop juste pour répondre à vos besoins.

La carte de commande de chez Seeedstudio reference 108020102 possedant 16 canaux basée sur un PCA9685 permettant de contrôler jusqu’à 16 servomoteurs ou 16 leds via une liaison PWM. Ce module communique avec une carte Arduino ou compatible via le bus I2C.

Cette carte comporte jusqu’à 6 pontets à souder permettant de raccorder jusqu’à 64 PCA9685 sur un seul bus I2C. Une source d’alimentation externe est nécessaire pour les servomoteurs. Caractéristiques: Alimentation partie logique: 3,3 et 5 Vcc Alimentation partie servomoteur: 2,3 à 5,5 Vcc Commande: via le bus I2C Adresse I2C par défaut: 0x7f (configurable par pontet à souder) Compatible niveaux logiques 5 V Sorties servos/leds: connecteur mâle au pas de 2,54 mm Intensité maxi: – 25 mA par led – 400 mA au total pour tous les servos Dimensions: 65 x 45 x 13 mm

Retour au sommaire

R2-D2 Anneau 1 et base

Mise à jour le 23/04/2021 : Voici les plans de montage du robot R2-D2 pour l’anneau 1 et la base .

Continuer la lecture →

R2-D2 – panneau arrière

Mise à jour le 23/04/2021 : Voici les plans de montage du robot R2-D2 pour le panneau arrière qui nous donne accès au système électronique du robot. Les fichiers n’appartiennent pas à RedOhm pour cela ,il faut s’inscrire sur le lien ci-dessous.
https://www.patreon.com/mrbaddeley

Seules les modifications réalisées par RedOhm sont disponibles sur le site :

https://www.redohm.fr/

Sommaire :

Fiche 002 : Panneau superieur
Fiche 003 : Panneau inferieur
Pour tout probléme
Retour au menu

002 – Panneau superieur

Retour au sommaire

003 – Panneau inferieur

Retour au sommaire

Pour tout probléme

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook Twitter Youtube

Grabcad Thingiverse

Menu R2D2

Les fichiers STL n’appartiennent pas à RedOhm pour cela ,il faut s’inscrire sur le lien ci-dessous.
https://www.patreon.com/mrbaddeley

Seules les modifications réalisées par RedOhm sont disponibles sur le site ainsi que la documentation de montage qui est de RedOhm :

https://www.redohm.fr/

Sommaire principal :

Présentation de R2D2
Anneau 1 avec base
Panneau arriére qui donne accés au système électronique
Retour au menu nos robot

Pilotage d’un moteur pas à pas avec un joystick

Mise à jour le 03/03/2021 :

Sommaire :

Principe de fonctionnement
Programme pour le pilotage d’un moteur pas à pas avec Arduino et un joystick
Vidéo pour le tuto
Pour tout probléme
Retour au menu

Principe de fonctionnement

Le but de ce tutoriel est de piloter un moteur pas à pas avec un joystick.

Nous verrons comment définir la valeur des positions de notre joystick pour créer un mouvement de marche avant ou de marche arrière et de conserver le couple maintien quand notre manipulateur est dans un état statique.

Dans le programme vous pourrez retrouver :

La création d’un générateur d’impulsion qui nous permettra de définir la vitesse et le déplacement du moteur pas à pas

La gestion du couple maintien par l’intermédiaire d’un bouton

Et enfin le pilotage du moteur pas à pas en avant et en arrière avec le joystick par l’intermédiaire de la borne DIR se trouvant sur notre driver

Retour au sommaire

Programme pour le pilotage d’un moteur pas à pas avec Arduino
et un joystick

//
//
//***********************************************************
// RedOhm
// le 06/02/2021
// 
// Pilotage d'un moteur pas a pas avec joystick
// 
// but : 
// 1 - creation d'un generateur d'impulsion pour le deplacement 
//     et la vitesse du moteur ( avec la fonction micros() ) 
// 2 - Creation de la fonction debrayage du moteur
// 4 - Pilotage avec un Joystik 
//  
// Ce programme est un logiciel libre: vous pouvez le redistribuer 
// et / ou le modifier
// Ce programme est distribué dans l'espoir qu'il vous sera utile,
// mais sans aucune garantie de fonctionnement 
// 
// Par: Mazelin Herve 
// IDE Arduino 1.8.13 
//**********************************************************

// Declaration des variables demarrage 
// unsigned long-> déclare une variable de type long non signé
// pour la base de temps il y a 1 000 microsecondes dans une milliseconde
//                     et
// 1 000 000 microsecondes dans une seconde.
unsigned long demarrage = micros();


// Declaration des variables 
// int -> declare une variable du type int (pour integer, entier en anglais)
// elles peuvent stocker des valeurs de - 32 768 à 32 767
int base_de_temps1 = 1 ;


// Affectation des sorties de la carte Ardunio pour le pilotage 
// du driver DRI0043 


// une impulsion montante ou descendante sur cette entrée fait
// avancer le moteur d’un pas. La tension de l’impulsion doit
// être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS. 
// La largeur d’impulsion doit être de minimum 2,5 μs pour un
// fonctionnement correct.
int PUL=12; 
// Definit le sens de rotation en fonction de l'etat bas ou haut
int DIR=10;
// ce signal est utilisé pour permettre ou interdire l’utilisation du
// driver. Le moteur est hors tension
int ENA=11; 


// déclaration de l'entrée du bouton branché sur la broche 15
// pour le debrayage du moteur
int bouton_debrayage = 15;
int bouton_debrayage_v;

// Declaration de pin pour le voyant marche avant vert
int voyant_vert_mar = 20; 
// Declaration de pin pour le voyant marche arriere rouge
int voyant_rouge_arr = 21; 

// declaration de l'entree analogique 6 pour l'axe x
int JoyStick_X = 6; // axe x 

// declaration de la vitesse du joystick
int vitesse=0 ;


/*
 *  Un programme Arduino doit impérativement contenir cette fonction 
 *  Elle ne sera exécutee une seule fois au démarrage du microcontroleur
 *  Elle sert à configurer globalement les entrées sorties
 *  
 */
 

void setup() 
{

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée, 
// soit en sortie.

// Configuration des broches pour le driver
  pinMode (PUL, OUTPUT);
  pinMode (DIR, OUTPUT);
  pinMode (ENA, OUTPUT);


// Configuration des broches pour les boutons et les voyants
  pinMode(bouton_debrayage,INPUT);
  pinMode(voyant_vert_mar,OUTPUT);
  pinMode(voyant_rouge_arr,OUTPUT);

}



// Le programme principal s’exécute par une boucle infinie appelée Loop () 

void loop()
{



// *******************************************
//      Demande de debrayage du moteur
// ******************************************* 
// debrayage du moteur de son driver
bouton_debrayage_v = digitalRead(bouton_debrayage);
 if ( bouton_debrayage_v == 1 )
 {
 digitalWrite(ENA,LOW); 
 
 }
 

// ******* Fin de demande debrayage **********
 



// *******************************************
//      Traitement du JoyStick
// ******************************************* 

int x;
// Lecture de l'entree analogique 
x=analogRead(JoyStick_X);
 if ((x>501)&&(x<518)&&(bouton_debrayage_v==0))
 {
 digitalWrite(voyant_vert_mar,LOW);   
 digitalWrite(voyant_rouge_arr,LOW);
 digitalWrite(ENA,HIGH);
 digitalWrite(DIR,HIGH); 
 digitalWrite(PUL,HIGH);   
 }
// si x est superieur a 520  les instructions comprises
// entre les accolades sont exécutées. 
else if (x>520)
{
 // Marche arriere 
 digitalWrite(voyant_vert_mar,LOW);   
 digitalWrite(voyant_rouge_arr,HIGH);
 digitalWrite(ENA,HIGH);
 digitalWrite(DIR,HIGH);
 vitesse = map ( x,520,1023,3500,5); 
 deplacement();
 
}
// sinon si x est inferieur a 500  les instructions comprises
// entre les accolades sont exécutées. 
else if (x<500)
{
 // Marche avant
 digitalWrite(voyant_rouge_arr,LOW);
 digitalWrite(voyant_vert_mar,HIGH);
 digitalWrite(DIR,LOW);
 digitalWrite(ENA,HIGH);
 vitesse = map ( x,500,0,3500,5); 
 deplacement();
}

// ***** Fin du traitement du JoyStick *********


}


//==============================================
//Fonction de deplacement du moteur 
//==============================================

void deplacement()
{
// la ligne if  effectue la difference entre le temps actuel et le 
// temps de debut de boucle .

if (micros()-demarrage>vitesse)
{
//Inversion de la valeur de la variable memoire et envoie l'information
//a la broche  
digitalWrite(PUL,base_de_temps1=!base_de_temps1);
// on reinitialise la variable demarrage avec le contenu de micros()
demarrage=micros();

}

  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

//***********************************************************

// RedOhm

// le 06/02/2021

// Pilotage d'un moteur pas a pas avec joystick

// but :

// 1 - creation d'un generateur d'impulsion pour le deplacement

// et la vitesse du moteur ( avec la fonction micros() )

// 2 - Creation de la fonction debrayage du moteur

// 4 - Pilotage avec un Joystik

// Ce programme est un logiciel libre: vous pouvez le redistribuer

// et / ou le modifier

// Ce programme est distribué dans l'espoir qu'il vous sera utile,

// mais sans aucune garantie de fonctionnement

// Par: Mazelin Herve

// IDE Arduino 1.8.13

//**********************************************************

// Declaration des variables demarrage

// unsigned long-> déclare une variable de type long non signé

// pour la base de temps il y a 1 000 microsecondes dans une milliseconde

// et

// 1 000 000 microsecondes dans une seconde.

unsigned long demarrage = micros();

// Declaration des variables

// int -> declare une variable du type int (pour integer, entier en anglais)

// elles peuvent stocker des valeurs de - 32 768 à 32 767

int base_de_temps1 = 1 ;

// Affectation des sorties de la carte Ardunio pour le pilotage

// du driver DRI0043

// une impulsion montante ou descendante sur cette entrée fait

// avancer le moteur d’un pas. La tension de l’impulsion doit

// être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS.

// La largeur d’impulsion doit être de minimum 2,5 μs pour un

// fonctionnement correct.

int PUL=12;

// Definit le sens de rotation en fonction de l'etat bas ou haut

int DIR=10;

// ce signal est utilisé pour permettre ou interdire l’utilisation du

// driver. Le moteur est hors tension

int ENA=11;

// déclaration de l'entrée du bouton branché sur la broche 15

// pour le debrayage du moteur

int bouton_debrayage = 15;

int bouton_debrayage_v;

// Declaration de pin pour le voyant marche avant vert

int voyant_vert_mar = 20;

// Declaration de pin pour le voyant marche arriere rouge

int voyant_rouge_arr = 21;

// declaration de l'entree analogique 6 pour l'axe x

int JoyStick_X = 6; // axe x

// declaration de la vitesse du joystick

int vitesse=0 ;

* Un programme Arduino doit impérativement contenir cette fonction

* Elle ne sera exécutee une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup()

{

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée,

// soit en sortie.

// Configuration des broches pour le driver

pinMode (PUL, OUTPUT);

pinMode (DIR, OUTPUT);

pinMode (ENA, OUTPUT);

// Configuration des broches pour les boutons et les voyants

pinMode(bouton_debrayage,INPUT);

pinMode(voyant_vert_mar,OUTPUT);

pinMode(voyant_rouge_arr,OUTPUT);

}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop()

{

// *******************************************

// Demande de debrayage du moteur

// *******************************************

// debrayage du moteur de son driver

bouton_debrayage_v = digitalRead(bouton_debrayage);

if ( bouton_debrayage_v == 1 )

{

digitalWrite(ENA,LOW);

}

// ******* Fin de demande debrayage **********

// *******************************************

// Traitement du JoyStick

// *******************************************

int x;

// Lecture de l'entree analogique

x=analogRead(JoyStick_X);

if ((x>501)&&(x<518)&&(bouton_debrayage_v==0))

{

digitalWrite(voyant_vert_mar,LOW);

digitalWrite(voyant_rouge_arr,LOW);

digitalWrite(ENA,HIGH);

digitalWrite(DIR,HIGH);

digitalWrite(PUL,HIGH);

}

// si x est superieur a 520 les instructions comprises

// entre les accolades sont exécutées.

else if (x>520)

{

// Marche arriere

digitalWrite(voyant_vert_mar,LOW);

digitalWrite(voyant_rouge_arr,HIGH);

digitalWrite(ENA,HIGH);

digitalWrite(DIR,HIGH);

vitesse = map ( x,520,1023,3500,5);

deplacement();

}

// sinon si x est inferieur a 500 les instructions comprises

// entre les accolades sont exécutées.

else if (x<500)

{

// Marche avant

digitalWrite(voyant_rouge_arr,LOW);

digitalWrite(voyant_vert_mar,HIGH);

digitalWrite(DIR,LOW);

digitalWrite(ENA,HIGH);

vitesse = map ( x,500,0,3500,5);

deplacement();

}

// ***** Fin du traitement du JoyStick *********

}

//==============================================

//Fonction de deplacement du moteur

//==============================================

void deplacement()

{

// la ligne if effectue la difference entre le temps actuel et le

// temps de debut de boucle .

if (micros()-demarrage>vitesse)

{

//Inversion de la valeur de la variable memoire et envoie l'information

//a la broche

digitalWrite(PUL,base_de_temps1=!base_de_temps1);

// on reinitialise la variable demarrage avec le contenu de micros()

demarrage=micros();

}

Retour au sommaire

Vidéo pour le tuto

Retour au sommaire

Pour tout probléme

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Retour au sommaire

L3-37 version RC , Fiche de montage

Mise à jour le 11/12/2020 : Dans cet article vous retrouverez les fichiers à télécharger pour construire la tête et le buste du robot L3 -37 pour la version RC, mais aussi l’ensemble des fiches de montage pour y parvenir.

Continuer la lecture →

HALLOWING M0 EXPRESS

Mise à jour le 21/08/2020 – Rubrique traitant de la carte HALLOWING M0 EXPRESS . Cette carte permet la création de regards avec un ou deux yeux. Des programmes déjà réalisés pour cette carte sont en distribution libre. Cerise sur le gâteau vous pouvait développer des programmes avec Ide Arduino ou sur python.

Continuer la lecture →

Support pour FreeBox V5

Mise à jour le 17/12/2020 – les Freebox V5 sont sensibles aux fortes chaleurs . Nous avons donc étudié un système de refroidissement pouvant pallier ce problème.

Continuer la lecture →