Cours Arduino

Apprendre Arduino livre en PDF pour débutant


Télécharger Apprendre Arduino livre en PDF pour débutant

★★★★★★★★★★4 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Table des matières

À propos                                                                                                                                                           1

Chapitre 1: Démarrer avec Arduino                                                                                                             2

Remarques                                                                                                                                                        2

Qu'est ce que Arduino?                                                                                                                                  2

Pourquoi utiliser Arduino?                                                                                                                             2

Versions                                                                                                                                                             2

Examples                                                                                                                                                           2

         Le strict minimum                                                                                                                                           2

         Cligner                                                                                                                                                          3

         Première installation                                                                                                                                       4

Installer                                                                                                                                                             5

Télécharger                                                                                                                                                      7

Moniteur série                                                                                                                                                  7

LED - Avec contrôle de bouton                                                                                                                          7

Chapitre 2: Arduino IDE                                                                                                                                 9

Examples                                                                                                                                                           9

         Installation sous Windows                                                                                                                               9

         Application portable sous Windows                                                                                                                 9

         Installation sur Fedora                                                                                                                                    9

         Installation sur Ubuntu                                                                                                                                    9

         Installation sur macOS                                                                                                                                   9

Chapitre 3: Bibliothèque de cristaux liquides                                                                                           10

Introduction                                                                                                                                                      10

Syntaxe                                                                                                                                                            10

Paramètres                                                                                                                                                      10

Examples                                                                                                                                                         10

         Utilisation de base                                                                                                                                        10

Chapitre 4: Bibliothèques                                                                                                                            12

Introduction                                                                                                                                                      12

Examples                                                                                                                                                         12

         Installation des bibliothèques avec le gestionnaire de bibliothèque                                                                  12

         Y compris les bibliothèques dans votre esquisse.                                                                                           13

Chapitre 5: Boucles                                                                                                                                      15

Syntaxe                                                                                                                                                            15

Remarques                                                                                                                                                      15

Examples                                                                                                                                                         15

         Tandis que                                                                                                                                                   15

         Pour                                                                                                                                                            16

         Faire pendant                                                                                                                                               16

         Contrôle de flux                                                                                                                                            17

Chapitre 6: Broches de matériel                                                                                                                 18

Examples                                                                                                                                                         18

         Arduino Uno R3                                                                                                                                           18

Chapitre 7: Comment Python s'intègre à Arduino Uno                                                                           21

Syntaxe                                                                                                                                                            21

Paramètres                                                                                                                                                      21

Remarques                                                                                                                                                      21

Examples                                                                                                                                                         21

         Première communication série entre Arduino et Python                                                                                  21

Chapitre 8: Comment stocker des variables dans EEPROM et les utiliser pour le stockage per 23

Syntaxe                                                                                                                                                            23

Paramètres                                                                                                                                                      23

Remarques

23

Examples

23

Stockez une variable dans EEPROM, puis récupérez-la et imprimez-la sur l'écran

24

Chapitre 9: Communication Bluetooth

25

Paramètres

25

Remarques

26

Examples

26

Monde de base bluetooth bonjour

26

Chapitre 10: Communication I2C

27

Introduction                                                                                                                                                      27

Examples                                                                                                                                                         27

         Plusieurs esclaves                                                                                                                                        27

Chapitre 11: Communication MIDI                                                                                                             30

Introduction                                                                                                                                                      30

Examples                                                                                                                                                         30

         MIDI THRU Exemple                                                                                                                                    30

         MIDI Thru with Queue                                                                                                                                   30

         Génération d'horloge MIDI                                                                                                                            32

         Messages MIDI définis                                                                                                                                 33

Chapitre 12: Communication série                                                                                                             38

Syntaxe                                                                                                                                                            38

Paramètres                                                                                                                                                      38

Remarques                                                                                                                                                      38

Examples                                                                                                                                                         39

         Simple à lire et à écrire                                                                                                                                 39

         Filtrage Base64 pour les données d'entrée série                                                                                            39

         Gestion des commandes sur série                                                                                                                 39

         Communication série avec Python                                                                                                                 40

Arduino:                                                                                                                                                          40

Python:                                                                                                                                                            41

Chapitre 13: Communication SPI                                                                                                               42

Remarques                                                                                                                                                      42

Signaux de sélection de puce                                                                                                                     42

Transactions                                                                                                                                                  42

Utilisation du SPI dans les routines du service d'interruption                                                                43

Examples 43

         Notions de base: initialiser le SPI et une broche de sélection de puce, et effectuer un tr                                   43

Chapitre 14: Entrées analogiques                                                                                                              45

Syntaxe                                                                                                                                                            45

Remarques                                                                                                                                                      45

Examples

45

Imprimer une valeur analogique

45

Obtenir la tension de la broche analogique

45

Chapitre 15: Entrées Numériques

47

Syntaxe

47

Paramètres

47

Remarques

47

Examples

47

Lecture bouton

47

Chapitre 16: Gestion du temps

49

Syntaxe

49

Remarques

49

Code bloquant ou non bloquant

49

Détails d'implémentation

49

Examples

50

blinky blinky avec delay ()

50

Blinky non bloquant avec la bibliothèque elapsedMillis (et la classe)

50

Blinky non bloquant avec le millis ()

51

Mesurer combien de temps quelque chose a pris, en utilisant Millis et ElapsedMicros

52

Plus d'une tâche sans délai ()

52

Chapitre 17: Les fonctions

54

Remarques

54

Examples

54

Créer une fonction simple

54

Appeler une fonction

54

Chapitre 18: Les interruptions

56

Syntaxe                                                                                                                                                            56

Paramètres                                                                                                                                                      56

Remarques                                                                                                                                                      56

Examples                                                                                                                                                         56

         Interruption sur le bouton presse                                                                                                                   57

Chapitre 19: Nombres aléatoires                                                                                                               58

Syntaxe                                                                                                                                                            58

Paramètres                                                                                                                                                      58

Remarques                                                                                                                                                      58

Examples                                                                                                                                                         58

         Générer un nombre aléatoire                                                                                                                        58

         Mettre une graine                                                                                                                                         59

Le code                                                                                                                                                           61

PWM avec un TLC5940                                                                                                                                   62

Chapitre 21: Servo                                                                                                                                        64

Introduction                                                                                                                                                      64

Syntaxe                                                                                                                                                            64

Examples                                                                                                                                                         64

         Déplacement du servo dans les deux sens                                                                                                    64

Chapitre 22: Sortie audio                                                                                                                             65

Paramètres                                                                                                                                                      65

Examples                                                                                                                                                         65

         Sorties de note de base                                                                                                                                65

Chapitre 23: Sortie numérique                                                                                                                    66

Syntaxe                                                                                                                                                            66

Examples                                                                                                                                                         66

         Ecrire à l'épinglette                                                                                                                                       66

Chapitre 24: Stockage de données                                                                                                           67

Examples     67 cardInfo       67 Enregistreur de carte SD       69

         Dump de fichier de carte SD                                                                                                                         70

         Exemple de fichier de base de carte SD                                                                                                        71

         Liste de fichiers                                                                                                                                            72

         Carte SD lecture / écriture                                                                                                                             74

Chapitre 25: Utiliser Arduino avec Atmel Studio 7                                                                                  76

Remarques                                                                                                                                                      76

Installer                                                                                                                                                           76

Les liaisons                                                                                                                                                    76

Considérations de débogage                                                                                                                      78

Configuration du logiciel                                                                                                                              80

Pour inclure des bibliothèques dans votre esquisse                                                                               81

Ajouter la fenêtre du terminal                                                                                                                      81

Avantages                                                                                                                                                      81

Examples                                                                                                                                                         82

Exemple de croquis importé Atmel Studio 7

82

Chapitre 26: Variables et types de données

83

Examples

83

Créer une variable

83

Attribuer une valeur à une variable

83

Types de variables

83

Crédits                                                                                                                                                            85


À propos

You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from:

It is an unofficial and free arduino ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official arduino.

The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to

Chapitre 1: Démarrer avec Arduino

Remarques

Qu'est ce que Arduino?

Arduino est une plate-forme électronique open source basée sur du matériel et des logiciels faciles à utiliser.

Pourquoi utiliser Arduino?

•    Peu coûteux. Vous pouvez également acheter des clones encore moins chers.

•    Facile à utiliser et commencez avec

•    Communauté énorme

•    Complètement Open Source

Versions

Version

Date de sortie

1.0.0

2016-05-08

Examples

Le strict minimum

Voici l'esquisse Arduino "au strict minimum". Cela peut être chargé dans l'IDE Arduino en choisissant File > Examples > 01. Basics > Bare Minimum .



void setup() {

  // put your setup code here, to run once

}

void loop() {

  // put your main code here, to run repeatedly

}

Le code de la fonction setup() sera exécuté une fois au démarrage du programme. Ceci est utile pour configurer des broches d'E / S, initialiser des variables, etc. Le code dans la fonction loop() sera exécuté à plusieurs reprises jusqu'à ce que l'Arduino soit désactivé ou qu'un nouveau programme soit téléchargé. Effectivement, le code ci-dessus ressemble à ceci dans la bibliothèque d'exécution Arduino:

setup(); while(1) {   loop(); }

Contrairement aux programmes exécutés sur votre ordinateur, le code Arduino ne peut jamais être arrêté. Ceci est dû au fait que le microcontrôleur ne contient qu'un seul programme. Si ce programme se ferme, il n'y aura rien à dire au microcontrôleur.

Cligner

Voici un court exemple qui illustre les fonctions setup() et loop() . Cela peut être chargé dans l'IDE

Arduino en choisissant File > Examples > 01. Basics > Blink . ( Remarque: la plupart des cartes Arduino ont une LED déjà connectée à la broche 13, mais vous devrez peut-être ajouter une LED externe pour voir les effets de cette esquisse.)

// the setup function runs once when you press reset or power the board void setup() {

  // initialize digital pin 13 as an output.   pinMode(13, OUTPUT);

}

// the loop function runs over and over again forever void loop() { digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level) delay(1000);              // wait for a second   digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW   delay(1000);              // wait for a second

}

L'extrait ci-dessus:

1.  Définit la fonction setup() . La fonction setup() est appelée en premier sur l'exécution dans chaque programme Arduino.

1.  Définit la broche 13 en sortie.

Sans cela, il pourrait être réglé sur une entrée, ce qui rendrait la LED non fonctionnelle. Cependant, une fois défini en tant que sortie, il restera comme cela, il ne faut donc le faire qu'une fois au démarrage du programme.

2.  Définit la fonction loop() . La fonction loop() est appelée à plusieurs reprises tant que le programme est en cours d'exécution.

1.  digitalWrite(13, HIGH); allume la LED.

2.  delay(1000); attend une seconde (1 000 millisecondes).

3.  digitalWrite(13, LOW); éteint la LED.

4.  delay(1000); attend une seconde (1000 millisecondes).

Étant donné que loop() est exécuté de manière répétée tant que le programme est en cours d'exécution, le voyant clignote pendant 2 secondes (1 seconde, 1 seconde). Cet exemple est basé sur l'Arduino Uno et sur toute autre carte ayant déjà une DEL connectée à la broche 13. Si la carte utilisée n'a pas de DEL intégrée connectée à cette broche, l'une d'entre elles peut être connectée en externe.

Plus sur le timing (par exemple, les délais et le temps de mesure): gestion du temps

Première installation

Logiciel requis:


setup() et loop() . Ceci est suffisant pour télécharger sur une carte Arduino, mais il ne fera rien du tout. L'exemple d'esquisse "Blink" fonctionne comme un test simple lors de la première utilisation d'une carte Arduino. Allez dans Fichier ? Exemples ? 01.Basics ? Blink. Cela ouvrira une nouvelle fenêtre avec l'esquisse Blink.


Sélectionnez votre tableau Allez dans Outils ? Panneau ? [nom de votre carte Arduino].

Sélectionnez le port COM de votre carte. La plupart des cartes compatibles Aurduino créeront un faux port COM, utilisé pour la communication série (débogage) et pour la programmation de la carte. COM 1 est généralement déjà présent et votre forum en créera un nouveau, par exemple COM 4. Sélectionnez ceci dans Outils ? Port ? COM 4 (ou un autre numéro COM).

Certaines cartes ont des paramètres supplémentaires dans le menu Outils, tels que la vitesse d'horloge. Celles-ci varient d'un conseil à l'autre, mais généralement, un ensemble de valeurs par défaut acceptable est déjà sélectionné.

Télécharger

Vous êtes maintenant prêt à télécharger Blink. Cliquez sur le bouton Télécharger ou sélectionnez Esquisse ? Télécharger. Le croquis sera compilé, puis téléchargé sur votre carte Arduino. Si tout fonctionnait bien, la DEL intégrée clignotera toutes les secondes.

Moniteur série

Dans l'IDE Arduino, vous avez un moniteur série. Pour l'ouvrir, utilisez le moniteur série à droite de la fenêtre.

Assurez-vous que le code est téléchargé avant d'ouvrir le moniteur. Le téléchargement et le moniteur ne fonctionneront pas en même temps!

LED - Avec contrôle de bouton

Vous pouvez également utiliser ce code pour configurer une LED avec un interrupteur à bouton avec une résistance de tirage, cela pourrait être de préférence avec l'étape suivante après la configuration du contrôleur de LED initial.

int buttonState = 0; // variable for reading the pushbutton status

void setup() {

    // initialize the LED pin as an output:     pinMode(13, OUTPUT); // You can set it just using its number

    // initialize the pushbutton pin as an input:     pinMode(2, INPUT);

}

void loop() {

    // read the state of the pushbutton value:     buttonState = DigitalRead(2);

    // check if the pushbutton is pressed.

    // If it's not, the buttonState is HIGH : if (buttonState == HIGH)

    {

        // turn LED off:

        digitalWrite(13, LOW);

    } else     {

        // turn LED off:

        digitalWrite(13, HIGH);

    }

}

Lire Démarrer avec Arduino en ligne:

Chapitre 2: Arduino IDE

Examples

Installation sous Windows

1.  Allez à

2.  Cliquez sur le lien "Windows Installer"

3.  Suivez les instructions

Application portable sous Windows

Pour utiliser l'IDE Arduino sous Windows sans avoir besoin de l'installer:

1.  Allez à

2.  Cliquez sur le lien "Fichier Windows ZIP pour installation non admin"

3.  Extraire l'archive dans un dossier

4.  Ouvrez le dossier et double-cliquez sur

Installation sur Fedora

1.  Ouvrez un terminal et lancez: sudo dnf install arduino

2.  Ouvrez l'application Arduino ou tapez arduino dans le terminal

Installation sur Ubuntu

1.  Ouvrez un terminal et lancez: sudo apt-get install arduino

2.  Ouvrez l'application Arduino ou tapez arduino dans le terminal

Installation sur macOS

1.  Allez à

2.  Cliquez sur le lien Mac OS X

3.  Décompressez le fichier .zip .

4.  Déplacez l'application Arduino vers Applications .

Lire Arduino IDE en ligne:

Chapitre 3: Bibliothèque de cristaux liquides

Introduction

La Liquid Crystal Library Arduino est une bibliothèque pour contrôler les écrans LCD compatibles avec le pilote Hitachi HD44780, caractérisé par son interface 16 broches. Les 16 broches peuvent être connectées via une interface I2C. Ces écrans contiennent une matrice de blocs de 5x7 pixels utilisés pour afficher des caractères ou de petites images monochromatiques. Les affichages sont généralement nommés en fonction du nombre de lignes et de colonnes dont ils disposent, par exemple 16x2 ou 1602 pour 16 colonnes et 2 lignes et 20x4 ou 2004 pour 20 colonnes et 4 lignes.

Syntaxe

•    #include <LiquidCrystal.h> // Inclut la bibliothèque

•    LiquidCrystal (rs, enable, d4, d5, d6, d7) //

•    LiquidCrystal (rs, rw, enable, d4, d5, d6, d7)

•    LiquidCrystal (rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)

•    LiquidCrystal (rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)

Paramètres

Paramètre

LiquidCrystal

Détails

rs

le numéro de la broche Arduino connectée à la broche RS sur l'écran

LCD

rw

le numéro de la broche Arduino connectée à la broche RW de l'écran

LCD (facultatif)

activer

le numéro de la broche Arduino connectée à la broche d'activation sur l'écran LCD

d0 - d7

les numéros des broches Arduino connectées aux broches de données correspondantes sur l'écran LCD. d0, d1, d2 et d3 sont facultatifs; En cas d'omission, l'écran LCD sera contrôlé en utilisant uniquement les quatre lignes de données (d4, d5, d6, d7).

Examples

Utilisation de base

/*

  Wiring:

   LCD pin 1 (VSS) -> Arduino Ground

   LCD pin 2 (VDD) -> Arduino 5V

   LCD pin 3 (VO)  -> Arduino Ground

   LCD pin 4 (RS)  -> Arduino digital pin 12

   LCD pin 5 (RW)  -> Arduino Ground

   LCD pin 6 (E)   -> Arduino digital pin 11

   LCD pin 11 (D4) -> Arduino digital pin 5

   LCD pin 12 (D5) -> Arduino digital pin 4

   LCD pin 13 (D6) -> Arduino digital pin 3

   LCD pin 14 (D7) -> Arduino digital pin 2

*/

#include <LiquidCrystal.h> // include the library

// initialize the library with the numbers of the interface pins

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {

  // set up the LCD's number of columns and rows:   lcd.begin(16, 2);

  // start writing on the first row and first column.

  lcd.setCursor(0, 0);

  // Print a message to the LCD.   lcd.print("hello, world!");

}

void loop() {

  // No need to do anything to keep the text on the display

}

Lire Bibliothèque de cristaux liquides en ligne:

Chapitre 4: Bibliothèques

Introduction

Vous trouverez ici la documentation sur:

-Installer des bibliothèques dans l'IDE Arduino

-Inclusion des bibliothèques dans un croquis

Examples

Installation des bibliothèques avec le gestionnaire de bibliothèque

Pour installer une nouvelle bibliothèque dans l'IDE Arduino:

•    Ouvrir le menu Esquisse> Inclure la bibliothèque> Gérer les bibliothèques.

Une fois que vous avez ouvert le gestionnaire de bibliothèque, vous pouvez utiliser le menu en haut pour filtrer les résultats.

•    Cliquez sur la bibliothèque de votre choix, sélectionnez une version dans le menu déroulant, puis cliquez sur installer.

Votre bibliothèque est maintenant installée. Pour l'utiliser, vous devez l'inclure dans votre croquis.

Y compris les bibliothèques dans votre esquisse.


Une fois que vous avez installé une bibliothèque, vous devez l'inclure dans votre esquisse pour pouvoir l'utiliser.

•    Ouvrez le menu Esquisse> Inclure la bibliothèque et cliquez sur la bibliothèque que vous souhaitez inclure.

•    Maintenant, l'EDI a généré les balises d'inclusion requises dans votre code.

La bibliothèque est maintenant incluse dans votre esquisse et vous pouvez l'utiliser dans votre code.

Lire Bibliothèques en ligne:

Chapitre 5: Boucles

Syntaxe

•    pour (déclaration, condition, itération) {}

•    while (condition) {}

•    do {} while (condition)

Remarques

General Remark Si vous avez l'intention de créer une boucle pour attendre que quelque chose se produise, vous êtes probablement sur la mauvaise voie ici. Rappelez-vous plutôt que tout le code après setup () est exécuté à partir d’une méthode appelée loop (). Donc, si vous avez besoin d'attendre quelque chose, c'est plus facile de ne rien faire (ou seulement d'autres choses indépendantes) et de revenir pour vérifier la condition d'attente la prochaine fois.

do { } while(condition) n'évaluera pas l'instruction de condition avant la première itération. Il est important de garder cela à l’esprit si la déclaration de condition a des effets secondaires.

Examples

Tandis que

Une while boucle évaluera son état, et si true , il exécutera le code à l' intérieur et recommencer.

Autrement dit, tant que sa condition est évaluée à true , le while en boucle exécutera plus et plus.

Cette boucle sera exécutée 100 fois, en ajoutant chaque fois 1 à la variable num :

