[BIBLIOTHEQUE] Serial Peripheral Interface

Une liaison SPI (pour Serial Peripheral Interface) est un bus de données série synchrone baptisé ainsi par Motorola, et qui opère en Full-duplex. Les circuits communiquent selon un schéma maître-esclaves, où le maître s'occupe totalement de la communication. Plusieurs esclaves peuvent coexister sur un bus, la sélection du destinataire se fait par une ligne dédiée entre le maître et l'esclave appelée chip select.

Le bus SPI contient 4 signaux logiques

• SCLK — Horloge (généré par le maître)
• MOSI — Master Output, Slave Input (généré par le maître)
• MISO — Master Input, Slave Output (généré par l'esclave)
• SS — Slave Select, Actif à l'état bas, (généré par le maître)

Il existe d'autres noms qui sont souvent utilisés.

• SCK — Horloge (généré par le maître)
• SDI,DI,SI — Serial Data IN
• SDO,DO,SO — Serial Data OUT
• nCS, CS, nSS, STE — SS

Dans le cas de la convention de nommage SDI/SDO, le SDO du maître doit-être relié au SDI de l'esclave et vice versa. Pour éviter les confusions au moment du câblage, il est donc souvent recommandé d'utiliser les dénominations MISO-MOSI qui évitent une certaine ambiguïté.

Fonctionnement

Une transmission SPI typique est une communication simultanée entre un maître et un esclave.

• Le maître génère l'horloge et sélectionne l'esclave avec qui il veut communiquer
• L'esclave répond aux requêtes du maître

À chaque coup d'horloge le maître et l'esclave s'échangent un bit. Après huit coups d'horloges le maître a transmis un octet à l'esclave et vice versa. La vitesse de l'horloge est réglée selon des caractéristiques propres aux périphériques.

Polarité et phase de l'horloge

La configuration de la SPI est souvent nommée dans les documentations techniques sous forme de nombre ou de couple, où le bit de poids fort est CPOL (Clock Polarity) et le bit de poids faible CPHA (Clock Phase)

Mode	CPOL	CPHA
0 (0,0)	0	0
1 (0,1)	0	1
2 (1,0)	1	0
3 (1,1)	1	1

Les modes 0 et 3 sont identiques en transmission, seul change l'état de la ligne d'horloge au repos. C'est pour cette raison que de nombreux périphériques peuvent être capables de dialoguer soit en mode 0 et 3, soit en mode 1 et 2.

[BIBLIOTHEQUE] SPI

Cette bibliothèque vous permet de communiquer avec des périphériques SPI, avec l’Arduino comme l’appareil maître.

UNE BRÈVE INTRODUCTION À L’INTERFACE PÉRIPHÉRIQUE SÉRIE (SPI)

Serial Peripheral Interface (SPI) est un protocole de données série synchrone utilisé par les microcontrôleurs pour communiquer avec un ou plusieurs dispositifs périphériques rapidement sur de courtes distances. Il peut également être utilisé pour la communication entre deux microcontrôleurs.

Avec une connexion SPI il ya toujours un dispositif maître (généralement un microcontrôleur) qui contrôle les périphériques. Généralement, il ya trois lignes communes à tous les appareils:

• MISO (Master à Slave Out) – La ligne de l’esclave pour l’envoi de données vers le maître,
• MOSI (Master Out Slave In) – La ligne principal pour l’envoi de données vers les périphériques,
• SCK (Serial Clock) – Les impulsions d’horloge qui synchronisent transmission de données généré par le maître

et une ligne spécifique pour chaque appareil:

• SS (Slave Select) – la broche sur chaque appareil que le maître peut utiliser pour activer et désactiver des appareils spécifiques.

Lorsque l’esclave choisi la broche d’un appareil faible, il communique avec le maître. Quand il est élevé, il ne tient pas compte du maître. Cela vous permet d’avoir plusieurs périphériques SPI partageant la même MISO, MOSI, et les lignes CLK.

Pour écrire du code pour un nouveau dispositif SPI vous devez noter quelques petites choses:

• Est-données décalées dans le bit le plus significatif (MSB) ou Least Significant Bit (LSB) en premier? Ceci est contrôlé par l’SPI.setBitOrder de fonction ().
• Est l’horloge de données au ralenti lorsque haute ou basse? Sont des échantillons sur le front montant ou descendant d’impulsions d’horloge?Ces modes sont commandés par le SPI.setDataMode () fonction.
• Quel est le débit SPI cadencé à? Ceci est contrôlé par l’SPI.setClockDivider () fonction.

La norme SPI est lâche et chaque dispositif met en oeuvre un peu différemment. Cela signifie que vous devez porter une attention particulière à la fiche technique de l’appareil lorsque vous écrivez votre code.

D’une manière générale, il existe quatre modes de transmission. Ces modes de contrôle si les données sont transférées à l’intérieur et sur ​​le front montant ou descendant du signal d’horloge de données (appelée l’horloge de phase ), et si l’horloge est inactive lorsque haute ou basse (appelé l’horloge polarité ). Les quatre modes se combinent polarité et de phase selon ce tableau:

Mode	Polarité de l’horloge (CPOL)	Phase de l’horloge (ACSP)
SPI_MODE0	0	0
SPI_MODE1	0	1
SPI_MODE2	1	0
SPI_MODE3	1	1

Le SPI.setDataMode () fonction vous permet de définir le mode de contrôle de polarité de l’horloge et la phase.

Chaque dispositif SPI a une vitesse maximale autorisée pour les bus SPI.Le SPI.setClockDivider () vous permet de modifier la vitesse d’horloge de rendre votre appareil fonctionne correctement (par défaut 4 MHz).

Une fois que vous avez vos paramètres SPI définies correctement vous avez juste besoin de comprendre qui s’enregistre dans le contrôle de votre appareil qui fonctionne, et vous êtes bon pour aller. Cela sera expliqué dans la fiche de données de votre appareil.

Pour en savoir plus sur SPI, voir la page de Wikipedia sur SPI .

LIENS

L’affichage du tableau suivant sur lequel les lignes broches SPI sont réparties sur les différentes cartes Arduino:

Arduino	MOSI	MISO	SCK	SS (esclave)	SS (maître)
Uno ou Duemilanove	11 ou ICSP-4	12 ou ICSP-1	13 ou ICSP-3	10	-
Mega1280 ou Mega2560	51 ou ICSP-4	50 ou ICSP-1	52 ou ICSP-3	53	-
Leonardo	ICSP-4	ICSP-1	ICSP-3	-	-
En raison	ICSP-4	ICSP-1	ICSP-3	-	4, 10, 52

Notez que MISO, MOSI et SCK sont disponibles dans un emplacement physique cohérente sur l’embase ICSP, ce qui est utile, par exemple, dans la conception d’un bouclier qui fonctionne sur chaque bord.

REMARQUE SUR SLAVE SÉLECTIONNEZ LE CODE PIN (SS) SUR LES PANNEAUX À BASE AVR

Toutes les cartes à base d’AVR ont une broche SS qui est utile quand ils agissent comme un esclave commandé par un maître externe. Depuis cette bibliothèque prend en charge que le mode maître, cet axe doit être réglé toujours aussi SORTIE sinon l’interface SPI pourrait être mis automatiquement en mode esclave par le matériel, ce qui rend la bibliothèque inopérant.

Il est cependant possible d’utiliser n’importe quelle broche que la sélection d’esclave (SS) pour les dispositifs. Par exemple, le bouclier Ethernet Arduino utilise la broche 4 à contrôler la connexion SPI sur la carte SD à bord, et la broche 10 pour contrôler la connexion au contrôleur Ethernet.

FONCTIONNALITÉ SPI ÉTENDUE POUR LA RAISON

L’interface SPI de l’Arduino Due fonctionne différemment que les autres cartes Arduino. La bibliothèque peut être utilisé sur la raison avec les mêmes méthodes disponibles pour d’autres cartes Arduino ou en utilisant les méthodes prolongées . Les méthodes de longues exploite le leSAM3X matériel et permet quelques fonctions intéressantes comme:

• la gestion automatique de la sélection de l’esclave du dispositif.
• gestion automatique des configurations de périphériques différents (vitesse d’horloge, le mode de données, etc) de sorte que chaque dispositif peut avoir sa propre configuration sélectionnée automatiquement.

Arduino a fait trois broches exposées pour les dispositifs sélection d’esclave (SS) lignes (broches 4, 10 et 52).

[TUTO] Un bouton poussoir en minuteur

Le Matériel:

• une plaque d'essai pour montage sans soudures,

• des straps,

• une LED rouge 5mm,

• une résistance 1/4w de 200 Ohms environ,

• un bouton poussoir pour CI,

Le Code:

___________________________________________________________________

// --- Déclaration des constantes utiles ---
const int APPUI=LOW; // constante pour tester état BP

// --- Déclaration des constantes des broches E/S numériques ---

const int BP=2; // Constante pour la broche 2
const int LED=3; // Constante pour la broche 3

// --- Déclaration des constantes des broches analogiques ---


// --- Déclaration des variables globales ---



// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---


// ////////////////////////// 2. FONCTION SETUP = Code d'initialisation ////////////////////////// 
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- 

// ------- Initialisation fonctionnalités utilisées -------  


// ------- Broches en sorties numériques -------  
 pinMode (LED,OUTPUT); // Broche LED configurée en sortie

// ------- Broches en entrées numériques -------  
 pinMode (BP,INPUT); // Broche BP configurée en entrée

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  
 digitalWrite (BP,HIGH); // Rappel au + activé sur la broche BP configurée en entrée

// ------- Initialisation des variables utilisées -------  

// ----- LED éteinte au début
digitalWrite (LED,LOW); // éteint la LED

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()


// --- ici instructions à exécuter par le programme principal --- 

if (digitalRead(BP)==APPUI) { // si le BP est appuyé

   digitalWrite(LED,HIGH); //allume la LED
   delay (5000); // attend 5 secondes - le BP est inactif pendant ce temps
   digitalWrite (LED,LOW); // éteint la LED

} // fin si BP appuyé


} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

___________________________________________________________________

[TUTO] Un BP en inverseur

Nécessaire:

-une plaque d'essai pour montage sans soudures,
-des straps,
-une LED rouge 5mm,
-une résistance 1/4w de 200 Ohms environ,
-un bouton poussoir pour CI,

Le Schéma:

Le Code:

_________________________________________________________________________

// /////////////////////////////// 1. Entête déclarative /////////////////////// 

// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

// --- Déclaration des constantes utiles ---

const int APPUI=LOW; // constante pour tester état BP

// --- Déclaration des constantes des broches E/S numériques ---

const int BP=2; // Constante pour la broche 2

const int LED=3; // Constante pour la broche 3

// --- Déclaration des constantes des broches analogiques ---

// --- Déclaration des variables globales ---

int etatLED=0; // variable d'état de la LED

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

// ////////////////////////// 2. FONCTION SETUP = Code d'initialisation ////////////////////////// 

// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- 

// ------- Initialisation fonctionnalités utilisées -------  

// ------- Broches en sorties numériques -------  

 pinMode (LED,OUTPUT); // Broche LED configurée en sortie

// ------- Broches en entrées numériques -------  

 pinMode (BP,INPUT); // Broche BP configurée en entrée

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

 digitalWrite (BP,HIGH); // Rappel au + activé sur la broche BP configurée en entrée

