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; use 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 (that's what working with MCUs is called) very friendly to beginners by providing functions that make doing common embedded tasks on an MCU easier. Rather than having to read the full microcontroller datasheet and know exactly what registers, memory locations, and bits you must access to control a certain feature (often called peripherals) 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 click "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.

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 (see: how to find your Projects folder) and put the .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. You need to write a blink function to do the following: toggle LED on, delay for some time, toggle LED off. We've given you the structure of this function in the pseudocode. 

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

   • OR you can use more LEDs and create your own pattern! 

   • 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, or off, etc. Get creative!

5. 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 Nano's PCB. You can address it in your code with the LED_BUILTIN keyword (e.g., with digitalWrite(LED_BUILTIN, HIGH); or digitalWrite(13, HIGH);). You don't need to define LED_BUILTIN anywhere in your program like you do with other pins; the compiler already knows it's there.
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.