Beyond Arduino: Electronics for Developers & Makers - (GPIO)

Explore the typical microcontroller architecture, including the CPU, memory, ADC, timer, GPIO, and serial interfaces, and the parallelism between modules and the CPU within a bus architecture.

Explore Arm Cortex operational modules, including CPU, debug unit, two-level bus with the advanced high speed bus and advanced peripheral bus, GPIO, serial ports, timers, USB, and system controls.

Examine actual block diagrams of microcontrollers, including LPC1114 and Arm Cortex-M0/M4F, detailing cores, buses, memory controllers, and peripherals like touch sensing, USB, PWM, ADC, DAC, and temperature sensors.

Understand how a cpu runs a main loop while peripherals like adc and serial ports operate in parallel, signaling data readiness, with microcontroller architecture and internal memory enabling concurrent tasks.

Explore how a switch matrix multiplexes many signals into few pins by assigning multiple functions per pin, demonstrated with an eight-pin LPC810 and a twenty-pin variant.

Multiplexers act as bidirectional switches that map multiple internal signals to a single pin, controlled by a setup register. This reduces pin count and enables flexible pin usage.

Compare beginner and advanced embedded development tools, outlining reliability, customization, and hardware support. The lecture advocates advanced tools for professionals, noting debuggers, simulators, and flexibility, despite higher cost and complexity.

Identify when to use beginner versus advanced tools for microcontrollers and hardware, from first-time coders to embedded application developers, with guidance on learning curves and suitable projects.

Explore popular development platforms and tools, from beginner options like Arduino and mbed to advanced tools such as Kyle Microvision, LPC Express, and Code Composer Studio.

Recognize that advanced tools offer higher quality for professional use, while beginner tools stay quick and dirty for hobbyists; programmers must graduate to development in their own hands.

Turn on and off LEDs via a digital output, calculate series resistor values, and understand current, polarity, and brightness, while noting that LEDs and resistors aren’t a silver bullet.

Calculate a series resistor for leds using Kirchhoff's voltage law, considering supply voltage, forward voltage, and desired current, then consult datasheets for color-specific voltage drops to control brightness and lifespan.

Learn about multicolor leds, including bi-color and tri-color rgb designs, and common anode, common cathode, and antiparallel topologies. Use outputs with current-limiting resistors to safely light single or multiple leds.

Learn to design led circuits by accounting for voltage drops and current, use one resistor per segment for tri-color leds and seven-segment displays, and view multicolor led as several leds.

Explore pulse width modulation and periodic pulses, focusing on rectangular signals and timing that defines high and low states in microcontroller outputs, including power control and analog signal generation.

Understand rectangular signals by defining period, pulse width, and duty cycle; the period is denoted by D, and the duty cycle equals pulse width over the period, 0–100%.

Learn how pulse width modulation controls LED brightness by varying duty cycle while keeping a constant period, enabling efficient power control and perceived brightness adjustments.

Drive a dc motor with a pwm signal through a power driver; high state powers the motor from the supply, low state stops it, and the duty cycle sets speed.

Pulse-width modulation uses duty cycle to set average voltage, five volts at 75% equals 3.75 volts; a low-pass filter converts it to an analog waveform for audio tones and DTMF.

Explore how to drive led arrays, from seven-segment displays to multi-digit matrices, using column-row scanning, common anodes/cathodes, and resistors to light specific leds.

Control LED arrays by scanning one row at a time, sending the row zero and corresponding column pattern, with resistors in rows or columns, harnessing persistence of vision.

Explore seven segment displays, comparing common anode and common cathode wiring and learning resistor requirements for each segment. Demonstrate multiplexing a multi-digit display to show numbers via rapid digit cycling.

Transistors act as switches with base-collector-emitter terminals to selectively activate common cathodes and drive 7-segment displays using positive logic, the segments array and the digits array, current amplification, and resistors.

Examine a five-digit scan algorithm for seven-segment displays using a digits array, modulo arithmetic, and a decode function to flash digits with persistence of vision.

Demonstrate the decode function to extract a single digit from a number and convert it into a seven-segment pattern using a lookup table and modulo operations.

Learn to represent decimal numbers with fixed or floating point, map them to multi-digit seven-segment displays, and control the decimal point via scan algorithms and persistence of vision.

Demonstrate the basic stamp 2 microcontroller from Parallax with a seven-segment display scan, highlighting its beginner-friendly design, 20 megahertz core, deep 24 dual inline packaging, and 2 kilobytes of EPROM.

The BASIC Stamp 2 runs only an interpreter, delivering about 4,000 basic instructions per second at 20 megahertz, with 32 bytes RAM, 2 kilobytes of EPROM, and no interrupts.

Explore a stem-to-module hardware demo driving a four-digit seven-segment display using pins p0–p15, with pins 8–15 as segments, a push button counter from 19997 to 20000, and cathode wiring.

Explore Parallax's basic stamp software, the development environment, and the EPROM/RAM memory map. See program hex and memory usage across modules and versions 1.0, 2.0, 2.5.

Explore the scan function in PBASIC by detailing directives, direction and port registers, and how the algorithm uses a subroutine to multiplex common cathode displays with a one-millisecond delay.

Explore the decode subroutine and a live demo, using division by ten and a lookup table to drive a seven-segment display with hexadecimal patterns for digits on the display.

Explore the Tiva C launchpad with a cortex M4 and floating point unit, USB serial, analog input/output, and rich memory, using Kyle Microvision and code composer studio.

Explore how to drive a 7-segment display using GPIO pins, wiring cathodes and segments across multiple ports, with a push button input and a USB programmer interface.

Explore the launchpad development software and its energia-based arduino clone workflow, highlighting beginner usability issues, buggy error reporting, and misaligned line references that hinder learning.

Learn to implement a c scan function for a seven-segment display on the tvc launch pad, using setup and loop, digit/segment mappings, a decode lookup, and a pushbutton edge trigger.

Decode function retrieves a digit from a lookup table to drive seven-segment patterns. The display writes each pattern bit to outputs, avoiding flicker despite an inefficient method.

Explore how a polling algorithm reads GPIO input and detects falling edges, showing why short button presses can be missed due to the scanner's delay and input-read rate.

Identify why the LCD display algorithm is blocking and polling-based, causing CPU busy-wait and flicker on slow microcontrollers, and learn that interrupt handling offers a better alternative.

The original scan algorithm is blocking and slow on low-end CPUs, causing display flicker; use a lookup table for powers of ten and seven-segment patterns to reduce divisions and delays.

A better scanning algorithm uses a decode function to precompute seven-segment patterns via a lookup table for the digits, enabling fast index-based updates and fewer in-loop calculations.

Explore an interrupt-driven implementation using a timer interrupt service routine to periodically update a multi-digit display and, every five cycles, refresh the segments.

Explore a better approach using two periodic interrupts to update digits and pattern separately, leveraging timer interrupts, interrupt service routines, and time-sharing to create smooth, parallel-like display updates.