Uno SMD R3 + cable USB

La Uno R3 en version CMS est la même carte que l’Uno R3 classique, avec un montage différent : le microcontrôleur ATmega328P et la plupart des composants sont soudés en surface sur le circuit imprimé au lieu d’être enfichés dans des supports. Le processeur ne se retire donc plus — mais le brochage, les dimensions, les programmes et les shields restent strictement identiques. Elle est livrée avec son câble USB.

C’est une carte compatible Uno R3 : tout montage décrit pour une Uno fonctionne ici sans la moindre modification, et les shields au format Uno s’enfichent directement sur les rangées de broches.

À quoi sert cette version ?

Comme toute Uno, la carte se programme depuis un ordinateur par le câble USB, puis exécute son programme seule dès qu’elle est alimentée. Elle lit des capteurs sur ses entrées, commande des LED, des relais, des moteurs ou des écrans sur ses sorties, et dialogue avec un ordinateur par sa liaison série.

Deux situations font préférer le montage soudé en surface :

• Un montage qui reste en place — une fois le projet terminé, il n’y a plus rien à retirer ni à remettre en place. Le contact entre la puce et sa carte ne peut pas se dégrader avec le temps.
• Un montage qui bouge — dans un boîtier, sur une machine ou dans un véhicule, un composant enfiché peut sortir de son support avec les vibrations. Soudé, il ne bouge plus.

Caractéristiques techniques

Brochage : les repères à connaître

Le brochage est celui de toutes les Uno R3. C’est ce qui permet de réutiliser sans adaptation les montages trouvés dans les livres et sur les sites spécialisés.

La masse se relie toujours en premier et se débranche en dernier. Deux montages qui ne partagent pas leur masse ne peuvent pas communiquer, même quand le câblage des signaux est juste.

Alimentation : trois façons de faire

• Par le câble USB — 5 V fournis par l’ordinateur. C’est le mode de la programmation et de tous les projets peu gourmands.
• Par le jack d’alimentation — un adaptateur de 7 à 12 V continu. En dessous de 7 V, le régulateur de la carte ne tient plus la sortie 5 V ; au-dessus de 12 V, il chauffe sans raison.
• Par la broche VIN — pour reprendre une alimentation déjà présente dans le montage, toujours entre 7 et 12 V. Y envoyer du 5 V ne suffit pas à faire fonctionner le régulateur.

Les gros consommateurs ne se branchent pas sur la carte. Servomoteurs, moteurs, bandeaux de LED et modules relais réclament leur propre alimentation, avec la masse reliée à celle de la carte. Faire passer ce courant par la Uno fait chauffer le régulateur et provoque des redémarrages inexpliqués.

Mettre la carte en service

Trois réglages, une seule fois, suffisent à faire clignoter la LED de la carte :

• Brancher la carte à l’ordinateur avec le câble USB fourni. Les témoins d’alimentation s’allument.
• Choisir la carte dans le menu des outils du logiciel : « Arduino Uno ». Le port se choisit juste à côté ; il apparaît dès que la carte est branchée.
• Téléverser un premier programme, par exemple l’exemple de clignotement fourni avec le logiciel. La petite LED marquée « L » clignote alors une fois par seconde.

Si le téléversement refuse de démarrer, vérifiez le port dans un premier temps, puis retirez tout module branché sur les broches 0 et 1 : c’est la cause la plus fréquente.

Mini-projet : un radar de recul qui sonne quand un obstacle approche

Ce montage fait le tour de l’essentiel : une mesure, une décision, une sortie, et un programme qui tourne ensuite tout seul sur une simple alimentation. Le capteur à ultrasons envoie une impulsion sonore et chronomètre son retour ; la carte en déduit une distance et fait sonner le buzzer en dessous d’un seuil. C’est exactement ce que fait un radar de recul de voiture, en plus simple.

Ce qu’il faut

Le câblage

