Microbit Demos

// The simplest Microbit program: shows a number on the LEDs.
// Button B increases the value, Button A decreases the value.
// No external wiring needed — just the micro:bit itself.

// --- Setup ---
let value = 0;
basic.showNumber(value);

// --- Button Handlers ---
input.onButtonPressed(Button.B, function () {
  value += 1;
  basic.showNumber(value);
});

input.onButtonPressed(Button.A, function () {
  value -= 1;
  basic.showNumber(value);
});

// Reads the micro:bit's built-in compass
// Displays an arrow on the LED screen
// pointing in the compass direction
// (N, NE, E, SE, S, SW, W, NW).
// Microbit screen should face up.
// You may need to tilt the Microbit around to calibrate the compass

// --- Setup ---
let angle = 0;
basic.showIcon(IconNames.Triangle);
input.calibrateCompass();

// --- Main Loop ---
basic.forever(function () {
  angle = input.compassHeading();
  if ((angle >= 0 && angle < 45) || angle >= 360) {
    basic.showArrow(ArrowNames.North);
  } else if (angle >= 45 && angle < 90) {
    basic.showArrow(ArrowNames.NorthWest);
  } else if (angle >= 90 && angle < 135) {
    basic.showArrow(ArrowNames.West);
  } else if (angle >= 135 && angle < 180) {
    basic.showArrow(ArrowNames.SouthWest);
  } else if (angle >= 180 && angle < 225) {
    basic.showArrow(ArrowNames.South);
  } else if (angle >= 225 && angle < 270) {
    basic.showArrow(ArrowNames.SouthEast);
  } else if (angle >= 270 && angle < 315) {
    basic.showArrow(ArrowNames.East);
  } else if (angle >= 315 && angle < 360) {
    basic.showArrow(ArrowNames.NorthEast);
  } else {
  }
  serial.writeValue("angle", angle);
  basic.pause(100);
});

// Shake the micro:bit to show a random number between 1 and 6 on the LED screen.

basic.pause(1000); // --- Setup ---
serial.redirectToUSB();
basic.showIcon(IconNames.Chessboard);
music.play(music.tonePlayable(262, music.beat(BeatFraction.Sixteenth)), music.PlaybackMode.UntilDone);

input.onGesture(Gesture.Shake, function () {
  // Runs when the micro:bit is shaken
  basic.showNumber(randint(1, 6));
  basic.pause(4000);
  basic.clearScreen();
});

// Tilt-to-navigate game:
// tilt the micro:bit to move a bright dot
// toward a dimmer dot on the 5x5 LED grid.
// Press button B when you reach it to win.

// --- Setup ---
// the LED screen has 5 pixels by 5 pixels
// these are numbered as 0 through 4
// the player starts in the top left LED
let player_x = 0;
let player_y = 0;

// the goal is in the center LED
let goal_x = 2;
let goal_y = 2;
serial.redirectToUSB();
music.play(music.tonePlayable(262, music.beat(BeatFraction.Sixteenth)), music.PlaybackMode.UntilDone);

// --- Main Loop ---
basic.forever(function () {
  basic.clearScreen();
  if (input.acceleration(Dimension.X) > 500) {
    player_x = Math.min(4, player_x + 1);
  } else if (input.acceleration(Dimension.X) < -500) {
    player_x = Math.max(0, player_x - 1);
  }
  if (input.acceleration(Dimension.Y) > 500) {
    player_y = Math.min(4, player_y + 1);
  } else if (input.acceleration(Dimension.Y) < -500) {
    player_y = Math.max(0, player_y - 1);
  }
  led.plotBrightness(player_x, player_y, 255);
  led.plotBrightness(goal_x, goal_y, 119);
  serial.writeLine("X" + input.acceleration(Dimension.X) + " " + "Y" + input.acceleration(Dimension.Y) + " " + "Z" + input.acceleration(Dimension.Z));
  basic.pause(100);
});

// --- Event Handlers ---
// Runs when button B is pressed to check if player reached the goal
input.onButtonPressed(Button.B, function () {
  if (player_x == goal_x && player_y == goal_y) {
    serial.writeString("WON");
    music.play(music.stringPlayable("C5 B A G F E D C ", 120), music.PlaybackMode.UntilDone);
    basic.clearScreen();
    basic.pause(1000);
    goal_x = randint(0, 4);
    goal_y = randint(0, 4);
  } else {
    music.play(music.tonePlayable(131, music.beat(BeatFraction.Sixteenth)), music.PlaybackMode.UntilDone);
    basic.clearScreen();
    basic.pause(1000);
  }
});

// Reads an external push button and shows its state on the LED screen.
// This is the simplest possible digital sensor — just on or off.
// Use this pattern any time you want an physical button
//
// Physical setup:
//   Button module has 3 pins labeled S (signal), V (power), G (ground).
//   Connect S → micro:bit pin 0
//   Connect V → micro:bit 3V
//   Connect G → micro:bit GND
//
// Digital read: 0 = button pressed, 1 = button released.
// pin 0 is "pulled up" -a little electricity keeps the pin at 1
// Pressing the switch connects the pin to ground, "pulling" it to 0

// --- Setup ---
basic.showIcon(IconNames.SmallDiamond);
pins.setPull(DigitalPin.P0, PinPullMode.PullUp);

// --- Main Loop ---
basic.forever(function () {
  if (pins.digitalReadPin(DigitalPin.P0) == 0) {
    //Button is pressed"
    basic.showIcon(IconNames.Yes);
  } else {
    //Button is not pressed
    basic.clearScreen();
  }
  basic.pause(100); // wait 1/10th of a second
});

// Reads a knock sensor and counts knocks on the LED screen.
// This is the simplest digital sensor — just on or off.
//
// This time we are using an event code block.
// The microbit is silently always checking if the pins are changing.
// If we write a special block of code called an evert, the microbit runs it when the change happens.
// This interrupts the basic.forever() loop, so we try to keep them short or we get confused.
//
// The knock sensor has 3 pins labeled S (signal), V (power), G (ground).
// Connect S → micro:bit pin 5
// Connect V → micro:bit 3V
// Connect G → micro:bit GND
//
// The sensor has a built-in pull-up resistor, so its signal is normally HIGH.
// A knock produces a brief LOW pulse  pins.onPulsed catches these brief signals.
// this is VERY fast.  So fast the springs will bounce back and forth a few times at 10x per second.
// this could look like 10 knocks, which is bad.
// so we

// Pin 5 is chosen for convenience for testing. Pressing Button A is also sets pins 5 to low

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
basic.pause(1000);
basic.clearScreen();

pins.setPull(DigitalPin.P5, PinPullMode.PullNone); // Sensor has its own pull-up; PullNone avoids any conflict

let count = 0; // we are counting the knocks
let TimeSinceLastConnectToGround = 0; // we will use this to de-bounce the knock sensor
let knockRegistered = false; // flag to tell the forever loop to update the display

pins.onPulsed(DigitalPin.P5, PulseValue.Low, function () {
  // this runs when the pin 5 gets connected to ground, that is, the wire in the spring knock sensor bends and touches the other wire.
  let TimeSinceMicrobitStart = input.runningTime(); // now is the number of milliseconds since the microbit started
  let TimeSinceLastCheck = TimeSinceMicrobitStart - TimeSinceLastConnectToGround;
  TimeSinceLastConnectToGround = TimeSinceMicrobitStart; // always update — extends the quiet window on each bounce

  if (TimeSinceLastCheck > 150) knockRegistered = true;
});

basic.forever(function () {
  // this loop just updates the screen
  // you might notice that, in theory, we could just update the screen in the event loop
  // but basic.showNumber takes time, which interferes with the sensing
  // AI is your buddy on this kind of subtle problem.

  if (knockRegistered) {
    knockRegistered = false;
    count += 1;
    if (count > 9) count = 0;

    basic.showNumber(count); // display runs here, outside the event handler
  } else basic.pause(50); // wait a bit
});

// Detects human movement using a PIR (passive infrared) motion sensor.
// When motion is detected, the LED screen shows an eye icon and plays a sound.
//
// How it works: the sensor detects body heat moving in front of it.
// Digital read: 1 = motion detected, 0 = no motion.
// The sensor has a ~2 second warm-up time when first powered on.
//
// Physical setup:
//   Sensor has 3 pins labeled S (signal), V (power), G (ground).
//   Connect S → micro:bit pin 0
//   Connect V → micro:bit 3V
//   Connect G → micro:bit GND

// --- Setup ---
basic.pause(2000);
music.play(music.tonePlayable(988, music.beat(BeatFraction.Eighth)), music.PlaybackMode.InBackground);
pins.setPull(DigitalPin.P0, PinPullMode.PullDown);
basic.showIcon(IconNames.Asleep);

// --- Main Loop ---
basic.forever(function () {
  if (pins.digitalReadPin(DigitalPin.P0) == 1) {
    basic.showIcon(IconNames.Happy);
    serial.writeLine("Motion detected!");
  } else {
    basic.showIcon(IconNames.Asleep);
    serial.writeLine("No motion");
  }
  basic.pause(100);
});

// Skin Capacitive switch — human skin activates. No sensor module needed.
//
// Physical setup:
//   Wire 1: micro:bit P0 → first conductive surface (what they touch)
//   No 3V or ground connection needed.
//
// Note!  Very finicky, may activate unexpectedly, especially with a long wire.

// --- Setup ---
basic.pause(1000);
music.play(music.tonePlayable(988, music.beat(BeatFraction.Eighth)), music.PlaybackMode.InBackground);
basic.showIcon(IconNames.Heart);
pins.touchSetMode(TouchTarget.P0, TouchTargetMode.Capacitive);
// --- Main Loop ---
basic.forever(function () {
  if (input.pinIsPressed(TouchPin.P0)) {
    basic.showIcon(IconNames.Yes);
    serial.writeLine("Touched!");
  } else {
    basic.showIcon(IconNames.SmallDiamond);
  }
  basic.pause(100);
});

