Talking Portal 2 Tourelle Pistolet

Outils et machines nécessaires

Imprimante 3D (générique)

À propos de ce projet

L'histoire

Ce Noël, j'ai décidé de concevoir et de construire un canon de tourelle Portal fonctionnel à partir du jeu Portal 2 . Pour moi, il s'agissait d'un exercice consistant à modéliser correctement l'ensemble de l'assemblage dans Fusion 360, avant de construire quoi que ce soit. Cette conception utilise un Arduino Nano, une puce de lecteur MP3, un capteur de distance, des servos, des LED et des pièces imprimées en 3D.

Le but ici était de le faire bouger en 3 "axes", avec le son parlé du jeu et des LED pour simuler le tir.

• Ouvrez les "ailes" s'il détecte quelqu'un devant. Utilisez un mécanisme à manivelle avec des curseurs, juste parce que.

• Si la personne est toujours là après l'ouverture, tirez jusqu'à ce qu'elle tombe. LED et son de mitrailleuse.

• Si la personne n'est plus là, lancez une petite routine de recherche d'analyse.

• Rapprochez-vous et allez dormir jusqu'à ce que quelqu'un d'autre arrive.

• Utilisez les sons et les voix de la tourelle du portail du jeu.

J'ai pris quelques libertés dans le design, en essayant de le rendre sensiblement le même que celui vu dans le jeu, mais fonctionnel et imprimable. Avec quelques croquis de base trouvés en ligne, j'ai commencé à modéliser et à planifier...

Les sons sont stockés sur une carte microSD, accessible depuis l'arrière afin que les sons puissent être mis à jour ou modifiés ultérieurement. Il est aligné avec la bande de remplissage noire, ce qui le rend pratiquement invisible une fois installé. 18 expressions et sons individuels utilisés dans ce tour de table.

Le capteur lidar (temps de vol) est sur une puce à profil rectangulaire. Ce capteur est quasiment invisible de face une fois assemblé.

Étape 1 : Modélisation de Fusion 360

La conception a commencé à partir de croquis trouvés en ligne. En utilisant ces images comme toiles, j'ai commencé à esquisser les contours des 3 vues. Il s'agissait ensuite de les extruder en 3D, puis de décortiquer la forme générale et de faire des découpes. Tous les composants électroniques ont été construits dans Fusion en tant que composants insérés et placés là où je pensais que cela aurait du sens. Les paramètres de conduite étaient :

• Arduino Nano devait avoir un connecteur accessible pour la mise à jour une fois entièrement assemblé

• La carte MicroSD devait être accessible de la même manière, et idéalement invisible une fois installée

• Le capteur de temps de vol doit également être invisible

• Un connecteur électrique de 2,1 mm pour l'alimentation à l'arrière

• Les pièces imprimées doivent être aussi grandes que possible (pas beaucoup de petites pièces)

• Imprimer sans support

Une fois les composants (Nano, autres puces, servos) ajoutés à la forme de base, ils ont été déplacés et positionnés selon les besoins, et les structures de support ont été construites pour les soutenir à l'intérieur de la coque.

Le mécanisme d'ouverture des ailes était un mécanisme à manivelle et à glissière. Pourquoi? Parce que je voulais utiliser un mécanisme à manivelle, voilà pourquoi ! Cela a ajouté quelques complications, mais cela a également eu un avantage; une fois la géométrie déterminée, la répétabilité opérationnelle serait assurée et les limites minimale et maximale étaient pratiquement garanties.

Une fois que le modèle entier a été construit et que j'étais confiant qu'il fonctionnerait et qu'il pourrait être construit (imprimé) et assemblé, j'ai imprimé les pièces et construit un prototype. Une fois que cela a fonctionné, je suis retourné au modèle et j'ai apporté quelques modifications pour améliorer l'apparence et l'assemblage (est-ce un mot ?). Ce modèle est le résultat de ces changements.

C'était assez éprouvant, car il n'y a vraiment pas beaucoup de formes carrées dans cette chose, et elle se ferme assez étroitement, sans réel accès pour peaufiner une fois assemblée. J'ai beaucoup appris sur ce projet, comme l'utilisation de composants intégrés dans d'autres composants. Cela a rendu la manipulation et le maintien des sous-ensembles liés pour un accès rapide. Au final, ça en valait la peine !

Étape 2 : pièces imprimées en 3D

