Bienvenue

Si vous désirez participer au forum, connectez-vous avec vos identifiants ou créez vous un compte.

(En cas de création de compte, un email vous sera envoyé pour validation et vous serez averti par courrier de l'ouverture de votre accès)

Nom d'utilisateur : Mot de passe : Se souvenir de moi

SUJET : A la découverte de l'Arduino

A la découverte de l'Arduino il y a 3 semaines 3 jours #335

A la recherche de solutions pour construire soi-même des instruments léger et peu coûteux, certains constructeurs d’ULM ont fait apparaître sur les forums des instruments de bord à base d’Arduino.

Apparu dans les universités et centres de recherches il y a plus de dix ans, l’Arduino est un microcontrôleur open source très peu coûteux et polyvalent.

La seule limite aux usages est votre imagination. Vous trouverez son utilisation dans le prototypage de laboratoires de recherche, dans des projets personnels autour de la domotique ou de la robotique et même dans certaines oeuvres d’art basées sur l’interaction, le mouvement ou les jeux de lumières.

Qu’est-ce qu’un microcontrôleur ?

Il y en a partout : le plus évident est celui de votre machine à laver où il a supplanté les programmateurs mécaniques, permettant d’avoir de beaux écrans de contrôle et plus de possibilités de réglage. En fait, tout ordinateur est un assemblage plus ou moins complexe de microcontrôleurs.

Dans le cas qui nous intéresse, il s’agit de matériels conçus spécifiquement pour gérer des entrées et des sorties.
Les entrées sont connectées à des sondes (analogiques ou numériques) ou des contacteurs d’état (ouvert/fermé) et les sorties permettent de commander des accessoires (relais, écrans, périphériques connectés, leds…)

Très polyvalent, vous trouverez des microcontrôleurs Arduino dans des drones, des robots, des objets connectés, des imprimantes 3D ou encore dans des machines à commandes numériques (CNC).

Sur une seule carte, il rassemble un microprocesseur, de la mémoire flash pour stocker le programme, de la mémoire vive pour l’exécuter et un nombre variable d’entrées sorties numériques et analogiques.

Retrouvez la suite de cette présentation dans Les Cahiers du RSA #297 de décembre 2017.

SIte officiel : https://www.arduino.cc

Patrick
Dernière édition: il y a 3 semaines 1 jour par 08484.
L'administrateur a désactivé l'accès en écriture pour le public.

A la découverte de l'Arduino il y a 2 semaines 1 jour #360

Commencer "vraiment" avec ARDUINO :
ou comment "mettre un pied dans la porte ..."

On trouve facilement des terra-octets de documentation sur ARDUINO, c'est un des ses avantages principaux. Mais, avant de pouvoir profiter du génie des autres, il faut avoir réussi le démarrage initial ...

Ce post correspond à ce ce que j’aurais aimé trouver quand j’ai voulu m’introduire dans le monde merveilleux de la programmation … C’est une tentative et son but (ambitieux) est vraiment de permettre à ceux qui ont envie de s’y mettre ou ont tenté sans persévérer, car ils ont buté sur un problème qu’ils n’ont pas pu résoudre, de faire tourner un petit programme qu’ils pourront faire devenir grand.

Ce texte a donc vocation à être amélioré par les retours et remarques qu’il pourra susciter …

Il est supposé qu’une carte ARDUINO est prête à être connectée à un PC avec son cordon USB et que le logiciel de programmation (l’IDE) est installé. Si ce n’est pas le cas, on peut aller voir ICI.
Pour ceux qui sont en froid avec l'Anglais, il existe des sites francophones dont celui-ci où tout n'est pas gratuit mais intéressant et en particulier cette page. Elle reprend, classées par grands usages, les nombreuses fonctions du langage de programmation de l’ARDUINO qui est une adaptation d’un langage très utilisé par les informaticiens : le langage C. Mais cet accès aux références du langage suppose qu’on sait déjà programmer, sinon on ne peut rien faire de la mine d’informations disponibles.

Pour accéder au monde de la programmation, il faut bien sûr trouver la porte d’entrée et ensuite il faut l’ouvrir ! Pour réussir à l’ouvrir, un bon moyen est de glisser un pied dans la porte, à la manière des vendeurs d’aspirateurs du siècle dernier :) A partir de ce moment-là, un déclic va se produire dans la tête de l’impétrant : il sait qu’il ne sait encore pratiquement rien mais il comprend qu’il a la capacité d’apprendre seul ce dont il a besoin pour atteindre son objectif.

