Étape 1: Code d’Arduino
commencer la minuterieTCNT2 = 99 ; réinitialiser la minuterie ct à 99 sur 255
TIFR2 = 0 X 00 ; TIMER2 int drapeau reg : effacer l’indicateur de débordement timer
#include < Servo.h >
int ledPin = 13 ;
changeData Boolean ; désactiver le timer2 interruption si faux
Servo servo0 ; créer l’objet de servo pour contrôler qu'un servo 0 est pour le pouce
Servo servo1 ; 1 est pour l’index
Servo servo2 ; 2 est pour le doigt du milieu
Servo servo3 ; 3 est pour l’anneau
Servo servo4 ; 4 est pour les petits
int potpin_servo [5] ; entrée analogique broche reliée au capteur flex
int tmp ; variable de travail
int temps ; voulu délai en ms
int [5] ; mémoriser la position en positions de vecteur où nous écrire la valeur mesurée pour chaque servo
int [5] ; mémoriser la position en positions de vecteur où nous lisons la valeur mesurée pour chaque servo
int élevé [7] ; mémoriser pour chaque doigt, la valeur la plus élevée de résistance (lorsque la main est fermée)
int faible [7] ; mémoriser pour chaque doigt, la plus faible valeur de la résistance (lorsque la main est ouverte)
int postes [5] [100] ; retarder max = 1000ms et interruption se produisent chaque 10ms = > 100 postes max
int f ; fréquence du mouvement recherché en Hz
comte de flotteur ;
int FPOS [5];// travail variable pour mouvement imposé
int P ; minuterie prescaller
int lowerAngle ; valeur max et min des servo : 30 et 160°
int upperAngle ;
int a ;
void setup()
{
pinMode(ledPin,OUTPUT) ;
Serial.Begin(9600) ;
SERVO1.Attach(3) ; s’adapte sur le servo sur la broche 3 l’objet de servo
Servo2.Attach(5) ;
servo3.Attach(6) ;
servo4.Attach(9) ;
servo0.Attach(10) ;
lowerAngle = 70 ;
upperAngle = 100 ;
temps = 0 ; délai initial
f = 100 ; fréquence en cHz (1 Hz = 100)
Count=(10000/f) ; pour 1 Hz, compter = 100 (100 * 10 ms = 1sec = > temps mouvement d'un!)
P = 99 ;
main tendue :
haute [0] = 586 ;
haute [1] = 576 ;
haute [2] = 564 ;
haute [3] = 562 ;
haute [4] = 528 ;
principale fermée
faible [0] = 694 ;
faible [1] = 764 ;
faible [2] = 736 ;
faible [3] = 760 ;
faible [4] = 738 ;
pour (int i = 0; i < 5; i ++)
{
[i] = 0 ; initialisation du vecteur contenant la position de début et de fin
sur [i] = 0 ;
potpin_servo [i] = i ; programme initial : mode normal
FPOS [i] = count ;
}
ServoInit() ; Définir une position initiale pour servo
interrupts() ;
Timer2init() ;
changeData = true ; aucun départ ne jusqu'à recevoir le signal de matlab
} ;
Sub ServoInit()
{
servo0.Write(upperAngle) ;
SERVO1.Write(upperAngle) ;
Servo2.Write(upperAngle) ;
servo3.Write(upperAngle) ;
servo4.Write(upperAngle) ;
}
Sub Timer2init()
{
Débordement Timer2 installation au feu chaque 8ms (125Hz)
période de [s] = (1 / f_clock [s]) * Prédiviseur * (255-comte)
(1/16000000) * 1024 * (255-99) =.00998 s = 10ms
TCCR2B = 0 X 00 ; Désactiver le Timer2 tandis que nous avons mis en place
TCNT2 = P ; Réinitialiser le compteur de Timer (255-99) = exécuter horloge de T/C ev 125-th
TIFR2 = 0 X 00 ; TIMER2 INT drapeau Reg : Indicateur de débordement Timer clair
TIMSK2 = 0 X 01 ; TIMER2 INT Reg : Timer2 débordement Interrupt Enable
TCCR2A = 0 X 00 ; TIMER2 contrôle Reg A: Vague Gen Mode normal
TCCR2B = 0 X 07 ; TIMER2 contrôle Reg B: Prédiviseur Timer la valeur 1024
};
ISR(TIMER2_OVF_vect)
{
SREG = SREG | B10000000 ; Définissez le bit 7 à 1 (global interrupt désactivé)
write_position_from_finger(0,potpin_servo[0]) ;
write_position_from_finger(1,potpin_servo[1]) ;
write_position_from_finger(2,potpin_servo[2]) ;
write_position_from_finger(3,potpin_servo[3]) ;
write_position_from_finger(4,potpin_servo[4]) ;
if((in[0]-out[0]) > =(time/10) || (out[0]-in[0]) > =(99-(time/10)-1)) / / si nous attendons peuvent acceuillir
{
write_position_on_servo (0, servo0) ;
write_position_on_servo (1 servo1) ;
write_position_on_servo (2, servo2) ;
write_position_on_servo (3, servo3) ;
write_position_on_servo (4, servo4) ;
}
if(changeData==true) / / changeData = true, réinitialisation de la position d’écriture et de lecture en vecteur (dans le temps est plus faible après avoir modifié les données par exemple)
{
pour (int i = 0; i < 5; i ++)
{
[i] = 0 ;
sur [i] = 0 ;
}
}
else / / si l’utilisateur change variables, arrêter l’interruption (il sera lancé à la fin de l’acquisition de données de l’utilisateur)
{
TCNT2 = P ; réinitialiser la minuterie ct à 99 sur 255
TIFR2 = 0 X 00 ; TIMER2 int drapeau reg : effacer l’indicateur de débordement timer
}
};
void write_position_on_servo (int number_of_servo, Servo servo)
{
tmp = postes [number_of_servo] [out [number_of_servo]] ; lire la première valeur de vecteur contenant les données du capteur flex
servo.Write(tmp) ;
Out [number_of_servo] = out [number_of_servo] + 1 ; incrémenter le numéro de mémoriser où nous devons lire
Si (hors [number_of_servo] > = 100) //if fin de tableau atteint, aller au début
{
Out [number_of_servo] = 0 ;
}
};
void write_position_from_finger (int number_of_servo, int potpin_finger)
{
if(changeData)
{tmp = upperAngle;}
d’autre
{
if(potpin_finger==9) / / si 9, servo est désactivé
{
tmp = upperAngle ;
}
if(potpin_finger==8) //If 8, se déplacer seul mode
{
Si (FPOS [number_of_servo] > ((count*5)/6)) / / ce nombre dépend de la vitesse du servo (est le nombre de 10 ms par le servo pour "up" avant il redescend)
{tmp = upperAngle;}
ElseIf (FPOS [number_of_servo] > ((count*2)/3))
{tmp = upperAngle-6;}
ElseIf (FPOS [number_of_servo] >(count/2))
{tmp = upperAngle-12;}
ElseIf (FPOS [number_of_servo] >(count/3))
{tmp = upperAngle-17;}
ElseIf (FPOS [number_of_servo] >(count/6))
{tmp = upperAngle-12;}
d’autre
{tmp = upperAngle-6;}
FPOS [number_of_servo] = FPOS [number_of_servo] -1 ;
if(POSF[number_of_servo]==0)
{FPOS [number_of_servo] = count;}
}
Si (potpin_finger == 0 || potpin_finger == 1 || potpin_finger == 2 || potpin_finger == 3 || potpin_finger == 4).
{
tmp=analogRead(potpin_finger) ; lire la valeur de flex
tmp >> 1 ; Décalage de bits à négliger la dernière valeur (erreur de mesure)
Serial.println(tmp) ;
Si (potpin_finger == 0 || potpin_finger == 2 || potpin_finger == 6)
{tmp = carte (tmp, faible [potpin_finger], haute [potpin_finger], upperAngle, lowerAngle) ;
} / / une inversion de servo
d’autre
{tmp = carte (tmp, faible [potpin_finger], haute [potpin_finger], lowerAngle, upperAngle);}
tmp = carte (tmp, faible [potpin_finger], haute [potpin_finger], lowerAngle, upperAngle) ;
}
}
Si (tmp < lowerAngle) / / protection du servo si analogique entrée signal défectueux
{tmp = lowerAngle;}
if(tmp>upperAngle)
{tmp = upperAngle;}
positions [number_of_servo] [[number_of_servo]] = tmp ;
dans [number_of_servo] = en [number_of_servo] + 1 ; incrémenter le numéro de mémoriser où nous devons stocker des données
Si (dans [number_of_servo] > = 100) //if fin de tableau atteint, aller au début
{[number_of_servo] = 0;}
}
void loop()
{
if(Serial.available() > 0) / / si il n’y a données à lire = > MATLAB envoie qqchose
{
a=Serial.Read() ;
if(a==1) / / START
{
changeData = false ;
} / / pour relancer
if(a==2) / / STOP
{changeData = true ;
} //va bloquer les actions fr ne relancant pas le minuteur
if(a==3) / / modifier les données
{
changeData = true ;
while(Serial.available() < 7) / / s’occupe de recevoir les 7 valeurs
{}
Delay(2000) ;
Time=Serial.Read() ;
temps = temps * 10 ;
f=Serial.Read() ;
potpin_servo[0]=Serial.Read() ;
potpin_servo[1]=Serial.Read() ;
potpin_servo[2]=Serial.Read() ;
potpin_servo[3]=Serial.Read() ;
potpin_servo[4]=Serial.Read() ;
Count=(5000/f) ;
pour (int i = 0; i < 5; i ++)
{FPOS [i] = count;}
}
if(a==4) / / INIT???
{
//
}
}
}