La tourelle du portail v4.zip est mise à jour et devrait contenir toutes les pièces imprimées nécessaires pour construire la dernière tourelle.

--- nouvelle "Jambe d'essai arrière". Pas fidèle à l'original, mais il est à l'arrière et permet d'utiliser un connecteur mini-USB droit vers le haut. ---

Ceux-ci ont été imprimés sur une Prusa Mk2, en utilisant du PLA pour toutes les pièces. L'orientation de l'impression doit être assez évidente. Le corps a été imprimé en position verticale, sans supports. Il y a le grand écart sur les côtés qui doit être comblé, mais je n'ai vraiment eu aucun gros problème avec des réglages assez standard, à part la bosse. La bosse à l'avant et à l'arrière peut être pratiquement éliminée avec un bon filament et de bons paramètres d'impression. J'ai trouvé que 0,2 mm fonctionnait bien dans la trancheuse et produisait un résultat décent. Toute plus grande et des ouvertures ont commencé à apparaître dans le corps près de la bande de remplissage.

La conception des canaux et des saillies a été réalisée avec des chanfreins à 45 degrés, de sorte que les éléments "suspendus dans l'espace" seront minimes.

J'ai eu peu de nettoyage à faire pour assembler l'ensemble. Les bandes de remplissage qui glissent dans les canaux sont maintenant assez simples, avec une largeur réduite et une épaisseur constante. Je pense que l'on pourrait utiliser une matière fine et noire découpée en bandes au lieu d'utiliser ces pièces imprimées (imprimées sur tranche).

Le seul domaine qui nécessite de la finesse est celui des broches du curseur dans le cadre de pas. Des goupilles droites (clous) dans les trous de forage qui sont chassées avec un foret de 1/8" et un peu de lubrifiant iront très loin.

Étape 3 : Composants

V4 (tourelle rouge) a un pont plus petit, nécessitant des ailes v4 et un cadre Pitch.

Le v6 ailes sont un option que permet différent couleur"pistolets". Je n'en ai pas fait un comme ça personnellement, mais ça devrait bien fonctionner.

Une fois le modèle terminé, et j'étais satisfait de mon prototype, j'ai imprimé la rev 2 avec les composants en plastique comme indiqué. Tout ici est du PLA, avec du noir et de la couleur design (bleu dans ce cas), et un tout petit peu de PLA translucide pour le "Lens" central ou l'œil laser.

Cette photo capture assez bien les composants, à l'exception du câblage.

Étape 4 :Électronique

La compilation utilise les composants suivants :

• Arduino Nano (1)

• DFPlayer Mini lecteur MP3 (ou MP3-TF-16P) (1)

• Capteur de distance de temps de vol VL53L0X (1)

• Micro servos génériques SG90 (3)

• LED rouges 5 mm (5)

• Résistances 220 Ohm pour LED (5)

• Résistance 1kOhm (1)

• Enceinte 4cm, 4Ohm, 3 Watt (1)

• Connecteur d'alimentation 2.1mm (1)

• Clous de charpente de 3" de long (4)

• Vis M2 x 6 (8)

• Vis M2,5 x 8 (2)

• Vis M3 x 8 (4)

• Vis M3 x 12 (4)

• Vis M3 x 16 (2)

• film rétractable

• petites cravates

Tous les composants sont facilement disponibles auprès d'Arduino, d'Amazon ou de Banggood et d'autres sources.

Les vis provenaient d'un kit d'assortiment. C'est pénible de les avoir autrement...

Étape 5 :Assemblage mécanique

La plupart de l'assemblage mécanique est raisonnable. Les pièces imprimées sont imprimées avec les plus gros trous taraudés si nécessaire, donc une chasse rapide avec une vis avant l'assemblage final sera utile et rendra l'assemblage des composants vissés assez facile.

L'Arduino et la puce MP3 s'enclenchent dans le berceau sans matériel. Le VL53LOX se glissera dans la coque avant sans attaches. Ajustez d'abord l'essai, puis retirez et installez une fois le câblage terminé.

L'ensemble coulissant utilise 4 clous de charpente comme rails coulissants. Ils mesurent environ 1/8" de diamètre, avec les têtes coupées. Ils ont été extraits d'une bande de clous à charpente DeWalt utilisés avec leur cloueuse à charpente électrique. Inutile de dire que les clous lisses sont indispensables.

Les servos se montent comme indiqué. L'orientation est importante. Les servos de pitch et de pivot sont "centrés" lors de l'installation dans leurs pièces. La manivelle est installée de telle sorte que, lorsqu'elle est en position ouverte, elle se ferme en tournant dans le sens inverse des aiguilles d'une montre, en vue de l'avant. La position ouverte correspond aux tiges et à la manivelle en ligne droite, avec une autre rotation de 10 degrés jusqu'au verrouillage.

L'assemblage des pieds est la partie la plus simple. Vis de 2 à 2,5 mm, avec les capuchons de jambe s'emboîtant sur les coudes de chaque jambe. Utilisez des attaches qui ne dépassent pas du haut de la plaque de jambe. De cette façon, le corps pivotant ne se bloquera pas si vous modifiez la plage de rotation.

Toutes les connexions des servos aux pièces imprimées sont effectuées à l'aide de la courte manivelle blanche fournie avec les servos. Ces manivelles s'enfoncent simplement dans les pièces imprimées. J'ai essayé d'imprimer l'alésage cannelé dans les pièces connectées à chaque servo, mais j'ai eu un succès limité et reproductible. Beaucoup plus facile d'utiliser les manivelles fournies avec les servos.

L'ensemble manivelle utilise les vis plus longues de 2,5 mm. Les tiges de manivelle ne doivent pas être coincées entre les moitiés de manivelle. En fait, vous pouvez essayer d'utiliser des vis plus courtes sans la partie Crank2. Cela devrait également fonctionner (espérons-le pas de couple appréciable ici si les ailes coulissent librement).

Le haut-parleur est capturé par un support servo (2 pièces) qui capture le haut-parleur. Haut-parleur entre ces "jambes", et maintenu en position en les fixant au servo de pitch. Ce servo est ensuite connecté à l'ensemble de pas (curseur), suivi de l'ensemble manivelle avec tiges. Le tout est assemblé avant d'être installé dans le corps LHS avec 4 petites vis.

Une fois que les entrailles principales sont installées, avec l'Arduino et le lecteur MP3 temporairement localisés, alors le plaisir commence - le câblage !

Étape 6 :Câblage

V5 - Option radio (photos de la tourelle rouge). Cela inclut une puce radio nRF24L01. Modifie complètement le câblage des broches Arduino pour s'adapter à toutes les connexions. Détails à venir...

L'emballage final est serré, donc passer du temps ici à déterminer les longueurs de fil en vaut la peine. La plupart des fils d'interconnexion avec lesquels je me suis retrouvé étaient entre 3" et 4".

Les LED sont directement câblées avec les résistances de 220 Ohm, suivies d'un film rétractable et d'une torsion de câblage, puis mises de côté après avoir été testées. J'ai utilisé un câblage de faible épaisseur ici car j'en avais traîné (câblage de communication de type CAT5) et je ne voulais pas que le câblage visible soit gênant.

Les embouts mécaniques sont simulés dans la coque, puis l'acheminement des fils est déterminé, puis la coupe et la préparation des fils sont la suivante.

J'ai construit les connecteurs des servos pour pouvoir brancher et remplacer les servos si jamais je gâchais quelque chose et dénudais les engrenages. Cela a été vraiment utile après avoir foiré lors de mon premier prototype.

Une fois satisfait du gros du câblage, les LED ont été soudées à la fin. Ensuite, il est temps de fourrer soigneusement l'ensemble filaire dans une moitié de la coque. La dernière étape consiste à souder le connecteur d'alimentation aux fils d'alimentation une fois que tout est à l'intérieur.

-- Remarque importante :assurez-vous que le câblage placé derrière le Nano n'appuie pas sur le bouton de réinitialisation !! Ceci causera évidemment des problèmes et empêchera l'unité de fonctionner correctement. --

À ce stade, tout le câblage est terminé, mais avant l'assemblage final, il est important de télécharger le code sur le Nano et de le mettre sous tension pour s'assurer que les LED, les servos et le lecteur MP3 fonctionnent comme prévu. Après cela, il est temps d'assembler le reste des pièces mécaniques.

Étape 7 : Code Arduino

Code mis à jour ! Je l'ai nettoyé et fait quelques ajustements.

Le fichier joint est ce que j'ai trouvé pour piloter l'unité comme indiqué dans les vidéos. Je vais continuer à peaufiner pour changer le caractère de la tourelle et la façon dont elle se comporte. Beaucoup d'options ici.