ARDUINO c’est un peu comme EXCEL, on peut l’employer pour des choses très élémentaires ou pour réaliser des trucs considérables, donc, à chacun son objectif …
Apprendre seul n’est pas vraiment la réalité, c’était la difficile situation de l’apprenti programmeur d’antan, c’est-à-dire d’avant internet. Aujourd’hui la situation est toute autre, il y a toujours quelqu’un sur la planète qui a trouvé une solution au problème qu’on se pose et qui a pris la peine de le raconter dans un forum ou un blog. Sur la planète, cela veut dire qu’il le raconte souvent en anglais …

Mais, avançons sur la façon de mettre un pied dans la porte ….

Un ARDUINO est un micro-contrôleur, micro pour indiquer qu’on a affaire à un tout petit ordinateur et contrôleur défini bien ce qu’il fait
Vous savez déjà qu’il dispose de bornes d’entrées (INPUT) et de bornes de sortie (OUTPUT). Sur les entrées on va raccorder tout ce qui va donner une information à l’ARDUINO, par exemple et ce n’est pas exhaustif, l’ouverture ou la fermeture d’un microcontact, la tension issue d’une sonde de pression ou de température, le train d’impulsions issue de la prise compte-tours ou du capteur de fuel flow ….
Sur les sorties, on va raccorder tous les « actionneurs » qui vont produire les effets recherchés, par exemple allumer un voyant, faire tourner un petit ou un gros moteur, émettre un son, etc ….
Tout ce qui émet ou peut recevoir un signal électrique peut donc être détecté et/ou actionné par un ARDUINO, à la condition EXPRESSE que les tensions en sortie et en entrée restent dans la plage 0 V - 5 V. Les entrées et sortie peuvent être Analogique, avec une tension pouvant prendre une valeur quelconque comprise entre 0 à 5 V ou Digitales avec deux possibilités, 0 V pour le niveau bas (LOW) et 5 V pour le niveau haut ( HIGH).
D’autre part, micro suppose peu puissant et si l’ARDUINO peut commander directement un voyant (de préférence une LED) ou un petit servo de type radiocommande, il faut généralement prévoir une interface de puissance pour commander des dispositifs plus « gourmands », comme un trim, un moteur de volets ou une pompe.

Mais tout cela peut être connu et compris sans qu’on ait réussi à mettre le pied dans la porte ….
Que fait un programme qui « tourne » sur un ARDUINO ?

On peut comparer le comportement du programme avec celui du hamster qui pédale sans fin pour faire tourner sa roue. Le programme va s’exécuter du début jusqu’à sa fin …. et immédiatement repartir au début, dérouler jusqu’à la fin, repartir au début ….. Indéfiniment. Il tourne en boucle (loop) et, il faut avoir en tête qu’il fait quelques milliers de tours par secondes …

Que fait un programme ARDUINO dans sa ronde infernale ?

En déroulant la boucle loop il va analyser toutes les entrées sollicitées, effectuer les tests et exécuter tout ce qui peut l'être. Il est généralement assez facile d'effectuer mentalement le parcours du hamster, pour voir ce qu'il rencontre sur sa routes
Cela peut être une entrée digitale qui est normalement à l’état haut (HIGH ou 5 V) et qui passe à l’état bas (LOW ou 0 V) car un micro contact l’a mise à la masse. Cela peut être une sonde de température dont la tension passe au-dessus (ou en dessous) d’une valeur prédéfinie.
Cette détection ou mesure étant faite, la partie du programme prévue pour ce cas de figure va s’exécuter. Cela peut être l’allumage d’un voyant qui va être activé par la sortie digitale associée à ce voyant. Réaliser un projet à base d'ARDUINO consiste donc à le raccorder avec tous les capteurs et sondes d'une part et avec les actionneurs, voyants, relais, moteurs d’autre part et à faire le programme qui relie le tout..

