സ്മാർട്ട് ഡ്രൈവ്#

ആമുഖം #

മോട്ടോറുകൾ, ചക്രങ്ങൾ, സെൻസർ എന്നിവ ഉപയോഗിച്ച് ഒരു റോബോട്ട് എങ്ങനെ ഡ്രൈവ് ചെയ്യുന്നുവെന്നും തിരിയുന്നുവെന്നും smartdrive ക്ലാസ് നിയന്ത്രിക്കുന്നു. ഒരു smartdrive ന് കണക്റ്റുചെയ്‌ത ഗൈറോ സെൻസർ അല്ലെങ്കിൽ തലച്ചോറിന്റെ ബിൽറ്റ്-ഇൻ ഇനേർഷ്യൽ സെൻസർ ഉപയോഗിക്കാൻ കഴിയും.

റോബോട്ടിനെ കൃത്യമായി ചലിപ്പിക്കാനും തിരിയാനും സഹായിക്കുന്നതിന് ഒരു smartdrive സെൻസർ ഉപയോഗിക്കുന്നു. ഓരോ പ്രോജക്റ്റിന്റെയും തുടക്കത്തിൽ, ഡ്രൈവ്ട്രെയിൻ സെൻസറിനെ യാന്ത്രികമായി കാലിബ്രേറ്റ് ചെയ്യുന്നു. കാലിബ്രേഷൻ സമയത്ത് റോബോട്ടിനെ ഏകദേശം 2 സെക്കൻഡ് നിശ്ചലമായി നിർത്തുക, അങ്ങനെ റോബോട്ടിന് ശരിയായി ചലിക്കാനും തിരിയാനും കഴിയും.

smartdrive ക്ലാസ് drivetrain ക്ലാസിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഇതിന് drivetrain പോലെയുള്ള അതേ ഡ്രൈവ്, ടേൺ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കാൻ കഴിയും, കൂടാതെ turnToHeading , turnToRotation പോലുള്ള സെൻസർ അധിഷ്ഠിത ഫംഗ്ഷനുകളും ഇത് ചേർക്കുന്നു.

ഈ പേജിൽ സ്മാർട്ട് ഡ്രൈവ് നാമത്തിന്റെ ഉദാഹരണമായി myDrivetrain ഉപയോഗിക്കുന്നു. ആവശ്യാനുസരണം നിങ്ങളുടെ സ്വന്തം കോൺഫിഗർ ചെയ്ത പേര് ഉപയോഗിച്ച് ഇത് മാറ്റിസ്ഥാപിക്കുക.

ക്ലാസ് കൺസ്ട്രക്‌ടറുകൾ #

1 — ഇടതും വലതും വശങ്ങൾക്കായി നിലവിലുള്ള motor_group ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിച്ച് ഒരു ഗൈറോ സെൻസർ അല്ലെങ്കിൽ ഇനേർഷ്യൽ സെൻസർ ഉപയോഗിച്ച് ഒരു സ്മാർട്ട് ഡ്രൈവ് സൃഷ്ടിക്കുന്നു.
smartdrive(
    motor_group     &l,
    motor_group     &r,
    gyro            &g,
    double          wheelTravel = 320,
    double          trackWidth  = 320,
    double          wheelBase   = 130,
    distanceUnits   unit = mm,
    double          externalGearRatio = 1.0 );

2 — ഇടതും വലതും വശങ്ങൾക്കായി നിലവിലുള്ള motor ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിച്ച് ഒരു ഗൈറോ സെൻസർ അല്ലെങ്കിൽ ഇനേർഷ്യൽ സെൻസർ ഉപയോഗിച്ച് ഒരു സ്മാർട്ട് ഡ്രൈവ് സൃഷ്ടിക്കുന്നു.
smartdrive(
    motor           &l,
    motor           &r,
    gyro            &g,
    double          wheelTravel = 320,
    double          trackWidth  = 320,
    double          wheelBase   = 130,
    distanceUnits   unit = mm,
    double          externalGearRatio = 1.0 );

