One: Microcontrollers

Lecture slides and class recordings are available below. 

The Arduino Flavor of C(++)

The Arduino Reference is your friend. Bookmark it; keep it open in a pinned tab; reference it as you write code. In the real world, you'll often have reference materials to look at, and OPS is the same way (i.e., we're not going to make you memorize every Arduino function and code operator, and there will be no tests on this). 

The Arduino platform makes embedded development very friendly to beginners by providing functions that make doing common embedded development tasks on an MCU easier. Rather than having to read the full microcontroller datasheet and know exactly what registers, memory location, and bits you must access to control a certain feature on the MCU, you can simply call a function that does all of that for you. This is commonly referred to as a Hardware Abstraction Layer, or HAL. These hardware abstraction functions include the ones we discussed in class like digitalWrite() and analogRead(). On the Arduino reference, you'll find explanations of every function, what arguments it takes (like pin numbers, INPUT/OUTPUT, HIGH/LOW, etc.), and example code for how to use that command in your Arduino sketch. 

If you ever want to do "real" embedded development though, you must remember that the functions you'll learn on Arduino's don't exist out there in the big leagues. So, if you're feeling adventurous, try right clicking some of those functions (just put your text cursor on the function name itself) in the Arduino IDE and select "Go to Definition." This will take you to the internal Arduino files where the code for that function exists. Give it a read, maybe even ask your favorite AI program to summarize what each line in the function is doing if you get lost. That stuff is what "real" embedded C looks like. And if you ever take ECE 306, you'll learn all about it.

There are two parts in the schematic below. 

On the right side, you can see the potentiometer symbol with the two outer terminals connected to GND and 5V and the middle terminal connected to an analog input pin (A2). Make sure the middle terminal is not connected to 5V or GND!
This creates a voltage divider between 5V and GND, with Vout connected to the analog pin so we can read the position of the potentiometer with analogRead(pot);. 

On the left side, you can see the LED circuits consisting of an two LEDs and resistors in series respectively. We call these current limiting resistors. They have two jobs to protect our circuit: they prevent us from drawing too much current from the Arduino's digital output (pins 2 and 5), and prevent us from putting too much current through either LED. Allowing too much current to flow through a component is a common way beginners (and experts!) accidentally kill their components. 

Also on the left side, you can see some extra parts laying around. Wanna add some additional functionality to your circuit / program? Have at it!

Let's do some "napkin math" on a current limiting resistor to see what exactly is going on in the LED portion of our circuit: 

• When we turn the LED on (with digitalWrite([led pin], HIGH);) we'll have ~5V at the LED pin (and ~0V on that pin if we set the pin to LOW, turning the LED off). 

• We know that the full 5 volts will drop across the LED and resistor, because the other end of the two components is connected to the ground (GND) pin, and GND = 0V. 

• So we can use Ohm's Law to find the current going through both the resistor and the LED (because they're in series): 5V / 470Ω ≈ 0.0106A (or 10.6mA). 

• From our pinout diagram above, we know we shouldn't draw more than 20mA from any one pin, and we're drawing less than half that, so our Arduino is safe. 

• From the LED specifications in our parts list, we know these LEDs are designed to operate at a max of 20mA. Our LED will still light up, but not at it's full brightness—and it definitely won't have enough current going through it to burn it out. 

You might've also noticed a few extra components floating around on the schematic. This is a reminder that, in OPS, you're more than welcome to build additional features onto your projects. You have all the parts (that we've learned about so far) in your kit at your disposal!

Reminder: The code projects / files we create in the Arduino IDE are called sketches and have a .ino file extension. In other software (like in ECE 209), you'll often only work with .c and .h files. We'll talk more about the differences later on.

You can download a copy of the pseudocode file here. You'll need to create a new folder for this project inside your Arduino sketches directory (how to find your Projects folder) and .ino file into that project folder.

1. Your program first needs to configure the pins you're using in your circuit correctly (this goes in setup()). You'll also need to start the Serial connection.

2. In each loop, you should take a reading from the potentiometer as an input (we gave you this line of code for free!). Then, if you like, do some math on that reading depending on the way you want to use it. 

3. For the outputs of the program, your LEDs need to to blink, alternating between one and the other being turned on (like a railroad crossing light). 

   • Something about how they switch on and off must be controlled by the potentiometer reading. This might be the delay between them toggling between each other, how long they stay on, off, etc. Get creative!

4. You also need to print some value to the Serial monitor on your computer. 

   • This might be the potentiometer value, your LED delay time, or maybe something else—as long as the output changes as you turn the potentiometer knob. 

Below is the pseudocode for your project (to give you a general idea of what your Arduino sketch will look like):

For a simple guide on how to connect and upload code to your Arduino, you can review the demo we did in the lecture video, or read step by step instructions from arduino.cc here.

When you first plug in your Arduino, some of the lights on the board should turn on and blink a few times.
This is caused by the startup sequence running on the MCU. At least one of them will stay on all the time, it's the one with "ON" or "POW" next to it, and means exactly what the label says; power is connected to the Arduino. (And the RX and TX LEDs blink when the serial interface is being used; we'll learn more about that later on).

The LED with a simple L next to it is called the User LED and is internally connected to digital pin 13 (through a current limiting resistor, of course) on the PCB. You can turn it on and off in your code (e.g., with digitalWrite(LED_BUILTIN, HIGH); or digitalWrite(13, HIGH);). This LED is a great tool for debugging if you want to test something without sending anything to the Serial monitor or connecting an external LED and resistor; all you need to do is blink it in some kind of identifiable pattern within your code. But remember, because this LED is always connected to pin 13, if you use pin 13 as an input, you won't be able to use that LED in your program anymore. And likewise, if you use pin 13 as an output, you can't draw as much current from that pin since the LED will also turn on whenever the pin is HIGH. 

We know this might be a simple project for some; the goal here is to get used to using your Arduinos, the breadboards, and writing code in the Arduino IDE. As always with OPS, we want you to explore. Play with the code, try building different circuit with more LEDs and blinking them with different patterns (Knight Rider, anyone?), or open some of the example sketches (under File -> Examples -> Built-In Examples) and see if you can build those circuits.