Horloge d'arcade rétro

Outils et machines nécessaires

Imprimante 3D (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Intro :Horloge d'arcade rétro - Arduino

Construisez une horloge de chevet d'arcade interactive, avec un écran tactile et des figurines d'arcade animées que vous pouvez enregistrer un son de votre choix pour l'alarme.

Le projet comprend un boîtier imprimé en 3D et quatre programmes distincts parmi lesquels choisir

1. Horloge d'arcade - Animation DK Mario, Space Invaders et Pac-Man

2. Pacman Clock - Jeu interactif animé Pac-Man avec fonctions d'horloge

3. DK Clock - Jeu DK animé interactif avec fonctions d'horloge

4. Tumble Ghost - Jeu de fantômes animé Pac-Man basé sur Flappy Bird

Beaucoup de plaisir à construire et un excellent cadeau pour tous ceux qui aiment revivre la nostalgie des personnages de jeux d'arcade des années 80.

Étape 1 :Rassemblez les matériaux

• Carte Arduino - Arduino Mega 2560 (les articles 1, 2 et 3 peuvent être achetés en une seule commande groupée)

• Bouclier Arduino pour écran tactile - Bouclier de carte d'extension LCD Mega Touch 3,2"

• Écran tactile - Écran LCD TFT 3,2" + écran tactile pour Arduino Mega 2560

• Module horloge temps réel - DS3231 RTC

• Module enregistreur vocal - enregistreur vocal ISD1820

• Filament PLA pour imprimante 3D

• Résine époxy en deux parties pour le collage du boîtier

• Câble USB Chargeur USB de longueur 2m (utilisé pour l'alimentation de l'horloge)

• Pistolet à colle chaude

• Attaches de câble X 3

Composants de gradation automatique du rétroéclairage en option uniquement requis si une horloge de chevet :

• Résistance 270k ohm

• Diode Zener 3.3v

• Résistance de 0,5 watt 47 ohms

• Résistance dépendante de la lumière (LDR)

Étape 2 :Imprimez le boîtier 3D

J'ai imprimé le boîtier de l'horloge sur une Creality Ender 3. Tous les fichiers d'impression 3D et les instructions pour le boîtier se trouvent ici sur Thingiverse.

Étape 3 : Construisez le circuit

Le circuit global contient une horloge en temps réel, un Arduino Mega, un module de son, un écran tactile et un écran de protection.

1. Horloge en temps réel

Montez l'horloge en temps réel à l'arrière de l'Arduino Mega comme sur l'image fournie. J'ai utilisé un pistolet à colle chaude et de la mousse d'emballage pour m'assurer qu'ils ne se touchent pas et qu'il y a un rembourrage pour absorber le mouvement. Dans mon cas, j'ai soudé 2 des pattes RTC directement à l'Arduino et utilisé un fil de raccordement pour connecter 5v et GND à l'Arduino.

2. Module d'enregistrement sonore

Ceux-ci sont vraiment cool et faciles à utiliser. De la même manière que ci-dessus, utilisez de la mousse et de la colle chaude pour positionner le module et le haut-parleur à l'arrière de l'Arduino en veillant à ce qu'ils soient isolés du toucher. Le module de son est déclenché par D8 sur l'Arduino, donc celui-ci et l'alimentation doivent être connectés conformément au schéma de circuit fourni.

3. Variateur de rétroéclairage automatique (facultatif)

Si vous avez l'intention de l'utiliser comme horloge de chevet, vous voudrez probablement baisser automatiquement le rétroéclairage la nuit afin que cela n'affecte pas votre sommeil. (Si ce n'est pas le cas, vous pouvez sauter cette étape !) Malheureusement, le rétroéclairage de l'écran TFT est câblé à +3,3 V et ne peut pas être réglé avec l'Arduino. Cela signifie que nous devons le déconnecter et nous reconnecter à une broche PWM sur l'Arduino pour contrôler la luminosité du rétroéclairage. Je voulais le faire avec un minimum de dommages aux broches ou aux pistes des composants, j'ai donc adopté l'approche suivante. Suivez attentivement les étapes ci-dessous

(a) Pour ce faire, une résistance dépendante de la lumière (LDR) est positionnée à l'arrière de l'unité pour détecter la lumière. Percez deux trous de 3 mm dans le boîtier et poussez les pieds LDR à travers les trous. Utilisez de la colle chaude à l'intérieur de l'armoire pour maintenir les pieds en place. Soudez deux fils à l'intérieur du boîtier et connectez-les selon le schéma de circuit. Ajoutez une résistance de 270k Ohm à A7 de l'Arduino selon le schéma de circuit.

(b) Retirez l'écran TFT et placez-le sur une surface ferme. Identifiez la broche 19 (LED_A) et retirez soigneusement quelques millimètres de plastique à la base de la broche. Pliez la broche à plat et loin du connecteur comme indiqué sur l'image ci-dessus. Vérifiez que le TFT Sheild peut se brancher parfaitement et que la broche tordue n'obstrue pas la fiche ou la prise.

(c) Soudez un registre de 47 Ohm au pli sur la broche et connectez un fil de la résistance à D9 de l'Arduino Mega. La broche Arduino D9 peut absorber jusqu'à 40 mA, donc la résistance le limite à moins que cela. Fixez une diode Zener 3,3 V à la même broche (LED_A) et connectez-la à la terre selon le schéma. Le but de ceci est de protéger le rétroéclairage contre les surtensions car il régulera la tension à 3,3v.

4. Écran TFT et bouclier Arduino

Poussez délicatement les connecteurs de l'écran tactile TFT 3,2 'dans le blindage TFT Arduino. Ensuite, connectez-vous soigneusement au haut de l'Arduino selon l'image fournie. Le RTC a une batterie et conservera donc l'heure correcte même si l'alimentation a été coupée. L'heure de l'alarme est stockée dans l'Eeprom sur l'Arduino, ce qui signifie qu'elle sera conservée en cas de coupure de courant.

Étape 4 :Chargez le code

Le projet nécessitera le chargement des fichiers et bibliothèques suivants avant de se compiler et de s'exécuter. Le code est unique et construit autour de la capacité des bibliothèques, du matériel, de certains graphiques personnalisés et d'autres projets que j'ai empruntés.

Veuillez noter :Le développement du code pour ce projet a utilisé IDE v1.06 et certaines des bibliothèques requises sont obsolètes. Cela signifie que certaines personnes rencontrent des problèmes avec la nouvelle version IDE 1.6 et supérieure lors du chargement du code. Par conséquent, dans un souci de simplicité, je recommande aux gens d'utiliser IDE v1.06 et d'avoir inclus les fichiers de bibliothèque de version corrects dans les fichiers zip au bas de l'étape 4 du didacticiel.

1. IDE Arduino

J'ai utilisé une version antérieure de l'IDE Arduino, donc dans un souci de simplicité, je vous recommande de télécharger la version 1.06 de l'IDE Arduino sur votre ordinateur de bureau avant d'installer le code. Vous pouvez obtenir sa version ici.

2. Bibliothèques

Ceux-ci doivent être téléchargés et ajoutés à l'IDE (environnement de développement intégré) qui s'exécute sur votre ordinateur, utilisé pour écrire et télécharger le code informatique sur la carte physique.

