Micro:bit V1 vs. V2 in 2026: Is the Older Board Still Worth It for Classroom Data Logging?

The original Micro:bit V1 (left) remains a powerful tool for teaching data logging and IoT fundamentals, even alongside the feature-rich V2 (right) produced using ChatGPT

Introduction 

Before you drop those original Micro:bit V1 boards into the recycling bin, ask yourself this: what if the board without all the bells and whistles is actually the better teaching tool? As we move further into 2026, many educators find their storage bins filled with V1 boards — the ones without the notched gold edge connectors. With the V2 boasting a built-in microphone, speaker, touch-sensitive logo, and a faster processor, it's tempting to assume the V1 is obsolete. But is it really? The answer, perhaps surprisingly, depends entirely on what you are trying to teach — and the V1 makes a far stronger case for itself than most people expect.

The Technical Trade-off 

To be fair to both boards, the V2 is the clear winner for AI, audio, and machine learning projects — and if your budget allows, it is the better long-term investment for a modern curriculum. The extra hardware opens up genuinely exciting new lesson possibilities that simply aren't possible on the V1.

However, when it comes to teaching the fundamentals of Data Science and Physical Computing, the V1 has a surprising advantage: its limitations. Because it has less 'built-in magic,' students are forced to engage with the mechanics of how hardware and software actually talk to each other. Without the V2's internal logging memory, students must learn to use Serial Communication to stream data via USB to a computer, or Radio Transmission to send data wirelessly from a 'Remote Probe' to a 'Base Station.' These are genuine, real-world Internet of Things (IoT) skills — the kind used by engineers building environmental monitors, weather stations, and smart building sensors every day.

There is a strong pedagogical argument here: when a tool does everything for you, you learn to use the tool. When a tool makes you work for the result, you learn to understand the process. The V1 sits firmly in the second camp, and in a classroom context, that is often exactly where you want to be.

It is also worth noting a practical reality: many schools simply cannot afford to replace entire sets of V1 boards overnight. Rather than seeing this as a problem, it is worth reframing it as an opportunity. A classroom with a mixed set of V1 and V2 boards can actually run richer, more differentiated lessons — using the V2 for AI and audio exploration while deploying the V1 as dedicated data-logging sensors.

Project Idea: Magnetic Field Logging 

One of the most effective and accessible V1 classroom activities is using the board's built-in magnetometer to detect and visualise invisible magnetic forces. It requires no additional hardware, no extra cost, and produces genuinely interesting results that link naturally to physics, mathematics, and data analysis.

By coding a simple loop using 'Serial Write Value' commands, students can stream live magnetic field readings directly to a computer and export the results as a CSV file — turning what looks like an 'old' piece of kit into a high-precision scientific instrument. Rolling a magnet towards the sensor, or letting it rock back and forth, produces clear oscillating wave patterns in the data that students can then analyse in Excel or Google Sheets. It is a simple setup with a surprisingly rich learning payoff.

For a full walkthrough, the following posts on this blog cover exactly this, with code examples and real results:

• DIY Data Science with Microbits — a complete guide to data logging methods with the V1, including both local USB logging and remote radio-based logging
• Detecting and Logging Magnetism with a Microbit — a step-by-step experiment with real data traces and both MakeCode blocks and MicroPython versions

The Verdict 

Don't bin your V1s — but do be honest about what they are best suited for. They are not the right tool for every lesson, and if you are teaching AI, speech recognition, or audio projects, the V2 is the board you want in students' hands. But as dedicated environmental sensors, data-logging probes, or radio-linked remote monitoring stations, the V1 remains durable, energy-efficient, and fully compatible with both the modern MakeCode editor and the MicroPython editor. Sometimes the older, simpler tool teaches the deeper lesson — and in 2026, the V1 still has plenty left to give.

Over to You 