// Detects touch using a capacitive touch sensor — no mechanical button needed.
// Touching the sensor pad lights up the LED screen
//
// Digital read: 1 = touched, 0 = not touched.
//
// Physical setup:
//   Sensor has 3 pins labeled S (signal), V (power), G (ground).
//   Connect S → micro:bit pin 0
//   Connect V → micro:bit 3V
//   Connect G → micro:bit GND
//   You can attach a wire to the sensor pad to extend the touch area.

// --- Setup ---
basic.pause(1000);
music.play(music.tonePlayable(988, music.beat(BeatFraction.Eighth)), music.PlaybackMode.InBackground);
pins.setPull(DigitalPin.P0, PinPullMode.PullDown);
basic.showIcon(IconNames.Heart);

// --- Main Loop ---
basic.forever(function () {
  if (pins.digitalReadPin(DigitalPin.P0) == 1) {
    basic.showIcon(IconNames.Yes);
    serial.writeLine("Touched!");
  } else {
    basic.showIcon(IconNames.SmallDiamond);
  }
  basic.pause(100);
});

//
// Detects touch using a MPR121 capacitive touch sensor — no mechanical button needed.
//
// To use the Microbit with a MPR121 Capacitive Touch chip,
// add the Extensions > search for `github.com/1010Technologies/pxt-makerbit-touch`.
//
// Physical setup:
// MPR121 SDA -> P20
// MPR121 SCL -> P19
// MPR121 VCC -> 3.3V
// MPR121 GND -> GND

// MPR121 has pins to the wire or foil to test with.
// You can attach a wire to the sensor pad to extend the touch area.

/*
Note that the makerbit extension's touch pins did not match my MPR121 breakout board pins
It might be that the makerbit board is wired differently than the MPR121 breakout board

T16	is MPR121 pin 0
T15	is MPR121 pin 1
T14	is MPR121 pin 2
T13	is MPR121 pin 3
T12	is MPR121 pin 4
T11	is MPR121 pin 5
T10	is MPR121 pin 6
T9	is MPR121 pin 7
T8	is MPR121 pin 8
T7	is MPR121 pin 9
T6	is MPR121 pin 10
T5	is MPR121 pin 11

*/

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard);

makerbit.onTouch(TouchSensor.T5, TouchAction.Touched, function () {
  basic.showIcon(IconNames.Yes);
});

makerbit.onTouch(TouchSensor.T5, TouchAction.Released, function () {
  basic.clearScreen();
});

basic.forever(function () {
  if (makerbit.wasTouched()) {
    serial.writeLine("" + makerbit.touchSensor() + " was Touched");
  }
  basic.pause(100);
});

// Skin conduction switch — human skin completes the circuit between two wires.
// No sensor module needed. Works with any two conductive surfaces a person bridges
// with their body: two metal plates, a handle + frame, fruit + foil, etc.
//
// How it works:
//   Capacitive mode with a GND reference wire held by the person.
//   The GND wire stabilizes the person's electric potential, making capacitive
//   detection reliable. TouchMode.Resistive does not work for skin.
//
// Physical setup:
//   Wire 1: micro:bit P0 → conductive surface (what they touch)
//   Wire 2: micro:bit GND → person holds this wire (bare wire, clip, or foil pad)
//   Touching the surface while holding GND triggers the sensor.
//
// Examples:
//   Two metal plates on a desk — bridge with fingertips
//   Door handle (P0) + floor mat (GND) — triggers when person grabs handle
//   Two strips of foil — touch both to trigger

// --- Setup ---
basic.pause(1000);
music.play(music.tonePlayable(988, music.beat(BeatFraction.Eighth)), music.PlaybackMode.InBackground);
basic.showIcon(IconNames.Heart);
pins.touchSetMode(TouchTarget.P0, TouchTargetMode.Capacitive);

// --- Main Loop ---
basic.forever(function () {
  if (input.pinIsPressed(TouchPin.P0)) {
    basic.showIcon(IconNames.Yes);
    serial.writeLine("Touched!");
  } else {
    basic.showIcon(IconNames.SmallDiamond);
  }
  basic.pause(100);
});

// Detects a nearby magnet using a Hall effect magnetic sensor.
// Magnets can be hidden inside objects, behind walls, or under surfaces
// to create invisible triggers — no visible button or switch needed.
//
//
// Hold a magnet close to the sensor face to trigger it.
// Try taping a small magnet to a game piece, box lid, or sliding panel.
//
// Physical setup:
//   Sensor has 3 pins labeled S (signal), V (power), G (ground).
//   Connect S → micro:bit pin 0
//   Connect V → micro:bit 3V
//   Connect G → micro:bit GND
//
// This code is for a sensor that goes low (== 0) when a magnet is present.

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
pins.setPull(DigitalPin.P0, PinPullMode.PullUp); // we set the pin to "PullUp" (Be positive unless it is connected to ground)

// --- Main Loop ---
basic.forever(function () {
  if (pins.digitalReadPin(DigitalPin.P0) == 0) {
    basic.showIcon(IconNames.Yes); //Magnet detected!
  } else {
    basic.clearScreen();
  }
  basic.pause(100);
});

/*
 * Make a LED breathe, Button A slows it down and Button B speeds it up
 */
input.onButtonPressed(Button.A, function () {
  // Button A: slow down (longer pause between steps)
  pauseDuration += 5;
  // keep the pause in bounds
  if (pauseDuration > 200) {
    pauseDuration = 200;
  }
  serial.writeLine("pauseDuration:" + pauseDuration);
});
input.onButtonPressed(Button.B, function () {
  // Button B: speed up (shorter pause between steps)
  pauseDuration += 0 - 5;
  // keep the pause in bounds
  if (pauseDuration < 5) {
    pauseDuration = 5;
  }
  serial.writeLine("pauseDuration:" + pauseDuration);
});

basic.pause(1000); // avoid flash on programming
basic.showIcon(IconNames.Chessboard);
basic.clearScreen();
serial.redirectToUSB();

// --- Setup ---
pins.analogWritePin(AnalogPin.P0, 0); // 0 to 1023

let brightness = 0;
let direction = 1; // +1 brightening, -1 dimming
let pauseDuration = 20; // ms between steps, lower is faster

basic.forever(function () {
  // --- Main Loop ---
  if (brightness >= 1023) {
    direction = -1;
  } else if (brightness <= 0) {
    direction = 1;
  }
  brightness += direction * 25; // fixed step keeps the fade smooth at any speed
  brightness = Math.max(0, Math.min(1023, brightness));
  serial.writeLine("brightness:" + brightness);
  pins.analogWritePin(AnalogPin.P0, brightness);
  basic.pause(pauseDuration);
});

/*
Cycles the colors on a RGB LED module

The RGB module has 4 pins:
  1) Connect to Pin 0 (this controls Red LED)
  2) Connect to Pin 1 (this controls Green LED)
  3) Connect to Pin 2 (this controls Blue LED)
  4) Voltage 3.3v seems to work
*/
// --- Setup ---
basic.pause(1000); // avoid flash on programming
basic.showIcon(IconNames.Chessboard);
basic.clearScreen();
serial.redirectToUSB();

let phaseNames = ["RedToGreen", "GreenToBlue", "BlueToRed"]; // for readable serial logging

let color_wheel_position = 0; // 0-359

basic.forever(function () {
  let phase = Math.floor(color_wheel_position / 120); // which color phase: 0, 1, or 2
  let phase_percent = ((color_wheel_position - 120 * phase) / 120) * 100; // 0-100% progress through this phase

  let red = 0,
    green = 0,
    blue = 0; // the amount of each color 0-99%

  if (phase == 0) {
    // RedToGreen
    green = phase_percent;
    red = 100 - phase_percent;
  } else if (phase == 1) {
    // GreenToBlue
    blue = phase_percent;
    green = 100 - phase_percent;
  } else {
    // BlueToRed
    red = phase_percent;
    blue = 100 - phase_percent;
  }

  // Note: LED pins work inverted — lower analog value = brighter.
  // pins.analogWritePin(AnalogPin.P0, 0)    = fully on
  // pins.analogWritePin(AnalogPin.P0, 1023) = fully off

  pins.analogWritePin(AnalogPin.P0, 1023 - red * (1023 / 100)); // scale color range up to 0-1023 that analog out uses
  pins.analogWritePin(AnalogPin.P1, 1023 - green * (1023 / 100)); // scale color range up to 0-1023 that analog out uses
  pins.analogWritePin(AnalogPin.P2, 1023 - blue * (1023 / 100)); // scale color range up to 0-1023 that analog out uses

  serial.writeLine("ColorPhase:" + phaseNames[phase] + " red:" + Math.round(red) + "% green:" + Math.round(green) + "% blue:" + Math.round(blue) + "%");

  basic.pause(10);
  color_wheel_position = (color_wheel_position + 1) % 360;
});

/*
 * Requires the "neopixel" extension (Extensions > search "microsoft/pxt-neopixel")
 *
 * Sized for a 144-LED WS2812B strip (144 pixels/m, ~1m / 3.2ft length).
 *
 * Wiring: the strip's input end has a 3-pin clip -- Red = +5V, White = GND,
 * Green = Data. These strips often ship with a mini controller (battery or
 * USB box with a button/remote for preset colors) that plugs into this same
 * clip. To drive the strip from the micro:bit instead, unplug that mini
 * controller and wire the clip directly: Green -> micro:bit P0, White ->
 * micro:bit GND, Red -> a separate 5V supply.
 *
 * Power: at full white, 144 pixels can draw up to ~8.6A (60mA each) -- far
 * more than the micro:bit or a USB port supplies. Never power the strip from
 * the micro:bit's 3V pin; use a separate 5V supply rated for the LED count,
 * and make sure its GND is tied to the micro:bit's GND.
 * Data: the micro:bit's 3.3V logic is below the WS2812B's 5V spec. It often
 * works for short runs, but a logic-level shifter (or a ~330-470 ohm resistor
 * on the data line) improves reliability, especially over 1m+ of strip.
 */

