Cet article s'adresse à ceux qui souhaitent travailler avec ev3 en Java. Cette fois, j'aimerais contrôler le char de différentes manières.
◯ ev3 (réservoir) ◯ Moteur L / Moteur M ◯ PC (éclipse) ◯ bluetooth ◯ microSD ◯ Documentation API (Il est recommandé de continuer tout en regardant ceci.)
◯ Il s'agit d'un programme qui fait avancer le réservoir pendant 5 secondes. C'est aussi simple que d'organiser les méthodes nécessaires, mais certaines parties ne fonctionnent pas avec le traitement séquentiel, donc une certaine ingéniosité est requise.
tank00.java
//Les choses nécessaires(Matériel)Importer
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;
//Créer une classe
public class tank00 {
//Créer une méthode statique
public static void main(String[] args) {
//Génération d'instance
RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
RegulatedMotor l_b = new EV3LargeRegulatedMotor(MotorPort.B);
//Régler la vitesse(Unités[degrees/s])
l_a.setSpeed(720);
l_b.setSpeed(720);
//Avancez pendant 5 secondes
l_a.forward();
l_b.forward();
Delay.msDelay(5000);
//Changer de direction sur place(Commencez à tourner en même temps)
l_a.rotate(-2160,true);
l_b.rotate(2160);
//Arrêtez deux moteurs en même temps
l_a.stop(true);
l_b.stop();
}
}
Point : public void rotate(int angle,boolean immediateReturn) immediateReturn - if true do not wait for the move to complete
La méthode rotate () est le deuxième argument, qui vous permet ** d'attendre la fin du processus avant de décider d'exécuter le processus suivant **. S'il est défini sur true, le processus suivant démarrera sans attendre la fin du processus. Cela permet aux deux moteurs A et B de tourner en même temps dans le programme ci-dessus.
Point : public void stop(boolean immediateReturn) En spécifiant true comme argument, vous pouvez ** exécuter immédiatement le processus suivant ** sans attendre que le processus arrête le moteur. [Référence]: Class Base Regulated Motor
◯ Créez votre propre méthode afin qu'elle puisse être réutilisée facilement.
tank01.java
//Les choses nécessaires(Matériel)Importer
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;
//Créer une classe
public class tank01 {
//Génération d'instance
private final static RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
private final static RegulatedMotor l_b = new EV3LargeRegulatedMotor(MotorPort.B);
//Définition de la vitesse du moteur variable de type entier
private final static int motorSpeed = 200;
//Créer une méthode statique
public static void main(String[] args) {
//Méthode à exécuter
forward();
turnRight();
forward();
stop();
}
//Définition de la méthode
public static void forward(){
l_a.setSpeed(motorSpeed);
l_b.setSpeed(motorSpeed);
l_a.forward();
l_b.forward();
Delay.msDelay(2000);
}
//Définition de la méthode
public static void turnRight(){
l_a.setSpeed(motorSpeed);
l_b.setSpeed(motorSpeed-100);
l_a.forward();
l_b.forward();
Delay.msDelay(1000);
}
//Définition de la méthode
public static void stop(){
l_a.stop(true);
l_b.stop();
}
}
Point: ** Créer une méthode ** Créez des méthodes principalement pour "** code afin de faciliter la lecture " et " réutiliser **". La combinaison du code associé en un seul s'appelle la ** modularisation **. La création d'une fonction peut être considérée comme modulaire.
◯ C'est un programme qui crée une méthode avec un degré de liberté plus élevé en spécifiant des arguments.
tank02.java
//Les choses nécessaires(Matériel)Importer
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
//Créer une classe
public class tank02 {
//Génération d'instance
private final static RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
private final static RegulatedMotor l_b = new EV3LargeRegulatedMotor(MotorPort.B);
//Créer une méthode statique
public static void main(String[] args) {
//Méthode à exécuter
tank_drive(80,80,4);
tank_drive(-100,-100,2);
tank_drive(-30,30,3);
stop();
}
//Définition de la méthode
public static void tank_drive(int a_speed,int b_speed,int rotations){
//Max's(a_speed)% or (b_speed)%de(Valeur absolue)Obtenez de la vitesse
l_a.setSpeed(Math.abs((int) l_a.getMaxSpeed()*a_speed/100));
l_b.setSpeed(Math.abs((int) l_b.getMaxSpeed()*b_speed/100));
//a_vitesse et b_Les cas sont classés en fonction de la combinaison de la vitesse positive et négative
if(a_speed > 0) {
//a_speed、b_Les deux vitesses sont positives
if(b_speed > 0) {
l_a.rotate(rotations*360,true);
l_b.rotate(rotations*360);
//a_la vitesse est positive, b_la vitesse est négative
}else {
l_a.rotate(rotations*360,true);
l_b.rotate(rotations*360*-1);
}
}else {
//a_la vitesse est négative b_la vitesse est positive
if(b_speed > 0) {
l_a.rotate(rotations*360*-1,true);
l_b.rotate(rotations*360);
//a_speed、b_Les deux vitesses sont négatives
}else {
l_a.rotate(rotations*360*-1,true);
l_b.rotate(rotations*360*-1);
}
}
}
//Définition de la méthode
public static void stop(){
l_a.stop(true);
l_b.stop();
}
}
Point: ** Valeur absolue ** Il peut être obtenu avec Math.abs (). [Article de référence]: Exemple pour obtenir la valeur absolue Java (abs)
◯ Il s'agit d'un programme qui fixe une limite de temps.
tank03.java
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Stopwatch;
import java.util.Random;
import lejos.utility.Delay;
public class tank03 {
//Génération d'instance
public static Stopwatch stopwatch = new Stopwatch();
private final static RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
private final static RegulatedMotor l_b = new EV3LargeRegulatedMotor(MotorPort.B);
//Créer une méthode statique
public static void main(String[] args) {
//Réinitialiser la minuterie
stopwatch.reset();
//boucle infinie
while (true) {
forward();
//Afficher le temps écoulé
System.out.println(Math.round(stopwatch.elapsed() / 1000));
//Après 20 secondes, arrêtez le moteur et sortez de la boucle
if(stopwatch.elapsed() > 20 * 1000) {
stop();
break;
}
}
}
//Définition de la méthode
public static void forward(){
//Génération d'instance
Random r = new Random();
//0-Sélectionnez au hasard une valeur dans la plage de vitesse maximale et réglez-la sur vitesse
l_a.setSpeed(r.nextInt((int) l_a.getMaxSpeed()));
l_b.setSpeed(r.nextInt((int) l_a.getMaxSpeed()));
l_a.forward();
l_b.forward();
Delay.msDelay(1000);
}
//Définition de la méthode
public static void stop(){
l_a.stop(true);
l_b.stop();
}
}
Point : Math.round Il s'agit d'une méthode d'arrondi. [Article de référence]: Exemple d'arrondi Java (rond)
Point: ** Classe aléatoire ** Produit une valeur aléatoire. [Article de référence]: Générer une plage spécifiée de nombres aléatoires en Java: Random.nextInt ()
Point : stopwatch.elapsed() Une méthode de la classe Stopwatch. Renvoie le temps écoulé.
◯ Ce programme est intentionnellement défini de manière à ce que la probabilité d'avancer soit élevée.
import java.util.Random;
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;
public class tank04 {
private final static RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
private final static RegulatedMotor l_b = new EV3LargeRegulatedMotor(MotorPort.B);
private final static int motorSpeed = 200;
//Créer une méthode statique
public static void main(String[] args) {
l_a.setSpeed(motorSpeed);
l_b.setSpeed(motorSpeed);
//Répéter le traitement 10 fois
for(int i = 0;i < 10;i++) {
//Génération d'instance
Random r = new Random();
//Sélectionnez au hasard un nombre compris entre 0 et 100
int random_value = r.nextInt(100);
System.out.println("random_value = " + random_value);
//10%Arrêtez avec une probabilité de
if(random_value < 10) {
stop();
//10%Tourner vers la droite avec une probabilité de
}else if(random_value < 20) {
turnRight();
//30%Tourner vers la gauche avec une probabilité de
}else if(random_value < 50) {
turnLeft();
//50%Probabilité d'avancer
}else {
forward();
}
}
}
//Définition de la méthode
public static void forward(){
l_a.forward();
l_b.forward();
Delay.msDelay(2000);
}
//Définition de la méthode
public static void turnRight(){
l_a.forward();
l_b.backward();
Delay.msDelay(1000);
}
//Définition de la méthode
public static void turnLeft(){
l_a.backward();
l_b.forward();
Delay.msDelay(1000);
}
//Définition de la méthode
public static void stop(){
l_a.stop(true);
l_b.stop();
Delay.msDelay(1000);
}
}
Point: ** Contrôle de probabilité ** Nous avons expliqué comment nous assurer que seules les chances d'aller de l'avant sont élevées. Cependant, si vous l'écrivez comme ci-dessous, ce ne sera pas ce que vous vouliez.
if(random_value < 100){
forward();
}else if(random_value < 50){
turnRight();
}else if(random_value < 20){
turnLeft();
}else{
stop();
}
C'est parce que le programme exécute les processus dans l'ordre du haut. Lorsque le nombre_aléatoire est déterminé, la première chose à vérifier si le nombre correspond à la condition est le haut «if (random_value <100)». Dans ce cas, tous les nombres satisfont à cette condition, donc seule la méthode forward () peut être exécutée.
◯ C'est un programme qui prend des éléments du tableau et définit la vitesse.
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;
public class tank05 {
private final static RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
private final static RegulatedMotor l_b = new EV3LargeRegulatedMotor(MotorPort.B);
//Créer une méthode statique
public static void main(String[] args) {
//Génération d'instance
//Déclaration du tableau et détermination du nombre d'éléments
int[] speed_list = new int[5];
//Initialisation des éléments
speed_list[0] = 500;
speed_list[1] = 1000;
speed_list[2] = 1500;
speed_list[3] = 2000;
speed_list[4] = 2500;
//Le processus est répété 5 fois et i est ajouté de 1 à chaque fois.
for (int i = 0;i < 5;i++) {
//Utiliser les éléments d'un tableau
//count = 0 : speed =S'affiche sous la forme 1500
System.out.println("count = " + i + ":" + "speed = " + speed_list[i]);
l_a.setSpeed(speed_list[i]);
l_b.setSpeed(speed_list[i]);
l_a.forward();
l_b.forward();
Delay.msDelay(3000);
}
l_a.stop(true);
l_b.stop();
}
}
Point: ** Comment utiliser le tableau ** Utilisez la baie dans la procédure suivante.
Point: ** Initialisation des éléments du tableau **
Il existe plusieurs manières d'initialiser les éléments d'un tableau. Si vous souhaitez stocker des éléments réguliers dans un tableau, vous pouvez le combiner avec une boucle comme suit.
for(int i = 0;i < 5;i++){
//speed_list = [500,1000,1500,2000,2500]
speed_list[i] = 500*(i+1);
}
Merci pour la lecture! !! La prochaine fois, j'aimerais écrire sur le contrôle de plusieurs moteurs!
Je veux faire un meilleur article ◯ C'est plus facile à comprendre ◯ C'est difficile à comprendre ◯ C'est faux ◯ Je veux que vous expliquiez plus ici Nous apprécions vos opinions et suggestions.
Recommended Posts