IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Eclairage pour vélomobile


Sujet :

Arduino

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2007
    Messages
    4
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2007
    Messages : 4
    Par défaut Eclairage pour vélomobile
    Bonjour à tous,

    Je suis novice en programmation Arduino et je me suis lancé dans un "gros" projet d'éclairage pour vélomobile. J'écris gros entre guillemets car je pense bien que pour certains ça ne sera pas grand chose mais pour moi c'est déjà énorme

    Je suis donc possesseur d'un vélomobile. Pour ceux qui ne connaissent pas, c'est un vélo couché caréné permettant d'une part d'être à l'abri des intempéries et d'autre part de gagner en vitesse par rapport à un vélo droit classique. Quelques infos sur le site de l'association si les modos tolèrent (ce n'est pas de la pub) : http://www.velomobile-france.com
    Si le vélomobile a ces avantages là par rapport au vélo droit, il a aussi 2 sérieux inconvénients : il n'est pas très visible car très bas et il est difficile de sortir le bras pour indiquer le changement de direction , de plus le système d'éclairage de série est constitué de tout ce qu'il y a de plus basique : des interrupteurs, une lampe à LED avant, une lampe de vélo classique à l'arrière et un module clignotant de moto associé à de simples LED 5mm en guise d'indicateurs de direction.

    J'ai donc pu constater aisément que :
    - l'éclairage de "puissance" n'est pas assez performant pour rouler à 50km/h de nuit ;
    - l'éclairage arrière est suffisant mais on pense suivre un simple vélo et le freinage n'est pas signalé ;
    - les indicateurs de directions font leur "taf" l'hiver (et encore) mais pas en pleine journée d'été

    J'ai donc entrepris de refaire la totalité de la partie électrique concernant l'éclairage pour passer à :
    - 2 lampe à LED en guise de feux de croisement,
    - 2 lampes à LED de 10w en guise de feux de route,
    - 1 rampe de LED horizontales adressable (5v) pour l'avant et l'arrière (clignos + feux diurnes),
    - 2 x 2 rampes de LED (12v) verticales à l'arrière pour feux cligno en diurne, fixes en nocturne + freins
    - 2 commodo de moto pour piloter le tout sans avoir à quitter les commandes de direction.

    et en option à venir :
    - la possibilité de brancher un mât équipé de LED clignotantes à l'aide d'un connecteur étanche 4 broches,
    - la possibilité d'ajouter un déport de clignotants (avec le mât en nocturne) pour augmenter la visibilité et attirer l'attention des automobilistes.

    Le VM est initialement équipé d'une assistance électrique mais la batterie était HS, je roulais donc sans assistance. Compte tenu que j'envisageais de refaire l'électricité, j'ai décidé de piloter aussi cette assistance et d'en profiter un peu puisque je ne suis plus tout jeune . J'ai donc investi également dans :
    - 1 batterie 36v 20Ah,
    - 1 relais à transistor pour la mise en route de l'assistance uniquement si nécessaire
    - 2 régulateurs d'alimentation pour passer de 36vdc à 12vdc et 5vdc.

    Je me suis donc lancé dans un projet de programmation sur la base d'un Arduino en commençant par me faire un peu la main pendant 1 an avec un kit Elegoo R3 Starter, entre plein d'autres choses à faire.
    Et voilà ce que donnent les différents modes de fonctionnement sur platine de test :

    - 1 mode jour + clignos et feux de détresse
    - 1 mode feux diurnes clignotants + clignos et feux de détresse
    - 1 mode nuit codes/phares + clignos et feux de détresse

    Après cette présentation du projet, entrons dans le vif du sujet.
    Voici le code que j'ai généré pour permettre le fonctionnement de l'éclairage que l'on aperçoit dans la vidéo du message précédent.
    S'ajoute le fonctionnement de l'allumage des rubans de LED lorsque je freine et mon problème majeur concernant ce fonctionnement. Lorsque je relâche les freins, les LEDs restent en mode FREIN_ON . Mes boucles while ne s'arrêtent pas !

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    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
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    //----------
    //Librairies
    //----------
    #include <Adafruit_NeoPixel.h>
    #include <FastLED.h>
     
    //Broches d'entrées
    const byte EclairageJour = 7; //broche 7 en entrée Feux de jour de "INTER 3 POS G2-3(jaune)" (constante sur 8 bits (base de calcul minimale de l'arduino)
    const byte EclairageMat = 5; // broche 5 en entrée éclairage du mât + reports latéraux de "INTER MAT"
    const byte ClignoDroit = 2; // broche 2 en entrée pour le cligno droit de "INTER 3 POS D2-1(vert/blanc)"
    const byte ClignoGauche = 3; // broche 3 en entrée pour le cligno gauche de "INTER 3 POS D2-3(vert/noir)"
    const byte Frein = 4; // broche 4 en entrée pour les freins (G && D)
    //const byte CdeEcran = 8; // broche 8 en entrée pour la commande de l'affichage de l'écran de "BP G1-3(vert/jaune)"
    const byte EclairageNuit = 6; // broche 6 en entrée pour la commande du feu fixe de nuit à l'arrière de "INTER 3 POS G2-1(rouge/jaune)"
     
    //Initialisation des variables d'entrée
    char EtatFeuxJour = HIGH; //INTER 3 POS G2-3 à 5v
    char EtatFeuxMat = HIGH; //INTER MAT à 5v
    char EtatClignoDroit = LOW; //INTER 3 POS D2-1 à 0v
    char EtatClignoGauche = LOW; //INTER 3 POS D2-3 à 0v
    char EtatFrein = LOW; //INTER FREINS à 0v
    char EtatFeuxNuit = HIGH; //INTER 3 POS G2-1 à 5v
    int i;
     
    //Broches de sorties
    #define Led_ar_Haut 10 // broche 10 en sortie (PWM sur Tor) éclairage leds rouges cligno arrière
    #define Led_mat 9 // broche 9 en sortie (PWM sur Tor) éclairage mât et reports latéraux
    #define Led_av_adr  12 //broche 12 bandeau avant clignotants
    #define Led_ar_adr  13 //broche 13 bandeau arrière clignotants
    #define Led_ar_Bas  11 // borche 11 en sortie (PWM sur Tor) leds rouges arrière fixe + frein
    // L'éclairage de puissance avant est géré directement par les interrupteurs et les relais 12v
     
    //Détermination du partage des bandeaux de leds adressables avant et arrière pour les feux de direction et les feux de jour.
    #define Num_leds  144 //définition du nombre de led sur chaque bandeau adressable
    byte debut = 0; //Led 1 du bandeau
    byte droite = 47; //Led 48 du bandeau, limite feu droit
    byte milieu = 72; //Led milieu de bandeau, départ feu de jour
    byte gauche = 96; //Led 97 du bandeau, limite feu gauche
    byte fin = 143; //Led 144 du bandeau 
     
    //Variables de gestion des leds adressables (indicateurs de direction et feux de jour)
    CRGB AV_leds[Num_leds];
    CRGB AR_leds[Num_leds];
     
     
    /*------------------------------------------------------------------------
    //Fonction d'initialisation de la carte contenant le code d'initialisation,
    //n'est éxécutée qu'une seule fois au démarrage de la carte.
    //Identification des I/O et autres réglages.
    ------------------------------------------------------------------------*/
     
    void setup() {
    //Initialisation des variables en entrée
      pinMode(EclairageJour, INPUT);
      pinMode(EclairageMat, INPUT);
      pinMode(ClignoGauche, INPUT);
      pinMode(ClignoDroit, INPUT);
      pinMode(Frein, INPUT);
      pinMode(EclairageNuit, INPUT);
    //Initialisation des variables en sortie
      pinMode(Led_mat, OUTPUT);
      pinMode(Led_ar_Haut, OUTPUT);
      pinMode(Led_ar_Bas, OUTPUT);
      pinMode(Led_av_adr, OUTPUT);
      pinMode(Led_ar_adr, OUTPUT);
    //renseignement des librairies avec le type de LED, les paramètres d'entrée LED_PIN et NUM_LED
      FastLED.addLeds<WS2812B, Led_av_adr, GRB>(AV_leds, Num_leds); //bandeau avant
      FastLED.addLeds<WS2812B, Led_ar_adr, GRB>(AR_leds, Num_leds); //bandeau arrière
    }
     
    //Fonction allumage des clignotants gauches
    void ClignotantGauche (){
      for (i = 0; i <= 47; i++){
        AV_leds[fin-i] = CRGB (255,115,0); //Allumage des leds avant en orange
        AR_leds[gauche+i] = CRGB (255,115,0); //Allumage des leds arrières en orange
        FastLED.show();
        delay(0);
      }
      for (i = 0; i <= 47; i++){
        AV_leds[fin-i] = CRGB (0,0,0); //Extinction des leds avant
        AR_leds[gauche+i] = CRGB (0,0,0); //Extinction des leds arrière
        FastLED.show();
        delay(0);
      }
    }
     
    //Fonction allumage des clignotants droits
    void ClignotantDroit() {
      for (i = 0; i <= 47; i++) {
        AV_leds[debut+i] = CRGB (255,115,0); //Allumage des leds avant en orange
        AR_leds[droite-i] = CRGB (255,115,0); //Allumage des leds arrière en orange
        FastLED.show();
        delay(0);
      }
      for (i = 0; i <= 47; i++) {
        AV_leds[debut+i] = CRGB (0,0,0); //Extinction des leds avant
        AR_leds[droite-i] = CRGB (0,0,0); //Extinction des leds arrière
        FastLED.show();
        delay(0);
      }
    }
     
    //Fonction allumage des feux de détresse
    void FeuxDetresse() {
      for(i = 0 ; i <= 47; i++){
        AV_leds[fin-i] = CRGB (255,115,0); //Allumage des leds avant gauche en orange
        AR_leds[gauche+i] = CRGB (255,115,0); //Allumage des leds arrière gauche en orange
        AV_leds[debut+i] = CRGB (255,115,0); //Allumage des leds avant droite en orange
        AR_leds[droite-i] = CRGB (255,115,0); //Allumage des leds arrière droite en orange
        FastLED.show();
        delay(0);
      }
      for(i = 0 ; i <= 47; i++){
        AV_leds[fin-i] = CRGB (0,0,0); //Extinction des leds
        AR_leds[gauche+i] = CRGB (0,0,0);
        AV_leds[debut+i] = CRGB (0,0,0);
        AR_leds[droite-i] = CRGB (0,0,0);
        FastLED.show();
        delay(0);
      }
    }
     
    //Fonction allumage des feux de jour avant sur adr
    void FeuxJourAvantCligno() {
      FastLED.setBrightness(32);
      for(i = 0 ; i <= 24; i++){
        AV_leds[milieu+i] = CRGB (255, 255, 255); //Allumage des leds avant en blanc du milieu vers la gauche
        AV_leds[milieu-i] = CRGB (255, 255, 255); //Allumage des leds avant en blanc du milieu vers la droite
        FastLED.show();
      }
      for(i = 0 ; i <= 24; i++){
        AV_leds[milieu+i] = CRGB (0, 0, 0); //Extinction des leds
        AV_leds[milieu-i] = CRGB (0, 0, 0);
        FastLED.show();
      }
    }
     
    /*/Fonction allumage des feux de jour arrière sur adr
    void FeuxJourArriereCligno(){ 
      FastLED.setBrightness(32);
      for(i = 0 ; i <= 24; i++){
        AR_leds[milieu+i] = CRGB (255, 0, 0); //Allumage des leds arrière en rouge du milieu vers la gauche
        AR_leds[milieu-i] = CRGB (255, 0, 0); //Allumage des leds arrière en rouge du milieu vers la droite
        FastLED.show();
      }
      for(i = 0 ; i <= 24; i++){
        AR_leds[milieu+i] = CRGB (0, 0, 0); //Extinction des leds
        AR_leds[milieu-i] = CRGB (0, 0, 0);
        FastLED.show();
      }
    }
    */
    //Fonction allumage fixe des feux de jour avant adr et arrière adr lors de l'utilisation des indicateurs de direction
    void FeuxJourFixe() {
      FastLED.setBrightness(32);
        for(i = 0 ; i <= 24; i++){
          AV_leds[milieu+i] = CRGB (255, 255, 255); //Allumage fixe des leds avant en blanc
          AV_leds[milieu-i] = CRGB (255, 255, 255); //Allumage fixe des leds avant en blanc
          AR_leds[milieu+i] = CRGB (255, 0, 0); //Allumage fixe des leds arrière en rouge
          AR_leds[milieu-i] = CRGB (255, 0, 0); //Allumage fixe des leds arrière en rouge
          FastLED.show();
      }
    }
     
    //Fonction allumage feux rouge arrière clignotant de jour
    void Feuxjour12Vcligno(){
      analogWrite(Led_ar_Bas, 128); //Allumage des leds rouges arrières clignotantes à 50% de puissance
      analogWrite(Led_ar_Haut, 128);
      delay(250);
      analogWrite(Led_ar_Bas, 0); //Extinction des leds rouges arrières clignotantes
      analogWrite(Led_ar_Haut, 0);
      delay(250);
    }
     
    //Fonction allumage feux stop
    void FeuxStopON(){
        analogWrite(Led_ar_Haut, 255); //Allumage des leds rouges arrières hautes à 100% de puissance
        analogWrite(Led_ar_Bas, 255); //Allumage des leds rouges arrières basses à 100% de puissance
    }
     
    void FeuxStopOFF(){
    //    digitalWrite(Led_ar_Haut, LOW); //Extinction des leds rouges arrières hautes
    //    digitalWrite(Led_ar_Bas, LOW); //Extinction des leds rouges arrières basses
        analogWrite(Led_ar_Haut, 0); //Extinction des leds rouges arrières hautes
        analogWrite(Led_ar_Bas, 0); //Extinction des leds rouges arrières basses
    }
     
    //Fonction allumage feux de nuit
    void FeuxNuitON(){
    //    digitalWrite(Led_ar_Haut, HIGH); //Extinction des leds rouges arrières hautes
    //    digitalWrite(Led_ar_Bas, HIGH); //Extinction des leds rouges arrières basses
     
        analogWrite(Led_ar_Haut, 255); //Allumage des leds rouges arrières fixes à 50% de puissance
        analogWrite(Led_ar_Bas, 255); //Allumage des leds rouges arrières cligno à 50% de puissance
    }
     
    //Fonction allumage du mat et des reports latéraux
    void FeuxMatON(){
      analogWrite(Led_mat, 255); //Allumage des leds à 75% de puissance (couleur définie par tansistors)
      delay(250);
      analogWrite(Led_mat, 0); //Extinction des leds
      delay(250);
    }
     
    /*----------------------------------------------------------------
    //Fonction principale du code, elle se répète en boucle à l'infini.
    //Elle contient toutes les insctruction du programme.
    ----------------------------------------------------------------*/
     
     
    void loop() {
    //Lecture de l'état des entrées
    EtatFeuxJour = digitalRead(EclairageJour); //Inter Eclairage PIN 7
    EtatFeuxMat = digitalRead(EclairageMat); //Inter Eclairage PIN 5
    EtatClignoDroit = digitalRead(ClignoDroit); //Inter ClignoDroit PIN 2
    EtatClignoGauche = digitalRead(ClignoGauche); //Inter ClignoGauche PIN 3
    EtatFrein = digitalRead(Frein); //Inters Frein PIN 4
    EtatFeuxNuit = digitalRead(EclairageNuit); //Inter Eclairage Nuit PIN 6
     
     
    //Initialisation de l'état du bouton virtuel pour choix du programme à exécuter
    char EtatBouton = 10;
    //Attribution d'une valeur à EtatBouton en fonction de la lecture des entrées
     
    if (EtatFeuxJour == HIGH && EtatFeuxNuit == HIGH){ //Pas d'éclairage
      EtatBouton = 0;
    }
    else if (EtatFeuxJour == LOW && EtatFeuxNuit == HIGH){ //Eclairage de jour
      EtatBouton = 1;
    }
    else if (EtatFeuxJour == HIGH && EtatFeuxNuit == LOW){ //Eclairage de nuit
      EtatBouton = 2;
    }
     
    // Exécution des fonctions selon la valeur de EtatBouton
    switch (EtatBouton) {
     
    //Sans éclairage  
      case 0:
        if (EtatClignoDroit == HIGH && EtatClignoGauche == LOW && EtatFrein == LOW){ //Clignotant droit seul
          ClignotantDroit();
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == HIGH && EtatFrein == LOW){ //Clignotant gauche seul
          ClignotantGauche();
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH && EtatFrein == LOW){ //Feux de détresse seuls
          do {
          FeuxDetresse();
          }
          while (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH);
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == LOW && EtatFrein == HIGH){ //Freins seuls
          FeuxStopON();
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == LOW && EtatFrein == HIGH){ //Freins et cligno droit
    //      do {
          while (EtatFrein == HIGH) {
          ClignotantDroit();
          FeuxStopON();
          }
    //      while (EtatFrein == LOW);
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == HIGH && EtatFrein == HIGH){ //Freins et cligno gauche
    //      do {
          while (EtatFrein == HIGH) {
          ClignotantGauche();
          FeuxStopON();
          }
    //    while (EtatFrein == LOW);
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH && EtatFrein == HIGH){ //Freins et Feux détresse
    //      do {
          while (EtatFrein == HIGH) {
          ClignotantDroit();
          ClignotantGauche();
          FeuxStopON();
          }
    //    while (EtatFrein == LOW);
        }
    //    else if (EtatFrein == LOW){
    //    FeuxStopOFF();
    //    }
        if (EtatFeuxMat = LOW){
          FeuxMatON();
        }
      break;
     
    //Eclairage de jour  
      case 1:
        if (EtatClignoDroit == LOW && EtatClignoGauche == LOW && EtatFrein == LOW){ //Pas de Clignotants
          FeuxJourAvantCligno();
    //      FeuxJourArriereCligno();
          Feuxjour12Vcligno();
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == LOW && EtatFrein == LOW){ //Clignotant droit
          ClignotantDroit();
    //      FeuxJourFixe();
          Feuxjour12Vcligno();
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == HIGH && EtatFrein == LOW){ //Clignotant gauche 
          ClignotantGauche();
    //      FeuxJourFixe();
          Feuxjour12Vcligno();
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH && EtatFrein == LOW){ //Feux de détresse
    //      do {
          while (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH) {
          FeuxDetresse();
    //      FeuxJourFixe();
          Feuxjour12Vcligno();
          }
    //      while (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH);
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == LOW && EtatFrein == HIGH){ //Freins seuls 
    //      do {
          while (EtatFrein == HIGH) {
            FeuxJourFixe();
            FeuxStopON();
          }
    //      while (EtatFrein == LOW);
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == LOW && EtatFrein == HIGH){ //Freins et cligno droit
    //      do {
          while (EtatFrein == HIGH) {
            ClignotantDroit();
            FeuxJourFixe();
            FeuxStopON();
            }
    //      while (EtatFrein == LOW);
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == HIGH && EtatFrein == HIGH){ //Freins et cligno gauche
    //      do {
            while (EtatFrein == HIGH) {
            ClignotantGauche();
            FeuxJourFixe();
            FeuxStopON();
            }
    //      while (EtatFrein == LOW);
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH && EtatFrein == HIGH){ //Freins et feux de détresse
    //      do {
            while (EtatFrein == HIGH) {
            ClignotantDroit();
            ClignotantGauche();
            FeuxJourFixe();
            FeuxStopON();
            }
    //      while (EtatFrein == LOW);
        }
        else if (EtatFrein == LOW){
          Feuxjour12Vcligno();
          FeuxStopOFF();
        }
        if (EtatFeuxMat = LOW){
          FeuxMatON();
        }
      break;
     
    //Eclairage de nuit
      case 2:
        if (EtatClignoDroit == LOW && EtatClignoGauche == LOW && EtatFrein == LOW){ //Sans frein ni cligno
          FeuxNuitON();
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == LOW && EtatFrein == LOW){ //Clignotant droit
          ClignotantDroit();
          FeuxNuitON();
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == HIGH && EtatFrein == LOW){ //Clignotant gauche
          ClignotantGauche();
          FeuxNuitON();
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH && EtatFrein == LOW){ //Feux de détresse
    //      do {
          while (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH) {
            FeuxDetresse();
            FeuxNuitON();
            }
    //      while (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH);
        }
        else if (EtatClignoDroit == LOW && EtatClignoGauche == LOW && EtatFrein == HIGH){ //Freins seuls
    //      do {
          while (EtatFrein == HIGH){
            FeuxJourFixe();
            FeuxStopON();
            }
    //      while (EtatFrein == LOW);
        }
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == LOW && EtatFrein == HIGH){ //Freins et cligno droit
    //      do {
            while (EtatFrein == HIGH){
            ClignotantDroit();
            FeuxJourFixe();
            FeuxStopON();
            }
    //      while (EtatFrein == LOW);
        }        
        else if (EtatClignoDroit == LOW && EtatClignoGauche == HIGH && EtatFrein == HIGH){ //Freins et cligno gauche
    //      do {
            while (EtatFrein == HIGH){
            ClignotantGauche();
            FeuxJourFixe();
            FeuxStopON();
            }
    //      while (EtatFrein == LOW);
        }        
        else if (EtatClignoDroit == HIGH && EtatClignoGauche == HIGH && EtatFrein == HIGH){ //Freins et feux de détresse
    //      do {
            while (EtatFrein == HIGH){
            ClignotantDroit();
            ClignotantGauche();
            FeuxJourFixe();
            FeuxStopON();
            }
    //      while (EtatFrein == LOW);
        }
        else if (EtatFrein == LOW);
          FeuxStopOFF();
     
        if (EtatFeuxMat = LOW){
          FeuxMatON();
        }
       break;
      }
    }
    La configuration des entrées est en simple INPUT car j'ai forcé la mise à la masse ou au 5v (selon les entrées) avec une résistance.

    Je n'ai malheureusement pas d'oscilloscope donc toutes les mesures sont faites au multimètre, il me faut me pencher sur une version logicielle et trouver de quoi concevoir un connecteur de mesure via l'USB du PC.
    En attendant, voilà ce que j'ai relevé :
    Ecl Off (Case 0) Ecl jour (case 1) Ecl nuit (Case 2)
    D10 frein off 0v signal oscillant
    0v-2v
    1,35v
    D10 frein on 4,5v 4,5v 4,38v
    D11 frein off 0v signal oscillant
    0v-2v
    1,33v
    D11 frein on 4,5v 4,5v 4,38v
    Pour chaque cas ou le frein repasse de "ON" à "OFF" (l'entrée D4 passe bien de 5v à 0v), la tension sur D10 et D11 ne retombe pas à 0v !

    Je suis donc à la recherche d'un peu d'aide car je ne comprend pas pourquoi les sorties ne sont pas réinitialisées !

    Merci par avance de votre aide précieuse.

  2. #2
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 921
    Par défaut
    Le multimètre ne verra pas les variations rapides il vous donnera une valeur moyenne - votre arduino lui va voir toutes les oscillations.

    Un bon schéma électrique de vos branchements aiderait à comprendre ce que vous faites.

  3. #3
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2007
    Messages
    4
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2007
    Messages : 4
    Par défaut
    Bonjour,

    merci pour la réponse. Voici le schéma de câblage.

    2 petits écueils sur celui-ci (je dois le remettre à jour) :
    - D5 est au 5v via une résistance
    - Inter Mât n'est pas au 5v mais au GND

    Nom : Schéma_électronique_éclairage_VM.png
Affichages : 641
Taille : 121,1 Ko

  4. #4
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 921
    Par défaut
    La résistance de pulldown de 1kΩ du frein est elle bien connectée?

    essayez ce code là comme "oscilloscope" de base avec le montage tel qu'il est aujourd'hui
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    const byte pinFrein = 4;
     
    void setup() {
      pinMode(pinFrein, INPUT);
      Serial.begin(115200);
      Serial.println(F("Frein"));
    }
     
    void loop() {
      Serial.println(digitalRead(pinFrein));
    }
    ouvrez le traceur série à 115200 bauds et vérifiez que lorsque vous manipulez un des deux freins (ou les 2) vous avez bien des fronts montant et descendant qui s'affichent sur la courbe en temps réel.
    y-a-t-il des rebonds ? un petit condensateur pourrait servir à gommer le rebond si vous ne le traitez pas en logiciel.


    Sinon j'ai pu jeter un oeil au code, il est bourré de boucles infinies: vous ne pouvez pas faire au début de la loop un seul
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    EtatFrein = digitalRead(Frein); //Inters Frein PIN 4
    puis ensuite avoir partout des boucles qui ressemblent à cela:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    while (EtatFrein == HIGH) {
      ClignotantDroit();
      FeuxStopON();
    }
    dans lesquelles vous ne mettez pas à jour EtatFrein. Il faudrait au moins faire
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    while (EtatFrein == HIGH) {
      ClignotantDroit();
      FeuxStopON();
      EtatFrein = digitalRead(Frein); // mise à jour de l'état
    }

  5. #5
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 253
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 253
    Par défaut
    Bonjour,
    Dans le schéma il y a des choses qui ne vont pas :

    Nom : ellipse844.png
Affichages : 567
Taille : 139,5 Ko

    En 1, la grille du transistor se retrouve au potentiel 5.45V (on voit le pont diviseur formé par une résistance de 1.2kΩ d'un côté et une 1kΩ de l'autre, le tout alimenté par du 12V.) Pour qu'un N-MOSFET conduise il faut un VGS positif au moins égale à 4V selon la doc du IRF540N mais le VGS ici sera de 5V, qui est la tension de sortie du Arduino. Ca ne peut pas fonctionner tel que c'est dessiné là.

    En 2, la résistance de pulldown (j'ai noté que c'était un GND et non un +5V) est connecté du mauvais côté de Inter Mat ce qui laisse cette broche en l'air à certain moment.

    En 3, je ne sais pas expliquer la présence de cette diode ?

    Pour le reste, je ne peux pas dire car je vois que certains blocs fonctionnels ont été matérialisé par des composants mais j'imagine que tu ne pouvais faire autrement. Le problème est peut être du côté hardware.


    ps : IRF540N est un très mauvais transistor pour le Arduino, même si on le voit dans bien des tutos, sont VGSth est à peine compatible et toutes les specs du transistors sont données pour un VGS de 10V - ça veut dire qu'on ignore beaucoup de ses caractéristiques en dessous de 10V ce qui est sacrément embêtant. Par exemple pour commuter des courants forts, il va chauffer anormalement car pas piloter avec suffisamment de tension.

  6. #6
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2007
    Messages
    4
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2007
    Messages : 4
    Par défaut
    @ Jay M
    La résistance de pulldown de 1kΩ du frein est elle bien connectée?
    Oui.
    Merci beaucoup pour le code et l'astuce de lecture du traceur série. Je peux affirmer qu'il n'y a pas de rebond lorsque je freine ou que je relâche la/les poignées de frein.
    Je testerais dès que possible la mise à jour de l'état du frein dans chaque boucle pour voir si ça enlève le problème.

    @Vincent PETIT
    Merci pour les conseils concernant le MOSFET.
    Le point 1 n'est pour l'instant pas encore mis en œuvre car il correspond à l'alimentation du mât clignotant. Or je préfère résoudre mon problème de frein avant de passer à cette étape là.
    Je regarderais pour un autre modèle plus approprié puisque j'en utilise aussi sur le circuit de freinage

    En 2, je me suis mal exprimé dans le message avant le schéma . D7 est bien au 5v. D6 est au 5v également et c'est le haut de Inter Mât qui est au GND Je vais modifier le schéma

    En 3, la diode me permet de conserver allumées la lampe frontale faisant office de code lorsque je met les phares avec les 2 lampes supplémentaires situées au niveau des rétroviseurs. J'ai donc en code 1 lampe allumée et en phare 3 lampes.

  7. #7
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2007
    Messages
    4
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2007
    Messages : 4
    Par défaut
    Hello,

    Compte tenu que ce que vous m'avez proposé en modification ne fonctionnait pas, j'ai :
    - isolé l'arduino de la platine pour lever tous les doutes concernant l'électronique autour,
    - réduit mon programme à sa plus simple expression en ne testant que l'entrée 4 et les sorties 10 et 11
    - effectué mes tests sur platine avec des leds (D4 à la masse via R=20Kohm, mis au 5v manuellement ; D10 et D11 vers led en série avec R=100ohm).

    Mon programme ressemble donc finalement à ça et ça fonctionne comme souhaité, à savoir l'extinction des led lorsque D4 revient à la masse !
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    //----------
    //Librairies
    //----------
    #include <Adafruit_NeoPixel.h>
     
    //Broches d'entrées
    const byte Frein = 4; // broche 4 en entrée pour les freins (G && D)
     
    //Initialisation des variables d'entrée
    char EtatFrein = LOW; //INTER FREINS à 0v
     
    //Broches de sorties
    int Led_ar_Haut = 10; // broche 10 en sortie (PWM sur Tor) éclairage leds rouges cligno arrière
    int Led_ar_Bas = 11; // borche 11 en sortie (PWM sur Tor) leds rouges arrière fixe + frein
     
    void setup() {
    //Initialisation des variables en entrée
      pinMode(Frein, INPUT);
    //Initialisation des variables en sortie
      pinMode(Led_ar_Bas, OUTPUT);
      pinMode(Led_ar_Haut, OUTPUT);
    }
     
    //Fonction allumage feux stop
    void FeuxStopON(){
        analogWrite(Led_ar_Haut, 16); //Allumage des leds rouges arrières hautes
        analogWrite(Led_ar_Bas, 32); //Allumage des leds rouges arrières basses
    }
    void FeuxStopOFF(){
        analogWrite(Led_ar_Haut, 0); //Extinction des leds rouges arrières fixes
        analogWrite(Led_ar_Bas, 0); //Extinction des leds rouges arrières cligno
    }
     
    /*----------------------------------------------------------------
    //Fonction principale du code, elle se répète en boucle à l'infini.
    //Elle contient toutes les insctruction du programme.
    ----------------------------------------------------------------*/
     
    void loop() {
    //Lecture de l'état des entrées
    EtatFrein = digitalRead(Frein); //Inters Frein PIN 4
     
    if (EtatFrein == HIGH){ //Freins seuls
       while (EtatFrein == HIGH){
        FeuxStopON();
        EtatFrein = digitalRead(Frein);
       }
    }
    else if (EtatFrein == LOW){
      FeuxStopOFF();
    }
    }
    Je n'ai donc plus qu'à partir de là pour le faire évoluer progressivement en ajoutant les autres fonctionnalités.
    Merci pour vos conseils mais je pense repasser par là bientôt

  8. #8
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 921
    Par défaut
    Compte tenu que ce que vous m'avez proposé en modification ne fonctionnait pas,
    vos enchaînements de tests n'étaient sans doute pas corrects.

    C'est une bonne idée de simplifier le code pour tester votre montage et ensuite partir d'une base saine, mais... votre code tel qu'il est présente un souci: lorsque le frein est détecté votre loop() se trouve coincée dans une boucle d'attente de relâchement du frein.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    if (EtatFrein == HIGH){ //Freins seuls
       while (EtatFrein == HIGH){
        FeuxStopON();
        EtatFrein = digitalRead(Frein);
       }
    }
    Au passage pas la peine de rallumer les feux en permanence, si on veut prendre cette approche vous pouvez écrire
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    if (EtatFrein == HIGH){ //Freins seuls
      FeuxStopON(); // on allume 
      while ( digitalRead(Frein) == HIGH) {) // on ne fait rien, on attend le relâchement. ATTENTION on est bloqué là
      FeuxStopOFF(); // on éteint
    }
    Mais cela présente une inconvénient si vous voulez faire autre chose pendant le freinage. Par exemple déclencher le clignotant en même temps que vous freinez, le test ne sera pas fait.

    Pour éviter ce genre de blocage on travaille souvent avec ce qu'on appelle une "machine à état".

    Votre système de frein ne peut être que dans 2 états (actionnés (FREINAGE) ou pas (ROUE_LIBRE)) et on teste donc dans la loop() en fonction de l'état courant si un ordre de changement est donné (si les freins étaient actionnés, les a-t-on relâchés? par exemple) et si c'est le cas on exécute une action (allumer ou éteindre les LEDs) et on recommence.

    Voici à quoi pourrait ressembler votre code en prenant cette approche.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    //Broches d'entrées
    const byte pinFrein = 4; // broche 4 en entrée pour les freins (G && D)
     
    //Broches de sorties
    const byte pinLed_ar_Haut = 10; // broche 10 en sortie (PWM sur Tor) éclairage leds rouges cligno arrière
    const byte pinLed_ar_Bas = 11;  // broche 11 en sortie (PWM sur Tor) leds rouges arrière fixe + frein
     
    enum : byte {ROUE_LIBRE, FREINAGE} etatFrein = ROUE_LIBRE; // valeur par défaut
     
    //Fonction allumage feux stop
    void FeuxStopON() {
      analogWrite(pinLed_ar_Haut, 16); //Allumage des leds rouges arrières hautes
      analogWrite(pinLed_ar_Bas, 32); //Allumage des leds rouges arrières basses
      etatFrein = FREINAGE;
    }
     
    void FeuxStopOFF() {
      analogWrite(pinLed_ar_Haut, 0); //Extinction des leds rouges arrières fixes
      analogWrite(pinLed_ar_Bas, 0); //Extinction des leds rouges arrières cligno
      etatFrein = ROUE_LIBRE;
    }
     
    void gestionFreins()
    {
      switch (etatFrein) {
        case ROUE_LIBRE: // on est en roue libre, on teste si on freine
          if (digitalRead(pinFrein) == HIGH) FeuxStopON(); // on allume les feux et change d'état
          break;
        case FREINAGE:  // on est en freinage, on teste si on a relâché les freins
          if (digitalRead(pinFrein) == LOW) FeuxStopOFF(); // on éteint les feux et change d'état
          break;
      }
    }
     
    void setup() {
      pinMode(pinFrein, INPUT);
      pinMode(pinLed_ar_Bas, OUTPUT);
      pinMode(pinLed_ar_Haut, OUTPUT);
    }
     
    void loop() {
      gestionFreins();
    }
    la machine à état est dans la fonction gestionFreins() et l'état en cours maintenu dans la variable etatFrein

Discussions similaires

  1. Eclairage et son pour le modélisme
    Par magique13 dans le forum Arduino
    Réponses: 0
    Dernier message: 29/04/2020, 12h10
  2. Choix eclairage : conseil pour debutant
    Par SofEvans dans le forum OpenGL
    Réponses: 4
    Dernier message: 17/11/2009, 12h09
  3. Outils, cours et NOUVEAUX tutoriels pour Borland C++Builder
    Par hiko-seijuro dans le forum C++Builder
    Réponses: 10
    Dernier message: 12/03/2006, 22h33
  4. Tutoriels et liens pour le Borland Database Engine
    Par Community Management dans le forum Paradox
    Réponses: 0
    Dernier message: 25/03/2002, 10h23
  5. Réponses: 2
    Dernier message: 20/03/2002, 23h01

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo