Étape 5: Le code, l’âme
La partie la plus intéressante, c’est où tout votre dur travail jusqu'à maintenant est payants. Nous avons travaillé pour s’occuper de tous les détails physiques, maintenant, qu’en est-il de ceux émotionnel ? : p
Dans un premier temps, vous aurez besoin d’avoir l' Arduino IDE installé pour votre système d’exploitation, vous devez installer manuellement la bibliothèque Adafruit pour être en mesure de contrôler la NeoPixel dans le cas où vous avez décidé de les utiliser.
Obtenir le code complet de Boa au moment où que j’écris ceci est jointe. Il recevra définitivement plus de code et de l’éducation que je vais:) Notez que le code est calibré pour fonctionner avec les capteurs et les servos, que j’ai utilisé, alors peut-être qu'il ne fera pas de sens pour vous quand vous l’essayez. Vous aurez besoin de passer par de nombreux essais jusqu'à ce que vous trouviez les bonnes valeurs (plus à ce sujet dans la section suivante)
Introduction
Pour moi, le point entier derrière ce projet est de rendre les oiO interactive et autonome, agissant à son compte. Il devrait continuer à offrir sa fonction principale, vous donner la lumière, mais il a aussi son humeur et sautes d’humeur, il change de posture et interagit avec l’utilisateur.
Mais il y avait un défi pour moi, résumées dans les points ci-dessous
1) Comment puis-je déplacer 3 servos dans le même temps, ou séparément si nécessaire
2) Comment puis-je faciliter les mouvements et introduire quelques assouplissement pour simuler un mouvement fluide. Aussi avoir un certain contrôle sur la vitesse des servos pour simuler des comportements différents.
3) comment je peux lire et contrôler tous les capteurs et les servos en parallèle sachant que Arduino ne prennent en charge le multitâche.
4) Comment puis-je rendre le comportement de l’oiO crédible et éviter la robotiques réponses aux entrées similaires, que je veux lui répondre différemment pour la même entrée (sonore et proximité), tout cela en sachant que Arduino contente de lire le code de haut en bas, puis les boucles
5) oiO doit avoir un sens du temps qui passe, par un acte selon elle.
Tout cela à faire avec 32 Ko de mémoire dynamique disponible sur l’Arduino pour le code et tout en la gardant simple !
Après 2 jours d’écriture de code, je pense que j’ai atteint mes objectifs et répondu à la question cinq d’une façon acceptable avec quelques compromis.
Nous pourrions discuter sur la façon dont je l’ai fait et comment crédible, c’est, mais fin de journée, la vidéo que vous avez vu, est à l’aide de seulement 17 % de la mémoire de code, et il y a beaucoup de place pour des améliorations, que je vais continuer à poursuivre. mais puisque vous avez le code, s’il vous plaît écrivez-moi à toute suggestion, ou simplement partager vos améliorations.
Dans les prochaines sections , je vais partager quelques extraits de code, que j’ai senti que j’ai besoin de discuter, je vous laisse lire le code complet et donner un sens de celui-ci, aussi il est fortement commenté pour aider à mieux comprendre et pour moi de rappeler les détails 3 mois a partir de maintenant:). J’espère que je ne plus le faire !
Points 1 & 2
Mouvement 3 servos simultanément sur l’Arduino n’est pas possible en mode natif. J’ai donc dû écrire une fonction qui prend 3 servos et 3 postes de cible pour chacun, en plus d’un facteur d’accélération pour contrôler la vitesse et la facilité des servos. Les fonction commandes les servos à l’aide de writeMicroseconds() au lieu de write(), comme l’ancien donne un contrôle plus précis en raison de sa plus large éventail de valeurs, contrôlant les servos en définissant la largeur exacte des impulsions PWM en millisecondes, au lieu de ce dernier que degrés angulaires des utilisateurs.
La fonction est :
- target_posX: a des limites au début et de fin de positions, entre 600 et 2400 mS, certains servos fonctionnent entre 1000 et 2000... s’il vous plaît vérifier vos limites de servos de contrôle ou de feuille de données avant de définir les valeurs
-accélération: est une valeur comprise entre 0,0 et 5.0, où :
-des valeurs entre 0,0 et 1,0 cause les servos pour lancer le mouvement rapidement mais finissent ainsi, autour de zéro des valeurs (ex : 0,05) donne la réponse beaucoup plus lent/désiré de lissage, la valeur de 0,1 est assez rapide
-valeurs comprises entre 1,0 et 5,0, ne sont pas considérées comme facteurs d’accélération qu’ils provoquent une modification dans le comportement, causant des servos pour déplacer linéairement commencent à s’arrêter à x par tranches en fonction de la valeur fournie. Valeur de 2.0 est vitesse de la tortue, alors qu’une valeur de 5.0 est relativement rapide.
Pour simuler un contrôle simultané des 3 servos, le sélecteur de chaque servo une étape à la fois, mais dans une rangée, c'est-à-dire déplace servo1 un tout petit pas, puis déplace servo 2 un tout petit pas, puis servo3 de la même façon, alors il le fait à nouveau et agin dans une boucle jusqu'à ce que tous les servos avait atteint leurs positions finales. Le résultat final, tous les servos semblent ont déménagé dans le même temps à leur position de la cible.
Points 3 et 4
Pour remédier à cela, le truc était de séparer la lecture les capteurs valeur de réellement agissant sur les servos et les yeux. Cela me permet de créer des compteurs qui comptent sonores et détections conséquente de proximité et aussi mesurer la synchronisation entre les occurrences. Ces compteurs et les horodatages peuvent servir plus tard indépendamment dans la partie qui agissent sur les servos et les yeux. J’ai tester pour les valeurs de compteurs et voir combien de temps il a fallu l’utilisateur entre chaque détection. Par exemple, c’est comment oiO peut différencier entre un utilisateur s’approchant de lui 3 fois de façon rapide, donc faire Boa en colère contre les yeux rouges et des mouvements saccadés ou si l’utilisateur a approché consécutivement d’une manière lente, ce qui rend oiO plus calme avec chauffe-couleur des yeux et de mouvements gracieux...
En un mot, obtenir les capteurs valeur première, puis agir plus tard. mais étant donné que l’Arduino loop() s’exécute assez rapidement, l’utilisateur ne remarqueront pas le retard.
Point 5
Étant donné que l’Arduino n’est pas connecté à une source de synchronisation externe, donc il ne peut pas dire le temps absolu, donc oiO est d’utiliser la synchronisation interne d’Arduino à l’aide de la fonction millis() qui comptabilise le nombre de millisecondes depuis le départ/reset de l’Arduino. Le compteur roule après aprox. 50 jours, plus que suffisant pour le cycle de vie de l’oiO. Cela devrait être suffisant pour calculer par exemple : 15 min est dépassée alors ne ceci et cela ou si elle a été de 60 secondes, l’utilisateur n’a pas interagir avec BOA.
Par exemple, c’est comment oiO détectera que l’utilisateur n’a pas interagir avec lui depuis 1 h et en conséquence commence assoupi, suivie de sommeil profond !
Contrôler les yeux
J’ai utilisé la bibliothèque Adafruit puisqu’elles fournissent des fonctions intéressantes pour contrôler la NeoPixels, j’ai ajouté quelques fonctions comme setEyesColor() et dimmer() d’avoir un accès facile au réglage des couleurs d’yeux et également contrôlent la gradation sur une couleur donnée avec une vitesse donnée et la direction.
un: luminosité min
b: max de luminosité
r, g, b: sont les composantes de couleur RVB, chacune peut avoir une valeur comprise entre 0 et 255
fadeDirection: peut être 1 = vers le haut, 2 = bas, 3 = updown
stepSpeed, délai en millisecondes entre la couleur fade comme suit
Conclusion
J’ai fortement recommande de lire le code et comprendre et modifiez-le si nécessaire. Toutes les variables dans la phase d’initialisation du code (c’est à dire avant et à l’intérieur de la setup()) doit être défini selon vos besoins.
