PROGRAMME URGENT

Bonjour,

Un conseil: il faudrait revoir les bases :wink:
Tout y est mais pas sous la bonne forme.

Les constantes sont généralement globales (hors de toutes fonctions).
De même la partie configuration hardware doit ce trouver dans setup() pour n'être réaliser qu'une seule fois.
Sinon pour le reste, il y a eu une variable et une constante non utilisé.

Ps: trop de commentaires n'est pas bon, surtout si il ne sont pas explicatif (ce qui est le cas ici) :wink:

Exemple de code plus lisible:

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM
const byte PIN_MESURE = A0; // Broche de mesure analogique (signal de contrôle)

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}

// Routine de travail (boucle infini)
void loop() {
    int mesure_brute = 0; // Mesure brute mesuré sur la broche analogique
	
    mesure_brute = analogRead(PIN_MESURE); // Mesure de la tension sur la broche du signal de contrôle
    mesure_brute = map(mesure_brute, 0, 1023, 0, 255); // Linéarisation de la mesure depuis [0 ~ 1023] vers [0 ~ 255]
    analogWrite(PIN_VITESSE, mesure_brute); // Génération d'un signal PWM contrôlant la vitesse du moteur
}

Merci pour tes explications.
Dans ce code, par exemple, si je veux une vitesse de 300 tours minutes, quelles variables dois-je modifierou comment dois-je faire?

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM
const byte PIN_MESURE = A0; // Broche de mesure analogique (signal de contrôle)

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}

// Routine de travail (boucle infini)
void loop() {
    int mesure_brute = 0; // Mesure brute mesuré sur la broche analogique
	
    mesure_brute = analogRead(PIN_MESURE); // Mesure de la tension sur la broche du signal de contrôle
    mesure_brute = map(mesure_brute, 0, 1023, 0, 255); // Linéarisation de la mesure depuis [0 ~ 1023] vers [0 ~ 255]
    analogWrite(PIN_VITESSE, mesure_brute); // Génération d'un signal PWM contrôlant la vitesse du moteur
}

edwinre:
Merci pour tes explications.
Dans ce code, par exemple, si je veux une vitesse de 300 tours minutes, quelles variables dois-je modifierou comment dois-je faire?

    mesure_brute = analogRead(PIN_MESURE); // Mesure de la tension sur la broche du signal de contrôle

mesure_brute = map(mesure_brute, 0, 1023, 0, 255); // Linéarisation de la mesure depuis [0 ~ 1023] vers [0 ~ 255]
    analogWrite(PIN_VITESSE, mesure_brute); // Génération d'un signal PWM contrôlant la vitesse du moteur
}

bonjour
il faut connaitre la vitesse max de ton moteur pour un PWM à 255, et en supposant que la relation vitesse/PWM soit lineaire (ce qui n'est surement pas le cas)
il faut que tu divise Vmax/255 pour avoir l'echelon du nb de tours pour un pas de PWM.

ex si la Vmax est 6000 t/mn , un echelon de PWM correspond ~ à 24 t/mn et donc pour 300 tours le pwm theorique a appliqué est de 12 = 300/25

Merci, donc ça veut dire que si je veux une vitesse de 300t/mins, je devrais avoir le pwm theorique a appliqué, 12. Mais où mettre cette valeur 12?

edwinre:
Merci, donc ça veut dire que si je veux une vitesse de 300t/mins, je devrais avoir le pwm theorique a appliqué, 12. Mais où mettre cette valeur 12?


analogWrite(PIN_VITESSE, mesure_brute);
pour test simple

faire

mesure_brute=12;
analogWrite(PIN_VITESSE, mesure_brute);

ou

analogWrite(PIN_VITESSE, 12);

Est ce que dans le code, je dois remplacer toutes les mesure_brute par 12?

Code d'origine]

mesure_brute = analogRead(PIN_MESURE); // Mesure de la tension sur la broche du signal de contrôle
    mesure_brute = map(mesure_brute, 0, 1023, 0, 255); // Linéarisation de la mesure depuis [0 ~ 1023] vers [0 ~ 255]
    analogWrite(PIN_VITESSE, mesure_brute); // Génération d'un signal PWM contrôlant la vitesse du moteur

Code modifié:

12 = analogRead(PIN_MESURE); // Mesure de la tension sur la broche du signal de contrôle
    12 = map(mesure_brute, 0, 1023, 0, 255); // Linéarisation de la mesure depuis [0 ~ 1023] vers [0 ~ 255]
    analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur

edwinre:
Est ce que dans le code, je dois remplacer toutes les mesure_brute par 12?

Va vraiment falloir revoir les bases du C :wink:

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}

// Routine de travail (boucle infini)
void loop() {
    analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur
}

Va vraiment falloir revoir les bases du C smiley-wink

Si c'est pour un devoir d'école dis le tout de suite parce que si tu le caches et qu'on le découvre par nous même ce ne sera pas bon pour la suite :0.
Depuis un mois tu ne serais que le 2eme ou le 3eme dans ce cas.
Un seul s'est présenté honnêtement sans rien cacher, et c'est sûr que c'est la meilleure méthode pour avoir de l'aide.

Pour info : Calendrier des projets de Terminale "S" option "science de l'ingénieur" -> S-SI.
Septembre à novembre : phase de définition
A partir de décembre : phase de réalisation
Fin : les projets doivent remis en vue de notation courant Juin. EDIT : Fin avril

De toute façon : il n'y a pas de travail urgent il n'y a que des gens en retard.

Je suis en première SSI et je dois écrire cette maquette pour piloter un moteur pour un robot pour mon projet de TPE.
Quel est la différence entre ce code:

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}

// Routine de travail (boucle infini)
void loop() {
    analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur
}

et celui ci:

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM
const byte PIN_MESURE = A0; // Broche de mesure analogique (signal de contrôle)

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}

// Routine de travail (boucle infini)
void loop() {
    int mesure_brute = 0; // Mesure brute mesuré sur la broche analogique
	
    mesure_brute = analogRead(PIN_MESURE); // Mesure de la tension sur la broche du signal de contrôle
    mesure_brute = map(mesure_brute, 0, 1023, 0, 255); // Linéarisation de la mesure depuis [0 ~ 1023] vers [0 ~ 255]
    analogWrite(PIN_VITESSE, mesure_brute); // Génération d'un signal PWM contrôlant la vitesse du moteur
}

Et j'ai oublié que je ne connaissais rien à la programmation il y a quelques temps.

Bonjour

Quel est la différence entre ce code:

et celui ci:

On dirait qu'ils n'ont pas le même nombre de lignes, que le second a des lignes en plus..
Repères les lignes 'en plus' et après avoir étudié içi http://arduino.cc/fr/Main/Reference les commandes en question, réfléchis et fais une proposition de réponse. (Quelle est la différence de comportement entre les deux ? Pourquoi ?)

Si c'est urgent il faut mettre les bouchées doubles et travailler plus vite pour comprendre !

Quel est l'intérêt d'un projet de TPE 'bourré' de réponses 'copiées-collées' ? C'est la meilleure manière pour attirer l'attention sur les parties décalées du contexte et se faire ensuite 'cuisiner' par le(s) prof(s) là où on est plus que 'léger' !

Eh bien maintenant c'est clair, comme quoi on ne trompe pas les vieux singes :grin:

Je ne vais pas entrer dans le détail de ton code , ce n'est pas trop mon truc, mais je vais te donner quelques conseils généraux.

quand tu écris :
analogWrite(PIN_VITESSE, mesure_brute);
T'es-tu assuré que "mesure_brute" est bien dans le bon format de variable et que sa valeur est compatible avec analogWrite ?
Pour faire cela en phase de mise au point il ne faut pas hésiter à faire des sorties dans un terminal (serialBegin(...) , serialWrite(....) )

Et j'approuve totalement ce qu'a écrit Al1fch : contrairement à toi, les prof ont une grande habitude de gérer les TPE.
Il leur sera très facile de détecter ce qui est de toi, ou ce que tu as parfaitement assimilé, de ce qui ne l'est pas.

Merci, je vais me poser et réfléchir à la question, mai avant, si je veux que mon moteur tourne par exemple pendant une minute, je vais devoir ajouter un variable temps et une fonction, mais quelle fonction je dois utiliser, delay() ou milis()?

mais quelle fonction je dois utiliser, delay() ou milis()

Si tu te reportes à la doc (liens ci-dessous)
http://arduino.cc/en/Reference/Delay

tu vois que delay() est bloquant (il arrête le programme pendant la temporisation) alors que millis() se contente de retourner une information de temps écoulé (sans bloquer le programme) à toi alors la charge de gérer l'échéance de temps. Tout dépend donc de ton besoin. Avec delay() une fois la temporisation lancée le programme ne répond plus à aucune sollicitation. A l'inverse en utilisant millis() tu peux parfaitement continuer à scruter la liaison série ou un bouton pour par exemple interrompre ou modifier la temporisation.

Ton besoin n'est pas très clair et ton énoncé au début un peu abscons.Si tu décrivais clairement l'attendu ce serait sans doute plus facile de t'aiguiller vers une solution. Tu noteras que j'ai utilisé "aiguiller vers" et non pas "rédiger". N'attends pas que l'on fasse ton travail. Il faudra mouiller un peu plus la chemise. Tu dis être débutant OK, il y a sur ce forum des "cours" sur le Playgrounds du site mère une quantité astronomiques d'informations en tout genre et si tu cherches un peu sur le net il y en a encore plus et ici on fera notre possible pour t'aider.

Par exemple, je veux que mon moteur aille a 300t/mins pendant 5 mins, dois-je faire comme ça?

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}

// Routine de travail (boucle infini)
for(int delay(0);delay(300000);void loop() {
    analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur
})
{
}

Par exemple, je veux que mon moteur aille a 300t/mins pendant 5 mins, dois-je faire comme ça?

Je voudrais pas faire mon désagréable mais dans le post juste au-dessus je t'ai mis un lien vers la référence de la commande delay(). Il y a un exemple commenté qui n'est quand même pas difficile à adapter à ton besoin s'il est aussi basique que ça. Il faudrait peut être lire les exemples et comprendre ce que tu fais. je pense que cela te ferait gagner un temps précieux (et à nous aussi d'ailleurs).

Ok, donc si je suis l'explemple:

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}

analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur a 300t/mins
delay(300000); // le moteur reste allumé 5mins
analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur a 0t/mins

Et j'ai enlevé la boucle voidloop() pour que le moteur ne recommence pas le cycle: allume 300t/mins pdt 5 mins - arret à l'infini

Sans void loop() ça n'ira pas....

Il faut absolument que tu commences par les bases :grin:

Alors je remets void loop():

const byte PIN_VITESSE = 3; // Broche de contrôle du moteur par PWM

// Fonction d'initialisation hardware
void setup() {
    pinMode(PIN_VITESSE, OUTPUT); // Mise en sortie de la broche connecté au moteur
}
void loop() {
analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur a 300t/mins
delay(300000); // le moteur reste allumé 5mins
analogWrite(PIN_VITESSE, 12); // Génération d'un signal PWM contrôlant la vitesse du moteur a 0t/mins
}

Mais si je le laisse, le moteur va faire:
Allumer 5 mins a 300t/mins
Arret
Allumer 5 mins a 300t/mins
Arret
Allumer 5 mins a 300t/mins
Arret
...

Non?

Le void loop() est une boucle infinie.

A toi de déterminer les conditions pour que ton moteur tourne selon ce que tu veux.

Commence par mettre par écrit ce que tu veux, Ex :

-moteur tourne à droite pendant 5 minutes
-stop pendant 30 secondes
-moteur tourne à gauche pendant 2 minutes
-pendant que le moteur tourne, faire un café.... (suivant comment tu programmes ton contrôleur peut faire des autres choses... ;))
-stop 0,5 secondes
-moteur tourne à droite pendant 1 minute
-...

Ensuite tu simplifies :

-D300000
-S30000
-etc

Et ensuite tu élabores tes conditions :

-si le moteur tourne à droite, il devra tourner dans l'autre sens au démarrage suivant.
-si il à fait deux démarrage, il peux démarrer dans un sens ou dans l'autre suivant une autre condition.
-si le café n'est pas chaud, il faut remettre la séquence à 0.... etc

Ensuite, tu commences à regarder la prog et à comprendre un peu mieux ce que tu fais.... et nous aussi XD