Commit 18c01fc7 authored by MONTEL ALICE p1309529's avatar MONTEL ALICE p1309529

merge github

parents
MIT License
Copyright (c) 2018 aml-lyon1
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
# Projet actionrobot : Épreuve du Labyrinthe
Challenge de programmation proposé aux étudiants informatiques par l'AML. L'objectif : faire sortir son robot du labyrinthe :D
Ce projet est en cours. V1.2 disponible le Mardi 12/06/2018, stay tuned ;)
Vous n'êtes pas à l'abris de voir de nouvelles fonctions apparaître, ou quelques liens supplémentaires alors pensez à checker régulièrement ce repo !
## Déroulement du tournoi
Ce tournoi est divisé en plusieurs manches, à l'issue desquelles des gens sont éliminés, pour n'en garder qu'un à la fin ! Chaque manche est composée de 2 rounds avec 2 labyrinthes différents.
À chaque manche, 4 robots concourent simultanément. Chaque robot encore en lice fera les 2 labyrinthes de la manche. Nous examinons 2 critères :
le temps cumulé que votre robot a mis à sortir
votre nombre de points qui dépend de votre classement à chaque round
Les points à chaque round sont calculés comme suit :
| Classement | Points |
| ---------- | ------ |
| 1er | 10 points |
| 2ème | 7 points |
| 3ème | 3 points |
| 4ème | 1 points |
Les manches se déroulent comme suit :
__1ère manche__ (20 -> 8)
Les 20 équipes sont réparties en 5 "poules" de 4 équipes.
Le meilleur de chaque groupe (en points) sont sélectionnés.
Ensuite, parmi ceux restants, les 3 meilleurs temps sont également sélectionnés.
__Quarts de finale__ (8 -> 4)
Les 8 équipes restantes sont réparties en 2 groupes de 4 équipes
Le meilleur de chaque groupe est sélectionné
Les 2 meilleurs temps sont sélectionnés parmi ceux restants.
__Demi-finale__ (4 -> 2)
Seuls les points comptent !
__Finale__
Les 2 dernières équipes s'affrontent dans un grand labyrinthe.
Le premier à remporter 2 victoires remporte le tournoi !
## Documentation
### Python
Tutoriel pour communiquer avec votre robot [ici](<https://media.readthedocs.org/pdf/python-ev3dev/latest/python-ev3dev.pdf>)
Un peu d'aide pour faire bouger votre robot [par là](<http://ev3dev-lang.readthedocs.io/projects/python-ev3dev/en/stable/motors.html>)
### Java
Si vous êtes plutôt Java, il existe un plugin Eclipse (Lejos EV3), un peu de doc par [ici](<http://www.lejos.org/ev3/docs/>). Et pour communiquer avec votre robot depuis Eclipse en partant de zéro, vous pouvez regarder par [](<http://www.lejos.org/ev3.php>). Amateurs de windows10, méfiance ! Il se peut que vous ayez quelques soucis de driver qui entrave la communication Eclipse <-> robot. Préférez donc une distrib Linux ou même Windows 7.
## Deadlines
La compétition aura lieu le 27 Septembre 2018, soyez prêts !
#### Contributions
Cette base de code est proposée par Augustin Chateau et Alice Montel, développé spécifiquement pour l'occasion.
La première version du projet est également disponible [ici](<https://github.com/Lyon1-Asterix/actionrobot>)
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry exported="true" kind="con" path="org.lejos.ev3.ldt.LEJOS_EV3_LIBRARY_CONTAINER"/>
<classpathentry kind="con" path="org.lejos.nxt.ldt.LEJOS_LIBRARY_CONTAINER/nxt"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="output" path="bin"/>
</classpath>
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>robotMaze</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.lejos.nxt.ldt.leJOSBuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.lejos.ev3.ldt.leJOSEV3Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.lejos.ev3.ldt.leJOSEV3Nature</nature>
<nature>org.lejos.nxt.ldt.leJOSNature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.source=1.7
Ici une base de projet Java et quelques liens de docs intéressantes ---- A venir ! :D
package robotMaze;
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;
public class Robot {
private int step ;
private int speed ;
private RegulatedMotor rightM ;
private RegulatedMotor leftM ;
/**
* Instantiate a robot with standard speed and step as defined in main class.
*/
public Robot() {
this.step = myclass.STD_STEP ;
this.speed = myclass.STD_SPEED ;
this.rightM = new EV3LargeRegulatedMotor(myclass.rightP) ;
this.leftM = new EV3LargeRegulatedMotor(myclass.leftP) ;
}
/**
* Instantiate a robot with speed and step as specified by the developer.
* @param step
* @param speed
*/
public Robot(int step, int speed) {
this.step = step;
this.speed = speed;
}
/**
* To get the step of the robot.
*
* @return step
*/
public int getStep() {
return step;
}
/**
* To set the step of the robot.
*
* @param step
*/
public void setStep(int step) {
this.step = step;
}
/**
* To get the speed of the robot.
*
* @return speed
*/
public int getSpeed() {
return speed;
}
/**
* To get the speed of the robot.
*
* @param speed
*/
public void setSpeed(int speed) {
this.speed = speed;
}
/**
* Make the robot move forward
*
* @param nbCase
*/
public void forward(int nbCase) {
for(int i=0; i<nbCase; i++) {
this.leftM.forward();
this.rightM.forward();
Delay.msDelay(myclass.STD_TIME);
this.leftM.stop();
this.rightM.stop();
}
}
/**
* Make the robot move backward
*
* @param nbCase
*/
public void backward(int nbCase) {
for(int i=0; i<nbCase; i++) {
this.leftM.backward();
this.rightM.backward();
Delay.msDelay(myclass.STD_TIME);
this.leftM.stop();
this.rightM.stop();
}
}
/**
* Make the robot turn right, without moving forward
*
*/
public void turnRight(int nbTour) {
for(int i=0; i<nbTour; i++) {
this.leftM.forward();
this.rightM.backward();
Delay.msDelay(myclass.STD_TIME);
this.leftM.stop();
this.rightM.stop();
}
}
/**
* Make the robot turn left, without moving forward
*/
public void turnLeft(int nbTour) {
for(int i=0; i<nbTour; i++) {
this.leftM.backward();
this.rightM.forward();
Delay.msDelay(myclass.STD_TIME);
this.leftM.stop();
this.rightM.stop();
}
}
/**
* The robot makes a Uturn, without moving forward
*/
public void uturn() {
this.turnLeft(2);
}
}
package robotMaze;
import lejos.hardware.port.MotorPort;
import lejos.hardware.port.Port;
public class myclass {
public final static int STD_SPEED = 240 ;
public final static int STD_STEP = 40 ;
public final static Port leftP = MotorPort.D ;
public final static Port rightP = MotorPort.A ;
public final static int STD_TIME = 1000;
/**
*
* @param args
*/
public static void main(String[] args) {
System.out.println("Here we go !");
Robot robot = new Robot();
robot.forward(1);
robot.backward(1);
robot.turnLeft(1);
robot.turnRight(1);
//robot.uturn();
}
}
\ No newline at end of file
Ce répertoire contiendra la base de code Python
## Prérequis
avoir installé [EV3-dev](http://www.ev3dev.org/docs/getting-started/)
En attendant une vraie doc, vous pouvez consulter la doc [ici](https://sites.google.com/site/ev3python/learn_ev3_python/basics-1)
## Contenu du répertoire
* le fichier init.py est un fichier vide permettant l'import d'une classe dans un autre fichier.
* __robot.py__ : class contenant les fonctions propres au robot telles que tourner et avancer.
* main.py : là où vous pouvez mettre votre code principal :-)
source : https://sites.google.com/site/ev3python/learn_ev3_python/screen/bmp-image-collection
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment