Hands-On with the Wio Terminal, Seeed Studio’s Arduino, MicroPython, and ArduPy-Compatible Dev Box

Seeed Studio’s Wio Terminal is a compact, self-contained development device built around the Microchip SAMD51 microcontroller, combining a color display, controls, sensors, wireless connectivity options, and Grove expansion in a handheld enclosure. Instead of starting every prototype with a breadboard, screen module, buttons, and sensor wiring, the Wio Terminal gives Arduino, MicroPython, and ArduPy developers a ready-to-use platform for experimenting quickly.

Its appeal comes from the mix of accessibility and flexibility: beginners can load Arduino sketches and interact with hardware immediately, while more advanced users can script in Python-style environments, connect Grove modules, log data, build dashboards, or prototype embedded interfaces. The built-in LCD, five-way switch, programmable buttons, buzzer, light sensor, infrared emitter, accelerometer, and expansion connectors make it feel less like a bare microcontroller board and more like a portable embedded lab.

#	Preview	Product	Price
1		Seeed Studio Wio Terminal ATSAMD51 Core with Realtek RTL8720DN BLE5.0 Dev Board, Wireless...		Buy on Amazon
2		Seeed Studio XIAO SAMD21 &Seeed Studio Wio Termina		Buy on Amazon
3		Seeedstudio Wio Link Environment Kit	$79.99	Buy on Amazon

As an Amazon Associate I earn from qualifying purchases.

This hands-on walkthrough looks at the Wio Terminal as a practical development box, from its hardware layout and setup process to programming workflows, peripheral access, and project ideas. The focus is on what it is like to actually use the device across Arduino, MicroPython, and ArduPy workflows, and where it fits best for learning, prototyping, and small connected projects.

Wio Terminal Hardware Tour and Key Specifications

The Wio Terminal is built like a self-contained development box rather than a bare microcontroller board. Its front face is dominated by a 2.4-inch color LCD, with a five-way joystick and three programmable buttons arranged for direct interaction. That layout makes it practical for projects that need menus, dashboards, simple games, sensor readouts, or field tools without immediately adding an external display, keypad, or enclosure.

#1 Best Overall

Seeed Studio Wio Terminal ATSAMD51 Core with Realtek RTL8720DN BLE5.0 Dev Board, Wireless Microcontroller Python Terminal Device Compatible with Raspberry Pi for Arduino, Micropython, and TinyML.

• 💙【Highly Integrated Design】 The Wio Terminal is equipped with a 2.4'' LCD Screen, onboard IMU(LIS3DHTR), microphone, buzzer, microSD card slot, light sensor, and infrared emitter(IR 940nm), packed multiple functions in a 72 x 57 x 12mm tiny but stylish enclosure.
• 💙【Powerful Processor and Reliable Wireless Connectivity】 Wio Terminal is an ATSAMD51-based microcontroller with wireless connectivity supported by Realtek RTL8720DN. It runs at 120MHz (Boost up to 200MHz) and supports both Bluetooth (BLE4/5.0) and Wi-Fi (2.4G/5G), providing a more powerful IOT capability than ESP32.
• 💙【Compatible with Raspberry Pi and 300+ Grove Modules】 Wio Terminal is equipped with various peripherals, including two multifunctional Grove ports for Grove Ecosystem and 40 Raspberry Pi compatible GPIO pins for more add-ons. By connecting Wio Terminal to Raspberry Pi, you can start programming and collect environmental data directly, with no need for soldering or breadboards. Over 300 Grove modules are available on Seeed and waiting for you to explore!
• 💙【Various Application】 Wio Terminal have various application like: You can easily build your TinyML applications with Edge Impulse; Sense and tag the Real-World data with over 300 Groves created by Seeed; Use 100% open-source Hardware in a pythonic way; Build your program interpreter starting from 90% with an LCD screen and compact enclosure.
• 💙【Rich Software Support】 Lots of software supported by Wio Terminal, such as Arduino, MicroPython, ArduPy, AT Firmware, Visual Studio Code, CircuitPython (coming soon).

Buy on Amazon

At the center of the board is a Microchip ATSAMD51P19 microcontroller based on an Arm Cortex-M4F core running at up to 120 MHz. It provides enough headroom for typical Arduino sketches, graphics rendering, sensor polling, serial communications, and MicroPython or ArduPy experiments. The Wio Terminal also includes 4 MB of external flash memory, which is useful for storing assets such as images, fonts, configuration data, and interpreted-language files.

The display is one of the board’s defining hardware features. With a 320 × 240 resolution, it is sharp enough for status panels, graphs, icons, and compact user interfaces. Since the screen is already integrated, beginners can move from “blink an LED” to more rewarding visual projects quickly, while experienced makers can prototype portable instruments without wiring a separate SPI screen.

Seeed also gives the Wio Terminal a useful set of built-in sensors and peripherals. Depending on firmware support and library choice, projects can access an accelerometer, microphone, buzzer, infrared emitter, light sensor, and microSD card storage. These components make it easy to build devices that react to motion, sound, ambient light, user input, or stored data. The onboard buzzer and buttons are especially handy for quick feedback, alerts, and menu navigation.

Expansion and Connectivity

For external hardware, the Wio Terminal supports Seeed’s Grove ecosystem through onboard Grove connectors, so sensors and actuators can be attached with plug-in cables instead of breadboard wiring. The 40-pin GPIO header follows the Raspberry Pi-style physical layout, giving access to common digital interfaces such as I2C, SPI, UART, PWM, analog input, and general-purpose I/O. This makes the board suitable for both tidy plug-and-play builds and more advanced custom circuits.

• USB-C: used for power, programming, serial communication, and firmware workflows.
• microSD slot: useful for data logging, storing images, saving configuration files, or loading resources.
• Grove ports: simplify connection to sensors, relays, displays, and environmental modules.
• 40-pin header: opens the board to breadboards, HAT-style accessories, and custom expansion boards.

Wireless capability comes from the Realtek RTL8720DN module, which provides Wi-Fi and Bluetooth hardware. In practice, wireless support depends on the firmware, libraries, and programming environment being used, so it is worth checking compatibility before planning a network-heavy project. Still, the presence of onboard wireless hardware gives the Wio Terminal a clear path toward IoT dashboards, remote sensors, MQTT clients, and connected control panels.

Physically, the board feels closer to a small handheld instrument than a lab-only dev kit. The plastic enclosure, screen, buttons, connectors, and power switch are already arranged for portable use. That combination is what makes the Wio Terminal attractive: it compresses a microcontroller, display, controls, storage, sensors, wireless hardware, and expansion options into one compact unit that can be programmed like an Arduino board while still supporting more exploratory workflows such as MicroPython and ArduPy.

Setting Up the Development Environment

Getting the Wio Terminal ready for development is straightforward, but the exact setup depends on whether you plan to use the Arduino IDE, MicroPython, ArduPy, or a mix of all three. The board connects over USB-C and appears as a USB device when powered, so the first step is to use a reliable data-capable USB-C cable rather than a charge-only cable. Once connected, the Wio Terminal can be placed into bootloader mode by quickly sliding the power switch twice, which makes it appear as a removable drive for firmware updates and recovery tasks.

For Arduino-based work, install the latest Arduino IDE or Arduino IDE 2.x, then add Seeed’s board support package through the Boards Manager. In the Arduino preferences, add the Seeed SAMD board package URL, open Boards Manager, search for Seeed SAMD, and install the package. After installation, select the Wio Terminal from the board list and choose the correct serial port. On Windows, you may need to wait for the USB serial driver to finish installing before the port appears; on macOS and Linux, it usually shows up as a standard serial device.

Core setup checklist

• USB connection: Use a USB-C data cable and connect directly to the computer when troubleshooting uploads.
• Bootloader access: Double-slide the power switch to enter bootloader mode for firmware flashing or board recovery.
• Arduino support: Install the Seeed SAMD board package and select the Wio Terminal board profile.
• Library setup: Add Wio Terminal display, sensor, Wi-Fi, and file system libraries as your projects require.
• Serial monitor: Use the serial monitor for debugging sketches, checking sensor output, and confirming board communication.

Library installation is the next practical step. For display projects, the TFT_eSPI library is commonly used with Seeed’s Wio Terminal configuration. For motion sensing, buttons, buzzer control, SD card access, Wi-Fi, Bluetooth, and other peripherals, Seeed provides examples and libraries through its documentation and GitHub repositories. Installing the examples is useful because they confirm that the screen, IMU, buttons, light sensor, and wireless module are working before you start combining features into a larger project.

If you want to experiment with MicroPython or ArduPy, the workflow shifts from compiling sketches to copying firmware and running scripts. In bootloader mode, firmware files can be dragged onto the mounted Wio Terminal drive, after which the board reboots into the selected runtime. A serial terminal or MicroPython-friendly editor can then be used to access the REPL, upload scripts, and test hardware modules interactively. This makes the Wio Terminal especially convenient for quick sensor checks, UI experiments, and classroom demonstrations where immediate feedback is more useful than a full compile-upload cycle.

Before moving on to full projects, run one basic example in each environment you intend to use. A simple screen color test, button readout, accelerometer printout, or Wi-Fi scan quickly verifies that the board package, firmware, serial connection, and libraries are aligned. If uploads fail, re-enter bootloader mode, confirm the selected port, close any serial monitor using the connection, and try a shorter USB cable or a different USB port.

Programming with Arduino IDE

The Arduino IDE is the most direct way to start programming the Wio Terminal, especially if you want quick access to its screen, buttons, buzzer, microSD slot, IMU, light sensor, infrared emitter, and wireless features. Once the Seeed SAMD board package is installed, the board appears as Seeed Wio Terminal under the Arduino board menu. Select the correct port, open a sketch, and the workflow feels much like working with an Arduino Zero-class board, but with far more hardware already integrated into the enclosure.

A good first test is the classic blink sketch, using the built-in LED to confirm that compilation, upload, and USB serial communication are working. The Wio Terminal uses a Microchip ATSAMD51-based platform, so sketches compile for a 32-bit Arm Cortex-M4F microcontroller rather than an 8-bit AVR. That gives you more memory, faster floating-point math, and enough performance for display graphics, sensor sampling, simple signal processing, and responsive user interfaces. If an upload fails, double-pressing the power button-side reset control places the board into bootloader mode, where it usually reappears on a fresh serial port for recovery.

Rank #2

Seeed Studio XIAO SAMD21 &Seeed Studio Wio Termina

• 【Highly Integrated Design】 The Wio Terminal is equipped with a 2.4'' LCD Screen, onboard IMU(LIS3DHTR), microphone, buzzer, microSD card slot, light sensor, and infrared emitter(IR 940nm), packed multiple functions in a 72 x 57 x 12mm tiny but stylish enclosure.
• 【Powerful Processor and Reliable Wireless Connectivity】 Wio Terminal is an ATSAMD51-based microcontroller with wireless connectivity supported by Realtek RTL8720DN. It runs at 120MHz (Boost up to 200MHz) and supports both Bluetooth (BLE4/5.0) and Wi-Fi (2.4G/5G), providing a more powerful IOT capability than ESP32.
• 【Compatible with Raspberry Pi and 300+ Grove Modules】 Wio Terminal is equipped with various peripherals, including two multifunctional Grove ports for Grove Ecosystem and 40 Raspberry Pi compatible GPIO pins for more add-ons. By connecting Wio Terminal to Raspberry Pi, you can start programming and collect environmental data directly, with no need for soldering or breadboards. Over 300 Grove modules are available on Seeed and waiting for you to explore!
• 【Various Application】 Wio Terminal have various application like: You can easily build your TinyML applications with Edge Impulse; Sense and tag the Real-World data with over 300 Groves created by Seeed; Use 100% open-source Hardware in a pythonic way; Build your program interpreter starting from 90% with an LCD screen and compact enclosure.
• 【Rich Software Support】 Lots of software supported by Wio Terminal, such as Arduino, MicroPython, ArduPy, AT Firmware, Visual Studio Code, CircuitPython (coming soon).

Buy on Amazon

For Wio Terminal development, the most commonly used Arduino libraries are Seeed’s LCD library for the 2.4-inch color display, sensor libraries for the onboard accelerometer and light sensor, and connectivity libraries for Wi-Fi and Bluetooth. The display is usually the centerpiece: instead of printing values only to Serial Monitor, you can render text, colored status panels, charts, menus, and icons directly on the device. The three front buttons and five-way switch make it practical to build menu-driven tools without adding external controls.

Typical Arduino workflow

1. Select the board: choose Seeed Wio Terminal from the Arduino IDE board list.
2. Select the port: pick the USB serial port assigned when the Wio Terminal is connected.
3. Install libraries: add Seeed display, sensor, and connectivity libraries from Library Manager or Seeed’s GitHub repositories.
4. Open an example: start with display text, button input, accelerometer readings, or Wi-Fi scanning examples.
5. Upload and monitor: send the sketch to the board, then use Serial Monitor for debug output while the screen handles user-facing information.

One practical starter sketch is a handheld sensor dashboard. The Arduino program reads the light sensor and IMU, draws a colored background on the LCD, prints live numeric readings, and uses the front buttons to switch screens. A second sketch might turn the Wio Terminal into a Wi-Fi scanner, showing nearby SSIDs, signal strength bars, and encryption status on the display. Because the hardware is already mounted in a compact case, these examples feel closer to finished instruments than loose breadboard demos.

The main adjustment for Arduino users is thinking beyond pin toggling. On the Wio Terminal, an Arduino sketch can be a complete small application with input, graphics, storage, and connectivity in the same program. That makes it well suited for prototypes such as portable data loggers, environmental monitors, classroom measurement tools, simple IoT controllers, and hardware test fixtures. Arduino IDE keeps the entry point familiar while letting the Wio Terminal’s built-in peripherals do most of the heavy lifting.

Running MicroPython and ArduPy on the Wio Terminal

Beyond the Arduino IDE, the Wio Terminal is a good fit for Python-style embedded development. Its ATSAMD51 microcontroller, integrated LCD, buttons, buzzer, light sensor, accelerometer, microSD slot, and Grove connectors make it useful as a self-contained test device for scripts that interact with real hardware. MicroPython and ArduPy both let you work at a higher level than C/C++, with quick edit-run cycles and simpler syntax for tasks such as reading sensors, updating the screen, logging data, or sending values over a serial connection.

MicroPython support typically starts by flashing a compatible firmware image to the board, then connecting over USB serial or using a filesystem-aware tool to copy scripts onto the device. The usual workflow is to place the Wio Terminal into bootloader mode, flash the firmware, confirm that a serial REPL is available, and then transfer a main.py file for automatic execution. Once the REPL is running, you can test small snippets interactively: toggle a pin, print accelerometer readings, or verify that the display driver is responding before building a larger application.

MicroPython workflow

• Flash firmware: Install a Wio Terminal-compatible MicroPython build using the bootloader or a vendor-supported flashing method.
• Open the REPL: Connect with a serial terminal or an editor such as Thonny, depending on the firmware and your operating system.
• Copy scripts: Save reusable code as main.py or supporting modules on the board’s filesystem.
• Iterate quickly: Test sensor reads, button inputs, display drawing, and file writes without recompiling a full firmware image.

ArduPy takes a slightly different approach. It blends the Arduino ecosystem with a Python scripting layer, so you can use Python-like code while still leaning on Arduino libraries underneath. This is especially attractive on the Wio Terminal because many examples and drivers in the Seeed ecosystem were built with Arduino compatibility in mind. With ArduPy, you can create firmware that includes selected libraries, then write Python scripts that call into those capabilities. For example, a project can expose LCD drawing, Grove sensor access, or Wi-Fi functions to a script while keeping lower-level driver details hidden.

The practical distinction is that MicroPython feels like a compact Python runtime designed for microcontrollers, while ArduPy feels more like a bridge between Arduino libraries and Python scripting. If you want a broad interactive Python experience and a familiar REPL, MicroPython is the natural place to start. If your project depends on Seeed or Arduino library support and you want to script against those features, ArduPy can be the better match. In both cases, memory matters: the Wio Terminal is capable for a microcontroller board, but large graphics buffers, many imported modules, and frequent file operations can consume RAM quickly.

A simple first test is a dashboard script: read the built-in buttons, show status text on the LCD, and log a timestamped value to the microSD card when a button is pressed. From there, you can extend the same structure into a portable sensor monitor, a Grove module tester, or a small classroom demo that shows input, processing, and output on one device. The Wio Terminal’s built-in screen and controls make these Python-based workflows more satisfying than using a bare microcontroller board, because you can see and operate the program immediately without adding extra hardware.

Using the Built-In Display, Sensors, Buttons, and Connectivity

The Wio Terminal feels more like a tiny self-contained instrument than a bare microcontroller board because so much hardware is already on the front panel. The 2.4-inch color LCD is the most visible part: it gives Arduino, MicroPython, and ArduPy sketches an immediate way to show menus, charts, sensor values, icons, status messages, and simple dashboards without wiring an external screen. In Arduino projects, Seeed’s display libraries build on TFT_eSPI-style drawing calls, so you can print text, draw primitives, push bitmaps, and update regions of the screen quickly enough for interactive interfaces.

The built-in controls make those interfaces usable without a breadboard. The Wio Terminal has a five-way joystick, three user buttons along the top edge, a power/reset arrangement, and a small buzzer for audible feedback. A common pattern is to use the joystick for navigation, the center press for selection, and the top buttons for shortcuts such as back, start/stop logging, or changing display modes. Because the buttons are already placed around the enclosure-friendly board layout, it is easy to prototype menu-driven tools that feel closer to a finished handheld device than a lab experiment.

Built-in inputs and outputs worth using first

• LCD display: Ideal for sensor dashboards, network status pages, oscilloscope-style traces, bitmap UIs, and setup screens.
• Five-way joystick: Useful for menu navigation, cursor movement, game controls, and parameter adjustment.
• Three top buttons: Good for mode switching, triggering measurements, confirming actions, or quick macros.
• Accelerometer: Enables tilt input, motion detection, step-like movement experiments, orientation-aware screens, and simple vibration monitoring.
• Microphone: Supports sound level meters, clap triggers, basic audio sampling, and TinyML-style audio classification experiments.
• Buzzer: Provides alarms, button click feedback, countdown tones, and notification sounds.
• microSD slot: Practical for data logging, configuration files, images, fonts, and offline assets.

Connectivity is another strong part of the board’s appeal. The Wio Terminal includes 2.4 GHz Wi-Fi and Bluetooth through its wireless coprocessor, making it suitable for compact IoT projects that need cloud upload, local web dashboards, MQTT messaging, or phone-to-device interaction. In practice, Wi-Fi examples are often the fastest path to a useful demo: connect to a network, fetch time from an NTP server, call a weather API, publish data to an MQTT broker, or host a small configuration page. Bluetooth projects can be more sensitive to firmware and library support, but the hardware gives you room to explore wireless control and nearby-device communication.

The expansion options help when the built-in peripherals are not enough. The 40-pin Raspberry Pi-compatible header exposes GPIO and common buses, while the Grove connectors make it quick to add Seeed modules such as environmental sensors, relays, GPS, LoRa radios, and displays without jumper-wire clutter. A solid workflow is to use the onboard screen and buttons as the local user interface, log readings to microSD, and attach one or two Grove sensors for the external measurement task. For example, an indoor air monitor can show temperature, humidity, and CO₂ on the LCD, use the joystick to switch between live and history views, beep when thresholds are exceeded, and send periodic readings over Wi-Fi.

Hands-On Project Ideas and Real-World Use Cases

The Wio Terminal works best when treated as a self-contained prototyping box rather than just another microcontroller board. Its color display, five-way switch, buttons, buzzer, accelerometer, light sensor, infrared emitter, microSD slot, Wi-Fi, Bluetooth, and Grove connectors make it practical for projects that would otherwise require a pile of breakout boards. You can sketch a user interface, read sensors, log data, and send results over the network without building much supporting hardware first.

Rank #3

Seeedstudio Wio Link Environment Kit

$79.99

Buy on Amazon

Environmental dashboard and data logger

A strong first project is a portable environmental monitor. Add a Grove temperature and humidity sensor, a barometric pressure sensor, or an air-quality module, then show live readings on the 2.4-inch LCD using large labels, color-coded status bars, and simple trend indicators. The onboard buttons can switch between pages for current values, graphs, and device settings. With a microSD card inserted, the Wio Terminal can also write timestamped CSV files for later analysis in a spreadsheet.

This project maps well to both Arduino and MicroPython. In Arduino, you can combine Seeed’s display libraries with sensor libraries and SD card support for a polished embedded-style interface. In MicroPython or ArduPy, the same idea becomes more scriptable, which is useful when tuning thresholds, changing sampling intervals, or testing different sensor combinations quickly.

Wi-Fi status panel for home or lab

With wireless networking enabled, the Wio Terminal can become a small desktop status panel. It can poll an MQTT broker, call a local HTTP endpoint, or read data from a cloud API and display the result as tiles. Useful examples include showing 3D printer progress, server health, GitHub Actions build status, room occupancy, greenhouse readings, or smart-home sensor values. The enclosure-friendly shape and front-facing display make it easy to place on a bench, shelf, or beside a workstation.

• MQTT monitor: subscribe to topics from Home Assistant, Node-RED, or custom ESP32 sensor nodes.
• Build indicator: show passing, failing, or running states from a CI pipeline.
• Network tool: display Wi-Fi signal strength, ping latency, or service availability.
• Smart-home remote: use the buttons to trigger lighting scenes or automation events.

Interactive controller and handheld interface

The built-in controls make the Wio Terminal a good handheld interface for robots, test rigs, and connected devices. The five-way switch can handle navigation or directional movement, while the three top buttons can act as mode selectors, triggers, or emergency stops. The accelerometer adds gesture input, tilt control, or shake detection. For a small rover, for example, the display can show battery voltage, motor state, distance sensor readings, and connection status while the buttons send movement commands.

Field tester for Grove modules and prototypes

Another practical use is a reusable tester for Grove sensors and actuators. Instead of writing a new sketch from scratch every time, build a menu-driven firmware that lets you choose a module type, read values, and confirm whether the device is working. This is useful in classrooms, workshops, and hardware labs where many modules are shared between users. A microSD card can store test logs, calibration values, or configuration files, and the display can provide wiring prompts for each module.

These examples show the Wio Terminal’s main advantage: it shortens the path from idea to working prototype. You can start with the built-in screen and controls, add one or two Grove modules, and still have a compact device that feels finished enough to use, demo, or hand to someone else for testing.

Frequently Asked Questions

Can the Wio Terminal be programmed with both Arduino and MicroPython?

Yes. The Wio Terminal works well with the Arduino IDE for C/C++ projects, and it can also run MicroPython or ArduPy firmware for Python-style development. In practice, you usually flash the firmware or upload code for the environment you want to use, so switching workflows may require re-flashing or changing tools.

What hardware is built into the Wio Terminal?

The Wio Terminal includes a 2.4-inch color LCD, five-way switch, three user buttons, buzzer, light sensor, infrared emitter, accelerometer, microSD slot, USB-C, and Grove connectors. It is based on a Microchip ATSAMD51 microcontroller and also includes wireless hardware through an RTL8720DN module. This makes it useful as a self-contained test device without needing a breadboard for every experiment.

Do I need extra parts to build useful projects with the Wio Terminal?

Not for basic projects. You can build menu interfaces, sensor dashboards, simple games, data loggers, USB tools, and display demos using only the built-in screen, buttons, accelerometer, light sensor, and microSD slot. For external sensors or actuators, the Grove connectors make it easy to add modules without much wiring.

Is the Wio Terminal a good board for beginners?

It is beginner-friendly if you are comfortable installing board packages, libraries, or firmware tools. The built-in screen and controls make projects feel more complete than a bare microcontroller board, and Arduino support gives new users a familiar starting point. MicroPython and ArduPy are also useful for faster experimentation, especially for readers who prefer Python syntax.

What kinds of real-world projects is the Wio Terminal best suited for?

The Wio Terminal is a strong fit for portable dashboards, sensor monitors, handheld controllers, data loggers, small IoT interfaces, classroom demos, and rapid prototyping. Its display, buttons, wireless capability, and Grove expansion ports reduce the amount of external hardware needed. It is less suited for projects that need high processing power, large memory, or long battery life without additional power management.

Bottom Line

The Wio Terminal is a compact, capable dev box that makes it easy to move between Arduino, MicroPython, and ArduPy without constantly rebuilding your hardware setup. With its built-in screen, buttons, sensors, wireless-ready expansion options, and Grove ecosystem support, it gives beginners and experienced makers a fast path from idea to working prototype.

If you want a portable board for learning, testing sensors, building dashboards, or creating connected embedded projects, the Wio Terminal is still a practical choice. Start with the Arduino workflow if you want the broadest library support, then explore MicroPython or ArduPy when you need faster scripting and more interactive experimentation.

Quick Recap

Bestseller No. 1

Seeed Studio Wio Terminal ATSAMD51 Core with Realtek RTL8720DN BLE5.0 Dev Board, Wireless Microcontroller Python Terminal Device Compatible with Raspberry Pi for Arduino, Micropython, and TinyML.

Bestseller No. 2

Seeed Studio XIAO SAMD21 &Seeed Studio Wio Termina

Bestseller No. 3

Seeedstudio Wio Link Environment Kit

$79.99

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.