// ------- Initialisation des variables utilisées -------  

} // fin de la fonction setup()

// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////

// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()

if (digitalRead(BP)==APPUI) { // si appui sur le BP

  if (etatLED==0) etatLED=1; else etatLED=0; // inverse la variable etatLED

  delay(250); // pause anti-rebond

}

// met la LED dans l'état de la variable etatLED

if (etatLED==1) { // si la variable vaut 1

  digitalWrite(LED,HIGH); // la LED est allumée

}

else { // sinon, càd si la variable vaut 0

  digitalWrite(LED,LOW); // la LED est éteinte

 }

// --- ici instructions à exécuter par le programme principal --- 

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin

________________________________________________________________________

[WIKI] Arduino

Arduino est un circuit imprimé en matériel libre (dont les plans de la carte elle-même sont publiés en licence libre mais dont certains composants sur la carte, comme le microcontrôleur par exemple, ne sont pas en licence libre) sur lequel se trouve un microcontrôleur qui peut être programmé pour analyser et produire des signaux électriques, de manière à effectuer des tâches très diverses comme la domotique (le contrôle des appareils domestiques - éclairage, chauffage…), le pilotage d'unrobot, etc. C'est une plateforme basée sur une interface entrée/sortie simple. Il était destiné à l'origine principalement mais pas exclusivement à la programmation multimédia interactive en vue de spectacle ou d'animations artistiques. C'est une partie de l'explication de la descendance de son interface de programmation de Processing, lui-même inspiré de l'environnement de programmation Wiring1.

