Skip to main content

പാഠം 2: ഒരു വൈൽ ലൂപ്പ് ഉപയോഗിക്കുന്നു

ഈ പാഠത്തിൽ, നിങ്ങൾ ബമ്പർ സെൻസറും whileലൂപ്പും ഉപയോഗിച്ച് ഒരു പ്രോജക്റ്റ് സൃഷ്ടിക്കും. മിനി-ചലഞ്ചിൽ, വാൾ മേസിന്റെ തുടക്കം മുതൽ 'A' എന്ന അക്ഷരം വരെ നാവിഗേറ്റ് ചെയ്യാൻ നിങ്ങൾ ഈ കഴിവുകൾ പ്രയോഗിക്കും.

വാൾ മെയ്സ് കളിസ്ഥലം കളിസ്ഥലത്തിന്റെ ഡാഷ്‌ബോർഡ് കാണിക്കുന്നില്ല. വിആർ റോബോട്ടിന് മുന്നിൽ ഒരു മതിൽ ഉണ്ട്, അത് സ്പർശിക്കുന്ന തരത്തിലാണ്, ഇത് മസിലിൽ മുന്നേറാൻ അത് തിരിയേണ്ടതുണ്ടെന്ന് സൂചിപ്പിക്കുന്നു.

പഠന ഫലങ്ങൾ

  • കമാൻഡിന്റെ സ്വഭാവം ഇതുവരെ പൂർത്തിയായിട്ടില്ലെങ്കിൽ പോലും, കാത്തിരിക്കാത്ത കമാൻഡുകൾ പ്രോജക്റ്റ് തുടരാൻ കാരണമാകുന്നുവെന്ന് തിരിച്ചറിയുക.
  • പ്രോജക്റ്റ് തുടരുന്നതിന് മുമ്പ് ഒരു വെയിറ്റിംഗ് കമാൻഡ് പെരുമാറ്റം പൂർത്തിയാക്കുന്നുവെന്ന് തിരിച്ചറിയുക.
  • whileലൂപ്പ് ഒരു ബൂളിയൻ അവസ്ഥ ആവർത്തിച്ച് പരിശോധിക്കുമെന്നും, കൺഡിഷൻ True എന്ന് റിപ്പോർട്ട് ചെയ്യുന്നതുവരെ അടുത്ത കമാൻഡിലേക്ക് നീങ്ങില്ലെന്നും തിരിച്ചറിയുക.
  • സെൻസർ അവസ്ഥ പരിശോധിക്കുന്നതിനായി, നോൺ-വെയ്റ്റിംഗ് കമാൻഡുകൾക്കൊപ്പം (ഉദാ: ഡ്രൈവ്) whileലൂപ്പ് ഉപയോഗിക്കുന്നുണ്ടെന്ന് തിരിച്ചറിയുക.
  • അല്ലകീവേഡ് ഒരു ബൂളിയൻ അവസ്ഥയുടെ മൂല്യം True ൽ നിന്ന് False ലേക്ക് അല്ലെങ്കിൽ False ൽ നിന്ന് True ലേക്ക് വിപരീതമാക്കുന്നുവെന്ന് തിരിച്ചറിയുക. 
  • left_bumper.pressedഉം right_bumper.pressedകമാൻഡുകൾ ലുംലൂപ്പിൽ True അല്ലെങ്കിൽ False മൂല്യം നൽകുന്നുവെന്ന് തിരിച്ചറിയുക.
  • ബമ്പർ സെൻസർ അമർത്തുന്നത് വരെ ഒരു VR റോബോട്ട് ഡ്രൈവ് മുന്നോട്ട് പോകുന്ന ഒരു പ്രോജക്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് വിവരിക്കുക.

ലൂപ്പുകൾക്കിടയിൽ

ലൂപ്പും ലൂപ്പും ബൂളിയൻ വ്യവസ്ഥകൾ അംഗീകരിക്കുന്നു. ലൂപ്പുകൾ ഒരു ബൂളിയൻ അവസ്ഥ ആവർത്തിച്ച് പരിശോധിച്ച് പ്രോജക്റ്റ് ഫ്ലോ നിയന്ത്രിക്കുന്നു. കൺഡിഷൻ& True ആണെങ്കിൽ ,ലൂപ്പ് എന്നിവ ലൂപ്പ് ചെയ്യുന്നത് തുടരും. കണ്ടീഷൻ False ആയി റിപ്പോർട്ട് ചെയ്തുകഴിഞ്ഞാൽ, while ലൂപ്പ് ലൂപ്പിൽ നിന്ന് പുറത്തുകടന്ന് ലൂപ്പിന് പുറത്തുള്ള അടുത്ത കമാൻഡിലേക്ക് നീങ്ങും.