• UTFT.h et URtouch.h situés dans le fichier zip ci-dessous

• Time.h situé dans le fichier zip ci-dessous

• DS1307RTC.h situé dans le fichier zip ci-dessous

• Wire.h et EEPROM.h sont déjà inclus dans IDE V1.06

Le crédit pour UTFT.h et URtouch.h revient à Rinky-Dink Electronics. J'ai inclus ces fichiers zip car il semble que le site Web source soit en panne.

4. Variations d'écran TFT

Les flous des écrans TFT et des constructeurs ont conduit à ces notes.

(a) Sainsmart - Si vous avez acheté un écran TFT de 3,2 pouces portant la marque Sainsmart à l'arrière de l'appareil TFT, vous aurez constaté qu'ils doivent modifier les bibliothèques pour résoudre les problèmes d'affichage. Si vous avez déjà acheté un écran TFT Sainsmart, il existe un correctif ci-dessous

Editez le fichier "initlcd.h" et modifiez la ligne suivante de

LCD_Write_COM_DATA (0x01, 0x2B3F);

à

LCD_Write_COM_DATA (0x01, 0x3B3F);

Vous devrez redémarrer l'IDE, puis recharger le code sur l'Arduino.

(b.) Jeu de puces de contrôleur TFT - Les personnes qui ont acheté un écran TFT de 3,2" peuvent également découvrir qu'elles peuvent également avoir l'un des deux jeux de puces différents "SSD1289" ou "ILI9341". c'est facile à réparer. Si vous obtenez un écran vide après avoir chargé le code, c'est probablement parce qu'il s'agit d'un contrôleur ILI9341.

Pour résoudre ce problème, vous devez apporter les modifications suivantes au code. Editez le code et modifiez la ligne de code suivante

de

UTFT monGLCD (SSD1289, 38, 39, 40, 41); //Les paramètres doivent être ajustés à votre modèle d'affichage/écran

à

UTFT monGLCD(ILI9341_16, 38, 39, 40, 41); //Les paramètres doivent être ajustés à votre modèle d'affichage/écran

Essayez maintenant de recharger le code sur l'Arduino.

(c.) Commandes d'écran tactile inversées

Certains fabricants ont signalé que les boutons de l'écran tactile de l'axe Y ont été inversés. Un correctif pour cela a été identifié où deux lignes de code à changer pour retourner la lecture de l'écran tactile.

Faites une recherche pour :"yT =myTouch.getY();" Remplacez-le par :"yT =240 - myTouch.getY();"

N'oubliez pas de chercher deux fois, la première instance est pour contrôler pacman en mode horloge, la seconde est pour le menu de configuration.

5. Fichiers graphiques

Il existe un groupe de fichiers bitmap que j'ai inclus ci-dessous qui doivent se trouver dans le même sous-répertoire que le code Arduino lorsque vous commencez à charger dans l'Arduino. Par conséquent, téléchargez les fichiers ci-dessous et utilisez l'IDE pour charger.

6. Configurer l'horloge

Une fois le code chargé avec succès, appuyez sur le centre de l'écran et cela devrait faire apparaître l'écran de configuration. Utilisez le menu pour régler l'heure et l'alarme au format 24 heures. Appuyez sur le bouton SAVE pour enregistrer le réglage. Le RTC a une batterie et conservera donc l'heure correcte même si l'alimentation a été coupée. L'heure de l'alarme est stockée dans l'EEPROM, ce qui signifie qu'elle sera conservée en cas de coupure de courant.

7. Test de l'alarme

Le module de son est utilisé pour fournir l'alarme. L'ISD1820 est contrôlé par la broche Arduino D8. Le son peut être facilement ajouté en jouant du son dans le microphone tout en appuyant simultanément sur le bouton d'enregistrement de l'ISD1820. Dans mon cas, j'ai enregistré la musique d'introduction originale de Pac-Man à partir d'un fichier audio lu via un autre appareil. Une fois le son enregistré, l'enregistrement peut être testé en appuyant sur le bouton PLAY-E qui devrait diffuser le son via le haut-parleur. Utilisez le menu de configuration pour régler l'heure de l'horloge et l'heure de l'alarme à quelques minutes d'intervalle. Assurez-vous de « RÉGLER » l'alarme et appuyez sur les boutons de menu « ENREGISTRER ». Une fois de retour à l'écran principal, l'alarme devrait sonner à l'heure. La désactivation de l'alarme peut être effectuée en appuyant au centre du panneau de l'écran tactile, ce qui donne l'écran de configuration.

8. Calibrage de l'écran tactile

Certains fabricants ont constaté que les boutons de l'écran de configuration ne s'alignaient pas avec les commandes tactiles TFT. Dans ces cas, l'écran tactile doit être étalonné. Cela peut être facilement fait en utilisant le code d'étalonnage de l'écran tactile et les instructions fournies dans la bibliothèque URtouch. Suivez ces instructions si vous observez ce problème.

9. Quatre programmes différents au choix

1. Horloge d'arcade - DK Mario, Space Invaders &Pacman animation2. Pacman Clock - Jeu interactif animé Pacman/Ms Pacman avec fonctions d'horloge

3. DK Clock - Jeu DK animé interactif avec fonctions d'horloge

4. Tumble Ghost - Jeu animé Pacman Ghost basé sur Flappy Bird

Étape 5 :Tout assembler

1. Ajout d'une alimentation externe

La dernière étape consiste à ajouter l'alimentation externe. À l'aide d'un foret, ajoutez un trou à l'arrière de l'armoire. Faites passer le câble USB à travers le panneau arrière, puis fixez les fils VCC, GND, D+ et D- du câble USB à la base du connecteur USB Arduino selon le schéma de circuit. Cela présente deux avantages, d'une part, l'entrée USB des cartes Arduino Mega est protégée contre les surintensités, et d'autre part, vous pouvez utiliser le câble USB pour télécharger les modifications de code sans avoir à démonter le boîtier. Collez à chaud l'isolation du câble d'alimentation à l'arrière de l'Arduino pour fournir une protection contre la tension du câble lors de l'assemblage des panneaux avant et arrière. Ajoutez un serre-câble au câble en plaçant un serre-câble fermement autour du câble à l'intérieur du boîtier sur le câble d'alimentation à 6-8 cm de la connexion Arduino. Le serre-câble doit éviter les tensions sur les articulations lorsque le câble USB est tiré en butant contre l'intérieur du boîtier.

2. Montage de l'électronique dans le boîtier

Placez le circuit sur le dessus du panneau avant avec les quatre guides de trous qui doivent aligner l'écran au centre de la découpe. Mettez le circuit sous tension afin que vous puissiez voir l'écran du panneau avant, vérifiez que l'image de l'écran est dans la bonne position, puis collez-la avec de la colle chaude. Le résultat est un ajustement parfait avec un écran carré qui est centré dans le trou découpé.

3. Assemblage final

Poussez doucement le panneau avant sur le panneau arrière et tirez doucement sur le cordon d'alimentation USB pour rattraper le mou dans le panneau arrière. Le serre-câble est utile ici et devrait protéger tout dommage au câblage. Branchez le chargeur USB et vous êtes prêt à partir.

J'espère que vous apprécierez !

