Discussion :

[jojodu71]

Si vous aviez une vitesse de retour moins élevée la vitesse serait mieux respectée et vous ne verriez pas d'accélération.

j'ai essayé en mettant la vitesse de retour à 2000 et ça ne fonctionné plus du tout. je l'ai donc augmenter à 1 million est plus de problème

Voici une version avec un clignotement du bandeau lumineux pendant que le moteur avance / lorsqu'on marque des points

c'est bon ,ça fonctionne. Par contre, si ce n'est pas trop compliqué et que ce n'est abusé de votre gentillesse, je prefererais avoir comme sur la version d'origine :
Pour chaque point marqué, le défilement en blanc (type K2000) des rubans leds, ainsi que le défilement en blanc également des flèches (Type <<<) de droite à gauche
Pour le vainqueur : le scintillement en blanc des bandeaux led et de la matrice led (scintillement paramétrable en nombre de led et en vitesse pour régler un vrai effet de scintillement et non un clignotement)

merci pour tout
vous êtes formidable.

[Jay M]

c'est bon ,ça fonctionne. Par contre, si ce n'est pas trop compliqué et que ce n'est abusé de votre gentillesse, je prefererais avoir comme sur la version d'origine :
Pour chaque point marqué, le défilement en blanc (type K2000) des rubans leds, ainsi que le défilement en blanc également des flèches (Type <<<) de droite à gauche
Pour le vainqueur : le scintillement en blanc des bandeaux led et de la matrice led (scintillement paramétrable en nombre de led et en vitesse pour régler un vrai effet de scintillement et non un clignotement)

Vous avez une vidéo de votre effet ?

____

AccelStepper ne sait pas gérer une vitesse supérieure à 1000 en pratique donc je ne suis pas sûr de pourquoi 1 million marche et pas 2000 ?

[jojodu71]

Vous avez une vidéo de votre effet ?

voici des vidéos du défilement led et flèche ainsi que du scintillement
merci

[jojodu71]

Bonjour, voici les morceaux de code avec les paramétrages de défilement et le scintillement des bandeaux :

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
// ---- Paramètres configurables ----  
#define NUM_PISTES 4           // Nombre de pistes 
#define NUM_LEDS 28            // Nombre total de LEDs par ruban 
#define LEDsToScroll 5         // Nombre de LEDs à faire défiler 
#define SCROLL_SPEED 20        // Vitesse du défilement (en millisecondes) 
#define TWINKLE_DURATION 5000  // Durée du scintillement en millisecondes 
#define TWINKLE_INTERVAL 30    // Intervalle entre les scintillements 
#define NUM_TWINKLE_LEDS 8     // Nombre de LEDs à faire scintiller aléatoirement à la fois
 
