Alimentation arduino nano et perte de neurones

International Français
1

Bonjour a tous.

Je me permet de lancer cette bouteille à la mer demandant de l'aide car je me sent un peut dépassé.

Projet : baudrier runique avec leds intégrées et communication radio
matériel utinilsé :

  • arduino nano
  • transmetteur et recepteur radio NRF24L01
  • leds programmables en pagaille
  • 4 bouton lillypad pour commander les animations lumineuses

problème : lorsque je programme l'arduino nano avec son câble USB tout fonctionne sans problème = animations lumineuses et communication avec les autres partie du costume opérationnelle. Tout va bien

Dés que j'alimente l'arduino avec 4 piles AA 1.5v = 6v directement sur le nano avec Vin et Gr les boutons fonctionnent, toutes les leds s'allument bien

MAIS la communication radio ne fonctionne plus.

Donc là je sèche....

Merci d'avance pour vos conseils.

2

Salut,

6V sur Vin c'est trop faible (le régulateur induit une chute de tension).

3

Donc on va lui coller une pile 9v dans le nez alors !
Pour ce qui est de la consommation en énergie, les leds ont leur propre alimentation a par la led centrale.

Merci des conseils.

4

Vérifie si la capacité d'une pile de 9V sera suffisante.
La capacité d'une pile se mesure en Ampère par heure (Ah).
1 Ah va donner une autonomie qui dépendra du courant que fourni la pile :

  • 1 heure à 1A
  • 10 heures à 0,1 A.

Comme c'est de l'énergie qui est stockée le volume de la pile va être important : plus il y aura de matière plus la capacité sera grande.
Et je reviens à ma remarque de début : une pile de 9V n'est pas bien grosse donc il est préférable de vérifier.

Une recherche avec les mots de recherche : capacité pile 9V devrait donner des réponses.
Dont une au hasard mais qui est une valeur sûre :

5

il pourrait être souhaitable de passer à des accumulateurs Ni-MH.

Je pense avoir compris que c'est pour vêtement, le poids est à prendre en compte.

Tu as des possibilité d'économiser du courant :

  1. la nano possède 3 Dels (led) : Alim et Tx et RX elles ne sont pas indispensables : tu peux les retirer , tu gagnera entre 10 à 20 mA par diode.

  2. Remplacer la nano par une mini-pro fera économiser la consommation de l'interface USB/UART encore une trentaine de mA économisés

  3. Maintenant c'est plus délicat :

  • tu peux utiliser un mini-pro à 3,3V qui consommera moins.
    Il tournera à 8MHz au lieu de 16 MHz ce qui fera consommer encore moins. Mais il faudra vérifier que le NRF24L01et sa bibliothèque acceptent d'être commandé par un micro à 8 MHz (il y a des spécialistes sur le forum).
  • tout n'a pas besoin d'être actif dans le microcontrôleur : par exemple tu n'utilises pas l'I2C et le SPI --> ils peuvent être désactivés. Si tu n'utilise pas un timer il est possible de le désactiver, etc......

Un bon endroit pour comprendre comment réduire la consommation d'un micro :

6

Pour ce qui est de la consommation en énergie, les leds ont leur propre alimentation a par la led centrale.

Il n'y a pas de petites économie et seule une del est connectée (dont on ne connais pas la consommation).
Déjà il faudrait voir si elle ne peut pas être réduite au minimum et faire un état des consommations.
Ensuite même si sur cette appli là il ne veut pas réduire la consommation de sa carte au moins il sait maintenant que c'est possible et cela pourra être utile pour un autre projet.

7

Slt a tous,

Et pourquoi ne pas passer sur des piles au lithium style lipo 2S de grande capacité,

c'est plus chère et encore, mais cela se recharge vite et avec un grand nombre de cycle

et effectivement sur un baudrier il devrait trouver la place de coudre des poches , et mettant une lipo pour
l'arduino et des autres pour les led il n'auras plus de pb de chute de tension sur l'arduino
ou du moins bcp plus rapidement, et des que l'alimentation des led et faible cela se verra.