A quoi va ressembler un programme qui va allumer un voyant indiquant que la verrière n’est pas verrouillée ?
Habituellement, quand on s’adresse à des débutants, on leur fait faire un programme dénommé « HELLO WORLD » qui ne sert à rien et qui suppose en plus qu’on sait afficher un texte ….
Donc allons-y pour la verrière, c’est un truc clair pour tout le monde.
Répéter indéfiniment 
{
   Si( l’entrée D4 est à l’état haut) // c’est-à-dire que le microcontact qui la met à la masse est ouvert
   {
      Mettre la sortie D13 à l’état haut // le niveau haut (HIGH) de 5V va alimenter le voyant
   }
   Sinon // c’est-à-dire que le micro contact qui la met à la masse est fermé
   {
      Mettre la sortie D13 à l’état Bas //avec le niveau bas (LOW) de 0V, le voyant est éteint
   }
}
J’entends les petits malins qui disent qu’il n’y a pas besoin d’un microcontrôleur pour faire ça C’est bien vrai, mais si on veut qu’une alarme soit efficace, il faut qu’elle clignote et là, c’est plus compliqué (bien qu’on trouve des LEDs clignotantes !).
Le programme « clignotant » avec 200 ms d’allumage et 300 ms d’extinction devient alors :
Répéter indéfiniment 
{
   Si( l’entrée D4 est à l’état haut) // c’est-à-dire que le microcontact qui la met à la masse est ouvert
   {
      Mettre la sortie D5 à l’état haut // le niveau haut (HIGH) de 5V va alimenter le voyant
      Attendre 200 ms  // le programme s’est mis en pause pendant 200 ms et ne peut rien faire d’autre
      Mettre la sortie D5 à l’état bas // le niveau bas (LOW) vaut 0V et  le voyant va s’éteindre
      Attendre 300 ms  // le programme s’est mis en pause pendant 300 ms et ne peut rien faire d’autre
   }
}
Derrière les // des commentaires qui ne font pas partie de ce que le programme exécutera
Note pour « ceux qui savent » et qui s’étonneraient qu’il n’y ait pas de branche else pour éteindre la LED quand la verrière est fermée, il faut considérer que l’entrée D4 serait mise à l’état bas dans le setup …

Dans la vraie vie ARDUINesque cela ressemble à cela :

On remarque que les mots clés du langage sont colorés. Si on avait tapé DigitalWrite à la place de digitalWrite, il n’y aurait pas eu de coloration en rouge, chose qui doit inquiéter le programmeur.
Les langages de programmation ne tolèrent pas l’à peu près, la syntaxe doit être RIGOUREUSEMENT respectée. C’est la source de nombreuses erreurs (débutant ou pas) heureusement assez faciles à débusquer. Le terme débusquer n’est pas choisi au hasard car programmer c’est, pour une grosse part du temps passé, aller à la chasse à ses propres erreurs.
Quand on programme, il faut laisser son amour propre au vestiaire. La programmation est une grande école d’humilité …. Le débutant qui fait des erreurs est un débutant normal …

On remarque aussi les points virgules qui terminent les lignes pour lesquelles une action est demandée et aussi les accolades ({ }) qui encadrent le code qui est concerné par le mot clé qui précède.
A la suite de loop() il y a l’ensemble du programme qui, comme son nom l’indique, tourne en boucle.
A la suite de if il y a le code à exécuter si la condition exprimée par (4 == HIGH) est respectée. Dans le cas contraire (verrière verrouillée) cette partie du programme est sautée, elle n’est pas exécutée.

On voit que, bizarrement, pour exprimer que l’entrée 4 est égale au niveau HIGH, on utilise le double signe = (==). Ceci vient du fait que le signe = est employé pour « charger » une valeur dans une variable. On peut écrire par exemple v_temp_huile = 98 ;
On emploie beaucoup la fonction if et la confusion entre les deux façons de dire égal est aussi une «discrète» source d’erreur …

Enfin, le double slash (//) sert à isoler les commentaires. Ils sont une partie très importante du programme bien qu’ils ne soient pas pris en compte par le calculateur. Ils servent à expliquer la démarche du programmeur (souvent au programmeur lui-même quelques semaines ou mois après qu’il ait terminé son chef d’œuvre !), un programme sans commentaire est en pratique inexploitable.

Dernier « détail » (pour le moment), si on perd de vue le hamster qui tourne dans sa roue, on peut penser qu’après avoir allumé la LED, attendu 200 ms et éteint la LED, on a fait le job. Que neni, si on teste on verra que la diode s’allume si le contact est ouvert et s’éteint à sa fermeture, mais pas de clignotant. La raison est simple (si on pense au hamster), dans la microseconde qui suit l’extinction de la LED, le programme reprend au début et … allume la LED. On verrait certainement la brève chute de tension au borne de la LED avec un oscilloscope, mais pas avec un œil humain.
Il faut donc qu'il y ait une pause après l'extinction de la LED. Ce fonctionnement en boucle doit toujours être à l’esprit de celui qui réfléchit à la logique de son programme, à son algorithme.

Pour mettre vraiment le pied dans la porte, il faut que ce programme marche vraiment et pour cela il faut d’abord planter le décor. Avant que le hamster puisse tourner comme un fou, il y a quelques préalables.
Tout à fait au début du programme, on va indiquer à l'ARDUINO de quelle façon on va utiliser ses entrées et ses sorties qu'on va d'ailleurs baptiser (en créant des variables) pour rendre plus facile la création et la lecture du programme. C’est l’endroit où on fait les « déclarations »
Puis, dans une partie dédiée à cet usage (le SETUP) on va préciser la situation de départ, fixer des valeurs initiales par exemple. Le SETUP sera toujours exécuté (une seule fois) au moment de la mise sous tension ou après un RESET . Et le hamster pourra entamer sa ronde sans fin ….
Le programme va ressembler à cela

Note : La sortie digitale 13 pour commander la LED n'a pas été choisie au hasard. Les cartes ARDUINO ont une petite LED orangée raccordée à D13, ce qui permet de faire notre manip sans rien raccorder. Pour simuler le contact de verrière il suffit de passer un câble de la broche D4 vers la masse ….

Ce programme fonctionne parfaitement, mais utiliser un ARDUINO juste pour un voyant de verrière, n'est pas le top de la modernité car il peut faire 100 fois plus de choses …
Pour cela il ne faut pas le freiner dans sa course comme on le fait avec les 2 instructions delay qui le font roupiller pendant ½ seconde à chaque tour. Alors qu'il pourrait faire des milliers de tours / seconde, le programme ne pourra en faire que 2 ….
delay n'est donc pas la bonne façon de procéder et de façon générale, il ne faut l'employer que lorsqu'on veut vraiment ralentir la ronde du hamster.
On va donc jouer avec le chronomètre interne de l'ARDUINO et en particulier avec l'instruction millis() qui renvoie chaque fois qu'elle est sollicitée, le nombre de millisecondes écoulées depuis la mise sous tension.
Ci-dessous, la nouvelle version du programme.
// Programme verriere fonctionnel mais sans procédure

// ******** ci-dessous les déclarations de variables **************

int pin_LED = 13 ; // on crée une variable pin_LED (de type integer) et en même temps on lui donne la veleur 13.
// 13 est le numéro de la sortie digitale à laquelle sera raccordée la led
int pin_contact = 4 ; //  idem avec pin_contact qui vaut 4. 4 est le numéro de l'entrée digitale
// à laquelle sera raccordée le contact normalement ouvert du micro contact de verrière

unsigned long time_fin_ON ; // "heure" de fin d'allumage. unsigned long pour pouvoir compter assez de milisecondes ...
unsigned long time_fin_OFF ; // "heure" de fin d'extinction.
int nb_ms_ON = 200 ; // durée d'allumage en ms
int nb_ms_OFF = 300 ; // durée d'extinction en ms
boolean flag_LED = true ; // boolean car le flag est levé ou baissé, vrai ou faux, en langage ARDUINO : true ou false
// flag_LED est positionné à true pour que le clignotement de la LED débute par l'allumage si le programme démarre avec la verrière ouverte.

// ************* fin de la déclaration des variables **********

void setup() // dans le SETUP, tout ce qui est utile de préciser avant de démmarer
{
  pinMode(pin_contact , INPUT_PULLUP ); // la broche 4(valeur de pin_contact)est définie comme une entrée et PULLUP indique que si la broche
  // n'est raccordée à rien son état est forcé au niveau HIGH.
  // C'est la méthode à employer quand on veut détecter un contact.
  pinMode(pin_LED , OUTPUT ); // la broche 13 (valeur de pin_LED)  est définie comme une sortie.

  time_fin_ON = millis() + nb_ms_ON ; // on calcule la fin de l'allumage à la mise sous tension pour le cas où la verrière est ouverte
}

void loop() // c'est la roue du hamster :-)
{
  if (digitalRead(pin_contact) == HIGH) // la verrière est ouverte et la LED clignote
  {
    if (flag_LED) //  pendant le clignotement, la LED est allumée
    {
      digitalWrite(pin_LED , HIGH) ; // on allume et on la maintient allumée
      if ( millis() > time_fin_ON) // on a atteint la fin de l'allumage

        flag_LED = false ; // on bascule (au prochain tour)vers l'extinction
      time_fin_OFF = millis() + nb_ms_OFF ; // on calcule au moment de l'extinction, l'heure de fin d'extinction
    }
    else  // pendant le clignotement, la LED est éteinte
    {
      digitalWrite(pin_LED , LOW) ;
      if ( millis() > time_fin_OFF) // on a atteint la fin de l'extinction
      {
        flag_LED = true ;  // on va basculer (au prochain tour) vers l'allumage
        time_fin_ON = millis() + nb_ms_ON ; // on calcule au moment de l'allumage, l'heure de fin d'allumage
      }
    }
  }
  else // la verrière est fermée ...
  {
    digitalWrite(pin_LED , LOW) ; //.... et donc la LED est maintenue éteinte.
    flag_LED = true ; // pour commencer par allumer la LED si la verrière s'ouvre
    time_fin_ON = millis() + nb_ms_ON ; // on recalcule (à chaque passage du hamster) l'heure de fin d'allumage quand la verrière va s'ouvrir
  }
}
Ce code est fonctionnel et pour le récupérer, il faut créer un nouveau programme dans l’IDE ARDUINO, effacer toutes les lignes existantes (crées automatiquement) et faire un Copier/Coller. Dans l’IDE ARDUINO faire Enregistrer sous à un endroit et avec un nom au choix … dont il suffit de se souvenir !
Le principe du programme est le suivant :
Un premier test détermine si la verrière est fermée (dans ce cas la LED est éteinte) ou ouverte. Dans le deuxième cas, la LED clignote et à cette fin on fait basculer un indicateur booléen (flag_LED qui est vrai ou faux) en fin d'allumage et en fin d'extinction. On calcule à chaque fois l'heure (en millisecondes) de fin de la séquence suivante (allumage ou extinction).
Il y a deux tests if imbriqués, ce qui est très fréquent. Pour bien comprendre il faut suivre le hamster … pas à pas !
Ce programme est parfaitement opérationnel mais il n’est pas dans la forme définitive qu'on peut recommander.
Dans la dernière version, la fonction de surveillance de la fermeture de verrière va constituer une procédure dont le libellé seul sera dans la boucle loop(). Ainsi, un programme qui traite de nombreuses fonctions sera facile à lire et à maintenir. Dans la boucle loop() on n'aura donc que les noms des différentes procédures qui seront bien isolées les unes des autres. On pourra voir facilement la logique générale d’un programme complexe.
Cela donnera, ci-dessous, la version définitive (pour cette fois) qui a avec un petit supplément très utile.
// Programme Voyant_verriere_03. Forme complète

// ******** ci-dessous les déclarations de variables **************

int pin_LED = 13 ; // on crée une variable pin_LED (de type integer) et en même temps on lui donne la veleur 13.
// 13 est le numéro de la sortie digitale à laquelle sera raccordée la led
int pin_contact = 4 ; //  idem avec pin_contact qui vaut 4. 4 est le numéro de l'entrée digitale
// à laquelle sera raccordée le contact normalement ouvert du micro contact de verrière

unsigned long time_fin_ON ; // unsigned long pour pouvoir compter assez de milisecondes ...
unsigned long time_fin_OFF ;
int nb_ms_ON = 150 ;
int nb_ms_OFF = 400 ;
boolean flag_LED = true ; // boolean car le flag est levé ou baissé, vrai ou faux, en langage ARDUINO : true ou false
// flag_LED est positionné à true pour que le clignotement de la LED débute par l'allumage

// ************* fin de la déclaration des variables **********

void setup() // dans le SETUP, tout ce qui est utile de préciser avant de démmarer
{
  pinMode(pin_contact , INPUT_PULLUP ); // la broche 4(valeur de pin_contact)est définie comme une entrée et PULLUP indique que si la broche
  // n'est raccordée à rien son état est forcé au niveau HIGH.
  // C'est la méthode à employer quand on veut détecter un contact.
  pinMode(pin_LED , OUTPUT ); // la broche 13 (valeur de pin_LED)  est définie comme une sortie.

  time_fin_ON = millis() + nb_ms_ON ; // on calcule la fin de l'allumage à la mise sous tension pour le cas où la verrière est ouverte
  Serial.begin(115200); // pour le moniteur
}

void loop() // c'est la roue du hamster :-)
{
  LED_clignote() ; // renvoie vers la procédure 
  Serial.println(millis()) ;
  
// la suite du code 
// et cent autres choses qu'ARDUINO pourra faire ....
// ...
}

// ************ ci-dessous, les fonctions et procédures ******************
void LED_clignote() // la procédure contient les lignes de programme qui étaient dans la boucle loop
{
  if (digitalRead(pin_contact) == HIGH) // la verrière est ouverte et la LED clignote
  {
    if (flag_LED) //  pendant le clignotement, la LED est allumée
    {
      digitalWrite(pin_LED , HIGH) ; // on allume et on la maintient allumée
      if ( millis() > time_fin_ON) // on a atteint la fin de l'allumage

        flag_LED = false ; // on bascule (au prochain tour)vers l'extinction
      time_fin_OFF = millis() + nb_ms_OFF ; // on calcule au moment de l'extinction, l'heure de fin d'extinction
    }
    else  // pendant le clignotement, la LED est éteinte
    {
      digitalWrite(pin_LED , LOW) ;
      if ( millis() > time_fin_OFF) // on a atteint la fin de l'extinction
      {
        flag_LED = true ;  // on bascule (au prochain tour)vers l'allumage
        time_fin_ON = millis() + nb_ms_ON ; // on calcule au moment de l'allumage, l'heure de fin d'allumage
      }
    }
  }
  else // la verrière est fermée ...
  {
    digitalWrite(pin_LED , LOW) ; //.... et donc la LED est maintenue éteinte.
    flag_LED = true ; // pour commencer par allumer la LED si la verrière s'ouvre
    time_fin_ON = millis() + nb_ms_ON ; // on recalcule (à chaque passage du hamster) l'heure de fin d'allumage quand la verrière va s'ouvrir
  }
}
L'IDE d'ARDUINO dispose d'un dispositif nommé MONITEUR (qu’on lance depuis le menu Outils) vers lequel le programme qui tourne dans l’ARDUINO peut envoyer des infos. Par exemple, pour voir à quelle vitesse tourne le hamster, on envoie l'heure (avec millis() )à chaque "tour". Avec un ARDUINO UNO (un grand classique) le programme tourne 1500 fois par secondes ….
Pour cela on a rajouté Serial.begin(115200); dans le setup() pour initialiser la communication (de type série) entre l'ARDUINO et le MONITEUR (inclus dans l'IDE) et dans la boucle loop(), Serial.println(millis()) ;
Serial.println effectue un retour à la ligne après son écriture alors que Serial.print imprime tout à suivre ….
Le MONITEUR est un élément indispensable à la mise au point d'un programme. Il permet de d'envoyer des marqueurs de son choix à des endroits choisis pour "tracer" le hamster. On retrouve là, la technique du Petit Poucet !

Sur ce petit exemple, un bon nombre de notions de base ont été passées en revue et la structure de ce programme peut servir de canevas à des cas de figure très variés.
Il devrait permettre à un amateur normalement déterminé de mettre son pied dans la porte du monde merveilleux de la programmation. ….

ATTENTION l’activité de programmation est addictive :) :) :)

Quelques infos en vrac :
Pour travailler en analogique (jauges carburant, capteur de pression, potentiomètre de recopie de position) les instructions cousines de digitalRead () et digitalWrite() sont :
analogRead (numéro de broche analogique) renvoie une valeur entre 0 et 1024 correspondant à une tension de 0 à 5V. Par exemple, on pourrait avoir : v_temp = analogRead (pin_sondeTemp) ;
analogWrite (numéro de broche PWM, valeur de 0 à 255) est une sorte de fonction « variateur » pour agir sur la luminosité d’une LED ou la vitesse d’un moteur. Les broches prévue pour le PWM (Pulse Witdth Modulation) dépendent du type de carte ARDUINO.

Les cartes ARDUINO les plus courantes sont la UNO, la MEGA (plus puissante) et la NANO aux caractéristiques identiques à la UNO mais bien plus compacte. Je trouve que cette dernière est intéressante car elle est facile à utiliser sur une plaque d’essai (avec des straps) pour implanter quelques composants supplémentaires … De plus elle permet de faire des montages définitifs très compacts sur une plaque perforée à souder ou mieux sur un circuit imprimé.
Un NANO d’origine (italienne) vaut une vingtaine d’Euros, on en trouve pour moins de 5 Euros direct from China avec quelques risques … forcément. Pour limiter les risques il faut les acheter par poignées ! Pour faire des économies, le chip de communication n’est pas standard et l’utilisation moins facile (mais c’est surmontable).
Il existe des cartes beaucoup plus puissantes, programmables avec l’IDE ARDUINO et compatibles avec la majorité de ses LIBRAIRIES (ou BIBLIOTHEQUES) comme la TEENSY 3.2.

