ISN TP 5 : « Un peu de robotique : Rurple … » 2/10/2015

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