À l’aide de composants de NXT avec un Micro contrôleur (6 / 6 étapes)

Étape 6: Le capteur à ultrasons

C’est le big one.  La complexité de tout avant ce n’est rien en comparaison.  Cependant, il n’est toujours pas si mal.  Le capteur à ultrasons le j’utilise le protocole C Squared ou I2C.  Ce protocole permet à un maître (le LEGO RCX) contrôler plusieurs appareils esclaves (capteurs) en utilisant seulement deux fils (plus les fils d’alimentation).  C’est très pratique lorsque vous commencez à regarder les multiplexeurs et à l’aide de plusieurs capteurs sur un port.  Il permet également des fonctionnalités supplémentaires pour le capteur à ultrasons.  I2C est un protocole numérique, mais il n’est pas explicitement soutenu par la BS2.  Heureusement, nous pouvons faire quelque chose connue sous le nom « bit-banging » le protocole de notre propre code écrit pour elle.  C’est avantageux parce que le capteur à ultrasons ne suit pas exactement en tout cas les protocole I2C.  Donc, sans plus tarder, voici un cours accéléré en I2C avec un accent sur le capteur à ultrasons.

Procédure générale :
Maître envoie le signal de départ
Maître envoie l’octet d’adresse (détermine quel périphérique est connecté et que ce soit lire ou écrire)
Esclave reconnaît
Transmission de données (du maître à l’esclave ou de l’esclave au maître)
Récepteur reconnaît après chaque octet
Maître envoie la commande d’arrêt

Vous aurez envie de télécharger le Kit de développeur matériel LEGO ici : http://mindstorms.lego.com/en-us/support/files/default.aspx

Si vous regardez à l’appendice 7, vous pourrez voir toutes les commandes possibles pour le capteur à ultrasons ainsi que les résultats escomptés.
Octets sont écrits comme Hex ou Base 16 (comme indiqué par « 0 x »).

Pour donner un exemple d’une commande, nous allons essayer de lire l’ID de produit qui devrait retourner « LEGO »
Pour ce faire, nous enverrions une commande de démarrage, puis écriture adresse de la sonde (2) qui est reconnu, puis la commande ID de produit (8) qui est reconnue suivie d’une commande de redémarrage (« R » dans l’appendice) et adresse de lecture de la sonde (3) qui doit être reconnue. Après l’adresse de lecture est envoyé, le capteur renvoie 5 octets (L, E, G, O et une valeur null 0 x 00).  Chaque octet doit être reconnu par le timbre.

La commande de redémarrage se compose d’un arrêt, un cycle d’horloge et un départ.  Ce cycle d’horloge supplémentaire, souvent appelée une « agitation » ne fait pas partie du protocole I2C standard.  Si vous utilisez un microcontrôleur supportant I2C, vous aurez besoin pour vous assurer de que vous envoyez ce cycle d’horloge supplémentaire.

Maintenant, nous devons entrer dans le fond des choses réel du protocole I2C.  Nous allons commencer par brochage de la sonde.
Broche 1 - 9V (Vcc)
Broche 2 - sol
Broche 3 - sol
Broche 4 - 5V (Vcc)
Broche 5 - SCL
Broche 6 - SDA

SCL est votre ligne d’horloge qui sert à synchroniser la transmission de données et SDA est la ligne de données réelles.  J’ai tendance à les appeler « horloge » ou « clk » et « données » si patient avec moi.

Il y a des résistances reliant les SCL et SDA à la source de 5V afin que si rien n’est fait, ils ont par défaut à 5 volts.  Communication se fait en tirant ces lignes à 0 et puis en les relâchant.  Notez que vous n’avez pas à tirer sur les lignes hautes, comme ils de défaut élevé.  À cause de cela, lorsque vous avez terminé avec une commande, il est préférable de mettre tous les deux à l’entrée.  Si vous échouez libérer les lignes, vous risquez une courte avec un maximum à l’extrémité de BS2 et un minimum à l’extrémité de la sonde.

Les commandes I2C eux-mêmes sont en fait assez simples.

Départ :
Commencez avec les deux lignes de hauts, tirez SDA faible, puis tirez horloge faible.  L’effet est que SDA passe d’élevé à faible tandis que l’horloge est élevé.

Arrêt :
Commencez avec les deux lignes de basses, laisser aller haut d’horloge, puis lacher SDA élevé.  L’effet est que SDA va de faible à élevé alors que l’horloge est élevé.

Voyez comment Stop est l’opposé du départ ?

Pour passer de l’horloge, tirez-le simplement basse pendant un moment, puis relâchez-la.

Envoi de données :
Données sont envoyées en octets et chaque octet est suivie d’un accusé de réception par le destinataire.
Tout d’abord, l’horloge est tiré en bas, puis SDA est défini sur le bit suivant pour être envoyé par l’émetteur, puis horloge est sorti haute et SDA est lu par le récepteur, puis horloge est tiré faible encore.  Cela se répète pour tous les 8 bits.  Données ne sont valides que lorsque l’horloge est élevé et les données peuvent uniquement être modifiées lorsque l’horloge est faible.  Changer SDA alors que l’horloge est élevé se traduit par la commande Start ou Stop. Après avoir envoyé les 8 bits, le récepteur maintient SDA inférieur à un accusé de réception tandis que les communiqués de maîtres et abaisse horloge une fois de plus.  Les octets sont envoyés MSB premier ou première de plus important peu.  Par exemple, l’octet pour « 2 » 00000010 recevraient commençant par le bit sur la gauche et se terminant par le bit sur la droite.

Octets de l’adresse :
Chaque capteur possède une adresse de 7 bits qui est transmises en même temps avec un peu de directionnel.
L’adresse de 7 bits du capteur ultrasonique est « 1 » ou « 0000001 »
Le foret directionnel est soit « 0 » pour écrire (envoi à l’esclave) ou « 1 » pour lire (réception de l’esclave).
Il en résulte une adresse envoi 00000010 ou 2 et une adresse de lecture de 00000011 ou 3.

Alors comment pouvons-nous réellement faire tout cela ?  J’ai essayé le codage explicite tout sur le timbre, mais il courait trop lentement.  Le capteur fonctionne à une vitesse optimale de 9600 Hz, et le timbre ne vient pas près que lors de l’exécution ligne par ligne.  Au lieu de cela, j’ai eu recours à l’aide des commandes SHIFTIN et SHIFTOUT qui sont en réalité beaucoup plus faciles.  Démarrage, arrêt et redémarrage sont toujours accomplies manuellement à l’aide de haute et basse commandes.  Le résultat ressemble à ceci :

byt0, byt1 et byt2 sont trouvent dans le Hardware Developer Kit annexe 7.
bytes_receive est le nombre d’octets à recevoir de la sonde
Alpha est 1 si une chaîne ASCII est attendue (pensez « alphabet ») et 0 si une réponse numérique est attendue
N’oubliez pas d’écrire une fonction erreur pour quand le capteur ne parvient pas à l’accusé de réception.  Mien juste redémarré l’ensemble du processus.

« commencer
Sda d’entrée
ENTRÉE clk
Sda faible
' send0
SHIFTOUT sda, clk, MSBFIRST, [byte0] ' adresse octets
SHIFTIN sda, clk, MSBPRE, [ack\1] ' accusé de réception
IF ack = 1 THEN erreur "s’il n’est pas reçu d’accusé de réception, exécutez erreur routine
' send1
SHIFTOUT sda, clk, MSBFIRST, [byt1] ' envoyer octet de commande
SHIFTIN sda, clk, MSBPRE, [ack\1] ' accusé de réception
IF ack = 1 THEN erreur "s’il n’est pas reçu d’accusé de réception, exécutez erreur routine
' redémarrer ' redémarrer commande (Stop, horloge, début)
FAIBLE clk
Sda faible
HAUTE clk
Sda haute
FAIBLE clk
HAUTE clk
Sda faible
« send2
SHIFTOUT sda, clk, MSBFIRST, [byt2] ' envoyer des octets d’adresse pour le retour
SHIFTIN sda, clk, MSBPRE, [ack\1] ' recevoir ack
IF ack = 1 THEN erreur "s’il n’est pas reçu d’accusé de réception, exécutez erreur routine
« recevoir
POUR i = 0 TO bytes_receive-1
SHIFTIN sda, clk, MSBPRE, [CBX_lucia (i) \8] ' recevoir octets
SHIFTOUT sda, clk, MSBFIRST, [0\1] ' accusé d’envoi
Alpha IF = 0 THEN DEBUG DEC bytr(i) ' si le nombre, la valeur décimale de chaque octet de débogage
PROCHAINE "répéter, selon le nombre d’octets escomptés
Alpha de IF = 1 THEN DEBUG STR CBX_lucia ' si chaîne, déboguer tous les octets comme chaîne alphanumérique
DÉBOGAGE DE CR
' Arrêter
FAIBLE clk
Sda faible
ENTRÉE clk
Sda d’entrée

Si le troisième octet de la commande (2 octets) est autre chose que "R + 0 x 03", envoyer le troisième octet sans la séquence de redémarrage et ne vous attendez pas une réponse.