VEXcode VR പൈത്തൺ ടൂൾബോക്സ്. കോഡിംഗ് ഇന്റർഫേസിലേക്ക് വിരൽ ചൂണ്ടുന്ന ഒരു അമ്പടയാളത്തോടൊപ്പം, while കമാൻഡ് ചുവപ്പ് നിറത്തിൽ ഹൈലൈറ്റ് ചെയ്തിരിക്കുന്നു. ടൂൾബോക്സിൽ നിന്ന് കോഡിംഗ് ഇന്റർഫേസിലേക്ക് while കമാൻഡ് ഡ്രാഗ് ചെയ്തതിന് ശേഷം കോഡ് def main():, while condition:, wait(5, MSEC) എന്ന് വായിക്കുന്നു.

അടിസ്ഥാനപരമായി, ഒരുwhileലൂപ്പ് VR റോബോട്ടിനോട് ഒരു പെരുമാറ്റംതുടരാൻ പറയുന്നു, അതേസമയംഒരു പ്രത്യേക വ്യവസ്ഥ പാലിക്കുന്നു. യുക്തി ഈ സാഹചര്യത്തിന് സമാനമാണ്:സൂര്യൻ പ്രകാശിക്കുമ്പോൾ, പുറത്ത് കളിക്കാൻ പോകൂ.നിങ്ങൾ എന്തു ചെയ്യും? "സൂര്യൻ പ്രകാശിക്കുന്നു" എന്ന അവസ്ഥയാണ് നിങ്ങൾ എവിടെയായിരിക്കണമെന്ന് നിർണ്ണയിക്കുന്നത്. സൂര്യൻ പ്രകാശിക്കുമ്പോൾ സ്ഥിതി ശരിയാണ്, അതിനാൽ നീ പുറത്ത് കളിക്കാൻ പോകൂ. സൂര്യൻ അസ്തമിക്കുമ്പോൾ, ആ അവസ്ഥ തെറ്റാണ്, അതിനാൽ നിങ്ങൾ തിരികെ അകത്തേക്ക് വരും.

ഇടതുവശത്ത് സൂര്യൻ പ്രകാശിക്കുമ്പോൾ വായിക്കുന്ന ഒരു കോഡ് ഉദാഹരണമുണ്ട്:, പുറത്ത് കളിക്കുക. while സ്റ്റേറ്റ്മെന്റിനു ശേഷം come inside എന്ന് കാണിക്കുന്നു. വലതുവശത്ത് ഒരു വെയിൽ ഉള്ള ദിവസം വീടിനു പുറത്ത് സൈക്കിൾ ചവിട്ടുന്ന ഒരു പെൺകുട്ടി. ചട്ടം അനുസരിച്ച്, സൂര്യൻ പ്രകാശിക്കുന്നതുവരെ അവൾ പുറത്ത് കളിച്ചു കൊണ്ടിരിക്കും, പിന്നീട് അകത്തേക്ക് പോകും.

വൈൽ ലൂപ്പുകളും വാൾ മെയ്സ് പ്രശ്നവും

വാൾ മെയ്സിലെ വിആർ റോബോട്ടിനും ഇതേ യുക്തി ബാധകമാണ്. ബമ്പർ, VR റോബോട്ട് മുന്നോട്ട് ഓടിച്ചുകൊണ്ടിരിക്കണം. അത് അമർത്തുമ്പോൾ, അത് നിർത്തുകയോ തിരിയുകയോ ചെയ്യണം. ഡ്രൈവ്, പോലുള്ള നോൺ-വെയിറ്റിംഗ് കമാൻഡുകൾക്കൊപ്പംwhileലൂപ്പുകൾ ഉപയോഗിച്ച് നമുക്ക് VR റോബോട്ടിനെ കോഡ് ചെയ്യാൻ കഴിയും. എന്നിരുന്നാലും, ബമ്പർ സെൻസർ കമാൻഡുകൾ ബമ്പർ സെൻസർ അമർത്തുന്നതിന്റെ അവസ്ഥ ഉപയോഗിക്കുന്നു (left_bumper.pressedor right_bumper.pressed)ബമ്പർ സെൻസർഅല്ലഅമർത്തുമ്പോൾ ഡ്രൈവ് ചെയ്യാൻ VR റോബോട്ടിനെ കോഡ് ചെയ്യുന്നതിന്, നമ്മൾ ഒരുഅല്ലഓപ്പറേറ്റർ ഉപയോഗിക്കേണ്ടതുണ്ട്.

