Bonsoir Binos13,

Oui pour le code final, non pour l'exemple de code dont AntoineRav parlait. La correction a dû être effectuée depuis.

Nanomaitre

Ok merci.

Bonjour à tous.

J'ai une question à propos du premier quiz question 15, il est indiqué que la bonne réponse est "led éteinte".

J'ai réalisé l'essai, la led reste allumée, cela dépends de la polarisation de celle-ci, anode connectée au +5V, il faut un zéro logique sur le port de l'arduino pour l'allumer.

Après mesure à l'oscilloscope, il apparaît que la led reste dans ce cas éteinte pendant seulement 5.16 microsecondes et allumée pendant presque 500 millisecondes....

 Si on inverse la polarisation de la led, le résultat est inversé !

Cependant votre cours est très bien construit, bravo à vous !

-
Edité par y8400 15 décembre 2015 à 11:38:53

Effectivement, il serait utile de préciser dans quel sens est branché la LED, mais je pense que dans "brancher correctement", l'auteur sous entendait pin3=>LED=>GND et pas +5V=>LED=>pin3 

Oui mais l'arduino préfère absorber du courant qu'en fournir...

Bonsoir,

pour répondre à cette douce interrogation du sens de la LED, en effet, l'erreur est de ma part !

Je sous-entendais que le courant de la LED était fourni par le pin et non par le +5V. Le "terme correctement connecté" est mal employé.

Je vais modifier l'énoncé pour éviter ce doute de sens de connexion.

Merci de l'avoir signalé ! Et bonne continuation à vous

Nanomaitre

Bonjour & merci pour ces tutos très sympa & accessible,

j'ai commencé hier et je viens de finir le "Dé"...

(par contre, les 2e quizz & test ne me sont pas encore accessibles ...) [c'est rageant !! ]

- - -

Juste une petite typo de com à remonter: (quand il n'y a plus que ça, c'est génial)
page jeux-de-lumiere-et-tableaux-avec-plusieurs-led :
"    //on les éteinds toutes brièvement" => "    //on les éteint toutes brièvement"

- - -

Sinon, pendant mes études j'avoue avoir fait un peu d'embarqué (mais c'est très loin ^^)
et les "int" utilisés ici me "choquent" (c'était un coup à avoir nos notes divisées par 2)
(et en pratique, c'est vrai qu'il vaut mieux éviter vue que la définition du int change selon la plateforme cible)
Depuis, il y a eu le C99... qui a des types explicites => je préfère utiliser intX_t & uintX_t, X nb de bits,   supportés en arduino

ça permet de distinguer les éléments dont on parle de façon plus claire (et également d’optimiser)

//  uint8_t : pour identifier les pins
//  int16_t : pour les nombres (cf "int" de arduino)

Peut-être avais-tu prévu d'aborder ça plus loin dans le cours.

En espérant que ça ne perturbe pas trop les "correcteurs".

Bonnes conceptions à tous,

B.

Bonjour bce,

merci d'avoir repéré la faute d'orthographe, je demande la correction sous peu.

Pour ta remarque, en fait, il y a plusieurs raisons qui m'ont poussées à ne pas utiliser ce type de déclaration de variables :

• C'est un cours pour débutant, inutile de complexifier des déclarations simples qui sont, de plus, celles données dans la plupart des forums ou programmes proposés.
• Ces déclarations sont souvent utilisées dans les bibliothèques (en c++ par exemple) et s'adressent plutôt à des personnes qui maîtrisent un peu mieux le concept de gestion de mémoire.
• On optimise rien du tout en déclarant différemment. L'IDE de l'Arduino compile ensuite le programme et place les valeurs dans une adresse mémoire. Et comme il s'agit d'utiliser l'IDE (et pas un autre moyen de transfert), je reste sur ce que les sketches proposent.
• En effet, on peut imaginer que l'utilisation des nombres sur 16 bits et des pins sur 8 bits paraît plus claire. En fait la question est surtout sur la place en mémoire. Pour un débutant, il est préférable de comprendre d'abord l'utilisation des variables sans trop chercher dans le typage.

En ce qui concerne les correcteurs, je pense qu'il est préférable que tu signales le choix que tu as fait, car tous n'auront pas ton niveau .

J'espère t'avoir répondu et te souhaite à toi aussi une bonne conception !

Nanomaitre

Bonjour,

Je me rends compte que je n'ai pas tout compris aux fonctions...

Dans un code, je vois dans la boucle:

void loop(){

...;

int x = random (y);

bidule(x);

J'en conclu donc que la variable x aura pour valeur de 0 à y-1. Ensuite, on réalise la fonction bidule (x).

Si je comprends bien, pour un x d'une certaine valeur, on aura donc un affichage correspondant à cette valeur x.

Par contre, là où je ne suis plus sûr de bien comprendre, c'est dans la déclaration de la fonction elle-même. Elle est libellée :

void bidule (int a){

puis dans le code de la fonction je vois : if (a == 1){ etc...

Est-ce que je dois en conclure que si lors de la réalisation dans la boucle de "int x = random (y);" je tire un 1, la fonction bidule(x), sera  bidule(1), ce qui correspond à a==1 dans la déclaration de la fonction? En somme c'est la transitivité? Si x = random (y) = 1 et que a==1 alors a==1=x?

Et pourquoi ne peut-on pas écrire void bidule (x){? (dans ce cas on a un message d'erreur : exit status 1 variable or field 'allumage' declared void)

Merci pour votre aide, je suis désolé je pars de 0 en code !

Bonne soirée

Antoine

-
Edité par AntoineRav 17 décembre 2015 à 20:54:46

Bonsoir Antoine,

Je pense que tu parles de la portée des variables et des déclarations.
(au pire, nanoMaître corrigera - merci pour le retour rapide à mon précédent post à propos.)

Prenons par exemple une fonction avec les types et le nombre de paramètres que tu souhaites :

( les mots TypeSortie, Type1 et Type2 sont remplaçables par des "int"... par exemple)

TypeSortie nomFonction(Type1 param1, Type2 param2 , ... )
{
  TypeSortie valSortie;
  // ... utilisation de param1 & param2 pour déterminer une valeur pour valSortie
  // rq : ici param1 et param2 et valSortie ont du sens
  //   mais pas x, y ni "resultat" qui ne sont pas définis à ce niveau
  return valSortie;
}

// rq : ici, hors de la fonction, param1 et param2 et valSortie n'ont plus de sens

et on peut appeler ainsi cette fonction (dans la loop par exemple ou n'importe quelle autre fonction):

TypeRetour resultat = nomFonction(x,y);
// ici, x et y ont du sens, mais pas "valSortie" ni "variable1" ni "variable2"
// x est même de type "Type1" (ou dans un type convertible en Type1)
// respectivement y est de type Type2 (ou convertissable en Type2)

Tout est une question de contexte et de portée de variable. Le jeu consiste à identifier où on est et ce qu'on connaît et qu'on peut manipuler alors.

Si c'était clair jusqu'ici, l'étape immédiatement après est "le bloc": (les accolades),

les variables définies au sein d'un bloc ne sont pas visible à l'extérieur.

{
//...
//au sein d'une fonction
// pas de variable "bMaCondition" définie jusqu'ici
{ // démarrage d'un sous bloc
  bool bMaCondition = false;
  // ... utilisation/modification possible de bMaCondition
} // fin du sous bloc
// ici, bMaCondition n'existe plus et n'a pas de sens.
//...
}

Enfin dernière problématique que tu soulèves : l'erreur : " exit status 1 variable or field 'allumage' declared void"

dans le premier exemple ci dessus, maFonction, le type de retour possible est "TypeSortie", le type de variable que tu décides,

cependant, il existe un faux type, un mot-clef disant "cette fonction n'a pas de résultat en sortie", il s'agit de "void".

Dans ce cas là, il ne faut pas utiliser de "return variable;" au sein de la fonction en question, et une erreur est détectée si c'est le cas.

(pour être complet, "return;" cad "sort de la fonction sans valeur" reste possible)

En espérant être resté compréhensible et t'avoir aidé.

B.

-
Edité par bce 17 décembre 2015 à 22:30:51

Bonsoir à vous deux,

Je ne vais pas corriger bce, car il a raison. Juste le dire de façon plus "aide mémoire"

• Une fonction est un bloc de code que l'on peut appeler depuis un autre bloc de code.
• Une fonction peut prendre des paramètres (c'est à dire des variables de types variés ). Ils sont indiqués dans les parenthèses qui suivent la déclaration de la fonction (on doit en déclarer le type et le nom). Les paramètres sont passés à la fonction lorsqu'on l'appelle. On les mets dans le bon ordre entre parenthèses en les séparant d'une virgule.
• On peut utiliser les paramètres dans la fonction (pour faire des boucles, des tests et des calculs).
• Une fonction peut retourner un paramètre (mais un seul). Il faut dans ce cas indiquer le type de paramètre retourné lorsqu'on déclare une fonction. Si c'est le cas, il est obligatoire que toutes les sorties de la fonction retournent le paramètre. Si la fonction ne doit rien retourner, on la déclare comme 'void'
• Les calculs de variables dans une fonction n'affectent pas les variables hors de la fonction (sauf les variables globales)

voici un exemple simple (sans les loop et setup) :

//fonction multiplication. Prend 2 int en paramètres, renvoie le résultat sous forme de long
long multiplication(int a,int b){
  return long(a*b);
}

//utilisation de la fonction
int x=3;
int y=7;
long c=multiplication(x,y); //appel de la fonction en donnant en paramètres les valeurs de x et y. le retour est stocké dans c

J'espère qu'entre les explications de bce et les miennes, tu auras trouvé ton bonheur !

Nanomaitre

-
Edité par nanomaitre 18 décembre 2015 à 1:23:02

Bonjour,

Merci à tous les deux pour avoir pris le temps d'écrire ces réponses très détaillées. Il me faut un peu de temps pour digérer tout ça!

Bonne journée

Antoine

-
Edité par AntoineRav 18 décembre 2015 à 10:51:08

Bonjour,

Désolé d'accaparer la parole de ce forum... Une question technique, depuis que je travaille sur la partie moteur, j'ai beaucoup de mal à téléverser le programme vers l'Arduino. Il faut que je reset la carte plusieurs fois ou que je passe par la téléversement d'un programme vide pour que cela fonctionne. Est-ce que l'utilisation d'un moteur (servo) utilise des ressources particulières à moins que le mapping soit plus coûteux en ressource?

Merci pour vos réponses,

A bientôt

Antoin

Azerty

AntoineRav a écrit:

Bonjour,

Désolé d'accaparer la parole de ce forum... Une question technique, depuis que je travaille sur la partie moteur, j'ai beaucoup de mal à téléverser le programme vers l'Arduino. Il faut que je reset la carte plusieurs fois ou que je passe par la téléversement d'un programme vide pour que cela fonctionne. Est-ce que l'utilisation d'un moteur (servo) utilise des ressources particulières à moins que le mapping soit plus coûteux en ressource?

Merci pour vos réponses,

A bientôt

Antoin

J'ai également eu pas mal de soucis a un moment sur le téléversement. J'avais sans cesse des erreurs qui s'affichait et je n'arrivais même pas à téléverser un programme vide mais après plusieurs manip, j'ai réussi à le débloquer. As-tu essayé de mettre hors tension la carte et de redémarrer ton PC ?

Bonsoir,

@ antoineRav et frk44, 

Il arrive en effet parfois que le téléversement bloque. De mon côté j'essaie plusieurs des possibilités suivantes :

• appuyer sur le reset de la carte et téléverser à nouveau.
• débrancher et rebrancher le câble USB
• attendre que le message de 'téléversement ok' soit affiché avant d'ouvrir le moniteur série.
• Redémarrer le logiciel Arduino
• Forcer à quitter le logiciel Arduino avant de le redémarrer (processus compris)
• Redémarrer le PC

(Bon tout ça c'était avant d'être sur mac, maintenant, je n'ai plus de problème )

Mais en aucun cas il ne s'agit de problème de ressource ou de fonction map(). On peut rencontrer un blocage si les variables dépassent la taille possible réservée dans l'Arduino. Il faudrait lire le message d'erreur s'il y en a un.

Bonne continuation 

Nanomaitre

Bonsoir,

Dans la partie 1, au niveau des tableau.

Lors du remplacement des variables par un tableau :

    for (int i = 0; i < 3; i++) // t pour parcourir le tableau
    {
      digitalWrite(pinLed[i], HIGH);//on allume la LED correspondante
      delay(temps); // pendant la valeur de temps
      digitalWrite(pinLed[i], LOW); //on éteint la correspondante
      delay(100); // court délai pendant lequel les 3 LED sont éteintes
    }

Le code serai plutôt ça pour avoir le même résultat qu'avant :

for (int i = 2; i >= 0; i--)
{
    digitalWrite(pinLed[i], HIGH);
    delay(temps); 
    digitalWrite(pinLed[i], LOW);
    delay(100);
}

 Enfin, ce n'est pas important

Bonjour JuJu89,

En fait j'ai modifié le code précédent ça évite une boucle en sens inverse pas évidente pour les débutants. Merci de la remarque.

(Toutes les modifications ne seront effectives qu'à partir du 2 janvier... vacances obligent)

Nanomaitre

Bonjour

Dans le 3ème chapitre de la 1ère partie (oui je sais je suis en retard, faute de temps), vous avez affirmer que la déclaration de variables en 2 étapes était moins gourmande en mémoire que celle en une étape.

Pouvez-vous expliquer cela s'il vous plait, car comme vous l'aviez mentionné avant, la variable au moment de sa déclaration contenait déjà une donnée aléatoire attribuée par le compilateur, donc en lui affectant une valeur sur le champs ceci ne changera pas grande chose au niveau d'épargne de mémoire, n'est ce pas ? ou est ce que j'ai une variable qui manque dans mon raisonnement :p.

cordialement,

-
Edité par oorroz 2 janvier 2016 à 19:35:17

Bonsoir ooroz

En fait il faut séparer deux points : la mémoire globale de l'Arduino et la mémoire prise par votre programme.

La mémoire globale de l'Arduino est fixe. Chacune des adresses (ou cases mémoires) contient un nombre 8 bits. En fonction de sa position dans la mémoire, du nombre à l'adresse précédente ou du nombre à l'adresse suivante, la puce de l'Arduino va interpréter ce nombre en le lisant. Un programme est donc une succession de nombres interprétés qui provoquent des connexions, des sauts vers une autre case mémoire, des modifications de cases mémoire. Un programme s'inscrit dans la mémoire et réserve des places pour ses variables.

Donc si on n'affecte pas la valeur d'une variable, l'IDE de l'arduino va réserver un emplacement mémoire pour cette variable, or cet emplacement contient forcément déjà un nombre (on parle ici d'emplacement 8 bits, mais pour d'autres variables, il s'agit d'une succession d'emplacement de 8 bits). Si on appelle cette variable, le programme sautera à la case mémoire correspondante et  utilisera le nombre en question. D'où l'idée de placer déjà un nombre choisi à cet emplacement. C'est l'initialisation de la variable.

Maintenant l'autre point est la place prise par votre programme dans la mémoire de l'Arduino. Le programme que vous tapez va être transformé en code machine (une succession de nombres mis dans la mémoire, qui seront ensuite interprétés) qui sera fixé dans la mémoire à partir d'une adresse décidée par l'IDE.

Lorsque je dis que la déclaration en deux temps est moins gourmande, c'est juste que le programme prendra moins de place en mémoire avec cette déclaration (moins de nombres pour le langage machine). 

Pour vous en assurer, faites le test d'un programme simple qui déclare une variable en un temps, et un autre qui déclare la même variable en deux temps. Vous verrez (dans le message de l'IDE après téléchargement) que la place prise par le second est inférieure en nombre d'octet (donc le code prend moins de place en mémoire) . Maintenant, ça ne se joue que sur quelques octets, mais ils sont parfois précieux sur l'Arduino.

Dans la grande majorité des cas, une déclaration en un temps est bien plus simple et ne gênera pas votre place mémoire.

J'espère que mon explication aura éclairé votre lanterne (expression étrange, vu qu'une lanterne sert à éclairer... mais bon)

Bonne continuation à vous 

Nanomaitre

Une autre méthode pour ménager la carte Arduino

Bonjour Nanomaître ainsi que tous les élèves ce de MOOC,

Je ne parviens pas à comprendre pourquoi il est préférable de brancher dans le sens +5V=>LED=>pin3 plutôt que pin3=>LED=>GND. Je veux bien l'admettre mais je ne comprends pas l'intérêt.

Après une petite recherche, je vois dans la doc Atmel Atmega328 que les pin sont garanties jusqu'à 40mA de fourniture de courant, ce qui est bien suffisant pour une LED (pas forcément pour un récepteur plus puissant).

Pour bien comprendre, dans le montage ménageant notre Arduino, lorsque le pin 13 devient un GND, le courant passe quand même dans notre Arduino.

Du coup, quelle est la limite de courant acceptable?

Merci pour ta réponse et pour ton cours.

Cordialement.

Bonjour _mudav,

Chaque pin numérique peut fournir et recevoir 20mA (en fait la limite est de 40mA sans dommage). Il faut aussi savoir que la fourniture de courant par groupe de pins ne peut pas dépasser 150mA au total (voir liens en plus bas)

La quantité de courant est suffisante pour une diode (avec résistance) sur un pin, mais ça ne l'est plus pour faire décoller un moteur ou gérer un relais.

On dit que l'on ménage l'Arduino en connectant dans l'autre sens car on utilise le +5V (qui fournit un courant continu presque directement depuis l'alimentation, avec en plus un régulateur) qui n'a pas la limite des 40mA (celle des pins numériques) en sortie. Le pin sert du coup de ground (il absorbe le courant) lorsqu'il est positionné en LOW.

En regardant les spécifications, on peut en effet voir que chaque pin numérique (en mode OUTPUT) ne peut absorber que 20mA (et chaque groupe pas plus de 100mA au total). Notre montage (diode plus résistance) réduit la quantité de courant dans le circuit, du coup, on respecte la quantité de courant attendu. En revanche, si on connecte directement un fil du +5V au pin (en mode OUTPUT) sans résistance, on risque d'endommager l'Arduino. (à noter que ce n'est pas le cas pour un pin en mode INPUT). Pour cette raison, il est conseillé de placer une résistance de 470Ω pour protéger le pin.

Tu trouveras plus d'infos sur cette page et cette page (en anglais...)

J'espère avoir répondu à ta question 

Nanomaitre

Et bonne année Arduinesque à tous ! 

Nanomaitre

il fout télécharger le protose logisiel qui fais la demonstration de larduino ou leu dachter une aparelle darduino

Bonjour, je vais paraître relou, mais j'aimerais être sûr de ne pas me tromper

Je voudrais savoir si ces 3 achats sont ok pour bien démarrer :

http://boutique.semageek.com/fr/2-arduino-uno-dip-rev3-7640152110092.html

http://boutique.semageek.com/fr/32-sidekick-basic-kit-v2.html

http://boutique.semageek.com/fr/59-c%C3%A2ble-usb-type-a-b.html

Ayant chercher longtemps un lot avec un bon rapport qualité/prix, je peux vous dire que beaucoup de contrefaçons trainent sur la toile..!

Juste un problème, ce kit ne propose pas de résistances de 220 ohms mais 330... Es-ce bon pour reproduire les tutos ?

Merci par avance !

-
Edité par Nemoh65 7 janvier 2016 à 15:57:26

Bonsoir,

le premier lien envoie vers l'Arduino R3 qui est bien la dernière version de la carte.

Le second lien envoie vers un kit tout à fait correct (il manque juste les moteurs, les transistors et une L293D mais qui peuvent s'acquérir facilement par la suite). En revanche il est indiqué en rupture de stock (et parfois, cela dure longtemps, longtemps...)

Le dernier lien envoie vers le câble USB qui manquait au premier lien

Tout ceci me paraît très bien, si ce qui est indiqué est ce que vous recevez effectivement.

Les résistances de 330Ω conviennent tout à fait à la place des 220Ω. Vos LED brilleront un tout petit peu moins fort, c'est tout.

J'espère avoir répondu à votre demande et bienvenue dans le monde d'Arduino !

Nanomaitre

-
Edité par nanomaitre 7 janvier 2016 à 19:40:01

Bonjour Nanomaitre !

Mince, je n'avais pas vu la rupture de stock

Je vais donc trouver une alternative. Pour ce qui est des résistances je n'étais pas sûr de moi, mes cours d'électroniques commencent a remonter !

En tout cas, merci pour ces réponses précises et rapides

Bonjour, bonsoir

Je viens de débuter le cours et je dois admettre avoir besoin d'aide.

Lors du premier branchement avec une LED, je me suis retrouvé avec un soucis. En branchant la LED sur le 3V, celle ci a grillé (3V -> LED -> GND), j'ai vérifié si j'avais mal lu mais non, du coup j'ai testé avec une autre (un défaut) mais la même chose.

Est ce que je me trompe quelque part ? Ou est ce que je dois douter de l'arduino ?

Merci a vous.

Tu n'aurais pas oublier de mettre une résistance par hasard?

J'ai testé sur la BB avec une résistance, pour vérifier que mes LED n'était pas un défectueuse, elle fonctionne bien en 5V avec resistance.
Mais la sortie 3V devrait fonctionner sans résistance, comme précisé dans le cours. Le schéma suivant étant fourni (plus simple que cela, difficile a faire )