basic.pause(1000); // avoid flash on programming
basic.showIcon(IconNames.Chessboard);
basic.clearScreen();
serial.redirectToUSB();

let strip = neopixel.create(DigitalPin.P0, 144, NeoPixelMode.RGB);

strip.setBrightness(40);

basic.forever(function () {
  // rainbow animation
  strip.rotate(1);
  strip.show();
  basic.pause(100);
});

input.onButtonPressed(Button.A, function () {
  strip.showColor(neopixel.colors(NeoPixelColors.Red));
});

input.onButtonPressed(Button.B, function () {
  strip.showColor(neopixel.colors(NeoPixelColors.Blue));
});

input.onGesture(Gesture.Shake, function () {
  strip.showRainbow(1, 360);
  strip.show();
});

/*
Scrolls a text message across a 4-in-1 MAX7219 dot matrix module --
four 8x8 LED matrices on one PCB, chained together into a single 32x8 display.
Button A shows a bouncing dot animation instead; Button B goes back to scrolling text.

MakeCode extension required:
In the MakeCode editor, click "Extensions" and search for "MAX7219", or paste
https://github.com/alankrantas/pxt-MAX7219_8x8

Physical setup:
  The module has 5 pins. It uses SPI, so any digital pins work, but these are the extension's defaults:
  Connect VCC -> micro:bit 3V (or 5V from an external supply -- 4 chained modules draw more than the micro:bit's 3V pin alone)
  Connect GND -> micro:bit GND
  Connect DIN -> micro:bit pin 15 (data in; some modules label this DOUT on the daisy-chain-out side -- use the DIN/CS/CLK side, not the DOUT side)
  Connect CS  -> micro:bit pin 16 (also labeled LOAD)
  Connect CLK -> micro:bit pin 13

  Note: 4-in-1 modules are often wired internally in a different order/orientation than
  four separate matrices chained by hand. This one needed a 90° counter-clockwise
  correction and reversed panel order below (for_4_in_1_modules) to display right-side up
  and in the correct left-to-right order -- if yours still looks wrong, try the other
  rotation_direction values, or set reversed back to false.
*/

basic.pause(1000); // prevent screen flash

const MATRIX_COUNT = 4; // number of 8x8 matrices chained together (32x8 pixels total)

max7219_matrix.setup(
  MATRIX_COUNT,
  DigitalPin.P16, // CS (LOAD)
  DigitalPin.P15, // DIN (MOSI)
  DigitalPin.P14, // MISO, unused but required by the setup block
  DigitalPin.P13, // CLK (SCK)
);
max7219_matrix.for_4_in_1_modules(rotation_direction.counterclockwise, true); // corrects a module that displays rotated 90° clockwise with panels in reverse order

max7219_matrix.brightnessAll(8); // 0 (dim) to 15 (max)

let mode = "scroll"; // "scroll" | "bounce"

input.onButtonPressed(Button.A, function () {
  // Button A: switch to the bouncing dot animation
  mode = "bounce";
});

input.onButtonPressed(Button.B, function () {
  // Button B: switch back to scrolling text
  mode = "scroll";
});

let dotX = 0;
let dotY = 0;
let dotDirX = 1;
let dotDirY = 1;

basic.forever(function () {
  // --- Main Loop ---
  if (mode === "scroll") {
    max7219_matrix.scrollText("Hello world!", 75, 500);
  } else {
    // Bounce a single dot across the full 32x8 area (8 columns per matrix x 4 matrices)
    // Clear the whole chain first so the dot doesn't leave a ghost behind on the panel it just left.
    max7219_matrix.clearAll();
    let matrix = max7219_matrix.getEmptyMatrix();
    max7219_matrix.setValueInMatrix(matrix, dotX % 8, dotY, 1);
    max7219_matrix.displayLEDsForOne(matrix, Math.idiv(dotX, 8));

    dotX += dotDirX;
    dotY += dotDirY;
    if (dotX <= 0 || dotX >= MATRIX_COUNT * 8 - 1) {
      dotDirX = 0 - dotDirX;
    }
    if (dotY <= 0 || dotY >= 7) {
      dotDirY = 0 - dotDirY;
    }
    basic.pause(60);
  }
});

/*
Simple demo of reading soundLevel
input.soundLevel() reads the volume on the built in microphone and gives it a number from 0-255

this can be used as variable, as seen in the forever loop, or an event as seen input.onSound()

The microbit microphone cannot effectively record sound, it is more of a loudness detector
*/

basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
input.setSoundThreshold(SoundThreshold.Loud, 200); // this defines the sound level that is "Loud"

basic.forever(function () {
  led.plotBarGraph(input.soundLevel(), 255);
  basic.pause(100);
});

input.onSound(DetectedSound.Loud, function () {
  // if a sound is "Loud", show an icon
  basic.showIcon(IconNames.Yes);
});

// tangible_interfaces_VU_meter https://makecode.microbit.org/S28568-79057-92892-69857
/*
 * Microbit VU Meter
 *
 * Reads the built-in microphone and displays sound level as a bar graph
 * on the 5×5 LED grid. All five columns show the same bar, so the whole
 * screen acts as one wide meter.
 *
 * Two visual layers:
 *   bar  — follows the live sound level in real time. Drawn at 50% brightness.
 *   peak — jumps up instantly when the bar exceeds it, but falls slowly on a timer.
 *          Drawn at 100% brightness so it stands out above the dimmer bar.
 *
 * The "peak hold" effect is the same technique used in recording-studio VU meters
 * and most phone volume indicators. The slow-falling dot makes it easy to see
 * the loudest recent moment even after the sound has dropped.
 *
 * Button A: decrease input gain (need louder sounds to fill the meter — good for loud rooms)
 * Button B: increase input gain (quieter sounds fill the meter — good for quiet rooms)
 * Press either button to see the current gain level (1–5) scroll across the screen.
 *
 * Hardware: BBC Microbit v2 (built-in microphone required — v1 does not have one)
 *
 * What to expect:
 *   Silence:   all LEDs off
 *   Quiet:     one or two rows lit from the bottom at half brightness
 *   Loud:      tall bar, bright peak dot floating at the top
 *   Very loud: all five rows lit, top row at full brightness
 *
 * Tuning:
 *   Increase PEAK_DECAY_MS to make the peak dot fall more slowly (stickier).
 *   Decrease PEAK_DECAY_MS to make it fall faster (snappier).
 */

// --- Display tuning constants ---
const PEAK_DECAY_MS = 200; // time between each one-row drop of the peak dot (milliseconds)
const BAR_BRIGHTNESS = 128; // bar LED brightness: 128 out of 255 ≈ 50% — deliberately dim
const PEAK_BRIGHTNESS = 255; // peak LED brightness: 255 = 100% — full on, so it stands out

// --- Input gain (sensitivity) ---
// The mic returns 0–255. The gain ceiling sets what counts as "full scale" on the meter.
// Lower ceiling = more sensitive (quieter sounds fill the meter).
// Higher ceiling = less sensitive (only loud sounds fill the meter).
const GAIN_CEILINGS = [255, 200, 155, 100, 50]; // five gain levels; index 0 = quietest, index 4 = loudest
let gainLevel = 2; // default: index 2 = ceiling 155, the middle setting

// --- State variables ---
let barHeight = 0; // current bar height in rows from the bottom (0 = silent, 5 = loudest)
let peakHeight = 0; // highest bar height seen recently, on the same 0–5 scale
let lastDecayTime = 0; // timestamp (ms) of the last peak decay step — used to pace the falling dot

// --- Startup sequence ---
basic.pause(1000); // wait 1 s before starting — avoids the power-on click triggering the meter
basic.showIcon(IconNames.Chessboard); // checkerboard flash: visible proof the program loaded
basic.clearScreen(); // blank the screen before the meter loop begins
lastDecayTime = input.runningTime(); // record the start time so the decay timer has a reference point

// --- Button A: decrease gain (need louder sounds to fill the meter) ---
input.onButtonPressed(Button.A, function () {
  if (gainLevel > 0) {
    // stop at index 0 — already at the lowest gain setting
    gainLevel -= 1; // step down to the next less-sensitive setting
  }
  basic.showNumber(gainLevel + 1); // show current level as 1–5 (more readable than 0–4)
});

// --- Button B: increase gain (quieter sounds fill the meter) ---
input.onButtonPressed(Button.B, function () {
  if (gainLevel < 4) {
    // stop at index 4 — already at the highest gain setting
    gainLevel += 1; // step up to the next more-sensitive setting
  }
  basic.showNumber(gainLevel + 1); // show current level as 1–5
});

// --- Main loop: runs continuously, as fast as the Microbit can ---
basic.forever(function () {
  // ── Step 1: Read the microphone ──────────────────────────────────────────

  let soundLevel = input.soundLevel(); // built-in mic: 0 (silence) → 255 (very loud)

  // Look up the ceiling for the current gain setting
  let ceiling = GAIN_CEILINGS[gainLevel]; // e.g. gainLevel=2 → ceiling=155

  // Map 0–ceiling into 0–5 rows, then clamp to 5 in case soundLevel exceeds ceiling
  // Math.map rescales a number from one range to another
  // Math.floor drops the decimal to give a whole number of rows
  // Math.min prevents the bar from going above the top of the grid when gain is high
  barHeight = Math.min(5, Math.floor(Math.map(soundLevel, 0, ceiling, 0, 5)));

  // ── Step 2: Decay peak before the peak-hold check ────────────────────────
  // Decay runs first so that a simultaneous new sound immediately snaps peak back up

  if (input.runningTime() - lastDecayTime > PEAK_DECAY_MS) {
    // has enough time passed?
    if (peakHeight > 0) {
      // only step down if peak is above the bottom
      peakHeight -= 1; // move peak one row toward the bottom
    }
    lastDecayTime = input.runningTime(); // reset the decay timer
  }

  // ── Step 3: Peak hold — snap up instantly if bar is now above peak ───────

  if (barHeight > peakHeight) {
    peakHeight = barHeight; // bar exceeded peak: snap peak up immediately, no delay
  }

  // After steps 2 and 3, peakHeight is always >= barHeight

  // ── Step 4: Draw the 5×5 grid ────────────────────────────────────────────
  // Loop through every column and row and set each LED individually

  for (let x = 0; x <= 4; x++) {
    // x: column 0 (left edge) → 4 (right edge)
    for (let y = 0; y <= 4; y++) {
      // y: row 0 (top edge) → 4 (bottom edge) — Microbit counts from the top

      // The Microbit counts rows from the top (y=0). A volume meter fills from the bottom.
      // Convert y to "rows from bottom" so row 0 = quiet end, row 4 = loud end.
      let rowFromBottom = 4 - y; // y=4 (bottom LED) → 0;  y=0 (top LED) → 4

      if (peakHeight > 0 && rowFromBottom == peakHeight - 1) {
        // ── Peak dot ────────────────────────────────────────────────
        // This row is the top of where the bar last peaked.
        // Full brightness so the dot stands out above the dimmer bar below it.
        led.plotBrightness(x, y, PEAK_BRIGHTNESS); // 255 = 100% bright
      } else if (rowFromBottom < barHeight) {
        // ── Bar fill ─────────────────────────────────────────────────
        // This row is inside the current bar — between the bottom and the peak.
        led.plotBrightness(x, y, BAR_BRIGHTNESS); // 128 ≈ 50% bright
      } else {
        // ── Off ──────────────────────────────────────────────────────
        // This row is above the bar and not the peak dot — no sound here.
        led.unplot(x, y); // turn this LED off
      }
    }
  }
});

// tangible_interfaces_sound_DJ_LED_animation https://makecode.microbit.org/S34840-21340-44158-76031
/*
 * Beat-reactive smoke ring animation — 16×16 NeoPixel matrix
 *
 * Listens to music on the built-in microphone. Each time the beat crosses
 * a loudness threshold, a colored ring fires from the center of the matrix
 * and expands outward like a smoke ring — bright at the ring edge, fading
 * to black on either side. Two rings are active at once; they alternate
 * slots and can overlap, mixing colors where they cross.
 *
 * Beat detection technique: upward threshold crossing.
 * A kick drum or bass hit causes a sharp spike in overall volume.
 * We watch for the moment the level crosses from below the threshold
 * to above it — that's the beat. A cooldown prevents one hit from
 * firing twice. This works well for dance music at 120 BPM; it is less
 * reliable for jazz or acoustic music with no dominant transient.
 *
 * Hardware:
 *   BTF-LIGHTING WS2812B 16×16 256-pixel matrix, serpentine from top-right
 *   Data line → Microbit P1 (change DATA_PIN below if wired differently)
 *   Power: external 5V supply direct to matrix — do NOT power from USB alone
 *   Note: Microbit outputs 3.3V; WS2812B spec is 3.5V minimum. This usually
 *   works in practice. If the matrix behaves erratically, add a 74AHCT125
 *   level shifter between P1 and the matrix data line.
 *
 * NeoPixel extension required — add via MakeCode Extensions menu.
 *
 * Tuning:
 *   BEAT_THRESHOLD — raise if false triggers in a noisy room; lower if beats are missed
 *   RING_SPEED     — higher = faster expansion
 *   RING_WIDTH     — higher = wider, softer ring edge
 */

// --- Hardware configuration ---
const DATA_PIN = DigitalPin.P1; // change this if your data wire is on a different pin
const NUM_PIXELS = 256; // 16 × 16 matrix
const MATRIX_W = 16; // pixels across
const MATRIX_H = 16; // pixels tall

// --- Beat detection ---
const BEAT_THRESHOLD = 180; // sound level (0–255) that counts as a beat — raise if noisy room
const BEAT_COOLDOWN_MS = 250; // minimum ms between beats — prevents one kick from firing twice

// --- Ring animation ---
const RING_SPEED = 0.02; // expansion speed in pixels per millisecond — ring reaches edge in ~550ms
const RING_WIDTH = 1.8; // falloff distance in pixels — controls how wide/soft the ring edge is
const MAX_RADIUS = 11; // distance from center to corner: sqrt(7.5²+7.5²) ≈ 10.6, rounded up

// --- NeoPixel matrix setup ---
let matrix = neopixel.create(DATA_PIN, NUM_PIXELS, NeoPixelMode.RGB); // RGB mode handles GRB wire order internally
matrix.setBrightness(128); // global brightness cap at 50% — full white at 256 pixels needs serious current

// --- Pre-compute distance from center for every pixel (done once at startup) ---
// Avoids calling Math.sqrt() 256 times every frame
// Indexed by wire pixel index (accounting for serpentine layout)
let distTable: number[] = [];

for (let y = 0; y < MATRIX_H; y++) {
  for (let x = 0; x < MATRIX_W; x++) {
    // Serpentine layout starting at top-right:
    // even rows run right→left, odd rows run left→right
    let wireIndex = y % 2 == 0 ? y * 16 + (15 - x) : y * 16 + x;

    let dx = x - 7.5; // offset from center (center falls between pixels 7 and 8)
    let dy = y - 7.5;
    distTable[wireIndex] = Math.sqrt(dx * dx + dy * dy); // Euclidean distance from center
  }
}

// --- Ring state — two ring slots, alternated on each beat ---
let ringActive = [false, false]; // is this ring slot currently expanding?
let ringStartTime = [0, 0]; // ms timestamp when this ring was fired
let ringHue = [0, 128]; // color of each ring (0–255 hue wheel); starts on red and cyan

let nextRingSlot = 0; // which slot to fire next (alternates 0 → 1 → 0 → ...)
let nextHue = 0; // hue assigned to the next beat (advances around the color wheel)

// --- Beat detection state ---
let prevSoundLevel = 0; // previous mic reading — needed to detect upward threshold crossing
let lastBeatTime = 0; // ms timestamp of the last detected beat

// --- Startup sequence ---
basic.pause(1000); // brief delay — avoids the power-on click triggering a false beat
basic.showIcon(IconNames.Chessboard); // visible confirmation the program loaded
basic.clearScreen(); // blank the Microbit display before the main loop

// --- Main loop ---
basic.forever(function () {
  let now = input.runningTime(); // current time in ms — used for ring age and beat cooldown
  let level = input.soundLevel(); // built-in mic: 0 (silence) → 255 (loud)

  // ── Beat detection ────────────────────────────────────────────────────────
  // Fire on the upward crossing: level just jumped above BEAT_THRESHOLD
  // The cooldown prevents the same hit from triggering twice
  if (level > BEAT_THRESHOLD && prevSoundLevel <= BEAT_THRESHOLD && now - lastBeatTime > BEAT_COOLDOWN_MS) {
    ringActive[nextRingSlot] = true; // activate this ring slot
    ringStartTime[nextRingSlot] = now; // record when it fired
    ringHue[nextRingSlot] = nextHue; // assign the current hue

    nextRingSlot = (nextRingSlot + 1) % 2; // flip to the other slot for next beat
    nextHue = (nextHue + 43) % 256; // advance hue ~60° around the wheel (43/256 ≈ 60°/360°)
    lastBeatTime = now; // reset the cooldown timer
  }
  prevSoundLevel = level; // store this reading for next frame's crossing check

  // ── Draw every pixel ──────────────────────────────────────────────────────
  // For each pixel, sum the color contributions from both ring slots
  for (let i = 0; i < NUM_PIXELS; i++) {
    let dist = distTable[i]; // pre-computed distance from center for this pixel

    let r = 0; // accumulated red channel (0–255, may temporarily exceed)
    let g = 0; // accumulated green channel
    let b = 0; // accumulated blue channel

    // Add contribution from each ring slot
    for (let ri = 0; ri < 2; ri++) {
      if (!ringActive[ri]) {
        // skip inactive ring slots
        continue;
      }

      let age = now - ringStartTime[ri]; // how long this ring has been expanding (ms)
      let radius = age * RING_SPEED; // current radius in pixels

      if (radius > MAX_RADIUS) {
        // ring has expanded past the corners
        ringActive[ri] = false; // deactivate — it's off-screen
        continue;
      }

      // Falloff: brightness peaks at the ring edge, drops to zero at RING_WIDTH pixels away
      let diff = Math.abs(dist - radius); // how far this pixel is from the ring edge
      let edgeFalloff = Math.max(0, 1 - diff / RING_WIDTH); // 1.0 at ring edge, 0 at RING_WIDTH away

      // Overall fade: ring starts at full brightness and dims as it expands toward the edges
      let expansionFade = Math.max(0, 1 - radius / MAX_RADIUS); // 1.0 at center, 0.0 at MAX_RADIUS

      let brightness = edgeFalloff * expansionFade; // combine both fades

      // Convert this ring's hue to RGB and scale by brightness
      let color = hueToRgb(ringHue[ri]); // full-saturation RGB for this hue
      r += ((color >> 16) & 0xff) * brightness; // red channel contribution
      g += ((color >> 8) & 0xff) * brightness; // green channel contribution
      b += (color & 0xff) * brightness; // blue channel contribution
    }

    // Clamp each channel to 255 and set the pixel
    // Using Math.min instead of bitwise clamp for clarity
    matrix.setPixelColor(i, neopixel.rgb(Math.min(255, Math.round(r)), Math.min(255, Math.round(g)), Math.min(255, Math.round(b))));
  }

  matrix.show(); // push all 256 pixel values to the matrix (~8ms wire transmission time)
});

