MicroPython-Powered Robotics for All: Hands-on with the Arduino Alvik

If you're trying to nurture a love of robotics in a new generation, it helps to have an accessible platform for the purpose — and that's exactly what Arduino delivers in the Alvik, a boxy two-wheeled robot platform with a grinning face at its front.

Alvik is more than the sum of its parts, though. As with the company's recently-launched Arduino PLC Starter Kit, the Alvik comes complete with pre-prepared courseware that walks the user — or the user's students — through a series of MicroPython-based programming projects.

Read on to see if Alvik delivers education excellence or gets caught up in its own gears.

The hardware

• Microcontroller: Arduino Nano ESP32 (ESP32-S3 at 240MHz, 512kB SRAM, 384kB flash, 8MB external PSRAM, 16MB external flash)
• Coprocessor: STMicroelectronics STM32 (Arm Cortex-M4)
• Chassis: Two-wheel with bearing
• Motors: 2× 6V precision geared motors with encoders
• Sensors: Six-axis IMU, RGB color sensor, 7× capacitive touch on-board; Time of Flight (ToF) distance sensor and 3× line-follower array in swappable sensor board
• Display: 2× RGB LEDs
• Connectivity: Wi-Fi, Bluetooth Low Energy (BLE)
• Expansion: 4× LEGO Technic mount points, 8× M3 screw points, 2× servo motor header, 2× I2C Grove, 2× I2C Qwiic
• Power: 18650 lithium-ion battery (pre-installed), USB Type-C
• Languages: MicroPython, Arduino (block-based visual programming planned, but not available at the time of writing)
• Size: 96×96×37mm (around 3.8×3.8×1.5")
• Weight: 200g (around 7oz)
• Price: $140 (including Alvik, battery, USB Type-C to Type-C cable, courseware access)

Alvik isn't a kit: the compact robot, measuring a little under four inches on a side, comes ready-to-run straight out of the box. And we mean "ready to run:" the Arduino Nano ESP32, which powers the robot comes pre-flashed with a MicroPython firmware loaded with three example programs, each demonstrating a different way to control the robot's motion.

The top of the robot plays host to seven capacitive touch points: a five-way joystick, a tick, and a cross. To either side of these are a pair of RGB LEDs, fitted to the rear of the board and shining up through holes in the PCB. Power the Alvik on through a small switch on the rear and you can use these controls to pick which of the three pre-loaded MicroPython programs you want to run — more on that later.

Above these controls is what you may think is the heart of the robot, the Arduino Nano ESP32 itself. Built around a u-blox NORA-W106 module, the compact microcontroller board features an Espressif ESP32-S3 chip with a dual-core Tensilica Xtensa LX7 processor running at 240MHz along with 8MB of pseudo-static RAM (PSRAM) and 16MB of flash memory, plus on-board Wi-Fi and Bluetooth Low Energy (BLE) radios. The Arduino Nano ESP32 isn't soldered into place, but connected to female headers on the board's reverse side — if you want to use it in a different project, it's easily popped out.

Less visible is the true heart of the Alvik: an STMicroelectronics STM32 microcontroller, soldered in place on the PCB's reverse side. It's this that's actually responsible for driving the Alvik's hardware; the Arduino Nano ESP32 simply serves as a platform for user applications, communicating with the STM32 over a pre-configured application programming interface (API) to make the robot do its tricks.

Elsewhere in the Alvik platform is its sensor package: a six-axis inertial measurement unit (IMU) with accelerometer and gyroscope and an RGB color sensor that shines down though a cut-out in the chassis — doubling as a way to access boot-select and reset switches. Those aren't the only sensors on-board, though: Alvik's cheery "face" is actually a swappable sensor module, which features a time-of-flight (ToF) distance sensor good out to around 350cm (around 11.5 feet) and a three-element line-following sensor array. This can be disconnected from the main Alvik robot and replaced with an alternative sensor package, though at the time of writing no alternative "faces" were available.

The two-wheeled chassis, with a ball bearing at the rear for stability, is driven by a pair of 6V precision motors with integrated encoders, rated at 96 revolutions per minute and 70mA current unloaded. In testing, the motors delivered on the promised precision — so long as you make sure the plastic wheels, with rubber tread, are properly fitted and flush against the robot's body.

Out of the box

As it's fully-assembled, and there's even charge in the 18650 battery hidden under a sensibly screw-protected cover, it's tempting to simply flip Alvik's switch and start experimenting — and, to its credit, Arduino expects you to do exactly that. Turn Alvik on and it won't start racing around the room on its own; it'll just flash its RGB LEDs and await further instruction.

Tapping the capacitive buttons scrolls through the three pre-loaded MicroPython programs, which — with no on-board display — are identified by color on the RGB LEDs. The red program is "Touch Mode," in which you can program the Alvik using the capacitive touch points on its rear, like a compact Big Trak: three taps forward, two taps right, and three taps back before hitting the tick will send Alvik away and back again.

The green program is "Hand Follower," a simple demonstration of the time-of-flight distance sensor on the robot's "face": place your hand in front and Alvik will move to keep a 10cm (around 4") distance from it. Finally, the blue program is a "Line Follower" that tracks a black line along a white surface. A couple of swipes with a thick marker on paper is good enough for this, though even better results are available using a strip of black electrical tape.

The source code for all three programs is available in Alvik's flash memory for investigation or modification, and can easily be accessed using the Arduino Lab for MicroPython integrated development environment (IDE). This is designed as the primary method for programming Alvik, and is the software around which the bundled courseware is based — yet despite Arduino launching a commercial product built around it, the Arduino Lab for MicroPython is still described as "experimental pre-release software."

That doesn't mean it doesn't work: in our testing, the Arduino Lab for MicroPython, installed on a 64-bit Linux desktop, was entirely responsive — even if it didn't always match the screenshots in the documentation.

Courseware

The meat of that documentation is the bundled courseware, which Arduino bills as being aligned to common curricula and ideal for teachers looking for a quick-start way to introduce students as young as eight to robotics and embedded development. It starts with a simple introductory walkthrough, covering software setup, hardware connectivity, blinking the LEDs, and moving the motors.

Once you're through that, which Arduino estimates will take around two hours, it's on to more advanced topics: precision movement control, automated angle-dependent speed control, color sensing, line following, and a hand-following project based around the ToF distance sensor — a two-hour project, Arduino says, but an odd choice given that a program for doing exactly that comes pre-loaded in Alvik's memory.

The course finishes with two four-hour "extended projects," though despite their name the projects don't require any additional hardware other than the Alvik itself — except things you're likely to have lying around already, like books or blocks to act as obstacles. All told, Arduino estimates there's a total of 26 hours' worth of material included in the courseware — and they're all available free of charge, though you'll need to register for a free account on the Arduino website to access them all.

The early, detailed-filled lessons, though, soon give way to more terse material. The two "extended projects" — an escape room and a smart traffic system — are the shortest of all, and are really more project outlines than fleshed out lessons. No code is included, no solutions given, and no mark scheme offered, meaning that anyone using them in a classroom environment will have a chunk of homework of their own before letting their students loose.

Although the Alvik user manual — only available digitally, with no printed documentation in the box — promises "diverse learning paths through different programming languages including MicroPython, Arduino C, and block-based coding," at the time of writing the courseware was only available for MicroPython; those looking to use Arduino C need to flash a new firmware from GitHub, with sparse documentation, and anyone hoping for a block-based visual coding environment will, at the time of writing, be disappointed to find nothing available at all.

There's another big omission in the courseware, too: coverage of the robot's wireless connectivity. A big selling point of the Arduino Nano ESP32 is its built-in Wi-Fi and Bluetooth radios, but they're entirely ignored in the lessons. Given that remote control of a robot is a common use-case for such connectivity, it's a strange exclusion.

Expansion

While the educational material concentrates only on what you can achieve with the Alvik robot on its own — a laudable approach, as the last thing you want is for a teacher to figure out their hardware budget would only get them halfway through the course — there's plenty of scope for expansion both physically and electronically.

Physically, the Alvik's plastic body has four LEGO Technic-compatible connectors, two to each side. Above and below each are nuts for M3 screws, meaning it's easy to attach additional hardware to the robot. For electronics, there are two each of Qwiic- and Grove-format connectors providing access to an I2C bus for solderless connectivity to external hardware; a pin header between the two offers control for up to two servo motors.

All told, the Alvik provides a tempting platform for experimentation — and the choice of the Arduino Nano ESP32, rather than a less powerful microcontroller board, means it can even serve as a starting point for on-device tiny machine learning (tinyML) and artificial intelligence (AI) projects, thanks to vector acceleration instructions included in the CPU's design.

For this, though, you're going to be on your own. The courseware concentrates exclusively on using MicroPython to control an unexpanded Alvik, though the user manual provides brief sample code demonstrating servo control, I2C bus scanning ,and interacting with an I2C OLED display connected to one of the two Qwiic ports.

Conclusion

There's a lot to love about the Alvik. It's far from the cheapest two-wheeled robot platform out there, but the hardware is solid and extremely well thought out. The only real omission: a lack of cliff-edge sensors, which would prevent the robot from careening off a table during classroom experimentation. As it is, Arduino has taken the undeniably cheaper route of simply including warnings about operating the robot near sudden drops.

The courseware is well-written, and doesn't require the user to pick up any additional hardware — but in an issue of over-promising and under-delivering, which is echoed by the company's PLC Starter Kit courseware, the manual opens with the assertion that you'll be learning to program the robot in MicroPython, the Arduino IDE, and an unspecified block-based visual language, then only delivers one-third of those languages.

For those simply working through the courseware, $140 may seem like a tall order; for those looking to use the courseware as a jumping-off platform for self-directed experimentation, though, Alvik delivers a robust and solid platform with room for student-friendly expansion. Get the Wi-Fi and BLE radios up and running, and you've got a robot capable of everything from basic autonomous operation to wide-area remote control.

The Arduino Alvik is now available to order on the Arduino Store.