Skip navigation
> RoadTest Reviews

Grove Inventor Kit + BBC micro:bit - Review

Scoring

Product Performed to Expectations: 10
Specifications were sufficient to design with: 9
Demo Software was of good quality: 10
Product was easy to use: 10
Support materials were available: 9
The price to performance ratio was good: 10
TotalScore: 58 / 60
  • RoadTest: Grove Inventor Kit + BBC micro:bit
  • Buy Now
  • Evaluation Type: Development Boards & Tools
  • Was everything in the box required?: Yes
  • Comparable Products/Other parts you considered: Two other products come to mind: the "mi:node Kit for microbit" from element14 (costing around £47) and the "Kitronik Inventor's Kit for micro:bit" (costing around £25). The mi:node Kit is very similar to the Grove Kit but has a slightly different range of components (also with Grove-style connectors). The Kitronik Kit is more "barebones" and uses a breadboard with discrete components and, as such, is aimed at a slightly different audience.
  • What were the biggest problems encountered?: Lack of documentation (and mounting points) for the Grove Shield for micro:bit itself.

  • Detailed Review:

    Introduction

    Grove Kit in box

    About me

    I am a self-employed IT Consultant based in London, UK. In my spare time I am a STEM Ambassador and CREST Assessor and all-round electronics enthusiast. I have a BSc degree in Electronics and Physics.

     

    RoadTest objectives

    My main objectives for this RoadTest are:

    1. To explore the Grove Inventor’s Kit to understand what it is, how it works and what it can be used for.
    2. To assess how well-suited it would be for classroom use, in particular for teaching physical computing.
    3. To investigate how the use of the Inventor’s Kit can be extended with additional Grove/non-Grove components, either for classroom work or for code clubs.

     

    What is the Grove Inventor’s Kit?

    The Grove Inventor’s Kit is a set of components that can be used with the BBC micro:bit, together with a small booklet showing how they can be used. The Kit does not come with a micro:bit (although one was kindly provided by element14 for this review). The Kit is based around the Grove system from Seeed Studios.

     

    What is the BBC micro:bit?

    The BBC micro:bit is a small microcontroller board that was developed in 2015 initially for the UK education sector, to help make coding more accessible for young people. In 2018, a micro:bit was given to every year 7 pupil in the UK, which was a controversial decision as schools had not had sufficient time to create a curriculum around the new device. By giving the micro:bits to the pupils rather than the schools, many schools were left without any micro:bits and initial take-up by the education sector was slow. Since 2016, several firms have brought out accessories such as edge connectors, motor drivers and cases, to increase the range of uses for the micro:bit. In parallel with this, hobbyists and teachers have developed a great deal of educational material to support the micro:bit and it is starting to be used more extensively as part of the UK Computing curriculum and by code clubs.

     

    What is the Grove System?

    Grove is a modular, standardised connector prototyping system. By using pre-wired connectors and sockets, it ensures secure connections and removes the uncertainty of the “which pin goes where” that you get when using separate jumper wires. Seeed Studios provide excellent documentation for the Grove system on this “Wiki”. The Grove system consists of a huge range of sensors, actuators (e.g. motors), displays and communication devices that connect (normally via a “Shield”) to microcontroller boards such as Arduino, Beaglebone and Raspberry Pi.

     

    Unboxing

    As can be seen from the photos below, the Kit consists of a number of components and a booklet, packed into a small cardboard box.

    Grove Shield for micro:bit
    Grove - Rotary Angle Sensor (potentiometer)
    Grove – Speaker
    Grove - Ultrasonic Ranger
    Grove - Light Sensor v1.2
    Grove - WS2812 Waterproof LED Strip - 30 LEDs 1 meter
    Grove – Gesture sensor
    Grove - 4-Digit 7-Segment Display
    Grove - Red LED
    Micro USB Cable - 48cm
    12 Projects Manual
    Alligator/crocodile cable x10
    Grove Cable x7

    Opening the boxGrove KIt contents laid out on table

    The components

    The Grove Shield for micro:bit

    A Grove Shield (otherwise known as a Grove Expansion Board) is simply a board that provides a number of different Grove-style connectors, into which you plug a microcontroller board. In this case, the Grove Shield is for the BBC micro:bit and it provides four standard Grove connectors, one Grove “zero” connector and additional crocodile/alligator-style (or 4mm banana plug) connections for 3.3v, Gnd and micro:bit ports P0, P1, P2, P8, P12 and P13.

     

    One of the four Grove-style connectors is for I2C and the other three are P0/P14, P1/P15 and P2/P16. This might seem confusing at first, so I shall explain! The standard Grove connector has four pins – VCC, Gnd plus two signal pins. Most (non-I2C) analogue Grove sensors only require one signal pin which, by convention, is pin 1 (yellow wire). This connects to the first micro:bit port shown on the label (i.e. P0 not P14). Similarly, with digital input and output devices. However, some Grove components (such as the 4 x 7-segment display provided as part of the Inventor’s Kit) have two signal lines. In these cases, both ports need to be configured in whatever software you are using.

     

    It is worth mentioning that non-Grove components can be used with the Inventor’s Kit, either by using the crocodile cables/connections supplied or by using separately-purchased Grove cables. A range of Grove cables is available from suppliers. In my testing, I used one such cable to connect a non-Grove LCD display to the micro:bit Shield. Other cables are available that allow you to connect two I2C devices to the one I2C port on the micro:bit Shield, or to connect two non-Grove servos to one Grove connector.

     

    The “Grove Zero” system is a new and different Grove system (somewhat similar to LittleBits), where the devices are snapped together using magnetic edge connectors. It appears to be aimed at a slightly younger audience than the traditional Grove system. No Grove Zero components were provided with the Grove Inventor’s Kit, so this functionality was not tested but it is useful to know that the Grove micro:bit Shield is compatible with Grove Zero components.

     

    Note: the supplied Kit included the first version of the micro:bit Shield. This has recently been superseded by v2.0. The main difference between the two is that the surface mount components have been moved from the back of the board to the front, to reduce the risk of damage when the board is resting on a table or other surface.

     

    Power supplies

    The Grove micro:bit Shield can either be powered by an inserted micro:bit (powered, in turn, by a battery or USB power supply) or through its own micro USB power connector (or both). The USB connector on the Shield provides a regulated 3.3v supply, capable of supplying more power to the connected devices than can be powered by the micro:bit itself. The supplied manual mentions that you should power the Shield through its own USB port if you are using several components at the same time. My own experience is that components such as the Ultrasonic Ranger, the Waterproof LED Strip and the 4-Digit 7-Segment Display should always be powered in this way (even if used singly) as they can draw more current than the micro:bit’s pins can supply.

     

    The Waterproof LED Strip contains 30 “NeoPixels”. The official documentation for the micro:bit cautions against powering more than eight NeoPixels from the micro:bit’s own supply. You can power more than eight, provided they are not on full brightness and not all switched on at the same time, but I think the manual should mention this.

     

    No schematic for the Shield was provided, but I was able to download the Eagle files for the board from Seeed Studios. The schematic shows that the Shield’s USB socket connects via an ETA3410 step-down converter, capable of delivering 2A (in total across all the ports) at 3.3v. Of course, this assumes that it is plugged in to a USB supply capable of providing that power. A USB 2.0 port on a PC can only provide 0.5A and USB 3.0 can provide 0.9A, so a mains powered USB power supply would be needed if you have a power-hungry component such as a servo or the WS2812 Waterproof LED Strip supplied.

     

    I think the manual should provide some guidance on what would be a suitable power supply. Based on the above, for high current-draw applications, I used an official Raspberry Pi power supply which is a switching power supply rated at 2.5A output. For most other applications, I either used the USB 2.0 port on my PC or the Adafruit Powerboost 500C board with a LiPo battery.

     

    Other components provided

    Apart from the Grove Shield, the components chosen from the huge range of Grove components available make a good choice for a kit aimed at relatively inexperienced coders. I was particularly pleased to see the Ultrasonic Ranger, the WS2812 Waterproof LED Strip and the 4-Digit 7-Segment Display included as they always go down well in the classroom and lend themselves to a wide variety of applications and programming constructs.

     

    The booklet provides some nice easy code for the WS2812 Waterproof LED Strip (otherwise known as a NeoPixel strip). I recently used some NeoPixel rings in a session I ran in a Secondary school with 12 year-olds, and this was by far the most popular component. You can’t beat bright, flashy lights! These strips are great as you just plug them in, and you are good to go, rather than worrying about which pin to connect to what. The video below doesn't do justice to the beautiful colours that you can generate.

     

     

    Here is the MakeBlock code for the above demo.

    MakeBlock code for testing Grove WS2812 LED Strip

    The Grove connector also makes a good, solid connection that doesn’t pull out accidentally. I did find the Grove connecting wires a bit stiff, which sometimes makes it difficult to get the smaller components to lie flat.

     

    Grove cables are somewhat inflexible

     

    The Gesture sensor is an amazing device. At first, I thought that it just duplicated the “gesture” functionality of the micro:bit itself. That utilises the built-in accelerometer but it means that the “gestures” are created by waving the micro:bit around. The Grove Gesture sensor is purely optical, which means that you just have to wave your hand above it for the gestures to be recognised by the board. It recognises the following nine gestures: forwards, backwards, up, down, left, right, clockwise, anticlockwise and wave, and each of these is supported by a custom MakeCode block. It connects via the I2C connector on the Shield.

     

     

    The Loudspeaker module is not just the passive speaker that is supplied with other kits, but it connects via a board containing a TI386 low voltage power amplifier and a potentiometer to control the gain of the amplifier. I was slightly surprised by the choice of amplifier as it is rated at 4v supply upwards, but it seemed to work OK with the micro:bit.

     

    Grove Loudspeaker

     

    I was keen to try the Ultrasonic Ranger as this type of sensor rarely works well on 3.3v and normally needs a good steady 5v supply. Recently, lower-voltage versions of the HC SR04 sensor have appeared, so this could be based on that design. The Ultrasonic Ranger uses “single pin mode” (trigger and echo take it in turns to use the same pin). The performance of this sensor was excellent. The readings are rock solid and accurate to within 3% from 0 to 220cm according to my tests, which is better than any other ultrasonic sensor I have tried with the micro:bit. The only drawback with this sensor is that the mounting holes don't seem to fit any standard mounting plate and I couldn't find one designed for the Grove either. The pictures below show two popular ultrasonic sensors - the HC-SR04 and the HY-SR05 and how they fit onto mounting plates. I did find some 3D printer templates on thingiverse, so that might be an option if you have access to a 3D printer.

     

    Grove Ultrasonic Ranger

    Ultrasonics with mounts

    Coding

    The Grove Inventor’s Kit is designed to be used with Microsoft MakeCode block programming environment, and Seeed Studios have developed some custom blocks to support three of the devices included in the Kit (the Gesture sensor, the Ultrasonic Ranger and the 4-Digit Display). All the other components in the Kit can be used with the standard MakeCode blocks. The MakeCode environment has been refined and extended over the past year or so and now supports other devices in addition to the micro:bit, including the Lego Ev3 brick and the Adafruit Circuit Playground Express. The MakeCode environment is web-based (HTML5) with cloud compilation. An Internet connection is required for first use (or when downloading new “packages” (i.e. custom blocks). Thereafter, everything runs locally. Programs are created in the browser, compiled into a “hex file”, then downloaded and “flashed” to the micro:bit via a USB-to-microUSB cable by “dragging and dropping” in Windows Explorer (on a PC). This must be inserted into the micro:bit’s own connector as the microUSB connector on the Grove Shield only provides power.

     

    Apart from MakeCode, the Inventor’s Kit can be used with any programming language or environment that is supported by the micro:bit. The most common alternative is the Mu Micropython editor. This offers the advantage of being able to compile and “flash” in one pass (i.e. no dragging and dropping required). It also provides a REPL (“A Read–Eval–Print Loop”), which allows you to see error messages on your PC, rather than waiting for them to scroll slowly across the micro:bit display. Mu also lets you send other output (e.g. the values of your variables) to the PC screen, which helps with debugging.  Seeed Studios do not provide any instructions, code examples or libraries for using the Kit with Python so you are on your own (although it’s easy enough to find out what you need to know using Google).

     

    Projects

    The projects booklet

    The booklet describes 12 projects that can be used to demonstrate some of the Inventor’s Kit’s possibilities. Each of the components is used at least once. The projects are well-chosen and simple to follow. The illustrations are very colourful and clear and this, together with the use of the Grove system to make the connections, means that incorrect or missing connections should be extremely rare.

     

    I asked my 10 year-old son to test out the projects in the booklet. He completed all the projects with no help needed – which confirms that the Kit is easy to use. n.b. There is an error on page 28 of the booklet: Step 2 - “In the Grove Package, add on Gesture Right to trigger the speaker start melody (entertainer) repeating (once).” This should say “add on Gesture Left”.

     

    The booklet assumes existing familiarity with the micro:bit itself and the MakeCode programming environment, which is fair enough but it is possible that the Kit might be bought together with a micro:bit as a Christmas present. In that case, I think the booklet should at least refer the user to one of the “getting started” guides for the micro:bit itself.

     

    Grove Ultrasonic Ranger and 4-Digit Display

    Extending the use of the Kit

    Having invested around £50 for the Grove Inventor’s Kit, it would be disappointing to find that, once you have completed the 12 projects in the booklet, there is nothing much else you can do with the Kit. This is not the case with the Grove Inventor’s Kit for the micro:bit. The booklet gives some ideas to get you started, but it gives enough information to make it easy for students to combine the components in different ways to build different circuits.

     

    A disadvantage of the modular approach is that you can get “locked in” to a particular eco-system. This would not be a problem if the parts you need are available in that eco-system and that they are not too expensive. The Grove Kit offers the best of both worlds – a wide range of not-too-expensive parts, and the ability to connect non-Grove components to the Grove Shield.

    I was keen to try and build a robot of some sort with the Kit, but there are two difficulties that need to be overcome. Firstly, there is no motor driver on the Shield so that would mean connecting a separate motor driver (not in itself difficult). However, the shape and size of the Shield does make that a bit tricky. The Shield is quite a bit wider than, for example, the Kitronik motor driver board and it lacks any official mounting holes. As an experiment, I tried using some of the crocodile clip connecting holes with plastic stand-offs.

     

    Grove Shield with plastic standoffs

     

    This worked OK as a way of raising the board off the table (to protect the SMD components on the back), but I failed to find any existing robot chassis that lined up with any of the holes. This is an opportunity missed, I think, as there are other Grove Shields that provide mounting holes, such as the Picaxe Grove Shield from Revolution Education which uses “Lego pitch”, allowing you to build around the Shield.

     

    Using the Kit with other Grove components

    It would have been nice if there had been a motor or an LCD screen included in the Kit but I appreciate that these would have increased the cost – which is already quite high compared with the cost of a micro:bit. Personally, I would have liked to see the Grove Mini Fan included. Being able to program and control the Mini Fan motor’s speed using “analogue read” from the Rotary Angle sensor feeding into “analogue write” to the motor would be a popular classroom activity.

     

    The Mini Fan consists of a small DC motor and fan, connected via a driver board. The driver board is quite interesting as it has its own Arduino-compatible Atmega168 microcontroller. The fan motor is connected to that via a MOSFET, to prevent excessive current draw from the Atmega168 pins. The advantage of having a separate board for the fan motor is that you can offload the PWM process to the Atmega168 to control the fan speed, avoiding PWM and other electrical interference in the micro:bit. You could, equally well, connect a high-current display, such as a white LED strip, to the Atmega168 board and control its brightness.

     

     

    Here are the MakeCode blocks you need to control the fan speed using the Grove Angle sensor (ie potentiometer).

    MakeBlock code for analogue read/write

     

    As well as the Mini Fan, I tried some other Grove components that are not included in the Kit, including, the PIR Motion Sensor and the LED Bar.

     

    The PIR Motion Sensor outputs a “high” signal when a moving person or animal is detected. A jumper pin allows you to control whether it is allowed to “re-trigger” once motion has been detected. I used this sensor with the Loudspeaker module to create an alarm system.

     

     

    As mentioned, Seeed Studios has developed custom MakeCode blocks for the tricky-to-use components contained in the Kit. Looking across the whole Grove catalogue, there are many devices (such as the LED Bar) where Seeed Studios has produced example Arduino code but where there is no support for using that device with the micro:bit (and no MakeCode blocks).

     

    The Grove LED bar is a nice component comprised of a 10 segment LED bar gauge and an MY9221 LED controlling chip. It can be used as an indicator for remaining battery life, voltage, water level, music volume or other values that require a gradient display. There are 10 LED bars in the LED bar graph: one red, one yellow, one light green, and seven green bars.

     

     

    Although Seeed Studios have provided a library for the Arduino and Raspberry Pi, they don’t appear to have provided one for the micro:bit. After some research, I found one (my9221.py) via the micropython forum, which works well. Here is some micropython test code that uses it.

     

    from microbit import *

    from my9221 import MY9221

    ledbar = MY9221(di=pin1, dcki=pin15, reverse=False)

    sleep(1500)

    # all LEDS on, full brightness

    ledbar.level(10)

    sleep(500)

    # four LEDS on, half brightness

    ledbar.level(4, 0x0F)

    sleep(1500)

    # first and last LED on

    ledbar.bits(0b1000000001)

    ledbar.bits(0x201)

    ledbar.bits(513)

    sleep(500)

    # alternating LEDs

    ledbar.bits(0b0101010101)

    ledbar.bits(0b1010101010)

    sleep(1500)

    # fade out LEDs

    buf = bytearray([0,1,3,7,15,31,63,127,255,255])

    ledbar.bytes(buf)

    sleep(2000)

    # reverse orientation, first LED is green

    ledbar.reverse(True)

    ledbar.level(1)

    sleep(1500)

    # normal orientation, first LED is red

    ledbar.reverse(False)

    ledbar.level(10,0x0F)

     

    Using the Kit with non-Grove components

    I then moved on to connecting some non-Grove components using various Grove connectors. Non-Grove components could alternatively be connected by cutting one of the provided Grove cables in half and soldering the bare ends on to the component you need to connect Obviously, some technical knowledge and soldering skill would be required for this.

    The components I tried included a 16 x 2 LCD display and an I2C temperature sensor.

     

    The Grove Inventor’s Kit does not provide an LCD display and, although Grove do supply a compatible 3.3v LCD display [link], it is rather pricey and, like me, you might already have a suitable non-Grove display amongst your existing components. Using this was as simple as buying a Grove to Header Pin Converter. I connected an LCD display with I2C backpack (based on the PCF8574 remote 8-bit i/o expander chip) using this converter cable to connect to the I2C port on the Grove Inventor’s Kit. Someone in the Chinese micro:bit community has written an I2C LCD package for MakeCode for micro:bit, so it was just a matter of importing the blocks from https://github.com/microbit-makecode-packages/i2cLCD1602 . Here it is showing the light level from the Grove Light Sensor.

     

     

    MakeBlock code for analogue read from Grove Light Sensor

     

    My next non-Grove component test was the MCP9808 digital temperature sensor which has a typical accuracy ±0.25°C from -40°C to +125°C. It uses the I2C bus and works over a 2.7V ~ 5.5V logic level voltage range. The easiest way to use it with the Grove Inventor’s Kit for micro:bit is to buy a breakout board that exposes its connections via breadboard-friendly pins. This can then be connected to the micro:bit shield using the Grove to Header Pin Converter. Adafruit makes a popular MCP9808 breakout board but I just went for a cheap Chinese board (costing around £2.50) as they do the same job. I have written a full tutorial on how to use this component with the micro:bit on my personal blog.

    Grove Shield with MCP9808 temperature sensor and LCD screen

    Because the Ultrasonic Ranger works so well with the micro:bit and is so easy to use, I couldn’t resist trying it in a robot, even though I couldn’t find a way of using the Grove Shield. I built an autonomous floor robot using two continuous rotation servos built onto a chassis made with 60 year-old Meccano! I found a way to mount the Ultrasonic Ranger using some Lego Technic beams and mounted the micro:bit on a Kitronik Edge Connector Board (whose two mounting pins just about lined up with the Meccano hole-spacing).

    Grove Ultrasonic Ranger Lego mountingMeccano robot with micro:bit and Grove Ultrasonic Ranger

    Evaluation

    Objectives

    Reviewing the Kit against my three objectives:

    1. To explore the Grove Inventor’s Kit to understand what it is, how it works and what it can be used for.
    2. To assess how well-suited it would be for classroom use, in particular for teaching physical computing.
    3. To investigate how the use of the Inventor’s Kit can be extended with additional Grove/non-Grove components, either for classroom work or for code clubs.

     

    Results

    1. I found that the Kit is well designed and good quality. It provides an excellent choice of components but a Mini Fan/motor shield could perhaps have been included so that you can can make something move – which can be very motivating for young learners. The components themselves are also well-designed and good quality. For example, even the simple Red LED module not only has a current-limiting resistor fitted AND a potentiometer (to control brightness), but it is mounted in a socket so you can replace the LED either with an LED of different colour, or perhaps a flashing LED. Similarly, the WS2812 LED Strip is not just a cheap indoor one, it is a waterproof one and is a full metre long with 30 LEDs.

     

    Although the booklet is good (particularly if supplemented with the online Wiki site), it would be helpful if Seeed had provided (or at least signposted) some technical documentation on the Grove Shield itself. I managed to decipher the Eagle files (which were hard to find anyway) so that I could assess what the current rating for the board would be, but it would be better if Seeed Studios had simply provided a datasheet in pdf format and made it readily-available.

     

    Documentation and guidance on powering the Shield through its own USB connector is sparse and users could possibly damage their micro:bit by powering current-hungry components through the micro:bit’s USB connector.

     

    2. In a classroom setting, what is needed is robust components that are easily connected, with clear instructions. The Grove Inventor’s Kit succeeds on all counts. The booklet is aimed at the intended user (i.e. the children) and works well at that level. It would be great if Seeed Studios could provide some educational materials aimed at teachers – such as a link to the areas of the Computing curriculum that are supported by the Kit and maybe some sample lesson plans.

     

    The booklet concentrates on MakeCode as the programming environment. If the Kit is pitched at both Primary and Secondary school level, then helping the transition to Python or other text-based languages would have been helpful. This could take the form of providing the micropython code for the examples in the booklet (which would not be difficult) and ensuring that Python libraries are available (e.g. for the 4-Digit Display).

     

    A Kit costs around £50 (including VAT), but the Grove Shield for micro:bit is also sold separately for around £8. As each Kit provides 8 additional components (plus connectors), it would be feasible to create a very useable “classroom set” by buying ten complete Kits plus another twenty Grove Shields (or half those numbers if the students work in pairs). This would still be a significant expense for most schools but I think it would be a good investment.

     

    3. I was delighted to find that, despite the use of Grove connectors and components, it is extremely easy to connect standard components to the micro:bit Shield, which means that you are not “locked in” to the Grove eco-system. Equally well, it is easy to find many other Grove components that will work with the Kit (although some of them might not be supported by MakeCode or micropython).

     

    Conclusion

    I really like the Grove Inventor’s Kit. It makes it super easy to get started with physical computing on the micro:bit and, although it is a bit pricey compared with the micro:bit itself, it is good value for money in terms of the components provided. Compared with buying the components separately, I estimate that it is around 15% cheaper. The Kit appears to be similar to the element14 mi:node kit and is around the same price. Although I haven't had the chance to test a mi:node kit, the Grove Kit appears to provide more interesting components.

     

    Due to its robustness, it will last well, including in the demanding classroom environment, but it would be better if it came in a robust compartmentalised plastic box, so that the components are easier to manage. Being part of the highly successful Grove eco-system means that there will always be plenty of components and support available. By providing alternative means of connection, even if the Grove system were to become obsolete, you will still be able to utilise your Kit with other components. The Grove Kit is ideal if the focus of the lesson is coding and you don't want to spend too much time building circuits and troubleshooting bad/incorrect connections. The Kitronik Inventor's Kit would be a better choice if the lesson is more focussed on the electronics and how to build circuits.

     

    My only real gripes were the lack of documentation for the Grove Shield (and lack of suitable mounting points), and the rather stiff connecting wires.

     

    I would recommend the Kit both for home use, and for the classroom.


Comments

Also Enrolling

Enrollment Closes: Jan 14 
Enroll
Enrollment Closes: Dec 17 
Enroll
Enrollment Closes: Dec 21 
Enroll