<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="fr">
		<id>http://wiki.labaixbidouille.com/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Adminsys</id>
		<title>Wiki L.A.B - Contributions de l’utilisateur [fr]</title>
		<link rel="self" type="application/atom+xml" href="http://wiki.labaixbidouille.com/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Adminsys"/>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php/Sp%C3%A9cial:Contributions/Adminsys"/>
		<updated>2026-04-17T20:13:15Z</updated>
		<subtitle>Contributions de l’utilisateur</subtitle>
		<generator>MediaWiki 1.26.0</generator>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Ch%C3%A2ssis_de_RobotDuLAB_D%C3%A9coup%C3%A9_au_Laser&amp;diff=698</id>
		<title>Châssis de RobotDuLAB Découpé au Laser</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Ch%C3%A2ssis_de_RobotDuLAB_D%C3%A9coup%C3%A9_au_Laser&amp;diff=698"/>
				<updated>2017-02-09T16:25:20Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec «   Catégorie:RobotDuLAB »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=697</id>
		<title>Catégorie:RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=697"/>
				<updated>2017-02-09T16:23:18Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs. Le code arduino est produit automatiquement. Il suffit ensuite de télécharger le code produit dans le robot depuis le PC.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:Blokly_exemple1.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour programmer le robot avec blokly il faut se connecter à la page : http://robotdulab.labaixbidouille.com/&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constitué d'un châssis avec une roulette à bille, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino et d'un capteur à ultrasons.&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* LED RGB, ou NeoPixel Ring&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== [[Châssis de RobotDuLAB|Châssis]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Châssis de RobotDuLAB Découpé au Laser]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Électronique de RobotDuLAB|Électronique]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Programmes d'exemple de RobotDuLAB|Programmes]] ===&lt;br /&gt;
