Dans un monde où l'efficacité énergétique devient primordiale, surveiller sa consommation électrique n'est plus un luxe mais une nécessité. Aujourd'hui, je vous présente comment créer votre propre système de mesure de courant avec le microcontrôleur ESP32 et le capteur SCT013-50, le tout programmé en MicroPython pour une flexibilité maximale.
Le capteur SCT013 : un allié pour l'électronique DIY
Le SCT013 est un transformateur de courant non invasif qui permet de mesurer jusqu'à 50A sans avoir à couper ou modifier votre installation électrique. Il suffit de le clipser autour d'un conducteur électrique pour obtenir une mesure précise de l'intensité qui y circule. Ce type de capteur est idéal pour les projets de domotique, de surveillance énergétique ou d'automatisation industrielle.
Matériel Requis : Le Kit du Parfait Électricien DIY
1. ESP32 (Wi-Fi/Bluetooth intégré)
2. Capteur SCT-013-50 ou SCT-013-100
3. Résistance de charge (10-60Ω selon modèle)
4. Câbles Dupont et breadboard
5. Alimentation 5V pour l’ESP32
Câblage : Connecter le SCT-013-50 à l’ESP32
- Sortie du SCT-013 → Broche ADC de l’ESP32 (ex: GPIO33)
- DAC de l’ESP32 (GPIO25/26) → Offset pour calibration
L'architecture du code MicroPython
Le code présenté est structuré autour d'une classe SCT013 qui encapsule toutes les fonctionnalités nécessaires à la mesure. Analysons ses composants clés :
Initialisation et mise en place du décalage
def __init__(self,p_adc,p_dac=25):
#pin dac sur ESP32 :25 et 26
dac = DAC(Pin(p_dac)) #26
offset = int(1.6*255/3.3)
dac.write(offset)
self.adc = ADC(Pin(p_adc)) #33
self.adc.atten(ADC.ATTN_11DB) # Configuration pour la plage 0-3.3V
self.adc.width(ADC.WIDTH_10BIT)
Cette méthode initialise le convertisseur analogique-numérique (ADC) et le convertisseur numérique-analogique (DAC). Le DAC est utilisé pour créer un décalage (offset) de 1,6V, nécessaire car le capteur SCT013 génère un signal alternatif qui oscille autour de zéro, alors que l'ESP32 ne peut lire que des tensions positives.
Mesure crête à crête
#Mesure crête à crête
def crete(self):
nb_per = 3
T = 20 # période du signal
tab = []
deadline = ticks_add(ticks_us(), T*nb_per*1000)
while ticks_diff(deadline,ticks_us()) > 0:
tab.append(self.adc.read())
gmax = max(tab)
gmin = min(tab)
return gmax - gmin
La méthode crete() capture plusieurs échantillons du signal sur 3 périodes (60 ms pour un signal à 50 Hz) et calcule la différence entre les valeurs maximale et minimale, ce qui donne l'amplitude crête à crête du signal.
Conversion en ampères efficaces
MicropyLthon
def mes_eff(self):
pt_carac = [(0,0), (23,0.211),
(333,16.346),
(473,23.701),
(790,39.462) ]
nb = len(pt_carac)-2
i = 1
a = -1
cc = self.crete()
while a==-1 and i A= pt_carac[i-1]
B= pt_carac[i]
if cc <= B[0]+4:
a, b = self.equa_droite(A, B)
i+=1
if a == -1:
A= pt_carac[i-1]
B= pt_carac[i]
a, b = self.equa_droite(A, B)
g_eff = a * cc + b
if g_eff < 0 :
return 0.0
return round(g_eff,2)
La méthode mes_eff() utilise une interpolation linéaire entre des points caractéristiques pour convertir la valeur crête à crête en ampères efficaces (RMS). Cette approche par morceaux permet d'obtenir une précision satisfaisante sur toute la plage de mesure.
Code complet pour utiliser la librairie SCT013
MicropyLthon
from machine import ADC, DAC, Pin
from time import ticks_add,ticks_diff,ticks_us,sleep
class SCT013:
def __init__(self,p_adc,p_dac=25):
#pin dac sur ESP32 :25 et 26
dac = DAC(Pin(p_dac)) #26
offset = int(1.6*255/3.3)
dac.write(offset)
self.adc = ADC(Pin(p_adc)) #33
self.adc.atten(ADC.ATTN_11DB) # Configuration pour la plage 0-3.3V
self.adc.width(ADC.WIDTH_10BIT)
def equa_droite(self,pt1, pt2):
x1, y1 = pt1
x2, y2 = pt2
a = (y2 - y1) / (x2 - x1)
b = y1 - a * x1
return a, b
#Mesure crête à crête
def crete(self):
nb_per = 3
T = 20 # période du signal
tab = []
deadline = ticks_add(ticks_us(), T*nb_per*1000)
while ticks_diff(deadline,ticks_us()) > 0:
tab.append(self.adc.read())
gmax = max(tab)
gmin = min(tab)
return gmax - gmin
def mes_eff(self):
pt_carac = [(0,0), (23,0.211),
(333,16.346),
(473,23.701),
(790,39.462) ]
nb = len(pt_carac)-2
i = 1
a = -1
cc = self.crete()
while a==-1 and i A= pt_carac[i-1]
B= pt_carac[i]
if cc <= B[0]+4:
a, b = self.equa_droite(A, B)
i+=1
if a == -1:
A= pt_carac[i-1]
B= pt_carac[i]
a, b = self.equa_droite(A, B)
g_eff = a * cc + b
if g_eff < 0 :
return 0.0
return round(g_eff,2)
def main():
sct = SCT013(p_adc=33,p_dac=26)
while True:
ieff = sct.mes_eff()
print(ieff,"A")
print("-"*20)
sleep(2)
if __name__ == "__main__":
main()
Pourquoi cette approche est efficace
- Non-invasive : Pas besoin de couper le circuit électrique
- Précision ajustable : La calibration peut être affinée en ajoutant plus de points caractéristiques
- Faible coût : L'ESP32 et le SCT013-50 sont des composants abordables
- Flexibilité : Le code MicroPython est facilement modifiable pour d'autres capteurs
Applications pratiques
- Surveillance de la consommation électrique d'appareils spécifiques
- Détection de surconsommation anormale
- Automatisation basée sur la consommation énergétique
- Intégration dans des projets de maison intelligente
Comment améliorer ce système
Pour rendre ce système encore plus utile, vous pourriez :
- Ajouter une connexion WiFi pour envoyer les données vers un serveur
- Implémenter un calcul de puissance (en multipliant par la tension)
- Créer une interface web pour visualiser les données
- Stocker les mesures sur une carte SD pour analyse ultérieure
Mise en œuvre pratique
Pour assembler ce système, vous aurez besoin de :
- Un microcontrôleur ESP32
- Un capteur SCT013-50
- Une résistance de charge (environ 33 Ω)
- Un condensateur de 10 µF
- Quelques fils de connexion
Le capteur doit être connecté à une entrée analogique de l'ESP32 via un circuit de conditionnement approprié, comprenant la résistance de charge et le condensateur pour filtrer le signal.
FAQ : Réponses aux Questions Courantes
Q : Puis-je mesurer du DC avec ce capteur ?
R : Non, le SCT-013-50 est conçu pour l’AC uniquement.
Q : Comment améliorer la précision ?
R : Utilisez une résistance de précision et étalonnez avec un appareil de référence.
Q : Est-ce compatible avec Arduino ?
R : Oui, mais MicroPython simplifie le prototypage !
Conclusion
Ce projet illustre parfaitement comment des composants électroniques simples, associés à un code bien structuré, peuvent créer un outil de mesure précis et utile. La classe SCT013 encapsule toute la complexité de la mesure et offre une interface simple pour obtenir des valeurs en ampères.
Que vous soyez un maker passionné, un étudiant en électronique ou un professionnel cherchant à optimiser la consommation énergétique, ce projet vous offre une base solide pour vos expérimentations.
N'hésitez pas à adapter ce code à vos besoins spécifiques et à partager vos améliorations avec la communauté !
Avez-vous déjà utilisé des capteurs de courant dans vos projets ? Quelles applications envisagez-