Crash Course Arduino and Microcontroller Development

This lecture covers lower level processor design and how exactly machine "instructions" are implemented at the machine code level. We review RTL or "Register Transfer Logic" as a shorthand used to describe these operations as well as learn that a processor is nothing more than a conmplex state machine with gates and enables directing the flow of data. We deconstruct single machine or assembly language instructions to really understand how a processor performs computation. Finally, we continue learning about the elements or blocks of typical processors/microcontrollers and finish off with some simulation and seeing how C/C++ is converted to assembly language with an online tool.

In this lecture we take a look at the Arduino Technology platform, the hardware, software, API, IDE. See some physical development boards as well as review some other processors from history on the bench as well as a surpise guest embedded system featuring "Baby Yoda"!

In this lecture, we introduce the Arduino hardware, the IDE, how to find information on the Arduino site. We talk about C/C++ a bit and how source code is compiled into machine code and the entire process of how the compiler and tool chain works from end to end.

In this lecture, we learn about filters, transfer functions (how a network changes an input signal at its output), gain, and work through a number of problems filter problems.

This short lecture talks about how Crash Courses work and what to expect. I will cover the breadth of the course and outline my goals for you as a student and what I hope you learn. Finally, we will take a look at this document, the parts list, and discuss the different ways to take the course.

In this lecture, we are going to talk about all the software and applications we use in the course, as well as online tools and simulators. We’ll install EasyEDA and the Arduino IDE tool, and make a short list of online tools you should get accounts on. This lecture is up here in front, so we don’t have to slow our momentum with a big tool install in the middle of the course. Also, in the future, I will add installation lectures and videos to this section if students need them.

In this lecture, we are going to install the CodeLite IDE and C/C++ compiler. If you like, you can skip this until you need it, but I suggest you just get it over with :) Also, make sure to download the latest README file for the compiler installation. You can find it in the resources link/tab for this lecture.

This lecture introduces the course and we start discussing classic microprocessors and basic computer architecture.

In this lecture, we use real Arduino UNO hardware, the IDE and some C++ code to blink LEDs, and make changes in real-time, so you can see how things fit together. This is the quintessential “Hello World”, but in hardware rather than software!

In this lecture, we take a look at two of the most popular online simulators for Arduino and how they work. We will take our simple blinking LED program and port it to these simulators, see how to work with these tools and the pro's and con's between them. This is important since it allows rapid prototyping of your Arduino and other embedded platforms as well as for those that do NOT have physical hardware.

In this lecture, we write a very crude "Arduino Simulator" online in C++ on the replit.com platform (which you should have a free account on at this point). The simulator runs our blink LED program on virtual hardare and uses "print" statements to turn on/off the LEDs. This is a great lecture to understand how more advanced tools are written and used.

In this lecture, we do the electrical design for a classic "Simon" memory game using the Arduino as the hardware platform.

In this lecture, we build the physical hardware by adding in all the LEDS, buttons, power management, and rest of our previous hardware design.

In this lecture, we write the foundation of the firmware for our Simon game. We add button presses, LED output, buzzer and tone generation.

In this lecture, we explore crude "debugging" via the serial terminal and test it out on our Simon hardware platform.

In this lecture, we port the Simon hardware and firmware to the TinkerCAD simulation platform to show how you can completely simulate a hardware/firmware design (within reason) with online simulators.

In this lecture, we review a number of basic hand tools for working with electronics and small parts.

In this lecture, we take a look at electronic test equipment such as multimeters, oscilloscopes, logic analyzers, signal generators, power supplies and more.

In this lecture, we learn how to use the oscilloscope as well as the logic analyzer to investigate the Arduino firmware uploading/downloading protocol and understand the strengths and weaknesses of each tool.

In this lecture, we cover the fundamentals of charge, electric and magnetic fields as they relate to current and voltage.

In this lecture, we delve into the single most important law in electronics, Ohm's Law. We learn how to analyze simple series and parallel DC circuits, as well as different approaches to the process.

In this lecture, we continue our electronics basic with some more circuit analysis techniques, we learn about "power", as well as fire up the PCB tool we will be using for simulation called EasyEDA.

In this lecture, we are going to delve into more advanced circuit analysis tools such as Kirchhoff's current and voltage laws, work some problems, build some hardware and then move onto simulation to check out our results.

In this lecture, we learn more about capacitors, their construction, modeling equations, and how they charge and discharge. We build and simulate our findings.

In this lecture, we learn about inductors, how they work, and the laws that govern them. Finally, we take a look at engergizing and de-energizing them and compute current and voltage.

In this lecture, we delve into the black art of "reactance", "impedance" and AC circuit analysis techniques that will be helpful to understand how to analyze simple AC circuits.

In this lecture, we take the theory learned about filters and apply it to a bench build and simulation of the tone generator.

In this lecture, we learn about diodes (used for rectification and steering currents), their theory, and run some simulations.

In this lecture, we learn about transformers and how to design a simple half wave rectifying power supply. Additionally, we cover some tips on how to read data sheets.

In this lecture, we cover the bipolar transistor and its operation, theory, and run some experiments with it using a motor and Arduino.

In this lecture, we learn about MOSFETs and how to use them primarily as switches to switch large currents. Then we redesign our previous motor control circuit based on a BJT transistor and upgrade it to use a mosfet.

In this lecture, we delve into the digital realm and learn about Boolean logic, gates, truth tables, base 2 math, and finish with an introduction to popular logic families like TTL, CMOS and LVTTL.

In this lecture, we learn more about the signaling in TTL and CMOS, how to interface to them, how to mix them, and about sinking and driving current. We finish up with looking at various packaging options for prototyping and how to work with this devices.

In this lecture, we build a TTL gate tester on the bench and compare results with simulation as well as see a couple problems that are common when building circuits and how to handle them.

In this lecture, we use the Arduino as a platform to build a universal logic simulator. We write firmware, build hardware, and re-create our previous virtual simulation in real hardware.

In this lecture, we learn about programmable memories such as ROM, PROM, EEPROM, FLASH, and more. Then we take a look at programmable logic such as PALs, GALs, CPLDs, and FPGAs. We finish off with actually desiging an IC and programming it in CUPL (a hardware programming language), downloading, and testing our creation!

In this lecture, we begin our study of C++ formally. We begin with the fundamentals of the language, its roots, history, and why its so popular in embedded development.

In this lecture, we go on a tour de force of how a compiler works. All of the questions you ever had about, ”how exactly does a line of code get compiled and ran on a piece of target hardware”, are answered here in gory detail. Additionally, we take a look at an array of tools that we will use to code with from desktop compilers to online tools and emulators.

In this lecture, we start writing some simple code to print to the screen and see how the process changes from tool to tool as well as how coding on the Arduino is different from desktop C++ coding. Additionally, we learn about workspaces, projects, and compiler setup details that are very important.

In this lecture, we begin writing code in C/C++ in three different environments; CodeLite, the Arduino IDE, and Replit.com online. Additionally, we take a deeper look out how the classic entry function in C/C++ main() implements the Arduino functions setup() and loop(), which is a point of confusion for everyone learning Arduino C/C++ programming differences.

In this lecture, we take a look at how C/C++ gets converted into a final executable and how we can dissassemble that file and see the assembly language generated for your programs. Additionally, we setup our programming environments for our C++ development online, on the desktop and on the Arduino.

In this lecture, we start working with C++, learning about main(), the syntax of C/C++, and how to print to the console with printf(), as well as a deep dive into the infamous problems with carriage return and linefeed on terminals and consoles.

In this lecture, we start coding with a gentle introduction to variables, built in types, some naming conventions, and revisit the printf() function since we will be using it a lot to print results out.

In this lecture, we continue our work with C++, learn more about data types, sizes of data, math operations and precedence, and a painless introduction to loops and the pre-processor.

In this lecture, we take a short detour and review binary, hex and octal number systems.

In this lecture, we take a closer look at the C/C++ pre-preprocessor and how to use it to create constants, macros and conditional compilation. Additionally, we talk about coding style and review some time tested conventions that many programmers use to write understandable code.

In this lecture, we review more math operators including bitwise logic operations and the shift operators. We also, delve into using the debugger to see our code execute and step thru it.

In this lecture, we cover a few more math operators then we take a look conditional statements and how to write "if" statements with boolean expressions, finally we cover type casting.

In this lecture, we take a look at how to write code that repeats using "while," and "for" loops. We also look at some of the new syntax available in C++ 11 and newer versions to help simplify loop iteration.

In this lecture, we take a look at a more efficient way to compute a n-way conditional using the "switch" statement, next we dig deeper into arrays and their memory layout. Finally, we talk a bit about the "string" class.

In this lecture, we take a closer look at some NULL terminated strings, as well as arrays, functions and the String object in the Arduino API.

In this lecture, we take a look at some of the time keeping API functions for fun and then we work more on loops, and repeatitive processing. Additionally, we break out EasyCAD, design a circuit, copy it into TinkerCAD, and then build it all on the bench as well as compile and upload the code from the Arduino API. A lot to cover!

In this lecture, we lay the foundation to display characters on the serial terminal, learn about VT100 emulation, and a little bit of hardware demo with a poor man's "game pad".

In this lecture, we start our discussion of "data structures" and their theoretical basis as well as how to implement them in C++.

In this lecture, we cover one of the most feared subjects in Computer Science; the pointer! And in fact, you will see that pointers (and their C++ brothers "references") are quite easy to understand and you will wonder what all the drama has been about.

In this lecture, we delve into object oriented programming (OOP), learn the basics and how to create classes in C++, what properties and methods are, and the syntax of it all.

In this lecture, we continue our discussion of classes and look into class methods, static data, constructors, destructors, copy constructors and much more.

In this lecture, we go deeper into C++ objects and learn more about constructors, destructors, shallow and deep copying as well as operator overloading and function overloading.

In this lecture, we take a look at some built in objects that are parts of the standard libraries of C++ and the Arduino variant. These include the "string" objects as well as a brief look at SD card support on the Arduino.

In this lecture, we learn about memory management on microcontrollers and the various memory regions, types, and keywords used in firmware to assert more control of the precious SRAM resources on microcontrollers.

In this lecture, we finish up our discussion of memory management with exploring in depth how the heap, and stack works. How to allocate dynamic memory in C and C++ and the various issues you need to be aware of when using dynamic memory allocation, especially on microcontrollers with limited RAM resources.

In this lecture, we see how to work with external source and header files in both the desktop C/C++ compiler as well as the quirky Arduino IDE. Additionally, I sneak in discussions of basic "recursion" and how to make code call itself, call itself, call itself… Get ready for your brain to explode!

In this lecture, we take a detailed look at the inside of the ATMega328P processor used in the Arduino Uno. Learn how the block of the processor fit together, how to find information in the datasheet, and how the GPIO blocks as well as others work at the low level.

In this lecture, we review some basics about switches and terminology and then take a look at some hardware like membrane keypads, 7-segment displays and drivers, and rotary encoders. We prepare for a hardware build later down the line.

In this lecture, we build the hardware we have been discussing and see how to use the membrane keypad as well as how rotary encoders work and quadrature encoding schemes.

In this lecture, we work on switch debouncing using our rotary switch as the device under test. We look at both hardware switch debouncing as well as software solutions and implement both as well as take a look in real-time with the oscope at mechanical debouncing problems.

In this lecture, we write code and build up a test fixture to experiment with the analog capabilities of the Arduino and read POTs (potentiometers) and analog thumb sticks. We take this tech and then integrate it into a graphical VT100 demo that moves a cursor around the PC screen via serial terminal.

In this lecture, we take the code we wrote previously with "C" style functional programming, and convert it to a more object oriented, class based approach. A good example of how to do this as well, as well, as you can decide for yourself if it makes the code easier to understand and use.

In this lecture, we learn how to interface to neopixels, and in general how the protocol works for these serial RGB LEDs. Additionally, we write a software "bit-bang" driver, so you can see exactly how these drivers would be written bare metal without use of an API.

In this lecture, we explore the mysteries of assembly language, the AVR328 instruction set, and it's programming model. Then we begin our journey by trying some C++ mixed with "inline" assembly language out to perform simple math operations, interact with global variables, and try it all out on our hardware as well as simulation.

In this lecture, we jump into how everything connects and unravel how inline assembly works, how to read and write memory, access processor registers, interface to the IO ports and their memory mapping issues. Next we'll see how to port snippets of C/C++ code line by line to assembly language with some simple examples of loops, and conditionals. Additionally, we see how to interface to C/C++ and access variables created by C/C++.