Arduino peut être utilisé pour construire des objets interactifs indépendants (prototypage rapide), ou bien peut être connecté à un ordinateur pour communiquer avec ses logiciels (ex. : Macromedia Flash, Processing, Max/MSP, Pure Data,SuperCollider). En 2011, les versions vendues sont pré-assemblées. Des informations sont fournies pour ceux qui souhaitent assembler l'Arduino eux-mêmes.

Le projet Arduino a reçu un titre honorifique à l'Ars Electronica 2006, dans la catégorie Digital Communities.

Matériel

Un module Arduino est généralement construit autour d'un microcontrôleur Atmel AVR (ATmega328 ou ATmega2560 pour les versions récentes, ATmega168 ou ATmega8 pour les plus anciennes), et de composants complémentaires qui facilitent la programmation et l'interfaçage avec d'autres circuits. Chaque module possède au moins un régulateur linéaire5V et un oscillateur à quartz 16 MHz (ou un résonateur céramique dans certains modèles).

Le microcontrôleur est pré-programmé avec un bootloader de façon à ce qu'un programmateur dédié ne soit pas nécessaire.

Les modules sont programmés au travers d'une connexion série RS-232, mais les connexions permettant cette programmation diffèrent selon les modèles. Les premiers Arduino possédaient un port série, puis l'USB est apparu sur les modèles Diecimila, tandis que certains modules destinés à une utilisation portable se sont affranchis de l'interface de programmation, relocalisée sur un module USB-série dédié (sous forme de carte ou de câble).

L'Arduino utilise la plupart des entrées/sorties du microcontrôleur pour l'interfaçage avec les autres circuits. Le modèle Diecimila par exemple, possède 14 entrées/sorties numériques, dont 6 peuvent produire des signaux PWM, et 6 entrées analogiques. Les connexions sont établies au travers de connecteurs femelle HE14 situés sur le dessus de la carte, les modules d'extension venant s'empiler sur l'Arduino. Plusieurs sortes d'extensions sont disponibles dans le commerce.

Les modules non officiels « BoArduino » et « Barebones », compatibles avec la technologie Arduino, utilisent des connecteurs mâle pour une utilisation aisée avec des plaques de test.

Logiciel

Le logiciel de programmation des modules Arduino est une application Java, libre et multi-plateformes, servant d'éditeur de code et de compilateur, et qui peut transférer le firmwareet le programme au travers de la liaison série (RS-232, Bluetooth ou USB selon le module). Il est également possible de se passer de l'interface Arduino, et de compiler les programmes via l'interface en ligne de commande2.

Le langage de programmation utilisé est le C++, compilé avec avr-g++ 3, et lié à la bibliothèque de développement Arduino, permettant l'utilisation de la carte et de ses entrées/sorties. La mise en place de ce langage standard rend aisé le développement de programmes sur les plates-formes Arduino, à toute personne maîtrisant le C ou le C++.

Plateforme

Matériel officiel

Les modules d'origine des différentes versions de l'Arduino sont fabriqués par la société italienne Smart Projects. Quelques-unes des cartes de marque Arduino ont été conçues par la société américaine SparkFun Electronics.

Treize versions des cartes de type Arduino ont été produites et vendues dans le commerce à ce jour dans l'ordre chronologique ci-dessous :

