വിഷൻ സെൻസർ#
ആമുഖം#
കളർ സിഗ്നേച്ചറുകളും കളർ കോഡുകളും കണ്ടെത്താനും ട്രാക്ക് ചെയ്യാനും കഴിയുന്ന ഒരു ക്യാമറ അധിഷ്ഠിത സെൻസറാണ് വിഷൻ സെൻസർ. ഇത് ഒരു റോബോട്ടിനെ അതിന്റെ ചുറ്റുപാടുകൾ വിശകലനം ചെയ്യാനും വിഷ്വൽ ഇൻപുട്ടിനോട് പ്രതികരിക്കാനും അനുവദിക്കുന്നു.
താഴെയുള്ള ഉദാഹരണങ്ങൾക്ക്, കോൺഫിഗർ ചെയ്ത വിഷൻ സെൻസറിന് vision_1എന്ന് പേരിടും, കൂടാതെ Vision ക്ലാസ് രീതികൾ പരാമർശിക്കുമ്പോൾ ഈ API ഡോക്യുമെന്റേഷനിലുടനീളം തുടർന്നുള്ള എല്ലാ ഉദാഹരണങ്ങളിലും RED_BOXപോലുള്ള കോൺഫിഗർ ചെയ്ത കളർ സിഗ്നേച്ചർ ഒബ്ജക്റ്റുകൾ ഉപയോഗിക്കും.
എല്ലാ രീതികളുടെയും ഒരു ലിസ്റ്റ് താഴെ കൊടുക്കുന്നു:
ഗെറ്ററുകൾ — വിഷൻ സെൻസറിൽ നിന്ന് ഡാറ്റ നേടുക.
take_snapshot— ഒരു പ്രത്യേക ഒപ്പിനായി ഡാറ്റ പിടിച്ചെടുക്കുന്നു.installed— വിഷൻ സെൻസർ IQ (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന്.
പ്രോപ്പർട്ടികൾ — take_snapshot ൽ നിന്ന് ലഭിച്ച ഒബ്ജക്റ്റ് ഡാറ്റ.
largest_object— വിഷൻ സെൻസർ സ്നാപ്പ്ഷോട്ടിൽ നിന്ന് ഏറ്റവും വലിയ വസ്തു ഉടനടി തിരഞ്ഞെടുക്കുക..exists— നിലവിലെ ഡിറ്റക്ഷനിൽ വസ്തു നിലവിലുണ്ടോ എന്ന്..width— കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി..height— കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം..centerX— വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ X സ്ഥാനം..centerY— വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ Y സ്ഥാനം..angle— Orientation of the Color Code..originX— വസ്തുവിന്റെ മുകളിൽ ഇടത് കോണിലെ X സ്ഥാനം..originY— വസ്തുവിന്റെ മുകളിൽ ഇടത് കോണിന്റെ Y സ്ഥാനം.
കൺസ്ട്രക്റ്റർമാർ — സെൻസറുകൾ സ്വമേധയാ ഇനീഷ്യലൈസ് ചെയ്ത് കോൺഫിഗർ ചെയ്യുക.
ഗെറ്ററുകൾ#
take_snapshot#
take_snapshot വിഷൻ സെൻസർ ഫ്രെയിമിൽ നിന്ന് ഡാറ്റ ഒരു സിംഗിൾ സിഗ്നേച്ചറിലേക്ക് ഫിൽട്ടർ ചെയ്യുന്നു - കോൺഫിഗർ ചെയ്ത കളർ സിഗ്നേച്ചർ അല്ലെങ്കിൽ കളർ കോഡ് പോലുള്ള സെൻസറിന് തിരിച്ചറിയാൻ കഴിയുന്ന ഒന്നിന്റെ സംരക്ഷിച്ച വിവരണം - കൂടാതെ ഒരു ട്യൂപ്പിൾ തിരികെ നൽകുന്നു.
കളർ സിഗ്നേച്ചറുകൾ ഉം കളർ കോഡുകൾ ഉം ഈ രീതി ഉപയോഗിച്ച് ഉപയോഗിക്കുന്നതിന് മുമ്പ് വിഷൻ യൂട്ടിലിറ്റിയിൽ ആദ്യം കോൺഫിഗർ ചെയ്യണം.
സൂചിക 0 മുതൽ വീതി അനുസരിച്ച് ഏറ്റവും വലുത് മുതൽ ചെറുത് വരെ ക്രമീകരിച്ച വസ്തുക്കളെ ട്യൂപ്പിൾ സംഭരിക്കുന്നു. ഓരോ വസ്തുവിന്റെയും പ്രോപ്പർട്ടികൾ അതിന്റെ സൂചിക ഉപയോഗിച്ച് ആക്‌സസ് ചെയ്യാൻ കഴിയും. പൊരുത്തപ്പെടുന്ന വസ്തുക്കളൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ ഒരു ശൂന്യമായ ട്യൂപ്പിൾ തിരികെ നൽകും.
Usage:
vision_1.take_snapshot(SIGNATURE)
പാരാമീറ്ററുകൾ |
വിവരണം |
|---|---|
|
നൽകിയിരിക്കുന്ന ഒപ്പിന്റെ ഡാറ്റ മാത്രം ഉൾപ്പെടുത്തുന്നതിനായി ഡാറ്റാസെറ്റ് ഫിൽട്ടർ ചെയ്യുന്നു. ലഭ്യമായ ഒപ്പുകൾ ഇവയാണ്:
|
# Move forward if a red object is detected
while True:
red_box = vision_1.take_snapshot(vision_1__RED_BOX)
if red_box[0].exists:
drivetrain.drive_for(FORWARD, 10, MM)
wait(5, MSEC)
വർണ്ണ ഒപ്പുകൾ#
കളർ സിഗ്നേച്ചർ എന്നത് വിഷൻ സെൻസറിന് തിരിച്ചറിയാൻ കഴിയുന്ന ഒരു സവിശേഷ നിറമാണ്. ഈ സിഗ്നേച്ചറുകൾ വിഷൻ സെൻസറിനെ അവയുടെ നിറത്തെ അടിസ്ഥാനമാക്കി വസ്തുക്കളെ കണ്ടെത്താനും ട്രാക്ക് ചെയ്യാനും അനുവദിക്കുന്നു. ഒരു കളർ സിഗ്നേച്ചർ കോൺഫിഗർ ചെയ്തുകഴിഞ്ഞാൽ, സെൻസറിന് അതിന്റെ വ്യൂ ഫീൽഡിൽ ആ പ്രത്യേക നിറമുള്ള വസ്തുക്കളെ തിരിച്ചറിയാൻ കഴിയും. നിറമുള്ള വസ്തുക്കളെ തത്സമയം പ്രോസസ്സ് ചെയ്യുന്നതിനും കണ്ടെത്തുന്നതിനും take_snapshot ഉപയോഗിച്ച് കളർ സിഗ്നേച്ചറുകൾ ഉപയോഗിക്കുന്നു.
ഒരു പ്രോജക്റ്റിൽ കോൺഫിഗർ ചെയ്ത കളർ സിഗ്നേച്ചർ ഉപയോഗിക്കുന്നതിന്, അതിന്റെ പേര് വിഷൻ സെൻസറിന്റെ പേരും, രണ്ട് അണ്ടർസ്കോറുകളും, തുടർന്ന് കളർ സിഗ്നേച്ചറിന്റെ പേരും ആയിരിക്കണം. ഉദാഹരണത്തിന്: vision_1__RED_BOX.
# Display if any objects match the RED_BOX signature
while True:
brain.screen.set_cursor(1, 1)
brain.screen.clear_row(1)
# Change to any configured Color Signature
red_box = vision_1.take_snapshot(vision_1__RED_BOX)
if red_box[0].exists:
brain.screen.print("Color signature detected!")
wait(100, MSEC)
കളർ കോഡുകൾ#
ഒരു പ്രത്യേക ക്രമത്തിൽ ക്രമീകരിച്ചിരിക്കുന്ന വർണ്ണ സിഗ്നേച്ചറുകൾ കൊണ്ട് നിർമ്മിച്ച ഒരു ഘടനാപരമായ പാറ്റേണാണ് കളർ കോഡ്. ഈ കോഡുകൾ വിഷൻ സെൻസറിനെ മുൻകൂട്ടി നിശ്ചയിച്ച വർണ്ണ പാറ്റേണുകൾ തിരിച്ചറിയാൻ അനുവദിക്കുന്നു. സങ്കീർണ്ണമായ വസ്തുക്കളെ തിരിച്ചറിയുന്നതിനോ സ്വയംഭരണ നാവിഗേഷനായി അതുല്യമായ മാർക്കറുകൾ സൃഷ്ടിക്കുന്നതിനോ കളർ കോഡുകൾ ഉപയോഗപ്രദമാണ്.
ഒരു പ്രോജക്റ്റിൽ കോൺഫിഗർ ചെയ്ത കളർ കോഡ് ഉപയോഗിക്കുന്നതിന്, അതിന്റെ പേര് സെൻസറിന്റെ പേരും, രണ്ട് അണ്ടർസ്കോറുകളും, തുടർന്ന് കളർ കോഡിന്റെ പേരും ആയിരിക്കണം. ഉദാഹരണത്തിന്: vision_1__BOX_CODE.
# Display if any objects match the BOX_CODE code
while True:
brain.screen.set_cursor(1, 1)
brain.screen.clear_row(1)
# Change to any configured Color Code
box_code = vision_1.take_snapshot(vision_1__BOX_CODE)
if box_code[0].exists:
brain.screen.print("Color code detected!")
wait(100, MSEC)
installed#
installed വിഷൻ സെൻസർ നിലവിൽ IQ (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു.
True— വിഷൻ സെൻസർ ഐക്യു (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.False— വിഷൻ സെൻസർ IQ (രണ്ടാം തലമുറ) തലച്ചോറുമായി ബന്ധിപ്പിച്ചിട്ടില്ല.
Usage:
vision_1.installed()
പാരാമീറ്ററുകൾ |
വിവരണം |
|---|---|
ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല. |
# Display a message if the Vision Sensor is connected
if vision_1.installed():
brain.screen.print("Installed!")
പ്രോപ്പർട്ടികൾ#
largest_object#
take_snapshot ന്റെ ഏറ്റവും പുതിയ ഉപയോഗത്തിൽ നിന്ന് ലഭിച്ച ട്യൂപ്പിളിലെ ഡാറ്റ ലഭിക്കുന്നതിന് largest_object വീണ്ടെടുക്കുന്നു.
ഒരു സൂചിക വ്യക്തമാക്കാതെ തന്നെ ഒരു ട്യൂപ്പിളിൽ നിന്ന് ഏറ്റവും വലിയ ഒബ്ജക്റ്റ് എപ്പോഴും ലഭിക്കാൻ ഈ രീതി ഉപയോഗിക്കാം.
Usage:
vision_1.largest_object()
# Turn slowly until the largest object is centered in
# front of the Vision Sensor
drivetrain.set_turn_velocity(10, PERCENT)
drivetrain.turn(RIGHT)
while True:
red_box = vision_1.take_snapshot(vision_1__RED_BOX)
if red_box[0].exists:
if 140 < vision_1.largest_object().centerX < 180:
drivetrain.stop()
wait(10,MSEC)
Tuple Properties#
take_snapshot ഉപയോഗിച്ചതിനുശേഷം ഒരു ട്യൂപ്പിളിൽ സൂക്ഷിച്ചിരിക്കുന്ന ഓരോ ഒബ്‌ജക്റ്റിലും ഉൾപ്പെടുത്തിയിരിക്കുന്ന എട്ട് പ്രോപ്പർട്ടികൾ ഉണ്ട്.
take_snapshot ഉപയോഗിച്ച സമയത്ത്, കണ്ടെത്തിയ വസ്തുവിന്റെ സ്ഥാനവും വലുപ്പവും എല്ലാ പ്രോപ്പർട്ടി മൂല്യങ്ങളും വിഷൻ സെൻസറിന്റെ കാഴ്ചയിൽ വിവരിക്കുന്നു. സെൻസറിന്റെ 316 ബൈ 212 പിക്സൽ റെസല്യൂഷനെ അടിസ്ഥാനമാക്കി, ഈ മൂല്യങ്ങൾ പിക്സലുകളിലാണ് അളക്കുന്നത്.
.നിലവിലുണ്ട്#
ട്യൂപ്പിളിൽ സൂചിക നിലവിലുണ്ടോ ഇല്ലയോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ .exists നൽകുന്നു.
True— സൂചിക നിലവിലുണ്ട്.False— സൂചിക നിലവിലില്ല.
# Check if at least one red objects is detected
# You will receive an error if no objects are detected
while True:
brain.screen.clear_screen()
brain.screen.set_cursor(1, 1)
red_objects = vision_1.take_snapshot(vision_1__RED_BOX)
if red_objects[0].exists:
brain.screen.print("At least 1")
else:
brain.screen.print("No red objects")
wait(0.5, SECONDS)
.വീതി#
.width കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി പിക്സലുകളിൽ നൽകുന്നു, ഇത് 1 നും 316 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.
# Move towards a blue object until its width is
# larger than 100 pixels
while True:
blue_box = vision_1.take_snapshot(vision_1__BLUE_BOX)
if blue_box[0].exists:
if blue_box[0].width < 100:
drivetrain.drive_for(FORWARD, 10, MM)
else:
drivetrain.stop()
wait(50, MSEC)
.ഉയരം#
.height കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം പിക്സലുകളിൽ നൽകുന്നു, ഇത് 1 നും 212 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.
# Move towards a blue object until its height is
# larger than 100 pixels
while True:
blue_box = vision_1.take_snapshot(vision_1__BLUE_BOX)
if blue_box[0].exists:
if blue_box[0].height < 100:
drivetrain.drive_for(FORWARD, 10, MM)
else:
drivetrain.stop()
wait(50, MSEC)
.സെന്റർഎക്സ്#
.centerX കണ്ടെത്തിയ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ x-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 316 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.
# Turn slowly until the largest blue object is centered
# in front of the Vision Sensor.
drivetrain.set_turn_velocity(10, PERCENT)
drivetrain.turn(RIGHT)
while True:
blue_box = vision_1.take_snapshot(vision_1__BLUE_BOX)
if blue_box[0].exists:
if 140 < vision_1.largest_object().centerX < 180:
drivetrain.stop()
wait(10,MSEC)
.സെന്റർവൈ#
.centerY കണ്ടെത്തിയ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ y-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 212 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.
# Move towards a blue object until its
# center y-coordinate is more than 140 pixels
while True:
blue_box = vision_1.take_snapshot(vision_1__BLUE_BOX)
if blue_box[0].exists:
if blue_box[0].centerY < 140:
drivetrain.drive(FORWARD)
else:
drivetrain.stop()
wait(50, MSEC)
.ആംഗിൾ#
.angle കണ്ടെത്തിയ വസ്തുവിന്റെ ഓറിയന്റേഷൻ ഡിഗ്രികളിൽ നൽകുന്നു, ഇത് 0 നും 359 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.
# Turn left or right depending on how a
# configured box code is rotated
while True:
box_code = vision_1.take_snapshot(vision_1__BOX_CODE)
if box_code[0].exists:
if 50 < box_code[0].angle < 100:
drivetrain.turn(RIGHT)
elif 270 < box_code[0].angle < 330:
drivetrain.turn(LEFT)
else:
drivetrain.stop()
else:
drivetrain.stop()
wait(50, MSEC)
.ഒറിജിൻഎക്സ്#
.originX കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള x-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 316 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.
# Display if a red object is to the
# left or the right
while True:
brain.screen.clear_screen()
brain.screen.set_cursor(1,1)
red_box = vision_1.take_snapshot(vision_1__RED_BOX)
if red_box[0].exists:
if red_box[0].originX < 160:
brain.screen.print("To the left!")
else:
brain.screen.print("To the right!")
wait(50, MSEC)
.ഒറിജിൻവൈ#
.originY കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള y-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 212 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.
# Display if a red object is close or far
# from the robot
while True:
brain.screen.clear_screen()
brain.screen.set_cursor(1,1)
red_box = vision_1.take_snapshot(vision_1__RED_BOX)
if red_box[0].exists:
if red_box[0].originY < 80:
brain.screen.print("Far")
else:
brain.screen.print("Close")
wait(50, MSEC)
കൺസ്ട്രക്‌ടർമാർ#
VEXcode-ന് പുറത്തുള്ള സെൻസറുകൾ കോൺഫിഗർ ചെയ്യുന്നതിന് ആവശ്യമായ Vision, Signature, Code ഒബ്ജക്റ്റുകൾ സ്വമേധയാ സൃഷ്ടിക്കാൻ കൺസ്ട്രക്‌ടറുകൾ ഉപയോഗിക്കുന്നു.
Vision Sensor#
Vision ഒരു വിഷൻ സെൻസർ സൃഷ്ടിക്കുന്നു.
ഉപയോഗം
Vision(port, brightness, sigs)
പാരാമീറ്ററുകൾ |
വിവരണം |
|---|---|
|
1 മുതൽ 12 വരെയുള്ള ഏത് സ്മാർട്ട് പോർട്ടിലേക്കാണ് വിഷൻ സെൻസർ ബന്ധിപ്പിച്ചിരിക്കുന്നത്. |
|
ഓപ്ഷണൽ. വിഷൻ സെൻസറിന്റെ തെളിച്ച മൂല്യം, 1 മുതൽ 100 വരെ. |
|
ഓപ്ഷണൽ. ഒന്നോ അതിലധികമോ കളർ സിഗ്നേച്ചർ അല്ലെങ്കിൽ കളർ കോഡ് വസ്തുക്കളുടെ പേര്. |
ഉദാഹരണം
# Create a new Signature "RED_BOX" with the Signature class
RED_BOX = Signature(1, -3911, -3435, -3673,10879, 11421, 11150,2.5, 0)
# Create a new Vision Sensor "vision_1" with the Vision
# class, with the "RED_BOX" Signature.
vision_1 = Vision(Ports.PORT1, 100, RED_BOX)
# Move forward if a red object is detected
while True:
red_object = vision_1.take_snapshot(RED_BOX)
if red_object[0].exists:
drivetrain.drive_for(FORWARD, 10, MM)
wait(5, MSEC)
Color Signature#
Signature ഒരു കളർ സിഗ്നേച്ചർ സൃഷ്ടിക്കുന്നു. ഒരു വിഷൻ സെൻസറിൽ ഒരേസമയം ഏഴ് വ്യത്യസ്ത കളർ സിഗ്നേച്ചറുകൾ വരെ സംഭരിക്കാൻ കഴിയും.
ഉപയോഗം:
Signature(index, uMin, uMax, uMean, vMin, vMax, vMean, rgb, type)
പാരാമീറ്റർ |
വിവരണം |
|---|---|
|
|
|
വിഷൻ യൂട്ടിലിറ്റിയിൽ |
|
വിഷൻ യൂട്ടിലിറ്റിയിലെ |
|
വിഷൻ യൂട്ടിലിറ്റിയിൽ |
|
വിഷൻ യൂട്ടിലിറ്റിയിൽ |
|
വിഷൻ യൂട്ടിലിറ്റിയിൽ |
|
വിഷൻ യൂട്ടിലിറ്റിയിൽ |
|
വിഷൻ യൂട്ടിലിറ്റിയിൽ |
|
വിഷൻ യൂട്ടിലിറ്റിയിൽ |
ഒരു കളർ സിഗ്നേച്ചർ സൃഷ്ടിക്കുന്നതിനുള്ള മൂല്യങ്ങൾ ലഭിക്കുന്നതിന്, വിഷൻ യൂട്ടിലിറ്റി ലേക്ക് പോകുക. ഒരു കളർ സിഗ്നേച്ചർ കോൺഫിഗർ ചെയ്തുകഴിഞ്ഞാൽ, കോൺഫിഗറേഷൻ വിൻഡോയിൽ നിന്ന് പാരാമീറ്റർ മൂല്യങ്ങൾ പകർത്തുക.
ഉദാഹരണം
# Create a new Signature RED_BOX with the Signature class
RED_BOX = Signature(1, 10121, 10757, 10439,-1657, -1223, -1440,2.5, 1)
# Create a new Vision Sensor "vision_1" with the Vision
# class, with the RED_BOX Signature.
vision_1 = Vision(Ports.PORT1, 100, RED_BOX)
# Move forward if a red object is detected
while True:
red_object = vision_1.take_snapshot(RED_BOX)
if red_object[0].exists:
drivetrain.drive_for(FORWARD, 10, MM)
wait(5, MSEC)
Color Code#
Code ഒരു കളർ കോഡ് സൃഷ്ടിക്കുന്നു. ഇത് ഉപയോഗിക്കുന്നതിന് കുറഞ്ഞത് രണ്ട് നിർവചിക്കപ്പെട്ട കളർ സിഗ്നേച്ചറുകളെങ്കിലും ആവശ്യമാണ്. ഒരു വിഷൻ സെൻസറിൽ ഒരേസമയം എട്ട് വ്യത്യസ്ത കളർ കോഡുകൾ വരെ സംഭരിക്കാൻ കഴിയും.
ഉപയോഗം:
Code(sig1, sig2, sig3, sig4, sig5)
പാരാമീറ്റർ |
വിവരണം |
|---|---|
|
മുമ്പ് സൃഷ്ടിച്ച ഒരു കളർ സിഗ്നേച്ചർ. |
|
മുമ്പ് സൃഷ്ടിച്ച ഒരു കളർ സിഗ്നേച്ചർ. |
|
ഓപ്ഷണൽ. മുമ്പ് സൃഷ്ടിച്ച കളർ സിഗ്നേച്ചർ. |
|
ഓപ്ഷണൽ. മുമ്പ് സൃഷ്ടിച്ച കളർ സിഗ്നേച്ചർ. |
|
ഓപ്ഷണൽ. മുമ്പ് സൃഷ്ടിച്ച കളർ സിഗ്നേച്ചർ. |
ഉദാഹരണം
# Create two new Signatures for a red and blue box
RED_BOX = Signature(1, 10121, 10757, 10439,-1657, -1223, -1440, 2.5, 1)
BLUE_BOX = Signature(2, -4443, -3373, -3908,6253, 7741, 6997, 2.5, 1)
# Create a Color Code for a red box to the left of a blue box
RED_BLUE = Code(RED_BOX, BLUE_BOX)
# Create a new Vision Sensor "vision_1" with the Vision
# class, with the red_box and blue_box Signatures.
vision_1 = Vision(Ports.PORT1, 100, RED_BOX, BLUE_BOX)
# Display a message if Color Code is detected
while True:
brain.screen.set_cursor(1, 1)
brain.screen.clear_row(1)
# Change to any configured Color Code
box_code = vision_1.take_snapshot(RED_BLUE)
if box_code[0].exists:
brain.screen.print("Color code detected!")
wait(100, MSEC)