def main():
	അവസ്ഥയല്ലെങ്കിലും:
		കാത്തിരിക്കുക (5, MSEC)

നിങ്ങളുടെ അറിവിലേക്കായി

ഒരു പെരുമാറ്റം അടുത്ത കമാൻഡ് എപ്പോൾ ആരംഭിക്കുമെന്ന് നോൺ-വെയ്റ്റിംഗ്, വെയ്റ്റിംഗ് കമാൻഡുകൾ നിർണ്ണയിക്കുന്നു. drive_for, turn_forതുടങ്ങിയ വെയിറ്റിംഗ് കമാൻഡുകൾ, പ്രോജക്റ്റിലെ അടുത്ത കമാൻഡിലേക്ക് പോകുന്നതിന് മുമ്പ് അവയുടെ പെരുമാറ്റങ്ങൾ പൂർത്തിയാക്കുന്നു. നോൺ-വെയ്റ്റിംഗ് കമാൻഡിന്റെ സ്വഭാവം പൂർത്തിയായില്ലെങ്കിൽ പോലും, drive, turnഎന്നിവ പോലുള്ള നോൺ-വെയ്റ്റിംഗ് കമാൻഡുകൾ പ്രോജക്റ്റിലെ അടുത്ത കമാൻഡിലേക്ക് നീങ്ങുന്നത് തുടരുന്നു.

കാത്തിരിക്കുന്ന കമാൻഡുകൾ

ഡ്രൈവ്‌ട്രെയിൻ.ഡ്രൈവ്_ഫോർ(ഫോർവേഡ്, 200, എംഎം)
ഡ്രൈവ്‌ട്രെയിൻ.ടേൺ_ഫോർ(വലത്, 90, ഡിഗ്രി)

കാത്തിരിക്കാത്ത കമാൻഡുകൾ

ഡ്രൈവ്‌ട്രെയിൻ.ഡ്രൈവ്(മുന്നോട്ട്)
ഡ്രൈവ്‌ട്രെയിൻ.ടേൺ(വലത്തേക്ക്)

ദി നോട്ട് കീവേഡ്

അല്ലകീവേഡ് സാധാരണയായിഉംലൂപ്പുകളും ഉപയോഗിച്ച് ഉപയോഗിക്കും, കൺഡിഷൻ False തിരികെ നൽകുമ്പോൾ ലൂപ്പിനുള്ളിലെ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ ഇത് സഹായിക്കും. 'സൂര്യൻ പ്രകാശിക്കുന്നു' എന്ന ഉദാഹരണം ഉപയോഗിക്കുന്നതിന്,അല്ലഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഇതേ ഫലം കൈവരിക്കാൻ കഴിയും. സൂര്യൻഅല്ലആയിരിക്കുമ്പോൾ, അകത്തേക്ക് വരൂ.

ഇടതുവശത്ത് ഒരു ഉദാഹരണ കോഡ് കാണിക്കുന്നു, സൂര്യൻ പ്രകാശിക്കാത്ത സമയത്ത് വായിക്കുന്നു:, അകത്തേക്ക് വരൂ. കുറച്ചു കഴിഞ്ഞപ്പോൾ കമാൻഡ് പുറത്ത് പ്ലേ ചെയ്യണം. വലതുവശത്ത് രാത്രിയിൽ ചന്ദ്രൻ ഉദിക്കുന്ന ഒരു വീട് കാണിക്കുന്നു. ഈ നിയമാവലി അനുസരിച്ച്, സൂര്യൻ പ്രകാശിക്കാത്ത സമയത്ത്, ആരും പുറത്ത് കളിക്കില്ല, വീടിനുള്ളിൽ തന്നെ തുടരും.

വാൾ മെയ്സിൽ, ബമ്പർ സെൻസർഅല്ലഅമർത്തുമ്പോൾ, അത് മുന്നോട്ട് നീങ്ങുന്ന തരത്തിൽ VR റോബോട്ടിനെ കോഡ് ചെയ്യാൻ ഇത് ഉപയോഗപ്രദമാണ്. 'ബമ്പർ സെൻസർ അമർത്തിയാൽ' എന്ന അവസ്ഥ ഇപ്പോഴും നിലനിൽക്കുന്നു, എന്നാൽ ഈ രീതിയിൽ, അത് തെറ്റ് (അമർത്തിയിട്ടില്ല) എന്ന് റിപ്പോർട്ട് ചെയ്യുമ്പോൾ, പ്രോജക്റ്റ് ഫ്ലോ ലൂപ്പിൽ തന്നെ തുടരും. ബമ്പർ സെൻസർ അമർത്തുമ്പോൾ, കണ്ടീഷൻ True ആകുന്നതിനാൽ, പ്രോജക്റ്റ് ലൂപ്പിൽ നിന്ന് പുറത്തേക്ക് നീങ്ങും.ഒരു പ്രത്യേക ഘടനയില്ലാത്ത ഒരു പ്രോജക്റ്റിന്റെ ഒഴുക്ക് വിവരിക്കുന്ന ഒരു പ്രോജക്റ്റ് ഫ്ലോ ഡയഗ്രം. ഇടതുവശത്ത്, പ്രധാന നിർവചനത്തിൽ, ഒരു ഡ്രൈവ് മുന്നോട്ട് വച്ചുകൊണ്ട്, ഇടതുവശത്ത് ബമ്പർ അമർത്തിപ്പിടിച്ചിട്ടില്ലാത്തപ്പോൾ, ലൂപ്പിനുള്ളിൽ 5 മില്ലിസെക്കൻഡ് കമാൻഡ് കാത്തിരിക്കുക എന്ന് എഴുതിയിരിക്കുന്നു. ലൂപ്പിന് പുറത്ത് ഒരു സ്റ്റോപ്പ് കമാൻഡ് ഉണ്ട്. വലതുവശത്ത്, ചാക്രികമായ ചുവന്ന അമ്പടയാളത്താൽ ചിത്രീകരിച്ചിരിക്കുന്ന പ്രോജക്റ്റ് ഫ്ലോയിൽ, ബമ്പർ അമർത്തിയിട്ടില്ലെങ്കിൽ, ആ അവസ്ഥ തെറ്റാണെന്ന് തിരികെ നൽകുകയും റോബോട്ട് മുന്നോട്ട് നീങ്ങുകയും ചെയ്യുന്നുവെന്ന് വായിക്കുന്നു. അടുത്തതായി, ഒരു നേരായ പച്ച അമ്പടയാളം താഴേക്ക് ചൂണ്ടുന്നു, ഇത് ബമ്പർ അമർത്തുമ്പോൾ, അവസ്ഥ ശരിയാണെന്ന് തിരിച്ചെത്തുകയും, പ്രോജക്റ്റ് ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുകയും റോബോട്ട് ഡ്രൈവിംഗ് നിർത്തുകയും ചെയ്യുന്നു എന്ന് സൂചിപ്പിക്കുന്നു.

നിങ്ങളുടെ അറിവിലേക്കായി

അല്ല എന്ന കീവേഡ് ഒരു ബൂളിയന്റെ മൂല്യം വിപരീതമാക്കുന്ന ഒരു ലോജിക്കൽ ഓപ്പറേറ്ററാണ്. ഒരു ബൂളിയൻ മൂല്യം നൽകുന്ന ഒരു കമാൻഡിന് മുന്നിൽഅല്ലഎന്ന കീവേഡ് ഇടുന്നത് True നെ False ലേക്ക് മാറ്റുകയും, False നെ True ലേക്ക് മാറ്റുകയും ചെയ്യും. ഉദാഹരണത്തിന്, VR റോബോട്ടിലെ ലെഫ്റ്റ് ബമ്പർ സെൻസർ അമർത്തിയാൽ left_bumper.pressedകമാൻഡ് True എന്ന് തിരികെ നൽകുമെന്ന് സങ്കൽപ്പിക്കുക. അല്ലഎന്ന കീവേഡ് ബൂളിയൻ മൂല്യം വിപരീതമാക്കുകയും ഈ എക്സ്പ്രഷൻ ഫാൾസ് റിട്ടേൺ ആക്കുകയും ചെയ്യും.

