Wikifab - Contributions de l’utilisateur [fr]

Horloge de jeu d'échecs

2018-12-13T00:55:10Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échecs conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs.</translate>
}}
{{ {{tntn|TutoVideo}}
|TutoVideoService=youtube
|TutoVideoURL=https://youtu.be/JywAD19mN-A
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments TM1637


Arduino entrée 3 : DIO du premier afficheur 7 segments TM1637


Arduino entrée 4 : CLK du deuxième afficheur 7 segments TM1637


Arduino entrée 5 : DIO du deuxième afficheur 7 segments TM1637


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe


http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino


http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-07T22:08:43Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échecs conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments TM1637


Arduino entrée 3 : DIO du premier afficheur 7 segments TM1637


Arduino entrée 4 : CLK du deuxième afficheur 7 segments TM1637


Arduino entrée 5 : DIO du deuxième afficheur 7 segments TM1637


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe


http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino


http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-07T19:55:56Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments TM1637


Arduino entrée 3 : DIO du premier afficheur 7 segments TM1637


Arduino entrée 4 : CLK du deuxième afficheur 7 segments TM1637


Arduino entrée 5 : DIO du deuxième afficheur 7 segments TM1637


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe


http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino


http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-07T19:54:09Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|TutoVideo}}
|TutoVideoService=youtube
|TutoVideoURL=https://youtu.be/w7TPAnJPFXc
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments TM1637


Arduino entrée 3 : DIO du premier afficheur 7 segments TM1637


Arduino entrée 4 : CLK du deuxième afficheur 7 segments TM1637


Arduino entrée 5 : DIO du deuxième afficheur 7 segments TM1637


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe


http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino


http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-04T19:53:01Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments TM1637


Arduino entrée 3 : DIO du premier afficheur 7 segments TM1637


Arduino entrée 4 : CLK du deuxième afficheur 7 segments TM1637


Arduino entrée 5 : DIO du deuxième afficheur 7 segments TM1637


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe


http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino

http://www.xavonline.net/zip/CODE-HORLOGE-ECHEC-TM1637.zip</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Fichier:Horloge TM1637.ino

2018-12-04T19:34:08Z

Xavonline : Xavonline a téléversé une nouvelle version de Fichier:Horloge TM1637.ino

Code arduino pour contrôler une horloge d'échiquier à base d'afficheurs 7 segments de type TM1637

Fichier:Horloge TM1637

2018-12-04T19:33:29Z

Xavonline : CODE-HORLOGE-ECHEC-FINAL-TM1637

/* inclusion de la librairie */
#include <Arduino.h>
#include <TM1637Display.h>

//*******************************//
//*******************************//
//** DECLARATION DES VARIABLES **//
//*******************************//
//*******************************//

// Pour le module du joueur 1
#define CLK1 2
#define DIO1 3
// Pour le module du joueur 2
#define CLK2 4
#define DIO2 5

// Module du joueur 1
TM1637Display TM001(CLK1, DIO1);
// Module du joueur 2
TM1637Display TM002(CLK2, DIO2);

// LA LED Blanche Pour le joueur 1
const int J1 = 9; // broche 9 du micro-contrôleur
// LA LED Blanche Pour le joueur 2
const int J2 = 10; // broche 10 du micro-contrôleur

// LA LED Verte R1
const int R1 = 11; // broche 11 du micro-contrôleur
// LA LED Rouge R2
const int R2 = 12; // broche 12 du micro-contrôleur

// Attribution
int pinBouton;
int pinBouton_deux;
int pinBouton_trois;

// 300 seconde correspond à 5 minutes
int joueur_un_seconde = 300;
int joueur_deux_seconde = 300;

// Affichage du temps de l'horloge sur les afficheurs 7 segments à 4 digits pour le joueur 1
int joueur_un_minute_dizaine;
int joueur_un_minute_unite;
int joueur_un_seconde_dizaine;
int joueur_un_seconde_unite;

int joueur_un_minute_total;
int joueur_un_seconde_total;

// Affichage du temps de l'horloge sur les afficheurs 7 segments à 4 digits pour le joueur 2
int joueur_deux_minute_dizaine;
int joueur_deux_minute_unite;
int joueur_deux_seconde_dizaine;
int joueur_deux_seconde_unite;

int joueur_deux_minute_total;
int joueur_deux_seconde_total;

// Etat des 3 boutons : bouton 1,2 et 3
boolean etatBouton;
boolean etatBouton_deux;
boolean etatBouton_trois;

//*******************************//
//*******************************//
//************ SETUP ************//
//*******************************//
//*******************************//

void setup() {

// LED du joueur n°1
pinMode(J1, OUTPUT); //L1 est une broche de sortie
// LED du joueur n°2
pinMode(J2, OUTPUT); //L2 est une broche de sortie
// LED rouge du mode de réglage
pinMode(R1, OUTPUT); //R1 est une broche de sortie
// LED verte du mode partie
pinMode(R2, OUTPUT); //R2 est une broche de sortie

//bouton changement joueur
pinBouton=6;
pinMode(pinBouton,INPUT_PULLUP);

//bouton 5 Minute plus
pinBouton_deux=7;
pinMode(pinBouton_deux,INPUT_PULLUP);

//bouton réglage
pinBouton_trois=8;
pinMode(pinBouton_trois,INPUT_PULLUP);

// Intensité des afficheurs
TM001.setBrightness(0x0f);
TM002.setBrightness(0x0f);

//*******************************//
//*******************************//
//INITIALISATION PREMIER COMPTEUR//
//*******************************//
//*******************************//
uint8_t segto_000;
uint8_t segto_001;
uint8_t segto_002;
uint8_t segto_003;
// 0x80 correspond à la colonne centrale de l'afficheur pour faire la différence entre les minutes et les secondes

// Attribuer 0 dans la première variable
segto_000 = 0x80 | TM001.encodeDigit(0);
// Attribuer 5 dans la deuxième variable
segto_001 = 0x80 | TM001.encodeDigit(5);
// Afficher 0 dans la troisième variable
segto_002 = 0x80 | TM001.encodeDigit(0);
// Afficher 0 dans la quatrième variable
segto_003 = 0x80 | TM001.encodeDigit(0);

// afficher les chiffres sur les sept segments à partir des variables
// Afficher 0 pour le premier digit à partir de la variable
TM001.setSegments(&segto_000, 1, 0);
// Afficher 5 pour le deuxième digit à partir de la variable
TM001.setSegments(&segto_001, 1, 1);
// Afficher 0 pour le troisième digit à partir de la variable
TM001.setSegments(&segto_002, 1, 2);
// Afficher 0 pour le quatrième digit à partir de la variable
TM001.setSegments(&segto_003, 1, 3);

//*******************************//
//*******************************//
//INITIALISATION DEUXIEME COMPTEUR//
//*******************************//
//*******************************//

uint8_t segto_004;
uint8_t segto_005;
uint8_t segto_006;
uint8_t segto_007;
segto_004 = 0x80 | TM002.encodeDigit(0);
segto_005 = 0x80 | TM002.encodeDigit(5);
segto_006 = 0x80 | TM002.encodeDigit(0);
segto_007 = 0x80 | TM002.encodeDigit(0);
TM002.setSegments(&segto_004, 1, 0);
TM002.setSegments(&segto_005, 1, 1);
TM002.setSegments(&segto_006, 1, 2);
TM002.setSegments(&segto_007, 1, 3);
}

//*******************************//
//*******************************//
//************ LOOP *************//
//*******************************//
//*******************************//

void loop() {

//-------------------------------------------//
//-------------------------------------------//
//------------ REGLAGE HORLOGE -------------//
//-------------------------------------------//
//-------------------------------------------//

// Bouton TROIS : MODE réglage
etatBouton_trois=digitalRead(pinBouton_trois);
while (etatBouton_trois == 1)
{
// On allume la LED R1, qui est la LED Rouge
digitalWrite(R1, HIGH);
// On eteind la LED R2, qui est la LED Verte
digitalWrite(R2, LOW);

etatBouton=digitalRead(pinBouton);
if (etatBouton == 1)
{
// Quand le bouton 1 est en position ON, On allume la LED du joueur 1
digitalWrite(J1, HIGH);
// Quand le bouton 1 est en position ON, On eteind la LED du joueur 2
digitalWrite(J2, LOW);
}
else
{
// Quand le bouton 1 est en position OFF, On eteind la LED du joueur 1
digitalWrite(J1, LOW);
// Quand le bouton 1 est en position OFF, On allume la LED du joueur 1
digitalWrite(J2, HIGH);
}

// Le bouton 2 correspond au réglage de l'horloge, a chaque appui sur le bouton, on ajoute 5 minutes de jeux
etatBouton_deux=digitalRead(pinBouton_deux);
if (etatBouton_deux == 0)
{
//On attend 750 milli-seconde (DELAY)
delay (750);
// Pour les réglages, On ajoute 300 secondes, ce qui correspond à 5 minutes
joueur_un_seconde = joueur_un_seconde + 300;
joueur_deux_seconde = joueur_deux_seconde + 300;
horloge_un(joueur_un_seconde);
horloge_deux(joueur_deux_seconde);
}
etatBouton_trois=digitalRead(pinBouton_trois);
}

//-------------------------------------------//
//-------------------------------------------//
//------- MODE PARTIE EN COURS -------------//
//-------------------------------------------//
//-------------------------------------------//
//
etatBouton_trois=digitalRead(pinBouton_trois);
// Quand le bouton 3 est à l'état 0, on passe en mode partie, la LED passe au vert (on allume la LED verte et on éteint la LED rouge)
while (etatBouton_trois == 0)
{

// On eteind la LED R1, qui est la LED Rouge
digitalWrite(R1, LOW);
// On allume la LED R2, qui est la LED Verte
digitalWrite(R2, HIGH);

// JOUEUR 1
etatBouton=digitalRead(pinBouton);
while (etatBouton == 1)
{
// On allume la LED J1, qui est la LED Blanche du joueur n°1
digitalWrite(J1, HIGH);
// On eteind la LED J2, qui est la LED Blanche du joueur n°2
digitalWrite(J2, LOW);

etatBouton=digitalRead(pinBouton);

// Si le temps est égal à 0 alors on stoppe le compteur à 0
// Sinon, on compte le temps
if(joueur_un_seconde == 0)
{
horloge_un(0);
etatBouton_trois=digitalRead(pinBouton_trois);
// Si le bouton réglage est à 1, on initialise le compteur à 5 minutes et on quitte la fonction PARTIE pour se mettre en mode REGLAGE
if(etatBouton_trois == 1)
{
joueur_un_seconde = 300;
joueur_deux_seconde = 300;
horloge_un(joueur_un_seconde);
horloge_deux(joueur_deux_seconde);
break;
};
}
else
{
// On lance le compte à rebours
joueur_un_seconde = joueur_un_seconde -1;
// On utilise la fonction horloge_un, elle est défini à la fin du fichier
horloge_un(joueur_un_seconde);
// on laisse passer 1 seconde
delay (1000);

// Lorsque on quitte le mode PARTIE, on rentre à nouveau dans le mode REGLAGE
etatBouton_trois=digitalRead(pinBouton_trois);
if(etatBouton_trois == 1)
{
// Lors du passage en mode réglage on initialise de nouveau l'horloge à 5 minutes (300 secondes) et on quitte la fonction PARTIE pour se mettre en mode REGLAGE
joueur_un_seconde = 300;
joueur_deux_seconde = 300;
horloge_un(joueur_un_seconde);
horloge_deux(joueur_deux_seconde);
break;
};

}

}

// JOUEUR 2
etatBouton=digitalRead(pinBouton);
while (etatBouton == 0)
{
// On eteind la LED J1, qui est la LED Blanche du joueur n°1
digitalWrite(J1, LOW);
// On allume la LED J2, qui est la LED Blanche du joueur n°2
digitalWrite(J2, HIGH);

etatBouton=digitalRead(pinBouton);

// Si le temps est égal à 0 alors on stoppe le compteur à 0
// Sinon, on compte le temps
if(joueur_deux_seconde == 0)
{
horloge_deux(0);
etatBouton_trois=digitalRead(pinBouton_trois);
// Si le bouton réglage est à 1, on initialise le compteur à 5 minutes et on quitte la fonction PARTIE pour se mettre en mode REGLAGE
if(etatBouton_trois == 1)
{
joueur_un_seconde = 300;
joueur_deux_seconde = 300;
horloge_un(joueur_un_seconde);
horloge_deux(joueur_deux_seconde);
// Avec break on quitte la fonction PARTIE pour se mettre en mode REGLAGE
break;
};
}
else
{
// On lance le compte à rebours
joueur_deux_seconde = joueur_deux_seconde -1;
// On utilise la fonction horloge_deux, elle est défini à la fin du fichier
horloge_deux(joueur_deux_seconde);
// on laisse passer 1 seconde
delay (1000);

// Lorsque on quitte le mode PARTIE, on rentre à nouveau dans le mode REGLAGE
etatBouton_trois=digitalRead(pinBouton_trois);
if(etatBouton_trois == 1)
{
// Lors du passage en mode réglage on initialise de nouveau l'horloge à 5 minutes (300 secondes) et on quitte la fonction PARTIE pour se mettre en mode REGLAGE
joueur_un_seconde = 300;
joueur_deux_seconde = 300;
horloge_un(joueur_un_seconde);
horloge_deux(joueur_deux_seconde);
// Avec break on quitte la fonction PARTIE pour se mettre en mode REGLAGE
break;
};
}

}

}

}
// FIN DE LA FONCTION LOOP

//-------------------------------------------//
//-------------------------------------------//
//-------------- LES FONCTIONS -------------//
//-------------------------------------------//
//-------------------------------------------//

void horloge_un(int joueur_un_seconde)
{

// On extrait les minutes en divisant par soixante
joueur_un_minute_total = joueur_un_seconde / 60;

// On extrait la dizaine des minutes en divisant par 10
joueur_un_minute_dizaine = joueur_un_minute_total / 10;

// On extrait les unités des minutes avec un modulo 10
joueur_un_minute_unite = joueur_un_minute_total % 10;

// On extrait les secondes en divisant par soixante
joueur_un_seconde_total = joueur_un_seconde % 60;

// On extrait la dizaine des secondes en divisant par 10
joueur_un_seconde_dizaine = joueur_un_seconde_total / 10;

// On extrait les unités des secondes avec un modulo 10
joueur_un_seconde_unite = joueur_un_seconde_total % 10;

// Déclaration des variables
uint8_t segto_000;
uint8_t segto_001;
uint8_t segto_002;
uint8_t segto_003;

// 0x80 correspond à la colonne du milieu
segto_000 = 0x80 | TM001.encodeDigit(joueur_un_minute_dizaine);
segto_001 = 0x80 | TM001.encodeDigit(joueur_un_minute_unite);
segto_002 = 0x80 | TM001.encodeDigit(joueur_un_seconde_dizaine);
segto_003 = 0x80 | TM001.encodeDigit(joueur_un_seconde_unite);

// affichage du temps passé sur les 4 digits du module 1 : TM001
TM001.setSegments(&segto_000, 1, 0);
TM001.setSegments(&segto_001, 1, 1);
TM001.setSegments(&segto_002, 1, 2);
TM001.setSegments(&segto_003, 1, 3);

}