ക്ലാസ് ഡിസ്ട്രക്റ്റർ #

smartdrive ഒബ്ജക്റ്റ് നശിപ്പിക്കുകയും അനുബന്ധ ഉറവിടങ്ങൾ പുറത്തുവിടുകയും ചെയ്യുന്നു.

~smartdrive();

പാരാമീറ്ററുകൾ #

സെൻസർ പാരാമീറ്റർ gyro അല്ലെങ്കിൽ inertial ഒബ്‌ജക്റ്റ് ആകാം.

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`&l` / `&r`	`motor_group` / `motor`	ഇടതും വലതും മോട്ടോറുകൾ അല്ലെങ്കിൽ മോട്ടോർ ഗ്രൂപ്പുകൾ. രണ്ട് പാരാമീറ്ററുകളും ഒരേ തരം ഉപയോഗിക്കണം: രണ്ട് `motor_group` ഒബ്‌ജക്റ്റുകൾ അല്ലെങ്കിൽ രണ്ട് `motor` ഒബ്‌ജക്റ്റുകൾ.
`&g`	`gyro` / `inertial`	സ്മാർട്ട് ഡ്രൈവ് ഉപയോഗിക്കുന്ന ഗൈറോ സെൻസർ അല്ലെങ്കിൽ ഇനേർഷ്യൽ സെൻസർ.
`wheelTravel`	`double`	ഡ്രൈവ്ട്രെയിൻ ചക്രങ്ങളുടെ ചുറ്റളവ്. സ്ഥിരസ്ഥിതി `320` ആണ്.
`trackWidth`	`double`	ഇടത്, വലത് ചക്രങ്ങൾ തമ്മിലുള്ള ദൂരം. സ്ഥിരസ്ഥിതി `320` ആണ്.
`wheelBase`	`double`	മുൻ ചക്രങ്ങളും പിൻ ചക്രങ്ങളും തമ്മിലുള്ള ദൂരം. സ്ഥിരസ്ഥിതി `130` ആണ്.
`unit`	`distanceUnits`	`wheelTravel`, `trackWidth`, `wheelBase`എന്നിവയ്ക്കുള്ള യൂണിറ്റ്: `mm` (ഡിഫോൾട്ട്) അല്ലെങ്കിൽ `inches`.
`externalGearRatio`	`double`	ഗിയറുകൾ ഉപയോഗിക്കുമ്പോൾ ഡ്രൈവ് ദൂരം ക്രമീകരിക്കാൻ ഉപയോഗിക്കുന്ന ഗിയർ അനുപാതം. സ്ഥിരസ്ഥിതി `1.0` ആണ്.

ഉദാഹരണം #

/* This constructor is required when using VS Code.
Drivetrain configuration is generated automatically
in VEXcode using the Device Menu. Replace the values
as needed. */

// Create the left and right motor objects.
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the Inertial Sensor object.
inertial myInertial = inertial(PORT3);

// Create the smartdrive object.
smartdrive myDrivetrain = smartdrive(
    leftMotor,  // left motor
    rightMotor, // right motor
    myInertial, // Inertial Sensor
    259.34,     // wheelTravel
    320,        // trackWidth
    40,         // wheelBase
    mm,         // unit
    1.0 );      // externalGearRatio

അംഗ പ്രവർത്തനങ്ങൾ #

smartdrive ക്ലാസ്സിൽ ഇനിപ്പറയുന്ന അംഗ ഫംഗ്‌ഷനുകൾ ഉൾപ്പെടുന്നു:

പ്രവർത്തനങ്ങൾ — തലക്കെട്ട് അല്ലെങ്കിൽ ഭ്രമണം ഉപയോഗിച്ച് റോബോട്ട് തിരിക്കുക.

turnToHeading — -359 മുതൽ 359 ഡിഗ്രി വരെയുള്ള ഒരു പ്രത്യേക തലക്കെട്ടിന് അഭിമുഖമായി റോബോട്ടിനെ തിരിക്കുന്നു. ലക്ഷ്യ തലക്കെട്ടിൽ എത്താൻ റോബോട്ട് ഏറ്റവും കുറഞ്ഞ ദിശ തിരിക്കും.
turnToRotation — റോബോട്ടിനെ ഒരു പ്രത്യേക ഭ്രമണത്തിലേക്ക് തിരിക്കുന്നു.
calibrateDrivetrain — സ്മാർട്ട് ഡ്രൈവ് ഉപയോഗിച്ച് കോൺഫിഗർ ചെയ്ത സെൻസർ കാലിബ്രേറ്റ് ചെയ്യുന്നു.

ക്രമീകരണങ്ങൾ — തലക്കെട്ടും ഭ്രമണ മൂല്യങ്ങളും ക്രമീകരിക്കുക.

setHeading — റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ട് ഒരു പുതിയ തലക്കെട്ടിലേക്ക് മാറ്റുന്നു.
setRotation — റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണത്തെ ഒരു പുതിയ ഭ്രമണത്തിലേക്ക് മാറ്റുന്നു.

മൂല്യങ്ങൾ — തലക്കെട്ടും ഭ്രമണവും പരിശോധിക്കുക.

heading — റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ട് 0 മുതൽ 359 ഡിഗ്രി വരെ തിരികെ നൽകുന്നു.
rotation — റോബോട്ടിന്റെ നിലവിലെ റൊട്ടേഷൻ നൽകുന്നു.

ഒരു smartdrive drivetrain ൽ നിന്നുള്ള പാരമ്പര്യ അംഗ ഫംഗ്ഷനുകളും ഉപയോഗിക്കാൻ കഴിയും, ഉദാഹരണത്തിന് drive, driveFor, turn, turnFor, stop, isDone, isMoving.

ഏതെങ്കിലും smartdrive അംഗ ഫംഗ്ഷനുകൾ വിളിക്കുന്നതിന് മുമ്പ്, ഒരു smartdrive ഒബ്ജക്റ്റ് സൃഷ്ടിക്കണം.

/* This constructor is required when using VS Code.
Drivetrain configuration is generated automatically
in VEXcode using the Device Menu. Replace the values
as needed. */

// Create the left and right motor objects.
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the Inertial Sensor object.
inertial myInertial = inertial(PORT3);

// Create the smartdrive object.
smartdrive myDrivetrain = smartdrive(
    leftMotor,  // left motor
    rightMotor, // right motor
    myInertial, // Inertial Sensor
    259.34,     // wheelTravel
    320,        // trackWidth
    40,         // wheelBase
    mm,         // unit
    1.0 );      // externalGearRatio

turnToHeading #

ഒരു ഹെഡ്ഡിംഗ് എന്നത് റോബോട്ട് അഭിമുഖീകരിക്കുന്ന ദിശയാണ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. turnToHeading റോബോട്ടിനെ -359 മുതൽ 359 ഡിഗ്രി വരെയുള്ള ഒരു പ്രത്യേക ഹെഡ്ഡിംഗിലേക്ക് തിരിക്കുന്നു. ലക്ഷ്യ ഹെഡിംഗിൽ എത്താൻ റോബോട്ട് ഏറ്റവും കുറഞ്ഞ ദിശയിലേക്ക് തിരിക്കും.

റോബോട്ടിന്റെ ആരംഭ തലക്കെട്ട് 0 ഡിഗ്രിയാണ്.

റോബോട്ട് തിരിയുന്നത് വരെ പ്രോജക്റ്റ് കാത്തിരിക്കും, തുടർന്ന് അടുത്ത കോഡ് വരി പ്രവർത്തിക്കും.

Available Functions

