Voici mon souci en tant que novice. J'ai aujourd'hui une installation pour mes décorations de noël de deux cartes méga ELEGOO relié en USB (chacun son port et chacun son code(l'un pour alimenter 48 relais/ la seconde 300 neo pixel)) sur mon ordinateur le tout piloter par un logiciel Vixen Light.
Sauf que je souhaite développer mais je n'ai pas 50 ports USB Du coup, j'ai vu qu'il existait des AZDelivery 3 x ESP32 D1 Mini.Sauf que je ne suis pas certains de ce que je comprend et j'aimerais confirmation que cette carte me permettrais d'alimenter mes NEOPIXEL directement sans passer par de nouvelles carte méga ? Si oui combien de led maximum sur la carte ? Le code présent sur ma carte méga sera aussi valable sur cette carte (en y modifiant les valeurs adéquate notamment le numéro de la PIN concerné). Enfin Bref, vous avez compris je suis perdu =)
Les appellations de cartes étant souvent assez fantaisistes, notamment chez l'importateur allemand AZDelivery, donnes un lien vers le produit pour que l'on parte sur une base solide.
Pourquoi pas une liaison USB PC > Arduino et depuis cet Arduino un bus i2C qui relie X (jusqu'à 127) Arduino esclaves, qui assument chacun une partie du show?
Qu'envoie Vixen Light à l'Arduino, as-tu un échantillon?
Alors j'ai vu cela mais je n'ai rien compris a vrai dire surtout au niveau de la partie codage. Si j'ai bien compris sur la partie câblage, c'est pas le plus compliqué. Mais c'était l'une des possibilités.
Alors là aucun idée, comment voir cela ? Sur ma carte 1 il s'agit simplement de l'information On/OFF, mais sur ma carte 2, il envoie en plus les infos Datas de ma guirlande LED(Quelle couleurs a quelle LED).
Le mieux est que tu fasses un ZIP des 2 fichiers de configuration Vixen Light et que tu le mets en ligne. J'installerai Vixen Light.
Comme je n'ai pas d'expérience avec ce logiciel, penses tu qu'il soit possible de mixer les 2 shows en 1?
Bonsoir Jpbbricole,
Alors je peux pas t'envoyer le fichier actuellement car le show se déroule sur un autre PC. Mais je t'ai fait un show express depuis ce PC.
Alors c'est déjà un unique show. Mais j'ai deux contrôleur (1 contrôleur correspond à 1 Arduino mega) et dans ce contrôleur j'ai chacune de mes sortie possible. Sur le contrôleur 1 j'ai 32 relais actuellement soit 32 sortie, sur le deuxième je peux paramétrer jusqu'à 300 LED soit 900 sortie (apparemment capacité maximum de la carte Arduino). et coté logiciel, en gros j'ai une ligne correspond à une lumière, et le tout est liée pour indiqué quelle lumière correspond a quelle sortie Arduino.
J'ai essayé ton test, sans succès, il manque des trucs et Vixen Lights est assez complexe
Si tu peux me faire un simple exemple programme Vixen avec son programme Arduino pour 20 simples LED et un la même chose pour des LED Neopixel, les 2 sur un seul port COM,ça me ferai gagner du temps.
Question, est ce que l'on peut faire coexister, sur le même port COM, des LED normales et des Neopixel?
Si oui, ne me fait pas 2 test séparé mais un seul qui comprend les 2 sortes.
Bonjour JP,
Alors je n'ai pas tout compris ce que tu souhaitais
Je n'ai pas de programme pour "20 simples LED". Mon premier contrôleur contrôle 48 relais qui allume et éteint simplement mes guirlande classique avec le systèmes simple de laisser passer/pas passer le courant. voici le code téléverser sur Arduino avant ouverture du logiciel VIXEN.
#define MEGA_VIXEN
//#define UNO_VIXEN
#ifdef MEGA_VIXEN
#define MAX_CHANNELS 48
int channels[MAX_CHANNELS] = {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};
#endif
#ifdef UNO_VIXEN
#define MAX_CHANNELS 8
int channels[MAX_CHANNELS] = {2, 3, 4, 5, 6, 7, 8, 9};
#endif
#define POWER_UP_STATE HIGH //0 = Lights off at power up, 255 = lights on at power up
#define INACTIVITY_STATE LOW //0 = Lights off when inactive, 255 = lights on when inactive
#define INACTIVITY_TIMEOUT_MILLISECONDS (5UL * 1000UL) // 5 = 5 seconds, 1000 = 1000 milliseconds in a second
int incomingByte[MAX_CHANNELS];
unsigned long inactivityTimer;
void setup()
{
int i;
Serial.begin(9600); // set up Serial at 9600 bps
for ( i = 0; i < MAX_CHANNELS; i ++ )
{
pinMode(channels[i], OUTPUT);
digitalWrite(channels[i], POWER_UP_STATE);
}
inactivityTimer = millis();
}
void loop()
{
int i;
if (Serial.available() >= MAX_CHANNELS)
{
for (i = 0; i < MAX_CHANNELS; i ++) incomingByte[i] = Serial.read();
inactivityTimer = millis();
}
if ( (millis() - inactivityTimer) >= INACTIVITY_TIMEOUT_MILLISECONDS )
{
for ( i = 0; i < MAX_CHANNELS; i ++ ) incomingByte[i] = INACTIVITY_STATE;
}
for (i = 0; i < MAX_CHANNELS; i ++ ) digitalWrite(channels[i], ~incomingByte[i]);
}
Sur mon deuxième contrôleur (et donc ma 2eme carte arduino mega), j'ai ce code qui me permet de générer mes néo pixel. Il fonctionne jusqu'à 300 LED au total (Ici paramétré sur 1 pin). Cependant, pour un bon fonctionnement, il faut suivre la procédure de paramétrage et patching vixen. Je te remet le liens en dessous si nécessaire.
/*
Vixen Lights 3.x - Arduino Generic Serial for Addressable Pixels
Using this code is pretty straight forward, simply hookup your one wire (WS2811 or WS2812) data line to pin 6 of your Arduino
and upload this code. Make sure you have properly installed the FastLED library from http://fastled.io Once you are done, simply
power your Pixel strips from an external power supply. Next configure a Generic Serial Controller inside of Vixen Lights 3.x and
add 3 x pixels for the number of channels. Configure the Generic Serial Controller to use 115200, 8, none, and 1. Then create
your element and add "Multiple Items (1 x number of pixels). Finally select your pixel elements and set them as RGB pixels before
patching them to the controler outputs. You should now be ready to begin testing.
For a complete tutorial check out blog.huntgang.com
Created November 8th, 2014
By Richard Sloan - www.themindfactory.com
And David Hunt - blog.huntgang.com
Version 1.4
*/
// You must download and install the library from http://fastled.io/
#include <FastLED.h>
// Sets the maximum number of LEDs that this code will handle to avoid running out of memory
#define NUM_LEDS 300
// Sets the pin which is used to connect to the LED pixel strip
#define DATA_PIN 6
CRGB leds[NUM_LEDS];
void setup() {
// Define the speed of the serial port
Serial.begin(115200);
}
void loop() {
// Set some counter / temporary storage variables
int cnt;
unsigned int num_leds;
unsigned int d1, d2, d3;
// Begin an endless loop to receive and process serial data
for(;;) {
// Set a counter to 0. This couter keeps track of the pixel colors received.
cnt = 0;
//Begin waiting for the header to be received on the serial bus
//1st character
while(!Serial.available());
if(Serial.read() != '>') {
continue;
}
//second character
while(!Serial.available());
if(Serial.read() != '>') {
continue;
}
//get the first digit from the serial bus for the number of pixels to be used
while(!Serial.available());
d1 = Serial.read();
//get the second digit from the serial bus for the number of pixels to be used
while(!Serial.available());
d2 = Serial.read();
//get the third digit from the serial bus for the number of pixels to be used
while(!Serial.available());
d3 = Serial.read();
//get the end of the header
while(!Serial.available());
if(Serial.read() != '<') {
continue;
}
while(!Serial.available());
if(Serial.read() != '<') {
continue;
}
// calculate the number of pixels based on the characters provided in the header digits
num_leds = (d1-'0')*100+(d2-'0')*10+(d3-'0');
// ensure the number of pixels does not exceed the number allowed
if(num_leds > NUM_LEDS) {
continue;
}
// Let the FastLED library know how many pixels we will be addressing
FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, num_leds);
// Loop through each of the pixels and read the values for each color
do {
while(!Serial.available());
leds[cnt].r = Serial.read();
while(!Serial.available());
leds[cnt].g = Serial.read();
while(!Serial.available());
leds[cnt++].b = Serial.read();
}
while(--num_leds);
// Tell the FastLED Library it is time to update the strip of pixels
FastLED.show();
// WOO HOO... We are all done and are ready to start over again!
}
}
Alors si ta question est : Peux on mettre sur le même port COM les deux cartes arduino sans codage de maitre/esclave, apparemment non car le logiciel ne saurait pas identifier quelle est la carte concerné.
Si ta question est: Peux on mettre les deux codes sur la même Arduino, j'ai lu que non mais sans certitude car c'est là où le bas blaisse dans mon cas, je ne sais pas/ne comprend pas les limites des cartes par rapport à mes besoins et encore moins le "charabia"
J'espère être clair et correspondre à tes demandes
La question était, est il possible de fondre tes 2 shows (LED normales et LED Neopixel) en 1 avec sortie sur un seul port COM?
Ou chaque type de LED doit avoir son propre canal (port COM) ?
Alors, je ne sais pas si on parle de la même chose donc je vais détaillé pour être le plus clair possible
Aujourd'hui quand j'ai à paramétrer un PORT COM , c'est simplement de sélectionner quelle prise USB est concernée et donc quelle carte Arduino.
Cependant si tu parles en donnée sortante de VIXEN, je n'ai pas "2 show" comme tu dit mais bien 1 seul show.
Avec dans ce show 48 guirlandes LED normal alimenté en mode ON/OFF mais piloté individuellement grâce au montage VIXEN sur prise USB 1(= ARDUINO1) où chaque PIN correspond à 1 guirlande (1 prise électrique), ainsi que 1 Guirlande Neo Pixel de 300 LED piloté sur ce même show mais envoyé sur USB2(=Arduino 2) sur la PIN6 car signal PWM.
J'ai donc 1 show, 2 contrôleurs qui fonctionnent séparément car 2 ports COM car deux Arduino donc 2 prise USB.
Contrôleur 1: 48 canal de sortie équivalent à chaque PIN utilisé (pin 3 à 51)
Contrôleur 2: 900 canal de sortie (Car une ampoule NEO PIXEL est l'équivalent de 3 LED(RGB)) mais sur une seul PIN.
Par contre si ta question c'est devons nous absolument avoir les deux méthodes en sortie séparée sur Vixens, la réponse est non ! C'est juste que j'ai montée les choses de cette façon car Cumulé les deux sur 1 seul Arduino est apparemment impossible. Mais je ne suis pas limité par Vixens sur le nombre de sortie sur 1 seul COM ni le type de signal/sortie.
J'espère que ma réponse te convient cette fois ci Si ce n'est pas le cas, j'en suis vraiment désolé.
Donc, mon idée est de tout passer via USB1 dans Arduino1 connecté à USB1, y discerner ce qui doit aller Arduino2 qui, lui, est connecté à Arduino1 en i2C ou en Serial, à voir.
Ca te semble plausible?
Plausible oui car j'avais lu cette possibilité quelque part sur le net. Cependant la réalisation de cela m'est complètement inconnu et incompréhensible. Saurait tu m'indiquer un très bon tutoriel (pour un débutant donc bien détaillé ?) pour envisager la construction et le codage de cela ? J'avais trouvé des tuto sur le branchement a faire (PIN RX et TX de mémoire) mais je n'avais rien compris au niveau codage (notamment où mettre mes codes actuelles et comment les modifier )
Il faut que j'étudie un peu la façon qu'a le programme d'envoyer ses ordres aux LED ou Neopixel. J'ai vu que les ordres pour les Neopixel étaient délimités par >>x,y,z<<.
Si tu pouvait me faire un petit exemple avec quelques LED et Neopixel sur un seul port, sans fioritures, ça m'arrangerais.
Avec un Mega, on pourrai avoir 3 "sous Arduino" via les ports série. Je vais mettre ça au clair.
PS: Passes moi les 2 programmes que tu as déjà fait.
Je vais essayer de te créer cela sur Vixen le + tôt possible (aujourd'hui ça va être compliqué)
Qu'entend tu par cela ? Car l'objectif à long terme c'est ne pas avoir de souci de prise USB et rien que la, j'ai commandé 5000 NeoPixel sachant qu'apparemment une Mega est capable de gérer 300 à la fois soit 17 méga (Il faut que je vois si des Mini/micro/nano en gère combien.
Par programme tu souhaite les codes de mes 2 arduino ? Si oui tu les retrouve ici
J'ai une question technique avec la solution proposé. N'y a t'il pas un risque d'arriver à saturation de la mémoire la carte maitre ? Car je cherche de mon coté aussi pour essayer de comprendre votre proposition, et si je comprend bien, une carte arduino possède une mémoire flash limité. Si la carte mère doit transmettre l'info à la bonne carte, la carte mère ne risque pas saturé si elle a l'info de X autre carte simultanée ?
Entre Vixen et le ou les Arduino, il y a une sorte de langage, c'est ça qu'il faut étudier.
Oui, le but est de n'avoir plus qu'une connexion USB, et dispatcher les ordres reçus de Vixen au différents Arduino qui doivent les recevoir et ce, dans l'Arduino qui a la liaison, selon une méthode à définir.
La quantité de Neopixel prévue, exclu une liaison série entre les Arduino, il faut un bus i2C.
Ca doit faire beaucoup plus, il faut 3 octets par Neopixel.
Ok donc cela répond à ma dernière question, le faite d'avoir le BUS I2C il ne va saturé le maitre en mémoire.
Et je commence à comprendre le principe. La carte relié en USB sera la carte maitre, qui va analyser l'information et l'envoyer directement sur la bonne carte esclave sans passer par les autres. Le tout est de savoir comment Vixens transmet l'information à Arduino d'ou l'exemple vixen avec LED Normal et NEO. Je te fais ça au plus vite.
Du coup, j'ai vu qu'il existait des AZDelivery 3 x ESP32 D1 Mini.Sauf que je ne suis pas certains de ce que je comprend et j'aimerais confirmation que cette carte me permettrais d'alimenter mes NEOPIXEL directement sans passer par de nouvelles carte méga ? Si oui combien de led maximum sur la carte ? Le code présent sur ma carte méga sera aussi valable sur cette carte (en y modifiant les valeurs adéquate notamment le numéro de la PIN concerné). Enfin Bref, vous avez compris je suis perdu =)
