Affichage des résultats du sondage: Quels sont les shields que vous préférez ou que vous estimez les plus utiles ?

Votants
23. Vous ne pouvez pas participer à ce sondage.
  • Afficheur LCD

    13 56,52%
  • Afficheur TFT ou matrice de LED

    5 21,74%
  • Réseau Ethernet

    13 56,52%
  • WiFi

    8 34,78%
  • Commande de moteur

    10 43,48%
  • Commande de relais

    9 39,13%
  • Téléphonie GPS/GPRS/...

    3 13,04%
  • Prototypage/circuit imprimé

    3 13,04%
  • NFC/RFID

    2 8,70%
  • Bluetooth/BLE

    6 26,09%
  • GPS

    4 17,39%
  • Mouvements/accéléromètre/gyroscope

    5 21,74%
  • Audio/MP3

    4 17,39%
  • Tactile (clavier sensitif...)

    2 8,70%
  • Stockage, data logging...

    4 17,39%
  • Autre, précisez ...

    0 0%
  • Pas d'avis

    1 4,35%
Sondage à choix multiple
  1. #21
    Rédacteur/Modérateur

    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    janvier 2009
    Messages
    9 739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : janvier 2009
    Messages : 9 739
    Points : 37 169
    Points
    37 169
    Billets dans le blog
    9

    Par défaut

    Digit Shield

    La réalisation d’un afficheur 7 segments à un ou plusieurs digits est un exercice classique par lequel tout apprenti en systèmes embarqués doit obligatoirement passer. On apprend alors à sérialiser les données avec un registre à décalage, le principe de l’affichage multiplexé, le système décimal codé binaire (BCD), etc. Le défi consiste à piloter un maximum de digits en consommant le moins de sorties Arduino possible.

    Pour les gens pressés, le Digit Shield de nootropic design fournit l’électronique de commande d’un afficheur 7 segments (avec le point décimal en plus) à 4 digits en utilisant seulement quatre sorties de l’Arduino (D1, D2, D3 et D4).

    Nom : DigitShield.JPG
Affichages : 831
Taille : 25,6 Ko

    Le constructeur propose trois variantes de son shield en fonction de la couleur souhaitée des LED de l’afficheur :

    Nom : TroisCouleursDigitShield.JPG
Affichages : 808
Taille : 24,4 Ko

    En observant le schéma électronique du shield, on y trouve :
    • un registre à décalage 74HC595N pour y disposer chaque octet envoyé sous forme série sur l’entrée SER, sous forme parallèle sur les sorties QA à QH ;
    • un décodeur BCD - 7 segments SN74LS247. Si les quatre entrées IA à ID codent le chiffre à afficher en binaire naturel, les sorties A, B, C, D, E , F et G permettent alors d’allumer les segments correspondants ;
    • quatre transistors commandés par les sorties QE, QF, QG et QH du registre à décalage pour gérer le multiplexage.


    Nom : CaptureDigitShield.JPG
Affichages : 913
Taille : 48,4 Ko
    Document nootropicdesign.com : extrait du schéma, fichiers EAGLE

    Si le langage de référence Arduino permet de piloter facilement le registre à décalage (instruction ShiftOut), il est encore plus simple de contrôler l’afficheur avec la bibliothèque fournie :

    Code c++ : Sélectionner tout - Visualiser dans une fenêtre à part
    DigitShield.setValue(123); // Display the value 123

  2. #22
    Rédacteur/Modérateur

    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    janvier 2009
    Messages
    9 739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : janvier 2009
    Messages : 9 739
    Points : 37 169
    Points
    37 169
    Billets dans le blog
    9

    Par défaut

    Bluetooth LE Shield

    Le Bluetooth Low Energy (ou BLE) Shield de MiKro-Labs permet d’établir la communication entre votre Arduino et tout périphérique communiquant selon la norme Bluetooth Low Energy 4 (aussi appelée Bluetooth Smart).


    Avec ce shield, vous pouvez par exemple concevoir toute application domotique nécessitant un pilotage à distance à partir d’un smartphone ou d’une tablette appairé (Android, iOS…) : système d’éclairage, ouverture/fermeture motorisée d’ouvrants, etc.
    Il s’appuie sur le Bluetooth Smart module BLE113 du constructeur Bluegiga.

    Du côté de l’Arduino, aucune bibliothèque supplémentaire n’est à installer puisque la communication s’établit par l’intermédiaire du port série (Rx et Tx). Grâce à un système de cavaliers (jumpers) sur la carte du BLE Shield, vous pouvez choisir entre le port série matériel des connecteurs 0 et 1 de l’Arduino et un port série virtuel configuré au choix parmi les connecteurs D4 à D13. Pour prévenir l’Arduino de la connexion ou déconnexion avec le périphérique Bluetooth, un signal d’interruption est généré et disponible sur un connecteur au choix parmi D2, D3 et D7. La vitesse de transmission est de 9600 bauds par défaut, mais peut être configurée jusqu’à 112500 bauds, la configuration étant mémorisée afin de ne pas avoir à la recommencer à chaque mise en service.
    Une LED bleue (au comportement configurable) indique l’état de connexion du shield. Un bouton latéral sur le bord de la carte, et donc accessible même si vous y empilez un autre shield, permet de faire un Reset du dispositif.

    À noter que la dernière version du shield implémente le service OTA de Bluegiga pour flasher une mise à jour du firmware. Celle-ci peut être réalisée de plusieurs façons : soit avec un CC Debugger via un adaptateur TagConnect à brancher sur le shield, soit en utilisant les outils Bluegiga avec un dongle USB BLED112, ou encore grâce à l’App iOS BLExplr proposée par le concepteur du shield.

    Code de démonstration d’émission/réception Bluetooth (port série virtuel Rx=D8, Tx=D9, état de connexion avec interruption sur D2), d'après https://github.com/michaelkroll/BLE-...oftware_Serial :
    Code c++ : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    /*
    	 * BLE Shield SoftSerial Test Sketch for Arduino 1.0.6
    	 * v3.0.0 2015-02-06
    	 * 
    	 * Copyright (c) 2012-2015 Dr. Michael Kroll
    	 *
    	 * Permission is hereby granted, free of charge, to any person obtaining a copy of this 
    	 * software and associated documentation files (the "Software"), to deal in the Software 
    	 * without restriction, including without limitation the rights to use, copy, modify, merge, 
    	 * publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons 
    	 * to whom the Software is furnished to do so, subject to the following conditions:
    	 *
    	 * The above copyright notice and this permission notice shall be included in all copies or 
    	 * substantial portions of the Software.
    	 *
    	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
    	 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
    	 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
    	 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
    	 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    	 *
    	 * http://www.mkroll.mobi
     
    	 * http://forum.mkroll.mobi
     
    	 */
    	#include <SoftwareSerial.h>
     
     
    	// In order to not interfear with the USB serial console
    	// we configure the BLE-Shields serial lines to be available
    	// through SoftwareSerial on pins D8 and D9. 
    	// Please set the jumpers
    	// to RX -> D8 and TX -> D9
    	SoftwareSerial bleShield(8,9);
    	boolean connected;
     
     
    	void setup()   {
     
     
    	  // On the Arduino Uno, the Serial port is mapped to the USB Cable
    	  // and available in pins D0 D1.
    	  // We set it to 9600 baud.
    	  Serial.begin(9600);
    	  Serial.print("BLE-Shield v3.0.0 Sketch setup...");
     
     
    	  // Set the data rate for the SoftwareSerial port
    	  // The BLE-Shield v3.0.0 is running at 9600 since this
    	  // is the default baudrate for the BLE-Shield v3.0.0 
    	  bleShield.begin(9600);
    	  // The BLE-Shield v3.0.0 is not only litting up the blue LED on connection, 
    	  // but raising and lowering an interrupt on the Arduino.
    	  // Finally you are able to see the connected state on the Arduino :-)
    	  // Here we attach the interrupt according to the spec at   
    	  // http://arduino.cc/en/Reference/attachInterrupt
     
    	  // The interrupt jumper has to be set to D2
    	  attachInterrupt(0, connection, CHANGE);
    	  Serial.println(" done.");
    	  connected = false;
    	}
     
     
     
     
    	void loop() // run over and over
    	{
    	  // Wait for Data on the serial console and submit it to the
    	  // BLE-Shield byte per byte. there is no longer a buffer involved.
    	  if (Serial.available()) {
    	    int ch = Serial.read();
    	    char c = char(ch);
    	    Serial.print(c);
    	    bleShield.print(c);
    	  }
     
    	  // Wait for data send from the iPhone and print it to the serial console.
    	  // That's it. Quite simple.
    	  if (bleShield.available()) {
    	    Serial.write(bleShield.read());
    	  }
    	}
     
     
    	// This method is called if the connection state changes. 
    	// When a connection is established, the Interrupt will be set to high, and
    	// set to low, once the BLE-Shield is disconnected.
    	void connection() {
    	  connected = !connected;
    	  if (connected) {
    	    Serial.println("BLE-Shield Connected = true");
    	  }
    	  else {
    	    Serial.println("BLE-Shield Connected = false");  
    	  }
    	}

  3. #23
    Rédacteur/Modérateur

    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    janvier 2009
    Messages
    9 739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : janvier 2009
    Messages : 9 739
    Points : 37 169
    Points
    37 169
    Billets dans le blog
    9

    Par défaut

    16 channel PWM/Servo Shield

    Comme vous pouvez le voir dans la vidéo de la servo party ci-dessous, ce shield du fabricant Adafruit permet de piloter jusqu’à 16 servomoteurs simultanément en utilisant uniquement deux connecteurs de votre Arduino grâce à la liaison série I2C (sur la Uno, A4=SDA et A5=SCL).


    Rappelons que les servomoteurs, du type de ceux que l’on retrouve en modélisme, sont des motoréducteurs à courant continu équipés en plus d'une boucle d’asservissement en position de l’axe de sortie. Un des trois fils (le fil jaune), en plus de l’alimentation Vcc (fil rouge) et la référence Gnd (fil marron), sert à piloter l’axe de sortie du servomoteur et lui faire prendre la position angulaire souhaitée (entre 0 et 180° en général).
    Le signal de commande est du type PWM (Pulse Width Modulation ou Modulation en Largeur d’Impulsion MLI en français). Le signal doit se répéter typiquement toutes les 20ms et la largeur d’impulsion définit la position angulaire.


    L’Arduino Uno comprend six sorties PWM (connecteurs repérés par un symbole ~) permettant de piloter autant de servomoteurs. Mais si vous souhaitez en piloter davantage pour votre application, préserver les timers du microcontrôleur ATmega pour d’autres usages ou si vous voulez économiser des connecteurs de votre carte, ce shield vous rendra service.
    Soudé sur la carte du shield, un PCA9685 (NXP), un driver I2C 12 bits gérant jusqu’à 16 sorties PWM, conçu à l'origine pour piloter des LED. Six broches (repérées A0 à A5) reliées au choix à l’alimentation ou à la référence Gnd par de simples points de soudure prévus sur le shield permettent de composer l’adresse identifiant le composant sur le bus I2C.

    Nom : fixI2Caddress.JPG
Affichages : 791
Taille : 26,9 Ko
    Doc Adafruit : adresse du composant 0x40 + offset=b00001, soit 0x41

    Ceci permet, par exemple, d’empiler d’autres exemplaires de ce shield configurés chacun à des adresses différentes et ainsi multiplier le nombre de sorties PWM pour piloter simultanément 32, 48, …, 992 (!!?) servomoteurs en théorie.

    Nom : PCA9685.JPG
Affichages : 891
Taille : 33,6 Ko
    Le PCA9685 au cœur du Servo Shield d’Adafruit

    Sur le plan de l’alimentation, si vous pouvez vous contenter de celle fournie par le port USB pour alimenter quelques mini-servomoteurs, le fabricant Adafruit a prévu un connecteur de type bornier à vis pour une alimentation extérieure (jusqu’à 6V maxi) nécessaire en cas d’utilisation de servomoteurs à fort couple et en quantité (voir les caractéristiques de vos servomoteurs, entre autres le courant maximal qu’ils peuvent absorber).

    Comme souvent, Adafruit fournit une bibliothèque logicielle pour exploiter rapidement les fonctionnalités du shield : https://github.com/adafruit/Adafruit...Driver-Library

  4. #24
    Rédacteur/Modérateur

    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    janvier 2009
    Messages
    9 739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : janvier 2009
    Messages : 9 739
    Points : 37 169
    Points
    37 169
    Billets dans le blog
    9

    Par défaut

    Mux Shield

    Si votre carte Arduino ne dispose pas suffisamment d’entrées-sorties numériques ou analogiques pour votre application, le Shield multiplexeur Mux II de Mayhew Labs pourrait vous être utile. Ce shield vous propose 48 entrées/sorties configurables réparties sur trois rangées.

    Nom : Mux2.JPG
