Arduino : Rubrique traitant de la carte nano

Mise à jour le 16/04/2020 – Rubrique traitant de la carte Arduino Nano sur les caractéristiques techniques , trucs et astuces , exemple de programme etc …

Vue de la carte Arduino Nano

Sommaire :

Description de la carte Arduino Nano
Documentation sur les spécifications techniques de la carte Arduino Nano
Pinout Arduino nano
Truc et astuce pour les cartes Arduino
- Afin de bénéficier du support des dernières versions
Exemple de programme pour Arduino Nano
- Programme 002 très simple destiné à un Arduino NANO, permettant de changer la couleur d’une LED RGB toutes les 2 secondes.
Shield pour carte Nano
- Shield E/S DFR0012 pour Nano
  - Ancienne version du Shield E/S DFR0012 repérage des broches
  - Nouvelle version du Shield E/S DFR0012 Repérage des broches
Carte dérivée de la carte Nano
- Carte Dreamer Nano DFR0213
- Module Bluno Nano DFR0296
A savoir sur l’utilisation des informations de cette article .
Pour tout probléme.
Retour au menu principal

Retour au sommaire

Description de la carte Arduino Nano

La carte Arduino Nano 3.0 est basée sur un ATMega328. Sa mémoire de 32 kB et ses E/S font de ce circuit un élément idéal pour les systèmes embarqués ou pour des applications nécessitant du multitâches.
La Nano 3.0 peut se programmer avec le logiciel Arduino. Le contrôleur ATMega328 contient un bootloader qui permet de modifier le programme sans passer par un programmateur. Le logiciel est téléchargeable gratuitement.

Caractéristiques et spécificités :

Alimentation :
- Via port USB ou
- 5 Vcc régulée sur broche 27 ou
- 6 à 20 V non régulée sur broche 30
Microprocesseur : ATMega328
Mémoire :
- Mémoire flash : 32 kB
- Mémoire SRAM: 2 kB
- Mémoire EEPROM: 1 kB
Entrées sorties :
- 14 broches d’E/S dont 6 PWM
- 8 entrées analogiques 10 bits
Intensité par E/S : 40 mA
Cadencement : 16 MHz
Bus : série , I2C et SPI
Gestion des interruptions : oui
Fiche USB : mini-USB
Boîtier : DIL30
Dimensions : 45 x 18 x 18 mm
Version d’origine : fabriquée en Italie.
Site officiel Arduino : www.arduino.cc

Retour au sommaire

Documentation sur les spécifications techniques de la carte
Arduino Nano

Alimentation de la carte nano

L’Arduino Nano peut être alimenté via la connexion USB Mini-B, ou par une alimentation externe non régulée 6-20 V (broche 30) ou une alimentation externe régulée 5 V (broche 27). La source d’alimentation est automatiquement sélectionnée pour la source de tension la plus élevée.

Mémoire

L’ATmega328P a 32 Ko, (également avec 2 Ko utilisé pour le bootloader) L’ATmega328P a 2 Ko de SRAM et 1 Ko d’EEPROM.

Entrées et sorties

Chacune des 14 broches numériques du Nano peut être utilisée comme entrée ou sortie, en utilisant les fonctions pinMode (), digitalWrite () et digitalRead (). Les entrées sorties fonctionnent en 5 volts. Chaque broche peut fournir ou recevoir un maximum de 40 mA ( attention au courant cumulé ) et dispose d’une résistance de pull-up interne (déconnectée par défaut) de 20-50 kOhms.

En outre, certaines broches ont des fonctions spécialisées:

Série : 0 (RX) et 1 (TX). Utilisé pour recevoir (RX) et transmettre (TX) des données série TTL. Ces broches sont connectées aux broches correspondantes de la puce série FTDI USB-TTL.
Interruptions externes : 2 et 3. Ces broches peuvent être configurées pour déclencher une interruption sur une valeur basse, un front montant ou descendant ou une modification de valeur. Voir la fonction attachInterrupt () pour plus de détails.
PWM : 3, 5, 6, 9, 10 et 11. Sortie PWM 8 bits avec la fonction analogWrite ().
SPI : 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Ces broches prennent en charge la communication SPI, qui, bien que fournie par le matériel sous-jacent, n’est pas actuellement incluse dans le langage Arduino.
LED 13 : Il y a une LED intégrée connectée à la broche 13 numérique.
Reset : passez cette ligne à LOW pour redémarrer le micro-contrôleur. habituellement utilisé pour rajouter une fonction ou un bouton de reset directement sur les shields/modules.
AREF. : Tension de référence pour les entrées analogiques. Utilisé avec analogReference
Entrées analogiques : La carte dispose pour cela de 8 entrées , repérées de A0 à A7 , qui peuvent admettre toute tension analogique comprise entre 0 et 5 V.
- Pour mesurer des tensions supérieures a 5 Volts il faut équiper l’entrée d’un pont diviseur.
- Les broches analogiques 6 et 7 ne peuvent pas être utilisées comme broches numériques. De plus, certaines broches ont des fonctionnalités spécialisées .
- Pour mesurer des tensions analogiques les cartes Arduino contiennent un convertisseur analogique-numérique (A/N). Ce convertisseur a une résolution de 10 bits, renvoyant des résultats de mesure sous forme d’entiers de 0 à 1023.

Rappel :Un signal analogique peut prendre une multitude de valeurs. Dans notre cas, par exemple, la grandeur analogique pourra varier aisément de 0 à 5V en passant par 0.75V, 3.89V.En revanche on peut mesurer des tensions plus élevées par un diviseur de tension pour élargir la plage de mesure ( les mesures de tensions supérieures à 50 Volts exige l’utilisation d’appareils conçus selon les normes de sécurité à ce domaine de tension )

A savoir : Pour mesurer une source de tension externe ,c’est la référence de la tension interne que nous utiliserons .Pour la mettre en service ,nous passons le paramètre INTERNAL à la fonction analogReference (INTERNAL )

DEFAULT : La référence de 5V par défaut ( pour Arduino Mega )
INTERNAL1V1 : Comme ci-dessus mais pour la Arduino Mega
INTERNAL2V56 : Une référence de 2.56V (uniquement pour le Mega)
EXTERNAL : La référence sera celle appliquée sur la broche ARef

L’instruction analogRead() ne fonctionnera pas correctement si la broche analogique utilisée pour la mesure a été mise en sortie, et donc dans ce cas, la reconfigurer en entrée avant d’utiliser l’instruction analogRead.

I2C: 4 (SDA) et 5 (SCL). Prise en charge de la communication I2C (TWI) à l’aide de la bibliothèque Wire (documentation sur le site Web de câblage).

Information site constructeur : https://store.arduino.cc/usa/arduino-nano

Retour au sommaire

Pinout Arduino nano

Retour au sommaire

Truc et astuce pour les cartes Arduino

Afin de bénéficier du support des dernières versions des derniers Arduino, il est tout d’abord préférable d’utiliser la dernière version du logiciel Arduino : https://www.arduino.cc/en/Main/Software

Il est également nécessaire de mettre à jour le module « Arduino AVR Boards ».

Pour cela, vous devez :

Aller dans le menu Outils>Type de Carte: « xxx »>Gestionnaire de Carte (Tools>Board>Boards Manager en Anglais)
Sélectionner le module « Arduino AVR Boards »
Cliquer sur le bouton de mise à jour (Update en Anglais)

Par exemple, lorsqu’une version/modèle d’Arduino n’est pas supporté, le téléversement (uploading) échoue sur Timeout, car le logiciel ne parvient pas à communiquer avec le matériel.

Après cette mise à jour, le problème sera immédiatement réglé, et vous pourrez utiliser votre nouveau matériel.

Retour au sommaire

Exemple de programme pour Arduino Nano

Programme 002 très simple destiné à un Arduino NANO, permettant de changer la couleur d’une LED RGB toutes les 2 secondes.

Matériel nécessaire pour le programme 002

1 Arduino NANO
1 Shield E/S DFR0012 pour Nano
1 Led 8 mm RGB Grove V2.0 104020048
- Pour plus d’information sur la led RGB de chez Seeedstudio

/*
 * 
 * Le 25/02/2018
 * RedOhm Benoit Bertrand 
 *        Herve Mazelin 
 * 
 * Programme très simple destiné à un Arduino NANO, permettant de changer la couleur d'une LED RGB toutes les 2 secondes.
 * 
 * Niveau de difficulté 4/10
 * 
 * Pour information 
 * @author <mailto:redohm@bertrand-benoit.net>Bertrand BENOIT</mailto>
 */
 
// Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove
#include <ChainableLED.h>

// Définition du nombre de LED.
#define NUM_LEDS      1

// Variable booléenne permettant de basculer sur les 2 couleurs.
bool firstColor = true;
 
// Definition des broches derriere la commande 
// ChainableLED leds ( e ,f , g )
// choisir de preference 2 pin qui se suivent
// e = pin 6
// f = pin 7
// g = le nombre de led 
ChainableLED leds(6, 7, NUM_LEDS);


// ---------------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// ---------------------------------------------------------------------------
void setup()
{
  // Ouvre le port série et fixe le debit de communication à 9600 bauds 
  Serial.begin(9600);  
}

// ---------------------------------------------------------------------------
// Le programme principal s’exécute par une boucle infinie appelée Loop () 
// ---------------------------------------------------------------------------
void loop()
{
  // Change la couleur de la LED, en fonction du booléen firstColor.
  if (firstColor) {
    // Change la couleur de la LED en rouge.
    leds.setColorRGB(0, 255, 0, 0);
    firstColor  = false;
  } else {
    // Change la couleur de la LED en bleu.
    leds.setColorRGB(0, 0, 0, 255);
    firstColor  = true;
  }

  // Temporise légèrement (2 secondes).
  delay(2000);
}

* Le 25/02/2018

* RedOhm Benoit Bertrand

* Herve Mazelin

* Programme très simple destiné à un Arduino NANO, permettant de changer la couleur d'une LED RGB toutes les 2 secondes.

* Niveau de difficulté 4/10

* Pour information

* @author <mailto:redohm@bertrand-benoit.net>Bertrand BENOIT</mailto>

// Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove

#include <ChainableLED.h>

// Définition du nombre de LED.

#define NUM_LEDS 1

// Variable booléenne permettant de basculer sur les 2 couleurs.

bool firstColor = true;

// Definition des broches derriere la commande

// ChainableLED leds ( e ,f , g )

// choisir de preference 2 pin qui se suivent

// e = pin 6

// f = pin 7

// g = le nombre de led

ChainableLED leds(6, 7, NUM_LEDS);

// ---------------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

// ---------------------------------------------------------------------------

void setup()

{

// Ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin(9600);

}

// ---------------------------------------------------------------------------

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

// ---------------------------------------------------------------------------

void loop()

{

// Change la couleur de la LED, en fonction du booléen firstColor.

if (firstColor) {

// Change la couleur de la LED en rouge.

leds.setColorRGB(0, 255, 0, 0);

firstColor = false;

} else {

// Change la couleur de la LED en bleu.

leds.setColorRGB(0, 0, 0, 255);

firstColor = true;

}

// Temporise légèrement (2 secondes).

delay(2000);

}

Retour au sommaire

Shield pour carte Nano

Shield E/S DFR0012 pour Nano

Le shield Nano IO DFR0012 est un module d’interface conçu pour le microcontrôleur Arduino Nano ou DFRduino Nano. Le module Nano s’enfiche directement sur le shield et ses entrées-sorties sont rendues accessibles ainsi que les borniers d’alimentation.

Le module doit être alimenté en 5 Vcc et peut être connecté au module radio APC220 ou au module Bluetooth TEL0026. Le bus I2C est également accessible via ce module.

Remarque: les versions 3.0 des modules Nano nécessitent une modification sur le shield

Alimentation à prévoir : 5 Vcc
Dimensions : 70 x 53 x 12 mm
Référence fabricant : DFR0012

–

Shield E/S DFR0012

Ancienne version du Shield E/S DFR0012 repérage des broches

Repérage des broches Shield E/S DFR0012 ancienne version

Nouvelle version du Shield E/S DFR0012 Repérage des broches

Nouvelle version du Shield E/S DFR0012 Repérage des broches

Retour au sommaire

Carte dérivée de la carte Nano
Nano DFR0213

La carte Dreamer Nano de DFRobot est dérivée de la carte Arduino Nano et est basée sur un ATmega32u4 (comme sur la carte Arduino Leonardo) ce qui permet la gestion du port USB par un seul processeur.

