Das fünfte Türchen

Derrière la 5ème. Nano V3 est caché dans cette porte du calendrier. On pourrait l'appeler le frère du micro - contrôleur Uno. Il permet d'exécuter des projets à petite échelle là où cela est essentiel. Il offre essentiellement tout ce dont vous avez besoin pour l'évaluation des capteurs ou le contrôle des actionneurs. Des détails importants sont disponibles dans la fiche technique et dans le Pinout, qui sont également liés dans l'AZ-Shop. Les deux doivent être à portée de main lorsque vous démarrez un projet.

L'information la plus importante est celle qui peut être utilisée comme base d'entrée et de sortie. En outre, huit pieds de tube et convertisseurs analogiques peuvent également être utilisés comme pieds de tube numérique. La communication avec d'autres appareils ou composants se fait notamment via l'interface I²C (A4 et A5), USART (D0 et D1) ou SPI (D10, D11 et D12). Les broches D2 et D3 peuvent être utilisées pour les signaux d'interruption externes (interruptions).

Dans l'article de l'Avent du 03.12. il était déjà montré comment installer l'IDE Arduino et comment charger l'exemple de clignotement sur la Uno. Pour le nano microcontrôleur, cela fonctionne exactement de la même manière. Vous devrez peut-être installer un pilote pour la puce CH340 sur la carte afin de reconnaître le microcontrôleur Nano V3 sur un port COM virtuel (la page liée est en chinois). Appuyez sur le grand bouton bleu. Le fichier ZIP contient le conducteur. Assurez-vous que vous utilisez un système 32 ou 64 bits).

Connexion microcontrôleur

Lorsque vous connectez ensuite le Nano, sélectionnez l'Arduino Nano sous Outils->Board. Comme processeur, l'ATmega328P (Old Bootloader). Sur les blogs d'AZ, vous trouverez un post d'Albert Vu décrivant comment "flasher" le bootloader pour ne plus avoir à choisir l'ancien bootloader. Sous le point de menu "Port", un port COM devrait maintenant apparaître. Les chiffres sont différents.

 


Pour tester, téléchargez l'exemple clignotant sur le microcontrôleur (Sketch -> Upload, ou CTRL+U). Il y a un LED sur la carte, qui devrait clignoter après un téléchargement réussi (le LED est connecté à la broche D13, soit dit en passant. La constante LED_BUILTIN fait référence à cette broche).

Des capteurs ou des résistances variables (potentiomètres, également appelés potentiomètres) fournissent une tension qui peut être mesurée sur les entrées analogiques. Sur la nano carte sont intégrés des convertisseurs analogique-numérique qui convertissent ces valeurs physiques.

La fonction analogRead(PINNUMBER) renvoie une valeur entre 0 et 1023, si vous souhaitez modifier cette plage, par exemple si vous avez besoin de 0 à 255, vous pouvez utiliser la fonction map(value, fromLow, fromHigh, toLow, toHigh) (plus d'informations ici).

Paramètres

Fonctions

Valeur

Input value Lecture analogique)

De bas en bas

Portée sismique inférieure (0 ici)

De haut

Champ de sismique supérieur (ici 1023)

Toro

Cible inférieure (0 ici)

Tonghai

Cible maximale (ici 255)

 

Entrée analogique

L'IDE Arduino et les bibliothèques intégrées fournissent de nombreux exemples de schémas. Cela est également vrai pour les broches analogiques. Ouvrez le plan d'AnalogInput dans le menu Fichier -> Exemples -> 03.Analog. Voici un exemple de clignotement modifié dans lequel un potentiomètre contrôle la vitesse de clignotement. Connectez tout comme dans le plan de frictions suivant et chargez l'exemple sur le NANO :


Les terminaux extérieurs du potentiomètre sont connectés à 5V et GND, le contact central (curseur) à A0. C'est ainsi qu'il est défini dans l'exemple de sketch. La broche 13 est (comme mentionné ci-dessus) le contact du LED embarqué. Si vous exécutez le programme sur le Nano, vous pouvez utiliser le potentiomètre pour régler la pause pour passer de la mise en marche à l'arrêt, ce qui permet d'augmenter ou de diminuer les pauses clignotantes.

Les valeurs d'entrée 0 à 1023 sont directement transmises ici comme une pause. La spécification dans la fonction delay() est donnée en millisecondes. Nous obtenons donc des pauses entre 0 et 1023 ms. Mais si nous voulons définir des pauses, par exemple entre 1 et 5 secondes (1000 et 5000 ms), alors la fonction map() mentionnée ci-dessus entre en jeu ici.

Insérez la ligne suivante après la ligne relative à l'importation :

/ / lire les valeurs à partir des capteurs:
sensorValue = analogRead(sensorPin);
// Ajouter:
sensorValue = map(sensorValue, 0, 1023, 1000, 5000);

La valeur précédemment lue est ainsi écrasée et convertie (mise à l'échelle) dans la nouvelle plage de valeurs. Les pauses devraient donc être sensiblement plus longues.

Note : La fonction delay() permet de faire des pauses réelles dans le déroulement du programme. Conséquemment, le changement au niveau du potentiomètre ne devient effectif que lorsque la pause est terminée. Pour changer cela, un programme non bloquant serait plus approprié. Veuillez consulter l'exemple de plan sous 02.Digital -> BlinkWithoutDelay. Il montre comment utiliser les mesures de temps pour allumer le LED. Avec le potentiomètre, vous devez changer l'intervalle.

L'astuce avec les LED tamisées

En règle générale, la luminosité d'un LED ne peut pas être modifiée par la tension, comme c'est le cas pour les lampes à induction. Une astuce permet de s'assurer que le LED ne s'allume et ne s'éteint que pendant un temps très court. Cela se produit si rapidement que plus le temps d'allumage et d'extinction est court, plus le LED apparaît sombre à nos yeux. On peut modifier un peu le schéma précédent pour en voir l'effet. Au lieu de delay(), nous utilisons delayMicroseconds() pour les pauses et nous changeons la plage de valeurs cibles de 1000 et 5000 à 0 et 10. Cela nous permet de modifier la luminosité du LED embarquée en tournant le potentiomètre.

Cependant, si vous voulez le faire correctement, vous pouvez utiliser ce que l'on appelle la modulation de largeur d'impulsion (PWM). La fiche technique indique les broches qui en sont capables. Souvent, un signe de tilde (un S horizontal) est imprimé sur la carte en plus des numéros de broches pour identifier les broches du PWM. Connectez une LED (n'oubliez pas la résistance série) à la broche 9 et chargez l'exemple "Fading" sous Fichier->Exemples->3.Analogique sur le NANO. La LED devrait maintenant émettre une impulsion.


Et charger l 'exemple "Demining" sous le file - > examples - > 3.analog sur le Nano. Le LED doit battre maintenant.

Pour contrôler le LED externe avec le potentiomètre, nous avons mis les deux plans ensemble :

int ledPin = 9;    //Connexion de del à une broche numérique 9
int sensorPin = A0;  // sélection d 'un pied d' entrée pour un potentiomètre
int fadevalue = 0;    // mémoriser des variables à partir de valeurs provenant des capteurs

void Setup () {   }

void loop() { 
fadeValue = analogRead(sensorPin);
  fadeValue = map(fadeValue, 0, 1023, 0, 255);
  analogWrite(ledPin, fadeValue);
}

Si vous voulez minimiser le Code, vous devez:

void setup() {}

void loop() { 
analogWrite(9, map(analogRead(A0), 0, 1023, 0, 255));}

La fonctionnalité reste la même.


Digital Input

Souvent, nous avons besoin de boutons de commande comme possibilités de contrôle. Que ce soit pour démarrer ou arrêter un processus ou d'autres fonctions. Ici, les broches numériques peuvent être utilisées relativement sans difficulté. Toutefois, il faut veiller à ce que, dans ce cas, les boutons poussoirs ne ferment pas simplement les circuits. C'est pourquoi il faut utiliser des résistances pull-up ou pull-down pour définir clairement les états des broches. Sur le Nano, des résistances de pull-up sont intégrées à chaque broche numérique. Elles sont activées dans le setup() lorsque la broche correspondante est initialisée en entrée :

pinMode(buttonPin, INPUT_PULLUP) ;

Cependant, l'entrée est alors active en bas. Cela signifie que l'état LOW de la broche est maintenant actif, c'est-à-dire ON. En revanche, HIGH est l'état OFF. L'exemple d'esquisse "DigitalInputPullup" sous Fichier->Exemples->2.Digital montre à nouveau comment cela fonctionne. Le bouton poussoir est connecté entre la broche D2 et GND.

Il est également possible de le construire avec des résistances externes. Alors vous n'avez pas besoin de la résistance interne. Dans l'exemple de croquis "Bouton", le circuit d'une résistance d'abaissement est décrit dans les informations et il est expliqué comment les entrées numériques sont utilisées. Le schéma du circuit ressemble à ceci:


L'un des problèmes des boutons est qu'ils "rebondissent". Si vous vous demandez pourquoi on a parfois l'impression d'avoir appuyé plusieurs fois sur le bouton, cela est dû à cet effet physique. Vous pouvez résoudre ce problème avec des condensateurs ou dans un logiciel.

Le sketch "Debounce" est un exemple d'une telle solution. Il s'agit essentiellement de détecter une frappe et d'ignorer ensuite la touche pendant un court instant. Une autre approche consisterait à vérifier plusieurs fois si le bouton est toujours enfoncé. On est alors sûr qu'il ne s'agissait pas d'un signal aléatoire et on le transmet au programme,

Au lieu d'utiliser un bouton-poussoir, vous pouvez aussi simplement tenir les extrémités de deux cavaliers ou câbles ensemble. Par exemple, si vous voulez construire un système d'alarme sur des fenêtres ou des portes, il suffit d'utiliser des contacts métalliques plats reliés aux broches. Cela fonctionne également.


Sources de tension externes

Souvent, vous souhaitez utiliser votre projet indépendamment d'un ordinateur. Cela n'est également nécessaire que pour le téléchargement du croquis vers le microcontrôleur. Si vous voulez utiliser une batterie ou une alimentation électrique, vous n'avez pas besoin du PC. Le Nano peut être alimenté en énergie par trois connexions. Par exemple, comme sur un PC, via le port mini-USB. Vous pouvez y brancher une prise USB ou une banque d'énergie.

Le Nano dispose également d'une connexion VIN (entrée de tension). Vous pouvez y appliquer un voltage entre 7V et 12V. Soit avec une alimentation de laboratoire, un bloc de 9V, un bloc de piles avec plusieurs piles AA, ou une pile LiPo avec régulateur de tension (les piles LiPo livrent généralement moins de 5V, donc la tension doit être transformée).

Dans la première porte du calendrier de l'Avent de l'AZ, il y avait le kit Breadboard, qui contient un module d'alimentation électrique. Elle fournit une tension de 3,3V ou 5V. Le 5V peut être connecté directement à la broche de 5V (qui est autrement utilisée comme source de tension pour d'autres composants) et la Nano peut être alimentée avec.

Appliquer 5V à la broche du NIV n'est pas une bonne idée, car comme mentionné ci-dessus, il faut y appliquer au moins 7V. Vous devez également éviter d'appliquer plus de 5V à la broche de 5V pour ne pas détruire le nano.


Entrée et sortie d'écran

Enfin, il convient de mentionner la possibilité d'afficher la sortie sur le moniteur. Cela est parfois nécessaire pour le "débogage". Cela se fait en utilisant la communication série entre le nano microcontrôleur et le PC. Dans le setup(), il est initialisé comme suit :

Serial.begin(9600);

La valeur entre parenthèses est le débit en mode baud (c'est-à-dire la vitesse de transmission). Dans IDE Arduino, dans le menu Outils, vous pouvez ouvrir soit le Moniteur série, soit le Traceur série. Le traceur est tout à fait adapté aux données des capteurs pour détecter les tendances. Le Serial Monitor produit des valeurs ou du texte. Il est important que le débit en bauds défini dans le coin inférieur droit du moniteur corresponde à la valeur de l'initialisation dans setup().

Vous pouvez maintenant insérer la sortie écran n'importe où dans votre code source avec :

Serial.println(valeur) // valeur de variable
Serial.print(valeur)  // valeur de variable sans changement de ligne de sortie
Serial.println(valeur, HEX); // la valeur de la variable est seize
Serial.println(valeur, BIN) // la valeur de la variable est une sortie binaire
Serial.println("Joyeux Noël!");      // sortie de texte

Il n'est donc pas possible de produire plusieurs variables simultanément avec un seul appel. Soit vous utilisez plusieurs appels de Serial.print(), soit vous rassemblez d'abord le texte dans une variable de type chaîne de caractères, que vous produisez ensuite.

Note : Sprintf ne supporte pas les nombres à virgule flottante (avec %f) sur une carte AVR dans l'IDE Arduino

double kommaZahl_A = 12.345678;
double kommaZahl_B = 98.765432;  
char kommaZahl_A_str[10];
char kommaZahl_B_str[10];
char ergebnisPuffer[10];
char ausgabePuffer[25];  

void setup() {  
// initialisation:
 Serial.begin(115200);
    
//  * * * * * * * * * * * * * * * *
Serial.print(kommaZahl_A, 2);   // deux virgules
Serial.print(" + ");
Serial.print(kommaZahl_B, 2);   // deux virgules
Serial.print(" = ");  
    //  La sortie des résultats du calcul comporte quatre virgules:
Numéro de série(virgule a + Virgule B, 4);
 
  / / * * * synthétise en chaîne, puis exporte * * * * * * *
  String ausgabeString = String(kommaZahl_A, 2) + " + " +    String(kommaZahl_B, 2) + " = " + String(kommaZahl_A + kommaZahl_B, 4);
  Serial.println(ausgabeString);
 
  * * * * * * * * composer avec sprintf et imprimer * * * * *
dtostrf(kommaZahl_A, 5, 2, kommaZahl_A_str);
dtostrf(kommaZahl_B, 5, 2, kommaZahl_B_str);
dtostrf(kommaZahl_A + kommaZahl_B, 8, 4, ergebnisPuffer);
sprintf(ausgabePuffer, "%s + %s = %s", kommaZahl_A_str, kommaZahl_B_str, ergebnisPuffer);
Serial.println(ausgabePuffer);
 }

void loop() {   }

Sortie:

12.35 + 98.77 = 111.1111
12.35 + 98.77 = 111.1111
12.35 + 98.77 = 111.1111

La connexion au clavier est également possible via le Serial Monitor. Pour ce faire, utilisez la requête sur Serial.available() et la fonction Serial.read() pour lire les bytes individuels qui sont arrivés par la connexion série. Si le byte est écrit dans une variable de type char, les lettres de la table ASCII sont sorties au lieu des valeurs numériques :

char temp;
 
void setup() {
  Serial.begin(115200);
  Serial.println(
"En attendant que le texte soit saisi...");
}
 
void loop() {
   while(Serial.available()) {
     temp = Serial.read();
     Serial.print(temp);    
  }
}

Sortie:

 


Autres conseils

L'ouverture du moniteur série redémarre le microcontrôleur connecté.

Les variables ne doivent pas être déclarées dans la fonction setup(). De préférence en dehors des fonctions en tant que variables globales. S'ils sont déclarés dans la fonction loop(), une nouvelle mémoire est réservée à la même variable à chaque passage de la boucle, ce qui peut éventuellement causer des problèmes sur les microcontrôleurs ayant peu de mémoire.

Consultez la référence allemande Arduino pour une description complète des fonctionnalités pouvant être utilisées dans un IDE Arduino. Testez également les exemples. Il y a beaucoup à découvrir. Il y a aussi une série en plusieurs parties avec le sujet Arduino IDE - programmation pour débutants dans la section blog d'AZ. Vous y trouverez d'autres astuces comme la manipulation des ports pour initialiser et commuter plusieurs broches numériques à la fois.


Nous vous souhaitons une bonne saison de l'Avent.
Andrew Wolter
pour AZ-Delivery Blog

Specials

Laisser un commentaire

Tous les commentaires sont modérés avant d'être publiés

Messages de blogs recommandés

  1. Installez maintenant ESP32 via l'administrateur de la carte
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA-Over the Air-ESP Programmation par WiFi