int num = 0; while (num < 100) {     // do something     num++; }

La boucle ci-dessus est équivalente à une boucle for :

for (int i = 0; i < 100; i++) {

    // do something

}

Cette boucle s'exécutera pour toujours:

while (true) {

    // do something

}

La boucle ci-dessus est équivalente à une boucle for :

for (;;) {

    // do something

}

Pour

for les boucles sont syntaxe simplifiée pour une configuration de boucle très fréquent, ce qui pourrait être accompli en plusieurs lignes avec un while boucle.

Voici un exemple courant de boucle for , qui s'exécutera 100 fois puis s'arrêtera.

for (int i = 0; i < 100; i++) {

    // do something

}

Cela équivaut à une while boucle:

int num = 0; while (num < 100) {     // do something     num++; }

Vous pouvez créer une boucle sans fin en omettant la condition.

for (;;) {

    // do something

}

Cela équivaut à une while boucle:

while (true) {

    // do something

}

Faire pendant

A do while boucle est le même que while la boucle, sauf qu'il est garanti d'exécuter au moins une fois.

La boucle suivante sera exécutée 100 fois.

int i = 0; do {     i++;

} while (i < 100);

Une boucle similaire, mais avec une condition différente, exécutera 1 fois.

int i = 0; do {     i++;

} while (i < 0);

Si la boucle au- dessus était simplement un while boucle, il exécute 0 fois, parce que la condition évaluerait à false avant la première itération. Mais comme il s'agit d'une boucle do while while, elle s'exécute une fois, puis vérifie sa condition avant de l'exécuter à nouveau.

Contrôle de flux

Il existe des moyens de briser ou de modifier le flux d'une boucle.

break; quittera la boucle en cours et n'exécutera plus de lignes dans cette boucle.

continue; n'exécutera plus de code dans l'itération courante de la boucle, mais restera dans la boucle.

La boucle suivante exécutera 101 fois (i = 0, 1, , 100) au lieu de 1000 en raison de l'instruction break :

for (int i = 0; i < 1000; i++) {

    // execute this repeatedly with i = 0, 1, 2,      if (i >= 100) {         break;

    }

}

La boucle suivante aura pour résultat que la valeur de j sera 50 au lieu de 100, à cause de l'instruction continue :

int j=0; for (int i = 0; i < 100; i++) {     if (i % 2 == 0) { // if `i` is even         continue;

    } j++; } // j has the value 50 now.

Lire Boucles en ligne:

Chapitre 6: Broches de matériel

Examples

Arduino Uno R3

Les microcontrôleurs utilisent des broches pour interagir avec le reste du circuit. Ces broches seront généralement l'une des broches d'entrée / sortie, vin ou terre. Les broches d'E / S peuvent être de simples broches d'E / S numériques ou présenter certaines caractéristiques spécifiques, telles que la possibilité de faire varier la tension de leur sortie en utilisant une modulation de largeur d'impulsion. Voici un schéma de l'Arduino R3 Uno et de ses broches.


( source )

Pins PWM PWM vous permet de contrôler la tension de la sortie en commutant la sortie entre haute et basse très très rapidement. Le pourcentage de temps pendant lequel la broche est haute est appelé «cycle de travail».

Broches PWM: 3, 5, 6, 9, 10, 11

Entrées analogiques

Tout comme une broche PWM peut émettre une gamme de tensions, les broches analogiques de l'Arduino Uno R3 peuvent détecter une gamme de tensions d'entrée. Vous pouvez l'utiliser pour lire la position d'un potentiomètre ou d'une autre entrée avec une entrée variable en douceur. Veuillez noter que les broches analogiques ne peuvent pas effectuer de sortie analogWrite - pour cela, vous devez utiliser des broches PWM.

Broches analogiques du CAN: A0, A1, A2, A3, A4, A5

Série, SPI et I2C

Les broches série de l'Arduino Uno R3 sont également utilisées par exemple par la puce USB vers série lorsqu'elle communique avec un ordinateur via le port USB intégré. Série: Tx sur 0, Rx sur 1

SPI et I2C sont des protocoles de communication que l’Arduino peut utiliser pour communiquer avec des blindages, des capteurs, des sorties, etc.:

Pins SPI: MOSI on 11, MISO 12, SCLK 13, SS 10

Broches I2C: SCL sur A5, SDA sur A4

LED embarquée

L’Arduino Uno R3 possède une LED avec sa propre résistance connectée à la broche 13. Cela signifie que même si vous n’attachez aucune LED à votre carte, si vous réglez la broche 13 sur une sortie et que vous la définissez à un niveau élevé, vous devriez voir une LED sur le tableau venez. Utilisez l'exemple d'esquisse «Blink» pour localiser votre LED intégrée.

De la page des épingles numériques d'Arduino

REMARQUE: La broche numérique 13 est plus difficile à utiliser comme entrée numérique que les autres broches numériques car elle est connectée à la carte sur la plupart des cartes par une LED et une résistance. Si vous activez sa résistance de tirage interne de 20k, celle-ci sera maintenue à environ 1,7V au lieu de 5V, car les résistances LED et série intégrées réduisent le niveau de tension, ce qui signifie qu’elle restitue toujours LOW. Si vous devez utiliser la broche 13 comme entrée numérique, réglez son mode pinMode () sur INPUT et utilisez une résistance de rappel externe.

Broche LED embarquée: 13

Lire Broches de matériel en ligne:


Chapitre 7: Comment Python s'intègre à Arduino Uno

Syntaxe

•    Serial.begin(baudrate) // Set baud rate (bits per second) for serial data transmission

•    Serial.println(value) // Print data to serial port followed by Carriage Return \r and Newline character \n

•    serial.Serial((port=None, baudrate=9600, bytesize=EIGHTBITS, parity=PARITY_NONE, stopbits=STOPBITS_ONE, timeout=None, xonxoff=False, rtscts=False, write_timeout=None, dsrdtr=False, inter_byte_timeout=None) // Initialize serial port with all parameters • serial.readline() // Read serial data which contains Carriage Return \r and Newline character \n

Paramètres

Paramètre

Détails

en série

Le paquet Python contient des classes et des méthodes pour accéder au port série

temps

Le package Python inclut des fonctions liées au temps

Remarques

J'utilise un Arduino Uno avec Arduino IDE 1.6.9 et Python 2.7.12 fonctionnant sous Windows 10.

Examples

Première communication série entre Arduino et Python

Dans ce premier exemple, une opération d'écriture série de base est lancée à partir d'un périphérique Arduino.

void setup() {

  // put your setup code here, to run once:

  Serial.begin(9600);

}

void loop() {

  // put your main code here, to run repeatedly:

Serial.println("Hello World!");   delay(100);

}

Dans setup() , la fonction Serial.begin(9600) configure le débit en bauds pour la communication de données en série. Dans cet exemple, un débit en bauds de 9600 est utilisé. D'autres valeurs peuvent être lues ici: Fonction Arduino Serial.begin ()

Dans loop() , le premier message que nous souhaitons envoyer est "Hello World!". Ce message est transmis en utilisant Serial.println("Hello World!") il enverra cette chaîne au port série au format ASCII. À la fin du message, il y a le retour de chariot (CR, \r) et le caractère de nouvelle ligne (\n) . De plus, un délai de 100 millisecondes est utilisé chaque fois que le programme imprime sur le port série.

Ensuite, téléchargez cette esquisse Arduino via le port COM (rappelez-vous ce numéro de port COM tel qu’il sera utilisé dans le programme Python).

Le programme Python qui lit les données série envoyées par l’appareil Arduino est illustré cidessous:

import serial import time

ser = serial.Serial('COM8', 9600) while (1):

    print ser.readline()     time.sleep(0.1)

Tout d'abord, le paquetage pyserial doit être importé. Pour plus d'informations sur l'installation de pyserial dans un environnement Windows, veuillez consulter cette instruction: Installation de Python et de pyserial . Ensuite, nous initialisons le port série avec le numéro de port COM et le débit en bauds. Le débit en bauds doit être identique à celui utilisé dans l'esquisse Arduino.

Le message reçu sera imprimé en boucle en utilisant la fonction readline() . Un délai de 100 millisecondes est également utilisé ici, comme dans l'esquisse Arduino. Veuillez noter que la fonction readline() pyserial nécessite un délai d'expiration lors de l'ouverture d'un port série (documentation pyserial : PySerial ReadLine ).

Lire Comment Python s'intègre à Arduino Uno en ligne:

Chapitre 8: Comment stocker des variables dans EEPROM et les utiliser pour le stockage permanent

Syntaxe

•    EEPROM.write (adresse, valeur); // (Stocker les variables dans EEPROM dans une adresse particulière)

•    (adresse); // (Récupère les valeurs de l'EEPROM et lit les données stockées dans l'EEPROM)

Paramètres

Paramètres de

EEPROM.write

Détail

adresse

L'adresse où la valeur doit être stockée dans l'EEPROM

valeur

Variable principale à stocker dans l'EEPROM. Notez qu'il s'agit d'un uint_8 (single byte) - vous devez séparer vous-même les types de données à plusieurs octets en octets simples. Vous pouvez également utiliser pour stocker des flottants ou d'autres types de données.

Paramètres d'

Détail

adresse

L'adresse à partir de laquelle la variable doit être lue

Remarques

Les adresses autorisées varient selon le matériel.

•    ATMega328 (Uno, Pro Mini, etc.): 0–1023

•    ATMega168: 0-511

•    ATMega1280: 0-4095

•    ATMega2560: 0-4095

la source

Examples

Stockez une variable dans EEPROM, puis récupérez-la et imprimez-la sur l'écran

Tout d'abord, ajoutez une référence à <EEPROM.h> au début de votre esquisse:

#include <EEPROM.h>

Ensuite, votre autre code:

// Stores value in a particular address in EEPROM. There are almost 512 addresses present.

    // Store value 24 to Address 0 in EEPROM     int addr = 0;     int val = 24;

    EEPROM.write(addr, val);     // Writes 24 to address 0

    // ---------

    // Retrieves value from a particular address in EEPROM

    // Retrieve value from address 0 in EEPROM

    int retrievedVal = (0);    // Retrieves value stored in 0 address in

// EEPROM

    // *[NOTE: put Serial.begin(9600); at void setup()]*

Serial.println(retrievedVal);        // Prints value stored in EEPROM Address 0 to

                                         // Serial (screen)

Lire Comment stocker des variables dans EEPROM et les utiliser pour le stockage permanent en ligne:

Chapitre 9: Communication Bluetooth

Paramètres

méthode

détails

SoftwareSerial.h

Documentation

SoftwareSerial (rxPin, txPin, inverse_logic)

Constructeur. rxPin : La valeur par défaut des données dans la broche (de réception) est 0. txPin : Broche de sortie de données (transmise), valeur par défaut: 1. inverse_logic : si true, traite LOW comme si HIGH et HIGH. par défaut à false.

commencer (vitesse)

Définit le débit en bauds pour la communication série. Les débits en bauds pris en charge sont 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600 et 115200.

disponible()

Vérifiez s'il y a des données sur la série

lis()

Lit une chaîne de série

écoute()

Vérifie si le port série du logiciel demandé écoute activement.

débordement()

Vérifie si un dépassement de tampon série du logiciel s'est produit. L'appel de cette fonction efface l'indicateur de débordement, ce qui signifie que les appels suivants renverront false sauf si un autre octet de données a été reçu et éliminé entre-temps. Le tampon série du logiciel peut contenir 64 octets.

peek ()

Renvoie un caractère reçu sur la broche RX du port série du logiciel. Contrairement à read (), les appels suivants à cette fonction renverront le même caractère. Notez qu'une seule instance de

SoftwareSerial peut recevoir des données entrantes à la fois (sélectionnez celle avec la fonction listen() ).

imprimer (données)

Imprime les données sur la broche de transmission du port série du logiciel. Fonctionne de la même manière que la fonction Serial.print() .

println (données)

Imprime les données sur la broche de transmission du port série du logiciel, suivie d'un retour chariot et d'un saut de ligne. Fonctionne de la même manière que la fonction Serial.println() .

Permet au port série du logiciel sélectionné d’écouter. Un seul port

écouter ()

série de logiciel peut écouter à la fois; les données qui arrivent pour les autres ports seront supprimées. Toutes les données déjà reçues sont ignorées pendant l'appel à listen() (à moins que l'instance

méthode

détails

donnée n'écoute déjà).

écrire (données)

Imprime les données sur la broche de transmission du port série du logiciel en tant qu'octets bruts. Fonctionne comme la fonction Serial.write() .

Remarques

Erreur commune: Si vous conservez les broches rx et tx à leurs valeurs par défaut (0 et 1), vous ne pouvez pas télécharger de nouveau code tant que vous ne le supprimez pas.

Examples

Monde de base bluetooth bonjour

#include <SoftwareSerial.h>

// its always better to change the default tx and rx as the may interfere with other process in future.

// configure tx , rx by defualt they will be 0 and 1 in arduino UNO

SoftwareSerial blue(3,2); void setup() {

  // preferred baud rate/data transfer rate in general is 38400 blue.begin(38400);

  // do initialization or put one time executing code here

}

void loop() {

  // put code that you want it to run every time no matter what if(blue.available()){

        // put only that code which needsd to run when there is some data

        // This means that the their is some data sent over the bluetooth

        // You can do something with the data

        int n;

        // consider that the data received to be integer, read it by using blue.parseInt();

        n = blue.parseInt();

    }

}

Lire Communication Bluetooth en ligne:

Chapitre 10: Communication I2C

Introduction

I2C est un protocole de communication qui permet à deux cartes Arduino ou plus de se parler. Le protocole utilise deux broches - SDA (ligne de données) et SCL (ligne d'horloge). Ces broches sont différentes d'un type de carte Arduino à un autre, vérifiez donc les spécifications de la carte.

Le protocole I2C définit une carte Arduino comme maître et toutes les autres comme esclave.

Chaque esclave a une adresse différente que le programmeur a définie en dur. Remarque: Assurez-vous que toutes les cartes connectées à la même source VCC

Examples

Plusieurs esclaves

L'exemple suivant montre comment le maître peut recevoir des données de plusieurs esclaves. Dans cet exemple, l'esclave envoie deux numéros courts. Le premier est pour la température et le second pour l'humidité. Veuillez noter que la température est un flotteur (24.3). Pour utiliser seulement deux octets et non quatre (float est quatre octets), je multiplie la température par 10 et la sauvegarde en tant que court-circuit. Voici donc le code maître:

#include <Wire.h>

#define BUFFER_SIZE  4

#define MAX_NUMBER_OF_SLAVES 24

#define FIRST_SLAVE_ADDRESS 1

#define READ_CYCLE_DELAY 1000

byte buffer[BUFFER_SIZE];

void setup()

{

  Serial.begin(9600);

Serial.println("MASTER READER");

Serial.println("*************");

  Wire.begin();        // Activate I2C link

}

void loop()

{

  for (int slaveAddress = FIRST_SLAVE_ADDRESS;        slaveAddress <= MAX_NUMBER_OF_SLAVES;        slaveAddress++)

  {

    Wire.requestFrom(slaveAddress, BUFFER_SIZE);    // request data from the slave     if(Wire.available() == BUFFER_SIZE)

      {  // if the available data size is same as I'm expecting

        // Reads the buffer the slave sent         for (int i = 0; i < BUFFER_SIZE; i++)

        {

          buffer[i] = ();  // gets the data

        }

        // Parse the buffer

        // In order to convert the incoming bytes info short, I use union         union short_tag {           byte b[2];           short val;         } short_cast;

        // Parse the temperature         short_cast.b[0] = buffer[0]; short_cast.b[1] = buffer[1];         float temperature = ((float)()) / 10;

        // Parse the moisture         short_cast.b[0] = buffer[2]; short_cast.b[1] = buffer[3];         short moisture = ;

        // Prints the income data

Serial.print("Slave address ");

Serial.print(slaveAddress);

Serial.print(": Temprature = ");

Serial.print(temprature);

Serial.print("; Moisture = ");

Serial.println(moisture);

      }

    }

Serial.println("*************************");

delay(READ_CYCLE_DELAY);

  }

}

Et maintenant le code de l'esclave:

#include <Wire.h>

#include <OneWire.h>

#include <DallasTemperature.h>

//=====================

// This is the hard-coded address. Change it from one device to another

#define SLAVE_ADDRESS 1

//=====================

// I2C Variables

#define BUFFER_SIZE 2

#define READ_CYCLE_DELAY 1000 short data[BUFFER_SIZE];

// Temprature Variables

OneWire oneWire(8);

DallasTemperature temperatureSensors(&oneWire); float m_temperature;

// Moisture Variables short m_moisture;

// General Variables


int m_timestamp;

void setup()

{

  Serial.begin(9600);

Serial.println("SLAVE SENDER");

  Serial.print("Node address: ");

Serial.println(SLAVE_ADDRESS);

  Serial.print("Buffer size: ");

Serial.println(BUFFER_SIZE * sizeof(short)); Serial.println("***********************");

  m_timestamp = millis();

Wire.begin(NODE_ADDRESS);  // Activate I2C network

Wire.onRequest(requestEvent); // Set the request event handler temperatureSensors.begin();

}

void loop()

{

  if(millis() - m_timestamp < READ_CYCLE_DELAY) return;

  // Reads the temperature

temperatureSensors.requestTemperatures();   m_temperature = temperatureSensors.getTempCByIndex(0);

  // Reads the moisture   m_moisture = analogRead(A0);

}

void requestEvent()

{

  data[0] = m_temperature * 10; // In order to use short, I multiple by 10   data[1] = m_moisture;

  Wire.write((byte*)data, BUFFER_SIZE * sizeof(short));

}

Lire Communication I2C en ligne:

Chapitre 11: Communication MIDI

Introduction

L'intention de cette rubrique est de démontrer certains programmes MIDI de base qui montrent comment utiliser le protocole et ajouter progressivement des fonctionnalités utiles que les applications plus complexes requièrent.

Examples

MIDI THRU Exemple

Le MIDI Thru est simple et facile à tester. Lorsque vous travaillez correctement, vous pourrez installer votre projet Arduino entre deux appareils MIDI, MIDI IN sur MIDI OUT et vous pourrez vérifier que les deux appareils fonctionnent ensemble. Si vous avez la possibilité de mesurer la latence, vous verrez une augmentation due à la capture de mémoire tampon en série et aux instructions de retransmission.

// This is a simple MIDI THRU.  Everything in, goes right out.

// This has been validate on an Arduino UNO and a Olimex MIDI Shield

boolean byteReady; unsigned char midiByte;

void setup() {     // put your setup code here, to run once:

    //  Set MIDI baud rate:

Serial.begin(31250);     byteReady = false;     midiByte = 0;

}

// The Loop that always gets called void loop() {    if (byteReady) { byteReady = false;

Serial.write(midiByte);

    }

}

 // The little function that gets called each time loop is called.

// This is automated somwhere in the Arduino code. void serialEvent() {   if (Serial.available()) {

    // get the new byte:     midiByte = (unsigned char)();     byteReady = true;

  }

}

MIDI Thru with Queue

// This is a more complex MIDI THRU.  This version uses a queue.  Queues are important because some

// MIDI messages can be interrupted for real time events.  If you are generating your own messages, // you may need to stop your message to let a "real time" message through and then resume your message.

