Embed Size (px)
Citation preview
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015
RURPLE est une application écrite en python qui permet de simuler le déplacement d’un robot dans une pièce. C’est
un logiciel libre que vous pouvez télécharger (voir les références)
Partie 1 : Prise en main
Après avoir lancé le logiciel Rurple, allez dans le menu « Scène, Nouveau labyrinthe… »
afin de créer une scène carrée de 5 carreaux de côté. Ensuite allez dans le menu « Scène,
Nombre de billes … » et placez quatre billes dans la poche du robot.
On commande le robot à l’aide de procédures suivantes :
avance( ) Le robot avance d’une case devant lui
gauche( ) Le robot pivote de 90 ° vers la gauche
depose( ) Le robot dépose une bille dans la case où il se trouve
Exemple :
Entrez le code suivant dans la fenêtre de droite et l’exécuter.
A savoir :
Pour réinitialiser la scène, utiliser en haut à gauche de l’écran.
Si cela ne fonctionne pas, on peut piloter le robot au clavier (A pour avance et G pour gauche) pour le remettre dans sa
position initiale.
Exercice 1 :
Modifier la taille de la scène pour qu’elle fasse 10 cases de large et modifier le programme pour que le robot dépose
une bille aux quatre coins de la pièce.
Partie 2 : Utiliser les capteurs du robot
Le robot perçoit son environnement grâce à des capteurs.
On utilise les capteurs à l’aide des fonctions suivantes :
mur_devant( ) Renvoi la valeur True s’il y a un mur devant le robot et False sinon
mur_a_droite( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
mur_a_gauche( ) Renvoi la valeur True s’il y a un mur sur le côté droit robot et False sinon
bille_en_poche( ) Renvoi la valeur True si le robot a encore des billes dans sa poche et False sinon
Bille_au_sol( ) Renvoi la valeur True s’il y a au moins une bille sur la case où est le robot et False sinon
Exemple :
Entrez le code suivant dans la fenêtre de droite.
L’exécuter avec les environnements suivants ( il suffit de cliquer sur les cases pour ajouter des billes et des murs) :
Exemple :
Entrez le code suivant dans la fenêtre de droite. L’exécuter dans des scènes de différentes tailles.
Exercice 2 :
Ecrire un programme pour que le robot dépose une bille dans chaque coin de la pièce quelque soit la scène.
Exemple :
Entrez le code suivant dans la fenêtre de droite.
Mettre des billes dans la case où est le robot et exécuter le programme.
Exercice 3 :
C'était une belle journée ensoleillée. Rurple jouait dehors avec ses amis.
Soudain, il commença à pleuvoir et Rurple se rappela que les fenêtres de sa
maison étaient ouvertes. Alors il retourna chez lui et s'arrêta face à la porte, ne
sachant pas vraiment comment faire.
Les fenêtres sont matérialisées par les billes et fermer la fenêtre consiste à
ramasser la bille. Aidez Rurple à fermer les fenêtres de sa maison.
Exercice 4 :
Le vent a soufflé vraiment très fort la nuit dernière. Il y a des détritus partout à l'extérieur de la maison de Rurple. Ses
parents lui ont demandé d'aller nettoyer l'allée. Des ordures sont éparpillées au hasard sur le chemin, qui est en ligne
droite, comme illustré ci-dessous :
Rurple doit ramasser tous les détritus, et les déposer dans la poubelle qui est à son point de départ.
La situation finale doit ressembler à ce qui suit :
Exercice 5 :
Les parents de Rurple sont si contents de son travail, qu'ils lui ont demandé de
ramasser toutes les ordures qui ont été apportées par le vent dans leur arrière-
cour pendant la tempête. Faites qu'il ramasse tous les détritus et qu'il les rapporte
avec lui et les dépose à sa position de départ. Essayez de généraliser à partir du
programme que vous venez d'écrire pour nettoyer l'allée. Créez votre propre
fichier monde, correspondant à une situation comme celle illustrée ci-dessous.
Votre solution ne doit dépendre ni des endroits exacts où se trouvent les détritus,
ni de la taille de la cour.
Exercice 4 : Parcourir un labyrinthe …
Créer une scène « labyrinthe », la sortie étant matérialisée par une bille et réaliser un programme qui permette au
Robot d’en sortir quelle que soit la situation.
Indication : Il existe une technique infaillible* pour sortir d'un labyrinthe lorsque l'on y entre par un côté : il
suffit de garder la même main sur le mur situé à votre gauche (ou à votre droite) et de le suivre. Cette
technique peut éventuellement vous faire parcourir tout le labyrinthe, mais elle assure d'en trouver la sortie.
* On pourra consulter : http://interstices.info/jcms/c_46065/l-algorithme-de-pledge
Références ------------------------------------------------------------------------------------------------------------------------
� Roberge Andre, ≪ Apprendre le langage Python avec RUR-PLE : un jeu d'enfants !
http://rur-ple.sourceforge.net
� Pinsard Denis, ≪ Rurple NG ≫http://dichotomies.fr/2011/infomath/guides/python/presentation-rurple
� Rurple-NG, télécharger la version française :
http://dichotomies.fr/2011/infomath/guides/python/installation-rurple