Code

• Horloge d'arcade rétro

Horloge d'arcade rétroC/C++

/* Retro Arcade Clock - TechKiwigadgets V1 - Première version de production*/ #include  #include #include #include  #include  #include  // une bibliothèque DS1307 de base qui renvoie l'heure en tant que time_t// Variables d'alarmeboolean alarmstatus =false; // indicateur où false est désactivé et true est onboolean soundalarm =false; // Drapeau pour indiquer que l'alarme doit être déclenchéeint alarmhour =0; // heure de réglage de l'alarmeint alarmminute =0; // Minute de réglage de l'alarmebyte ahour; //Variable d'octet pour hourbyte amin; //Variable d'octet pour minuteint actr =300; // Lorsque l'alarme retentit, c'est un compteur utilisé pour réinitialiser la carte son jusqu'à ce que l'écran touchedint act =0;int p =0; // Position d'animation E.G Pacman Graphic Flag 0 =Closed, 1 =Medium Open, 2 =Wide Open, 3 =Medium Openint m =0; // Position de l'animation mario 3 positions// Coordonnées graphiques X,Y// myGLCD.drawBitmap (30, 14, 40, 40, rd_ghost); // Ghostint fermé ghostX =15;int ghostY =14;int ghostD =0; // direction d ==0 =droite, 1 =bas, 2 =gauche, 3 =haut // myGLCD.drawBitmap (140, 14, 40, 40, MarioR3) ; // Ghostint fermé MarioX =141;int MarioY =14;int MarioD =0; // direction d ==0 =droite, 1 =bas, 2 =gauche, 3 =haut // myGLCD.drawBitmap (240, 14, 40, 40, Monkey2); // Fermé Ghostint MonkeyX =261;int MonkeyY =14;int MonkeyD =0; // direction d ==0 =droite, 1 =bas, 2 =gauche, 3 =haut // myGLCD.drawBitmap (30, 180, 40, 40, pacman); // Fantôme fermé pacmanX =15;int pacmanY =185;int pacmanD =2; // direction d ==0 =droite, 1 =bas, 2 =gauche, 3 =haut// myGLCD.drawBitmap (140, 180, 40, 40, Alien); // Fermé Ghostint AlienX =141;int AlienY =185;int AlienD =2; // direction d ==0 =droite, 1 =bas, 2 =gauche, 3 =haut// myGLCD.drawBitmap (240, 180, 40, 40, Cannon); // Closed Ghost int CannonX =270;int CannonY =185;int CannonD =2; // direction d ==0 =droite, 1 =bas, 2 =gauche, 3 =haut// Initialise les valeurs de temps RTC :const int DS1307 =0x68; // Adresse du DS1307 voir fiches techniques// Display Dimmer Variablesint dimscreen =255; // Cette variable est utilisée pour piloter la luminosité de l'écran où 255 est la luminosité maxint LDR =100; // Variable LDR mesurée directement depuis Analog 7//====Création d'objetsUTFT myGLCD(SSD1289,38,39,40,41); //Les paramètres doivent être ajustés à votre modèle d'affichage/d'écranURTouch myTouch( 6, 5, 4, 3, 2);//====Définition de la policeextern uint8_t SmallFont[];extern uint8_t BigFont[];extern uint8_t SevenSegNumFont[]; extern uint8_t SevenSeg_XXXL_Num[];// Définir bitmapsextern unsigned int Alien1[0x640] ; // Alien 1 graphicextern unsigned int Alien2[0x640]; // Alien 2 graphicextern unsigned int Cannon[0x640]; // Space invaders cannonextern unsigned int MarioL1[0x310]; // M Gauche 1extern non signé int MarioL2[0x310]; // Ghost Bitmap Straight aheadextern unsigned int MarioL3[0x310]; // Ghost Bitmap Straight aheadextern non signé int MarioR1[0x310]; // Ghost Bitmap Straight aheadextern non signé int MarioR2[0x310]; // Ghost Bitmap Straight aheadextern unsigned int MarioR3[0x310]; // Ghost Bitmap Straight aheadextern non signé int MarioStop[0x310]; // Ghost Bitmap Straight aheadextern unsigned int MarioU1[0x310]; // Ghost Bitmap Straight aheadextern unsigned int MarioU2[0x310]; // Ghost Bitmap Straight aheadextern unsigned int MarioU3[0x310]; // Ghost Bitmap Straight aheadextern unsigned int MarioU4[0x310]; // Ghost Bitmap Straight aheadextern unsigned int rd_ghost[784]; // Ghost Bitmap Straight aheadextern unsigned int ru_ghost[784]; // Ghost Bitmap Straight aheadextern unsigned int rl_ghost[784]; // Ghost Bitmap Straight aheadextern unsigned int rr_ghost[784]; // Ghost Bitmap Straight aheadextern unsigned int r_o_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int r_m_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int l_o_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int l_m_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int u_m_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int u_o_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int d_m_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int d_o_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int c_pacman[784]; // Ghost Bitmap Straight aheadextern unsigned int Monkey2[0x640]; // Ghost Bitmap Straight aheadextern unsigned int Monkey3[0x640]; // Ghost Bitmap Straight ahead// Coordonnées de l'écran tactileboolean screenPressed =false;int xT,yT;int userT =4; // indicateur pour indiquer le toucher directionnel sur screenboolean setupscreen =false; // utilisé pour accéder à l'écran de configuration//variables de configuration d'alarmeboolean xsetup =false; // Indicateur pour déterminer si le mode de configuration existant// Délai d'animation pour ralentir le mouvement downint dly =0; // Orignally 30// Time Refresh counter int rfcvalue =300; // attendre longtemps jusqu'à ce que le temps de vérification des changements rfc =1 ; // Déclare les variables globales pour l'heure précédente, pour permettre l'actualisation des seuls chiffres qui ont changé // Il y a quatre chiffres qui doivent être dessinés indépendamment pour assurer un positionnement cohérent de l'heure entier c1 =20; // Chiffre des dizaines d'heures int c2 =20; // Chiffre des heures int c3 =20; // Chiffre des minutes des dizaines int c4 =20; // Ones minute digitvoid setup() {//Initialize RTC Serial.begin(9600); // while (!Serial); // attendre jusqu'à ce que Arduino Serial Monitor ouvre delay(200); setSyncProvider(RTC.get); // la fonction pour obtenir l'heure du RTC setSyncInterval(60); // synchronise l'heure toutes les 60 secondes (1 minutes) if(timeStatus()!=timeSet){ Serial.println("Impossible de synchroniser avec le RTC"); RTC.set(1408278800); // régler le RTC sur 25 août 2014 9h00 setTime(1408278800); } else{ Serial.println("RTC a réglé l'heure système"); }// L'alarme de configuration permet à la broche de lire le son sur la carte ISD1820 pinMode (8, OUTPUT); // D8 utilisé pour basculer le son digitalWrite(8,LOW); // Définir sur faible pour désactiver le son // Lancer l'affichage myGLCD.InitLCD(); monGLCD.clrScr(); monTouche.InitTouch(); myTouch.setPrecision(PREC_LOW); écran de dessin(); // Lancer le jeu UpdateDisp(); // mise à jour de la valeur sur l'horloge }boucle vide() {// incrémentation du drapeau graphique Pacman 0 =fermé, 1 =moyennement ouvert, 2 =large ouvertp=p+1; si(p==4){ p=0; // Remettre le compteur à fermé}// incrémenter le Drapeau Graphique Pacman 0 =Fermé, 1 =Moyen Ouvert, 2 =Large Ouvertm=m+1; si(m==3){ m=0; // Réinitialiser le compteur à fermé} // Définir la luminosité de l'écran // Vérifiez la lumière ambiante et ajustez la luminosité de la LED en fonction de la luminosité ambiante. Environ 500 sombres sont inférieurs à 100 LDR =analogRead (A7) ; 28, 36); monGLCD.setBackColor(0, 0, 0); myGLCD.printNumI(LDR,250,60);*/if (LDR>=121){ dimscreen =255; } if (LDR <=120) { dimscreen =45; } analogWrite(9, dimscreen); // Contrôle la luminosité 0 est sombre, la pièce ambiante est d'environ 25 et 70 est la lumière directe du soleil // Lisez la date et l'heure actuelles à partir du RTC et réinitialisez boardrfc++ ; if (rfc>=rfcvalue) { // compter les cycles et imprimer le temps UpdateDisp(); // met à jour la valeur pour l'horloge puis ... dly =18; // réinitialiser le délai rfc =0; }//===Vérifier si l'alarme doit être déclenchée if (alarmstatus ==true){ if ( (alarmhour ==hour()) &&(alarmminute ==minute())) { // Sonner l'alarme soundalarm =true; } }//===Démarrer le son de l'alarme - Le son paie pendant 10 secondes puis redémarre à 20 secondes markif ((alarmstatus ==true)&&(soundalarm==true)){ // Déclenche un compteur et prend des mesures pour redémarrer son si l'écran n'est pas touché if (act ==0) { // Déclenche l'alarme en basculant D8, son enregistré déclenché par la transition LOW à HIGH digitalWrite (8, HIGH); // Mettre digitalWrite(8,LOW); // Définir un faible UpdateDisp(); // mettre à jour la valeur pour l'horloge } act =act +1; if (act ==actr) { // Déclenche l'alarme en basculant D8, son enregistré déclenché par la transition LOW à HIGH digitalWrite (8, HIGH); // Mettre digitalWrite(8,LOW); // Set low act =0; // Réinitialiser le compteur toutes les 20 secondes } }// Vérifier si l'utilisateur saisit l'écran tactile// UserT définit la direction 0 =droite, 1 =bas, 2 =gauche, 3 =haut, 4 =pas de saisie tactile myTouch.read(); if (myTouch.dataAvailable() &&!screenPressed) { xT =myTouch.getX(); yT =monTouche.getY(); // ************************************ // ******* Entrer en mode configuration ** ******* // ************************************ si (((xT>=120) &&(xT<=200) &&(yT>=105) &&(yT<=140)) &&(soundalarm !=true)) { // Appeler la routine de configuration si l'alarme ne sonne pas xsetup =true ; // Bascule le drapeau clocksetup(); // Routine de configuration de l'horloge d'appel UpdateDisp(); // mettre à jour la valeur sur l'horloge } else // Si le centre de l'écran est touché pendant l'alarme, désactivez le son et réinitialisez l'alarme pour qu'elle ne soit pas définie si (((xT>=120) &&(xT<=200) &&(yT> =105) &&(yT<=140)) &&((alarmstatus ==true) &&(soundalarm ==true))) { alarmstatus =false; alarme sonore =faux ; digitalWrite(8,LOW); // Définir bas } screenPressed =true; } // Ne permet pas de maintenir l'écran / vous devez appuyer dessus sinon ( !myTouch.dataAvailable() &&screenPressed){ ​​screenPressed =false; }drawghost(ghostX, ghostY, ghostD, p); // Incrémenter la position et dessiner l'image// ghost Direction //// direction d ==0 =right, 1 =down, 2 =left, 3 =upif(ghostD ==0){ // Right // Incrémenter le compteur et tester résultats ghostX =ghostX + 3; if (ghostX ==270){ myGLCD.fillRect(ghostX-3, ghostY, ghostX, ghostY+28); // Effacer le graphique avant de changer de position ghostD =1; // Changer de direction vers le bas } } else if(ghostD ==1) { // Vers le bas // Incrémenter le compteur et tester les résultats ghostY =ghostY + 3; if (ghostY ==185){ myGLCD.fillRect(ghostX+3, ghostY-3, ghostX+36, ghostY); // Effacer le graphique avant de changer de position ghostD =2; // Changer de direction vers le bas } } else if(ghostD ==2) { // Gauche // Incrémenter le compteur et tester les résultats ghostX =ghostX - 3; if (ghostX ==12){ myGLCD.fillRect(ghostX+28, ghostY, ghostX+31, ghostY+28); // Effacer le graphique avant d'imprimer le nouveau positi ghostD =3; // Changer de direction vers le bas } } else if(ghostD ==3) { // Up // Incrémenter le compteur et tester les résultats ghostY =ghostY - 3; if (ghostY ==14){ myGLCD.fillRect(ghostX, ghostY+29, ghostX+28, ghostY+28); // Effacer le graphique avant d'imprimer la nouvelle position ghostD =0; // Changer de direction vers le bas }}drawMonkey(MonkeyX, MonkeyY, MonkeyD, p); // Incrémenter la position et dessiner l'image// Monkey Direction //// direction d ==0 =right, 1 =down, 2 =left, 3 =upif(MonkeyD ==0){ // Right // Incrémenter le compteur et tester résultats SingeX =SingeX + 3 ; if (MonkeyX ==270){ myGLCD.fillRect(MonkeyX-3, MonkeyY, MonkeyX, MonkeyY+40); // Effacer la trace du graphique avant de changer de direction MonkeyD =1; // Changer de direction vers le bas } } else if(MonkeyD ==1) { // Down // Incrémenter le compteur et les résultats du test MonkeyY =MonkeyY + 3; if (MonkeyY ==185){ myGLCD.fillRect(MonkeyX+3, MonkeyY-3, MonkeyX+38, MonkeyY); // Effacer le graphique avant d'imprimer la nouvelle position MonkeyD =2; // Changer de direction vers le bas } } else if(MonkeyD ==2) { // Left // Incrémenter le compteur et les résultats du test MonkeyX =MonkeyX - 3; if (MonkeyX ==12){ myGLCD.fillRect(MonkeyX+41, MonkeyY+1, MonkeyX+40, MonkeyY+38); // Effacer le graphique avant d'imprimer la nouvelle positi MonkeyD =3; // Changer de direction vers le bas } } else if(MonkeyD ==3) { // Up // Incrémenter le compteur et les résultats du test MonkeyY =MonkeyY - 3; if (MonkeyY ==14){ myGLCD.fillRect(MonkeyX, MonkeyY+38, MonkeyX+40, MonkeyY+43); // Effacer le graphique avant d'imprimer la nouvelle position MonkeyD =0; // Changer de direction vers le bas }}drawCannon(CannonX, CannonY, CannonD, p); // Incrémenter la position et dessiner l'image// Cannon Direction //// direction d ==0 =right, 1 =down, 2 =left, 3 =upif(CannonD ==0){ // Right // Incrémenter le compteur et tester résultats CannonX =CannonX + 3; if (CannonX ==270){ myGLCD.fillRect(CannonX-3, CannonY+3, CannonX, CannonY+36); // Effacer le graphique avant de changer de direction CannonD =1; // Changer de direction vers le bas } } else if(CannonD ==1) { // Vers le bas // Incrémenter le compteur et les résultats du test CannonY =CannonY + 3; if (CanonY ==185){ CannonD =2; // Changer de direction vers le bas } } else if(CannonD ==2) { // Gauche // Incrémenter le compteur et les résultats du test CannonX =CannonX - 3; if (CannonX ==12){ myGLCD.fillRect(CannonX+41, CannonY+3, CannonX+40, CannonY+36); // Effacer le graphique avant d'imprimer une nouvelle positi CannonD =3; // Changer de direction vers le bas } } else if(CannonD ==3) { // Up // Incrémenter le compteur et les résultats du test CannonY =CannonY - 3; if (CanonY ==14){ CannonD =0; // Changer de direction vers le bas }}drawpacman(pacmanX, pacmanY, pacmanD, p); // Incrémenter la position et dessiner l'image// pacman Direction //// direction d ==0 =right, 1 =down, 2 =left, 3 =upif(pacmanD ==0){ // Right // Incrémenter le compteur et tester résultats pacmanX =pacmanX + 3; if (pacmanX ==270){ monGLCD.fillRect(pacmanX-3, pacmanY+3, pacmanX, pacmanY+36); // Effacer le graphique avant de changer de direction pacmanD =1; // Changer de direction vers le bas } } else if(pacmanD ==1) { // Vers le bas // Incrémenter le compteur et tester les résultats pacmanY =pacmanY + 3; if (pacmanY ==185){ myGLCD.fillRect(pacmanX+3, pacmanY-3, pacmanX+36, pacmanY); // Effacement du graphique avant de changer de position pacmanD =2; // Changer de direction vers le bas } } else if(pacmanD ==2) { // Gauche // Incrémenter le compteur et tester les résultats pacmanX =pacmanX - 3; if (pacmanX ==12){ monGLCD.fillRect(pacmanX+28, pacmanY, pacmanX+31, pacmanY+28); // Effacer le graphique avant d'imprimer le nouveau positi pacmanD =3; // Changer de direction vers le bas } } else if(pacmanD ==3) { // Up // Incrémenter le compteur et tester les résultats pacmanY =pacmanY - 3; if (pacmanY ==14){ monGLCD.fillRect(pacmanX, pacmanY+29, pacmanX+28, pacmanY+28); // Effacement du graphique avant d'imprimer la nouvelle position pacmanD =0; // Changer de direction vers le bas }}drawAlien(AlienX, AlienY, AlienD, p); // Incrémenter la position et dessiner l'image// Alien Direction //// direction d ==0 =right, 1 =down, 2 =left, 3 =upif(AlienD ==0){ // Right // Incrémenter le compteur et tester résultats AlienX =AlienX + 3 ; if (AlienX ==270){ monGLCD.fillRect(AlienX-3, AlienY+3, AlienX, AlienY+36); // Effacer la trace du graphique avant de changer de direction AlienD =1; // Changer de direction vers le bas } } else if(AlienD ==1) { // Down // Incrémenter le compteur et les résultats du test AlienY =AlienY + 3; if (AlienY ==185){ AlienD =2; // Changer de direction vers le bas } } else if(AlienD ==2) { // Gauche // Incrémenter le compteur et les résultats du test AlienX =AlienX - 3; if (AlienX ==12){ myGLCD.fillRect(AlienX+41, AlienY+3, AlienX+40, AlienY+36); // Effacer le graphique avant d'imprimer une nouvelle positi AlienD =3; // Changer de direction vers le bas } } else if(AlienD ==3) { // Up // Incrémenter le compteur et les résultats du test AlienY =AlienY - 3; if (AlienY ==14){ AlienD =0; // Changer de direction vers le bas }}drawMario(MarioX, MarioY, MarioD, p); // Incrémenter la position et dessiner l'image// Mario Direction //// direction d ==0 =right, 1 =down, 2 =left, 3 =upif(MarioD ==0){ // Right // Incrémenter le compteur et tester résultats MarioX =MarioX + 3 ; if (MarioX ==270){ monGLCD.fillRect(MarioX-3, MarioY+3, MarioX, MarioY+36); // Effacer le graphique avant de changer de direction MarioD =1; // Changer de direction vers le bas } } else if(MarioD ==1) { // Vers le bas // Incrémenter le compteur et les résultats du test MarioY =MarioY + 3; if (MarioY ==185){ monGLCD.fillRect(MarioX+3, MarioY-3, MarioX+36, MarioY); // Effacer le graphique avant d'imprimer la nouvelle position MarioD =2; // Changer de direction vers le bas } } else if(MarioD ==2) { // Gauche // Incrémenter le compteur et les résultats du test MarioX =MarioX - 3; si (MarioX ==12){ MarioD =3; // Changer de direction vers le bas } } else if(MarioD ==3) { // Up // Incrémenter le compteur et les résultats du test MarioY =MarioY - 3; if (MarioY ==14){ monGLCD.fillRect(MarioX, MarioY+30, MarioX+28, MarioY+28); // Effacer le graphique avant d'imprimer la nouvelle position MarioD =0; // Changer de direction vers le bas }}delay(dly); }// ************************************************* ******************************************************** ***********// =====Mettre à jour l'horloge numérique// ************************* ******************************************************** ******************************* void UpdateDisp(){ // Efface la zone horaire myGLCD.setColor(0, 0, 0); monGLCD.setBackColor(0, 0, 0);// monGLCD.fillRect(60, 80 ,262, 166); entier h; // Valeur de l'heure au format 24 heures int e; // Valeur minute au format minute int pm =0; // Drapeau pour déterminer si PM ou AM // Il y a quatre chiffres qui doivent être dessinés indépendamment pour assurer un positionnement cohérent de l'heure int d1; // Chiffre des dizaines int d2; // Chiffre des heures int d3; // Chiffre des minutes des dizaines int d4; // Chiffre des minutes h =heure(); // Valeur de l'horloge RT 24 heures e =minute();/* TESTh =12;e =8;*/// Calculer les valeurs des chiffres de l'heure pour timeif ((h>=10) &&(h <=12)) { / / AM heures 10,11,12 d1 =1; // calcule le chiffre des heures des dizaines d2 =h - 10; // calcule le chiffre de l'heure des unités 0,1,2 } else if ( (h>=22) &&(h <=24)) { // PM heures 10,11,12 d1 =1; // calcule le chiffre des heures des dizaines d2 =h - 22 ; // calculate Ones hour digit 0,1,2 } else if ((h <=9)&&(h>=1)) { // AM hours below ten d1 =0; // calculate Tens hour digit d2 =h; // calculate Ones hour digit 0,1,2 } else if ( (h>=13) &&(h <=21)) { // PM hours below 10 d1 =0; // calculate Tens hour digit d2 =h - 12; // calculate Ones hour digit 0,1,2 } else { // If hour is 0 d1 =1; // calculate Tens hour digit d2 =2; // calculate Ones hour digit 0,1,2 } // Calculate minute digit values for timeif ((e>=10)) { d3 =e/10; // calculate Tens minute digit 1,2,3,4,5 d4 =e - (d3*10); // calculate Ones minute digit 0,1,2 } else { // e is less than 10 d3 =0; d4 =e; } if (h>=12){ // Set // h =h-12; // Work out value pm =1; // Set PM flag} // *************************************************************************// Print each digit if it has changed to reduce screen impact/flicker// Set digit font colour to white myGLCD.setColor(255, 255, 255); myGLCD.setBackColor(0, 0, 0); myGLCD.setFont(SevenSeg_XXXL_Num); // First Digitif(((d1 !=c1)||(xsetup ==true))&&(d1 !=0)){ // Do not print zero in first digit position myGLCD.printNumI(d1,10,70); // Printing thisnumber impacts LFH walls so redraw impacted area // ---------------- Clear lines on Outside wall myGLCD.setColor(0,0,0); myGLCD.drawRoundRect(1, 238, 318, 1); }//If prevous time 12:59 or 00:59 and change in time then blank First Digitif((c1 ==1) &&(c2 ==2) &&(c3 ==5) &&(c4 ==9) &&(d2 !=c2) ){ // Clear the previouis First Digit and redraw wall myGLCD.setColor(0,0,0); myGLCD.fillRect(50, 70, 70, 165);}if((c1 ==0) &&(c2 ==0) &&(c3 ==5) &&(c4 ==9) &&(d2 !=c2) ){ // Clear the previouis First Digit and redraw wall myGLCD.setColor(0,0,0); myGLCD.fillRect(50, 70, 70, 165);} myGLCD.setColor(255, 255, 255); myGLCD.setBackColor(0, 0, 0); myGLCD.setFont(SevenSeg_XXXL_Num); // Second Digitif((d2 !=c2)||(xsetup ==true)){ myGLCD.printNumI(d2,70,70); // Print 0}// Third Digitif((d3 !=c3)||(xsetup ==true)){ myGLCD.printNumI(d3,143,70); // Was 145 }// Fourth Digitif((d4 !=c4)||(xsetup ==true)){ myGLCD.printNumI(d4,204,70); // Was 205 }if (xsetup ==true){ xsetup =false; // Reset Flag now leaving setup mode } // Print PM or AM // myGLCD.setColor(1, 73, 240); myGLCD.setBackColor(0, 0, 0); myGLCD.setFont(BigFont); if (pm ==0) { myGLCD.print("AM", 270, 147); } else { myGLCD.print("PM", 270, 147); }// ----------- Alarm Set on LHS lower pillarif (alarmstatus ==true) { // Print AS on fron screenleft hand side myGLCD.print("AS", 7, 147); } // Round dots myGLCD.setColor(255, 255, 255); myGLCD.setBackColor(0, 0, 0); myGLCD.fillCircle(137, 105, 5); myGLCD.fillCircle(137, 135, 5);//--------------------- copy exising time digits to global variables so that these can be used to test which digits change in futurec1 =d1;c2 =d2;c3 =d3;c4 =d4;}// =====initiateGame - Custom Functionvoid drawscreen() { // Setup Clock Background //Draw Background lines myGLCD.setColor(1, 73, 240);// myGLCD.setColor(229, 14, 122);// myGLCD.setColor(255, 0, 131); // ---------------- Outside wall myGLCD.drawRoundRect(0, 239, 319, 0); myGLCD.drawRoundRect(2, 237, 317, 2); myGLCD.drawBitmap (ghostX, ghostY, 28, 28, rd_ghost); // Closed Ghost myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioR3); // Closed Ghost myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey2); // Closed Ghost myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, r_o_pacman); // Closed Ghost myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien1); // Closed Ghost myGLCD.drawBitmap (CannonX, CannonY, 40, 40, Cannon); // Closed Ghost } // ********************************** // ******* Enter Setup Mode ********* // ********************************** // Use up down arrows to change time and alrm settings void clocksetup(){ int timehour =hour();int timeminute =minute();// Read Alarm Set Time from Eeprom // read a byte from the current address of the EEPROM ahour =EEPROM.read(100); alarmhour =(int)ahour; if (alarmhour>24 ) { alarmhour =0; } amin =EEPROM.read(101); alarmminute =(int)amin; if (alarmminute>60 ) { alarmminute =0; }boolean savetimealarm =false; // If save button pushed save the time and alarm // Setup Screen myGLCD.clrScr();// ---------------- Outside wall myGLCD.setColor(255, 255, 0); myGLCD.setBackColor(0, 0, 0); myGLCD.drawRoundRect(0, 239, 319, 0); myGLCD.drawRoundRect(2, 237, 317, 2); //Reset screenpressed flagscreenPressed =false;// Read in current clock time and Alarm time // Setup buttons myGLCD.setFont(BigFont); // Time Set buttons myGLCD.print("+ +", 135, 38); myGLCD.print("- -", 135, 82); myGLCD.drawRoundRect(132, 35, 152, 55); // time hour + myGLCD.drawRoundRect(180, 35, 200, 55); // time minute + myGLCD.drawRoundRect(132, 80, 152, 100); // time hour - myGLCD.drawRoundRect(180, 80, 200, 100); // time minute - // Alarm Set buttons myGLCD.print("+ +", 135, 138); myGLCD.print("- -", 135, 182); myGLCD.drawRoundRect(132, 135, 152, 155); // alarm hour + myGLCD.drawRoundRect(180, 135, 200, 155); // alarm minute + myGLCD.drawRoundRect(132, 180, 152, 200); // alarm hour - myGLCD.drawRoundRect(180, 180, 200, 200); // alarm minute - myGLCD.print("SAVE", 13, 213); myGLCD.print("EXIT", 245, 213); myGLCD.drawRoundRect(10, 210, 80, 230); myGLCD.drawRoundRect(243, 210, 310, 230); // Get your Ghost on myGLCD.drawBitmap (50, 20, 28, 28, rd_ghost); // Closed Ghost myGLCD.drawBitmap (240, 100, 28, 28, r_o_pacman); // Closed Ghost myGLCD.drawBitmap (240, 20, 40, 40, Alien1); // Closed Ghost // Begin Loop herewhile (xsetup ==true){ if (alarmstatus ==true){ // flag where false is off and true is on myGLCD.print("SET", 220, 160); } else { myGLCD.print("OFF", 220, 160); } myGLCD.drawRoundRect(218, 157, 268, 177);// Draw Sound Button myGLCD.print("TEST", 50, 110); // Triggers alarm sound myGLCD.drawRoundRect(48, 108, 116, 128); // Display Current Time myGLCD.print("Time", 40, 60); // myGLCD.printNumI(timehour, 130, 60); if(timehour>=10){ // Annoyingly if number less than 10 doesnt print on RHS and misses zero so need to compensate myGLCD.printNumI(timehour, 130, 60); // If>=10 just print minute } else { myGLCD.print("0", 130, 60); myGLCD.printNumI(timehour, 146, 60); } myGLCD.print(":", 160, 60); if(timeminute>=10){ // Annoyingly if number less than 10 doesnt print on RHS and misses zero so need to compensate myGLCD.printNumI(timeminute, 175, 60); // If>=10 just print minute } else { myGLCD.print("0", 175, 60); myGLCD.printNumI(timeminute, 193, 60); } //Display Current Alarm Setting myGLCD.print("Alarm", 40, 160); // myGLCD.printNumI(alarmhour, 130, 160); if(alarmhour>=10){ // Annoyingly if number less than 10 doesnt print on RHS and misses zero so need to compensate myGLCD.printNumI(alarmhour, 130, 160); // If>=10 just print minute } else { myGLCD.print("0", 130, 160); myGLCD.printNumI(alarmhour, 146, 160); } myGLCD.print(":", 160, 160); if(alarmminute>=10){ // Annoyingly if number less than 10 doesnt print on RHS and misses zero so need to compensate myGLCD.printNumI(alarmminute, 175, 160); // If>=10 just print minute } else { myGLCD.print("0", 175, 160); myGLCD.printNumI(alarmminute, 193, 160); } // Read input to determine if buttons pressed myTouch.read(); if (myTouch.dataAvailable()) { xT =myTouch.getX(); yT =myTouch.getY(); // Capture input command from user if ((xT>=230) &&(xT<=319) &&(yT>=200) &&(yT<=239)) { // (243, 210, 310, 230) Exit Button xsetup =false; // Exit setupmode } else if ((xT>=0) &&(xT<=90) &&(yT>=200) &&(yT<=239)) { // (243, 210, 310, 230) Save Alarm and Time Button savetimealarm =true; // Exit and save time and alarm xsetup =false; // Exit setupmode } else if ((xT>=130) &&(xT<=154) &&(yT>=32) &&(yT<=57)) { // Time Hour + (132, 35, 152, 55) timehour =timehour + 1; // Increment Hour if (timehour ==24) { // reset hour to 0 hours if 24 timehour =0; } } else if ((xT>=130) &&(xT<=154) &&(yT>=78) &&(yT<=102)) { // (132, 80, 152, 100); // time hour - timehour =timehour - 1; // Increment Hour if (timehour ==-1) { // reset hour to 23 hours if <0 timehour =23; } } else if ((xT>=178) &&(xT<=202) &&(yT>=32) &&(yT<=57)) { // Time Minute + (180, 35, 200, 55) timeminute =timeminute + 1; // Increment Hour if (timeminute ==60) { // reset minute to 0 minutes if 60 timeminute =0; } } else if ((xT>=178) &&(xT<=202) &&(yT>=78) &&(yT<=102)) { // (180, 80, 200, 100); // time minute - timeminute =timeminute - 1; // Increment Hour if (timeminute ==-1) { // reset minute to 0 minutes if 60 timeminute =59; } } else if ((xT>=130) &&(xT<=154) &&(yT>=133) &&(yT<=157)) { // (132, 135, 152, 155); // alarm hour + alarmhour =alarmhour + 1; // Increment Hour if (alarmhour ==24) { // reset hour to 0 hours if 24 alarmhour =0; } } else if ((xT>=130) &&(xT<=154) &&(yT>=178) &&(yT<=202)) { // (132, 180, 152, 200); // alarm hour - alarmhour =alarmhour - 1; // Increment Hour if (alarmhour ==-1) { // reset hour to 23 hours if <0 alarmhour =23; } } else if ((xT>=178) &&(xT<=202) &&(yT>=133) &&(yT<=157)) { // (180, 135, 200, 155); // alarm minute + alarmminute =alarmminute + 1; // Increment Hour if (alarmminute ==60) { // reset minute to 0 minutes if 60 alarmminute =0; } } else if ((xT>=178) &&(xT<=202) &&(yT>=178) &&(yT<=202)) { // (180, 180, 200, 200); // alarm minute - alarmminute =alarmminute - 1; // Increment Hour if (alarmminute ==-1) { // reset minute to 0 minutes if 60 alarmminute =59; } } else if ((xT>=216) &&(xT<=270) &&(yT>=155) &&(yT<=179)) { // (218, 157, 268, 177); // alarm set button pushed if (alarmstatus ==true) { alarmstatus =false; // Turn off Alarm } else { alarmstatus =true; // Turn on Alarm } } else if ((xT>=46) &&(xT<=118) &&(yT>=106) &&(yT<=130)) { // ((48, 108, 116, 128); // alarm test button pushed // Set off alarm by toggling D8, recorded sound triggered by LOW to HIGH transition digitalWrite(8,HIGH); // Set high digitalWrite(8,LOW); // Set low } // Should mean changes should scroll if held down delay(250); } } if ( savetimealarm ==true) { // The following codes transmits the data to the RTC Wire.beginTransmission(DS1307); Wire.write(byte(0)); Wire.write(decToBcd(0)); Wire.write(decToBcd(timeminute)); Wire.write(decToBcd(timehour)); Wire.write(decToBcd(0)); Wire.write(decToBcd(0)); Wire.write(decToBcd(0)); Wire.write(decToBcd(0)); Wire.write(byte(0)); Wire.endTransmission(); // Ends transmission of data // Write the Alarm Time to EEPROM so it can be stored when powered off //alarmhour =(int)ahour; ahour =(byte)alarmhour; amin =(byte)alarmminute; EEPROM.write(100, ahour); EEPROM.write(101, amin); // Now time and alarm data saved reset fla g savetimealarm =false;} //* Clear Screen myGLCD.setColor(0, 0, 0); myGLCD.setBackColor(0, 0, 0); myGLCD.fillRect(0,239,319,0); xsetup =true; // Set Flag now leaving setup mode in order to draw Clock Digits setSyncProvider(RTC.get); // the function to get the time from the RTC setSyncInterval(60); // sync the time every 60 seconds (1 minutes) drawscreen(); // Initiate the screen UpdateDisp(); // update value to clock } // =================Decimal to BCD converterbyte decToBcd(byte val) { return ((val/10*16) + (val%10));} /* myGLCD.drawBitmap (ghostX, ghostY, 28, 28, ghost); // Closed Ghost myGLCD.drawBitmap (MarioX, MarioY, 40, 40, Mario); // Closed Ghost myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey); // Closed Ghost myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, r_o_pacman); // Closed Ghost myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien); // Closed Ghost myGLCD.drawBitmap (CannonX, CannonY, 40, 40, Cannon); // Closed Ghost *///**********************************************************************************************************//======Draws the rd_ghost - bitmapvoid drawghost(int x, int y, int d, int p) { // Draws the ghost - bitmap // knotting direction d ==0 =right, 1 =down, 2 =left, 3 =up myGLCD.setColor(0, 0, 0); myGLCD.setBackColor(0, 0, 0); if ( d ==0){ // Right myGLCD.fillRect(x-3, y, x, y+28); // Clear trail off graphic before printing new position // draw image myGLCD.drawBitmap (ghostX, ghostY, 28, 28, rr_ghost); } else if ( d ==1){ // Down myGLCD.fillRect(x+3, y-3, x+36, y); // Clear trail off graphic before printing new position // draw image myGLCD.drawBitmap (ghostX, ghostY, 28, 28, rd_ghost); } else if ( d ==2){ // Left myGLCD.fillRect(x+28, y, x+31, y+28); // Clear trail off graphic before printing new positi // draw image myGLCD.drawBitmap (ghostX, ghostY, 28, 28, rl_ghost); // draw image } else if ( d ==3){ // Up myGLCD.fillRect(x, y+29, x+28, y+28); // Clear trail off graphic before printing new position // draw image myGLCD.drawBitmap (ghostX, ghostY, 28, 28, ru_ghost); }}//**********************************************************************************************************//======Draws the Mario - bitmapvoid drawMario(int x, int y, int d, int p) { // Draws the Mario - bitmap // Mario direction d ==0 =right, 1 =down, 2 =left, 3 =up myGLCD.setColor(0, 0, 0); myGLCD.setBackColor(0, 0, 0); if ( d ==0){ // Right myGLCD.fillRect(x-3, y+3, x, y+36); // Clear trail off graphic before printing new position // draw image if (p==0) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioR1); } else if (p==1) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioR3); } else if (p==2) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioR2); } else if (p==3) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioR3); } } else if ( d ==1){ // Down myGLCD.fillRect(x+3, y-3, x+36, y); // Clear trail off graphic before printing new position // draw image if (p==0) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU1); } else if (p==1) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU2); } else if (p==2) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU1); } else if (p==3) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU2); } } else if ( d ==2){ // Left myGLCD.fillRect(x+28, y, x+31, y+28); // Clear trail off graphic before printing new positi // draw image if (p==0) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioL1); } else if (p==1) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioL3); } else if (p==2) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioL2); } else if (p==3) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioL3); } } else if ( d ==3){ // Up myGLCD.fillRect(x, y+30, x+28, y+28); // Clear trail off graphic before printing new position // draw image if (p==0) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU1); } else if (p==1) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU2); } else if (p==2) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU1); } else if (p==3) { myGLCD.drawBitmap (MarioX, MarioY, 28, 28, MarioU2); } }// myGLCD.drawBitmap (MarioX, MarioY, 40, 40, MarioR3); }//**********************************************************************************************************//======Draws the Cannon - bitmapvoid drawCannon(int x, int y, int d, int p) { // Draws the Cannon - bitmap // Cannon direction d ==0 =right, 1 =down, 2 =left, 3 =up myGLCD.setColor(0, 0, 0); myGLCD.setBackColor(0, 0, 0); if ( d ==0){ // Right myGLCD.fillRect(x-3, y+3, x, y+36); // Clear trail off graphic before printing new position // draw image } else if ( d ==1){ // Down myGLCD.fillRect(x+3, y-3, x+36, y); // Clear trail off graphic before printing new position // draw image } else if ( d ==2){ // Left myGLCD.fillRect(x+41, y+3, x+40, y+36); // Clear trail off graphic before printing new positi // draw image } else if ( d ==3){ // Up myGLCD.fillRect(x, y+41, x+40, y+40); // Clear trail off graphic before printing new position // draw image } myGLCD.drawBitmap (CannonX, CannonY, 40, 40, Cannon); }//**********************************************************************************************************//======Draws the Monkey - bitmapvoid drawMonkey(int x, int y, int d, int p) { // Draws the Monkey - bitmap // Monkey direction d ==0 =right, 1 =down, 2 =left, 3 =up myGLCD.setColor(0, 0, 0); myGLCD.setBackColor(0, 0, 0); if ( d ==0){ // Right myGLCD.fillRect(x-3, y, x, y+40); // Clear trail off graphic before printing new position // draw image if (p==0) { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey2); } else if (p==1) { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey2); } else if (p==2) { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey3); }else { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey3); } } else if ( d ==1){ // Down myGLCD.fillRect(x, y-3, x+40, y); // Clear trail off graphic before printing new position // draw image myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey3); } else if ( d ==2){ // Left myGLCD.fillRect(x+41, y, x+40, y+40); // Clear trail off graphic before printing new positi // draw image if (p==0) { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey2); } else if (p==1) { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey2); } else if (p==2) { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey3); }else { myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey3); } } else if ( d ==3){ // Up myGLCD.fillRect(x, y+43, x+40, y+40); // Clear trail off graphic before printing new position // draw image myGLCD.drawBitmap (MonkeyX, MonkeyY, 40, 40, Monkey3); } }//**********************************************************************************************************//======Draws the pacman - bitmapvoid drawpacman(int x, int y, int d, int p) { // Draws the pacman - bitmap // pacman direction d ==0 =right, 1 =down, 2 =left, 3 =up myGLCD.setColor(0, 0, 0); myGLCD.setBackColor(0, 0, 0); if ( d ==0){ // Right myGLCD.fillRect(x-3, y+3, x, y+36); // Clear trail off graphic before printing new position // draw image if (p==0) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, c_pacman); } else if (p==1) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, r_m_pacman); } else if (p==2) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, r_o_pacman); }else { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, r_m_pacman); } } else if ( d ==1){ // Down myGLCD.fillRect(x+3, y-3, x+36, y); // Clear trail off graphic before printing new position // draw image if (p==0) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, c_pacman); } else if (p==1) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, d_m_pacman); } else if (p==2) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, d_o_pacman); }else { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, d_m_pacman); } } else if ( d ==2){ // Left myGLCD.fillRect(x+28, y, x+31, y+28); // Clear trail off graphic before printing new positi // draw image if (p==0) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, c_pacman); } else if (p==1) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, l_m_pacman); } else if (p==2) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, l_o_pacman); }else { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, l_m_pacman); } } else if ( d ==3){ // Up myGLCD.fillRect(x, y+29, x+28, y+28); // Clear trail off graphic before printing new position // draw image if (p==0) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, c_pacman); } else if (p==1) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, u_m_pacman); } else if (p==2) { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, u_o_pacman); }else { myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, u_m_pacman); } }// myGLCD.drawBitmap (pacmanX, pacmanY, 28, 28, r_o_pacman); }//**********************************************************************************************************//======Draws the Alien - bitmapvoid drawAlien(int x, int y, int d, int p) { // Draws the Alien - bitmap // Alien direction d ==0 =right, 1 =down, 2 =left, 3 =up myGLCD.setColor(0, 0, 0); myGLCD.setBackColor(0, 0, 0); if ( d ==0){ // Right myGLCD.fillRect(x-3, y+3, x, y+36); // Clear trail off graphic before printing new position // draw image if((p ==1)||(p ==3)){ myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien1); } else { myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien2); } } else if ( d ==1){ // Down myGLCD.fillRect(x+3, y-3, x+36, y); // Clear trail off graphic before printing new position // draw image if((p ==1)||(p ==3)){ myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien1); } else { myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien2); } } else if ( d ==2){ // Left myGLCD.fillRect(x+41, y+3, x+40, y+36); // Clear trail off graphic before printing new positi // draw image if((p ==1)||(p ==3)){ myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien1); } else { myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien2); } } else if ( d ==3){ // Up myGLCD.fillRect(x, y+41, x+40, y+40); // Clear trail off graphic before printing new position // draw image if((p ==1)||(p ==3)){ myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien1); } else { myGLCD.drawBitmap (AlienX, AlienY, 40, 40, Alien2); } } }

Pièces et boîtiers personnalisés

Thingverse

Schémas