Crash Course Arduino and Microcontroller Development

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.

This lecture covers how microprocessors work internally. We cover classic 8-bit processors like the 6502, learn how an ALU works, Von Neumann vs. Harvard Architecture. We learn what machine and assembly language are as well as covers microcontrollers which are complete computers on a single IC, or otherwise known as systems on a chip or SOCs. Lastly, we learn what a "datasheet".

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 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 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.

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

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 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.

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.