Quelles sont vos cartes d'interface Arduino (shields) préférées ?
Votez pour les shields que vous estimez les plus utiles

Le , par f-leb

17PARTAGES

9  0 
Quels sont les shields que vous préférez ou que vous estimez les plus utiles ?
Le Top 10 des cartes d’interface Arduino (shields) les plus utiles
Votez pour vos shields préférés, et partagez vos propres projets Arduino avec la communauté

Une carte Arduino seule, même si vous disposez de quelques LED, résistances, boutons poussoir, etc. n'est pas d'une grande utilité et peut rester limitée à des fins d'apprentissage. Si vous voulez aller plus loin et piloter les moteurs de votre robot, vous devrez passer par une interface dédiée.
Un des atouts majeurs de l’Arduino est qu’il existe justement une multitude de fabricants proposant des cartes d’interface, appelées shields dans la terminologie Arduino, capables de couvrir la plupart des besoins d’une application embarquée : capteurs, relais de puissance, commande de moteurs, Internet, affichage sur matrice LED ou écran LCD, communication Wifi…


Le Motor shield Arduino, prêt à être enfiché sur la carte Arduino Uno

Ces cartes d’extension, dont la taille est sensiblement celle de l’Arduino, sont conçues normalement pour s’enficher directement sur les connecteurs de celle-ci, vous évitant ainsi tout le travail de connexion par câble ou de soudure de composants. Elles sont en général accompagnées d’une bibliothèque logicielle vous permettant d’exploiter rapidement ses fonctionnalités.
Dans certains cas, vous pourrez même combiner les fonctionnalités de plusieurs shields, en les empilant les uns sur les autres.


Deux shields Arduino empilés

Nous vous proposons, sous forme de sondage, de voter pour les shields ou catégories de shields Arduino que vous jugerez parmi les plus utiles, ou dont vous avez particulièrement apprécié les fonctionnalités pour vos propres applications prototypées et embarquées. La qualité de la discussion viendra des expériences que vous partagerez, alors témoignez de vos différentes utilisations.

S’ensuivront dans ce fil d’autres messages amenant une description de différents shields officiels ou non parmi les plus populaires.
N’hésitez pas à poster vos commentaires dans ce fil, notamment pour présenter un shield qui ne figurerait pas dans la liste proposée, forcément non exhaustive, ou pour décrire vos propres projets menés à l’aide de ces shields.

Il s'agit d'avoir un sondage de qualité, merci de suivre ces consignes :
  • SMS interdit en essayant d'écrire en français ;
  • évitez de multiplier les messages courts ;
  • les messages type taverne ou SMS seront effacés immédiatement sans préavis ou explications.


Les cartes d'interface (shield)
Les meilleurs cours et tutoriels pour apprendre à utiliser la carte Arduino

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de f-leb
Rédacteur/Modérateur https://www.developpez.com
Le 17/05/2016 à 19:28
LCD shield
Afficheur LCD


Le LCD Keypad shield de DFRobot à l'oeuvre avec un télémètre à ultrasons

Parce que vous ne pourrez pas toujours faire des affichages à coup de Serial.print sur l’écran de votre PC dans vos applications censées être embarquées, un affichage sur un petit écran LCD de 2-3 lignes de 16 ou 20 caractères enfiché sur votre Arduino peut s’avérer bien utile. Ce genre de composants nécessitent de recourir à un contrôleur spécifique et de jouer du fer à souder… sauf si vous disposez d’un shield LCD.
Le LCD Keypad Shield de DFRobot par exemple (monochrome, 2 lignes de 16 caractères, affichage en négatif avec rétroéclairage) fonctionne avec un contrôleur classique compatible Hitachi (broches rs, w, enable et quatre broches supplémentaires en mode 4 bits). Vous n’aurez alors aucun mal à piloter votre shield avec la bibliothèque LiquidCrystal proposée en standard dans l’environnement Arduino.
Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
#include <LiquidCrystal.h> 
  
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); 
  
void setup() 
{ 
  lcd.begin(16,2); 
  lcd.print("Hello, world!"); 
} 
  
void loop() {}

Ce shield dispose en plus de boutons poussoirs qui vous permettront, par exemple, de faire de la navigation et de la sélection dans des systèmes de menus.
Et si vous trouvez que le nombre de broches monopolisées est trop important pour votre application, tournez-vous vers un équivalent, mais muni cette fois d’un contrôleur I2C ou SPI.
5  0 
Avatar de f-leb
Rédacteur/Modérateur https://www.developpez.com
Le 18/05/2016 à 18:10
Ethernet Shield


Arduino Ethernet shield - www.arduino.org

Ce shield va vous permettre de connecter votre Arduino (Uno ou Mega) avec Internet (jusqu’à 100 Mbit/s), et donc rentrer de plain-pied dans l’Internet des Objets (IdO). Il suffit pour cela de le relier à votre réseau grâce à un câble RJ45. Le shield est basé sur le chipset Wiznet W5500 chargé de la pile de protocoles TCP ou UDP/IP. Il comporte également un lecteur de carte microSD permettant de stocker fichiers, pages HTML, images, etc. au cas où le shield serait par exemple configuré en serveur Web (attention, quelques connexions simultanées seulement...). À noter qu'une version avec un module PoE (Power Over Ethernet) est disponible et permet, si le réseau le gère, d'alimenter l'Arduino et le shield par le câble réseau.

Physiquement, la liaison entre ce shield et votre carte Arduino Uno ou Mega est de type série SPI (3 broches SCK, MOSI et MISO et 2 broches supplémentaires Ship Select pour les contrôleurs Ethernet et carte SD), et les connecteurs de la Uno sont repris sur le dessus du shield pour pouvoir éventuellement y empiler un autre shield.
La bibliothèque Ethernet2 proposée dans l’environnement standard d’Arduino comprend les classes nécessaires (Ethernet, IPAddress, Server, Client, EthernetUDP) pour configurer votre shield en client ou serveur Ethernet. La bibliothèque SD prendra en charge les opérations de lecture/écriture sur la carte microSD.

Exemple de serveur Web d’après ARDUINO ETHERNET SHIELD 2: MONITOR YOUR SENSORS WITH A WEB SERVER :
Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/* 
  Web Server 
  
 A simple web server that shows the value of the analog input pins. 
 using an Arduino Wiznet Ethernet shield. 
  
 Circuit: 
 * Ethernet shield attached to pins 10, 11, 12, 13 
 * Analog inputs attached to pins A0 through A5 (optional) 
  
 created 18 Dec 2009 
 by David A. Mellis 
 modified 9 Apr 2012 
 by Tom Igoe 
  
 */ 
#include <SPI.h> 
#include <Ethernet2.h> 
  
// Enter a MAC address and IP address for your controller below. 
// The IP address will be dependent on your local network: 
byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED 
}; 
IPAddress ip(192, 168, 1, 177); 
  
// Initialize the Ethernet server library 
// with the IP address and port you want to use 
// (port 80 is default for HTTP): 
EthernetServer server(80); 
  
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 
  } 
  
  
  // start the Ethernet connection and the server: 
  Ethernet.begin(mac, ip); 
  server.begin(); 
  Serial.print("server is at "); 
  Serial.println(Ethernet.localIP()); 
} 
  
  
void loop() { 
  // listen for incoming clients 
  EthernetClient client = server.available(); 
  if (client) { 
    Serial.println("new client"); 
    // an http request ends with a blank line 
    boolean currentLineIsBlank = true; 
    while (client.connected()) { 
      if (client.available()) { 
        char c = client.read(); 
        Serial.write(c); 
        // if you've gotten to the end of the line (received a newline 
        // character) and the line is blank, the http request has ended, 
        // so you can send a reply 
        if (c == '\n' && currentLineIsBlank) { 
          // send a standard http response header 
          client.println("HTTP/1.1 200 OK"); 
          client.println("Content-Type: text/html"); 
          client.println("Connection: close");  // the connection will be closed after completion of the response 
          client.println("Refresh: 5");  // refresh the page automatically every 5 sec 
          client.println(); 
          client.println("<!DOCTYPE HTML>"); 
          client.println("<html>"); 
          // output the value of each analog input pin 
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) { 
            int sensorReading = analogRead(analogChannel); 
            client.print("analog input "); 
            client.print(analogChannel); 
            client.print(" is "); 
            client.print(sensorReading); 
            client.println(""); 
          } 
          client.println("</html>"); 
          break; 
        } 
        if (c == '\n') { 
          // you're starting a new line 
          currentLineIsBlank = true; 
        } 
        else if (c != '\r') { 
          // you've gotten a character on the current line 
          currentLineIsBlank = false; 
        } 
      } 
    } 
    // give the web browser time to receive the data 
    delay(1); 
    // close the connection: 
    client.stop(); 
    Serial.println("client disconnected"); 
  } 
}