Affichages : 786
Taille : 29,2 Ko
    Mux Shield Mayhew Labs : à droite les trois rangées de seize connecteurs I/O 1, I/O 2 et I/O 3

    Chaque rangée de 16 connecteurs peut être configurée par logiciel :
    • en entrée numérique ;
    • en sortie numérique ;
    • en entrée analogique.

    (Les connecteurs d’une même rangée ne peuvent être configurés individuellement. Par exemple, si la première rangée (I/O 1) est configurée en entrée analogique, les seize connecteurs de cette rangée seront des entrées analogiques).

    Pour gérer son fonctionnement, le shield utilise les connecteurs D2, D4, D6 et D7 de l’Arduino, les entrées analogiques A0, A1 et A2. Les connecteurs D8, D10, D11 et D12 sont également concernés, mais peuvent être libérés si vous décidez de configurer chaque rangée de façon matérielle avec quelques points de soudure sur les jumpers au dos de la carte.

    Le Mux Shield utilise une combinaison de multiplexeurs analogiques 74HC4067, de registres à décalage 74HC595 et de signaux de contrôle pour fonctionner. Si une rangée de 16 connecteurs est configurée en entrée, c’est le multiplexeur qui est activé, tandis que les registres à décalage sont désactivés.
    Et inversement, ce sont les deux registres à décalage chaînés qui sont activés si la rangée est configurée en sortie tandis que le multiplexeur est désactivé.

    Nom : SchematicMuxii.JPG
Affichages : 903
Taille : 55,3 Ko
    Extrait du schéma du Mux Shield

    Pour les utilisateurs pressés, Mayhew Labs fournit une bibliothèque prête à l’emploi.
    Exemple d’utilisation du Mux Shield d’après Mux Shield Library for Arduino (includes examples) :

    Code c++ : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    /*This example shows how to use the Mux Shield for a combination of 
    analog inputs, digital inputs, and digital outputs.
    */
    #include <MuxShield.h>
     
    //Initialize the Mux Shield
    MuxShield muxShield;
     
    void setup()
    {
      muxShield.setMode(1,DIGITAL_IN_PULLUP);  //set I/O 1 as digital in with pullup
      muxShield.setMode(2,DIGITAL_OUT);        //set I/O 2 as digital output
      muxShield.setMode(3,ANALOG_IN);          //set I/O 3 as analog input
     
      Serial.begin(28800);
    }
    //Arrays to store input values
    int digital1, digital2;
    int analog1, analog2;
     
    void loop()
    {
      //Sample a few inputs from IO1
      digital1 = muxShield.digitalReadMS(1,0);  //IO1, pin 0
      digital2 = muxShield.digitalReadMS(1,1);  //IO1, pin 1
     
      //Set a few outputs on IO2
      muxShield.digitalWriteMS(2,2,HIGH);  //IO2, pin 2
      muxShield.digitalWriteMS(2,3,HIGH);  //IO2, pin 3
     
      //Read analog inputs on IO3
      analog1 = muxShield.analogReadMS(3,14);  //IO3, pin 14
      analog2 = muxShield.analogReadMS(3,15);  //IO1, pin 15
     
      //Print the results
      Serial.print("digital1: ");Serial.print(digital1);Serial.print('\t');
      Serial.print("digital2: ");Serial.print(digital2);Serial.print('\t');
      Serial.print("analog1: ");Serial.print(analog1);Serial.print('\t');
      Serial.print("analog2: ");Serial.print(analog2);Serial.println();
     
    }

  5. #25
    Membre actif

    Homme Profil pro
    Développeur Web
    Inscrit en
    octobre 2013
    Messages
    92
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Pérou

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : octobre 2013
    Messages : 92
    Points : 202
    Points
    202

    Par défaut

    Citation Envoyé par f-leb Voir le message
    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.).
    Attention : la fragilité de ces cartes en papier imprégné (?) peut ruiner de nombreuses heures de travail ! Vécu pour vous : il y a maintenant fort longtemps, j'ai (sur ?)peuplé une de ces cartes (format européen). Une fois bien remplie, elle s'est brisée au moment de l'insertion et tout le travail a été perdu.

Discussions similaires

  1. Réponses: 26
    Dernier message: 20/06/2013, 09h27
  2. Propriétés des cartes réseau
    Par Yodagobah dans le forum MFC
    Réponses: 2
    Dernier message: 05/01/2005, 13h55
  3. Modifier l'ordre des cartes son
    Par YéTeeh dans le forum Matériel
    Réponses: 3
    Dernier message: 19/08/2003, 01h13

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo