Python Sonrach do Róbónna#

Réamhrá #

Áirítear leis an Laoch Bot, Swish, rogha mótair amháin, rogha grúpa mótair amháin, agus an Braiteoir Optúil.

Tá gach modh caighdeánach VEXcode VR ar fáil lena n-úsáid i gClós Súgartha IQ 24-25 Rapid Relay.

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ótar agus grúpa mótair an róbait.

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

Optúil
- is_near_object – Tugann sé seo ar ais an mbraitheann an Braiteoir Optúil réad laistigh den raon.
- color – Tugann sé seo an dath a bhraith an Braiteoir Optúil 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 Optúil ar ais.
- object_detected – Cláraíonn sé feidhm le glaoch uirthi nuair a bhraitheann an Braiteoir Optúil réad.
- object_lost – Cláraíonn sé feidhm le glaoch uirthi nuair a chailleann an Braiteoir Optúil réad.

Ú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`	An t-aonad achair: `INCHES` 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`	An t-aonad rothlaithe: `DEGREES`.
`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`	An t-aonad rothlaithe: `DEGREES`.
`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`	An t-aonad rothlaithe: `DEGREES`.
`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`	An t-aonad ceannteidil: `DEGREES`.

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`	An t-aonad rothlaithe: `DEGREES`.

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`	An t-aonad luais: `PERCENT`.

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`	An t-aonad luais: `PERCENT`.

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`	An t-aonad ceannteidil: `DEGREES`.

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`	An t-aonad rothlaithe: `DEGREES`.

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`	An t-aonad luais: `PERCENT`.

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 Swish an mótar iontógála chun Liathróidí a bhailiú agus iad a bhogadh isteach sa chatapult. Íslíonn grúpa mótair an chatapult agus scaoileann sé lámh an chatapult chun Liathróidí a sheoladh.

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

Gníomhartha #

casadh #

Casadh spin rothlaíonn mótar nó grúpa mótair ar aghaidh nó ar gcúl go deo. Leanfaidh an mótar nó an grúpa mótair ag rothlú go dtí go dtugtar gníomh eile dó, amhail rothlú i dtreo difriúil nó stopadh.

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.spin(direction)` — Grúpa Catapult

Paraiméadair

Cur síos

direction

An treo a sníomhann an mótar nó an grúpa mótair:

FORWARD — Sníomhann sé an Mótar Iontógála i dtreo an iontógála nó íslíonn sé an Grúpa Catapult.
REVERSE — Sníomhann sé an Mótar Iontógála i dtreo an asbhaint nó scaoileann sé an Grúpa Catapult.

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

casadh_do #

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

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.spin_for(direction, distance, units, wait=True)` — Grúpa Catapult

Paraiméadair	Cur síos
`direction`	An treo a sníomhann an mótar nó an grúpa mótair: `FORWARD` — Sníomhann sé an Mótar Iontógála i dtreo an iontógála nó íslíonn sé an Grúpa Catapult. `REVERSE` — Sníomhann sé an Mótar Iontógála i dtreo an asbhaint nó scaoileann sé an Grúpa Catapult.
`distance`	An fad a rothlaíonn an mótar nó an grúpa mótair. `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 nó an grúpa mótair 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():
    # Release the preloaded Ball
    catapult_group.spin_for(REVERSE, 5, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_for(FORWARD, 1350, DEGREES)

# VR threads — Do not delete
vr_thread(main)

casadh_go_suíomh #

spin_to_position Casann mótar nó grúpa mótair go suíomh ar leith.

Is é suíomh mótair nó grúpa 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 nó an ghrúpa mótair go 0 céim. Is féidir suíomh an mhótair nó an ghrúpa mó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 nó an ghrúpa mótair.

Mar shampla, má thosaíonn an mótar nó an grúpa mótair 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 dhá réad mótair nó grúpa 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_group`	`catapult_group.spin_to_position(angle, units, wait=True)` — Grúpa Catapult