4  0 
Avatar de f-leb
Rédacteur/Modérateur https://www.developpez.com
Le 20/05/2016 à 18:53
Motor shield


Arduino Motor shield- www.arduino.cc

Le motor shield d’Arduino est un contrôleur muni d’une double structure avec pont en H (Dual Full Bridge Driver L298), spécifiquement prévu pour piloter un moteur pas-à-pas bipolaire (quatre fils et deux phases), ou encore de deux moteurs à courant continu.

Il est donc, par exemple, adapté pour équiper un petit robot roulant avec deux roues indépendantes motorisées. Les connexions du moteur au shield et de l'alimentation externe peuvent se faire grâce au bornier à vis, mais des connecteurs de type TinkerKit sont également prévus pour faciliter le branchement.

Avant de mettre en œuvre votre motorisation, il convient de bien lire la documentation du shield si vous voulez éviter de griller votre carte Arduino.
En effet, séparer les sources d’alimentation est fortement recommandé, surtout si le moteur requiert une alimentation de 9V ou plus : une pour l’alimentation de la carte Arduino qui commande le ou les moteurs, et l’autre pour l’étage de puissance d’alimentation des moteurs. Il vous faudra pour cela couper la soudure de la ligne Vin connect située sous le shield. Dans ce cas, la tension d’alimentation maximale des moteurs sur l’entrée Vin du bornier à vis du shield est de 18V, et le courant maxi supporté peut monter jusqu’à 4A (2A si deux moteurs).

Du point de vue de la commande, des sorties PWM et Direction doublées permettent de contrôler indépendamment la vitesse et le sens de rotation des moteurs A et B. Une autre sortie (qui peut être désactivée), doublée elle aussi pour chacun des moteurs A et B, permet de freiner (brake). Enfin, une entrée analogique pour chaque moteur peut être utilisée pour relever l’intensité consommée (current sensing : 1,65 V/A).

Exemple de pilotage d’un moteur d’après www.arduino.cc/en/Tutorial/DueMotorShieldDC :

Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
const int  
PWM_A   = 3, 
DIR_A   = 12, 
BRAKE_A = 9, 
SNS_A   = A0; 
  
  
void setup() { 
  // Configure the A output 
  pinMode(BRAKE_A, OUTPUT);  // Brake pin on channel A 
  pinMode(DIR_A, OUTPUT);    // Direction pin on channel A 
  
  // Open Serial communication 
  Serial.begin(9600); 
  Serial.println("Motor shield DC motor Test:\n"); 
} 
  
