Arduino Crash Course – Project 1

Are you ready for a 0 assisted project? I believe you are if you truly followed along the first 2 lessons of this crash course. After every several lessons or so, I will post a project that will leverage the new found knowledge from the recent lessons. The key point to these projects is not to make you struggle. You should be excited to try and solve on your own.

Before I describe the first project of this crash course, let’s cover some more key topics (don’t worry, these topics won’t be a part of the project, but will most likely come up in future lessons and potentially future projects). As you may already know from the first 2 lessons, or you will quickly find out, this Arduino Crash Course is completely different in that I am trying to not just provide you with how to build or complete a specific project, but provide you with the knowledge to go beyond simple applications found all over the web to be able to produce things on your own.

Series Vs. Parallel Connections

There are 2 different types of connections in electrical circuitry (well 3 if you include the neither series nor parallel case). You have actually already been exposed to Series circuits in previous lessons in this Arduino crash course.

Series Circuit

A series circuit is simply defined that electricity, or current in particular, out of one component has no where to go but into the next component in the circuit. So if we take an example of the photocell resistor (or any of the resistors connected to LEDs) in the previous lessons of this crash course, these resistors are in series with the LEDs. The current has no where to go but from the resistor to the anode of the LED. Earlier in the first lesson we were introduced to Ohm’s Law which is the guiding principle of how Voltage (V, sometimes E) measured in volts, Current (I) measured in Amps, and Resistance (R) measured in Ω where V = IR.

For components connected in series, the current (I) is the same through each component within that series, but there will be a voltage drop across each component based on the resistance of that particular component. Let’s work through a specific example. Say we just had 3 resistors in series connected to a battery (NOTE: do not physically do this unless you know the resistors are able to handle the wattage. Wattage will be discussed in later lessons in this crash course, so if you don’t know, don’t physically try it!).

From this description, we can actually calculate how much current if flowing through this circuit by Ohm’s Law. We know the voltage is 9V, and we know the individual resistances of each resistor. One property of Series is the total resistance of the circuit is the sum of all the components resistances. Therefore, we have 220Ω+1000Ω+780Ω = 2000Ω total resistance in this circuit. So finish plugging in the number into Ohm’s Law and we have:

9V = I*2000Ω => I = .0045A or 4.5mA (milliAmps)

So we know the current of the flowing through this circuit. But can we calculate the voltage drop across each resistor? You betcha! And you guessed it, it’s using Ohm’s Law

V_1 = .0045A*220Ω = 0.99V
V_2 = .0045A*1000Ω = 4.5V
V_3 = .0045A*780Ω = 3.51V

Where V_1, V_2, V_3 represents the voltage drop after passing through R1, R2, and R3 respectively. You may have noticed that if you sum up all the voltages, it represents our source voltage of 9V which is another characteristic of series circuits.

Parallel Circuit

A parallel circuit is a circuit where the conductor splits and connects to 2 or more components before rejoining back on the negative side of each component. It may be easier to think of it as a flow of current being split and then rejoined. If we take another resistor example, we have a diagram such as:

A key property of parallel circuits, is the voltage is the same across the parallel circuit, so all resistors will be sourced at 9V (of course assuming 0 resistance in the conductor connecting the resistors). The current through the circuit is the sum of the currents flowing through all resistors (or any loads) connected in parallel. Let’s calculate the current through each resistor knowing that the 9V remains the same across all:

I_1 = 9V / 220Ω ~ 0.04091A
I_2 = 9V / 1000Ω = .009A
I_3 = 9V / 780Ω ~0.01154

So can we calculate the total resistance of these resistors in parallel? You betcha! Although, do note that we did have to round current through 1st and 3rd resistor, so it won’t be match perfectly like the series circuit but it’ll be close:

9V = (0.04091A + .009A + 0.01154A) * R
R = 9V / 0.06145A ~ 146.46054Ω

This brings up another key property for calculating total resistance:

1/R_TOT = 1/R_1 + 1/R_2 + 1/R_3 + …. + 1/R_N

Where R_TOT is the total resistance, and R_1 to R_N is the individual resistances in parallel. If we take the resistors values and use this formula, you should arrive at roughly the same answer for total resistance (again will be slightly off, but that’s do to rounding that was done).

This image from wikipedia greatly sums up the characteristics of resistance in a series vs parallel:

Summary Before Project