Paraiméadair	Cur síos
`angle`	An luach suímh a rothlóidh an mótar nó an grúpa mótair 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 nó an grúpa mótair 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 nó an grúpa mótair 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 nó an grúpa mótair 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():
    # Release the preloaded Ball
    catapult_group.spin_to_position(-90, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stop mótar #

stop stopann mótar nó grúpa mótair ó sníomh.

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.stop()` — Grúpa Catapult

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

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Sóiteoirí #

socraigh_suíomh #

Is é suíomh mótair nó grúpa 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 suíomh reatha an mhótair nó an ghrúpa mótair go luach nua.

Mar shampla, má tá mótar nó grúpa mótair 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 nó leis an ngrúpa mótair sníomh go suíomhanna bunaithe ar an luach nua sin.

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.set_position(position, units)` — Grúpa Catapult

Paraiméadair	Cur síos
`position`	An luach suímh le socrú don mhótar nó don ghrúpa mótair. `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():
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)
    # Set the new Catapult position to be 0 degrees
    catapult_group.set_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

socraigh_luas #

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

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

Nóta: Má bhíonn luas níos airde ann, bíonn an mótar nó an grúpa mótair ag sníomh 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 mótar nó an grúpa mótair ag sníomh níos moille, ach d’fhéadfadh sé a bheith níos cruinne.

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.set_velocity(velocity, units)` — Grúpa 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():
    # Start spinning the Intake Motor to prepare for picking up a Ball
    intake_motor.set_velocity(100, PERCENT)
    intake_motor.spin(FORWARD)

# 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 nó grúpa mótair iarracht gluaiseacht a chríochnú. Mura féidir leis an mótar nó leis an ngrúpa mótair críochnú laistigh den am sin, stopfaidh sé den iarracht agus bogfaidh sé ar aghaidh go dtí an chéad líne eile cóid. Coinníonn sé seo an mótar nó an grúpa mótair ó bheith sáinnithe i ngluaiseacht.

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.set_timeout(value, units)` — Grúpa Catapult

Paraiméadair	Cur síos
`value`	An méid ama is féidir leis an mótar nó leis an ngrúpa mótair 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 waits to reach its target
    catapult_group.set_timeout(2, SECONDS)
    catapult_group.spin_for(FORWARD, 2160, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Faighteoirí #

is_done #

is_done tugann sé seo ar ais an bhfuil an mótar nó an grúpa mótair 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 nó an ghrúpa mótair.

True — Tá an mótar nó an grúpa mótair críochnaithe ag bogadh.
False — Tá an mótar nó an grúpa mótair 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 dhá réad mótair nó grúpa 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_group`	`catapult_group.is_done()` — Grúpa Catapult

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

ag_sníomh #

is_spinning ar ais cibé an bhfuil an mótar nó an grúpa mótair ag sníomh, mar luach Booleanach. Is féidir é seo a úsáid chun am iompraíochtaí eile a rialú bunaithe ar ghluaiseacht an mhótair nó an ghrúpa mótair.

True — Tá an mótar nó an grúpa mótair ag sníomh.
False — Níl an mótar nó an grúpa mótair 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 dhá réad mótair nó grúpa 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_group`	`catapult_group.is_spinning()` — Grúpa Catapult

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

seasamh #

Is é suíomh mótair nó grúpa mótair 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 mhótair nó an ghrúpa mótair ar ais.

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

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.position(units)` — Grúpa Catapult

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

def main():
    # Lower the Catapult to prepare to load another Ball
    while not catapult_group.position(DEGREES) == 1260:
        catapult_group.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

luas #

Tugann velocity ar ais cé chomh tapa agus atá an mótar nó an grúpa mótair ag sníomh.

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

Úsáid:
Is féidir ceann amháin de dhá réad mótair nó grúpa 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_group`	`catapult_group.velocity(units)` — Grúpa Catapult

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

def main():
    # Print the current Catapult velocity
    brain.screen.print(catapult_group.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 #

Taispeánann brain.screen.print téacs, uimhreacha, nó luachanna athrógacha sa Chonsól ag baint úsáide as suíomh reatha an chúrsóra. Oibríonn sé cosúil le print ar leathanach API an Chonsóil.

Ú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 #

Optúil #

is_gar_don_réad #

is_near_object tugann sé luach Booleach ar ais a léiríonn an bhfuil nó nach bhfuil an Braiteoir Optúil ag brath réad laistigh den raon.

True – Braitheann an Braiteoir Optúil réad.
False – Ní bhraitheann an Braiteoir Optúil réad.

Usage:
intake_optical.is_near_object()

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor detects a Ball
    if intake_optical.is_near_object():
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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 Optúil ag lorg raonta datha a mheaitseálann an dath sonraithe. Chun raonta datha sonracha a bhrath, féach hue.

Usage:
intake_optical.color()

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

def main():
    # Launch a loaded Ball once yellow is detected in the Intake
    if intake_optical.color() == YELLOW:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# 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 Optúil. Ciallaíonn céatadán níos ísle go léirítear níos lú solais ar ais.

Usage:
intake_optical.brightness()

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor sees a Ball
    if intake_optical.brightness() > 0:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# 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:
intake_optical.hue()

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor reports a hue value
    if intake_optical.hue() > 100:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

réad_braite #

object_detected feidhm le glaoch uirthi aon uair a bhraitheann an Braiteoir Optúil réad nua.

Usage:
intake_optical.object_detected(callback, arg)

Paraiméadair	Cur síos
`callback`	Feidhm shainithe a fhorghníomhaítear nuair a bhraitheann an Braiteoir Optúil réad nua.
`arg`	Roghnach. Tuple ina bhfuil argóintí le cur chuig an bhfeidhm athghlaoite. Féach Úsáid Feidhmeanna le Paraiméadair le haghaidh tuilleadh eolais.

def launch_ball():
    catapult_group.spin_for(REVERSE, 5, DEGREES)

def main():
    # Launch the Ball when the Intake Optical Sensor detects an object
    intake_optical.object_detected(launch_ball)

# VR threads — Do not delete
vr_thread(main)

réad_caillte #

object_lost feidhm le glaoch uirthi aon uair a chailleann an Braiteoir Optúil réad braite.

Usage:
intake_optical.object_lost(callback, arg)

Paraiméadair	Cur síos
`callback`	Feidhm shainithe a fhorghníomhaítear nuair a chailleann an Braiteoir Optúil réad braite.
`arg`	Roghnach. Tuple ina bhfuil argóintí le cur chuig an bhfeidhm athghlaoite. Féach Úsáid Feidhmeanna le Paraiméadair le haghaidh tuilleadh eolais.

def lower_catapult():
    catapult_group.spin_to_position(1260, DEGREES)

def main():
    # Lower the Catapult when the Intake Optical Sensor no longer detects an object
    intake_optical.object_lost(lower_catapult)

# VR threads — Do not delete
vr_thread(main)