J'ai structuré le code à l'aide de sous-routines que j'appelle au besoin. Il garde le corps principal propre et a été très utile lorsque je jouais avec différentes caractéristiques. Cela m'a aidé à manipuler le code pour différents comportements.

J'ai également utilisé de nombreuses variables à l'avance, ce qui m'a aidé à peaufiner et à ajuster les positions de stationnement et les plages minimale et maximale, par exemple.

J'ai utilisé la bibliothèque DFMiniMP3 dans mon code. J'ai essayé d'autres bibliothèques, comme celle de DFRobot, mais j'ai eu des problèmes, alors je suis revenu à celle-ci. Cela signifiait que je devais garder les pièces du « vide statique » pour le garder fonctionnel. Ce ne sont pas nécessaires pour l'opération, mais bon, je ne suis pas un maître codeur. J'aimerais entendre parler d'une autre bibliothèque aussi simple et soignée que la bibliothèque VL53LOX. Faites-moi savoir si vous trouvez une meilleure façon de le faire !

Quant aux sons, la mise en oeuvre se fait de manière simple, en ayant un dossier nommé "mp3" sur la carte SD, avec les noms de fichiers 0001.mp3, 0002.mp3, etc. Les quatre premiers chiffres doivent être dans ce format, mais vous pouvez ajouter n'importe quel suffixe après cela pour aider à identifier les sons particuliers. Voir https://www.dfrobot.com/blog-277.html pour un exemple. J'ai inclus une photo de mes noms de fichiers tels qu'ils sont utilisés sur le dossier. Les numéros correspondent aux rappels du code.

Les fichiers sonores que j'ai extraits de la page Wikipedia sur Portal Turret sons. Le code crée un fichier son aléatoire (1 sur 2 ou 3 sons) pour éviter que les choses ne se périment.

Étape 8 :Assemblage final du corps

Cette partie est un peu délicate à cause des bandes de remplissage noires. L'échelle de l'assemblage final est suffisamment petite pour que les bandes et les rainures de réception soient minuscules. Cela a nécessité de chasser le canal avec un pointeur ou un autre petit outil de grattage pour s'assurer que les bandes s'adapteraient avec peu de résistance avant d'essayer de mettre l'autre côté.

Attacher soigneusement les fils ensemble et les attacher si nécessaire rendra cela beaucoup plus facile.

J'en ai assemblé quelques-uns maintenant et je trouve qu'il est plus facile d'assembler les deux moitiés en premier, puis d'insérer les bandes de remplissage. Insérez un côté dans la moitié avec la "tablette" qui empêche la bande de remplissage de tomber, puis faites légèrement levier pour l'ouvrir et appuyez doucement. Pas trop mal maintenant.

C'était l'une des parties les plus délicates. Peut-être qu'un jour, je repenserai cet assemblage, mais j'aime son apparence une fois terminé, et il est assez robuste.

Étape 9 :Assemblages d'ailes

Maintenant que le corps est assemblé, avec les LED des ailes qui dépassent, il est temps de préparer les ailes et de les assembler.

Il est impératif que les trous du curseur soient ciselés avec un foret de 1/8", puis nettoyés. Coupez les têtes des clous à l'aide d'un coupe-boulons, d'un étau, d'une scie à métaux ou de l'outil de coupe de clous préféré. Les goupilles du curseur (clous coupés) ) sont installés dans les ailes en les ajustant à la presse dans chaque pièce d'aile. Des clous droits, ébavurés et lissés sont la clé pour faire ce travail. Les curseurs d'aile et les trous doivent être lubrifiés et testés avant de connecter les tiges de manivelle et de fonctionner. Sec graphite, ou un autre lubrifiant adapté au PLA est recommandé. Je trouve qu'un petit tube de lubrifiant personnel fonctionne très bien et est bon marché. C'est vraiment lisse. Cela nécessite également quelques « plaintes » lorsque votre partenaire ou parent entre et demande ce qui est exactement vous en avez besoin pour l'établi !!

Commencez par déterminer quelle partie de l'aile va où et essayez d'abord de faire glisser cette partie. Ensuite, assemblez les moitiés supérieure et inférieure une fois les broches installées, appliquez un peu de lubrifiant (un coton-tige fonctionne bien pour cela) et assurez-vous que les ailes glissent bien. Cela peut être délicat, mais sans vous assurer que les ailes glissent sans effort, sans se coincer, vous passerez un moment frustrant. Croyez-moi...

