Command Based Programlama

Command Based programlama nedir?
WPILib, "Command Based programlama" adlı programlar yazma yöntemini destekler. Command Based programlama, robot programlarınızı düzenlemenize yardımcı olacak bir tasarım modelidir. Diğer masaüstü programlarından farklı olabilecek bazı robot programlarının özellikleri şunlardır:
Faaliyetler zamanla gerçekleşir, örneğin bir Frizbi çekmek veya bir asansör yükseltmek ve bir hedefe bir tüp yerleştirmek için bir dizi adım.
Bu aktiviteler eşzamanlı olarak gerçekleşir, bu da robot performansını arttırmak için bir asansör, bilek ve kavrayıcının hepsi aynı zamanda bir alma pozisyonuna hareket etmesi istenebilir.
Robot mekanizmalarını ve aktivitelerini, robotunuzu hata ayıklamaya yardımcı olmak için ayrı ayrı test etmek istenebilir.
Çoğu zaman programın son dakikada belki de yarışmalarda ek otonom programlarla güçlendirilmesi gerekir, bu nedenle kolayca genişletilebilir kod önemlidir.
Command based programlama, robot programını daha az yapılandırılmış bir teknik kullanmaktan çok daha basit hale getirmek için tüm bu hedefleri kolayca destekler.
Komutlar ve alt sistemler
WPILib kütüphanesine dayalı programlar iki temel kavram etrafında düzenlenmiştir: Alt Sistemler ve Komutlar.
Alt sistemler - robotun her bir parçasının yeteneklerini tanımlar ve Alt Sistemin alt sınıflarıdır.
Komutlar - alt sistemlerde tanımlanan yetenekleri içeren robotun çalışmasını tanımlar. Komutlar Komut veya KomutGrup alt sınıflarıdır. Komutlar, zamanlanmış veya SmartDashboard'dan basılan düğmelere veya sanal düğmelere yanıt olarak çalışır.
Komutlar nasıl çalışır
Komutlar, robotu küçük parçalar halinde çalıştırmanın görevlerini çözmenizi sağlar. Her komutun, bazı çalışma yapan bir execute () yöntemi ve tamamlandığını söyleyen isFinished () yöntemi vardır. Bu, sürücü istasyonundan veya her 20 ms'den bir güncellemede gerçekleşir. Komutlar birlikte gruplandırılabilir ve sıralı olarak gerçekleştirilebilir, bir önceki grupta olduğu gibi grupta bir sonraki başlar.
 Eşzamanlılık
Bazen eşzamanlı olarak gerçekleşen çeşitli operasyonların olması arzu edilir. Önceki örnekte, asansör hareket ederken bileğerin konumunu ayarlamak isteyebilirsiniz. Bu durumda bir komut grubu çalışan bir paralel komut (veya komut grubu) başlatabilir.
Nasıl Çalışır - Komutları Zamanlama
Komutların planlandığı üç ana yol vardır:
​
1.
Elle, komut üzerindeki start () yöntemini çağırarak (otonom olarak kullanılır)
2.
Programlayıcı tarafından otomatik olarak kodda belirtilen düğme / tetikleme eylemlerine dayanır (genellikle OI sınıfında tanımlanır ancak Zamanlayıcı tarafından kontrol edilir).
3.
Bir önceki komut tamamlandığında otomatik olarak (varsayılan komutlar ve komut grupları).
Sürücü istasyonu yeni veriler aldığında, robot programınızın periyodik yöntemi denir. Herhangi bir komutun planlanması veya iptal edilmesi gerekip gerekmediğini görmek için tetikleyici koşullarını kontrol eden bir Zamanlayıcı çalıştırır.
Bir komut zamanlandığında, Zamanlayıcı, başka hiçbir komutun, yeni komutun gerektirdiği aynı alt sistemleri kullanmadığından emin olmayı denetler. Alt sistemlerden biri veya daha fazlası şu anda kullanılıyorsa ve geçerli komut kesilirse, kesintiye uğrayacak ve yeni komut zamanlanacaktır. Geçerli komut kesilmezse, yeni komut programlanamaz.
Nasıl Çalışır - Komutları Çalıştırma
Yeni komutları kontrol ettikten sonra, programlayıcı aktif komutlar listesinden geçer ve her komutta execute () ve isFinished () yöntemlerini çağırır. Görünür eşzamanlı yürütmenin, programa karmaşıklık katacak iş parçacıkları veya görevler kullanılmadan gerçekleştirildiğine dikkat edin. Her bir komutun basitçe, hedefine doğru ilerlemek için bir kod (yürütme yöntemi) ve komutun hedefe ulaşıp ulaşmadığını belirleyen bir yöntem (isFinished) vardır. Execute ve isFinished yöntemleri tekrar tekrar denir.
Komut grupları
Daha basit komutlardan daha karmaşık komutlar oluşturulabilir. Örneğin, bir diski çekmek, birbiri ardına yürütülen uzun bir komut dizisi olabilir. Belki sıradaki bu komutların bazıları eşzamanlı olarak yürütülebilir. Komut grupları komutlardır, ancak bir Tamamlanmamış ve yürütme yöntemine sahip olmak yerine, yürütmek için başka komutların bir listesi vardır. Bu, daha basit işlemlerden daha karmaşık işlemlerin oluşturulmasına olanak tanır, programlamada temel bir ilkedir. Bireysel küçük komutların her biri önce kolayca test edilebilir, daha sonra grup test edilebilir. Komut grupları hakkında daha fazla bilgi, Komut grubu oluşturma komutları makalesinde bulunabilir.
Bir robot projesi oluşturma
Eclipse eklentileri ile sağlanan şablon projelerinden birini kullanarak bir komut tabanlı robot projesi oluşturun.

Proje Oluştur
Proje gezgini penceresinde boş bir alanda sağ tıklayın. "New" i ve ardından "Project ..." i seçin.
Proje tipinin seçilmesi
Gerekirse WPILib Robot C ++ veya Java Geliştirme klasörlerini genişletin ve uygun proje türünü seçin, Robot C ++ veya Java Project. Sadece yüklediğiniz eklentinin seçeneklerini göreceksiniz.
Örnek Bir Proje Seçmek
Proje isminizi kutuya yazıp Command-Based Robot için radyo düğmesini seçin.
Proje Gezgini penceresindeki örnek projeye bakın
 CommandBasedRobotTemplate projesinin Project Explorer penceresinde bulunmuş olabilecek diğer projelere eklendiğine dikkat edin. Komutlar için bir klasör ve Alt sistemler için başka bir klasör var.
Projeye Komut ve Alt Sistemlerin Eklenmesi
Komutlar ve Altsistemler her biri sınıf olarak oluşturulur. Eklenti, programınıza eklemenizi kolaylaştırmak için hem Komutlar hem de Alt Sistemler için yerleşik şablonlara sahiptir.
Projeye alt sistemler ekleme
Bir alt sistem eklemek için, proje adına sağ tıklayın ve açılan menüden "new" ve "Subsystem" i seçin.
Alt sistemi adlandırma
Alt sistem için bir ad doldurun. Bu alt sistem için sonuçta ortaya çıkan sınıf adı olacaktır, bu nedenle adınız sizin diliniz için geçerli bir sınıf adı olmalıdır.
Projede oluşturulan alt sistem
Projedeki Subsystems klasöründe oluşturulan yeni alt sistemi görebilirsiniz. Alt sistemler oluşturma hakkında daha fazla bilgi için Basit alt sistemler makalesine bakın.
Projeye bir komut eklemek
Bir alt sistem oluşturmaya benzer adımlar kullanarak proje için bir komut oluşturulabilir. Proje Gezgini'nde proje adına ilk olarak sağ tıklayın ve new -> Command seçin.

Komut adını ayarla
Komut adını iletişim kutusundaki "Class Name" alanına girin. Bu, Komuta için sınıf adı olacaktır, bu nedenle diliniz için geçerli bir sınıf adı olmalıdır.
Komut projede oluşturuldu
Komutun Proje Gezgini penceresinde projedeki Komutlar klasöründe oluşturulduğunu görebilirsiniz. Komut oluşturma hakkında daha fazla bilgi için Basit Komutlar Oluşturma makalesine bakın.
Basit Alt Sistemler
Bir alt sistem oluşturma
1
Java
2
​
3
import edu.wpi.first.wpilibj.*;
4
import edu.wpi.first.wpilibj.command.Subsystem;
5
import org.usfirst.frc.team1.robot.RobotMap;
6
​
7
public class Claw extends Subsystem {
8
​
9
	Victor motor = RobotMap.clawMotor;
10
​
11
    public void initDefaultCommand() {
12
    }
13
​
14
    public void open() {
15
    	motor.set(1);
16
    }
17
​
18
    public void close() {
19
    	motor.set(-1);
20
    }
21
​
22
    public void stop() {
23
    	motor.set(0);
24
    }
25
}
26
​
Copied!
Bu bir robot üzerinde bir pençe çalışan oldukça basit bir alt sisteme bir örnektir. Pençe mekanizması, pençeyi açmak ve kapatmak için tek bir motora sahiptir ve sensörler yoktur (pratikte mutlaka iyi bir fikir değildir, ancak örnek için çalışır). Buradaki fikir, açık ve kapalı işlemlerin basitçe zamanlanmasıdır. Pençe motorunu çalıştıran üç yöntem vardır, open (), close () ve stop (). Çenenin açılıp kapanmadığını kontrol eden belirli bir kodun bulunmadığına dikkat edin. Açık yöntem, tırnağı açık yönde hareket ettirir ve yakın yöntem, pençenin yakın yönde hareket etmesini sağlar. Pençenin belirli bir süre boyunca açılıp kapanmasını sağlamak için bu işlemin zamanlamasını kontrol etmek için bir komut kullanın.
Pençeyi bir komutla çalıştırma
1
​
2
Java
3
​
4
package org.usfirst.frc.team1.robot.commands;
5
​
6
import edu.wpi.first.wpilibj.command.Command;
7
import org.usfirst.frc.team1.robot.Robot;
8
/**
9
 *
10
 */