seb

8

Je vais opter pour une alimentation séparée pour les leds et une autre pour le nano.
Sur mes gantelets 4 piles AA alimentent le tout avec perfection mais sur le baudrier ça ne marche pas probablement a cause du trop grand nombre de leds.

gantelets.JPG
gantelets.JPG543×724 55.5 KB

9

Il est clair que le dégazage des potentielles bombes ambulantes que sont les accus utilisant du lithium peut-être très dangereux (brûlures corporelles graves et incendies). Il ne faut jamais que le - et le + rentrent en contact directement sinon c'est l'échauffement rapides en quelques seconde, puis grande chance de dégazage... Ils ne faut jamais les charger à plus de que la tension annoncée sinon même sanction.

Et pourtant c'est ce que fais ;), en sécurité normalement, comme d'autres j'imagine :

Le version que j'estime assez sécurisée :

juste avant je précise que se suis vapoteur et dans le monde de la vapote nous sommes nombreux à déjà manipuler des accus 18650 de chimie li-ion. C'est également ce genre d'accus que l'on place dans une "power bank" de ce type (attention, je ne conseille pas forcément ce modèle qui a le défaut de couper l'alim en pensant que rien n'est connecté tellement notre montage ne consomme presque rien).

Cette power bank élève la tension (les accus sont montés en parallèle) à environ 5V, sur son port USB (normal, elles sont-faites pour alimenter des périphériques USB). L'intensité max que la power bank peut délivrer est annoncée (1A, 2x1A, 2A, ...?). A prendre en compte évidemment.

En plaçant des accus supportant le courant demandé (voir leur caractéristiques de CDM (Courant de Décharge maximum)) dans ces power bank on obtient en fonction de la capacité des accus choisis des bonnes autonomies.

Attention : Il ne faut pas acheter ce genre d'accus n'importe ou sur internet, il y a des contrefaçons, potentiellement dangereuses puisque ne respectant pas les données importantes comme le courant de décharge maximum (CDM). Un site reconnu chez les vapoteurs est nkon.

Pourquoi c'est plus sécuritaire : on est protégé par l'électronique embarquée dans la power bank. Un court-circuit du montage ne mettra pas les accus en court circuit ou pas assez longtemps pour que le tout s'emballe (enfin c''est ce que je pense mais je n'ai pas fait le test personnellement).

Il y a une autre version, beaucoup moins sécuritaire d'utiliser ces accus, en n'utilisant pas de power bank. Et donc pas de bridage des ampères et/ou de la tension par la power bank. Là il vaut mieux utiliser des fusibles, bien se renseigner sur leur mise en série et surtout en parallèle car danger ! ) et serrer les fesses au moment de la mise sous tension :slight_smile:

Il y a sans doute d'autres solutions, je fais part de celle que j'utilise, pour un courant de décharge de 1A voir 2A, si vous pensez que cela reste risqué n'hésitez à le signaler.

Et ne perdez pas de vue les mises en gardes faites !

10

D'accord avec toi mais certaines applications nécessitent pour des raisons d'autonomie et/ou puissance l'utilisation d'accu au lithium. La solution proposée utilise des li-ion qui contrairement au LiPO sont munis d'une "carcasse" solide (risque mécaniques). L'utilisation d'une power bank qui n'est pas "noname" (et donc supposée bien conçue) couplée avec des accus provenant d'un fournisseur sérieux de CDM supérieur (et de loin) au courant fourni par la power bank limite quand même grandement les risques (on n'accède pas, en tant qu' "amateur", directement aux bornes des accus).

Une remarque au passage : chez les vapoteurs les accidents avec ces accus 18650 li-ion se produisent lors d'un transport dans une poche et qu'il y a contact entre le + et le - avec des clés et/ou pièce métallique ou bien lors d'un usage dans des cigarettes électroniques non pourvue d'électronique de protection. Des étuis de transport sont prévus contre ce genre de risque.

