mercredi 31 juillet 2013

[INFORMATIQUE] Ipadian ! Tester l'interface de l'ipad !


iPadian est un projet très intéressant, offert en collaboration avec Apple, ce qui nous permet de transformer nos PC de bureau en un véritable écran de l'iPad en quelques clics. Il s'agit d'un logiciel très léger (seulement 35 Mo) qui est facile à installer et à personnaliser rapidement vous permettant de définir l'image d'arrière-plan et n'importe quelle application qui leur donne envie réellement d'atteindre clic, l'écran de la tablette d'Apple sont à votre portée. Nous pouvons, par exemple, choisir d'afficher des notifications de bureau avec Google email ou mises à jour de Facebook et Twitter, ajouter app comme les nouvelles, la météo ou la photo du jour et télécharger n'importe quel type d'application App Store d'opposition. Toute personne qui veut commencer à toucher l'univers iPad ne peut pas essayer iPadian même pour quelques heures. 



► Configuration requise: 
Configuration requise: Processeur: Pentium 1,0 GHz 3/Athlon 
OS: Windows XP/Vista/7/8 
mémoire: 1GBi RAM 
vidéo Carte: carte vidéo 512 Mo avec prise en charge de Pixel Shader. NVIDIA Ge force 3/ATI Rad-eon 8500 ou supérieur 
Autres: 260Mo d'espace disque dur, 8x CD-ROM ou DVD-ROM 2x dur

► Instruction d'installation:

1. Extraire le fichier avec Winrar ou 7zip. 
-2. Exécutez le iPadian.exe. 
-3. Enjoy ..!


http://uploaded.net/file/7fcj090v/iPadian+%255B2012ENG%255D.rar




mercredi 24 juillet 2013

[BIBLIOTHEQUE] IrRemote

IrRemote, par Ken Shirriff , vous permet de recevoir ou transmettre des codes de télécommande infrarouge. Vous pouvez faire vos projets Contrôlé par une télécommande, ou de les faire contrôler d'autres appareils comme les téléviseurs et composants stéréo.
Télécharger : IRremote.zip (modifié pour fonctionner sur des planches Teensy et autres)

Configuration matérielle requise

Pour la transmission, une seule LED infrarouge et la résistance sont nécessaires. Pour la réception, d'un module récepteur IR avec filtre passe-bande interne est nécessaire.
TODO: Ajoutez les références des réputés bons voyants et récepteurs infrarouges. Le voyant cette photo est Lumex OED-EL-8L (Digikey 67-1000-ND) et le récepteur est probablement GP1UD281YK0F Forte (maintenant discontinué, Digikey 425-1987-ND).

TODO: Test Vishay récepteur TSOP39338 (Digikey 751-1390-5-ND). Il est très probable à travailler. Mettre à jour cette photo. Peut-être PJRC devrait vendre une autre en bon LED & paire de récepteur?


Pour la transmission, vous devez connecter le LED à une broche spécifique. La sortie du récepteur peut être connecté à n'importe quel axe.

ConseilRecevez
Pin
Transmettre
Pin
Minuterie
Utilisé
PWM Pins
handicapés
Teensy 3.0Tout5CMTAucun
Teensy 2.0Tout10412
Teensy 1.0Tout17115, 18
Teensy + + 2.0Tout120
Teensy + + 1.0Tout120


Utilisation de base

IrRemote agit comme 2 bibliothèques, l'une pour l'émission et l'autre pour recevoir. Habituellement, il est plus facile de trouver les codes pour transmettre en utilisant d'abord le récepteur.

Recevoir