// Méthode pour faire défiler les LEDs  
    void scrollLeds() {
        int position = 0; // Position actuelle des LEDs 
 
        // Défilement vers la droite 
        while (position < NUM_LEDS - LEDsToScroll) {
            strip1.clear();
            strip2.clear();
            for (int i = 0; i < LEDsToScroll; i++) {
                strip1.setPixelColor(position + i, strip1.Color(255, 255, 255)); // Couleur blanche 
                strip2.setPixelColor(position + i, strip2.Color(255, 255, 255)); // Couleur blanche 
            }
            strip1.show();
            strip2.show();
            delay(SCROLL_SPEED);
            position++;
        }
 
        // Défilement vers la gauche 
        while (position > 0) {
            strip1.clear();
            strip2.clear();
            for (int i = 0; i < LEDsToScroll; i++) {
                strip1.setPixelColor(position + i - 1, strip1.Color(255, 255, 255)); // Couleur blanche 
                strip2.setPixelColor(position + i - 1, strip2.Color(255, 255, 255)); // Couleur blanche 
            }
            strip1.show();
            strip2.show();
            delay(SCROLL_SPEED);
            position--;
        }
 
        // Revenir à la couleur de fond après le défilement 
        setAllColor(backgroundColor); // Revenir à la couleur de fond 
    }
 
    // Méthode pour démarrer le scintillement  
    void startTwinkling() {
        strip1.clear();
        strip2.clear();
        unsigned long startTime = millis(); // Heure de début du scintillement 
 
        // Pendant la durée du scintillement, faire scintiller les LEDs 
        while (millis() - startTime < TWINKLE_DURATION) {
            randomTwinkle();
            delay(TWINKLE_INTERVAL);
        }
 
        setAllColor(backgroundColor); // Revenir à la couleur de fond 
        isTwinkling = false; // Réinitialiser l'indicateur après le scintillement 
    }
 
    // Méthode pour faire scintiller plusieurs LEDs de manière aléatoire  
    void randomTwinkle() {
        strip1.clear();
        strip2.clear();
        for (int i = 0; i < NUM_TWINKLE_LEDS; i++) {
            int ledIndex = random(NUM_LEDS); // Choisir un index de LED aléatoire 
            strip1.setPixelColor(ledIndex, strip1.Color(255, 255, 255)); // Blanc 
            strip2.setPixelColor(ledIndex, strip2.Color(255, 255, 255)); // Blanc 
        }
        strip1.show();
        strip2.show();
        delay(random(10, 50)); // Attendre un court instant avant d'éteindre les LEDs scintillantes 
 
        // Éteindre les LEDs scintillantes 
        for (int i = 0; i < NUM_TWINKLE_LEDS; i++) {
            int ledIndex = random(NUM_LEDS); // Choisir un index de LED aléatoire 
            strip1.setPixelColor(ledIndex, 0); // Éteindre la LED 
            strip2.setPixelColor(ledIndex, 0); // Éteindre la LED 
        }
        strip1.show();
        strip2.show();
    }
};

[jojodu71]

Idem pour le défilement de la flèche et le scintillement de la matrice :

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
// ============================
// DÉFINITION DE LA FLÈCHE  
// ============================
const uint8_t arrowShape[MATRIX_HEIGHT][MATRIX_WIDTH] = {
    {0, 0, 0, 0, 0, 0, 1, 1}, // Ligne 1  
    {0, 0, 0, 0, 0, 1, 1, 1}, // Ligne 2  
    {0, 0, 0, 0, 1, 1, 1, 0}, // Ligne 3  
    {0, 0, 0, 1, 1, 1, 0, 0}, // Ligne 4  
    {0, 0, 0, 1, 1, 1, 0, 0}, // Ligne 5  
    {0, 0, 0, 0, 1, 1, 1, 0}, // Ligne 6  
    {0, 0, 0, 0, 0, 1, 1, 1}, // Ligne 7  
    {0, 0, 0, 0, 0, 0, 1, 1}  // Ligne 8  
};
 
// ============================
// PARAMÈTRES MODIFIABLES  
// ============================
unsigned long scrollDelay = 50; // Délai entre chaque position de la flèche  
int repeatCount = 3;              // Nombre de répétitions du défilement  
bool displayNumberAfterScroll = true; // Afficher le numéro après le défilement  
unsigned long blinkDuration = 5000; // Durée de scintillement en millisecondes  
unsigned long blinkSpeed = 20; // Vitesse du scintillement (intervalle entre les LED) en millisecondes  
int ledCount = 8; // Nombre de LEDs à faire scintiller simultanément  
int brightness = 200; // Luminosité par défaut pour toutes les matrices
 
 
// Fonction pour faire défiler une flèche de droite à gauche  
void scrollArrow(int matrixIndex) {
    for (int arrowPosition = MATRIX_WIDTH; arrowPosition >= -(MATRIX_WIDTH); arrowPosition--) {
        matrices[matrixIndex].clear(); // Nettoie la matrice
 
        // Dessine la flèche à la position actuelle  
        for (int y = 0; y < MATRIX_HEIGHT; y++) {
            for (int x = 0; x < MATRIX_WIDTH; x++) {
                if (arrowShape[y][x] == 1) { // Vérifie si le pixel de la flèche est allumé  
                    // Calculer la position du pixel en inversant X  
                    int pixelX = MATRIX_WIDTH - 1 - (arrowPosition + x); // Inverser X
 
                    // Dessiner la flèche uniquement si elle est dans les limites  
                    if (pixelX >= 0 && pixelX < MATRIX_WIDTH) {
                        setPixel(matrixIndex, pixelX, y, matrices[matrixIndex].Color(255, 255, 255)); // Flèche blanche  
                    }
                }
            }
        }
 
        matrices[matrixIndex].show(); // Affiche l'effet  
        delay(scrollDelay); // Délai entre chaque position de défilement  
    }
}
 
// Fonction pour faire scintiller un nombre spécifié de LEDs aléatoires  
void blinkMatrix(int matrixIndex) {
    static unsigned long lastBlinkTime[NUM_MATRICES] = {0, 0, 0, 0}; // Dernier temps de scintillement pour chaque matrice  
    if (millis() - lastBlinkTime[matrixIndex] >= blinkSpeed) { // Scintillement à la vitesse spécifiée  
        lastBlinkTime[matrixIndex] = millis(); // Met à jour le temps du dernier scintillement
 
        // Allumer un nombre spécifié de LEDs (jusqu'à ledCount) en blanc  
        matrices[matrixIndex].clear();
        for (int i = 0; i < ledCount; i++) {
            int randomLED = random(MATRIX_WIDTH * MATRIX_HEIGHT);
            matrices[matrixIndex].drawPixel(randomLED % MATRIX_WIDTH, randomLED / MATRIX_WIDTH, matrices[matrixIndex].Color(255, 255, 255)); // Allume une LED en blanc  
        }
        matrices[matrixIndex].show(); // Affiche l'état actuel  
    }
}
 
bool isBlinking[NUM_MATRICES] = {false, false, false, false}; // État du scintillement pour chaque matrice  
unsigned long blinkStartTime[NUM_MATRICES];

[Jay M]

OK merci pour tout ça

Ce code est inutilisable en l’état parce plein de delay() et pendant ce temps là vous ne gérez pas les moteurs les laser ou les fins de course.

Je vais regarder comment récrire ces fonctions en asynchrone comme le reste du code

[jojodu71]

Merci beaucoup

[Jay M]

Je regarde dans l’après midi - j’ai été occupé ces 2 derniers jours

[jojodu71]

Pas de soucis, tu n’as aucune obligation envers moi. Je ne te remercierai jamais assez pour tout ce que tu as fait pour moi. J’espère arriver à comprendre ton code pour pouvoir le modifier au besoin ou le réutiliser pour d’autres applications.

[Jay M]

Voilà une version avec des effets similaires aux vôtres (normalement).

Escargot8.zip

dites moi si c'est OK

A bientôt

[jojodu71]

Voilà une version avec des effets similaires aux vôtres (normalement).

dites moi si c'est OK

Au niveau effets et animations c'est parfait

Par contre au niveau déplacement, les moteurs grognent et les mouvements se font par saccades. j'ai essayé de réglé les vitesse, mais c'est encore pire. Par contre, je n'ai plus le paramètre pour régler l'accélération comme dans tes versions précédentes. c'est un peu mieux, mais je n'arrive pas à trouver le bon compromis en jouant sur la vitesse et l'acceleration, les les moteurs grondent soit ils sifflent . En retour rapide, tout est parfait la vitesse est constante et fluide.
j'ai également remarqué un beug sur l'affichage de la matrice 4, il manque un pixel sur le panneau stop, et ce même pixel est bleu alors que les autres sont violet lors de l'affichage du numéro. j'ai inversé deux pistes pour êtres sure que cela ne vienne pas de la matrice mais pareil. le problème vient bien de la piste 4. ce n'est qu'un détail, mais si tu as une idée;
merci d'avance
a bientôt

[jojodu71]

Je viens d'avoir un autres phénomène bizarre, mais ça ne me l'a fait qu'une fois. si je lance la balle et quelle marque des points avant que le cycle soit lancé, rien ne bouge mais lorsque le je lance le cycle, il tient compte des points marqués et se déplace tout seul.
bizarre

[jojodu71]

J’ai fait un essai en chargeant mon code d’origine qui gère les moteurs avec la bibliothèque Accelstepper et tout est beaucoup plus fluide. Pensez vous qu’il serait possible d’utiliser cette bibliothèque avec les réglages du code d’origine dans votre code sans que celui-ci devienne instable comme le mien et perturbe le fonctionnement général ? Merci

[Jay M]

Bonjour - oui je vais remettre la partie accélération, il faut quelques modifications dues à la façon dont accelStepper recalcule les vitesse quand on donne un nouvel objectif mais ce doit être faisable . Je regarde ça dans la journée

[jojodu71]

Bonjour - oui je vais remettre la partie accélération, il faut quelques modifications dues à la façon dont accelStepper recalcule les vitesse quand on donne un nouvel objectif mais ce doit être faisable . Je regarde ça dans la journée

Super, merci beaucoup.

[Jay M]

Voilà j'ai remis l'accélération

Escargot9.zip

Pour la gestion de l'avancement vous avez quatre constantes sur lesquelles jouer dans le fichier Globals.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
const long nbPasPourUnPoint = -200;         // négatif pour aller vers l'arrivée. Référence du Nombre de pas demandés au moteur à chaque point marqué
const float diviseurFacteurVitesse = 3.0;   // pour la formule de calcul de la vitesse réelle
const float VITESSE_MAX = 500;              // en nombre de pas par seconde
const float ACCELERATION = 100;             // en nombre de pas par seconde par seconde (ici par exemple en 5s on atteint la vitesse max)

et vous avez la roue codeuse qui prend une valeur entre 0 et 9 aussi de disponible pour un réglage sans recompilation.

la formule de calcul pour le Nombre de pas vraiment demandés au moteur à chaque point marqué

nbPasPourUnPoint * (roue codeuse + 1) / diviseurFacteurVitesseEnsuite il faudra voir avec vos moteurs et les micros-pas pour transformer un pas réel en distance linéaire sur vos pistes.

Pour les animations des pistes quand on marque un point vous avez ces constantes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
const uint32_t periodeEffetFleche  = 20;    // on anime d'un pas la flèche au bout de ce temps (ms)
const int      nbPassagesFleche = 3;        // la flèche fera ce nombre de passages quand on marque 1 point
 
const uint32_t periodeEffetBordure = 20;    // on anime d'un pas les bordures au bout de ce temps (ms)
const int      nbLedSEffetBordure = 5;      // nombre de les animées sur la bordure

Par exemple avec ces réglages quand vous marquez un point :
- un passage de la flèche prend 16 périodes (la matrice a 8 de large) et on le fait 3 fois ===> 3 x 16 x 20ms = 960*ms
- pour la bordure, on fait 28 (nombre de leds) affichages x 2 (va et vient) donc 28 x 2 x 20 =1 120 ms

[jojodu71]

Bonjour,
Desolé, mais ça ne fonctionne pas mieux; les moteurs grognent vraiment très fort et quelque soit les réglages de vitesse et d'accélération
si vous avez une idée ? Quelle est la difference entre votre gestion et celle de Accelstepper ?
merci pour tout
cordialement

[Jay M]

A priori j’utilise accelStepper normalement. Pouvez vous me mettre une vidéo avec le son de ce que ça fait ?

[jojodu71]

J’ai chargé votre code version 6 et les mouvements sont plutôt fluides. Je sais pas quelles variantes il y a entre la version actuelle et la version 6, mais si ça peut vous aider.

[jojodu71]

A priori j’utilise accelStepper normalement. Pouvez vous me mettre une vidéo avec le son de ce que ça fait ?

voici une vidéo avec la version 9