Video tutorials

Using everything that we've learned about LEGO Education SPIKE Prime competition programming we arrive at the final boss mission - how do we consistently reach a mission model at the other end of the field. Consistently. Every time. We use line following, motion sensor, counting of lines and border alignment. All the different concepts that we've looked at separately are now implemented together.

The LEGO Mindstorms EV3 set comes with two LARGE motors. But even though these motors look almost the same they are not quite the same. There are always some differences in their behaviour. If you have more than two motors, because you bought them or you won them somewhere at a competition, it is worth doing an experiment to find which pair of motors works best. 

The robot can move with different speed by applying different power to the motors. It will most of the time make smaller deviations when it moves slower. But you can't just move with a power of 10 all the time. This is a way too slow especially for competitions like FIRST LEGO League or World Robot Olympiad. In this video tutorial I would like to discuss the balance between motor power and robot movement error, how does the battery influence the power of the robot and to conduct an EV3-G experiment that will record the values of the Gyro Sensor along with the current power. 

This video tutorial contains the final 2 programs for moving straight with a LEGO Mindstorms EV3 robot. The first program is for proportional compensation that just keeps the robot orientation straight, while the second program is for Integral compensation that returns the robot to the straight line when the robot makes a mistake. 

This is where the confusion really comes. We are keeping the robot orientation straight while the robot moves, but at the end the, robot is not at the fiinal location that we would like it to be. The robot is still about 2-3 centimeters away after moving for about a meter.

The first part of making the robot move straight is to keep it oriented straight. While it moves it could make an error and turn slightly to the right and then the program should turn in back to the left to make its orientation straight. In this video tutorial, we would discuss how to implement a program to keep the robot orientation straight even when we are pushing or pulling it to either side and in the same time it has different wheels.

Would you like to resolve all the problems with the light/color sensors that you have? And to make all of them work in a predictable, stable way even when using more than one MINDSTORMS colour sensors. 

When using Color sensors it is important to calibrate them depending on the light conditions in your venue. In this way, the calibrated sensor will show values between 0 and 100 independent of the light conditions. But using the default EV3 colour calibration available in the colour sensor block could lead to unpredicted problems that are difficult to track and resolved especially when used with multiple Color sensors. So in this series of tutorial we implement the calibration ourselves discussing the principles of colour sensor calibration.

The integral part "remembers" the errors that the robot has made in the past and we can compensate for those errors. This will make the robot return back to the line that we would like to keep it aligned. 

It's inevitable. While following this gapped line we would reach a gap. The robot must somehow understand that there is a gap and must make a decision on what to do. For detecting the gap we use the Rotation Sensor. Not the most popular, but very convenient in many cases. Check out the video.

We should multiply the error by a certain number and then add it to the steering of the LEGO Mindstorms Steering block. In this way, by changing the coefficient we change how much/fast should the proportional part influence the steering of the robot. 

In this video tutorial, we would do a few experiments with the coefficients for the Integral compensation. There are actually two coefficients - "c" and "b"

We keep the robot orientation straight while moving, but when we stop the robot could be in a different orientation. This applies for both using the Mindstorms Gyro Sensor when moving straight or the Mindstorms Color sensor when following a line. In this video tutorial, we will do a few examples of when an how this could happen.

Let's record the values of the Gyro Sensor while the robot is moving and is trying to keep its orientation straight. This is an interesting experiment and we will have to use file access to write the values to a file. 

This video tutorial is about understanding the "magic". In this video tutorial, we would conduct an experiment and will look at how exactly does the integral part of the PID algorithm compensate for the error that the LEGO Mindstorms EV3 robot makes. 

In this tutorial, we would implement a program that finds the minimum and maximum value detected by the sensor and stores this two values in an array.

Many times we just upload blocks and leave it up to you to use it. In this tutorial, I would like to show you how to use the implemented blocks. How to import them into the EV3-G software. How to see them in the palette. How to drag and drop them to build a working program. 

"Array initialization" is the first step in every program that involves Arrays. This applies to most programming languages and for EV3-G it is a must. 

In this tutorial, we would show you how to initialize the array and how to extract this logic in a new block

This is one of the last tutorials in the LEGO Education SPIKE Prime programming for Competitions course and it demonstrates what we've all been waiting for - how to reach a mission model from base in a reliable and consistent way when the mission model is on the other end of the field. Naturally what we use are all the different concepts that we've learned in the course and the tutorial is more advanced than the other so if anything is not clear take a look also at the different tutorials an concepts in the course.

In the course section for Advance Sensor Calibration we previously showed you how to find the minimum and maximum value for a single LEGO Mindstorms Color Sensor and to store this value in an array. The program was implemented with the EV3-G software. In this tutorial we are going to find the Min and Max for all the four sensors and to store all the 8 values in an array.

Implement a program for stopping at a black line with the blocks containing the implementation details for the InitArray, Calibration and Getting the calibrated result. 

Following the Advance Light/Color sensors calibration for a minimum value for a single sensor tutorial, in this one, we continue with finding the maximum value detected by a sensor and storing this value in an array.

In this video tutorial we show how you can build robots that position on the field consistently and reliably by following and line and then aligning to a line. We also demonstrate the concept of "double align" which is quite powerful and even if there were some mistakes they will be handled.

In this video tutorial we demonstrate a really important concept for FIRST LEGO League competitions - you position the robot on the field with depending on timers and rotations. The issue with moving the robot for 10 seconds and then stopping is that every time it is in a different location. Same for rotations. The wheels will slip, the battery will change, something will happen and the robot will not be in the same place every time. This is not consistent and reliable.

As an exercise try to implement the calibration of the minimum and maximum values for a single sensor. 

Implement the program for array initialization.

Follow the video tutorials for initializing arrays and implement the program. 

Following the previous tutorials from the course, implement the calibration of the minimum and maximum values. 

One of the smartest things you could do in any software program is to extract logic in small reusable, simple, understandable units. In EV3-G these are called Blocks and we are going to extract the logic for finding a minimum and maximum for each of the sensors in a new block.