void horloge_deux(int joueur_deux_seconde)
{
// On extrait les minutes en divisant par soixante
joueur_deux_minute_total = joueur_deux_seconde / 60;

// On extrait la dizaine des minutes en divisant par 10
joueur_deux_minute_dizaine = joueur_deux_minute_total / 10;

// On extrait les unités des minutes avec un modulo 10
joueur_deux_minute_unite = joueur_deux_minute_total % 10;

// On extrait les secondes en divisant par soixante
joueur_deux_seconde_total = joueur_deux_seconde % 60;

// On extrait la dizaine des secondes en divisant par 10
joueur_deux_seconde_dizaine = joueur_deux_seconde_total / 10;

// On extrait les unités des secondes avec un modulo 10
joueur_deux_seconde_unite = joueur_deux_seconde_total % 10;

// Déclaration des variables
uint8_t segto_004;
uint8_t segto_005;
uint8_t segto_006;
uint8_t segto_007;

// 0x80 correspond à la colonne du milieu
segto_004 = 0x80 | TM002.encodeDigit(joueur_deux_minute_dizaine);
segto_005 = 0x80 | TM002.encodeDigit(joueur_deux_minute_unite);
segto_006 = 0x80 | TM002.encodeDigit(joueur_deux_seconde_dizaine);
segto_007 = 0x80 | TM002.encodeDigit(joueur_deux_seconde_unite);

// affichage du temps passé sur les 4 digits du module 2 : TM002
TM002.setSegments(&segto_004, 1, 0);
TM002.setSegments(&segto_005, 1, 1);
TM002.setSegments(&segto_006, 1, 2);
TM002.setSegments(&segto_007, 1, 3);
}

Horloge de jeu d'échecs

2018-12-04T19:32:14Z

Xavonline :

{{ {{tntn|Tuto Details}}
|SourceLanguage=none
|Language=fr
|IsTranslation=0
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|Tuto_Attachments={{ {{tntn|Tuto Attachments}}
|Attachment=Horloge TM1637
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments TM1637


Arduino entrée 3 : DIO du premier afficheur 7 segments TM1637


Arduino entrée 4 : CLK du deuxième afficheur 7 segments TM1637


Arduino entrée 5 : DIO du deuxième afficheur 7 segments TM1637


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe


http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Fichier:Horloge TM1637.ino

2018-12-04T19:31:25Z

Xavonline : Code arduino pour contrôler une horloge d'échiquier à base d'afficheurs 7 segments de type TM1637

Code arduino pour contrôler une horloge d'échiquier à base d'afficheurs 7 segments de type TM1637

Horloge de jeu d'échecs

2018-12-01T14:49:50Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments TM1637


Arduino entrée 3 : DIO du premier afficheur 7 segments TM1637


Arduino entrée 4 : CLK du deuxième afficheur 7 segments TM1637


Arduino entrée 5 : DIO du deuxième afficheur 7 segments TM1637


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe


http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-01T14:46:01Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments


Arduino entrée 3 : DIO du premier afficheur 7 segments


Arduino entrée 4 : CLK du deuxième afficheur 7 segments


Arduino entrée 5 : DIO du deuxième afficheur 7 segments


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe

http://www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-01T14:41:43Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|ExternalAttachmentsLinks={{ {{tntn|ExternalAttachmentsLinks}}
|ExternalAttachmentsLinks=www.xavonline.net/partage/CODE-HORLOGE-ECHEC-TM1637.ino
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments


Arduino entrée 3 : DIO du premier afficheur 7 segments


Arduino entrée 4 : CLK du deuxième afficheur 7 segments


Arduino entrée 5 : DIO du deuxième afficheur 7 segments


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-01T14:39:52Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments


Arduino entrée 3 : DIO du premier afficheur 7 segments


Arduino entrée 4 : CLK du deuxième afficheur 7 segments


Arduino entrée 5 : DIO du deuxième afficheur 7 segments


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-01T14:38:59Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|Tuto_Attachments={{ {{tntn|Tuto Attachments}}}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments


Arduino entrée 3 : DIO du premier afficheur 7 segments


Arduino entrée 4 : CLK du deuxième afficheur 7 segments


Arduino entrée 5 : DIO du deuxième afficheur 7 segments


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Fichier:Xavonline.ino

2018-12-01T14:38:38Z

Xavonline : Xavonline a téléversé une nouvelle version de Fichier:Xavonline.ino

Code arduino d'une horloge d'échiquier utilisant des afficheurs 7 segments de type TM1637

Horloge de jeu d'échecs

2018-12-01T14:29:59Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate> Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate> Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>
* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>
* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>
Arduino entrée 2 : CLK du premier afficheur 7 segments


Arduino entrée 3 : DIO du premier afficheur 7 segments


Arduino entrée 4 : CLK du deuxième afficheur 7 segments


Arduino entrée 5 : DIO du deuxième afficheur 7 segments


Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)


Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)


Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)


Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)


Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.


Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Principe et code en langage C</translate>
|Step_Content=<translate>
Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.


Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.


Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.


Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate> Création du boitier</translate>
|Step_Content=<translate>
Réaliser grâce au logiciel en ligne : http://www.makercase.com/


On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Horloge de jeu d'échecs

2018-12-01T14:14:11Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=<translate>Une horloge Arduino pour jouer au jeu d'échec conventionnel.</translate>
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=<translate>Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.</translate>
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=<translate>* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique</translate>
|Tools=<translate>* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique</translate>
|Tuto_Attachments={{ {{tntn|Tuto Attachments}}
|Attachment=CODE-HORLOGE-ECHEC-TM1637
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate>Connecter l'Arduino nano et les composants</translate>
|Step_Content=<translate>Arduino entrée 2 : CLK du premier afficheur 7 segments

Arduino entrée 3 : DIO du premier afficheur 7 segments

Arduino entrée 4 : CLK du deuxième afficheur 7 segments

Arduino entrée 5 : DIO du deuxième afficheur 7 segments

Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)

Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)

Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)

Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)

Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)

Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.

Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate>Principe et code en langage C</translate>
|Step_Content=<translate>Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.

Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.

Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.

Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=<translate>Création du boitier</translate>
|Step_Content=<translate>Réaliser grâce au logiciel en ligne : http://www.makercase.com/

On l'adapte avec adobe illustrator ou bien laserwork.</translate>
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=<translate></translate>
}}
{{ {{tntn|Tuto Status}}
|Complete=Published
}}

Fichier:CODE-HORLOGE-ECHEC-TM1637.ino

2018-12-01T14:14:01Z

Xavonline : Code arduino pour contrôler une horloge d'échiquier à base d'afficheurs 7 segments de type TM1637

Code arduino pour contrôler une horloge d'échiquier à base d'afficheurs 7 segments de type TM1637

Horloge de jeu d'échecs

2018-12-01T14:10:48Z

Xavonline :

{{ {{tntn|Tuto Details}}
|Main_Picture=Horloge_de_jeu_d'échecs_final.jpg
|Licences=Attribution (CC BY)
|Description=Une horloge Arduino pour jouer au jeu d'échec conventionnel.
|Area=Electronics, Play and Hobbies
|Type=Creation
|Difficulty=Medium
|Duration=3
|Duration-type=hour(s)
|Cost=50
|Currency=EUR (€)
|Tags=Arduino, jeu, jeux, échec, échecs, plateau, pièces, design, roumigiere,
|SourceLanguage=none
|Language=fr
|IsTranslation=0
}}
{{ {{tntn|Introduction}}
|Introduction=Principe de la double horloge à compte à rebours : il existe deux modes, un mode partie pour que les joueurs d’échecs interagissent avec les afficheurs. Un mode réglage pour choisir le temps de jeu par tranche de 5 minutes.
}}
{{ {{tntn|Materials}}
|Step_Picture_00=Horloge_de_jeu_d'échecs_materiel.jpg
|Material=* 2 TM1637 7 segment display
* Arduino nano
* Alimentation 5 volt
* 4 Résistance 330 ohm
* 1 LED rouge
* 1 LED verte
* 2 LED blanche
* Du contreplaqué pour le boitier
* Des vis pour le boitier
* 3 interrupteur ON / OFF
* 1 bouton poussoir
* Du câble
* De l’étain pour les soudures
* Peinture acrylique
|Tools=* 1 fer à souder
* Pistolet à colle
* Pinceaux pour peinture acrylique
|Tuto_Attachments={{ {{tntn|Tuto Attachments}}
|Attachment=Xavonline
}}
}}
{{ {{tntn|Separator}}}}
{{ {{tntn|Tuto Step}}
|Step_Title=Connecter l'Arduino nano et les composants
|Step_Content=Arduino entrée 2 : CLK du premier afficheur 7 segments

Arduino entrée 3 : DIO du premier afficheur 7 segments

Arduino entrée 4 : CLK du deuxième afficheur 7 segments

Arduino entrée 5 : DIO du deuxième afficheur 7 segments

Arduino entrée 6 : Bouton Interrupteur va et vient (En mode partie pour passer la main au compte à rebour de l’autre joueur)

Arduino entrée 7 : Bouton poussoir (En mode réglage pour ajouter 5 minutes au compte à rebour)

Arduino entrée 8 : Bouton Interrupteur va et vient (pour lancer la partie ou passer en mode réglage du compte à rebour)

Arduino entrée 9 : LED blanche joueur n°1 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)

Arduino entrée 10 : LED blanche joueur n°2 avec une résistance de 330 ohm (En mode partie pour indiquer quel joueur à la main)

Arduino entrée 11 : LED rouge pour indiquer que l’on se trouve en mode réglage.

Arduino entrée 12 : LED verte pour indiquer que l’on se trouve en mode partie.
|Step_Picture_00=Horloge_de_jeu_d'échecs_arduino.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=Principe et code en langage C
|Step_Content=Les deux afficheurs 7 segments servent de compte à rebours visuel lors le la partie.

Des moyens de contrôles avec les boutons poussoirs pour interagir avec l’horloge de l'échiquier.

Des moyens visuels avec les LED pour différencier le mode partie et le mode réglage. Les leds blanches servent à différencier le joueur 1 et le joueur deux.

Pour la programmation en langage C, j’utilise le mode INPUT_PULLUP pour gérer les boutons, en effet, avec cette fonction on utilise une résistance interne à l’arduino et on économise donc des résistances externe
|Step_Picture_00=Horloge_de_jeu_d'échecs_code.jpg
}}
{{ {{tntn|Tuto Step}}
|Step_Title=Création du boitier
|Step_Content=Réaliser grâce au logiciel en ligne : http://www.makercase.com/

On l'adapte avec adobe illustrator ou bien laserwork.
|Step_Picture_00=Horloge_de_jeu_d'échecs_makercase.jpg
}}
{{ {{tntn|Notes}}
|Notes=
}}
{{ {{tntn|Tuto Status}}
|Complete=Draft
}}

Fichier:Xavonline.ino

2018-12-01T14:09:46Z

Xavonline : Code arduino d'une horloge d'échiquier utilisant des afficheurs 7 segments de type TM1637

Code arduino d'une horloge d'échiquier utilisant des afficheurs 7 segments de type TM1637

Fichier:Horloge de jeu d'échecs makercase.jpg

2018-12-01T14:05:12Z

Xavonline : Fichier téléversé avec MsUpload on Horloge_de_jeu_d'échecs