Cet article s'adresse à ceux qui souhaitent travailler avec ev3 en Java. Cette fois, j'aimerais contrôler le moteur de différentes manières.

table des matières

Quoi préparer
Structure du code
Contrôle du moteur L 2-0. Programme pour faire tourner le moteur L pendant une certaine période de temps 2-1. Programme pour faire tourner le moteur L d'un certain angle 2-2. Programme d'accélération du moteur L 3-3. Programmes utilisant des boucles for 2-4. Programmes utilisant des boucles while 2-5. Programmes utilisant if et else
Contrôle du moteur M finalement

0. Quoi préparer

◯ ev3 (bloc intelligent) ◯ Moteur L / Moteur M ◯ PC (éclipse) ◯ bluetooth ◯ microSD ◯ Documentation API (Il est recommandé de continuer tout en regardant ceci.)

1. Structure du code

◯ Le programme utilisé cette fois est à peu près comme ça. Parlons d'abord de cette forme.

`templete.java`


//Préparer le matériel pour le programme
import package.Class;

//Créer une classe
public class Nom de classe{

	//Créer une méthode statique
    public static void main(String[] args) {

        //Génération d'instance
Objet de classe=nouvelle classe();
        
        //Utiliser la méthode
objet.Méthode();
    }
}

Point :import C'est pour se procurer les matériaux (morceaux de code) nécessaires à la programmation. Écrivez en tant que `ʻimport package.Class``.

Par exemple, ʻimport lejos.hardware.motor.EV3LargeRegulatedMotor`` signifie rechercher la classe ʻEV3LargeRegulatedMotor dans le paquet` `lejos.hardware.motor.

Point: ** Classe ** Une collection de champs et de méthodes connexes. (Exemple)

classe publique humaine{
    //champ
hauteur du flotteur;
poids flottant;
capacité de chant flottant;
    //Méthode
public vide sommeil(){};
public vide manger(){};
parler du vide public(){};
public void chanter(){};
}

Point: ** méthode statique ** ** Une méthode (fonction) qui peut être appelée sans instancier une classe.

Article de référence Explication de la méthode principale, ses arguments (args) et valeur de retour Expliquez soigneusement la méthode statique de Java! Apprenons ensemble des exemples d'utilisation et des idées!

Point: ** Instance ** C'est une matérialisation (objet) de la classe. L'instance a ** champs et méthodes que la classe a **. Vous pouvez créer plusieurs instances à partir d'une classe.

Point: ** Créer une instance ** Créer un objet à partir d'une classe. Créez une instance comme suit.

Objet de classe=nouvelle classe(constructeur)

Faire. Le constructeur vous permet de ** créer un objet avec individualité ** à partir d'une classe.

** (Exemple) ** Faire du Takeshi Gouda à partir de gens de classe

Takeshi Gouda=nouvel humain(la taille= 157,poids= 70,Compétence en tant que chanteur= 0);

[Article de référence]: Interface implémentée! Comment utiliser les outils en Java

Point: ** Point (.) ** Le point (.) Signifie ** aller à l'intérieur **. Les points vous permettent d'accéder aux champs et aux méthodes d'un objet.

Takeshi Gouda.chanter();

2. Contrôle du moteur L

2-0. Programme pour faire tourner le moteur L pendant une certaine période de temps

◯ Programme pour faire tourner et arrêter le moteur L pendant 5 secondes

`lmotor00.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 lmotor00 {

	//Créer une méthode statique
    public static void main(String[] args) {

        //Génération d'instance
        RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
        
        //Réglez sur une vitesse qui tourne de 720 degrés par seconde
        l_a.setSpeed(720);
        //Faire tourner le moteur vers l'avant
        l_a.forward();
        //5000 millisecondes(5 secondes)Etre prêt=Continuer le traitement
        Delay.msDelay(5000);
        //Arrêtez le moteur
        l_a.stop();
    }
}

Point: ** Classe. Méthode ** msDelay () est une ** méthode statique **, vous pouvez donc l'utiliser sans utiliser d'instance.

[Article de référence] Expliquez soigneusement la méthode statique de Java! Apprenons ensemble des exemples d'utilisation et des idées! Quels sont les avantages des méthodes statiques

Point : setSpeed() Une méthode qui détermine la vitesse de rotation du moteur. Dans l'argument, spécifiez l'angle à faire pivoter en 1 seconde.

Point : forward() Une méthode de rotation du moteur dans le sens positif. S'il n'y a pas de méthode pour s'arrêter, il continue de tourner.

2-1. Programme pour faire tourner le moteur L d'un certain angle

◯ Programme pour faire tourner le moteur de 1080 degrés

`lmotor01.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 lmotor01 {

	//Créer une méthode statique
    public static void main(String[] args) {

        //Génération d'instance
        RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
        
        //Réglez sur une vitesse qui tourne de 360 degrés par seconde
        l_a.setSpeed(360);
        //Faites pivoter le moteur de 1080 degrés dans le sens négatif
        l_a.rotate(-1080);
    }
}

Point : rotate() Faire pivoter de l'angle spécifié par l'argument La rotation s'arrête lorsque le traitement est terminé

2-2. Programme pour accélérer le moteur L

◯ C'est un programme qui accélère progressivement le moteur L.

