Programmation Arduino pour débutants. Arduino pour débutants : instructions étape par étape. Programmation et projets Arduino : par où commencer

Ce simulateur fonctionne mieux sur le navigateur Chrome
Regardons de plus près Arduino.

Arduino n'est pas un gros ordinateur pouvant être connecté à des circuits externes. Arduino Uno utilise Atmega 328P
C'est la plus grosse puce du tableau. Cette puce exécute des programmes stockés dans sa mémoire. Vous pouvez télécharger le programme via USB à l'aide de l'IDE Arduino. Le port USB alimente également l’arduino.

Il y a un connecteur d'alimentation séparé. La carte possède deux broches étiquetées 5 V et 3,3 V, qui sont nécessaires pour alimenter divers appareils. Vous trouverez également des broches marquées GND, ce sont les broches de masse (la masse est 0V). La plateforme Arduino dispose également de 14 broches numériques, numérotées de 0 à 13, qui se connectent à des nœuds externes et ont deux états, haut ou bas (activé ou désactivé). Ces contacts peuvent fonctionner comme sorties ou comme entrées, c'est-à-dire ils peuvent soit transmettre certaines données et contrôler des appareils externes, soit recevoir des données d'appareils. Les broches suivantes de la carte sont étiquetées A0-A5. Ce sont des entrées analogiques pouvant recevoir des données de divers capteurs. Ceci est particulièrement pratique lorsque vous devez mesurer une certaine plage, telle que la température. Les entrées analogiques ont des fonctions supplémentaires qui peuvent être activées séparément.

Comment utiliser une carte de développement.

La maquette est nécessaire pour connecter temporairement les pièces, vérifier le fonctionnement de l'appareil, avant de tout souder ensemble.
Tous les exemples suivants sont assemblés sur une maquette afin que vous puissiez rapidement apporter des modifications au circuit et réutiliser des pièces sans vous soucier de la soudure.

La planche à pain comporte des rangées de trous dans lesquels vous pouvez insérer des pièces et des fils. Certains de ces trous sont connectés électriquement les uns aux autres.

Les deux rangées du haut et du bas sont reliées en rangées sur toute la planche. Ces lignes sont utilisées pour alimenter le circuit. Il peut s'agir de 5 V ou de 3,3 V, mais dans tous les cas, la première chose à faire est de connecter 5 V et GND à la planche à pain, comme indiqué sur l'image. Parfois, ces connexions de rangées peuvent être rompues au milieu du tableau, alors si vous en avez besoin, vous pouvez les connecter comme indiqué sur l'image.

Pourquoi une résistance est-elle nécessaire dans un circuit ? Dans ce cas, cela limite le courant qui traverse la LED. Chaque LED est conçue pour un certain courant, et si ce courant est plus élevé, la LED tombera en panne. Vous pouvez découvrir quelle doit être la valeur de la résistance en utilisant la loi d'Ohm. Pour ceux qui ne le savent pas ou qui ont oublié, la loi d’Ohm dit qu’il existe une relation linéaire entre le courant et la tension. Autrement dit, plus nous appliquons de tension à la résistance, plus le courant la traversera.
V=I*R
Où V- tension aux bornes de la résistance
je- courant traversant la résistance
R.- une résistance qu'il faut trouver.
Tout d’abord, nous devons connaître la tension aux bornes de la résistance. La plupart des LED de 3 mm ou 5 mm que vous utiliserez ont une tension de fonctionnement de 3 V. Cela signifie que nous devons éteindre 5-3 = 2V au niveau de la résistance.

Nous calculerons ensuite le courant traversant la résistance.
La plupart des LED de 3 mm et 5 mm brillent à pleine luminosité à 20 mA. Un courant supérieur à cela peut les désactiver, tandis qu’un courant de moindre intensité réduira leur luminosité sans causer de dommages.

Nous voulons donc connecter la LED au circuit 5V pour qu'elle transporte un courant de 20mA. Puisque toutes les pièces sont incluses dans un seul circuit, la résistance aura également un courant de 20 mA.
Nous obtenons
2 V = 20 mA * R
2V = 0,02A * R
R = 100 ohms
100 Ohms est la résistance minimale, il est préférable d'en utiliser un peu plus, car les LED ont des caractéristiques variables.
Dans cet exemple, une résistance de 220 ohms est utilisée. Uniquement parce que l'auteur en a beaucoup : clin d'oeil : .

Insérez la LED dans les trous au milieu de la carte afin que son long fil soit connecté à l'un des fils de la résistance. Connectez la deuxième extrémité de la résistance à 5 V et connectez le deuxième fil de la LED à GND. La LED devrait s'allumer.

Veuillez noter qu'il existe une différence dans la façon dont vous connectez la LED. Le courant circule du terminal le plus long vers le terminal le plus court. Dans le diagramme, vous pouvez imaginer que le courant circule dans la direction où le triangle est dirigé. Essayez de retourner la LED et vous verrez qu’elle ne s’allumera pas.

Mais la façon dont vous connectez la résistance ne fait aucune différence. Vous pouvez le retourner ou essayer de le connecter à une autre broche de la LED, cela n'affectera pas le fonctionnement du circuit. Cela limitera toujours le courant traversant la LED.

Anatomie du croquis Arduino.

Les programmes pour Arduino sont appelés sketch. Ils se composent de deux fonctions principales. Fonction installation et fonction boucle
Dans cette fonction, vous définirez tous les paramètres de base. Quelles broches fonctionneront comme entrée ou sortie, quelles bibliothèques connecter, initialiser les variables. Fonction Installation() ne s'exécute qu'une seule fois pendant l'esquisse, lorsque l'exécution du programme démarre.
c'est la fonction principale qui est exécutée après installation(). En fait, c'est le programme lui-même. Cette fonction fonctionnera indéfiniment jusqu'à ce que vous coupiez l'alimentation.

LED clignotante Arduino

Dans cet exemple, nous allons connecter un circuit LED à l'une des broches numériques de l'Arduino et l'allumer et l'éteindre à l'aide d'un programme, et vous apprendrez également plusieurs fonctions utiles.

Cette fonction est utilisée dans installation() fait partie du programme et sert à initialiser les broches que vous utiliserez en entrée (SAISIR) ou sortir (SORTIR). Vous ne pourrez pas lire ou écrire des données à partir de la broche tant que vous ne l'aurez pas réglée respectivement sur mode broche. Cette fonction a deux arguments : numéro de broche est le numéro PIN que vous utiliserez.

Mode-définit le fonctionnement de la broche. A l'entrée (SAISIR) ou sortir (SORTIR). Pour allumer la LED, nous devons donner un signal DEPUIS Arduino. Pour ce faire, nous configurons la broche de sortie.
- cette fonction est utilisée pour définir l'état (État) pina (numéro de broche). Il existe deux états principaux (en fait 3 d'entre eux), l'un est HAUT, il y aura du 5V sur le pin, c'est autre chose Faible et la broche sera 0v. Cela signifie que pour allumer la LED, nous devons régler la broche connectée à la LED à un niveau élevé. HAUT.

Retard. Sert à retarder le fonctionnement du programme pendant une période spécifiée en msec.
Vous trouverez ci-dessous le code qui fait clignoter la LED.
//LED Blink int ledPin = 7;//Broche Arduino à laquelle la LED est connectée void setup() ( pinMode(ledPin, OUTPUT);// définition de la broche comme OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// allumer le délai LED (1000);// délai 1000 ms (1 sec) digitalWrite (ledPin, LOW);// éteindre le délai LED (1000); // attendre 1 sec)

Quelques précisions sur le code.
Les lignes commençant par "//" sont des commentaires et sont ignorées par Arduino.
Toutes les commandes se terminent par un point-virgule ; si vous les oubliez, vous recevrez un message d'erreur.

ledPin est une variable. Les variables sont utilisées dans les programmes pour stocker des valeurs. Dans cet exemple, la variable ledPin la valeur est attribuée à 7, c'est le numéro de broche Arduino. Lorsque le programme Arduino rencontre une ligne avec une variable ledPin, il utilisera la valeur que nous avons spécifiée plus tôt.
Alors enregistre pinMode (ledPin, SORTIE) similaire à l'enregistrement pinMode (7, SORTIE).
Mais dans le premier cas, il vous suffit de changer la variable et elle changera à chaque ligne où elle est utilisée, et dans le second cas, pour changer la variable, vous devrez apporter des modifications manuellement dans chaque commande.

La première ligne indique le type de la variable. Lors de la programmation Arduino, il est important de toujours déclarer le type de variables. Pour l'instant, il vous suffit de savoir que INT annonce des nombres négatifs et positifs.
Ci-dessous, une simulation du croquis. Cliquez sur Démarrer pour voir le circuit en action.

Comme prévu, la LED s'éteint et se rallume au bout d'une seconde. Essayez de modifier le délai pour voir comment cela fonctionne.

Contrôle de plusieurs LED.

Dans cet exemple, vous apprendrez à contrôler plusieurs LED. Pour ce faire, installez 3 LED supplémentaires sur la carte et connectez-les aux résistances et aux broches Arduino comme indiqué ci-dessous.

Afin d'allumer et d'éteindre les LED une par une, vous devez écrire un programme similaire à celui-ci :
//Multi LED Clignotement int led1Pin = 4; int led2Pin = 5 ; int led3Pin = 6 ; int led4Pin = 7 ; void setup() ( //définir les broches comme OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH );//allumer le délai LED (1000);//délai 1 sec digitalWrite(led1Pin, LOW);//éteindre le délai LED (1000);//délai 1 sec //faire de même pour les 3 autres LED digitalWrite (led2Pin, HIGH);//allumer le délai LED (1000);//retarder 1 sec digitalWrite(led2Pin, LOW);//éteindre le délai LED (1000);//retarder 1 sec digitalWrite(led3Pin, HIGH) );//allumer le délai LED (1000);//retarder 1 sec digitalWrite(led3Pin, LOW);//éteindre le délai LED (1000);//retarder 1 sec digitalWrite(led4Pin, HIGH);//allumer le délai LED (1000);//retard 1 sec digitalWrite(led4Pin, LOW);//éteindre le délai LED (1000);//retard 1 sec)

Ce programme fonctionnera très bien, mais ce n'est pas la solution la plus rationnelle. Le code doit être modifié. Pour que le programme fonctionne encore et encore, nous utiliserons une construction appelée .
Les boucles sont utiles lorsque vous devez répéter plusieurs fois la même action. Dans le code ci-dessus on répète les lignes

