Crash Course Arduino and Microcontroller Development

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.

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.

In this lecture, we talk about everything related to memory management units, external memories, how to interface to them, pros and cons of various memory architectures, and how high end microcontrollers can do everything (and more) a microprocessor can do.

In this lecture, we explore more advanced debugging with desktop C++ as well as using embedded tools from Microchip to program and debug ATMega328P processors directly through the ISP and JTAG port.

In this lecture, we discuss some really important topics in optimization. The lecture covers everything from cycle counting, to algorithms, to memory organization, compiler settings, assembly language, using the debugger, and more. When working with constrained systems like microcontrollers, we must be efficient with our use of resources and learn to think in such a way not to waste them.

In this lecture, we continue our coverage of optimization techniques and discuss Big-O notation, math tricks, deep algorithm analysis, fixed point math, and static vs. dynamic memory allocation.

In this lecture, we get serious about data structures and learn about linked lists, trees, how they are constructed, searched, their pros and cons, along with many tips and tricks to make your embedded code more efficient. Additionally, we use our new Big-O notation and tools to analyze everything and predict performance.

In this lecture, we continue our cycle counting and optimization work and take a look at more techniques to speed our code up such as using bit shifting for math operations such as multiplication, removing unnecessary division operations, taking advantage of numerical insights such as closed sums for series. We analyze in real-time a number of simple algorithms, and see how applying various operations can speed up execution by a factor of 1000%! Finally, we finish off with an exploration of classic lookup tables, and see how they can be used to speed your code up.

In this lecture, we take a trip on the more mathematical side of optimization theory and look at some approximation techniques based on classic Taylor and Maclaurin series expansions. This is one of the most interesting lectures in the optimization series and shows a very powerful technique that is used time and time again on constrained embedded systems with little compute resources.

In this lecture, we take a look at the computer science behind multitasking, what it is, how it's implemented, and approaches used on microcontrollers.

In this lecture, we take the theory we learned and implement a crude interrupt based multitasking system and use it to build a demo system with a with a number of hardware elements (from our Elegoo kits) and in real-time we control all of them with our little kernel.

In this lecture, we finish off the multitasking demo with reviewing the circuitry and wiring for each of the hardware devices, along with numerous demos of the hardware as we try various adjustments for each hardware task. This lecture wraps up our homebrew multitasking kernel.

In this lecture, we take a look at a commercial real-time operating system or RTOS by the name of "freeRTOS". This RTOS is written in C, lightweight and specifically designed for embedded systems. There is a port of it available for most Arduino processors including the ATMega 328P, so we will take a look at the RTOS and give it a spin with the Arduino Uno.

In this lecture, we take a look at one of the oldest and classic communications protocols known as RS-232. This is a serial protocol (only requiring 3 signals; TX, RX, and GND) which has been around for decades. We will take a look at both the classic 12V version of the protocol and the more modern "digital" version that has replaced it on hardware running at 5V or lower, also, known as "TTL Serial".

In this lecture, we build a two Arduino network and send data back and forth between them. This is one of the largest and most complex experiments in the course, and a lot of very important concepts are illustrated. Additionally, we learn to use the "Logic Analyzer" to decode ASCII traffic as well, as decode it manually with an oscope.

In this lecture, we finish off our serial communications demo and bi-directional communications example by adding buttons and LEDs to both clients and then passing messages in both directions from the buttons to control the LEDs on the other system.

In this lecture, we cover the fundamentals and theory behind the serial protocol known as SPI or Serial Peripheral Interface. This protocol is relatively easy to learn, full duplex and runs at rates of 25MHz and beyond.

In this lecture, we build up the hardware model, firmware, math, and everything else to bring the SPI temperature sensor TMP121 online. There's a lot of work to be done, but this process is illustrative of the process you will repeat time and time again as you want to interface to new devices that support the SPI protocol.

In this lecture, we build the hardware with the SPI Temperature sensor and put everything together we have learned to create a working SPI program that interogates the SPI temperature sensor in real-time. We use a number of tools including the logic analyzer. Finally, we finish off with a preview of the next device we are going to play with -- the "Digital POT".

In this lecture, we review the datasheet and operation of a typical SPI digital POTentiometer. Then we wire it up, write code based on the datasheet, and then run tests in real-time along with the logic analyzer to see the operation of the POT.