void loop() { 
  
// Set the outputs to run the motor forward 
  
  digitalWrite(BRAKE_A, LOW);  // setting brake LOW disable motor brake 
  digitalWrite(DIR_A, HIGH);   // setting direction to HIGH the motor will spin forward 
  
  analogWrite(PWM_A, 255);     // Set the speed of the motor, 255 is the maximum value 
  
  delay(5000);                 // hold the motor at full speed for 5 seconds 
  Serial.print("current consumption at full speed: "); 
  Serial.println(analogRead(SNS_A)); 
  
// Brake the motor 
  
  Serial.println("Start braking\n"); 
  // raising the brake pin the motor will stop faster than the stop by inertia 
  digitalWrite(BRAKE_A, HIGH);  // raise the brake 
  delay(5000); 
  
// Set the outputs to run the motor backward 
  
  Serial.println("Backward"); 
  digitalWrite(BRAKE_A, LOW);  // setting againg the brake LOW to disable motor brake 
  digitalWrite(DIR_A, LOW);    // now change the direction to backward setting LOW the DIR_A pin 
  
  analogWrite(PWM_A, 255);     // Set the speed of the motor 
  
  delay(5000); 
  Serial.print("current consumption backward: "); 
  Serial.println(analogRead(SNS_A)); 
  
  // now stop the motor by inertia, the motor will stop slower than with the brake function 
  analogWrite(PWM_A, 0);       // turn off power to the motor 
  
  Serial.print("current brake: "); 
  Serial.println(analogRead(A0)); 
  Serial.println("End of the motor shield test with DC motors. Thank you!"); 
  
  
  while(1); 
}
4  0 
Avatar de f-leb
Rédacteur/Modérateur https://www.developpez.com
Le 27/05/2016 à 16:58
Googly Eye Shield

Avec sa paire d'yeux mobiles à coller soi-même (deux paires de tailles différentes fournies), ce shield proposé par evilmadscientist.com et à assembler, va vous permettre de donner une personnalité à votre carte Arduino.


Le Googly Shield décoré et monté sur une Arduino Mega
[: 8O :]

Ce shield ne sert à rien direz-vous. Presque à rien... Mais ne manqueriez-vous pas d'imagination ? Ou négligeriez-vous tout simplement l'impact psychologique d'une Arduino au regard jovial dans un monde froid de puces de silicium ?

Et si vous colliez une petite plaque de câblage (breadboard) en plus sur ce shield pour le prototypage. Ou s'il vous servait de séparateur entre votre carte Arduino et un shield mal conçu, avec des composants sous celui-ci qui risquent de rentrer en contact avec le port USB surélevé de l'Arduino.

Et s'il était indispensable après tout...
4  0 
Avatar de Luke spywoker
Membre expérimenté https://www.developpez.com
Le 23/05/2016 à 6:52
Salut les arduinos,

Tout cela me rappelle quand j'avais ma première carte arduino, et que je suis partie dans un délire de vouloir faire clignoter toutes les possibilités d'une combinaison de 8 LED, sur une planche a nouille...

Le débuts de mes test se faisait avec un brin d'algorithmie et la sortie serial.

Puis j'ai essayer de faire d'afficher la LED qui clignote sur un écran LCD et je fut bien déçut quand je n'arrivait pas a afficher quoi que ça soit sur cet écran.

C'était la faute d'un réglage de l'écran qui était coupler avec un truc tournant contrôlant la tension ou la résistance du truc en entrée de l'écran (désolé je ne peut être plus précis)...

Bref au bout du compte j'arrivais a peine afficher quelque chose sur mon écran (mauvais matériel, problème technique, ou développeur trop bête je ne saurai vous dire.) tout en devant tourner la manivelle du truc (désolé je ne peut être plus précis) dès que l'affichage s'effaçait...

Mais je me rendus et j'ai fait la même chose autrement:

Une page web représentant les 8 LED, (Bravo l'artiste HTML+Javascript pour le dessin des LED a 2 états en HTML sans canvas).

Alors l'on pouvait cliquer sur une LED dans son browser elle s'allumait ou l'éteindre dans le navigateur web.

La page et le Javascript été fait je n'avait plus qu'a relier le tout a la planche a nouille et faire passer les commandes par la connexion série me je disais-je...

Erreur cela ne marchais malgré que les simples composants du projet fonctionnaient.

Mais pas de corps en corps c.a.d avec la connexion série laquelle devant transporter les données.

Malgré l'achat d'un shield ethernet, pour essayer de faire passer les données par un câble ethernet, j'ai abandonner le projet sans vraiment avoir finaliser ou complètement échouer.

Alors je tenait a vous dire que la lecture de votre article m'a donner envie de remettre les fils dans les slots !!!
3  0 
Avatar de steel-finger
Membre actif https://www.developpez.com
Le 18/05/2016 à 9:54
@f-leb : Je trouve le schéma bien simplifié par rapport au mien, je voie qu'il y a un connecteur qui est branché sur le bas de l'écran peut tu m'en dire plus ?
edit: et sur le haut de l'écran.

Personnellement j'ai jamais testé de shield mais j'ai une préférence pour les Arduino nano
2  0 
Avatar de Auteur
Expert éminent https://www.developpez.com
Le 18/05/2016 à 10:17
Les shields présentés ici sont surtout pour les cartes de type UNO ou Leonardo ou des cartes qui ont ce format ou compatibles.

Citation Envoyé par steel-finger
@f-leb : Je trouve le schéma bien simplifié par rapport au mien, je voie qu'il y a un connecteur qui est branché sur le bas de l'écran peut tu m'en dire plus ?
edit: et sur le haut de l'écran.
le shield sur la photo est le "LCD Keypad shield" de DFRobot : http://www.dfrobot.com/wiki/index.ph...KU:_DFR0009%29
Il existe de nombreux shield LCD avec ou sans bouton.
2  0 
Avatar de deusyss
Rédacteur/Modérateur https://www.developpez.com
Le 18/05/2016 à 18:17
Citation Envoyé par f-leb Voir le message
La planche à pain tu veux dire (breadboard)
Oui c'est ça. A mon IUT on appelait planche à nouilles parce que quand on a finit un prototypage la dessus ...
2  0 
Avatar de f-leb
Rédacteur/Modérateur https://www.developpez.com
Le 24/05/2016 à 19:04
Shield GSM/GPRS

Ils sont plusieurs fabricants à disposer de shields GPS/GPRS dans leur catalogue. Précisons que ces shields proposent une connectivité IP via le réseau téléphonique mobile GPRS. Il suffit de brancher le shield sur votre carte Arduino Uno/Mega, d’insérer une carte SIM offrant une couverture GPRS provenant de votre opérateur, et bien sûr du code… En plus de l’accès à Internet, vous pouvez alors transformer votre carte Arduino en véritable téléphone (à condition d’y brancher un micro et un haut-parleur), envoyer ou recevoir des SMS.


Le GPRS Shield V3 de www.seeedstudio.com/, par exemple, est basé sur le module SIM900 (SIMCom) tandis que l’Arduino GSM Shield 2 utilise un M10 (Quectel). Les deux modules sont Quad-band (850, 900, 1800 et 1900MHz) et supportent les protocoles TCP/UDP et HTTP au travers d’une connexion GPRS. L’Arduino GPRS Shield existe en version avec antenne intégrée ou avec un connecteur dédié, tandis qu’une antenne sur un petit circuit imprimé est fournie avec le GPRS Shield de Seeedstudio. Retrouvez les caractéristiques détaillées sur les sites d’arduino.org et seedstudio.com. Attention au niveau de l’alimentation, ce genre de modules consomment en général davantage que les 500 mA d’un port USB ; alimentation externe 1 voire 2A recommandée.

Il y a plusieurs façons de communiquer avec le module. Il est possible de lui envoyer directement des commandes AT via une liaison série UART classique (19200 bauds, 8-N-1 par défaut). Le GPRS shield d’Arduino monopolise les broches D2 et D3 de la Uno pour établir une liaison série virtuelle (Rx, Tx) avec le module M10, celui de Seeedstudio les broches D7 et D8, mais il est possible de l’employer avec le port série matériel sur les broches D0 et D1. Pour programmer le GPRS Shield d’Arduino, vous pouvez également utiliser la bibliothèque standard GSM et ses méthodes objet dédiées.

Exemple de code permettant d’envoyer un SMS ou de composer un numéro pour un appel vocal, uniquement en envoyant des commandes AT, d’après www.seeedstudio.com/wiki/GPRS_Shield_V2.0 :

Code c++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <SoftwareSerial.h> 
#include <String.h> 
  
SoftwareSerial gprsSerial(7,8); 
  
void setup() 
{ 
  gprsSerial.begin(19200); // GPRS shield baud rate  
  Serial.begin(19200);    
  delay(500); 
} 
  
void loop() 
{ 
  
  if (Serial.available()) // if there is incoming serial data 
   switch(Serial.read()) // read the character 
   { 
     case 't': // if the character is 't' 
       SendTextMessage(); // send the text message 
       break; 
     case 'd': // if the character is 'd' 
       DialVoiceCall(); // dial a number 
       break; 
  
   }  
  
  if (gprsSerial.available()){ // if the shield has something to say 
    Serial.write(gprsSerial.read()); // display the output of the shield 
  } 
} 
  
/* 
* Name: SendTextMessage 
* Description: Send a text message to a number 
*/ 
void SendTextMessage() 
{ 
  Serial.println("Sending Text..."); 
  gprsSerial.print("AT+CMGF=1\r"); // Set the shield to SMS mode 
  delay(100); 
  // send sms message, the phone number needs to include the country code e.g. if a U.S. phone number such as (540) 898-5543 then the string must be: 
  // +15408985543 
  gprsSerial.println("AT+CMGS = \"+xxxxxxxxxx\""); 
  delay(100); 
  gprsSerial.println("How are you today?"); //the content of the message 
  delay(100); 
  gprsSerial.print((char)26);//the ASCII code of the ctrl+z is 26 (required according to the datasheet) 
  delay(100); 
  gprsSerial.println(); 
  Serial.println("Text Sent."); 
} 
  
/* 
* Name: DialVoiceCall() 
* Description: Can call/dial a phone number 
*/ 
void DialVoiceCall() 
{ 
  gprsSerial.println("ATD+xxxxxxxxxx;");//dial the number, must include country code 
  delay(100); 
  gprsSerial.println(); 
}
2  0 
Avatar de f-leb
Rédacteur/Modérateur https://www.developpez.com
Le 02/06/2016 à 20:54
Proto Shield

Un Proto Shield dispose d’une aire avec un jeu de trous pastillés cuivrés pour souder des composants et réaliser son propre circuit électronique. En quelque sorte, vous avez là un shield facilitant la réalisation de shield personnalisé et répondant à vos besoins en matière de prototypage.
De nombreux fabricants proposent un Proto Shield dans leur catalogue, à commencer par le Proto Shield officiel reprenant les connecteurs de l’Arduino UNO R3 ou MEGA :


Proto Shields officiels arduino.cc
En haut , le Proto Shield pour l'Arduino UNO R3 assemblé avec son bouton Reset.
En bas, le Proto Shield prêt à assembler pour l'Arduino MEGA

D’autres fabricants proposent des Proto Shields un peu plus avancés et à assembler soi-même avec des emplacements prévus sur le circuit pour souder des LED, des boutons poussoirs, et même un module WiFi pour le kit Proto Shield de Sparkfun ci-dessous :


Document Sparkfun : Kit Proto Shield Sparkfun

DFRobot quant à lui propose un Proto Shield qui prolonge les connecteurs de l’Arduino grâce à des borniers à vis, pour brancher temporairement des composants avec des câbles dénudés :


Mais finalement le meilleur Proto Shield, et le moins cher, sera peut-être le vôtre réalisé avec une simple plaque PCB universelle percée et pastillée, et quelques connecteurs. Le moins cher, mais pas la solution la plus simple quand on sait que les connecteurs de l'Arduino ne s'alignent pas sur la grille de trous de la plaque au pas standard de 2,54 mm (0.1", vous obligeant ainsi à quelque bricolage (percer de nouveaux trous, tordre des pattes de connecteurs, etc.).


Un Proto Shield Do It Yourself, d’après http://arduinotronics.blogspot.fr
2  0 
Contacter le responsable de la rubrique Systèmes embarqués

Partenaire : Hébergement Web