Le capteur se branche sur quatre fils et travaille en 5 V : aucune alimentation séparée n’est nécessaire. Le buzzer actif, lui, sonne dès qu’on lui applique du 5 V, sans réglage de fréquence.

Le programme

À copier dans le logiciel de programmation, puis à téléverser :

/*
 * Uno R3 CMS : radar de recul, le buzzer sonne quand un obstacle approche
 * Carte : Uno R3 version CMS (ATmega328P)
 * Montage : HC-SR04 sur les broches 9 et 10, buzzer actif sur la broche 8
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */
const int PIN_TRIG = 9;        // impulsion de depart vers le capteur
const int PIN_ECHO = 10;       // retour de l echo
const int PIN_BUZZER = 8;      // buzzer actif
const int SEUIL_CM = 30;       // distance a partir de laquelle le buzzer sonne
// Mesure une distance en centimetres et la renvoie.
long mesurerDistance() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);      // impulsion de 10 microsecondes
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  // pulseIn chronometre le retour de l echo, en microsecondes.
  // Au dela de 30 millisecondes, il renvoie 0 : plus aucun echo recu.
  long duree = pulseIn(PIN_ECHO, HIGH, 30000);
  if (duree == 0) {
    return 999;                // voie libre : on renvoie une distance lointaine
  }
  // Le son parcourt environ 58 microsecondes par centimetre,
  // aller et retour compris.
  return duree / 58;
}
void setup() {
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
  pinMode(PIN_BUZZER, OUTPUT);
  // Liaison USB : sert a lire les distances et a choisir le seuil.
  Serial.begin(9600);
}
void loop() {
  long distance = mesurerDistance();
  // min() renvoie la plus petite des deux valeurs.
  // Elle vaut la mesure tant que l obstacle est plus pres que le seuil.
  bool proche = (min(distance, SEUIL_CM) == distance);
  if (proche) {
    digitalWrite(PIN_BUZZER, HIGH);
  } else {
    digitalWrite(PIN_BUZZER, LOW);
  }
  // Envoi de la distance a l ordinateur : sert uniquement au reglage.
  Serial.println(distance);
  delay(100);
}

Comment ça marche

• pulseIn() attend que la broche 10 passe à 5 V, puis mesure combien de temps elle y reste. Le capteur y envoie une impulsion dont la durée est proportionnelle à la distance de l’obstacle.
• La division par 58 convertit cette durée en centimètres : c’est le temps que met le son pour faire l’aller-retour sur un centimètre. Le chiffre exact dépend un peu de la température de l’air, ce qui est sans importance pour un radar de recul.
• Le troisième argument de pulseIn() est un délai de garde : passé 30 millisecondes sans écho, la fonction rend la main avec la valeur 0 — un obstacle trop lointain ou trop mou pour réfléchir le son.
• min(distance, SEUIL_CM) compare la mesure au seuil : le résultat vaut la mesure tant que celle-ci reste sous le seuil. La comparaison tient donc en une seule égalité, et le seuil se lit d’un coup d’œil en haut du programme.
• digitalWrite() avec HIGH envoie 5 V sur la broche 8 et fait sonner le buzzer ; LOW le remet à la masse et le fait taire.
• Serial.println() envoie la distance à la fenêtre du moniteur série. C’est ce qui permet de régler le seuil : approchez la main, lisez la valeur, et placez SEUIL_CM juste au-dessus.
• delay(100) espace les mesures de 100 millisecondes. Sans lui, le moniteur série défile trop vite pour être lu et le buzzer grésille au moindre mouvement du capteur.

Pour aller plus loin

• Moduler le son — un buzzer qui bipe de plus en plus vite quand l’obstacle se rapproche se comprend sans regarder l’écran. Le buzzer actif se contente de s’allumer et de s’éteindre : c’est la durée du silence entre deux bips qu’on raccourcit.
• Commander une vraie lampe — un module relais 5 V se branche sur une broche de sortie et allume ce que la carte ne peut pas alimenter. Le secteur se câble uniquement sur les contacts du relais, jamais sur la carte.
• Afficher la distance — un afficheur LCD 16×02 avec interface I2C se branche sur A4 et A5, et laisse toutes les autres broches libres.
• Verrouiller le montage — un bornier à vis se visse sur la carte et remplace les fils volants par des raccords qui ne bougent plus.

Variante : la même carte à microcontrôleur enfichable

Le circuit est identique ; seule la façon de le monter change. La Uno R3 en version à support reçoit le même programme et les mêmes shields, mais son processeur est enfiché.

Sur les deux versions, la fréquence, la mémoire, le nombre de broches et la tension de service sont les mêmes. Un programme écrit pour l’une tourne sur l’autre sans être retouché.

Questions fréquentes

L’ordinateur ne reconnaît pas la carte. Que faire ?

Regardez le petit circuit situé juste à côté du connecteur USB : c’est lui qui fait la conversion entre l’USB et le processeur. S’il porte la référence ATmega16U2, l’ordinateur le reconnaît sans rien installer. S’il porte la référence CH340, il faut installer son pilote une seule fois, et toute la famille de cartes qui l’utilisent fonctionnera ensuite. Dans les deux cas, la carte à choisir dans le logiciel est « Arduino Uno ».

Peut-on remplacer le microcontrôleur ?

Non, pas sur cette version : la puce est soudée sur la carte et ne se dépose pas comme un composant enfiché. C’est un avantage tant que la carte fonctionne, et une contrainte le jour où l’on veut changer de processeur ou reprogrammer une puce séparément — dans ce cas, mieux vaut la version à support. Une carte dont la puce est morte pour cause de surtension se remplace, elle ne se répare pas.

Les shields pour Uno sont-ils tous compatibles ?

Oui. Le format, l’entraxe des rangées de broches et le brochage sont ceux de la Uno R3, donc un shield de prototypage ou un bornier à vis s’enfichent directement. Un shield prévu pour la Mega, en revanche, ne tombe pas sur les bonnes broches : la Mega 2560 est plus longue.

Quelle alimentation choisir pour un montage autonome ?

Un adaptateur de 9 V sur le jack est le choix habituel : la carte reste alimentée, protégée par son régulateur, et rien ne dépend de l’ordinateur. Le câble d’alimentation 9 V convient directement. Si le montage comprend aussi des modules gourmands, une alimentation 5 V 2 A les prendra en charge séparément, la masse restant reliée à celle de la carte.

Combien de courant puis-je tirer des sorties ?

Comptez 20 mA au maximum par broche d’entrée-sortie, et quelques centaines de milliampères pour l’ensemble des sorties réunies. La sortie 3,3 V ne fournit que 50 mA : elle est faite pour un petit module, pas pour un moteur ni un bandeau de LED. Au-delà, la tension s’écroule et la carte redémarre sans prévenir.

Faut-il la protéger dans un boîtier ?

Dès que le montage quitte la table, oui. Le boîtier pour Uno R3 laisse passer le jack, le câble USB et les rangées de broches, et met la carte à l’abri d’un outil qui tombe ou d’un fil qui tire sur une piste. Le montage soudé en surface résiste mieux aux vibrations, mais rien ne protège une carte nue d’un contact métallique sur ses broches.

À combiner avec

Pour remplacer les câbles par un support qui s’enfiche directement sur la carte, le shield de prototypage au format Uno reprend tout le brochage. Une fois le montage terminé, le boîtier pour Uno R3 referme l’ensemble. Si vous débutez, le KIT Starter réunit la plaque d’essai, les fils, les résistances et les capteurs livrés avec une carte équivalente. Ceux qui suivent un cours peuvent aussi regarder la carte Nano, plus petite et prévue pour être soudée à demeure, ou le circuit ATmega328P en boîtier DIP s’ils préfèrent la version à processeur enfichable.