Still using V1s in your classroom, club, or at home? Fantastic. Try the magnetic field logging experiment linked above and share how it goes in the comments below. If you have found other creative uses for your older boards — whether in a school lab, a maker space, or on the kitchen table — drop them in the comments too. And if this post has convinced you to dust off a forgotten box of V1s, the best place to start is the DIY Data Science guide — everything you need is already there and waiting.

All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

DIY Data Science with microbits

DIY Data Science: A Complete Guide to Data Logging with the Micro:bit V1

Whether you are a STEM teacher looking for a classroom lab solution, a parent seeking a weekend project, or a maker building an environmental monitor, the Micro:bit V1 is a hidden gem for data logging.

While the newer V2 has built-in logging memory, the V1 is incredibly capable when paired with a computer. By using the Serial (USB) Connection and Radio Communication, you can turn these pocket-sized boards into useful sensors.

The Equipment List

To get started, you will need:

• For Local Logging:

  • 1x Micro:bit V1.

  • 1x Micro-USB cable (high quality, data-capable).

  • A computer with a Chrome-based browser (to use the WebUSB feature in MakeCode).

• For Remote Logging:

  • 2x Micro:bit V1s.

  • 1x Battery pack (2xAAA) for the "Remote" Micro:bit.

  • 1x Micro-USB cable for the "Receiver" Micro:bit.

• Optional (For Experiments):

  • A strong magnet (to test the Compass/Magnetometer (see later in this post).

  • A flashlight (to test Light Level).

  • An ice pack or hair dryer (to test the Temperature sensor).

Method 1: The "Direct Link" (Local Logging)

The simplest way to log data is to keep your Micro:bit tethered to your computer. The Micro:bit senses the environment and "talks" back to the computer through the USB cable using Serial Communication.

The Setup:

1. Code it: In MakeCode, go to Advanced > Serial. Use the serial write value "label" = [sensor] block.

2. Flash it: Connect your Micro:bit via USB and download the code.

3. View it: A purple "Show Data Device" button will appear under the simulator. Click it to see a live scrolling graph of your data!

4. Save it: Use the "Export" button in the top right to download your data as a CSV file, which can be opened in Excel or Google Sheets for analysis.

Method 2: The "Messenger" (Remote Logging)

What if you want to measure something 20 feet away from your laptop? We can use two Micro:bits: a Sender and a Receiver.

1. The Sender (The Remote "Probe")

This Micro:bit is powered by a battery pack and placed wherever the "action" is.

• The Logic: It reads a sensor and broadcasts it over the radio.

• Key Blocks: radio set group [number] and radio send value "name" = [value].

2. The Receiver (The Data Bridge)

This Micro:bit stays plugged into your computer via USB. It acts as a translator, listening for radio signals and passing them to the PC.

• The Logic: "When I hear a radio message, write that value to the Serial (USB) port."

• Key Blocks: on radio received name value → serial write value [name] = [value].

Project Spotlight: Detecting and Logging Magnetism

One of the most exciting uses for this setup is exploring invisible forces. By using the built-in magnetometer (compass sensor), you can track the strength of magnetic fields as a magnet moves closer or further away.

For a specific step-by-step on setting up this experiment, check out our deep dive: Detecting and Logging Magnetism with the Micro:bit V1.

Teacher & Parent Pro-Tip: The "CSV" Advantage

The real magic happens when students export their data. Instead of just looking at a screen, they can:

• Calculate the Average, Min, and Max in Excel.

• Create charts for a science event or just for interest.

Conclusion

The Micro:bit V1 may be the "older" model, but for data logging, it remains a powerhouse. By teaching kids how to move data from a sensor to a radio, then to a cable, and finally into a spreadsheet, you are teaching them the fundamentals of the Internet of Things (IoT) and data capture.

For more detailed technical steps and code snippets, visit the original guides:

• Local V1 Datalogging Guide

• Remote V1 Datalogging Guide

 

All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

Detecting and logging magnetism with a microbit

Producing a data logger using the microbit to detect and log changes in the magnetic field.

Traces

The micro:bit includes a built-in compass that can also be used as a magnetic field detector. With a small amount of code, we can use this sensor to measure changes in the magnetic field and log the data to a computer.

If you are new to this idea, a useful introduction is the video from Mr Morrison below, which explains the basic concept.

The video demonstrates how the micro:bit can detect magnetic fields and display the readings on the device itself. Let’s extend that idea by turning the micro:bit into a data logger that continuously records magnetic field changes.

Coding and Sending data to a Computer

Instead of displaying the magnetic readings directly on the micro:bit’s LEDs, we can send the data through the USB cable to a computer.

The MakeCode editor already provides blocks that allow data to be sent using the serial connection. By placing the magnetic measurement inside a command that continuously sends serial data, we can stream the readings to the computer.

In the example code, two values are transmitted:

• X-axis magnetic field

• Y-axis magnetic field

These correspond to two directions in which the magnetic field can change. Each measurement is sent repeatedly through the USB cable so the computer can record it.

From a coding perspective, this modification is very simple: instead of showing the value on the device, we send it through the serial interface.

Code needed

After downloading the program to the micro:bit, keep the USB cable connected, as this is how the data is transmitted.

Once the program starts running, the MakeCode interface should display a “Show Data Device” button similar to the one shown below.

On the Computer ready for data logging

Clicking this button opens a data viewer that shows the incoming magnetic readings in real time.

Data logging in action

Example: rocking the magnets

The graph above shows data recorded when a small set of circular magnets was rolled towards the micro:bit and then allowed to rock back and forth.

The rocking motion produces a clear oscillating pattern in both the X and Y magnetic field graphs. As the magnets move, the magnetic field detected by the sensor changes direction and strength, producing the wave-like traces you can see.

It’s a simple experiment, but it demonstrates how the micro:bit can be used as a low-cost scientific data logger for investigating magnetic fields and motion.

Doing it in python!

Using the same makecode editor (the same editor as above for the blocks) click on the Python tab after code has been produced and it should now change to:

def on_forever():

    serial.write_value("x", input.magnetic_force(Dimension.X))

    serial.write_value("y", input.magnetic_force(Dimension.Y))

basic.forever(on_forever)

After it is downloaded; running it is exactly the same as running the blocks version earlier - here is an example of it in action

Running using Python

Have fun - I am :-)

All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

Remote Data Logging with V1 Microbit

Remote Data Logging with Two Micro:bits

In a previous post, we used a single micro:bit to log sensor data. That worked well, but it came with a significant limitation: the micro:bit had to stay plugged into the computer the whole time. In many real situations, you want to place a sensor somewhere away from your computer — across a room, outside a window, or just somewhere more useful.

The solution is to split the job between two devices: one micro:bit collects and transmits sensor data wirelessly, while the other receives it and passes it to your computer for logging. This is actually very close to how remote monitoring systems work in the real world.

---

The Plan

We'll build on the previous data-logging project and turn it into a simple wireless monitoring system. 

Tip: To avoid confusion, program each micro:bit separately. Only plug one in at a time, and use a separate MakeCode window for each.

---

Micro:bit 1 — The Transmitter

This micro:bit handles the sensing. It reads the light level and temperature, then broadcasts those values wirelessly using the micro:bit's built-in radio. You can read more about how the radio works here.

The key idea is that both micro:bits are set to the same radio group — just a shared number that lets them communicate with each other while ignoring other devices.

Once programmed, this micro:bit doesn't need to stay connected to the computer. Attach a battery pack and you can move it wherever you want to take measurements. That's what makes it remote.

 

 

Micro:bit 2 — The Receiver

This one stays plugged into your computer. It listens for incoming radio signals from the transmitter and, when it picks one up, stores the received values in variables. It then writes those values to the MakeCode data viewer, exactly as the single-micro:bit version did.

To make this work, it needs to:

• Use the same radio group number as the transmitter
• Identify which value has been received (light or temperature) based on the label sent with each reading
• Log the value to the serial output for the data viewer to display

.

Figure 2 Reciever

 

 

Seeing It in Action

Once both micro:bits are running, open the Show Data panel in MakeCode on the receiver's window. You should see graphs updating in real time, just like before.

Temperature changes slowly, so don't be surprised if that line looks fairly flat at first — try holding the transmitter in your hand to warm it up gradually. Light is easier to experiment with: point the transmitter's LED panel toward a bright screen or lamp and you'll see the values respond immediately.

To save your data as a CSV file and open it in a spreadsheet later, use the blue download icon in the data viewer — same as before.

figure 3 Data logging remotely

 

Ideas to Take It Further

• Add a visual indicator on the transmitter. When it's running without the computer, there's no obvious sign it's doing anything. Could you add something to the display to show it's actively sending data?
• Experiment with sampling rate. Right now the transmitter sends data as fast as it can. Try replacing the forever loop with one that sends data at set intervals — like once per second or every five seconds. This mirrors what we did in the single micro:bit version and can make your graphs much easier to read.

All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

Microbit V1 datalogging

Often we need applications that allow collection of data over time, for example temperature or light levels through the day. Allowing us potentially analyse the data for trends. The microbit is a fantastic tool, with some of these sensors already in place (e.g. light and temperature) or can be added to with extra sensors from add-on boards (such as Kitronik Air Quality and Environmental Board for micro:bit https://shop.pimoroni.com/products/kitronik-air-quality-and-environmental-board-for-micro-bit?variant=39475687227475 )

 

Datalogging with a V2 microbit is relatively easy all the details are available here: https://microbit.org/get-started/user-guide/data-logging/ to get started.

 

But what about the older V1 can it do it?

 

The answer is yes but it is a little more work and is generally a little more limited but still very worth while. In this post we are going to look at doing this.

 

In Figure 1 starting the process off in MakeCode (https://makecode.microbit.org/#editor) is shown below. Basic mechanism every 1sec

• -            The light level is write from the microbit to the computer (via the USB) a value at a time – serially
• -            Same thing will be done for temperature

That is it to start with.

Figure 1

Figure 2 shows where various elements are in menu. To get the Serial ones you will need to open up the Advanced menu and then Serial menu options (see figure 3)

Figure 2

 

Figure 3

Figure 4

Once everything is set up,  under the similar microbit (Figure 4) you will see another button “Show data Simulator” We can play with the microbit simulator to simulate light and temperature levels; click on new data simulation button and graphs starts rolling across the screen – drag the temperature and light levels on the microbit simulator and you see the graphs change – it is logging the simulate data – it works!

Now for the fun bit.

Click on Download we need to pair the computer and microbit. Figures 5 to 8 show the steps.

Figure 5

Figure 6

Figure 7

Figure 8

We can now take values from the real device. A new button should have appeared along with the “Show data Simulator” button; “Show data Device” Click on this button and instead of simulated data we get data from the  microbit (see figure 9)

Figure 9

 

So in figure 9, the top graph is light level the bottom is temperature taken from the room. Play with covering the sensor the LED grid and light levels change.

 

Collecting data is great, but we are taking it one step further logging the data over time and then sharing it To do this click on the blue download button above the graphs to save the logged data as a CSV file. Once it is in CSV format it is yours to play with in other tools such as spreadsheets.

 

 

Activity

-            how can this be more meaningful?

-            How do we do this with so a microbit can see data – some more remote monitoring (see https://microbit.org/projects/make-it-code-it/makecode-wireless-data-logger/ )

-            How could you do this in Python

Related post https://robotsandphysicalcomputing.blogspot.com/2024/08/remote-data-logging-with-v1-mircobit.html

All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon