# IR Seeker IR Seeker is a multi-platform 360 degree IR Seeker, suitable for Robocup Junior Soccer (Standard, Lightweight). IR Seeker is a multi-platform 360 degree IR Seeker, suitable for Robocup Junior Soccer (Standard, Lightweight). For more advanced teams, the sensor can be programmed using the Arduino platform using the Grove I2C output. * Spike Prime * EV3 (Labview) * EV3 (Python) * Arduino (I2C) ![Version 2](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FGAIFGoCIqSNBC1NGZRd5%2FIR%20Seeker%20-%20v1-2%202%20.jpg?alt=media\&token=eacc005c-7956-4383-91a8-465615b37e30) Please note: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2F3twsz7CCmv6TVi7Qta5v%2FEV3%20LabView.png?alt=media\&token=9c2fe5f5-b9d6-4f96-aa66-34b186c2f8f7) ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FundRYaYnIauXQOUZm1WC%2FEV3%20Classroom.png?alt=media\&token=32bec9fc-66f8-41c2-b659-a1b439c48bdf) When the brick and board are connected to Spike Prime Software, the value of the position will jump around between a few close by positions. This is normal, your code for your robot will need to take this into account. ## Getting Started **Got 2 minutes?** Check out a video overview : ### Guides: Jump right in Follow our handy guides to get started on the basics as quickly as possible: {% content-ref url="/pages/SyAfKNWO5IYfPlwe9IWr" %} [Spike Prime](/guides/spike-prime) {% endcontent-ref %} {% content-ref url="/pages/W9cincGLW2FgZz9jbmsT" %} [EV3](/guides/ev3) {% endcontent-ref %} {% content-ref url="/pages/ZCRYs4Afuih1Wn1zVvt2" %} [Advanced (Arduino)](/guides/advanced-arduino) {% endcontent-ref %} # Spike Prime {% hint style="info" %} **Firmware Update**:\ We highly recommend updating to the latest firmware version. This will ensure that your sensor continues to work with Spike. The 2023 Spike release requires an update to your sensor. Please download the [latest version](/updates/latest-version) and follow the [upgrade process](/updates/firmware). {% endhint %} {% hint style="info" %} **Out of the box setup:** your IR Seeker is ready to use, plug it in and it will appear as if it is a colour sensor (unless it is an older V2 firmware). Rather than colour, the board will report the direction of the ball using the same pattern as a clock from the green value of the sensor. {% endhint %} The small switches on the board are used to turn on functionality. The [Board Feature Switches](/board-overview/board-feature-switches) page has more details on these settings. These settings can help you to get more features from the board. ## Blocks **Standard Mode**: The IR Seeker will make use of the distance sensor block, a basic program to show the current direction of the ball is shown below. ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FdQ9eXgKw9vReGkFR2TIg%2FBlocks.png?alt=media\&token=2b723a84-7983-4858-ad7f-9d657cf1a018) **Advanced Mode**: The IR Seeker will appear as a colour sensor. A basic program to show the current direction and signal strength is shown below. ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FK9DHPpNC3R2WWOlru6bu%2Fimage.png?alt=media\&token=d89fb784-2366-49ad-950c-ca146e4e87fc) The signal strength block uses the 'more sensors' additional block, this can be added by clicking the icon in the bottom left hand corner: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2F9zZAYMXpoQBx8uXS53Ul%2Fimage.png?alt=media\&token=b169370a-98d9-47db-a0a6-acda21c4f1c9) Then select the 'More Sensors' option: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FlQu0WUbVc42FDhuwkwEE%2Fimage.png?alt=media\&token=e75f80d8-466f-422b-82de-57457a6a149b) From here you will see some more blocks: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FMXF8jZJ4O6YpY9psI6hJ%2Fimage.png?alt=media\&token=e220a39a-04a5-49e5-ac5c-0301fab8d0ba) ## Python The IR Seeker will appear as if it is a Distance Sensor, we use the method get\_*distance*\_cm() to return the direction of the ball. ```python hub = PrimeHub() ir_seeker = DistanceSensor('A') while True: #write the direction to the screen every second. print(ir_seeker.get_distance_cm()) wait_for_seconds(1) ``` ## Advanced Python The main issue with using the IR Seeker as a distance sensor is that it can only provide the ball direction. Often the signal strength is important as well, however we need to use the advanced functionality to use both the **ball direction** and **ball distance** (signal strength). First step is to ensure the switch is set to advanced mode: DIP Switch 1 - On - DIP Switch 2 - On ```python import hub ir_seeker = hub.port.C.device #CHANGE TO YOUR PORT NUMBER ir_seeker.mode(5, bytes([0,0,0,0])) while True: data = ir_seeker.get() direction = data[0] print("Direction", direction) strength = data[2] print("Strength", strength) wait_for_seconds(1) ``` For Spike Prime 3.3.1 (and above) ```python import hub import color_sensor import runloop async def main(): while True: data = color_sensor.rgbi(hub.port.C) direction = data[1] print("Direction", direction) strength = data[2] print("Strength", strength) await runloop.sleep_ms(1000) runloop.run(main()) ``` The code will connect to the sensor and then issue a mode change command, the sensor can then be read and the raw values returned and used. ## Introduction {% embed url="" %} # PyBricks Using PyBricks Python The following example shows the most effective way to read the sensor in PyBricks. Be sure to update to the [SPIKE V3 firmware](/board-overview/spike-v3). ```python from pybricks.iodevices import PUPDevice from pybricks.parameters import Port device = PUPDevice(Port.A) while True: values = device.read(5) if len(values) > 0: print("Strength", values[0]) #return the signal strength if len(values) > 1: print("Direction", values[1]) #return the direction of the ball 0 - 12 ``` # Spike V3 Sample Simple Example Program The following program describes the process that can be undertaken to develop a program for the SPIKE V3. First this assumes that the robot is holonomic - that means that the robot is designed to face the goals while being able to move in any direction.
Students should first build up functions that move the robot in the common directions that the robot will move. The following layout shows the blocks that help students understand the desired movements: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FEz3Hu4098ro4oNZeWErk%2Fimage.png?alt=media\&token=01b36903-0508-44d8-a14c-da05a10ddc93) Each of these blocks are filled with the movement motor blocks: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FAZNht5DdoFTpdyThhXEX%2Fimage.png?alt=media\&token=5c0a53aa-a1f6-4bd0-a371-cb924749ceee) Remember that all of the motor speeds should be defined, even if only two motors are used for a movement:\ ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FcKUg90GAhQdilbEduQGc%2Fimage.png?alt=media\&token=ea501646-93f1-45ee-accb-53836eed3257) Be sure to include rotation movement, this will help us re-align our robot to the starting position. The next part is to build a simple loop that reads the robot position, ball position and optionally the ball strength. Have the students map out the direction they think the robot should undertake:

Map out which direction the robot should move - tip: go backwards as often as you can

This is a **non complete** sample program: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FYeJYhXput6GFk4f4WDHm%2Fimage.png?alt=media\&token=cff2a890-0d62-41cf-9542-9d9234fa090f) The code above will have the robot rotate if the alignment is out by 20 degrees or more. The code then will move the robot depending on the position of the ball. The ideal path is to create an orbit around the ball, the robot should be moving backwards behind the ball and only move forward when the ball is in front of the robot. Try to avoid forward movements until the ball is in front of the robot. As the sensor values and robot position changes, with the correct movement values the robot will naturally orbit the ball. Imagine that the ball is located at position 5 (back right). If the robot moves diagonal back right (assume the ball is stationary) the robot will eventually see the ball at sensor 3 or 4, which should also keep the robot moving to the right. The robot will then see sensor 1 or 12 and should then move forward, causing the orbit effect that is effective.
The challenge is to find the values and movement that work well for your robot. There is no secret combination, just lots of testing. Use the values of the ball strength to help make your path a little different (i.e. if the ball is on sensor 3 but far away, go directly towards the ball, not behind it).\ The ball signal strength is not a percentage value, you'll need to take readings and work out values that are meaningful to your robot. **Added Tip**: Think about mounting the IR Seeker upside down or building structure over the sensors to limit light going into the board. You might find that this helps with better readings # Two Wheeled Robot While a four wheeled robot provides the best performance for a soccer robot, often it's not possible to have four wheels. For those times, we've put together some ideas that might help make your two wheeled robot move better. ### Robot Position It's important that your robot is facing the goal as often as it can. This helps to ensure that you are pushing the ball in the right direction and that your robot position matches your coding logic. {% embed url="" %} The key is to have the robot periodically check to see if it is offset from it's starting position. We don't want to check too often, otherwise it will get caught up always trying to straighten and not be able to move effectively. Lets assume that every 2 seconds we will check to see if the robot is out of position and then make a correcting move.
The code will check every 2 seconds and test to see if the yaw is greater than 45 degrees, if it is out of position it will move to the left for a small period of time. Likewise the right hand turn check:
### Ball Chasing Next we put the ball direction into a variable so that we can easily compare it to our known directions. Some of our movements are pretty easy, if the ball position is zero, then we want to stop as no ball has been detected.
In the code above the loop has been broken into two parts. 1. When the robot is driving forward: BallPosition is greater than 8 or BallPosition is less than 4. - These are our **forward** movements. 2. Otherwise, we need to move **backwards**. Remember it's always better to get behind the ball and push forward.\ If the ball is directly behind us (i.e. position 6), we don't want the robot to go directly back, we want to choose a side and move to that direction. From here we pick a sensor position and think about the movement we want the robot to take to get behind the ball. Often we want to have one motor value higher than the other to get it to move in the right direction. This will mean that the robot starts to face the wrong way, but our position check above will help get the robot into the right position (when correcting movements are made to the robots position every 2 seconds, see above). Your goal is to get the robot behind the ball so that when it straightens up it can push forward.
It takes a lot of testing, each robot will be different. Thats where the fun starts! {% embed url="" %}
# EV3 ### Blocks Please note: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2F3twsz7CCmv6TVi7Qta5v%2FEV3%20LabView.png?alt=media\&token=9c2fe5f5-b9d6-4f96-aa66-34b186c2f8f7) ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FundRYaYnIauXQOUZm1WC%2FEV3%20Classroom.png?alt=media\&token=32bec9fc-66f8-41c2-b659-a1b439c48bdf) The IR Seeker board can be used with the EV3 Labview software using our custom blocks. [Download EV3 Blocks](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/BBSIRSeeker.ev3b) Once downloaded the blocks can be used like other ev3-g blocks. A very simple program to write the sensor value to the screen can be seen below: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2F6vuLcMZxAAXIOWHAgGCh%2Fev3blocks.png?alt=media\&token=23473ef9-8185-4010-aa6e-46cd2bc4abd4) There is no need to change the value 8 in the block. ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2F8LflqyNT93Kf9vqfIBrj%2FSample.PNG?alt=media\&token=753b5cec-ca98-4a7e-bd65-0aaf31406214) The IR Seeker feature switches should be set to: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FNTQLWEEINvULZfBmkvvB%2FAdvancedPosition.png?alt=media\&token=ed3c1eed-2cfc-4b88-accb-3bb510922131) ### EV3 Python Using EV3 Python: ```python from pybricks.iodevices import I2CDevice ir_sensor = I2CDevice(Port.S4, 0x08) #read two bytes, one contains direction, one contains strength ball_sensor_data = ir_sensor.read(2,2) ball_position = ball_sensor_data[0] ball_sig_strength = ball_sensor_data[1] ``` The IR Seeker feature switches should be set to: ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FNTQLWEEINvULZfBmkvvB%2FAdvancedPosition.png?alt=media\&token=ed3c1eed-2cfc-4b88-accb-3bb510922131) # Advanced (Arduino) A 3.3v Arduino can be connected to the IR Seeker as an I2C device. The sample code below will read the best sensor value and the signal strength of the board. The IR Seeker feature switches should be set to: 1. Off 2. On The pinout for I2C:
```arduino #include #include void setup() { Wire.begin(); } void loop() { Wire.requestFrom(0x10 / 2, 2); while (Wire.available()) { int c = Wire.read(); // direction is the first byte Serial.print("Best Sensor is: "); Serial.println(c); //smaller number the closer the ball int strength = Wire.read(); Serial.print("Strength is: "); Serial.println(strength); } delay(250); } ``` ```c /* * Example: read the whole sensor ring from the IR seeker over I2C. * * The seeker must be in ADVANCED_MODE (DIP switch 2 up) for its I2C peripheral to be enabled. * * The ALL register (0x02) returns one 16-byte snapshot per read: * * byte 0..11 raw pulse count per sensor, 0..255, in sensor order 1..12 * byte 12 best sensor, 1..12 (0 = no ball) * byte 13 strength, 0..100 * byte 14..15 bearing, little-endian uint16: 0..359 degrees, 361 = no ball * * Everything in the frame comes from the same detection cycle, so the counts * always agree with the best sensor and bearing reported alongside them. * * Wiring: seeker SDA/SCL to the master's SDA/SCL, plus a common ground. * Pull-ups are on the seeker board. */ #include #include #define IR_ADDR 0x08 // 7-bit address (the board sets it as 0x10/2) #define IR_MODE_DIRECTION 0x00 #define IR_MODE_ANGLE 0x01 #define IR_MODE_ALL 0x02 #define IR_SENSORS 12 #define IR_ALL_LEN (IR_SENSORS + 4) #define IR_ANGLE_NONE 361 struct IRFrame { uint8_t counts[IR_SENSORS]; // 0..255 per sensor, sensor 1 first uint8_t bestSensor; // 1..12, 0 = no ball uint8_t strength; // 0..100 uint16_t angle; // 0..359, or IR_ANGLE_NONE }; // Select which register subsequent reads return. Only needs sending when the // mode changes — the board remembers it until the next write (or a reset). void irSetMode(uint8_t mode) { Wire.beginTransmission(IR_ADDR); Wire.write(mode); Wire.endTransmission(); } // Read one ALL frame. Returns false (leaving `f` untouched) if the board did // not supply a full frame, e.g. it is unplugged or not in ADVANCED_MODE. bool irReadAll(IRFrame& f) { if (Wire.requestFrom(IR_ADDR, IR_ALL_LEN) != IR_ALL_LEN) { return false; } uint8_t buf[IR_ALL_LEN]; for (int i = 0; i < IR_ALL_LEN; i++) { buf[i] = Wire.read(); } for (int i = 0; i < IR_SENSORS; i++) { f.counts[i] = buf[i]; } f.bestSensor = buf[IR_SENSORS]; f.strength = buf[IR_SENSORS + 1]; f.angle = (uint16_t)buf[IR_SENSORS + 2] | ((uint16_t)buf[IR_SENSORS + 3] << 8); return true; } void setup() { Serial.begin(115200); while (!Serial && millis() < 3000) {} Wire.begin(); // join the bus as master irSetMode(IR_MODE_ALL); // ask for the full frame from now on Serial.println(F("IR seeker: reading ALL register (0x02)")); } void loop() { IRFrame f; if (!irReadAll(f)) { Serial.println(F("no response - check wiring and DIP 2")); delay(500); return; } Serial.print(F("counts:")); for (int i = 0; i < IR_SENSORS; i++) { Serial.print(' '); Serial.print(f.counts[i]); } if (f.angle == IR_ANGLE_NONE) { Serial.println(F(" | no ball")); } else { Serial.print(F(" | sensor ")); Serial.print(f.bestSensor); Serial.print(F(" strength ")); Serial.print(f.strength); Serial.print(F(" bearing ")); Serial.print(f.angle); Serial.println(F(" deg")); } delay(50); } ``` {% embed url="" %} # Firmware Firmware is the code that runs on your board. It can be updated to fix bugs and provide new functionality. ### Installing the firmware The IR board can be easily updated to change the functionality of the board. To update your board to the latest software. The following steps detail the process for updating the firmware. 1. Plug the IR board into your computer 2. Find the reset button on the board 3. Double press the reset button. If you have pressed the button correctly, you will see a new USB drive appear on your computer. This drive will be called BBSBOOT. 4. Copy the firmware update to this drive. 5. The IR board will restart and the USB drive will disappear. It’s now ready to be used on your robot again. {% embed url="" %} # Latest Version Find the latest version for your IR Seeker 2026 - BETA This is a beta version for IR Seeker (Sept 16th 2026) - Please let us know if you find any issues. {% file src="/files/WWUIQ9aeSKt0ihCCciCt" %} Version 2.2 This version is compatible with the Spike V3 application. This is the latest version of Spike released early 2023. [Download version 2.2](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/firmware2-2.uf2) - (May 15th 2023) Please see the [notes](/board-overview/spike-v3) on how to use version 2.2 ### Version 2 The latest version of our firmware brings more advanced features for our board. [Download the latest version 2](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/IRSeeker-2.uf2) Version 2.2 is needed for the Spike V3 application {% content-ref url="/pages/eHoxhP0oDREnyzJiPs5H" %} [Version 2](/previous-boards/version-2) {% endcontent-ref %} ### Version 1 {% content-ref url="/pages/W80D6RuT3dF9W6jwX3qh" %} [Version 1](/previous-boards/version-1) {% endcontent-ref %} # Calibration Process Step-by-step guide for high-school RoboCup teams to calibrate the IR Seeker board using the Web Serial visualiser. {% hint style="warning" %} The process below is specifically for the latest beta version of the IR Seeker Firmware {% endhint %} Your board has 12 infrared sensors in a ring that detect the pulsing light from the soccer ball. This guide walks your team through tuning them so the robot sees the ball clearly and judges its direction accurately. You only need a laptop and the ball, and the settings are saved onto the board — so you do this once, then re-do it only if things change. ## What calibration does (and why it matters) Two things can throw off how well the robot "sees" the ball: 1. **Background IR noise** — sunlight and some lights give off infrared too, which can fool the sensors. 2. **Uneven sensors** — part of your robot (a wheel, a wall, a bracket) might sit in front of some sensors and dim the ball's light, so those directions read weaker than they should. The robot then mis-judges the ball's direction. Calibration fixes both, using two controls on the page: * **Detection threshold** — how bright a signal has to be before a sensor says "I see the ball." This tunes out background noise. * **Per-sensor sensitivity (gain)** — boosts the weaker sectors so every sensor responds equally. This is what corrects for parts of your robot blocking the light. ## What you'll need * [ ] The robot (or just the IR board) with **all DIP switches flipped UP** * [ ] A laptop running **Chrome or Edge** (the page uses Web Serial) * [ ] A **USB cable** from the laptop to the board * [ ] Your **IR soccer ball**, switched **ON**, with **fresh / charged batteries** * [ ] A piece of **string** and some tape (your distance jig — see below) * [ ] A tape measure or ruler ## Set up the room first Background infrared is the number-one thing that ruins calibration. * **Block out sunlight.** Close blinds, or work in an interior room. Direct sun is full of IR and will swamp the sensors. * **Move away from heat / IR sources** — incandescent and halogen lamps, heaters, big TVs / plasma screens. Normal LED ceiling lights are usually fine. * **Clear other IR balls and remotes** from the area. Another team's ball or a TV remote nearby will confuse the sensors. * **Keep people and bags back** from the board while measuring — a body or hand close to a sensor can reflect or block IR. {% hint style="info" %} **Quick check:** with the ball **switched off** and nothing near the board, every sensor on the screen should be **black**. If some glow, you've got background IR or your threshold is too low — fix the room first, then set the threshold below. {% endhint %} ## The string trick — keeping the distance the same The sensitivity step works by spinning the ball around the board and recording how strongly each sensor reads. If your distance wobbles, the readings are meaningless. A piece of string keeps the ball at a fixed radius the whole way around — it's the perfect tool for this. 1. Pick a distance that's realistic for play — somewhere around **30–50 cm** works well. 2. **Tape one end of the string to the centre of the board** (the middle of the sensor ring) so it can pivot freely. 3. Cut or mark the string so the ball sits at your chosen distance when the string is **pulled tight**. 4. Hold the ball at the end and walk it around in a full circle, keeping the **string taut** and the ball at the **same height as the sensor ring** the whole time. A taut string gives you a perfect circle every time. {% hint style="info" %} Pick a distance where the sensor facing the ball lights up **strong red but not maxed out**. If a sensor shows the "saw too much" warning (flagged), move the ball a bit **farther away** and re-measure the string. {% endhint %} ## Step-by-step {% stepper %} {% step %} ## Enter visualiser mode and connect 1. Flip **all DIP switches UP** and power the board. 2. Plug the USB cable into the laptop. 3. Open the [calibration page](https://irseeker-visualiser.buildingblockrobotics.com/) in **Chrome / Edge**, click **Connect**, and pick the board's port from the list. 4. The 12-sensor ring should come alive. Switch the ball **on** and wave it near the board — the sensor facing it should glow red. {% endstep %} {% step %} ## Set the detection threshold 1. With the **ball off** and nothing nearby, look at the ring — all sensors should be **black**. 2. If some sensors glow on their own, **drag the Detection threshold slider up** until they all go dark. That's the noise floor. 3. Turn the **ball on** and check that the facing sensor lights up clearly. If detection feels too twitchy, nudge the threshold up a little; if it misses the ball, nudge it down. {% endstep %} {% step %} ## Capture per-sensor sensitivity (the orbit) 1. Set up your **string jig** (above). 2. Click **Start capture**. 3. **Slowly orbit the ball** one full lap around the board with the string taut, pausing briefly in front of each sensor so it gets a clean head-on reading. Take about 15–20 seconds for the lap. 4. Click **Stop capture**. The page automatically sets each sensor's gain so they all respond equally — the weaker (blocked) sectors get boosted. 5. Any sensor that **never saw the ball** is left at 100% and flagged. If a sensor you expected to work is flagged, check that nothing is fully blocking it and that your orbit passed in front of it, then capture again. {% endstep %} {% step %} ## Fine-tune by hand (optional) * Hold the ball in front of a specific sensor and watch its bar. If one direction still reads low compared with its neighbours, **drag that sensor's slider up** a little until they match. {% hint style="warning" %} Don't over-boost. Cranking a blocked sensor too high just amplifies its noise. If a sensor is **physically** blocked, the real fix is moving the bracket or wheel — calibration can only do so much. {% endhint %} {% endstep %} {% step %} ## Save to the board * Click **Save to board**. The status should change to **✓ saved**. Your settings are now stored on the board and survive power-off. {% endstep %} {% step %} ## Verify * Walk the ball around once more and confirm the highlighted sensor and the direction arrow track it smoothly all the way around, with no dead or over-sensitive sectors. {% endstep %} {% endstepper %} ### If your board is mounted upside-down Some robots have the board mounted flipped over (component side down). When that happens the ring is mirrored left-for-right, so the robot would think the ball is on the opposite side and chase the wrong way. Tick **Board mounted upside-down (flip left/right)** in the Orientation section. A **⇄ Mirrored** badge appears at the top of the page, and the board reports directions correctly again in every mode. {% hint style="success" %} **Always check it the easy way:** hold the ball directly to the robot's **left** and make sure the display lights up on the **left**. Then check right, front and back. If left and right are swapped, toggle the setting; if they're correct, leave it. Then **Save to board**. {% endhint %} {% hint style="warning" %} Only use this if the board is genuinely mounted upside-down. Setting it when it shouldn't be will make the robot chase the ball **backwards** — which is a confusing bug to track down. When in doubt, leave it off and do the left/right ball check above. {% endhint %} {% hint style="info" %} Be sure to reset the DIP Switches to the SPIKE Position (1 - On, 2 - Off, 3 - Off) {% endhint %} ## Tips & troubleshooting | Problem | Likely cause | Fix | | ---------------------------------------- | ---------------------------------------------------- | ------------------------------------------------------------------ | | Sensors glow with no ball | Background IR / threshold too low | Block sunlight; raise threshold | | One direction always reads weak | Robot structure blocking that sensor | Re-run capture; boost that sensor; consider moving the obstruction | | A sensor is flagged "saw no ball" | Orbit missed it, or it's fully blocked | Capture again, slower; check for a physical block | | Readings jump around | Loose distance, low ball battery, or moving too fast | Use the string; charge the ball; orbit slowly | | Sensor maxes out / flagged as too strong | Ball too close | Move the ball farther; re-measure the string | | Sensor never shows a reading | Broken Sensor on the Board | May need a repair | ## When to re-calibrate Redo calibration whenever: * You **change or rebuild the robot** near the sensors (new bracket, wheel, wall). * You **swap the ball**, or it's been a while. * You arrive at a **new venue** (different lighting). A quick threshold check at competition is always worth it. # Board Feature Switches The IR Seeker has three small switches that can control how the board operates. ### Version 2: The latest version update of the sensor uses the following switches: #### Spike Mode: DIP Switch 1 DIP Switch 1 ON - This will allow the sensor to work with SPIKE Prime.
DIP Switch 1 OFF - This will allow the sensor to work with EV3 Labview, Arduino or other platforms.
#### Advanced Mode: DIP Switch 2 If DIP Switch 1 is enabled and DIP Switch 2, the sensor will appear as a Spike Colour Sensor where the reflected light can be used for the direction and the raw red value of the sensor can be used for the signal strength.
If DIP Switch 1 is enabled and DIP Switch 2 is off, the sensor will appear as a Spike Distance Sensor where the distance value is used for the direction. No signal strength is available in this mode outside of the hardware setting (DIP 3).
#### Hardware Signal Strength: DIP Switch 3 DIP Switch 3 used with DIP Switch 1 will only return a value to the Spike if the ball is within half a field distance. This can be used to build a defender style robot that only attacks when the ball is close to the robot.
{% hint style="info" %} The following information relates to Version 1 of our IR seeker. If you are unsure which version you have please contact us at and we can provide the correct firmware files. {% endhint %} ### Version 1: Spike Prime Distance Sensor Mode To use the IR Seeker as a Spike Prime distance sensor, move the switches to the following position: 1 - On, 2 - Off - 3 - Off ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FAEmnzVYEOSe2ZU3wJ1l8%2FDefaultSwitchPos.png?alt=media\&token=b030d26c-6cd0-4bb8-b8ca-a065807a2a88) ### Advanced Mode - Including EV3 Labview In order to receive both the ball direction and ball strength from the sensor, the switches should be moved to the following position: 1 - Off, 2 - On, 3 - Off ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FNTQLWEEINvULZfBmkvvB%2FAdvancedPosition.png?alt=media\&token=ed3c1eed-2cfc-4b88-accb-3bb510922131) This position should be used for Arduino development. More information can be found here {% content-ref url="/pages/ZCRYs4Afuih1Wn1zVvt2" %} [Advanced (Arduino)](/guides/advanced-arduino) {% endcontent-ref %} ### Defender Mode In order to use the Spike as a Distance sensor, but with reduced visibility we can move the switches to the following position: 1 - On, 2 - Off, 3 - On ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FergNRFQddAxXlEaAMR9K%2FDefenderPos.png?alt=media\&token=4b2e226e-d57b-4c07-9e36-6eaa2b73a9ab) This will operate the same as the standard mode, however the sensor will only report the direction when the ball is within roughly half a field radius (around 50cm). # SPIKE V3 This information relates to the V3 release of SPIKE. {% hint style="info" %} [Download](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/firmware2-2.uf2) (May 15th, 2023) the Beta Version for the V3 release of SPIKE. Please use the upgrade [instructions](/updates/firmware) to update your board. This version will only appear as a colour sensor. {% endhint %} {% hint style="info" %} For V1 Boards with no DIP Switches, please use this version: [Version 2.2 for V1 Boards](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/firmware-v1-2-2.uf2) (May 15th, 2023) {% endhint %} ### Version 2.1: The latest version update of the sensor uses the following switches: #### Spike Mode: DIP Switch 1 DIP Switch 1 ON - This will allow the sensor to work with SPIKE Prime V3.
SPIKE MODE - Use DIP 1
This mode will make the sensor appear as if it is a colour sensor. The following table shows the values that can be used to program your robot. | Block | Description | | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- | | Colour |

Red - No Ball,

Yellow - Ball a little distance away
Blue - Ball is close

| | | | | Red | Signal Strength of the ball | | Green | Best Sensor of the ball (0-12) - 0 = ball not found | | Blue |

Angle of the ball relative to the sensor.
Direct in front is 0 degrees, moving 30 degrees around the board. i.e. Sensor 1 = 30, Sensor 2 = 60.

| Be sure to use the extra sensor blocks to access the colour blocks

Click on the extra blocks icon in the bottom left

Select More Sensors

Use the raw colour block to get access to all features.

# Using the Building Holes Welcome to your new Building Block Robotics IR Seeker. This unique IR Seeker has a hole pattern that allows teams to attach their IR Seeker to their robot at two different angles. The yellow holes are 45-degree holes. They will allow you to mount the EV3 and Spike Prime bricks at a 45 degree angle compared to the robot. These holes do not line up with the remaining holes. The 11x7 magenta lift-arm indicates where the EV3/Spike Prime brick is mounted – using 4 holes from the 90-degree hole pattern indicated with an Please refer to images below. The red holes are 90-degree holes. They will allow you to mount the EV3 and Spike Prime bricks at the same angle compared to the robot. These holes do not line up with the remaining holes. The 11x7 magenta lift-arm indicates where the EV3/Spike Prime brick is mounted – using 4 holes from the 90-degree hole pattern indicated with an Please refer to images below. ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FZuFaYXpJ7IWMHNU7F78H%2FboardOverview.png?alt=media\&token=cc3bcbe2-fe2c-47b3-82a8-bac94f6eb08a)
### 45 Degree - Yellow Holes ### 90 Degree - Red Holes # Installing EV3 Blocks The IR Seeker has custom blocks for EV3. This section details how to install them. 1. [Download the EV3 Blocks](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/BBSIRSeeker.ev3b) 2. Open the EV3 software, open up a new project. Use the Block Import menu item. ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FUfWyVFHysCC0IsAH0Stq%2FBlockImport.PNG?alt=media\&token=66abb6c0-26ef-4f0f-9896-357fd99848bc) ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FnaqzimxH6J5XlyOSx4Pc%2FImportPath.PNG?alt=media\&token=80cacfdd-0bac-467b-afd0-8e92124d9647) This will load a dialog that allows you to select the file that was downloaded in step 1. The EV3 software will ask to be restarted, once it starts again, a new block for the IRSeeker can be found in the yellow block category. # Version 2 Version 2 of our board is a major enhancement of the board. It includes the ability to have both signal strength and direction information. The use of the feature switches has been changed to enable this new functionality. # Version 1 Version 1 of our IR Seeker Our version 1 board uses different firmware version to provide advanced functionality. ### Firmware Links [Standard Version](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/Standard-v1-11.uf2) The standard mode of the IR Seeker supports the following configurations: * EV3 (EV3G - Via our custom blocks) * EV3 Python * Micro:Bit (via Adapter) * I2C - Via EV3 Port or Grove style connector * Spike Prime (Distance Sensor) [Standard Version (Defender)](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/Defender-v1-11.uf2) The defender mode of the IR Seeker supports the following configurations with half the field visibility of the standard firmware. * EV3 (EV3G - Via our custom blocks) * EV3 Python * Micro:Bit (via Adapter) * I2C - Via EV3 Port or Grove style connector * Spike Prime (Distance Sensor)
[Advanced Version](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/Advanced-v1-11.uf2) This mode can only be used from Spike Python, the sensor will no longer show up as a distance sensor. This mode will return both the direction and signal strength. * EV3 (EV3G - Via our custom blocks) * EV3 Python * EV3 (Classroom - Distance Sensor) * Micro:Bit (via Adapter) * Spike Prime Python ONLY ### Do I have a version 1 board? The version 1 IR Seeker has a single expansion port as shown in the image below. ![Version 1 of the IR Seeker](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2FuQWhbPecRg9dxj2iscjr%2Firseekerv1.jpg?alt=media\&token=4137c816-4bf1-42bd-8eaf-df4533eae57f) ### Detailed View ![](https://4213710887-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwumhy9Amexb1fvjNOGl8%2Fuploads%2F2xgwcf5CNSENcbBps8s6%2FIRSeeker-Labels.jpg?alt=media\&token=15f5c946-e8b4-4814-ba94-283486ff8446) # Board Update Your board is setup for SPIKE Legacy, it needs to be updated for SPIKE Version 3. Your IRSeeker has version 2 installed. This version will work with SPIKE Legacy. If you would like to use the new SPIKE Version 3, you will need to follow the process to update your board. **Step 1:** Download the [version 2.1 firmware](https://s3.amazonaws.com/www.buildingblockrobotics.com/firmware/firmware2-1b.uf2) for SPIKE Version 3. **Step 2**: Plug the board into your computer with a USB cable. **Step 3**: Quickly Double tap the reset button on the board. When done correctly, a new USB device will appear. **Step 4**. Copy the downloaded file from Step 1 onto the board. This [firmware page](/updates/firmware) has more details on how to update the firmware version of your board.