Un mot au sujet des LIBRAIRIES. Quand on cherche à réaliser une fonction un peu complexe, la première chose à faire et de voir s’il n’y a pas une librairie qui fait le job très facilement … La communauté ARDUINO est très active voire prolifique !
Mais les LIBRAIRIES, en dehors de celles qui sont déjà présentes en standard dans l’IDE et qu’on utilise à la manière de Monsieur JOURDAIN, on s’y intéresse au moment où on met le deuxième pied dans la porte :)

Bons grattages de tête ...

Michel
MCRO1 F-PMTR / LFOU
Dernière édition: il y a 2 semaines 1 jour par 10585.
L'administrateur a désactivé l'accès en écriture pour le public.

Vos assurances RSA

Petites annonces

Retrouvez les petites annonces du site ou déposez les vôtres.

Boutique RSA

La Boutique est à votre disposition pour renouveler ou prendre une adhésion en ligne, adhérer au RSANAV, aussi acheter un article RSA (Textiles, Casquettes, Cahiers du RSA, goodies, ...)

Cahiers du RSA

Depuis 1947, notre très belle revue fédérale est une publication technique. Documentée et reconnue dans le monde aéronautique, elle démontre notre savoir faire et donne de précieux conseils.

Clubs RSA

Votre fédération représente de nombreux Aéroclubs, Associations de construction, de restauration, Musées et structures de sauvegarde du patrimoine, mais aussi, tous les passionnés que vous êtes.

RSANav

Le RSA-Nav est un service alternatif à celui de l’OSAC pour les renouvellement des certificats de navigabilité de nos aéronefs agréé par la DGAC. Nos 38 experts "PEN" bénévoles sont à votre disposition à proximité de votre terrain.