Étape 4: Détails sommaires
Il suffit de couper et coller comme le téléchargement d’un fichier à ibles ne peut pas retenir le nom de fichier et sera source de confusion.
=== début des croquis ===
/*
Ce programme est basé Arduino croquis exemples et ce qui suit :
ADXL345_Example.PDE - croquis de l’exemple de l’intégration avec un ADXL345 triple accéléromètre axes.
Copyright (C) 2011 amour Electronics (loveelectronics.co.uk)
Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier
elle aux termes de la version 3 de licence publique générale de GNU comme
publiée par la Free Software Foundation.
Ce programme est distribué dans l’espoir qu’il sera utile,
mais sans aucune garantie ; sans même la garantie implicite de
Qualité marchande ou ADEQUATION a un usage particulier. Voir le
GNU General Public License pour plus de détails.
Vous devriez avoir reçu une copie de la GNU General Public License
avec ce programme. Si non, voir < http://www.gnu.org/licenses/>.
*/
Inclure la bibliothèque de fils afin que nous puissions commencer à l’aide de I2C.
#include < Wire.h >
Inclure la bibliothèque de ADXL345 Electronics amour donc nous pouvons utiliser l’accéléromètre.
#include < ADXL345.h >
inclure la bibliothèque de servo pour contrôler le servo
#include < Servo.h >
Servo myservoA ; Créez l’objet servo pour contrôler un servo
vous pouvez créer un maximum de huit objets de servo
Servo myservoB ; Créez l’objet servo pour contrôler un servo
vous pouvez créer un maximum de huit objets de servo
posA int = 0 ; variable pour stocker la position du servo
posB int = 0 ;
Déclarez une instance globale de l’accéléromètre.
ADXL345 accel ;
Mettre en place une épingle, que nous allons utiliser pour indiquer notre statut à l’aide d’une LED.
int statusPin = 2 ; J’utilise la broche numérique 2.
//------------------------------------------------------
void setup()
{
myservoA.attach(7) ; attache le servo sur la broche 6 à l’objet de servo
myservoB.attach(6) ; s’adapte sur le servo sur la broche 7 l’objet servo
Commencez par configurer le Port série afin que nous puissions sortir de nos résultats.
Serial.Begin(9600) ;
Démarrer la bibliothèque I2C fils donc nous pouvons utiliser I2C pour parler à l’accéléromètre.
Wire.Begin() ;
Une LED pour indiquer notre statut est prêt.
pinMode (statusPin, sortie) ;
Créez une instance de l’accéléromètre sur l’adresse par défaut (0x1D)
Accel = ADXL345() ;
Vérifier que l’accéléromètre est enfait connecté.
if(Accel. EnsureConnected())
{
Serial.println ("connecté à ADXL345. ») ;
digitalWrite (statusPin, HIGH) ; Si nous sommes connectés, allumer notre statut LED.
}
d’autre
{
Serial.println ("connexion impossible à ADXL345.") ;
digitalWrite (statusPin, basse) ; Si nous ne sommes pas connectés, éteindre nos LED.
}
Définissez la plage de l’accéléromètre à un maximum de 2G.
Accel. SetRange (2, true) ;
Prévenez l’accéléromètre pour commencer à prendre des mesures.
Accel. EnableMeasurements() ;
}
//----------------------------------
void loop()
{
if(Accel. IsConnected) / / si nous sommes reliés à l’accéléromètre.
{
Lire les données brutes de l’accéléromètre.
AccelerometerRaw brute = accel. ReadRawAxis() ;
Ces données sont accessibles comme ceci :
int xAxisRawData = raw. XAxis ;
Lire le * échelle * les données de l’accéléromètre (cela fait sa propre lecture de l’accéléromètre
Si vous n’avez pas à ReadRawAxis avant d’utiliser cette méthode).
Cette méthode utile vous donne la valeur en G grâce à la librairie électronique de l’amour.
AccelerometerScaled échelle = accel. ReadScaledAxis() ;
Ces données sont accessibles comme ceci :
float xAxisGs = mise à l’échelle. XAxis ;
Nous sortie nos données reçues.
Sortie (raw, à l’échelle) ;
}
}
Copiez les données sur le port série.
Sortie Sub (AccelerometerRaw crue, AccelerometerScaled mis à l’échelle)
{
initialiser les broches de la LED en tant que sortie :
pinMode (sortie 8) ;
pinMode (sortie 9) ;
pinMode (sortie 11) ;
pinMode (sortie 12,) ;
Signalez-nous les valeurs brutes provenant de l’accéléromètre.
Serial.Print("Raw:\t") ;
Serial.Print (raw. XAxis) ;
Serial.Print("") ;
Serial.Print (raw. YAxis) ;
Serial.Print("") ;
Serial.Print (raw. ZAxis) ;
Parlez-nous de cette données, mais il adapte en unités utiles (G).
Serial.Print ("\tScaled:\t") ;
Serial.Print (mise à l’échelle. XAxis) ;
Serial.Print ("G") ;
Serial.Print (mise à l’échelle. YAxis) ;
Serial.Print ("G") ;
Serial.Print (mise à l’échelle. ZAxis) ;
Serial.println("G") ;
Voir la led pour axe
Si (mise à l’échelle. XAxis > 0) {}
digitalWrite (8, HIGH) ; la valeur de la LED sur
}
d’autre
{
digitalWrite (8, faible) ; déclencher la LED
}
//
Si (mise à l’échelle. YAxis > 0) {}
digitalWrite (9, HIGH) ; la valeur de la LED sur
}
d’autre
{
digitalWrite (9, faible) ; déclencher la LED
}
//
Si (mise à l’échelle. ZAxis > 0,8) {}
digitalWrite (11, haute) ; la valeur de la LED sur
}
d’autre
{
digitalWrite (11, faible) ; déclencher la LED
}
faire bouger selon conditions senties---les servo
Si (mise à l’échelle. ZAxis < 0,8) {}
Serial.println ("*** soulever plus bas---relance inférieure") ;
RaiseLower() ;
Delay(265) ;
}
//
Si (mise à l’échelle. YAxis < 0) {}
Serial.println ("*** secousse moyen---secousse Middle") ;
twitchMiddle() ;
Delay(400) ;
}
//
Si (mise à l’échelle. XAxis < 0 graduées. YAxis > 0 et à l’échelle. ZAxis > 0) {}
Serial.println ("*** clin d’oeil clin d’oeil droite droite---") ;
winkRight() ;
Delay(265) ;
}
}
//-------------------------------
sous-routine pour soulever et inférieur
Sub RaiseLower()
{
twitchshort() ;
Twitch() ;
pour (posA = 0; posA < 135 ; posA += 1) / / va de 0 degrés à 135 degrés
{/ / par incréments de 1 degré
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(12) ; attend 15 ms pour le servo atteindre la position
}
pour (posA = 135 ; posA > = 1; posA-= 1) / / passe de 135 degrés à 0 degrés
{
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(12) ; attend 15 ms pour le servo atteindre la position
}
}
sous-routine pour secousse---
Sub twitch()
{
pour (posA = 0; posA < 45 ; posA += 1) / / va de 0 degrés à 45 degrés
{/ / par incréments de 1 degré
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(8) ; attend 15 ms pour le servo atteindre la position
}
pour (posA = 45 ; posA > = 1; posA-= 1) / / va de 45 degrés à 0 degrés
{
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(8) ; attend 15 ms pour le servo atteindre la position
}
}
sous-routine pour courte secousse---
Sub twitchshort()
{
pour (posA = 0; posA < 25 ; posA += 1) / / va de 0 degrés à 25 degrés
{/ / par incréments de 1 degré
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(5) ; attend 15 ms pour le servo atteindre la position
}
pour (posA = 25 ; posA > = 1; posA-= 1) / / va de 25 ° à 0 degrés
{
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(5) ; attend 15 ms pour le servo atteindre la position
}
}
sous-routine pour secousse moyen---
Sub twitchMiddle()
{
pour (posA = 0; posA < 100 ; posA += 1) / / va de 100 degrés à 0 degrés
{/ / par incréments de 1 degré
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(10) ; attend 15 ms pour le servo atteindre la position
}
pour (posA = 100 ; posA > = 1; posA-= 1) / / va de 100 degrés à 0 degrés
{
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(10) ; attend 15 ms pour le servo atteindre la position
}
Delay(250) ;
pour (posA = 0; posA < 120 ; posA += 1) / / va de 100 degrés à 0 degrés
{/ / par incréments de 1 degré
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(10) ; attend 15 ms pour le servo atteindre la position
}
}
sous-routine pour clin d’oeil droite---
Sub winkRight()
{
pour (posA = 0; posA < 120 ; posA += 1) / / va de 0 degrés à 120 degrés
{/ / par incréments de 1 degré
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(10) ; attend 15 ms pour le servo atteindre la position
}
pour (posA = 120 ; posA > = 1; posA-= 1) / / va de 180 degrés à 0 degrés
{
myservoA.write(posA) ; dire de servo pour aller à positionner dans la variable « pos »
myservoB.write(180-posA) ;
Delay(10) ; attend 15 ms pour le servo atteindre la position
}
myservoB.write(180) ; soulever l’autre oreille si au repos pour correspondre à la position verticale
}
=== fin de croquis ===
Si vous inclinez votre tête vers l’avant, les oreilles devraient faire un plein de haut en bas.
Si vous inclinez votre tête vers la droite, l’oreille gauche doit monter et descendre.
Il faudrait une légère agitation si une légère inclinaison. Les oreilles goutte à une position basse.
Jouer avec les valeurs de retard et les boucles de minutage de servo d’action réaliste.
N’oubliez pas, vous devrez peut-être savoir où vos servos sont placées au début de 0 degré et de quelle façon elles tournent. Vous devrez ensuite accueillir le mouvement avec les commandes de servo dans le croquis.
X, Y, Z et servo mouvement dans mon prototype ne corresponde pas la vôtre.
