Différences
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente | ||
start:projet:arduino:pour_commencer [2015/09/23 16:32] – [H - Le port seriel] psalles | start:projet:arduino:pour_commencer [2016/12/09 21:23] (Version actuelle) – [opérateurs bitwise] jcano | ||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
+ | ====== Mémo Arduino du Fablab : Pour débuter ====== | ||
+ | |||
+ | <note warning>// | ||
+ | </ | ||
+ | ====== I – Introduction : ====== | ||
+ | {{ : | ||
+ | ==== Qu'est ce que c' | ||
+ | |||
+ | Les cartes Arduino sont des cartes électroniques programmables, | ||
+ | |||
+ | ==== Quel est l’intérêt alors ? Cela ressemble étrangement à des langages informatiques traditionnels ! ==== | ||
+ | |||
+ | Hé bien, chers lecteurs, c'est qu'une Arduino est capable de lire directement des tensions (comme si c' | ||
+ | |||
+ | ==== Qu' | ||
+ | |||
+ | Ça , je vous le demande !! ;-) Mais téléchargez d' | ||
+ | |||
+ | ======II – Comment programmer :====== | ||
+ | |||
+ | =====A/ Les bases de la syntaxe en Arduino : | ||
+ | |||
+ | On dit qu'un exemple vaut mille mots, donc voici un programme typique, Blink ou clignotement de LED : | ||
+ | |||
+ | | ||
+ | |||
+ | On remarque que chaque instruction est composé d'une fonction (// | ||
+ | __On peut découper le programme en trois grandes structures : | ||
+ | \\ \\ | ||
+ | ==== Structure de définition : | ||
+ | |||
+ | |||
+ | La première partie du programme définit comment vous voulez **nommer** les entrées-sorties. | ||
+ | « int » en dehors des "// | ||
+ | |||
+ | <note tip>// | ||
+ | // </ | ||
+ | ==== Structure "Void Setup" (initialisation) : | ||
+ | |||
+ | |||
+ | Cette structure entre accolades ne sera exécutée **qu' | ||
+ | |||
+ | Elle contient également les **déclarations de sortie** : en effet, toutes les pin (pattes) de l' | ||
+ | \\ \\ | ||
+ | <note tip>// | ||
+ | |||
+ | ==== Structure "Void Loop" (boucle) : ==== | ||
+ | |||
+ | |||
+ | Structure clé de votre programme, cette dernière sera **exécutée en boucle** (loop) jusqu' | ||
+ | \\ | ||
+ | Ici, on effectue deux fois la commande // | ||
+ | \\ \\ | ||
+ | <note tip>// | ||
+ | | ||
+ | | ||
+ | | ||
+ | le programme repart de " | ||
+ | //</ | ||
+ | ===== B/ Les deux types de pins : ===== | ||
+ | |||
+ | |||
+ | Comme dit ci-dessus, les cartes Arduino servent à être implémentées **dans** des circuits électroniques. Il est donc nécessaire que notre chère carte communique avec le reste du circuit, c'est pour cela que savoir se servir des pins est très important.\\ | ||
+ | Il existe **deux types** de pins servant à cela dans une carte Arduino, quel que soit le modèle : | ||
+ | \\ \\ | ||
+ | **Les pins analogiques : | ||
+ | **Les pins numériques (ou digitaux): | ||
+ | Une petite localisation de ces derniers sur **l' | ||
+ | {{ : | ||
+ | \\ | ||
+ | Les pins **analogiques** permettent une lecture de tension, une lecture d' | ||
+ | Les pins **digitaux** quant à eux permettent de lire et d' | ||
+ | **NB**= nous reviendrons sur ces quatre fonctions d' | ||
+ | |||
+ | ===== C/ Types de variables : ===== | ||
+ | **NB:** ceci n'est pas une liste exhaustive, ni rigoureuse, il en existe d' | ||
+ | \\ \\ | ||
+ | ====int :==== | ||
+ | Cette catégorie de variable, que vous avez déjà entr' | ||
+ | Comme les **pins** sont repérés par des entiers (oui, 1, **A0** et 3 sont des entiers pour Arduino :!:) elle peut servir à affecter un nom à un pin \\ | ||
+ | **exemple: | ||
+ | \\ | ||
+ | \\ | ||
+ | Mais elle sert à bien d' | ||
+ | \\ **exemple :** un compteur : " | ||
+ | \\ // void setup () { int i=0; } //mise à zéro du compteur et déclaration de variable// | ||
+ | \\ void loop () { | ||
+ | \\ " | ||
+ | \\ i++ (incrémentation) } | ||
+ | // \\ Bref, à chaque fois que l' | ||
+ | // | ||
+ | \\ | ||
+ | <note tip> Il existe en réalité deux types de variables entières (modes de **int**) une variable int sera par défaut déclarée (suivant le modèle de carte Arduino utilisée) dans l'un des deux : \\ \\ | ||
+ | - **long** qui permettent de définir des __entiers relatifs__ volumineux (inclus dans [-2, | ||
+ | \\ | ||
+ | - **short** qui définit des __entiers__ inclus dans [-32, | ||
+ | \\ **NB:** si on veut forcer une variable à être **long** ou **short** il suffit de remplacer **int** dans la déclaration (par **short** par exemple), __la syntaxe est la même__ | ||
+ | ====float==== | ||
+ | Son principe d' | ||
+ | <note important> | ||
+ | |||
+ | * Ce dernier est idiot, il ne comprend que les additions/ | ||
+ | * Il faut donc lui faire replacer la virgule à chaque opération, et cela demande vingt fois plus de temps (ou quarante, enfin bref vous m'avez compris 8-)) | ||
+ | |||
+ | </ | ||
+ | |||
+ | Les floats font 32 bits (1 mot simple) : | ||
+ | * 1 pour indiquer le signe du nombre représenté **S** | ||
+ | * 8 pour représenter l' | ||
+ | * 23 pour représenter la fraction **F** (qui permet | ||
+ | * Le nombre réel vaut alors **(-1)^S * F * 2^E** | ||
+ | |||
+ | <note tip>A noter que cette représentation mène à des erreurs de précision, la fraction n' | ||
+ | |||
+ | |||
+ | ====double==== | ||
+ | Pareil que le précédent sauf qu' | ||
+ | |||
+ | Pour en savoir plus sur l' | ||
+ | |||
+ | ====char==== | ||
+ | A été crée initialement pour coder __un caractère__ (d'où son nom) en un nombre entier compris entre 0 et 255 (ou entre -128 et 127) : | ||
+ | \\ **ex:** //char LaLettreMysterieuse=' | ||
+ | \\ //est équivalent à //char LaLettreMysterieuse=90// | ||
+ | \\ | ||
+ | La ressource pour l' | ||
+ | \\ | ||
+ | Sinon, il s'agit d'une variable entière stockée sur 8 bits soit 1 octet. | ||
+ | ====boolean==== | ||
+ | Permet d' | ||
+ | \\ qui ne peut prendre que les valeurs " | ||
+ | \\ Très utiles pour les expressions logiques !! 8-) | ||
+ | |||
+ | ===== D/ Opérateurs élémentaires ===== | ||
+ | Voici un rappel succinct des différents **opérateurs** mathématiques élémentaires utilisés en Arduino : | ||
+ | \\ **NB** j'en ai " | ||
+ | // // | ||
+ | = (affectation) | ||
+ | + (addition) | ||
+ | - (soustraction) | ||
+ | * (multiplication) | ||
+ | / (division) | ||
+ | % (modulo) | ||
+ | |||
+ | ====opérateurs de comparaison==== | ||
+ | |||
+ | == (égal à) | ||
+ | != (différent de) | ||
+ | < (strictement inférieur à) | ||
+ | > (strictement supérieur à) | ||
+ | <= (inférieur ou égal à) | ||
+ | >= (supérieur ou égal à) | ||
+ | | ||
+ | ====opérateurs booléens==== | ||
+ | |||
+ | && (et) | ||
+ | || (ou) | ||
+ | ! (non) | ||
+ | |||
+ | ====opérateurs de composition==== | ||
+ | |||
+ | Leur emploi est synonyme de paresse ou d’astuce ;-) ! \\ | ||
+ | |||
+ | ++ (incrément) | ||
+ | -- (décrément) | ||
+ | **ex:** //i++; équivaut à i=i+1;// | ||
+ | |||
+ | += (addition composée) | ||
+ | -= (soustraction composée) | ||
+ | *= (multiplication composée) | ||
+ | /= (division composée) | ||
+ | **ex:** //i+=N; équivaut à i=i+N;// | ||
+ | |||
+ | ====opérateurs bitwise ==== | ||
+ | Ce sont des opérateurs permettent une opération bit à bit et non pas de la valeur globale. \\ | ||
+ | <note tip> | ||
+ | |||
+ | Les shifts (décalage de bits) | ||
+ | << shift vers la gauche | ||
+ | >> shift vers la droite | ||
+ | Exemple : 0b10001011<< | ||
+ | <note tip> | ||
+ | <note important> | ||
+ | |||
+ | | OU bitwise, ex : 0b1010 | 0b0001 = 0b1011 | ||
+ | & ET bitwise, ex : 0b0101 & 0b1100 = 0b0100 | ||
+ | ^ NOR (NON OU) bitwise, ex : 0b1010 ^ 0b1011 = 0b0001 | ||
+ | ~ NON bitwise, ex : ~0b1011 = 0b0100 | ||
+ | |||
+ | Operations composées : | ||
+ | |||
+ | |= OU bitwise appliqué à lui même | ||
+ | ^= NOR bitwise appliqué à lui même (inverse l' | ||
+ | &= ET bitwise appliqué à lui même | ||
+ | |||
+ | < | ||
+ | char i = 42; | ||
+ | char bits0et1 = i & 0x00000011; //on selectionne les deux bits finaux | ||
+ | Puis, on sépare le bit 0 du bit 1, et on fait une comparaison logique sur le dernier bit des deux chars ainsi obtenus (un OU bitwise ou logique font autant bien l' | ||
+ | boolean OUbits0et1 = bits0et1 | (bits0et1>> | ||
+ | return ~OUbits0et1; | ||
+ | La propriété de divisibilité par 4 est vraie si «les deux derniers bits sont tous deux nuls», c'est à dire si «le bit 1 OU le bit 0 n'est PAS à VRAI». | ||
+ | | ||
+ | |||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | ===== E/ Fonctions classiques : | ||
+ | |||
+ | Ceci n'est qu'un résumé des **syntaxes** de ces différentes fonctions : si il subsiste certains doutes quant à leur emploi, je vous invite à visiter la page [[http:// | ||
+ | ==== Les tests ==== | ||
+ | // \\ | ||
+ | **if** : "Si la condition est respectée alors les instructions seront exécutées **une** fois" | ||
+ | \\ if (condition) { instructions } // \\ | ||
+ | |||
+ | **if (variante avec **else** (sinon)) :** Si le test est vrai alors " | ||
+ | |||
+ | < | ||
+ | |||
+ | ==== Les boucles ==== | ||
+ | |||
+ | **while (tant que):** "Tant que la condition sera respectée alors la boucle d' | ||
+ | // | ||
+ | \\ \\ | ||
+ | | ||
+ | //for( initialisation ; test ; incrément\décrément)// | ||
+ | \\ | ||
+ | __exemple :__ "Je veux que ma boucle d' | ||
+ | // for( int i = 0 ; i<5 ; i++) { instructions} // | ||
+ | |||
+ | ==== Fonctions utiles (mais spécifiques) ==== | ||
+ | |||
+ | |||
+ | **constrain: | ||
+ | y = constrain( x, m, M); \\ \\ // | ||
+ | y = x si m < **x** < M \\ | ||
+ | y = m si **x** < m \\ | ||
+ | y = M si M < **x** \\ // | ||
+ | |||
+ | **map :** Permet d' | ||
+ | // A = map( x, in_min, in_max, out_min, out_max);// \\ | ||
+ | est strictement équivalent à : \\ | ||
+ | A = (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; \\ | ||
+ | |||
+ | **goto: DELETEME à utiliser avec modération DELETEME ** \\ | ||
+ | |||
+ | Cette fonction permet **de sortir** d'une boucle dès qu' | ||
+ | Si on devait résumer goto en quelques mots, c'est la **téléportation** intrinsèque au programme ! | ||
+ | // \\ [instructions1; | ||
+ | :ptdr \\ | ||
+ | | ||
+ | goto ptdr; \\ | ||
+ | | ||
+ | // | ||
+ | à chaque fois que //" | ||
+ | |||
+ | **delay : ** Cette fonction permet de retarder de N millisecondes le programme. \\ | ||
+ | // | ||
+ | // | ||
+ | |||
+ | ==== Fonctions mathématiques ==== | ||
+ | Eh, oui ! Arduino les connait... en ce qui concerne la syntaxe, je vous conseille la chose suivante : \\ | ||
+ | // float x ; // x est un réel \\ | ||
+ | // float y ; // idem pour y \\ | ||
+ | // float z ; // | ||
+ | // y = f(x); // \\ | ||
+ | Où f(x) est remplacé par : | ||
+ | |||
+ | min(x, | ||
+ | max(x, | ||
+ | abs(x) | ||
+ | pow(x, | ||
+ | sqrt(x) | ||
+ | sin(x) | ||
+ | cos(x) | ||
+ | tan(x) | ||
+ | ==== Conversion de données ==== | ||
+ | |||
+ | char() | ||
+ | int() < fonction " | ||
+ | long() | ||
+ | float() < convertit un nombre en réel | ||
+ | |||
+ | |||
+ | ===== F/ Les quatre fonctions à action externe spécifiques à Arduino : ===== | ||
+ | |||
+ | ==== digitalRead : | ||
+ | Permet de contrôler si la tension à laquelle est soumise un pin est haute (5V) ou basse (0V) retourne la valeur sous une variable booléenne ayant pour valeurs // | ||
+ | // \\ | ||
+ | I=digitalRead(pin) // on affecte à I HIGH ou LOW | ||
+ | ==== digitalWrite : | ||
+ | Sans doute la fonction la plus simple et utile des quatre, elle a permis de réaliser le //programme Blink// ci-dessus. Quand vous l' | ||
+ | __mise à l' | ||
+ | __mise à l' | ||
+ | ==== analogRead : | ||
+ | Cette fonction permet de lire sur 1024 points de mesure une tension de 0 à 5V :-O. En français pur et simple cela signifie que si l'on dédie le pin A0 à cette mesure, que l'on le nomme // | ||
+ | // | ||
+ | Il est donc nécessaire de convertir cette mesure brute en mesure réelle, en millivolts : \\ \\ | ||
+ | On peut donc écrire | ||
+ | <note tip>A ceux qui ont remarqué les .0 après les précédents chiffres : ce n'est pas nécessaire de les mettre mais conseillé, en effet les mesures réelles sont rarement entières après de telles divisions, alors pour ne pas perdre de l' | ||
+ | <note warning> | ||
+ | // [[start: | ||
+ | ==== analogWrite (PWM ou hacheur en VF) : ==== | ||
+ | \\ | ||
+ | Les Arduinos ne délivrent **PAS** directement du courant continu analogique : ce serait trop facile pour vous, hein ? ;-) \\ | ||
+ | Mais pas de panique ! I existe des moyens de retranscrire en analogique ce que dit notre Arduino, en effet elle est dotée de **pins marqués PWM** c'est à dire des hacheurs. \\ | ||
+ | Le **PWM** est un signal rectangulaire (fréquence de l' | ||
+ | donc **r = DuréeSignalHaut/ | ||
+ | Bon, assez parlé voici une __image explicative__ \\ | ||
+ | {{ : | ||
+ | En fait, le rapport cyclique r est codé dans une Arduino entre 0 et 255, c'est à dire qu'il existe 255 niveaux d' | ||
+ | **Exemple** : je veux obtenir une tension en moyenne égale à 2V sur le pin // alim2v // . Je calcule r : ** r = 2/5 = 0.4 ** // | ||
+ | puis je calcule le codage correspondant : ** CODAGE = r*255 = 0.4*255 = 102 ** (si le nombre n' | ||
+ | puis j' | ||
+ | On pourra utiliser la formule générale : // ** analogWrite( " | ||
+ | |||
+ | < | ||
+ | \\ Par exemple : | ||
+ | // int k = TensionVoulue(t)*255/ | ||
+ | |||
+ | <note tip> Une **note spécifique** relative à la **conversion numérique-analogique** sera bientôt mise en ligne \\ | ||
+ | </ | ||
+ | |||
+ | <note important> | ||
+ | </ | ||
+ | |||
+ | === Petit aperçu de ce que ça donne à l' | ||
+ | Voici une boucle de commande PWM visualisée sur l' | ||
+ | |||
+ | void loop () { \\ | ||
+ | for( int i; i<256; i++) { \\ | ||
+ | AnalogWrite( Sortie, i); \\ | ||
+ | delay(10); */ -> valeur arbitraire mais il faut un petit delay pour y voir quelque chose /* \\ | ||
+ | } \\ | ||
+ | \\ | ||
+ | |||
+ | \\ | ||
+ | {{: | ||
+ | \\ | ||
+ | |||
+ | [[start: | ||
+ | |||
+ | ===== G/ Définir une fonction ===== | ||
+ | |||
+ | Lorsqu' | ||
+ | Une fonction doit comporter. | ||
+ | * des arguments (ou variables) | ||
+ | * une image (optionnel) | ||
+ | * un nom | ||
+ | * un type | ||
+ | * une structure de définition | ||
+ | ==== Types de fonctions ==== | ||
+ | * void -> Sans doute le plus courant, cette fonction **n'a pas d' | ||
+ | * int -> Permet de renvoyer **un entier** [CFR plus haut] | ||
+ | * float -> Permet de renvoyer **un réel** | ||
+ | * char -> Permet de renvoyer une **liste de caractères** | ||
+ | * boolean -> Permet de renvoyer une **variable booléene** | ||
+ | * etc... | ||
+ | ==== Syntaxe ==== | ||
+ | **typeDeFonction nomDeVotreFonction( typeDeVariable nomDeVariable, | ||
+ | \\ \\ | ||
+ | NB : ** On peut avoir autant de variable que l'on veut mais il faut préciser le type au préalable ! | ||
+ | ==== Exemples ==== | ||
+ | === Clignotant === | ||
+ | // void blink() { \\ \\ | ||
+ | digitalWrite(led, | ||
+ | delay(1000); | ||
+ | digitalWrite(led, | ||
+ | delay(1000); | ||
+ | } \\ | ||
+ | // Cette fonction est sensé faire clignoter une diode à 0.5Hz ! | ||
+ | === Correction proportionnelle === | ||
+ | On se donne un système asservi par un capteur donnant une tension Ucapteur on veut une tension Uconsigne. Une correction **proportionnelle** est en fait la multiplication de l' | ||
+ | \\ \\ | ||
+ | // **float proportionnele(float Ucapteur, float Uconsigne, float K)** { \\ \\ | ||
+ | float Erreur= (Uconsigne-Ucapteur)/ | ||
+ | float CorrectionProportionnelle=Erreur*K; | ||
+ | CorrectionProportionnelle=constrain(CorrectionProportionnelle, | ||
+ | return CorrectionProportionnelle; | ||
+ | } | ||
+ | // | ||
+ | ===== H - Le port serie ===== | ||
+ | //par Pierre Salles, que je remercie chaleureusement ! // | ||
+ | ====Présentation ==== | ||
+ | |||
+ | |||
+ | //"Ce qui se passe dans l' | ||
+ | \\ Ou pas. | ||
+ | |||
+ | Votre PC ne sert pas juste à envoyer une bout de code sur votre carte préférée. | ||
+ | \\ Ces deux lascars peuvent entretenir des relations plus que fusionnelles. 8-) | ||
+ | |||
+ | La liaison USB sert d' | ||
+ | avec quelques lignes de codes, vous pouvez accéder à toutes vos variables en | ||
+ | temps réels. | ||
+ | Vous pouvez aussi envoyer des instructions à l' | ||
+ | la souris. (mais on verra ça un peu plus tard). | ||
+ | |||
+ | {{ : | ||
+ | |||
+ | Le code : | ||
+ | |||
+ | //void setup() { | ||
+ | \\ Serial.begin(9600); | ||
+ | \\ Serial.print(" | ||
+ | \\ Serial.println(" | ||
+ | \\ Serial.print(" | ||
+ | \\ } | ||
+ | |||
+ | \\ void loop() { | ||
+ | } | ||
+ | // | ||
+ | |||
+ | rajouter image du serial avec ce prog. | ||
+ | |||
+ | Il faut d' | ||
+ | La valeur entre paranthèse est une valeur en bauds. \\ Cela correspond à un nombre de bits | ||
+ | transmis par seconde. | ||
+ | Les valeurs de référence sont : 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, | ||
+ | 38400, 57600, et 115200 | ||
+ | |||
+ | |||
+ | Ensuite, le Serial.print() permet d' | ||
+ | \\ Le Serial.println() permet d' | ||
+ | |||
+ | ===A quoi ça sert?=== | ||
+ | |||
+ | Le but n'est bien sur pas d' | ||
+ | \\ On peut l' | ||
+ | \\ \\ Exemple : \\ | ||
+ | \\ Mon programme ne marche pas!! Au secours! Que se passe t' | ||
+ | \\ Aide Dora à trouver la solution... | ||
+ | \\ | ||
+ | |||
+ | // int x = 0; | ||
+ | \\ int y = 0; | ||
+ | \\ void setup() {} | ||
+ | \\ \\ void loop () { | ||
+ | \\ while (x<100) { | ||
+ | \\ y++; | ||
+ | \\ } | ||
+ | \\ *partie utile du programme qui visiblement ne fonctionne pas* | ||
+ | \\ } | ||
+ | // | ||
+ | |||
+ | \\ Bon, pas besoin de chercher loin, mais c'est juste pour se faire une idée. Si vous ne trouvez pas, initialisez la liaison Serial comme expliqué précédemment (Serial.begin), | ||
+ | |||
+ | Correction : | ||
+ | |||
+ | // int x = 0; | ||
+ | \\ int y = 0; | ||
+ | \\ void setup() { | ||
+ | \\ Serial.begin(9600); | ||
+ | \\ } | ||
+ | \\ void loop () { | ||
+ | \\ while (x<100) { | ||
+ | \\ y++; | ||
+ | \\ Serial.print(" | ||
+ | \\ Serial.print(x); | ||
+ | \\ Serial.print(" | ||
+ | \\ Serial.println(y); | ||
+ | \\ delay(500); | ||
+ | \\ } | ||
+ | \\ *reste du programme* | ||
+ | \\ } | ||
+ | |||
+ | // | ||
+ | \\ Le delay(u) est une pause de u millisecondes. Si vous avez essayé de faire le programme seuls, sans mettre cette ligne, vous avez peut être eu un peu peur LOL | ||
+ | |||
+ | \\ Vous pouvez donc expliquer à Dora que la condition de sortie de la boucle n'est jamais vérifiée, et vous pouvez lui montrer les données du moniteur série pour justifier vos propos. | ||
+ | |||
+ | ===Mais encore...=== | ||
+ | \\ On peut quand même faire plus intéressant avec toutes ces valeurs. Vous pouvez les enregistrer automatiquement dans un fichier Excel par exemple. | ||
+ | \\ [[http:// | ||
+ | \\ Téléchargez le .zip. \\ Lancez le .exe \\ Un nouveau dossier va apparaitre, avec le fichier Excel. L' | ||
+ | |||
+ | \\ \\ Bon, la base est donnée ici. Cette liaison a beaucoup de potentiel, à découvrir dans la partie Processing pour les intéressés :-) | ||
+ | |||
+ | ====== III - Utilisation du logiciel ====== | ||
+ | <note important> | ||
+ | ===== A/ Compilateur ===== | ||
+ | Maintenant que vous savez parfaitement comment se structure un programme, il faudrait maintenant **l' | ||
+ | ==== Ma première compilation==== | ||
+ | Tout d' | ||
+ | \\ \\ | ||
+ | int led = 13; | ||
+ | | ||
+ | void loop () { | ||
+ | digitalWrite(led, | ||
+ | delay(1000); | ||
+ | digitalWrite(led, | ||
+ | } | ||
+ | \\ \\ | ||
+ | Bien, maintenant que vous avez copié le programme, vérifiez-moi ce dernier (compilation) en cliquant sur le bouton **en forme de coche**. | ||
+ | \\ \\ | ||
+ | **Plein d' | ||
+ | Rassurez-vous, | ||
+ | **Le logiciel vous affiche quelque chose comme ça:** \\ \\ | ||
+ | |||
+ | // core.a(main.cpp.o): | ||
+ | C:\Program Files (x86)\Arduino\hardware\arduino\cores\arduino/ | ||
+ | \\ | ||
+ | Le compilateur vous a donc dit qu'il n' | ||
+ | Bref, insérez au **bon endroit** la ligne de code suivante : \\ | ||
+ | void setup() { | ||
+ | pinMode(led, | ||
+ | } | ||
+ | ==== Ma deuxième compilation... ==== | ||
+ | Voici la version corrigée... | ||
+ | int led = 13; | ||
+ | | ||
+ | void setup() { | ||
+ | pinMode(led, | ||
+ | } | ||
+ | void loop () { | ||
+ | digitalWrite(led, | ||
+ | delay(1000); | ||
+ | digitalWrite(led, | ||
+ | } | ||
+ | | ||
+ | |||
+ | Recompilez donc ledit programme et... paf ! Un deuxième écran d' | ||
+ | **Le message dit :** | ||
+ | // sketch_nov18a.ino: | ||
+ | sketch_nov18a: | ||
+ | |||
+ | Oups ! Un point-virgule manque à l' | ||
+ | |||
+ | ==== Ma troisième sera la bonne ! ==== | ||
+ | int led = 13; | ||
+ | | ||
+ | void setup() { | ||
+ | pinMode(led, | ||
+ | } | ||
+ | void loop () { | ||
+ | digitalWrite(led, | ||
+ | delay(1000); | ||
+ | digitalWrite(led, | ||
+ | } | ||
+ | Recompilez le programme, qui cette fois sera **validé** en terme de syntaxe Arduino, mais cela ne signifie pas toujours qu'il fonctionne correctement. | ||
+ | ===== B/ Téléverser un programme ===== | ||
+ | Munissez vous de votre câble **USB**, et si votre ordinateur ne reconnait pas la carte, allez dans le gestionnaire des périphériques et installez le driver (se trouve dans le dossier de l' | ||
+ | Copiez le programme précédent, | ||
+ | Puis, appuyez sur le bouton téléverser (flèche vers la gauche) en ayant sélectionné au préalable le **modèle de la carte** . \\ | ||
+ | <note tip>Le téléversement implique une compilation de votre programme, on peut ainsi faire les deux étapes d'un coup ! </ | ||
+ | |||
+ | Eh bien quel beau clignotant vous avez là ! \\ | ||
+ | \\ | ||
+ | **Comment ça ? La LED de l' | ||
+ | \\ | ||
+ | En fait, elle s' | ||
+ | Rajoutez // | ||
+ | |||
+ | ===== C/ Liens, support logiciel et références ===== | ||
+ | ====Site officiel d' | ||
+ | [[http:// | ||
+ | ==Références du langage : très utiles pour ceux qui veulent aller plus loin== | ||
+ | http:// | ||
+ | ==Toute la gamme Arduino... == | ||
+ | http:// | ||
+ | ==Téléchargements utiles== | ||
+ | http:// | ||
+ | \\ | ||
+ | \\ | ||
+ | ==== Ma référence absolue en matière d' | ||
+ | \\ | ||
+ | **Avis aux amateurs de transistors** \\ | ||
+ | **Avis aux amateurs d' | ||
+ | **Avis aux amateurs de CMOS** \\ | ||
+ | **Avis aux amateurs de musique**\\ | ||
+ | Ce site risque bien de vous plaire : [[http:// | ||
+ | ====Site d'un " | ||
+ | [[https:// | ||
+ | ====Site d'un électronicien que vous reconnaîtrez...==== | ||
+ | Je sais, se faire de la pub c'est mal m(... surtout que j'ai lancé le site il y a peu :!: \\ | ||
+ | Néanmoins : [[http:// | ||
+ | |||
+ | ====== IV – Une réalisation " | ||
+ | |||
+ | //Maquette d' | ||
+ | // | ||
+ | <note warning> | ||
+ | \\ | ||
+ | **Si vous n'avez pas peur... continuez !** </ | ||
+ | |||
+ | ==== A/ Présentation du projet ==== | ||
+ | |||
+ | <note tip>En fait, j' | ||
+ | ==== Qu'est ce qu'un onduleur ? ==== | ||
+ | Un onduleur est un dispositif permettant de passer d'un courant de basse tension continu (ex: batterie 12VDC) à un courant alternatif de haute tension (230VAC). | ||
+ | ==== Comment construire un onduleur ? ==== | ||
+ | Le schéma générique est assez simple, il faut **générer une onde sinusoïdale de fréquence 50Hz** (réseau E.D.F) à partir du 12VDC, que cette dernière soit **insaturée en intensité** (en clair qu' | ||
+ | \\ | ||
+ | Deux problématiques se dressèrent donc face à moi... | ||
+ | === La qualité du signal === | ||
+ | On peut obtenir facilement des tensions alternatives avec des montages simples : | ||
+ | \\ | ||
+ | {{: | ||
+ | \\ | ||
+ | Ici, on remarque que le montage de l’oscillateur (**multivibrateur astable**) est simple (5 transistors, | ||
+ | Sans trop chipoter on peut considérer en **sortie de l' | ||
+ | \\ | ||
+ | {{: | ||
+ | \\ | ||
+ | Ruse de sioux : on inverse la voie 2... | ||
+ | \\ | ||
+ | {{: | ||
+ | \\ | ||
+ | et bim ! | ||
+ | \\ | ||
+ | Mais si on branche une ampoule aux bornes des transistors de puissance... | ||
+ | \\ | ||
+ | {{: | ||
+ | \\ | ||
+ | patatras ! | ||
+ | |||
+ | === L' | ||
+ | |||
+ | Un jour, mon professeur de SI m'a dit que le rapport d'un transformateur était constant... ce même jour j'ai mesuré 500V au lieu de 230V en sortie de ce dernier. Comme quoi, asservir en tension un onduleur est primordial si vous voulez que votre alimentation de smartphone soit encore valide après une première utilisation ;-) | ||
+ | \\ | ||
+ | Voici quelques images illustrant le problème : on fait varier la charge en sortie (ou impédance) et on se rend compte que la tension d' | ||
+ | \\ | ||
+ | En effectuant les mesures dans les conditions suivantes : \\ | ||
+ | {{: | ||
+ | \\ | ||
+ | On observe : \\ | ||
+ | {{: | ||
+ | \\ | ||
+ | |||
+ | |||
+ | |||
+ | ==== B/ Que vient faire Arduino dans ce montage ? ==== | ||
+ | |||
+ | J'ai utilisé une Arduino nano en vue d' | ||
+ | Dans un pur souci de sécurité & de moyens, j'ai réalisé toutes mes expériences en 110V mais la problématique est quasi-similaire en 230V... | ||
+ | \\ \\ | ||
+ | Mais trois problèmes ésotériques se dessinèrent contre l' | ||
+ | === Mesurer... === | ||
+ | La tension était en 110V alternatif alors que Umax<5V __**continus**__ pour mon Arduino. \\ | ||
+ | Il a donc fallu créer un montage redresseur et diviseur de tension sans trop perdre en **rapidité & précision**. | ||
+ | === Générer le signal sinusoïdal === | ||
+ | Arduino ne peut pas générer sans " | ||
+ | \\ | ||
+ | {{: | ||
+ | |||
+ | \\ | ||
+ | Voici le signal en sortie de ce nouvel oscillateur : | ||
+ | \\ | ||
+ | | ||
+ | \\ | ||
+ | Et son spectre, super centré ;-) | ||
+ | \\ | ||
+ | {{: | ||
+ | === Contrôler le tout en entrée, grâce à la Nano === | ||
+ | J'ai fait une chose assez stupide pour le contrôle de l' | ||
+ | - Lissage du PWM (signaux rectangulaires en sortie de l' | ||
+ | - Comme il ne restait plus rien, première amplification (A2) | ||
+ | - Multiplication par le signal **constant en amplitude**à 50 Hz du pont de Wien | ||
+ | - Amplification de puissance | ||
+ | - Transformation du signal (" | ||
+ | - Redressage d'une partie infime du courant, lissage et adaptation en vue de contrôler la valeur de l' | ||
+ | \\ | ||
+ | Tout se lit dans le schéma suivant : | ||
+ | \\ | ||
+ | {{: | ||
+ | ==== C/ Correction et codage adapté ==== | ||
+ | Une étude de l' | ||
+ | \\ | ||
+ | Le schèma-blocs était le suivant (les constantes étant obtenues en régime permanent ou temporel expérimentalement (tests de réponses en boucle ouvertes, mesures d' | ||
+ | \\ | ||
+ | {{: | ||
+ | |||
+ | ===Divers diagrammes pour prouver la stabilité de mon système faits sous Scilab :=== | ||
+ | == Diagramme de black == | ||
+ | {{: | ||
+ | == Diagramme de Bode == | ||
+ | {{: | ||
+ | === Codage Arduino === | ||
+ | Ce programme ultra-court suffisait (ceci prouve l' | ||
+ | {{: | ||
+ | |||
+ | |||
+ | ==== D/ Résultats (positifs !!) ==== | ||
+ | |||
+ | Je vous laisse juger tout cela grâce à des images : | ||
+ | === Fidélité du modèle === | ||
+ | ==Scilab : == | ||
+ | (vérifiez le temps de réponse et les asymptotes 8-)) \\ | ||
+ | {{: | ||
+ | == Réalité : == | ||
+ | {{: | ||
+ | \\ | ||
+ | L' | ||
+ | === Utilité de l' | ||
+ | |||
+ | == Sans lui : le smartphone grille... == | ||
+ | {{: | ||
+ | == Avec lui : il survit... == | ||
+ | {{: | ||
+ | |||
+ | |||
+ | === Qualité du signal === | ||
+ | {{: | ||
+ | |||
+ | <note tip> | ||