Pour info je viens de laisser 10 mn en court-circuit franc le + et le - en sortie USB de la power bank donnée en lien plus haut avec les accus donnés aussi plus haut (je répète qu'ils existe des contrefaçons et que donc tous mes produits sont de marques connues, et de vendeur connu). Je sais ce n'est pas malin mais bon il fallait vérifier. Et bien cela fait 10 mn qu'elle "crache" 2 ampères (loin des 30 A de courant de décharge continu possible avec 1 seul de ces accus) sans échauffement ni des accus, ni de la power bank ni du câble.

J'alimente une raspberry PI + caméra embarqué + WiFI pendant des heures avec ce système.

C'est possible après le risque zéro n'existe pas, c'est certain.

Je ne dis pas que c'est la seule ou la meilleure solution. C'est juste celle que j'utilise en connaissance de cause sans soucis depuis quelques temps (1 an) quand je fais de l'embarqué "amateur" (raspberry, robots, ...).

Je pense qu'il vaut mieux informer les lecteurs des dangers, des pièges et en essayant de proposer la moins pire des solutions que de les laisser faire leurs expériences seuls avec ce genre d'accus.

11

J'ai séparer les alimentations du nano et des leds

après tests :

il semblerait qu'il me faille faire un reset bouton sur le nano après l'avoir allumer pour tout marche correctement avec les piles.

si je poste le code pouvez vous m'aider ?

#include <Adafruit_NeoPixel.h>
#include <Wire.h>
//#include "Adafruit_MPR121.h"  //librairie pour le capacitif
#include <SPI.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

//#include "Adafruit_Soundboard.h"    //carte son
//#include <SoftwareSerial.h>         //pour la com avec la carte son si le serial hardware est deja prit

#define PIXEL_COUNT_1 16
#define PIXEL_COUNT_2 16
#define PIXEL_COUNT_3 16
#define PIXEL_COUNT_4 16

//---------------------------selecteur de couleur
int Green_selecteur = 255;
int Red_selecteur = 0;
int Blue_selecteur = 255;
//int White_selecteur = 0;
int Green_selecteur_pulse = 5;
int Red_selecteur_pulse = 0;
int Blue_selecteur_pulse = 5;
//int White_selecteur_pulse = 0;
//---------------------------selecteur de couleur

//---------------------------bouton de fonction sur le harnet------------------------
int bouton1 = 5; //definition du pin du bouton 1
int bouton2 = 6; //definition du pin du bouton 2
int bouton3 = 7; //definition du pin du bouton 3
int bouton4 = 9; //definition du pin du bouton 4
int val_bouton1 = 0; //variable de récupération des valeur des boutons 
int val_bouton2 = 0; //variable de récupération des valeur des boutons 
int val_bouton3 = 0; //variable de récupération des valeur des boutons 
int val_bouton4 = 0; //variable de récupération des valeur des boutons 
int analog_bouton1 = 0;
int analog_bouton2 = 0;
int analog_bouton3 = 0;
int analog_bouton4 = 0;

//---------------------------bouton de fonction sur le harnet------------------------

int var_continu = 0 ;        // Variable qui conditionne les boucles d'animation infinies
//int _ABVAR_2_BLEU = 0 ;
int _ABVAR_1_a=0;           // variable pour la fonction startShow_pulse

#define PINA 2 //pin de la bande de led A (pour la led interne du flora c'est le port 8)
#define PINB 3 //pin de la bande de led B
#define PINC 4 //pin de la bande de led C
#define PIND 5 //pin de la bande de led D
#define PINE 6 //pin de la bande de led E

int NPIXA = 1 ; // nombre de pixels de la stripA : cristal pectoral
int NPIXB = 15 ; // nombre de pixels de la stripB
int NPIXC = 12 ; // nombre de pixels de la stripC
int NPIXD = 15 ; // nombre de pixels de la stripD
int NPIXE = 12 ; // nombre de pixels de la stripE

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
Adafruit_NeoPixel stripA = Adafruit_NeoPixel(NPIXA, PINA, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripB = Adafruit_NeoPixel(NPIXB, PINB, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripC = Adafruit_NeoPixel(NPIXC, PINC, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripD = Adafruit_NeoPixel(NPIXD, PIND, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripE = Adafruit_NeoPixel(NPIXE, PINE, NEO_GRB + NEO_KHZ800);

//----------------DEBUT radio HF V.1---------------------------------
//ces modules radio ont besoin des pin 8,10,11,12 et 13 pour fonctionner (plus l'alimentation)
#include <RH_NRF24.h>
// Singleton instance of the radio driver
   RH_NRF24 nrf24;
// RH_NRF24 nrf24(8, 7);  // use this to be electrically compatible with Mirf
// RH_NRF24 nrf24(8, 10); // For Leonardo, need explicit SS pin
// RH_NRF24 nrf24(8, 7);  // For RFM73 on Anarduino Mini
//uint8_t code_radio1;      // déclare une variable pour stocker le code radio reçu.
uint8_t buf[RH_NRF24_MAX_MESSAGE_LEN];          // declare la variable "buf" en lui donnant la taille maximum
uint8_t len = sizeof(buf);

//----------------FIN radio HF V.1---------------------------------



void setup() {


  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  pinMode(A4, INPUT);

  //while (!Serial);        // needed to keep leonardo/micro from starting too fast!

  Serial.begin(9600);

  stripA.begin();
  stripA.show(); 
  stripB.begin();
  stripB.show();
  stripC.begin();
  stripC.show();
  stripD.begin();
  stripD.show();
  stripE.begin();
  stripE.show();
  

//--------------------DEBUT INITIATLISATION RADIO-----------------------------
  //while (!Serial) ; // wait for serial port to connect. Needed for Leonardo only
  if (!nrf24.init()) {Serial.println("init failed");}
  // Defaults after init are 2.402 GHz (channel 2), 2Mbps, 0dBm
  if (!nrf24.setChannel(1))  {Serial.println("setChannel failed");}
  if (!nrf24.setRF(RH_NRF24::DataRate2Mbps, RH_NRF24::TransmitPower0dBm)) {Serial.println("setRF failed");}
//--------------------FIN INITIATLISATION RADIO-------------------------------
  
}

void loop() {
12

yapa la loop ?

13

ca ne rentre pas sur un seul post.
Je posterais le reste demain.

14 
void loop() {
//--------------------------------------DEBUT INTERPRETATION BOUTONS----------------------------------------

val_bouton1 = digitalRead(A1); // lit le statu de la pin du bouton 1 et le stock dans val_bouton
val_bouton2 = digitalRead(A2); // lit le statu de la pin du bouton 1 et le stock dans val_bouton
val_bouton3 = digitalRead(A3); // lit le statu de la pin du bouton 1 et le stock dans val_bouton
val_bouton4 = digitalRead(A4); // lit le statu de la pin du bouton 1 et le stock dans val_bouton

//-----------------section de test des boutons------------------------

analog_bouton1 = analogRead(A1); //
analog_bouton2 = analogRead(A2); //
analog_bouton3 = analogRead(A3); //
analog_bouton4 = analogRead(A4); //

Serial.print("BOUTON 1 ");
Serial.println(analog_bouton1);
Serial.print("BOUTON 2 ");
Serial.println(analog_bouton2);
Serial.print("BOUTON 3 ");
Serial.println(analog_bouton3);
Serial.print("BOUTON 4 ");
Serial.println(analog_bouton4);

delay(500);

//-----------------section de test des boutons------------------------


if(analog_bouton1==0)
//if (val_bouton1 == HIGH)    //verifie la valeur de val_bouton1 pour agir en consequence
{
// mettre la fonction de led
  Serial.println("BOUTON 1 ACTIVER");
  emission_hf_variables_multiples(0);
  var_continu=0;
  for(int i=0; i<3; i=i+1)
  {rainbow_penta_strip(20);}
  delay(1000);
}

if(analog_bouton2==0)
//if (val_bouton2 == HIGH)    //verifie la valeur de val_bouton1 pour agir en consequence
{
// mettre la fonction de led
  Serial.println("BOUTON 2 ACTIVER");
  emission_hf_variables_multiples(16);
  var_continu=0;
  for(int i=0; i<10; i=i+1)
  {PULSE_SELECTIF_penta_strip(Red_selecteur_pulse, Green_selecteur_pulse, Blue_selecteur_pulse, 5, 10);};
  delay(1000);
  
}

if(analog_bouton3==0)
//if (val_bouton3 == HIGH)    //verifie la valeur de val_bouton1 pour agir en consequence
{
  // mettre la fonction de led
  Serial.println("BOUTON 3 ACTIVER");
  emission_hf_variables_multiples(16);
  var_continu=0;
  rainbowCycleSelectif_penta_strip(&stripA,&stripB,&stripC,&stripD,&stripE,20);
  colorWipeRapide2_penta_strip(stripA.Color(0, 0, 0),15,1000);
  delay(1000);
}

if(analog_bouton4==0)
//if (val_bouton4 == HIGH)    //verifie la valeur de val_bouton1 pour agir en consequence
{
// mettre la fonction de led
  Serial.println("BOUTON 4 ACTIVER");
  emission_hf_variables_multiples(17);
  var_continu=0;
  theaterChaseRainbow_penta_strip_accretion_v2(50);
  delay(1000);
}


//une fois les boutons interprété je remet lleur variable à LOW pour être sur que je puisse les réutiliser sans interferance ?
  val_bouton1 = LOW;
  val_bouton2 = LOW;
  val_bouton3 = LOW;
  val_bouton4 = LOW;

//--------------------------------------FIN INTERPRETATION BOUTONS------------------------------------------

//---------------------------------------DEBUT interprétation du code radio   
  if (nrf24.available())            // attendre qu'un message revienne
  { 
    if (nrf24.recv(buf, &len))                    // teste si un message est arrivé
    {
     
     //---------------------------------interprétation du code radio reçu---------------------------
     if (strcmp((char*)buf,"A")==0){Serial.println(F(" message conforme à A "));emission_hf_variables_multiples(0);  ;rainbow_penta_strip(20);}
     if (strcmp((char*)buf,"B")==0){Serial.println(F(" message conforme à B "));emission_hf_variables_multiples(1);  ;colorWipeRapide2_penta_strip((Red_selecteur, Green_selecteur, Blue_selecteur),stripB.numPixels(), 500); } //  colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(0, 0, 0, 0), 1);
     if (strcmp((char*)buf,"C")==0){Serial.println(F(" message conforme à C "));emission_hf_variables_multiples(2);  ;colorWipe_penta_strip_HAUT_BAS((Red_selecteur, Green_selecteur, Blue_selecteur),stripB.numPixels(), 100); }
     if (strcmp((char*)buf,"D")==0){Serial.println(F(" message conforme à D "));emission_hf_variables_multiples(3);  ;colorWipe_penta_strip_BAS_HAUT((Red_selecteur, Green_selecteur, Blue_selecteur),stripB.numPixels(), 100); }
     if (strcmp((char*)buf,"E")==0){Serial.println(F(" message conforme à E "));emission_hf_variables_multiples(4);  ;PULSE_SELECTIF_penta_strip(Red_selecteur_pulse, Green_selecteur_pulse, Blue_selecteur_pulse, 5, 30);}
     if (strcmp((char*)buf,"F")==0){Serial.println(F(" message conforme à F "));emission_hf_variables_multiples(5);  ;PULSE_SELECTIF_penta_strip(Red_selecteur_pulse, Green_selecteur_pulse, Blue_selecteur_pulse, 5, 30);}
     if (strcmp((char*)buf,"G")==0){Serial.println(F(" message conforme à G "));emission_hf_variables_multiples(6);  selecteur_couleur(0);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"H")==0){Serial.println(F(" message conforme à H "));emission_hf_variables_multiples(7);  selecteur_couleur(1);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"I")==0){Serial.println(F(" message conforme à I "));emission_hf_variables_multiples(8);  selecteur_couleur(2);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"J")==0){Serial.println(F(" message conforme à J "));emission_hf_variables_multiples(9);  selecteur_couleur(3);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"K")==0){Serial.println(F(" message conforme à K "));emission_hf_variables_multiples(10); selecteur_couleur(4);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"L")==0){Serial.println(F(" message conforme à L "));emission_hf_variables_multiples(11); selecteur_couleur(5);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"M")==0){Serial.println(F(" message conforme à M "));emission_hf_variables_multiples(12); selecteur_couleur(6);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"N")==0){Serial.println(F(" message conforme à N "));emission_hf_variables_multiples(13); selecteur_couleur(7);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     if (strcmp((char*)buf,"O")==0){Serial.println(F(" message conforme à O "));emission_hf_variables_multiples(14); selecteur_couleur(8);colorWipeSection_3pixels_HB(&stripA,&stripB,&stripC,&stripD,&stripE,stripA.Color(Red_selecteur, Green_selecteur, Blue_selecteur, 0), 20);var_continu=0;}
     
     
     if (strcmp((char*)buf,"W")==0){/*Serial.println(F(" message conforme à W "))*/; if (var_continu==0){var_continu=1;rainbow_penta_strip(20);}}
     if (strcmp((char*)buf,"X")==0){/*Serial.println(F(" message conforme à X "))*/; if (var_continu==0){var_continu=2;PULSE_SELECTIF_penta_strip(0,5,5, 5, 30);}}
     if (strcmp((char*)buf,"Y")==0){/*Serial.println(F(" message conforme à Y "))*/; if (var_continu==0){var_continu=3;PULSE_SELECTIF_penta_strip(5,0,5, 5, 30);}}
    
    }
  }
//----------------------------------FIN captation d'instruction radio ------------------------------


 //------INTERPRETATION DES BOUCLES INFINIES D'ANIMATION LED------- 
  if(var_continu!=0)
  {
    if (var_continu==1)
    { rainbow_penta_strip(20);    }
  
    if (var_continu==2)
    {       PULSE_SELECTIF_penta_strip(0,5,5, 5, 30);     }
  
    if (var_continu==3)
    {     PULSE_SELECTIF_penta_strip(5,0,5, 5, 30);     }
  }
 //------fin INTERPRETATION DES BOUCLES INFINIES D'ANIMATION LED-------
 
   delay(500);
}  //fin du void loop principal
15

Tu définis :

int bouton1 = 5; //definition du pin du bouton 1
int bouton2 = 6; //definition du pin du bouton 2
int bouton3 = 7; //definition du pin du bouton 3
int bouton4 = 9; //definition du pin du bouton 4

mais ensuite, les pinmodes sont différents :

  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  pinMode(A4, INPUT);

C'est incohérent. Un bouton n'a pas besoin d'une entrée analogique. Il faut que tu lises un peu de doc sur les boutons poussoirs. Si tu les déclares en INPUT_PULLUP (voir le lien), ça te donnera :

pinMode(bouton1 ,INPUT_PULLUP);
pinMode(bouton2 ,INPUT_PULLUP);
pinMode(bouton3 ,INPUT_PULLUP);
pinMode(bouton4 ,INPUT_PULLUP);

et la lecture se fera en déclarant dans l'entête :

boolean etatBouton1;
boolean etatBouton2;
boolean etatBouton3;
boolean etatBouton4;

et
etatBouton1=digitalRead(pinBouton1);sachant que etatBouton1 vaudra LOW quand le bouton est appuyé et HIGH sinon.

Donc cette partie :

  //--------------------------------------DEBUT INTERPRETATION BOUTONS----------------------------------------

  val_bouton1 = digitalRead(A1); // lit le statu de la pin du bouton 1 et le stock dans val_bouton
  val_bouton2 = digitalRead(A2); // lit le statu de la pin du bouton 1 et le stock dans val_bouton
  val_bouton3 = digitalRead(A3); // lit le statu de la pin du bouton 1 et le stock dans val_bouton
  val_bouton4 = digitalRead(A4); // lit le statu de la pin du bouton 1 et le stock dans val_bouton

  //-----------------section de test des boutons------------------------

  analog_bouton1 = analogRead(A1); //
  analog_bouton2 = analogRead(A2); //
  analog_bouton3 = analogRead(A3); //
  analog_bouton4 = analogRead(A4); //

  Serial.print("BOUTON 1 ");
  Serial.println(analog_bouton1);
  Serial.print("BOUTON 2 ");
  Serial.println(analog_bouton2);
  Serial.print("BOUTON 3 ");
  Serial.println(analog_bouton3);
  Serial.print("BOUTON 4 ");
  Serial.println(analog_bouton4);

est à changer par (plus simple) :

  etatBouton1=digitalRead(pinBouton1);
  etatBouton2=digitalRead(pinBouton2);
  etatBouton3=digitalRead(pinBouton3);
  etatBouton4=digitalRead(pinBouton4);

  Serial.print("BOUTON 1 ");
  Serial.println(etatBouton1);
  Serial.print("BOUTON 2 ");
  Serial.println(etatBouton2);
  Serial.print("BOUTON 3 ");
  Serial.println(etatBouton3);
  Serial.print("BOUTON 4 ");
  Serial.println(etatBouton4);

Tu modifies ensuite les tests selon l'état du bouton (LOW = enfoncé).

Cette partie ne sert à rien à mon avis :

  //une fois les boutons interprété je remet lleur variable à LOW pour être sur que je puisse les réutiliser sans interferance ?
  val_bouton1 = LOW;
  val_bouton2 = LOW;
  val_bouton3 = LOW;
  val_bouton4 = LOW;

ainsi que les déclarations :

int val_bouton1 = 0; //variable de récupération des valeur des boutons
int val_bouton2 = 0; //variable de récupération des valeur des boutons
int val_bouton3 = 0; //variable de récupération des valeur des boutons
int val_bouton4 = 0; //variable de récupération des valeur des boutons
int analog_bouton1 = 0;
int analog_bouton2 = 0;
int analog_bouton3 = 0;
int analog_bouton4 = 0;

