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

ആമുഖം #

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

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

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

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

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

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

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

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

~smartdrive();

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

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

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`&l` / `&r`	`motor_group` / `motor`	നിലവിലുള്ള `motor` അല്ലെങ്കിൽ `motor` സംഭവങ്ങളെക്കുറിച്ചുള്ള പരാമർശങ്ങൾ. രണ്ട് പാരാമീറ്ററുകളും ഒരേ തരത്തിലുള്ളതായിരിക്കണം: രണ്ട് `motor_group` സംഭവങ്ങൾ അല്ലെങ്കിൽ രണ്ട് `motor_group` സംഭവങ്ങൾ. `&l` പാരാമീറ്റർ ഇടത് മോട്ടോർ അല്ലെങ്കിൽ മോട്ടോർ ഗ്രൂപ്പിനെ സൂചിപ്പിക്കുന്നു, കൂടാതെ `&r` വലത് മോട്ടോർ അല്ലെങ്കിൽ മോട്ടോർ ഗ്രൂപ്പിനെ സൂചിപ്പിക്കുന്നു.
`&g`	`gyro&`	നിലവിലുള്ള `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 instances
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the inertial instance
inertial myInertial = inertial(PORT3);

// Create the smartdrive instance
smartdrive myDrivetrain = smartdrive(
    leftMotor,  // left motor object
    rightMotor, // right motor object
    myInertial, // inertial object
    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 instances
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the inertial instance
inertial myInertial = inertial(PORT3);

// Create the smartdrive instance
smartdrive myDrivetrain = smartdrive(
    leftMotor,  // left motor object
    rightMotor, // right motor object
    myInertial, // inertial object
    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 600 rpm when using `rpm`, or from 0 to 3600 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 പുരോഗമിക്കുമ്പോൾ മറ്റൊരു ഡ്രൈവ്‌ട്രെയിൻ മൂവ്‌മെന്റ് ഫംഗ്‌ഷൻ (turn അല്ലെങ്കിൽ drive പോലുള്ളവ) നടപ്പിലാക്കുന്നത് നിലവിലെ ചലനത്തെ തടസ്സപ്പെടുത്തും.
turnToHeading ടാർഗെറ്റ് അധിഷ്ഠിതമായതിനാൽ (ഒരു angle പാരാമീറ്റർ ഉപയോഗിക്കുന്നു), isDone ഉം isMoving ഉം പോലുള്ള ഫംഗ്ഷനുകൾ turnToHeading നൊപ്പം പ്രവർത്തിക്കുന്നു.

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 600 rpm when using `rpm`, or from 0 to 3600 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 പുരോഗമിക്കുമ്പോൾ മറ്റൊരു ഡ്രൈവ്‌ട്രെയിൻ മൂവ്‌മെന്റ് ഫംഗ്‌ഷൻ (turn അല്ലെങ്കിൽ drive പോലുള്ളവ) നടപ്പിലാക്കുന്നത് നിലവിലെ ചലനത്തെ തടസ്സപ്പെടുത്തും.
turnToRotation ടാർഗെറ്റ് അധിഷ്ഠിതമായതിനാൽ (ഒരു angle പാരാമീറ്റർ ഉപയോഗിക്കുന്നു), isDone ഉം isMoving ഉം പോലുള്ള ഫംഗ്ഷനുകൾ turnToRotation നൊപ്പം പ്രവർത്തിക്കുന്നു.

Examples

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

calibrateDrivetrain #

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

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

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

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

Available Functions

void calibrateDrivetrain();

Parameters

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

Return Values

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

Notes

ഓരോ പ്രോജക്റ്റിന്റെയും തുടക്കത്തിൽ റോബോട്ട് യാന്ത്രികമായി കാലിബ്രേറ്റ് ചെയ്യുന്നു.
കാലിബ്രേഷൻ സമയത്ത് റോബോട്ടിനെ ഏകദേശം 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();