DigitalWrite (led4Pin, ÉLEVÉ); retard (1000); écriture numérique (led4Pin, FAIBLE); retard (1000);
code de croquis complet en pièce jointe (téléchargements : 1201)

Réglage de la luminosité des LED

Parfois, vous devrez modifier la luminosité des LED dans le programme. Cela peut être fait en utilisant la commande analogWrite() . Cette commande allume et éteint la LED si rapidement que l'œil ne peut pas voir le scintillement. Si la LED est allumée la moitié du temps et éteinte la moitié du temps, il apparaîtra visuellement qu’elle brille à la moitié de sa luminosité. C'est ce qu'on appelle la modulation de largeur d'impulsion (PWM ou PWM en anglais). La cale est assez souvent utilisée, car elle permet de contrôler un composant « analogique » à l'aide d'un code numérique. Toutes les broches Arduino ne conviennent pas à ces fins. Seuls les terminaux à proximité desquels une telle désignation est dessinée " ~ ". Vous le verrez à côté des broches 3,5,6,9,10,11.
Connectez une de vos LED à l'une des broches PWM (pour l'auteur, il s'agit de la broche 9). Exécutez maintenant le croquis clignotant de la LED, mais modifiez d'abord la commande écriture numérique() sur analogWrite(). analogWrite() a deux arguments : le premier est le numéro de broche, et le second est la valeur PWM (0-255), par rapport aux LED, ce sera leur luminosité, et pour les moteurs électriques, la vitesse de rotation. Vous trouverez ci-dessous un exemple de code pour différentes luminosités de LED.
//Changer la luminosité de la LED int ledPin = 9;//une LED est connectée à cette broche void setup() ( pinMode(ledPin, OUTPUT);// initialisation de la broche à la sortie ) void loop() ( analogWrite( ledPin, 255);//retard de pleine luminosité (255/255 = 1) (1000);//pause 1 sec digitalWrite(ledPin, LOW);//éteindre le délai LED (1000);//pause 1 sec analogWrite( ledPin, 191);//luminosité par 3/4 (191/255 ~ = 0,75) délai (1000);//pause 1 sec digitalWrite(ledPin, LOW);//éteindre le délai LED (1000);// pause 1 seconde analogWrite (ledPin, 127); // demi-luminosité (127/255 ~ = 0,5) délai (1000); // pause 1 seconde digitalWrite (ledPin, LOW); // éteindre le délai LED (1000);/ /pause 1 sec analogWrite(ledPin, 63); //quart de luminosité (63/255 ~ = 0,25) délai (1000);//pause 1 sec digitalWrite(ledPin, LOW);//éteint le délai LED (1000) ;//pause 1 seconde)

Essayez de changer la valeur PWM dans la commande analogWrite() pour voir comment cela affecte la luminosité.
Ensuite, vous apprendrez à régler la luminosité en douceur de pleine à zéro. Vous pouvez bien sûr copier un morceau de code 255 fois
analogWrite (ledPin, luminosité); delay(5);//luminosité à court délai = luminosité + 1 ;
Mais vous comprenez que cela ne sera pas pratique. La meilleure façon de procéder est d’utiliser la boucle FOR que nous avons utilisée précédemment.
L'exemple suivant utilise deux boucles, une pour diminuer la luminosité de 255 à 0
pour (int luminosité=0;luminosité=0;luminosité--)( analogWrite(ledPin,luminosité); delay(5); )
retard(5) utilisé pour ralentir la vitesse de fondu d'entrée et de sortie 5*256=1280ms=1,28sec)
La première ligne utilise " luminosité-" pour faire diminuer la valeur de luminosité de 1 à chaque fois que la boucle est répétée. Notez que la boucle fonctionnera jusqu'à ce que luminosité >=0.Remplacement du panneau > sur le signe >= nous avons inclus 0 dans la plage de luminosité. Ce croquis est modélisé ci-dessous. //changer en douceur la luminosité int ledPin = 9;//une LED est connectée à cette broche void setup() ( pinMode(ledPin, OUTPUT);// initialisation de la broche de sortie) void loop() ( //augmenter en douceur la luminosité luminosité (0 à 255) pour (int luminosité=0;luminosité=0;luminosité--)( analogWrite(ledPin,brightness); delay(5); ) delay(1000);//attendre 1 seconde //réduire en douceur la luminosité (255 à 0) pour (int luminosité=255;luminosité>=0;luminosité--)( analogWrite(ledPin,brightness); delay(5); ) delay(1000);//wait 1 sec ) )
Ce n'est pas très visible, mais l'idée est claire.

LED RVB et Arduino

Une LED RVB est en fait composée de trois LED de couleurs différentes dans un seul boîtier.

En allumant différentes LED avec des luminosités différentes, vous pouvez les combiner pour créer différentes couleurs. Pour Arduino, où le nombre de niveaux de luminosité est de 256, vous obtiendrez 256^3=16581375 couleurs possibles. En réalité, bien sûr, ils seront moins nombreux.
La LED que nous utiliserons est la cathode commune. Ceux. les trois LED sont structurellement connectées par des cathodes à une seule borne. Nous allons connecter cette broche à la broche GND. Les broches restantes, via des résistances de limitation, doivent être connectées aux broches PWM. L'auteur a utilisé les broches 9 à 11. De cette façon, il sera possible de contrôler chaque LED séparément. Le premier croquis montre comment allumer chaque LED individuellement.