#define QUEUE_DEPTH 128

// Queue Logic for storing messages int headQ = 0; int tailQ = 0; unsigned char tx_queue[QUEUE_DEPTH];

void setup() {     // put your setup code here, to run once:

    //  Set MIDI baud rate:

    Serial.begin(31250);

}

// getQDepth checks for roll over.  Folks have told me this

// is not required.  Feel free to experiment.

int getQDepth() { int depth = 0;     if (headQ < tailQ) {         depth = QUEUE_DEPTH - (tailQ - headQ);

    } else {

        depth = headQ - tailQ;

    }

    return depth;

}

void addQueue (unsigned char myByte) {     int depth = 0;     depth = getQDepth();

    if (depth < (QUEUE_DEPTH-2)) {         tx_queue[headQ] = myByte; headQ++;         headQ = headQ % QUEUE_DEPTH; // Always keep the headQ limited between 0 and 127

    }

}

unsigned char deQueue() {     unsigned char myByte;     myByte = tx_queue[tailQ]; tailQ++;     tailQ = tailQ % QUEUE_DEPTH;  // Keep this tailQ contained within a limit

    // Now that we dequeed the byte, it must be sent.     return myByte;

}

void loop() {

   if (getQDepth>0) {

Serial.write(deQueue());

    }

}

 // The little function that gets called each time loop is called.

// This is automated somwhere in the Arduino code.

void serialEvent() {   if (Serial.available()) {

    // get the new byte:     addQueue((unsigned char)());;

  }

}

Génération d'horloge MIDI

// This is a MiDI clk generator.  This takes a #defined BPM and

// makes the appropriate clk rate.  The queue is used to let other messages // through, but allows a clock to go immediately to reduce clock jitter

#define QUEUE_DEPTH 128

#define BPM 121

#define MIDI_SYSRT_CLK 0xF8

// clock tracking and calculation unsigned long lastClock; unsigned long captClock; unsigned long clk_period_us;

// Queue Logic for storing messages int headQ = 0; int tailQ = 0; unsigned char tx_queue[QUEUE_DEPTH];

void setup() {

    //  Set MIDI baud rate:

    Serial.begin(31250);

clk_period_us = 60000000 / (24 * BPM);     lastClock = micros();

}

// getQDepth checks for roll over.  Folks have told me this

// is not required.  Feel free to experiment. int getQDepth() { int depth = 0;     if (headQ < tailQ) {         depth = QUEUE_DEPTH - (tailQ - headQ);

    } else {

        depth = headQ - tailQ;

    }

    return depth;

}

void addQueue (unsigned char myByte) {     int depth = 0;     depth = getQDepth();

    if (depth < (QUEUE_DEPTH-2)) {         tx_queue[headQ] = myByte; headQ++;         headQ = headQ % QUEUE_DEPTH; // Always keep the headQ limited between 0 and 127

    }

}

unsigned char deQueue() {     unsigned char myByte;

    myByte = tx_queue[tailQ];     tailQ++;     tailQ = tailQ % QUEUE_DEPTH;  // Keep this tailQ contained within a limit

    // Now that we dequeed the byte, it must be sent.     return myByte;

}

void loop() {     captClock = micros();

    if (lastClock > captClock) {

        // we have a roll over condition - Again, maybe we don't need to do this.         if (clk_period_us <= (4294967295 - (lastClock - captClock))) {

            // Add a the ideal clock period for this BPM to the last measurement value             lastClock = lastClock + clk_period_us;

            // Send a clock, bypasing the transmit queue

Serial.write(MIDI_SYSRT_CLK);

        }

    } else if (clk_period_us <= captClock-lastClock) {

        // Basically the same two commands above, but not within a roll over check         lastClock = lastClock + clk_period_us;

        // Send a clock, bypasing the transmit queue

Serial.write(MIDI_SYSRT_CLK);

    }

    if (getQDepth>0) {

Serial.write(deQueue());

    }

}

 // The little function that gets called each time loop is called.

// This is automated somwhere in the Arduino code. void serialEvent() {   if (Serial.available()) {

    // get the new byte:     addQueue((unsigned char)());;

  }

}

Messages MIDI définis

En général, le protocole MIDI est décomposé en "messages". Il existe 4 classes générales de messages:

•    Voix Channel

•    Mode de canal

•    Système commun

•    Messages système en temps réel



Les messages commencent par une valeur d'octet supérieure à 0x80. Toute valeur inférieure à 0x7F est considérée comme une donnée. Ce qui signifie que 127 est la valeur maximale pouvant être encodée dans un seul octet de données MIDI. Pour encoder des valeurs plus grandes, deux octets de données MIDI ou plus sont requis.

Il convient de signaler que les messages doivent être envoyés pour terminer sans interruption

SAUF Système Les messages en temps réel, qui sont un seul octet, peuvent être injectés au milieu de n'importe quel message.

Messages vocaux de canal

Statut

D7..D0

Octets de données

La description

1000nnnn

0kkkkkkk

0vvvvvvv

Note Off event. Ce message est envoyé lorsqu'une note est libérée (terminée). (kkkkkkk) est le numéro de la clé (note).

(vvvvvvv) est la vitesse.

1001nnnn

0kkkkkkk

0vvvvvvv

Remarque sur l'événement. Ce message est envoyé lorsqu'une note est enfoncée (début). (kkkkkkk) est le numéro de la clé (note). (vvvvvvv) est la vitesse.

1010nnnn

0kkkkkkk

0vvvvvvv

Pression de touche polyphonique (Aftertouch). Ce message est le plus souvent envoyé en appuyant sur la touche

(kkkkkkk) est le numéro de la clé (note). (vvvvvvv) est la valeur de la pression.

1011nnnn

0ccccccc

0vvvvvvv

Changement de contrôle. Ce message est envoyé lorsqu'une valeur de contrôleur change. Les contrôleurs incluent des dispositifs tels que des pédales et des leviers. Les numéros de contrôleur 120-127 sont réservés en tant que "Messages de mode de canal" (ci-dessous). (ccccccc) est le numéro du contrôleur (0-119). (vvvvvvv) est la valeur du contrôleur (0127).

1100nnnn

0ppppppp

Changement de programme. Ce message est envoyé lorsque le numéro de patch change. (ppppppp) est le nouveau numéro de programme.

1101nnnn

0vvvvvvv

Pression du canal (After-touch). Ce message est le plus souvent envoyé en appuyant sur la touche Ce message est différent du post-touch polyphonique. Utilisez ce message pour envoyer la valeur de pression maximale la plus élevée (de toutes les touches enfoncées actuelles). (vvvvvvv) est la valeur de la pression.

1110nnnn

0lllllll

0mmmmmmm

Changement de Pitch Bend. Ce message est envoyé pour indiquer une modification de la hauteur tonale (roue ou levier, en général). Le pitch bender est mesuré par une valeur de quatorze bits. Centre (pas de changement de hauteur) est 2000H. La sensibilité est une fonction du récepteur, mais peut être définie à l'aide de RPN 0. (lllllll) sont les 7 bits les moins significatifs. (mmmmmmm) sont les 7 bits les plus significatifs.

Messages du mode canal

Statut

D7..D0

Octets de données

La description

1011nnnn

0ccccccc

0vvvvvvv

Messages du mode canal. C'est le même code que le changement de commande (ci-dessus), mais implémente le contrôle de mode et le message spécial en utilisant les numéros de contrôleur réservés 120-127. Les commandes sont les suivantes:

Tout son éteint. À la réception de tous les sons désactivés, tous les oscillateurs s’éteignent et leurs enveloppes de volume sont mises à zéro dès que possible. c = 120, v = 0: tout son éteint

Réinitialiser tous les contrôleurs. Lorsque Réinitialiser tous les contrôleurs est reçu, toutes les valeurs du contrôleur sont réinitialisées à leurs valeurs par défaut. (Voir les pratiques spécifiques recommandées pour les défauts).

c = 121, v = x: la valeur ne doit être nulle que si cela est autorisé autrement dans une pratique spécifique recommandée.

Contrôle local. Lorsque le contrôle local est désactivé, tous les périphériques d'un canal donné répondent uniquement aux données reçues via MIDI. Les données lues, etc. seront ignorées.

Local Control On restaure les fonctions des contrôleurs normaux.

c = 122, v = 0: contrôle local désactivé

c = 122, v = 127: Contrôle local activé

Toutes les notes sont désactivées. Lorsqu'un signal All Notes est reçu, tous les oscillateurs sont désactivés.

c = 123, v = 0: Toutes les notes sont désactivées (Voir le texte pour la description des commandes du mode réel.)

c = 124, v = 0: Mode Omni désactivé

c = 125, v = 0: mode omni activé

c = 126, v = M: Mode mono activé (Poly désactivé) où M est le nombre de canaux (Omni Off) ou 0 (Omni On)

c = 127, v = 0: Mode Poly activé (Mono Off) (Remarque: ces quatre messages provoquent également la désactivation de toutes les notes)

Messages communs au système

Statut

D7..D0

Octets de données

La description

11110000

0iiiiiii [0iiiiiii

0iiiiiii] 0ddddddd

--- --- 0ddddddd

11110111