In this lecture, we review how the hardware UART works in the AVR ATMega 328P processor. This is a great generic example of how to analyze any peripheral on any processor, and what the steps are. Then when we understand it, we write assembly language firmware to talk directly to the UART and transmit characters in both real hardware and simulation. This lecture is fundamental to embedded engineering and developing drivers for peripherals.

In this lecture, we continue our coverage of assembly language with learning how to include external assembly language files. This allows us to use the full power of the assembler as well as the syntax and features supported by the assembler, making for much cleaner coding. Additionally, we see how to interface to external assembly and access external variables as well how C/C++ needs to access the symbols and functions in the external files.

In this lecture, we continue learning about assembly language basics and focus on how to interface to external assembly files, how to call functions, how to return values across the C/C++ stack and registers. We see how to perform math operations in assembly in 8/16 bit and how to return the results. Additionally, we use tools like disassemblers to "see" what's going on and what our C/C++ programs along with ASM like as binaries.

In this lecture, we finish off our tour of assembly language (for the most part) by taking a look at some advanced topics like accessing tables in ASM, various addressing modes that are available in assembly programming, and other advanced topics that you might find interesting. Remember, 99% of the time in embedded development you will write code in C/C++, but that 1% of the time, only assembly will do, especially with resource limited processors or very time critical code, so assembly programming is a great skill to have as an embedded engineer.

In this lecture, we learn about low level programming of microcontrollers. And how the Arduino's 328P processor can be programmed with an external ICP/ISP programmer. Additionally, we cover code security and "fuse" bits which allow low level control of some of the processor's features.

In this lecture, we continue learning about low level programming of the Arduino and build a programmer out of an Arduino to program another Arduino! Then we experiment with the fuse bits, and clock out bits, to see that we can modify them programmatically, then we finish off by using a pro tool from Microchip to upload code directly to the ATMega328P via the ISP port.

In this lecture, we cover clocking concepts and how microcontrollers are clocked internally, externally, as well as coverage of PLLs (phase locked loops), the difference between crystals and oscillators, and much more. Additionally, we experiment with the clock settings on the ATMega 328P via the fuse bits. Finally, we talk about the watch dog timer and finish with an experiment on the bench.

In this lecture, we take a look at interrupts, what they are, why they are needed, and how they work. We contrast this will polling techniques as well and discuss pros and cons.

In this lecture, we re-write our polling code and implement it with the INT0 and INT1 interrupts in C++. We see how these interrupts can be triggered externally by pin change events such as rising or falling edges.

In this lecture, we dig into the timer/counters on the ATMega328P, but the concepts are generic and applicable to any processor. We learn about the common modes of operation, how timers interact with pins, the external world, and how complex signals can be generated with very little hardware.

In this lecture, we take what we learned in the previous lecture and implement a number of timer modes for waveform generation using interrupts. All at the register level without use of any API calls.

In this lecture, we use one the Arduino 3rd party APIs to setup and control the interrupts on the processor. Then we take a look at interrupt generated signals vs timer generated signals and how hardware is vastly better than software at generating signals.

In this lecture, we take a look at a less robust interrupt called the pin change interrupt. It doesn't have the features of INT0/1 interrupt, but still is very useful.

In this lecture, we finish off the pin change interrupts and their setup and application with a fun exploration of PIR "passive infrared" sensors and how to set them up to detect motion and then use their signals to cause an interrupt on the processor.

In this lecture, we take a look at the watchdog timer which is a hardware feature of most processors that allows the processor to reset itself if the code become non-responsive.

In this lecture, we learn about the power saving and sleep modes of the ATMega328P processor. All modern microcontrollers and microprocessors have various power savings modes that shut down clocks, and non-essential block. You will see how we can reduce the current over 14,000 times!

In this lecture, we continue our coverage of sleep modes, and power measurements. We measure the current consumed by the processor in various sleep modes, as well as add in the WDT (watch dog timer) to add a wake on interrupt, to show how to write programs that work, sleep, wake, and repeat. Finally, we take our PIR sensor and use it to wake the processor, showing the ideal way to save power until an external event occurs that needs attention.

In this lecture, we discuss Direct Memory Access (DMA), what it is, how it works, and why you need to use it in modern processor applications.