// --- Convert hue (0–255) to a packed RGB color at full saturation and brightness ---
// The hue wheel is divided into 6 sectors; one primary channel rises or falls linearly in each sector
function hueToRgb(hue: number): number {
  let h = hue % 256; // keep hue in range (handles any accumulated overflow)
  let sector = Math.idiv(h * 6, 256); // which 1/6 of the wheel: 0=red, 1=yellow, 2=green, 3=cyan, 4=blue, 5=magenta
  let offset = (h * 6) % 256; // position within that sector (0–255)

  switch (sector) {
    case 0:
      return neopixel.rgb(255, offset, 0); // red → yellow
    case 1:
      return neopixel.rgb(255 - offset, 255, 0); // yellow → green
    case 2:
      return neopixel.rgb(0, 255, offset); // green → cyan
    case 3:
      return neopixel.rgb(0, 255 - offset, 255); // cyan → blue
    case 4:
      return neopixel.rgb(offset, 0, 255); // blue → magenta
    default:
      return neopixel.rgb(255, 0, 255 - offset); // magenta → red
  }
}

// tangible_interfaces_frequency_generate


basic.pause(1000);
basic.showIcon(IconNames.Chessboard); // --- Startup indicator ---
basic.clearScreen();

basic.forever(function () {
  // Ode to Joy — stays within C4–B4, so the detector can recognize every note
  music.play(music.stringPlayable("E4 E4 F4 G4 G4 F4 E4 D4 C4 C4 D4 E4 E4 D4 D4", 120), music.PlaybackMode.UntilDone);
  basic.pause(1000); // pause between repeats so the detector can reset
});

// tangible_interfaces_frequency_detect

/*
 * Tone Detector
 * This program enables the microbit to use an electret microphone sensor to recognize a simple note frequency
 * produced by another microbit — One Octave (C4 to B4).
 *
 * This demonstrates one simple technique of using math to identify which frequency is playing.
 * Classic arcade tunes are made with simple "square waves" (simple, pure frequencies).
 * This technique will not work on music or even singing, as the multiple frequencies
 * are too complex. Fast Fourier Transform is the mathematical approach, but it requires more computing power
 * than the microbit has. A Raspberry Pi or any computer or phone has a fast enough chip.
 *
 * The microbit is not fast enough to do those calculations, so we use a
 * trick, zero-crossing frequency detection. Sound is a back and forth wave, like AC power.
 * Sometimes it is positive, sometimes negative.
 *
 * A square wave tone is sound waves moving back and forth extremely regularly.
 * Each time the signal crosses the midpoint, half a cycle has passed.
 * Measuring the time between crossings gives us the frequency.
 *
 * When we convert the microphone AC signal from the analog to digital pin (ADC),
 * silence on the ADC reads as ~512 (the midpoint of 0–1023).
 * The positive half of the wave gets set from 513 to 1023,
 * the negative half of the wave gets set from 511 to 0.
 * So we just count each time the ADC reading is on either side of silence.
 * But remember, the readings will not be exact!
 *
 * A "Schmitt trigger" uses two thresholds instead of one. The signal
 * must swing past MID+margin before it counts as "high," and past
 * MID−margin before it counts as "low." This ignores small wiggles
 * near the midpoint that would otherwise create false crossings.
 * The margin auto-scales to however loud the signal actually is.
 *
 * Each iteration: collect crossings for 500ms (Phase 1), then decide
 * whether the crossings were consistent enough to name a note (Phase 2).
 * Consistent half-periods = real tone. Scattered half-periods = noise.
 *
 * What to expect:
 *   Silence:         LED is dark,   serial shows "-"
 *   Noise:           LED shows X,   serial shows "X"
 *   Recognized tone: LED shows letter (C D E F G A B)
 *
 * Tuning:
 *   Watch the serial output. If you get false detections in a noisy room,
 *   lower MAX_SPREAD_MICROS or raise MIN_CROSSINGS.
 *
 * Hardware:
 *   Connect an electret microphone module (e.g. MAX9814) to P0:
 *     VCC → 3V    GND → GND    OUT → P0
 *
 *   If you are having trouble with two microbits generating & recognizing tones,
 *   wire the two microbits GNDs together to eliminate one common error.
 */

basic.pause(1000); // Start up pause to avoid flash
basic.showIcon(IconNames.Chessboard); // Startup indicator
basic.clearScreen();

// --- Tuning constants ---
const MIDPOINT = 512; // ADC center: silence reads here
const WINDOW_MS = 500; // how long each collect phase runs (milliseconds)
const MIN_CROSSINGS = 20; // minimum crossings to trust the result
const MAX_SPREAD_MICROS = 250; // if half-periods vary more than this (µs), it's noise
const MIN_HALF_PERIOD_US = 800; // shorter than this = above B4; reject
const MAX_HALF_PERIOD_US = 2500; // longer than this = below C4; reject
const MIN_SCHMITT_MARGIN = 30; // floor for the Schmitt hysteresis band
const MAX_SILENCE_AMPLITUDE = 60; // peak-to-peak below this = silence, not noise

// --- Accumulators — reset at the start of every collect window ---
let periodSum = 0; // running total of all measured half-periods (µs)
let periodCount = 0; // how many valid half-periods collected this window
let minPeriod = 999999; // shortest half-period seen (used to compute spread)
let maxPeriod = 0; // longest half-period seen (used to compute spread)
let peakMin = MIDPOINT; // lowest ADC sample seen (used to auto-scale Schmitt margin)
let peakMax = MIDPOINT; // highest ADC sample seen (used to auto-scale Schmitt margin)
let schmittAbove = false; // true = signal is currently above the high threshold
let lastCrossingTime = 0; // 0 means "no crossing seen yet this window"

function recordCrossing(): void {
  // --- Record one zero-crossing and measure the half-period ---
  let now = control.micros();
  if (lastCrossingTime === 0) {
    lastCrossingTime = now; // first crossing — just start the clock
  } else {
    let halfPeriod = now - lastCrossingTime;
    // Ignore crossings outside the frequency range we care about
    if (halfPeriod > MIN_HALF_PERIOD_US && halfPeriod < MAX_HALF_PERIOD_US) {
      periodSum += halfPeriod;
      periodCount++;
      if (halfPeriod < minPeriod) minPeriod = halfPeriod;
      if (halfPeriod > maxPeriod) maxPeriod = halfPeriod;
    }
    lastCrossingTime = now;
  }
}

basic.forever(function () {
  // --- Main loop: collect, then analyze, repeat ---

  // ── Phase 1: Collect crossings for WINDOW_MS milliseconds ────────────────

  periodSum = 0;
  periodCount = 0;
  minPeriod = 999999;
  maxPeriod = 0;
  peakMin = 1023;
  peakMax = 0;
  schmittAbove = false;
  lastCrossingTime = 0;

  let windowStart = control.millis();

  while (control.millis() - windowStart < WINDOW_MS) {
    // this is a very fast loop. The basic.forever has a built in 50ms pause which would prevent this technique from working
    let sample = pins.analogReadPin(AnalogPin.P0);

    // Track the signal's swing so the Schmitt margin adapts to loudness
    if (sample < peakMin) peakMin = sample;
    if (sample > peakMax) peakMax = sample;

    let dynamicMid = Math.round((peakMax + peakMin) / 2);
    let margin = Math.round((peakMax - peakMin) / 4);
    if (margin < MIN_SCHMITT_MARGIN) margin = MIN_SCHMITT_MARGIN;

    // Schmitt trigger: count crossings only on full swings past the band
    if (!schmittAbove && sample >= dynamicMid + margin) {
      schmittAbove = true; // signal swung up past high threshold
      recordCrossing();
    } else if (schmittAbove && sample <= dynamicMid - margin) {
      schmittAbove = false; // signal swung down past low threshold
      recordCrossing();
    }
    basic.pause(0); // this micro pause allows other event types like button presses
  }

  // ── Phase 2: Analyze and display ─────────────────────────────────────────

  let spread = maxPeriod - minPeriod; // how much the half-periods varied — low = consistent tone, high = noise

  if (periodCount >= MIN_CROSSINGS && spread < MAX_SPREAD_MICROS) {
    // Half-periods are plentiful and consistent: confident it's a real tone
    let avgHalfPeriod = Math.round(periodSum / periodCount);
    let frequency = Math.round(500000 / avgHalfPeriod); // µs half-period → Hz

    // --- Return note closest to frequency ---

    const NOTE_NAMES = ["C", "D", "E", "F", "G", "A", "B"]; // --- Note table: one octave, C4 to B4 ---
    const NOTE_FREQS = [262, 294, 330, 349, 392, 440, 494]; // Hz

    let bestIndex = 0;
    let bestDistance = Math.abs(frequency - NOTE_FREQS[0]);

    for (let i = 1; i < NOTE_FREQS.length; i++) {
      let dist = Math.abs(frequency - NOTE_FREQS[i]);
      if (dist < bestDistance) {
        bestDistance = dist;
        bestIndex = i;
      }
    }

    let noteName = NOTE_NAMES[bestIndex];

    basic.showString(noteName);
    serial.writeLine(noteName + "  " + frequency + " Hz  crossings=" + periodCount + "  spread=" + spread + " µs");
  } else {
    let amplitude = peakMax - peakMin;
    if (amplitude < MAX_SILENCE_AMPLITUDE) {
      // Signal barely moved — silence
      basic.clearScreen();
      serial.writeLine("-  amp=" + amplitude);
    } else {
      // Signal was loud but periods were inconsistent — noise
      basic.showIcon(IconNames.No);
      serial.writeLine("X  crossings=" + periodCount + "  spread=" + spread + "  amp=" + amplitude);
    }
  }

  // end of very fast cycle, take a breath, finish forever loop
});

// In MakeCode, open Extensions and paste this URL to add the extension:
//   https://github.com/RBilsland/pxt-bluetooth-midi
// It is a fork of microsoft/pxt-bluetooth-midi that builds for the micro:bit V2 and adds macOS support.

/*
Turn the micro:bit into a wireless musical instrument.

The micro:bit advertises itself as a Bluetooth Low Energy MIDI device. A phone or
laptop connects to it and receives note-on / note-off messages, the same language
a USB keyboard controller speaks. No audio travels over Bluetooth, only the
instructions "start this note" and "stop this note". The sound is produced on the
computer by whatever synth or app is listening, such as a GarageBand software
instrument.

The Bluetooth MIDI service starts on its own when the program boots. There is no
start-service call to make.

WHAT THIS PROGRAM DOES
- Button A held: play note A (C). Release to stop.
- Button B held: play note B (G, a fifth above C).
- Both buttons held: play a chord. Each new press steps through a four-chord
  progression in C major (C, G, A minor, F), the I-V-vi-IV pattern behind
  countless pop songs.
- Tilt left or right while anything is sounding: bend the pitch down or up.
- Screen shows a small heart while waiting, a full heart once a device connects.

PLATFORM SUPPORT
- The RBilsland fork builds for both the micro:bit V1 and V2. (The original Microsoft extension is V1 only and crashes on a V2 board.)

CONNECT ON macOS
- Open Audio MIDI Setup, found in Applications, then Utilities.
- From the Window menu choose Show MIDI Studio, then click the Bluetooth icon.
- Click Connect next to the "uBit" entry.
- Open GarageBand, create a project, add a Software Instrument track like piano, if not already there
- The Microbit will play notes in that instrument.

CONNECT ON iOS
- Connect from inside a GarageBand: tap the settings icon, then Advanced, then Bluetooth MIDI Devices, then tap the "uBit" entry

- Android: works with a scanner app such as nRF Connect.
- Windows: needs a separate BLE MIDI bridge app; not covered here.


PAIRING
- In MakeCode project settings, set Bluetooth pairing to "No Pairing Required" or "JustWorks"
*/

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard); // waiting for a connection

// A MIDI channel is one instrument voice. Channel 1, set to General MIDI
// program 1, Acoustic Grand Piano. Programs run 1 to 128: 25 is nylon guitar,
// 57 is trumpet, 82 is a synth lead.
let instrument = midi.channel(1);
instrument.setInstrument(1);

// MIDI note numbers: 60 is middle C. Adding 1 is one semitone, adding 12 is one
// octave.
const NOTE_A = 60; // C4, played by button A
const NOTE_B = 67; // G4, played by button B

// Each chord is a list of MIDI notes played together. A press of both buttons
// plays the next one and wraps around to the start.
const PROGRESSION = [
  [60, 64, 67], // C  major   (I)
  [67, 71, 74], // G  major   (V)
  [57, 60, 64], // A  minor   (vi)
  [53, 57, 60], // F  major   (IV)
];
let chordStep = 0;

const BEND_CENTER = 8192; // pitch bend is 14-bit, 0 to 16383, center is 8192

// The notes currently sounding, so they can be turned off later.
let sounding: number[] = [];

function silence() {
  for (let n of sounding) instrument.noteOff(n);
  sounding = [];
}

// Stop whatever is playing, then strike a fresh set of notes. Restriking every
// time means a button press always sounds, even when the note was part of the
// chord that came before it.
function playNotes(next: number[]) {
  silence();
  for (let n of next) instrument.noteOn(n);
  sounding = next;
}

bluetooth.onBluetoothConnected(function () {
  basic.showIcon(IconNames.Heart);
});

bluetooth.onBluetoothDisconnected(function () {
  basic.showIcon(IconNames.SmallHeart);
  silence(); // drop any note left hanging when the link breaks
});

// Remember last loop's buttons so notes and screen only change on a real press
// or release, not on every loop.
let prevA = false;
let prevB = false;

basic.forever(function () {
  let a = input.buttonIsPressed(Button.A);
  let b = input.buttonIsPressed(Button.B);

  if (a != prevA || b != prevB) {
    //prevA/prevB prevents re-triggering every 20 ms.
    if (a && b) {
      // both buttons: play the current chord, then advance the progression
      playNotes(PROGRESSION[chordStep]);
      led.plotBarGraph(chordStep + 1, PROGRESSION.length); // 1 to 4 bars, instant
      chordStep = (chordStep + 1) % PROGRESSION.length;
    } else if (a) {
      playNotes([NOTE_A]);
      basic.clearScreen();
      led.plot(0, 2); // left dot
    } else if (b) {
      playNotes([NOTE_B]);
      basic.clearScreen();
      led.plot(4, 2); // right dot
    } else {
      silence();
      basic.clearScreen();
    }
    prevA = a;
    prevB = b;
  }

  // Tilt bends the pitch of whatever is sounding. A flat, still micro:bit sits
  // at the center value, so a resting instrument stays in tune.
  if (sounding.length > 0) {
    // acceleration on X runs about -1023 tilted left to 1023 tilted right
    let tilt = input.acceleration(Dimension.X);
    let bend = Math.constrain(BEND_CENTER + Math.round(tilt * 4), 0, 16383);
    instrument.pitchBend(bend);
  } else {
    instrument.pitchBend(BEND_CENTER);
  }

  basic.pause(20);
});

/* Reference
https://support.microbit.org/support/solutions/articles/19000053392-how-do-i-play-a-midi-instrument-on-the-micro-bit
http://www.multiwingspan.co.uk/micro.php?page=midi
*/

/*
A basic demo of servo movement
Sweeps a servo motor back and forth from 0 to 180 degrees continuously.

NOTE if writing a new microbit program, go to Extensions and search for "Servo" and add it.

Physical setup for typical microservo
They typically come with a 3 wire ribbon
Orange wire → micro:bit pin 0
Red wire → micro:bit 3V
Brown wire→ micro:bit GND
*/

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard);

servos.P0.setRange(0, 180);
let direction = 1;
let angle = 0;
basic.clearScreen();

basic.forever(function () {
  // --- Main Loop ---
  if (angle > 180 || angle < 0) {
    direction = direction * -1;
  }
  angle += direction;
  servos.P0.setAngle(angle);
  serial.writeValue("angle", angle);
});

// A simple demo: steers a servo motor with buttons A and B.

let rotation = 100; //
servos.P1.setRange(0, 180);

basic.forever(function () {
  // --- Main Loop ---
  servos.P1.setAngle(rotation);
  basic.pause(200);
});

input.onButtonPressed(Button.A, function () {
  // Button A moves the servo clockwise

  if (rotation < 180) {
    rotation += 10;
  }
});

input.onButtonPressed(Button.B, function () {
  // Button B moves the servo counter clockwise
  if (rotation > 0) {
    rotation += -10;
  }
});

/*
Servo steered by an Analog Sensor
The basic potentiometer module (rotational varible resistor) is an intuitive control
What other input might you use?
See the Sonar Servo demos)

No extensions required — uses built-in micro:bit blocks only.

Physical setup:

Analog sensor
S pin to Microbit Pin 0
V pin to Voltage
G pin to Ground

Servo
Orange Wire to Microbit Pin 1
Red Wire to voltage
Brown Wire to Ground
*/

basic.pause(1000); // prevent LED flash when programming
basic.showIcon(IconNames.Chessboard); // --- Setup ---
serial.redirectToUSB();

basic.forever(function () {
  // --- Main Loop ---
  let servo = Math.map(pins.analogReadPin(AnalogReadWritePin.P0), 0, 1023, 0, 180);
  led.plotBarGraph(servo, 180);
  pins.servoWritePin(AnalogPin.P1, servo);
  serial.writeLine("" + servo);
});

/*
  Flex Sensor — Finger Bend to Servo Gripper
  Reads a flex sensor on Pin P0.
  Maps finger bend to a servo on Pin P1.
  Straight finger = open gripper (0°). Bent finger = closed gripper (180°).

  Wiring:
    - Flex sensor: one end to 3.3V, other end to P0 
  - 47kΩ resistor one end to P0 , other end to GND
  - Servo: orange → P1, red → 3.3V, brown → GND
*/

basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
serial.redirectToUSB();

// Calibrate first: bend and straighten your finger while watching serial output.
// Set these to match your actual readings.
const FLEX_STRAIGHT = 700; // reading when finger is straight (sensor flat)
const FLEX_BENT = 300; // reading when finger is fully bent

basic.forever(function () {
  let flexReading = pins.analogReadPin(AnalogPin.P0);

  let servoAngle = Math.map(flexReading, FLEX_STRAIGHT, FLEX_BENT, 0, 180); //convert the current value in the range of FLEX_STRAIGHT to FLEX_BENT, map it to the servo range
  servoAngle = Math.max(0, Math.min(180, servoAngle)); // limit values to safe range for servo

  pins.servoWritePin(AnalogPin.P1, servoAngle);
  led.plotBarGraph(flexReading, 1023);
  serial.writeLine("flex: " + flexReading + " | servo: " + Math.round(servoAngle));
  basic.pause(50);
});

/*
  Flex Sensor with Smoothing — Finger Bend to Servo Gripper
  Reads a flex sensor on Pin P0, applies moving average smoothing,
  maps smoothed finger bend to a servo on Pin P1.
  Straight finger = open gripper (0°). Bent finger = closed gripper (180°).

  Wiring:
    - Flex sensor: one end to 3.3V, other end to P0
    - 47kΩ resistor: one end to P0, other end to GND
    - Servo: orange → P1, red → 3.3V, brown → GND

  HOW TO CALIBRATE:
    Run the sensor and watch "raw" in the serial output.
    Hold finger straight → note the value → set FLEX_STRAIGHT
    Bend finger fully → note the value → set FLEX_BENT
*/

basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
serial.redirectToUSB();

// --- Calibration (update after observing your sensor) ---
const FLEX_STRAIGHT = 700; // reading when finger is straight
const FLEX_BENT = 300;     // reading when finger is fully bent

// --- Moving Average Setup ---
let readings_history: number[] = [];
const readings_history_size = 3; // lower = more responsive, higher = smoother
/*
  2–3 = responsive, good for servo control
  5   = smooth balance (try this if servo feels jittery)
  10  = very smooth, but lags behind fast bends
*/

const FLEX_MIN = Math.min(FLEX_BENT, FLEX_STRAIGHT);
const FLEX_MAX = Math.max(FLEX_BENT, FLEX_STRAIGHT);
let midpoint = Math.round((FLEX_MIN + FLEX_MAX) / 2);
for (let i = 0; i < readings_history_size; i++) {
  readings_history.push(midpoint);
}

// --- Output Variables ---
let raw_sensor_value = 0;
let smoothed_value = midpoint;
let servoAngle = 0;

// --- Main Loop ---
basic.forever(function () {
  raw_sensor_value = pins.analogReadPin(AnalogPin.P0);

  // Step 1: Range filter — ignore readings outside the calibrated sensor range
  if (raw_sensor_value < FLEX_MIN || raw_sensor_value > FLEX_MAX) {
    serial.writeLine("raw=" + raw_sensor_value + "  [out of range, skipping]");
    return;
  }

  // Step 2: Moving average — add new reading, drop oldest
  readings_history.push(raw_sensor_value);
  if (readings_history.length > readings_history_size) {
    readings_history.shift();
  }
  let sum = 0;
  for (let i = 0; i < readings_history.length; i++) {
    sum += readings_history[i];
  }
  smoothed_value = Math.round(sum / readings_history.length);

  // Step 3: Map smoothed value to servo angle
  servoAngle = Math.map(smoothed_value, FLEX_STRAIGHT, FLEX_BENT, 0, 180);
  servoAngle = Math.max(0, Math.min(180, servoAngle));

  pins.servoWritePin(AnalogPin.P1, servoAngle);
  led.plotBarGraph(smoothed_value, 1023);
  serial.writeLine("raw=" + raw_sensor_value + "  smoothed=" + smoothed_value + "  servo=" + Math.round(servoAngle));

  basic.pause(50);
});

/*
Controls a fan module — a small motor with a propeller that blows air.
The microbit pins are not strong enough to power the motor
so the module has a L9110, a small chip common for controlling motors

Button A turns the fan forwards
Button B turns it reverse
Touch Logo stops fan

Physical setup:
  Fan module has 4 pins: INA, INB, VCC, GND.
  Connect INA → micro:bit pin 0
  Connect INB → micro:bit pin 1
  Connect VCC → micro:bit Voltage  
  Connect GND → micro:bit GND

  The fan may be very weak using just microbit power
  you may want to use additional battery power
*/

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
pins.digitalWritePin(DigitalPin.P0, 0); // Make sure fan starts off
pins.digitalWritePin(DigitalPin.P1, 0); // Make sure fan starts off

input.onButtonPressed(Button.A, function () {
  // Button A: turn fan on
  pins.digitalWritePin(DigitalPin.P0, 1);
  pins.digitalWritePin(DigitalPin.P1, 0);
  basic.showArrow(ArrowNames.West);
  serial.writeLine("Fan forwards");
});

input.onButtonPressed(Button.B, function () {
  // Button B: turn fan off
  pins.digitalWritePin(DigitalPin.P0, 0);
  pins.digitalWritePin(DigitalPin.P1, 1);
  basic.showArrow(ArrowNames.East);
  serial.writeLine("Fan backwards");
});

input.onLogoEvent(TouchButtonEvent.Pressed, function () {
  // Stop Fan
  pins.digitalWritePin(DigitalPin.P0, 0);
  pins.digitalWritePin(DigitalPin.P1, 0);
  basic.showIcon(IconNames.No);
  serial.writeLine("Fan stop");
});

/*
Controls a fan module — a small motor with a propeller that blows air.
The microbit pins are not strong enough to power the motor
so the module has a L9110, a small chip common for controlling motors

Button A reduces the speed, even going backwards
Button B increases the speed
Touch Logo stops fan

Physical setup:
  Fan module has 4 pins: INA, INB, VCC, GND.
  Connect INA → micro:bit pin 0
  Connect INB → micro:bit pin 1
  Connect VCC → micro:bit Voltage  
  Connect GND → micro:bit GND

  The fan may be very weak using just microbit power
  you may want to use additional battery power
*/

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
pins.digitalWritePin(DigitalPin.P0, 0); // Make sure fan starts off
pins.digitalWritePin(DigitalPin.P1, 0); // Make sure fan starts off
let speed = 0; // speed can go from -100  to +100
let speedIncrement = 10; // how much we change the speed each button click

input.onButtonPressed(Button.A, function () {
  // Button A: decrease the fan speed
  speed -= speedIncrement; // reduce one increment of speed
  if (speed < -100) speed = -100; // keep the speed in bounds
  changeSpeed();
  basic.showArrow(ArrowNames.South);
  serial.writeLine("Fan- speed=" + speed);
});

input.onButtonPressed(Button.B, function () {
  // Button A: increase the fan speed
  speed += speedIncrement; // increase one increment of speed
  if (speed > 100) speed = 100; // keep the speed in bounds
  changeSpeed();
  basic.showArrow(ArrowNames.North);
  serial.writeLine("Fan+ speed=" + speed);
});

input.onLogoEvent(TouchButtonEvent.Pressed, function () {
  // Stop Fan
  speed = 0;
  changeSpeed();
  serial.writeLine("Fan stop");
});

function changeSpeed() {
  // briefly stop the pins (so fast no one will notice!).
  // This is to prevent the motor from trying to go both ways

  pins.digitalWritePin(DigitalPin.P0, 0); // turn off the pin
  pins.digitalWritePin(DigitalPin.P1, 0); // turn off the pin

  let analogSpeed = Math.map(Math.abs(speed), 0, 100, 0, 1023); // convert speed variable into a output value

  if (speed > 0) {
    pins.analogWritePin(AnalogPin.P0, analogSpeed);
  } else if (speed < 0) {
    pins.analogWritePin(AnalogPin.P1, analogSpeed);
  }
}

/*
Controls a relay module — an electrically operated switch that can turn
real-world devices on and off. You'll hear a satisfying "click" when it switches.
A relay lets your micro:bit control things like lamps, fans, or motors
that need more power than the micro:bit can provide directly.

PLEASE be extremely careful if you are using higher voltage components!!!

Button A turns the relay on (click!), Button B turns it off.
Digital write: 1 = relay ON (closed circuit), 0 = relay OFF (open circuit).

Physical setup:
Relay module has 3 low-voltage pins: S (signal), V (power), G (ground).
Connect S → micro:bit pin 0
Connect V → micro:bit 3V
Connect G → micro:bit GND

The relay also has screw terminals for the high-voltage side:
COM (common), NO (normally open), NC (normally closed).
For basic testing, just listen for the click — no need to wire the screw terminals.
To control a device: wire it through COM and NO so it turns on when the relay activates.
*/

// --- Setup ---
basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
pins.digitalWritePin(DigitalPin.P0, 0);

// --- Event Handlers ---
input.onButtonPressed(Button.A, function () {
  // Button A: turn relay on
  pins.digitalWritePin(DigitalPin.P0, 1);
  basic.showIcon(IconNames.Yes);
  serial.writeLine("Relay ON");
});

input.onButtonPressed(Button.B, function () {
  // Button B: turn relay off
  pins.digitalWritePin(DigitalPin.P0, 0);
  basic.showIcon(IconNames.No);
  serial.writeLine("Relay OFF");
});

/*
Reads an analog sensor on pin P0
Displays the value as a bar graph on the LED screen
Send the raw value and percentage to the computer.
*/

basic.pause(1000); // Start up
basic.showIcon(IconNames.Chessboard);
let AnalogReading = 0;

basic.forever(function () {
  // --- Main Loop ---
  AnalogReading = pins.analogReadPin(AnalogPin.P0);
  led.plotBarGraph(AnalogReading, 1023);
  serial.writeLine("Analog Reading " + AnalogReading + "|" + Math.round(Math.map(AnalogReading, 0, 1023, 0, 99)) + "%");
  basic.pause(100);
});

/*
Reads a thin-film pressure (force) sensor and displays how hard you're pressing.
Unlike a button (on/off), this sensor gives an analog value — it knows HOW MUCH
force is applied. Squeeze harder = higher reading.
Use cases: squeeze toys, sit-on sensors, footstep detection, grip strength.

Physical setup:
Sensor has 3 pins labeled S (signal), V (power), G (ground).
Connect S → micro:bit pin 0
Connect V → micro:bit 3V
Connect G → micro:bit GND
Press the round film area with your finger to see values change.
*/

basic.pause(1000); // Start up
basic.showIcon(IconNames.Chessboard);
let forceReading = 0;

basic.forever(function () {
  // --- Main Loop ---

  forceReading = pins.analogReadPin(AnalogPin.P0);
  led.plotBarGraph(forceReading, 1023);
  serial.writeLine("forceReading " + forceReading + "|" + Math.round(Math.map(forceReading, 0, 1023, 0, 99)) + "%");
  basic.pause(100);
});

/*
 Reads an analog joystick and displays x and y position as a dot on the LED screen.
 Pressing the joystick button plays a sound.

 Wiring: Y direction → pin 0, X direction → pin 1, Switch → pin 2
 MAP scales the 0-1023 input to 0-4 (pixel positions on the LED grid)
 ROUND converts to whole numbers for LED coordinates
 Digital read pin 2: 1 = button clicked
*/

basic.pause(1000); // Start up
serial.redirectToUSB();
basic.showIcon(IconNames.Chessboard);
let Y = 0;
let X = 0;

// --- Main Loop ---
basic.forever(function () {
  basic.clearScreen();
  X = Math.round(Math.map(pins.analogReadPin(AnalogReadWritePin.P1), 0, 1023, 4, 0));
  Y = Math.round(Math.map(pins.analogReadPin(AnalogReadWritePin.P2), 0, 1023, 0, 4));
  if (pins.digitalReadPin(DigitalPin.P0) == 1) {
    music.play(
      music.createSoundExpression(WaveShape.Sine, 5000, 0, 255, 0, 500, SoundExpressionEffect.None, InterpolationCurve.Linear),
      music.PlaybackMode.InBackground,
    );
    basic.showIcon(IconNames.SmallDiamond);
  } else {
    led.plotBrightness(X, Y, 255);
  }
  basic.pause(100);
  serial.writeNumbers([X, Y, 0]);
});