In this lecture, we build up the hardware model, firmware, APIs, and port a 3D wire frame game to run on the Arduino driving a SPI LCD. This is one of the coolest projects in the course!

In this lecture, we cover the tactics used to port a 3D game to the Ardunio supporting a SPI LCD. We review how the source code uses a frame buffer and how keyboard input, graphics, sound, and everything else must be mapped to the Arduino platform. By the end, we will be playing a wire-frame 3D game on the Arduino!

In this lecture, we explore the next serial protocol in our series - I2C or Inter IC Communications. We will look at the electrical connections as well as the data protocol and libraries to facilitate communication. Additionally, we will take a look at a couple sample ICs that support the protocol and their datasheets (humidity/temp sensor and real time clock).

In this lecture, we focus on the details of the AD5241 (Analog Devices) digital POT, take a look at the datasheet, registers, and how to write to the POT via I2C. This IC is more complex than the SPI POT, so a good example of a typical I2C device and how to get it working. Additionally, we write the firmware, build a model in Fritzing (another CAD tool like TinkerCAD), and prepare to build the physical hardware and test our design.

In this lecture, we build the physical hardware for the Digital POT demo, upload the code and run it in real-time. Additionally, we analyze the I2C packets with a logic analyzer and review both writing the POT wiper value as well as GPIO bits that the IC we use has as an added feature. Finally, we see how noise tolerant and robust I2C is, and even works with really sloppy wiring!

In this lecture, we continue our pace since we have the fundamentals of I2C under our belts, and we jump right into another interesting sensor the SI7021 humidity and temperature sensor. This sensor is interesting since it performs a number of weather related measurements, is fast, small, and low cost. We review the data sheet, and write firmware to read data from the sensor, and we build up the circuitry on the bench to see the sensor in action.

In this lecture, we explore more I2C devices with the DS1307 Real-Time Clock or RTC. This device is used to maintain accurate time while your embedded system is powered off. To do this it not only has very accurate time keep hardware, but a battery to maintain the time for years. In this lecture, we will see how to use an off the shelf API to communicate with the DS1307 as well as write our own low level driver.

In this lecture, we learn about accelerometers, gyros and experiment with a popular unit from Invensense the MPU6050. We will build the hardware, review the datasheets, use an API as well as write our own driver.

In this lecture, we take a look at the new(ish) web/cloud based Arduino IDE. This new IDE is browser based and supported by all popular browsers. It works by installing a piece of software, a driver, plug in of sorts to make the physical connectio from the sandbox of the browser to the hardware you have connected via your USB serial port.

In this lecture, we learn about the new Arduino IDE 2.x, it's new features. We'll build some programs, upload, test, and take the new IDE for a spin and contrast it to the legacy version.

In this lecture, we take a look at an advanced coding editor called Visual Studio Code, also known as “VSCode” from Microsoft. Additionally, we look at an embedded development framework; PlatformIO that can be plugged into VSCode it that allows us to develop for dozens of microcontrollers and platforms (including Arduino).

In this lecture, we take a look at a debugging solution for VSCode that supports Arduino. The debugger uses only the serial port, doesn't require changes to the bootloader, and supports single stepping, variable watches, and more.

In this lecture, we learn about an advanced, professional IDE from Microchip called MPLAB X. We start with a documentation review of the IDE, learn how it can be used to develop for AVR, PIC, ARM processors. We learn about the compilers available from Microchip that plug into it as well as the new technologies that the tool supports. Then we begin one of the most complex installs we have done in the course, install the tool, and run it.

Finally, we take a look at how to update the tool, and a quick walk around features such as the Code Configurator, “Melody”, “Harmony”, and the Graphical Builder app as well as the Pin Manager and more. We finish off with a discussion about the Unified Microchip Library, and prepare for writing code, compiling, uploading to our targets in Part II.

In this lecture, we create a number of projects, compile, download, and explore the operation of MPLAB X IDE. We basically create a "Hello World" application from scratch, use the Unified Library, and learn our way around this very complex tool. Additionally, you will see how we overwrite the Arduino bootloader, and how we can reload it onto the Arduino after using these low level tools.