left_bumper.pressed() അല്ല

നിങ്ങൾ ഉപയോഗിക്കുന്ന സെൻസർ ഡാറ്റയെ ആശ്രയിച്ച്, ഒരു VR റോബോട്ടിനെ ആവശ്യമുള്ള പെരുമാറ്റങ്ങൾ നടപ്പിലാക്കുന്നതിന്അല്ലകീവേഡ് ആവശ്യമായി വന്നേക്കാം. 

def main():
	left_bumper.pressed( അല്ലാത്തപ്പോൾ):
		drivetrain.drive(FORWARD)
		wait(5, MSEC)
	drivetrain.stop()

While ലൂപ്പും ബമ്പർ സെൻസറും ഉപയോഗിച്ച് ഒരു പ്രോജക്റ്റ് നിർമ്മിക്കുന്നു

പ്രോജക്റ്റിന് പേര് നൽകി സംരക്ഷിക്കുക

  • ഒരു പുതിയ ടെക്സ്റ്റ് പ്രോജക്റ്റ് തുറന്ന് ആവശ്യപ്പെടുമ്പോൾവാൾ മേസ് പ്ലേഗ്രൗണ്ട്തിരഞ്ഞെടുക്കുക. വാൾ മെയ്സ് പ്ലേഗ്രൗണ്ട് സെലക്ഷൻ ടൈലിൽ താഴെ വാൾ മെയ്സ് എന്ന് എഴുതിയിരിക്കുന്നു, മുകളിലുള്ള മേസ് കാണിക്കുന്നു.

  • പ്രോജക്റ്റിന് എന്ന് പേര് നൽകുക യൂണിറ്റ്4പാഠം.VEXcode VR ടൂൾബാർ. ടൂൾബാറിന്റെ മധ്യത്തിലുള്ള പ്രോജക്റ്റ് നാമം യൂണിറ്റ് 4 പാഠം 2 എന്ന് വായിക്കുകയും ഒരു ചുവന്ന ബോക്സ് ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്യുകയും ചെയ്തിരിക്കുന്നു.

     

  • ഒരു പുതിയ ടെക്സ്റ്റ് പ്രോജക്റ്റിന്റെ ഭാഗമായി സ്വയമേവ പോപ്പുലേറ്റ് ചെയ്യുന്ന ഡ്രൈവ്‌ട്രെയിൻ കമാൻഡിന് പകരമായി whileകമാൻഡ് വർക്ക്‌സ്‌പെയ്‌സിലേക്ക് വലിച്ചിടുക അല്ലെങ്കിൽ ടൈപ്പ് ചെയ്യുക. ലൂപ്പിനുള്ളിൽ wait കമാൻഡ് ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക. waitകമാൻഡ് നീക്കം ചെയ്യരുത്, ഇത് VR റോബോട്ട് പ്രോജക്റ്റ് ശരിയായി നടപ്പിലാക്കുന്നുവെന്ന് ഉറപ്പാക്കും. നിങ്ങളുടെ പ്രോജക്റ്റ് ഇതുപോലെ ആയിരിക്കണം:

    def main():
	while അവസ്ഥ:
		wait(5, MSEC)

  • whileകമാൻഡിൽ 'while' ന് ശേഷംഅല്ലഓപ്പറേറ്റർ ടൈപ്പ് ചെയ്യുക. നിങ്ങളുടെ പ്രോജക്റ്റ് ഇപ്പോൾ ഇതുപോലെ ആയിരിക്കണം:

    def main():
	while not condition:
		wait(5, MSEC)

  • while ലൂപ്പിന്റെ 'കണ്ടീഷനിൽ' left_bumper.pressedകമാൻഡ് ഡ്രാഗ് ചെയ്യുക അല്ലെങ്കിൽ ടൈപ്പ് ചെയ്യുക. കണ്ടീഷൻ ട്രൂ അല്ലാത്തപ്പോൾ ലൂപ്പിനുള്ളിലെ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യും, അതായത് ലെഫ്റ്റ് ബമ്പർ സെൻസർഅമർത്താതെആയിരിക്കുമ്പോൾ. നിങ്ങളുടെ പ്രോജക്റ്റ് ഇപ്പോൾ ഇതുപോലെ ആയിരിക്കണം:

    def main():
	left_bumper അല്ലാത്തപ്പോൾ.pressed():
		wait(5, MSEC)

  • whileലൂപ്പിനുള്ളിൽ, drive കമാൻഡ് ഡ്രാഗ് ചെയ്യുക അല്ലെങ്കിൽ ടൈപ്പ് ചെയ്യുക. driveകമാൻഡുംwaitകമാൻഡുംwhileലൂപ്പിനുള്ളിൽ ശരിയായി ഇൻഡന്റ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക, അങ്ങനെ ലൂപ്പ് ഉദ്ദേശിച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നു. നിങ്ങൾക്ക് ഗൈഡിംഗ് ലൈനുകൾ ഒരു ദൃശ്യ സഹായമായി ഉപയോഗിക്കാം. നിങ്ങളുടെ പ്രോജക്റ്റ് ഇപ്പോൾ ഇതുപോലെ ആയിരിക്കണം:

    def main():
	left_bumper.pressed( അല്ലാത്തപ്പോൾ):
		drivetrain.drive(FORWARD)
		wait(5, MSEC)

  • whileലൂപ്പിന് പുറത്ത് stop കമാൻഡ് ഡ്രാഗ് ചെയ്യുകയോ ടൈപ്പ് ചെയ്യുകയോ ചെയ്യുക. stopകമാൻഡ്whileലൂപ്പുമായി വിന്യസിച്ചിട്ടുണ്ടെന്നും ഇൻഡന്റ് ചെയ്തിട്ടില്ലെന്നും ഉറപ്പാക്കുക, അങ്ങനെ അത് ഉദ്ദേശിച്ചതുപോലെ ലൂപ്പിന് പുറത്ത് പ്രവർത്തിക്കുന്നു. നിങ്ങൾക്ക് ഗൈഡിംഗ് ലൈനുകൾ ഒരു ദൃശ്യ സഹായമായി ഉപയോഗിക്കാം.  നിങ്ങളുടെ പ്രോജക്റ്റ് ഇപ്പോൾ ഇതുപോലെ ആയിരിക്കണം:

    def main():
	left_bumper.pressed( അല്ലാത്തപ്പോൾ):
		drivetrain.drive(FORWARD)
		wait(5, MSEC)
	drivetrain.stop()
  • പ്ലേഗ്രൗണ്ട് വിൻഡോ തുറന്നിട്ടില്ലെങ്കിൽ അത് തുറക്കുക. വാൾ മെയ്സ് പ്ലേഗ്രൗണ്ട്തുറക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക. 
  • പ്രോജക്റ്റ് പ്രവർത്തിപ്പിക്കുക.
  • വാൾ മെയ്‌സിന്റെ തുടക്കം മുതൽ VR റോബോട്ട് ഡ്രൈവ് ചെയ്യുന്നത് കാണുക, ബമ്പർ സെൻസർ ഭിത്തിയിൽ അമർത്തുമ്പോൾ നിർത്തുക.
  • ഡ്രൈവ് കമാൻഡ്, ലെഫ്റ്റ് ബമ്പർ പ്രെസ്ഡ് കമാൻഡ് ഉപയോഗിച്ച് ബമ്പർ സെൻസറിന്റെ അവസ്ഥ പരിശോധിക്കുമ്പോൾ വിആർ റോബോട്ടിനെ മുന്നോട്ട് ഡ്രൈവ് ചെയ്യാൻ അനുവദിക്കുന്നു. left_bumper.pressedകമാൻഡ് True ആയി റിപ്പോർട്ട് ചെയ്തുകഴിഞ്ഞാൽ, VR റോബോട്ട് ലൂപ്പിന് പുറത്തുള്ള അടുത്ത കമാൻഡിലേക്ക് നീങ്ങുകയും ഡ്രൈവിംഗ് നിർത്തുകയും ചെയ്യും.

ഈ പാഠത്തിന്റെ ബാക്കി ഭാഗം തുടരാൻ അടുത്തത് ബട്ടൺ തിരഞ്ഞെടുക്കുക.

< തിരികെ മുകളിലേക്ക് മടങ്ങുക അടുത്തത് >