11
public class OpenClaw extends Command {
12
​
13
    public OpenClaw() {
14
        requires(Robot.claw);
15
        setTimeout(.9);
16
    }
17
​
18
    protected void initialize() {
19
    	Robot.claw.open()
20
    }
21
​
22
    protected void execute() {
23
    }
24
​
25
    protected boolean isFinished() {
26
        return isTimedOut();
27
    }
28
​
29
    protected void end() {
30
    	Robot.claw.stop();
31
    }
32
​
33
    protected void interrupted() {
34
    	end();
35
    }
36
}
37
​
Copied!
Komutlar, alt sistemlerin işlemlerinin zamanlamasını sağlar. Her komut alt sistemle farklı bir işlem yapar. Komutlar, açma veya kapama için zamanlamayı sağlar. İşte pençenin açılmasını kontrol eden basit bir Komutanlık örneği. Bu komut için bir zaman aşımı ayarlandığına dikkat edin (0.9 saniye), pençenin açılmasını ve isFinished () yöntemindeki süreyi kontrol etmeyi zamanlamak için. Komutları kullanma hakkında makalede daha fazla ayrıntı bulabilirsiniz.
Yerleşik PID kontrolü için PIDSubsystems
Bir bilek ekleminin açısını kontrol etmek için bir PIDSubsystem
Bu örnekte, bilek eklemi için bir PIDSubsystem'in temel öğelerini görebilirsiniz:
​
1
Java
2
​
3
package org.usfirst.frc.team1.robot.subsystems;
4
import edu.wpi.first.wpilibj.*;
5
import edu.wpi.first.wpilibj.command.PIDSubsystem;
6
import org.usfirst.frc.team1.robot.RobotMap;
7
​
8
​
9
public class Wrist extends PIDSubsystem { // This system extends PIDSubsystem
10
​
11
	Victor motor = RobotMap.wristMotor;
12
	AnalogInput pot = RobotMap.wristPot();
13
​
14
	public Wrist() {
15
		super("Wrist", 2.0, 0.0, 0.0);// The constructor passes a name for the subsystem and the P, I and D constants that are used when computing the motor output
16
		setAbsoluteTolerance(0.05);
17
		getPIDController().setContinuous(false);
18
	}
19
	
20
    public void initDefaultCommand() {
21
    }
22
​
23
    protected double returnPIDInput() {
24
    	return pot.getAverageVoltage(); // returns the sensor value that is providing the feedback for the system
25
    }
26
​
27
    protected void usePIDOutput(double output) {
28
    	motor.pidWrite(output); // this is where the computed output value fromthe PIDController is applied to the motor
29
    }
30
}
31
​
Copied!
Basit Komutlar Oluşturma
Bu makalede, bir Komutun temel biçimi açıklanmakta ve robotunuzu Joystick'lerle sürmek için bir komut oluşturma örneği sunulmaktadır.
Temel Komut Biçimi
Bir komutu uygulamak için, WPILib Command sınıfından bir takım yöntemler geçersiz kılınır. Yöntemlerin çoğu, kazan plakasıdır ve çoğu zaman göz ardı edilebilir, ancak ihtiyacınız olduğunda maksimum esneklik için vardır. Bu temel komut sınıfında birkaç parça var:
​
1
C++
2
​
3
#include "MyCommandName.h"
4
​
5
/*
6
	 * 1.	Constructor - Might have parameters for this command such as target positions of devices. Should also set the name of the command for debugging purposes.
7
	 *  This will be used if the status is viewed in the dashboard. And the command should require (reserve) any devices is might use.
8
	 */
9
MyCommandName::MyCommandName() : CommandBase("MyCommandName") 
10
{
11
	Requires(Elevator);
12
}
13
​
14
// initialize() - This method sets up the command and is called immediately before the command is executed for the first time and 
15
// every subsequent time it is started . Any initialization code should be here.
16
void MyCommandName::Initialize()
17
{
18
​
19
}
20
​
21
/*
22
 *	execute() - This method is called periodically (about every 20ms) and does the work of the command. Sometimes, if there is a position a
23
 *  subsystem is moving to, the command might set the target position for the subsystem in initialize() and have an empty execute() method.
24
 */
25
void MyCommandName::Execute()
26
{
27
​
28
}
29
​
30
bool MyCommandName::IsFinished()
31
{
32
	return false;
33
}
34
​
35
void MyCommandName::End()
36
{
37
​
38
}
39
​
40
// Make this return true when this Command no longer needs to run execute()
41
void MyCommandName::Interrupted()
42
{
43
​
44
}
45
​
Copied!
1
Java
2
​
3
public class MyCommandName extends Command {
4
​
5
	/*
6
	 * 1.	Constructor - Might have parameters for this command such as target positions of devices. Should also set the name of the command for debugging purposes.
7
	 *  This will be used if the status is viewed in the dashboard. And the command should require (reserve) any devices is might use.
8
	 */
9
    public MyCommandName() {
10
    	super("MyCommandName");
11
        requires(elevator);
12
    }
13
​
14
    // 	initialize() - This method sets up the command and is called immediately before the command is executed for the first time and every subsequent time it is started .
15
    //  Any initialization code should be here. 
16
    protected void initialize() {
17
    }
18
​
19
    /*
20
     *	execute() - This method is called periodically (about every 20ms) and does the work of the command. Sometimes, if there is a position a
21
     *  subsystem is moving to, the command might set the target position for the subsystem in initialize() and have an empty execute() method.
22
     */
23
    protected void execute() {
24
    }
25
​
26
    // Make this return true when this Command no longer needs to run execute()
27
    protected boolean isFinished() {
28
        return false;
29
    }
30
}
31
​
Copied!
Basit Komut Örneği
Bu örnek, robotun tank tahriklerini kullanarak joysticklerin sağladığı değerlerle sürecek basit bir komutu göstermektedir.


1
C++
2
​
3
#include "DriveWithJoysticks.h"
4
#include "RobotMap.h"
5
​
6
DriveWithJoysticks::DriveWithJoysticks() : CommandBase("DriveWithJoysticks")
7
{
8
	Requires(Robot::drivetrain); // Drivetrain is our instance of the drive system
9
}
10
​
11
// Called just before this Command runs the first time
12
void DriveWithJoysticks::Initialize()
13
{
14
​
15
}
16
​
17
    /*
18
     * execute() - In our execute method we call a tankDrive method we have created in our subsystem. This method takes two speeds as a parameter which we get from methods in the OI class.
19
     * These methods abstract the joystick objects so that if we want to change how we get the speed later we can do so without modifying our commands
20
     * (for example, if we want the joysticks to be less sensitive, we can multiply them by .5 in the getLeftSpeed method and leave our command the same).
21
     */
22
void DriveWithJoysticks::Execute()
23
{
24
	Robot::drivetrain->Drive(Robot::oi->GetJoystick());
25
}
26
​
27
    /*
28
     * isFinished - Our isFinished method always returns false meaning this command never completes on it's own. The reason we do this is that this command will be set as the default command for the subsystem. This means that whenever the subsystem is not running another command, it will run this command. If any other command is scheduled it will interrupt this command, then return to this command when the other command completes.
29
     */
30
bool DriveWithJoysticks::IsFinished()
31
{
32
	return false;
33
}
34
​
35
void DriveWithJoysticks::End()
36
{
37
	Robot::drivetrain->Drive(0, 0);
38
}
39
​
40
// Called when another command which requires one or more of the same
41
// subsystems is scheduled to run
42
void DriveWithJoysticks::Interrupted()
43
{
44
	End();
45
}
46
​
Copied!
1
Java
2
​
3
public class DriveWithJoysticks extends Command {
4
​
5
    public DriveWithJoysticks() {
6
    	requires(drivetrain);// drivetrain is an instance of our Drivetrain subsystem
7
    }
8
​
9
    protected void initialize() {
10
    }
11
​
12
    /*
13
     * execute() - In our execute method we call a tankDrive method we have created in our subsystem. This method takes two speeds as a parameter which we get from methods in the OI class.
14
     * These methods abstract the joystick objects so that if we want to change how we get the speed later we can do so without modifying our commands
15
     * (for example, if we want the joysticks to be less sensitive, we can multiply them by .5 in the getLeftSpeed method and leave our command the same).
16
     */
17
    protected void execute() {
18
    	drivetrain.tankDrive(oi.getLeftSpeed(), oi.getRightSpeed());
19
    }
20
​
21
    /*
22
     * isFinished - Our isFinished method always returns false meaning this command never completes on it's own. The reason we do this is that this command will be set as the default command for the subsystem. This means that whenever the subsystem is not running another command, it will run this command. If any other command is scheduled it will interrupt this command, then return to this command when the other command completes.
23
     */
24
    protected boolean isFinished() {
25
        return false;
26
    }
27
​
28
    protected void end() {
29
    }
30
​
31
    protected void interrupted() {
32
    }
33
}
34
​
Copied!
Komut grupları oluşturma
Karmaşık bir işlem yapmak için bir komut oluşturma
​
1
C++
2
​
3
#include "PlaceSoda.h"
4
​
5
PlaceSoda::PlaceSoda()
6
{
7
	AddSequential(new SetElevatorSetpoint(TABLE_HEIGHT));
8
	AddSequential(new SetWristSetpoint(PICKUP));
9
	AddSequential(new OpenClaw());
10
}
11
​
12
​
Copied!
1
Java
2
​
3
public class PlaceSoda extends CommandGroup {
4
​
5
    public  PlaceSoda() {
6
    	addSequential(new SetElevatorSetpoint(Elevator.TABLE_HEIGHT));
7
    	addSequential(new SetWristSetpoint(Wrist.PICKUP));
8
    	addSequential(new OpenClaw());
9
    }
10
}
11
​
Copied!
Bu, bir sodayı masaya yerleştiren bir komut grubunun örneğidir. Bunu başarmak için, (1) robot elevatörü "TABLE_HEIGHT" a geçmeli, (2) bilek açısını ayarlamalı, ardından (3) tırnağı açmalıdır. Tüm bu görevler, sodanın düşemeyeceğinden emin olmak için sırayla çalıştırılmalıdır. AddSequential () yöntemi, bir komutu (veya komut grubunu) bir parametre olarak alır ve bu komut programlandığında bunları birbiri ardına yürütür.
Komutları paralel olarak çalıştırma
​
1
C++
2
​
3
#include "PrepareToGrab.h"
4
​
5
PrepareToGrab::PrepareToGrab()
6
{
7
	AddParallel(new SetWristSetpoint(PICKUP));
8
	AddParallel(new SetElevatorSetpoint(BOTTOM));
9
	AddParallel(new OpenClaw());
10
}
11
​
Copied!
1
Java
2
​
3
public class PrepareToGrab extends CommandGroup {
4
​
5
    public  PrepareToGrab() {
6
    	addParallel(new SetWristSetpoint(Wrist.PICKUP));
7
    	addParallel(new SetElevatorSetpoint(Elevator.BOTTOM));
8
    	addParallel(new OpenClaw());
9
    }
10
}
Copied!
Programı daha verimli hale getirmek için, çoğu kez aynı anda birden fazla komutun çalıştırılması istenir. Bu örnekte, robot bir soda alabilir. Robot hiçbir şey tutmadığından, tüm eklemler bir şey düşürmekten endişe etmeden aynı anda hareket edebilir. Burada tüm komutlar paralel olarak çalışır, böylece tüm motorlar aynı anda çalışır ve her isFinished () yöntemi çağrıldığında tamamlanır. Komutlar emredilemez. Adımlar şunlardır: (1) bileği başlatma ayar noktasına getirin, daha sonra (2) asansörü yerden teslim konumuna getirin ve (3) tırnağı açın.
Paralel ve sıralı komutları karıştırma
​
1
C++
2
​
3
#include "Grab.h"
4
​
5
Grab::Grab()
6
{
7
	AddSequential(new CloseClaw());
8
	AddParallel(new SetElevatorSetpoint(STOW));
9
	AddSequential(new SetWristSetpoint(STOW));
10
}
11
​
Copied!
1
Java
2
​
3
public class Grab extends CommandGroup {
4
​
5
    public  Grab() {
6
    	addSequential(new CloseClaw());
7
    	addParallel(new SetElevatorSetpoint(Elevator.STOW));
8
    	addSequential(new SetWristSetpoint(Wrist.STOW));
9
    }
10
}
Copied!
Genellikle, diğer parçaların çalıştırılmasından önce tamamlanması gereken bir komut grubunun bazı bölümleri vardır. Bu örnekte, bir soda kabı tutulur, daha sonra asansör ve bilek istiflenmiş konumlarına hareket edebilir. Bu durumda, el bileği ve asansörü, kap kapana kadar beklemek zorundadır, sonra bağımsız olarak çalışabilirler.
Joystick inputları ile komutları çalıştırma
Düğmeye basılı tutulduğunda kumanda düğmelerine basıldığında, serbest bırakıldığında veya sürekli olarak komutların çalışmasına neden olabilirsiniz. Bu sadece birkaç satırlık kod gerektiren yapmak için son derece kolaydır.
OI sınıfı
Komut tabanlı şablon, Operatör Arayüzü davranışlarının tipik olarak tanımlandığı OI.java'da bulunan OI adında bir sınıf içerir. Eğer RobotBuilder kullanıyorsanız bu dosya org.usfirst.frc ####. NAME paketinde bulunabilir.

Joystick nesnesini ve JoystickButton nesnelerini oluşturun
​
1
C++
2
​
3
OI::OI()
4
{
5
	joy = new Joystick(1);
6
​
7
	JoystickButton* button1 = new JoystickButton(joy, 1),
8
			button2 = new JoystickButton(joy, 2),
9
			button3 = new JoystickButton(joy, 3),
10
			button4 = new JoystickButton(joy, 4),
11
			button5 = new JoystickButton(joy, 5),
12
			button6 = new JoystickButton(joy, 6),
13
			button7 = new JoystickButton(joy, 7),
14
			button8 = new JoystickButton(joy, 8);
15
	
16
}
17
​
Copied!
1
Java
2
​
3
public class OI {
4
    // Create the joystick and the 8 buttons on it
5
	Joystick leftJoy = new Joystick(1);
6
	Button button1 = new JoystickButton(leftJoy, 1),
7
			button2 = new JoystickButton(leftJoy, 2),
8
			button3 = new JoystickButton(leftJoy, 3),
9
			button4 = new JoystickButton(leftJoy, 4),
10
			button5 = new JoystickButton(leftJoy, 5),
11
			button6 = new JoystickButton(leftJoy, 6),
12
			button7 = new JoystickButton(leftJoy, 7),
13
			button8 = new JoystickButton(leftJoy, 8);
14
	
15
}
Copied!
Bu örnekte Joystick 1 olarak bağlı bir Joystick nesnesi vardır. Daha sonra robotun çeşitli yönlerini kontrol etmek için bu joystick üzerinde 8 düğme tanımlanmıştır. Bu, test için özellikle yararlıdır, ancak SmartDashboard üzerindeki butonların üretilmesi komutların test edilmesi için başka bir alternatiftir.
Düğmeleri komutlarla ilişkilendirin
​
1
C++
2
​
3
	button1->WhenPressed(new PrepareToGrab());
4
	button2->WhenPressed(new Grab());
5
	button3->WhenPressed(new DriveToDistance(0.11));
6
	button4->WhenPressed(new PlaceSoda());
7
	button6->WhenPressed(new DriveToDistance(0.2));
8
	button8->WhenPressed(new Stow());
9
	
10
	button7->WhenPressed(new SodaDelivery());
11
​
Copied!
1
Java
2
​
3
	public OI() {
4
		button1.whenPressed(new PrepareToGrab());
5
		button2.whenPressed(new Grab());
6
		button3.whenPressed(new DriveToDistance(0.11));
7
		button4.whenPressed(new PlaceSoda());
8
		button6.whenPressed(new DriveToDistance(0.2));
9
		button8.whenPressed(new Stow());
10
		
11
		button7.whenPressed(new SodaDelivery());
12
	}
13
​
Copied!
Bu örnekte, önceki kod parçasından gelen joystick düğmelerinin çoğu, komutlarla ilişkilendirilmiştir. İlgili tuşa basıldığında komut çalıştırılır. Bu, özel eylemler yapmak için düğmeleri olan bir teleop programı oluşturmanın mükemmel bir yoludur.
Diğer seçenekler
 Yukarıda gösterilen "whenPressed ()" koşuluna ek olarak, düğmeleri komutlara bağlamak için kullanabileceğiniz birkaç başka koşul vardır:
Komutlar, bir düğme WhenPold () yerine whenReleased () kullanılarak serbest bırakıldığında çalışabilir.
Komutlar, whileHeld () öğesini çağırmak suretiyle tuşa basarken sürekli olarak çalışabilir.
ToggleWhenPressed () kullanılarak bir tuşa basıldığında komutlar değiştirilebilir.
CancelWhenPressed () kullanılarak bir tuşa basıldığında bir komut iptal edilebilir.
Ayrıca, komutlar, Düğme yerine Trigger sınıfını kullanarak seçiminizin keyfi koşulları tarafından tetiklenebilir. Tetikleyiciler (ve Düğmeler) genellikle her 20 ms'de veya zamanlayıcı çağrıldığında her zaman sorgulanır.
Otonom periyodu boyunca komutları çalıştırma
Otonom Periyodunda kullanılacak bir komut oluşturma
1
C++
2
​
3
	button1->WhenPressed(new PrepareToGrab());
4
	button2->WhenPressed(new Grab());
5
	button3->WhenPressed(new DriveToDistance(0.11));
6
	button4->WhenPressed(new PlaceSoda());
7
	button6->WhenPressed(new DriveToDistance(0.2));
8
	button8->WhenPressed(new Stow());
9
	
10
	button7->WhenPressed(new SodaDelivery());
11
​
Copied!
1
Java
2
​
3
	public OI() {
4
		button1.whenPressed(new PrepareToGrab());
5
		button2.whenPressed(new Grab());
6
		button3.whenPressed(new DriveToDistance(0.11));
7
		button4.whenPressed(new PlaceSoda());
8
		button6.whenPressed(new DriveToDistance(0.2));
9
		button8.whenPressed(new Stow());
10
		
11
		button7.whenPressed(new SodaDelivery());
12
	}
13
​
Copied!
Robotumuz, otonom dönemde aşağıdaki görevleri yerine getirmelidir: yerden bir soda alabilir, daha sonra bir masadan belirli bir mesafeyi sürdürebilir ve oradaki tenekeyi teslim edebilir. Süreci oluşur:
1.
Kapmak için hazırlayın (asansör, bilek ve kavrayıcıyı yerine hareket ettirin)
2.
Sodayı tutabilirsiniz.
3.
Ultrasonik telemetre ile gösterilen tablodan bir mesafeye kadar sürün
4.
Sodayı bırakın
5.
Uzaklık mesafesinden bir mesafeye geri dönüş
6.
Tutucuyu yeniden yerleştirmek
Bu görevleri yapmak için, bu örnekte gösterildiği gibi sırayla yürütülen 6 komut grubu vardır.
Otonom çalışacak şekilde bu komutu ayarlama
1
C++
2
​
3
Command* autonomousCommand;
4
​
5
class Robot: public IterativeRobot {
6
​
7
    /**
8
     * This function is run when the robot is first started up and should be
9
     * used for any initialization code.
10
     */
11
	void RobotInit()
12
	{
13
        // instantiate the command used for the autonomous period
14
		autonomousCommand = new SodaDelivery();
15
		oi = new OI();
16
​
17
	}
18
	
19
​
20
	void AutonomousInit()
21
	{
22
        // schedule the autonomous command (example)
23
		if(autonomousCommand != NULL) autonomousCommand->Start();
24
	}
25
	/*
26
	 * This function is called periodically during autonomous
27
	 */
28
	void AutonomousPeriodic()
29
	{
30
		Scheduler::GetInstance()->Run();
31
	}
32
​
Copied!
1
Java
2
​
3
public class Robot extends IterativeRobot {
4
​
5
​
6
​
7
    Command autonomousCommand;
8
​
9
    /**
10
     * This function is run when the robot is first started up and should be
11
     * used for any initialization code.
12
     */
13
    public void robotInit() {
14
		oi = new OI();
15
        // instantiate the command used for the autonomous period
16
        autonomousCommand = new SodaDelivery();
17
    }
18
​
19
    public void autonomousInit() {
20
        // schedule the autonomous command (example)
21
        if (autonomousCommand != null) autonomousCommand.start();
22
    }
23
​
24
    /**
25
     * This function is called periodically during autonomous
26
     */
27
    public void autonomousPeriodic() {
28
        Scheduler.getInstance().run();
29
    }
Copied!
SodaDelivery komutunu otonom program olarak çalıştırmak için
1.
Bunu RobotInit () yönteminde örneklendirin. RobotInit (), robot başladığında sadece bir kez çağrılır, böylece komut örneğini oluşturmak için iyi bir zaman olur.
2.
AutonomousInit () yöntemi sırasında başlatın. AutonomousInit (), otonom dönemin başlangıcında bir kez çağrılır, böylece oradaki komutu programlanır.
3.
Programlayıcıya AutonomousPeriodic () yöntemi sırasında tekrar tekrar denir. AutonomousPeriodic () her 20 ms'de (nominal olarak) çağrılır, böylece programlanmış olan tüm komutlar boyunca geçiş yapan zamanlayıcıyı çalıştırmak için iyi bir zamandır.
Basit Otonom Bir Programı Command-Based Otonom Programa Dönüştürme
Döngüler ile ilk otonom kod
​
1
C++
2
​
3
// Aim shooter
4
SetTargetAngle(); // Initialization: prepares for the action to be performed
5
while (!AtRightAngle()) { // Condition: keeps the loop going while it is satisfied
6
	CorrectAngle(); // Execution: repeatedly updates the code to try to make the condition false
7
	delay(); // Delay to prevent maxing CPU
8
}
9
HoldAngle(); // End: performs any cleanup and final task before moving on to the next action
10
​
11
// Spin up to Speed
12
SetTargetSpeed(); // Initialization: prepares for the action to be performed
13
while (!FastEnough()) { // Condition: keeps the loop going while it is satisfied
14
	SpeedUp(); // Execution: repeatedly updates the code to try to make the condition false
15
	delay(); // Delay to prevent maxing CPU
16
}
17
HoldSpeed();
18
​
19
// Shoot Frisbee
20
Shoot(); // End: performs any cleanup and final task before moving on to the next action
21
}
22
​
Copied!
1
Java
2
​
3
// Aim shooter
4
SetTargetAngle(); // Initialization: prepares for the action to be performed
5
while (!AtRightAngle()) { // Condition: keeps the loop going while it is satisfied
6
	CorrectAngle(); // Execution: repeatedly updates the code to try to make the condition false
7
	delay(); // Delay to prevent maxing CPU
8
}
9
HoldAngle(); // End: performs any cleanup and final task before moving on to the next action
10
​
11
// Spin up to Speed
12
SetTargetSpeed(); // Initialization: prepares for the action to be performed
13
while (!FastEnough()) { // Condition: keeps the loop going while it is satisfied
14
	SpeedUp(); // Execution: repeatedly updates the code to try to make the condition false
15
	delay(); // Delay to prevent maxing CPU
16
}
17
HoldSpeed();
18
​
19
// Shoot Frisbee
20
Shoot(); // End: performs any cleanup and final task before moving on to the next action
21
}
Copied!
Yukarıdaki kod bir atıcıyı hedefler, sonra bir tekerleği döndürür ve son olarak, tekerlek istenen hızda çalıştığında frizbi vurur. Kod üç farklı eylemden oluşur: amaç, hızlanmak ve Frizbi'yi vurmak. İlk iki eylem, dört bölümden oluşan bir komut desenini takip eder:
1.
Başlatma: eylemin gerçekleştirilmesini hazırlar.
2.
Durum: her şey yolunda iken döngü devam ediyor.
3.
Yürütme: koşulu yanlış yapmak için kodu tekrar tekrar günceller.
4.
Son: Bir sonraki eyleme geçmeden önce herhangi bir temizleme ve son görevi gerçekleştirir.
Son eylem sadece açık bir başlatma özelliğine sahiptir, ancak nasıl okunduğunuza bağlı olarak, bir dizi koşul altında örtülü olarak sona erebilir. 
Komut olarak yeniden yazma
​
1
C++
2
​
3
#include "AutonomousCommand.h"
4
​
5
AutonomousCommand::AutonomousCommand()
6
{
7
     AddSequential(new Aim());
8
     AddSequential(new SpinUpShooter());
9
     AddSequential(new Shoot());
10
}
11
​
Copied!
1
Java
2
​
3
public class AutonomousCommand extends CommandGroup {
4
​
5
    public  AutonomousCommand() {
6
    	addSequential(new Aim());
7
    	addSequential(new SpinUpShooter());
8
    	addSequential(new Shoot());
9
    }
10
}
11
​
Copied!
Aynı kod, her eylemin kendi komutu olarak yazıldığı üç eylemi gruplandıran bir KomutGrup olarak yeniden yazılabilir. Öncelikle, komut grubu yazılacak, daha sonra üç eylemi gerçekleştirmek için komutlar yazılacaktır. Bu kod oldukça basittir. Ardı ardına üç eylem yapar, bu birbiri ardına gerçekleşir. Çizgi 3 robotu hedefliyor, sonra 4 numaralı çizgi shooterup'ı çeviriyor ve son olarak 5. hat aslında frizbiyi vuruyor. AddSequential () yöntemi, bu komutların birbiri ardına çalışması için ayarlar.
Aim Komutu
1
C++
2
​
3
#include "Aim.h"
4
​
5
Aim::Aim()
6
{
7
     Requires(Robot::turret);
8
}
9
​
10
// Called just before this Command runs the first time
11
void Aim::Initialize()
12
{
13
     SetTargetAngle();
14
}
15
​
16
// Called repeatedly when this Command is scheduled to run
17
void Aim:Execute()
18