avant d'investir....

bonjour

après avoir lu deux livres sur l'arduino mais étant complètement novice, je n'ai pas trouvé de réponse.

ma question:

avec une carte arduino mega 2560 et 2 ou 3 cartes de 8 relais, est il possible de nommer chaque carte relais pour qu'elles aient chacune un programme de longueur différente et une vitesse différente.

exemple

carte 1
longueur programme 450 lignes vitesse 120ms

carte 2
longueur programme 150 lignes vitesse 150ms

ainsi de suite

je ne veux pas qu'on me donne la solution, je veux juste savoir si c'est possible avant d'investir.
si vous me dites que c'est possible j'investirai et je chercherai la solution.

merci
bonne journée

Bonjour,

J'avoue que je ne comprend pas très bien la question
Qu'est ce que tu entends par programme?
C'est quoi la vitesse? J'espère que ce n'est pas la période ou va commuter le relais. Un relais n'est pas fait pour commuter durablement toutes les 120ms. Si c'est bien ça que tu veux faire, il faut t'orienter vers une commutation électronique.

par programme je veux dire par exemple chenillard ou défilement de séquences lumineuses

pour la vitesse si c'est bien ça un relais peut "claqué" toutes les 75 ms sans problème.

Oui, un relais peut commuter toutes les 75 ms, mais ce que j’ai dit c’est qu’un relais n’est pas fait pour commuter durablement toutes les 120ms

La datasheet des relais qu’on trouve généralement sur les cartes relais arduino donnent une durée de vie de 105 commutations à pleine charge.
Ce qui donne un temps de fonctionnement de 100000*0.125=12500s soit 3 heures 1/2 ce qui ne fait quand même pas lourd.

Si tu ne les utilises pas à pleine charge tu peux espérer atteindre la journée de bon fonctionnement.

désolé d'être brusque mais la n'est pas la question.

est il possible d'avoir une réponse a ma question?

merci

Bonjour,

Désolé, mais moi non plus je ne comprend pas bien la question.

Peut-être changer la formulation en étant plus concret.

Serge .D

je ne vois pas ce que vous ne comprenez pas

il y a une carte arduino 2560 et plusieurs cartes relais et je veux envoyé différents programmes sur ces cartes relais avec des vitesse de défilements différents et des longueurs de séquences différentes.

exemple: la 1ere carte un chenillard avec 8 lampes qui s'allument successivement donc 8 lignes déroulant a 150ms
la seconde carte un chenillard avec 8 lampes style la voiture K2000 donc aller un retour donc 15 lignes déroulant a 100ms

.........

Peut-être que j'ai compris ?

Dans un microcontrôleur il ne peut y avoir qu'un seul programme qui donc doit tout gérer.
Un microcontroleur n'a rien de commun avec un microprocesseur de PC qui ont 4 ou 8 cœurs qui tournent a des gigahertzet et des gigaoctets de mémoire.
Ce que tu veux faire est parfaitement faisable avec les micros qui équipent les cartes Arduino.

désolé d'être brusque mais la n'est pas la question.

Tu peux te comporter absolument comme tu veux mais n'oublie pas qu'en face de toi il n'y aura que des bénévoles qui ne sont pas obligé de répondre donc je pense qu'un ton plus policé serait de mise si tu veux continuer à recevoir des réponses.

En face de toi tu va trouver des amateurs éclairés souvent brillants et aussi des professionnels qui peuvent être très compétants dans leur domaine. Tu fais toujours comme tu veux mais je pense que tu devrais écouter les conseils qui te sont donnés ou expliquer pourquoi d'après toi tu ne peux pas les suivre, ce qui peut arriver.

J'espère que tu va écouter les miens :

  1. Pour commencer une carte Uno est suffisante, ici 90% les achètent sur internet directement en Chine au 1/4 du prix officiel, c'est un choix personnel qui ne se discute pas.
  2. Pour bien débuter il faut lire les règles du forum francophone qui contient aussi des conseils et un lien vers le tuto d'Eskimon qui est la meilleure documentation pour commencer.
  3. Il ne faut avoir les yeux plus gros que le ventre et ce n'est nullement dégradant de commencer par faire des petits exemples pour bien acquérir les bases aussi bien en programmation qu'en matériel avant de passer au projet que tu as en tête.

J'ai fini, à toi de jouer comme tu en a envie, mais maintenant en connaissance de cause.

A bientôt pour des questions précises.

encore désolé d'être brusque ou franc mais ça fait 23 ans que je suis bénévole dans 3 associations, donc le bénévolat je sais ce que c'est.

ce qui me gène c'est qu'on réagisse a des valeurs quelconques mises en exemples qui n'ont rien a voir avec ma question.

maintenant je vous remercie pour votre réponse et je vais pouvoir investir et cherché comment faire.

si je suis parti sur une 2560 c'est que j'ai vu ce montage.

une carte 2560 et 5 cartes de 8 relais mais la personne qui s'en sert actuellement est 'bridé" car le nombres de lignes et la vitesse d'exécution des séquences lumineuses doivent être identiques pour les 5 cartes relais.

moi pour faire la même choses j'utilise actuellement des automates tsx47. sur ces automates j'ai des cartes 16 sorties que je peux séparé en plusieurs séquences lumineuses avec nombres de lignes et vitesse différentes. comme ce matériel n'est plus tout jeune je cherche un remplaçant et donc je me suis tourné vers l'arduino.

si vous souhaitez voir la finalité de ce projet, recherchez sur Google carnaval cholet nuit.

j'espère n'avoir froissé personne et si j'ai d'autres questions j'espère avoir des réponses

merci
bonne soirée

une carte 2560 et 5 cartes de 8 relais mais la personne qui s'en sert actuellement est 'bridé" car le nombres de lignes et la vitesse d'exécution des séquences lumineuses doivent être identiques pour les 5 cartes relais.

Jette un œil du coté du Rasp et son linux.
Sinon il y a les cartes a base de micro ARM.
Soit Arduino équipé Atmel ARM, mais limité à 48 MHz d'horloge soit du coté des cartes "Mbed" je pense au large choix de carte Nucléo de STmicro qui propose des micros jusqu'à 200 MHz d'horloge..
Mbed c'est le même esprit qu'Arduino : des bibliothèques open source mise à disposition et programmation en C/Cpp.
Mbed est plus orienté professionnel qu'Arduino.

ST interdit l'utilisation de ses cartes dans du matériel qui sera vendu. ST est un fournisseur de circuit intégré et ses cartes sont destinées à faire connaître ses produits. ST ne veut assumer aucune responsabilité sur ses cartes. Pour les autres cartes ARM (Texas, Renesas, etc...) je n'ai pas d'info.

Pour simplifier et mettre de côté le débat sur les relais, votre question se résume à:

"est-ce que je peux piloter 16 ou 24 pins en changeant leur valeurs toutes les 120ms sur un Aruino Mega"

point 1: il y a bien 16 ou 24 pins dispos sur un MEGA, donc cette partie là ne pose pas de soucis.

Point 2: sachant qu'un arduino MEGA tourne à 16MHz et qu'un digitalWrite() de base (sans optimiser quoi que ce soit) prend environ 6µs, pour changer 24 pins il faudra donc 144µs et comme vous avez 120ms, votre Arduino ne fera donc rien pendant 99,88% du temps, en attendant le prochain tick d'horloge...

Ensuite pour pouvoir faire cela correctement, bien sûr il faudra que vous codiez proprement avec des machines à états.

non ma question n'est pas ça.

ma question:

dans mon exemple j'ai une carte 2560 et 5 cartes a 8 relais.
je souhaiterais "nommé" les cartes pour les différencié

exemple la carte 1 je veux utilisé que 4 relais sur les 8
la carte 2 je veux utilisé que 6 relais sur les 8

sur la carte 1 la séquence lumineuse n'a que 50 changements d'états a une vitesse X
sur la carte 2 la séquence lumineuse n'a que 250 changements d'états a une vitesse Y

est ce possible?

je ne sais pas comment vous l'expliquez autrement.

Bonsoir

La réponse précédente de J-M-L démontre que du point de vue des E/S et du timing microprocesseur c'est possible.
->Donc : OK pour le hard, C'est fondemental !!

Vient ensuite , sur cette base, l'écriture d'un code qui satisfait les contraintes de relais, séquences et cadences diverses de changement d'états.
Ecrire un code qui ordonnance tout ceci représente un investissement important.
->Disons que le 'soft' est plutôt 'hard'.....

al1fch:
Bonsoir

La réponse précédente de J-M-L démontre que du point de vue des E/S et du timing microprocesseur c'est possible.
->Donc : OK pour le hard, C'est fondemental !!

Vient ensuite , sur cette base, l'écriture d'un code qui satisfait les contraintes de relais, séquences et cadences de changement d'états.
Ecrire un code qui ordonnance ceci représente un investissement important.
->Disons que le 'soft' est plutôt 'hard'.....

mais c'est possible avec arduino?

mais c'est possible avec arduino?

Arduino , c'est une carte et le langage C.

la carte peut le faire , un bon programmeur en langage C aussi

Il faut juste prendre la mesure de la tâche, ça ne ressemble pas à ce qui se fait couramment avec Arduino, c'est loin du 'tout venant', ça demande un type de programmation particulier, donc un investissement pour maîtriser cette programmation très particulière.

le fil de discussion a pour titre 'avant d'investir', pour moi le gros de l'investissement est dans la programmation.

Pour avoir une idée d'exécution de tâches indépendantes donnant l'impression d'agir en parallèle chacune à son rythme voir la librairie Ordonnancement de bricoleau (exemple blinkmultiple)
Voir également le tutoriel de J-M-L sur les Machines à états , la librairie YASM de bricoleau.

mat49:
mais c’est possible avec arduino?

tout à fait… au final - et c’est ce que j’essayais de dire - vous allez avoir la loop() qui tourne et qui dira à certaines pins de s’allumer à un certain moment. c’est un séquenceur.

Ensuite vous voulez vous simplifier la vie en définissant des “groupes de pins” sur lesquels executer une certaine fonction de temps en temps - c’est faisable mais faut coder :slight_smile:

Je vous donne un exemple de ce à quoi ça pourrait ressembler, ensuite il faudra sans doute mémoriser des états pour que chaque fonction soit ré-entrante éventuellement (pour faire deux fois la même animation)

const uint8_t nbMaxPins = 10; // nombre max de pins dans un groupe 

struct groupeDePins_t {
  const char * nomDuGroupe;
  const uint8_t nbPins;
  const uint32_t periode;
  const uint8_t lesPins[nbMaxPins];
  uint32_t chrono;
  void (*fonction)(groupeDePins_t*);
};

// on prédéfinit les animations pour les associer aux groupes
extern void animation1(groupeDePins_t*);
extern void animation2(groupeDePins_t*);

groupeDePins_t g1 = {
  "Groupe 1",
  3,
  2000ul,
  {2, 3, 4},
  0,
  animation1
};

groupeDePins_t g2 = {
  "Groupe 2",
  2,
  5000ul,
  {5, 6},
  0,
  animation1
};

groupeDePins_t g3 = {
  "Groupe 3",
  4,
  10000ul,
  {7, 8, 9, 10},
  0,
  animation2
};

groupeDePins_t tousLesGroupes[] = {g1, g2, g3};
const uint8_t nombreDeGroupes = sizeof(tousLesGroupes) / sizeof(tousLesGroupes[0]);

void animation1(groupeDePins_t* monGroupe)
{
  Serial.println();
  Serial.print(F("Activation de "));
  Serial.println(monGroupe->nomDuGroupe);
  Serial.print(F("Les Pins à modifier sont "));
  for (uint8_t indexPin = 0 ; indexPin < monGroupe->nbPins; indexPin++) {
    Serial.print(monGroupe->lesPins[indexPin]);
    Serial.print(F(" "));
  }
  Serial.println();
}

void animation2(groupeDePins_t* monGroupe)
{
  Serial.println();
  Serial.print(F("Activation de "));
  Serial.println(monGroupe->nomDuGroupe);
  Serial.println();
}

void setup()
{
  Serial.begin(115200);

  for (uint8_t groupe = 0; groupe < nombreDeGroupes; groupe++) {
    tousLesGroupes[groupe].chrono = 0;
    for (uint8_t indexPin = 0 ; indexPin < tousLesGroupes[groupe].nbPins; indexPin++) {
      pinMode(tousLesGroupes[groupe].lesPins[indexPin], OUTPUT); // on mets les pins de relais en sortie
    }
  }

}

void loop()
{
  for (uint8_t groupe = 0; groupe < nombreDeGroupes; groupe++) {
    if (millis() - tousLesGroupes[groupe].chrono >= tousLesGroupes[groupe].periode) {
      (*tousLesGroupes[groupe].fonction)(&(tousLesGroupes[groupe])); // on appelle la fonction associée à ce groupe
      tousLesGroupes[groupe].chrono += tousLesGroupes[groupe].periode; // le prochain déclenchement
    }
  }
}