Python Sonrach do Róbónna#

Réamhrá #

Tá trí rogha mótair agus an Braiteoir Dathanna sa Laoch Bot, Fling.

Tá gach modh caighdeánach VEXcode VR ar fáil lena n-úsáid sa Chlós Súgartha IQ 21-22 Pitching In.

Seo thíos liosta de na modhanna uile atá ar fáil atá sainiúil do róbat:

Tiománaí – Bog agus cas an róbat.

Gníomhartha
- drive — Bogann sé an róbat ar aghaidh nó ar gcúl go deo.
- drive_for — Bogann sé an róbat ar aghaidh nó ar gcúl ar feadh achar sonrach.
- turn — Casann sé an róbat ar chlé nó ar dheis go deo.
- turn_for — Casann sé an róbat ar chlé nó ar dheis ar feadh líon áirithe céimeanna.
- turn_to_heading — Casann sé an róbat chun aghaidh a thabhairt ar threo ar leith ó -359 go 359 céim.
- turn_to_rotation — Casann sé an róbat go rothlú ar leith.
- stop — Stopann sé gluaiseacht an róbait.
Múiteoirí
- set_heading — Athraíonn sé ceannteideal reatha an róbait go ceannteideal nua.
- set_rotation — Athraíonn sé rothlú reatha an róbait go rothlú nua.
- set_timeout — Socraíonn sé cé mhéad ama a thógfaidh sé ar an róbat iarracht a dhéanamh gluaiseacht a chríochnú.
- set_drive_velocity — Insíonn sé don róbat cé chomh tapa is atá sé tiomáint.
- set_turn_velocity — Insíonn sé don róbat cé chomh tapa agus atá sé casadh.
Gabhálaithe
- heading — Tugann sé seo ceannteideal reatha an róbait ar ais ó 0 go 359.99 céim.
- rotation — Tugann sé seo rothlú reatha an róbait ar ais.
- is_done — Tugann sé seo ar ais an bhfuil an róbat críochnaithe ag bogadh, mar luach Booleánach.
- is_moving — Tugann sé seo ar ais an bhfuil an róbat ag bogadh, mar luach Booleánach.
- velocity — Tugann sé seo léargas ar cé chomh tapa agus atá an róbat ag tiomáint.

Gluaiseacht - Bog agus rianaigh mótair an róbait.

Gníomhartha
- spin — Casann sé mótar ar aghaidh nó ar gcúl go deo.
- spin_for — Casann sé mótar ar feadh achar ar leith.
- spin_to_position — Casann sé mótar go suíomh ar leith.
- stop — Cuireann sé stop le mótar ó bheith ag sníomh.
Múiteoirí
- set_position — Athraíonn sé suíomh reatha an mhótair go luach nua.
- set_velocity — Insíonn sé seo do mhótar cé chomh tapa agus atá sé le sníomh.
- set_timeout — Socraíonn sé cé mhéad ama a thógfaidh sé ar mhótar iarracht gluaiseacht a chríochnú.
Gabhálaithe
- is_done — Tugann sé seo ar ais an bhfuil an mótar críochnaithe ag bogadh, mar luach Booleanach.
- is_spinning — Tugann sé seo ar ais an bhfuil an mótar ag sníomh, mar luach Booleánach.
- position — Tugann sé seo suíomh reatha an mhótair ar ais.
- velocity — Tugann sé seo ar ais cé chomh tapa agus atá an mótar ag sníomh.

Consól – Priontáil chuig an gConsól agus déan monatóireacht ar luachanna.

Priontáil
- brain.screen.print — Taispeánann sé téacs, uimhreacha, nó luachanna athróg sa Chonsól.
- brain.screen.next_row — Bogann sé seo cúrsóir an Chonsóil go dtí tús an chéad ró eile.
- brain.screen.clear_screen — Glanann sé gach sraith ón gConsól.
Monatóir
- monitor_variable — Cuireann sé athróg réamhshainithe amháin nó níos mó leis an táb Monatóra.
- monitor_sensor — Cuireann sé luach braiteora amháin nó níos mó leis an táb Monatóra.

Braiteoireacht - Bain úsáid as braiteoirí éagsúla an róbait.

Dath
- color - Tugann sé seo an dath a bhraith an Braiteoir Datha ar ais.
- brightness - Tugann sé seo ar ais an méid solais a léirítear ón réad.
- hue - Tugann sé seo an dath a bhraith an Braiteoir Datha ar ais.
- is_near_object - Tugann sé seo ar ais an mbraitheann an Braiteoir Datha réad laistigh den raon.

Úsáideann na samplaí ar an leathanach seo suíomh tosaigh réamhshocraithe an Chlós Súgartha.

Rialaíonn an traein tiomána conas a thiomáineann agus a chasann an Róbat VR. Is féidir leis an traein tiomána bogadh ar aghaidh nó ar gcúl, casadh ar chlé nó ar dheis, casadh de réir treorach, agus a rothlú a rianú.

Gníomhartha #

tiomáint #

Bogann tiomáint drive an róbat ar aghaidh nó ar gcúl go deo. Leanfaidh an róbat ag bogadh go dtí go dtabharfar gníomh eile dó, amhail casadh nó stopadh.

Usage:
drivetrain.drive(direction)

Paraiméadair	Cur síos
`direction`	An treo a mbogann an róbat: `FORWARD` nó `REVERSE`.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

tiomáint_le haghaidh #

drive_for bogann an róbat ar aghaidh nó ar gcúl ar feadh achar sonrach. Fanfaidh an tionscadal go dtí go mbeidh an róbat críochnaithe ag bogadh sula rithfidh an chéad líne eile de chód.

Usage:
drivetrain.drive_for(direction, distance, units, wait)

Paraiméadair	Cur síos
`direction`	An treo a mbogann an róbat: `FORWARD` nó `REVERSE`.
`distance`	An fad a thiomáineann an róbat. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	Roghnach. An t-aonad achair: `INCHES` (réamhshocraithe) nó `MM` (milliméadair).
`wait`	Roghnach. `wait=True` (réamhshocraithe) fanann an tionscadal go dtí go mbeidh an róbat críochnaithe ag bogadh sula ritheann an chéad líne eile cóid. `wait=False` ritheann an chéad líne eile cóid láithreach.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_thread(main)

casadh #

Casann turn an róbat ar chlé nó ar dheis go deo. Leanfaidh an róbat ag casadh go dtí go dtabharfar gníomh eile dó, amhail tiomáint nó stopadh.

Usage:
drivetrain.turn(direction)

Paraiméadair	Cur síos
`direction`	An treo a chasann an róbat: `LEFT` nó `RIGHT`.

def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

cas_le_#

Casann turn_for an róbat ar chlé nó ar dheis ar feadh líon áirithe céimeanna. Tá an casadh i gcoibhneas le suíomh reatha an róbait. Fanfaidh an tionscadal go dtí go mbeidh an róbat críochnaithe ag casadh sula rithfidh an chéad líne eile de chód.

Usage:
drivetrain.turn_for(direction, angle, units, wait)

Paraiméadair	Cur síos
`direction`	An treo a chasann an róbat: `LEFT` nó `RIGHT`.
`angle`	Líon na gcéimeanna a chasann an róbat. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	Roghnach. An t-aonad rothlaithe: `DEGREES` (réamhshocraithe).
`wait`	Roghnach. `wait=True` (réamhshocraithe) fanann an tionscadal go dtí go mbeidh an róbat críochnaithe ag casadh sula ritheann an chéad líne eile cóid. `wait=False` ritheann an chéad líne eile cóid láithreach.

def main():
    # Turn the robot right and left
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_for(LEFT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

cas_go_ceannteideal #

Is é treo an róbait an treo atá os comhair, a thomhaistear i gcéimeanna. turn_to_heading Casann an róbat chun aghaidh a thabhairt ar threo ar leith ó -359 go 359 céim. Casfaidh an róbat an treo is giorra chun an treo sprice a bhaint amach.

Is é 0 céim treo tosaigh an róbait.

Fanfaidh an tionscadal go dtí go mbeidh an róbat críochnaithe ag casadh sula rithfidh an chéad líne eile de chód.

Usage:
drivetrain.turn_to_heading(angle, units, wait)

Paraiméadair	Cur síos
`angle`	An treo ar cheart don róbat aghaidh a thabhairt air, i gcéimeanna. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`) ó -359 go 359.
`units`	Roghnach. An t-aonad rothlaithe: `DEGREES` (réamhshocraithe).
`wait`	Roghnach. `wait=True` (réamhshocraithe) fanann an tionscadal go dtí go mbeidh an róbat críochnaithe ag casadh sula ritheann an chéad líne eile cóid. `wait=False` ritheann an chéad líne eile cóid láithreach.

def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

cas_go_rothlú #

turn_to_rotation Casann an róbat go rothlú ar leith.

Is é rothlú an méid atá casta ag an róbat, arna thomhas i gcéimeanna. Ag tús tionscadail, socraítear an luach rothlaithe go 0 céim. Is féidir rothlú a shocrú freisin ag baint úsáide as an modh set_rotation.

Is luachanna absalóideacha iad luachanna rothlaithe. Ciallaíonn sé seo go mbraitheann treo an chasadh ar rothlú reatha an róbait. Méadaíonn casadh ar dheis an rothlú, agus laghdaíonn casadh ar chlé an rothlú.

Mar shampla, má thosaíonn an róbat ag 0 céim agus má chasann tú go rothlú 720 céim, casfaidh sé ar dheis faoi dhó. Má chasann tú ansin go rothlú 360 céim, casfaidh sé ar chlé uair amháin, mar go bhfuil 360 níos lú ná 720.

Fanfaidh an tionscadal go dtí go mbeidh an róbat críochnaithe ag casadh sula rithfidh an chéad líne eile de chód.

Usage:
drivetrain.turn_to_rotation(angle, units, wait)

Paraiméadair	Cur síos
`angle`	An luach rothlaithe, i gcéimeanna, a chasfaidh an róbat chuige. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	Roghnach. An t-aonad rothlaithe: `DEGREES` (réamhshocraithe).
`wait`	Roghnach. `wait=True` (réamhshocraithe) fanann an tionscadal go dtí go mbeidh an róbat críochnaithe ag casadh sula ritheann an chéad líne eile cóid. `wait=False` ritheann an chéad líne eile cóid láithreach.

def main():
    # Turn left, then spin in a circle
    # clockwise and face right
    drivetrain.turn_to_rotation(-90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_rotation(450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stad #

stop stopann gluaiseacht an róbait.

Usage:
drivetrain.stop()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

Sóiteoirí #

socraigh_ceannteideal #

Is éard atá i dtreo an róbait ná an treo ina bhfuil sé ag tabhairt aghaidh, agus é á thomhas i gcéimeanna. Athraíonn set_heading treo reatha an róbait go luach treo nua.

Mar shampla, má tá an róbat casadh chun aghaidh a thabhairt ar dheis, má shocraítear an treo go 0 céim, déantar an suíomh sin atá ag tabhairt aghaidh ar dheis a athrú go dtí an 0 céim nua. Ansin is féidir leis an róbat casadh chuig suíomhanna eile bunaithe ar an treo nua sin.

Usage:
drivetrain.set_heading(heading, units)

Paraiméadair	Cur síos
`heading`	An luach ceannlíne, i gcéimeanna, le socrú don róbat. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	Roghnach. An t-aonad ceannteidil: `DEGREES` (réamhshocraithe).

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

socraigh_rothlú #

Is é rothlú an méid atá casta ag an róbat, arna thomhas i gcéimeanna. Ag tús tionscadail, socraítear an luach rothlaithe go 0 céim. Athraíonn set_rotation rothlú reatha an róbait go luach nua.

Mar shampla, má tá dhá chasadh iomlána déanta ag an róbat ar dheis, beidh a luach rothlaithe 720 céim. Má shocraítear an rothlú go 0 céim, athshocrófar an rothlú sin ó 720 go 0 céim. Ansin is féidir leis an róbat casadh go rothluithe bunaithe ar an luach nua sin.

Usage:
drivetrain.set_rotation(rotation, units)

Paraiméadair	Cur síos
`rotation`	An luach rothlaithe, i gcéimeanna, le socrú don róbat. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	Roghnach. An t-aonad rothlaithe: `DEGREES` (réamhshocraithe).

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

socraigh_am_scoite #

set_timeout socraíonn sé cé mhéad ama a dhéanfaidh an róbat iarracht gluaiseacht a chríochnú. Mura féidir leis an róbat críochnú laistigh den am sin, stopfaidh sé den iarracht agus bogfaidh sé ar aghaidh go dtí an chéad líne eile de chód. Coinníonn sé seo an róbat ó bheith sáinnithe i ngluaiseacht.

Usage:
drivetrain.set_timeout(value, units)

Paraiméadair	Cur síos
`value`	An méid ama is féidir leis an róbat iarracht a dhéanamh gluaiseacht a chríochnú. Is féidir leis seo a bheith ina shlánuimhir dhearfach `integer` nó ina dheachúil (`float`).
`units`	An t-aonad ama: `SECONDS` nó `MSEC` (mileasoicind).

def main():
    # Turn right after driving forward
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# VR threads — Do not delete
vr_thread(main)

socraigh_luas_tiomána #

Insíonn set_drive_velocity don róbat cé chomh tapa agus atá sé le tiomáint. Má tá céatadán níos airde ann, tiomáintfidh an róbat níos tapúla agus má tá céatadán níos ísle ann, tiomáintfidh an róbat níos moille.

Tosaíonn gach tionscadal leis an róbat ag tiomáint ag luas 50% de réir réamhshocraithe.

Nóta: Má bhíonn luas níos airde ann, bíonn an róbat ag tiomáint níos tapúla, ach d’fhéadfadh sé a bheith níos lú cruinn. Má bhíonn luas níos ísle ann, bíonn an róbat ag tiomáint níos moille, ach d’fhéadfadh sé a bheith níos cruinne.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Paraiméadair	Cur síos
`velocity`	An luas le tiomáint ó 0% go 100%. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	Roghnach. An t-aonad luais: `PERCENT` (réamhshocraithe).

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

socraigh_luas_casadh #

Insíonn set_turn_velocity don róbat cé chomh tapa agus atá sé le casadh. Má bhíonn céatadán níos airde ann, casann an róbat níos tapúla agus má bhíonn céatadán níos ísle ann, casann an róbat níos moille.

Tosaíonn gach tionscadal leis an róbat ag casadh ag luas 50% de réir réamhshocraithe.

Nóta: Má bhíonn luas níos airde ann, casann an róbat níos tapúla, ach d’fhéadfadh sé a bheith níos lú cruinn. Má bhíonn luas níos ísle ann, casann an róbat níos moille, ach d’fhéadfadh sé a bheith níos cruinne.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Paraiméadair	Cur síos
`velocity`	An luas le casadh leis ó 0% go 100%. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	Roghnach. An t-aonad luais: `PERCENT` (réamhshocraithe).

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Faighteoirí #

ceannteideal #

Is é treo an róbait ná an treo ina bhfuil sé ag tabhairt aghaidh, arna thomhas i gcéimeanna. Tugann heading treo reatha an róbait ar ais ó 0 go 359.99 céim.

Is é 0 céim treo tosaigh an róbait.

Usage:
drivetrain.heading(units)

Paraiméadair	Cur síos
`units`	Roghnach. An t-aonad ceannteidil: `DEGREES` (réamhshocraithe).

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

rothlú #

Is é rothlú an méid atá casta ag an róbat, arna thomhas i gcéimeanna. Ag tús tionscadail, socraítear an luach rothlaithe go 0 céim. Tugann rotation rothlú reatha an róbait ar ais.

Méadaíonn casadh ar dheis an rothlú, agus laghdaíonn casadh ar chlé an rothlú. Mar shampla, má dhéantar dhá chasadh iomlána ar dheis, beidh rothlú 720 céim ann.

Usage:
drivetrain.rotation(units)

Paraiméadair	Cur síos
`units`	Roghnach. An t-aonad rothlaithe: `DEGREES` (réamhshocraithe).

def main():
    # Display the rotation after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

is_done #

is_done tugann sé seo ar ais an bhfuil an róbat críochnaithe ag bogadh, mar luach Booleanach. Is féidir é seo a úsáid chun am iompraíochtaí eile a rialú bunaithe ar ghluaiseacht an róbait.

True — Tá an róbat críochnaithe ag bogadh.
False — Tá an róbat fós ag bogadh.

Oibríonn an modh seo i gcomhar leis na modhanna Drivetrain seo a leanas a bhfuil an paraiméadar wait acu: drive_for, turn_for, turn_to_heading, agus turn_to_rotation.

Usage:
drivetrain.is_done()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

ag_bogadh #

is_moving luach Booleánach ar ais chun a fháil amach an bhfuil an róbat ag bogadh. Is féidir é seo a úsáid chun am iompraíochtaí eile a rialú bunaithe ar ghluaiseacht an róbait.

True — Tá an róbat ag bogadh.
False — Níl an róbat ag bogadh.

Usage:
drivetrain.is_moving()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

luas #

Tugann velocity ar ais cé chomh tapa agus atá an róbat ag tiomáint, mar chéatadán ó -100% go 100%.

Usage:
drivetrain.velocity(units)

Paraiméadair	Cur síos
`units`	Roghnach. An t-aonad luais: `PERCENT` (réamhshocraithe).

Sampla

def main():
    # Display the velocity after driving
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

Gluaiseacht #

Úsáideann Fling an mótar iontógála chun Liathróidí a tharraingt isteach nó iad a dhíbirt. Seolann mótair teannas an chatapult agus lámh an chatapult na Liathróidí, agus athraíonn an teannas cé chomh fada agus a thaistealaíonn na Liathróidí.

Tá a threo-iompar féin ag gach mótar. Míníonn na tuairiscí treorach conas a ghluaiseann gach treo an mótar sin ar Fling.

Gníomhartha #

casadh #

Casann spin mótar ar aghaidh nó ar gcúl go deo. Leanfaidh an mótar ag sníomh go dtí go dtugtar gníomh eile dó, amhail sníomh i dtreo difriúil nó stopadh.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.spin(direction)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.spin(direction)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.spin(direction)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`direction`	Braitheann an treo a sníomhann an mótar ar an mótar roghnaithe: `FORWARD` — Casann sé an Mótar Iontógála i dtreo an iontógála nó bogann sé an mótar catapult roghnaithe ar aghaidh. `REVERSE` — Casann sé an Mótar Iontógála i dtreo an asghabhála nó bogann sé an mótar catapult roghnaithe ar gcúl.

Paraiméadair

Cur síos

direction

Braitheann an treo a sníomhann an mótar ar an mótar roghnaithe:

FORWARD — Casann sé an Mótar Iontógála i dtreo an iontógála nó bogann sé an mótar catapult roghnaithe ar aghaidh.
REVERSE — Casann sé an Mótar Iontógála i dtreo an asghabhála nó bogann sé an mótar catapult roghnaithe ar gcúl.

def main():
    # Spin the Intake Motor to collect a Ball
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

casadh_do #

spin_for rothlaíonn mótar ar feadh achar sonrach. Tá an rothlú i gcoibhneas le suíomh reatha an mhótair. Fanfaidh an tionscadal go dtí go mbeidh an mótar críochnaithe ag rothlú sula rithfidh an chéad líne eile de chód.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.spin_for(direction, distance, units, wait=True)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.spin_for(direction, distance, units, wait=True)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`direction`	Braitheann treo rothlaithe an mhótair ar an mótar roghnaithe: `FORWARD` nó `REVERSE`.
`distance`	An fad a rothlaíonn an mótar. `DEGREES` úsáid slánuimhreacha. `TURNS` is féidir slánuimhreacha nó deachúlacha a úsáid.
`units`	Roghnach. An t-aonad achair: `DEGREES` (réamhshocraithe) nó `TURNS`.
`wait`	Roghnach. `wait=True` (réamhshocraithe) — Fágann sé seo go bhfanann an tionscadal go dtí go mbeidh an mótar críochnaithe ag sníomh sula ritheann an chéad líne eile cóid. `wait=False` — Fágann sé seo go ritheann an chéad líne eile cóid láithreach.

def main():
    # Collect a Ball with the Intake Motor
    intake_motor.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

casadh_go_suíomh #

spin_to_position Casann mótar go suíomh ar leith.

Is é suíomh mótair an fad atá sé sníomhaithe, arna thomhas i DEGREES nó TURNSIs ionann casadh amháin agus 360 céim. Ag tús tionscadail, socraítear suíomh an mhótair go 0 céim. Is féidir suíomh an mhótair a shocrú freisin ag baint úsáide as an modh set_position.

Is luachanna absalóideacha iad luachanna suímh. Ciallaíonn sé seo go mbraitheann treo an rothlaithe ar shuíomh reatha an mhótair.

Mar shampla, má thosaíonn an mótar ag 0 céim agus má rothlaíonn sé go dtí suíomh 720 céim, rothlóidh sé ar aghaidh dhá chasadh. Má rothlaíonn sé ansin go dtí suíomh 360 céim, rothlóidh sé ar gcúl casadh amháin, mar go bhfuil 360 níos lú ná 720.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.spin_to_position(angle, units, wait=True)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.spin_to_position(angle, units, wait=True)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`angle`	An luach suímh a rothlóidh an mótar chuige. `DEGREES` úsáid slánuimhreacha. `TURNS` is féidir slánuimhreacha nó deachúlacha a úsáid.
`units`	Roghnach. An t-aonad suímh: `DEGREES` (réamhshocraithe) nó `TURNS`.
`wait`	Roghnach. `wait=True` (réamhshocraithe) — Fágann sé seo go bhfanann an tionscadal go dtí go mbeidh an mótar críochnaithe ag sníomh sula ritheann an chéad líne eile cóid. `wait=False` — Fágann sé seo go ritheann an chéad líne eile cóid láithreach.

Paraiméadair

Cur síos

angle

An luach suímh a rothlóidh an mótar chuige. DEGREES úsáid slánuimhreacha. TURNS is féidir slánuimhreacha nó deachúlacha a úsáid.

units

Roghnach. An t-aonad suímh: DEGREES (réamhshocraithe) nó TURNS.

wait

Roghnach.

wait=True (réamhshocraithe) — Fágann sé seo go bhfanann an tionscadal go dtí go mbeidh an mótar críochnaithe ag sníomh sula ritheann an chéad líne eile cóid.
wait=False — Fágann sé seo go ritheann an chéad líne eile cóid láithreach.

def main():
    # Move the Catapult Motor to a launch position
    catapult_motor.spin_to_position(2600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stop mótar #

stop stopann mótar ó sníomh.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.stop()` — Mótar Iontógála
`catapult_motor`	`catapult_motor.stop()` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.stop()` — Mótar Teannais Catapult

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Spin the Intake Motor, then stop it
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Sóiteoirí #

socraigh_suíomh #

Is é suíomh mótair an fad atá sé sníomhaithe, a thomhastar i DEGREES nó TURNS. Is ionann casadh amháin agus 360 céim. set_position athraíonn sé suíomh reatha an mhótair go luach nua.

Mar shampla, má tá mótar tar éis sníomh go 180 céim, má shocraítear an suíomh go 0 céim athshocrófar an suíomh sin ó 180 go 0 céim. Ansin is féidir leis an mótar sníomh go suíomhanna bunaithe ar an luach nua sin.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.set_position(position, units)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.set_position(position, units)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.set_position(position, units)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`position`	An luach suímh le socrú don mhótar. `DEGREES` úsáid slánuimhreacha. `TURNS` is féidir slánuimhreacha nó deachúlacha a úsáid.
`units`	Roghnach. An t-aonad suímh: `DEGREES` (réamhshocraithe) nó `TURNS`.

def main():
    # Set the Catapult Motor position, then return it to 0 degrees
    catapult_motor.set_position(2600, DEGREES)
    catapult_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

socraigh_luas #

Insíonn set_velocity do mhótar cé chomh tapa agus atá sé le sníomh. Má bhíonn céatadán níos airde ann, sníomhann an mótar níos tapúla agus má bhíonn céatadán níos ísle ann, sníomhann an mótar níos moille.

Tosaíonn gach tionscadal le gach mótar ag sníomh ag luas 50% de réir réamhshocraithe.

Nóta: Má bhíonn luas níos airde ann, rothlaíonn an mótar níos tapúla, ach d’fhéadfadh sé a bheith níos lú cruinn. Má bhíonn luas níos ísle ann, rothlaíonn an mótar níos moille, ach d’fhéadfadh sé a bheith níos cruinne.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.set_velocity(velocity, units)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.set_velocity(velocity, units)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`velocity`	An luas le sníomh leis ó -100% go 100%. Is féidir leis seo a bheith ina shlánuimhir `integer` nó ina dheachúil (`float`).
`units`	An t-aonad luais: `PERCENT`.

def main():
    # Set the Catapult Motor velocity before moving it
    catapult_motor.set_velocity(75, PERCENT)
    catapult_motor.spin_to_position(2600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

socraigh_am_scoite #

set_timeout socraíonn sé cé mhéad ama a dhéanfaidh mótar iarracht gluaiseacht a chríochnú. Mura féidir leis an mótar críochnú laistigh den am sin, stopfaidh sé ag iarraidh agus bogfaidh sé ar aghaidh go dtí an chéad líne eile de chód. Coinníonn sé seo an mótar ó bheith sáinnithe i ngluaiseacht.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.set_timeout(value, units)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.set_timeout(value, units)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.set_timeout(value, units)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`value`	An méid ama is féidir leis an mótar iarracht a dhéanamh gluaiseacht a chríochnú. Is féidir leis seo a bheith ina shlánuimhir dhearfach `integer` nó ina dheachúil (`float`).
`units`	An t-aonad ama: `SECONDS` nó `MSEC` (mileasoicind).

def main():
    # Limit how long the Catapult Motor waits to reach its target
    catapult_motor.set_timeout(2, SECONDS)
    catapult_motor.spin_to_position(5000, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Faighteoirí #

is_done #

is_done tugann sé seo ar ais an bhfuil an mótar críochnaithe ag bogadh, mar luach Booleanach. Is féidir é seo a úsáid chun am iompraíochtaí eile a rialú bunaithe ar ghluaiseacht an mhótair.

True — Tá an mótar críochnaithe ag gluaiseacht.
False — Tá an mótar fós ag gluaiseacht.

Oibríonn an modh seo i gcomhar leis na modhanna Gluaiseachta seo a leanas a bhfuil an paraiméadar wait acu: spin_for agus spin_to_position.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.is_done()` — Mótar Iontógála
`catapult_motor`	`catapult_motor.is_done()` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.is_done()` — Mótar Teannais Catapult

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

ag_sníomh #

is_spinning Booleánach ar ais chun a fháil amach an bhfuil an mótar ag sníomh, mar luach Booleánach. Is féidir é seo a úsáid chun am iompraíochtaí eile a rialú bunaithe ar ghluaiseacht an mhótair.

True — Tá an mótar ag sníomh.
False — Níl an mótar ag sníomh.

Oibríonn an modh seo i gcomhar leis na modhanna Gluaiseachta seo a leanas a bhfuil an paraiméadar wait acu: spin_for agus spin_to_position.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.is_spinning()` — Mótar Iontógála
`catapult_motor`	`catapult_motor.is_spinning()` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.is_spinning()` — Mótar Teannais Catapult

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

seasamh #

Is é suíomh innill an fad atá sé sníomhaithe, a thomhastar i DEGREES nó TURNSIs ionann casadh amháin agus 360 céim. position tugann sé suíomh reatha an innill ar ais.

Ag tús tionscadail, socraítear suíomh an mhótair go 0 céim. Má rothlaíonn an mótar casadh iomlán amháin ar aghaidh, beidh an suíomh 360 céim nó casadh amháin. Má rothlaíonn an mótar sa treo eile, beidh an suíomh diúltach.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.position(units)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.position(units)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.position(units)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`units`	An t-aonad chun suíomh an mhótair a thabhairt ar ais i: `DEGREES` nó `TURNS`.

def main():
    # Print the current Catapult Motor position
    brain.screen.print(catapult_motor.position(DEGREES))

# VR threads — Do not delete
vr_thread(main)

luas #

velocity a thugann ar ais cé chomh tapa agus atá an mótar ag sníomh.

Ciallaíonn luach dearfach go bhfuil an mótar ag sníomh ar aghaidh. Ciallaíonn luach diúltach go bhfuil an mótar ag sníomh ar gcúl.

Úsáid:
Is féidir ceann amháin de thrí réad mótair atá ar fáil a úsáid leis an modh seo, mar a thaispeántar thíos:

mótar	Ordú
`intake_motor`	`intake_motor.velocity(units)` — Mótar Iontógála
`catapult_motor`	`catapult_motor.velocity(units)` — Mótar Catapult
`catapult_tension_motor`	`catapult_tension_motor.velocity(units)` — Mótar Teannais Catapult

Paraiméadair	Cur síos
`units`	An t-aonad luais le tabhairt ar ais: `PERCENT`.

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Consól #

Taispeánann an Consól téacs, uimhreacha, agus luachanna athróg agus tionscadal ar siúl. Is féidir le modhanna consól an cúrsóir a bhogadh go sraith nua, an Consól a ghlanadh, agus athróga nó luachanna braiteora a chur leis an táb Monatóra.

Priontáil #

prionta.scáileáin.inchinne #

brain.screen.print taispeánann téacs, uimhreacha, nó luachanna athróg sa Chonsól ag baint úsáide as suíomh reatha an chúrsóra.

Úsáid brain.screen.next_row nuair is mian leat go dtosóidh an chéad luach priontáilte eile ar shraith nua.

Usage:
brain.screen.print(value)

Paraiméadair	Cur síos
`value`	An téacs, an uimhir, nó an luach athrógach le taispeáint sa Chonsól.

def main():
    # Display a message in the Console
    brain.screen.print("Hello, robot!")

# VR threads — Do not delete
vr_thread(main)

Consól VEXcode, ag taispeáint an Chonsóil agus an téacs "Haigh, a róbat!" le feiceáil.

scáileán.inchinn.an chéad_roghanna_eile#

brain.screen.next_row bogann an cúrsóir go colún 1 ar an gcéad ró eile sa Chonsól. Beidh an chéad luach eile a phriontáiltear le feiceáil ar an ró sin.

Usage:
brain.screen.next_row()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Print on two rows
    brain.screen.print("Row 1")
    brain.screen.next_row()
    brain.screen.print("Row 2")

# VR threads — Do not delete
vr_thread(main)

Consól VEXcode, ag taispeáint an Chonsóil agus an téacs "Ró 1" ar an gcéad líne agus "Ró 2" ar an dara líne.

scáileán.inchinn.scáileán_clear #

brain.screen.clear_screen Glanann sé na sraitheanna uile ón gConsól agus bogann sé an cúrsóir ar ais go Ró 1.

Usage:
brain.screen.clear_screen()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Display text, then clear it after two seconds
    brain.screen.print("This will disappear...")
    wait(2, SECONDS)
    brain.screen.clear_screen()

# VR threads — Do not delete
vr_thread(main)

Monatóir #

athróg_monatóra #

monitor_variable Cuireann athróg réamhshainithe amháin nó níos mó leis an táb Monatóireachta i VEXcode. Ligeann sé seo duit féachaint ar luach athróige ag athrú agus tionscadal ar siúl.

Ní mór athróga a bheith domhanda le go n-éireoidh le monatóireacht a dhéanamh orthu le monitor_variable Cuir ainm gach athróige ar fáil mar theaghrán.

Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)

Paraiméadair	Cur síos
`variable`	Ainm athróg dhomhanda réamhshainithe le monatóireacht a dhéanamh uirthi, tugtha mar theaghrán. Chun níos mó ná athróg amháin a mhonatóiriú, scar gach ainm athróg le camóg.

def main():
    # Monitor the amount of loops
    global loops
    monitor_variable("loops")

    # Drive in a square 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)
        drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

braiteoir_monatóra #

Cuireann monitor_sensor luach braiteora amháin nó níos mó leis an táb Monatóra i VEXcode. Ligeann sé seo duit féachaint ar luachanna braiteora ag athrú agus tionscadal ar siúl.

Cuir gach luach braiteora ar fáil mar theaghrán.

Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)

Paraiméadair	Cur síos
`sensor`	The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include: Brain `brain.timer.time` Drivetrain `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity_rpm` `drivetrain.velocity_percent` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position_degrees` `arm_motor.position_turns` `arm_motor.velocity_rpm` `arm_motor.velocity_percent` Arm Motor Group `arm_motor_group.is_done` `arm_motor_group.is_spinning` `arm_motor_group.position_degrees` `arm_motor_group.position_turns` `arm_motor_group.velocity_rpm` `arm_motor_group.velocity_percent` Intake Motor `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.velocity_percent` Intake Motor Group `intake_motor_group.is_done` `intake_motor_group.is_spinning` `intake_motor_group.position_degrees` `intake_motor_group.position_turns` `intake_motor_group.velocity_rpm` `intake_motor_group.velocity_percent` Catapult Motor `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Catapult Tension Motor `catapult_tension_motor.is_done` `catapult_tension_motor.is_spinning` `catapult_tension_motor.position_degrees` `catapult_tension_motor.position_turns` `catapult_tension_motor.velocity_rpm` `catapult_tension_motor.velocity_percent` Bumpers `intake_bumper.pressing` `bumper.pressing` Front Distance Sensor `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Front Optical Sensor `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` Color Sensor `color.is_near_object` `color.color` `color.brightness` `color.hue`

Paraiméadair

Cur síos

sensor

The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include:

Brain
- brain.timer.time
Drivetrain
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity_rpm
- drivetrain.velocity_percent
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position_degrees
- arm_motor.position_turns
- arm_motor.velocity_rpm
- arm_motor.velocity_percent
Arm Motor Group
- arm_motor_group.is_done
- arm_motor_group.is_spinning
- arm_motor_group.position_degrees
- arm_motor_group.position_turns
- arm_motor_group.velocity_rpm
- arm_motor_group.velocity_percent
Intake Motor
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.velocity_percent
Intake Motor Group
- intake_motor_group.is_done
- intake_motor_group.is_spinning
- intake_motor_group.position_degrees
- intake_motor_group.position_turns
- intake_motor_group.velocity_rpm
- intake_motor_group.velocity_percent
Catapult Motor
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Catapult Tension Motor
- catapult_tension_motor.is_done
- catapult_tension_motor.is_spinning
- catapult_tension_motor.position_degrees
- catapult_tension_motor.position_turns
- catapult_tension_motor.velocity_rpm
- catapult_tension_motor.velocity_percent
Bumpers
- intake_bumper.pressing
- bumper.pressing
Front Distance Sensor
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Front Optical Sensor
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
Color Sensor
- color.is_near_object
- color.color
- color.brightness
- color.hue

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Braiteadh #

Dath #

dath #

Tugann color sampla de rang Color ar ais, bunaithe ar an luach datha a braitheadh. Is féidir iad seo a chur i gcomparáid le réada réamhshainithe Color chun ráitis choinníollacha a chruthú.

Is iad na dathanna féideartha ná:

NONE
RED - Luach datha idir 340° - 20°
GREEN - Luach datha idir 80° - 140°
BLUE - Luach datha idir 200° - 240°
YELLOW - Luach datha idir 40° - 60°
ORANGE - Luach datha idir 20° - 40°
PURPLE - Luach datha idir 240° - 280°
CYAN - Luach datha idir 140° - 200°

Nóta: Tá an Braiteoir Datha ag lorg raonta datha a mheaitseálann an dath sonraithe. Chun raonta datha sonracha a bhrath, féach hue.

Usage:
color.color()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Print the color detected by the Color Sensor
    brain.screen.print(color.color())

# VR threads — Do not delete
vr_thread(main)

gile #

Tugann brightness an méid solais a léirítear ón réad ar ais mar dheachúil (float) a léiríonn céatadán.

Ciallaíonn céatadán níos airde go léirítear níos mó solais ar ais chuig an Braiteoir Datha. Ciallaíonn céatadán níos ísle go léirítear níos lú solais ar ais.

Usage:
color.brightness()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Print the Color Sensor brightness
    brain.screen.print(color.brightness())

# VR threads — Do not delete
vr_thread(main)

dath #

Tugann hue luach hue an datha braite ar ais mar dheachúil (float) ó 0 go 359.

Is bealach é lí chun dath a chur síos trí uimhreacha a úsáid timpeall ar roth datha.

Roth dathanna ciorclach a thaispeánann speictream iomlán dathanna atá lipéadaithe le luachanna céime timpeall an imlíne, ag méadú i méaduithe 30 céim ó 0 céim ag an mbarr go 360 céim.

Usage:
color.hue()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Print the hue detected by the Color Sensor
    brain.screen.print(color.hue())

# VR threads — Do not delete
vr_thread(main)

is_gar_don_réad #

is_near_object tugann sé luach Booleach ar ais a léiríonn an mbraitheann an Braiteoir Datha réad laistigh den raon nó nach mbraitheann.

True – Braitheann an Braiteoir Datha réad.
False – Ní bhraitheann an Braiteoir Datha réad.

Usage:
color.is_near_object()

Paraiméadair	Cur síos
	Níl aon pharaiméadair ag an modh seo.

def main():
    # Print whether the Color Sensor detects an object nearby
    brain.screen.print(color.is_near_object())

# VR threads — Do not delete
vr_thread(main)