1. Serial Arduino programmé avec une connexion série par connecteur DB9 et utilisant un ATmega8.
2. Arduino Extreme, programmable via une connexion USB et utilisant un ATmega8.
3. Arduino Mini, une version miniature de l'Arduino utilisant un ATmega168 de type CMS.
4. Arduino Nano, une version encore plus petite de l'Arduino alimenté par USB et utilisant un ATmega168 de type CMS(Atmega328 pour la nouvelle version).
5. LilyPad Arduino, une conception de type minimaliste pour permettre une application portable utilisant un ATmega168 de type CMS.
6. Arduino NG, programmable via une connexion USB et utilisant un ATmega8.
7. Arduino NG plus, programmable via une connexion USB et utilisant un ATmega168.
8. Arduino Bluetooth(BT), programmable via une connexion Bluetooth et utilisant un ATmega168.
9. Arduino Diecimila, possède une interface USB et utilise un ATmega168 dans un boitier format DIL28. (16 ko flash, 1 ko SRAM, 0,5 ko EEPROM)
10. Arduino Duemilanove (2009) utilise un Atmega168 et est alimenté en électricité par le connecteur USB ou une alimentation externe avec commutation automatique4. La nouvelle version5 est équipé d'un ATmega328 (32 ko de flash, 2 ko de SRAM, et 1 ko d'EEPROM).
11. Arduino Mega est équipé d'un ATmega1280 de type CMS pour avoir des Entrées/Sorties supplémentaires et de la mémoire (128 ko flash, 8 ko SRAM, 4 ko EEPROM)6.
12. Arduino Uno utilise un ATmega328 comme les derniers modèles de Duemilanove, mais alors que le Duemilanove utilisait une puce FTDI pour la programmation via un connecteur USB, le Uno utilise une puce ATmega8U2 programmé comme un convertisseur série7.
13. Arduino Mega2560 est équipé d'un ATmega2560 de type CMS, augmentant la mémoire totale disponible à 256 ko. Il est équipé aussi de la nouvelle puce USB ATmega8U28.
14. Arduino Ethernet est une carte Arduino UNO intégrant un chip Wiznet W5100 pour rajouter la connectivité Ethernet intégré9.
15. Arduino Leonardo est une version bas coût de l'Arduino UNO à base d'un ATmega32U4.
16. Arduino DUE est une évolution de l'Arduino Mega2560 avec un micro-contrôleur 32 bits Atmel SAM3X (ARM 32 bits Cortex-M3).
17. Arduino Esplora est une carte dérivée de l'Arduino Leonardo. Elle a la forme d'une Manette de jeu. Contrairement aux autres Arduino, c'est une carte "tout-en-un" qui comporte de nombreux capteurs (température, accélération, lumière, microphone, potentiomètre, ...) ainsi que 4 boutons poussoirs et un Joystick analogique.

Arduino	Processeur	Flash ko	EEPROM ko	SRAM ko	Broches d'E/S numériques	...avec PWM	Broches d'entrée analogique	Type d'interface USB	Dimensions pouces	Dimensions mm
Diecimila	ATmega168	16	0,5	1	14	6	6	FTDI	2,7" x 2,1"	68,6 mm x53,3 mm
Duemilanove	ATmega168/328P	16/32	0,5/1	1/2	14	6	6	FTDI	2,7" x 2,1"	68,6 mm x53,3 mm
Uno	ATmega328P	32	1	2	14	6	6	ATmega8U2	2,7" x 2,1"	68,6 mm x53,3 mm
Leonardo	ATmega32U4	32	1	2,5	20	7	12	ATmega32U4	2,7" x 2,1"	68,6 mm x53,3 mm
Mega	ATmega1280	128	4	8	54	15	16	FTDI	4" x 2,1"	101,6 mm x53,3 mm
Mega2560	ATmega2560	256	4	8	54	15	16	ATmega8U2	4" x 2,1"	101,6 mm x53,3 mm
Due	Atmel SAM3X8E	512	0	96	54	12	12	SAM3X8E (USB Host), ATmega16u2 (programmation)	4" x 2,1"	101,6 mm x53,3 mm
Fio	ATmega328P	32	1	2	14	6	8	None	1,6" x 1,1"	40,6 mm x27,9 mm
Nano	ATmega168 or ATmega328	16/32	0,5/1	1/2	14	6	8	FTDI	1,70" x 0,73"	43 mm x18 mm
LilyPad	ATmega168V or ATmega328V	16	0,5	1	14	6	6	None	2" ø	50 mm ø
Esplora	ATmega32U4	32	1	2,5	N/A	N/A	N/A	ATmega32U4	6,5" x 2,4"	165,1 mm x60,96 mm

Matériels et logiciels dérivés

Plusieurs logiciels et matériels compatibles Arduino (bien que non officiels) ont été produits commercialement par d'autres fabricants :

• Les kits Freeduino Bare Bones Board et Really Bare Bones Board compatibles Arduino, fabriqués et vendus par Modern Device Company.
• Le Freeduino Through-Hole, compatible Arduino, module évitant l'utilisation de composants CMS et destiné à une fabrication personnelle ; fabriqué et vendu par NKC Electronics (sous forme de kit).
• Le Boarduino, un clone peu cher du Diecimila, avec des connecteurs pour une utilisation sur plaque de test.
• Le Romeo, variation de l'Arduino Uno dédiée à la robotique, fournit des interfaces de puissance pour contrôler des moteurs. Le Romeo est édité par DFRobot.
• Des versions « Fundamental Logic » ^{(Archive • Wikiwix • Que faire ?)}. Consulté le 20130318 en kit ou montées, le « MaxSerial Freeduino » ^{(Archive • Wikiwix • Que faire ?)}. Consulté le 20130318 compatible Arduino Diecimila, interface RS-232, alimentation 3.3V optionnelle sur la carte ; et le mini « iDuino » ^{(Archive • Wikiwix • Que faire ?)}. Consulté le 20130318 pour une utilisation sur plaque de test.

Plusieurs logiciels compatibles Arduino (bien que non officiels) ont été développés pour faciliter la programmation des cartes Arduino. Bien que très différents les uns des autres, ils permettent une programmation sans utilisation du langage Arduino. On retrouve :

• La solution graphique Ardublock qui permet une programmation par assemblage de blocs fonctionnels. C’est un plug-in qui ajoute une interface graphique à celle d’Arduino.
• La solution graphique MiniBloq qui permet elle aussi une programmation par assemblage de blocs fonctionnels. C’est un plug-in qui ajoute une interface graphique à celle d’Arduino.

• Le pseudo-langage EDU qui permet une programmation avec un ensemble de mots clés simplifiés. C’est une librairie qui permet l'écriture d’un programme en français directement dans l'interface Arduino.

Matériel libre et logiciel libre

Le design matériel de l'Arduino est distribué sous licence Creative Commons Attribution Share-Alike 2.5 et est disponible sur le site d'Arduino. Les schémas ainsi que les typonsde circuits sont également disponibles. Le code source de l'environnement de programmation et les bibliothèques embarquées sont disponibles sous licence LGPL.

Restrictions du nom Arduino

Bien que le design matériel et logiciel soit sous licence copyleft, les développeurs ont exprimé le désir que le nom Arduino et ses dérivés soient exclusivement réservés aux modules officiels, et qu'ils ne soient pas utilisés pour des projets non autorisés. La politique d'usage du nom Arduino insiste sur le fait que les projets officiels sont ouverts à la collaboration10.

En réponse à cette restriction, des utilisateurs ont développé une cinquantaine de modules équivalents, nommés Freeduino, Sanguino, Seeduino, Uduino, Diduino, etc11. Ces modules, totalement compatibles avec le logiciel Arduino, et parfois avec les blasons12 Arduino, sont généralement moins chers^{[réf. souhaitée]} que les cartes Arduino originales. La plupart offrent également des fonctions additionnelles.
On trouve par ailleurs des contrefaçons, ornées de sérigraphies qui mentent sur l'identité du constructeur et sur le lieu de fabrication, et qui se reconnaissent notamment à leur prix nettement inférieur à celui des cartes "officielles".

L'équipe de développement

Le cœur de l'équipe des développeurs du projet Arduino est composé de Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis et Nicholas Zambetti.