Python Sonrach do Róbónna#

Réamhrá #

Tá dhá rogha mótair sa Laoch Bot, Dex, Braiteoir Fís AI, Braiteoir Optúil, agus Braiteoir Córas Suite Cluiche (GPS).

Tá gach modh caighdeánach VEXcode VR ar fáil lena n-úsáid sa Chlós Súgartha V5 25-26 Push Back.

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.

Fís AI - Gabh agus anailísigh rudaí ag baint úsáide as an Braiteoir Fís AI.

Gabhálaithe
- take_snapshot – Tugann sé seo liosta de rudaí a braitheadh le haghaidh síniú ar leith ar ais.
Airíonna
- width – Leithead an réada braite i bpicteilíní.
- height – Airde an réada braite i bpicteilíní.
- centerX – Suíomh X lár an réada i bpicteilíní.
- centerY – Suíomh Y lár an réada i bpicteilíní.
- originX – Suíomh X chúinne uachtarach na láimhe clé den réada i bpicteilíní.
- originY – Suíomh Y chúinne uachtarach na láimhe clé den réada i bpicteilíní.
- id – Aicmiú nó aitheantas clibe an réada.

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é seo 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.
GPS
- x_position – Tugann sé seo comhordanáid x reatha Braiteora GPS ar an réimse ar ais.
- y_position – Tugann sé seo comhordanáid y reatha Braiteora GPS ar an bpáirc ar ais.
- heading – Tugann sé seo an ceannteideal atá os comhair an róbait faoi láthair ar ais bunaithe ar léamha an Braiteora GPS ó 0 go 359 céim.

Ú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 Dex an mótar iontógála chun bloic a tharraingt isteach sa róbat. Bogann mótar an iompair na bloic ón iontógáil go barr an róbait ionas gur féidir iad a bhrú isteach i sprioc.

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 Dex.

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 dhá 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
`conveyor_motor`	`conveyor_motor.spin(direction)` — Mótar Iompair

Paraiméadair

Cur síos

direction

An treo a sníomhann an mótar:

FORWARD — Casann sé Mótar an Iompair suas nó casann sé an Mótar Iontógála i dtreo an iontógála.
REVERSE — Casann sé Mótar an Iompair síos nó casann sé an Mótar Iontógála i dtreo an asbhaint.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# 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 dhá 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)` — Mótar Iontógála
`conveyor_motor`	`conveyor_motor.spin_for(direction, distance, units, wait)` — Mótar Iompair