1 — നിലവിലെ ടേൺ പ്രവേഗം ഉപയോഗിച്ച് റോബോട്ടിനെ നിർദ്ദിഷ്ട തലക്കെട്ടിലേക്ക് തിരിക്കുന്നു.
bool turnToHeading(
    double        angle,
    rotationUnits units,
    bool          waitForCompletion = true );

2 — നിർദ്ദിഷ്ട വേഗതയിൽ റോബോട്ടിനെ നിർദ്ദിഷ്ട തലക്കെട്ടിലേക്ക് തിരിക്കുന്നു.
bool turnToHeading(
    double        angle,
    rotationUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

Parameters

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`angle`	`double`	റോബോട്ട് അഭിമുഖീകരിക്കേണ്ട ദിശ, ഡിഗ്രികളിൽ. `deg` അല്ലെങ്കിൽ `degrees` ഉപയോഗിക്കുമ്പോൾ ഇത് -359 മുതൽ 359 വരെയാകാം.
`units`	`rotationUnits`	ഹെഡിംഗ് യൂണിറ്റ്: `deg` (ഡിഗ്രി), `rev` (റവല്യൂഷനുകൾ), അല്ലെങ്കിൽ `raw` (റോ യൂണിറ്റുകൾ). ഒരു റവല്യൂഷൻ 360 ഡിഗ്രിക്ക് തുല്യമാണ്.
`velocity`	`double`	The velocity to turn with from 0% to 100% when using `velocityUnits::pct`, from 0 to 120 rpm when using `rpm`, or from 0 to 720 degrees per second when using `dps`. If no velocity is provided, the robot turns at the current turn velocity.
`units_v`	`velocityUnits`	പ്രവേഗ യൂണിറ്റ്: `velocityUnits::pct` (ശതമാനം), `rpm` (മിനിറ്റിൽ ഭ്രമണങ്ങൾ), അല്ലെങ്കിൽ `dps` (സെക്കൻഡിൽ ഡിഗ്രി).
`waitForCompletion`	`bool`	`true` (default) എന്നത് റോബോട്ട് തിരിയുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് അടുത്ത കോഡ് വരി പ്രവർത്തിക്കുന്നു. `false` എന്നത് അടുത്ത കോഡ് വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

Return Values

റോബോട്ട് ലക്ഷ്യ തലക്കെട്ടിൽ എത്തിയോ എന്ന് ഒരു ബൂളിയൻ മൂല്യമായി നൽകുന്നു.

true — റോബോട്ട് ലക്ഷ്യ തലക്കെട്ടിൽ എത്തി.
false — റോബോട്ട് ടേൺ പൂർത്തിയാക്കിയില്ല, അല്ലെങ്കിൽ waitForCompletion false ആയി സജ്ജീകരിച്ചതിനാൽ ടേൺ പൂർത്തിയാകുന്നതിന് മുമ്പ് ഫംഗ്ഷൻ മടങ്ങി.

Notes

turnToHeading പ്രവർത്തിക്കുമ്പോൾ മറ്റൊരു ഡ്രൈവ്ട്രെയിൻ മൂവ്മെന്റ് ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നത് നിലവിലെ ചലനത്തെ തടസ്സപ്പെടുത്തും.
turnToHeading ഒരു ടാർഗെറ്റ് ഹെഡിംഗ് ഉപയോഗിക്കുന്നു, അതിനാൽ isDone ഉം isMoving ഉം ഇതിനൊപ്പം ഉപയോഗിക്കാം.

Examples

// Face the new 0 degrees.
myDrivetrain.setHeading(90, degrees);
myDrivetrain.turnToHeading(0, degrees);

turnToRotation #

turnToRotation റോബോട്ടിനെ ഒരു പ്രത്യേക ഭ്രമണത്തിലേക്ക് തിരിക്കുന്നു.

ഭ്രമണം എന്നത് റോബോട്ട് എത്രമാത്രം തിരിഞ്ഞിരിക്കുന്നു എന്നതാണ്, ഇത് ഡിഗ്രികളിലോ പരിക്രമണങ്ങളിലോ അളക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, ഭ്രമണ മൂല്യം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. setRotation ഫംഗ്ഷൻ ഉപയോഗിച്ചും ഭ്രമണം സജ്ജമാക്കാൻ കഴിയും.

ഭ്രമണ മൂല്യങ്ങൾ കേവലമാണ്. ഇതിനർത്ഥം ഭ്രമണ ദിശ റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണത്തെ ആശ്രയിച്ചിരിക്കുന്നു എന്നാണ്. വലത്തേക്ക് തിരിയുന്നത് ഭ്രമണം വർദ്ധിപ്പിക്കുകയും ഇടത്തേക്ക് തിരിയുന്നത് ഭ്രമണം കുറയ്ക്കുകയും ചെയ്യുന്നു.

ഉദാഹരണത്തിന്, റോബോട്ട് 0 ഡിഗ്രിയിൽ നിന്ന് ആരംഭിച്ച് 720 ഡിഗ്രി ഭ്രമണത്തിലേക്ക് തിരിഞ്ഞാൽ, അത് രണ്ടുതവണ വലത്തേക്ക് തിരിക്കും. തുടർന്ന് 360 ഡിഗ്രി ഭ്രമണത്തിലേക്ക് തിരിഞ്ഞാൽ, അത് ഒരു തവണ ഇടത്തേക്ക് തിരിക്കും, കാരണം 360 720 നേക്കാൾ കുറവാണ്.

Available Functions

1 — നിലവിലെ ടേൺ പ്രവേഗം ഉപയോഗിച്ച് റോബോട്ടിനെ നിർദ്ദിഷ്ട ഭ്രമണത്തിലേക്ക് തിരിക്കുന്നു.
bool turnToRotation(
    double        angle,
    rotationUnits units,
    bool          waitForCompletion = true );

2 — നിർദ്ദിഷ്ട വേഗതയിൽ റോബോട്ടിനെ നിർദ്ദിഷ്ട ഭ്രമണത്തിലേക്ക് തിരിക്കുന്നു.
bool turnToRotation(
    double        angle,
    rotationUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

Parameters

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`angle`	`double`	റോബോട്ട് തിരിയുന്ന ഭ്രമണ മൂല്യം.
`units`	`rotationUnits`	ഭ്രമണ യൂണിറ്റ്: `deg` (ഡിഗ്രി), `rev` (പരിവർത്തനങ്ങൾ), അല്ലെങ്കിൽ `raw` (അസംസ്കൃത യൂണിറ്റുകൾ). ഒരു പരിക്രമണം 360 ഡിഗ്രിക്ക് തുല്യമാണ്.
`velocity`	`double`	The velocity to turn with from 0% to 100% when using `velocityUnits::pct`, from 0 to 120 rpm when using `rpm`, or from 0 to 720 degrees per second when using `dps`. If no velocity is provided, the robot turns at the current turn velocity.
`units_v`	`velocityUnits`	പ്രവേഗ യൂണിറ്റ്: `velocityUnits::pct` (ശതമാനം), `rpm` (മിനിറ്റിൽ ഭ്രമണങ്ങൾ), അല്ലെങ്കിൽ `dps` (സെക്കൻഡിൽ ഡിഗ്രി).
`waitForCompletion`	`bool`	`true` (default) എന്നത് റോബോട്ട് തിരിയുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് അടുത്ത കോഡ് വരി പ്രവർത്തിക്കുന്നു. `false` എന്നത് അടുത്ത കോഡ് വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

Return Values

റോബോട്ട് ലക്ഷ്യ ഭ്രമണത്തിൽ എത്തിയോ എന്ന് ഒരു ബൂളിയൻ മൂല്യമായി നൽകുന്നു.

true — റോബോട്ട് ലക്ഷ്യ ഭ്രമണത്തിൽ എത്തി.
false — റോബോട്ട് ടേൺ പൂർത്തിയാക്കിയില്ല, അല്ലെങ്കിൽ waitForCompletion false ആയി സജ്ജീകരിച്ചതിനാൽ ടേൺ പൂർത്തിയാകുന്നതിന് മുമ്പ് ഫംഗ്ഷൻ മടങ്ങി.

Notes

turnToRotation പ്രവർത്തിക്കുമ്പോൾ മറ്റൊരു ഡ്രൈവ്ട്രെയിൻ മൂവ്മെന്റ് ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നത് നിലവിലെ ചലനത്തെ തടസ്സപ്പെടുത്തും.
turnToRotation ഒരു ടാർഗെറ്റ് റൊട്ടേഷൻ ഉപയോഗിക്കുന്നു, അതിനാൽ isDone ഉം isMoving ഉം ഇതിനൊപ്പം ഉപയോഗിക്കാം.

Examples

// Spin counterclockwise for 2 turns, then face forward.
myDrivetrain.setRotation(720, degrees);
myDrivetrain.turnToRotation(0, degrees);

calibrateDrivetrain #

calibrateDrivetrain കണക്റ്റുചെയ്‌ത ഗൈറോ സെൻസർ അല്ലെങ്കിൽ സ്മാർട്ട്‌ഡ്രൈവിനൊപ്പം കോൺഫിഗർ ചെയ്‌ത ബ്രെയിനിന്റെ ബിൽറ്റ്-ഇൻ ഇനേർഷ്യൽ സെൻസർ കാലിബ്രേറ്റ് ചെയ്യുന്നു.

കാലിബ്രേഷൻ സെൻസറിനെ ചലനം ശരിയായി അളക്കാൻ സഹായിക്കുന്നു. കാലിബ്രേഷൻ സമയത്ത് റോബോട്ടിനെ ഏകദേശം 2 സെക്കൻഡ് നിശ്ചലമായി നിർത്തുക. കാലിബ്രേഷൻ സമയത്ത് റോബോട്ട് ചലിച്ചാൽ, സെൻസറിന് ചലനം ശരിയായി അളക്കാൻ കഴിഞ്ഞേക്കില്ല.

കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നതിന് മുമ്പ് കാലിബ്രേഷൻ പൂർത്തിയാകുന്നതുവരെ പ്രോജക്റ്റ് കാത്തിരിക്കും.

കുറിപ്പ്: calibrateDrivetrain സ്വയമേവ ജനറേറ്റ് ചെയ്യപ്പെടുന്നു. ഇത് പ്രോജക്റ്റ് ഉറവിടത്തിന്റെ ഭാഗമായി നൽകിയിരിക്കുന്നു കൂടാതെ VEX IQ C++ API-യുടെ ഭാഗമല്ല.

Available Functions

void calibrateDrivetrain();

Parameters

ഈ ഫംഗ്ഷൻ ഒരു പാരാമീറ്ററുകളും സ്വീകരിക്കുന്നില്ല.

Return Values

ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.

Notes

VEXcode-ൽ ഒരു സ്മാർട്ട് ഡ്രൈവ് കോൺഫിഗർ ചെയ്യുമ്പോൾ, ഓരോ പ്രോജക്റ്റിന്റെയും തുടക്കത്തിൽ റോബോട്ട് യാന്ത്രികമായി കാലിബ്രേറ്റ് ചെയ്യുന്നു.
കാലിബ്രേഷൻ സമയത്ത് റോബോട്ടിനെ ഏകദേശം 2 സെക്കൻഡ് നിശ്ചലമായി നിർത്തുക.

Function Implementation

VEXcode സൃഷ്ടിച്ച calibrateDrivetrain ന്റെ യാന്ത്രികമായി സൃഷ്ടിച്ച ഇംപ്ലിമെന്റേഷന്റെ ഒരു ഉദാഹരണം താഴെ കൊടുക്കുന്നു:

bool vexcode_initial_drivetrain_calibration_completed = false;
void calibrateDrivetrain() {
  wait(200, msec);
  Brain.Screen.print("Calibrating");
  Brain.Screen.newLine();
  Brain.Screen.print("Inertial");
  DrivetrainInertial.calibrate();
  while (DrivetrainInertial.isCalibrating()) {
    wait(25, msec);
  }
  vexcode_initial_drivetrain_calibration_completed = true;
  // Clears the screen and returns the cursor to row 1, column 1.
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
}

setHeading #

ഒരു തലക്കെട്ട് എന്നത് റോബോട്ട് അഭിമുഖീകരിക്കുന്ന ദിശയാണ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. setHeading റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ടിനെ ഒരു പുതിയ തലക്കെട്ട് മൂല്യത്തിലേക്ക് മാറ്റുന്നു.

ഉദാഹരണത്തിന്, റോബോട്ട് വലത്തേക്ക് അഭിമുഖമായി തിരിഞ്ഞിട്ടുണ്ടെങ്കിൽ, തലക്കെട്ട് 0 ഡിഗ്രിയിലേക്ക് സജ്ജമാക്കുന്നത് ആ വലതുവശത്തുള്ള സ്ഥാനത്തെ പുതിയ 0 ഡിഗ്രിയാക്കുന്നു. തുടർന്ന് ആ പുതിയ തലക്കെട്ടിനെ അടിസ്ഥാനമാക്കി റോബോട്ടിന് മറ്റ് സ്ഥാനങ്ങളിലേക്ക് തിരിയാൻ കഴിയും.

Available Functions

void setHeading(
  double value,
  rotationUnits units);

Parameters

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`value`	`double`	റോബോട്ടിന് വേണ്ടി സജ്ജമാക്കേണ്ട ഹെഡിംഗ് മൂല്യം. `deg` അല്ലെങ്കിൽ `degrees` ഉപയോഗിക്കുമ്പോൾ ഇത് -359 മുതൽ 359 വരെയാകാം.
`units`	`rotationUnits`	ഹെഡിംഗ് യൂണിറ്റ്: `deg` (ഡിഗ്രി), `rev` (റവല്യൂഷനുകൾ), അല്ലെങ്കിൽ `raw` (റോ യൂണിറ്റുകൾ). ഒരു റവല്യൂഷൻ 360 ഡിഗ്രിക്ക് തുല്യമാണ്.

Return Values

ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.

Examples

// Face the new 0 degrees.
myDrivetrain.setHeading(90, degrees);
myDrivetrain.turnToHeading(0, degrees);

setRotation #

റോബോട്ട് എത്രമാത്രം തിരിഞ്ഞിരിക്കുന്നു എന്നതാണ് ഭ്രമണം, ഇത് ഡിഗ്രികളിലോ പരിക്രമണങ്ങളിലോ അളക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, ഭ്രമണ മൂല്യം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. setRotation റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണത്തെ ഒരു പുതിയ മൂല്യത്തിലേക്ക് മാറ്റുന്നു.

ഉദാഹരണത്തിന്, റോബോട്ട് വലത്തേക്ക് രണ്ട് പൂർണ്ണ തിരിവുകൾ നടത്തിയിട്ടുണ്ടെങ്കിൽ, അതിന്റെ ഭ്രമണ മൂല്യം 720 ഡിഗ്രി ആയിരിക്കും. ഭ്രമണം 0 ഡിഗ്രിയിലേക്ക് സജ്ജമാക്കുന്നത് ആ ഭ്രമണത്തെ 720 ൽ നിന്ന് 0 ഡിഗ്രിയിലേക്ക് പുനഃസജ്ജമാക്കും. തുടർന്ന് ആ പുതിയ മൂല്യത്തെ അടിസ്ഥാനമാക്കി റോബോട്ടിന് ഭ്രമണങ്ങളിലേക്ക് തിരിയാൻ കഴിയും.

Available Functions

void setRotation(
  double value,
  rotationUnits units);

Parameters

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`value`	`double`	റോബോട്ടിനായി സജ്ജമാക്കേണ്ട ഭ്രമണ മൂല്യം.
`units`	`rotationUnits`	ഭ്രമണ യൂണിറ്റ്: `deg` (ഡിഗ്രി), `rev` (പരിവർത്തനങ്ങൾ), അല്ലെങ്കിൽ `raw` (അസംസ്കൃത യൂണിറ്റുകൾ). ഒരു പരിക്രമണം 360 ഡിഗ്രിക്ക് തുല്യമാണ്.

Return Values

ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.

Examples

// Spin counterclockwise for 2 turns, then face forward.
myDrivetrain.setRotation(720, degrees);
myDrivetrain.turnToRotation(0, degrees);

heading #

ഒരു തലക്കെട്ട് എന്നത് റോബോട്ട് അഭിമുഖീകരിക്കുന്ന ദിശയാണ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. heading റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ട് 0 മുതൽ 359 ഡിഗ്രി വരെ തിരികെ നൽകുന്നു.

റോബോട്ടിന്റെ ആരംഭ തലക്കെട്ട് 0 ഡിഗ്രിയാണ്.

Available Functions

double heading( rotationUnits units = rotationUnits::deg );

Parameters

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`units`	`rotationUnits`	ഓപ്ഷണൽ. ഹെഡ്ഡിംഗ് ഇൻ ചെയ്യേണ്ട യൂണിറ്റ്: `degrees`, `deg` (ഡിഫോൾട്ട്), `rev`, അല്ലെങ്കിൽ `raw`. ഒരു പരിക്രമണം 360 ഡിഗ്രിക്ക് തുല്യമാണ്.

Return Values

തിരഞ്ഞെടുത്ത യൂണിറ്റിൽ റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ട് double ആയി നൽകുന്നു.

Examples

// Show heading before and after turning.
Brain.Screen.print("Before: %f", myDrivetrain.heading(degrees));
myDrivetrain.turnFor(right, 90, degrees);
wait(1, seconds);
Brain.Screen.newLine();
Brain.Screen.print("After: %f", myDrivetrain.heading(degrees));
myDrivetrain.stop();

rotation #

റോബോട്ട് എത്രമാത്രം തിരിഞ്ഞിരിക്കുന്നു എന്നതാണ് ഭ്രമണം, ഇത് ഡിഗ്രികളിലോ പരിക്രമണങ്ങളിലോ അളക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, ഭ്രമണ മൂല്യം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. rotation റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണം നൽകുന്നു.

വലത്തേക്ക് തിരിയുന്നത് ഭ്രമണം വർദ്ധിപ്പിക്കുന്നു, ഇടത്തേക്ക് തിരിയുന്നത് ഭ്രമണം കുറയ്ക്കുന്നു. ഉദാഹരണത്തിന്, വലത്തേക്ക് രണ്ട് പൂർണ്ണ തിരിവുകൾ നടത്തുന്നത് 720 ഡിഗ്രി ഭ്രമണം തിരികെ നൽകും.

Available Functions

double rotation( rotationUnits units = rotationUnits::deg );

Parameters

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`units`	`rotationUnits`	ഓപ്ഷണൽ. ഭ്രമണം തിരികെ നൽകേണ്ട യൂണിറ്റ്: `degrees`, `deg` (സ്ഥിരസ്ഥിതി), `rev`, അല്ലെങ്കിൽ `raw`ഒരു പരിക്രമണം 360 ഡിഗ്രിക്ക് തുല്യമാണ്.

Return Values

തിരഞ്ഞെടുത്ത യൂണിറ്റിൽ റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണം double ആയി നൽകുന്നു.

Examples

// Show rotation before and after turning.
Brain.Screen.print("Before: %f", myDrivetrain.rotation(degrees));
myDrivetrain.turnFor(right, 90, degrees);
wait(1, seconds);
Brain.Screen.newLine();
Brain.Screen.print("After: %f", myDrivetrain.rotation(degrees));
myDrivetrain.stop();