What’s fascinating about this, is you can actually create different resistance values even if you may not have a specific resistor laying around. For example, if you wanted/needed a resistance of 400Ω, you can put 2 200Ω resistors in series, or 2 800Ω resistors in parallel. You can also reduce a more complicated circuit into a simpler one by reducing series/parallel resistors into a total resistor. For practice, I recommend working through some examples on https://www.electronics-tutorials.ws/resistor/res_5.html where there is a step by step breakdown of combination circuits (you should also check out the other tutorials on Series and Parallel circuits if the topic is still a little bit hazy). You will encounter resistors in series and or parallel many times over the crash course and if you continue on in the hobby electronics because there are so many basic circuit building blocks that leverage these basic concepts to achieve a goal.

Phew, Now Really onto the Project

In this project, use a 7-segment display to represent the current state the system is in (you can use numbers like was done in lesson 2 of this crash course, or anything you wish, goal is learning here so be creative). When a button is pushed, it changes the state you are in. Each state is represented by 8 LEDs. It’s up to you how you decide what each state means with regards to the LED lit up or not.

Again this project is for learning, and I am leaving the project description vague as possible. But to help spur some thinking, say I want to program a very simple (and boring) system, where I have 8 total states. The following state chart represents my very boring and simple example:

In this boring implementation of this, we simply go in a circular loop of 0-8, lighting a single LED as we go. But please be more creative with your project. Maybe have a wave like state, continously light up LEDs 1-8 until all were lit and then start shutting them down one by one in a LIFO (last in first out order). Or a FIFO order. Or each state can even be animations in and of itself, where initial state just lights up LEDs one at a time with a second in between, state 1 may be a chasing animation where you light up 1 “running away” from another LED with each passing second.

The possibilities are really endless here, so just start tinkering!

If you ever feel stuck with how the wiring should go, going back to either Lesson 1 or Lesson 2 of the crash course should help.

Feel free to share your designs and videos (and code if you wish) on the circuit fanatic Facebook page (https://www.facebook.com/Circuit-Fanatic-103372208107053). Like the page and follow if you haven’t already if you wish to have some more community as you work through this Arduino crash course.

Lesson 2 – I want to Rock(er)!

Lesson Overview

Another lesson, more LEDs to control (everyone loves LEDs). In this lesson we are going to go over rocker switches, a photocell resistor, and get into a common component containing a system of LEDs known as a 7-segment display. This lesson won’t go into the same level of detail as the previous lesson (as it is assumed you have a solid understanding of what was done in Lesson 1 of the Crash Course, so go back to it if you want to see an explanation if you don’t understand some concepts here).

In this lesson, we will control an LED via a rocker switch, control the brightness of an LED with a photocell, and produce a simple counter using the 7-segment display that will consistently loop through 0-9 with a push of a button.

Parts Needed

If you purchased a kit like mentioned in the first lesson of the crash course, you should have the components already needed for this project as well.

• Arduino Uno
• 2 220-ohm resistors
• 1 SPST button (Single Pole, Single Throw)
• 1 Photocell
• 1 Rocker Switch
• 2 LEDs (any color will be fine, but don’t use an RGB LED)
• 1 7-Segment Display (common cathode)
• Wires (dupont connectors wires are most commonly used)
• Bread Board – optional but extremely helpful for all prototyping

Parts Explained

Photocell – This tiny component is such a cool little component. The photocell will basically change it’s resistance based on the amount of light present. In complete darkness, the resistance is the highest, while as more light is present, the resistance from the photocell drops. In a way, that makes this component similar to the potentiometer discussed in first lesson of the crash course in the way that it is a component that provides a variable resistance to the rest of your circuit.

Rocker Switch – The rocker switch is well known because many housing light switches have rocker switches. A rocker switch is basically a component that is either on (allowing electricity to flow by connecting the pins) or off (electricity does not flow to the attached circuit). This should sound familiar as well if you read Lesson 1 of the Crash Course. A button is basically the same underlying as a rocker switch. Think if you taped a button down as the “on” state, and then removed the tape as the “off” state.

7-Segment Display – Whoa! That’s a lot of pins to connect to! Don’t be too overwhelmed with the number of pins for this device. Why? Well, because each pin can be viewed as power source to an LED (yes that’s right) within the 7-segment display. A common-cathode just means that all the LEDs internally share the same cathode (negative). Look at the diagram below showing each LED as well as the connection pin (for most common) displays out there:

Let’s Build

Before you immediately jump into the provided wiring diagram, try thinking through it yourself on how you should connect the pieces. Go ahead and connect it that way. If you truly want to learn, you got to do it yourself. I purposefully left a wrong diagram in first lesson of the crash course to try to make this point, but don’t just blindly plug in any solution you see (well, if you do, you simply won’t ever learn what you are truly doing). If you just want to see results and not learn, then really what’s the point!

Without further adieu:

Does it come close to how you connected it? If you didn’t get the exact IO pins I used to connect to the Arduino, than that is fine (remember the actual IO pin we use only matters in the code). And once again, we see a major issue with this diagram. Can you spot it? If you took the first lesson of this crash course, it should be rather apparent. The LEDs are both improperly connected. Always remember the longer leg of the LED is the anode, and should be connected to the positive side, and the shorter leg should be connected to the ground. Always double check your connections for all polarized components!

Walkthrough

First we will start with the button. In the first lesson of the crash course, we did not need to connect the button to a GPIO pin, but now we are using it as an input, so we need to include it. But similar to first post, the wiring diagram is not using the diagonal pin. This lesson of the crash course we will go over what is considered a pull-down resistor. Look at how to properly set up the button here with a pull down resistor (taken from https://www.arduino.cc/en/tutorial/button):

I recommend checking out that link as pull-up resistors are discussed as well and there is sample code in there on how to read the value of the button.

The rocker switch connection really depends on what type of rocker switch you have. Remember SPST button description in lesson 1 of the crash course? Well if you have a 2 pin Rocker switch, this is very similar where the 2 pins are connected in the “on” state. If you have a 3 pin Rocker switch, than chances are you have a SPDT (single pole double throw) switch. This means you can actually connect 2 different circuits for both states “on” and “off”. In the diagram we have a 3 pin, but we connect the “off” flow back to ground. NOTE: we should really have a resistor to ground and not connect directly to ground. Similar to the pull-down resistor you saw with the button above.

In the “on” phase, we connect the 5V from the rocker switch -> 220ohm resistor -> anode of LED. This should appear similar to what we did in Lesson 1 of the crash course with the button connection.

Moving onto the photocell. One leg is connected to the 5V source, the other leg is connected to 220ohm resistor->anode of LED.

Finally we get to the elephant in the room. The 7-segment display. It’s not nearly as bad as it looks. If you look back to the diagram of the 7-segment display up, you will see the pins representing a segment on the 2 outermost pins on each side and the ground pins are the middle pin on both the top and bottom of the display. One thing to notice here is that the resistor is actually connected to the ground pin instead of into the anodes of the LEDs. This is important to note that the resistor (generally) does not matter where in the circuit it is placed, as long as it’s present within the circuit. We could put 8 individual 220ohm resistors into each anode of each segment and it would be identical, but since we know that all LEDs in the display have a common cathode, we can simply place 1 in the cathode. Note: This will also work if you reversed the resistor on the other LEDs in the diagram and had the resistor connecting the cathode to the ground.

Great! All Wired up, Let’s Code!

So in the first lesson of the crash course, I just posted the whole code base. Each lesson going forward, it’s best to try to write the code yourself first and to try and keep from just blind copying and pasting, I will break down all code future lessons of this crash course into sections with a description of what is happening.

Before we get started, let’s just start with an inventory of the IO we have in place for this lesson:

• Pin 8 – INPUT (button)
• Pin 7 – OUTPUT (Segment ‘e’ in Display)
• Pin 6 – OUTPUT (‘d’)
• Pin 5 – OUTPUT (‘c’)
• Pin 4 – OUTPUT (‘dp’)
• Pin 3 – OUTPUT (‘g’)
• Pin 2 – OUTPUT (‘f’)
• Pin 1 – OUTPUT (‘a’)
• Pin 0 – OUTPUT (‘b’)

This is always a good practice to just jot down your wiring so you not only know whether each pin is Output or Input, but also know what it is connected to. So knowing this, try to write the setup method of your Arduino sketch.

void setup() { 
  pinMode(8, INPUT); // initializes digital pin 8 as an input 
  pinMode(7, OUTPUT); // initializes digital pin 7 as an output 
  pinMode(6, OUTPUT); // initializes digital pin 6 as an output 
  pinMode(5, OUTPUT); // initializes digital pin 5 as an output 
  pinMode(4, OUTPUT); // initializes digital pin 4 as an output 
  pinMode(3, OUTPUT); // initializes digital pin 3 as an output 
  pinMode(2, OUTPUT); // initializes digital pin 2 as an output
  pinMode(1, OUTPUT); // initializes digital pin 1 as an output 
  pinMode(0, OUTPUT); // initializes digital pin 0 as an output
}

Now before we get any further, remember what we are trying to do here with regards to the 7-segment display (keep a count of how many times the button has been pushed). For this, we will need a variable to keep the state of how many times a button has been pushed. So outside of the setup method, let’s declare and initialize an integer like so:

int count = 0;

So why outside of the setup method? Well we have to worry about scope of the variable. This is a global variable that needs to be read with each iteration of the loop method where we will use this variable. So why not declare and initialize in the loop method? Well if we did that, the variable will be redeclared and reinitialized to 0 every time the loop function is called (basically making it always 0). We can however just simply declare the variable outside of the setup method, and then initialize it within the setup method such as this:

int count;

void setup() {
  count = 0;
  ...
}

Now let’s work on the loop method.

void loop() {
  int val = digitalRead(8);
  if (val == HIGH){
    count++;
    count = count % 10;
  }
  if (count == 0) {
    drawZero();
  } else if (count == 1) {
    drawOne();
  }
  ...
  ...
  } else if (count == 9) {
    drawNine();
  }
}

First we read the value of the button (pin 8). If it is HIGH, we increment the number of times it’s been pushed. The next line uses the modulus operator, which simply a fancy word for the remainder. So if we take the count and divide by 10, the remainder should always be between 0 and 9. Perfect!

Then we should have a bunch of if / else if blocks to draw the numbers based on the count. I will help with the writing of the draw zero, but will leave the rest to you to write and work around with.

So, we want to draw a 0 on the 7-segment display? If we scroll back to the diagram of the 7-segment display, we see that we need to light up (write HIGH) on segments ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’. If we look back on our wiring, we will see in order to do this, we need HIGH on pins 1, 0, 5, 6, 7, and 2 and LOW for the other pins (3 and 4).

void drawZero() {
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(1, HIGH);
  digitalWrite(0, HIGH);
  digitalWrite(5, HIGH);
  digitalWrite(6, HIGH);
  digitalWrite(7, HIGH);
  digitalWrite(2, HIGH);
}

Repeat the same process for drawOne() – drawNine().

Why Am I Getting an Error When Uploading?

Chances are you are getting an error uploading the sketch to the Arduino (especially if you have wired the circuit first before uploading the sketch). This is because pins 0 and 1 on the Arduino are actually used by the Rx (receive) and the Tx (transmit) pins for the serial communication between the Arduino and the USB connection. Therefore, if have these pins in any other state other than floating (i.e. not connected), and you try to upload your sketch via a USB connection, you will always have an upload error. How to fix this? Well, it is actually common practice to not leverage pins 0 and 1 on the Arduino if you can avoid it (there are so many more GPIO pins to use). So for this lesson, simply just choose 2 other pins (and make sure you update the code accordingly!). If you really wanted to use pins 0 and/or 1 in your sketch as a generic GPIO pin and you want to upload sketch via USB, simply disconnect the pins 0 and 1 while it is uploading! Once uploaded, you can place the pins back. How does this work, well the USB is no longer communicating to the Arduino after it has finished uploading the program (unless you are using some sort of Serial communication to be discussed in future lesson to help with debugging). The USB is simply providing the 5v power the microcontroller needs. And since the program has been “burned” into the microcontroller flash, you can unplug the USB wire, plug back in the pins, and then reconnect the USB cable and the program that was previously uploaded will run.

As you will see in this course, I am making you fall for these traps on purpose. Not to be mean, but to be teaching moments. You learn more by failing and understanding than you do by succeeding (especially if you are “succeeding” just because you are copying and pasting someone else’s work).

What’s Next

Congratulations. You got through the second lesson of the crash course and you are started to be a master of LEDs! I hope your mind is racing with all the cool things you can do with just the knowledge you learned from these first 2 lessons!

Want some more things to trial out? Try to solve the drawing of the segments using an array solution (this solution will actually remove the need to have 10 separate functions for each digit). There is several ways of doing this, but I think the easiest is to represent the each digit with a single byte representation representing which segments should be on/off. For example, if we take the segments necessary to make a 0 (pin 0, 1, 2, 5, 6, 7 as HIGH), we can represent this in binary as 0b11100111 (0xE7 in HEX, or simply 231 in base 10 notation), therefore we can have an integer array with 10 elements (representing 0-9) where the first element is 231 (calculate the other elements yourself). This is definitely a good exercise if you have never converted between binary and decimal notation, but also learning bitwise operations will make your development easier (in the digital world, we are dealing with just a bunch of 0’s and 1’s after all).

Need something a little bit simpler, or want more? How about you change the 7-segment display to spell out your name one letter at a time? Or we can leverage the decimal point in these segments to actually count to 20 (0-19), by lighting up the decimal means we already looped 1x through the digits.

Finally, try working with a pull-up resistor. Choose one of the components (the button is probably the easiest as that’s the component we used to describe pull-down resistors), and connect the component to a pull-up resistor (i.e. HIGH for when it is unpressed, LOW for when it is pressed). If done properly, you should see the LED connected to the button is always on, until the button is pushed and the LED is then turned off. How is the wiring different? If you can start to see and think in terms of “default state” such as LOW or HIGH, it will go a long way when working with more complex components.

Lesson 1 – Control the Blink!

I figured we should start our journey going over many components commonly used and to get our feet wet with some cool projects. My goal here is to go beyond just simply wiring diagrams and code snippets, but to get into a level deeper on what is actually happening and how it is all working. Let’s get started!

Lesson Overview

In this lesson we will control 2 LEDs (light-emitting diodes). We will control whether the LED is on or off from a button push and the other LED we will control the brightness of the LED with something called a potentiometer (sometimes called a trimpot or thumbpot or even just a pot).

Parts Needed

You may be better off buying a complete kit as opposed to individual parts. If you already have an Arduino Uno, this kit will provide the majority of the parts we will use for the lessons in the Arduino crash course. If you don’t have an Arduino Uno yet, then this kit (with a clone version of the Arduino Uno), is a great starter kit and you can use all the parts through this Arduino crash course. Elegoo is a very reputable supplier of parts. I have bought many of their parts over the years, and never had a single issue.

• Arduino Uno
• 2 220-ohm resistors
• 1 SPST button (Single Pole, Single Throw)
• 1 Potentiometer
• 2 LEDs (any color will be fine, but don’t use an RGB LED)
• Wires (dupont connectors wires are most commonly used)
• Bread Board – optional but extremely helpful for all prototyping

Parts Explained

Arduino – all the lessons in this Arduino course will be using an Arduino board, so I will just go into explanation of what the Arduino is in this first lesson. Arduino is the blanket term for the open-hardware (Arduino boards) and open-software (Arduino IDE) solution. Because it has become super popular, and the fact that it’s an open hardware, there are many clones available on the market, and for the most part all act the same. The Arduino Uno contains an Microchip ATmega328 microcontroller, which is an 8-bit microcontroller with many key features that allow it to be very versatile (including 23 GPIO pins, 6 PWM channels, 10-bit ADC, and interfaces to the most common communication protocols which will all be covered in future lessons). I do recommend just looking at the microcontroller datasheet and try to see how many things you understand at this point (http://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061A.pdf). Once you are done with all the lessons, revisit this datasheet and see how much you have learned and picked up with just these tutorials.

220-Ohm Resistor – A resistor is one of the most prevalent and important components for circuits and for good reason. Resistance is the 3rd major factor in Ohm’s Law (more on this below).

SPST Button – A button is one of the easiest interfaces to allow user input to control some sort of output. A single pole, single throw simply means single input and a single output. If you think about the button being in the OFF state when it is not pressed on. When the button is pushed, it connects the the pin(s) and completes the circuit. When the button is not pushed, the circuit is broken and does not flow to the output. Note: do not get confused if your button has 4 pins, it can still be a SPST button. most SPST buttons available in the market and especially ones that come in Arduino kits will have the proper spacing to sit between the center and straddle the 2 strips allowing you to connect have the input and the output on different lines of a breadboard. As you would imagine, we will be using this button in our lesson to complete a circuit to an LED via a resistor to light up the LED when pushed.

Potentiometer – This common component allows user input to change the resistance into a circuit. As someone turns a potentiometer clockwise, it will increase the resistance to the output. A potentiometer can be used for many applications. Here we will be using it to control the brightness of an LED by increasing/(decreasing) the resistance to lower/(higher) the brightness of the LED. In more technical words, we will be resisting more or less current into the LED. Too much resistance, and the LED will not light up. On the flip side, 0 resistance, the LED will be the brightest.

LEDs – Light emitting diodes are no doubt fun. They also provide some output to the end user for things such as status (how many gadgets do you have that have some sort of light to represent that it is on?). A diode in general is an electrical component that conducts electricity in one direction. Other diodes are used to protect components from backwards current flow. An LED (as well as most other diodes) have an anode (positive lead – power source) and a cathode (negative lead – to ground).

Wires – wires are simply ways to allow electricity to flow through the circuit and connect components together. Since wires are just carriers of electricity, you want a wire to be a great conductor and to have as close to 0 resistance as possible. A dupont connector (in particular male-to-male) are very common when prototyping with Arduino. Female dupont connectors are also popular when dealing with other quick prototyping systems (such as raspberry pi).

Breadboard – although optional, it definitely makes prototyping significantly easier by allowing you to place components directly onto the breadboard, and then connect wires in the other available ports on the same line. Most breadboards have a power strip along the sides to allow quick access to positive (5v for Arduino Uno) and ground rails. Most breadboards are split into at least 2 parts where each line is connected (through internal conductor) so each hole in that row will be connected the the other holes within same row and part.

Ohm’s Law

The first major thing to truly understand in doing any electronics project is Ohm’s Law. The three main components of electricity are Voltage (V, although sometimes referenced as E) measure in Volts (V), Current (I) measured in Amps (A), and resistance (R) measured in Ohms (Ω). Quite simply Ohm’s Law is as follows:

V=IR

This means that voltage = current times resistance.

Resistor Calculation for This Project

If you bought a specific LED, always check the datasheet for max current draw and forward voltage. If you bought a bunch of LEDs in a kit without any documentation, there is a good chance that it will follow these characteristics.

To fully understand why we are using the 220Ω resistor in this project. Most of the common 5mm LEDs on the market, have max current (I) of 20mA (milliAmps, this is equivalent to .02A).

The forward voltage of an LED (the voltage needed for the electricity to flow through the Diode) is based on the color spectrum (more specifically the material the LED is made out of to make the color). Typical forward voltage by color are:

Color	Forward Voltage
Red	1.8V
Orange	2.0V
Yellow	2.2V
Green	3.5V
Blue	3.6V
White	4.0V

So now we know the forward voltage and the initial voltage (5V for Arduino) and we know that the typical LED will draw a max of 20mA. So if we algebraically work with Ohm’s Law we have the following calculation for the min resistance we need to not burn out the LED:

  R = (5 - 4) / .02 = 50Ω for white
  R = (5 - 3.6) / .02 = 70Ω for blue
  R = (5 - 3.5) / .02 = 75Ω for green
  R = (5 - 2.2) / .02 = 140Ω for yellow
  R = (5 - 2.0) / .02 = 150Ω for orange
  R = (5 - 1.8) / .02 = 160Ω for red

Keep in mind, is calculation for the lowest resistor value we should use to not damage the LED. So 220Ω will give us a bright LED while still giving room for some tolerances on both the resistor, input voltage, and the LED itself.

Try it yourself!

So we calculated these values based off the Arduino voltage source of 5V, but what resistance values should we use if we had a 12V power source instead of a 5V source? Should our resistance increase or decrease? Do some of the calculations yourself and see if the result matches what you would have expected.

Let’s Build

Finally, let’s get to building our project. Here is a drawing of the connections to this lesson:

There are a couple things wrong with this wiring diagram that I want you to try to figure out. If you wired this up this way, it will not work (hint: remember LEDs are diodes and diodes will only allow current to flow from the anode to the cathode).

Hopefully you were able to recognize that the LEDs themselves are actually flipped (anode is incorrectly connected to the ground, and cathode is incorrectly connected to the power source). There is a minor change for the push button that should be done as well. Since we are using an SPST button, 2 of the pins are always connected together and the other 2 pins are connected if the button is pushed. When dealing with buttons, it’s always advisable to connect to the pin diagonally from your first connection, as that will almost always guarantee your circuit is not continuing on unless the button is pushed.

We will start on the left side. You will see that GPIO pin 9 from the Arduino is connected to one of the pins of the push button. What we should do is take the corner of that button and connect the resistor to (what should be) anode of the LED (the longer leg). The shorter leg can then be connected to the ground (the ground is connected to the Arduino GND pin as well to form a common Ground). On the right side, we have the left pin of the potentiometer connected to GPIO 8 of the Arduino, middle connected to ground, and the 3rd pin connected to the resistor which is then connected to the (what should be) anode of the other LED. Finally the cathode of that LED is also connected to the common ground.

Note: Please be careful with connecting the LEDs and ensure the polarity is correct (source -> anode -> cathode -> ground). If it is reversed, it could potentially damage the LED.

Great! All Wired up, Let’s Code!

For coding for this lesson (and all other lessons in this Arduino crash course), we will be using the Arduino IDE. You can install it from here. They now even have a web IDE (although I have never used that). While it’s downloading/installing, you should read some introduction to the IDE just to get a feel for the software and how to use it to program your Arduino.

Since this is the first lesson, I will just supply the code and describe it line by line. In future lessons, I may only provide snippets or may just describe what the code should do and have you give it a go on your own (the only way to truly understand something is to actually work through it, not by copying and pasting).

void setup() { // the setup function runs once when you press reset or power the board
	pinMode(9, OUTPUT); // initializes digital pin 9 as an output. 
	pinMode(8, OUTPUT); // initializes digital pin 8 as an output.
	digitalWrite(9, HIGH); // sends power along the wire connected to pin 9 (the potentiometer) 
	digitalWrite(8, HIGH); // sends power along the wire connected to pin 8 (the button)
}
void loop() { // the loop function runs over and over again forever, but nothing to do here
}

That’s it?!?! Yeap, that is all that is needed for this example. Arduino libraries do a lot of abstracting away (and we may uncover some of those layers in future lessons), but let’s see what we are actually doing here.

pinMode – this function call takes the pin number (8 and 9 for our wiring), and tells the microcontroller that this is an output pin. That is, I want to turn on and off this pin whenever I want and control this pin.

digitalWrite – this function takes a pin that has already been defined by pinMode, and a value of either HIGH or LOW (this is encapsulation within Arduino itself with a #define in one of the core libraries). When we set the pin high, we are basically telling the microcontroller to set the voltage of the pin to a high state (5V in Arduino case). This will then in essence turn on the circuitry connected to the that pin as it is now “attached” to the circuit. When we set the pin LOW (go ahead and try it), we are telling the microcontroller to set the voltage of the pin to Ground (i.e. 0V), therefore shutting down the circuit that it is connected to.

As you will see, each Arduino sketch we make will have a setup() and a loop() function that we need to define. You can view the setup function as everything that needs to get done and initialized before hitting the main processing. Setup is called just once each time the system gains power. The loop function is the function that will continuously be called forever as the board holds power. We could have certainly thrown our digitalWrite functional calls in the loop, but it is unnecessary as we are only setting the voltage once and letting our components handle the LEDs.

Now to what’s happening. The LED connected to the button should be off. But if you press the button, you should see the LED stay lit for as long as you press it. This is because, as stated before, the pushing of the button is actually pushing down a conductor connecting the 2 sides together, thus allowing the circuit to continue on to the resistor and then the LED.

On the potentiometer side, depending on the initial state of the potentiometer, you should see either a very faint LED (or maybe even off) or a bright one. But as you turn the potentiometer, you should see the brightness of the LED follows. This is happening because when you turn clockwise, the resistance is increasing. More resistance to the LED means dimmer light. Conversely, turning the potentiometer counter-clockwise will reduce the overall resistance of the LED, causing it to have more power and allowing it to be brighter.

What’s Next

Play around with your wiring and the code. Maybe change the GPIO pin that these things are connected to? How would the code change? How would you change the wiring if you wanted the button to control the potentiometer circuit as well? Where should the button be placed and how do you order your components so you have a push button to allow the light to turn on, and also a potentiometer to control the brightness of the LED? Play around with the digitalWrite function. Can you write code that turns the LEDs (even if button is pushed) for 5 seconds, then enables it for 5 seconds and repeats (hint: https://www.arduino.cc/reference/en/language/functions/time/delay/)? While you are looking at that documentation for delay, preview the documentation for digitalWrite and pinMode (and peruse some more of the related functions). The power of Arduino is in the community that supports it, the amazing documentation, and the flexibility and power of being able to conquer projects even beyond basic hobbyist projects such as this.