# Circuit Playground Digital Input

## Overview

![](https://cdn-learn.adafruit.com/assets/assets/000/039/655/medium800/circuit_playground_banner_signal.png?1487872831)

In this guide we will use our Circuit Playground along with some alligator clips and a resistor to explore how we can read digital inputs.

**No soldering required!**

# Required Parts

You will need the following items.

[Circuit Playground](https://www.adafruit.com/products/3000)

![circuit_playground_cp.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/624/medium640/circuit_playground_cp.jpg?1487797637)

[Small Alligator Clip Test Lead](https://www.adafruit.com/products/1008)

![circuit_playground_gators.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/626/medium640/circuit_playground_gators.jpg?1487797704)

[10k Ohm Resistor](https://www.adafruit.com/products/2784)

![circuit_playground_resistor.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/627/medium640/circuit_playground_resistor.jpg?1487797762)

# Before Starting

If you are new to the Circuit Playground, you may want to first read these overview guides.

- [Overview](../../../../introducing-circuit-playground)
- [Lesson #0](../../../../circuit-playground-lesson-number-0)

This project will use the Arduino IDE. Make sure you have added the board support for the Circuit Playground as well as installed the Circuit Playground library. **MUST DO BOTH.** This is covered in the guides linked above.

# Circuit Playground Digital Input

## Digital Signals

The term [digital signal](https://en.wikipedia.org/wiki/Digital_signal) can be used to describe a wide range of signal types. But in this guide we are going to use a very simple definition for a digital signal - **a signal which has only two values**. Such a signal would look something like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/039/654/medium800/circuit_playground_digital_signal.png?1487872814)

The two values could be anything. However, since we are dealing with an electrical signal, we will be dealing with an electrical value - **voltage**. But what are the two values for the voltage?

Typically, 0V is used for one of them and is referred to as "LOW". The other one is referred to as "HIGH" and its voltage [depends on the hardware](https://en.wikipedia.org/wiki/Logic_family), but some common values you'll see are 5V (ex: Arduino Uno) and 3.3V (ex: Circuit Playground).

# 3V Logic

Let's focus on the 3.3V logic used by the Circuit Playground. Quite often this is just referred to as "three volt logic" as we're all too lazy to mention that extra "point three".

So.....what about 3.2999V? It's not 3.3V, so is it HIGH? Is it LOW? Or what about 0.1V? It's not 0V, so it it LOW? Is it HIGH? Real world signals will have some noise and thus will behave this way. Therefore, to deal with this, a range of values is setup to represent HIGH and LOW. For 3.3V level logic, it looks like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/039/722/medium800/circuit_playground_3v_logic_levels.jpg?1487992091)

So 3.2999V would be seen as HIGH and 0.1V would be seen as LOW. Everything that is designed to work with 3.3V logic is expected to work within these limits. If it doesn't, it is considered broken. Nothing should be generating values in the "gray zone".

# Pocket Ref

For this guide, it's good enough to just keep this decoder ring in mind:

- 0V = LOW = FALSE = 0
- 3.3V = HIGH = TRUE = 1 

# Circuit Playground Digital Input

## Circuit Hookup

Alright, let's go hands on.

The hookup for this guide is very simple. While a button could be used, we will simply touch the alligator clips together to simulate this same function. We'll use a resistor a little later, but for now just connect the alligator clips as shown.

This is the overall view of the hookup.

- RED to 3.3V
- BLUE to #3
- BLACK to GND

![circuit_playground_circuit_hookup.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/660/medium640/circuit_playground_circuit_hookup.jpg?1487879589)

Simply connect the alligator clips to the gold pads on the edge of the Circuit Playground as shown.

![circuit_playground_circuit_hookup2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/662/medium640/circuit_playground_circuit_hookup2.jpg?1487879710)

Danger: 

Be careful to not let the **BLACK** and **RED** alligator clips touch each other directly. We will be touching other alligator clips together, but never these two.

Touching **RED** to **BLUE** is OK.

![circuit_playground_red_to_blue.png](https://cdn-learn.adafruit.com/assets/assets/000/039/672/medium640/circuit_playground_red_to_blue.png?1487880872)

Touching **BLACK** to **BLUE** is OK.

![circuit_playground_black_to_blue.png](https://cdn-learn.adafruit.com/assets/assets/000/039/673/medium640/circuit_playground_black_to_blue.png?1487880955)

Touching **BLACK** to **RED** is NOT OK.

 

This will short power to ground and the Circuit Playground will not be happy.

![circuit_playground_black_to_red.png](https://cdn-learn.adafruit.com/assets/assets/000/039/669/medium640/circuit_playground_black_to_red.png?1487880088)

# Circuit Playground Digital Input

## Hello Digital

Alright, let's start super simple. To read the digital value on the #3 pad, we will use the Arduino library function [digitalRead](https://www.arduino.cc/en/Reference/digitalRead). You can use the following sketch to read and print the value.

```auto
///////////////////////////////////////////////////////////////////////////////
// Circuit Playground Digital In - Hello Digital
//
// Author: Carter Nelson
// MIT License (https://opensource.org/licenses/MIT)

#include <Adafruit_CircuitPlayground.h>

///////////////////////////////////////////////////////////////////////////////
void setup() {
  Serial.begin(9600);
  
  CircuitPlayground.begin();
  
  pinMode(3, INPUT);
}

///////////////////////////////////////////////////////////////////////////////
void loop() {
  int reading = digitalRead(3);
  
  Serial.println(reading);
  
  delay(500);
}

```

With this code loaded and running on the Circuit Playground, open the Serial Monitor.

**Tools -\> Serial Monitor**

Now touch the **BLACK** clip to the **BLUE** clip.

![circuit_playground_black_to_blue.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/676/medium640/circuit_playground_black_to_blue.jpg?1487881872)

This sets the voltage of the digital input to 0V ( **LOW** ). You should see 0s scroll by in the Serial Monitor.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/677/medium800/circuit_playground_serial_monitor0.png?1487881969)

Now touch the **RED** clip to the **BLUE** clip.

![circuit_playground_red_to_blue.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/678/medium640/circuit_playground_red_to_blue.jpg?1487882008)

This sets the voltage of the digital input to 3.3V ( **HIGH** ). You should see 1s scroll by in the Serial Monitor.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/679/medium800/circuit_playground_serial_monitor1.png?1487882073)

Pretty straight forward. When the digital input pin is connected to 0V (GND) it is **LOW** and prints out 0s. When the digital input pin is connected to 3.3V it is **HIGH** and prints out 1s.

And there are our two values, 0 ( **LOW** ) and 1 ( **HIGH** ). So we're done, right? Of course not. Just getting started.

What about the case where neither the **BLACK** nor the **RED** are touching the **BLUE** clip? Is that **LOW**? Is that **HIGH**? Truth is, I don't know. And no one does, not even the Circuit Playground. The poor little **BLUE** alligator clip is floating in space not tied to any known value. This is called a "floating input" and we'll look at how to deal with this next.

# Circuit Playground Digital Input

## Floating Inputs

Here's what our alligator clip setup looks like when nothing is connected to the **BLUE** clip.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/696/medium800/circuit_playground_floating3.png?1487885601)

You might think that the voltage would be 0V and the digital pin would read **LOW**. After all, it's not attached to anything. It's attached to nothing. And 0 is like nothing. However, voltages don't exist at a point - they exist between two points. And in the case of the floating input, one of those points is not fixed to any known value. Therefore, the voltage is also unknown.

The end result is that the actual value is unpredictable, which isn't very useful. You can try using the sketch from the previous section and watch for the value to change. However, the following sketch will monitor the pin constantly (very fast) and detect when it changes.

```auto
///////////////////////////////////////////////////////////////////////////////
// Circuit Playground Digital In - Floating Input
//
// Author: Carter Nelson
// MIT License (https://opensource.org/licenses/MIT)

#include <Adafruit_CircuitPlayground.h>

int initialValue;

///////////////////////////////////////////////////////////////////////////////
void setup() {
  Serial.begin(9600);
  while (!Serial) ;
  
  CircuitPlayground.begin();
  
  pinMode(3, INPUT);

  initialValue = digitalRead(3);

  Serial.print("Initial value = "); Serial.println(initialValue);
  Serial.println("Waiting for that to change...");
}

///////////////////////////////////////////////////////////////////////////////
void loop() {
  int reading = digitalRead(3);
  
  if (reading != initialValue) {
    Serial.print("It changed! value = "); Serial.println(reading);
    while (true) ; // sit here forever
  }
}
```

With this code loaded and running on the Circuit Playground, open the Serial Monitor.

**Tools -\> Serial Monitor**

Now pick up the **BLUE** alligator clip and try touching it with your finger. You may need to try touching it several times, but hopefully at some point it will see a change and report it as shown below. Note that your initial value might be 1 - it totally depends on what ever randomness is happening in your test environment.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/695/medium800/circuit_playground_serial_monitor_floatdemo.png?1487885303)

The fix for this is pretty straight forward. You just set things up so that the digital input, the **BLUE** alligator clip, is always attached to a known value, in this case either the **RED** (3.3V) alligator clip or the **BLACK** (0V) alligator clip. This is called "pulling" the input, as you are forcing it (pulling it) to a specific value. When the input is pulled to 3.3V it is called "pulling up". When the input is pulled to 0V it is called "pulling down". You can go either way.

But wait! Remember we can't touch the **RED** and **BLACK** wires directly to each other. So if one of those is already attached to the **BLUE** clip, how do we ever touch the other one? The answer is to use a resistor - and guess what it's called? Well, a pull up resistor or a pull down resistor, as the case may be.

Let's play with both.

# Circuit Playground Digital Input

## Pull It Up

Let's start with a pull up resistor. To do so, we will take the 10k ohm resistor and attach it as shown below.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/712/medium800/circuit_playground_pull_up.jpg?1487960063)

We can just use the alligator clips to hook this up.

Attach the 10k ohm resistor between the **BLUE** and **RED** alligator clips.

![circuit_playground_pull_up1.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/689/medium640/circuit_playground_pull_up1.jpg?1487883901)

Now run the sketch from the previous section again. Try touching the **BLUE** alligator clip with your hand as you did before. Now it should never see any changes. It should be nicely held at 3.3V.

Now try touching the **BLACK** clip to the **BLUE** clip.

![circuit_playground_pull_up2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/690/medium640/circuit_playground_pull_up2.jpg?1487883948)

Now it should see the change and report it.

So we've fixed the floating input problem. The resistor "pulls" the input "up" to 3.3V and the pin reads **HIGH** (1). When we touch the **BLACK** clip, the pin sees 0V and reads **LOW** (0).

Additionally, the resistor prevents a short between power and ground. That's why it's important to touch the **BLACK** only to the **BLUE**. Even with this resistor in the circuit, it is still bad to touch **BLACK** to **RED**. **DON'T DO IT!!**

We can do the same thing in the other direction. That is, we can "pull down". Let's look at that next.

# Circuit Playground Digital Input

## Pull It Down

This is the same idea as the pull up resistor, except now it is attached to GND. The hook up is shown below.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/713/medium800/circuit_playground_pull_down.jpg?1487960092)

Again, we use the alligator clips to set this up.

Attach the 10k ohm resistor between the **BLACK** and **BLUE** alligator clips.

![circuit_playground_pull_down1.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/692/medium640/circuit_playground_pull_down1.jpg?1487884048)

Run the sketch again and touch the **BLUE** clip with your finger. As before, it should not detect any changes. It is being held **LOW** and is happy there.

Now try touching the **RED** clip to the **BLUE** clip.

![circuit_playground_pull_down2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/693/medium640/circuit_playground_pull_down2.jpg?1487884092)

It should see the change and report it.

Note that the only thing different between this and the pull up configuration is the order of the values.

- A pull up is normally **HIGH** and goes **LOW** when the alligator clips are touched together.
- A pull down is normally **LOW** and goes **HIGH** when the alligator clips are touched together.

And remember that our touching of the alligator clips is like pressing a button. So the same logic applies for button presses as well.

# Circuit Playground Digital Input

## Which Way?

So you've got two options for dealing with floating inputs. You can either pull it up or pull it down. But which one should you use? It's a good question but beyond the scope of the guide. It's one of those "depends" kind of things.

For now, it is enough to simply understand what a floating input is, why it is an issue, and how they can be dealt with.

# Circuit Playground Digital Input

## Bouncing Inputs

[Bumbles](http://christmas-specials.wikia.com/wiki/The_Abominable_Snowmonster_of_the_North) aren't the only thing that bounce. So do push buttons. When you press your basic, normally open, momentary style button, it closes its little internal switch connection. In an ideal world we could hook that up to our Circuit Playground, like we have the alligator clips, and get an input signal that would look like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/039/697/medium800/circuit_playground_button_ideal.png?1487891151)

That's the way a button should work and how most people think they work. However, in reality it looks more like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/039/698/medium800/circuit_playground_button_real.png?1487892148)

It goes up and down several times before finally stabilizing. Take a button apart and check out its guts and see how it works. Inside you'll find some form of mechanism that brings two contacts together - much like we are doing with the alligator clips. However, the contact doesn't happen instantly. It bounces around a bit, going closed, open, closed, open, closed, etc. This is purely a mechanical phenomenon, kind of like dropping a ball - it bounces before finally sitting still on the ground.

It does this over the period of time = **t**. While this period of time is very fast, and seems almost instantaneous to you and me, to the Circuit Playground, it's a huge period of time. The Circuit Playground can execute many many instructions in that period of time.

We can use our alligator clip setup to gain an appreciation for this. We will use the "pull down" setup from the previous section, so make sure you've got the alligator clips hooked up that way.

Now run the following sketch.

```auto
///////////////////////////////////////////////////////////////////////////////
// Circuit Playground Digital In - Bounce Demo
//
// Author: Carter Nelson
// MIT License (https://opensource.org/licenses/MIT)

#include <Adafruit_CircuitPlayground.h>

int currentState;
int previousState;
uint32_t count;

///////////////////////////////////////////////////////////////////////////////
void setup() {
  Serial.begin(9600);
  
  CircuitPlayground.begin();
  
  pinMode(3, INPUT);

  count = 0;
  
  currentState = digitalRead(3);
  previousState = currentState;
}

///////////////////////////////////////////////////////////////////////////////
void loop() {
  currentState = digitalRead(3);
  if (currentState != previousState) {
    count = count + 1;
    Serial.print("State changed from ");
    Serial.print(previousState);
    Serial.print(" to ");
    Serial.print(currentState);
    Serial.print(". count = ");
    Serial.println(count);
    previousState = currentState;

    //delay(100);
  }
}
```

With this sketch loaded and running on the Circuit Playground, open the Serial Monitor.

**Tools -\> Serial Monitor**

Now play around with touching the alligator clips together.

Touch the **RED** to the **BLUE** alligator clip.

![circuit_playground_pull_down2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/039/705/medium640/circuit_playground_pull_down2.jpg?1487893863)

Did you get more than one print out when you made the connection? Try touching the clips several times and watch the behavior of the messages in the Serial Monitor. If you do it just right, you can get only one message to print. However, more often you get multiple lines. Same when the connection is removed - the bounce happens in both directions.

Touching the alligator clips together like this is a very bouncy operation. The Circuit Playground is fast enough to see all those bounces and prints out a message each time.

Here's what I get trying this after a fair amount of coffee to add some extra bounce.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/701/medium800/circuit_playground_serial_monitor_bounce.png?1487893769)

So how do we fix this? There are many ways, both hardware based and software based. So many in fact that a discussion of debouncing techniques is worthy of its own guide (or more).

However, we will demonstrate one very simple software approach. The trick is to just add a delay after the initial detection. This forces the Circuit Playground to go to sleep during the bouncing and not pay any attention to it.

To test this, simply uncomment (remove the //) the following line in the previous sketch. (it's near the bottom)

```auto
  delay(100);
```

Run this new code and play around again with touching the alligator clips together. Now you should get a single print out when touched and separated as shown below.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/711/medium800/circuit_playground_serial_monitor_bounce2.png?1487957873)

The main drawback to this technique is that the Circuit Playground can not do anything else during the delay() period. For more complicated programs the processor is always doing something and you try to avoid forcing is to go to sleep using something like delay().

However, for simple programs, this technique works just fine. In fact, you'll see it used quite often. It's simple and works. Ever seen anything like this at the top of a sketch?

```auto
#define DEBOUNCE    100
```

Look elsewhere in the code and you'll likely find:

```auto
delay(DEBOUNCE)
```

It's using the same technique and simply defining the delay period globally.

# Circuit Playground Digital Input

## Under The Hood

The Circuit Playground has[two push buttons](../../../../circuit-playground-lesson-number-0/buttons-and-slide-switch). They are simple momentary buttons that effectively do the same thing as pressing the alligator clips together. But how are they integrated into the Circuit Playground? Do they deal with any of the issues we've talked about? Let's take a look.

Take a look at [the schematic](../../../../introducing-circuit-playground/downloads#schematic) for the Circuit Playground. The circuit diagram for the buttons can be found in the upper left.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/706/medium800/circuit_playground_cp_schem_buttons.png?1487896340)

Let's just look at one button since they are both used in the same way. Here's a blow up of the part of the circuit diagram that matters. The thing above the label EVQQ is the actual button.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/707/medium800/circuit_playground_cp_schem_button1.png?1487896369)

We don't have a button in our alligator clip setup, so let's remove it. Now we are left with this.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/708/medium800/circuit_playground_cp_schem_button2.png?1487896384)

It may not look like it, but this is identical to the "pull down" version of our alligator clip setup. Here's the schematic showing where the various alligator clips are.

![](https://cdn-learn.adafruit.com/assets/assets/000/039/709/medium800/circuit_playground_cp_schem_button_labels.png?1487896401)

So the Circuit Playground deals with the floating input issue by using a **pull down resistor**. The same thing is done for both buttons. Righty-o.

Now, what about dealing with switch bounce? Any magic going on there? Well, let's take a look at the code for **CircuitPlayground.leftButton()** and see what's going on. Here it is ([direct link to repo](https://github.com/adafruit/Adafruit_CircuitPlayground/blob/master/Adafruit_CircuitPlayground.cpp#L74)):

```auto
boolean Adafruit_CircuitPlayground::leftButton(void) {
  return digitalRead(CPLAY_LEFTBUTTON);
}
```

Hmmmm. It just returns the value from **digitalRead()** for the input the button is attached to. Same as we've been doing with our alligator clips. That's it. Nothing else.

So, there is **no debouncing** being done by the Circuit Playground library. It is left up to the user (you) to incorporate this in their program somehow.

# Circuit Playground Digital Input

## Questions and Code Challenges

The following are some questions related to this project along with some suggested code challenges. The idea is to provoke thought, test your understanding, and get you coding!

While the sketches provided in this guide work, there is room for improvement and additional features. Have fun playing with the provided code to see what you can do with it. Or do something new and exciting!

# Questions

- The microcontroller on the Circuit Playground has internal pull up resistors. Why were external pull downs used instead? (hint: it's kind of subjective)
- Why was a value of 10k ohms used for the pull up/down resistor?

# Code Challenges

- Reduce the amount of delay in the bounce sketch and see how it affects the debounce behavior. Try making it as low as 1, i.e. delay(1).
- Modify the bounce sketch to read the input from one of the Circuit Playground push buttons to examine its bounce behavior. (remove the delay)


## Featured Products

### Circuit Playground Express

[Circuit Playground Express](https://www.adafruit.com/product/3333)
 **Circuit Playground Express** is the next step towards a perfect introduction to electronics and programming. We've taken the original Circuit Playground Classic and made it even better! Not only did we pack even more sensors in, we also made it even easier to...

In Stock
[Buy Now](https://www.adafruit.com/product/3333)
[Related Guides to the Product](https://learn.adafruit.com/products/3333/guides)
### Circuit Playground Classic

[Circuit Playground Classic](https://www.adafruit.com/product/3000)
Would you like to learn electronics, with an all-in-one board that has sensors and LEDs built in? **Circuit Playground** is here - and it's the best way to practice programming on real hardware with no soldering or sewing required!

This is the **Classic**...

In Stock
[Buy Now](https://www.adafruit.com/product/3000)
[Related Guides to the Product](https://learn.adafruit.com/products/3000/guides)
### Small Alligator Clip Test Lead (set of 12)

[Small Alligator Clip Test Lead (set of 12)](https://www.adafruit.com/product/1008)
Connect this to that without soldering using these handy mini alligator clip test leads. 15" cables with alligator clip on each end, color coded. You get 12 pieces in 6 colors. Strong and grippy, these always come in handy! We often use these in conjunction with a multimeter so we...

Out of Stock
[Buy Now](https://www.adafruit.com/product/1008)
[Related Guides to the Product](https://learn.adafruit.com/products/1008/guides)
### Through-Hole Resistors - 10K ohm 5% 1/4W - Pack of 25

[Through-Hole Resistors - 10K ohm 5% 1/4W - Pack of 25](https://www.adafruit.com/product/2784)
ΩMG! You're not going to be able to resist these handy resistor packs!&nbsp;Well, axially, they&nbsp;do all of the resisting for you!

This is a **25 Pack of 10K Ω Resistors.** More specifically, they are **carbon film** , through-hole...

In Stock
[Buy Now](https://www.adafruit.com/product/2784)
[Related Guides to the Product](https://learn.adafruit.com/products/2784/guides)

## Related Guides

- [Introducing Circuit Playground](https://learn.adafruit.com/introducing-circuit-playground.md)
- [Adafruit Circuit Playground Express](https://learn.adafruit.com/adafruit-circuit-playground-express.md)
- [Cam Follower Automaton](https://learn.adafruit.com/cam-follower-automaton.md)
- [Combo Dial Safe with Circuit Playground Express](https://learn.adafruit.com/combo-dial-safe-with-circuit-playground-express.md)
- [Circuit Playground Slouch Detector](https://learn.adafruit.com/circuit-playground-slouch-detector.md)
- [Circuit Playground Express Sugar Glider](https://learn.adafruit.com/cpx-sugar-glider.md)
- [Sipping Power With NeoPixels](https://learn.adafruit.com/sipping-power-with-neopixels.md)
- [Digital Fidget Spinner](https://learn.adafruit.com/digital-fidget-spinner.md)
- [Buttermilk Boat with Circuit Playground Express](https://learn.adafruit.com/boat-with-circuit-playground-express.md)
- [CRICKIT Snake Bot](https://learn.adafruit.com/crickit-snake-bot.md)
- [Steven Universe Wearable, Fusable Gem](https://learn.adafruit.com/steven-universe-wearable-fusable-gem.md)
- [Chatty Light-Up Circuit Playground Express Mask](https://learn.adafruit.com/chatty-light-up-cpx-mask.md)
- [CPX Glowing Disembodied Hand](https://learn.adafruit.com/cpx-glowing-disembodied-hand.md)
- [Tilt Controlled Marble Maze](https://learn.adafruit.com/tilt-controlled-marble-maze.md)
- [Sound Activated Shark Mask](https://learn.adafruit.com/sound-activated-shark-mask.md)
- [Installing CircuitPython on SAMD21 Boards](https://learn.adafruit.com/installing-circuitpython-on-samd21-boards.md)
- [NeoPixels with MakeCode](https://learn.adafruit.com/neopixels-with-makecode.md)