4.4.5 Structuri repetitive

Structurile repetitive le folosim pentru a repeta execuția unor instrucțiuni atât timp cât o condiție este adevărată. de exemplu atât timp opMode instructiunile din bucla se vor executa in mod repetat

while (opModeIsActive()) {

    //Daca timpul scurs este mai mare decat 3 secunde(3000 milisecunde)
    //robotul se va deplase in fata, apoi va sta 2 secunde(2000 milisecunde)
    //si se va opri

    telemetry.addData("Spot", spot);
    telemetry.update();

    if(!displaced) {

        motorStangaFata.setPower(-0.3);
        motorStangaSpate.setPower(0.3);
        motorDreaptaFata.setPower(0.3);
        motorDreaptaSpate.setPower(-0.3);

        sleep(1500);

        if(spot == 1){
            motorStangaFata.setPower(-0.3);
            motorStangaSpate.setPower(0.3);
            motorDreaptaFata.setPower(-0.3);
            motorDreaptaSpate.setPower(0.3);
        }
        else if(spot == 3){
            motorStangaFata.setPower(0.3);
            motorStangaSpate.setPower(-0.3);
            motorDreaptaFata.setPower(0.3);
            motorDreaptaSpate.setPower(-0.3);
        }

        sleep(1500);

        motorStangaFata.setPower(0);
        motorStangaSpate.setPower(0);
        motorDreaptaFata.setPower(0);
        motorDreaptaSpate.setPower(0);
        displaced = true;
    }

Structura repetitiva cu număr fix de pași – for

for(i=1;i<=10;i++)

System.out.println(i);//afiseaza numerele de la 1 la 10, fiecare pe cate un rand

Structura repetitivă cu test inițial – while

i=1;

while(i<=10)

{System.out.println(i); i++;}// afiseaza numerele de la 1 la 10, fiecare pe cate un rand

Strucutură repetitivă cu test final – do { } while();

i=1;

do

{System.println.out(i);i++;}

while(i<10);// afiseaza numerele de la 1 la 10, fiecare pe cate un rand

Structurile repetitive sunt esențiale în programarea pentru FTC, deoarece permit executarea repetată a unui bloc de cod până când o anumită condiție este îndeplinită. În Java, cele mai comune structuri repetitive sunt while, for și do-while.

1. Bucla while

Bucla while repetă un bloc de cod atâta timp cât o condiție specificată este adevărată. Este utilă pentru bucle infinite controlate de o condiție de oprire.

Sintaxa

while (condiție) {
    // Codul care se execută repetat
}

Exemplu în Contextul FTC

Un exemplu comun de utilizare a buclei while în FTC este așteptarea unui anumit eveniment, cum ar fi apăsarea unui buton pe gamepad:

public class WaitForButtonOpMode extends LinearOpMode {

    @Override
    public void runOpMode() {
        waitForStart();

        // Așteaptă până când butonul 'A' de pe gamepad este apăsat
        while (opModeIsActive() && !gamepad1.a) {
            telemetry.addData("Status", "Waiting for button A");
            telemetry.update();
        }

        telemetry.addData("Status", "Button A pressed, continuing...");
        telemetry.update();

        // Alte instrucțiuni de control al robotului pot urma aici
    }
}

2. Bucla for

Bucla for este utilizată atunci când numărul de repetări este cunoscut dinainte. Este utilă pentru iterații care necesită un contor.

Sintaxa

for (inițializare; condiție; incrementare) {
    // Codul care se execută repetat
}

Exemplu în Contextul FTC

În contextul FTC, o buclă for poate fi utilizată pentru a itera printr-o serie de acțiuni, cum ar fi verificarea unui set de senzori:

public class CheckSensorsOpMode extends LinearOpMode {

    private ColorSensor[] colorSensors;

    @Override
    public void runOpMode() {
        // Inițializarea senzorilor de culoare
        colorSensors = new ColorSensor[3];
        colorSensors[0] = hardwareMap.get(ColorSensor.class, "sensor1");
        colorSensors[1] = hardwareMap.get(ColorSensor.class, "sensor2");
        colorSensors[2] = hardwareMap.get(ColorSensor.class, "sensor3");

        waitForStart();

        // Verifică fiecare senzor de culoare
        for (int i = 0; i < colorSensors.length; i++) {
            telemetry.addData("Sensor " + i + " Red", colorSensors[i].red());
            telemetry.addData("Sensor " + i + " Blue", colorSensors[i].blue());
        }
        telemetry.update();
    }
}

3. Bucla do-while

Bucla do-while este similară cu bucla while, dar condiția este verificată la sfârșitul buclei. Astfel, codul din interiorul buclei se execută cel puțin o dată.

Sintaxa

do {
    // Codul care se execută repetat
} while (condiție);

Exemplu în Contextul FTC

Un exemplu de utilizare a buclei do-while în FTC este repetarea unei acțiuni până când o anumită condiție devine falsă:

public class DoWhileOpMode extends LinearOpMode {

    private DcMotor motor;

    @Override
    public void runOpMode() {
        motor = hardwareMap.get(DcMotor.class, "motor");

        waitForStart();

        // Rulează motorul până când butonul 'B' de pe gamepad este apăsat
        do {
            motor.setPower(0.5);

            telemetry.addData("Status", "Motor running");
            telemetry.update();
        } while (opModeIsActive() && !gamepad1.b);

        motor.setPower(0); // Oprește motorul
        telemetry.addData("Status", "Motor stopped");
        telemetry.update();
    }
}

Sfaturi pentru Utilizarea Structurilor Repetitive în FTC

1. Asigurarea Condiției de Oprire: Este important să te asiguri că există o condiție de oprire pentru a evita buclele infinite care pot bloca programul.
2. Utilizarea Telemetriei: Utilizează telemetria pentru a monitoriza valorile și stările în interiorul buclelor. Acest lucru ajută la debugging și la înțelegerea comportamentului robotului.
3. Structurarea Codului: Păstrează buclele concise și ușor de înțeles. Dacă o buclă devine prea complexă, consideră să o separi în funcții sau metode mai mici.

Aceste structuri repetitive sunt instrumente puternice care te ajută să controlezi eficient comportamentul robotului în competițiile FTC.