&lt;br /&gt;
== [[Téléchargements des fichiers de RobotDuLAB|Téléchargements]] ==&lt;br /&gt;
&lt;br /&gt;
[[Category:Projet]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=602</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=602"/>
				<updated>2016-08-29T09:11:27Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page redirigée vers Catégorie:RobotDuLAB&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;#REDIRECT [[:Catégorie:RobotDuLAB]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=528</id>
		<title>Catégorie:RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=528"/>
				<updated>2016-08-11T17:27:52Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs. Le code arduino est produit automatiquement. Il suffit ensuite de télécharger le code produit dans le robot depuis le PC.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:Blokly_exemple1.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constitué d'un châssis avec une roulette à bille, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino et d'un capteur à ultrasons.&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* LED RGB, ou NeoPixel Ring&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== [[Châssis de RobotDuLAB|Châssis]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Électronique de RobotDuLAB|Électronique]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Programmes d'exemple de RobotDuLAB|Programmes]] ===&lt;br /&gt;
&lt;br /&gt;
== [[Téléchargements des fichiers de RobotDuLAB|Téléchargements]] ==&lt;br /&gt;
&lt;br /&gt;
[[Category:Projet]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Projet&amp;diff=527</id>
		<title>Catégorie:Projet</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Projet&amp;diff=527"/>
				<updated>2016-08-11T17:26:52Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Dans cette catégorie vous retrouverez tous les projets qu'ils soient en cours ou terminés.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
File:Bobine.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Bobine Tesla Musicale]]&amp;lt;/div&amp;gt;|link=[[Bobine Tesla Musicale]]&lt;br /&gt;
File:Kinharpe3.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Harpe Laser Midi]]&amp;lt;/div&amp;gt;|link=[[Harpe Laser Midi]]&lt;br /&gt;
File:XyloRobot.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[XyloRobot]]&amp;lt;/div&amp;gt;|link=[[XyloRobot]]&lt;br /&gt;
File:LabVM.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Machine Virtuelle du LAB]]&amp;lt;/div&amp;gt;|link=[[Machine Virtuelle du LAB]]&lt;br /&gt;
File:Wired.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[NeoPixel Painter]]&amp;lt;/div&amp;gt;|link=[[NeoPixel Painter]]&lt;br /&gt;
File:LABanque.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[LABanque : Monnaie complémentaire communautaire fondante|LABanque]]&amp;lt;/div&amp;gt;|link=[[LABanque : Monnaie complémentaire communautaire fondante]]&lt;br /&gt;
File:Logo_domoweb_blanc.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Domotique]]&amp;lt;/div&amp;gt;|link=[[Domotique]]&lt;br /&gt;
File:Vignette RoboDuLAB.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[:Catégorie:RobotDuLAB|RobotDuLAB]]&amp;lt;/div&amp;gt;|link=[[:Catégorie:RobotDuLAB]]&lt;br /&gt;
File:Vignette Logo.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Jeu de Stratégie]]&amp;lt;/div&amp;gt;|link=[[JeuStrategy]]&lt;br /&gt;
File:random.jpeg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Random Shield]]&amp;lt;/div&amp;gt;|link=[[RandomShield]]&lt;br /&gt;
File:canbus.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte du Bus CAN]]&amp;lt;/div&amp;gt;|link=[[Découverte du Bus CAN]]&lt;br /&gt;
File:internetOfFrogs.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Terrarium pour dendrobate connecté]]&amp;lt;/div&amp;gt;|link=[[Terrarium pour dendrobate connecté]]&lt;br /&gt;
File:Hypercubecentral|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Géométrie en aveugle]]&amp;lt;/div&amp;gt;|link=[[Geometrie en Aveugle]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Projet&amp;diff=526</id>
		<title>Catégorie:Projet</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Projet&amp;diff=526"/>
				<updated>2016-08-11T17:26:11Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Dans cette catégorie vous retrouverez tous les projets qu'ils soient en cours ou terminés.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
File:Bobine.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Bobine Tesla Musicale]]&amp;lt;/div&amp;gt;|link=[[Bobine Tesla Musicale]]&lt;br /&gt;
File:Kinharpe3.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Harpe Laser Midi]]&amp;lt;/div&amp;gt;|link=[[Harpe Laser Midi]]&lt;br /&gt;
File:XyloRobot.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[XyloRobot]]&amp;lt;/div&amp;gt;|link=[[XyloRobot]]&lt;br /&gt;
File:LabVM.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Machine Virtuelle du LAB]]&amp;lt;/div&amp;gt;|link=[[Machine Virtuelle du LAB]]&lt;br /&gt;
File:Wired.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[NeoPixel Painter]]&amp;lt;/div&amp;gt;|link=[[NeoPixel Painter]]&lt;br /&gt;
File:LABanque.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[LABanque : Monnaie complémentaire communautaire fondante|LABanque]]&amp;lt;/div&amp;gt;|link=[[LABanque : Monnaie complémentaire communautaire fondante]]&lt;br /&gt;
File:Logo_domoweb_blanc.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Domotique]]&amp;lt;/div&amp;gt;|link=[[Domotique]]&lt;br /&gt;
File:Vignette RoboDuLAB.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[:Catégorie:RoboduLAB|RoboduLAB]]&amp;lt;/div&amp;gt;|link=[[:Catégorie:RoboduLAB]]&lt;br /&gt;
File:Vignette Logo.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Jeu de Stratégie]]&amp;lt;/div&amp;gt;|link=[[JeuStrategy]]&lt;br /&gt;
File:random.jpeg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Random Shield]]&amp;lt;/div&amp;gt;|link=[[RandomShield]]&lt;br /&gt;
File:canbus.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte du Bus CAN]]&amp;lt;/div&amp;gt;|link=[[Découverte du Bus CAN]]&lt;br /&gt;
File:internetOfFrogs.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Terrarium pour dendrobate connecté]]&amp;lt;/div&amp;gt;|link=[[Terrarium pour dendrobate connecté]]&lt;br /&gt;
File:Hypercubecentral|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Géométrie en aveugle]]&amp;lt;/div&amp;gt;|link=[[Geometrie en Aveugle]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=525</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=525"/>
				<updated>2016-08-11T17:24:30Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Contenu remplacé par «  Catégorie:RobotDuLAB Catégorie:Arduino Catégorie:Blockly »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;br /&gt;
[[Catégorie:Blockly]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Programmes_d%27exemple_de_RobotDuLAB&amp;diff=524</id>
		<title>Programmes d'exemple de RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Programmes_d%27exemple_de_RobotDuLAB&amp;diff=524"/>
				<updated>2016-08-11T17:23:58Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt; - soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt; - soi... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== [[Code arduino : démonstration du fonctionnement du robot en mode autonome]] ====&lt;br /&gt;
&lt;br /&gt;
==== [[Programmation du robot en langage graphique (Blokly)]] ====&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;br /&gt;
[[Catégorie:Blockly]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=523</id>
		<title>Catégorie:RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=523"/>
				<updated>2016-08-11T17:23:34Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : /* Programmes d'exemple de RobotDuLAB|Programmes */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs. Le code arduino est produit automatiquement. Il suffit ensuite de télécharger le code produit dans le robot depuis le PC.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:Blokly_exemple1.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constitué d'un châssis avec une roulette à bille, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino et d'un capteur à ultrasons.&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* LED RGB, ou NeoPixel Ring&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== [[Châssis de RobotDuLAB|Châssis]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Électronique de RobotDuLAB|Électronique]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Programmes d'exemple de RobotDuLAB|Programmes]] ===&lt;br /&gt;
&lt;br /&gt;
== [[Téléchargements des fichiers de RobotDuLAB|Téléchargements]] ==&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Code_arduino_:_d%C3%A9monstration_du_fonctionnement_du_robot_en_mode_autonome&amp;diff=522</id>
		<title>Code arduino : démonstration du fonctionnement du robot en mode autonome</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Code_arduino_:_d%C3%A9monstration_du_fonctionnement_du_robot_en_mode_autonome&amp;diff=522"/>
				<updated>2016-08-11T17:22:19Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=521</id>
		<title>Catégorie:RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=521"/>
				<updated>2016-08-11T17:21:00Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : /* Programmes */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs. Le code arduino est produit automatiquement. Il suffit ensuite de télécharger le code produit dans le robot depuis le PC.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:Blokly_exemple1.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constitué d'un châssis avec une roulette à bille, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino et d'un capteur à ultrasons.&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* LED RGB, ou NeoPixel Ring&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== [[Châssis de RobotDuLAB|Châssis]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Électronique de RobotDuLAB|Électronique]] ===&lt;br /&gt;
&lt;br /&gt;
=== Programmes d'exemple de RobotDuLAB|Programmes ===&lt;br /&gt;
Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== [[Code arduino : démonstration du fonctionnement du robot en mode autonome]] ====&lt;br /&gt;
&lt;br /&gt;
==== [[Programmation du robot en langage graphique (Blokly)]] ====&lt;br /&gt;
&lt;br /&gt;
== [[Téléchargements des fichiers de RobotDuLAB|Téléchargements]] ==&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Code_arduino_:_d%C3%A9monstration_du_fonctionnement_du_robot_en_mode_autonome&amp;diff=520</id>
		<title>Code arduino : démonstration du fonctionnement du robot en mode autonome</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Code_arduino_:_d%C3%A9monstration_du_fonctionnement_du_robot_en_mode_autonome&amp;diff=520"/>
				<updated>2016-08-11T17:19:38Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « ===== Programme sans NeoPixel Ring =====  Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino &amp;lt;br /&amp;gt;  &amp;lt;syntaxhighlight... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Programmation_du_robot_en_langage_graphique_(Blokly)&amp;diff=519</id>
		<title>Programmation du robot en langage graphique (Blokly)</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Programmation_du_robot_en_langage_graphique_(Blokly)&amp;diff=519"/>
				<updated>2016-08-11T17:18:50Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « Pour programmer le robot en langage graphique, il faut : # se connecter sur la page : http://robotdulab.labaixbidouille.com # composer le programme en assemblant les blocs... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Pour programmer le robot en langage graphique, il faut :&lt;br /&gt;
# se connecter sur la page : http://robotdulab.labaixbidouille.com&lt;br /&gt;
# composer le programme en assemblant les blocs,&lt;br /&gt;
# copier le code produit dans l'IDE arduino, ou cliquer sur le bouton &amp;quot;Télécharger&amp;quot;,&lt;br /&gt;
# télécharger (téléverser) le code dans la carte de prototypage arduino.&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;br /&gt;
[[Catégorie:Blockly]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=T%C3%A9l%C3%A9chargements_des_fichiers_de_RobotDuLAB&amp;diff=518</id>
		<title>Téléchargements des fichiers de RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=T%C3%A9l%C3%A9chargements_des_fichiers_de_RobotDuLAB&amp;diff=518"/>
				<updated>2016-08-11T17:16:57Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « === Documents de présentation ===  https://github.com/LabAixBidouille/RobotDuLAB-blockly/blob/gh-pages/Plaquette%20robodulab-2.pdf  === Pièces imprimables === Les pièce... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Documents de présentation ===&lt;br /&gt;
&lt;br /&gt;
https://github.com/LabAixBidouille/RobotDuLAB-blockly/blob/gh-pages/Plaquette%20robodulab-2.pdf&lt;br /&gt;
&lt;br /&gt;
=== Pièces imprimables ===&lt;br /&gt;
Les pièces imprimables : base, roue, support capteur Ultra-sons et plaque pour support de piles sont téléchargeable sur Thingiverse:&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Bibliothèque RobotDuLAB ===&lt;br /&gt;
&lt;br /&gt;
La bibliothèque arduino &amp;quot;RoboduLAB&amp;quot; peur être téléchargée ici : &lt;br /&gt;
https://github.com/LabAixBidouille/RobotDuLAB-arduino-library&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Ch%C3%A2ssis_de_RobotDuLAB&amp;diff=517</id>
		<title>Châssis de RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Ch%C3%A2ssis_de_RobotDuLAB&amp;diff=517"/>
				<updated>2016-08-11T17:15:53Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=%C3%89lectronique_de_RobotDuLAB&amp;diff=516</id>
		<title>Électronique de RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=%C3%89lectronique_de_RobotDuLAB&amp;diff=516"/>
				<updated>2016-08-11T17:15:37Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;==== Liste des différents composants du robot sans NeoPixel Ring ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot sans NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot avec NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=%C3%89lectronique_de_RobotDuLAB&amp;diff=515</id>
		<title>Électronique de RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=%C3%89lectronique_de_RobotDuLAB&amp;diff=515"/>
				<updated>2016-08-11T17:15:12Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « ==== Liste des différents composants du robot sans NeoPixel Ring ==== La partie électronique du robot comporte à minima : * une carte arduino (UNO),  * deux servomoteur... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;==== Liste des différents composants du robot sans NeoPixel Ring ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot sans NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot avec NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Ch%C3%A2ssis_de_RobotDuLAB&amp;diff=514</id>
		<title>Châssis de RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Ch%C3%A2ssis_de_RobotDuLAB&amp;diff=514"/>
				<updated>2016-08-11T17:14:36Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt; Les fichiers .stl sont téléchargeables ici : http:... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=513</id>
		<title>Catégorie:RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=513"/>
				<updated>2016-08-11T17:13:57Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs. Le code arduino est produit automatiquement. Il suffit ensuite de télécharger le code produit dans le robot depuis le PC.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:Blokly_exemple1.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constitué d'un châssis avec une roulette à bille, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino et d'un capteur à ultrasons.&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* LED RGB, ou NeoPixel Ring&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== [[Châssis de RobotDuLAB|Châssis]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Électronique de RobotDuLAB|Électronique]] ===&lt;br /&gt;
&lt;br /&gt;
=== [[Programmes d'exemple de RobotDuLAB|Programmes]] ===&lt;br /&gt;
&lt;br /&gt;
==== [[Code arduino : démonstration du fonctionnement du robot en mode autonome]] ====&lt;br /&gt;
&lt;br /&gt;
==== [[Programmation du robot en langage graphique (Blokly)]] ====&lt;br /&gt;
&lt;br /&gt;
== [[Téléchargements des fichiers de RobotDuLAB|Téléchargements]] ==&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=512</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=512"/>
				<updated>2016-08-11T17:05:09Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constitué d'un châssis avec une roulette à bille, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino et d'un capteur à ultrasons.&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* LED RGB, ou NeoPixel Ring&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== Chassis ===&lt;br /&gt;
&lt;br /&gt;
Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Électronique ===&lt;br /&gt;
&lt;br /&gt;
==== Liste des différents composants du robot sans NeoPixel Ring ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot sans NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot avec NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
=== Programmes ===&lt;br /&gt;
&lt;br /&gt;
Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== Code arduino : démonstration du fonctionnement du robot en mode autonome ====&lt;br /&gt;
===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Programmation du robot en langage graphique (Blokly) ====&lt;br /&gt;
&lt;br /&gt;
Pour programmer le robot en langage graphique, il faut :&lt;br /&gt;
# se connecter sur la page : http://robotdulab.labaixbidouille.com&lt;br /&gt;
# composer le programme en assemblant les blocs,&lt;br /&gt;
# copier le code produit dans l'IDE arduino, ou cliquer sur le bouton &amp;quot;Télécharger&amp;quot;,&lt;br /&gt;
# télécharger (téléverser) le code dans la carte de prototypage arduino.&lt;br /&gt;
&lt;br /&gt;
== Téléchargements ==&lt;br /&gt;
=== Documents de présentation ===&lt;br /&gt;
&lt;br /&gt;
https://github.com/LabAixBidouille/RobotDuLAB-blockly/blob/gh-pages/Plaquette%20robodulab-2.pdf&lt;br /&gt;
&lt;br /&gt;
=== Pièces imprimables ===&lt;br /&gt;
Les pièces imprimables : base, roue, support capteur Ultra-sons et plaque pour support de piles sont téléchargeable sur Thingiverse:&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Bibliothèque RobotDuLAB ===&lt;br /&gt;
&lt;br /&gt;
La bibliothèque arduino &amp;quot;RoboduLAB&amp;quot; peur être téléchargée ici : &lt;br /&gt;
https://github.com/LabAixBidouille/RobotDuLAB-arduino-library&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;br /&gt;
[[Catégorie:Blockly]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=511</id>
		<title>Catégorie:RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=511"/>
				<updated>2016-08-11T17:00:12Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs. Le code arduino est produit automatiquement. Il suffit ensuite de télécharger le code produit dans le robot depuis le PC.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:Blokly_exemple1.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=500</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=500"/>
				<updated>2016-08-11T09:46:49Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs (type scratch). Le programme se télécharge directement dans le robot depuis le PC ou la tablette en WIFI.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:S4a.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constiué d'un chassis, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino.&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== Chassis ===&lt;br /&gt;
&lt;br /&gt;
Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Électronique ===&lt;br /&gt;
&lt;br /&gt;
==== Liste des différents composants du robot sans NeoPixel Ring ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot sans NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot avec NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
=== Programmes ===&lt;br /&gt;
&lt;br /&gt;
Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== Code arduino : démonstration du fonctionnement du robot en mode autonome ====&lt;br /&gt;
===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Programmation du robot en langage graphique (Blokly) ====&lt;br /&gt;
&lt;br /&gt;
Pour programmer le robot en langage graphique, il faut :&lt;br /&gt;
# se connecter sur la page : http://robotdulab.labaixbidouille.com&lt;br /&gt;
# composer le programme en assemblant les blocs,&lt;br /&gt;
# copier le code produit dans l'IDE arduino, ou cliquer sur le bouton &amp;quot;Générer code&amp;quot;,&lt;br /&gt;
# télécharger (téléverser) le code dans la carte de prototypage arduino.&lt;br /&gt;
&lt;br /&gt;
== Téléchargements ==&lt;br /&gt;
=== Documents de présentation ===&lt;br /&gt;
=== Pièces imprimables ===&lt;br /&gt;
Les pièces imprimables : base, roue, support capteur Ultra-sons et plaque pour support de piles sont téléchargeable sur Thingiverse:&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Bibliothèque RobotDuLAB ===&lt;br /&gt;
&lt;br /&gt;
La bibliothèque arduino &amp;quot;RoboduLAB&amp;quot; peur être téléchargée ici : &lt;br /&gt;
https://github.com/LabAixBidouille/RobotDuLAB-arduino-library&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;br /&gt;
[[Catégorie:Blockly]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=499</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=499"/>
				<updated>2016-08-11T09:44:55Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : /* Programmation du robot en langage graphique (Blokly) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs (type scratch). Le programme se télécharge directement dans le robot depuis le PC ou la tablette en WIFI.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:S4a.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constiué d'un chassis, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino.&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== Chassis ===&lt;br /&gt;
&lt;br /&gt;
Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Électronique ===&lt;br /&gt;
&lt;br /&gt;
==== Liste des différents composants du robot sans NeoPixel Ring ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot sans NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot avec NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
=== Programmes ===&lt;br /&gt;
&lt;br /&gt;
Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== Code arduino : démonstration du fonctionnement du robot en mode autonome ====&lt;br /&gt;
===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Programmation du robot en langage graphique (Blokly) ====&lt;br /&gt;
&lt;br /&gt;
Pour programmer le robot en langage graphique, il faut :&lt;br /&gt;
# se connecter sur la page : http://robotdulab.labaixbidouille.com&lt;br /&gt;
# composer le programme en assemblant les blocs,&lt;br /&gt;
# copier le code produit dans l'IDE arduino, ou cliquer sur le bouton &amp;quot;Générer code&amp;quot;,&lt;br /&gt;
# télécharger (téléverser) le code dans la carte de prototypage arduino.&lt;br /&gt;
&lt;br /&gt;
== Téléchargements ==&lt;br /&gt;
=== Documents de présentation ===&lt;br /&gt;
=== Pièces imprimables ===&lt;br /&gt;
Les pièces imprimables : base, roue, support capteur Ultra-sons et plaque pour support de piles sont téléchargeable sur Thingiverse:&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Bibliothèque RobotDuLAB ===&lt;br /&gt;
&lt;br /&gt;
La bibliothèque arduino &amp;quot;RoboduLAB&amp;quot; peur être téléchargée ici : &lt;br /&gt;
https://github.com/LabAixBidouille/RobotDuLAB-arduino-library&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=498</id>
		<title>Catégorie:RobotDuLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:RobotDuLAB&amp;diff=498"/>
				<updated>2016-08-11T09:43:48Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec «  &amp;lt;br&amp;gt; '''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt; &amp;lt;br&amp;gt; * Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt; * Toutes les pièces mécaniques sont im... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs (type scratch). Le programme se télécharge directement dans le robot depuis le PC ou la tablette en WIFI.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:S4a.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=496</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=496"/>
				<updated>2016-08-11T09:39:53Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== Présentation du projet ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs (type scratch). Le programme se télécharge directement dans le robot depuis le PC ou la tablette en WIFI.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:S4a.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Constitution du robot ==&lt;br /&gt;
RoboduLAB est constiué d'un chassis, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino.&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== Chassis ===&lt;br /&gt;
&lt;br /&gt;
Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Électronique ===&lt;br /&gt;
&lt;br /&gt;
==== Liste des différents composants du robot sans NeoPixel Ring ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot sans NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Raccordement des différents éléments du robot avec NeoPixel Ring ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
=== Programmes ===&lt;br /&gt;
&lt;br /&gt;
Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== Code arduino : démonstration du fonctionnement du robot en mode autonome ====&lt;br /&gt;
===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Programmation du robot en langage graphique (Blokly) ====&lt;br /&gt;
&lt;br /&gt;
Pour programmer le robot en langage graphique, il faut :&lt;br /&gt;
# se connecter sur la page : https://labaixbidouille.github.io/RobotDuLAB-blockly/&lt;br /&gt;
# composer le programme en assemblant les blocs,&lt;br /&gt;
# copier le code produit dans l'IDE arduino, ou cliquer sur le bouton &amp;quot;Générer code&amp;quot;,&lt;br /&gt;
# télécharger (téléverser) le code dans la carte de prototypage arduino.&lt;br /&gt;
&lt;br /&gt;
== Téléchargements ==&lt;br /&gt;
=== Documents de présentation ===&lt;br /&gt;
=== Pièces imprimables ===&lt;br /&gt;
Les pièces imprimables : base, roue, support capteur Ultra-sons et plaque pour support de piles sont téléchargeable sur Thingiverse:&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== Bibliothèque RobotDuLAB ===&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=495</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=495"/>
				<updated>2016-08-11T09:37:36Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : /* Librairie RboduLAB */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== [[Présentation du projet]] ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs (type scratch). Le programme se télécharge directement dans le robot depuis le PC ou la tablette en WIFI.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:S4a.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== [[Constitution du robot]] ==&lt;br /&gt;
RoboduLAB est constiué d'un chassis, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino.&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== [[Chassis]] ===&lt;br /&gt;
&lt;br /&gt;
Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== [[Électronique]] ===&lt;br /&gt;
&lt;br /&gt;
==== [[Liste des différents composants du robot sans NeoPixel Ring]] ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== [[Raccordement des différents éléments du robot sans NeoPixel Ring]] ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== [[Raccordement des différents éléments du robot avec NeoPixel Ring]] ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
=== [[Programmes]] ===&lt;br /&gt;
&lt;br /&gt;
Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== [[Code arduino : démonstration du fonctionnement du robot en mode autonome]] ====&lt;br /&gt;
===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== [[Programmation du robot en langage graphique (Blokly)]] ====&lt;br /&gt;
&lt;br /&gt;
Pour programmer le robot en langage graphique, il faut :&lt;br /&gt;
# se connecter sur la page : https://labaixbidouille.github.io/RobotDuLAB-blockly/&lt;br /&gt;
# composer le programme en assemblant les blocs,&lt;br /&gt;
# copier le code produit dans l'IDE arduino, ou cliquer sur le bouton &amp;quot;Générer code&amp;quot;,&lt;br /&gt;
# télécharger (téléverser) le code dans la carte de prototypage arduino.&lt;br /&gt;
&lt;br /&gt;
== [[Téléchargements]] ==&lt;br /&gt;
=== [[Documents de présentation]] ===&lt;br /&gt;
=== [[Pièces imprimables]] ===&lt;br /&gt;
Les pièces imprimables : base, roue, support capteur Ultra-sons et plaque pour support de piles sont téléchargeable sur Thingiverse:&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== [[Librairie RobotDuLAB]] ===&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=494</id>
		<title>RoboduLAB</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=RoboduLAB&amp;diff=494"/>
				<updated>2016-08-11T09:37:07Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== [[Présentation du projet]] ==&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
'''Un robot pour apprendre à programmer en classe''' &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
* Utilisable en écoles primaires, collèges et lycées &amp;lt;br&amp;gt;&lt;br /&gt;
* Toutes les pièces mécaniques sont imprimables (impression 3D – fichiers .stl fournis) &amp;lt;br&amp;gt;&lt;br /&gt;
* Partie électronique basée sur une carte de prototypage « arduino » &amp;lt;br&amp;gt;&lt;br /&gt;
* Libre (copiable, modifiable) et évolutif (de nombreuses options possibles) &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
RoboduLAB, permet une approche ludique de l’apprentissage du code à l’école primaire, des plots  au format lego permettent de personnaliser le robot.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Fichier:RoboduLAB_avec_lego.jpg|sans_cadre|RoboduLAB avec paques lego et ring 16 LED|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
En collège et en lycée RoboduLAB est un support de thème très riche pour le travail en équipes projets : conception, réalisation, expérimentation. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
La programmation se fait par assemblage de blocs (type scratch). Le programme se télécharge directement dans le robot depuis le PC ou la tablette en WIFI.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
[[Fichier:S4a.JPG|sans_cadre|Programmation par blocs|600px]] &lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== [[Constitution du robot]] ==&lt;br /&gt;
RoboduLAB est constiué d'un chassis, de deux roues montées sur des servomoteurs qui sont commandés par une carte de prototypage arduino.&lt;br /&gt;
Il sera possible de rajouter différentes options au modèle de base :&lt;br /&gt;
* suivi de ligne, &lt;br /&gt;
* module WIFI, &lt;br /&gt;
* détection des vides, &lt;br /&gt;
* sons (MP3), &lt;br /&gt;
* …&lt;br /&gt;
&lt;br /&gt;
=== [[Chassis]] ===&lt;br /&gt;
&lt;br /&gt;
Le chassis est constitué d'un ensemble de pièces imprimables par une une imprimante 3D et une roulette à bille.&amp;lt;br&amp;gt;&lt;br /&gt;
Les fichiers .stl sont téléchargeables ici : http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== [[Électronique]] ===&lt;br /&gt;
&lt;br /&gt;
==== [[Liste des différents composants du robot sans NeoPixel Ring]] ====&lt;br /&gt;
La partie électronique du robot comporte à minima :&lt;br /&gt;
* une carte arduino (UNO), &lt;br /&gt;
* deux servomoteurs à rotation continue, &lt;br /&gt;
* un capteur à ultrasons, &lt;br /&gt;
* un boîtier pour piles (6 piles AA) &lt;br /&gt;
* un interrupteur à glissière.&lt;br /&gt;
&lt;br /&gt;
==== [[Raccordement des différents éléments du robot sans NeoPixel Ring]] ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_sans_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== [[Raccordement des différents éléments du robot avec NeoPixel Ring]] ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Schéma_avec_ring.JPG]]&lt;br /&gt;
&lt;br /&gt;
=== [[Programmes]] ===&lt;br /&gt;
&lt;br /&gt;
Le programme nécessaire pour le fonctionnement du robot peut être :&amp;lt;br&amp;gt;&lt;br /&gt;
- soit écrit directement en C++ et téléchargé (téléversé) dans la carte arduino,&amp;lt;br&amp;gt;&lt;br /&gt;
- soit représenté par des blocs graphiques (Blokly). Il sera alors possible de produire automatiquement le code en C++ qui sera téléchargé dans le robot.&lt;br /&gt;
&lt;br /&gt;
==== [[Code arduino : démonstration du fonctionnement du robot en mode autonome]] ====&lt;br /&gt;
===== Programme sans NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A (en dessous du swich ON/OFF&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B (à gauche du servo A)&lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  delay (2000); // on attend 2s&lt;br /&gt;
} // fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 10 =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche();&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Programme avec NeoPixel Ring =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme de démonstration permet de faire fonctionner le robot équipé d'un Neopixel Ring d'une manière autonome&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Servo.h&amp;gt; // librairie pour servomoteur &lt;br /&gt;
#include &amp;lt;Adafruit_NeoPixel.h&amp;gt; // librairie pour NeoPixel Ring&lt;br /&gt;
&lt;br /&gt;
#define broche_servoA 3 // broche servo A &lt;br /&gt;
#define broche_servoB 5 // broche servo B &lt;br /&gt;
#define trig 2 // broche trig du capteur US HC-SR04&lt;br /&gt;
#define echo 4 // broche echo du capteur US HC-SR04&lt;br /&gt;
#define ring 6 // broche Data du NeoPixel Ring &lt;br /&gt;
&lt;br /&gt;
const int MAX_SENS2=1000; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur&lt;br /&gt;
const int ARRET=1490; // largeur impulsion pour position ANGLE_MEDIANE degrés du servomoteur&lt;br /&gt;
const int MAX_SENS1=2000; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur&lt;br /&gt;
&lt;br /&gt;
// classiquement : centrage sur 1500 - maxi sens 1 = 1000 et maxi sens 2 = 2000&lt;br /&gt;
&lt;br /&gt;
// --- Déclaration des constantes des broches E/S numériques ---&lt;br /&gt;
&lt;br /&gt;
long lecture_echo = 0; // variable sur 4 octets mesure de distance&lt;br /&gt;
long cm = 0; // variable sur 4 octets pour la conversion en cm&lt;br /&gt;
&lt;br /&gt;
//--- Création objet servomoteur &lt;br /&gt;
Servo servoA;  // crée un objet servo pour contrôler le servomoteur A&lt;br /&gt;
Servo servoB;  // crée un objet servo pour contrôler le servomoteur B &lt;br /&gt;
&lt;br /&gt;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, ring, NEO_GRB + NEO_KHZ800); // &lt;br /&gt;
&lt;br /&gt;
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme&lt;br /&gt;
&lt;br /&gt;
void setup()   { // debut de la fonction setup()&lt;br /&gt;
&lt;br /&gt;
// --- ici instructions à exécuter 1 seule fois au démarrage du programme --- &lt;br /&gt;
&lt;br /&gt;
  pinMode (broche_servoA,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (broche_servoB,OUTPUT); // Broche broche_servo configurée en sortie&lt;br /&gt;
  pinMode (trig,OUTPUT); // broche broche trig configurée en sortie&lt;br /&gt;
  digitalWrite(trig, LOW); // met un niveau logique , LOW (BAS) sur la broche trig&lt;br /&gt;
  pinMode(echo, INPUT);  // la broche echo est initialisée en entree&lt;br /&gt;
  Serial.begin(115200);  // initialisation de la liaison série à 115200 bauds&lt;br /&gt;
  strip.begin();&lt;br /&gt;
  strip.show(); // Initialisation du NeoPixel Ring&lt;br /&gt;
  rainbowCycle(10); // LED RING = Arc en ciel&lt;br /&gt;
} &lt;br /&gt;
// fin de la fonction setup()&lt;br /&gt;
// ********************************************************************************&lt;br /&gt;
&lt;br /&gt;
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension&lt;br /&gt;
&lt;br /&gt;
void loop(){ // debut de la fonction loop()&lt;br /&gt;
&lt;br /&gt;
   Avant();&lt;br /&gt;
   digitalWrite(trig, HIGH); // met un niveau logique , HIGH (HAUT) sur la broche trig&lt;br /&gt;
   delayMicroseconds(10); // attente pendant 10 microsecondes&lt;br /&gt;
   digitalWrite(trig, LOW);  // met un niveau logique , LOW (BAS) sur la broche trig.&lt;br /&gt;
   lecture_echo = pulseIn(echo, HIGH); //  lit la durée du niveau HAUT appliqué sur la broche echo&lt;br /&gt;
   cm = lecture_echo / 58; // conversion de la distance en cm&lt;br /&gt;
   Serial.print(&amp;quot;Distance en cm : &amp;quot;); // affiche le message : &amp;quot;Distance en cm&amp;quot; sur le moniteur série&lt;br /&gt;
   Serial.println(cm); // affiche la mesure en cm avec retour à la ligne&lt;br /&gt;
   if (cm &amp;lt; 20) // si mesure &amp;lt; 20 cm =&amp;gt; tourner sens aléatoire&lt;br /&gt;
   {&lt;br /&gt;
     if (millis()%2 == 1)&lt;br /&gt;
     {&lt;br /&gt;
        Droite(); // appel fonction Droite()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
     else&lt;br /&gt;
     {&lt;br /&gt;
        Gauche(); // appel fonction Gauche()&lt;br /&gt;
        delay (1000); &lt;br /&gt;
     }&lt;br /&gt;
   }&lt;br /&gt;
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin&lt;br /&gt;
&lt;br /&gt;
void Stop() {&lt;br /&gt;
  if (servoA.attached()) servoA.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
  if (servoB.attached()) servoB.detach(); // détache le servomoteur de la broche  = arret propre servomoteur&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Avant() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  strip.setPixelColor(14, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(15, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.setPixelColor(0, strip.Color(0,150,0)); // LED verte brillance moyenne.&lt;br /&gt;
  strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Arriere() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
}&lt;br /&gt;
void Gauche() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS1); // crée impulsion - sens2&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS1); // crée impulsion - sens1&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=2;i&amp;lt;5;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Droite() {&lt;br /&gt;
  if (!servoA.attached()) servoA.attach(broche_servoA); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoA.writeMicroseconds(MAX_SENS2); // crée impulsion - sens1&lt;br /&gt;
  if (!servoB.attached()) servoB.attach(broche_servoB); // attache le servomoteur à la broche si pas attaché&lt;br /&gt;
  servoB.writeMicroseconds(MAX_SENS2); // crée impulsion - sens2&lt;br /&gt;
  ringOff(); // appel fonction extinction de toutes les LED&lt;br /&gt;
  for(int i=10;i&amp;lt;13;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(150,0,0)); // LED rouge brillance moyenne.&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ringOff()&lt;br /&gt;
{&lt;br /&gt;
   for(int i=0;i&amp;lt;16;i++){&lt;br /&gt;
    strip.setPixelColor(i, strip.Color(0,0,0)); // Toutes les LED éteintes&lt;br /&gt;
    strip.show(); // Envoi des données vers le Ring.&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void rainbowCycle(uint8_t wait) {&lt;br /&gt;
  uint16_t i, j;&lt;br /&gt;
&lt;br /&gt;
  for(j=0; j&amp;lt;256; j++) { // 1 cycle couleur arc en ciel j&amp;lt;256*n = n cycles couleur arc en ciel&lt;br /&gt;
    for(i=0; i&amp;lt; strip.numPixels(); i++) {&lt;br /&gt;
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) &amp;amp; 255));&lt;br /&gt;
    }&lt;br /&gt;
    strip.show();&lt;br /&gt;
    delay(wait);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
uint32_t Wheel(byte WheelPos) {&lt;br /&gt;
  WheelPos = 255 - WheelPos;&lt;br /&gt;
  if(WheelPos &amp;lt; 85) {&lt;br /&gt;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);&lt;br /&gt;
  } else if(WheelPos &amp;lt; 170) {&lt;br /&gt;
    WheelPos -= 85;&lt;br /&gt;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);&lt;br /&gt;
  } else {&lt;br /&gt;
   WheelPos -= 170;&lt;br /&gt;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== [[Programmation du robot en langage graphique (Blokly)]] ====&lt;br /&gt;
&lt;br /&gt;
Pour programmer le robot en langage graphique, il faut :&lt;br /&gt;
# se connecter sur la page : https://labaixbidouille.github.io/RobotDuLAB-blockly/&lt;br /&gt;
# composer le programme en assemblant les blocs,&lt;br /&gt;
# copier le code produit dans l'IDE arduino, ou cliquer sur le bouton &amp;quot;Générer code&amp;quot;,&lt;br /&gt;
# télécharger (téléverser) le code dans la carte de prototypage arduino.&lt;br /&gt;
&lt;br /&gt;
== [[Téléchargements]] ==&lt;br /&gt;
=== [[Documents de présentation]] ===&lt;br /&gt;
=== [[Pièces imprimables]] ===&lt;br /&gt;
Les pièces imprimables : base, roue, support capteur Ultra-sons et plaque pour support de piles sont téléchargeable sur Thingiverse:&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
http://www.thingiverse.com/thing:833005&lt;br /&gt;
&lt;br /&gt;
=== [[Librairie RboduLAB]] ===&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:RobotDuLAB]]&lt;br /&gt;
[[Catégorie:Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Communication_IR&amp;diff=446</id>
		<title>Communication IR</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Communication_IR&amp;diff=446"/>
				<updated>2016-01-04T14:57:53Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : /* PARTIE EMISSION */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Matériel =====&lt;br /&gt;
* 2 Arduino Uno&lt;br /&gt;
* LED IR émittrice (exemple TSAL 6200)&lt;br /&gt;
* KIT IR Réception (exemple SGK0002)&lt;br /&gt;
* 2 résistances de 190 ohm (+/-)&lt;br /&gt;
* APN avec déclenchement IR (Nikon D80 par exemple)&lt;br /&gt;
&lt;br /&gt;
===== Principe =====&lt;br /&gt;
&lt;br /&gt;
L'arduino couplé avec la LED IR va émettre en direction de l'arduino couplé avec le kit IR.&lt;br /&gt;
Les exemples de code se basent sur la librairie [https://github.com/shirriff/Arduino-IRremote IR REMOTE]&lt;br /&gt;
Cette librairie permet d’émettre et de recevoir via l’infrarouge; elle permet de gérer les protocoles NEC, Sony, Philips RC5/RC6 et le traitement de données brutes.&lt;br /&gt;
La librairie comporte 2 fonctions essentielles, IRsend pour émettre un code et IRrecv pour recevoir un code.&lt;br /&gt;
Article intéressant complémentaire : http://www.righto.com/2009/11/ir-bubbles-controlling-relay-with.html&lt;br /&gt;
&lt;br /&gt;
Il est possible grâce à cette barrière IR de détecter qu'un objet la coupe par exemple et ainsi déclencher une action.&lt;br /&gt;
&lt;br /&gt;
===== Montage =====&lt;br /&gt;
&lt;br /&gt;
====== PARTIE RECEPTION ======&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Recepteur-ir-fritz.jpg|900px]]&lt;br /&gt;
[[Fichier:Recepteur-ir-photo2.jpeg|900px]]&lt;br /&gt;
&lt;br /&gt;
====== PARTIE EMISSION ======&lt;br /&gt;
&lt;br /&gt;
Attention à bien utiliser le PIN 3 PWM &lt;br /&gt;
&lt;br /&gt;
[[Fichier:Emetteur-ir-fritz.jpg|900px]]&lt;br /&gt;
[[Fichier:Emetteur-ir-photo.jpeg|900px]]&lt;br /&gt;
&lt;br /&gt;
===== Programme =====&lt;br /&gt;
&lt;br /&gt;
====== PARTIE RECEPTION ======&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;IRremote.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
int RECV_PIN = 11;&lt;br /&gt;
IRrecv irrecv(RECV_PIN);&lt;br /&gt;
decode_results results;&lt;br /&gt;
&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
  Serial.begin(9600);&lt;br /&gt;
  irrecv.enableIRIn(); // Start the receiver&lt;br /&gt;
}&lt;br /&gt;
void loop() {&lt;br /&gt;
  if (irrecv.decode(&amp;amp;results)) {&lt;br /&gt;
    Serial.println(results.value, HEX);&lt;br /&gt;
    irrecv.resume(); // Receive the next value&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====== PARTIE EMISSION ======&lt;br /&gt;
&lt;br /&gt;
Il est nécessaire d'utiliser le PIN 3 PWM d'après la documentation de la librairie&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;IRremote.h&amp;gt;&lt;br /&gt;
IRsend irsend;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
  Serial.begin(9600);&lt;br /&gt;
}&lt;br /&gt;
void loop() {&lt;br /&gt;
    for (int i = 0; i &amp;lt; 3; i++) {&lt;br /&gt;
      irsend.sendSony(0xa90, 12); // Sony TV power code&lt;br /&gt;
      delay(40);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:Communiquer avec un ordinateur]]&lt;br /&gt;
[[Catégorie:Formation_Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Communication_filaire&amp;diff=445</id>
		<title>Communication filaire</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Communication_filaire&amp;diff=445"/>
				<updated>2016-01-04T14:55:10Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Matériel =====&lt;br /&gt;
* 1 Arduino UNO&lt;br /&gt;
&lt;br /&gt;
===== Principe =====&lt;br /&gt;
&lt;br /&gt;
Le langage Arduino, issu de C/C++, intègre une API très facile à prendre en main pour la communication série.&lt;br /&gt;
Elle contient les fonctions suivantes :&lt;br /&gt;
&lt;br /&gt;
* begin(): Fixe le débit en bits par secondes pour la transmission.&lt;br /&gt;
* end(): désactive la communication série&lt;br /&gt;
* available(): donne le nombre de bytes (caractères) disponible pour la lecture sur le port série.&lt;br /&gt;
* read(): Lit le premier octet disponible sur le port série&lt;br /&gt;
* flush(): Attend que toutes les données sortantes soient complètement envoyées&lt;br /&gt;
* print(): Affiche les données sur le port série&lt;br /&gt;
* println(): Affiche les données sur le port série, suivi d'un retour charriot (ASCII 13, or '\r') et d'une nouvelle ligne (ASCII 10, or '\n')&lt;br /&gt;
* write(): écrit les données sur le port série&lt;br /&gt;
&lt;br /&gt;
Le but de cet atelier est de vous familiariser avec l'échange via une liaison série à l'aide de deux exemples. &lt;br /&gt;
# Le premier cas montre comment communiquer entre un arduino et un langage type Python. Nous pourrons tout aussi bien ouvrir un terminal série.&lt;br /&gt;
# Le second cas présente comment contrôler une arduino de manière plus précise à l'aide d'une grammaire maison.&lt;br /&gt;
===== Programme =====&lt;br /&gt;
&lt;br /&gt;
Nous allons commencer par faire un petit programme echo&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/* une variable pour stocker l'information en provenance du port serie */&lt;br /&gt;
byte byteRead;&lt;br /&gt;
&lt;br /&gt;
void setup() {                &lt;br /&gt;
  Serial.begin(9600);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop() {&lt;br /&gt;
   /*  On teste si de l'information est disponible */&lt;br /&gt;
  if (Serial.available()) {&lt;br /&gt;
    /* On lit l'octet disponible en premier */&lt;br /&gt;
    byteRead = Serial.read();&lt;br /&gt;
    /* On affiche sur le terminal en retour le caractère saisi */&lt;br /&gt;
    Serial.write(byteRead);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On va apporter une petite modification en remplaçant Serial.write(byteRead) par Serial.println(byteRead)&lt;br /&gt;
Désormais ce n'est plus un vrai écho dans le terminal. Le résultat affiché est désormais le code ASCII&lt;br /&gt;
La table de conversion est bien utile pour comprendre les correspondances : http://www.ascii.cl/&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/* une variable pour stocker l'information en provenance du port serie */&lt;br /&gt;
byte byteRead;&lt;br /&gt;
&lt;br /&gt;
void setup() {                &lt;br /&gt;
  Serial.begin(9600);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop() {&lt;br /&gt;
   /*  On teste si de l'information est disponible */&lt;br /&gt;
  if (Serial.available()) {&lt;br /&gt;
    /* On lit l'octet disponible en premier */&lt;br /&gt;
    byteRead = Serial.read();&lt;br /&gt;
    /* On affiche sur le terminal en retour le caractère saisi */&lt;br /&gt;
    Serial.println(byteRead);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Plus compliqué : ce programme ,très poli, vous donne le bonjour et vous invite à lui donner un chiffre.&lt;br /&gt;
Il fera clignoter d'autant plus la mini led intégrée à l'arduino sur le pin 13.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
#define LED_PIN 13&lt;br /&gt;
&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
  pinMode(LED_PIN, OUTPUT);&lt;br /&gt;
  Serial.begin(9600);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop()&lt;br /&gt;
{&lt;br /&gt;
    Serial.println(&amp;quot;Bonjour Sebastien, je suis Sarah le gluon de la LED13. Combien de fois dois je tilter ?&amp;quot;);&lt;br /&gt;
    while(Serial.available()) {&lt;br /&gt;
         int chiffre = Serial.read() -'0';&lt;br /&gt;
        clignote(chiffre);&lt;br /&gt;
    }&lt;br /&gt;
    delay(1000);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void clignote(int chiffre)&lt;br /&gt;
{&lt;br /&gt;
  for (int i = 0; i &amp;lt; chiffre; i++)&lt;br /&gt;
  {&lt;br /&gt;
    digitalWrite(LED_PIN, HIGH);&lt;br /&gt;
    delay(1000);&lt;br /&gt;
    digitalWrite(LED_PIN, LOW);&lt;br /&gt;
    delay(1000);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Passons au montage final : envoyer une séquence dans le terminal pour modifier les couleurs d'une LED RGB&lt;br /&gt;
&lt;br /&gt;
===== Montage =====&lt;br /&gt;
&lt;br /&gt;
Nous reprenons un montage bien connu  :&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Montage_serie_rgb.jpg|600px]]&lt;br /&gt;
&lt;br /&gt;
[[Fichier:LED_RGB_Fritzing.png|sans_cadre|Montage LED RGB|600px]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
int ledR = 6; // broche de la LED Rouge&lt;br /&gt;
int ledG = 5; // broche de la LED Verte&lt;br /&gt;
int ledB = 3; // broche de la LED Bleue&lt;br /&gt;
&lt;br /&gt;
// valeur de l'intensite calculee à partir des infos reçues du port serie&lt;br /&gt;
unsigned int ledCurrent = 0;&lt;br /&gt;
&lt;br /&gt;
// Octet courant lu&lt;br /&gt;
byte byteRead;&lt;br /&gt;
&lt;br /&gt;
int i = 0; // variable de la boucle for&lt;br /&gt;
&lt;br /&gt;
void setup() // setup est déroulé une seule fois après la remise à zéro&lt;br /&gt;
{&lt;br /&gt;
  pinMode(ledR, OUTPUT); // la broche led (3) est initialisee en sortie&lt;br /&gt;
  pinMode(ledG, OUTPUT); // la broche led (5) est initialisee en sortie&lt;br /&gt;
  pinMode(ledB, OUTPUT); // la broche led (6) est initialisee en sortie&lt;br /&gt;
&lt;br /&gt;
  // ouverture du port serie&lt;br /&gt;
  Serial.begin(9600);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop() // loop est déroulee indefiniment&lt;br /&gt;
{&lt;br /&gt;
  if (Serial.available())&lt;br /&gt;
  {&lt;br /&gt;
    byteRead = Serial.read();&lt;br /&gt;
&lt;br /&gt;
    if (byteRead == 'R') {&lt;br /&gt;
      ledCurrent = ledR;&lt;br /&gt;
    } else if (byteRead == 'G') {&lt;br /&gt;
      ledCurrent = ledG;&lt;br /&gt;
    } else if (byteRead == 'B') {&lt;br /&gt;
      ledCurrent = ledB;&lt;br /&gt;
    }&lt;br /&gt;
    else if (byteRead == 'A')&lt;br /&gt;
    {&lt;br /&gt;
      digitalWrite (ledR,LOW);&lt;br /&gt;
      digitalWrite (ledG,LOW);&lt;br /&gt;
      digitalWrite (ledB,LOW);&lt;br /&gt;
      for (i = 0; i &amp;lt;= 255; i++) // i varie de 1 à 255&lt;br /&gt;
      {&lt;br /&gt;
        analogWrite(ledR, i); // génère une impulsion sur la broche de largeur i =&amp;gt; la luminosité R augmente&lt;br /&gt;
        analogWrite(ledG, i); // génère une impulsion sur la broche de largeur i =&amp;gt; la luminosité G augmente&lt;br /&gt;
        analogWrite(ledB, i); // génère une impulsion sur la broche de largeur i =&amp;gt; la luminosité B augmente&lt;br /&gt;
        delay(20); // pause de 20 ms entre chaque pas&lt;br /&gt;
      }&lt;br /&gt;
    }&lt;br /&gt;
    allumer(ledCurrent);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// Prend en parametre la LED à allumer&lt;br /&gt;
void allumer(int led)&lt;br /&gt;
{&lt;br /&gt;
  for (i = 0; i &amp;lt;= 255; i++) // i varie de 1 à 255&lt;br /&gt;
  {&lt;br /&gt;
    analogWrite(led, i); // génère une impulsion sur la broche de largeur i =&amp;gt; la luminosité R augmente&lt;br /&gt;
    delay(20); // pause de 20 ms entre chaque pas&lt;br /&gt;
  }&lt;br /&gt;
  digitalWrite (led, LOW);&lt;br /&gt;
}&lt;br /&gt;
}&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:Communiquer avec un ordinateur]]&lt;br /&gt;
[[Catégorie:Formation_Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Avancer_un_pas_apr%C3%A8s_l%27autre_:_le_moteur_pas_%C3%A0_pas&amp;diff=444</id>
		<title>Avancer un pas après l'autre : le moteur pas à pas</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Avancer_un_pas_apr%C3%A8s_l%27autre_:_le_moteur_pas_%C3%A0_pas&amp;diff=444"/>
				<updated>2016-01-04T14:41:41Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Matériel =====&lt;br /&gt;
* Arduino Uno&lt;br /&gt;
* Plaque d'essai (breadboard)&lt;br /&gt;
* Straps ou fils de liaison&lt;br /&gt;
* 1 moteur à courant continu 5v &lt;br /&gt;
* 1 Arduino Motorshield (http://arduino.cc/en/Main/ArduinoMotorShieldR3)&lt;br /&gt;
&lt;br /&gt;
===== Principe =====&lt;br /&gt;
&lt;br /&gt;
Ce moteur possède quatre fils d’alimentation pour piloter des bobines par paire. Etant donné un schéma vaut mieux qu’un long discours, voici comment il est constitué :&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pap principe.png]]&lt;br /&gt;
&lt;br /&gt;
Vous l’aurez compris, les bobines sont reliées deux à deux en série et sont donc pilotées ensemble. Il n’y a donc finalement que deux enroulements à &lt;br /&gt;
commander puisque deux bobines montées en série n’en font plus qu’une. Leur placement de part et d’autre de l’aimant permanent du rotor permet de piloter &lt;br /&gt;
ce dernier.&lt;br /&gt;
&lt;br /&gt;
Lorsqu’il n’y a aucun courant traversant les bobines, le rotor (où l’axe de sortie est lié) est libre de tourner, rien ne cherche à le retenir &lt;br /&gt;
dans sa course. Maintenant, si nous décidons de faire passer du courant entre les points C et D pour alimenter la bobine de gauche et celle de &lt;br /&gt;
droite, un courant va s’établir et deux champs électromagnétiques vont apparaître de part et d’autres du rotor. Que va-t-il alors se passer ? &lt;br /&gt;
L’aimant du rotor va tourner sur lui même pour se placer de façon à ce que son pôle Nord soit en face du pôle Sud du champ magnétique créé dans la &lt;br /&gt;
première bobine et que son pôle Sud soit en face du pôle Nord créé dans la deuxième bobine.&lt;br /&gt;
Si on alimente non plus les bobines entre C et D mais plutôt entre A et B, le rotor va alors tourner pour s’aligner à nouveau vers &lt;br /&gt;
les pôles qui l’intéressent (Nord/Sud, Sud/Nord).&lt;br /&gt;
Ensuite on recommence, on va alors alimenter de nouveau les bobines entre D et C, donc avec un courant de signe opposé à la fois où elles ont été alimentées &lt;br /&gt;
entre C et D (par exemple C était relié au “+” de l’alimentation tout à l’heure et là on le fait passer au “-”, idem pour D que l’on fait passer du “-” au “+”) &lt;br /&gt;
et le moteur va encore faire un quart de tour. On peut continuer ainsi de suite pour faire tourner le moteur en faisant attention de ne pas se tromper &lt;br /&gt;
dans les phases d’alimentation. A chaque phase, on va donc faire tourner le moteur d’un quart de tour :&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pap phase.png]]&lt;br /&gt;
&lt;br /&gt;
Ce quart de rotation s’appelle un pas. Et comme il faut plusieurs pas pour faire tourner le moteur sur 360°, on l’a donc appelé ainsi, le moteur pas-à-pas.&lt;br /&gt;
&lt;br /&gt;
Dans le cas illustré ci-dessus, on dit que le moteur fait 4 pas par tour. Il existe bien des moteurs qui font ce nombre de pas mais ce ne sont pas les plus fréquents. Généralement le nombre de pas par tour est bien plus conséquent (24, 48, 180,...). La constitution mécanique de leur rotor est plus complexe (le rotor comporte autant d'aimants que de pas par tour), mais le principe de fonctionnement reste identique. On cherche toujours à attirer un aimant grâce à des champs magnétiques crées par des bobines parcourues par un courant.&lt;br /&gt;
&lt;br /&gt;
===== Montage =====&lt;br /&gt;
Le montage consiste simplement à emboîter le shield dans l'arduino et à câbler les deux moteurs dans les borniers à vis étiquetés A et B.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MotorShield R3 Montage.jpg]]&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PaP.jpg]]&lt;br /&gt;
&lt;br /&gt;
===== Programme =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/* &lt;br /&gt;
 Stepper Motor Control with Arduino Motor Control Shield V3.0.&lt;br /&gt;
 */&lt;br /&gt;
const int dirA = 12;&lt;br /&gt;
const int dirB = 13;&lt;br /&gt;
&lt;br /&gt;
const int motA = 3;&lt;br /&gt;
const int motB = 11;&lt;br /&gt;
&lt;br /&gt;
const int brakeA = 9;&lt;br /&gt;
const int brakeB = 8;&lt;br /&gt;
&lt;br /&gt;
const int delayLength = 30;&lt;br /&gt;
&lt;br /&gt;
void setup() {&lt;br /&gt;
  pinMode(dirA, OUTPUT);&lt;br /&gt;
  pinMode(dirB, OUTPUT);&lt;br /&gt;
  pinMode(brakeA, OUTPUT);&lt;br /&gt;
  pinMode(brakeB, OUTPUT);&lt;br /&gt;
  pinMode(motA, OUTPUT);&lt;br /&gt;
  pinMode(motB, OUTPUT);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop() {&lt;br /&gt;
  digitalWrite(brakeA, LOW);&lt;br /&gt;
  digitalWrite(brakeB, HIGH);&lt;br /&gt;
  &lt;br /&gt;
  digitalWrite(dirA, HIGH);&lt;br /&gt;
  digitalWrite(motA, HIGH);&lt;br /&gt;
  &lt;br /&gt;
  delay(delayLength);&lt;br /&gt;
  &lt;br /&gt;
  digitalWrite(brakeA, HIGH);&lt;br /&gt;
  digitalWrite(brakeB, LOW);&lt;br /&gt;
  &lt;br /&gt;
  digitalWrite(dirB, HIGH);&lt;br /&gt;
  digitalWrite(motB, HIGH);&lt;br /&gt;
&lt;br /&gt;
  delay(delayLength);&lt;br /&gt;
  &lt;br /&gt;
  digitalWrite(brakeA, LOW);&lt;br /&gt;
  digitalWrite(brakeB, HIGH);&lt;br /&gt;
  &lt;br /&gt;
  digitalWrite(dirA, LOW);&lt;br /&gt;
  digitalWrite(motA, HIGH);&lt;br /&gt;
  &lt;br /&gt;
  delay(delayLength);&lt;br /&gt;
  &lt;br /&gt;
  digitalWrite(brakeA, HIGH);&lt;br /&gt;
  digitalWrite(brakeB, LOW);&lt;br /&gt;
  &lt;br /&gt;
  digitalWrite(dirB, LOW);&lt;br /&gt;
  digitalWrite(motB, HIGH);&lt;br /&gt;
  &lt;br /&gt;
  delay(delayLength); &lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/* &lt;br /&gt;
 Stepper Motor Control with Arduino Motor Control Shield V3.0.&lt;br /&gt;
&lt;br /&gt;
 This program drives a bipolar stepper motor. The motor is controlled&lt;br /&gt;
 by Arduino pins 10, 11, 12, 13.&lt;br /&gt;
&lt;br /&gt;
 The motor should do five revolutions into one and five into another direction.&lt;br /&gt;
&lt;br /&gt;
 Using this sketch for longer is not recommended because it will keep the motor under current&lt;br /&gt;
 and can cause it to become quite hot.&lt;br /&gt;
&lt;br /&gt;
 */&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;Stepper.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
int enA  = 3;  // Enable pin 1 on Motor Control Shield   &lt;br /&gt;
int enB  = 11;  // Enable pin 2 on Motor Control Shield   &lt;br /&gt;
int dirA = 12;  // Direction pin dirA on Motor Control Shield&lt;br /&gt;
int dirB = 13;  // Direction pin dirB on Motor Control Shield&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
const int stepsPerRevolution = 180;  // Change this to fit the number of steps per revolution&lt;br /&gt;
                                     // for your motor&lt;br /&gt;
&lt;br /&gt;
// Initialize the stepper library on pins 12 and 13:&lt;br /&gt;
Stepper myStepper(stepsPerRevolution, dirA, dirB);            &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void setup() {&lt;br /&gt;
  // set the speed at 60 rpm:&lt;br /&gt;
  myStepper.setSpeed(60);&lt;br /&gt;
&lt;br /&gt;
  // Enable power to the motor&lt;br /&gt;
  pinMode(enA, OUTPUT);&lt;br /&gt;
  digitalWrite (enA, HIGH);&lt;br /&gt;
&lt;br /&gt;
  pinMode(enB, OUTPUT);&lt;br /&gt;
  digitalWrite (enB, HIGH);  &lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop() {&lt;br /&gt;
  // Step five revolutions into one direction:&lt;br /&gt;
  myStepper.step(stepsPerRevolution*5);&lt;br /&gt;
  delay(2000);&lt;br /&gt;
&lt;br /&gt;
  // Step five revolutions in the other direction:&lt;br /&gt;
  myStepper.step(-stepsPerRevolution*5);&lt;br /&gt;
  delay(2000); &lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Catégorie:Les actionneurs physiques]]&lt;br /&gt;
[[Catégorie:Formation_Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Aller_dans_tous_les_sens_:_Pilotage_avanc%C3%A9_d%27un_moteur_%C3%A0_courant_continu_avec_un_pont_en_H&amp;diff=443</id>
		<title>Aller dans tous les sens : Pilotage avancé d'un moteur à courant continu avec un pont en H</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Aller_dans_tous_les_sens_:_Pilotage_avanc%C3%A9_d%27un_moteur_%C3%A0_courant_continu_avec_un_pont_en_H&amp;diff=443"/>
				<updated>2016-01-04T14:04:56Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Matériel =====&lt;br /&gt;
* Arduino Uno&lt;br /&gt;
* Plaque d'essai (breadboard)&lt;br /&gt;
* Straps ou fils de liaison&lt;br /&gt;
* 1 moteur à courant continu 5v &lt;br /&gt;
* 1 Arduino Motorshield (http://arduino.cc/en/Main/ArduinoMotorShieldR3)&lt;br /&gt;
&lt;br /&gt;
===== Principe =====&lt;br /&gt;
Jusqu'à présent nous avons commandé des moteurs à courant continu avec uniquement un seul transistor. Cette &lt;br /&gt;
solution est suffisante tant que l'on n'a pas besoin de changer de sens de rotation. Pour changer de sens de &lt;br /&gt;
rotation, il faut changer la polarité du courant. &lt;br /&gt;
&lt;br /&gt;
Pour réaliser cette tache, il faut utiliser un montage spécial appelé pont en H :&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pont H.png]]&lt;br /&gt;
&lt;br /&gt;
Le pont en H permet de choisir le sens du courant en fonction de l'état des 4 interrupteurs (ils peuvent être remplacés par des transistors) &lt;br /&gt;
qui le composent. Pour comprendre le fonctionnement de ce pont en H (appelé ainsi à cause de sa forme), imaginons que l'on ferme les &lt;br /&gt;
transistors 1 et 4 en laissant ouverts le 2 et le 3. Le courant passe de la gauche vers la droite.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pont H sens 1.png]]&lt;br /&gt;
&lt;br /&gt;
Si en revanche on fait le contraire (2 et 3 fermés et 1 et 4 ouverts), le courant ira dans l’autre sens.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pont H sens 2.png]]&lt;br /&gt;
&lt;br /&gt;
Le pont en H a d'autres configurations valides permettant de gérer le freinage du moteur.&lt;br /&gt;
&lt;br /&gt;
Dans notre cas, nous n'allons pas câbler le pont en H mais nous allons directement utiliser le shield moteur. Ce shield est basé sur &lt;br /&gt;
un L298 qui contient 2 ponts en H permettant de piloter des moteurs demandant une intensité maximale inférieure à 2A.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MotorShield R3 Front 450px.jpg]]&lt;br /&gt;
&lt;br /&gt;
Le câblage du shield est le suivant : &lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|-&lt;br /&gt;
! Fonction !! Canal A !! Canal B&lt;br /&gt;
|-&lt;br /&gt;
| Direction|| Digital 12|| Digital 13&lt;br /&gt;
|-&lt;br /&gt;
| Vitesse (PWM)|| Digital 3|| Digital 11&lt;br /&gt;
|-&lt;br /&gt;
| Frein|| Digital 9|| Digital 8&lt;br /&gt;
|-&lt;br /&gt;
| Intensité|| Analog 0|| Analog 1&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
===== Montage =====&lt;br /&gt;
Le montage du shield revient juste à emboîter le shield dans l'arduino et à câbler les deux moteurs dans les borniers à vis étiquetés A et B.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MotorShield R3 Montage.jpg]]&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Shield moteur bb.png|900px]]&lt;br /&gt;
&lt;br /&gt;
===== Programme =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
const int vitesseMotA=3; // Constante pour la broche 3&lt;br /&gt;
const int sensMotA=12; // Constante pour la broche 12&lt;br /&gt;
const int freinMotA=9; // Constante pour la broche 9&lt;br /&gt;
const int intensiteMotA=A0; // intensité du moteur 0&lt;br /&gt;
&lt;br /&gt;
const int vitesseMotB=11; // Constante pour la broche 11&lt;br /&gt;
const int sensMotB=13; // Constante pour la broche 13&lt;br /&gt;
const int freinMotB=8; // Constante pour la broche 8&lt;br /&gt;
const int intensiteMotB=A1; // intensité du moteur 1&lt;br /&gt;
&lt;br /&gt;
void setup()   {&lt;br /&gt;
    &lt;br /&gt;
    Serial.begin(115200); &lt;br /&gt;
&lt;br /&gt;
    pinMode (vitesseMotA,OUTPUT); // Broche vitesseMotA configurée en sortie&lt;br /&gt;
    pinMode (freinMotA,OUTPUT); // Broche freinMotA configurée en sortie&lt;br /&gt;
    pinMode (vitesseMotB,OUTPUT); // Broche vitesseMotB configurée en sortie&lt;br /&gt;
    pinMode (sensMotA,OUTPUT); // Broche sensMotA configurée en sortie&lt;br /&gt;
    pinMode (sensMotB,OUTPUT); // Broche senMotB configurée en sortie&lt;br /&gt;
    digitalWrite(vitesseMotA,LOW); // a l'arret&lt;br /&gt;
    digitalWrite(sensMotA,LOW); &lt;br /&gt;
    digitalWrite(freinMotA,LOW); // frein off &lt;br /&gt;
&lt;br /&gt;
    digitalWrite(vitesseMotB,LOW); // à l'arret &lt;br /&gt;
    digitalWrite(sensMotB,LOW);  &lt;br /&gt;
    digitalWrite(freinMotB,LOW); // frein off&lt;br /&gt;
&lt;br /&gt;
} &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void loop(){&lt;br /&gt;
    //------ test initial du moteur A ---- &lt;br /&gt;
    //- sens 1&lt;br /&gt;
    digitalWrite(sensMotA,LOW); // sens 1&lt;br /&gt;
    digitalWrite(vitesseMotA, HIGH); // vitesse maximale&lt;br /&gt;
    delay(2000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotA, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    //- sens 2&lt;br /&gt;
    digitalWrite(sensMotA,HIGH); // sens 2&lt;br /&gt;
    digitalWrite(vitesseMotA, HIGH); // vitesse maximale&lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    Serial.println(analogRead(intensiteMotA)); &lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotA, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    &lt;br /&gt;
    //------ test initial du moteur B ---- &lt;br /&gt;
    //- sens 1&lt;br /&gt;
    digitalWrite(sensMotB,LOW); // sens 1&lt;br /&gt;
    digitalWrite(vitesseMotB, HIGH); // vitesse maximale&lt;br /&gt;
    delay(2000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotB, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    //- sens 2&lt;br /&gt;
    digitalWrite(sensMotB,HIGH); // sens 2&lt;br /&gt;
    digitalWrite(vitesseMotB, HIGH); // vitesse maximale&lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    Serial.println(analogRead(intensiteMotB)); &lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotB, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    //---- test vitesse variable moteur A --- &lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotA,i); // PWM croissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotA)); &lt;br /&gt;
    &lt;br /&gt;
    }&lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotA,255-i); // PWM décroissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotA)); &lt;br /&gt;
    }&lt;br /&gt;
    &lt;br /&gt;
    //---- test vitesse variable moteur B --- &lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotB,i); // PWM croissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotB)); &lt;br /&gt;
    &lt;br /&gt;
    }&lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotB,255-i); // PWM décroissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotB)); &lt;br /&gt;
    &lt;br /&gt;
    }&lt;br /&gt;
     &lt;br /&gt;
    while(1); // stop loop&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:Les actionneurs physiques]]&lt;br /&gt;
[[Catégorie:Formation_Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Aller_dans_tous_les_sens_:_Pilotage_avanc%C3%A9_d%27un_moteur_%C3%A0_courant_continu_avec_un_pont_en_H&amp;diff=441</id>
		<title>Aller dans tous les sens : Pilotage avancé d'un moteur à courant continu avec un pont en H</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Aller_dans_tous_les_sens_:_Pilotage_avanc%C3%A9_d%27un_moteur_%C3%A0_courant_continu_avec_un_pont_en_H&amp;diff=441"/>
				<updated>2016-01-04T14:00:52Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Adminsys a déplacé la page Aller dans tous les sens : Pilotage avancé d'un moteurs à courant continu avec un pont en H vers Aller dans tous les sens : Pilotage avancé d'un moteur à courant continu avec un pont en H&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Matériel =====&lt;br /&gt;
* Arduino Uno&lt;br /&gt;
* Plaque d'essai (breadboard)&lt;br /&gt;
* Straps ou fils de liaison&lt;br /&gt;
* 1 moteur à courant continu 5v &lt;br /&gt;
* 1 Arduino Motorshield (http://arduino.cc/en/Main/ArduinoMotorShieldR3)&lt;br /&gt;
&lt;br /&gt;
===== Principe =====&lt;br /&gt;
Jusqu'à présent nous avons commandé des moteurs à courant continu uniquement avec un seul transistor. Cette &lt;br /&gt;
solution est suffisante tant que l'on n'a pas besoin de changer de sens de rotation. Pour changer de sens de &lt;br /&gt;
rotation, il faut changer la polarité du courant. &lt;br /&gt;
&lt;br /&gt;
Pour réaliser cette tache, il faut utiliser un montage spécial appelé pont en H :&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pont H.png]]&lt;br /&gt;
&lt;br /&gt;
Le pont en H permet de choisir le sens du courant en fonction de l'état des 4 interrupteurs (ils peuvent être remplacés par des transistors) &lt;br /&gt;
qui le composent. Pour comprendre le fonctionnement de ce pont en H (appelé ainsi à cause de sa forme), imaginons que l'on ferme les &lt;br /&gt;
transistors 1 et 4 en laissant ouverts le 2 et le 3. Le courant passe de la gauche vers la droite.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pont H sens 1.png]]&lt;br /&gt;
&lt;br /&gt;
Si en revanche on fait le contraire (2 et 3 fermés et 1 et 4 ouverts), le courant ira dans l’autre sens.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pont H sens 2.png]]&lt;br /&gt;
&lt;br /&gt;
Le pont en H a d'autres configurations valides permettant de  gérer le freinage du moteur.&lt;br /&gt;
&lt;br /&gt;
Dans notre cas, nous n'allons pas câbler le pont en H mais nous allons directement utiliser le shield moteur. Ce shield est basé sur &lt;br /&gt;
un L298 qui contient 2 ponts en H permettant de piloter des moteurs demandant une intensité maximale inférieure à 2A.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MotorShield R3 Front 450px.jpg]]&lt;br /&gt;
&lt;br /&gt;
Le câblage du shield est le suivant : &lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|-&lt;br /&gt;
! Fonction !! Canal A !! Canal B&lt;br /&gt;
|-&lt;br /&gt;
| Direction|| Digital 12|| Digital 13&lt;br /&gt;
|-&lt;br /&gt;
| Vitesse (PWM)|| Digital 3|| Digital 11&lt;br /&gt;
|-&lt;br /&gt;
| Frein|| Digital 9|| Digital 8&lt;br /&gt;
|-&lt;br /&gt;
| Intensité|| Analog 0|| Analog 1&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
===== Montage =====&lt;br /&gt;
Le montage du shield revient juste à emboîter le shield dans l'arduino et à câbler les deux moteurs dans les borniers à vis étiquetés A et B.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MotorShield R3 Montage.jpg]]&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Shield moteur bb.png|900px]]&lt;br /&gt;
&lt;br /&gt;
===== Programme =====&lt;br /&gt;
&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
const int vitesseMotA=3; // Constante pour la broche 3&lt;br /&gt;
const int sensMotA=12; // Constante pour la broche 12&lt;br /&gt;
const int freinMotA=9; // Constante pour la broche 9&lt;br /&gt;
const int intensiteMotA=A0; // intensité du moteur 0&lt;br /&gt;
&lt;br /&gt;
const int vitesseMotB=11; // Constante pour la broche 11&lt;br /&gt;
const int sensMotB=13; // Constante pour la broche 13&lt;br /&gt;
const int freinMotB=8; // Constante pour la broche 8&lt;br /&gt;
const int intensiteMotB=A1; // intensité du moteur 1&lt;br /&gt;
&lt;br /&gt;
void setup()   {&lt;br /&gt;
    &lt;br /&gt;
    Serial.begin(115200); &lt;br /&gt;
&lt;br /&gt;
    pinMode (vitesseMotA,OUTPUT); // Broche vitesseMotA configurée en sortie&lt;br /&gt;
    pinMode (freinMotA,OUTPUT); // Broche freinMotA configurée en sortie&lt;br /&gt;
    pinMode (vitesseMotB,OUTPUT); // Broche vitesseMotB configurée en sortie&lt;br /&gt;
    pinMode (sensMotA,OUTPUT); // Broche sensMotA configurée en sortie&lt;br /&gt;
    pinMode (sensMotB,OUTPUT); // Broche senMotB configurée en sortie&lt;br /&gt;
    digitalWrite(vitesseMotA,LOW); // a l'arret&lt;br /&gt;
    digitalWrite(sensMotA,LOW); &lt;br /&gt;
    digitalWrite(freinMotA,LOW); // frein off &lt;br /&gt;
&lt;br /&gt;
    digitalWrite(vitesseMotB,LOW); // à l'arret &lt;br /&gt;
    digitalWrite(sensMotB,LOW);  &lt;br /&gt;
    digitalWrite(freinMotB,LOW); // frein off&lt;br /&gt;
&lt;br /&gt;
} &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void loop(){&lt;br /&gt;
    //------ test initial du moteur A ---- &lt;br /&gt;
    //- sens 1&lt;br /&gt;
    digitalWrite(sensMotA,LOW); // sens 1&lt;br /&gt;
    digitalWrite(vitesseMotA, HIGH); // vitesse maximale&lt;br /&gt;
    delay(2000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotA, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    //- sens 2&lt;br /&gt;
    digitalWrite(sensMotA,HIGH); // sens 2&lt;br /&gt;
    digitalWrite(vitesseMotA, HIGH); // vitesse maximale&lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    Serial.println(analogRead(intensiteMotA)); &lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotA, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    &lt;br /&gt;
    //------ test initial du moteur B ---- &lt;br /&gt;
    //- sens 1&lt;br /&gt;
    digitalWrite(sensMotB,LOW); // sens 1&lt;br /&gt;
    digitalWrite(vitesseMotB, HIGH); // vitesse maximale&lt;br /&gt;
    delay(2000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotB, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    //- sens 2&lt;br /&gt;
    digitalWrite(sensMotB,HIGH); // sens 2&lt;br /&gt;
    digitalWrite(vitesseMotB, HIGH); // vitesse maximale&lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    Serial.println(analogRead(intensiteMotB)); &lt;br /&gt;
    delay(1000); // 2 secondes&lt;br /&gt;
    digitalWrite(vitesseMotB, LOW); // vitesse maximale&lt;br /&gt;
    &lt;br /&gt;
    //---- test vitesse variable moteur A --- &lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotA,i); // PWM croissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotA)); &lt;br /&gt;
    &lt;br /&gt;
    }&lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotA,255-i); // PWM décroissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotA)); &lt;br /&gt;
    }&lt;br /&gt;
    &lt;br /&gt;
    //---- test vitesse variable moteur B --- &lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotB,i); // PWM croissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotB)); &lt;br /&gt;
    &lt;br /&gt;
    }&lt;br /&gt;
    &lt;br /&gt;
    for (int i=0; i&amp;lt;=255; i++) {&lt;br /&gt;
      analogWrite(vitesseMotB,255-i); // PWM décroissant&lt;br /&gt;
      delay(50); // pause&lt;br /&gt;
      Serial.println(analogRead(intensiteMotB)); &lt;br /&gt;
    &lt;br /&gt;
    }&lt;br /&gt;
     &lt;br /&gt;
    while(1); // stop loop&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:Les actionneurs physiques]]&lt;br /&gt;
[[Catégorie:Formation_Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Aller_dans_tous_les_sens_:_Pilotage_avanc%C3%A9_d%27un_moteurs_%C3%A0_courant_continu_avec_un_pont_en_H&amp;diff=442</id>
		<title>Aller dans tous les sens : Pilotage avancé d'un moteurs à courant continu avec un pont en H</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Aller_dans_tous_les_sens_:_Pilotage_avanc%C3%A9_d%27un_moteurs_%C3%A0_courant_continu_avec_un_pont_en_H&amp;diff=442"/>
				<updated>2016-01-04T14:00:52Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Adminsys a déplacé la page Aller dans tous les sens : Pilotage avancé d'un moteurs à courant continu avec un pont en H vers Aller dans tous les sens : Pilotage avancé d'un moteur à courant continu avec un pont en H&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;#REDIRECTION [[Aller dans tous les sens : Pilotage avancé d'un moteur à courant continu avec un pont en H]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Afficher_les_infos_d%27une_carte_SD&amp;diff=440</id>
		<title>Afficher les infos d'une carte SD</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Afficher_les_infos_d%27une_carte_SD&amp;diff=440"/>
				<updated>2016-01-04T13:59:36Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;===== Matériel =====&lt;br /&gt;
* Arduino Uno&lt;br /&gt;
* [http://www.adafruit.com/products/1141 Adafruit Data Logging Shield]&lt;br /&gt;
* Une carte SD formaté en fat32&lt;br /&gt;
&lt;br /&gt;
===== Principe =====&lt;br /&gt;
Avant de pouvoir écrire ou lire une carte SD, il est nécessaire de s'assurer ''a minima'' que la carte fonctionne.&lt;br /&gt;
Si vous voulez écrire et qu'elle est en lecture seule, vous allez au devant de gros problèmes.&lt;br /&gt;
&lt;br /&gt;
===== Programme =====&lt;br /&gt;
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
  Ce programme affiche toutes les informations concernant la carte SD ainsi que son mode READ/WRITE&lt;br /&gt;
*/&lt;br /&gt;
#include &amp;lt;SPI.h&amp;gt;&lt;br /&gt;
#include &amp;lt;SD.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sd2Card card;&lt;br /&gt;
SdVolume volume;&lt;br /&gt;
SdFile root;&lt;br /&gt;
&lt;br /&gt;
// Arduino Ethernet shield: pin 4&lt;br /&gt;
// Adafruit SD shields and modules: pin 10&lt;br /&gt;
// Sparkfun SD shield: pin 8&lt;br /&gt;
const int chipSelect = 4;    &lt;br /&gt;
&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
 // Ouvre le port serie et attend au besoin...&lt;br /&gt;
  Serial.begin(9600);&lt;br /&gt;
   while (!Serial) {&lt;br /&gt;
    ; // wait for serial port to connect. Needed for Leonardo only&lt;br /&gt;
  }&lt;br /&gt;
&lt;br /&gt;
  Serial.print(&amp;quot;\nInitializing SD card...&amp;quot;);&lt;br /&gt;
  pinMode(10, OUTPUT); &lt;br /&gt;
&lt;br /&gt;
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {&lt;br /&gt;
    Serial.println(&amp;quot;initialization failed. Things to check:&amp;quot;);&lt;br /&gt;
    Serial.println(&amp;quot;* is a card is inserted?&amp;quot;);&lt;br /&gt;
    Serial.println(&amp;quot;* Is your wiring correct?&amp;quot;);&lt;br /&gt;
    Serial.println(&amp;quot;* did you change the chipSelect pin to match your shield or module?&amp;quot;);&lt;br /&gt;
    return;&lt;br /&gt;
  } else {&lt;br /&gt;
   Serial.println(&amp;quot;Wiring is correct and a card is present.&amp;quot;); &lt;br /&gt;
  }&lt;br /&gt;
&lt;br /&gt;
  // print the type of card&lt;br /&gt;
  Serial.print(&amp;quot;\nCard type: &amp;quot;);&lt;br /&gt;
  switch(card.type()) {&lt;br /&gt;
    case SD_CARD_TYPE_SD1:&lt;br /&gt;
      Serial.println(&amp;quot;SD1&amp;quot;);&lt;br /&gt;
      break;&lt;br /&gt;
    case SD_CARD_TYPE_SD2:&lt;br /&gt;
      Serial.println(&amp;quot;SD2&amp;quot;);&lt;br /&gt;
      break;&lt;br /&gt;
    case SD_CARD_TYPE_SDHC:&lt;br /&gt;
      Serial.println(&amp;quot;SDHC&amp;quot;);&lt;br /&gt;
      break;&lt;br /&gt;
    default:&lt;br /&gt;
      Serial.println(&amp;quot;Unknown&amp;quot;);&lt;br /&gt;
  }&lt;br /&gt;
&lt;br /&gt;
  // Maintenant on essaie d'ouvrir le volume en fat 16 ou 32&lt;br /&gt;
  if (!volume.init(card)) {&lt;br /&gt;
    Serial.println(&amp;quot;Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card&amp;quot;);&lt;br /&gt;
    return;&lt;br /&gt;
  }&lt;br /&gt;
&lt;br /&gt;
  // On affiche la taille de l'espace&lt;br /&gt;
  uint32_t volumesize;&lt;br /&gt;
  Serial.print(&amp;quot;\nVolume type is FAT&amp;quot;);&lt;br /&gt;
  Serial.println(volume.fatType(), DEC);&lt;br /&gt;
  Serial.println();&lt;br /&gt;
  &lt;br /&gt;
  volumesize = volume.blocksPerCluster();    &lt;br /&gt;
  volumesize *= volume.clusterCount();       &lt;br /&gt;
  volumesize *= 512;                            &lt;br /&gt;
  Serial.print(&amp;quot;Volume size (bytes): &amp;quot;);&lt;br /&gt;
  Serial.println(volumesize);&lt;br /&gt;
  Serial.print(&amp;quot;Volume size (Kbytes): &amp;quot;);&lt;br /&gt;
  volumesize /= 1024;&lt;br /&gt;
  Serial.println(volumesize);&lt;br /&gt;
  Serial.print(&amp;quot;Volume size (Mbytes): &amp;quot;);&lt;br /&gt;
  volumesize /= 1024;&lt;br /&gt;
  Serial.println(volumesize);&lt;br /&gt;
  &lt;br /&gt;
  Serial.println(&amp;quot;\nFichiers trouves sur la carte avec nom, date et taille en bytes: &amp;quot;);&lt;br /&gt;
  root.openRoot(volume);&lt;br /&gt;
 &lt;br /&gt;
  // Liste les fichiers de la carte avec date et taille&lt;br /&gt;
  root.ls(LS_R | LS_DATE | LS_SIZE);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop(void) { &lt;br /&gt;
  // rien à faire&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:Stocker et récupérer des données]]&lt;br /&gt;
[[Catégorie:Formation_Arduino]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Exemple_de_tutoriel&amp;diff=346</id>
		<title>Exemple de tutoriel</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Exemple_de_tutoriel&amp;diff=346"/>
				<updated>2015-12-18T20:48:59Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « &amp;lt;!--    Page pouvant servir d'exemple pour la création d'un tutoriel.    Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet --&amp;gt; Fichier:Logo-f... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&amp;lt;!--&lt;br /&gt;
   Page pouvant servir d'exemple pour la création d'un tutoriel.&lt;br /&gt;
   Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|droite]]&lt;br /&gt;
L'image en vignette, doit permettre de visualiser ce que l'on sera capable de réaliser à la fin du tutoriel. Choisissez la &lt;br /&gt;
avec soin car c'est elle qui donnera envie de se lancer dans votre tutoriel.&lt;br /&gt;
&lt;br /&gt;
== Présentation et objectifs ==&lt;br /&gt;
&lt;br /&gt;
Décrivez en quelques lignes l'intention pédagogique de votre tutoriel. Généralement essayer &lt;br /&gt;
d'avoir un seul objectif principal et moins de 5 objectifs secondaires. Si vous dépassez ces seuils, &lt;br /&gt;
il sera intéressant de découper votre tutoriel.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|Une jolie description d'un croquis exprimant mieux l'intention qu'une longue longue phrase]]&lt;br /&gt;
&lt;br /&gt;
Vous pouvez rajouter dans ce paragraphe des photos des croquis papier que vous avez fait pour mieux visualiser &lt;br /&gt;
ce qu'il y avait à faire.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Pré-requis ==&lt;br /&gt;
Listez les compétence nécessaires à la réalisation. Vous pouvez insérer des [http://labaixbidouille.com/fablab/ liens] vers des tutoriels ailleurs ou sur le [[Bobine_Tesla_Musicale|wiki]].&lt;br /&gt;
&lt;br /&gt;
=== Matériel ===&lt;br /&gt;
&lt;br /&gt;
Décrivez le matériel nécessaire :&lt;br /&gt;
* les composants électroniques&lt;br /&gt;
* la mécanique&lt;br /&gt;
* etc...&lt;br /&gt;
&lt;br /&gt;
=== Logiciels ===&lt;br /&gt;
&lt;br /&gt;
Vous l'aurez deviné, ici on va parler du soft si il y en a :)&lt;br /&gt;
&lt;br /&gt;
== Nom de votre tutoriel ==&lt;br /&gt;
Un résumé rapide du travail à faire (une liste d'item suffit).&lt;br /&gt;
&lt;br /&gt;
=== Première Version :  ===&lt;br /&gt;
==== Etape 1 :  ====&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|Une jolie description]]&lt;br /&gt;
==== Etape 2 :  ====&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|Une jolie description]]&lt;br /&gt;
==== Etape 3 :  ====&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|Une jolie description]]&lt;br /&gt;
&lt;br /&gt;
=== Deuxième Version : ===&lt;br /&gt;
==== Etape 1 :  ====&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|Une jolie description]]&lt;br /&gt;
==== Etape 2 :  ====&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|Une jolie description]]&lt;br /&gt;
==== Etape 3 :  ====&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|Une jolie description]]&lt;br /&gt;
&lt;br /&gt;
=== Conseils ===&lt;br /&gt;
Donnez une liste de conseils correspondant aux difficultés que vous avez rencontré pendant la réalisation du tutoriel.&lt;br /&gt;
&lt;br /&gt;
== Pour aller plus loin ==&lt;br /&gt;
&lt;br /&gt;
Que peut-on faire de plus une fois le tutoriel réalisé ?&lt;br /&gt;
&lt;br /&gt;
== Bibliographie ==&lt;br /&gt;
&lt;br /&gt;
* pourquoi pas&lt;br /&gt;
* une liste&lt;br /&gt;
* de liens&lt;br /&gt;
&lt;br /&gt;
&amp;lt;!--&lt;br /&gt;
  Enfin, vous listez les catégories auquels le projet appartient&lt;br /&gt;
  Il y a au moins la catégorie Projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Category:Tutoriel]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_Tutoriel&amp;diff=345</id>
		<title>Création d'un Tutoriel</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_Tutoriel&amp;diff=345"/>
				<updated>2015-12-18T20:48:38Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « Quelques conseils pour la création d'un nouveau projet == La Création ==  Pour créer une nouvelle page, ajouter un lien dans la liste des :Catégorie:Tutoriel|tutorie... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Quelques conseils pour la création d'un nouveau projet&lt;br /&gt;
== La Création ==&lt;br /&gt;
&lt;br /&gt;
Pour créer une nouvelle page, ajouter un lien dans la liste des [[:Catégorie:Tutoriel|tutoriels]] puis sauver et ensuite cliquer sur le lien ainsi créé.&lt;br /&gt;
&lt;br /&gt;
== Le Contenu ==&lt;br /&gt;
&lt;br /&gt;
Dans une première partie, essayer si possible de présenter l'objectif du tutoriel, ses principes et ses contraintes ainsi que la liste des compétences &lt;br /&gt;
nécessaires.&lt;br /&gt;
Puis essayer de décrire au mieux la réalisation, aussi bien du point de vue Software/Hardware/intégration.&amp;lt;br /&amp;gt;&lt;br /&gt;
Vous pouvez vous baser sur la page [[Exemple de tutoriel]]&lt;br /&gt;
&lt;br /&gt;
== Les pièces jointes ==&lt;br /&gt;
Pour importer un document, il faut éditer le paragraphe, drag and drop du fichier puis créer un lien vers celui-ci et finir par sauvegarder la page.&lt;br /&gt;
Il faut définir toutes les extensions autorisées, n’hésitez donc pas, le cas échéant, à faire une demande d'ajout dans la partie discussion de cette page.&lt;br /&gt;
&lt;br /&gt;
== Les Catégories ==&lt;br /&gt;
&lt;br /&gt;
La liste des catégories est [[:Special:Catégories|disponible ici]].&lt;br /&gt;
Au besoin, n'hésitez pas à en ajouter.&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
Ajouter la/les catégories désirées en ajoutant la/les lignes suivante au bas de la page du projet : &amp;lt;nowiki&amp;gt;[[Category:Nom2LaCategorie]]&amp;lt;/nowiki&amp;gt;.&amp;lt;br/&amp;gt;&lt;br /&gt;
N'oubliez pas d'ajouter la catégorie Projet avec cette ligne :&lt;br /&gt;
 &amp;lt;nowiki&amp;gt;[[Category:Tutoriel]]&amp;lt;/nowiki&amp;gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Exemple_de_projet&amp;diff=344</id>
		<title>Exemple de projet</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Exemple_de_projet&amp;diff=344"/>
				<updated>2015-12-18T20:47:51Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « &amp;lt;!--    Page pouvant servir d'exemple pour la création d'un projet.    Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet --&amp;gt; Fichier:Logo-fab... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&amp;lt;!--&lt;br /&gt;
   Page pouvant servir d'exemple pour la création d'un projet.&lt;br /&gt;
   Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Fichier:Logo-fablab.png|vignette|droite]]&lt;br /&gt;
&lt;br /&gt;
== Présentation ==&lt;br /&gt;
&lt;br /&gt;
Décrivez en quelques lignes les tenants et aboutissants de votre projet.&lt;br /&gt;
&lt;br /&gt;
Vous pouvez insérer des [http://labaixbidouille.com/fablab/ liens] vers projets équivalents ailleurs ou sur le [[Bobine_Tesla_Musicale|wiki]]&lt;br /&gt;
&lt;br /&gt;
== Matériel ==&lt;br /&gt;
&lt;br /&gt;
Décrivez le matériel nécessaire :&lt;br /&gt;
* les composants électroniques&lt;br /&gt;
* la mécanique&lt;br /&gt;
* etc...&lt;br /&gt;
&lt;br /&gt;
== Logiciels ==&lt;br /&gt;
&lt;br /&gt;
Vous l'aurez deviné, ici on va parler du soft si il y en a :)&lt;br /&gt;
&lt;br /&gt;
=== Architecture ===&lt;br /&gt;
&lt;br /&gt;
=== Languages ===&lt;br /&gt;
&lt;br /&gt;
== Évolutions possibles ==&lt;br /&gt;
&lt;br /&gt;
Que peut-on faire de plus une fois la 1ère version réalisée ?&lt;br /&gt;
&lt;br /&gt;
== Bilbiographie ==&lt;br /&gt;
&lt;br /&gt;
* pourquoi pas&lt;br /&gt;
* une liste&lt;br /&gt;
* de liens&lt;br /&gt;
&lt;br /&gt;
&amp;lt;!--&lt;br /&gt;
  Enfin, vous listez les catégories auquels le projet appartient&lt;br /&gt;
  Il y a au moins la catégorie Projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Category:Projet]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_Projet&amp;diff=343</id>
		<title>Création d'un Projet</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_Projet&amp;diff=343"/>
				<updated>2015-12-18T20:47:27Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « Quelques conseils pour la création d'un nouveau projet == La Création ==  Pour créer une nouvelle page, ajouter un lien dans la liste des projets... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Quelques conseils pour la création d'un nouveau projet&lt;br /&gt;
== La Création ==&lt;br /&gt;
&lt;br /&gt;
Pour créer une nouvelle page, ajouter un lien dans la liste des [[:Catégorie:Projet|projets]] puis sauver et ensuite cliquer sur le lien ainsi créé.&lt;br /&gt;
&lt;br /&gt;
== Le Contenu ==&lt;br /&gt;
&lt;br /&gt;
Dans une première partie, essayer si possible de présenter l'objectif du projet, ses principes et ses contraintes ainsi que la liste des compétences &lt;br /&gt;
nécessaires et, le cas échéant, l'équipe associée.&lt;br /&gt;
Puis essayer de décrire au mieux la réalisation, aussi bien du point de vue Software/Hardware/intégration.&amp;lt;br /&amp;gt;&lt;br /&gt;
Vous pouvez vous baser sur la page [[Exemple de projet]]&lt;br /&gt;
&lt;br /&gt;
== Les pièces jointes ==&lt;br /&gt;
Pour importer un document, il faut éditer le paragraphe, drag and drop du fichier puis créer un lien vers celui-ci et finir par sauvegarder la page.&lt;br /&gt;
Il faut définir toutes les extensions autorisées, n’hésitez donc pas, le cas échéant, à faire une demande d'ajout dans la partie discussion de cette page.&lt;br /&gt;
&lt;br /&gt;
== Les Catégories ==&lt;br /&gt;
&lt;br /&gt;
La liste des catégories est [[:Special:Catégories|disponible ici]].&lt;br /&gt;
Au besoin, n'hésitez pas à en ajouter.&lt;br /&gt;
&amp;lt;br /&amp;gt;&lt;br /&gt;
Ajouter la/les catégories désirées en ajoutant la/les lignes suivante au bas de la page du projet : &amp;lt;nowiki&amp;gt;[[Category:Nom2LaCategorie]]&amp;lt;/nowiki&amp;gt;.&amp;lt;br/&amp;gt;&lt;br /&gt;
N'oubliez pas d'ajouter la catégorie Projet avec cette ligne :&lt;br /&gt;
 &amp;lt;nowiki&amp;gt;[[Category:Projet]]&amp;lt;/nowiki&amp;gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Accueil&amp;diff=341</id>
		<title>Accueil</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Accueil&amp;diff=341"/>
				<updated>2015-12-15T12:30:24Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : A protégé « Accueil » : Page à fort trafic ([Modifier=Autoriser uniquement les administrateurs] (infini) [Renommer=Autoriser uniquement les administrateurs] (infini))&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;L'objectif de ce wiki est de constituer la mémoire des différents projets réalisés au sein des espaces de Fabrication numérique du [http://fablab-provence.com/ Fab Lab Provence].&lt;br /&gt;