Une fois les ailes prêtes à l'emploi, il suffit de les faire glisser en place, de placer la bielle sur le trou de l'aile et de les assembler avec une seule vis. Ensuite, les LED sont insérées dans les trous des canons, les fils sont coincés contre l'aile et vous êtes prêt à partir ! Vous pouvez également utiliser de la colle chaude pour les verrouiller une fois que tout est testé.

Étape 10 :effrayez et choquez vos amis !

La dernière petite mise en garde sur cette conception est qu'une prise coudée est une excellente idée, car elle n'interfère pas avec la jambe arrière lors du pivotement. La jambe arrière révisée (v3) a été étirée pour donner un peu plus d'espace.

Une fois construit et branché (5V ou adapté pour Nano), il restera silencieux jusqu'à ce que quelqu'un soit détecté dans la distance programmée, puis s'animera et tuera quiconque pénètre dans son domaine !

Faites-moi savoir si vous en construisez un (ou plusieurs) et si vous proposez de nouvelles fonctionnalités ou de nouveaux concepts !

Code

• Tourelle de portail avec radio (ROUGE)

Tourelle de portail avec radio (RED)C/C++

///* Tourelle de portail - Option avec radio !! * Chris Nowak - février 2019 * https://www.instructables.com/member/ChrisN219/ * https://create.arduino.cc/projecthub/Novachris/talking-portal-2-turret-gun-637bf3 * * Ce Le code comprend toutes les fonctionnalités nécessaires pour exécuter l'opéra Cara Mia, * Temps de conversation et mode manuel, contrôlés par le contrôle de la tourelle Maseter (MTC). * Le MTC est un contrôleur séparé présenté sur une autre version. La tourelle * fonctionnera de manière autonome en utilisant ce code sans le MTC. * * Le code est conçu pour fonctionner avec trois tourelles, mais chacune fonctionnera indépendamment. * Beaucoup de code de débogage laissé dedans. Utilisez ou nettoyez comme vous le souhaitez. Il est principalement débogué, * mais n'est pas parfait. Vu le prix que tu as payé, je pense que c'est ok !;) * =================ROUGE ====================*/#include  #include #include "Arduino.h"#include #include #include #include #include # inclure class Mp3Notify{public:static void OnError(uint8_t errorCode) { // voir DfMp3_Error pour le code signifiant Serial.println(); Serial.print("Erreur Com "); Serial.println(errorCode); } static void OnPlayFinished(uint8_t globalTrack) { Serial.println(); Serial.print("Lecture terminée pour #"); Serial.println(globalTrack); } static void OnCardOnline (code uint8_t) { Serial.println(); Serial.print("Carte en ligne "); Serial.println(code); } static void OnCardInserted (code uint8_t) { Serial.println(); Serial.print("Carte insérée "); Serial.println(code); } static void OnCardRemoved (code uint8_t) { Serial.println(); Serial.print("Carte retirée "); Serial.println(code); }} ; Servo servo_pivot;Servo servo_wings;Servo servo_pitch;Capteur VL53L0X;// Configuration pour carte sonLogicielSerial secondaireSerial(4, 2); // RX, TXDFMiniMp3 mp3(secondarySerial); // Configuration pour la radio radioRF24 (10, 9); // nRF24L01 (CE,CSN)Réseau RF24Network (radio); // Inclut la radio dans le networkconst uint64_t this_node =01; // Cette tourelle - Rouge - au format Octal ( 04,031, etc)const uint64_t WHT =02; // Tourelle 02 - Whiteconst uint64_t BLU =03; // Tourelle 03 - Blueconst uint64_t MTC =00; // Contrôle de tourelle maîtreunsigned long previousMillis1 =0;unsigned long previousMillis2 =0;unsigned long previousMillis3 =0;byte LED_LH_up =A1;byte LED_LH_down =A2;byte LED_CENTRE =A3;byte LED_RH_up =7;byte LED_RH_down =8;byte PIVOT 6 ; //whitebyte WINGS =3; //yellowbyte PITCH =5; //bluebyte parkPIVOT =96; //Plus petit nombre tourne CW vu du topbyte posPIVOT =96;byte maxPIVOT =116;byte minPIVOT =76;byte WINGclose =165;byte WINGopen =10;byte WINGpos =160;byte parkPITCH =86;byte posPITCH =86; byte maxPITCH =96;byte minPITCH =75;byte pos =90;byte pulse =20;byte pitchCW =1;byte pivotCW =1;byte randomWake;byte randomOpen;byte randomFalse;byte randomStart;byte randomDisengage;int triggerDistance =300; octet buttonStatus;byte busyRed =1;byte restModeWhite;byte goState;int x;int y;byte pb1State; // Firebyte pb2State; // say random commentbyte pb3State;byte randomPic;// Payload from Master Turret Control (MTC)// int payload [] ={0, 1, 2 , 3 , 4 , 5 };// int payload [] ={x , y, pb1State, pb2State, pb3State, goState};int payload [6];/* Ceci est la carte de "conversation" pour "Chat Time". * 0-99 =dictons de la tourelle rouge * 100-199 =dictons de la tourelle blanche * 200-299 =dictons de la tourelle bleue * Les fichiers sur toutes les cartes SD sont enregistrés en tant que 0-100. * Ajoutez 100 au numéro de dossier ici pour le blanc, 200 pour le bleu. * Le fichier 204 serait une tourelle BLEUE, numéro de fichier 0004. */ int chatSayings [] ={ 0, // Démarrer la pause sur i =0, suivi de "rounds"... 204, 164, 25, // 1 205, 127, 76, // 2 208, 162, 65, // 3 143, 230, 23, // 4 130, 41, 225, // 5 153, 31, 133, // 6 234, 49, 155, / / 7 229, 175, 74, // 8 231, 58, 226, // 9 161, 223, 59, // 10 227, 68, 236, // 11 136, 50, 224, // 12 34, 160 , 78, // 13 222, 42 // End};/* Ceci est la carte de synchronisation des tourelles ROUGE et BLANC. Ils partagent des dictons. * Ces timings correspondent au temps nécessaire * pour jouer les dictons individuels, en millisecondes. * Modifiez les dictons ci-dessus comme vous le souhaitez, mais ne modifiez pas ces horaires. * Par exemple, i =2 prendra 0,8 seconde (NormalTimings[2]) * pour lire le fichier chatSayings[2]. */int NormalTimings [] ={1000, // Commencer la pause sur i =0, suivi de "rounds"...2600, 800, 2800, 900, 1700, 1600, 1300, 2500, 1400, 1900, // 1 - 101600, 2300, 800, 3000, 300, 100, 200, 0, 0, 300, // 11 - 20298000, 1300, 2600, 1300, 1400, 2100, 1900, 1600, 800, 1700, // 21 - 301100 , 1000, 1000, 2100, 1500, 1300, 1100, 800, 1200, 1000, // 31 - 402200, 1700, 1300, 1400, 1500, 1000, 2000, 500, 2700, 9000, // 41 - 501100, 1200 , 900, 2400, 1200, 1100, 2100, 2000, 2500, 1700, // 51 - 601100, 1000, 1100, 500, 1900, 0, 1300, 2100, 1700, 900, // 61 - 701100, 800, 1100 , 1700, 1100, 1100, 1500, 1500, 500, 900, // 71 - 802100 // 81};/* Ceci est la carte de synchronisation de la tourelle BLEUE. * Ces timings correspondent au temps nécessaire * pour jouer les dictons individuels, en secondes. * Par exemple, i =2 prendra 0,9 secondes (DefectiveTimings[2]) * pour lire le fichier chatSayings [2]. */int DefectiveTimings [] ={1000, // Commencer la pause sur i =0, suivi de "rounds"...1700, 900, 2000, 600, 1100, 1800, 1900, 3000, 1500, 800, // 1 - 102100, 800, 1900, 900, 3200, 2700, 0, 0, 0, 2000, // 11 - 204400, 800, 3200, 900, 1400, 2000, 2100, 1200, 1300, 1000, // 21 - 301100 , 1400, 2100, 1000, 1600, 1000, 1200 // 31 - 40};////////////////////////////// ////////////////////////////////// //=======================CONFIGURATION =================================///// ////////////////////////////////////////////////////////////// //////////////void setup(){ secondaireSerial.begin(9600);// Serial.begin(9600);// mp3.begin(); mp3.setVolume(22); Fil.begin(); SPI.begin(); // Configuration de la radio radio.begin(); radio.setPALevel(RF24_PA_LOW); // met la radio à faible puissance. Tous proches les uns des autres radio.setDataRate(RF24_2MBPS); // Je trouve que cela fonctionne mieux avec plusieurs radios network.begin(70, this_node); //(canal, adresse de nœud) sensor_read(); pinMode(LED_LH_up, SORTIE); pinMode(LED_LH_down, SORTIE); pinMode(LED_CENTRE, SORTIE); pinMode(LED_RH_up, SORTIE); pinMode (LED_RH_down, SORTIE); digitalWrite(LED_CENTRE, HAUT); activate_servos(); servo_wings.write(WINGopen); // ailes ouvertes servo_pivot.write(parkPIVOT); // garer le pivot servo_pitch.write(parkPITCH); // parc de stationnement randomWake =random(1, 3); mp3.playMp3FolderTrack(1) ; // lecture du délai de commentaire de réveil (2000); servo_wings.write(WINGclose); // délai de fermeture des ailes (1500); digitalWrite(LED_CENTRE, BAS); turn_off_servos(); occupéRouge =0;}/////////////////////////////////////////// ///////////////////////=======================BOUCLE PRINCIPALE =============================//////////////////// /////////////////////////////////////////////boucle vide( ){ while (sensor.readRangeSingleMillimeters()>triggerDistance) { //rien devant le capteur, ne fait rien ReadNet(); WriteNet(); output_sensor(); if (payload[5] ==1) { // Conditions utilisées avec MTC. La tourelle fonctionnera automatiquement sans délai MTC (500); WriteNet(); Cara Mia(); // L'heure de l'opéra !! } else if (payload[5] ==2) { delay(500); WriteNet(); Chatty_time(); // Moment bavard !!} ReadNet(); } else if (payload[5] ==3) { delay(500); WriteNet(); Contrôle manuel (); // Contrôle manuel } } if (sensor.readRangeSingleMillimeters()triggerDistance){ // ouvert et la personne est devenue falseActivate(); //dites "où es-tu allé ?" commentaire et délai de fermeture (2000); scanArea(); //effectuer une analyse de la zone } else { // quelqu'un est définitivement là - ouvrez le feu !! engager(); retard (2400); for (int j=0; j <=2; j++){ if (sensor.readRangeSingleMillimeters()=maxPIVOT) pivotCW =0; si (posPIVOT <=minPIVOT) pivotCW =1 ; si (posPITCH>=maxPITCH) pitchCW =0 ; si (posPITCH <=minPITCH) pitchCW =1;}///////////////////////////////////// /////////////////////////////=======================ACTIVER =============================/////////////// ////////////////////////////////////////////////////////////// ////void activate(){ // ouvre des ailes et dit quelque chose busyRed =1; ReadNet(); WriteNet(); output_sensor(); digitalWrite(LED_CENTRE, HAUT); // Oeil LED sur randomOpen =random (3, 6); // choisissez le commentaire d'ouverture aléatoire mp3.playMp3FolderTrack (randomOpen); // joue au hasard le commentaire "Je te vois" servo_wings.write(WINGopen); // ouvre les ailes output_sensor(); délai (3400);}////////////////////////////////////////// ///////////////////////====================FAUX ACTIVER ============================//////////////////////// ///////////////////////////////////////// void falseActivate(){ / /occupéRouge =1 ; ReadNet(); WriteNet(); output_sensor(); randomFalse =random (6, 9); // choisissez le commentaire d'ouverture aléatoire mp3.playMp3FolderTrack (randomFalse); // play random "where'd you go?" comment delay (1800);}/////////////////////////////////////////////////////////////////////=======================SCAN AREA =============================/////////////////////////////////////////////////////////////////////void scanArea(){ // continue scanning for a bit after falseActivate busyRed =1; ReadNet(); WriteNet(); output_sensor(); mp3.playMp3FolderTrack(2); // "searching..." servo_pitch.write(parkPITCH); delay(1600); servo_pitch.detach(); servo_wings.detach(); mp3.playMp3FolderTrack(21); for (int i=0; i <=220; i++){ //scan for a little bit... output_sensor(); if (pivotCW ==0) posPIVOT =posPIVOT - 1; // increment one step CW if CW =0 if (pivotCW ==1) posPIVOT =posPIVOT + 1; // otherwise go one step other direction if (posPIVOT>=maxPIVOT) pivotCW =0; // if max rotation clockwise, switch to counterclockwise if (posPIVOT <=minPIVOT) pivotCW =1; // if min rotation counterclockwise,switch to clockwise servo_pivot.write(posPIVOT); if (sensor.readRangeSingleMillimeters()=(850 + (i * 100))) { // 1050 randomWingPos =random(10 + (i*20), (60 + (i*20))); servo_wings.write(randomWingPos); previousMillis1 =millis(); } } } disengage(); busyRed =0; goState =0; mp3.stop(); ReadNet(); delay(1000);}/////////////////////////////////////////////////////////////////// //=======================CHATTY TIME ===========================/////////////////////////////////////////////////////////////////////void Chatty_time(){ busyRed =1; WriteNet(); int i =0; int talk; int saying; int timeadder =750; int talkTime =NormalTimings[i]; int randomPivotPos; activate_servos(); servo_wings.write(WINGopen); digitalWrite(LED_CENTRE, HIGH); do { ReadNet(); WriteNet(); //output_sensor(); // used for debugging... if (i>=43) { // end of sequence busyRed =0; WriteNet(); disengage(); retourner; } unsigned long currentMillis =millis(); // grab current time if ((unsigned long)(currentMillis - previousMillis3)>=talkTime) { if (chatSayings[i] <100) { // RED Turret talking talk =chatSayings[i]; saying =chatSayings[i]; talkTime =(NormalTimings[saying] + timeadder); } else if ((chatSayings[i]> 99) &&(chatSayings[i] <200)) { // WHITE turret talking talk =0; saying =chatSayings[i] - 100; talkTime =(NormalTimings[saying] + timeadder); } else { // BLUE turret talking talk =0; saying =chatSayings[i] - 200; // sound file # of BLUE talkTime =(DefectiveTimings[saying] + timeadder); // Time for that saying } if (talk ==0) { digitalWrite(LED_CENTRE, LOW); } else { digitalWrite(LED_CENTRE, HIGH); mp3.playMp3FolderTrack(talk); } randomPivotPos =random(minPIVOT, maxPIVOT); servo_pivot.write(randomPivotPos); Serial.println(); Serial.print(F("i:")); Serial.print (i); Serial.print ("\t"); Serial.print(F("chatSayings[i] ")); Serial.print (chatSayings[i]); Serial.print ("\t"); Serial.print(F("Saying ")); Serial.print (saying); Serial.print ("\t"); Serial.print(F("talk ")); Serial.print (talk); Serial.print ("\t"); Serial.print(F("chat time ")); Serial.print (talkTime); Serial.print ("\t"); Serial.print(F("busyRed:"));Serial.print (busyRed); Serial.print (" "); previousMillis3 =millis(); i++; } } while (payload[4] ==1); busyRed =0; WriteNet(); digitalWrite(LED_CENTRE, LOW); disengage();}/////////////////////////////////////////////////////////////////// //=======================MANUAL CONTROL =======================/////////////////////////////////////////////////////////////////////void ManualControl(){ int servoWings; int servoPitch; int servoPivot; activate_servos(); servo_wings.write(WINGopen); digitalWrite(LED_CENTRE, HIGH); ReadNet(); do { output_sensor(); ReadNet(); servoPivot =map(payload[0], 1023, 0, minPIVOT, maxPIVOT); servoPitch =map(payload[1], 1023, 0, minPITCH, maxPITCH); servo_pivot.write(servoPivot); servo_pitch.write(servoPitch); unsigned long currentMillis =millis(); // grab current time if (payload[3] ==0) { if ((unsigned long)(currentMillis - previousMillis1)>=2500) { randomPic =random(1, 20); mp3.playMp3FolderTrack(randomPic); previousMillis1 =millis(); } } if (payload[2] ==0){ fire(); } } while (payload[5] ==3); disengage(); busyRed =0; WriteNet(); digitalWrite(LED_CENTRE, LOW); }/////////////////////////////////////////////////////////////////////=========================RECEIVING ===========================/////////////////////////////////////////////////////////////////////void ReadNet(){ network.update(); if ( network.available() ) { RF24NetworkHeader header; network.peek(header); network.read(header, &payload, sizeof(payload));} // Read the package }/////////////////////////////////////////////////////////////////////=========================SENDING =============================/////////////////////////////////////////////////////////////////////void WriteNet(){ network.update(); RF24NetworkHeader header4(MTC); bool ok4 =network.write(header4, &busyRed, sizeof(busyRed));/* if (ok4) { // used for debugging... Serial.print("MTC ok4 ");} else { Serial.print("------- ");} */}

Pièces et boîtiers personnalisés

Schémas