`lmotor02.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 lmotor02 {

	//Créer une méthode statique
    public static void main(String[] args) {

        //Génération d'instance
        RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);

        //Réglez la vitesse au maximum
        l_a.setSpeed((int) l_a.getMaxSpeed());
        //Réglez l'accélération sur 100(La vitesse initiale est lente et accélère)
        l_a.setAcceleration(100);
        l_a.rotate(7200);
        //Réglez l'accélération sur 9000(Accélérez à la fois)
        l_a.setAcceleration(9000);
        l_a.rotate(-7200);
    }
}

Point: ** Accélération ** L'accélération est ** le taux de changement de vitesse par unité de temps **. L'unité ** degrés / s / s ** de l'argument de la méthode setAcceleration () indique combien la vitesse angulaire [degrés / s] change en ** 1 seconde [s] **. (Exemple) Lors d'un changement de 100 degrés par seconde

temps[s]	0	1	2	3	4	5	6	7	8	9	10
vitesse angulaire[degrees/s]	0	100	200	300	400	500	600	700	800	900	1000
accélération[degrees/s/s]	0	100	100	100	100	100	100	100	100	100	100

Point : getMaxSpeed() Une méthode qui renvoie la valeur de vitesse maximale. La vitesse maximale dépend également du montant de la charge.

Point : setAcceleration() Une méthode qui détermine le degré d'accélération. Plus la valeur est petite, plus l'accélération est lente.

2-3. Programmes utilisant des boucles for

◯ Un programme qui augmente la vitesse toutes les 2 secondes

`lmotor03.java`


import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;

//Créer une classe
public class lmotor03 {

	//Créer une méthode statique
    public static void main(String[] args) {

        //Génération d'instance
        RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);
 
        //i <Augmentez i de 100 en remplissant 1000
        for(int i = 10 ; i < 1000 ; i += 100) {
        	//Régler la vitesse sur i
        	l_a.setSpeed(i);
        	l_a.forward();
        	Delay.msDelay(2000);
        }
        //Arrêtez le moteur après avoir quitté la boucle for
        l_a.stop();
    }
}

Point: ** pour la boucle ** Répétez le processus tant que «i <seuil» est vrai. À chaque traitement, i est ajouté (soustrait).

for(int i =valeur initiale;i <Seuil; i +=Augmentation Diminution){
En traitement
}

2-4. Programmes utilisant des boucles while

◯ C'est un programme qui accélère le moteur L toutes les 2 secondes.

`lmotor04.java`


import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;

//Créer une classe
public class lmotor04 {

	//Créer une méthode statique
    public static void main(String[] args) {

        //Génération d'instance
        RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);

        //Définir une variable de type entier s
        int s = 0; 
        //s <Lors de la réunion de 1000{}Répétez le processus à l'intérieur
        while(s < 1000) {
        	//Réglez la vitesse sur s
        	l_a.setSpeed(s);
        	l_a.forward();
        	Delay.msDelay(2000);
        	//s = s + 100
        	s += 100;
        }
        //Arrêtez le moteur après avoir quitté la boucle while
        l_a.stop();
    }
}

Point: ** boucle while ** C'est un mécanisme pour définir une condition et répéter le processus pendant que la condition est vraie.

while(conditions){
En traitement;
}

2-5. Programmes utilisant if et else

◯ C'est un programme qui accélère le moteur L toutes les 2 secondes. Cependant, ** si le bouton central du bloc intelligent est enfoncé **, la boucle se termine.

`lmotor05.java`


import lejos.hardware.Button;
import lejos.hardware.motor.EV3LargeRegulatedMotor;
import lejos.hardware.port.MotorPort;
import lejos.robotics.RegulatedMotor;
import lejos.utility.Delay;

//Créer une classe
public class lmotor05 {

	//Créer une méthode statique
    public static void main(String[] args) {

        //Génération d'instance
        RegulatedMotor l_a = new EV3LargeRegulatedMotor(MotorPort.A);

        //Définir une variable de type entier s
        int s = 0; 
        //s <Lors de la réunion de 1000{}Répétez le processus à l'intérieur
        while(s < 1000) {
        	//Si le bouton central est enfoncé
        	if(Button.getButtons() == 2) {
        		//Traitement de la boucle de fin
        		break;
        	//Si le bouton central n'est pas enfoncé
        	}else {
            //Réglez la vitesse sur s
        	l_a.setSpeed(s);
        	l_a.forward();
        	Delay.msDelay(2000);
        	//s = s + 100
        	s += 100;
        	}
        }
        //Arrêtez le moteur après avoir quitté la boucle while
        l_a.stop();
    }
}

Point : if,else Si la condition est vraie, le processus 1 est exécuté, sinon le processus 2 est exécuté.

if(conditions){
Processus 1;
}else{
Processus 2;
}

Les autres instructions utilisant if sont les suivantes.

if(conditions){
En traitement;
}

if(Condition a){
Processus 1;
}else if(Condition b){
Processus 2;

if(Condition a){
Processus 1;
}else if(Condition b){
Processus 2;
}else{
Processus 3;
}

Point : Button.getButtons() Une méthode statique qui renvoie la valeur entière correspondant au bouton enfoncé. Chaque bouton du bloc intelligent reçoit ** un numéro **. Table de correspondance entre les boutons et les valeurs entières ```If (Button.getButtons () == 2) `` signifie ** si le bouton central est enfoncé ** depuis la table de correspondance.

Point : break Ceci est une instruction pour terminer la boucle.

3. Contrôle du moteur M

C'est le même que le moteur L sauf qu'il utilise la classe EV3MediumRegulatedMotor.

//Génération d'instance
RegulatedMotor m_a = new EV3MediumRegulatedMotor(MotorPort.A);

finalement

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.

[ev3 × Java] Commande de moteur unique