Chaque projet réalisé au sein du [http://labaixbidouille.com/fablab/ L.A.B] bénéficiera d'une page dédiée.&lt;br /&gt;
&lt;br /&gt;
En plus de constituer un corpus de documentation, ce wiki se veut aussi un espace de partage de ressources et de bonnes idées. Il peut tout &lt;br /&gt;
autant servir à organiser la vie de chaque lieu qu'à préparer un article à publier sur nos différents blogs.&lt;br /&gt;
&lt;br /&gt;
Cet espace est donc à la libre disposition de la communauté et tous les membres peuvent le hacké/détourner pour l'adapter à vos besoins.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;center&amp;gt;&lt;br /&gt;
&amp;lt;gallery widths=&amp;quot;300px&amp;quot; heights=&amp;quot;200px&amp;quot; perrow=&amp;quot;3&amp;quot;&amp;gt;&lt;br /&gt;
File:local.jpg&lt;br /&gt;
File:amphi.jpg&lt;br /&gt;
File:geekbidouille.jpg&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&amp;lt;/center&amp;gt;&lt;br /&gt;
= [[:Category:LAB|L'association L.A.B]] =&lt;br /&gt;
{{:Category:LAB}}&lt;br /&gt;
&lt;br /&gt;
=[[:Category:Projet|Projets]]=&lt;br /&gt;
{{Catégorie:Projet}}&lt;br /&gt;
&lt;br /&gt;
=[[:Category:Tutoriel|Tutoriels]]=&lt;br /&gt;
&amp;lt;!-- inclusion de pages qui ne sont pas des projets mais plutôt des how-to de choses qui serviront sur plusieurs projets --&amp;gt;&lt;br /&gt;
{{Catégorie:Tutoriel}}&lt;br /&gt;
&lt;br /&gt;
=[[:Category:Formations|Ateliers et Formations]]=&lt;br /&gt;
{{Catégorie:Formations}}&lt;br /&gt;
&lt;br /&gt;
== Sponsors, Donateurs et Soutiens ==&lt;br /&gt;
Notre salle actuelle est mise à disposition par le département informatique de [http://iut.univ-amu.fr/ l'IUT d'Aix-Marseille]. &lt;br /&gt;
L'équipement du local est possible notamment grâce à une politique volontariste de la [http://www.agglo-paysdaix.fr/ Communauté d’Agglomération du Pays d'Aix] &lt;br /&gt;
envers les acteurs de l'innovation numérique.&lt;br /&gt;
 &lt;br /&gt;
Nous remercions les sociétés suivantes pour leur don d'équipements :&lt;br /&gt;
* [http://www.atmel.com/ Atmel] (carte SAM4S Xplain et kit wireless)&lt;br /&gt;
* [http://www.st.com STMicroelectronics] (cartes [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF250863 STM32 Discovery] et [[http://labaixbidouille.com/fablab/soiree-geekbidouille-stmicroelectronique-presentera-le-tout-nouveau-stm32-nucleo/ STM32 Nucléo]])&lt;br /&gt;
* [http://www.groupe-sii.com/fr SII] (3 Ordinateurs du LAB)&lt;br /&gt;
* L'Agence Française de Sécurité (Don d'un stock de composants électroniques)&lt;br /&gt;
* La Société [http://www.setdidact.com/ SET (Système Etude Technique)] (Composants électroniques et connectique)&lt;br /&gt;
N'hésitez à nous contacter si vous souhaitez nous soutenir.&lt;br /&gt;
&lt;br /&gt;
__NOTOC__&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Informations_pratiques&amp;diff=340</id>
		<title>Informations pratiques</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Informations_pratiques&amp;diff=340"/>
				<updated>2015-12-15T12:28:59Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « =Contact=  &amp;lt;contact@labaixbidouille.com&amp;gt;  Retrouvez-nous sur les plateformes sociales suivantes :  * [https://twitter.com/LabAixBidouille Sur Twitter] * [https://www.faceb... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=Contact=&lt;br /&gt;
&lt;br /&gt;
&amp;lt;contact@labaixbidouille.com&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Retrouvez-nous sur les plateformes sociales suivantes : &lt;br /&gt;
* [https://twitter.com/LabAixBidouille Sur Twitter]&lt;br /&gt;
* [https://www.facebook.com/LabAixBidouille Sur Facebook]&lt;br /&gt;
* [http://www.meetup.com/Labaixbidouille/ Sur Meetup]&lt;br /&gt;
* [https://github.com/LabAixBidouille/ Sur Github]&lt;br /&gt;
* [https://groups.google.com/forum/?hl=fr&amp;amp;fromgroups#!forum/lab-aix Sur Google groups]&lt;br /&gt;
&lt;br /&gt;
L.A.B&amp;lt;br /&amp;gt;&lt;br /&gt;
IUT d’Aix-en-Provence &amp;lt;br /&amp;gt;&lt;br /&gt;
431 Avenue Gaston Berger &amp;lt;br /&amp;gt;&lt;br /&gt;
13625 Aix-en-Provence cedex 1 &amp;lt;br /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[http://labaixbidouille.com/fablab/contact/|Comment venir ?]]&lt;br /&gt;
&lt;br /&gt;
=Horaires d'ouverture=&lt;br /&gt;
&lt;br /&gt;
Tous les Mardi et mercredi de 17h30 à 20h pour les Open Workshop.&lt;br /&gt;
&lt;br /&gt;
L'avant dernier vendredi du mois à partir de 19h pour la soirée geekbidouille.&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_(Arnaud)&amp;diff=339</id>
		<title>Création d'un cube troué avec FreeCAD (Arnaud)</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_(Arnaud)&amp;diff=339"/>
				<updated>2015-12-15T12:24:47Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;[[Fichier:cube-troue.png|vignette|droite]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Présentation et objectifs ==&lt;br /&gt;
&lt;br /&gt;
Il s'agit de créer un modèle 3D d'un cube troué avec OpenSCAD.&lt;br /&gt;
On va d'abord créer un polygone 2D (cadre d'un carré) puis lui appliquer une extrusion linéaire. On crée également les 2 cylindres qui vont ensuite être soustrait à la forme du cadre extrudé.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:cube-troue.png|vignette|objet 3D final]]&lt;br /&gt;
&lt;br /&gt;
== Pré-requis ==&lt;br /&gt;
Il faut avoir déjà pratiquer les 3 tutoriaux précédents.&lt;br /&gt;
&lt;br /&gt;
=== Matériel ===&lt;br /&gt;
&lt;br /&gt;
Un ordinateur&lt;br /&gt;
&lt;br /&gt;
=== Logiciels ===&lt;br /&gt;
&lt;br /&gt;
FreeCAD&lt;br /&gt;
&lt;br /&gt;
== Nom de votre tutoriel ==&lt;br /&gt;
Réalisation d'un cube troué&lt;br /&gt;
&lt;br /&gt;
=== Première Version :  ===&lt;br /&gt;
==== Etape 1 :  ====&lt;br /&gt;
On crée d'abord le polygone qui sera extrudé&lt;br /&gt;
Pour celà, on crée une esquisse (Taches -&amp;gt; Créer une esquisse) que l'on oriente sur le plan XY.&lt;br /&gt;
On crée successivement 2 carré avec l'outil &amp;quot;créer un rectangle dans l'esquisse&amp;quot;.&lt;br /&gt;
On sélectionne 2 cotés perpendiculaires du premier carré et on applique la contrainte d'égalité entre 2 lignes (signe =). On fixe la longueur du carré en sélectionnant un côté et en appliquant une contrainte de longueur de ligne (double flèche).&lt;br /&gt;
On fait de même avec le 2eme rectangle.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:freecad-etape01.png|vignette|polygone de départ]]&lt;br /&gt;
==== Etape 2 :  ====&lt;br /&gt;
Il faut ensuite une extrusion linéaire sur le cadre précédemment créé.&lt;br /&gt;
Pour cela il faut fermer l'esquisse, sélectionner la forme (sketch) et appliquer une protusion.&lt;br /&gt;
[[Fichier:cadre-extrude.png|vignette|Cadre extrudé]]&lt;br /&gt;
==== Etape 3 :  ====&lt;br /&gt;
On ajoute 2 cylindres perpendiculaires en utilisant les fonctions translete, rotation et cylinder&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;C&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
linear_extrude(10) {&lt;br /&gt;
   polygon(&lt;br /&gt;
	points=[[0,0],[0,10],[10,10],[10,0],[1,1],[1,9],[9,9],[9,1]],&lt;br /&gt;
	paths=[[0,1,2,3],[4,5,6,7]]&lt;br /&gt;
	);&lt;br /&gt;
}&lt;br /&gt;
translate([-1,5,5])&lt;br /&gt;
   rotate([0,90,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
translate([5,-1,5])&lt;br /&gt;
   rotate([-90,0,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:cube-avant-difference.png|vignette|cube avec les cylindres à soustraire à la forme]]&lt;br /&gt;
==== Etape 4 :  ====&lt;br /&gt;
On soustrait les 2 cylindres du cadre extrudé pour obtenir l'objet final.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;C&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
difference(){linear_extrude(10) {&lt;br /&gt;
   polygon(&lt;br /&gt;
	points=[[0,0],[0,10],[10,10],[10,0],[1,1],[1,9],[9,9],[9,1]],&lt;br /&gt;
	paths=[[0,1,2,3],[4,5,6,7]]&lt;br /&gt;
	);&lt;br /&gt;
}&lt;br /&gt;
translate([-1,5,5])&lt;br /&gt;
   rotate([0,90,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
translate([5,-1,5])&lt;br /&gt;
   rotate([-90,0,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:cube-troue.png|vignette|cube avec les cylindres à soustraire à la forme]]&lt;br /&gt;
&lt;br /&gt;
=== Conseils ===&lt;br /&gt;
Il est important de se représenter les différentes étapes de construction de l'objet à partir de formes simples et de les ordonner correctement.&lt;br /&gt;
&lt;br /&gt;
== Pour aller plus loin ==&lt;br /&gt;
&lt;br /&gt;
On peut utiliser des variables pour pouvoir réutiliser ce code et créer des objets personnalisés de même type.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;!--&lt;br /&gt;
  Enfin, vous listez les catégories auquels le projet appartient&lt;br /&gt;
  Il y a au moins la catégorie Projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Category:Tutoriel]]&lt;br /&gt;
[[Category:FreeCAD]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_Fran%C3%A7ois&amp;diff=338</id>
		<title>Création d'un cube troué avec FreeCAD François</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_Fran%C3%A7ois&amp;diff=338"/>
				<updated>2015-12-15T12:24:38Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&amp;lt;!--&lt;br /&gt;
   Page pouvant servir d'exemple pour la création d'un tutoriel.&lt;br /&gt;
   Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Fichier:Cubefreecad.jpg|vignette|droite]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Création d'un cube troué ==&lt;br /&gt;
Ici nous allons concevoir un cube percé de part en part en utilisant le logiciel Freecad. De forme, certes, basique, ce cube va nous permettre d'utiliser quelques primitives. &lt;br /&gt;
&lt;br /&gt;
== Pré-requis ==&lt;br /&gt;
Il est préférable d'avoir bien pris en main l'interface du logiciel et d'avoir déjà créé quelques formes basiques avant d'aborder cet exercice. &lt;br /&gt;
&lt;br /&gt;
=== Le procédé  ===&lt;br /&gt;
==== Etape 1 :  ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Esquisse.jpg]]&lt;br /&gt;
&lt;br /&gt;
Dans l'onglet &amp;quot;Tâches&amp;quot; de la fenêtre &amp;quot;Vue combinée&amp;quot; cliquez sur &amp;quot;Créer une esquisse&amp;quot;. Une fenêtre vous propose de choisir le plan sur lequel vous voulez créer votre esquisse (XY, XZ, YZ)... peut importe pour l'instant, cliquez sur OK&amp;quot; &lt;br /&gt;
&lt;br /&gt;
==== Etape 2 :  ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Esquisse rectangle.jpg]]&lt;br /&gt;
&lt;br /&gt;
Dans la barre d'outils &amp;quot;Géométries d'esquisse&amp;quot; cliquez sur &amp;quot;Créer un rectangle dans l'esquisse&amp;quot;. Une fois le rectangle créé sélectionnez une arête du rectangle (verticale ou horizontale) en cliquant dessus (elle s'affiche alors en vert) et dans la même barre d'outils cliquez sur &amp;quot;Fixer la distance horizontale entre deux points ou extrémités de ligne&amp;quot; (ou &amp;quot;verticale&amp;quot; en fonction de l'arête sélectionnée). Rentrez la valeur désirée dans la fenêtre qui s'affiche (attention à l'unité de mesure) appuyez sur entrée (ou cliquez sur OK).          &lt;br /&gt;
&lt;br /&gt;
[[Fichier:Taille rectangle.jpg]]&lt;br /&gt;
&lt;br /&gt;
Sélectionnez une arête perpendiculaire à celle que vous avez déjà fixée puis, toujours dans la même barre d'outils, cliquez sur &amp;quot;Créer une contrainte d'égalité entre deux lignes ou entre des cercles et/ou des arcs&amp;quot;. Vous avez maintenant un carré. Si vous voulez le centré sur les axes de repérage, sélectionnez   &lt;br /&gt;
&lt;br /&gt;
==== Etape 3 :  ====&lt;br /&gt;
&lt;br /&gt;
Congratulations, l'objet est fini.&lt;br /&gt;
Récapitulatif, pour atteindre ce résultat, il faut taper:&lt;br /&gt;
&lt;br /&gt;
difference () {&lt;br /&gt;
cube(20, true);&lt;br /&gt;
cube ([18, 18, 25], center=true);&lt;br /&gt;
rotate ([90,0,0]) cylinder (h = 25, r=6, center = true, $fn=100);&lt;br /&gt;
rotate ([0,90,0]) cylinder (h = 25, r=6, center = true, $fn=100);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Cubex.png]]&lt;br /&gt;
&lt;br /&gt;
[[Category:Tutoriel]]&lt;br /&gt;
[[Category:FreeCAD]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Modelisation3D&amp;diff=337</id>
		<title>Catégorie:Modelisation3D</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Modelisation3D&amp;diff=337"/>
				<updated>2015-12-15T12:22:45Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Annulation des modifications 336 de Adminsys (discussion)&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Liste des tutoriels d'apprentissage de la modélisation 3D&lt;br /&gt;
===[[:Category:SketchUp|Modélisation 3D avec SketchUp]]===&lt;br /&gt;
SketchUp est un logiciel de modélisation 3D orienté vers l'architecture. Initialement édité par la société @Last Software (racheté par Google ensuite), ce logiciel se caractérise par des outils simples (rotation, extrusion, déplacement, etc.), qui en font un logiciel de 3D très différent des modeleurs 3D classiques. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:Imageintro.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec SketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec SketchUp]]&lt;br /&gt;
Fichier:Capture decran cube rose.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué (Audrey) avec SketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué (Audrey) avec SketchUp]]&lt;br /&gt;
Fichier:Cube Final.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Creation d'un cube a trous avec sketchUp]]&amp;lt;/div&amp;gt;|link=[[Creation d'un cube a trous avec sketchUp]]&lt;br /&gt;
Fichier:Coeur termine.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cœur pour pendentif avec sketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cœur pour pendentif avec sketchUp]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===[[:Category:OpenSCAD|Modélisation 3D avec OpenSCAD]]===&lt;br /&gt;
[http://www.openscad.org/index.html OpenSCAD] est un logiciel de modélisation 3D paramétrique. C'est un logiciel libre qui fonctionne à la fois sous Linux, Mac OS et Windows. Le projet a débuté en février 2010 et évolue progressivement d'année en année. &lt;br /&gt;
&lt;br /&gt;
Prochainement, grâce au travail de [http://shainasabarwal.wordpress.com/2014/08/03/gsoc-project-ui-brushup-of-openscad/ Shaina Sabarwal] fait dans le cadre des [https://www.google-melange.com/gsoc/homepage/google/gsoc2014 Google Summer of Code], l'interface du logiciel sera grandement amélioré. Espérons que cette nouvelle version ne tardera pas à sortir car elle changera fondamentalement l'expérience utilisateur.&lt;br /&gt;
&lt;br /&gt;
OpenSCAD a pour particularité de fonctionner de façon entièrement paramétrique, c'est-à-dire que la conception passe par la rédaction d'un script dans une sous-fenêtre située à gauche, tandis qu'une sous-fenêtre à droite permet juste de visualiser l'objet en 3D après une étape de rendu. Même s'il peut paraitre rudimentaire au premier abord, il permet de réaliser des modèles complexes si l'on structure bien son script. Il est utilisé par [http://www.thingiverse.com/ thingiverse] pour les [http://www.thingiverse.com/apps/customizer modèles 3D personnalisables].&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:intro_openSCAD.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Premier pas avec OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Premier pas avec OpenSCAD]]&lt;br /&gt;
Fichier:Sapin_OpenSCAD.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des primitives de dessin 2D d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des primitives de dessin 2D d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo equerre.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des primitives de dessin 3D d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des primitives de dessin 3D d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo_union.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des opération de transformation géométrique d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des opération de transformation géométrique d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo_union.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué]]&amp;lt;/div&amp;gt;|link=[[Création cube troué]]&lt;br /&gt;
Fichier:cube-troue.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué (Arnaud)]]&amp;lt;/div&amp;gt;|link=[[Création cube troué (Arnaud)]]&lt;br /&gt;
Fichier:Cubex.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué (Raphaël)]]&amp;lt;/div&amp;gt;|link=[[Création cube troué (Raphaël)]]&lt;br /&gt;
Fichier:De.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Creation d'un dé]]&amp;lt;/div&amp;gt;|link=[[Creation d'un dé]]&lt;br /&gt;
Fichier:De.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Premier pas]]&amp;lt;/div&amp;gt;|link=[[Premier pas]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===[[:Category:FreeCAD|Modélisation 3D avec FreeCAD]]===&lt;br /&gt;
[http://www.freecadweb.org/index-fr.html FreeCAD] est un logiciel à conception paramétrique proposant des outils similaires à CATIA, SolidWorks et Solid Edge. Il est doté d'une architecture modulaire, qui permet l'ajout de nouvelles fonctionnalités très simplement, sans devoir modifier le noyau de l'application.&lt;br /&gt;
&lt;br /&gt;
FreeCAD est basé sur Open CASCADE, un puissant noyau géométrique. Il dispose d'un modèle de représentation des scènes 3D conforme au format Open Inventor et fourni par la bibliothèque logicielle Coin 3D, ainsi qu'une vaste interface de programmation Python. L'interface graphique est basée sur Qt. FreeCAD fonctionne donc de façon quasi identique sur les plateformes Windows, Mac OS X et Linux.&lt;br /&gt;
&lt;br /&gt;
De nombreuses fonctionnalités accessibles via le code Python n'ont pas été implémentées via l'IHM graphique. Ceci rend ce programme difficile d'accès à ses utilisateurs potentiels (design mécanique) qui n'ont pas de formation programmation.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:Cubefreecad.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec FreeCAD François]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec FreeCAD François]]&lt;br /&gt;
Fichier:Cube-troue.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec FreeCAD (Arnaud)]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec FreeCAD (Arnaud)]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Category:Tutoriel]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Modelisation3D&amp;diff=336</id>
		<title>Catégorie:Modelisation3D</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Modelisation3D&amp;diff=336"/>
				<updated>2015-12-15T12:22:15Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Liste des tutoriels d'apprentissage de la modélisation 3D&lt;br /&gt;
===[[:Category:SketchUp|Modélisation 3D avec SketchUp]]===&lt;br /&gt;
SketchUp est un logiciel de modélisation 3D orienté vers l'architecture. Initialement édité par la société @Last Software (racheté par Google ensuite), ce logiciel se caractérise par des outils simples (rotation, extrusion, déplacement, etc.), qui en font un logiciel de 3D très différent des modeleurs 3D classiques. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:Imageintro.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec SketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec SketchUp]]&lt;br /&gt;
Fichier:Capture decran cube rose.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué (Audrey) avec SketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué (Audrey) avec SketchUp]]&lt;br /&gt;
Fichier:Cube Final.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Creation d'un cube a trous avec sketchUp]]&amp;lt;/div&amp;gt;|link=[[Creation d'un cube a trous avec sketchUp]]&lt;br /&gt;
Fichier:Coeur termine.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cœur pour pendentif avec sketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cœur pour pendentif avec sketchUp]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===[[:Category:OpenSCAD|Modélisation 3D avec OpenSCAD]]===&lt;br /&gt;
[http://www.openscad.org/index.html OpenSCAD] est un logiciel de modélisation 3D paramétrique. C'est un logiciel libre qui fonctionne à la fois sous Linux, Mac OS et Windows. Le projet a débuté en février 2010 et évolue progressivement d'année en année. &lt;br /&gt;
&lt;br /&gt;
Prochainement, grâce au travail de [http://shainasabarwal.wordpress.com/2014/08/03/gsoc-project-ui-brushup-of-openscad/ Shaina Sabarwal] fait dans le cadre des [https://www.google-melange.com/gsoc/homepage/google/gsoc2014 Google Summer of Code], l'interface du logiciel sera grandement amélioré. Espérons que cette nouvelle version ne tardera pas à sortir car elle changera fondamentalement l'expérience utilisateur.&lt;br /&gt;
&lt;br /&gt;
OpenSCAD a pour particularité de fonctionner de façon entièrement paramétrique, c'est-à-dire que la conception passe par la rédaction d'un script dans une sous-fenêtre située à gauche, tandis qu'une sous-fenêtre à droite permet juste de visualiser l'objet en 3D après une étape de rendu. Même s'il peut paraitre rudimentaire au premier abord, il permet de réaliser des modèles complexes si l'on structure bien son script. Il est utilisé par [http://www.thingiverse.com/ thingiverse] pour les [http://www.thingiverse.com/apps/customizer modèles 3D personnalisables].&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:intro_openSCAD.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Premier pas avec OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Premier pas avec OpenSCAD]]&lt;br /&gt;
Fichier:Sapin_OpenSCAD.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des primitives de dessin 2D d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des primitives de dessin 2D d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo equerre.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des primitives de dessin 3D d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des primitives de dessin 3D d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo_union.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des opération de transformation géométrique d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des opération de transformation géométrique d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo_union.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué]]&amp;lt;/div&amp;gt;|link=[[Création cube troué]]&lt;br /&gt;
Fichier:cube-troue.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué (Arnaud)]]&amp;lt;/div&amp;gt;|link=[[Création cube troué (Arnaud)]]&lt;br /&gt;
Fichier:Cubex.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué (Raphaël)]]&amp;lt;/div&amp;gt;|link=[[Création cube troué (Raphaël)]]&lt;br /&gt;
Fichier:De.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Creation d'un dé]]&amp;lt;/div&amp;gt;|link=[[Creation d'un dé]]&lt;br /&gt;
Fichier:De.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Premier pas]]&amp;lt;/div&amp;gt;|link=[[Premier pas]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===[[:Category:FreeCAD|Modélisation 3D avec FreeCAD]]===&lt;br /&gt;
[http://www.freecadweb.org/index-fr.html FreeCAD] est un logiciel à conception paramétrique proposant des outils similaires à CATIA, SolidWorks et Solid Edge. Il est doté d'une architecture modulaire, qui permet l'ajout de nouvelles fonctionnalités très simplement, sans devoir modifier le noyau de l'application.&lt;br /&gt;
&lt;br /&gt;
FreeCAD est basé sur Open CASCADE, un puissant noyau géométrique. Il dispose d'un modèle de représentation des scènes 3D conforme au format Open Inventor et fourni par la bibliothèque logicielle Coin 3D, ainsi qu'une vaste interface de programmation Python. L'interface graphique est basée sur Qt. FreeCAD fonctionne donc de façon quasi identique sur les plateformes Windows, Mac OS X et Linux.&lt;br /&gt;
&lt;br /&gt;
De nombreuses fonctionnalités accessibles via le code Python n'ont pas été implémentées via l'IHM graphique. Ceci rend ce programme difficile d'accès à ses utilisateurs potentiels (design mécanique) qui n'ont pas de formation programmation.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:Cubefreecad.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec FreeCAD François]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec FreeCAD François]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Category:Tutoriel]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_Fran%C3%A7ois&amp;diff=335</id>
		<title>Création d'un cube troué avec FreeCAD François</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_Fran%C3%A7ois&amp;diff=335"/>
				<updated>2015-12-15T12:21:41Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « &amp;lt;!--    Page pouvant servir d'exemple pour la création d'un tutoriel.    Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet --&amp;gt; Fichier:Cubefr... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&amp;lt;!--&lt;br /&gt;
   Page pouvant servir d'exemple pour la création d'un tutoriel.&lt;br /&gt;
   Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Fichier:Cubefreecad.jpg|vignette|droite]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Création d'un cube troué ==&lt;br /&gt;
Ici nous allons concevoir un cube percé de part en part en utilisant le logiciel Freecad. De forme, certes, basique, ce cube va nous permettre d'utiliser quelques primitives. &lt;br /&gt;
&lt;br /&gt;
== Pré-requis ==&lt;br /&gt;
Il est préférable d'avoir bien pris en main l'interface du logiciel et d'avoir déjà créé quelques formes basiques avant d'aborder cet exercice. &lt;br /&gt;
&lt;br /&gt;
=== Le procédé  ===&lt;br /&gt;
==== Etape 1 :  ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Esquisse.jpg]]&lt;br /&gt;
&lt;br /&gt;
Dans l'onglet &amp;quot;Tâches&amp;quot; de la fenêtre &amp;quot;Vue combinée&amp;quot; cliquez sur &amp;quot;Créer une esquisse&amp;quot;. Une fenêtre vous propose de choisir le plan sur lequel vous voulez créer votre esquisse (XY, XZ, YZ)... peut importe pour l'instant, cliquez sur OK&amp;quot; &lt;br /&gt;
&lt;br /&gt;
==== Etape 2 :  ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Esquisse rectangle.jpg]]&lt;br /&gt;
&lt;br /&gt;
Dans la barre d'outils &amp;quot;Géométries d'esquisse&amp;quot; cliquez sur &amp;quot;Créer un rectangle dans l'esquisse&amp;quot;. Une fois le rectangle créé sélectionnez une arête du rectangle (verticale ou horizontale) en cliquant dessus (elle s'affiche alors en vert) et dans la même barre d'outils cliquez sur &amp;quot;Fixer la distance horizontale entre deux points ou extrémités de ligne&amp;quot; (ou &amp;quot;verticale&amp;quot; en fonction de l'arête sélectionnée). Rentrez la valeur désirée dans la fenêtre qui s'affiche (attention à l'unité de mesure) appuyez sur entrée (ou cliquez sur OK).          &lt;br /&gt;
&lt;br /&gt;
[[Fichier:Taille rectangle.jpg]]&lt;br /&gt;
&lt;br /&gt;
Sélectionnez une arête perpendiculaire à celle que vous avez déjà fixée puis, toujours dans la même barre d'outils, cliquez sur &amp;quot;Créer une contrainte d'égalité entre deux lignes ou entre des cercles et/ou des arcs&amp;quot;. Vous avez maintenant un carré. Si vous voulez le centré sur les axes de repérage, sélectionnez   &lt;br /&gt;
&lt;br /&gt;
==== Etape 3 :  ====&lt;br /&gt;
&lt;br /&gt;
Congratulations, l'objet est fini.&lt;br /&gt;
Récapitulatif, pour atteindre ce résultat, il faut taper:&lt;br /&gt;
&lt;br /&gt;
difference () {&lt;br /&gt;
cube(20, true);&lt;br /&gt;
cube ([18, 18, 25], center=true);&lt;br /&gt;
rotate ([90,0,0]) cylinder (h = 25, r=6, center = true, $fn=100);&lt;br /&gt;
rotate ([0,90,0]) cylinder (h = 25, r=6, center = true, $fn=100);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Cubex.png]]&lt;br /&gt;
&lt;br /&gt;
[[Category:Tutoriel]]&lt;br /&gt;
[[Category:OpenSCAD]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Modelisation3D&amp;diff=334</id>
		<title>Catégorie:Modelisation3D</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cat%C3%A9gorie:Modelisation3D&amp;diff=334"/>
				<updated>2015-12-15T12:21:27Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Liste des tutoriels d'apprentissage de la modélisation 3D&lt;br /&gt;
===[[:Category:SketchUp|Modélisation 3D avec SketchUp]]===&lt;br /&gt;
SketchUp est un logiciel de modélisation 3D orienté vers l'architecture. Initialement édité par la société @Last Software (racheté par Google ensuite), ce logiciel se caractérise par des outils simples (rotation, extrusion, déplacement, etc.), qui en font un logiciel de 3D très différent des modeleurs 3D classiques. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:Imageintro.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec SketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec SketchUp]]&lt;br /&gt;
Fichier:Capture decran cube rose.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué (Audrey) avec SketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué (Audrey) avec SketchUp]]&lt;br /&gt;
Fichier:Cube Final.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Creation d'un cube a trous avec sketchUp]]&amp;lt;/div&amp;gt;|link=[[Creation d'un cube a trous avec sketchUp]]&lt;br /&gt;
Fichier:Coeur termine.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cœur pour pendentif avec sketchUp]]&amp;lt;/div&amp;gt;|link=[[Création d'un cœur pour pendentif avec sketchUp]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===[[:Category:OpenSCAD|Modélisation 3D avec OpenSCAD]]===&lt;br /&gt;
[http://www.openscad.org/index.html OpenSCAD] est un logiciel de modélisation 3D paramétrique. C'est un logiciel libre qui fonctionne à la fois sous Linux, Mac OS et Windows. Le projet a débuté en février 2010 et évolue progressivement d'année en année. &lt;br /&gt;
&lt;br /&gt;
Prochainement, grâce au travail de [http://shainasabarwal.wordpress.com/2014/08/03/gsoc-project-ui-brushup-of-openscad/ Shaina Sabarwal] fait dans le cadre des [https://www.google-melange.com/gsoc/homepage/google/gsoc2014 Google Summer of Code], l'interface du logiciel sera grandement amélioré. Espérons que cette nouvelle version ne tardera pas à sortir car elle changera fondamentalement l'expérience utilisateur.&lt;br /&gt;
&lt;br /&gt;
OpenSCAD a pour particularité de fonctionner de façon entièrement paramétrique, c'est-à-dire que la conception passe par la rédaction d'un script dans une sous-fenêtre située à gauche, tandis qu'une sous-fenêtre à droite permet juste de visualiser l'objet en 3D après une étape de rendu. Même s'il peut paraitre rudimentaire au premier abord, il permet de réaliser des modèles complexes si l'on structure bien son script. Il est utilisé par [http://www.thingiverse.com/ thingiverse] pour les [http://www.thingiverse.com/apps/customizer modèles 3D personnalisables].&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:intro_openSCAD.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Premier pas avec OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Premier pas avec OpenSCAD]]&lt;br /&gt;
Fichier:Sapin_OpenSCAD.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des primitives de dessin 2D d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des primitives de dessin 2D d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo equerre.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des primitives de dessin 3D d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des primitives de dessin 3D d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo_union.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Découverte des opération de transformation géométrique d'OpenSCAD]]&amp;lt;/div&amp;gt;|link=[[Découverte des opération de transformation géométrique d'OpenSCAD]]&lt;br /&gt;
Fichier:Logo_union.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué]]&amp;lt;/div&amp;gt;|link=[[Création cube troué]]&lt;br /&gt;
Fichier:cube-troue.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué (Arnaud)]]&amp;lt;/div&amp;gt;|link=[[Création cube troué (Arnaud)]]&lt;br /&gt;
Fichier:Cubex.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création cube troué (Raphaël)]]&amp;lt;/div&amp;gt;|link=[[Création cube troué (Raphaël)]]&lt;br /&gt;
Fichier:De.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Creation d'un dé]]&amp;lt;/div&amp;gt;|link=[[Creation d'un dé]]&lt;br /&gt;
Fichier:De.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Premier pas]]&amp;lt;/div&amp;gt;|link=[[Premier pas]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===[[:Category:FreeCAD|Modélisation 3D avec FreeCAD]]===&lt;br /&gt;
[http://www.freecadweb.org/index-fr.html FreeCAD] est un logiciel à conception paramétrique proposant des outils similaires à CATIA, SolidWorks et Solid Edge. Il est doté d'une architecture modulaire, qui permet l'ajout de nouvelles fonctionnalités très simplement, sans devoir modifier le noyau de l'application.&lt;br /&gt;
&lt;br /&gt;
FreeCAD est basé sur Open CASCADE, un puissant noyau géométrique. Il dispose d'un modèle de représentation des scènes 3D conforme au format Open Inventor et fourni par la bibliothèque logicielle Coin 3D, ainsi qu'une vaste interface de programmation Python. L'interface graphique est basée sur Qt. FreeCAD fonctionne donc de façon quasi identique sur les plateformes Windows, Mac OS X et Linux.&lt;br /&gt;
&lt;br /&gt;
De nombreuses fonctionnalités accessibles via le code Python n'ont pas été implémentées via l'IHM graphique. Ceci rend ce programme difficile d'accès à ses utilisateurs potentiels (design mécanique) qui n'ont pas de formation programmation.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;gallery &amp;gt;&lt;br /&gt;
Fichier:Cubefreecad.jpg|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec FreeCAD François]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec FreeCAD François]]&lt;br /&gt;
Fichier:Cube-troue.png|&amp;lt;div style=&amp;quot;text-align: center; font-size: 0.9em;&amp;quot;&amp;gt;[[Création d'un cube troué avec FreeCAD (Arnaud)]]&amp;lt;/div&amp;gt;|link=[[Création d'un cube troué avec FreeCAD (Arnaud)]]&lt;br /&gt;
&amp;lt;/gallery&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Category:Tutoriel]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_(Arnaud)&amp;diff=333</id>
		<title>Création d'un cube troué avec FreeCAD (Arnaud)</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD_(Arnaud)&amp;diff=333"/>
				<updated>2015-12-15T12:21:21Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « droite   == Présentation et objectifs ==  Il s'agit de créer un modèle 3D d'un cube troué avec OpenSCAD. On va d'abord créer un po... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;[[Fichier:cube-troue.png|vignette|droite]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Présentation et objectifs ==&lt;br /&gt;
&lt;br /&gt;
Il s'agit de créer un modèle 3D d'un cube troué avec OpenSCAD.&lt;br /&gt;
On va d'abord créer un polygone 2D (cadre d'un carré) puis lui appliquer une extrusion linéaire. On crée également les 2 cylindres qui vont ensuite être soustrait à la forme du cadre extrudé.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:cube-troue.png|vignette|objet 3D final]]&lt;br /&gt;
&lt;br /&gt;
== Pré-requis ==&lt;br /&gt;
Il faut avoir déjà pratiquer les 3 tutoriaux précédents.&lt;br /&gt;
&lt;br /&gt;
=== Matériel ===&lt;br /&gt;
&lt;br /&gt;
Un ordinateur&lt;br /&gt;
&lt;br /&gt;
=== Logiciels ===&lt;br /&gt;
&lt;br /&gt;
FreeCAD&lt;br /&gt;
&lt;br /&gt;
== Nom de votre tutoriel ==&lt;br /&gt;
Réalisation d'un cube troué&lt;br /&gt;
&lt;br /&gt;
=== Première Version :  ===&lt;br /&gt;
==== Etape 1 :  ====&lt;br /&gt;
On crée d'abord le polygone qui sera extrudé&lt;br /&gt;
Pour celà, on crée une esquisse (Taches -&amp;gt; Créer une esquisse) que l'on oriente sur le plan XY.&lt;br /&gt;
On crée successivement 2 carré avec l'outil &amp;quot;créer un rectangle dans l'esquisse&amp;quot;.&lt;br /&gt;
On sélectionne 2 cotés perpendiculaires du premier carré et on applique la contrainte d'égalité entre 2 lignes (signe =). On fixe la longueur du carré en sélectionnant un côté et en appliquant une contrainte de longueur de ligne (double flèche).&lt;br /&gt;
On fait de même avec le 2eme rectangle.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:freecad-etape01.png|vignette|polygone de départ]]&lt;br /&gt;
==== Etape 2 :  ====&lt;br /&gt;
Il faut ensuite une extrusion linéaire sur le cadre précédemment créé.&lt;br /&gt;
Pour cela il faut fermer l'esquisse, sélectionner la forme (sketch) et appliquer une protusion.&lt;br /&gt;
[[Fichier:cadre-extrude.png|vignette|Cadre extrudé]]&lt;br /&gt;
==== Etape 3 :  ====&lt;br /&gt;
On ajoute 2 cylindres perpendiculaires en utilisant les fonctions translete, rotation et cylinder&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;C&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
linear_extrude(10) {&lt;br /&gt;
   polygon(&lt;br /&gt;
	points=[[0,0],[0,10],[10,10],[10,0],[1,1],[1,9],[9,9],[9,1]],&lt;br /&gt;
	paths=[[0,1,2,3],[4,5,6,7]]&lt;br /&gt;
	);&lt;br /&gt;
}&lt;br /&gt;
translate([-1,5,5])&lt;br /&gt;
   rotate([0,90,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
translate([5,-1,5])&lt;br /&gt;
   rotate([-90,0,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:cube-avant-difference.png|vignette|cube avec les cylindres à soustraire à la forme]]&lt;br /&gt;
==== Etape 4 :  ====&lt;br /&gt;
On soustrait les 2 cylindres du cadre extrudé pour obtenir l'objet final.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;C&amp;quot; enclose=&amp;quot;div&amp;quot;&amp;gt;&lt;br /&gt;
difference(){linear_extrude(10) {&lt;br /&gt;
   polygon(&lt;br /&gt;
	points=[[0,0],[0,10],[10,10],[10,0],[1,1],[1,9],[9,9],[9,1]],&lt;br /&gt;
	paths=[[0,1,2,3],[4,5,6,7]]&lt;br /&gt;
	);&lt;br /&gt;
}&lt;br /&gt;
translate([-1,5,5])&lt;br /&gt;
   rotate([0,90,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
translate([5,-1,5])&lt;br /&gt;
   rotate([-90,0,0])&lt;br /&gt;
   cylinder(h=12,r=2,$fn=20);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:cube-troue.png|vignette|cube avec les cylindres à soustraire à la forme]]&lt;br /&gt;
&lt;br /&gt;
=== Conseils ===&lt;br /&gt;
Il est important de se représenter les différentes étapes de construction de l'objet à partir de formes simples et de les ordonner correctement.&lt;br /&gt;
&lt;br /&gt;
== Pour aller plus loin ==&lt;br /&gt;
&lt;br /&gt;
On peut utiliser des variables pour pouvoir réutiliser ce code et créer des objets personnalisés de même type.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;!--&lt;br /&gt;
  Enfin, vous listez les catégories auquels le projet appartient&lt;br /&gt;
  Il y a au moins la catégorie Projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Category:Tutoriel]]&lt;br /&gt;
[[Category:OpenSCAD]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Fichier:Freecad-etape01.png&amp;diff=332</id>
		<title>Fichier:Freecad-etape01.png</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Fichier:Freecad-etape01.png&amp;diff=332"/>
				<updated>2015-12-15T12:21:10Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD&amp;diff=331</id>
		<title>Création d'un cube troué avec FreeCAD</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Cr%C3%A9ation_d%27un_cube_trou%C3%A9_avec_FreeCAD&amp;diff=331"/>
				<updated>2015-12-15T12:19:36Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : Page créée avec « &amp;lt;!--    Page pouvant servir d'exemple pour la création d'un tutoriel.    Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet --&amp;gt; Fichier:Cubefr... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&amp;lt;!--&lt;br /&gt;
   Page pouvant servir d'exemple pour la création d'un tutoriel.&lt;br /&gt;
   Pour l'utiliser, copiez-collez le code de celle-ci vers votre page de projet&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
[[Fichier:Cubefreecad.jpg|vignette|droite]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Création d'un cube troué ==&lt;br /&gt;
Ici nous allons concevoir un cube percé de part en part en utilisant le logiciel Freecad. De forme, certes, basique, ce cube va nous permettre d'utiliser quelques primitives. &lt;br /&gt;
&lt;br /&gt;
== Pré-requis ==&lt;br /&gt;
Il est préférable d'avoir bien pris en main l'interface du logiciel et d'avoir déjà créé quelques formes basiques avant d'aborder cet exercice. &lt;br /&gt;
&lt;br /&gt;
=== Le procédé  ===&lt;br /&gt;
==== Etape 1 :  ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Esquisse.jpg]]&lt;br /&gt;
&lt;br /&gt;
Dans l'onglet &amp;quot;Tâches&amp;quot; de la fenêtre &amp;quot;Vue combinée&amp;quot; cliquez sur &amp;quot;Créer une esquisse&amp;quot;. Une fenêtre vous propose de choisir le plan sur lequel vous voulez créer votre esquisse (XY, XZ, YZ)... peut importe pour l'instant, cliquez sur OK&amp;quot; &lt;br /&gt;
&lt;br /&gt;
==== Etape 2 :  ====&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Esquisse rectangle.jpg]]&lt;br /&gt;
&lt;br /&gt;
Dans la barre d'outils &amp;quot;Géométries d'esquisse&amp;quot; cliquez sur &amp;quot;Créer un rectangle dans l'esquisse&amp;quot;. Une fois le rectangle créé sélectionnez une arête du rectangle (verticale ou horizontale) en cliquant dessus (elle s'affiche alors en vert) et dans la même barre d'outils cliquez sur &amp;quot;Fixer la distance horizontale entre deux points ou extrémités de ligne&amp;quot; (ou &amp;quot;verticale&amp;quot; en fonction de l'arête sélectionnée). Rentrez la valeur désirée dans la fenêtre qui s'affiche (attention à l'unité de mesure) appuyez sur entrée (ou cliquez sur OK).          &lt;br /&gt;
&lt;br /&gt;
[[Fichier:Taille rectangle.jpg]]&lt;br /&gt;
&lt;br /&gt;
Sélectionnez une arête perpendiculaire à celle que vous avez déjà fixée puis, toujours dans la même barre d'outils, cliquez sur &amp;quot;Créer une contrainte d'égalité entre deux lignes ou entre des cercles et/ou des arcs&amp;quot;. Vous avez maintenant un carré. Si vous voulez le centré sur les axes de repérage, sélectionnez   &lt;br /&gt;
&lt;br /&gt;
==== Etape 3 :  ====&lt;br /&gt;
&lt;br /&gt;
Congratulations, l'objet est fini.&lt;br /&gt;
Récapitulatif, pour atteindre ce résultat, il faut taper:&lt;br /&gt;
&lt;br /&gt;
difference () {&lt;br /&gt;
cube(20, true);&lt;br /&gt;
cube ([18, 18, 25], center=true);&lt;br /&gt;
rotate ([90,0,0]) cylinder (h = 25, r=6, center = true, $fn=100);&lt;br /&gt;
rotate ([0,90,0]) cylinder (h = 25, r=6, center = true, $fn=100);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Cubex.png]]&lt;br /&gt;
&lt;br /&gt;
[[Category:Tutoriel]]&lt;br /&gt;
[[Category:OpenSCAD]]&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	<entry>
		<id>http://wiki.labaixbidouille.com/index.php?title=Fichier:Taille_rectangle.jpg&amp;diff=330</id>
		<title>Fichier:Taille rectangle.jpg</title>
		<link rel="alternate" type="text/html" href="http://wiki.labaixbidouille.com/index.php?title=Fichier:Taille_rectangle.jpg&amp;diff=330"/>
				<updated>2015-12-15T12:19:32Z</updated>
		
		<summary type="html">&lt;p&gt;Adminsys : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>Adminsys</name></author>	</entry>

	</feed>