IRrecv irrecv (receivePin)
Créer l'objet récepteur, en utilisant un nom de votre choix.
irrecv. enableIRIn ()
Commencez le processus de réception. Cela permettra à l'interruption de l'horloge qui consomme une petite quantité de CPU toutes les 50 ms.
irrecv. décodage (et résultats)
Essayez de recevoir un code IR. Retourne true si un code a été reçue, ou false si rien reçu encore. Lorsqu'un code est reçu, l'information est stockée dans "Résultats".
results.decode_type : sera l'un des éléments suivants: NEC , Sony , RC5 , RC6 , ou UNKNOWN . results.value : Le code IR réelle (0 si le type est inconnu) results.bits : Le nombre de bits utilisés par le présent code résultats . rawbuf : Un tableau d'IR impulsion fois results.rawlen : Le nombre d'éléments stockés dans le tableau



irrecv. reprendre ()
Après avoir reçu, ce doit être appelée pour réinitialiser le récepteur et de le préparer à recevoir un autre code.
irrecv. blink13 ( vrai )
Activer le clignotement du voyant lorsque le cours de la réception. Parce que vous ne pouvez pas voir la lumière infrarouge, clignotant de la LED peut être utile lors du dépannage, ou tout simplement de donner une rétroaction visuelle.

Transmettre

IRsend irsend;
Créez l'objet de transmission. Un certain nombre d'axe fixe est toujours utilisée, selon le timer de la bibliothèque est l'utilisation.
. irsend sendNEC (IRcode, nombrebits);
Envoyer un code au format NEC.
. irsend sendSony (IRcode, nombrebits);
Envoyer un code au format Sony.
. irsend sendRC5 (IRcode, nombrebits);
Envoyer un code au format RC5.
. irsend sendRC6 (IRcode, nombrebits);
Envoyer un code dans RC6
. irsend SendRaw (rawbuf, rawlen, fréquence);


Envoyer un code brut. Normalement, vous devriez obtenir le contenu du rawbuf et rawlen en utilisant le récepteur de nombreuses fois et la moyenne des résultats. Certains ajustements peuvent être nécessaires pour une meilleure performance. La fréquence est la fréquence du filtre passe-bande attendue au niveau du récepteur, où 38 est le plus couramment utilisé.

Exemple de programme - Recevoir




# Include <IRremote.h>

const  int RECV_PIN = 6;

IRrecv irrecv (RECV_PIN);

decode_results résultats;

vide  setup ()
{
  Série . commencer (9600);
  . irrecv enableIRIn (); / / démarrer le récepteur 
  . irrecv blink13 ( vrai );
}

vide  boucle () {
   si (irrecv. décodage (et résultats)) {
     si (results.decode_type == NEC ) {
       série . print ( "NEC:" );
    }  d'autre  si (results.decode_type == SONY ) {
       série . print ( "SONY:" );
    }  d'autre  si (results.decode_type == RC5 ) {
       série . impression ( "RC5:" );
    }  d'autre  si (results.decode_type == RC6 ) {
       série . print ( "RC6:" );
    }  d'autre  si (results.decode_type == UNKNOWN ) {
       série . print ( "Unknown:" );
    }
    Série . println (results.value, HEX );
    . irrecv reprendre (); / / recevoir la valeur suivante
  }
}

Exemple de programme - Transmettre

# Include <IRremote.h>

IRsend irsend;

vide  setup () {
}

vide  boucle () {
    . irsend sendSony (0x68B92, 20);
     retard (100);
    . irsend sendSony (0x68B92, 20);
     retard (100);
    . irsend sendSony (0x68B92, 20);
     retard (300000);
}

Utilisation de la minuterie

IrRemote nécessite une minuterie pour l'émission et la réception. Si vous souhaitez utiliser une autre bibliothèque qui exige le même délai, vous pouvez modifier IRremoteInt.h faire irRemote utiliser un minuteur différent.







mardi 23 juillet 2013

[UTILE] : Des diagrammes de Pinout pour Arduino et ATMega

Arduino UNO Pinout

Arduino uno Pinout Web 600x424 Pratique : Des diagrammes de Pinout pour Arduino et ATMega




ATMega328 Pinout

arduino atmega328 Web 600x424 Pratique : Des diagrammes de Pinout pour Arduino et ATMega



ATMega328 Pinout en package QTFP

atmega328 qtfp web 600x424 Pratique : Des diagrammes de Pinout pour Arduino et ATMega




ATtiny Pinout

attiny web 600x424 Pratique : Des diagrammes de Pinout pour Arduino et ATMega



ATMega1284 Pinout

atmega1284p 600x424 Pratique : Des diagrammes de Pinout pour Arduino et ATMega






ATMega644 Pinout

atmega644p 600x424 Pratique : Des diagrammes de Pinout pour Arduino et ATMega




Arduino UNO Pinout à l’échelle 1:1

Ce diagramme de pinout est surement le plus intéressant car il va permettre de l’imprimer et de le positionner directement sous la carte Arduino UNO.

Arduino Pinout web 600x424 Pratique : Des diagrammes de Pinout pour Arduino et ATMega









[NOUVEAUTE] Arduino GSM Shield : Un nouveau shield officiel pour rendre mobile votre carte Arduino

L’équipe Arduino vient de lancer la commercialisation de leur nouveau shield GSM. Ce dernier, développé en partenariat avec Telefónica Digital,va vous permettre d’utiliser une connexion téléphonique mobile pour réaliser de l’échange de données.

Avec l’Arduino GSM Shield, il sera donc possible de relier votre carte Arduino à Internet en utilisant une connexion GPRS, mais vous pourrez aussi bénéficier de la connexion GSM classique pour réaliser et recevoir des appels vocaux ou encore envoyer et recevoir des SMS.

arduino gsm shield un nouveau shield officiel pour rendre mobile votre carte arduino 01 600x318 Arduino GSM Shield : Un nouveau shield officiel pour rendre mobile votre carte Arduino

Le shield est basé sur un modem radio M10 de chez Quectel, c’est un modem quadribande GSM/GPRS qui travaille sur les fréquences GSM850MHz, GSM900MHz, DCS1800MHz et PCS1900MHz. Il est interfacé grâce à une liaison série classique à l’aide de commandes AT.

Il sera possible d’utiliser le protocole TCP/UDP et HTTP à travers la connexion GPRS dont la limitation viendra principalement du débit avec un transfert max à 85.6 kps.

arduino gsm shield un nouveau shield officiel pour rendre mobile votre carte arduino 021 600x279 Arduino GSM Shield : Un nouveau shield officiel pour rendre mobile votre carte Arduino

On remarquera que la carte dispose d’une connectique Arduino Rev3 ( pinout 1.0 ) comme sur une UNO mais le format est plus celui d’une carte MEGA.

arduino gsm shield un nouveau shield officiel pour rendre mobile votre carte arduino 03 600x295 Arduino GSM Shield : Un nouveau shield officiel pour rendre mobile votre carte Arduino






Le shield dispose également d’une antenne intégrée et d’un support pour la carte SIM. Une carte SIM Telefónica sera fournie avec le shield, elle permettra une connexion de donnée dans la plupart des pays avec un forfait dédié BlueVia :

10€ pour 10 MB de données valable 6 mois
15€ pour 20 mB de données valable 12 mois
Cela reste un peu cher, mais c’est sans engagement et dans tous les cas, vous êtes libre d’utiliser la carte SIM et l’opérateur de votre choix.





Au niveau du tarif, il faudra compter 83€ TTC evnviron !!



[NOUVEAUTE] Arduino Yùn : Une nouvelle carte officielle qui combine Arduino, WIFI et Linux.


Massimo Banzi vient d’annoncer à la Maker Faire Bay Area le lancement d’un nouveau type de carte Arduino combinant à la fois Arduino, le WIFi et Linux, il s’agit de la carte Arduino Yùn.

Cette carte a été élaborée avec Dog Hunter, une entreprise spécialisée dans le développement de carte embarquées sous Linux.

Pour la petite histoire « Yùn » signifie « Cloud » ou « Nuage », et l’on peut déjà penser que cette carte sera dédié pour communiquer avec des services web.

arduino yun une nouvelle carte officielle qui combine arduino wifi et linux 01 600x400 Arduino Yùn : Une nouvelle carte officielle qui combine Arduino, WIFI et Linux.

Au niveau de l’architecture physique

On retrouve le format d’une carte Arduino classique avec différents connecteurs :

un connecteur micro USB pour la programmation du ATMega32U4
un connecteur USB standard pour pouvoir brancher des périphériques
un slot micro-SD pour du stockage
un connecteur pour l’antenne WIFI externe
un connecteur RJ45 pour le réseau filaire
Un peu apercevoir aussi l’emplacement d’un module PoE
arduino yun une nouvelle carte officielle qui combine arduino wifi et linux 02 600x399 Arduino Yùn : Une nouvelle carte officielle qui combine Arduino, WIFI et Linux.






Pour l’architecture électronique

Un micro-contrôleur ATMega32U4 cadencé à 16 MHz ( à la manière de l’Arduino Leonardo )
Un chip Atheros AR9330 fonctionnant sous une distri Linux Linino, une version basée sur OpenWRT
Au niveau du fonctionnement




La première fois que vous allez alimenter votre carte Arduino Yùn, elle va devenir un Acces Point avec le SSID « Arduino ». Il faudra d’abord se connecter à ce réseau, puis avec un simple navigateur accéder au panel de configuration pour la rattacher à votre réseau. Dans l’IDE Arduino, vous devriez ensuite découvrir la carte dans la section « Port » avec l’affichage de son adresse IP.

Une nouvelle librairie va faire également son apparition, Bridge Librairy, qui permet de relier Arduino Yùn avec Linux du AR9330. Il sera facile d’échanger des données entre le monde Linux et le monde Arduino.

Au niveau logiciel

La carte Yùn supportera les scripts Python et Shell de base, mais rien de vous empêchera de modifier son coeur grâce à l’existant de la communauté Linux.

Il sera également possible de prendre la main dessus grâce à une serveur SSH embarqué.

Au niveau du prix

Le prix annoncé est de 69$ HT soit environ 64€ TTC avec une date de disponibilité pour fin Juin.




[TUTO] Un Robot autonome pour débutant !!

Voici le schéma et le nécessaire pour réalisé un robot autonome avec peu de matériel !

Le matériel nécessaire:

-Arduino
- 1 LED
- Quelques Jumps
- Capteur Ultrason
- Dual Stepper
- Et un chassis composé de 2 moteur dc

Le schéma de montage:



Le Code:

_______________________________________________________________________

int switchPin= 2; // Right bump switch on pin 2
int swval; // Variable for reading switch status
int ultraSoundSignal = 7; // Ultrasound signal pin
int val = 0;
int ultrasoundValue = 0;
int timecount = 0; // Echo counter
int ledPin = 13; // LED connected to digital pin 13
int motorpinright = 10; // pin for left motor reverse
int motorpinleft = 11; // pin for left motor forward
int motorpinrevright = 5; // pin for right motor reverse
int motorpinrevleft = 6; // pin for right motor forward


void setup() {
pinMode(switchPin, INPUT); // Sets the digital pin as input
pinMode(ledPin, OUTPUT); // Sets the digital pin as output
pinMode(motorpinright, OUTPUT); // Motor drives-----------
pinMode(motorpinleft, OUTPUT); //------------------------
pinMode(motorpinrevright, OUTPUT); //------------------------
pinMode(motorpinrevleft, OUTPUT); //------------------------
}

void loop() {



/* Start Scan
* --------------------------------------------------
*/{
timecount = 0;
val = 0;
pinMode(ultraSoundSignal, OUTPUT); // Switch signalpin to output

/* Send low-high-low pulse to activate the trigger pulse of the sensor
* -------------------------------------------------------------------
*/

digitalWrite(ultraSoundSignal, LOW); // Send low pulse
delayMicroseconds(2); // Wait for 2 microseconds
digitalWrite(ultraSoundSignal, HIGH); // Send high pulse
delayMicroseconds(5); // Wait for 5 microseconds
digitalWrite(ultraSoundSignal, LOW); // Holdoff

/* Listening for echo pulse
* -------------------------------------------------------------------
*/

pinMode(ultraSoundSignal, INPUT); // Switch signalpin to input
val = digitalRead(ultraSoundSignal); // Append signal value to val
while(val == LOW) { // Loop until pin reads a high value
val = digitalRead(ultraSoundSignal);
}

while(val == HIGH) { // Loop until pin reads a high value
val = digitalRead(ultraSoundSignal);
timecount = timecount +1; // Count echo pulse time
}

/* Lite up LED if any value is passed by the echo pulse
* -------------------------------------------------------------------
*/

if(timecount > 0){
digitalWrite(ledPin, HIGH);
delay(50); //LED on for 50 microseconds
digitalWrite(ledPin, LOW);
}

/* Delay of program
* -------------------------------------------------------------------
*/

delay(100);

}
/* Action based on data
* -------------------------------------------------------------------
*/
{
ultrasoundValue = timecount; // Append echo pulse time to ultrasoundValue
}
if (ultrasoundValue > 800)

{
/* Drive straight forward 
*-----------------------------------------------
*/
analogWrite(motorpinleft, 255); //100% speed 
analogWrite(motorpinright, 255); //100% speed0
}
/*------------------------------------------------
*/
else
/* Turn hard right
*---------------------------------------------
*/
{
analogWrite(motorpinleft, 0); //stop left motor 
analogWrite(motorpinright, 0); //stop right motor
analogWrite(motorpinrevright, 0); // stop right rev motor
analogWrite(motorpinrevleft, 0); // stop left rev motor
analogWrite(motorpinrevright, 255); //100% speed
analogWrite(motorpinleft, 255); //100% speed
delay(380); //380 milliseconds
analogWrite(motorpinrevright, 0); // off 
analogWrite(motorpinleft, 0); // off

/*----------------------------------------------
*/
}

/* Backup and turn right when switch gets bumped and closes circuit to ground
*---------------------------------------------------
*/ 
/* 
*/
digitalWrite(switchPin, HIGH); // Sets the pin to high
swval = digitalRead(switchPin); // Read input value and store it
if (swval == LOW) {
analogWrite(motorpinleft, 0); //stop left motor 
analogWrite(motorpinright, 0); //stop right motor
analogWrite(motorpinrevleft, 0); // stop left rev motor 
analogWrite(motorpinrevright, 0); // stop right rev motor
analogWrite(motorpinrevleft, 255); //100% speed 
analogWrite(motorpinrevright, 255); //100% speed
delay(800); //800 milliseconds
analogWrite(motorpinrevleft, 0); // off 
analogWrite(motorpinrevright, 0); // off
analogWrite(motorpinrevright, 255); //100% reverse speed
analogWrite(motorpinleft, 255); //100% forward speed
delay(700); //700 milliseconds
analogWrite(motorpinrevright, 0); // off 
analogWrite(motorpinleft, 0); // off
delay(50); //50 milliseconds
}

/*------------------------------------------------
*/


}

__________________________________________________________________________




vendredi 19 juillet 2013

[BIBLIOTHEQUE] controlP5

controlP5 est une bibliothèque écrite par Andreas Schlegel pour l'environnement de programmation traitement . Dernière mise à jour 23/12/2012.
ControlP5 est une interface graphique et contrôleur de la bibliothèque de traitement qui peut être utilisé dans la création, l'application et le mode applet. Les contrôleurs comme les curseurs, boutons, poignées, boutons, champs de texte, boutons radio, cases à cocher, entre autres, peuvent être facilement ajoutés à un sketch de traitement. Ils peuvent être disposés dans des fenêtres de contrôle séparés, et peuvent être organisés dans des onglets ou des groupes. → lire plus .

Installation

Décompressez et placez le dossier extrait controlP5 dans le dossier des bibliothèques de vos esquisses de traitement.Référence et des exemples sont inclus dans le dossier controlP5.

Exporter vers Applet

Les règles de sécurité pour les applets sont très élevés et rigoureux, afin de faire controlP5 travail correctement au sein d'une applet, vous devez faire champs et des fonctions qui sont utilisées par controlP5 publique dans votre code.

Détails

Mots-clés gui, ui, contrôleur, interface, interface utilisateur
Référence . Jetez un oeil à la référence de javadoc ici . une copie de la référence est inclus dans le fichier. zip ainsi.
Source . Le code source de controlP5 est disponible à Google Code , et son référentiel peut être consulté ici .
Plate-forme OSX, Windows, Linux traitement 2.0b7 Dépendancesaucun 

Détection contrôleur automatique des événements
ControlP5 propose une gamme de contrôleurs qui vous permettent de changer facilement et d'ajuster les valeurs alors que l'esquisse est en marche. Chaque contrôleur est identifié par un nom unique attribué lors de la création d'un contrôleur. ControlP5 localise les variables et fonctions à l'intérieur de votre croquis et relieront les contrôleurs à des variables ou des fonctions correspondant ControlP5toggle automatiquement → exemple . changements de contrôleur peut facilement être capturés au sein de votre sketch mettant en œuvre la fonction ControlP5controlEvent ControlEvent →exemple .
Afficher, masquer, charger, enregistrer
les contrôleurs qui ont été ajoutés à votre croquis peut être organisé en onglets et des groupes de garder votre contrôleur définit organisé. Tous les contrôleurs sont dessinés sur un croquis de traitement par défaut. Plusieurs combinaisons de touches permettent d'afficher et de masquer l'interface utilisateur, et de sauvegarder et de charger ControlP5 propriétés, ControlP5properties → exemple . La position d'un contrôleur peut être réglé lors de l'exécution par le déplacement d'un contrôleur tandis que la touche ALT est enfoncée. Touche-commandes ALT-mouseMove mouvement des contrôleurs ALT-h afficher et masquer les contrôleurs Alt-Shift-s configuration du contrôleur de sauvegarde dans une des propriétés-documents Alt-Shift-L charger une configuration de contrôleur à partir d'un document de propriétés-
Configuration de Windows
Ajouter des fenêtres séparées à votre croquis. Ces fenêtres peuvent contenir controlP5 contrôleurs ou vous pouvez tout simplement utiliser un ControlWindow de rendre un croquis supplémentaire dans n'importe quel moteur de rendu disponible.ControlP5controlWindow → exemple .
Polices personnalisées
Par défaut controlP5 utilise un bitFont à rendre le texte. Pour afficher le texte en PFont format, controlP5 utilise un wrapper appelé ControlFont ControlP5controlFont → exemple .
Contrôleurs personnalisés
Jetez un oeil à l'→ ControlP5diyController exemple qui demostrates comment créer votre propre contrôleur personnalisé.
Boutons personnalisés
créer des contrôleurs qui utilisent des états basés sur des images au lieu de la valeur par défaut controlP5-look ControlP5button →exemple . expérimental

Téléchargement





[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)
ModeCPOLCPHA
0 (0,0)00
1 (0,1)01
2 (1,0)10
3 (1,1)11

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.









jeudi 18 juillet 2013

[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:
ModePolarité de l’horloge (CPOL)Phase de l’horloge (ACSP)
SPI_MODE000
SPI_MODE101
SPI_MODE210
SPI_MODE311
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:
ArduinoMOSIMISOSCKSS (esclave)SS (maître)
Uno ou Duemilanove11 ou ICSP-412 ou ICSP-113 ou ICSP-310-
Mega1280 ou Mega256051 ou ICSP-450 ou ICSP-152 ou ICSP-353-
LeonardoICSP-4ICSP-1ICSP-3--
En raisonICSP-4ICSP-1ICSP-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).