Système exclusif Ce type de message permet aux fabricants de créer leurs propres messages (tels que des vidages en masse, des paramètres de patch et d'autres données non spécifiées) et fournit un mécanisme pour créer des messages de spécification MIDI supplémentaires. Le code d'identification du fabricant (attribué par MMA ou AMEI) est

soit 1 octet (0iiiiiii), soit 3 octets (0iiiiiii 0iiiiiii 0iiiiiii). Deux des ID à 1 octet sont réservés aux extensions appelées messages exclusifs universels, qui ne sont pas spécifiques à un fabricant. Si un appareil reconnaît le code d'identification comme étant le sien (ou comme un message universel pris en charge), il écoutera le reste du message (0ddddddd). Sinon, le message sera ignoré. (Remarque: seuls les messages en temps réel peuvent être entrelacés avec un système exclusif.)

11110001

0nnndddd

MIDI Time Code Quarter Frame. nnn = Type de message dddd = Valeurs

11110010

0lllllll

0mmmmmmm

Pointeur de position de morceau. C'est un registre interne à 14 bits qui contient le nombre de battements MIDI (1 battement = six horloges MIDI) depuis le début du morceau. l est le LSB, m le MSB.

11110011

0sssssss

Song Select. The Song Select spécifie la séquence ou le morceau à jouer.

11110100

Indéfini. (Réservé)

11110101

Indéfini. (Réservé)

11110110

Demande de réglage. À la réception d'une demande de réglage, tous les synthétiseurs analogiques doivent accorder leurs oscillateurs.

11110111

Fin de la exclusivité. Utilisé pour terminer un vidage exclusif du système (voir ci-dessus).

Messages système en temps réel

Statut

D7..D0

Octets de données

La description

11111000

Horloge de chronométrage Envoyé 24 fois par trimestre, lorsque la synchronisation est requise (voir texte).

Statut

D7..D0

Octets de données

La description

11111001

Indéfini. (Réservé)

11111010

Début. Lancer la séquence en cours de lecture. (Ce message sera suivi par des horloges de synchronisation).

11111011

Continuer. Continuez au point où la séquence a été arrêtée.

11111100

Arrêtez. Arrête la séquence en cours.

11111101

Indéfini. (Réservé)

11111110

Détection active. Ce message est destiné à être envoyé à plusieurs reprises pour indiquer au destinataire qu'une connexion est active. L'utilisation de ce message est facultative. Lorsqu'il est initialement reçu, le récepteur s'attend à recevoir un autre message Active Sensing tous les 300 ms (max) et s'il ne le fait pas, il supposera que la connexion est terminée. À la fin de la communication, le récepteur éteindra toutes les voix et reviendra au fonctionnement normal (détection non active).

11111111

Réinitialiser. Réinitialise tous les récepteurs du système au statut de mise sous tension. Ceci doit être utilisé avec parcimonie, de préférence sous contrôle manuel. En particulier, il ne devrait pas être envoyé à la mise sous tension.

Lire Communication MIDI en ligne:

Chapitre 12: Communication série

Syntaxe

•    Serial.begin(speed) // Ouvre le port série sur le débit en bauds donné

•    Serial.begin(speed, config)

•    Serial[1-3].begin(speed) // Arduino Mega uniquement! Lorsque vous écrivez 1-3, cela signifie que vous pouvez choisir entre les numéros 1 à 3 lors du choix du port série.

•    Serial[1-3].begin(speed, config) // Arduino Mega seulement! Lorsque vous écrivez 1-3, cela signifie que vous pouvez choisir entre les numéros 1 à 3 lors du choix du port série.

•    () // Lit le prochain octet de l'entrée sans le retirer du tampon

•    Serial.available() // Obtient le nombre d'octets dans le tampon

•    Serial.print(text) // Écrit le texte sur le port série

•    Serial.println(text) // Identique à Serial.print() mais avec une nouvelle ligne

Paramètres

Paramètre

Détails

La vitesse

Le taux du port série (généralement 9600)

Texte

Le texte à écrire sur le port série (n'importe quel type de données)

Bits de

données

Nombre de bits de données dans un paquet (de 5 à 8), la valeur par défaut est 8

Parité

Options de parité pour la détection des erreurs: none (par défaut), pair, impair

Bits d'arrêt

Nombre de bits d'arrêt dans un paquet: un (par défaut), deux

Remarques

L'Arduino Mega dispose de quatre ports série parmi lesquels il est possible de choisir. Ils sont accédés de la manière suivante

  Serial.begin(9600);

  Serial1.begin(38400);

  Serial2.begin(19200);

  Serial3.begin(4800);

Le port série d'un Arduino peut être configuré avec des paramètres supplémentaires. Le paramètre config définit les bits de données, la parité et les bits d'arrêt. Par exemple:

8 bits de données, même parité et 1 bit d'arrêt seraient - SERIAL_8E1

6  bits de données, parité impaire et 2 bits d'arrêt seraient - SERIAL_6O2

7  bits de données, pas de parité et 1 bit d'arrêt serait - SERIAL_7N1

Examples

Simple à lire et à écrire

Cet exemple écoute les entrées provenant de la connexion série, puis les répète sur la même connexion.

byte incomingBytes;

void setup() {

  Serial.begin(9600); // Opens serial port, sets data rate to 9600 bps.

}

void loop() {

  // Send data only when you receive data.

  if (Serial.available() > 0) {     // Read the incoming bytes. incomingBytes = ();      // Echo the data.

Serial.println(incomingBytes);

  }

}

Filtrage Base64 pour les données d'entrée série

String base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

void setup() {

    Serial.begin(9600); // Turn the serial protocol ON

Serial.println("Start Typing");

}

void loop() {

    if (Serial.available() > 0) { // Check if data has been sent from the user         char c = ();   // Gets one byte/Character from serial buffer         int result = base64.indexOf(c); // Base64 filtering         if (result>=0)

            Serial.print(c); // Only print Base64 string

    }

}

Gestion des commandes sur série

byte incoming; String inBuffer;

void setup() {

    Serial.begin(9600); // or whatever baud rate you would like

}

void loop(){

    // setup as non-blocking code     if(Serial.available() > 0) { incoming = ();

        if(incoming == '\n') {  // newline, carriage return, both, or custom character

// handle the incoming command             handle_command();

// Clear the string for the next command             inBuffer = "";

        } else{

// add the character to the buffer             inBuffer += incoming;

        }

    }

     // since code is non-blocking, execute something else . . . .

}

void handle_command() {

    // expect something like 'pin 3 high'

    String command = inBuffer.substring(0, inBuffer.indexOf(' '));     String parameters = inBuffer.substring(inBuffer.indexOf(' ') + 1);

if(command.equalsIgnoreCase('pin')){

        // parse the rest of the information

        int pin = parameters.substring("0, parameters.indexOf(' ')).toInt();

        String state = parameters.substring(parameters.indexOf(' ') + 1);

if(state.equalsIgnoreCase('high')){             digitalWrite(pin, HIGH);

}else if(state.equalsIgnoreCase('low)){             digitalWrite(pin, LOW);

        }else{

Serial.println("did not compute");

        }

    } // add code for more commands

}

Communication série avec Python

Si vous avez un Arduino connecté à un ordinateur ou à un Raspberry Pi et que vous souhaitez envoyer des données de l’Arduino au PC, vous pouvez procéder comme suit:

Arduino:

void setup() {

  // Opens serial port, sets data rate to 9600 bps:

  Serial.begin(9600);

}

void loop() {

  // Sends a line over serial:

  Serial.println("Hello, Python!");   delay(1000); }

Python:

import serial

ser = serial.Serial('/dev/ttyACM0', 9600)  # Start serial communication while True:

    data = ser.readline()  # Wait for line from Arduino and read it     print("Received: '{}'".format(data))  # Print the line to the console

Lire Communication série en ligne:

Chapitre 13: Communication SPI

Remarques

Signaux de sélection de puce

La plupart des esclaves ont une entrée de sélection de puce faible active. Le code approprié pour initialiser et utiliser une broche de sélection de puce est le suivant:

#define CSPIN 1 // or whatever else your CS pin is

// init: pinMode(CSPIN, OUTPUT); digitalWrite(CSPIN, 1); // deselect 

// use: digitalWrite(CSPIN, 0); // select

perform data transfer

digitalWrite(CSPIN, 1); // deselect

La désélection d'un esclave est tout aussi importante que sa sélection, car un esclave peut piloter la ligne MISO pendant sa sélection. Il peut y avoir beaucoup d'esclaves, mais un seul peut conduire MISO. Si un esclave n'est pas désélectionné correctement, deux esclaves ou plus peuvent piloter le MISO, ce qui peut entraîner des courts-circuits entre leurs sorties et endommager les appareils.

Transactions

Les transactions ont deux objectifs:

•    dire au SPI que nous voulons commencer et finir de l'utiliser dans un contexte particulier

•    configurer le SPI pour une puce spécifique

La ligne d'horloge a différents états de veille dans les différents modes SPI. Le changement du mode SPI lorsqu'un esclave est sélectionné peut induire en erreur l'esclave. Réglez donc toujours le mode SPI avant de sélectionner un esclave. Le mode SPI peut être défini avec un objet SPISettings transmis à SPI.beginTransaction :

SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); digitalWrite(CSPIN, 0);

perform data transfer

digitalWrite(CSPIN, 1); SPI.endTransaction();

SPISettings peuvent également être stockés ailleurs:

SPISettings mySettings(1000000, MSBFIRST, SPI_MODE0);

SPI.beginTransaction(mySettings);

Si une autre partie du code tente d'utiliser le SPI entre une paire d'appels à beginTransaction() et endTransaction() , une erreur peut survenir - la manière dont cela se produit dépend de l'implémentation.

Voir aussi la référence Arduino: SPISettings

Utilisation du SPI dans les routines du service d'interruption

Si le SPI doit être utilisé dans un ISR, aucune autre transaction ne peut avoir lieu en même temps.

La bibliothèque SPI fournit usingInterrupt(interrupt_number) pour faciliter cela. Cela fonctionne en désactivant l'interruption donnée chaque fois que beginTransaction() est appelée, de sorte que l'interruption ne peut pas se déclencher entre cette paire d'appels à beginTransaction() et endTransaction() .

Voir aussi la référence Arduino: SPI: usingInterrupt

Examples

Notions de base: initialiser le SPI et une broche de sélection de puce, et effectuer un transfert d'un octet

#include <SPI.h>

#define CSPIN 1

void setup() {   pinMode(CSPIN, OUTPUT); // init chip select pin as an output digitalWrite(CSPIN, 1); // most slaves interpret a high level on CS as "deasserted"

  SPI.begin();

SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); digitalWrite(CSPIN, 0);

  unsigned char sent = 0x01;   unsigned char received = SPI.transfer(sent);

  // more data could be transferred here

digitalWrite(CSPIN, 1);   SPI.endTransaction();

  ();

}

void loop() {

  // we don't need loop code in this example.

}

Cet exemple:

•    initialise correctement et utilise une broche de sélection de puce (voir remarques)

•    utilise correctement une transaction SPI (voir remarques)

•    utilise uniquement le SPI pour transférer un seul octet. Il existe également une méthode de transfert de tableaux, qui n’est pas utilisée ici.

Lire Communication SPI en ligne:


Chapitre 14: Entrées analogiques

Syntaxe

• analogRead(pin) // Lecture depuis la broche donnée.

Remarques

Serial.println(val)

Pour obtenir de l'aide sur la communication série, voir: Communication série

Examples

Imprimer une valeur analogique

int val = 0;    // variable used to store the value

                // coming from the sensor

void setup() {

  Serial.begin(9600); //Begin serializer to print out value

  // Note: Analogue pins are

  // automatically set as inputs

}

void loop() {

  val = analogRead(0); // read the value from

                       // the sensor connected to A0.

  Serial.println(val); //Prints the value coming in from the analog sensor

  delay(10); // stop the program for

             // some time

}

Obtenir la tension de la broche analogique

Les broches analogiques peuvent être utilisées pour lire des tensions utiles pour la surveillance de la batterie ou pour l'interfaçage avec des périphériques analogiques. Par défaut, la broche AREF sera la même que la tension de fonctionnement de l'arduino, mais peut être réglée sur d'autres valeurs en externe. Si la tension à lire est supérieure à la tension d'entrée, un diviseur potentiel sera nécessaire pour abaisser la tension analogique.

#define analogPin 14    //A0 (uno)

#define AREFValue 5 //Standard for 5V Arduinos

#define ADCResolution 1023 //Standard for a 10bit ADC

int ADCValue = 0; float voltage = 0;

void setup()

{

    Serial.begin(9600);

}

void loop()

{

    readADC();

    Serial.print(voltage); Serial.println("V");

}

void readADC()

{

    ADCValue = analogRead(analogPin);

    float = ( ( (float)ADCValue/ADCRange ) * AREFValue ); //Convert the ADC value to a float, devide by the ADC resolution and multiply by the AREF voltage

}

Lire Entrées analogiques en ligne:

Chapitre 15: Entrées Numériques

Syntaxe

•    pinMode(pin, pinMode) // Définit la broche sur le mode défini.

•    digitalRead(pin); // Lit la valeur d'une broche numérique spécifiée,

Paramètres

Paramètre

Détails

Pinmode

Devrait être réglé sur INPUT ou INPUT_PULLUP

Remarques

Si la broche d'entrée n'est pas tirée LOW ou HIGH, la valeur flottera. Autrement dit, ce ne sera pas clairement un 1 ou un 0, mais quelque part entre les deux. Pour une entrée numérique, une résistance de pullup ou de pulldown est une nécessité.

Examples

Lecture bouton

Voici un exemple de base sur la manière de câbler et d’allumer / éteindre une LED lorsque le bouton-poussoir est enfoncé.

/* Basic Digital Read

 * ------------------

 *

*   turns on and off a light emitting diode(LED) connected to digital

*   pin 13, when pressing a pushbutton attached to pin 7. It illustrates the

*   concept of Active-Low, which consists in connecting buttons using a  * 1K to 10K pull-up resistor.

 *

*   Created 1 December 2005

*   copyleft 2005 DojoDave <>

*  

 *

 */

int ledPin = 13; // choose the pin for the LED int inPin = 7;   // choose the input pin (for a pushbutton) int val = 0;     // variable for reading the pin status

void setup() {   pinMode(ledPin, OUTPUT);  // declare LED as output   pinMode(inPin, INPUT);    // declare pushbutton as input

}

void loop(){   val = digitalRead(inPin);  // read input value   if (val == HIGH) {         // check if the input is HIGH (button released) digitalWrite(ledPin, LOW);  // turn LED OFF

  } else {

    digitalWrite(ledPin, HIGH);  // turn LED ON

  }

}

Exemple tiré d' .

Lire Entrées Numériques en ligne:

Chapitre 16: Gestion du temps

Syntaxe

•    non signé long millis ()

•    non signé long micros ()

•    délai d'annulation (millisecondes longues non signées)

•    délai videMicrosecondes (microsecondes longues non signées)

•    Voir l'en-tête elapsedMillis pour les constructeurs et les opérateurs de cette classe. En bref:

? elapsedMillis elapsedMillisObject; crée un objet pour suivre le temps écoulé depuis sa création ou depuis un autre point défini explicitement dans le temps

? elapsedMillisObject = 0; réinitialiser le temps suivi par l'objet à "depuis maintenant"

? unsigned long deltaT = elapsedMillisObject; nous permet de regarder le temps suivi ? elapsedMillisObject + = et - = ceux-ci fonctionnent comme prévu

Remarques

Code bloquant ou non bloquant

Pour des esquisses très simples, écrire du code de blocage à l'aide de delay() et delayMicroseconds() peut être approprié. Lorsque les choses deviennent plus complexes, l'utilisation de ces fonctions peut présenter certains inconvénients. Certains d'entre eux sont:

•    Perte de temps CPU: des croquis plus complexes peuvent nécessiter le CPU pour autre chose en attendant la fin de la période de clignotement des voyants.

•    Retards inattendus: lorsque delay() est appelé dans des sous-routines qui ne sont pas appelées de manière évidente, par exemple dans les bibliothèques que vous incluez.

•    les événements manquants qui se produisent pendant le délai et qui ne sont pas traités par un gestionnaire d'interruption, par exemple une pression sur le bouton d'interrogation: un bouton peut être pressé pendant 100 ms, mais cela peut être delay(500) .

Détails d'implémentation

millis() repose généralement sur une minuterie matérielle dont la vitesse est bien supérieure à 1 kHz. Lorsque millis() est appelée, l'implémentation retourne une valeur, mais vous ne savez pas quel âge elle a. Il est possible que la milliseconde "courante" vienne juste de démarrer ou qu'elle se termine juste après cet appel de fonction. Cela signifie que, lors du calcul de la différence entre deux résultats à partir de millis() , vous pouvez être désactivé par presque zéro et presque une milliseconde. Utilisez micros() si une plus grande précision est nécessaire.

En elapsedMillis code source de elapsedMillis que millis() interne pour comparer deux points dans le temps, ce qui nuit également à cet effet. Encore une fois, il existe une alternative elapsedMicros pour une plus grande précision, à partir de la même bibliothèque.

Examples

blinky blinky avec delay ()

Une des manières les plus simples de faire clignoter une LED est: allumez-la, attendez un peu, éteignez-la, attendez encore et répétez sans cesse:

// set constants for blinking the built-in LED at 1 Hz

#define OUTPIN LED_BUILTIN

#define PERIOD 500

void setup()

{

  pinMode(OUTPIN, OUTPUT);      // sets the digital pin as output

}

void loop()

{

  digitalWrite(OUTPIN, HIGH);   // sets the pin on   delayMicroseconds(PERIOD);        // pauses for 500 miliseconds   digitalWrite(OUTPIN, LOW);    // sets the pin off delayMicroseconds(PERIOD);        // pauses for 500 milliseconds

  // doing other time-consuming stuff here will skew the blinking

}

Cependant, attendre comme dans l'exemple ci-dessus gaspille les cycles du processeur, car il ne fait que rester en boucle pendant un certain temps. C'est ce que les méthodes non bloquantes, à l'aide de millis() ou elapsedMillis , font mieux - dans le sens où elles ne brûlent pas autant de fonctionnalités du matériel.

Blinky non bloquant avec la bibliothèque elapsedMillis (et la classe)

La bibliothèque elapsedMillis fournit une classe avec le même nom qui garde la trace du temps écoulé depuis sa création ou sa valeur:

#include <elapsedMillis.h>

#define OUTPIN LED_BUILTIN

#define PERIOD 500

elapsedMillis ledTime;

bool ledState = false;

void setup() {

  // initialize the digital pin as an output.

  pinMode(OUTPIN, OUTPUT);


}

void loop()

{

    if (ledTime >= PERIOD)

    {

        ledState = !ledState;         digitalWrite(OUTPIN, ledState);         ledTime = 0;

    }

    // do other stuff here

}

Vous pouvez voir dans l'exemple que l'objet ledTime est assigné à zéro lorsque la broche du voyant a été basculée. Cela n’est peut-être pas surprenant à première vue, mais cela se produit si des choses plus chronophages se produisent:

Considérons une situation où la comparaison entre ledTime et PERIOD se fait après 750 millisecondes. Le réglage de ledTime à zéro signifie que toutes les opérations de bascule suivantes seront 250 ms en retard. Si, au contraire, PERIOD a été soustrait de ledTime , la LED verrait une courte période, puis continuer à clignoter comme si rien ne se passait.

Blinky non bloquant avec le millis ()

Ceci est très proche d’ un exemple de la documentation arduino :

// set constants for blinking the built-in LED at 1 Hz

#define OUTPIN LED_BUILTIN

#define PERIOD 500  // this is in milliseconds

int ledState = LOW;

// millis() returns an unsigned long so we'll use that to keep track of time unsigned long lastTime = 0;

void setup() {

  // set the digital pin as output:

  pinMode(OUTPIN, OUTPUT);

}

void loop() {   unsigned long now = millis();   if (now - lastTime >= PERIOD) // this will be true every PERIOD milliseconds

  {

lastTime = now;     if (ledState == LOW)

    {

      ledState = HIGH;

    } else

    {

      ledState = LOW;

    }

    digitalWrite(OUTPIN, ledState);

  }

  // now there's lots of time to do other stuff here

}

Utiliser millis() de cette façon - pour chronométrer les opérations de manière non bloquante - est quelque chose qui est nécessaire assez fréquemment, alors envisagez d'utiliser la bibliothèque elapsedMillis pour cela.

unsigned long intervals[] = {250,2000}; //this defines the interval for each task in milliseconds unsigned long last[] = {0,0};           //this records the last executed time for each task

void setup() {   pinMode(LED_BUILTIN, OUTPUT); //set the built-it led pin as output

Serial.begin(115200);         //initialize serial

}

void loop() {   unsigned long now = millis();   if(now-last[0]>=intervals[0]){ last[0]=now; firstTask(); }   if(now-last[1]>=intervals[1]){ last[1]=now; secondTask(); }

Mesurer combien de temps quelque chose a pris, en utilisant Millis et ElapsedMicros

#include <elapsedMillis.h>

void setup() {

Serial.begin(115200);   elapsedMillis msTimer;   elapsedMicros usTimer;

  long int dt = 500;   delay(dt);

  long int us = usTimer;   long int ms = msTimer;

Serial.print("delay(");Serial.print(dt);Serial.println(") took");

Serial.print(us);Serial.println(" us, or");

Serial.print(ms);Serial.println(" ms");

}

void loop() {

}

Dans cet exemple, un objet elapsedMillis et un objet elapsedMicros sont utilisés pour mesurer combien de temps quelque chose a pris, en les créant juste avant que l'expression que nous voulons chronométrer soit exécutée, et en obtenant ensuite leurs valeurs. Ils afficheront des résultats légèrement différents, mais le résultat en millisecondes ne sera pas désactivé par plus d'une milliseconde.

Plus d'une tâche sans délai ()

Si vous avez plus d'une tâche à exécuter à plusieurs reprises dans des intervalles différents, utilisez cet exemple comme point de départ:

  //do other things here

}

void firstTask(){

  //let's toggle the built-in led

  digitalWrite(LED_BUILTIN, digitalRead(LED_BUILTIN)?0:1);

}

void secondTask(){

  //say hello

  Serial.println("hello from secondTask()");

}

Pour ajouter une autre tâche à exécuter toutes les 15 secondes, étendez les intervals variables et last :

unsigned long intervals[] = {250,2000,15000}; unsigned long last[] = {0,0,0};

Ajoutez ensuite une instruction if pour exécuter la nouvelle tâche. Dans cet exemple, je l'ai nommé thirdTask .

if(now-last[2]>=intervals[2]){ last[2]=now; thirdTask(); }

Enfin déclarez la fonction:

void thirdTask(){   //your code here

}

Lire Gestion du temps en ligne:


Chapitre 17: Les fonctions

Remarques

En dehors du C / C ++ ordinaire, l'IDE Arduino permet d'appeler une fonction avant sa définition.

Dans les fichiers .cpp, vous devez définir la fonction ou du moins déclarer le prototype de fonction avant de pouvoir l'utiliser. 

Dans un fichier .ino, l'IDE Arduino crée un tel prototype dans les coulisses. Arduino - déclaration de fonction - officielle

Examples

Créer une fonction simple

int squareNum (int a) {     return a*a; }

int : type de retour squareNum : nom de la fonction int a : type et nom du paramètre return a*a : retourne une valeur (même type que le type de retour défini au début)

Appeler une fonction

Si vous avez une fonction déclarée, vous pouvez l'appeler n'importe où dans le code. Voici un exemple d'appel d'une fonction:

void setup(){

  Serial.begin(9600);

}

void loop() {   int i = 2;

  int k = squareNum(i); // k now contains 4

Serial.println(k);   delay(500);

}

int squareNum(int a) {     return a*a;

}

Lire Les fonctions en ligne:

Chapitre 18: Les interruptions

Syntaxe

•    digitalPinToInterrupt (broche); // convertit un identifiant de broche en identifiant d'interruption, à utiliser avec attachInterrupt() et detachInterrupt() .

•    attachInterrupt (digitalPinToInterrupt (pin), ISR, mode); // conseillé

•    attachInterrupt (interruption, ISR, mode); // non recommandé

•    detachInterrupt (digitalPinToInterrupt (pin));

•    detachInterrupt (interruption);

•    noInterrupts (); // désactive les interruptions

•    interruptions (); // réactiver les interruptions après l' noInterrupts() de noInterrupts() .

Paramètres

Paramètre

Remarques

interrompre

Identifiant de l'interruption. Ne pas être confondu avec le numéro d'identification.

ISR

Routine de service d'interruption. C'est la méthode qui sera exécutée lorsque l'interruption se produira.

mode

Qu'est-ce qui devrait déclencher l'interruption? Un de bas, changer, se lever ou tomber. Les commissions sont également autorisées.

Remarques

Les routines de service d'interruption (ISR) doivent être aussi courtes que possible, car elles mettent en pause l'exécution du programme principal et peuvent donc vider le code en fonction du temps. Généralement, cela signifie que dans l'ISR, vous définissez un drapeau et sortez, et dans la boucle du programme principal, vous vérifiez le drapeau et faites ce que ce drapeau est censé faire.

Vous ne pouvez pas utiliser delay() ou millis() dans un ISR car ces méthodes elles-mêmes reposent sur des interruptions.

Examples

Interruption sur le bouton presse

Cet exemple utilise un bouton-poussoir (commutateur tactile) connecté à la broche numérique 2 et à la masse, en utilisant une résistance de rappel interne pour que la broche 2 soit haute lorsque le bouton n'est pas enfoncé.

const int LED_PIN = 13; const int INTERRUPT_PIN = 2; volatile bool ledState = LOW;

void setup() {     pinMode(LED_PIN, OUTPUT);     pinMode(INTERRUPT_PIN, INPUT_PULLUP);     attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), myISR, FALLING); // trigger when button pressed, but not when released.

}

void loop() {     digitalWrite(LED_PIN, ledState);

}

void myISR() {     ledState = !ledState;     // note: LOW == false == 0, HIGH == true == 1, so inverting the boolean is the same as switching between LOW and HIGH.

}

Un exemple avec cet exemple simple est que les boutons-poussoirs ont tendance à rebondir, ce qui signifie que le circuit s’ouvre et se ferme plus d’une fois avant de s’établir dans l’état final fermé ou ouvert. Cet exemple ne prend pas cela en compte. Par conséquent, il suffit parfois d'appuyer sur le bouton pour basculer le voyant plusieurs fois, au lieu d'une fois.

Lire Les interruptions en ligne:

Chapitre 19: Nombres aléatoires

Syntaxe

•    random (max) // Retourne un nombre (long) pseudo-aléatoire compris entre 0 (inclus) et max (exclusif)

•    random (min, max) // Retourne un nombre pseudo-aléatoire (long) entre min (inclus) et max (exclusif)

•    randomSeed (seed) // Initialise le générateur de nombres pseudo-aléatoires, le faisant démarrer à un point spécifié de sa séquence.

Paramètres

Paramètre

Détails

min

La valeur minimale possible (incluse) à générer par la fonction random() .

max

La valeur maximale possible (exclusive) à générer par la fonction random() .

la graine

La graine qui sera utilisée pour mélanger la fonction random() .

Remarques

Si randomSeed() est appelée avec une valeur fixe (par exemple, randomSeed(5) ), la séquence de nombres aléatoires générée par l'esquisse sera répétée à chaque exécution. Dans la plupart des cas, une graine aléatoire est préférée, qui peut être obtenue en lisant une broche analogique non connectée.

Examples

Générer un nombre aléatoire

La fonction random() peut être utilisée pour générer des nombres pseudo-aléatoires:

void setup() {

    Serial.begin(9600);

}

void loop() {     long randomNumber = random(500);  // Generate a random number between 0 and 499

Serial.println(randomNumber);

    randomNumber = random(100, 1000); // Generate a random number between 100 and 999

    Serial.println(randomNumber);

    delay(100); }

Mettre une graine

S'il est important qu'une séquence de nombres générée par random() diffère, il est randomSeed() de spécifier une graine avec randomSeed() :

void setup() {

    Serial.begin(9600);

    // If analog pin 0 is left unconnected, analogRead(0) will produce a

    // different random number each time the sketch is run.     randomSeed(analogRead(0));

}

void loop() {     long randomNumber = random(500); // Generate a random number between 0 and 499



    Serial.println(randomNumber);

    delay(100); }

Lire Nombres aléatoires en ligne:

Chapitre 20: PWM - Modulation de la largeur d'impulsion

Examples

Contrôler un moteur à courant continu via le port série en utilisant PWM

Dans cet exemple, nous visons à accomplir l’une des tâches les plus courantes: un petit moteur à courant continu est installé, comment puis-je utiliser mon Arduino pour le contrôler? Facile, avec communication PWM et série, en utilisant la fonction analogWrite() et la bibliothèque Serial .

Les bases

La modulation de largeur d'impulsion ou PWM en abrégé est une technique permettant d'imiter des signaux analogiques en utilisant une sortie numérique. Comment cela marche-t-il? En utilisant un train d'impulsions dont la relation D (rapport cyclique) entre le temps à haut niveau (numérique 1, généralement 5V) et le temps à bas niveau (numérique 0, 0V) dans chaque période peut être modifiée pour produire une tension moyenne entre ces deux niveaux:

En utilisant la fonction analogWrite(pin,value) Arduino analogWrite(pin,value) nous pouvons faire varier la value du rapport cyclique de la sortie de la pin . Notez que la pin doit être mise en mode de sortie et que la value doit être comprise entre 0 (0V) et 255 (5V). Toute valeur intermédiaire simulera une sortie analogique intermédiaire proportionnelle.

Cependant, la fonction des signaux analogiques est généralement liée au contrôle de systèmes mécaniques qui nécessitent plus de tension et de courant que la carte Arduino seule. Dans cet exemple, nous allons apprendre à amplifier les capacités PWM d'Arduino.

Pour cela, une diode MOSFET est utilisée. Essentiellement, cette diode agit comme un commutateur. Il permet ou interrompt le flux électrique entre ses bornes de source et de drain . Mais au lieu d'un commutateur mécanique, il dispose d'un troisième terminal appelé gate . Un très petit courant (<1mA) "ouvrira" cette porte et permettra au courant de circuler. Ceci est très pratique, car nous pouvons envoyer la sortie PWM d'Arduino à cette porte, créant ainsi un autre train d'impulsions PWM avec le même rapport cyclique à travers le MOSFET, ce qui permet des tensions et des courants qui pourraient détruire l'Arduino.

Bill of materials: de quoi avez-vous besoin pour construire cet exemple?

•    Diode MOSFET: par exemple, le populaire BUZ11

•    Diode de protection pour le moteur: Schottky SB320

•    Résistance: rien 10K ~ 1M Ohm

•   


Moteur: Un petit moteur typique (un moteur typique peut être 12V)

•    Une source d'alimentation compatible avec le moteur que vous avez sélectionné • Une planche à pain

•    Câbles colorés!

•    Un Arduino, mais tu le savais déjà.

La construction

Mettez tout ensemble! Alimentez les rails de la maquette et placez-y la diode MOSFET.

Connectez le moteur entre le rail positif et le drain MOSFET. Connecter la diode de protection de la même manière: entre le drain MOSFET et le rail positif. Connectez la source du MOSFET au rail de terre commun. Enfin, connectez la broche PWM (nous utilisons la broche 10 dans cet exemple) à la grille du MOSFET et également à la terre commune via la résistance (nous avons besoin d'un courant très faible!).

Voici un exemple de l'apparence de cette construction. Si vous préférez un schéma, en voici un.


Le code

Maintenant, nous pouvons connecter l'Arduino à un ordinateur, télécharger le code et contrôler le moteur en envoyant des valeurs via la communication série. Rappelons que ces valeurs doivent être des entiers compris entre 0 et 255. Le code réel de cet exemple est très simple. Une explication est fournie dans chaque ligne.

int in = 0;                   // Variable to store the desired value byte pinOut = 10;             // PWM output pin

void setup() {                // This executes once

  Serial.begin(9600); // Initialize serial port   pinMode(pinOut, OUTPUT);        // Prepare output pin

}

void loop() {                 // This loops continuously   if(Serial.available()){         // Check if there's data     in = ();           // Read said data into the variable "in"     analogWrite(pinOut, in);      // Pass the value of "in" to the pin

  }

}

Et c'est tout! Vous pouvez désormais utiliser les fonctionnalités PWM d'Arduino pour contrôler les applications qui nécessitent des signaux analogiques, même lorsque les besoins en énergie dépassent les limites de la carte.

PWM avec un TLC5940

Le TLC5940 est un élément pratique à avoir lorsque vous manquez de ports PWM sur l’Arduino. Il dispose de 16 canaux, chacun individuellement contrôlable avec 12 bits de résolution (0-4095). Une bibliothèque existante est disponible à l' adresse

. Il est utile pour contrôler plusieurs servos ou LED RVB. N'oubliez pas que les LED doivent être des anodes communes pour fonctionner. De plus, les puces peuvent être chaînées en série, permettant encore plus de ports PWM.

Exemple:

// Include the library

#include <Tlc5940.h>

void setup() {

    // Initialize

    ();

    Tlc.clear();

}

unsigned int level = 0; void loop() {

    // Set all 16 outputs to same value     for (int i = 0; i < 16; i++) {

        (i, level);

    }

    level = (level + 1) % 4096;

    // Tell the library to send the values to the chip

Tlc.update();     delay(10);

}

Lire PWM - Modulation de la largeur d'impulsion en ligne:

Chapitre 21: Servo

Introduction

Un Servo est un système fermé contenant un moteur et des circuits de support. L'arbre d'un servo peut être tourné à un angle fixe dans un arc en utilisant un signal de commande. Si le signal de contrôle est maintenu, le servo conservera son angle. Les servos peuvent facilement être contrôlés avec la bibliothèque Arduino Servo.h .

Syntaxe

•    #include <Servo.h> // Inclure la bibliothèque de servos

•    Servo.attach (pin) // Fixe le servo sur la broche. Renvoie un objet Servo

•    Servo.write (degrés) // Degrés pour passer à (0 - 180)

•    () // Obtient la rotation actuelle du servo

Examples

Déplacement du servo dans les deux sens

#include <Servo.h>

Servo srv;

void setup() {   srv.attach(9); // Attach to the servo on pin 9

}

Pour utiliser un servo, vous devez d'abord appeler la fonction attach() . Il commence à générer un signal PWM contrôlant un servo sur une broche spécifiée. Sur les cartes autres qu'Arduino Mega, l'utilisation de la bibliothèque Servo désactive la fonctionnalité analogWrite () (PWM) sur les broches 9 et 10, qu'il y ait ou non un Servo sur ces broches.

void loop() {

  Servo.write(90); // Move the servo to 90 degrees   delay(1000); // Wait for it to move to it's new position

  Servo.write(0); // Move the servo to 0 degrees

  delay(1000); // Wait for it to move to it's new position }

Notez que vous n'êtes pas assuré que le servo a atteint la position souhaitée, ni que vous pouvez le vérifier depuis le programme.

Lire Servo en ligne:


Chapitre 22: Sortie audio

Paramètres

Paramètre

Détails

orateur

Devrait être une sortie vers un haut-parleur analogique

Examples

Sorties de note de base

#define NOTE_C4  262 //From pitches.h file defined in [Arduino Tone Tutorial][1]

int Key = 2; int KeyVal = 0;

byte speaker = 12;

void setup()

{

pinMode(Key, INPUT);  //Declare our key (button) as input   pinMode(speaker, OUTPUT);

}

void loop()

{

  KeyVal = digitalRead(Key);   if (KeyVal == HIGH) {     tone(speaker, NOTE_C4); //Sends middle C tone out through analog speaker

  } else {

    noTone(speaker); //Ceases tone emitting from analog speaker

  }

  delay(100);

}

[1]:

Lire Sortie audio en ligne:

Chapitre 23: Sortie numérique

Syntaxe

• digitalWrite(pin, value)

Examples

Ecrire à l'épinglette

int ledPin = 13;                 // LED connected to digital pin 13

void setup()

{

  pinMode(ledPin, OUTPUT);      // sets the digital pin as output

}

void loop()

{

digitalWrite(ledPin, HIGH);   // sets the LED on   delay(1000); // waits for a second   digitalWrite(ledPin, LOW);    // sets the LED off delay(1000);                  // waits for a second

}

Exemple à .

Lire Sortie numérique en ligne:

Chapitre 24: Stockage de données

Examples

cardInfo

/*

 SD card test

 This example shows how use the utility libraries on which the'  SD library is based in order to get info about your SD card.  Very useful for testing a card when you're not sure whether its working or not.

  The circuit:

  * SD card attached to SPI bus as follows:

 ** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila

 ** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila

 ** CLK - pin 13 on Arduino Uno/Duemilanove/Diecimila  ** CS -   depends on your SD card shield or module.

           Pin 4 used here for consistency with other Arduino examples

 created 28 Mar 2011  by Limor Fried  modified 9 Apr 2012  by Tom Igoe

 */

 // include the SD library:

#include <SPI.h>

#include <SD.h>

 // set up variables using the SD utility library functions:

Sd2Card card;

SdVolume volume;

SdFile root;

// change this to match your SD shield or module;

// Arduino Ethernet shield: pin 4

// Adafruit SD shields and modules: pin 10

// Sparkfun SD shield: pin 8 const int chipSelect = 4;

void setup() {   // Open serial communications and wait for port to open:

Serial.begin(9600);   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

Serial.print("\nInitializing SD card ");

  // we'll use the initialization code from the utility libraries

  // since we're just testing if the card is working!

  if (!(SPI_HALF_SPEED, chipSelect)) {

Serial.println("initialization failed. Things to check:");

    Serial.println("* is a card inserted?");


    Serial.println("* is your wiring correct?");

Serial.println("* did you change the chipSelect pin to match your shield or module?");     return;   } else {

Serial.println("Wiring is correct and a card is present.");

  }

  // print the type of card

Serial.print("\nCard type: ");   switch (()) {     case SD_CARD_TYPE_SD1:       Serial.println("SD1");       break; case SD_CARD_TYPE_SD2:       Serial.println("SD2"); break;     case SD_CARD_TYPE_SDHC: Serial.println("SDHC");       break;     default:

      Serial.println("Unknown");

  }

  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32 if (!(card)) {

Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");     return;

  }

  // print the type and size of the first FAT-type volume   uint32_t volumesize;

Serial.print("\nVolume type is FAT");

  Serial.println(volume.fatType(), DEC);

  Serial.println();

  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks   volumesize *= volume.clusterCount();       // we'll have a lot of clusters

  volumesize *= 512;                            // SD card blocks are always 512 bytes

  Serial.print("Volume size (bytes): ");

Serial.println(volumesize);

Serial.print("Volume size (Kbytes): ");   volumesize /= 1024;

Serial.println(volumesize);

Serial.print("Volume size (Mbytes): ");   volumesize /= 1024;

Serial.println(volumesize);

  Serial.println("\nFiles found on the card (name, date and size in bytes): ");   root.openRoot(volume);

  // list all files in the card with date and size   (LS_R | LS_DATE | LS_SIZE);

}

void loop(void) {

}

Enregistreur de carte SD

/*

  SD card datalogger

 This example shows how to log data from three analog sensors  to an SD card using the SD library.   The circuit:

 * analog sensors on analog ins 0, 1, and 2  * SD card attached to SPI bus as follows:

 ** MOSI - pin 11

 ** MISO - pin 12

 ** CLK - pin 13

 ** CS - pin 4

 created 24 Nov 2010  modified 9 Apr 2012  by Tom Igoe   This example code is in the public domain.

 */

#include <SPI.h>

#include <SD.h>

const int chipSelect = 4;

void setup() {   // Open serial communications and wait for port to open:

Serial.begin(9600);   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

Serial.print("Initializing SD card ");

  // see if the card is present and can be initialized:   if (!SD.begin(chipSelect)) {     Serial.println("Card failed, or not present");

    // don't do anything more:     return;

  }

  Serial.println("card initialized.");

}

void loop() {   // make a string for assembling the data to log:

  String dataString = "";

  // read three sensors and append to the string:

  for (int analogPin = 0; analogPin < 3; analogPin++) {     int sensor = analogRead(analogPin);     dataString += String(sensor);     if (analogPin < 2) {       dataString += ",";

    }

  }

  // open the file. note that only one file can be open at a time,   // so you have to close this one before opening another.

  File dataFile = ("", FILE_WRITE);

  // if the file is available, write to it:   if (dataFile) {     dataFile.println(dataString); dataFile.close();

    // print to the serial port too:

Serial.println(dataString);

  }

  // if the file isn't open, pop up an error:   else {

Serial.println("error opening ");

  }

}

Dump de fichier de carte SD

/*

  SD card file dump

 This example shows how to read a file from the SD card using the  SD library and send it over the serial port.

  The circuit:

 * SD card attached to SPI bus as follows:

 ** MOSI - pin 11

 ** MISO - pin 12

 ** CLK - pin 13

 ** CS - pin 4

 created 22 December 2010  by Limor Fried  modified 9 Apr 2012  by Tom Igoe   This example code is in the public domain.

 */

#include <SPI.h>

#include <SD.h>

const int chipSelect = 4;

void setup() {   // Open serial communications and wait for port to open:

Serial.begin(9600);   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

Serial.print("Initializing SD card ");

  // see if the card is present and can be initialized:   if (!SD.begin(chipSelect)) {     Serial.println("Card failed, or not present");

    // don't do anything more:     return;

  }

  Serial.println("card initialized.");

  // open the file. note that only one file can be open at a time,   // so you have to close this one before opening another.

  File dataFile = ("");

  // if the file is available, write to it:   if (dataFile) {     while (dataFile.available()) {       Serial.write(());

    }

dataFile.close();   }

  // if the file isn't open, pop up an error:   else {

Serial.println("error opening ");

  }

}

void loop()

{

}

Exemple de fichier de base de carte SD

/*

  SD card basic file example

 This example shows how to create and destroy an SD card file  The circuit:

 * SD card attached to SPI bus as follows:

 ** MOSI - pin 11

 ** MISO - pin 12

 ** CLK - pin 13

 ** CS - pin 4

 created Nov 2010  by David A. Mellis  modified 9 Apr 2012  by Tom Igoe   This example code is in the public domain.

 */

#include <SPI.h>

#include <SD.h>

File myFile;

void setup() {   // Open serial communications and wait for port to open:

Serial.begin(9600);   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

Serial.print("Initializing SD card ");

  if (!SD.begin(4)) {

Serial.println("initialization failed!");     return;

  }

Serial.println("initialization done.");

  if (SD.exists("")) {

Serial.println(" exists.");

  }   else {

Serial.println(" doesn't exist.");

  }

   // open a new file and immediately close it:

Serial.println("Creating ");   myFile = ("", FILE_WRITE);   myFile.close(); 

  // Check to see if the file exists:

  if (SD.exists("")) {

Serial.println(" exists.");

  }   else {

    Serial.println(" doesn't exist.");

  }

   // delete the file:

Serial.println("Removing ");

SD.remove("");

  if (SD.exists("")) {

Serial.println(" exists.");

  }   else {

Serial.println(" doesn't exist.");

  }

}

void loop() {   // nothing happens after setup finishes.

}

Liste de fichiers

/*

 Listfiles

 This example shows how print out the files in a  directory on a SD card   The circuit:

 * SD card attached to SPI bus as follows:

 ** MOSI - pin 11

 ** MISO - pin 12

 ** CLK - pin 13

 ** CS - pin 4

 created Nov 2010  by David A. Mellis  modified 9 Apr 2012  by Tom Igoe  modified 2 Feb 2014  by Scott Fitzgerald   This example code is in the public domain.

*/

#include <SPI.h>

#include <SD.h>

File root;

void setup() {   // Open serial communications and wait for port to open:

Serial.begin(9600);   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

Serial.print("Initializing SD card ");

  if (!SD.begin(4)) {

    Serial.println("initialization failed!");     return;

  }

Serial.println("initialization done.");

  root = ("/");

  printDirectory(root, 0);

Serial.println("done!");

}

void loop() {   // nothing happens after setup finishes.

}

void printDirectory(File dir, int numTabs) {    while(true) {

     File entry =  dir.openNextFile();      if (! entry) {

       // no more files        break;

     }

     for (uint8_t i=0; i<numTabs; i++) {

       Serial.print('\t');

     }

     Serial.print(());

     if (entry.isDirectory()) {        Serial.println("/");        printDirectory(entry, numTabs+1);

     } else {

       // files have sizes, directories do not

Serial.print("\t\t");

       Serial.println((), DEC);

     }      entry.close();

   }

}

Carte SD lecture / écriture

/*

  SD card read/write

 This example shows how to read and write data to and from an SD card file  The circuit:

 * SD card attached to SPI bus as follows:

 ** MOSI - pin 11

 ** MISO - pin 12

 ** CLK - pin 13

 ** CS - pin 4

 created Nov 2010  by David A. Mellis  modified 9 Apr 2012  by Tom Igoe   This example code is in the public domain.

 */

#include <SPI.h>

#include <SD.h>

File myFile;

void setup() {   // Open serial communications and wait for port to open:

Serial.begin(9600);   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

Serial.print("Initializing SD card ");

  if (!SD.begin(4)) {

Serial.println("initialization failed!");     return;

  }

Serial.println("initialization done.");

  // open the file. note that only one file can be open at a time,

  // so you have to close this one before opening another.

  myFile = ("", FILE_WRITE);

  // if the file opened okay, write to it:   if (myFile) {

Serial.print("Writing to "); myFile.println("testing 1, 2, 3.");

    // close the file:     myFile.close();

Serial.println("done.");

  } else {     // if the file didn't open, print an error:

Serial.println("error opening ");

  }

  // re-open the file for reading:   myFile = ("");   if (myFile) {

Serial.println(":");

    // read from the file until there's nothing else in it:

    while (myFile.available()) {       Serial.write(());

    }

    // close the file:     myFile.close();   } else {     // if the file didn't open, print an error:

Serial.println("error opening ");

  }

}

void loop()

{

  // nothing happens after setup

}

Lire Stockage de données en ligne:

Chapitre 25: Utiliser Arduino avec Atmel Studio 7

Remarques

Installer

•    Téléchargez et installez Atmel Studio 7 à partir d' ici .

•    Achetez un débogueur. Vous pouvez vous débrouiller avec un programmeur ISP, mais si vous voulez des fonctionnalités de débogage, ce qui est l'un des grands avantages de l'utilisation d'Atmel Studio, vous voudrez un débogueur. Je recommande le ICE d'Atmel , car il fournit des capacités de débogage pour les arduinos basés sur AVR (comme Uno, Pro mini, etc.) et les Arduinos basés sur ARM, tels que Zero et Due. Si vous avez un budget, vous pouvez l' obtenir sans le boîtier en plastique et faites attention à ne pas le choquer .

Les liaisons

• Pour l'Uno, utilisez le câble ICSP à 6 broches . Branchez un côté dans l'Uno comme indiqué.

Branchez l'autre côté dans le port AVR du débogueur.


Pour l'Arduino Pro Mini, utilisez le câble mini-squid comme indiqué, en connectant à nouveau l'autre côté du port AVR du débogueur.

Considérations de débogage

Pour le débogage avec Uno, vous devez couper le tracé d'activation de Reset (vous pouvez toujours le souder pour l'utiliser avec l'IDE Arduino):


En utilisant le Pro Mini, si vous avez l'intention de connecter le port série à votre ordinateur en utilisant une carte FTDI, ne connectez pas la ligne DTR, car cela pourrait interférer avec l'interface de débogage de fil série (SWD) d'Atmel. Je connecte simplement l'alimentation, la terre, Tx et Rx comme indiqué ci-dessous. Rx et Tx sur Arduino vont à Tx et Rx, respectivement sur la carte FTDI. Certaines cartes FTDI sont étiquetées différemment, donc si le port série ne fonctionne pas, échangez Rx et Tx.

Vous devrez fournir l’alimentation séparément à l’Arduino car le débogueur ne l’alimentera pas. Cela peut être fait sur le Pro Mini via la carte FTDI comme indiqué ci-dessus, ou avec un câble USB ou un adaptateur secteur sur le Uno.

Configuration du logiciel


Branchez Atmel ICE sur votre ordinateur, démarrez Atmel Studio et vous pouvez désormais importer un projet Arduino existant.

Dans Atmel Studio, allez dans Fichier -> Nouveau -> Projet et sélectionnez "Créer un projet à partir d’une esquisse Arduino". Remplissez les options, y compris les menus déroulants du tableau et des périphériques.

Allez dans Project -> yourProjectName Properties, cliquez sur Tool, sélectionnez Atmel ICE sous debugger / programmer et debugWire sous interface. Aller au débogage -> Démarrer le débogage et casser. Vous devriez voir un avertissement et vous demander si vous souhaitez définir le fusible DWEN. Choisissez OK, débranchez l'Arduino du secteur et rebranchez-le. Vous pouvez arrêter le débogage en cliquant sur le bouton carré rouge et commencer par cliquer sur le bouton triangle vert. Pour ramener l'Arduino à un état dans lequel il peut être utilisé dans l'EDI Arduino, pendant que vous êtes en train de déboguer, choisissez Debug -> disable debugWIRE and close.

Notez que toutes les fonctions que vous ajoutez doivent également inclure un prototype de fonction (la boucle et la configuration n'en ont pas besoin). Vous pouvez voir ceux que Atmel Studio a ajoutés en haut de l'esquisse s'il y avait des fonctions lorsque vous avez importé votre projet dans Atmel Studio (voir l'exemple de code par exemple).

La prise en charge de C ++ 11 est activée par défaut dans Arduino 1.6.6 et les versions ultérieures. Cela fournit plus de fonctionnalités de langage C ++ et son activation peut augmenter la compatibilité avec le système Arduinio. Pour activer C ++ 11 dans Atmel Studio 7, faites un clic droit sur votre fichier de projet, sélectionnez les propriétés, cliquez sur ToolChain sur la gauche, cliquez sur Miscellaneous sous AVR / GNU C ++ Compiler et mettez -std=c++11 dans les autres flags champ.

Pour inclure des bibliothèques dans votre esquisse

Copiez le fichier de bibliothèque .cpp dans C:\Users\YourUserName\Documents\Atmel

Studio\7.0\YourSolutionName\YourProjectName\ArduinoCore\src\core core core, choisissez add -> item existant et choisissez le fichier que vous avez ajouté. Faites de même avec le fichier de bibliothèque .h et le dossier YourProjectName / Dependancies.

Ajouter la fenêtre du terminal

Vous pouvez toujours ouvrir l'IDE Android et utiliser cette fenêtre série (sélectionnez simplement le port série approprié). Toutefois, pour ajouter une fenêtre série intégrée à Atmel Studio, accédez à Outils -> Extensions et mises à jour, cliquez sur Téléchargements disponibles et recherchez Terminal Window ou Terminal pour Atmel Studio et installez-le. Une fois installé, accédez à Affichage -> Terminal Window.

Avantages

La programmation d'Arduino avec un IDE modéré comme Atmel Studio 7 vous offre de nombreux avantages par rapport à l'IDE Arduino, notamment le débogage, l'auto-complétion, la définition et la déclaration, la navigation avant / arrière, les signets et les options de refactorisation.

Vous pouvez configurer les liaisons de clé en allant dans Outils -> Options -> Environnement -> Clavier. Certains accélèrent le développement:

•    Edit.CommentSelection, Edit.UncommentSelection

•    View.NavigateForward, View.NavigateBackward

•    Edit.MoveSelectedLinesUp, Edit.MoveSelectedLinesDown

•    Edit.GoToDefinition

Examples

Exemple de croquis importé Atmel Studio 7

Ceci est un exemple de ce à quoi ressemble une simple esquisse Arduino après avoir été importée dans Atmel Studio. Atmel Studio a ajouté les sections générées automatiquement en haut. Le reste est identique au code Arduino d'origine. Si vous développez le projet ArduinoCore qui a été créé et regardez dans le dossier src -> core, vous trouverez , le point d’entrée du programme. Vous pouvez y voir l'appel à la fonction de configuration Arduino et une boucle sans fin pour appeler la fonction de boucle Arduino encore et encore.

/* Begining of Auto generated code by Atmel studio */

#include <Arduino.h>

/* End of auto generated code by Atmel studio */

// Beginning of Auto generated function prototypes by Atmel Studio void printA();

// End of Auto generated function prototypes by Atmel Studio

void setup() {

  Serial.begin(9600);

}

void loop() {     printA();

}

void printA() {

Serial.println("A");

}

Lire Utiliser Arduino avec Atmel Studio 7 en ligne:

Chapitre 26: Variables et types de données

Examples

Créer une variable

Pour créer une variable:

variableType variableName;

Par exemple:

int a;

Pour créer une variable et l'initialiser:

variableType variableName = initialValue;

Par exemple:

int a = 2;

Attribuer une valeur à une variable

Si vous avez une variable déclarée auparavant, vous pouvez lui attribuer une valeur:

Par exemple:

int a;  // declared previously a = 2;

Ou changez la valeur:

int a = 3;  // initalized previously a = 2;

Types de variables

•    char : valeur de 1 octet signée

•    byte : entier non signé de 8 bits

•    int : signé 16 bits (sur des cartes ATMEGA) ou 32 bits (sur Arduino Due)

•    unsigned int : entier non signé 16 bits (sur les cartes ATMEGA) ou 32 bits (sur Arduino Due) • long : entier de 32 bits signé

•    unsigned long : entier non signé de 32 bits

•    float : nombre à virgule flottante de 4 octets

•    double : 4 octets (sur les cartes ATMEGA) ou 8 octets (sur Arduino Due) Exemples:

char a = 'A'; char a = 65;

byte b = B10010;

int c = 2;

unsigned int d = 3;

long e = 186000L;

unsigned long f = millis(); // as an example

float g = 1.117;

double h = 1.117;

Lire Variables et types de données en ligne:

Crédits

S.

No

Chapitres

Contributeurs

1

Démarrer avec

Arduino

Abhishek Jain, Christoph, Community, Danny_ds, Doruk, geek1011, gmuraleekrishna, H. Pauwelyn, jleung513, Martin

Carney, Mizole Ni, Shef, uruloke, Wolfgang

2

Arduino IDE

geek1011, Jeremy, jleung513, sohnryang, uruloke

3

Bibliothèque de cristaux liquides

Morgoth

4

Bibliothèques

Oscar Lundberg

5

Boucles

datafiddler, Martin Carney, MikeCAT

6

Broches de matériel

Jeremy, Martin Carney

7

Comment Python

s'intègre à Arduino

Uno

Danny_ds, Peter Mortensen, Stark Nguyen

8

Comment stocker des variables dans EEPROM et les

utiliser pour le

stockage permanent

AZ Vcience, Chris Combs, Danny_ds, Jeremy, Peter Mortensen

, RamenChef

9

Communication

Bluetooth

Girish, Martin Carney

10

Communication I2C

Asaf

11

Communication MIDI

Rich Maes

12

Communication série

blainedwards8, Danny_ds, geek1011, Leah, Martin Carney, MikeS159, Morgoth, Nufail Achath, Peter Mortensen, uruloke

13

Communication SPI

Christoph

14

Entrées analogiques

Jake Lites, MikeS159, Ouss4, uruloke

15

Entrées Numériques

Martin Carney, uruloke

16

Gestion du temps

Christoph, Rei

17

Les fonctions

datafiddler, Leah, MikeCAT

18

Les interruptions

DavidJ, Martin Carney

19

Nombres aléatoires

Danny_ds, Javier Rizzo Aguirre, MikeCAT

20

PWM - Modulation de la largeur d'impulsion

Danny_ds, Johnny Mopp, JorgeGT, Martin Carney

21

Servo

geek1011, mactro, Morgoth

22

Sortie audio

Jake Lites, MikeCAT

23

Sortie numérique

uruloke

24

Stockage de données

Danny_ds, robert

25

Utiliser Arduino avec

Atmel Studio 7

Danny_ds, Nate

26

Variables et types de données

Leah, MikeCAT



1192