Informatique et Création Numérique - Contributions de l'utilisateur [fr]

Année 2018-2019

2018-11-07T12:01:48Z

Rex : /* Projet "robot parlant" */

Cette page liste les projets pour l'année scolaire 2018/2019.

= Projet "jeu de combat 3D" =
Un grand classique : essayer de réaliser un jeu de combat en utilisant le moteur graphique Unity 3D.

Pour plus de détails voyez la page [[projet ICN jeu de combat avec unity 3D 2018/2019]].

= Projet "jeu de rôle 2D Godot" =
L'idée est de réaliser un jeu d'aventure en 2D avec une interaction avec des personnages posant des énigmes.
Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu d'aventure avec Godot 2D 2018/2019]].

= Projet "robot télécommandé" =
Le but est de construire un robot qui puisse être commandé par une Raspberry Pi. Il doit être possible de
se connecter sur la Raspberry Pi avec un téléphone portable et pouvoir commander la Raspberry Pi avec une
application mobile. L'image de la caméra de la Raspberry Pi doit pouvor être visualisée sur le téléphone.

Pour plus de détails voyez la page [[projet ICN robot télécommandé 2018/2019]].

= Projet "jeu 2D snake" =
Le but est de réaliser un jeu en 2D de type "snake". Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu snake 2D avec Godot 2018/2019]].

= Projet "jeu 2D humoristique" =
Le but est de réaliser un jeu drôle en 2D. Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu humoristique 2D avec Godot 2018/2019]].

= Projet "Horloge DCF77 augmentée" =
Le but est de réaliser une horloge de classe se mettant à l'heure automatiquement et permettant une interaction avec
les élèves.

Pour plus de détails voyez la page [[projet ICN horloge DCF augmentée 2018/2019]].

= Projet "robot parlant" =
Le but est de construire un robot pouvant se déplacer en autonomie en détectant les obstacles.
Le robot doit pouvoir dire quelques phrases pré-enregistrées de préférence à propos.

Pour plus de détails voyez la page [[projet ICN robot parlant 2018/2019]].

= Projet "jeu tétris 3D" =
Le but est de réaliser un jeu de tétris mais en 3D en s'appuyant sur le moteur de jeu Godot dans son mode 3D.

Pour plus de détails voyez la page [[projet ICN jeu tétris 3D 2018/2019]].

Année 2018-2019

2018-11-07T11:55:23Z

Rex : /* Projet "jeu 2D" */

Cette page liste les projets pour l'année scolaire 2018/2019.

= Projet "jeu de combat 3D" =
Un grand classique : essayer de réaliser un jeu de combat en utilisant le moteur graphique Unity 3D.

Pour plus de détails voyez la page [[projet ICN jeu de combat avec unity 3D 2018/2019]].

= Projet "jeu de rôle 2D Godot" =
L'idée est de réaliser un jeu d'aventure en 2D avec une interaction avec des personnages posant des énigmes.
Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu d'aventure avec Godot 2D 2018/2019]].

= Projet "robot télécommandé" =
Le but est de construire un robot qui puisse être commandé par une Raspberry Pi. Il doit être possible de
se connecter sur la Raspberry Pi avec un téléphone portable et pouvoir commander la Raspberry Pi avec une
application mobile. L'image de la caméra de la Raspberry Pi doit pouvor être visualisée sur le téléphone.

Pour plus de détails voyez la page [[projet ICN robot télécommandé 2018/2019]].

= Projet "jeu 2D snake" =
Le but est de réaliser un jeu en 2D de type "snake". Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu snake 2D avec Godot 2018/2019]].

= Projet "jeu 2D humoristique" =
Le but est de réaliser un jeu drôle en 2D. Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu humoristique 2D avec Godot 2018/2019]].

= Projet "Horloge DCF77 augmentée" =
Le but est de réaliser une horloge de classe se mettant à l'heure automatiquement et permettant une interaction avec
les élèves.

Pour plus de détails voyez la page [[projet ICN horloge DCF augmentée 2018/2019]].

= Projet "robot parlant" =
Le but est de construire un robot parlant.

Pour plus de détails voyez la page [[projet ICN robot parlant 2018/2019]].

= Projet "jeu tétris 3D" =
Le but est de réaliser un jeu de tétris mais en 3D en s'appuyant sur le moteur de jeu Godot dans son mode 3D.

Pour plus de détails voyez la page [[projet ICN jeu tétris 3D 2018/2019]].

Année 2018-2019

2018-11-07T11:51:25Z

Rex :

Cette page liste les projets pour l'année scolaire 2018/2019.

= Projet "jeu de combat 3D" =
Un grand classique : essayer de réaliser un jeu de combat en utilisant le moteur graphique Unity 3D.

Pour plus de détails voyez la page [[projet ICN jeu de combat avec unity 3D 2018/2019]].

= Projet "jeu de rôle 2D Godot" =
L'idée est de réaliser un jeu d'aventure en 2D avec une interaction avec des personnages posant des énigmes.
Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu d'aventure avec Godot 2D 2018/2019]].

= Projet "robot télécommandé" =
Le but est de construire un robot qui puisse être commandé par une Raspberry Pi. Il doit être possible de
se connecter sur la Raspberry Pi avec un téléphone portable et pouvoir commander la Raspberry Pi avec une
application mobile. L'image de la caméra de la Raspberry Pi doit pouvor être visualisée sur le téléphone.

Pour plus de détails voyez la page [[projet ICN robot télécommandé 2018/2019]].

= Projet "jeu 2D snake" =
Le but est de réaliser un jeu en 2D de type "snake". Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu snake 2D avec Godot 2018/2019]].

= Projet "jeu 2D" =
Le but est de réaliser un jeu en 2D. Le jeu est à réaliser avec le moteur de jeu Godot dans son mode 2D.

Pour plus de détails voyez la page [[projet ICN jeu 2D avec Godot 2018/2019]].

= Projet "Horloge DCF77 augmentée" =
Le but est de réaliser une horloge de classe se mettant à l'heure automatiquement et permettant une interaction avec
les élèves.

Pour plus de détails voyez la page [[projet ICN horloge DCF augmentée 2018/2019]].

= Projet "robot parlant" =
Le but est de construire un robot parlant.

Pour plus de détails voyez la page [[projet ICN robot parlant 2018/2019]].

= Projet "jeu tétris 3D" =
Le but est de réaliser un jeu de tétris mais en 3D en s'appuyant sur le moteur de jeu Godot dans son mode 3D.

Pour plus de détails voyez la page [[projet ICN jeu tétris 3D 2018/2019]].

Année 2018-2019

2018-11-07T10:09:28Z

Rex :

Année 2018-2019

2018-11-07T09:57:18Z

Rex :

MediaWiki:Sidebar

2018-11-07T08:58:53Z

Rex :

Projet ICN.io A.T.A 2017/2018

2018-05-23T11:44:23Z

Rex :

Nous nous somme inspirés des jeux web .IO qui sont des jeux en multijoueurs assez amusants pour la plupart. Quelques exemples : [http://agar.io/ Agar.io] [http://slither.io/ Slither.io] [https://diep.io/ Diep.io]

Nous avons décidé d'en produire un nous même, codé en Javascript, CSS et html, tout en utilisant d'autres language essentiels pour l'aspect multijoueur comme l'AJAX et le PHP.

Le Javascript est un language interprété c'est à dire qu'un script en Javascript doit être exécuté avec un interpréteur, comme ceux des navigateurs.

Pour apprendre le JavaScript vous pouvez aller sur [https://openclassrooms.com/courses/dynamisez-vos-sites-web-avec-javascript Openclassroom] ou d'autres sites.

Pour le html vous pouvez aller sur [https://openclassrooms.com/courses/apprenez-a-creer-votre-site-web-avec-html5-et-css3/votre-premiere-page-web-en-html Openclassroom] et [https://www.w3schools.com/html/ w3school] (ce dernier est en
anglais.)

Pour apprendre le CSS, vous pouvez aller sur [https://openclassrooms.com/courses/apprenez-a-creer-votre-site-web-avec-html5-et-css3/mettre-en-place-le-css Openclassroom] ou d'autres sites.

Pour apprendre l'AJAX vous pouvez aller sur [https://openclassrooms.com/courses/simplifiez-vos-developpements-javascript-avec-jquery/premiers-pas-avec-ajax Openclassroom] ou d'autres sites.

Pour apprendre le PHP vous pouvez aller sur [https://openclassrooms.com/courses/concevez-votre-site-web-avec-php-et-mysql Openclassroom]

Vous pouvez également aller regarder des tutoriels sur YouTube, ce sera d'autant plus efficace, il n'y a pas un meilleur site que l'autre. Nous donnons simplement des conseils pour les nouveaux en la matière.

Nous avons utilisé les librairies [https://github.com/processing/p5.js/releases/download/0.6.1/p5.js p5] et [https://github.com/molleindustria/p5.play/archive/master.zip p5Play] qui nous donnent des fonctions utilisables pour créer notre jeu. Nous nous sommes contentés d'utiliser directements des fonctions plutôt que de les créer à l'exception de certaines, cela nous aurait pris beaucoup trop de temps.

Edouard s'est plus intéressé au Javascript et à l'aspect graphique tandis que Theo s'est penché sur le php principalement mais aussi le HTML, le CSS, l'AJAX et le Javascript

Notre premier vrai code effectué est un code qui exécute un script afin d'entrer un nom pour notre jeu :

[[Fichier:Username.png|thumb|center|1688px|Entrez un nom]]

Vous pouvez récupérer le code si besoin [http://space.fenelonlille.org/Entrez%20un%20nom.js ici]

Notre jeu est un jeu web et donc sur un site : space.fenelonlille.org. Ce site est hébergé par Fénelon. Pour transférer nos fichiers sur ce site, nous utilisons FileZilla, un logiciel de transfert de fichiers.

[[Fichier:FileZilla.png|thumb|center|1700px|FileZilla]]

A gauche, nous avons les fichiers locaux et à droite, les fichiers sur le serveur du lycée. Un simple drag-clic suffit pour transférer les fichiers d'un point à l'autre.

Nous avons créé un fichier dit "main" que l'on ouvre en tant que jeu.

[[Fichier:Main.png|thumb|center|1635px|Main ICN.io]]

Ce fichier répertorie tous les autres fichiers utilisés pour faire fonctionner le jeu.

Nous avons créé plusieurs vaisseaux pour notre jeu, ils ont tous des statistiques propres à leur catégorie. On a dans l'odre :

*Les points de vie maximum.
*La vitesse maximale.
*Les dégats minimums de son projectile.
*Les dégats maximums de son projectile.
*La vitesse de base de son projectile.
*Le délai obligatoire entre chaque projectile.
*L'accélération du vaisseau.
*La portée maximale de son projectile.
*Le nom de sa catégorie.
*Son numéro de catégorie.
*La zone visible avec ce vaisseau.

[[Fichier:Vaisseauxspecifi2.png|thumb|center|700px|Caractéristiques de deux vaisseaux différents]]

On a les statistiques des vaisseaux mais ilsn'ont pas d'apparence, on doit alors leur attribuer une image, soit en la créant, soit en la téléchargeant. Il est impératif qu'elle soit sous format ".png", et qu'elle ait un fond

transparent. Pour cela modifiez son extension et retouchez là avec [https://pixlr.com/editor/ pixlr] ou autres. Pour approprier une image à sa catégorie on doit pouvoir changer de catégorie :

[[Fichier:Catégorie.png|thumb|center|1033px|Catégories]]

On attribue ensuite une image à chaque catégorie :

[[Fichier:Images.png|thumb|center|701px|Attribution des images]]

Maintenant on a des vaisseaux avec des statistiques et qui ressemblent à quelque chose mais maintenant il faut les faire bouger, pour ça on créer une fonction permettant de les faire bouger :

[[Fichier:Mouvements.png|thumb|center|1325px|Mouvements du vaisseau]]

Maintenant qu'on a plusieurs vaisseaux et qu'ils bougent, il faut les faire tirer, sinon notre jeu n'a pas d'intérêt. Donc on a créé plusieurs fonctions de tir différentes, une fonction pour un missile lié à un seul vaisseau et une fonction de tir standard pour la plupart de nos vaisseaux.

D'abord, on donne une image à nos projectiles

[[Fichier:Standard.png|thumb|center|371px|Balle Standard]]
[[Fichier:Missile.png|thumb|center|416px|Missile]]

On créer ensuite la fonction de tir générale pour TOUS les vaisseaux :

[[Fichier:Tir.png|thumb|center|411px|Fonction de tir générale]]

On doit ensuite prendre en compte que les vaisseaux perdent des points de vie au contact des projecticles. On doit donc créer une fonction pour ça :

[[Fichier:Dégats.png|thumb|center|1166px|Dégats infligés]]

On doit ensuite uniquement pour le missile, coder son comportement, ici nous voulons un missile à tête chercheuse.

[[Fichier:MissileComp2.png|thumb|center|770px|Comportement du missile]]

Nous pouvons retrouver cette fonction avec des instructions en plus ci-dessous pour compléter la fonction de tête chercheuse.

[[Fichier:MissileComp.png|thumb|center|730px|Comportement du missile]]

Ensuite, on code le tir pour chacun des vaisseaux, car nous voulons un type de tir différents pour chacun. Dans ce code, nous mettrons dans l'ordre :

*D'où le projectile est tiré.
*A quel vaisseau il appartient, car nous ne voulons pas faire tirer un vaisseau aléatoire.
*Les dégats du projectile.
*Attribution de l'image du projectile pour le vaisseau. Nous donnons juste la variable à laquelle nous avons attribué l'image auparavant.
*Sa vitesse.
*Son sens de tir (Sa rotation, ou angle de tir)
*Sa durée de vie

[[Fichier:Base.png|thumb|center|667px|Tir du vaisseau de base]]
[[Fichier:Tank.png|thumb|center|654px|Tir du Tank]]

Le scout tire 3 projectiles simultanément et de trois endroits différents, donc nous devons faire un partie pour chaque projectiles.

[[Fichier:Scout.png|thumb|center|1354px|Tir du scout]]
[[Fichier:Railgun.png|thumb|center|1318px|Tir du Railgun]]

Le multijoueur est possible grâce au php et au AJAX qui se communiquent les informations qui se déroule dans le jeu :

[[Fichier:Infos.png|thumb|center|238px|Infos transmises]]

Toutes ces infos sont transmises en permanance et en continu au fichier "Reception" qui va les actualiser en permanence et en continu.

[[Fichier:Receptionphp.png|thumb|center|1920px|Données d'un vaisseau gérées par le fichier reception.php]]

Chaque ligne comme celle-ci dans ce fichier reception.php est un nouveau vaisseau, si ce fichier n'est pas là, le multijoueur ne serait pas possible et il n'y aurait qu'un type de jeu local. Ce fichier va permettre de gérer des

connexions de différents ordinateur et donc de permettre le multijoueur.

Projet ICN robot sonore A.T.A 2017/2018

2018-05-09T11:39:34Z

Rex :

Bienvenue sur la page de '''Projet ICN robot sonore A.T.A 2017/2018 robot calmant !!!'''
==='''''Participants'''''===
* '''Antoine BUGNER'''
* '''Alexandre DELAHAYE'''
* '''Tinaël DELZENNE-ZAMPARUTTI'''
 

== '''''Le robot''''' ==
Donc le but de ce robot est simple : juste détecter les zones où il y a du bruits, et enclencher une enceinte disant à la personne ou à la zone du bruit quelque chose... C'est un robot unique au monde et donc nous sommes heureux de vous le présenter.
<gallery widths=200px heights=125px>
Fichier:IMG 20171122 113442.jpg|Le robot avec les fils.
Fichier:IMG 20171206 113849.jpg|Sans fils
Fichier:IMG 20171206 114001.jpg|Du dessous
</gallery>
== '''''Circuit imprimé''''' ==
Voici '''le circuit imprimé''' utilisé pour le robot sonore, ou calmant
----
[[Fichier:Circuit imprimé A.T.A.png|thumb|left|200px|Le circuit imprimé]]
 
''Voici le fichier .fzz pour ceux qui voudrait voir comment nous avons procéder.''
[[Media:Projet ICN A.T.A.fzz]]
 
== '''''Les composants du robot :''''' ==
=== Le micro ===
<gallery widths=300px heights=225px>
Fichier:IMG 20171122 113033.jpg|Voici le micro utilisé
Fichier:IMG 20171122 113042.jpg|autre vue.
</gallery>
 
=== Plaquette d'essais et plaquette pololu md08 ===
Plaquette avec '''pololu md08''' et donc plusieurs fils qui permettent '''le bon fonctionnement de l'appareil.'''
<gallery widths=200px heights=125px>
Fichier:0J4621.1200.jpg|'''POLOLU Md08'''
Fichier:IMG 20171206 114238.jpg|'''Pololu Md08'''
Fichier:G-PE170WHI.jpg|plaquette essais vierge
Fichier:IMG 20171122 114828-1-.jpg|Voici la plaquette avec la pololu md08 et plusieurs fils qui y sont renseigné dans le fichier suivant :[[Media:Projet ICN A.T.A.fzz]]
</gallery>
 
Bien sur, étant donner que c'est quand même beaucoup plus simple d'enlever les fils, nous avons remplacer tous ça avec une carte arduino ou tous les fils sont remplacés par des circuits gravé sur une plaque de cuivre. On appelle ça "bouclier".
<gallery widths=300px heights=225px>
Fichier:Circuit imprimé A.T.A.png|donc voici la version numérique :
Fichier:IMG 20171129 110735.jpg| et voici le final :
</gallery>
 

=== Carte Arduino Uno ===
Voici la carte principale donc '''l'Arduino Uno''' qui est donc la base de la commande du robot.
[[Fichier:IMG 20171122 114840-1-.jpg|200px|thumb|left|Voici la carte Arduino qui permet le bon fonctionnement de l'appareil. Fichier pour plus de précision : [[Media:Projet ICN A.T.A.fzz]] ]]
 
== '''Les étapes du montage du robot''' ==
=== Première étape : ''Faire que le robot puisse rouler. 1.'' ===
Montage du robot, manque de matériel, nous n'avons pas pus prendre de photos de la construction. Mais après cela, nous avons terminé le montage du robot mais sans la carte arduino et la plaquette avec la pololu md08
 
=== ''1e. 2.'' ===
Position des fils sur le logiciel fritzing, puis créations de la carte via informatique :
Voici le fichier : [[Media:Projet ICN A.T.A.fzz]]
[[Fichier:Circuit imprimé A.T.A.png|thumb|left|donc voici le circuit imprimé finalisé version informatique ]]
 
=== ''1e. 3.'' ===
Création du "bouclier" donc de la plaque de cuivre avec tous les systèmes.
[[Fichier:IMG 20171129 110735.jpg|thumb|left|200px|Donc le "bouclier"]]
 
=== '''1e. 4. La soudure !''' ===
<gallery widths=250px heights=175px>
Fichier:IMG 20171129 112007.jpg|'''Le fer à souder'''
Fichier:IMG 20171129 112829.jpg|
Fichier:IMG 20171129 121927.jpg|Et donc en plus précis...
Fichier:IMG 20171129 124707.jpg|Soudure finie
</gallery>
 

=== 1e. 5. '''Etape terminée !!!''' ===
C'est bon, '''la carte est terminé''', il faut plus que nous la relions sur '''la base arduino''' et le moteur pourra '''être en état fonctionnel'''.
[[Fichier:IMG 20171206 114300.jpg|thumb|left|200px|Voici le bouclier terminé avec toutes les soudures.]]
 
== '''2. Montage du micro''' ==
=====''Test du micro''=====
Nous devons mettre le micro sur la plaque d'essai pour le tester.
<gallery widths=300px heights=225px>
Fichier:IMG 20171206 114318.jpg|Micro sur plaque d'essai.
Fichier:IMG 20171206 114335.jpg|Autre vue
</gallery>
=====''Support micro''=====
Voici les differentes versions de support:

<gallery widths=250px heights=175px>
Fichier:Photo oreille 1.png|étape 1
Fichier:Photo oreille 2.png|étape 2
Fichier:Photo oreille 3.png|étape 3
Fichier:Support finale.png|étape finale
</gallery>

== '''Les programmes''' ==

Voici le programme arduino qui permet de faire marcher les moteurs du robot et donc pouvoir le contrôler et faire bouger ce robot

int pwmB = 11;
int bin2 = 13;
int bin1 = 12;
int stby = 8;
int ain1 = 7;
int ain2 = 4;
int pwmA = 3;
void avancer(void)//Déclare la fonction qui fait avancer le robot
{
Serial.println("Avant");
digitalWrite(ain1, HIGH);//Lance le courant
digitalWrite(ain2, LOW);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);//Donne la puissance du moteur 1
analogWrite(pwmB, 125);//Donne la puissance du moteur 2 (pour qu'il aille droit)
}

void tour(void) //Déclare la fonction qui fait effectuer un tour au robot
{
Serial.println("Tour");
digitalWrite(ain1, LOW);//Lance le courant...
digitalWrite(ain2, HIGH);//et fait en sorte qu'un des moteurs tourne a l'envers pour que le robot tourne sur lui-même
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);//Donne la puissance du moteur 1
analogWrite(pwmB, 125);//Donne la puissance du moteur 2
delay(3750);//Donne le temps durant lequel le robot va tourner sur lui-même
digitalWrite(stby, LOW);//arrête les moteurs
}

void demitour(void)
{
Serial.println("Tour");
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(890);
digitalWrite(stby, LOW);
}

void quarttour(void)
{
Serial.println("Tour");
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(450);
digitalWrite(stby, LOW);
}

void setup()
{
Serial.begin(9600);
pinMode(pwmB, OUTPUT);
pinMode(bin2, OUTPUT);
pinMode(bin1, OUTPUT);
pinMode(stby, OUTPUT);
pinMode(ain1, OUTPUT);
pinMode(ain2, OUTPUT);
pinMode(pwmA, OUTPUT);
tour(); // Exécute la fonction du tour
avancer();
demitour();
avancer();
tour();
}

void loop()
{
}

Voici le programme arduino qui permet de faire marcher les moteurs du robot et donc pouvoir le contrôler et faire bouger ce robot

const int capteur1 =A0;// pin connecté à la sortie digital du micro L
const int capteur2 =A1;// pin connecté à la sortie digital du micro R
const int LED1 =12;// pin connecté à la LED RED + resistance
const int LED2 =13;// pin connecté à la LED GREEN + resistance

void setup()
{
pinMode(capteur1, INPUT);//Déclare le micro 1
pinMode(capteur2, INPUT);//Déclare le micro 2
pinMode(LED1, OUTPUT);//Déclare la led 1
pinMode(LED2, OUTPUT);//Déclare la led 2
Serial.begin (9600);
}

void loop()
int v1 = analogRead(capteur1);//Déclare la variable du volume capté et met cette variable au niveau du volume capté par le micro 1
int v2 = analogRead(capteur2);//Déclare la variable du volume capté et met cette variable au niveau du volume capté par le micro 2
if (v1>8)//si le volume est superieur a 8, la led s'allume
{
Serial.println(v1);
digitalWrite(LED1, HIGH);// Eteindre la LED
delay(100);// Temps de traitement
digitalWrite(LED1, LOW);
delay(100);
}
if (v2>10)
{
Serial.println(v2);
digitalWrite(LED2, HIGH);// Eteindre la LED
delay(100);// Temps de traitement
digitalWrite(LED2, LOW);
delay(100);
}
}

Projet ICN robot sonore A.T.A 2017/2018

2018-05-09T11:38:51Z

Rex :

Bienvenue sur la page de '''Projet ICN robot sonore A.T.A 2017/2018 robot calmant !!!'''
==='''''Participants'''''===
* '''Antoine BUGNER'''
* '''Alexandre DELAHAYE'''
* '''Tinaël DELZENNE-ZAMPARUTTI'''
 

== '''''Le robot''''' ==
Donc le but de ce robot est simple : juste détecter les zones où il y a du bruits, et enclencher une enceinte disant à la personne ou à la zone du bruit quelque chose... C'est un robot unique au monde et donc nous sommes heureux de vous le présenter.
<gallery widths=200px heights=125px>
Fichier:IMG 20171122 113442.jpg|Le robot avec les fils.
Fichier:IMG 20171206 113849.jpg|Sans fils
Fichier:IMG 20171206 114001.jpg|Du dessous
</gallery>
== '''''Circuit imprimé''''' ==
Voici '''le circuit imprimé''' utilisé pour le robot sonore, ou calmant
----
[[Fichier:Circuit imprimé A.T.A.png|thumb|left|200px|Le circuit imprimé]]
 
''Voici le fichier .fzz pour ceux qui voudrait voir comment nous avons procéder.''
[[Media:Projet ICN A.T.A.fzz]]
 
== '''''Les composants du robot :''''' ==
=== Le micro ===
<gallery widths=300px heights=225px>
Fichier:IMG 20171122 113033.jpg|Voici le micro utilisé
Fichier:IMG 20171122 113042.jpg|autre vue.
</gallery>
 
=== Plaquette d'essais et plaquette pololu md08 ===
Plaquette avec '''pololu md08''' et donc plusieurs fils qui permettent '''le bon fonctionnement de l'appareil.'''
<gallery widths=200px heights=125px>
Fichier:0J4621.1200.jpg|'''POLOLU Md08'''
Fichier:IMG 20171206 114238.jpg|'''Pololu Md08'''
Fichier:G-PE170WHI.jpg|plaquette essais vierge
Fichier:IMG 20171122 114828-1-.jpg|Voici la plaquette avec la pololu md08 et plusieurs fils qui y sont renseigné dans le fichier suivant :[[Media:Projet ICN A.T.A.fzz]]
</gallery>
 
Bien sur, étant donner que c'est quand même beaucoup plus simple d'enlever les fils, nous avons remplacer tous ça avec une carte arduino ou tous les fils sont remplacés par des circuits gravé sur une plaque de cuivre. On appelle ça "bouclier".
<gallery widths=300px heights=225px>
Fichier:Circuit imprimé A.T.A.png|donc voici la version numérique :
Fichier:IMG 20171129 110735.jpg| et voici le final :
</gallery>
 

=== Carte Arduino Uno ===
Voici la carte principale donc '''l'Arduino Uno''' qui est donc la base de la commande du robot.
[[Fichier:IMG 20171122 114840-1-.jpg|200px|thumb|left|Voici la carte Arduino qui permet le bon fonctionnement de l'appareil. Fichier pour plus de précision : [[Media:Projet ICN A.T.A.fzz]] ]]
 
== '''Les étapes du montage du robot''' ==
=== Première étape : ''Faire que le robot puisse rouler. 1.'' ===
Montage du robot, manque de matériel, nous n'avons pas pus prendre de photos de la construction. Mais après cela, nous avons terminé le montage du robot mais sans la carte arduino et la plaquette avec la pololu md08
 
=== ''1e. 2.'' ===
Position des fils sur le logiciel fritzing, puis créations de la carte via informatique :
Voici le fichier : [[Media:Projet ICN A.T.A.fzz]]
[[Fichier:Circuit imprimé A.T.A.png|thumb|left|donc voici le circuit imprimé finalisé version informatique ]]
 
=== ''1e. 3.'' ===
Création du "bouclier" donc de la plaque de cuivre avec tous les systèmes.
[[Fichier:IMG 20171129 110735.jpg|thumb|left|200px|Donc le "bouclier"]]
 
=== '''1e. 4. La soudure !''' ===
<gallery widths=250px heights=175px>
Fichier:IMG 20171129 112007.jpg|'''Le fer à souder'''
Fichier:IMG 20171129 112829.jpg|
Fichier:IMG 20171129 121927.jpg|Et donc en plus précis...
Fichier:IMG 20171129 124707.jpg|Soudure finie
</gallery>
 

=== 1e. 5. '''Etape terminée !!!''' ===
C'est bon, '''la carte est terminé''', il faut plus que nous la relions sur '''la base arduino''' et le moteur pourra '''être en état fonctionnel'''.
[[Fichier:IMG 20171206 114300.jpg|thumb|left|200px|Voici le bouclier terminé avec toutes les soudures.]]
 
== '''2. Montage du micro''' ==
=====''Test du micro''=====
Nous devons mettre le micro sur la plaque d'essai pour le tester.
<gallery widths=300px heights=225px>
Fichier:IMG 20171206 114318.jpg|Micro sur plaque d'essai.
Fichier:IMG 20171206 114335.jpg|Autre vue
</gallery>
=====''Support micro''=====
Voici les differentes versions de support:

<gallery widths=250px heights=175px>
Fichier:Photo oreille 1.png|étape 1
Fichier:Photo oreille 2.png|étape 2
Fichier:Photo oreille 3.png|étape 3
Fichier:Support finale.png|étape finale
</gallery>

== '''Les programmes''' ==

Voici le programme arduino qui permet de faire marcher les moteurs du robot et donc pouvoir le contrôler et faire bouger ce robot

int pwmB = 11;
int bin2 = 13;
int bin1 = 12;
int stby = 8;
int ain1 = 7;
int ain2 = 4;
int pwmA = 3;
void avancer(void)//Déclare la fonction qui fait avancer le robot
{
Serial.println("Avant");
digitalWrite(ain1, HIGH);//Lance le courant
digitalWrite(ain2, LOW);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);//Donne la puissance du moteur 1
analogWrite(pwmB, 125);//Donne la puissance du moteur 2 (pour qu'il aille droit)
}

void tour(void) //Déclare la fonction qui fait effectuer un tour au robot
{
Serial.println("Tour");
digitalWrite(ain1, LOW);//Lance le courant...
digitalWrite(ain2, HIGH);//et fait en sorte qu'un des moteurs tourne a l'envers pour que le robot tourne sur lui-même
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);//Donne la puissance du moteur 1
analogWrite(pwmB, 125);//Donne la puissance du moteur 2
delay(3750);//Donne le temps durant lequel le robot va tourner sur lui-même
digitalWrite(stby, LOW);//arrête les moteurs
}

void demitour(void)
{
Serial.println("Tour");
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(890);
digitalWrite(stby, LOW);
}

void quarttour(void)
{
Serial.println("Tour");
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(450);
digitalWrite(stby, LOW);
}

void setup()
{
Serial.begin(9600);
pinMode(pwmB, OUTPUT);
pinMode(bin2, OUTPUT);
pinMode(bin1, OUTPUT);
pinMode(stby, OUTPUT);
pinMode(ain1, OUTPUT);
pinMode(ain2, OUTPUT);
pinMode(pwmA, OUTPUT);
tour(); // Exécute la fonction du tour
avancer();
demitour();
avancer();
tour();
}

void loop()
{
}

Voici le programme arduino qui permet de faire marcher les moteurs du robot et donc pouvoir le contrôler et faire bouger ce robot

const int capteur1 =A0;// pin connecté à la sortie digital du micro L
const int capteur2 =A1;// pin connecté à la sortie digital du micro R
const int LED1 =12;// pin connecté à la LED RED + resistance
const int LED2 =13;// pin connecté à la LED GREEN + resistance
void setup()
{
pinMode(capteur1, INPUT);//Déclare le micro 1
pinMode(capteur2, INPUT);//Déclare le micro 2
pinMode(LED1, OUTPUT);//Déclare la led 1
pinMode(LED2, OUTPUT);//Déclare la led 2
Serial.begin (9600);
}

void loop()
int v1 = analogRead(capteur1);//Déclare la variable du volume capté et met cette variable au niveau du volume capté par le micro 1
int v2 = analogRead(capteur2);//Déclare la variable du volume capté et met cette variable au niveau du volume capté par le micro 2
if (v1>8)//si le volume est superieur a 8, la led s'allume
{
Serial.println(v1);
digitalWrite(LED1, HIGH);// Eteindre la LED
delay(100);// Temps de traitement
digitalWrite(LED1, LOW);
delay(100);
}
if (v2>10)
{
Serial.println(v2);
digitalWrite(LED2, HIGH);// Eteindre la LED
delay(100);// Temps de traitement
digitalWrite(LED2, LOW);
delay(100);
}
}

Projet ICN robot sonore A.T.A 2017/2018

2018-05-09T11:36:33Z

Rex :

Bienvenue sur la page de '''Projet ICN robot sonore A.T.A 2017/2018 robot calmant !!!'''
==='''''Participants'''''===
* '''Antoine BUGNER'''
* '''Alexandre DELAHAYE'''
* '''Tinaël DELZENNE-ZAMPARUTTI'''
 

== '''''Le robot''''' ==
Donc le but de ce robot est simple : juste détecter les zones où il y a du bruits, et enclencher une enceinte disant à la personne ou à la zone du bruit quelque chose... C'est un robot unique au monde et donc nous sommes heureux de vous le présenter.
<gallery widths=200px heights=125px>
Fichier:IMG 20171122 113442.jpg|Le robot avec les fils.
Fichier:IMG 20171206 113849.jpg|Sans fils
Fichier:IMG 20171206 114001.jpg|Du dessous
</gallery>
== '''''Circuit imprimé''''' ==
Voici '''le circuit imprimé''' utilisé pour le robot sonore, ou calmant
----
[[Fichier:Circuit imprimé A.T.A.png|thumb|left|200px|Le circuit imprimé]]
 
''Voici le fichier .fzz pour ceux qui voudrait voir comment nous avons procéder.''
[[Media:Projet ICN A.T.A.fzz]]
 
== '''''Les composants du robot :''''' ==
=== Le micro ===
<gallery widths=300px heights=225px>
Fichier:IMG 20171122 113033.jpg|Voici le micro utilisé
Fichier:IMG 20171122 113042.jpg|autre vue.
</gallery>
 
=== Plaquette d'essais et plaquette pololu md08 ===
Plaquette avec '''pololu md08''' et donc plusieurs fils qui permettent '''le bon fonctionnement de l'appareil.'''
<gallery widths=200px heights=125px>
Fichier:0J4621.1200.jpg|'''POLOLU Md08'''
Fichier:IMG 20171206 114238.jpg|'''Pololu Md08'''
Fichier:G-PE170WHI.jpg|plaquette essais vierge
Fichier:IMG 20171122 114828-1-.jpg|Voici la plaquette avec la pololu md08 et plusieurs fils qui y sont renseigné dans le fichier suivant :[[Media:Projet ICN A.T.A.fzz]]
</gallery>
 
Bien sur, étant donner que c'est quand même beaucoup plus simple d'enlever les fils, nous avons remplacer tous ça avec une carte arduino ou tous les fils sont remplacés par des circuits gravé sur une plaque de cuivre. On appelle ça "bouclier".
<gallery widths=300px heights=225px>
Fichier:Circuit imprimé A.T.A.png|donc voici la version numérique :
Fichier:IMG 20171129 110735.jpg| et voici le final :
</gallery>
 

=== Carte Arduino Uno ===
Voici la carte principale donc '''l'Arduino Uno''' qui est donc la base de la commande du robot.
[[Fichier:IMG 20171122 114840-1-.jpg|200px|thumb|left|Voici la carte Arduino qui permet le bon fonctionnement de l'appareil. Fichier pour plus de précision : [[Media:Projet ICN A.T.A.fzz]] ]]
 
== '''Les étapes du montage du robot''' ==
=== Première étape : ''Faire que le robot puisse rouler. 1.'' ===
Montage du robot, manque de matériel, nous n'avons pas pus prendre de photos de la construction. Mais après cela, nous avons terminé le montage du robot mais sans la carte arduino et la plaquette avec la pololu md08
 
=== ''1e. 2.'' ===
Position des fils sur le logiciel fritzing, puis créations de la carte via informatique :
Voici le fichier : [[Media:Projet ICN A.T.A.fzz]]
[[Fichier:Circuit imprimé A.T.A.png|thumb|left|donc voici le circuit imprimé finalisé version informatique ]]
 
=== ''1e. 3.'' ===
Création du "bouclier" donc de la plaque de cuivre avec tous les systèmes.
[[Fichier:IMG 20171129 110735.jpg|thumb|left|200px|Donc le "bouclier"]]
 
=== '''1e. 4. La soudure !''' ===
<gallery widths=250px heights=175px>
Fichier:IMG 20171129 112007.jpg|'''Le fer à souder'''
Fichier:IMG 20171129 112829.jpg|
Fichier:IMG 20171129 121927.jpg|Et donc en plus précis...
Fichier:IMG 20171129 124707.jpg|Soudure finie
</gallery>
 

=== 1e. 5. '''Etape terminée !!!''' ===
C'est bon, '''la carte est terminé''', il faut plus que nous la relions sur '''la base arduino''' et le moteur pourra '''être en état fonctionnel'''.
[[Fichier:IMG 20171206 114300.jpg|thumb|left|200px|Voici le bouclier terminé avec toutes les soudures.]]
 
== '''2. Montage du micro''' ==
=====''Test du micro''=====
Nous devons mettre le micro sur la plaque d'essai pour le tester.
<gallery widths=300px heights=225px>
Fichier:IMG 20171206 114318.jpg|Micro sur plaque d'essai.
Fichier:IMG 20171206 114335.jpg|Autre vue
</gallery>
=====''Support micro''=====
Voici les differentes versions de support:

<gallery widths=250px heights=175px>
Fichier:Photo oreille 1.png|étape 1
Fichier:Photo oreille 2.png|étape 2
Fichier:Photo oreille 3.png|étape 3
Fichier:Support finale.png|étape finale
</gallery>

== '''Les programmes''' ==

Voici le programme arduino qui permet de faire marcher les moteurs du robot et donc pouvoir le contrôler et faire bouger ce robot

int pwmB = 11;
int bin2 = 13;
int bin1 = 12;
int stby = 8;
int ain1 = 7;
int ain2 = 4;
int pwmA = 3;
void avancer(void)//Déclare la fonction qui fait avancer le robot
{Serial.println("Avant");
digitalWrite(ain1, HIGH);//Lance le courant
digitalWrite(ain2, LOW);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);//Donne la puissance du moteur 1
analogWrite(pwmB, 125);//Donne la puissance du moteur 2 (pour qu'il aille droit)

}
void tour(void) //Déclare la fonction qui fait effectuer un tour au robot
{

Serial.println("Tour");
digitalWrite(ain1, LOW);//Lance le courant...
digitalWrite(ain2, HIGH);//et fait en sorte qu'un des moteurs tourne a l'envers pour que le robot tourne sur lui-même
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);//Donne la puissance du moteur 1
analogWrite(pwmB, 125);//Donne la puissance du moteur 2
delay(3750);//Donne le temps durant lequel le robot va tourner sur lui-même
digitalWrite(stby, LOW);//arrête les moteurs
}

void demitour(void){
Serial.println("Tour");
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(890);
digitalWrite(stby, LOW);
}
void quarttour(void){
Serial.println("Tour");
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(450);
digitalWrite(stby, LOW);
}
void setup()
{
Serial.begin(9600);
pinMode(pwmB, OUTPUT);
pinMode(bin2, OUTPUT);
pinMode(bin1, OUTPUT);
pinMode(stby, OUTPUT);
pinMode(ain1, OUTPUT);
pinMode(ain2, OUTPUT);
pinMode(pwmA, OUTPUT);
tour(); // Exécute la fonction du tour

avancer();
demitour();
avancer();
tour();
}
void loop()
{
}

Voici le programme arduino qui permet de faire marcher les moteurs du robot et donc pouvoir le contrôler et faire bouger ce robot

const int capteur1 =A0;// pin connecté à la sortie digital du micro L
const int capteur2 =A1;// pin connecté à la sortie digital du micro R
const int LED1 =12;// pin connecté à la LED RED + resistance
const int LED2 =13;// pin connecté à la LED GREEN + resistance
void setup()
{
pinMode(capteur1, INPUT);//Déclare le micro 1
pinMode(capteur2, INPUT);//Déclare le micro 2
pinMode(LED1, OUTPUT);//Déclare la led 1
pinMode(LED2, OUTPUT);//Déclare la led 2
Serial.begin (9600);
}

void loop()
int v1 = analogRead(capteur1);//Déclare la variable du volume capté et met cette variable au niveau du volume capté par le micro 1
int v2 = analogRead(capteur2);//Déclare la variable du volume capté et met cette variable au niveau du volume capté par le micro 2
if (v1>8)//si le volume est superieur a 8, la led s'allume
{
Serial.println(v1);
digitalWrite(LED1, HIGH);// Eteindre la LED
delay(100);// Temps de traitement
digitalWrite(LED1, LOW);
delay(100);
}
if (v2>10)
{
Serial.println(v2);
digitalWrite(LED2, HIGH);// Eteindre la LED
delay(100);// Temps de traitement
digitalWrite(LED2, LOW);
delay(100);
}
}

Projet PONG 2017/2018

2018-05-09T11:02:51Z

Rex :

La programmation de PONG nous permet de nous familiariser avec l'interface de GODOT et la façon de s'en servir afin de créer, par la suite, un jeu de combat en 2D, grâce à ce même logiciel.

Le principe de PONG est un jeu de tennis de table virtuel, et est l'un des plus anciens jeu vidéo jamais crée. Nous l'avons recrée sur GODOT en y ajoutant quelques modifications :

*Nous avons réussi à jouer avec 4 palettes, ce qui permet de jouer en 2 contre 2.

*Nous avons également réussi à faire en sorte que les palettes se déplacent également de gauche à droite, et pas seulement de haut en bas.

*Nous avons crée un affichage des scores et un compteur de rebonds.

*Nous avons fait en sorte que la balle change de couleur aléatoirement à chaque rebond.

*Nous avons ajouté des sons à chaque fois que la balle touchait une palette.

Logiciel utilisé : [https://godotengine.org/ Godot]

Ficher PONG : [https://icn.fenelonlille.org/mediawiki/index.php/Fichier:Pong.zip#file PONG]

Fayad ; Vladisslav ; Timéo ; Julien

Projet ICN.io A.T.A 2017/2018

2018-05-09T11:01:01Z

Rex :

Nous nous somme inspirés des jeux web .IO qui sont des jeux en multijoueurs assez amusants pour la plupart.

Nous avons décidé d'en produire un nous même, codé en Javascript, CSS et html.

Nous avons utilisé la librairie p5 qui nous donne des fonctions utilisable pour des créer notre jeu; Nous nous sommes contenté d'assembler les fonctions plutôt que de les créer...

Edouard s'est plus intéressé au Javascript et à l'aspect graphique tandis que Theo s'est penché sur le php principalement mais aussi le HTML, le CSS, l'AJAX et le Javascript

Notre premier vrai code effectué est un code qui exécute un script afin d'entrer un nom pour notre jeu :

var Username = prompt("Entrez un nom (celui ci vous désignera durant la partie(10 caractères max.))");
while (true) {
if (Username){
if (Username.length > 10) { Username = prompt("Votre nom est trop long, entrez-en un plus court"); }
else { if (confirm("Etes-vous sur de vouloir posséder ce nom ?")) {alert("Votre nom sera " + Username); break; }
else {Username = prompt("Entrez un autre nom");}
}
}
else {Username = prompt("Ce nom n'est pas disponible, veuillez en entrer un autre.")}
}

Nous avons créé un fichier dit "main" que l'on ouvre en tant que jeu.

[[Fichier:Vaisseau_normal_healer.jpg|thumb|center|300px|Main ICN.io]]

Ce fichier répertorie tous les autres fichiers utilisés pour faire fonctionner le jeu.

Nous avons créé plusieurs vaisseaux pour notre jeu ils sont caractérisés par ceci dans notre code :

[[Fichier:Carac_Vaisseau.png|thumb|center|300px|Caractéristiques des vaisseaux]]

Cette partie de code peut être réutilisée pour défénir les statistiques d'un vaisseau :

[[Fichier:Carac_Vaisseau 2.png|thumb|center|300px|Caractéristiques de deux vaisseaux différents]]

Nous pouvons modifier les points de vies, l'accélération, la vitesse de leurs projectiles et autres grâce à cette partie de code.

Le multijoueur est possible grâce au php et au AJAX qui se communiquent les informations qui se déroule dans le jeu :

[[Fichier:Données_php.png|thumb|center|300px|Données d'un vaisseau gérées par le fichier reception.php]]

Chaque ligne comme celle-ci dans ce fichier reception.php est un nouveau vaisseau, si ce fichier n'est pas là, le multijoueur ne serait pas possible et il n'y aurait qu'un type de jeu local. Ce fichier va permettre de gérer des connexions de différents ordinateur et donc de permettre le multijoueur.

Projet ICN.io A.T.A 2017/2018

2018-05-09T10:59:43Z

Rex :

Nous nous somme inspirés des jeux web .IO qui sont des jeux en multijoueurs assez amusants pour la plupart.

Nous avons décidé d'en produire un nous même, codé en Javascript, CSS et html.

Nous avons utilisé la librairie p5 qui nous donne des fonctions utilisable pour des créer notre jeu; Nous nous sommes contenté d'assembler les fonctions plutôt que de les créer...

Edouard s'est plus intéressé au Javascript et à l'aspect graphique tandis que Theo s'est penché sur le php principalement mais aussi le HTML, le CSS, l'AJAX et le Javascript

Notre premier vrai code effectué est un code qui exécute un script afin d'entrer un nom pour notre jeu :

var Username = prompt("Entrez un nom (celui ci vous désignera durant la partie(10 caractères max.))");
while (true) {
if (Username){
if (Username.length > 10) { Username = prompt("Votre nom est trop long, entrez-en un plus court"); }
else { if (confirm("Etes-vous sur de vouloir posséder ce nom ?")) {alert("Votre nom sera " + Username); break; }
else {Username = prompt("Entrez un autre nom");}
}
}
else {Username = prompt("Ce nom n'est pas disponible, veuillez en entrer un autre.")}
}

Nous avons créé un fichier dit "main" que l'on ouvre en tant que jeu.

[[Fichier:Vaisseau_normal_healer.jpg|thumb|left|300px|Main ICN.io]]

Ce fichier répertorie tous les autres fichiers utilisés pour faire fonctionner le jeu.

Nous avons créé plusieurs vaisseaux pour notre jeu ils sont caractérisés par ceci dans notre code :

[[Fichier:Carac_Vaisseau.png|thumb|left|300px|Caractéristiques des vaisseaux]]

Cette partie de code peut être réutilisée pour défénir les statistiques d'un vaisseau :

[[Fichier:Carac_Vaisseau 2.png|thumb|left|300px|Caractéristiques de deux vaisseaux différents]]

Nous pouvons modifier les points de vies, l'accélération, la vitesse de leurs projectiles et autres grâce à cette partie de code.

Le multijoueur est possible grâce au php et au AJAX qui se communiquent les informations qui se déroule dans le jeu :

[[Fichier:Données_php.png|thumb|left|300px|Données d'un vaisseau gérées par le fichier reception.php]]

Chaque ligne comme celle-ci dans ce fichier reception.php est un nouveau vaisseau, si ce fichier n'est pas là, le multijoueur ne serait pas possible et il n'y aurait qu'un type de jeu local. Ce fichier va permettre de gérer des connexions de différents ordinateur et donc de permettre le multijoueur.

Projet ICN.io A.T.A 2017/2018

2017-12-20T13:24:19Z

Rex :

Projet panneau multifonction 2017/2018

2017-12-20T11:30:20Z

Rex :

Bonjour à vous et bienvenue dans notre monde numérique nous avons confectionné spécialement pour vous un panneau d'affichage multifonctions où vous pourrez afficher ce que vous voulez grâce à un programme disponible sur cette page :

Alors nous sommes une équipe de 4 passionnés d'informatique.
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

<gallery widths=200px heights=225px>
Fichier:Snapchat-1628077171.jpg|Romain
Fichier:Snapchat-1557163491.jpg|Jess
Fichier:Snapchat-651539379.jpg|Bouba
Fichier:20171023 115243.jpg|Gabin
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Page d'informations sur le panneau de LEDs : [https://www.dfrobot.com/wiki/index.php/64x32_RGB_LED_Matrix_-_4mm_pitch_SKU:DFR0460]
[[Fichier:1000px-DFR0460 Diagram.jpg|thumb|500px|left|Schéma de connexion]]
 
<gallery widths=300px heights=225px>
Fichier:Circuit.jpg|platine d'essai panneaux multifonction
Fichier:Gabin.jpg|circuit imprimé panneaux multifonction
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>

Fichier:Snapchat-1381717098.jpg|voici l’arrière de notre projet

</gallery>
 

Fichier:Snapchat-1381717098.jpg

</gallery>
 
[[Media:Arduino_mega.fzz]]

Projet panneau multifonction 2017/2018

2017-12-20T11:29:56Z

Rex :

Bonjour à vous et bienvenue dans notre monde numérique nous avons confectionné spécialement pour vous un panneau d'affichage multifonctions où vous pourrez afficher ce que vous voulez grâce à un programme disponible sur cette page :

Alors nous sommes une équipe de 4 passionnés d'informatique.
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

<gallery widths=200px heights=225px>
Fichier:Snapchat-1628077171.jpg|Romain
Fichier:Snapchat-1557163491.jpg|Jess
Fichier:Snapchat-651539379.jpg|Bouba
Fichier:20171023 115243.jpg|Gabin
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Page d'informations sur le panneau de LEDs : [https://www.dfrobot.com/wiki/index.php/64x32_RGB_LED_Matrix_-_4mm_pitch_SKU:DFR0460]
[[Fichier:1000px-DFR0460 Diagram.jpg|thumb|500px|left|Schéma de connexion]]

<gallery widths=300px heights=225px>
Fichier:Circuit.jpg|platine d'essai panneaux multifonction
Fichier:Gabin.jpg|circuit imprimé panneaux multifonction
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>

Fichier:Snapchat-1381717098.jpg|voici l’arrière de notre projet

</gallery>
 

Fichier:Snapchat-1381717098.jpg

</gallery>
 
[[Media:Arduino_mega.fzz]]

Fichier:1000px-DFR0460 Diagram.jpg

2017-12-20T11:28:02Z

Rex :

Projet panneau multifonction 2017/2018

2017-12-20T11:25:52Z

Rex :

Bonjour à vous et bienvenue dans notre monde numérique nous avons confectionné spécialement pour vous un panneau d'affichage multifonctions où vous pourrez afficher ce que vous voulez grâce à un programme disponible sur cette page :

Alors nous sommes une équipe de 4 passionnés d'informatique.
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Informations sur le panneau de LEDs : https://www.dfrobot.com/wiki/index.php/64x32_RGB_LED_Matrix_-_4mm_pitch_SKU:DFR0460

<gallery widths=200px heights=225px>
Fichier:Snapchat-1628077171.jpg|Romain
Fichier:Snapchat-1557163491.jpg|Jess
Fichier:Snapchat-651539379.jpg|Bouba
Fichier:20171023 115243.jpg|Gabin
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>
Fichier:Circuit.jpg|platine d'essai panneaux multifonction
Fichier:Gabin.jpg|circuit imprimé panneaux multifonction
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>

Fichier:Snapchat-1381717098.jpg|voici l’arrière de notre projet

</gallery>
 

Fichier:Snapchat-1381717098.jpg

</gallery>
 
[[Media:Arduino_mega.fzz]]

Projet panneau multifonction 2017/2018

2017-12-20T11:23:32Z

Rex :

Bonjour à vous et bienvenue dans notre monde numérique nous avons confectionné spécialement pour vous un panneau d'affichage multifonctions où vous pourrez afficher ce que vous voulez grâce à un programme disponible sur cette page :

Alors nous sommes une équipe de 4 passionnés d'informatique.
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=200px heights=225px>
Fichier:Snapchat-1628077171.jpg|Romain
Fichier:Snapchat-1557163491.jpg|Jess
Fichier:Snapchat-651539379.jpg|Bouba
Fichier:20171023 115243.jpg|Gabin
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>
Fichier:Circuit.jpg|platine d'essai panneaux multifonction
Fichier:Gabin.jpg|circuit imprimé panneaux multifonction
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>

Fichier:Snapchat-1381717098.jpg|voici l’arrière de notre projet

</gallery>
 

Fichier:Snapchat-1381717098.jpg

</gallery>
 
[[Media:Arduino_mega.fzz]]

Projet panneau multifonction 2017/2018

2017-12-20T11:23:17Z

Rex :

Bonjour à vous et bienvenue dans notre monde numérique nous avons confectionné spécialement pour vous un panneau d'affichage multifonctions où vous pourrez afficher ce que vous voulez grâce à un programme disponible sur cette page :

Alors nous sommes une équipe de 4 passionnés d'informatique.
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>
Fichier:Snapchat-1628077171.jpg|Romain
Fichier:Snapchat-1557163491.jpg|Jess
Fichier:Snapchat-651539379.jpg|Bouba
Fichier:20171023 115243.jpg|Gabin
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>
Fichier:Circuit.jpg|platine d'essai panneaux multifonction
Fichier:Gabin.jpg|circuit imprimé panneaux multifonction
</gallery>
 
-------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<gallery widths=300px heights=225px>

Fichier:Snapchat-1381717098.jpg|voici l’arrière de notre projet

</gallery>
 

Fichier:Snapchat-1381717098.jpg

</gallery>
 
[[Media:Arduino_mega.fzz]]

MediaWiki:Sidebar

2017-09-27T10:50:42Z

Rex :

Année 2017-2018

2017-09-27T10:49:49Z

Rex : Page créée avec « Pour l'année scolaire 2017/2018 le projet commun d'horloge connectée se poursuit. Par ailleurs les élèves se sont regroupés par petits groupes pour réaliser leurs pr... »

Pour l'année scolaire 2017/2018 le projet commun d'horloge connectée se poursuit. Par ailleurs les élèves se sont regroupés par petits groupes pour réaliser leurs propres projets.

= Projet commun d'horloge connectée =
Il est proposé de réaliser une horloge radio-pilotée qui pourra être installée en salle pupitre. L'apparence de l'horloge ainsi que ses fonctionnalités sont laissés à l'imagination des élèves.

Pour plus de détails voyez la page [[projet ICN commun 2017/2018]].

Accueil

2017-09-27T10:47:40Z

Rex :

[[Fichier:SallePupitre113.JPG|200px|thumb|right|Salle pupitre où se déroule l'ICN]]

Bienvenue sur notre site Informatique et Création Numérique (ICN) du [http://fenelon-lille.savoirsnumeriques5962.fr/ Lycée Fénelon de Lille]. Ce cours a été instauré la première fois l'année scolaire 2015/2016 et a lieu 2 heures par semaine avec un nombre d'élèves réduit. Ce module est destiné à favoriser un apprentissage scientifique et technique et une réflexion critique sur des enjeux. Un module amène progressivement les élèves à l'élaboration d’un projet réalisé en groupe. Un projet est finalisé à la fois par une réalisation technique et un questionnement sur les enjeux du numérique.

Des exemples de projets :

* Réaliser un jeu et comprendre les capacités de l'informatique à instrumenter l’activité de loisir.
* Développer un programme de traitement de la langue et comprendre l’apport de l’informatique dans les avancées du traitement des corpus textuels.
* Programmer un robot et comprendre le rôle de la robotique dans les activités humaines.
* Réaliser un site Internet et comprendre les enjeux de la publication d'information.
 
Les productions des élèves pour les différentes années scolaires sont disponibles en suivant les liens ci-après.
----
[[Année 2017-2018]]

[[Année 2016-2017]]

[[Année 2015-2016]]
----

Aide pour écrire vos textes : [https://fr.wikibooks.org/wiki/MediaWiki_pour_d%C3%A9butants/Premi%C3%A8re_utilisation_de_votre_wiki#Bases_de_la_syntaxe_wiki Aide MediaWiki]

Projet ICN5 2016/2017

2017-09-17T19:05:01Z

Rex :

== Participants ==

* Gabrielle REDON

== Cahier des charges ==
[[Fichier:P1000139.JPG|200px|thumb|right|Vue artistique du projet final]]

L'objet final sera constitué des composants ci-dessous.
* une broderie de type mandala ;
* un micro-contrôleur comme un Arduino Lily-Pad ;
* un dispositif électronique à base de registres à décalage pour commander un grand nombre de LEDs ;
* de LEDs dissiminés sur l'ensemble de la broderie ;
* un capteur de type accéléromètre peut être ajouté pour commander des comportements différents.

 

== Réalisations ==

=== Disposition des LEDs sur le mandala ===
Pour simuler la répartition des LEDs sur la mandala, le logiciel géogébra a été utilisé.

Le programme géogébra est : [[Fichier:Mandala_LEDs.ggb]].

Le dessin obtenu est :

[[Fichier:Mandala_LEDs.svg|300px|thumb|center|Disposition des LEDs]]

Cet autre programme géogébra montre les groupes de LEDs à allumer en même temps : [[Fichier:LED_mandala_groupes.ggb]].

[[Fichier:LED mandala groupes.svg|300px|thumb|center|Disposition des groupes de LEDs]]

{| class="wikitable"
! Groupe !! Nombre
|-
| Groupe rouge
| 32 LEDs
|-
| Groupe violet
| 32 LEDs
|-
| Groupe rose
| 32 LEDs
|-
| Groupe azur
| 16 LEDs
|-
| Groupe jaune
| 24 LEDs
|-
| Groupe noir
| 32 LEDs
|-
| Groupe bleu
| 32 LEDs
|-
| Groupe vieux rose
| 32 LEDs
|-
| Tous groupes
| 232 LEDs
|}

Schéma du mandala avec les dimensions agrandies pour la réalisation finale : [[Fichier:LED mandala espace.ggb]].

[[Fichier:LED mandala espace.svg|300px|thumb|center|Version aérée]]

=== Test du dispositif électronique ===
Les registres à décalage sont des composants qui permettent d'obtenir un grand nombre de sorties numériques. Les valeurs de ces sorties peuvent être positionnées avec un petit nombre de sorties du micro-contrôleur. Dans le cas des registres à décalage 74HC595 que nous allons utiliser il suffit de 3 sorties pour pouvoir programmer les sorties du registre à décalage. De plus, il est possible d'enchaîner autant de registres à décalage qu'on le souhaite. Ici nous allons enchainer 3 registres pour un nombre total de sorties de 24. Nous pourrons ainsi commander 24 groupes de LEDs.

Voici le montage sur plaque d'essai pour trois 74HC595 en cascade.

[[Fichier:DSCF4472.JPG|300px|thumb|center|Registres à décalage à droite]]
 

Par ailleurs nous souhaitons commander plusieurs groupes de LEDs avec une seule sortie. Or une seule sortie d'un registre à décalage ne permet pas d'alimenter plus qu'une LED. Il faut donc utiliser des transistors pour alimenter plusieurs LEDs avec une seule sortie.

Le montage d'utilisation d'un transistor NPN est donné dans ce schéma.

[[Fichier:Transistor_Utilisation.png|300px|thumb|center|Utilisation de transistor]]

Dans notre cas le transistor utilisé est un classique [https://www.sparkfun.com/datasheets/Components/BC546.pdf BC547] tiré d'un kit Arduino. Ce transistor peut encaisser un courant de 100mA sous une tension de 45V. La tension maximale est sur-dimensionnée par rapport à la pile de 9V que nous utilisons. Par contre le courant est assez limité. Considérant que nos LEDs consomment Iled=20mA sous une tension de 1,8V, nous voyons que nous pouvons seulement alimenter cinq groupes de LEDs en parallèle, quatre pour avoir une marge de sécurité. Par contre, il est possible de commander plusieurs LEDs en série par groupe, le courant consommé sera le même. Il n'est pas possible de mettre un nombre infini de LEDs en série. En effet, le voltage total ne doit pas dépasser celui de l'alimentation, 9V ici. Le transistor lui-même nécessite, au minimum, 0,2V pour fonctionner, il reste 8,8V pour les LEDs, de quoi alimenter quatre LEDs en série. Nous nous contenterons ici d'en mettre trois.

Pour en revenir au schéma nous avons Valim=9V, VCE=0,2V, Vled=1,8V. La loi d'Ohm, U=RxI, impose donc une résistance R1=VR1/Iled=(9-0,2-3*1,8)/0,02. Soit 170 Ohm. A noter que la résistance R3 est négligée car très faible. Dans le montage des résistances de 220 Ohm sont utilisées, les LEDs ne sont donc pas à leur brillance maximale.

La résistance R2 sert à limiter le courant arrivant sur la commande du transistor, c'est à dire sur sa base. Cette limitation est nécessaire pour éviter de griller le composant. Attention le courant doit tout de même être suffisant pour mettre le transistor en mode saturé où il se comporte comme un interrupteur. Pour connaître le courant minimum à appliquer, il suffit de diviser le courant qui doit circuler à travers le transistor, du collecteur à l'émetteur par le gain du transistor. Prenons un gain de 100 pour un BC547 générique, sachant que nous allons faire circuler un courant d'environ 80mA dans le transistor, il faudrait un courant minimum de 0,8mA sur la base du transistor. Cela dit, la fiche technique recommande un courant de 5mA pour obtenir un VCE de 0,2V avec un courant ICE de 100mA. La documentation technique indique que pour un courant sur la base de 5mA et un courant traversant de 100mA, la tension VBE est de 0,9V. Donc, sachant que le transistor est commandé en 5V par un Arduino, la loi d'Ohm impose une résistance R2=(5-0,9)/0,005. Soit une résistance R2 de 820 Ohm. La résistance R3 est encore négligée.

Voici le montage sur plaque d'essai pour allumer 12 LEDs avec une seule sortie en utilisant un transistor (insérer une photo).
[[Fichier:DSCF4473.JPG|300px|thumb|center|LEDs commandées par transistor à gauche]]
 

Et ça marche :
[[Fichier:DSCF4478.JPG|300px|thumb|center|LEDs allumées]]
 
Toutes les LEDs contrôlées par le transistor sont bien allumées mais comme elles ne sont pas du même type l'appareil photo ne montre que les plus brillantes.

=== Circuits électroniques ===
Pour pouvoir prendre le moins de place possible sur la broderie, il faut concevoir un circuit imprimé avec des composants de surface.
[[Fichier:74HC595_traversant.jpg|left|thumb|Registre à décalage traversant]]
[[Fichier:74HC595_surface.jpg|right|thumb|Registre à décalage de surface]]
 

==== Circuits électroniques principaux ====

Ce circuit imprimé est assez complexe. Après différents essais, une version fonctionnelle est obtenue : [[Fichier:Mandala.fzz]].
<gallery widths=300px heights=225px>
Fichier:Mandala_plaque_essai.png|Plaque d'essai
Fichier:Mandala_schematique.png|Schématique
Fichier:Mandala_PCB.png|Circuit électronique
</gallery>

Il faut aussi réaliser des circuits imprimés pour les LEDs. Pour éviter de la dissipation d'énergie par effet joule (chaleur) il est préférable de monter les LEDs en série puis de mettre des groupes de LEDs en parallèle. Ci-dessous une version de ce circuit pour des LEDs uniformément distribuées avec des modèles différents pour les début, milieu et fin de chaîne : [[Fichier:porteLEDs.fzz]].

<gallery widths=300px heights=225px>
Fichier:porteLEDs_plaque_essai.png|Plaque d'essai
Fichier:porteLEDs_schematique.png|Schématique
Fichier:porteLEDs_PCB.png|Circuit électronique
</gallery>

Il est aussi possible de concevoir un unique modèle de circuit imprimé pour porter les LEDs isolées [[Fichier:genericPorteLEDs.fzz]].
[[Fichier:GenericPorteLEDs_PCB.png|center|thumb|200px|Porte LEDs générique]]

 
Pour ces circuits, les empreintes utilisées pour les LEDs étaient celles des résistances soit 0603 impérial, il a donc été nécessaire de les changer par du 3015 métriques (soit environ de dimensions 1206 impériales). Cependant cette modification n'a été effectuée que sur les portes LED génériques, le seul modèle qui sera utilisé.

==== Calculs pour l'organisation des LEDs ====

Les composants que nous souhaitons utiliser pour les circuits imprimés sont des composants de surface : des LEDs bleues KPL-3015QBC-D et des transistors [http://www.farnell.com/datasheets/454047.pdf MMBT3904].
[[Fichier:LedBleue.jpg|left|thumb|LEDs KPL-3015QBC-D]]
[[Fichier:TransistorSMD.jpg|right|thumb|Transistor MMBT3904]]
 

Les LEDs consomment 20mA sous 3,3V. Les transistors sont donnés pour une intensité maximale de 200mA. Par contre, la fiche technique ne donne les valeurs en saturation que pour un courant traversant de 50mA. Cependant au vu des courbes de la fiche, il semble possible de travailler avec un courant traversant de 100mA à condition d'avoir un courant de 10mA sur la base. Dans ces conditions la tension VCE de saturation s'établit à 0,2V et la tension VBE de saturation à 0,9V. Donc deux LEDs bleues KPL-3015QBC-D peuvent être mises en série pour un total de 2x3,3V soit 6,6V. La résistance R1 en série avec les LEDs doit donc être R1=(9-0,2-6,6)/0,02=110 Ohm. La résistance de limitation du courant sur la base est R2=(5-0,9)/0,01=410 Ohm. A noter qu'il faudrait s'assurer que les registres à décalage puissent fournir 10mA par sortie, cela semble possible au vu de la fiche technique mais est à confirmer dans la pratique.

Avec ces valeurs une sortie ne peut commander que 5 lignes parallèle de 2 LEDs en série. Soit 10 LEDs au total. Comme le montre le tableau ci-dessous nous ne disposerions pas d'assez de sorties pour tous les groupes de LEDs.

{| class="wikitable"
! Groupe !! 10 (2x5) LEDs maximum !! 12 (2x6) LEDs maximum !! 15 (3x5) LEDs maximum !! 18 (3x6) LEDs maximum
|-
| Groupe rouge
| 4 sorties
| 3 sorties
| 3 sorties
| 2 sorties
|-
| Groupe violet
| 4 sorties
| 3 sorties
| 3 sorties
| 2 sorties
|-
| Groupe rose
| 4 sorties
| 3 sorties
| 3 sorties
| 2 sorties
|-
| Groupe azur
| 2 sorties
| 2 sorties
| 2 sorties
| 1 sortie
|-
| Groupe jaune
| 3 sorties
| 2 sorties
| 2 sorties
| 2 sorties
|-
| Groupe noir
| 4 sorties
| 3 sorties
| 3 sorties
| 2 sorties
|-
| Groupe bleu
| 4 sorties
| 3 sorties
| 3 sorties
| 2 sorties
|-
| Groupe vieux rose
| 4 sorties
| 3 sorties
| 3 sorties
| 2 sorties
|-
| Tous les groupes
| 29 sorties
| 22 sorties
| 22 sorties
| 15 sorties
|}

Le tableau montre qu'il faut un minimum de 12 LEDs par sortie pour pouvoir gérer tous les groupes.

Avec les mêmes LEDs il faut passer à 6 lignes parallèles de 2 LEDs en série. Cela signifie une consommation de 120mA par transistor. C'est inférieur à la limite absolue de 200mA. D'après les courbes de la fiche technique cela doit pouvoir se faire en assurant un courant de 12mA sur la base. La tension VCE de saturation devrait rester en dessous de 0,3V et la tension VBE de saturation devrait approcher 0,95V. La résistance R1 reste comparable à un peu plus de 100 Ohm par contre R2 descend aux environs de 340 Ohm. Si 12mA sont trop importants pour les sorties à décalage il est possible de réduire la consommation au détriment de l'augmentation de la tension VCE de saturation. Même avec un VCE de 1V, deux LEDs en série seraient encore possible, la résistance R1 tomberait alors à 70 Ohm.

Si, en pratique, la solution avec 12 LEDs KPL-3015QBC-D (polarity mark qui indiquent le négatif) n'est pas viable, il est possible de changer de LEDs. En effet, les LEDs bleues ont toujours besoin d'une tension plus élevée que les LEDs d'autres couleurs. Ainsi les LEDs rouge de la même famille KPL-3015EC, travaillent sous 2V. Il est donc possible d'en mettre 5*3=15 par transistor et c'est surement la solution qui sera utilisée lors de la finalisation du projet. Il est aussi possible, si l'on souhaite rester sur des LEDs bleues, de prendre des LEDs à faible consommation comme les KA-3021LVVBS-D. Ces LEDs sont un peu plus larges et délivrent seulement 0,05 candelas au lieu des 0,2 candelas des LEDs KPL (soit 4 fois moins puissantes). Par contre elles ne consomment que 2mA. Il est donc possible de mettre 10 fois plus de LEDs par groupe soit une centaine. Là encore des tests sont nécessaires pour savoir si la brillance de LEDs 2mA est suffisante.

Une autre problématique est aussi la consommation totale. Chaque ensemble de 2 LEDs en série consomme 20mA. Quelle puissance d'alimentation faut-il prévoir pour le Mandala ? Cette consommation dépend du nombre total de LEDs allumées en même temps donc des animations prévues pour le mandala.

==== Mise en pratique ====

Pour valider les calculs et les hypothèses de la section précédente des tests ont été réalisés avec un Arduino Uno, le circuit avec les registres à décalage et 32 portes LEDs génériques. Sur le circuit principal, trois transistors ont été soudés avec des résistances de 330 Ohms sur la commande et des résistances de 2 Ohms sur l'émetteur. Sur les portes LEDs ont été soudées des LEDs bleues KPL-3015QBC-D et des résistances de 100 Ohms. Les portes LEDs sont groupés par deux (deux LEDs et une résistance). Deux transistors sont connectés à 5 groupes en parallèle et un autre est connecté à 6 groupes en parallèle.

L'Arduino est programmé en utilisant la bibliothèque ShiftPWM : https://github.com/elcojacobs/ShiftPWM.

Le test à été réalisé en alimentant l'Arduino par un port USB et les LEDs par une pile 9V. Le test a été tout à fait concluant comme ont pu en juger les parents venus se renseigner sur l'ICN lors de la matinée portes ouvertes.

Une fois la faisabilité assurée, d'autres circuits porte LEDs ont été créés car la version générique n'était pas utilisable au centre du mandala où la densité en LEDs est importante :
* une version en arc : [[Fichier:ArcPorteLEDs.fzz]] ;
* une version en V : [[Fichier:NuagePorteLEDs.fzz]] ;
* une version en rayon long : [[Fichier:RayonPorteLEDs.fzz]] ;
* une version en rayon court : [[Fichier:RayonMinPorteLEDs.fzz]].

Voici une représentation des différents circuits porte LEDs :

<gallery widths=200px heights=200px>
Fichier:GenericPorteLEDs_PCB.png|LEDs isolées
Fichier:ArcPorteLEDs_PCB.png|LEDs en arc
Fichier:NuagePorteLEDs_PCB.png|LEDs en V
Fichier:RayonPorteLEDs_PCB.png|LEDs en rayon long
Fichier:RayonMinPorteLEDs_PCB.png|LEDs en rayon court
</gallery>

== Réalisation ==

Après la conception vient le temps de la réalisation. Dans le cas de ce mandala, la réalisation prend beaucoup de temps que ce soit pour le placement et la connexion des circuits porte-LEDs ou pour la broderie.

Quelques images de la phase de positionnement des circuits sont présentées ci-dessous.

<gallery widths=400px heights=400px>
Fichier:mandala_1.jpg|Positionnement des premiers circuits, début de broderie
Fichier:mandala_2.jpg|Plus de circuits
</gallery>

Quelques images de la phase de connexion des circuits suivent.

<gallery widths=400px heights=400px>
Fichier:P1000196.JPG|Toutes les connexions
Fichier:DSCF4620.JPG|Connexions temporaires de l'Arduino
Fichier:DSCF4621.JPG|Détail des connexions
</gallery>

La broderie est une tâche demandant une extrême minutie, de la concentration et surtout de la patience. Voici quelques images de la broderie en cours.

<gallery widths=400px heights=400px>
Fichier:mandala_3.jpg|Détail au centre
Fichier:P1000193.JPG|Réalisation des pétales
</gallery>

<gallery widths=400px heights=400px>
Fichier:P1000198.JPG|Détail du milieu
Fichier:P1000197.JPG|Vue d'ensemble
</gallery>

== Perspectives ==

Déjà ce projet est loin d'être terminé, la phase de broderie nécessite encore plusieurs semaines de travail.

La programmation des LEDs n'est pas achevée, une chorégraphie plus en rapport avec la broderie doit être imaginée.

La réalisation de la connexion avec des câbles a montré sa limite sur le prototype actuel. C'est une tâche longue et qui ne donne pas un résultat esthétique au verso de l'oeuvre. Une seconde maquette avec des connexions par des circuits imprimés adaptés est en cours.

Voici les images de l'ensemble des circuits nécessaires aux connexions.

<gallery widths=150px heights=150px>
Fichier:cercle_ext_pcb.png|connexion entre portes LEDs disques externes
Fichier:cercle_moy_pcb.png|connexion entre portes LEDs disques milieu
Fichier:cercle_int_pcb.png|connexion entre portes LEDs disques internes
</gallery>

<gallery widths=150px heights=150px>
Fichier:arc_disque2_pcb.png|connexion entre portes LEDs arc et disque
Fichier:arc_disque1_pcb.png|connexion entre portes LEDs disque et arc
Fichier:nuage_inter_pcb.png|connexion entre portes LEDs en V
Fichier:rayon_inter_pcb.png|connexion entre portes LEDs rayons
</gallery>

<gallery widths=150px heights=150px>
Fichier:rayon_arc_pcb.png|alimentation des portes LEDs arc
Fichier:rayon_ext_pcb.png|alimentation des portes LEDs disque externe
Fichier:rayon_moy_pcb.png|alimentation des portes LEDs disque milieu
Fichier:rayon_int_pcb.png|alimentation des portes LEDs disque interne
</gallery>

La gallerie ci-dessous donne une vision de ce second prototype.

<gallery widths=300px heights=300px>
Fichier:LED_mandala_modele.png|Vue partielle des connexions
Fichier:DSCF4641.JPG|Circuits positionnés au recto
Fichier:DSCF4642.JPG|Vue des circuits au verso
</gallery>

== Avancement de la broderie ==

Etat actuel de la broderie.

<gallery widths=400px heights=400px>
Fichier:DSCF4663.JPG|Vue de dessus
Fichier:DSCF4665.JPG|Vue de biais
</gallery>

Fichier:DSCF4665.JPG

2017-09-17T19:02:18Z

Rex :

Projet ICN2 2016/2017

2017-09-17T19:02:04Z

Rex : /* Amélioration */

== Participants ==

* Nassim BOUDANES

== Cahier des charges ==
[[Fichier:chassis-chenilles.jpg|200px|thumb|right|Chassis avec chenilles]]

Pour réaliser ce robot filoguidé les composants suivants vont être utilisés :
* un chassis avec moteurs et chenilles ;
* deux joysticks miniatures pour la commande ;
* un contrôleur de moteurs ;
* un détecteur ultra-son ;
* un Arduino nano pour gérer le tout.

 

== Réalisations ==
=== Prise en main ===
[[Fichier:P1000118.JPG|200px|thumb|right|Chassis pour l'apprentissage]]
Dans les premières séances un chassis complétement monté est utilisé pour comprendre la programmation de ce type de robot.
 

=== La manette ===
Il a été décidé de construire un circuit imprimé pour la manette, le circuit comprend deux joysticks et une prise RJ12 femelle. Le câble entre la manette et le robot sera constitué d'un câble à 6 conducteurs avec deux prises RJ12 mâles à chaque bout. Le logiciel Fritzing est utilisé pour concevoir le circuit imprimé. Le fichier de ce circuit est disponible [[Fichier:Manette.fzz]].

<gallery widths=300px heights=225px>
Fichier:Manette_plaque_essai.png|Plaque d'essai
Fichier:Manette_schematique.png|Schématique
Fichier:Manette_PCB.png|Circuit électronique
</gallery>

Le circuit de la manette a été produit par la société Fritzing, les deux exemplaires sont visibles sur la photo.
[[Fichier:DSCF4476.JPG|300px|thumb|center|Circuit imprimé manette]]
 

[[Fichier:Manette.svg|200px|thumb|left|Forme pour la manette]]
[[Fichier:IMG_0736.jpg|200px|thumb|right|Manette plexiglass]]

Pour que la manette soit plus simple d'utilisation, une forme a été créée avec inkscape pour obtenir une plaque de plexiglass adaptée.
La plaque a été découpée à Polytech'Lille mais avec des réglages mal adaptés, d'où les traces de brulé.
 

=== Contrôle du chassis ===
Un contrôleur de moteurs pololu à base de circuit TB6612FNG a ensuite été testé pour faire tourner les moteurs du chassis de test.

[[Fichier:DSCF4474.JPG|300px|thumb|left|Chassis et plaque d'essai]]
[[Fichier:DSCF4475.JPG|300px|thumb|right|Zoom sur l'Arduino et le contrôleur de moteur]]
 

À terme ce montage doit être utilisé pour le chassis acheté par l'élève.
[[Fichier:DSCF4480.JPG|300px|thumb|left|Montage sur le chassis choisi]]
[[Fichier:DSCF4481.JPG|300px|thumb|right|Autre vue]]
 

Comme il n'est pas pratique de fixer la plaque d'essai au chassis, un second circuit imprimé [[Media:Robot chenille.fzz]] a été conçu, le circuit comporte :
* une prise RJ12 femelle pour connecter le câble en provenance de la manette ;
* un emplacement pour l'Arduino nano ;
* un emplacement pour le contrôleur de moteurs pololu ;
* un emplacement pour le détecteur ultrasons.

<gallery widths=300px heights=225px>
Fichier:Chenille_plaque_essai.png|Plaque d'essai
Fichier:Chenille_schematique.png|Schématique
Fichier:Chenille_PCB.png|Circuit électronique
</gallery>

Le circuit imprimé a été gravé lors de la visite à Polytech'Lille.
[[Fichier:IMG_0737.jpg|300px|thumb|center|Circuit imprimé pour le chassis]]

Voici une image du rendu actuel de la manette :

<gallery widths=300px heights=225px>
Fichier:Manette création 1.jpg|Rendu actuel de la manette
Fichier:Manette création 3.jpg|Vue globale de la manette
Fichier:Manette création 2.jpg|Vue d'ensemble
</gallery>

Le circuit principal a été fixé sur le chassis, et le programme de fonctionnement a été écrit et est fonctionnel.

<gallery widths=400px heights=325px>
Fichier:20170322_112526.jpg|Robot de face gauche
Fichier:20170322 112518.jpg|Robot de profil
Fichier:20170322_112501.jpg|Robot de face droite
</gallery>

Le système complet, robot avec manette connectée par un câble, est lui aussi fonctionnel :

[[Fichier:DSCF4615.JPG|300px|thumb|center|Système complet]]

=== Le programme ===

L'Arduino micro a été programmé pour lire les commandes de la manette et commander les moteurs du chassis. Ce programme est donné ci-dessous.

const int SW1_pin = A3;
const int SW2_pin = A4;
const int X_pin = A5;
const int Y_pin = A7;

int motor1_pwm = 6;
int motor1_in1Pin = 5;
int motor1_in2Pin = 4;

int motor2_pwm = 10;
int motor2_in1Pin = 7;
int motor2_in2Pin = 8;

int pinSTBY = 3;

void setup() {

pinMode(motor1_in1Pin, OUTPUT);
pinMode(motor1_in2Pin, OUTPUT);
pinMode(motor1_pwm, OUTPUT);

pinMode(motor2_in1Pin, OUTPUT);
pinMode(motor2_in2Pin, OUTPUT);
pinMode(motor2_pwm, OUTPUT);

pinMode(SW1_pin, INPUT_PULLUP);
pinMode(SW2_pin, INPUT_PULLUP);
pinMode(pinSTBY, OUTPUT);

pinMode(X_pin, INPUT);
pinMode(Y_pin, INPUT);

Serial.begin(9600);

digitalWrite(pinSTBY, HIGH);

}

void SetMotor1(int speed, boolean reverse)
{
analogWrite(motor1_pwm, speed);
digitalWrite(motor1_in1Pin, ! reverse);
digitalWrite(motor1_in2Pin, reverse);
}

void SetMotor2(int speed, boolean reverse)
{
analogWrite(motor2_pwm, speed);
digitalWrite(motor2_in1Pin, ! reverse);
digitalWrite(motor2_in2Pin, reverse);
}

void loop() {

int b1=digitalRead(SW1_pin);
int b2=digitalRead(SW2_pin);
int X=analogRead(X_pin);
int Y=analogRead(Y_pin);

Serial.print("Bouton Gauche: ");
Serial.print(b2);
Serial.print("\n");
Serial.print("Bouton Droit: ");
Serial.print(b1);
Serial.print("\n");
Serial.print("X-axis: ");
Serial.print(analogRead(X_pin));
Serial.print("\n");
Serial.print("Y-axis: ");
Serial.println(analogRead(Y_pin));
Serial.print("\n\n");

if (Y < 400)
{
SetMotor1(210, true);
SetMotor2(210, true);
}

if (Y > 700)
{
SetMotor1(210, false);
SetMotor2(210, false);
}
if(Y < 750 && Y > 350)
{
SetMotor1(0, false);
SetMotor2(0, false);
}

if (X < 400)
{
SetMotor1(150, true);
SetMotor2(150, false);
}

if (X > 700)
{
SetMotor1(150, false);
SetMotor2(150, true );
}

}

== Amélioration ==

Le problème ensuite rencontré est le suivant : l'alimentation.
En effet, le chassis ne possède que 4 emplacement de piles AA, pour un total de 6V, alors que le voltage nécessaire est de 9V, il manque donc 2 piles. 
Il fallut alors créer une plaque contenant un emplacement pour 2 piles, et cette plaque permettra de gérer l'ensemble de l'alimentation du robot. 
Le fichier Fritzing est téléchargeable ici : [[Media:Plaque Alimentation Robot.fzz]].

[[Fichier:Robot chenille alim PCB.png|300px|thumb|center|Circuit imprimé pour les piles supplémentaires]]

Une fois la plaque installé, le robot est bien alimenté et fonctionne parfaitement. Vous trouvez ci-dessous des photos du robot final.

<gallery widths=300px heights=250px>
Fichier:DSCF4656.JPG|Robot avec le porte piles
Fichier:DSCF4658.JPG|Autre vue du porte piles
Fichier:DSCF4660.JPG|Le robot en marche
</gallery>

== Démonstration ==

Pour une vidéo de démonstration cliquez [[media:DSCF4659.MP4|ici]].

Fichier:DSCF4663.JPG

2017-09-17T19:01:02Z

Rex :

Fichier:DSCF4659.MP4

2017-09-17T18:57:18Z

Rex :

Projet ICN2 2016/2017

2017-09-17T18:49:47Z

Rex : /* Amélioration */

Projet ICN2 2016/2017

2017-09-17T18:49:16Z

Rex :

== Participants ==

* Nassim BOUDANES

== Cahier des charges ==
[[Fichier:chassis-chenilles.jpg|200px|thumb|right|Chassis avec chenilles]]

Pour réaliser ce robot filoguidé les composants suivants vont être utilisés :
* un chassis avec moteurs et chenilles ;
* deux joysticks miniatures pour la commande ;
* un contrôleur de moteurs ;
* un détecteur ultra-son ;
* un Arduino nano pour gérer le tout.

 

== Réalisations ==
=== Prise en main ===
[[Fichier:P1000118.JPG|200px|thumb|right|Chassis pour l'apprentissage]]
Dans les premières séances un chassis complétement monté est utilisé pour comprendre la programmation de ce type de robot.
 

=== La manette ===
Il a été décidé de construire un circuit imprimé pour la manette, le circuit comprend deux joysticks et une prise RJ12 femelle. Le câble entre la manette et le robot sera constitué d'un câble à 6 conducteurs avec deux prises RJ12 mâles à chaque bout. Le logiciel Fritzing est utilisé pour concevoir le circuit imprimé. Le fichier de ce circuit est disponible [[Fichier:Manette.fzz]].

<gallery widths=300px heights=225px>
Fichier:Manette_plaque_essai.png|Plaque d'essai
Fichier:Manette_schematique.png|Schématique
Fichier:Manette_PCB.png|Circuit électronique
</gallery>

Le circuit de la manette a été produit par la société Fritzing, les deux exemplaires sont visibles sur la photo.
[[Fichier:DSCF4476.JPG|300px|thumb|center|Circuit imprimé manette]]
 

[[Fichier:Manette.svg|200px|thumb|left|Forme pour la manette]]
[[Fichier:IMG_0736.jpg|200px|thumb|right|Manette plexiglass]]

Pour que la manette soit plus simple d'utilisation, une forme a été créée avec inkscape pour obtenir une plaque de plexiglass adaptée.
La plaque a été découpée à Polytech'Lille mais avec des réglages mal adaptés, d'où les traces de brulé.
 

=== Contrôle du chassis ===
Un contrôleur de moteurs pololu à base de circuit TB6612FNG a ensuite été testé pour faire tourner les moteurs du chassis de test.

[[Fichier:DSCF4474.JPG|300px|thumb|left|Chassis et plaque d'essai]]
[[Fichier:DSCF4475.JPG|300px|thumb|right|Zoom sur l'Arduino et le contrôleur de moteur]]
 

À terme ce montage doit être utilisé pour le chassis acheté par l'élève.
[[Fichier:DSCF4480.JPG|300px|thumb|left|Montage sur le chassis choisi]]
[[Fichier:DSCF4481.JPG|300px|thumb|right|Autre vue]]
 

Comme il n'est pas pratique de fixer la plaque d'essai au chassis, un second circuit imprimé [[Media:Robot chenille.fzz]] a été conçu, le circuit comporte :
* une prise RJ12 femelle pour connecter le câble en provenance de la manette ;
* un emplacement pour l'Arduino nano ;
* un emplacement pour le contrôleur de moteurs pololu ;
* un emplacement pour le détecteur ultrasons.

<gallery widths=300px heights=225px>
Fichier:Chenille_plaque_essai.png|Plaque d'essai
Fichier:Chenille_schematique.png|Schématique
Fichier:Chenille_PCB.png|Circuit électronique
</gallery>

Le circuit imprimé a été gravé lors de la visite à Polytech'Lille.
[[Fichier:IMG_0737.jpg|300px|thumb|center|Circuit imprimé pour le chassis]]

Voici une image du rendu actuel de la manette :

<gallery widths=300px heights=225px>
Fichier:Manette création 1.jpg|Rendu actuel de la manette
Fichier:Manette création 3.jpg|Vue globale de la manette
Fichier:Manette création 2.jpg|Vue d'ensemble
</gallery>

Le circuit principal a été fixé sur le chassis, et le programme de fonctionnement a été écrit et est fonctionnel.

<gallery widths=400px heights=325px>
Fichier:20170322_112526.jpg|Robot de face gauche
Fichier:20170322 112518.jpg|Robot de profil
Fichier:20170322_112501.jpg|Robot de face droite
</gallery>

Le système complet, robot avec manette connectée par un câble, est lui aussi fonctionnel :

[[Fichier:DSCF4615.JPG|300px|thumb|center|Système complet]]

=== Le programme ===

L'Arduino micro a été programmé pour lire les commandes de la manette et commander les moteurs du chassis. Ce programme est donné ci-dessous.

const int SW1_pin = A3;
const int SW2_pin = A4;
const int X_pin = A5;
const int Y_pin = A7;

int motor1_pwm = 6;
int motor1_in1Pin = 5;
int motor1_in2Pin = 4;

int motor2_pwm = 10;
int motor2_in1Pin = 7;
int motor2_in2Pin = 8;

int pinSTBY = 3;

void setup() {

pinMode(motor1_in1Pin, OUTPUT);
pinMode(motor1_in2Pin, OUTPUT);
pinMode(motor1_pwm, OUTPUT);

pinMode(motor2_in1Pin, OUTPUT);
pinMode(motor2_in2Pin, OUTPUT);
pinMode(motor2_pwm, OUTPUT);

pinMode(SW1_pin, INPUT_PULLUP);
pinMode(SW2_pin, INPUT_PULLUP);
pinMode(pinSTBY, OUTPUT);

pinMode(X_pin, INPUT);
pinMode(Y_pin, INPUT);

Serial.begin(9600);

digitalWrite(pinSTBY, HIGH);

}

void SetMotor1(int speed, boolean reverse)
{
analogWrite(motor1_pwm, speed);
digitalWrite(motor1_in1Pin, ! reverse);
digitalWrite(motor1_in2Pin, reverse);
}

void SetMotor2(int speed, boolean reverse)
{
analogWrite(motor2_pwm, speed);
digitalWrite(motor2_in1Pin, ! reverse);
digitalWrite(motor2_in2Pin, reverse);
}

void loop() {

int b1=digitalRead(SW1_pin);
int b2=digitalRead(SW2_pin);
int X=analogRead(X_pin);
int Y=analogRead(Y_pin);

Serial.print("Bouton Gauche: ");
Serial.print(b2);
Serial.print("\n");
Serial.print("Bouton Droit: ");
Serial.print(b1);
Serial.print("\n");
Serial.print("X-axis: ");
Serial.print(analogRead(X_pin));
Serial.print("\n");
Serial.print("Y-axis: ");
Serial.println(analogRead(Y_pin));
Serial.print("\n\n");

if (Y < 400)
{
SetMotor1(210, true);
SetMotor2(210, true);
}

if (Y > 700)
{
SetMotor1(210, false);
SetMotor2(210, false);
}
if(Y < 750 && Y > 350)
{
SetMotor1(0, false);
SetMotor2(0, false);
}

if (X < 400)
{
SetMotor1(150, true);
SetMotor2(150, false);
}

if (X > 700)
{
SetMotor1(150, false);
SetMotor2(150, true );
}

}

== Amélioration ==

Le problème ensuite rencontré est le suivant : l'alimentation.
En effet, le chassis ne possède que 4 emplacement de piles AA, pour un total de 6V, alors que le voltage nécessaire est de 9V, il manque donc 2 piles. 
Il fallut alors créer une plaque contenant un emplacement pour 2 piles, et cette plaque permettra de gérer l'ensemble de l'alimentation du robot. 
Le fichier Fritzing est téléchargeable ici : [[Media:Plaque Alimentation Robot.fzz]].

[[Fichier:Robot chenille alim PCB.png|300px|thumb|center|Circuit imprimé pour les piles supplémentaires]]

Une fois la plaque installé, le robot est bien alimenté et fonctionne parfaitement. Vous trouvez ci-dessous des photos du robot final.

<gallery widths=400px heights=325px>
Fichier:DSCF4656.JPG|Robot avec le porte piles
Fichier:DSCF4658.JPG|Autre vue du porte piles
Fichier:DSCF4660.JPG|Le robot en marche
</gallery>

Fichier:DSCF4660.JPG

2017-09-17T18:47:43Z

Rex :

Fichier:DSCF4658.JPG

2017-09-17T18:47:02Z

Rex :

Fichier:DSCF4656.JPG

2017-09-17T18:45:43Z

Rex :

Projet ICN2 2016/2017

2017-09-17T18:42:15Z

Rex : /* À réaliser */

== Participants ==

* Nassim BOUDANES

== Cahier des charges ==
[[Fichier:chassis-chenilles.jpg|200px|thumb|right|Chassis avec chenilles]]

Pour réaliser ce robot filoguidé les composants suivants vont être utilisés :
* un chassis avec moteurs et chenilles ;
* deux joysticks miniatures pour la commande ;
* un contrôleur de moteurs ;
* un détecteur ultra-son ;
* un Arduino nano pour gérer le tout.

 

== Réalisations ==
=== Prise en main ===
[[Fichier:P1000118.JPG|200px|thumb|right|Chassis pour l'apprentissage]]
Dans les premières séances un chassis complétement monté est utilisé pour comprendre la programmation de ce type de robot.
 

=== La manette ===
Il a été décidé de construire un circuit imprimé pour la manette, le circuit comprend deux joysticks et une prise RJ12 femelle. Le câble entre la manette et le robot sera constitué d'un câble à 6 conducteurs avec deux prises RJ12 mâles à chaque bout. Le logiciel Fritzing est utilisé pour concevoir le circuit imprimé. Le fichier de ce circuit est disponible [[Fichier:Manette.fzz]].

<gallery widths=300px heights=225px>
Fichier:Manette_plaque_essai.png|Plaque d'essai
Fichier:Manette_schematique.png|Schématique
Fichier:Manette_PCB.png|Circuit électronique
</gallery>

Le circuit de la manette a été produit par la société Fritzing, les deux exemplaires sont visibles sur la photo.
[[Fichier:DSCF4476.JPG|300px|thumb|center|Circuit imprimé manette]]
 

[[Fichier:Manette.svg|200px|thumb|left|Forme pour la manette]]
[[Fichier:IMG_0736.jpg|200px|thumb|right|Manette plexiglass]]

Pour que la manette soit plus simple d'utilisation, une forme a été créée avec inkscape pour obtenir une plaque de plexiglass adaptée.
La plaque a été découpée à Polytech'Lille mais avec des réglages mal adaptés, d'où les traces de brulé.
 

=== Contrôle du chassis ===
Un contrôleur de moteurs pololu à base de circuit TB6612FNG a ensuite été testé pour faire tourner les moteurs du chassis de test.

[[Fichier:DSCF4474.JPG|300px|thumb|left|Chassis et plaque d'essai]]
[[Fichier:DSCF4475.JPG|300px|thumb|right|Zoom sur l'Arduino et le contrôleur de moteur]]
 

À terme ce montage doit être utilisé pour le chassis acheté par l'élève.
[[Fichier:DSCF4480.JPG|300px|thumb|left|Montage sur le chassis choisi]]
[[Fichier:DSCF4481.JPG|300px|thumb|right|Autre vue]]
 

Comme il n'est pas pratique de fixer la plaque d'essai au chassis, un second circuit imprimé [[Media:Robot chenille.fzz]] a été conçu, le circuit comporte :
* une prise RJ12 femelle pour connecter le câble en provenance de la manette ;
* un emplacement pour l'Arduino nano ;
* un emplacement pour le contrôleur de moteurs pololu ;
* un emplacement pour le détecteur ultrasons.

<gallery widths=300px heights=225px>
Fichier:Chenille_plaque_essai.png|Plaque d'essai
Fichier:Chenille_schematique.png|Schématique
Fichier:Chenille_PCB.png|Circuit électronique
</gallery>

Le circuit imprimé a été gravé lors de la visite à Polytech'Lille.
[[Fichier:IMG_0737.jpg|300px|thumb|center|Circuit imprimé pour le chassis]]

Voici une image du rendu actuel de la manette :

<gallery widths=300px heights=225px>
Fichier:Manette création 1.jpg|Rendu actuel de la manette
Fichier:Manette création 3.jpg|Vue globale de la manette
Fichier:Manette création 2.jpg|Vue d'ensemble
</gallery>

Le circuit principal a été fixé sur le chassis, et le programme de fonctionnement a été écrit et est fonctionnel.

<gallery widths=400px heights=325px>
Fichier:20170322_112526.jpg|Robot de face gauche
Fichier:20170322 112518.jpg|Robot de profil
Fichier:20170322_112501.jpg|Robot de face droite
</gallery>

Le système complet, robot avec manette connectée par un câble, est lui aussi fonctionnel :

[[Fichier:DSCF4615.JPG|300px|thumb|center|Système complet]]

Le problème ensuite rencontré est le suivant : l'alimentation.
En effet, le chassis ne possède que 4 emplacement de piles AA, pour un total de 6V, alors que le voltage nécessaire est de 9V, il manque donc 2 piles. 
Il fallut alors créer une plaque contenant un emplacement pour 2 piles, et cette plaque permettra de gérer l'ensemble de l'alimentation du robot. 
Le fichier Fritzing est téléchargeable ici : [[Media:Plaque Alimentation Robot.fzz]].

[[Fichier:Robot chenille alim PCB.png|300px|thumb|center|Circuit imprimé pour les piles supplémentaires]]

Une fois la plaque installé, le robot est bien alimenté et fonctionne parfaitement.

=== Le programme ===

L'Arduino micro a été programmé pour lire les commandes de la manette et commander les moteurs du chassis. Ce programme est donné ci-dessous.

const int SW1_pin = A3;
const int SW2_pin = A4;
const int X_pin = A5;
const int Y_pin = A7;

int motor1_pwm = 6;
int motor1_in1Pin = 5;
int motor1_in2Pin = 4;

int motor2_pwm = 10;
int motor2_in1Pin = 7;
int motor2_in2Pin = 8;

int pinSTBY = 3;

void setup() {

pinMode(motor1_in1Pin, OUTPUT);
pinMode(motor1_in2Pin, OUTPUT);
pinMode(motor1_pwm, OUTPUT);

pinMode(motor2_in1Pin, OUTPUT);
pinMode(motor2_in2Pin, OUTPUT);
pinMode(motor2_pwm, OUTPUT);

pinMode(SW1_pin, INPUT_PULLUP);
pinMode(SW2_pin, INPUT_PULLUP);
pinMode(pinSTBY, OUTPUT);

pinMode(X_pin, INPUT);
pinMode(Y_pin, INPUT);

Serial.begin(9600);

digitalWrite(pinSTBY, HIGH);

}

void SetMotor1(int speed, boolean reverse)
{
analogWrite(motor1_pwm, speed);
digitalWrite(motor1_in1Pin, ! reverse);
digitalWrite(motor1_in2Pin, reverse);
}

void SetMotor2(int speed, boolean reverse)
{
analogWrite(motor2_pwm, speed);
digitalWrite(motor2_in1Pin, ! reverse);
digitalWrite(motor2_in2Pin, reverse);
}

void loop() {

int b1=digitalRead(SW1_pin);
int b2=digitalRead(SW2_pin);
int X=analogRead(X_pin);
int Y=analogRead(Y_pin);

Serial.print("Bouton Gauche: ");
Serial.print(b2);
Serial.print("\n");
Serial.print("Bouton Droit: ");
Serial.print(b1);
Serial.print("\n");
Serial.print("X-axis: ");
Serial.print(analogRead(X_pin));
Serial.print("\n");
Serial.print("Y-axis: ");
Serial.println(analogRead(Y_pin));
Serial.print("\n\n");

if (Y < 400)
{
SetMotor1(210, true);
SetMotor2(210, true);
}

if (Y > 700)
{
SetMotor1(210, false);
SetMotor2(210, false);
}
if(Y < 750 && Y > 350)
{
SetMotor1(0, false);
SetMotor2(0, false);
}

if (X < 400)
{
SetMotor1(150, true);
SetMotor2(150, false);
}

if (X > 700)
{
SetMotor1(150, false);
SetMotor2(150, true );
}

}

== Amélioration ==

Pour pouvoir utiliser les 4 piles AA internes du chassis plutôt qu'une pile externe de 9V difficile à fixer, un second circuit imprimé a été réalisé. Ce circuit comprend particulièrement un porte piles 2xAA. Avec un total de 6 piles AA il est possible d'alimenter correctement l'Arduino.

Améliorer le programme et surtout la sensibilité des joysticks pour permettre une meilleure précision.

Fichier:DSCF4647.JPG

2017-09-17T18:37:04Z

Rex :

Projet ICN3 2016/2017

2017-09-17T18:36:33Z

Rex : /* Equipement de la maison */

== Participants ==

* Paul LAMANDE
* Grégoire FLEURY
* Baptiste SENECLAUZE

== Cahier des charges ==

[[Fichier:P1000119.JPG|200px|thumb|right|Composants utilisés]]

La maquette de maison doit comporter les dispositifs suivants.
* volets asservis par des servo-moteurs ;
* détection de la lumière ambiante pour l'ouverture ou la fermeture des volets et pour allumer ou éteindre les lumières ;

La maquette de la maison est conçue en 3D puis réalisée à l'ancienne à partir de contre-plaqué.

Les élements sont commandé par un Arduino lui-même relié à une Raspberry Pi pour la gestion par smartphone.
 

== Réalisations ==

=== Montages électroniques ===
Différents montages ont été testés :
* Montage pour le sonar ultrason : le montage permet d'allumer une LED sur détection de mouvement. Le montage a été réalisé sur une plaque d'essai puis un programme a été écrit pour ce montage.
* Montage pour le servo-moteur : le montage permet de faire bouger le servo-moteur. Là aussi montage sur plaque d'essai et programme de test.
* Montage pour la photo-résistance ; le montage permet d'allumer une LED en cas d'intensité lumineuse faible. Le test a été réalisé avec des luminosités différentes.
* plutôt qu'une LED nous avons décidé d'utiliser une ampoule 100mA

=== Maquette de la maison ===

La maquette de la maison a d'abord été représentée sur Google Sketchup (ajouter le dessin).

Nous avons, pendant les vacances, réalisé la maison en contreplaqué, peinte et volet équipés de charnières.

<gallery widths=300px heights=225px>
Fichier:20161027 150217.jpg|Vue de l'extérieur de la maison (volets motorisés) encore absence de capteurs et de LED
Fichier:20161027 150225.jpg|Ici une autre vue, de l'intérieur cette fois. La maison est en coupe pour observer les systèmes.
Fichier:20170524_121453.jpg|Schéma d'ensemble de la maison
</gallery>

=== Bouclier de commande ===

Nous avons réalisé un montage complet avec des servo-moteurs, une photo-résistance et un sonar ultrason. Nous écrivons aussi le programme faire fonctionner ce montage.

[[Fichier:DSCF4483.JPG|300px|thumb|center|Montage et conception de carte]]
 

Nous modélisons le circuit imprimé grâce au logiciel de création de circuit imprimés Fritzing. Le fichier de la carte est disponible : [[Media:emaison.fzz]].

<gallery widths=300px heights=225px>
Fichier:Maison_plaque_essai.png|Plaque d'essai
Fichier:Maison_schematique.png|Schématique
Fichier:Maison_PCB.png|Circuit électronique
</gallery>

Le circuit imprimé a été gravé lors de notre visite à Polytech'Lille.
[[Fichier:IMG_0738.jpg|300px|thumb|center|Bouclier de contrôle de la maison]]
 

=== Equipement de la maison ===

Le circuit imprimé a été soudé et inséré au dessus de l'arduino comme la photo ci-dessous le montre.
[[Fichier:DSCF4671.JPG|300px|thumb|center|Maison avec son contrôleur]]

La maquette de la maison a été équipée de différents capteurs et actionneurs comme cela se voit sur les photos ci-après.
<gallery widths=400px heights=300px>
Fichier:DSCF4646.JPG|Vue sur les servo-moteurs et sur la lampe
Fichier:DSCF4645.JPG|Cherchez la photo-résistance et le sonar ultrason
Fichier:DSCF4647.JPG|Vue externe de la photo-résistance et du sonar
</gallery>

=== Programme ===

Le programme de commande des servo-moteurs des volets en fonction de la lumière est le suivant :

#include <Servo.h>

int photocellPin = A0;
int photocellReading;
Servo monServo;
Servo tonServo;
Servo sonServo;
Servo leurServo;

void setup(){
monServo.attach(9, 1000, 2000);
tonServo.attach(3, 1000, 2000);
sonServo.attach(5, 1000, 2000);
leurServo.attach(6, 1000, 2000);
Serial.begin(9600);
}

void loop(){
photocellReading = analogRead(photocellPin);
Serial.println(photocellReading);
if (photocellReading < 500) {
monServo.write(0);
tonServo.write(0);
sonServo.write(0);
leurServo.write(0);
}
else if (photocellReading > 500) {
monServo.write(180);
tonServo.write(180);
sonServo.write(180);
leurServo.write(180);
}
delay(5000);
}

Un autre programme allume une lumière sur détection d'un mouvement en face de la maison :

int duration;
int distance;
int sensorpin = 12;
int pinRelais = 13;

void setup()
{
Serial.begin(9600);
pinMode(pinRelais, OUTPUT);
}

void loop()
{
pinMode(sensorpin, OUTPUT);
digitalWrite(sensorpin, LOW);
delayMicroseconds(2);
digitalWrite(sensorpin, HIGH);
delayMicroseconds(10);
digitalWrite(sensorpin, LOW);
pinMode(sensorpin, INPUT);
duration =pulseIn(sensorpin, HIGH);
distance = duration/58;
Serial.println(distance);
delay(100);
if (distance < 20){
digitalWrite(pinRelais, HIGH);
}
if (distance > 20){
digitalWrite(pinRelais, LOW);
}

}

Projet ICN3 2016/2017

2017-09-17T18:33:52Z

Rex : /* Equipement de la maison */

== Participants ==

* Paul LAMANDE
* Grégoire FLEURY
* Baptiste SENECLAUZE

== Cahier des charges ==

[[Fichier:P1000119.JPG|200px|thumb|right|Composants utilisés]]

La maquette de maison doit comporter les dispositifs suivants.
* volets asservis par des servo-moteurs ;
* détection de la lumière ambiante pour l'ouverture ou la fermeture des volets et pour allumer ou éteindre les lumières ;

La maquette de la maison est conçue en 3D puis réalisée à l'ancienne à partir de contre-plaqué.

Les élements sont commandé par un Arduino lui-même relié à une Raspberry Pi pour la gestion par smartphone.
 

== Réalisations ==

=== Montages électroniques ===
Différents montages ont été testés :
* Montage pour le sonar ultrason : le montage permet d'allumer une LED sur détection de mouvement. Le montage a été réalisé sur une plaque d'essai puis un programme a été écrit pour ce montage.
* Montage pour le servo-moteur : le montage permet de faire bouger le servo-moteur. Là aussi montage sur plaque d'essai et programme de test.
* Montage pour la photo-résistance ; le montage permet d'allumer une LED en cas d'intensité lumineuse faible. Le test a été réalisé avec des luminosités différentes.
* plutôt qu'une LED nous avons décidé d'utiliser une ampoule 100mA

=== Maquette de la maison ===

La maquette de la maison a d'abord été représentée sur Google Sketchup (ajouter le dessin).

Nous avons, pendant les vacances, réalisé la maison en contreplaqué, peinte et volet équipés de charnières.

<gallery widths=300px heights=225px>
Fichier:20161027 150217.jpg|Vue de l'extérieur de la maison (volets motorisés) encore absence de capteurs et de LED
Fichier:20161027 150225.jpg|Ici une autre vue, de l'intérieur cette fois. La maison est en coupe pour observer les systèmes.
Fichier:20170524_121453.jpg|Schéma d'ensemble de la maison
</gallery>

=== Bouclier de commande ===

Nous avons réalisé un montage complet avec des servo-moteurs, une photo-résistance et un sonar ultrason. Nous écrivons aussi le programme faire fonctionner ce montage.

[[Fichier:DSCF4483.JPG|300px|thumb|center|Montage et conception de carte]]
 

Nous modélisons le circuit imprimé grâce au logiciel de création de circuit imprimés Fritzing. Le fichier de la carte est disponible : [[Media:emaison.fzz]].

<gallery widths=300px heights=225px>
Fichier:Maison_plaque_essai.png|Plaque d'essai
Fichier:Maison_schematique.png|Schématique
Fichier:Maison_PCB.png|Circuit électronique
</gallery>

Le circuit imprimé a été gravé lors de notre visite à Polytech'Lille.
[[Fichier:IMG_0738.jpg|300px|thumb|center|Bouclier de contrôle de la maison]]
 

=== Equipement de la maison ===

Le circuit imprimé a été soudé et inséré au dessus de l'arduino comme la photo ci-dessous le montre.
[[Fichier:DSCF4671.JPG|300px|thumb|center|Maison avec son contrôleur]]

La maquette de la maison a été équipée de différents capteurs et actionneurs comme cela se voit sur les photos ci-après.
<gallery widths=400px heights=300px>
Fichier:DSCF4646.JPG|Vue sur les servo-moteurs et sur la lampe
Fichier:DSCF4645.JPG|Cherchez la photo-résistance et le sonar ultrason
</gallery>

=== Programme ===

Le programme de commande des servo-moteurs des volets en fonction de la lumière est le suivant :

#include <Servo.h>

int photocellPin = A0;
int photocellReading;
Servo monServo;
Servo tonServo;
Servo sonServo;
Servo leurServo;

void setup(){
monServo.attach(9, 1000, 2000);
tonServo.attach(3, 1000, 2000);
sonServo.attach(5, 1000, 2000);
leurServo.attach(6, 1000, 2000);
Serial.begin(9600);
}

void loop(){
photocellReading = analogRead(photocellPin);
Serial.println(photocellReading);
if (photocellReading < 500) {
monServo.write(0);
tonServo.write(0);
sonServo.write(0);
leurServo.write(0);
}
else if (photocellReading > 500) {
monServo.write(180);
tonServo.write(180);
sonServo.write(180);
leurServo.write(180);
}
delay(5000);
}

Un autre programme allume une lumière sur détection d'un mouvement en face de la maison :

int duration;
int distance;
int sensorpin = 12;
int pinRelais = 13;

void setup()
{
Serial.begin(9600);
pinMode(pinRelais, OUTPUT);
}

void loop()
{
pinMode(sensorpin, OUTPUT);
digitalWrite(sensorpin, LOW);
delayMicroseconds(2);
digitalWrite(sensorpin, HIGH);
delayMicroseconds(10);
digitalWrite(sensorpin, LOW);
pinMode(sensorpin, INPUT);
duration =pulseIn(sensorpin, HIGH);
distance = duration/58;
Serial.println(distance);
delay(100);
if (distance < 20){
digitalWrite(pinRelais, HIGH);
}
if (distance > 20){
digitalWrite(pinRelais, LOW);
}

}

Projet ICN3 2016/2017

2017-09-17T18:33:23Z

Rex :

== Participants ==

* Paul LAMANDE
* Grégoire FLEURY
* Baptiste SENECLAUZE

== Cahier des charges ==

[[Fichier:P1000119.JPG|200px|thumb|right|Composants utilisés]]

La maquette de maison doit comporter les dispositifs suivants.
* volets asservis par des servo-moteurs ;
* détection de la lumière ambiante pour l'ouverture ou la fermeture des volets et pour allumer ou éteindre les lumières ;

La maquette de la maison est conçue en 3D puis réalisée à l'ancienne à partir de contre-plaqué.

Les élements sont commandé par un Arduino lui-même relié à une Raspberry Pi pour la gestion par smartphone.
 

== Réalisations ==

=== Montages électroniques ===
Différents montages ont été testés :
* Montage pour le sonar ultrason : le montage permet d'allumer une LED sur détection de mouvement. Le montage a été réalisé sur une plaque d'essai puis un programme a été écrit pour ce montage.
* Montage pour le servo-moteur : le montage permet de faire bouger le servo-moteur. Là aussi montage sur plaque d'essai et programme de test.
* Montage pour la photo-résistance ; le montage permet d'allumer une LED en cas d'intensité lumineuse faible. Le test a été réalisé avec des luminosités différentes.
* plutôt qu'une LED nous avons décidé d'utiliser une ampoule 100mA

=== Maquette de la maison ===

La maquette de la maison a d'abord été représentée sur Google Sketchup (ajouter le dessin).

Nous avons, pendant les vacances, réalisé la maison en contreplaqué, peinte et volet équipés de charnières.

<gallery widths=300px heights=225px>
Fichier:20161027 150217.jpg|Vue de l'extérieur de la maison (volets motorisés) encore absence de capteurs et de LED
Fichier:20161027 150225.jpg|Ici une autre vue, de l'intérieur cette fois. La maison est en coupe pour observer les systèmes.
Fichier:20170524_121453.jpg|Schéma d'ensemble de la maison
</gallery>

=== Bouclier de commande ===

Nous avons réalisé un montage complet avec des servo-moteurs, une photo-résistance et un sonar ultrason. Nous écrivons aussi le programme faire fonctionner ce montage.

[[Fichier:DSCF4483.JPG|300px|thumb|center|Montage et conception de carte]]
 

Nous modélisons le circuit imprimé grâce au logiciel de création de circuit imprimés Fritzing. Le fichier de la carte est disponible : [[Media:emaison.fzz]].

<gallery widths=300px heights=225px>
Fichier:Maison_plaque_essai.png|Plaque d'essai
Fichier:Maison_schematique.png|Schématique
Fichier:Maison_PCB.png|Circuit électronique
</gallery>

Le circuit imprimé a été gravé lors de notre visite à Polytech'Lille.
[[Fichier:IMG_0738.jpg|300px|thumb|center|Bouclier de contrôle de la maison]]
 

=== Equipement de la maison ===

Le circuit imprimé a été soudé et inséré au dessus de l'arduino comme la photo ci-dessous le montre.
[[Fichier:DSCF4671.JPG|300px|thumb|center|Maison avec son contrôleur]]

La maquette de la maison a été équipée de différents capteurs et actionneurs comme cela se voit sur les photos ci-après.
<gallery widths=300px heights=225px>
Fichier:DSCF4646.JPG|Vue sur les servo-moteurs et sur la lampe
Fichier:DSCF4646.JPG|Cherchez la photo-résistance et le sonar ultrason
</gallery>

=== Programme ===

Le programme de commande des servo-moteurs des volets en fonction de la lumière est le suivant :

#include <Servo.h>

int photocellPin = A0;
int photocellReading;
Servo monServo;
Servo tonServo;
Servo sonServo;
Servo leurServo;

void setup(){
monServo.attach(9, 1000, 2000);
tonServo.attach(3, 1000, 2000);
sonServo.attach(5, 1000, 2000);
leurServo.attach(6, 1000, 2000);
Serial.begin(9600);
}

void loop(){
photocellReading = analogRead(photocellPin);
Serial.println(photocellReading);
if (photocellReading < 500) {
monServo.write(0);
tonServo.write(0);
sonServo.write(0);
leurServo.write(0);
}
else if (photocellReading > 500) {
monServo.write(180);
tonServo.write(180);
sonServo.write(180);
leurServo.write(180);
}
delay(5000);
}

Un autre programme allume une lumière sur détection d'un mouvement en face de la maison :

int duration;
int distance;
int sensorpin = 12;
int pinRelais = 13;

void setup()
{
Serial.begin(9600);
pinMode(pinRelais, OUTPUT);
}

void loop()
{
pinMode(sensorpin, OUTPUT);
digitalWrite(sensorpin, LOW);
delayMicroseconds(2);
digitalWrite(sensorpin, HIGH);
delayMicroseconds(10);
digitalWrite(sensorpin, LOW);
pinMode(sensorpin, INPUT);
duration =pulseIn(sensorpin, HIGH);
distance = duration/58;
Serial.println(distance);
delay(100);
if (distance < 20){
digitalWrite(pinRelais, HIGH);
}
if (distance > 20){
digitalWrite(pinRelais, LOW);
}

}

Fichier:DSCF4645.JPG

2017-09-17T18:32:53Z

Rex :

Fichier:DSCF4646.JPG

2017-09-17T18:31:39Z

Rex :

Projet ICN3 2016/2017

2017-09-17T18:26:16Z

Rex : /* Equipement de la maison */

== Participants ==

* Paul LAMANDE
* Grégoire FLEURY
* Baptiste SENECLAUZE

== Cahier des charges ==

[[Fichier:P1000119.JPG|200px|thumb|right|Composants utilisés]]

La maquette de maison doit comporter les dispositifs suivants.
* volets asservis par des servo-moteurs ;
* détection de la lumière ambiante pour l'ouverture ou la fermeture des volets et pour allumer ou éteindre les lumières ;

La maquette de la maison est conçue en 3D puis réalisée à l'ancienne à partir de contre-plaqué.

Les élements sont commandé par un Arduino lui-même relié à une Raspberry Pi pour la gestion par smartphone.
 

== Réalisations ==

=== Montages électroniques ===
Différents montages ont été testés :
* Montage pour le sonar ultrason : le montage permet d'allumer une LED sur détection de mouvement. Le montage a été réalisé sur une plaque d'essai puis un programme a été écrit pour ce montage.
* Montage pour le servo-moteur : le montage permet de faire bouger le servo-moteur. Là aussi montage sur plaque d'essai et programme de test.
* Montage pour la photo-résistance ; le montage permet d'allumer une LED en cas d'intensité lumineuse faible. Le test a été réalisé avec des luminosités différentes.
* plutôt qu'une LED nous avons décidé d'utiliser une ampoule 100mA

=== Maquette de la maison ===

La maquette de la maison a d'abord été représentée sur Google Sketchup (ajouter le dessin).

Nous avons, pendant les vacances, réalisé la maison en contreplaqué, peinte et volet équipés de charnières.

<gallery widths=300px heights=225px>
Fichier:20161027 150217.jpg|Vue de l'extérieur de la maison (volets motorisés) encore absence de capteurs et de LED
Fichier:20161027 150225.jpg|Ici une autre vue, de l'intérieur cette fois. La maison est en coupe pour observer les systèmes.
Fichier:20170524_121453.jpg|Schéma d'ensemble de la maison
</gallery>

=== Bouclier de commande ===

Nous avons réalisé un montage complet avec des servo-moteurs, une photo-résistance et un sonar ultrason. Nous écrivons aussi le programme faire fonctionner ce montage.

[[Fichier:DSCF4483.JPG|300px|thumb|center|Montage et conception de carte]]
 

Nous modélisons le circuit imprimé grâce au logiciel de création de circuit imprimés Fritzing. Le fichier de la carte est disponible : [[Media:emaison.fzz]].

<gallery widths=300px heights=225px>
Fichier:Maison_plaque_essai.png|Plaque d'essai
Fichier:Maison_schematique.png|Schématique
Fichier:Maison_PCB.png|Circuit électronique
</gallery>

Le circuit imprimé a été gravé lors de notre visite à Polytech'Lille.
[[Fichier:IMG_0738.jpg|300px|thumb|center|Bouclier de contrôle de la maison]]
 

=== Equipement de la maison ===

Le circuit imprimé a été soudé et inséré au dessus de l'arduino comme la photo ci-dessous le montre.

La maquette de la maison a été équipée de différents capteurs comme cela se voit sur les photos ci-après.

=== Programme ===

Le programme de commande des servo-moteurs des volets en fonction de la lumière est le suivant :

#include <Servo.h>

int photocellPin = A0;
int photocellReading;
Servo monServo;
Servo tonServo;
Servo sonServo;
Servo leurServo;

void setup(){
monServo.attach(9, 1000, 2000);
tonServo.attach(3, 1000, 2000);
sonServo.attach(5, 1000, 2000);
leurServo.attach(6, 1000, 2000);
Serial.begin(9600);
}

void loop(){
photocellReading = analogRead(photocellPin);
Serial.println(photocellReading);
if (photocellReading < 500) {
monServo.write(0);
tonServo.write(0);
sonServo.write(0);
leurServo.write(0);
}
else if (photocellReading > 500) {
monServo.write(180);
tonServo.write(180);
sonServo.write(180);
leurServo.write(180);
}
delay(5000);
}

Un autre programme allume une lumière sur détection d'un mouvement en face de la maison :

int duration;
int distance;
int sensorpin = 12;
int pinRelais = 13;

void setup()
{
Serial.begin(9600);
pinMode(pinRelais, OUTPUT);
}

void loop()
{
pinMode(sensorpin, OUTPUT);
digitalWrite(sensorpin, LOW);
delayMicroseconds(2);
digitalWrite(sensorpin, HIGH);
delayMicroseconds(10);
digitalWrite(sensorpin, LOW);
pinMode(sensorpin, INPUT);
duration =pulseIn(sensorpin, HIGH);
distance = duration/58;
Serial.println(distance);
delay(100);
if (distance < 20){
digitalWrite(pinRelais, HIGH);
}
if (distance > 20){
digitalWrite(pinRelais, LOW);
}

}

Fichier:DSCF4671.JPG

2017-09-17T18:25:10Z

Rex :

Projet ICN Écolycée 2016/2017

2017-09-17T18:18:12Z

Rex :

== Maquettes d'oiseaux ==

Nous nous sommes portés volontaires pour le projet de construction de maquettes d'animaux volants. Ces animaux doivent être présents en France et plus précisément à Lille. Il peut s'agir de merles, de mésanges ou de chauves souris de type pipistrelle. Ces maquettes serviront pour décorer la cour de notre Lycée Fénelon. Nous avons eu l'idée de fabriquer ces oiseaux en plexiglss, car cette matière résiste aux intempéries. Les animaux seront donc composés de plaques de plexiglas d'épaisseur variant selon la taille de l'animal reliés par des traverses ce qui donnerait un assemblage en 3 dimensions.

=== Les plaques de plexiglas ===

Les contours pour un pigeon et pour une mésange ont été dessinés sous paint et sous inkscape. Ces fichiers largement retouchés par M. Dhaussy sont donnés ci-après.

<gallery widths=300px heights=225px>
Fichier:Pigeon_V2.svg|Pièces pour le pigeon
Fichier:Mesange_V2.svg|Pièces pour la mésange
</gallery>

Un premier prototype a été découpé dans du contre-plaqué pour voir ce que cela donnait.
[[Fichier:IMG_0729.jpg|400px|thumb|left|Essai de découpe du pigeon]]

 

=== Les dessins entre les plaques ===

[[Fichier:IMG_0740.jpg|300px|thumb|left|Mésange plexiglas]]
[[Fichier:IMG_0731.jpg|200px|thumb|right|Plexiglas pour les maquettes]]

Durant la visite à Polytech'Lille un exemplaire du pigeon et un exemplaire de la mésange ont été découpés.

 

Voici les images des oiseaux, qui vont ensuite être imprimées et fixées entre les plaques de plexiglas.

<gallery widths=300px heights=300px>
Fichier:Image aile mésange 2.png|Image ailes de la mésange
Fichier:Image aile mésange 1.png|Image ailes de la mésange
Fichier:Image corps mésange.png|Image corps de la mésange
</gallery>

<gallery widths=300px heights=300px>
Fichier:Pigeon image finale.png|Image corps du pigeon
Fichier:Pigeon image finale reverse.png|Image corps du pigeon retournée
Fichier:Image aile pigeon.png|Image ailes du pigeon
</gallery>

=== Test de collage ===

Un tutoriel sur Internet montre comment réaliser de la colle à base de morceaux de plexiglas et d'acétone. Un essai a été tenté (voir les photos).

<gallery widths=300px heights=300px>
Fichier:DSCF4648.JPG|Fabrication de la colle
Fichier:DSCF4649.JPG|Vue rapprochée
</gallery>

Malheureusement il faut du temps pour faire fondre le plexiglas nous avons donc laissé la colle dans la salle. Quand nous sommes repassés à la séance suivante, la colle était complétement prise.

Pour l'assemblage nous nous sommes rabattus sur un collage avec de la colle silicone.

=== Réalisation ===

Quelques photos de l'assemblage des oiseaux.

<gallery widths=300px heights=300px>
Fichier:DSCF4653.JPG|Découpe pour la mésange
Fichier:DSCF4655.JPG|Découpe pour le pigeon
Fichier:DSCF4669.JPG|Pigeon assemblé
</gallery>

=== A réaliser ===

Quelques tests sont à faire avant de créer de nouvelles maquettes.

* faire des tests de collage des plaques jumelles avec des chutes de plexiglas et de l'acétone ;
* étudier la fixation des ailes sur le corps, collage à l'acétone ?

Fichier:DSCF4669.JPG

2017-09-17T18:18:06Z

Rex :

Fichier:DSCF4655.JPG

2017-09-17T18:17:30Z

Rex :

Fichier:DSCF4653.JPG

2017-09-17T18:15:50Z

Rex :

Projet ICN Écolycée 2016/2017

2017-09-17T18:11:01Z

Rex : /* A réaliser */

== Maquettes d'oiseaux ==

Nous nous sommes portés volontaires pour le projet de construction de maquettes d'animaux volants. Ces animaux doivent être présents en France et plus précisément à Lille. Il peut s'agir de merles, de mésanges ou de chauves souris de type pipistrelle. Ces maquettes serviront pour décorer la cour de notre Lycée Fénelon. Nous avons eu l'idée de fabriquer ces oiseaux en plexiglss, car cette matière résiste aux intempéries. Les animaux seront donc composés de plaques de plexiglas d'épaisseur variant selon la taille de l'animal reliés par des traverses ce qui donnerait un assemblage en 3 dimensions.

=== Les plaques de plexiglas ===

Les contours pour un pigeon et pour une mésange ont été dessinés sous paint et sous inkscape. Ces fichiers largement retouchés par M. Dhaussy sont donnés ci-après.

<gallery widths=300px heights=225px>
Fichier:Pigeon_V2.svg|Pièces pour le pigeon
Fichier:Mesange_V2.svg|Pièces pour la mésange
</gallery>

Un premier prototype a été découpé dans du contre-plaqué pour voir ce que cela donnait.
[[Fichier:IMG_0729.jpg|400px|thumb|left|Essai de découpe du pigeon]]

 

=== Les dessins entre les plaques ===

[[Fichier:IMG_0740.jpg|300px|thumb|left|Mésange plexiglas]]
[[Fichier:IMG_0731.jpg|200px|thumb|right|Plexiglas pour les maquettes]]

Durant la visite à Polytech'Lille un exemplaire du pigeon et un exemplaire de la mésange ont été découpés.

 

Voici les images des oiseaux, qui vont ensuite être imprimées et fixées entre les plaques de plexiglas.

<gallery widths=300px heights=300px>
Fichier:Image aile mésange 2.png|Image ailes de la mésange
Fichier:Image aile mésange 1.png|Image ailes de la mésange
Fichier:Image corps mésange.png|Image corps de la mésange
</gallery>

<gallery widths=300px heights=300px>
Fichier:Pigeon image finale.png|Image corps du pigeon
Fichier:Pigeon image finale reverse.png|Image corps du pigeon retournée
Fichier:Image aile pigeon.png|Image ailes du pigeon
</gallery>

=== Test de collage ===

Un tutoriel sur Internet montre comment réaliser de la colle à base de morceaux de plexiglas et d'acétone. Un essai a été tenté (voir les photos).

<gallery widths=300px heights=300px>
Fichier:DSCF4648.JPG|Fabrication de la colle
Fichier:DSCF4649.JPG|Vue rapprochée
</gallery>

Malheureusement il faut du temps pour faire fondre le plexiglas nous avons donc laissé la colle dans la salle. Quand nous sommes repassés à la séance suivante, la colle était complétement prise.

=== Réalisation ===

=== A réaliser ===

Quelques tests sont à faire avant de créer de nouvelles maquettes.

* laver les plaques, éventuellement avec un abrasif très fin comme une éponge magique ; (fait)
* imprimer les images du corps et des ailes à la bonne dimension ; (fait)
* faire des tests de collage des plaques jumelles avec des chutes de plexiglas et de l'acétone ;
* étudier la fixation des ailes sur le corps, collage à l'acétone ?

Il faudrait aussi redimensionner la mésange pour qu'elle ne fasse pas fuir les rapaces ... (fait ;D)

Fichier:DSCF4649.JPG

2017-09-17T18:10:28Z

Rex :

Projet ICN Écolycée 2016/2017

2017-09-17T18:10:18Z

Rex :

== Maquettes d'oiseaux ==

Nous nous sommes portés volontaires pour le projet de construction de maquettes d'animaux volants. Ces animaux doivent être présents en France et plus précisément à Lille. Il peut s'agir de merles, de mésanges ou de chauves souris de type pipistrelle. Ces maquettes serviront pour décorer la cour de notre Lycée Fénelon. Nous avons eu l'idée de fabriquer ces oiseaux en plexiglss, car cette matière résiste aux intempéries. Les animaux seront donc composés de plaques de plexiglas d'épaisseur variant selon la taille de l'animal reliés par des traverses ce qui donnerait un assemblage en 3 dimensions.

=== Les plaques de plexiglas ===

Les contours pour un pigeon et pour une mésange ont été dessinés sous paint et sous inkscape. Ces fichiers largement retouchés par M. Dhaussy sont donnés ci-après.

<gallery widths=300px heights=225px>
Fichier:Pigeon_V2.svg|Pièces pour le pigeon
Fichier:Mesange_V2.svg|Pièces pour la mésange
</gallery>

Un premier prototype a été découpé dans du contre-plaqué pour voir ce que cela donnait.
[[Fichier:IMG_0729.jpg|400px|thumb|left|Essai de découpe du pigeon]]

 

=== Les dessins entre les plaques ===

[[Fichier:IMG_0740.jpg|300px|thumb|left|Mésange plexiglas]]
[[Fichier:IMG_0731.jpg|200px|thumb|right|Plexiglas pour les maquettes]]

Durant la visite à Polytech'Lille un exemplaire du pigeon et un exemplaire de la mésange ont été découpés.

 

Voici les images des oiseaux, qui vont ensuite être imprimées et fixées entre les plaques de plexiglas.

<gallery widths=300px heights=300px>
Fichier:Image aile mésange 2.png|Image ailes de la mésange
Fichier:Image aile mésange 1.png|Image ailes de la mésange
Fichier:Image corps mésange.png|Image corps de la mésange
</gallery>

<gallery widths=300px heights=300px>
Fichier:Pigeon image finale.png|Image corps du pigeon
Fichier:Pigeon image finale reverse.png|Image corps du pigeon retournée
Fichier:Image aile pigeon.png|Image ailes du pigeon
</gallery>

=== Test de collage ===

Un tutoriel sur Internet montre comment réaliser de la colle à base de morceaux de plexiglas et d'acétone. Un essai a été tenté (voir les photos).

<gallery widths=300px heights=300px>
Fichier:DSCF4648.JPG|Fabrication de la colle
Fichier:DSCF4649.JPG|Vue rapprochée
</gallery>

Malheureusement il faut du temps pour faire fondre le plexiglas nous avons donc laissé la colle dans la salle. Quand nous sommes repassés à la séance suivante, la colle était complétement prise.

=== A réaliser ===

Quelques tests sont à faire avant de créer de nouvelles maquettes.

* laver les plaques, éventuellement avec un abrasif très fin comme une éponge magique ; (fait)
* imprimer les images du corps et des ailes à la bonne dimension ; (fait)
* faire des tests de collage des plaques jumelles avec des chutes de plexiglas et de l'acétone ;
* étudier la fixation des ailes sur le corps, collage à l'acétone ?

Il faudrait aussi redimensionner la mésange pour qu'elle ne fasse pas fuir les rapaces ... (fait ;D)

Fichier:DSCF4648.JPG

2017-09-17T18:08:58Z

Rex :

Projet ICN commun 2016/2017

2017-09-17T18:00:15Z

Rex : /* A réaliser */

== Cahier des charges ==

Plusieurs solutions ont été proposées pour l'apparence de l'horloge :
* utilisation d'un disque dur : https://www.youtube.com/watch?v=xaL4Cqu8DAs ;
* un écran derrière un miroir : https://www.youtube.com/watch?v=fkVBAcvbrjU ;
* affichage de l'heure avec des aiguilles physiques ou en projection ;
* utilisation de matrices de LEDs pour les messages ;
* utilisation d'afficheurs à segments comme pour les réveils du commerce.

Les afficheurs LCD à segments sont difficiles à trouver en pièces détachés. Les écrans de taille raisonnable sont relativement onéreux. L'affichage par un disque dur est assez délicat à réaliser et peu informatif. Les élèves se sont repliés sur un affichage par matrices de LEDs. Une matrice pour l'heure, une matrice pour les informations.

La listes de fonctionnalités évoquées suit.

* affichage de l'heure et de la date ;
* affichage d'autres fuseaux horaires ;
* affichage de la température ambiante :
* affichage de l'intitulé du cours ;
* sonnerie de début et de fin de cours ;
* avertissement en cas de niveau sonore trop élevé ;
* affichage d'un message de bienvenue ;
* affichage de la météo du jour.

== Liste du matériel nécessaire ==
Voici les informations des différents éléments de l'horloge établies par Noé :

* 420 Adafruit x2 192mmx96mm 23.53euros http://www.digikey.fr/product-detail/fr/adafruit-industries-llc/420/1528-1412-ND/5699167
* Raspberry Pi 3 type B 88mmx58mm 39.95euros http://www.materiel.net/micro-pc-raspberry-pi/raspberry-pi-3-type-b-128021.html
* Arduino mega 2560 R3 100mmx53mm 39.95euros http://www.selectronic.fr/carte-arduino-mega.html
* Electret microphone MX9814 7.50euros http://www.mouser.fr/ProductDetail/Adafruit/1713/?qs=sGAEpiMZZMsMyYRRhGMFNofwqklVUFtrRKKXD3NROZM%3d
* Haut-parleur x2 1W/ 8ohms 2.41euros http://www.lextronic.fr/P5204-haut-parleur--1w--8-ohms.html
* Amplificateur MAX98306 12.21euros https://shop.mchobby.be/breakout/195-amplificateur-2-x-37w-class-d-3232100001954-adafruit.html

Pour l'instant 151.04euros

Il faudrait peut-être rajouter un récepteur DCF77 pour obtenir l'heure exacte :

* CONRAD 13.99euros http://www.conrad.fr/ce/fr/product/641138/Platine-de-reception-DCF-alimentation-25-15-VDC-3-mA

matériel pour la prochaine séance:
* 40 vis en nylon de 3mm de diamètre et environ 1,5 cm de longueur
les vis ne sont pas assez longues pour la plupart et leurs diamètre est trop gros pour certains trous

Il sera également nécessaire d'ajouter un carte son USB à la Raspberry Pi car elle n'en dispose pas (Réf : carte son externe USB 5.1 6.90euros https://www.pearl.fr/article/PX6653/carte-son-externe-usb-5-1)

== Apparence de l'horloge ==

Une première version de l'apparence de l'horloge a été dessinée avec le logiciel sketchup par Célya. A l'aide des dimensions des matrices de LEDs, un dessin vectoriel a été créé pour être utilisé par la découpeuse laser de Polytech'Lille.

Les photos ci-dessous présentent une première maquette en contre-plaqué de test.

<gallery widths=300px heights=225px>
Fichier:IMG_0724.jpg|Maquette en contre-plaqué de l'horloge
Fichier:IMG_0726.jpg|Maquette vue de face
Fichier:IMG_0727.jpg|Maquette vue de profil
</gallery>

La seconde version du fichier pour la découpeuse laser est donnée ci-après.

[[Fichier:Horloge_201612.svg|500px|thumb|left|Faces de l'horloge]]

[[Fichier:IMG_0731.jpg|200px|thumb|right|Plexiglass utilisé pour les faces]]

 

== Réalisations ==

Quelques étapes de la réalisation de l'horloge par ordre chronologique.

* travail sur le design de l'horloge en le schématisant sur sketchup ;
* recherche des différents éléments de l'horloge (prix, fournisseurs, etc) :
* création du fichier pour découper les plaques de plexiglas avec inkscape ;
* découpage des plaques de plexiglass au Fabricarium de Polytech'Lille.
* relier le Raspberry Pi à l'horloge atomique dont l'émetteur est situé à Mainflingen;

== Récupération des signaux DCF77 ==

Les sites suivants sont conseillés par les encadrants pour faire fonctionner la platine de réception DCF77 :
* un [http://www.stefan-buchgeher.info/elektronik/dcf/dcf_kap2.html schéma] décrivant comment utiliser le module ;
* un [http://blog.debuglevel.de/raspberry-pi-und-dcf77-empfaenger-von-conrad/ site] décrivant comment utiliser le port série d'une Raspberry ;
* un [http://s159401799.onlinehome.fr/index.html?600HorlogeAtomiqueDCF77.html autre site] décrivant comment utiliser une entrée quelconque d'une Raspberry ;
* enfin ce [http://vogelchr.blogspot.fr/2013/09/dcf77-via-gpio-on-raspberry-pi-patched.html dernier site] montre comment modifier un programme pour synchroniser la date avec une entrée quelconque de la Raspberry ;

Un grand travail de récupération des signaux DCF77 a été réalisé.

Il y avait beaucoup de perturbation pour les ondes DCF dans la salle si bien que nous n'arrivions pas à capter un signal en entier pour avoir l'heure. Nous avons donc décidé d'isoler le Raspberry PI en le mettant devant la salle. Pour pourvoir le contrôler nous l'avons donc connecté à un point d’accès mobile sur lequel nous avons utilisé le SSH depuis un ordinateur dans la salle.trou du cul

La carte DCF77 montrée sur la photo suivante a été utilisée.

Cette carte a été connecté à la Raspberry Pi.

Les logiciels utilisés pour récupérer les signaux DCF77 sont : <code>radioclkd2</code> (version modifié), ...

Le logiciel <code>radioclkd2</code> a été récupéré sur Internet [http://vogelchr.blogspot.fr/2013/09/dcf77-via-gpio-on-raspberry-pi-patched.html] et compilé sur la Raspberry Pi. Un script a été écrit pour le lancer correctement après configuration des ports d'entrée/sortie de la Raspberry. Le script est donné ci-après :

#!/bin/sh
if [ ! -d /sys/class/gpio/gpio17/ ] ; then
echo 17 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio17/direction
echo both > /sys/class/gpio/gpio17/edge
fi
radioclkd2 -s gpio -v /sys/class/gpio/gpio17/value:-DCD

Pour que le logiciel <code>radioclkd2</code> puisse communiquer la date et l'heure au logiciel <code>ntp</code> qui s'occupe de la gestion du temps, il faut ajouter les lignes ci-dessous dans le fichier de configuration de <code>ntp</code>, c'est à dire <code>/etc/ntp.conf</code> :

server 127.127.28.0
fudge 127.127.28.0 flag1 1

Ce fichier permet aux deux logiciels de communiquer par mémoire partagée. Pour pouvoir vérifier le bon fonctionnement de la communication utiliser les lignes suivantes :

server 127.127.28.0
fudge 127.127.28.0 flag1 1 flag4 1
statistics clockstats
statsdir /ntpstats/
filegen clockstats file clockstats type day enable

Les statistiques sur la récupération de l'heure par DCF77 sont alors sauvegardés dans le répertoire <code>/var/lib/ntp/ntpstats</code>.

Pour intégrer proprement la carte dans l'horloge un circuit électronique a été réalisé avec le logiciel Fritzing. Le fichier de cette carte est disponible : [[Media:Dcf77.fzz]].[[Fichier:20170607_122319.jpg]]

[[Fichier:Dcf77 PCB.png|thumb|300px|center|Circuit imprimé pour connecter le récepteur DCF77 à la Raspberry Pi]]

== Début de construction de l'horloge ==

Les photos ci-dessous montrent une partie de l'horloge montée avec
* les plaques de plexiglas les plus propres obtenues avec la découpeuse laser de Polytech'Lille ;
* les deux matrices de LEDs comportant, chacune, 32x16 LEDs ;
* la Raspberry PI avec le chapeau de contrôle des matrices de LEDs.

La Raspberry PI est configurée en mode point d'accès WiFi pour pour dialoguer avec l'horloge à partir d'un téléphone portable.

<gallery widths=400px heights=400px>
Fichier:DSCF4650.JPG|Horloge de face
Fichier:DSCF4651.JPG|Horloge de coté
</gallery>

== Encore à réaliser ==

Il reste encore beaucoup de travail à réaliser pour cette horloge.

* la Raspberry ne possède pas d'entrée audio, il faut donc trouver une carte son USB reconnue par la Raspberry et expérimenter la capture audio avec cette carte son ;
* il faut concevoir le dispositif d'accroche pour les haut-parleurs sur la facade avant ;
* un circuit électronique pour la connexion carte son / haut-parleurs et platine DCF / Raspberry sera certainement nécessaire, utiliser la place prévue à l'origine pour l'Arduino pour la fixer dans l'horloge.

== Quelques indications ==

Pour utiliser les matrices de LEDs avec la Raspberry PI :
* suivez le [https://learn.adafruit.com/adafruit-rgb-matrix-plus-real-time-clock-hat-for-raspberry-pi/driving-matrices tutorial adafruit] à partir du chapitre 6, en particulier
** récupérez les paquetages nécessaires par <tt>apt-get install python-dev python-imaging</tt>;
** récuperez les [https://github.com/adafruit/rpi-rgb-led-matrix/archive/master.zip programmes de démonstration].
* modifiez le programme pour afficher en boucle les textes qui se trouvent dans un fichier donné.

Pour transformer la Raspberry PI en point d'accès WiFi, il faut :
* installer le paquetage <tt>hostapd</tt>, configurer le serveur <tt>hostapd</tt> en WPA (méthode d'identification) avec un SSID (réseau WiFi) et un mot de passe ;
* modifier le fichier <tt>/etc/network/interfaces</tt> pour donner une adresse IP à la Raspberry PI sur son interface WiFi ;
* installer le paquetage <tt>isc-dhcp-server</tt> et configurer le serveur <tt>dhcpd</tt> pour donner des adresses IP aux téléphones portables qui se connecteront sur votre SSID ;
* installer le paquetage <tt>bind9</tt> et configurer le serveur <tt>named</tt> pour donner un nom facile à retenir à l'horloge.
* installer les paquetage <tt>apache2</tt> et <tt>php5</tt> pour pouvoir créer un petit site Web dont les fichiers doivent se trouver dans le répertoire <tt>/var/www/html</tt>.