Arduino, batterie et projet embarqué [MIS A JOUR]

Bonjour à vous!
Je viens en quête de savoir! En effet j'ai fait quelques recherches sur ce que je vais vous demander mais n'ai pas réussi à me décider sur la solution à adopter
Je précise que je n'ai pas une grande connaissance de l'électronique, je connais le noms des composants, vaguement à quoi il servent mais je ne me suis par exemple jamais servi d'un transistor.

Dans le cadre d'une escape game pour enfants je souhaite construire plusieurs petits "jeux" embarqué et fonctionnant avec des Arduinos. Par soucis de réalisme (thématique pirate) et de praticité, je souhaiterais donc éviter d'avoir à alimenter mes Arduino en secteur. Je peux éventuellement envisager d'en brancher un mais je compte déjà 3 systèmes faisant appel a des Arduinos. Il me faudrait donc des batteries...

De plus, le rôle des ces Arduino est ,comme souvent pour ces projets, d'ouvrir un petit compartiment ou au au moins donner l'accès à un autre objet si l'énigme est résolu.
Je sais que souvent ce sont des électroaimant qu'on utilise pour cela, mais je ne pense pas pouvoir me permettre de faire fonctionner ça sur une batterie. Du coup j'ai découvert les solenoid qui me semble être une bonne alternative, ou un moteur pas à pas.
Dans les deux cas ca serait pour bloquer / permettre l'ouverture d'un compartiment / trappe. Par exemple ouvrir un coffre au trésor

Outre les système d'ouverture / fermeture pour chaque Arduino, je compte ajouter d'autre capteurs. Je pense notamment à un émetteur et récepteur laser, des interrupteurs basiques, des interrupteurs reeds (interrupteurs se fermant proche d'un aimant) et ,ce qui je pense peut coincer sur batterie, un haut parleur. Même s'il n'a pas besoin d'être puissant j'ai essayé pour un autre projet un haut parleur 5W non amplifié (je crois...) et je pense que le volume ne sera pas assez fort pour être entendus par des enfants qui s'amuse en même temps.
Je pense que c'est d'ailleurs cet Arduino que je vais brancher en secteur, comme ça si y'a besoin d'alimenter un haut parleur aussi c'est plus simple.

Mes questions sont donc les suivantes:

-Y'a t'il des modèles de batterie connues pour bien fonctionner avec les arduinos? Ou qui serait adapté à mon projet? Sinon comment calculer les caractéristique de ce que j'ai besoin?

-Est'il possible d'alimenter avec une même batterie : un circuit incluant un solenoid / moteur pas à pas et l'Arduino qui le contrôle ? Ne vont t'ils pas manger toute la batterie à eux seuls?
Je précise que leur utilisation va être très minime au cours du jeu

-Quelle autonomie puis-je espérer? Concrètement 8h d'autonomie max serait déjà très bien car je pourrais faire une journée complète d'activité sans avoir à les recharger / échanger avec des chargées

Voilà, je sais que c'est long et il y'a beaucoup d'infos, mais je débute! Il faut bien commencer quelque part. J'ai essayé de vous donner tous les renseignement que je voyais utile mais s'il en manque je me ferais un plaisir de compléter. Merci beaucoup!

N'importe quelle batterie LITHIUM-ION, mais seulement avec un ARDUINO PRO MINI 3.3V. Les autres ARDUINO nécessitent 5V.

Si l'utilisation est réduite, non. Un solénoïde consomme seulement si l'on s'en sert.

Cette question rejoint la précédente. Tout dépend de ce que l'on entend par "leur utilisation va être très minime au cours du jeu".
Une PRO MINI 3.3V consomme 5.5mA en mode actif et 1.5mA en mode veille (1.5µA si on la bricole un peu), si ce mode est utilisable (réveil par un bouton par exemple).

Okay mais de là découle de nouvelles questions encore:

-Un ARDUINO PRO MINI 3.3V peut utiliser tous les modules que j'avais prévus d'utiliser comme un Arduino plus standard?

Pour le solenoid je vais détailler l'utilisation que je comptais en faire ça rendra le problème plus clair.

En gros j'ai 4 interrupteur et le solenoid reliés à mon Arduino. Si les 4 sont activé en même temps, je veux rétracter la tige du solenoid qui sera à ce moment encastré dans un petit trou maintenant ma trappe fermée. Normalement cela permettra donc d'ouvrir la trappe. Je compte meme sur la gravité pour qu'une fois libérée, la trappe s'ouvre toute seule.
Donc si on considère qu'on "utilise" le solenoid quand on retracte la tige seulement ça peut meme ne durer qu'une seconde. Juste le temps que le truc s'ouvre quoi.

De plus de ce que je suppose, s'il y'a un mode veille, il doit surement avoir des moyens pour le faire s'en sortir. Mais est ce que c'est par exemple quelque chose d'interne qui déclenche les changement d'état , (genre toutes les 5 sec tu sort de veille, check l'état des interrupteurs puis te rendors et ceci en boucle) ou ça peut être un déclenchement externe ?(du style un état d'un des interrupteur qui change du coup il sort de veille)

Pasque en fonction de tous ces paramètre en étant un peu malin sur le code on doit pouvoir gratter du temps de batterie

Bonsoir

il y'a un mode veille, il doit surement avoir des moyens pour le faire s'en sortir. Mais est ce que c'est par exemple quelque chose d'interne qui déclenche les changement d'état , (genre toutes les 5 sec tu sort de veille, check l'état des interrupteurs puis te rendors et ceci en boucle) ou ça peut être un déclenchement externe ?(du style un état d'un des interrupteur qui change du coup il sort de veille)

Ces deux méthodes de sortie de veille sont disponibles

Pas besoin d'un Arduino pour ça. Juste les 4 inter câblés en série et ça ne consomme rien au repos.

1 Like

Citation Ces deux méthodes de sortie de veille sont disponibles

:+1:

CitationPas besoin d'un Arduino pour ça. Juste les 4 inter câblés en série et ça ne consomme rien au repos.

En fait j'ai menti. Ce sont des interrupteurs en normalement fermés et si les 4 sont ouverts, alors le solénoïde doit s'activer. Et je vais rajouter au plan initial des led (ou source plus lumineuse meme) qui vont devoir s'allumer.

Okay petite mise à jour après des recherches sur les batterie

J'ai trouvé une vidéo faisant un petit comparatif des conso d'arduinos en utilisant juste l'arduino seul, sans rien de connecté, et avec un programme faisant clignoter une LED. Ce tableau prends en compte une batterie de 4200 mAh et donc les différentes autonomies possibles sur les différents modèles:

Du coup, même s'il s'agit d'une consommation "à vide" cela peut donner un certain ordre d'idée.

En me baladant sur le net j'ai trouvé des batteries faite pour charger des téléphones portable et j'ai été étonné de voir des capacités annoncés de 26800 mAh en 5 à 12V. Ce qui, si je ne m'abuse, me semble incroyable comme possibilité d'autonomie, puisque cela représente plus de 5 fois la batterie testé dans le tableau

La seule question que je me pose maintenant c'est comment estimer la consommation d'un Arduino avec un circuit plus complexe? Y'a t'il moyen de le calculer sans avoir à acheter tous les composant et faire le relevé une fois le circuit fini?

Oui, mais j'ai plusieurs PRO MINI qui tournent pendant 20-21 mois sur une batterie de 650mAH.
Elles ne consomment pas 1.5mA, mais 1.5µA :
http://riton-duino.blogspot.com/2018/02/arduino-pro-mini-basse-consommation.html

Si c'est un powerbank, pourquoi pas, mais sans plus de précision, que dire ?
A savoir qu'un powerbank se coupe si la consommation sur sa sortie est trop faible.

Lire les datasheets des composants en question.

Si c'est un powerbank, pourquoi pas, mais sans plus de précision, que dire ?
A savoir qu'un powerbank se coupe si la consommation sur sa sortie est trop faible.

J'ignorais ce détails qui pourrait en effet être fâcheux Pour ce ce qui est des caractéristique j'ai un peu maté sur amazon et je ne trouve pas plus d'infos. En plus je viens de voir que souvent les powerbank intégrent des convertisseurs de tensions (ou courant je ne suis pas sur) et du coup grignotent lentement la batterie même quand rien n'y ai branché.

Depuis le post original j'ai décidé d'adapter un peu mon projet. Je vais avoir plusieurs modules indépendants (Rasp, arduino et ESP32) à monter sur batterie.
J'ai décidé de commencer par celui qui me semble être le plus galéré, un ESP32

Le principe c'est d'avoir un ESP32 sur batterie et qui s'il détecte 3 tag RFID bien positionnés sur les 3 lecteurs, ouvre un des compartiments avec un des 5 solenoids 5V

Pour la batterie je vais mettre une 18650 3000mAh (celle là) dans ce boitier. Celui-ci me permet de récupérer du 3V pour ne pas endommager l'ESP en plus de servir de boitier de charge à la cellule.

Pour la partie RFID je compte utiliser 3 lecteur RFID PN5180 qui permettent un meilleure détection en RFID que les autres lecteurs classiques. Ceux ci marche en 5V donc directement utilisable depuis les pin de l'ESP32. Pour le schémas, je compte réutiliser partiellement celui de cette vidéo ci:

Je n'ai pas besoin de la partie avec le relay ni du 4éme lecteur RFID. Lien vers la vidéo
d'explication du montage

Pour les solénoïdes , l'idée est d'ouvrir 5 solénoïdes 5V très brièvement en fonction des combinaisons de tag RFID mis en face des lecteurs

Un exemple:
-Tag A, B et C mis en face des lecteurs RFID 1,2 et 3 => Ouverture du solénoïde 1 pour 3 secs
-Tag D, B et C mis en face des lecteurs RFID 1,2 et 3 => Ouverture du solénoïde 2 pour 3 secs
ect

Sauf que, les solénoïdes après utilisation crée des pics de tensions que n'aime pas trop l'ESP!
Du coup je vais devoir faire pour chaque Solénoïdes un montage avec une diode est un transitor pour protéger l'ESP! Pour être plus précis, quelque chose comme ça:

Le probléme c'est que je ne sais juste pas calculer la valeur de la résistance et du transistor qu'il me faut. Cet exemple est en 12V pas 5 comme sur l'ESP! SI quelqu'un saurait m'expliquer comment faire pour calculer la chose.

BREF, j'ai essayé de détailler le plus possible mais y'a t'il parmi vous des gens qui saurait me dire si tout ceci semble possible dans la pratique ou pas du tout car : x raisons?
Ce qui personnellement me stresse c'est de savoir que ma seule pin sortant du 5V de l'ESP32 va devoir alimenter 3 lecteurs RFID et 5 Selunoid....

Merci à vous

RFID : première nouvelle. Si tu avais donné cette info dès le départ, cela aurait évité des réponses inutiles.
Un ESP32 possède un mode veille, mais il sera inutilisable dans un cas comme celui-ci, à moins d'ajouter un bouton poussoir pour le réveiller, avant de lire la carte. Ensuite il y a le temps de démarrage, et de connexion à une box, à moins qu'il soit configuré en AP.
A quoi sert l'ESP32 ? serveur WEB ? client ?

RFID : première nouvelle. Si tu avais donné cette info dès le départ, cela aurait évité des réponses inutiles.

Quand j'ai posté pour ce sujet je ne savais pas encore que j'allais devoir utiliser du RFID, ça a évolué en cours de route.

A quoi sert l'ESP32 ? serveur WEB ? client ?

Je l'utilise juste comme un microcontrôleur, cela pourrait tout aussi bien être un Arduino. Mais les exemples que j'ai trouvé pour faire fonctionner les PN5180 (lecteurs RFID) étaient avec des ESP32 car il ne prennent pas le 5V des Arduino. Cela rendrait le circuit plus compliqué alors que cela marche directement avec un ESP32

Je te conseille de te renseigner sur la consommation d'un ESP32 en active mode, et également celle d'un lecteur RFID. Je pense que sans WIFI on doit être au dessus de 100mA, sans compter les activations de solénoïdes.
Multiplie ensuite les mA par des heures et tu obtiendras des mAH.

Réouverture du topic car entre temps j'ai fait des achats et je me retrouve aujourd'hui avec un problème que je ne comprends pas. J'ai acheté des batterie 12V pour les différents projets embarqués que j'ai. J'ai actuellement aujourd'hui quelquechose d'assez similaire avec le schémas que j'ai posté précédemment.

  • Un arduino Mega avec 3 lecteur RFID connectés
  • Un relai commandé par l'Arduino et alimentant un petit solenoid 12V

Lorsque je mets mes 3 cartes en face des lecteurs, je demande au relai d'alimenter le solenoid pendant 5 sec pour l'ouvrir.

POUR LE MOMENT, le relai et l'Arduino ont deux alimentations différentes et sur secteurs.
Sur secteur tout marche pas de soucis.

Si je mets le relai sur batterie et l'arduino alimenté sur USB encore une fois pas de soucis ca marche
En revanche si j'utilise une batterie pour alimenter mon arduino, celui si va s'allumer, lancer mon programme qui va détecter les cartes, ouvrir le relai... pour une seconde environs! Puis plus rien ne marche. Evidement je vois la lueur des leds de l'arduino faiblir progressivement, ce qui indique un problème d'alimentation.
Ce que je ne comprends pas, c'est que l'arduino ne partage meme pas son alimentation avec le relai et le solenoid.

Avez vous déjà eu des expériences similaire? Est ce que je dois rajouter quelquechose entre la batterie et l'arduino en plus?
Merci à vous encore une fois

Je te conseille de lire ceci :
https://riton-duino.blogspot.com/2020/04/arduino-lalimentation.html
Spécialement le paragraphe 3.3.3. Puissance maximale

Désolé pour le long temps de réponse, je bosse sur plein de trucs à la fois
J'ai regardé ton article et je vois qu'on y parle de Arduino nano et ESP, et même si j'en utiliserai aussi je suis dans le cas présent avec un Arduino MEGA. Je suppose que ce n'est pas la même base de consommation du coup
Cependant vu ce que tu me dis, je suppose que je vais avoir besoin d'un régulateur entre la batterie et mon arduino c'est ça?

La réponse se trouve dans ton post #7.

Une MEGA peut parfaitement être alimentée sous 12V, étant donné qu'elle possède déjà son propre régulateur. Par contre la bobine du relais (12V) devra être alimentée par la batterie.

Je me demande ce qui justifie une MEGA pour faire si peu de choses. La consommation est énorme par rapport à une PRO MINI.

Alors je ne saurais plus te répondre pourquoi, mais j'ai eu du mal à utiliser les lecteurs avec un nano que j'avais aussi. Passé plusieurs heures à essayer sans réussir à le faire marcher j'ai essayé avec le mega qui a marché direct. De toute façon je vais pour mon projet qui inclut plusieurs arduinos sur batterie, alimenter des nano ET des mega (chacun avec leur batterie évidement) donc je vais devoir savoir faire pour les deux

Ben je suis bien d'accord mais pourquoi alors mon arduino se comporte bizarrement? J'ai vérifié et ma batterie chargée envoie bien du 12V

Trop de courant consommé sur le 5V ?
Tu peux réduire le 12V à environ 7V avec un régulateur à découpage.

Y'a moyen vu que mon code demande une lecture permanente des 3 lecteurs. Je vais essayer de réduire le nombre de lecture à la seconde et voir si ça change quelque chose
En tout cas j'ai testé ma batterie 12V sur une autre Arduino mega d'un autre projet et ça marche nikel

Bon aprés quelques tests, j'ai tenté de rajouté des delay(3000); dans ma boucle afin d'essayer de temporiser les lectures et donc, essayer de réduire la consommation. Je ne sais pas comment je peux, grâce à une modification du code, diminuer la consommation hormis cela

Ce qui me fait dire que c'est bien un problème de consommation, c'est que branché en USB, je n'ai aucun soucis le montage fonctionne. Dés que je mets l'arduino sur ma batterie 12V, comme dis précédemment, les leds deviennent rapidement faible, puis plus rien. De plus, je remarque qu'une composant devient particulièrement chaud sur la carte, celui surligné en jaune ici:

Voilà une image plus propre de mon montage actuel:

Je pense aussi que c'est bel est bien les lecteurs qui posent soucis, c'est qu'en débranchant les PINS 2 à 10 du schémas, l'Arduino arrive à s'allumer est à maintenir ses leds allumés sur batterie.

J'ai donc cherché à savoir combien ces lecteurs consomment et j'ai trouvé la datasheet, mais je vous avoue ne pas savoir quoi chercher ni même ou dessus...

Pour ce qui est de mon code le voici dans son intégralité:

#include <Debug.h>
#include <PN5180.h>
#include <PN5180ISO15693.h>

/*

*/
 const int ledred = 7;
 const int ledgreen = 6;
 int totalTags = 0;

// The number of PN5180 readers connected
 const byte numReaders = 3;///  A MODIFIER
 const byte numTag = 6;

// What is the "correct" UID that should be detected by each reader
uint8_t correctUid[][8] = 
{
  {0x8A,0x9F,0x9D,0xA4,0x50,0x1,0x4,0xE0}, //TAG 1
  {0xA5,0x73,0xE4,0xF6,0x50,0x1,0x4,0xE0}, //TAG 2
 {0x48,0x52,0x9D,0xA4,0x50,0x1,0x4,0xE0},
 {0x22,0x4C,0xA6,0xF6,0x50,0x1,0x4,0xE0},
 {0x6A,0x4E,0xA6,0xF6,0x50,0x1,0x4,0xE0},
 {0xF2,0x4B,0xA6,0xF6,0x50,0x1,0x4,0xE0}
  
};


//Si ce tag est lu par un des lecteurs, le puzzle sera reset
uint8_t resetUid[][8] = {{0xD1,0xD2,0x48,0x2A,0x50,0x1,0x4,0xE0}}; //TAG 1}

//Valeur par défaut quand il n'y a pas de tag
uint8_t noUid[][8] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; //TAG 1}

//Serial.println("Etape 1");
// GLOBALS
// Each PN5180 reader requires unique NSS, BUSY, and RESET pins,
// as defined in the constructor below
PN5180ISO15693 nfc[] = {
PN5180ISO15693(22,24,26), // Pins correspondants aux fonstions des lecteurs
  PN5180ISO15693(28,30,32), // works
  PN5180ISO15693(34,36,38), // works

 //MISO BLEU 50
 //MOSI VERT 51
 //SCK JAUNE 52
};

// Array to record the value of the last UID read by each reader
uint8_t lastUid[numReaders][8];
 
// the setup function runs once when you press reset or power the board
void setup() {
 Serial.begin(9600);

  Serial.println("Etape 1");
  pinMode(ledred,OUTPUT);// Led rouge
  pinMode(ledgreen,OUTPUT);// Led verte

 
  Serial.println("RFID Tirroir, escape pirate");

  for(int i=0; i<numReaders; i++){
    Serial.print("Reader #");
    Serial.println(i);
    Serial.println(F("Initialising..."));
    nfc[i].begin();
    Serial.println(F("Resetting..."));
    nfc[i].reset();
    Serial.println(F("Enabling RF field..."));
    nfc[i].setupRF();
  }
  Serial.println(F("Setup Complete"));


}

// the loop function runs over and over again forever
void loop() {
  for(int i=0; i<numReaders; i++) {
    // Variable to store the ID of any tag read by this reader
    uint8_t thisUid[8];
    // Try to read a tag ID (or "get inventory" in ISO15693-speak) 
    ISO15693ErrorCode rc = nfc[i].getInventory(thisUid);
    // If the result code was that a card had been read
    if(rc == ISO15693_EC_OK) {
      // If this is the same ID as we read last frame
      if(memcmp(thisUid, lastUid[i], 8) == 0) {
        // Nothing to do - move on to the next reader
        continue;
      }
      // If it's a different ID
      else {
        Serial.print(F("New Card Detected on Reader "));
        Serial.print(i);
        Serial.print(F("... "));
        for (int j=0; j<sizeof(thisUid); j++) {
          Serial.print(thisUid[j],HEX);
          Serial.print(" ");
        }
        Serial.println();
        // Update the array that keeps track of most recent ID
        memcpy(lastUid[i], thisUid, sizeof(lastUid[i][0])*8);
        
        // Has placing this card solved the puzzle?
        checkIfPuzzleSolved();
      }
    }
    // If a card cannot be read
    else {
      // Test if we previously knew about a card (in which case it's just been removed
      // The most significant (last) byte of a valid UID should always be 0xE0. e.g. E007C4A509C247A8
      if(lastUid[i][7] == 0xE0){
        Serial.print("Card ");
        for (int j=0; j<sizeof(lastUid[i]); j++) {
          Serial.print(lastUid[i][j], HEX);
        }
        Serial.print(" removed from Reader ");
        Serial.println(i);
        // Update the array that keeps track of last known ID
        memset(lastUid[i], 0, sizeof(lastUid[i][0])*8);
      }
      
      #ifdef DEBUG
        Serial.print(F("Error in getInventory: "));
        Serial.println(nfc[i].strerror(rc));
      #endif
    }
 
    // Slight delay before checking the next reader
    delay(10);
  }
 // digitalWrite(ledgreen, LOW);
 // digitalWrite(ledred, HIGH);   
 // delay(1000);    
 // digitalWrite(ledred, LOW);
 // digitalWrite(ledgreen, HIGH);                    
}

void onPuzzleSolved() {
  // Activate the relay
 switch(totalTags)
 {
  case 6:
  Serial.println(" Tirroir 1 ");
  digitalWrite(ledred, HIGH);     
  delay(5000); 
  digitalWrite(ledred, LOW);
  break;
  case 33:
  Serial.println(" Tirroir 2 ");
  delay(1000); 
  break;
 }
 /*
if(totalTags ==6){
  Serial.print(" Bonne carte ");*/
  // Loop forever
  }
  


// Check whether all PN5180s have detected the correct tag
void checkIfPuzzleSolved() {
  totalTags=0;
  // Test each reader in turn
  for(int i=0; i<numReaders; i++){                        //Pour chaque lecteur, en les testant un par un
    // Serial.println("Test Puzzle ");
    for(int j=0; j<numTag; j++){ 
    // If this reader hasn't detected the correct tag
    if(memcmp(lastUid[i], correctUid[j], 8) == 0){        //Si l'ID du lecteur est different de l'ID attendu
      totalTags +=  checkValueCard(j);
      //Serial.print("total : " ); 
      Serial.println(totalTags);                                           //On arrete
      }
    }
  }
  //Serial.print(" Bonne carte ");
  onPuzzleSolved();                                       //On résous le puzzle
}
int checkValueCard(int idCard){
  switch(idCard){
    case 0:
    return 1;
    break;
    case 1:
    return 2;
    break;
    case 2:
    return 3;
    break;
    case 3:
    return 10;
    break;
    case 4:
    return 11;
    break;
    case 5:
    return 12;
    break;
  }
}

J'espère avoir donné un peu plus de pistes pour résoudre le soucis