# data[].attributes.attachment_link.readable_text
It's just been announced that Disney Infinity is dead. This isn't so much of a surprise - V1 showed some promise, but V2 didn't include any Disney characters, alienating the market they'd grown with V1 (I would have bought it if the selection of Marval characters included Jessica Jones, just to unlock the empty whiskey bottle in the toy box), while lacking depth to appeal to older players.

Skylanders has also jumped the shark... I quite liked Swap Force, but Super Chargers was just dull - probably because as a parent my role was to hold the second controller and press fire, while offspring got to do all the driving.

So the only think left to do with all those figures - let them battle it out one last time with your Microbit! Both Skylanders and Disney Infinity use "RFID" tags inside the figures, so that the base station can identify them. It's the same technology that's used for contactless credit cards.

To teach your Microbit to read RFID tags you need a "Mifare RC522", sometimes called MF522. These cost about £2.50 on eBay, and you can use them to read all sorts of cards. You can even buy "blank" cards, which you can store data on. Inifiity/Skylanders use this feature to record the progress on the figure rather than in the game, but they have a security code so you can't easily write to them yourself. All we're going to do is read the ID of the card.

Hook up is really easy: If you've checked out our other microbit posts you'll have used SPI. Just connect the power, and the 4 SPI wires from the MF522 to equivalent ones on your microbit, and you're good to go. There may also be a "reset" pin but just ignore that.

make cardReader rfid device D16

First thing to do is make an SPI device and then an rfid device. I used D16 for "CS/SS" though you could use something else if you wanted to. I'm going to display the data on the screen using a script called scroll, so I also set up some variables for that.

To use the "scroll" script we set the message and run the script. We kick of by saying "ready". Now we're going going to tell the reader to "get card", which tells it to start talking to a card. If it finds one it puts its card ID into cardData, so when we find one we can set that as the message.

The card ID will look like four hexadecimal numbers. I check them against the figures I already know about, and if they match, I replace the ID with the characters name. I picked Elsa and Legendary Bash to use (remember these are the numbers for my figures - yours will be different). You can add as many as you like. If you have a lot you could write some code to check them against a list rather than testing teach one. You could even add an SD card, and have a file of known figures.

Once I know the character I "say" it to the computer, and run "scroll". We don't "and wait" this time as we need to tell the card reader that we're now done with this card, and it should disconnect. Then we wait until the scrolling is complete.

The code to display/scroll text is something we've also seen before:

# data[].attributes.attachment_link.description
It's just been announced that Disney Infinity is dead. This isn't so much of a surprise - V1 showed some promise, but V2 didn't include any Disney characters, alienating the market they'd grown with V1 (I would have bought it if the selection of Marval characters included Jessica Jones, just to unlock the empty whiskey bottle in the toy box), while lacking depth to appeal to older players.

# data[].attributes.attachment_link.readable_text
Once you've got past the basics of flashing LED's and using the built in i2c devices on a microbit, the next thing you'll probably wonder what else you can connect to it...

Quite a lot of the cool things you might want to connect use "SPI", which is quite a lot like I2C, just different - in the same way that firewire, thunderbolt and USB are all different but do similar kinds of things. Like i2c it can be a bit scary to hook up at first, but its actually pretty easy.

In addition to power (and earth) an SPI device will typically use 4 wires. Two of these are mysteriously labeled MISO and MOSI, but in fact they're really simple:

MISO: Master In, Slave Out

MOSI: Master Out, Slave In

For our purposes the Master is the computer (Microbit) and the Slave is the thing we want to connect. MOSI sends data from the computer to the device, and MISO sends data from the device back to the Master. See... it really is easy.

The third wire is Clock, and that just makes sure that the two ends are properly synchronised. On the Microbit pin 13 is clock, 14 is MISO and 15 is MOSI. On Arduino they're on pins 11,12 and 13.

Remember how we said SPI is like USB... well just like USB you can connect lots of things to SPI at the same time. However the microbit needs to know which device its talking to. For that we need the final wire CS - Chip/Circuit Select. You can actually use any pin you like as chip select, but pin 16 is generally going to be the best choice on Microbit, as its sitting there right next to 13,14,15 not doing anything very much!

If you want to connect multiple SPI devices at the same time, then that's totally OK - just share the CLK, MOSI, MISO connections and give each their own CS connection.

So what can we connect? Well one of the most common SPI devices is an SD card reader. In fact there's actually no such thing as an SD card reader - its really not much more than a connector between the card and the computer. SD cards actually know how to talk SPI!

You can get on of these for about £1 on eBay, (search for "arduino sdcard reader"). SD cards operate at 3.3v and actually a lot of the ones sold for Arduino might damage the card when you run them at 5V, but the Microbit is 3.3v so we're good! (for Arduino get something like the Data logging shield or ethernet shield which has a card reader built in, along with the extra circuitry to access it safely, rather than one of these cheap stand alone boards).

There'll be 6 pins: 0v/Gnd, 3V/Vcc, MISO, MOSI, CS, and CLK. Just hook them up as described above and you're good to go!

If you've installed Sniff already, then you'll find the code to access the SD card in examples/Embedded. It's in the Embedded, rather than the Microbit folder because it runs essentially unchanged on Microbit, Arduino, Propeller or anything else you might want to try it on.

The code begins with some definitions. We need an SPI device to create the SPI bus, then an SD card device. You probably need to change the pin number here to correspond to the Microbit. On the Arduino SD cards generally use either D10 or D4 as their CS pin, but we want to use D16.

The example code starts with some diagnostics:

.repeat until sdcardValid

..tell fileSystem to "init"

..say "File System Failure"

This tests that the card reader is working, it has a card in, and that there's readable data on the card - you don't need to include any of this in your own code, but its good for testing. If this doesn't work then first check your wiring. If you're confident that its correct then you probably need to format your card. This is actually the hardest part! The Microbit is pretty limited in the complexity of code it can run, so it uses the FAT16 file system. This is OLD, so can only handle cards up to 2Gb. Your desktop machine will read FAT16 fine, but it might not be able to format FAT16. Or if it does format them, it can do a really bad job. If you've got access to an Arduino, then use t his sketch to reformat your cards, and theres a good chance that magically everything will start working.

Once you get past that hurdle, everything is nice and simple. The SDcard demo checks if the file "newFile.txt" exists:

.set fileData to "newFile.txt"

Reading it back is pretty similar, but this time we "start read". If its there and readable, then fileOK will be true, so we go around the loop, calling "read string". If that works then fileOK is true, and we print out what we got. Keep going until it fails, then "end read" to say you're done.

The read test also deletes the file when its done, so each time you reset the microbit it will alternate between doing a read test and a write test!

An SD card is a really cheap and easy way of adding permanent storage to your project, so you can make something that logs data overnight, or even for weeks. It's really easy to store data in a CSV file, and then just take the SD card to a computer and load it into a spreadsheet.

# data[].attributes.attachment_link.title
SPI Explained (connecting SD cards to the Microbit!)

# data[].attributes.attachment_link.description
Once you've got past the basics of flashing LED's and using the built in i2c devices on a microbit, the next thing you'll probably wonder what else you can connect to it...

# data[].attributes.attachment_link.readable_text
Established: April 5, 2010

Kodu is a new visual programming language made specifically for creating games. It is designed to be accessible for children and enjoyable for anyone. The programming environment runs on the Xbox, allowing rapid design iteration using only a game controller for input.

Programming as a Creative Medium

The core of the Kodu project is the programming user interface. The language is simple and entirely icon-based. Programs are composed of pages, which are broken down into rules, which are further divided into conditions and actions. Conditions are evaluated simultaneously.

The Kodu language is designed specifically for game development and provides specialized primitives derived from gaming scenarios. Programs are expressed in physical terms, using concepts like vision, hearing, and time to control character behavior. While not as general-purpose as classical programming languages, Kodu can express advanced game design concepts in a simple, direct, and intuitive manner.

Screen Shots

Kodu provides an end-to-end creative environment for designing, building, and playing your own new games.

High-level language incorporates real-world primitives: collision, color, vision

Uses Xbox 360 Game Controller for input - no keyboard required

Runs on XBox 360 and PC

Interactive terrain editor

Bridge and path builder

Terrain editor - create worlds of arbitrary shape and size

20 different characters with different abilities

Free PC version: Fuse Labs Kodu

Also at Fuse Labs page:

Tutorial Videos

Classroom Kit for Educators

Visit KoduGameLab.com!

In the News

Projects We Like

Papers

# data[].attributes.attachment_link.description
Kodu is a new visual programming language made specifically for creating games. It is designed to be accessible for children and enjoyable for anyone. The programming environment runs on the Xbox, allowing rapid design iteration using only a game controller for input. Programming as a Creative Medium The core of the Kodu project is the ...

# data[].attributes.attachment_link.description
Make a Whack a Fruit game using the BBC micro:bit

# data[].attributes.attachment_link.readable_text
Code it. Connect it.

Bitty Software - mobile apps for micro:bit and free coding tutorials

Table of Contents

Documentation

Development Tools

Hex Files

Hex files are now located at the downloads page of the Bitty Software web site.

micro:bit Blue - The micro:bit Bluetooth demo app for Android

Most of the videos below feature an Android application I wrote to enable the testing and demonstration of the many Bluetooth capabilities which the BBC micro:bit has.

This application will be released as open source in the next few weeks!

Note that to use the application and enjoy your micro:bit's Bluetooth capabilities in full, you need a hex file which contains the full list of Bluetooth "services". The hex file your new micro:bit contains when you unbox it does have all the services but the animation it runs means you cannot set the LED display over Bluetooth.

There are a choice of hex files suitable for use with micro:bit Blue available from the downloads page at the Bitty Software web site

External Resources

Videos

The Bitty Software web site has videos of its own which are not included in the list below. Well worth checking out:

I've combined my love of cycling with my love of the micro:bit! Cyclists often use a training technique involving dividing their measured heart rate during a training session into 5 bands or 'zones'. They monitor the distribution of the time their heart rate has spent in each zone as a histogram during training with the aim that it have a certain shape or bias for a given intensity of training. Here's a screenshot from a cycling analytics system I use:

The heart rate zone histogram is on the right of course.

Those 5 zones got me thinking. The micro:bit has a 5 x 5 LED matrix so what if..... I somehow hooked up a heart rate monitor (over Bluetooth of course!) and displayed a real-time histogram on the micro:bit so that I had a small, wearable heart rate zone training monitor? There was only one way to find out...

At the top of the image you can see my Bluetooth Polar heart rate monitor which I strap around my chest. It transmits heart rate measurements approximately once per second to my phone which is running my multi-purpose micro:bit demo to which I've added my new heart rate zone demo. The phone displays a histogram which is updated in real time along with other details and uses the micro:bit's Bluetooth LED Service to mirror the histogram onto the micro:bit LED grid. Simples!

BBC micro:bit heart rate histogram from Martin Woolley on Vimeo.

#include "MicroBit.h"

/*
 * Temperature Alarm
 * Uses the Bluetooth Event Service to inform registered clients whenever the temperature falls below xx or rises above yy
 */
MicroBit uBit;

uint16_t state      = 0; // 0=ok, 1=alarming because it's cold, 2=alarming because it's hot
uint16_t ok         = 0;
uint16_t any        = 0;
uint16_t temp_alarm = 9000;
uint16_t set_lower  = 9001;
uint16_t set_upper  = 9002;
uint16_t cold       = 1;
uint16_t hot        = 2;
uint8_t  upper      = 24;
uint8_t  lower      = 19;
int reading_count   = 0;

void onSetLower(MicroBitEvent e)
{
 lower = e.value;
    uBit.display.scroll("L=");
    uBit.display.scrollAsync(lower);
}

void onSetUpper(MicroBitEvent e)
{
 upper = e.value;
    uBit.display.scroll("U=");
    uBit.display.scrollAsync(upper);
}

void onTemperatureReading(MicroBitEvent e)
{
 int temperature = uBit.thermometer.getTemperature();
 reading_count++;
 if (reading_count == 10) {
   uBit.display.scrollAsync(temperature);
   reading_count = 0;
 }
 if (temperature > upper && state == ok) {
     MicroBitEvent evt(temp_alarm, hot);
  state = hot;
  return;
 }
 if (temperature < lower && state == ok) {
     MicroBitEvent evt(temp_alarm, cold);
  state = cold;
  return;
 }
 if (temperature >= lower && temperature <= upper && state != ok) {
     MicroBitEvent evt(temp_alarm, ok);
  state = ok;
 }
}

void app_main()
{
  uBit.display.scrollAsync("TEMP ALARM");
  new MicroBitTemperatureService(*uBit.ble, uBit.thermometer);
  // listen for client events which set the upper and lower temperature limits
  uBit.messageBus.listen(set_lower, any, onSetLower);
  uBit.messageBus.listen(set_upper, any, onSetUpper);
  // listen to the temperature sensor
  uBit.messageBus.listen(MICROBIT_ID_THERMOMETER, MICROBIT_THERMOMETER_EVT_UPDATE, onTemperatureReading);
}

Kitronik sell a nice buggy kit which is designed to follow lines on the ground. I reprogrammed it to respond to event messages delivered over Bluetooth from a smartphone application using the Bluetooth Event Service so I could remote control it.

/*
/*
The MIT License (MIT)

Copyright (c) 2016 British Broadcasting Corporation.
This software is provided by Lancaster University by arrangement with the BBC.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/

#include "MicroBit.h"

MicroBit uBit;

int pin0, pin8, pin12, pin16 = 0;

int drive = 0;

void onConnected(MicroBitEvent e)
{
    uBit.display.print("C");
}

void onDisconnected(MicroBitEvent e)
{
    uBit.display.scroll("D");
}

void onControllerEvent(MicroBitEvent e)
{
  uBit.serial.printf("event %d\n",e.value);
  if (e.value == MES_DPAD_BUTTON_1_DOWN) {
      pin12 = 1;
      pin16 = 1;
      drive = 1;
  } else {
    if (e.value == MES_DPAD_BUTTON_1_UP) {
      uBit.serial.printf("2\n");
      pin12 = 0;
      pin16 = 0;
      drive = 0;
    }
  }

  if (drive == 1) {
      if (e.value == MES_DPAD_BUTTON_C_DOWN) {
          uBit.serial.printf("3\n");
          pin12 = 1;
          pin16 = 0;
      } else {
          if (e.value == MES_DPAD_BUTTON_D_DOWN) {
              uBit.serial.printf("4\n");
              pin12 = 0;
              pin16 = 1;
          } else {
              if (e.value == MES_DPAD_BUTTON_C_UP || e.value == MES_DPAD_BUTTON_D_UP) {
                  uBit.serial.printf("5\n");
                  pin12 = 1;
                  pin16 = 1;
              } else {
                    uBit.serial.printf("6\n");
              }
          }
      }
  }

  uBit.io.P0.setDigitalValue(pin0);
  uBit.io.P8.setDigitalValue(pin8);
  uBit.io.P12.setDigitalValue(pin12);
  uBit.io.P16.setDigitalValue(pin16);

}

int main()
{
    // Initialise the micro:bit runtime.
    uBit.init();

    uBit.display.scroll("BUGGY!");
    uBit.messageBus.listen(MES_DPAD_CONTROLLER_ID, 0, onControllerEvent);
    uBit.messageBus.listen(MICROBIT_ID_BLE, MICROBIT_BLE_EVT_CONNECTED, onConnected);
    uBit.messageBus.listen(MICROBIT_ID_BLE, MICROBIT_BLE_EVT_DISCONNECTED, onDisconnected);

    // If main exits, there may still be other fibers running or registered event handlers etc.
    // Simply release this fiber, which will mean we enter the scheduler. Worse case, we then
    // sit in the idle task forever, in a power efficient sleep.
    release_fiber();
}

and the corresponding JavaScript:

let pin0 = 0;
let pin8 = 0;
let pin12 = 0;
let pin16 = 0;
let drive = 0;
basic.showString("ROBOT WARS!");
bluetooth.onBluetoothConnected(() => {
    basic.showString("C");
});
bluetooth.onBluetoothDisconnected(() => {
    basic.showString("D");
});
control.onEvent(control.eventSourceId(EventBusSource.MES_DPAD_CONTROLLER_ID), control.eventValueId(EventBusValue.MICROBIT_EVT_ANY), () => {
    if (control.eventValue() == control.eventValueId(EventBusValue.MES_DPAD_BUTTON_1_DOWN)) {
        pin12 = 1;
        pin16 = 1;
        drive = 1;
    } else if (control.eventValue() == control.eventValueId(EventBusValue.MES_DPAD_BUTTON_1_UP)) {
        pin12 = 0;
        pin16 = 0;
        drive = 0;
    } else { }
    if (drive == 1) {
        if (control.eventValue() == control.eventValueId(EventBusValue.MES_DPAD_BUTTON_C_DOWN)) {
            pin12 = 1;
            pin16 = 0;
        } else {
            if (control.eventValue() == control.eventValueId(EventBusValue.MES_DPAD_BUTTON_D_DOWN)) {
                pin12 = 0;
                pin16 = 1;
            } else {
                if (control.eventValue() == control.eventValueId(EventBusValue.MES_DPAD_BUTTON_C_UP) || control.eventValue() == control.eventValueId(EventBusValue.MES_DPAD_BUTTON_D_UP)) {
                    pin12 = 1;
                    pin16 = 1;
                } else { }
            }
        }
    }
    pins.digitalWritePin(DigitalPin.P0, pin0);
    pins.digitalWritePin(DigitalPin.P8, pin8);
    pins.digitalWritePin(DigitalPin.P12, pin12);
    pins.digitalWritePin(DigitalPin.P16, pin16);
});

micro:bit contains a magnetometer or digital compass. The Bluetooth profile includes a service called the Magnetometer Service and this allows connected devices to obtain the compass bearing of the micro:bit and for it to be updated in real-time. Here's a demo.....

/*
#include "MicroBit.h"
#include "MicroBitSamples.h"

#ifdef MICROBIT_BLE_MAGNETOMETER

MicroBit uBit;

int main()
{
    // Initialise the micro:bit runtime.
    uBit.init();

    // Note GATT table size increased from default in MicroBitConfig.h
    // #define MICROBIT_SD_GATT_TABLE_SIZE             0x500
    new MicroBitMagnetometerService(*uBit.ble, uBit.compass);
    uBit.display.scroll("MAGNETOMETER");

    // If main exits, there may still be other fibers running or registered event handlers etc.
    // Simply release this fiber, which will mean we enter the scheduler. Worse case, we then
    // sit in the idle task forever, in a power efficient sleep.
    release_fiber();
}

#endif

micro:bit now has a Bluetooth UART service which emulates serial data comms over Bluetooth low energy. I used it to implement the classic two player guessing game Animal Vegetable or Mineral. Simples!

#include "MicroBit.h"
#include "MicroBitSamples.h"
#include "MicroBitUARTService.h"

#ifdef MICROBIT_UART

MicroBit uBit;
MicroBitUARTService *uart;

int connected = 0;

void onConnected(MicroBitEvent e)
{
    uBit.display.scroll("C");

    connected = 1;

    // my client will send ASCII strings terminated with the colon character
    ManagedString eom(":");

    while(1) {
        ManagedString msg = uart->readUntil(eom);
        uBit.display.scroll(msg);
    }

}

void onDisconnected(MicroBitEvent e)
{
    uBit.display.scroll("D");
    connected = 0;
}

void onButtonA(MicroBitEvent e)
{
    if (connected == 0) {
        uBit.display.scroll("NC");
        return;
    }
    uart->send("YES");
    uBit.display.scroll("YES");
}

void onButtonB(MicroBitEvent e)
{
    if (connected == 0) {
        uBit.display.scroll("NC");
        return;
    }
    uart->send("NO");
    uBit.display.scroll("NO");
}

void onButtonAB(MicroBitEvent e)
{
    if (connected == 0) {
        uBit.display.scroll("NC");
        return;
    }
    uart->send("GOT IT!!");
    uBit.display.scroll("GOT IT!!");
}

/*
Recommend disabling the DFU and Event services in MicroBitConfig.h since they are not needed here:

#ifndef MICROBIT_BLE_DFU_SERVICE
#define MICROBIT_BLE_DFU_SERVICE                0
#endif

#ifndef MICROBIT_BLE_EVENT_SERVICE
#define MICROBIT_BLE_EVENT_SERVICE              0
#endif

*/

int main()
{
    // Initialise the micro:bit runtime.
    uBit.init();

    uBit.messageBus.listen(MICROBIT_ID_BLE, MICROBIT_BLE_EVT_CONNECTED, onConnected);
    uBit.messageBus.listen(MICROBIT_ID_BLE, MICROBIT_BLE_EVT_DISCONNECTED, onDisconnected);
    uBit.messageBus.listen(MICROBIT_ID_BUTTON_A, MICROBIT_BUTTON_EVT_CLICK, onButtonA);
    uBit.messageBus.listen(MICROBIT_ID_BUTTON_B, MICROBIT_BUTTON_EVT_CLICK, onButtonB);
    uBit.messageBus.listen(MICROBIT_ID_BUTTON_AB, MICROBIT_BUTTON_EVT_CLICK, onButtonAB);


    // Note GATT table size increased from default in MicroBitConfig.h
    // #define MICROBIT_SD_GATT_TABLE_SIZE             0x500
    uart = new MicroBitUARTService(*uBit.ble, 32, 32);
    uBit.display.scroll("AVM");

    // If main exits, there may still be other fibers running or registered event handlers etc.
    // Simply release this fiber, which will mean we enter the scheduler. Worse case, we then
    // sit in the idle task forever, in a power efficient sleep.
    release_fiber();
}

#endif

The BBC micro:bit has a default Bluetooth profile which includes a range of "services". Access to the full set of extensive Bluetooth capabilities on the micro:bit is not currently available if you use the on-line code editors Blocks, Touch Develop or the one from Code Kingdom. No Bluetooth functionality is available from mico:python either. So if you want to exploit Bluetooth on your micro:bit beyond the small number of canned use cases supported by these code editors, it is recommended that you use ARM's mbed IDE. This video shows you how, explains the issues and the workarounds to those issues.

# data[].attributes.attachment_link.description
Hex files are now located at the downloads page of the Bitty Software web site. Most of the videos below feature an Android application I wrote to enable the testing and demonstration of the many Bluetooth capabilities which the BBC micro:bit has. This application will be released as open source in the next few weeks!

# data[].attributes.attachment_link.description
yotta is a tool that we're building at mbed to help ourselves and others build better software for C-family languages by making it easier to share and re-use software modules. It's a command line tool yotta, but also a culture of building software components that do one thing well, declare a clear interface, and can be re-used.

# data[].attributes.attachment_link.description
juggling - Juggle with devices and get it visualized on your phone!

# data[].attributes.attachment_link.description
Discover how to use your BBC micro:bit as an iBeacon on the Locly Sandbox platform to easily link content to places (or carry the micro-bit with you as a personal beacon!). You can get written instructions on our blog: http://blog.locly.com/?p=2091. Have fun!

# data[].attributes.attachment_link.title
BBC micro:bit with Espruino JavaScript and Web Bluetooth

# data[].attributes.attachment_link.description
Using http://www.espruino.com and a fully online version of the Espruino Web IDE, it's possible to program a micro:bit in JavaScript completely wirelessly using Bluetooth Low Energy (Bluetooth Smart). All code runs on the micro:bit itself! Espruino MicroBit Page: http://www.espruino.com/MicroBit Online Web IDE: https://espruino.github.io/EspruinoWebIDE/

# data[].attributes.attachment_link.description
Learn how to program a BBC Microbit using python and how to add neopixels for some extra flashy colour light fun! #BBCMakeItDigital Suitable for beginners. Thanks to Damien George & Nicholas Tollervey for making Python on the Microbit so much fun. Code is on GitHub - https://github.com/MissPhilbin/GeekGurlDiaries Like, share, & subscribe for more!

# data[].attributes.attachment_link.description
Kodu reads the micro:bit accelerometer & face buttons, writes to the LED screen, and interfaces with the real world over I/O pins in this feature demonstration video.

# data[].attributes.attachment_link.title
Using the ARM mbed IDE to select Bluetooth services to include in your BBC micro:bit application

# data[].attributes.attachment_link.description
The BBC micro:bit has a default Bluetooth profile which includes a range of "services". Access to the full set of extensive Bluetooth capabilities on the micro:bit is not currently available if you use the on-line code editors Blocks, Touch Develop or the one from Code Kingdom. No Bluetooth functionality is available from mico:python either.

# data[].attributes.attachment_link.entities[].name
Review Single Board Computer First Look Getting

# data[].attributes.attachment_link.description
In the first computer-juggling film ever on YouTube, ARM engineers show how the innovative new BBC micro-bit computer can be a fantastically fun device. The micro:bit starts arriving in UK schools today as part of a roll-out of one million devices for 11-12 year olds. The micro:bit features ARM®-based NXP microprocessors and Nordic Bluetooth chips.

# data[].attributes.attachment_link.title
Hello, World! - BBC micro:bit MicroPython 0.5.0 documentation

# data[].attributes.attachment_link.description
tells MicroPython to get all the stuff it needs to work with the BBC micro:bit. All this stuff is in a module called (a module is a library of pre-existing code). When you something you're telling MicroPython that you want to use it, and is Python's way to say everything.

# data[].attributes.attachment_link.description
Pair up your Android phone or tablet with micro:bit, and turn your device into your personal gadget in 6 awesome projects.

# data[].attributes.attachment_link.description
The BBC micro:bit is a pocket-sized, codeable computer that allows you to get creative.

# data[].attributes.attachment_link.description
The open source microbit-ble-demo-android application contains a full demonstration of the micro:bit Bluetooth LED service. The main body of code for this demonstration can be found in ui.LEDsActivity.java except for the Bluetooth operations themselves which are in bluetooth.BleAdapterService which acts as a kind of higher level Bluetooth API for activities to use without needing to directly concern themselves too closely with the Android APIs themselves.

# data[].attributes.attachment_link.readable_text
Barry Byford is a bit of a Bluetooth nut and he has turned his attention to the micro:bit and its Bluetooth interface. In this example (in the video above) he shows us how a micro:bit button press can be detected by the Raspberry Pi and then used to trigger LEDs on the Ryanteck Traffic HAT. Details of the code and how to do it are contained in the YouTube description here.

# data[].attributes.attachment_link.title
Controlling the Raspberry Pi using Bluetooth on the micro:bit

# data[].attributes.attachment_link.description
Barry Byford is a bit of a Bluetooth nut and he has turned his attention to the micro:bit and its Bluetooth interface. In this example (in the video above) he shows us how a micro:bit button press can be detected by the Raspberry Pi and then used to trigger LEDs on the Ryanteck Traffic HAT.

# data[].attributes.attachment_link.description
The actual pairing can be carried out using the "offical" micro:bit mobile app, graciously provided by Samsung. Pairing is only permitted in a special pairing mode, which you enter by holding down both buttons on each side of the LED screen (called A & B), and pressing reset with your other fingers, or nose.