Paraiméadair	Cur síos
`direction`	An treo a sníomhann an mótar: `FORWARD` — Casann sé Mótar an Iompair suas nó casann sé an Mótar Iontógála i dtreo an iontógála. `REVERSE` — Casann sé Mótar an Iompair síos nó casann sé an Mótar Iontógála i dtreo an asbhaint.
`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():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# 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 dhá 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
`conveyor_motor`	`conveyor_motor.spin_to_position(angle, units, wait=True)` — Mótar Iompair

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():
    # Pick up a second Block
    conveyor_motor.spin_to_position(150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

stad #

stop stopann mótar ó sníomh.

Úsáid:
Is féidir ceann amháin de dhá 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
`conveyor_motor`	`conveyor_motor.stop()` — Mótar Iompair

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

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)
    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 dhá 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
`conveyor_motor`	`conveyor_motor.set_position(position, units)` — Mótar Iompair

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():
    # Pick up a second Block
    conveyor_motor.set_position(-150, DEGREES)
    conveyor_motor.spin_to_position(0, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# 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 dhá 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
`conveyor_motor`	`conveyor_motor.set_velocity(velocity, units)` — Mótar Iompair

Paraiméadair	Cur síos
`velocity`	An luas le sníomh 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():
    # Pick up a second Block
    conveyor_motor.set_velocity(90, PERCENT)
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# 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 dhá 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
`conveyor_motor`	`conveyor_motor.set_timeout(value, units)` — Mótar Iompair

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():
    # Pick up a second Block
    conveyor_motor.set_timeout(0.5, SECONDS)
    conveyor_motor.spin_to_position(1000, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# 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 dhá 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
`conveyor_motor`	`conveyor_motor.is_done()` — Mótar Iompair

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

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not conveyor_motor.is_done():
        drivetrain.drive(FORWARD)
        intake_motor.spin(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

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 dhá 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
`conveyor_motor`	`conveyor_motor.is_spinning()` — Mótar Iompair

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

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while conveyor_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 200, MM)
        intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

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 dhá 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
`conveyor_motor`	`conveyor_motor.position(units)` — Mótar Iompair

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():
    # Pick up a second Block
    while conveyor_motor.position(DEGREES) < 150:
        conveyor_motor.spin(FORWARD)
        wait(2, MSEC)
    conveyor_motor.stop()
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# 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 dhá 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
`conveyor_motor`	`conveyor_motor.velocity(units)` — Mótar Iompair

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

def main():
    # Pick up a second block
    conveyor_motor.set_velocity(100, PERCENT)
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(conveyor_motor.velocity(PERCENT))
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Fís AI #

Faighteoirí #

tóg_pictiúr #

Scagann take_snapshot sonraí ó fhráma Braiteoir Fís AI go síniú aonair — cur síos sábháilte ar rud is féidir leis an braiteoir a aithint, amhail eilimint chluiche ar an bpáirc — agus tugann sé tuple ar ais.

Stórálann an tuple réada in ord ón gceann is mó go dtí an ceann is lú de réir leithead, ag tosú ag innéacs 0. Is féidir rochtain a fháil ar airíonna gach réada trína innéacs a úsáid. Seoltar tuple folamh ar ais mura mbraitear aon réada comhoiriúnacha.

Usage:
ai_vision.take_snapshot(signature)

Paraiméadair	Cur síos
`signature`	Scagann sé an tacar sonraí chun sonraí an tsínithe tugtha amháin a áireamh. Is iad na sínithe atá ar fáil: `AiVision.ALL_AIOBJS` - Braitheann sé Bloic Dhearga agus Gorma.

Paraiméadair

Cur síos

signature

Scagann sé an tacar sonraí chun sonraí an tsínithe tugtha amháin a áireamh. Is iad na sínithe atá ar fáil:

AiVision.ALL_AIOBJS - Braitheann sé Bloic Dhearga agus Gorma.

def main():
    # If an object is detected, pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            intake_motor.spin(FORWARD)
            drivetrain.drive(FORWARD)
            while not bumper.pressing():
                wait(2, MSEC)
            drivetrain.stop()
            break

# VR threads — Do not delete
vr_thread(main)

Airíonna #

Tá seacht n-airíonna san áireamh le gach réad atá stóráilte i dtuple tar éis take_snapshot a úsáid.

Déanann gach luach maoine seachas .id cur síos ar shuíomh agus méid an réada braite i radharc Braiteoir Fís AI ag an nóiméad a úsáideadh take_snapshot Tomhaistear na luachanna seo i bpicteilíní, bunaithe ar réiteach 320 faoi 240 picteilín an braiteora.

.leithead #

Tugann .width leithead an réada braite i bpicteilíní ar ais, ar slánuimhir é idir 1 agus 320.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 65:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

airde #

.height tugann sé airde an réada braite i bpicteilíní ar ais, ar slánuimhir é idir 1 agus 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 55:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX seolann sé comhordanáid-x lár an réada braite i bpicteilíní ar ais, ar slánuimhir idir 0 agus 320 é.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(LEFT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 140 < ai_objects[0].centerX < 180:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY seolann sé comhordanáid-y lár an réada braite i bpicteilíní ar ais, ar slánuimhir idir 0 agus 240 é.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 140:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX seolann sé comhordanáid-x chúinne uachtarach na láimhe clé de bhosca teorann an réada braite i bpicteilíní, ar slánuimhir idir 0 agus 320 í.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(RIGHT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 100 < ai_objects[0].originX < 140:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.bunúsY #

Tugann .originY comhordanáid-y chúinne uachtarach na láimhe clé de bhosca teorann an réada braite ar ais i bpicteilíní, arb é slánuimhir idir 0 agus 240 é.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 120:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id #

.id tugann sé aitheantóir an Aicmithe AI a braitheadh ar ais mar shlánuimhir.

Aicmiú AI	aitheantas	Síniú
Bloc Gorm	1	`GameElements.BLUE_BLOCK`
Bloc Dearg	2	`GameElements.RED_BLOCK`

def main():
    # Pick up a Red Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            drivetrain.drive(FORWARD)
            if (ai_objects[0].id) == 2:
                intake_motor.spin(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()
                break

# 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` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` 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` GPS Sensor `gps.position_mm` `gps.position_inches` `gps.heading` Pusher Rotation Sensor `pusher_rotation.angle` `pusher_rotation.position` AI Vision Sensor `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

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
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
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
GPS Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
Pusher Rotation Sensor
- pusher_rotation.angle
- pusher_rotation.position
AI Vision Sensor
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

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:
optical.is_near_object()

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

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not optical.is_near_object():
        wait(2, MSEC)
    conveyor_motor.stop()

# 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:
optical.color()

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

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not optical.color() == BLUE:
        wait(2, MSEC)
    conveyor_motor.stop()

# 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:
optical.brightness()

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

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not 0 < optical.brightness():
        wait(2, MSEC)
    conveyor_motor.stop()

# 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° ag an mbarr go 360°.

Usage:
optical.hue()

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

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not 220 < optical.hue() < 260:
        wait(2, MSEC)
    conveyor_motor.stop()

# 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:
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 ready_block():
  # Stop the conveyor when Block is at the Sensor
  conveyor_motor.stop()

def main():
  # Move the preloaded Block near the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_detected(ready_block)

# 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:
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 ready_block():
  # Stop the conveyor when Block is at the top
  conveyor_motor.stop()

def main():
  # Move the preloaded Block to the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_lost(ready_block)

# VR threads — Do not delete
vr_thread(main)

GPS #

suíomh_x #

Tugann x_position comhordanáid-x reatha Braiteora GPS (Córas Suiteála Cluiche™) ar an bpáirc ar ais.

Usage:
gps.x_position(units)

Paraiméadair	Cur síos
aonaid	Aonad an luacha fritháirimh: `INCHES` nó `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -795:
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

suíomh_y #

Tugann y_position comhordanáid y reatha Braiteora GPS (Córas Suiteála Cluiche™) ar an bpáirc ar ais.

Usage:
gps.y_position(units)

Paraiméadair	Cur síos
aonaid	Aonad an luacha fritháirimh: `INCHES` nó `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not -450 > gps.y_position(MM):
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

ceannteideal #

Tugann heading an ceannteideal atá os comhair an róbait faoi láthair ar ais bunaithe ar léamha an Braiteora GPS (Córas Positioning Cluiche™) ó 0 go 359 céim.

Usage:
gps.heading()

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

def main():
    # Score the preloaded Block into a Center Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not 40 > gps.heading():
        wait(2, MSEC)
    drivetrain.drive_for(FORWARD, 1000, MM)
    drivetrain.turn(RIGHT)
    while not gps.heading() > 310:
        wait(2, MSEC)
    drivetrain.drive_for(REVERSE, 400, MM)
    conveyor_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)