/*
Reads a GUVA-S12SD ultraviolet (UV) sensor and estimates the UV index.
UV index 0-2 is low, 3-5 moderate, 6-7 high, 8-10 very high, 11+ extreme.
Great for wearable projects: when should you reapply sunscreen?

Analog read: the sensor outputs a voltage proportional to UV intensity.
Formula: UV Index = voltage / 0.1V (linear, per Adafruit GUVA-S12SD spec).

Physical setup:
  Sensor has 3 pins labeled S (signal), V (power), G (ground).
  Connect S → micro:bit pin 0
  Connect V → micro:bit 3V
  Connect G → micro:bit GND
  Point the sensor window toward the sky or a UV light source.
*/

basic.pause(1000); // Start up
serial.redirectToUSB();
basic.showIcon(IconNames.Chessboard);

let analogInput = 0;
let uvVoltage = 0;
let uvIndex = 0;

basic.forever(function () {
  // --- Main Loop ---
  // Step 1: Read the raw sensor value (0 to 1023)
  analogInput = pins.analogReadPin(AnalogPin.P0);

  // Step 2: Convert to voltage — micro:bit reads 0–3.3V as 0–1023
  uvVoltage = (analogInput / 1023) * 3.3;

  // Step 3: Convert voltage to UV index — sensor outputs 0.1V per UV index unit
  uvIndex = Math.round(uvVoltage / 0.1);

  basic.showNumber(uvIndex); // Show the UV index number on the LED screen

  serial.writeLine("raw " + analogInput + "  |  voltage: " + uvVoltage + "V  |  uvIndex: " + uvIndex);
  basic.pause(1000);
});

/*
MQ-2 alcohol sensor - Use to detect hand sanitizer or other alcohol. The sensor heats up during use. This is normal.

Wiring:
MQ-2 VCC to 5V
MQ-2 GND → GND
MQ-2 A0  → micro:bit pin 0
Microbit VCC → 3.3V (not 5V — the analog output follows VCC and will exceed micro:bit's pin limit at 5V)
Microbit GND → GND

Phases:
  Warmup   — 90 seconds for sensor to stabilize. Press A to skip if already warm.
  Calibrate — press A to record clean-air baseline (averages 10 readings over 5 seconds)
  Measure  — bar graph shows rise above baseline; serial shows raw values
*/

basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
const CALIBRATE_SAMPLES = 10;
const WARMUP_TICKS = 180; // 90 seconds at 500ms per tick
let baseline = 0;
let IsWarmedUp = false;
let ticks = 0;

input.onButtonPressed(Button.A, function () {
  IsWarmedUp = true; // give user option to skip warmup, fo example if restarting program
});

basic.forever(function () {
  let reading = pins.analogReadPin(AnalogPin.P0);
  if (IsWarmedUp == false) {
    ticks += 1;
    serial.writeValue("warmup", reading);
    if (ticks >= WARMUP_TICKS) {
      IsWarmedUp = true;
      basic.showString("Press A");
    }
  } else if (input.buttonIsPressed(Button.A)) {
    // is button a pressed?  stop and take sample calibration
    basic.showIcon(IconNames.SmallDiamond);
    let sum = 0;
    for (let i = 0; i < CALIBRATE_SAMPLES; i++) {
      sum += pins.analogReadPin(AnalogPin.P0);
      basic.pause(500);
    }
    baseline = sum / CALIBRATE_SAMPLES;
    serial.writeValue("baseline", baseline);
    basic.showIcon(IconNames.Yes);
  } else {
    // normal usage mode

    led.plotBarGraph(reading - baseline, 1023 - baseline);
    serial.writeLine("gas: " + reading + "  base: " + baseline);
  }

  basic.pause(500);
});

/*
Reads an ultrasonic distance sensor (HC-SR04) and displays the distance
as a bar graph on the LED screen and logs distance values over serial.

This is a widely used sensor for small learning robots, but is very basic.
It can sense an object target larger than a pen up to a wall. 
But is not a camera, it just knows if something is there, not its shape 
or if there are multiple objects.  

For background, the ultrasonic distance sensor works like a bat.
It sends a sound "ping" and counts the time for the echo.
The trig pin triggers the ping (output from micro:bit to sensor).
The echo pin receives the return signal (input from sensor to micro:bit).

Note if writing a program from scratch, add the "Sonar" extension in Makecode editor.
*/

basic.pause(1000); // --- Setup ---
basic.showIcon(IconNames.Chessboard);
serial.writeLine("Start Ultrasonic Sensor");
let DistanceInCM = 0;
let trigPin = DigitalPin.P1; // connect to the trig pin on the distance sensor
let echoPin = DigitalPin.P0; // connect to the echo pin on the distance sensor

basic.forever(function () {
  // --- Main Loop ---
  DistanceInCM = sonar.ping(trigPin, echoPin, PingUnit.Centimeters);

  if (DistanceInCM == 0) return; // the device returns 0 if there is no object in view
  if (DistanceInCM > 200) return; // the device occasionally returns wild numbers, ignore them

  led.plotBarGraph(DistanceInCM, 200); // measured as a proportion of 200 cm, adjust as needed

  serial.writeLine("DistanceInCM=" + DistanceInCM);
  basic.pause(100);
});

//
// Tap-to-login with a PN532 RFID / NFC reader.
//   - Tap a tag: an enrolled tag shows a tick, any other tag shows a cross.
//   - Hold button A and tap a tag to add it to the list. If the tag is
//     already on the reader, lift it and tap again while holding A.
//   - Press buttons A+B together: forget every enrolled tag.
// The list is kept in memory, so it clears when the micro:bit loses power.
//
// In MakeCode: Extensions > paste  https://github.com/DFRobot/pxt-NFCI2C
//
// Wiring, PN532 over I2C:
//   PN532 SDA -> micro:bit P20
//   PN532 SCL -> micro:bit P19
//   PN532 VCC -> micro:bit 3V
//   PN532 GND -> micro:bit GND
// Set the PN532's DIP switch to I2C, then unplug and replug its power so
// it reads the switch. Hold a tag flat, about 1 cm from the antenna - a
// tag resting directly on the chip is often too close to read.

// Tag IDs allowed to "log in". Starts empty; fill it by enrolling tags.
let enrolledIDs: string[] = [];

// The last tag ID handled, to prevent double reads of a tap
let lastTag = "";

input.onButtonPressed(Button.AB, function () {
  // erase all tags from memory
  enrolledIDs = [];
  lastTag = "";
  basic.showIcon(IconNames.Skull);
});

basic.pause(1000);
basic.showIcon(IconNames.Chessboard);
basic.clearScreen();

basic.forever(function () {
  let tag = NFC.getUid(); // the tag's ID, or "No NFC Card!" when none is near

  if (tag == "No NFC Card!") {
    lastTag = ""; // tag has left; ready for the next tap
    basic.pause(200);
  } else if (tag == lastTag) {
    basic.pause(200); // same tag still sitting on the reader
    return;
  } else {
    // there is a tag, and it is a new tap
    lastTag = tag;

    if (input.buttonIsPressed(Button.A)) {
      // Button A is being held down, so add to enrolledIDs
      if (enrolledIDs.indexOf(tag) < 0) {
        enrolledIDs.push(tag);
        serial.writeLine("ID now enrolled: " + tag + "  (" + enrolledIDs.length + " total)");
        basic.showIcon(IconNames.Diamond);
      } else {
        serial.writeLine("ID was already enrolled: " + tag + "  (" + enrolledIDs.length + " total)");
        basic.showIcon(IconNames.Yes);
      }
    } else if (enrolledIDs.indexOf(tag) >= 0) {
      serial.writeLine("ID allowed: " + tag);
      basic.showIcon(IconNames.Yes);
    } else {
      serial.writeLine("ID denied:  " + tag);
      basic.showIcon(IconNames.No);
    }
    basic.pause(1000);
    basic.clearScreen();
  }
});

/*
Reads temperature and humidity from a DHT11 sensor, a common low cost, but not extremely precise sensor.
One sensor gives you two readings — the core of every smart thermostat or weather station.

The DHT22 is an improved version, but more accurate sensors exist, including 
SHT31, SHT40, or BME280 (which also measures barometric pressure)

Note: this program requires a MakeCode extension.
  In the MakeCode editor, click "Extensions" and search for "DHT11".
  Add the "DHT11_DHT22" extension by Alan Krantas.
  https://makecode.microbit.org/pkg/alankrantas/pxt-dht11_dht22#dht11_dht22-querydata

Physical setup:
  Sensor has 3 pins labeled S (signal), V (power), G (ground).
  Connect S → micro:bit pin 0
  Connect V → micro:bit 3V
  Connect G → micro:bit GND
  */

basic.showIcon(IconNames.Chessboard);
basic.pause(1000); // Wait for sensor to stabilize before first read
dht11_dht22.selectTempType(tempType.celsius);

basic.forever(function () {
  // --- Main Loop ---

  // Query the sensor. These are the default values for a 3 pin PCB version of the sensor
  // The last true parameter delays by 2 second between readings (the sensor is slow).
  dht11_dht22.queryData(DHTtype.DHT11, DigitalPin.P0, true, false, true);

  // Only read if query succeeded — bad wiring or signal noise can cause checksum failure
  if (dht11_dht22.readDataSuccessful()) {
    let temperature = dht11_dht22.readData(dataType.temperature);
    let humidity = dht11_dht22.readData(dataType.humidity);
    serial.writeLine("tempC=" + temperature + " humidity=" + humidity);
  } else {
    serial.writeLine("sensor error");
  }
});