Alimentation Arduino, pont en H et moteur 12V avec batterie

Bonjour,
Je commande un moteur 12V avec un arduino par l'intermédiaire d'un pont en H. J'ai voulu rendre le dispositif autonome en le mettant sur batterie (batterie étanche bateau 12V) que j'ai reliée à un petit panneau solaire (30W crête).
Le moteur tourne une fois le soir et une fois le matin (porte de poulailler), le pont et l'arduino reste allumés le reste du temps.

La batterie tient 2 jours ... ceci m'étonne car la consommation électrique de ces circuits ne doit pas être énorme.

Auriez-vous une idée pour optimiser la consommation ? existe-t-il un moyen de couper l'alimentation le jour (programmateur en 12V) ?

Merci par avance pour votre aide.
Julien

Bonjour,
Il nous faudra un peu plus de détails:

type de carte arduino et pont en H.

capacité batterie

type moteur

le câblage du tout.

etc

Merci pour ta relance, en effet, mon message n'est pas précis.

Merci !

bonjour,

ah ouais, quand même! la photo du montage sur le site du module L298N fait un sacré plat de spaghetti pour deux moteurs! J'avais imaginé un bête pont en H avec 4 relais (c'est plus de mon niveau :wink: ).
Je n'ai pas de réponse à ta question, ne maitrisant ni la conso de ta carte ni celle du pont. en revanche, peut-être que ton code permettrait aux plus moustachus du forum de t'en dire quoi.
Question annexe : si tu utilises le moteur à vis sans fin du lien amazon, est-ce que tu as utilisé des contacts de fin de course? J'ai de mon coté le même genre de montage mais avec des moteurs pas à pas, mais justement pour éviter les fins de course aléatoires et gourmandes en courants de court-circuits je me demande comment faire - mis à part les inters de fin de course - pour savoir ou en sont les moteurs...
tiens nous au courant,

la carte c'est une ATméga2560 (pas la plus économe en énergie sûrement).
Le pont en H est un L298N :

Pas vraiment économe :

  • ATMEGA2560 : 59mA si alimentée par VIN
  • L298 : 6mA (si VEN = LOW), 24mA sinon.

Autonomie = 7AH / 107 heures
A cela il faut soustraire l'énergie consommée par le moteur.

Je commande un moteur 12V avec un arduino par l'intermédiaire d'un pont en H. J'ai voulu rendre le dispositif autonome en le mettant sur batterie (batterie étanche bateau 12V) que j'ai reliée à un petit panneau solaire (30W crête).

Comment est branché le panneau solaire ?
Quel chargeur est-il utilisé ?

J'alimente le L298 en 12V, je peux l'alimenter en 5 c'est ça ? mais il fera quand même tourner mon moteur 12V ?
Et pour AT mega, il y a une autre manière de l'alimenter aussi ?

Le panneau solaire arrive sur le contrôleur de charge :
https://fr.aliexpress.com/item/4000218846226.html?spm=a2g0s.9042311.0.0.56f16c371tewhZ

Le contrôleur de charge alimente le L298.

Il faudrait d'abord contrôler que le panneau recharge effectivement la batterie.
Un batterie de 7AH ne devrait pas être rechargée au delà de C/10 : 700mA.

Ensuite une MEGA est surdimensionnée pour cette utilisation.
Il faudrait au moins utiliser le sleep mode : consommation-dune-carte-arduino

Et jouer sur les broches Enable du L298.

Ok, merci. Je vais regarder pour la recharge du panneau.

Que signifie jouer avec les broches du L298 ?

Broches Enable du L298 à LOW = moins de consommation.

Ok merci, donc je dois, une fois que le moteur a fini de tourner, remettre les broches sur LOW ...

Pour la fonction sleep, si je veux la tester, comment je peux mesurer la consommation de la carte ? avec le câble usb, pas facile de mettre un ampèremètre dans le circuit ? une pince ampèremétrique non plus. Quelle est la solution SVP ?

Merci @hbachetti

C'est tout simple :

C'est pas faux, mais dis donc, ça a son prix sur les boutiques françaises...

Je vais regarder comment marche la fonction sleep de l'arduino.

Sinon est-ce que cela pourrait être intéressant d'utiliser un relais arduino pour couper l'alimentation du pont et le rallumer uniquement quand j'en ai besoin ?

Et je n'ai pas répondu @Lio88510, oui j'utilise des fins de course pour l'arrêt du moteur, ça marche bien.

C'est pas faux, mais dis donc, ça a son prix sur les boutiques françaises...

Sur AliExpress : un modèle capable de mesurer 100µA.

Sinon, si tu as envie de jouer : usb-un-voltmetre-amperemetre

Sinon est-ce que cela pourrait être intéressant d'utiliser un relais arduino pour couper l'alimentation du pont et le rallumer uniquement quand j'en ai besoin ?

Essaie d'abord avec sleep mode et Enable à LOW.
Mais pourquoi pas ?
Un relais 2 contacts sur 5V et 12V
Ou mieux : 2 MOSFETS, un petit et un plus gros (CANAL P pour pouvoir couper l'alimentation par le +).

Tu gagnerais aussi pas mal en adoptant une PRO MINI 8MHz.

RitonDuino: ARDUINO PRO MINI & basse consommation

Une MEGA en sleep mode consommera environ 7mA, une PRO MINI peut descendre à 1.5µA !
En 5V elle consommera un peu plus.

Bonjour,
Je vais sûrement commander un pro mini, mais avant cela je voudrais faire des tests avec le montage et code existants qui fonctionnent.

Pour la fonction sleep, on ne trouve pas facilement des exemples de codes qui montrent comment on entre et sort du mode veille, c'est surprenant. Surtout que je lis dans le forum qu'il y a plein d'exemples ... j'ai du mal chercher.

Quand tu me parles de relais, tu pourrais me donner un lien ? je ne vois pas ce qu'est "Un relais 2 contacts sur 5V et 12V". Les Mofset c'est peut-être trop compliqué pour le moment (leur choix par exemple).

Merci beaucoup pour ce temps passé à me conseiller.
Julien

Tu peux utiliser une librairie :

Voir les exemples.

Il y a aussi un exemple de code dans mon article : consommation-dune-carte-arduino

Je ne sais pas comment tu gères le temps dans ton logiciel : RTC ou pas ?
Le temps maximal d'endormissement sans réveil par interruption externe est de 8s.
Une fonction d'endormissement en minutes :

#include <LowPower.h>
void lowPowerSleep(int minutes)
{
  int seconds = minutes * 60;
  int sleeps = seconds / 8;
  for (int i = 0 ; i < sleeps ; i++) {
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
  }
}

Ce code peut fonctionner jusqu'à 9H d'endormissement. Au delà il faudra utiliser des variables long.

Au sujet de la coupure d'alimentation du L298 il faut couper le 5V et le 12V car les deux consomment.

On ne trouve pas de modules tout faits à deux contacts, mais rien n'empêche d'utiliser un module à 2 relais.
Mais c'est un peu utiliser un canon pour tuer une mouche.

Couper l'alimentation 5V du L298 avec un MOSFET :

Couper l'alimentation 12V du L298 avec un MOSFET :

Intéressant ! pour les Moffset on verra plus tard, je garde sous le coude.

Je n'ai pas de temps dans mon programme, la porte s'ouvre et se ferme en fonction de la luminosité, avec un compteur pour être sûr que c'est bien le matin et le soir.

Je pourrais mettre en veille 9H une fois la porte ouverte et fermée, mais ensuite il faut que puisse tester la valeur de la luminosité pour, si la luminosité s'approche d'une valeur seuil, laisser l'arduino en veille le temps de l'ouverture ou de la fermeture.

J'utiliserais alors plutôt le powerDownWakePeriodic ?

J'utiliserais alors plutôt le powerDownWakePeriodic ?

Oui, avec une période à ta convenance.

Si tu pars de l'exemple powerDownWakePeriodic le temps d'endormissement maximal est de 8 secondes.

La fonction lowPowerSleep() proposée plus haut est une boucle d'endormissements / réveils successifs.
L'AVR s'endort 8s, se réveille, s'endort à nouveau 8s, se réveille, etc. jusqu'à atteindre le nombre de minutes demandé.
Le temps de réveil est très court (qq µs) par rapport aux 8s de sommeil, donc la consommation sera faible.

Bonjour,
J'ai fait aussi un portier de poulailler déclenchant par la luminosité. forum.arduino.cc/index.php?topic=379566.0

Pas besoin de compteur pour distinguer le jour de la nuit, il suffit d'attribuer une variable à l'état de la trappe dans le setup :

 panneau = analogRead(pinpanneau);//luminosité lue sur le PV
 // Pour forcer la trappe à se fermer la nuit ou à s'ouvrir le jour.
 if (panneau > nuit) {//jour
   trappe = 1; // fermée
 }
 if (panneau < nuit) {
   trappe = 0; // ouverte
 }

Puis le jour attendre le seuil nuit et ainsi de suite.

J'avais utilisé un mode économiseur un peu compliqué. Aujourd'hui j'utilise aussi la librairie low-Power très simple d'utilisation.
A chaque réveil le processeur exécute le minimum d'opérations, dans ce cas : attente du seuil jour la nuit et du seuil nuit le jour, puis retour directe en veille pour 8 secondes, sinon attends la fin d'ouverture ou de fermeture de trappe pour retourner en veille. Pas besoin non plus de faire une boucle.

Mon bricolage fonctionne depuis 4 ans. Je tiens au moins 2 mois sans soleil avec une batterie de 6 V 4Ah NIMH et un panneau de 6V 2 W. La recharge se gère par le pro mini.

Vu la consommation, tu dois avoir un moteur puissant capable de couper une poule étourdie en 2 non ?

Le pro mini utilisé est un 16 Mhz/ 5 V. J'ai mesuré 4.5µA sans led power ni régulateur, mais dans ce cas, j'ai juste supprimé la led power et la consommation est de 0,4 mA.

Bonjour,
Merci à tous les deux.

Après avoir débuté cette conversation, je suis en effet tombé sur ton topic achess qui m'a paru tout à fait en accord avec ce que je voulais faire.

Mais en effet, la partie mise en veille me paraissait compliquée.

Le compteur existait dans l'idée de laisser un laps de temps aux poules pour rentrer quand la luminosité est faible, et d'éviter que la trappe se ferme quand il y a un gros nuage noir qui passe.

Mon blocage principal réside dans la sortie de veille qui permet à l'arduino de comprendre qu'on est à un seuil et qu'il faut rester éveiller le temps de l'action (ouverture ou fermeture) : où dois-je mettre la fonction powerDownWakePeriodic ?

Il est peut-être intéressant que je vous livre "mon" code (des guillemets car j'ai bien pioché dans ce que j'ai trouvé ici et là !)

#include <simpleBouton.h>

const uint8_t pin_bouton = 4;
const int ENB = 7;
const int IN3 = 5;
const int IN4 = 6;
const int pinVal = A2;
int buttonState;
int buttonState2;
//int buttonState3;
int compteur = 500;
int jour;
simpleBouton bouton(2); //fin de course 1
simpleBouton bouton2(3); //fin de course 2
simpleBouton bouton3(pin_bouton); //ouverture manuel
int led = 9; //permet de vérifier la fermeture de la porte depuis la maison

void setup() {
Serial.begin(115200);
  // put your setup code here, to run once:
  pinMode(ENB, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  pinMode(led,OUTPUT);

  digitalWrite(ENB, LOW);
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
    
jour= 1; // on initialise l'arduino le jour
}

void loop() {

delay(1000);
int valeur = analogRead(pinVal);
buttonState = digitalRead(2);
buttonState2 = digitalRead(3);
//buttonState3 = digitalRead(4);

//----------sortie sur le serial pour vérification---------
Serial.print("resistance : ");
Serial.println(valeur);
Serial.print("compteur : ");
Serial.println(compteur);
Serial.print("jour : ");
Serial.println(jour);
if (buttonState == 0)
  {
  Serial.println("Capteur haut: ferme");  
  digitalWrite(led, HIGH);
  //jour = LOW;
  }  
else
  {
  Serial.println("Capteur haut: ouvert");  
  digitalWrite(led, LOW);
  }
if (buttonState2 == 0)
  {
  Serial.println("Capteur bas: ferme");
  //jour=HIGH;  
  }  
else
  {
  Serial.println("Capteur bas: ouvert");  
  }  
Serial.println("");  
//---------------------------------------------


//-----fin de course et bouton "manuel"---------
bouton.actualiser();
bouton2.actualiser();
bouton3.actualiser();
if (bouton.vientDEtreEnfonce())
  {
    actionAssociee();
  }
if (bouton2.vientDEtreEnfonce())
  {
    actionAssociee();
  }
  if (bouton3.vientDEtreEnfonce())
  {
  Serial.println("test"); 
  }
//------------------------------------------

if (jour==HIGH) //SI c'est le jour
  {
    if (valeur<75) //150si la valeur de la photorésistance est petite
    {
    compteur=compteur-1; //le compteur diminue
    }
    else
    {
    compteur=500;
    } 
    
     if (compteur<495)  //5si le compteur est inférieur à un seuil
      {
      digitalWrite(IN4, LOW);
      digitalWrite(IN3, HIGH);
      analogWrite(ENB, 255); //150
      jour=LOW;
      compteur=500;
      }
      
}  

 // On fera la même chose quand le jour se lève avec un compteur qui s'incrémente vers le haut
if (jour==LOW)
  {
    if (valeur>75)
    {
    compteur=compteur+1;
    }
    else
    {
    compteur=500;
    } 
    
    if (compteur>505) //600
    {
  digitalWrite(IN3, LOW);
    digitalWrite(IN4, HIGH);
   analogWrite(ENB, 255); //150
    jour=1;
    compteur = 500; 
    } 
    if (bouton3.vientDEtreEnfonce()) //S'il fait encore nuit le matin j'ouvre la porte manuellement
      {
     digitalWrite(IN3, LOW);
     digitalWrite(IN4, HIGH);
      analogWrite(ENB, 150);
      jour = 1;
      compteur = 2000;   //2000
      }
  }  
}  
void actionAssociee()
{
  analogWrite(ENB, 0);
}

Il y a de l'optimisation à faire, j'en suis conscient. Je compte rajouter l'extinction du L298 avec le MOSFET un de ces quatre (mais pareil, comment faire ça avec l'arduino en veille ?)

Re re merci.

La mise en veille de l'ARDUINO doit être demandée à partir du moment où le capteur de fin de course est atteint.
Cela veut dire qu'il n'y a plus rien à faire.
La broche Enable du L298 doit être mise à LOW avant la mise en veille, et à HIGH à la prochaine ouverture ou fermeture.
Peut être une sécurité à ajouter :
Un objet bloque la porte, ou un fin de course est défectueux :

  • couper le moteur au bout d'un certain temps
  • signaler le problème avec un buzzer (bip court et répétitif) ou une LED clignotante.