Breakthrough Robotics

Cargo Connect - Kicking off 2021 season

2021-09-13T00:00:00-05:00

On Tuesday, our Breakthrough Robotics team will pick up for another season, after having taken last year off.

What is FIRST Lego League?

The Breakthrough Robotics team participates in the First Lego League competition. In FLL, student engage in research, problem-solving, coding and engineering – building and programming a LEGO robot that navigates the missions of a robot game. As part of Challenge, teams also participate in a research project to identify and solve a relevant real-world problem.

This year, the season theme is Cargo Connects with a focus on real-world transportation and supply chains. There’s a ton of info about the exact mission challenges and more specifics at the FIRST Website.

Meetings

We meet twice a week.

Tuesdays are required practice. We will use these days to go over the activities we are working on on and get an intro. Typical agenda for Tuesdays is as follows:

Time	Activity
6:30pm	Arrival & dinner
6:45pm	Weekly Standup (meet to go over activities for the night
~7:00pm	Core Values activity
7:15pm	Split into groups for work
7:45pm	(optional) check in on progress
8:15pm	Clean up
8:30pm	Leave

Thursdays are encouraged but optional practice. These nights are available for kids to continue work towards their goals.

Time	Activity
6:30pm	Arrival & dinner
6:45pm	Split into groups for work
7:45pm	(optional) check in on progress
8:15pm	Clean up
8:30pm	Leave

Season kickoff

Here’s a teaser kickoff from FLL for the season:

Check out our 2021 season details for more info.

I look forward to seeing you all there! Luke

Welcome to CoderZ

2020-05-14T00:00:00-05:00

Hello students! Tonight, we are going to be setting up a virtual robotics environment to allow for socially-distanced learning.

Please join the Zoom here at 7pm on Thursday May 14:

Join Zoom Meeting

The password is “bots”.

Follow along with the slides for this evening:

LEGO’s New Robot Language Is Awesome

2020-01-16T00:00:00-06:00

Last night was a great first class of Robotics 101. Every year when we start this class with a fresh set of new students, we try something new. We have two goals in the class: first, to help the kids learn the basic skills necessary to be an effective team member on the First Lego League team in the fall - but more importantly, to cultivate an interest and help them discover a passion for engineering.

This winter, LEGO released a version of Scratch built entirely to operate with EV3 robots. It’s a dramatic improvement over the previous version, called Labview, which has been the main choice for First Lego League for years.

Simpler language for simpler programs

Here is the intro program showing how a robot can drive straight. In Scratch, it’s pretty clear what’s happening - the robot should move forward for 2 rotations of the wheel, then stop for a second, move backward, stop, and then forward again.

In prior years (as recently as a month ago), the official software from LEGO used LabView. This language doesn’t use language, and is laid out horizontally. The code is a bit more confusing and requires more translation for new developers as a result. Here’s the same code shown in LabView:

Easier to understand more complicated programs too

Labview also presents challenges as programs get more complex. It’s challenging to comment, and when programs get more than a few pieces of logic they stretch into screenfuls without great ways to organize. LEGO has a concept of a “myblock” which is kind of like a function except they can’t nest, and editing the function is a challenge.

My students have often run into trouble understanding code with any switches or loops. We have to consistently re-explain what each block does (“oh, that’s a loop”) before we can get to the basic logic. For example, here’s a line follower in Labview. The robot follows the edge of a black line by using the color sensor to see whether it’s looking at a light or dark area and turning accordingly:

Even this relatively small program presents a lot of challenges. However, in Scratch the same program becomes more readable - the loop fades to the edge and the main attention is drawn to the core logic. Many of the optional features are not present unless specificaly called to. And you can sort of read the code and undresatnd roughly what it’s doing without necessarily having a lot of training in the specific blocks that are used.

Really complicated math is easier as well

When students write in Labview, the language makes it really hard to do even basic math. Labview includes the concepts of variables and math, but values are shuttled between blocks using “data wires” which are fairly arcane and nonintuitive. As an example, an advanced form of line following is called a “PID” line follower which takes into account past behavior to more precisely follow a black line.

The EV3Lessons tutorial on PID (link) is really top-notch and walks through the different components and how they work. However, the final result is nearly unintelligible:

While it’s still complicated, the Scratch version at least proceeds linearly and you can trace more easily where the different values come from and how they end up determining the motor direction. This is especially true if students have experience working in any other programming language, which are more likely to use variables than data wires. Here is the code from the updated Scratch tutorial on PID (also from Ev3Lessons) - link.

I am really excited for the potential of students to learn using Scratch and build more powerful programs than what is possible with Labview.

Real world use is fully supported

Bluetooth is the primary way we encoufrage our students to connect. It has been a challenge because, well Bluetooth is finicky. But the new connection screen really helps things out. Last year, I printed out worksheets showing students all the steps to take, but this year it’s built into the program. I can tell them “Just click Connect” and they followed the prompts and all got their robots hooked up.

Here’s the connection procedure - super fast end to end.

Compared with the old software, it’s a significant improvement. And when I consider alternatives - such as MakeCode, OpenRoberta, or Python, which each involve some major lifting (either inserting a SIM card, or only connecting via USB and some magic with connected drives), it becomes obviously easier for students to just use the code out of the box.

But this new release changes it all. It’s officially supported and released by LEGO - which means we can trust that over time, it will be the mainstream standard and bugs will be fixed. It supports Bluetooth out of the box with an intuitive connection interface that’s easier tan the one in Labview.

When I tried it with the class last night, we found that the kids were able to quickly build their robots AND connect them. By the end of the one -hour class, all students had their robots built and majority had connected them to the computers and gotten them to go straight.

Teaching kids to teach themselves

One issue I ran into with MakeCode is the very limited curriculum for kids to learn. There isn’t much of an online community for EV3 Make code so I wrote all my own guides. But this is painstaking and not great - most of waht I etaech kids is how to google for their simple asnwers. There are resources like Ev3Lessons.org that are tailored to Labview and were inaccessible to my previous attempts.

But I am super grateful to the Seshan Borthers for rewriting all their lessons to support the new language as well. The website ev3lessons has been essential for my journey as a coahc the last four years and the kids have learned some great techniques; but it has hampered my other attmpets to teach b because those resources arne’t aabilable if you’ren ot using Labview. But now, they support the new language as well.

Even the Seshan brothers tools show how the new language is easier. For exampe, take this advanced lesson on how to build a proportional line follower. The Labview ersion reuires a bunch of comments in the code itself and the math operations on variables are super hard to follow - I often have to write down what the equations should be just to make any sense.

Whereas, here in the Scratch version, the essential math fits on one line and at leaste makes sense as an equation. Students can then focus on “why” the code is this way rather than on “what” it’s doing.

In addition, the built-in tutorials for Scratch are similar to those offered by the prior version of EV3, but I think the smoothness of hte language makes the enviroment a bit more slick. For example, the tutorial automatically restricts that available blocks for certain lessons so that you’ll gradually release complexity and let kids move their way up.

Also, Scratch is a mainstream coding tool that kids may have encountered in school, as well. While it’s not a major professional language (like Python), it is more standard then some of the more custom ones like Labview, Make Code or OpenRoberta, which are all robot specific. We think that will expose the kids to better, more mature tech as well.

In summary, the new Scratch language is fun and will be a better fit for our class this winter.

Season Officially Begins

2019-09-03T00:00:00-05:00

Welcome to the Lego League Official Season! Tonight we begin the intense work to build a robot, develop a solution to a problem in the community, and grow as a team.

Team members! Please read through the rules- it is up to YOU to understand what’s required for your missions.

We will organize this season into two-week sprints. Every other Tuesday, we’ll have a team planning meeting, where we will use a Kanban board to organize which tasks each person will work on for that sprint. You can choose what you want to focus on and then work for two weeks to achieve each milestone.

Practice is every Tuesday & Wednesday (except for the Wednesday Nov 27 before Thanksgiving). Please plan to come to at least one practice every week, but come to as many as you can!

Reading below:

See you tonight!

Sprint Planning for First Lego League

2019-09-03T00:00:00-05:00

This is my third year of coaching our First Lego League team. I’ve noticed a few common questions come up that we haven’t had a great system to answer in the past:

Does everyone know what they need to do each night? Sometimes I’ve seen kids don’t really know or understand what’s expected of them. The rules and missions can be daunting and the language very precise, especially for a younger team of 4th and 5th graders.
Does everyone have the help they need to be successful? Kids can get stuck on simple things, like where is the LEGO piece I need for this attachment or how do I save my program? They can also get overwhelmed by the steps needed for the project.
What happened last time? Our practices are two nights a week, and volunteer coaches and kids may only be there for some of them. It’s helpful to know what was accomplished last time so you can pick up where they left off.

We have tried digital solutions - a shared Google doc, Slack channel, and email - but those seem to rarely work. First, not everyone has access to Internet outside of robotics, and at practice, once the laptops come out distractions go through the roof.

This fall, we are trying something with a bit more structure that I borrowed from professional sofware engineering - a Kanban board and sprints.

Standup

Tonight, we learned about “standup”. A standup is a brief meeting where everyone is standing in a circle. We have a big red one-minute sand timer that gets passed around. Each person talks for one minute and answers three questions:

What progress did I make last time?
What am I planning to work towards tonight?
What help do I need to make progress?

After everyone goes, we assess- are there gaps? If someone isn’t sure what to work on, then their teammates can make suggestions until each person has a project for the night.

Kanban Board

We track all the tasks on a “Kanban board”. I’m used to using digital versions of this such as Asana or Trello, but for this team a physical board is really effective. We use big post-its for each big task. Each kid has their own card which can move around and stick to the tasks. As people choose tasks, they are moved to “In Progress” with the person or people who are working on it attached.

So far we have only had two practices but it’s going well - the kids loved making the board and the first standup led to one of the most focused practices I’ve seen.

Sprint Planning

It’s possible that the daily standup will be sufficient; however, I think having a longer planning meeting every two or three weeks will be helpful. At the longer meeting, we’ll allocate 30-45 minutes at the beginning of practice to glom together three functions. In professional software development, these are sometimes combined and sometimes kept separate - we will have to experiment but I suspect doing them all at once will make the most sense.

Demos - as the season progresses, it will be helpful to have mini-milestones to showcase the current progress of the robot missions and project. A formal demo gives everyone a chance to show what they’ve done to their peers.
Retro - a quick reflection on what went well and what could be better during the last two weeks.
Planning - we’ll look ahead to the whole remainder of the season, evaluate where we are compared to our goals and consider if the set of goals should change.

These kids are ready for a great season of learning and discovery! Can’t wait to see what they create and how they grow as a team. Hopefully the agile structure will help them along.

City Shaper Kickoff - First Day!

2019-08-12T00:00:00-05:00

Every summer, Breakthrough hosts a 4-day Bootcamp to kick off the season. This was our best first day kickoff yet! We had eight hardy souls come out in the middle of summer to begin tackling the twin challenges of the Robot Game and the Innovation Project. Unfortunately, our challenge set has not yet arrived, but I think that will end up being a blessing as it gives us more time to digest the rules and focus on preparation so that the team will use their time more effectively when we get down to the business of actually building & programming.

First, we watched the kickoff video:

Then, the kids split into groups to go through each mission and think about how it might be accomplished. We used these awesome worksheets provided by the Seshan brothers (thanks!).

Already, I can tell that the kids AND coaches have a better understanding of all the missions than any of the teams did last season. It pays to spend some time learning!

Homework

Each team member should read through the full contents of the packet below, which covers the rules of the robot game.

Custom Blocks (MyBlocks) in MakeCode

2018-09-01T00:00:00-05:00

Our team is potentially participating in the pilot to use different programming languages this fall (see the MakeCode Pilot page). However, MakeCode has not nearly as many tutorials as are available for Mindstorms EV3 Native software, so we have looked at ways to replicate some of the familiar tasks that one may do using EV3.

In Ev3, MyBlocks are a way to reuse code in different contexts, which makes for more compact and easily understood programs. In MakeCode, you can write JavaScript functions to allow for reusable code instead. With special text comments, you can configure custom, reusable blocks that are a slightly more flexible than those found in EV3. (More on the differences below).

Move Centimeters in EV3

At EV3Lessons.com, the Seshan brothers have written an excellent tutorial for a simple MyBlock that moves the robot a given distance in centimeters. Using this MyBlock, you can measure the conversion from centimeters to rotations one time, enter it into the Myblock, and then re-use the block every time you want to move the robot.

The EV3 code is doing two things:

A Math block multiplies the distance (in CM) by a fixed, precalculated ratio to get the degrees that the large motors should rotate to achieve that distance. In the example, the ratio is 20.5 degrees for each centimeter.
The number of rotations is fed into a Move Steering block to propel the motor forward.
Both blocks are packaged as a single Myblock which can be invoked repeatedely.

Move centimeters in MakeCode

To do this in MakeCode, we will first make a program that moves centimeters manually. We can then create a custom block to allow it repeatedely.

To start, I’ll create a New Project which gives the basic New Project screen:

I’ll create a program that moves the motor for 10 centimeters, using the similar multiplication block that we saw above:

When I test it, I see that the robot moves 10 cm. Yes!

Let’s click the “JavaScript” button to see the equivalent code for the blocks we created:

The blocks and code do the same thing: multiple 10 x 20.5, and then tell the motors to steer that number of rotations.

So let’s take that same thing and create a custom block.

Custom blocks in MakeCode

MakeCode provides for the ability to create custom blocks using JavaScript functions. The biggest drawback is that it does require a little bit of text JavaScript code in order to create a custom block. (However, once created a custom block can be used exclusively through drag-n-drop).

MakeCode has documentation for this here.

First, click on JavaScript mode, and then the Explorer tab on the bottom left of the side panel:

Then, select the “+” next to the Explorer.

It asks if you want to create custom blocks - click “Go Ahead!”

Ok, now this is the most confusing part. When you click “Go Ahead”, MakeCode creates a new file called custom.ts in your project. It’s filled in with a bunch of sample code that can be overwhelming. We’ll explain this file briefly and then show you how to add your own custom block.

The file defines a few custom blocks already, called “foo” and “fib”. You can delete the whole file and replace it with this text:

//% color="green" block="Custom Blocks"
namespace custom {
    //% blockId=move_cm
    //% block="move|cm %v"
    export function move_cm(distance_cm: number): void {
        motors.largeBC.steer(distance_cm * 20.5, 50)
    }
}

Let’s explain what’s going on here:

First, we define the custom namespace. This means that all of our new blocks will live in a category called “Custom Blocks” that carries a green color. Note that we use a special comment tag //% to tell the MakeCode engine about our new block.

//% color="green" block="Custom Blocks"
namespace custom {

Next, we define the actual block using special comments. This tells MakeCode to expect a block that we call “move_cm”. The user will see the word “move” and then the value of a single parameter, “cm”.

    //% blockId=move_cm
    //% block="move|cm %v"

Third, we define the function itself. This is like the setup screen of the MyBlock in EV3. It says that the function is named “move_cm” and takes a single parameter called “distance_cm”.

    export function move_cm(distance_cm: number): void {

Finally, the actual contents of the function tell the block what to. In this case, we pass in the distance_cm, multiple it by 20.5, and use it to direct motors B+C to move forward at 50% power.

        motors.largeBC.steer(distance_cm * 20.5, 50)

Put it all together again:

//% color="green" block="Custom Blocks"
namespace custom {
    //% blockId=move_cm
    //% block="move|cm %v"
    export function move_cm(distance_cm: number): void {
        motors.largeBC.steer(distance_cm * 20.5, 50)
    }
}

After saving, we click on the main.blocks link on the sidebar:

That shows us the Custom Blocks sidebar and our new block is there!

We can drag it into our program to use it just as any other block:

Finally! Hopefully that was helpful in learning how to create the equivalent of a MyBlock in MakeCode.

Hydrodynamics - 2017 Season Wrapup

2018-08-01T00:00:00-05:00

The Breakthrough Robotics team performed better than expected last December during the regional qualifier for the Hydrodynamics season. Team members Aiden, Sammy, and Jayla led the robot to score the third highest score, with a final run that came right down to the buzzer.

The robot ultimately was composed of several interlocking gears and had 5 runs, each with their own attachments.

Additionally, the Breakthrough team won the Project award for outstanding teamwork. They came up with a creative application that would solve a real problem that humans encounter with water- how do people in remote areas of the world construct a water filter using locally available materials? Our team built a filter using rocks, sand, leaves, and plastic tubes and demonstrated for the judges.

However, our weakest performance came in the Core Values exercise. The judges did not see the team work well together, and we came up short.

This was a great showing for a team that had never worked that closely together before. Next year, we will need to develop our teamwork through more Core Values exercises and bring the same level of intensity to the project, even as we focus on applying some of the lessons from the Robot Game.