Foundation
Raspberry Pi
Documentation
Computers
Accessories
Microcontrollers
Services
Pico C SDK
Build HAT
Introducing the Build HAT
Edit this on GitHub
The Raspberry Pi Build HAT is an add-on board that
connects to the 40-pin GPIO header of your Raspberry Pi,
which was designed in collaboration with LEGO®
Education to make it easy to control LEGO® Technic™
motors and sensors with Raspberry Pi computers.
NOTE
A full list of supported devices can be found in the
Device Compatibility section.
It provides four connectors for LEGO® Technic™ motors
and sensors from the SPIKE™ Portfolio. The available
sensors include a distance sensor, a colour sensor, and a
versatile force sensor. The angular motors come in a
range of sizes and include integrated encoders that can
be queried to Pnd their position.
The Build HAT Pts all Raspberry Pi computers with a 40-
pin GPIO header, including — with the addition of a ribbon
cable or other extension device — Raspberry Pi 400.
Connected LEGO® Technic™ devices can easily be
controlled in Python, alongside standard Raspberry Pi
accessories such as a camera module.
The Raspberry Pi Build HAT power supply (PSU), which is
available separately, is designed to power both the Build
HAT and Raspberry Pi computer along with all connected
LEGO® Technic™ devices.
The LEGO® Education SPIKE™ Prime Set 45678 and
SPIKE™ Prime Expansion Set 45681, available separately
from LEGO® Education resellers, include a collection of
useful elements supported by the Build HAT.
NOTE
The HAT works with all 40-pin GPIO Raspberry Pi
boards, including Raspberry Pi 4 and Raspberry Pi
Zero. With the addition of a ribbon cable or other
extension device, it can also be used with Raspberry
Pi 400.
Controls up to 4 LEGO® Technic™ motors and
sensors included in the SPIKE™ Portfolio
Easy-to-use Python library to control your LEGO®
Technic™ devices
Fits onto any Raspberry Pi computer with a 40-pin
GPIO header
Onboard RP2040 microcontroller manages low-
level control of LEGO® Technic™ devices
External 8V PSU available separately to power both
Build HAT and Raspberry Pi
NOTE
The Build HAT can not power the Raspberry Pi 400 as it
does not support being powered via the GPIO headers.
Preparing your Build HAT
Edit this on GitHub
NOTE
Before starting to work with your Raspberry Pi Build
HAT you should set up your Raspberry Pi, install the
latest version of the operating system using
Raspberry Pi Imager.
Attach 9mm spacers to the bottom of the board. Seat the
Raspberry Pi Build HAT onto your Raspberry Pi. Make
sure you put it on the right way up. Unlike other HATs, all
the components are on the bottom, leaving room for a
breadboard or LEGO® elements on top.
+tting build hat
Access the GPIO Pins
If you want to access the GPIO pins of the Raspberry Pi,
you can add an optional tall header and use 15 mm
spacers.
tall headers
The following pins are used by the Build HAT itself and
you should not connect anything to them.
GPIO Use Status
GPIO0/1 ID prom
GPIO4 Reset
GPIO14 Tx
GPIO15 Rx
GPIO16 RTS unused
GPIO17 CTS unused
Setting up your Raspberry Pi
Once the Raspberry Pi has booted, open the Raspberry Pi
ConPguration tool by clicking on the Raspberry Menu
button and then selecting “Preferences” and then
“Raspberry Pi ConPguration”.
Click on the “interfaces” tab and adjust the Serial settings
as shown below:
Using your Raspberry Pi Headless
If you are running your Raspberry Pi headless and using
raspi-config, select “Interface Options” from the Prst
menu.
Then “P6 Serial Port”.
Disable the serial console:
And enable the serial port hardware.
The Pnal settings should look like this.
You will need to reboot at this point if you have made any
changes.
Powering the Build HAT
Connect an external power supply — the oicial
Raspberry Pi Build HAT power supply is recommended —
however any reliable +8V±10% power supply capable of
supplying 48W via a DC 5521 centre positive barrel
connector (5.5mm × 2.1mm × 11mm) will power the Build
HAT. You don’t need to connect an additional USB power
supply to the Raspberry Pi as well, unless you are using a
Raspberry Pi 400.
NOTE
The Build HAT can not power the Raspberry Pi 400 as it
does not support being powered via the GPIO headers.
NOTE
The LEGO® Technic™ motors are very powerful; so to
drive them you’ll need an external 8V power supply. If you
want to read from motor encoders and the SPIKE™ force
sensor, you can power your Raspberry Pi and Build HAT
the usual way, via your Raspberry Pi’s USB power socket.
The SPIKE™ colour and distance sensors, like the motors,
require an external power supply.
You have the choice to use Build HAT with Python or
.NET.
Using the Build HAT from
Python
Edit this on GitHub
Installing the Python Library
Install the Build HAT Python library. Open a Terminal
window and type,
$ pip3 install buildhat
For more information about the Build HAT Python Library
see ReadTheDocs.
Using Motors from Python
There are a number of motors that work with the Build
HAT.
Connecting a Motor
Connect a motor to port A on the Build HAT. The LPF2
connectors need to be inserted the correct way up. If the
connector doesn’t slide in easily, rotate by 180 degrees
and try again.
connect motor
Working with Motors
Start the Thonny IDE. Add the program code below:
from buildhat import Motor
motor_a = Motor('A')
motor_a.run_for_seconds(5)
Run the program by clicking the play/run button. If this is
the Prst time you’re running a Build HAT program since
the Raspberry Pi has booted, there will be a few seconds
pause while the Prmware is copied across to the board.
You should see the red LED extinguish and the green LED
illuminate. Subsequent executions of a Python program
will not require this pause.
Your motor should turn clockwise for 5 seconds.
Change the Pnal line of your program and re-run.
motor_a.run_for_seconds(5, speed=50)
The motor should now turn faster. Make another change:
motor_a.run_for_seconds(5, speed=-50)
The motor should turn in the opposite (anti-clockwise)
direction
Create a new program by clicking on the plus button in
Thonny. Add the code below:
from buildhat import Motor
motor_a = Motor('A')
while True:
print("Position: ", motor_a.get_aposition())
Run the program. Grab the motor and turn the shaft. You
should see the numbers printed in the Thonny REPL
changing.
Using Sensors from Python
There is a large range of sensors that work with the Build
HAT.
Working with Sensors
Connect a Colour sensor to port B on the Build HAT, and a
Force sensor to port C.
NOTE
If you’re not intending to drive a motor, then you don’t
need an external power supply and you can use a
standard USB power supply for your Raspberry Pi.
Create another new program:
from signal import pause
from buildhat import ForceSensor, ColorSensor
button = ForceSensor('C')
cs = ColorSensor('B')
def handle_pressed(force):
cs.on()
print(cs.get_color())
def handle_released(force):
cs.off()
button.when_pressed = handle_pressed
button.when_released = handle_released
pause()
Run it and hold a coloured object (LEGO® elements are
ideal) in front of the colour sensor and press the Force
sensor plunger. The sensor’s LED should switch on and
the name of the closest colour should be displayed in the
thonny REPL.
Using the Build HAT from
.NET
Edit this on GitHub
Installing the .NET Framework
The .NET framework from Microsoft is not available via
apt on Raspberry Pi. However, you can follow the oicial
instructions from Microsoft to install the .NET framework.
Alternatively, there is a simpliPed third party route to get
the .NET toolchain on to your Raspberry Pi.
WARNING
The installation script is run as root. You should read
it Prst and make sure you understand what it is doing.
If you are at all unsure you should follow the oicial
instructions manually.
$ wget -O - https://raw.githubusercontent.com/pjgpetecodes/dotnet5pi/master/install.sh | sudo bash
After installing the .NET framework you can create your
project:
$ dotnet new console --name buildhat
This creates a default program in the buildhat
subdirectory, and we need to be in that directory in order
to continue:
$ cd buildhat
You will now need to install the following nuget packages:
$ dotnet add package System.Device.Gpio --version 2.1.0
$ dotnet add package Iot.Device.Bindings --version 2.1.0
Running C# Code
You can run the program with the dotnet run
command. Let’s try it now to make sure everything works.
It should print "Hello World!"
$ dotnet run
Hello World!
(When instructed to "run the program" in the instructions
that follow, you will simply rerun dotnet run)
Editing C# Code
In the instructions below, you will be editing the Ple
buildhat/Program.cs, the C# program which was
generated when you ran the above commands.
Any text editor will work to edit C# code, including Geany,
the IDE/Text Editor that comes pre-installed. Visual Studio
Code (often called "VS Code") is also a popular
alternative.
Using the Build HAT from .NET
The Raspberry Pi Built HAT is referred to "Brick" in LEGO®
parlance and you can talk directly to it from .NET using
the Build HAT Serial Protocol.
You can create a brick object as below,
Brick brick = new("/dev/serial0");
but you need to remember to dispose of the brick at the
end of your code.
brick.Dispose();
WARNING
If you do not call brick.Dispose() your program
will not terminate.
If you want to avoid calling brick.Dispose at the end,
then create your brick with the using statement:
using Brick brick = new("/dev/serial0");
In this case, when reaching the end of the program, your
brick will be automatically disposed.
Displaying the information
You can gather the various software versions, the
signature, and the input voltage:
var info = brick.BuildHatInformation;
Console.WriteLine($"version: {info.Version}, firmware date: {info.FirmwareDate}, signature:");
Console.WriteLine($"{BitConverter.ToString(info.Signature)}");
Console.WriteLine($"Vin = {brick.InputVoltage.Volts} V");
NOTE
The input voltage is read only once at boot time and is
not read again afterwards.
Getting sensors and motors details
The functions GetSensorType, GetSensor will allow you
to retrieve any information on connected sensor.
SensorType sensor = brick.GetSensorType((SensorPort)i);
Console.Write($"Port: {i} {(Brick.IsMotor(sensor) ? "Sensor" : "Motor")} type: {sensor} Connected: ");
In this example, you can as well use the IsMotor static
function to check if the connected element is a sensor or
a motor.
if (Brick.IsActiveSensor(sensor))
{
ActiveSensor activeSensor = brick.GetActiveSensor((SensorPort)i);
}
else
{
var passive = (Sensor)brick.GetSensor((SensorPort)i);
Console.WriteLine(passive.IsConnected);
}
ActiveSensor have a collection of advanced properties
and functions allowing to understand every element of
the sensor. It is also possible to call the primitive
functions from the brick from them. This will allow you to
select speciPc modes and do advance scenarios. While
this is possible, motor and sensor classes have been
created to make your life easier.
Events
Most sensors implements events on their special
properties. You can simply subscribe to
PropertyChanged and PropertyUpdated. The changed
one will be Pred when the value is changing while the
updated one when there is a success update to the
property. Depending on the modes used, some properties
may be updated in the background all the time while
some others occasionally.
You may be interested only when a color is changing or
the position of the motor is changing, using it as a
tachometer. In this case, the PropertyChanged is what
you need!
Console.WriteLine("Move motor on Port A to more than position 100 to stop this test.");
brick.WaitForSensorToConnect(SensorPort.PortA);
var active = (ActiveMotor)brick.GetMotor(SensorPort.PortA);
bool continueToRun = true;
active.PropertyChanged += MotorPropertyEvent;
while (continueToRun)
{
Thread.Sleep(50);
}
active.PropertyChanged -= MotorPropertyEvent;
Console.WriteLine($"Current position: {active.Position}, eventing stopped.");
void MotorPropertyEvent(object? sender, PropertyChangedEventArgs e)
{
Console.WriteLine($"Property changed: {e.PropertyName}");