remplacées par les boolean plus haut.

16

Merci pour ces conseils d'optimisation. Je testerais ça demain.

Par contre ça me dis pas pourquoi le nano a besoin d'un reset pour fonctionner correctement.
Le premier afflux d'énergie à l'allumage le perturberait ?

A pluche

17

Je n'avais pas compris la question, je croyais que tu voulais ajouter un bouton reset pour ton appli...

Ben, je sais pas : probablement un problème de piles ou batteries pas assez puissantes.

18

Non il y a besoin d'appuyer sur le bouton reset du Nano pour qu'il exécute son programme correctement.
Au premier allumage il pédale dans la semoule. Que ce soit avec 6v ou 9v.
D'où mon incompréhension.

19

C'est à dire que lorsqu'on utilise 2 alimentations distinctes il y a toujours un sous-ensemble qui démarre avant l'autre et cela peut conduire à des problèmes d'initialisation.
Ce que tu pourrais faire c'est:

  • envoyer vers l'arduino une image de l'alimentation des LEDs (avec un pont diviseur, un opto-coupleur, ...)
  • toujours démarrer l'arduino avant les LEDs
  • bloquer dès l'entrée dans setup() dans un test où tu attends de voir l'alimentation établie sur les LEDs, plus une petite temporisation pour faire bonne mesure
  • terminer l'initialisation et dérouler le programme
20

Merci de l'info, je vais ajouter une temporisation.