Carte Dreamer Nano DFR0213 – RedOhm

Elle est compatible avec le logiciel Arduino et dispose de 20 E/S dont 6 PWM. Elle peut se fixer sur une plaque d’essais sans soudure. Le logiciel est téléchargeable gratuitement.

Caractéristiques et spécificités :

Version : 4.0
Alimentation :
- Via port USB ou
- 5 Vcc régulée sur broche 27 ou
- 6 à 12 V non régulée sur broche 30
Microprocesseur : ATMega32u4
Mémoire :
- Flash : 32 kB
- SRAM: 2,5 kB
- EEPROM: 1 kB
Entrées sorties :
- 20 broches d’E/S dont 6 PWM et 8 entrées analogiques
Intensité par E/S : 40 mA
Cadencement : 16 MHz
Bus : série, I2C et SPI
Gestion des interruptions : Oui
Fiche USB : micro-USB B
Boîtier : DIL30
Dimensions : 45 x 18 x 18 mm
Référence fabricant : DFR0213

Retour au sommaire

Carte dérivée de la carte Nano
Bluno Nano DFR0296

Module Bluno DFRobot constitué d’une carte Nano et d’un module Bluetooth 4.0 permettant le contrôle de ce module via votre smartphone par exemple. Il est basé sur un ATMega328 et est totalement compatible avec la carte Arduino Nano.

Le logiciel est téléchargeable gratuitement. Des exemples sont disponibles pour l’utilisation avec un smartphone Android ou Ios (vérifier la compatibilité), une bonne connaissance technique est nécessaire.

Nano DFR0296

Caractéristiques et spécificités :

Alimentation :
- via port USB ou
- 6 à 20 V non régulée sur broche 30
Microprocesseur : ATMega328
Mémoire :
- flash : 32 kB
- Mémoire SRAM : 2 kB
- Mémoire EEPROM : 1 kB
Broches
- 14 broches d’E/S dont 6 PWM
- 8 entrées analogiques 10 bits
Intensité par E/S : 40 mA
Cadencement : 16 MHz
Port : bus série, I2C et SPI
Divers
- gestion des interruptions
- fiche USB: micro-USB B
- boîtier DIL30
Dimensions : 53 x 19 x 13 mm
Référence fabricant : DFR0296

Bluno s’intègre à une puce TI CC2540 BT 4.0 avec la carte de développement Arduino UNO. Il permet la programmation sans fil via BLE, prend en charge Bluetooth HID,et prend en charge la commande AT pour configurer le BLE et vous pouvez facilement mettre à niveau le firmware BLE. Bluno est également compatible avec tous les Arduino, ce qui signifie que tout projet réalisé avec Uno peut directement passer au sans fil!

DFRobot a également développé l’Application pour Bluno (Android et IOS), et ils sont complètement open source, de sorte que vous pouvez modifier et développer votre propre plate-forme matérielle BLE.

Puce BLE intégrée: TI CC2540
Portée de transmission: plus de 20 m
Programmation sans fil via BLE
Prise en charge Bluetooth HID
Prise en charge des iBeacons
Prise en charge de la commande AT pour configurer le BLE
Communication transparente via Serial
Mise à jour du firmware BLE facile à utiliser
Alimentation CC: alimenté par USB
Microcontrôleur: Atmega328
Bootloader: Arduino Uno
Compatible avec la cartographie des broches Arduino Uno

Retour au sommaire

A savoir sur l’utilisation des informations de cette article

Les informations sur les caractéristiques et spécificités de la carte nano, cartes dérivées et ses interfaces associées qui sont fournis sur cette page correspondent aux informations des fiches techniques du constructeur si malgré le soin apporté à la réalisation de cet article une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable.

Les programmes , schémas et autres que ceux donnés par le constructeur font parti des montages utiles à nos applications si malgré le soin apporté à nos montages une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable .

L’ensemble des informations techniques de cet article a été utilisé pour nos applications, elles vous sont fournies comme un exemple de document de travail. Mais nous ne pourrions être tenu responsables d’une mauvaise utilisation de celle-ci.

Retour au sommaire

Pour tout probléme

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook Twitter Youtube

Retour au sommaire.