L'exemple suivant utilise les commandes analogWrite() et pour obtenir différentes valeurs de luminosité aléatoires pour les LED. Vous verrez différentes couleurs changer de manière aléatoire.
//LED RVB - couleurs aléatoires //connexions des broches int red = 9 ; int vert = 10 ; int bleu = 11 ; void setup())( pinMode(red, OUTPUT); pinMode(blue, OUTPUT); pinMode(green, OUTPUT); ) void loop())( //choisissez une couleur aléatoire analogWrite(red, random(256)); analogWrite( bleu, random(256)); analogWrite(green, random(256)); //attendez une seconde)

Aléatoire(256)-renvoie un nombre aléatoire compris entre 0 et 255.
Dans le fichier joint se trouve un croquis qui démontrera des transitions de couleurs douces du rouge au vert, puis au bleu, au rouge, au vert, etc. (téléchargements : 331)
L'exemple d'esquisse fonctionne, mais il y a beaucoup de code en double. Vous pouvez simplifier le code en écrivant votre propre fonction d'assistance qui passera en douceur d'une couleur à l'autre.
Voici à quoi cela ressemblera : (téléchargements : 367)
Examinons la définition de la fonction pièce par pièce. La fonction s'appelle fader et a deux arguments. Chaque argument est séparé par une virgule et a un type déclaré sur la première ligne de la définition de la fonction : fader vide (int color1, int color2). Vous voyez que les deux arguments sont déclarés comme int, et on leur donne des noms couleur1 Et couleur2 comme variables de condition pour définir une fonction. Vide signifie que la fonction ne renvoie aucune valeur, elle exécute simplement des commandes. Si vous deviez écrire une fonction renvoyant le résultat d’une multiplication, elle ressemblerait à ceci :
multiplicateur int (numéro int1, numéro int2)( produit int = numéro1*numéro2; produit de retour; )
Remarquez comment nous avons déclaré le type int comme type de retour à la place
vide.
À l'intérieur de la fonction, il y a des commandes que vous avez déjà utilisées dans le croquis précédent, seuls les numéros de broches ont été remplacés par couleur1 Et couleur2. La fonction s'appelle fader, ses arguments sont calculés comme couleur1 = rouge Et couleur2 = vert. L'archive contient une esquisse complète utilisant des fonctions (téléchargements : 275)

Bouton

Le croquis suivant utilisera un bouton avec des contacts normalement ouverts, sans verrouillage.

analogiqueLecture vous permet de lire les données de l'une des broches analogiques Arduino et affiche une valeur comprise entre 0 (0 V) et 1023 (5 V). Si la tension à l'entrée analogique est de 2,5 V, alors 2,5 / 5 * 1023 = 512 sera imprimé
analogiqueLecture n'a qu'un seul argument - Il s'agit du numéro d'entrée analogique (A0-A5). Le croquis suivant montre le code de lecture de la tension du potentiomètre. Pour ce faire, connectez une résistance variable, les bornes extérieures aux broches 5V et GND et la borne centrale à l'entrée A0.

Exécutez le code suivant et voyez sur le moniteur série comment les valeurs changent en fonction de la rotation du bouton de résistance.
//entrée analogique int potPin = A0;//la broche centrale du potentiomètre est connectée à cette configuration vide de broche())( //la broche analogique est incluse comme entrée par défaut, donc l'initialisation n'est pas nécessaire Serial.begin(9600 ); ) void loop())( int potVal = analogRead(potPin);//potVal est un nombre compris entre 0 et 1023 Serial.println(potVal)
L'esquisse suivante combine l'esquisse du clic sur le bouton et l'esquisse du contrôle de la luminosité des LED. La LED s'allumera à partir du bouton et la luminosité sera contrôlée par un potentiomètre.
//détection d'appui sur un bouton avec sortie LED et intensité variable int buttonPin = 7; int ledPin = 9 ; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//si le bouton est enfoncé int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal);//allumer la LED avec l'intensité définie par le pot Serial.println("pressed"); ( digitalWrite(ledPin, LOW);//s'éteint si le bouton n'est pas enfoncé Serial.println("unpressed"); ) )

L’étude des microcontrôleurs vous semble-t-elle compliquée et incompréhensible ? Avant l'apparition d'Arudino, ce n'était vraiment pas facile et nécessitait un certain ensemble de programmeurs et d'autres équipements.

C'est une sorte de concepteur électronique. L'objectif initial du projet est de permettre aux gens d'apprendre facilement à programmer des appareils électroniques, tout en consacrant un minimum de temps à la partie électronique.

L'assemblage de circuits complexes et la connexion des cartes peuvent être réalisés sans fer à souder, mais à l'aide de cavaliers avec connexions mâles et femelles détachables. De cette façon, les éléments montés et les cartes d'extension peuvent être connectés, qui dans le lexique Arduino sont simplement appelés « Boucliers ».

Quelle est la première carte Arduino à acheter pour un débutant ?

Elle est considérée comme la planche de base et la plus populaire. Ce tableau a la taille d'une carte de crédit. Assez grand. La plupart des boucliers en vente s'y adaptent parfaitement. La carte dispose de prises pour connecter des appareils externes.

Dans les magasins nationaux en 2017, son prix est d'environ 4 à 5 dollars. Sur les modèles modernes, son cœur est Atmega328.

Image de la carte Arduino et explication des fonctions de chaque broche, brochage Arduino UNO

Le microcontrôleur de cette carte est une longue puce dans un boîtier DIP28, ce qui signifie qu'il possède 28 pattes.

La deuxième planche la plus populaire coûte presque deux fois plus que la précédente - 2 à 3 dollars. Il s'agit de frais. Les cartes actuelles sont construites sur le même Atmega328, elles sont fonctionnellement similaires à UNO, les différences résident dans la taille et la solution de coordination avec USB, nous y reviendrons plus tard. Une autre différence est que des fiches en forme de broche sont fournies pour connecter les appareils à la carte.

Le nombre de broches (pattes) de cette carte est le même, mais vous pouvez voir que le microcontrôleur est réalisé dans un boîtier TQFP32 plus compact, ADC6 et ADC7 sont ajoutés au boîtier, les deux autres pattes « supplémentaires » dupliquent le bus d'alimentation . Sa taille est assez compacte – environ la taille de votre pouce.

La troisième carte la plus populaire est qu'elle ne dispose pas de port USB pour se connecter à un ordinateur ; je vous expliquerai un peu plus tard comment se fait la connexion ;

Il s'agit de la plus petite carte de toutes testées, sinon elle est similaire aux deux précédentes, et son cœur est toujours l'Atmega328. Nous ne considérerons pas d'autres tableaux, car il s'agit d'un article destiné aux débutants, et la comparaison des tableaux est un sujet pour un article séparé.

En haut se trouve un schéma de connexion USB-UART, la broche « GRN » est connectée au circuit de réinitialisation du microcontrôleur, elle peut être appelée par autre chose, vous découvrirez pourquoi cela est nécessaire plus tard.

Alors que UNO est idéal pour le prototypage, Nano et Pro Mini sont parfaits pour terminer votre projet car ils prennent peu de place.

Comment connecter Arduino à un ordinateur ?

Arduino Uno et Nano se connectent à l'ordinateur via USB. Cependant, il n'existe pas de support matériel pour le port USB ; une solution de circuit de conversion de niveau, généralement appelée USB vers série ou USB-UART (rs-232), est utilisée ici. Dans le même temps, un chargeur de démarrage Arduino spécial est flashé dans le microcontrôleur, ce qui permet de flasher via ces bus.

L'Arduino Uno implémente cette connexion sur un microcontrôleur avec support USB - ATmega16U2 (AT16U2). Il s'avère qu'un microcontrôleur supplémentaire sur la carte est nécessaire pour flasher le firmware du microcontrôleur principal.

Dans Arduino Nano, cela est implémenté par la puce FT232R ou son analogique CH340. Ce n'est pas un microcontrôleur - c'est un convertisseur de niveau, ce qui facilite l'assemblage de l'Arduino Nano à partir de zéro de vos propres mains.

Généralement, les pilotes sont installés automatiquement lorsque vous connectez la carte Arduino. Cependant, lorsque j'ai acheté une copie chinoise de l'Arduino Nano, l'appareil a été identifié, mais il n'a pas fonctionné, il y avait un autocollant rond sur le convertisseur avec des informations sur la date de sortie, je ne sais pas si cela a été fait exprès , mais quand je l'ai décollé, j'ai vu le marquage CH340.

Je n'avais jamais rencontré cela auparavant et pensais que tous les convertisseurs USB-UART étaient assemblés sur FT232, j'ai dû télécharger les pilotes, ils sont très faciles à trouver en recherchant « Pilotes Arduino ch340 ». Après une simple installation, tout a fonctionné !

Le microcontrôleur peut également être alimenté via le même port USB, c'est-à-dire si vous le connectez à un adaptateur depuis un téléphone mobile, votre système fonctionnera.

Que dois-je faire si ma carte n'a pas d'USB ?

La carte Arduino Pro Mini a des dimensions plus petites. Ceci a été réalisé en supprimant le connecteur USB pour le firmware et le même convertisseur USB-UART. Il faut donc l’acheter séparément. Le convertisseur le plus simple basé sur CH340 (le moins cher), CPL2102 et FT232R, coûte à partir de 1 dollar.

Lors de l'achat, faites attention à la tension pour laquelle cet adaptateur est conçu. Pro mini est disponible en versions 3,3 et 5 V ; les convertisseurs disposent souvent d'un cavalier pour commuter la tension d'alimentation.

Lors du flashage du firmware Pro Mini, immédiatement avant de le démarrer, vous devez appuyer sur RESET, cependant, dans les convertisseurs avec DTR, cela n'est pas nécessaire, le schéma de connexion est dans la figure ci-dessous.

Ils sont connectés à des bornes spéciales « Mama-Mama » (femelle-femelle).

En fait, toutes les connexions peuvent être effectuées à l'aide de telles bornes (Dupont), elles sont livrées des deux côtés avec des prises et des fiches, et d'un côté il y a une prise et de l'autre il y a une fiche.

Comment écrire des programmes pour Arduino ?

Pour travailler avec des croquis (le nom du firmware dans le langage des ingénieurs Arduino), il existe un environnement de développement intégré spécial pour Arduino IDE, vous pouvez le télécharger gratuitement depuis le site officiel ou depuis n'importe quelle ressource thématique, il n'y a généralement aucun problème ; avec installation.

Voici à quoi ressemble l'interface du programme. Vous pouvez écrire des programmes dans un langage C AVR simplifié spécialement développé pour Arduino, essentiellement un ensemble de bibliothèques appelées Wiring, ainsi qu'en C AVR pur. Dont l'utilisation simplifie le code et accélère son fonctionnement.

En haut de la fenêtre se trouve un menu familier dans lequel vous pouvez ouvrir un fichier, des paramètres, sélectionner la carte avec laquelle vous travaillez (Uno, Nano et bien d'autres) et également ouvrir des projets avec des exemples de code prêts à l'emploi. Vous trouverez ci-dessous un ensemble de boutons pour travailler avec le firmware ; vous verrez l'affectation des touches dans la figure ci-dessous.

En bas de la fenêtre se trouve une zone d'affichage des informations sur le projet, l'état du code, du firmware et la présence d'erreurs.

Bases de la programmation Arduino IDE

Au début du code, vous devez déclarer des variables et inclure des bibliothèques supplémentaires, le cas échéant, cela se fait comme suit :

#include biblioteka.h; // connecte la bibliothèque appelée « Biblioteka.h »

#définir changenaya 1234 ; // Déclare une variable avec la valeur 1234

La commande Define permet au compilateur de choisir lui-même le type de variable, mais vous pouvez le définir manuellement, par exemple un entier entier ou un flottant à virgule flottante.

int led = 13 ; // crée la variable « led » et lui attribue la valeur « 13 »

Le programme peut déterminer l'état de la broche comme 1 ou 0. 1 est une unité logique, si la broche 13 est égale à 1, alors la tension sur sa branche physique sera égale à la tension d'alimentation du microcontrôleur (pour Arduino UNO et Nano-5 V)

Un signal numérique est écrit à l'aide de la commande digitalWrite (pin, value), par exemple :

digitalWrite (led, élevé); // écrivez-en un dans le journal de la broche 13 (nous l'avons déclaré ci-dessus). Unités.

Comme vous pouvez le comprendre, les ports sont accessibles selon la numérotation sur la carte, correspondant au numéro. Voici un exemple similaire au code précédent :

digitalWrite (13, élevé); // définit la broche 13 sur un

Une fonction de temporisation fréquemment utilisée est appelée par la commande delay(), dont la valeur est spécifiée en millisecondes, les microsecondes sont obtenues en utilisant

delayMicroseconds() Délai(1000); //le microcontrôleur attendra 1000 ms (1 seconde)

Les paramètres des ports d'entrée et de sortie sont spécifiés dans la fonction void setup() avec la commande :

pinMode(NOMERPORTA, SORTIE/ENTRÉE); // arguments - nom de variable ou numéro de port, entrée ou sortie parmi lesquels choisir

Comprendre le premier programme Blink

En guise de « Hello, world » pour les microcontrôleurs, il existe un programme pour faire clignoter une LED, regardons son code :

Au début, avec la commande pinMode, nous avons demandé au microcontrôleur d'attribuer le port avec la LED à la sortie. Vous avez déjà remarqué que dans le code il n'y a pas de déclaration de la variable "LED_BUILTIN", le fait est que dans Uno, Nano et autres cartes, une LED intégrée est connectée à la broche 13 de l'usine et elle est soudée sur le conseil. Il peut être utilisé par vous pour l'affichage dans vos projets ou pour de simples tests de vos programmes flashés.

Ensuite, nous définissons la broche à laquelle la LED est soudée sur un (5 V), la ligne suivante fait attendre le MK 1 seconde, puis met la broche LED_BUILTIN à zéro, attend une seconde et le programme se répète en cercle, donc lorsque LED_BUILTIN est égal à 1 - la LED (et toute autre charge connectée au port) est allumée, lorsqu'à 0 elle est éteinte.

Nous lisons la valeur du port analogique et utilisons les données lues

Le microcontrôleur AVR Atmega328 dispose d'un convertisseur analogique-numérique 10 bits intégré. L'ADC 10 bits vous permet de lire des valeurs de tension de 0 à 5 volts, par pas de 1/1024 de l'amplitude totale du signal (5 V).

Pour que ce soit plus clair, considérons la situation, disons que la valeur de tension à l'entrée analogique est de 2,5 V, ce qui signifie que le microcontrôleur lira la valeur de la broche « 512 », si la tension est de 0 à « 0 », et si 5 V- (1023). 1023 - parce que le comptage commence à 0, c'est-à-dire 0, 1, 2, 3, etc. jusqu'à 1023 - 1024 valeurs au total.

Voici à quoi cela ressemble dans le code, en utilisant le croquis standard « analogInput » comme exemple

int sensorPin = A0 ;

int ledPin = 13 ;

int valeur du capteur = 0 ;

pinMode(ledPin, SORTIE);

sensorValue = analogRead (sensorPin);

digitalWrite(ledPin, ÉLEVÉ);

délai (sensorValue);

digitalWrite(ledPin, FAIBLE);

délai (sensorValue);

Nous déclarons les variables :

Ledpin - nous attribuons indépendamment une broche avec une LED intégrée à la sortie et lui donnons un nom individuel ;

sensorPin - entrée analogique, réglée selon les marquages ​​sur la carte : A0, A1, A2, etc. ;

sensorValue - une variable pour stocker la valeur entière lue et continuer à travailler avec elle.

Le code fonctionne comme ceci : sensorValue enregistre la valeur analogique lue depuis sensorPin (commande analogRead). - ici se termine le travail avec le signal analogique, alors tout est comme dans l'exemple précédent.

Nous en écrivons un sur ledPin, la LED s'allume et attend un temps égal à la valeur sensorValue, c'est-à-dire de 0 à 1023 millisecondes. Nous éteignons la LED et attendons à nouveau cette période, après quoi le code se répète.

Ainsi, en positionnant le potentiomètre on règle la fréquence de clignotement de la LED.

Fonction de carte pour Arudino

Toutes les fonctions pour les actionneurs (je n'en connais pas) ne prennent pas en charge "1023" comme argument, par exemple, le servo est limité par l'angle de rotation, c'est-à-dire par demi-tour (180 degrés) (demi-tour) du servomoteur l'argument de fonction maximum est "180"

Parlons maintenant de la syntaxe : map (la valeur que nous traduisons, la valeur d'entrée minimale, la valeur d'entrée maximale, la valeur de sortie minimale, la valeur de sortie maximale).

Dans le code, cela ressemble à ceci :

(map(analogRead(pot), 0, 1023, 0, 180));

Nous lisons la valeur du potentiomètre (analogRead(pot)) de 0 à 1023, et en sortie nous obtenons des nombres de 0 à 180

Valeurs de la carte de valeurs :

En pratique, nous appliquons cela au fonctionnement du code du même servo variateur, jetez un œil au code de l'IDE Arduino, si vous lisez attentivement les sections précédentes, alors cela ne nécessite aucune explication.

Et le schéma de connexion.

Conclusions Arduino est un outil très pratique pour apprendre à travailler avec des microcontrôleurs. Et si vous utilisez du C AVR pur, ou comme on l'appelle parfois « Pure C », vous réduirez considérablement le poids du code, et une plus grande partie de celui-ci tiendra dans la mémoire du microcontrôleur, vous obtiendrez ainsi une excellente usine- carte de débogage faite avec la possibilité de flasher le firmware via USB.

J'aime Arduino. Il est dommage que de nombreux programmeurs de microcontrôleurs expérimentés lui reprochent sans fondement d'être trop simplifié. En principe, seul le langage est simplifié, mais personne ne vous oblige à l'utiliser, de plus vous pouvez flasher le microcontrôleur via le connecteur ICSP et y télécharger le code souhaité, sans aucun chargeur de démarrage inutile.

Pour ceux qui veulent jouer avec l'électronique, comme un concepteur avancé, c'est parfait, et pour les programmeurs expérimentés, en tant que carte qui ne nécessite pas d'assemblage, elle sera également utile !

Pour plus d'informations sur Arduino et les fonctionnalités de son utilisation dans divers circuits, consultez l'e-book - .

Arduino est très populaire parmi tous les passionnés de design. Ceux qui n’en ont jamais entendu parler devraient également y être initiés.

Qu’est-ce qu’Arduino ?

Comment pouvez-vous décrire brièvement Arduino ? Les meilleurs mots seraient : Arduino est un outil qui peut être utilisé pour créer divers appareils électroniques. Il s’agit essentiellement d’une véritable plate-forme informatique matérielle à usage général. Il peut être utilisé aussi bien pour construire des circuits simples que pour mettre en œuvre des projets assez complexes.

Le concepteur s'appuie sur son matériel, qui est une carte d'entrées-sorties. Pour programmer la carte, des langages basés sur C/C++ sont utilisés. Ils sont appelés respectivement Traitement/Câblage. Du groupe C, ils ont hérité d'une extrême simplicité, grâce à laquelle ils peuvent être maîtrisés très rapidement par n'importe qui, et la mise en pratique des connaissances n'est pas un problème assez important. Pour que vous compreniez la facilité de travail, on dit souvent qu'Arduino est destiné aux concepteurs assistants débutants. Même les enfants peuvent comprendre les cartes Arduino.

Que peut-on récupérer dessus ?

Les applications d'Arduino sont assez diverses ; il peut être utilisé aussi bien pour les exemples les plus simples, qui seront recommandés à la fin de l'article, que pour des mécanismes assez complexes, notamment des manipulateurs, des robots ou des machines de production. Certains artisans parviennent à utiliser de tels systèmes pour fabriquer des tablettes, des téléphones, des systèmes de surveillance et de sécurité domestique, des systèmes de maison intelligente ou simplement des ordinateurs. Les projets Arduino pour débutants, avec lesquels même ceux qui n'ont aucune expérience peuvent se lancer, se trouvent à la fin de l'article. Ils peuvent même être utilisés pour créer des systèmes de réalité virtuelle primitifs. Tout cela grâce au matériel et aux capacités assez polyvalents offerts par la programmation Arduino.

Où puis-je acheter les composants ?

Les composants fabriqués en Italie sont considérés comme originaux. Mais le prix de ces kits n’est pas bas. Par conséquent, un certain nombre d'entreprises, voire de particuliers, fabriquent des méthodes artisanales d'appareils et de composants compatibles Arduino, appelés en plaisantant clones de production. Lors de l'achat de tels clones, on ne peut pas dire avec certitude qu'ils fonctionneront, mais le désir d'économiser de l'argent fait des ravages.

Les composants peuvent être achetés soit dans le cadre de kits, soit séparément. Il existe même des kits pré-préparés pour assembler des voitures, des hélicoptères dotés de différents types de commandes ou des navires. Un ensemble comme celui illustré ci-dessus, fabriqué en Chine, coûte 49 $.

En savoir plus sur l'équipement

La carte Arduino est un simple microcontrôleur AVR, qui a été flashé avec un chargeur de démarrage et possède le port USB-UART minimum requis. Il existe d’autres éléments importants, mais dans le cadre de l’article, il serait préférable de se concentrer uniquement sur ces deux éléments.

Tout d’abord, à propos du microcontrôleur, un mécanisme construit sur un seul circuit dans lequel se trouve le programme développé. Le programme peut être influencé en appuyant sur des boutons, en recevant des signaux des composants de la création (résistances, transistors, capteurs, etc.), etc. De plus, les capteurs peuvent être très différents dans leur fonction : éclairage, accélération, température, distance, pression, obstacles, etc. Des pièces simples peuvent être utilisées comme dispositifs d'affichage, depuis les LED et les tweeters jusqu'aux dispositifs complexes, tels que les écrans graphiques. Les qualités considérées sont les moteurs, les vannes, les relais, les servos, les électro-aimants et bien d'autres, dont la liste prendrait très, très longtemps. Le MK travaille directement avec certaines de ces listes, à l'aide de fils de connexion. Certains mécanismes nécessitent des adaptateurs. Mais une fois que vous aurez commencé à concevoir, il vous sera difficile de vous en détacher. Parlons maintenant de la programmation Arduino.

En savoir plus sur le processus de programmation du tableau

Un programme déjà prêt à fonctionner sur un microcontrôleur est appelé firmware. Il peut y avoir soit un projet, soit des projets Arduino, il serait donc conseillé de stocker chaque firmware dans un dossier séparé pour accélérer le processus de recherche des fichiers nécessaires. Il est flashé sur le cristal MK à l'aide d'appareils spécialisés : des programmeurs. Et ici, Arduino a un avantage : il n'a pas besoin de programmeur. Tout est fait pour que la programmation Arduino pour les débutants ne soit pas difficile. Le code écrit peut être chargé dans le MK via un câble USB. Cet avantage n'est pas obtenu par un programmeur prédéfini, mais par un micrologiciel spécial - un chargeur de démarrage. Le chargeur de démarrage est un programme spécial qui démarre immédiatement après la connexion et écoute s'il y a des commandes, s'il faut flasher le cristal, s'il y a des projets Arduino ou non. Il y a plusieurs avantages très intéressants à utiliser un bootloader :

1. Utiliser un seul canal de communication, ce qui ne nécessite pas de coûts de temps supplémentaires. Ainsi, les projets Arduino ne nécessitent pas de connecter de nombreux fils différents et il y aura confusion lors de leur utilisation. Un câble USB suffit pour un fonctionnement réussi.
2. Protection contre les mains tordues. Il est assez simple de mettre le microcontrôleur à l'état de brique à l'aide d'un micrologiciel direct, vous n'avez pas besoin de travailler dur. Lorsque vous travaillez avec un chargeur de démarrage, vous ne pourrez pas accéder aux paramètres potentiellement dangereux (avec l'aide d'un programme de développement, bien sûr, sinon tout peut être cassé). Par conséquent, Arduino pour débutants est conçu non seulement du point de vue qu'il est compréhensible et pratique, il vous permettra également d'éviter des dépenses financières indésirables associées à l'inexpérience de la personne qui travaille avec eux.

Des projets pour démarrer

Lorsqu'on a acquis un kit, un fer à souder, de la colophane et de la soudure, il ne faut pas sculpter d'emblée des structures très complexes. Bien sûr, vous pouvez les réaliser, mais les chances de succès avec Arduino pour les débutants sont assez faibles avec des projets complexes. Pour vous entraîner et améliorer vos compétences, vous pouvez essayer de mettre en œuvre quelques idées plus simples qui vous aideront à comprendre l'interaction et le fonctionnement d'Arduino. Comme premières étapes pour travailler avec Arduino pour les débutants, nous pouvons vous conseiller de considérer :

1. Créez-en un qui fonctionnera grâce à Arduino.
2. Connexion d'un bouton séparé à Arduino. Dans ce cas, vous pouvez vous assurer que le bouton peut régler la lueur de la LED à partir du point n°1.
3. Connexion potentiomètre.
4. Commande de servomoteur.
5. Connexion et travail avec une LED tricolore.
6. Connexion de l'élément piézoélectrique.
7. Connexion d'une photorésistance.
8. Connexion d'un capteur de mouvement et signaux sur son fonctionnement.
9. Raccordement d'un capteur d'humidité ou de température.

Des projets pour l'avenir

Il est peu probable que vous soyez intéressé par Arduino pour connecter des LED individuelles. Très probablement, vous êtes attiré par la possibilité de créer votre propre voiture ou votre propre plaque tournante volante. Ces projets sont difficiles à mettre en œuvre et demanderont beaucoup de temps et de persévérance, mais une fois terminés, vous obtiendrez ce que vous voulez : une précieuse expérience de conception Arduino pour les débutants.