
A FREE comprehensive reverse engineering tutorial covering x86, x64, 32-bit/64-bit ARM, 8-bit AVR and 32-bit RISC-V architectures.
FREE EMBEDDED HACKING COURSE PROMO HERE
This lesson will teach you how to interface with the physical analog world by directly commanding the ATmega328P's Analog to Digital Converter (ADC) peripheral in pure AVR assembly.
-> Click HERE to read the lesson and see the code.
Assembled by @0xInfection (Twitter)
This tutorial will begin with the basic concepts of malware reverse engineering and graduate to an entry-level basic examination of Assembly Language.
-> Click HERE to read the FREE ebook.
This tutorial will address the two basic techniques that you can employ when analyzing malware. The first being static analysis and the other being dynamic analysis.
This tutorial will address the basic forms of malware and how they work in simple terms.
This tutorial will address x86 Assembly Languages and their usage to produce object code for the aforementioned series of processors.
This tutorial will address the very basics of the binary number system.
This tutorial will address the very basics of the hexadecimal number system.
This tutorial will address the basics of transistors and memory.
This tutorial will address the basics of memory and examine our first GDB debugger instance and examine our first real look into our computers memory and instructions.
This tutorial will address the basic architecture of an x86 processor.
This tutorial will address the general purpose x86 registers.
This tutorial will address the x86 segment registers.
This tutorial will address the x86 instruction pointer register.
This tutorial will address the x86 control registers.
This tutorial will address the status, control and systems flags.
This tutorial will address the stack.
This tutorial will address the heap.
This tutorial will address how to install Ubuntu Linux on both Windows and MAC.
This tutorial will address how to install the vim text editor.
This tutorial will address the age old question of why to bother understanding the basics of Assembly Language.
This tutorial will address op codes and instruction code handling.
This tutorial will address how to compile a basic x86 Assembly Program.
This tutorial will address how to create our first real Assembly Program by moving immediate data.
This tutorial will address how to debug our first real Assembly Program by moving immediate data.
This tutorial will address how to hack our first real Assembly Program by moving immediate data.
This tutorial will address how to create our second real Assembly Program by moving between registers.
This tutorial will address how to debug our second real Assembly Program by moving between registers.
This tutorial will address how to hack our second real Assembly Program by moving between registers.
This tutorial will address how to create our third real Assembly Program by moving between memory and registers.
This tutorial will address how to debug our third real Assembly Program by moving between memory and registers.
This tutorial will address how to hack our third real Assembly Program by moving between memory and registers.
This tutorial will address how to create our fourth real Assembly Program by moving between registers and memory.
This tutorial will address how to debug our fourth real Assembly Program by moving between registers and memory.
This tutorial will address how to hack our fourth real Assembly Program by moving between registers and memory.
This tutorial will address how to create our fifth real Assembly Program by indirect addressing with registers.
This tutorial will address how to debug our fifth real Assembly Program by indirect addressing with registers.
This tutorial will address how to hack our fifth real Assembly Program by indirect addressing with registers.
This tutorial will address how to hack our sixth real Assembly Program with CMOV instructions.
This tutorial will address how to debug our sixth real Assembly Program with CMOV instructions.
This tutorial will conclude this x86 tutorial.
This tutorial will introduce our ARM-32 Course 1 tutorial series.
This tutorial will discuss number systems such as binary, decimal and hexadecimal in detail.
This tutorial will discuss binary addition.
This tutorial will discuss binary subtraction.
This tutorial will discuss word lengths.
This tutorial will discuss registers.
This tutorial will discuss the program counter.
This tutorial will discuss the CPSR.
This tutorial will discuss the Link Register.
This tutorial will discuss the Stack Pointer.
This tutorial will discuss ARM Firmware Boot Procedures.
This tutorial will discuss Von Neumann Architecture.
This tutorial will discuss the instruction pipeline.
This tutorial will discuss the add instruction.
This tutorial will discuss debugging the add instruction.
This tutorial will discuss hacking the add instruction.
This tutorial will discuss the adds instruction.
This tutorial will discuss debugging the adds instruction.
This tutorial will discuss hacking the adds instruction.
This tutorial will discuss the ADC instruction.
This tutorial will discuss debugging the ADC instruction.
This tutorial will discuss hacking the ADC instruction.
This tutorial will discuss the SUB instruction.
This tutorial will discuss debugging the SUB instruction.
This tutorial will discuss hacking the SUB instruction.
This tutorial will introduce our ARM-32 Course 2 course.
This tutorial will discuss number systems.
This tutorial will discuss program counter.
This tutorial will discuss the link register.
This tutorial will discuss the stack pointer.
This tutorial will discuss the firmware boot procedures.
This tutorial will discuss the Von Neumann Architecture.
This tutorial will discuss the basics of a hello world program in ARM 32-bit.
This tutorial will discuss debugging hello world.
This tutorial will discuss hacking hello world.
This tutorial will discuss constants.
This tutorial will discuss debugging constants.
This tutorial will discuss hacking constants.
This tutorial will discuss character variables.
This tutorial will discuss debugging character variables.
This tutorial will discuss hacking character variables.
This tutorial will discuss boolean variables.
This tutorial will discuss debugging boolean variables.
This tutorial will discuss hacking boolean variables.
This tutorial will discuss integer variables.
This tutorial will discuss debugging integer variables.
This tutorial will discuss hacking integer variables.
This tutorial will discuss float variables.
This tutorial will discuss debugging float variables.
This tutorial will discuss hacking float variables.
This tutorial will discuss double variables.
This tutorial will discuss debugging double variables.
This tutorial will discuss hacking double variables.
This tutorial will discuss the sizeof operator.
This tutorial will discuss debugging sizeof operator.
This tutorial will discuss hacking sizeof operator.
This tutorial will discuss the pre-increment operator.
This tutorial will discuss debugging pre-increment operator.
This tutorial will discuss hacking pre-increment operator.
This tutorial will discuss the post-increment operator.
This tutorial will discuss debugging post-increment operator.
This tutorial will discuss hacking post-increment operator.
This tutorial will discuss the pre-decrement operator.
This tutorial will discuss debugging pre-decrement operator.
This tutorial will discuss hacking pre-decrement operator.
This tutorial will discuss post-decrement operator.
This tutorial will discuss debugging post-decrement operator.
This tutorial will discuss hacking post-decrement operator.
ARM 32-bit Raspberry Pi Hacking Hello World example in Kali Linux.
-> Click HERE to read the project on GitHub.
ARM 32-bit Raspberry Pi Hacking Int example in Kali Linux.
ARM 32-bit Raspberry Pi Hacking Float example in Kali Linux.
ARM 32-bit Raspberry Pi Hacking Double example in Kali Linux.
ARM 32-bit Raspberry Pi Hacking Char example in Kali Linux.
ARM 32-bit Raspberry Pi Char Pointer example in Kali Linux.
This tutorial will discuss the cyber revolution.
This tutorial will discuss transistors.
This tutorial will discuss logic gates.
This tutorial will discuss the general architecture.
This tutorial will discuss calling conventions.
This tutorial will discuss boolean instructions.
This tutorial will discuss pointers.
This tutorial will discuss load effective address.
This tutorial will discuss the data segment.
This tutorial will discuss the shl instruction.
This tutorial will discuss the shr instruction.
This tutorial will discuss rol instruction.
This tutorial will discuss the ror instruction.
This tutorial will discuss boot sector basics.
This tutorial will discuss more boot sector basics.
This tutorial will discuss x64 assembly.
This tutorial will discuss more x64 assembly.
This tutorial will discuss C++ code as it relates to 64-bit assembly.
This tutorial will discuss more C++ code as it relates to 64-bit assembly.
This tutorial will discuss c and how it relates to x64 assembly.
This tutorial will discuss x64 networking basics.
This tutorial will discuss the power of the C language.
This tutorial will discuss hacking variables.
This tutorial will discuss hacking branches.
This tutorial will discuss hacking pointers.
In this lesson we will discuss the course concepts and the meaning of life.
In this lesson we will discuss how to set up our development in 64-bit ARM with Kali Linux.
In this lesson we will discuss how to write and compile a simple hello world program in C++.
In this lesson we will debug our simple hello world program.
In this lesson we will hack our simple hello world program.
In this lesson we will discuss how to write and compile a simple basicio program in C++ and discuss basic input validation.
In this lesson we will discuss how to debug a simple basicio program in C++ and discuss basic input validation.
In this lesson we will discuss how to hack a simple basicio program in C++ and discuss basic input validation.
In this lesson we will discuss the char primitive datatype.
In this lesson we will discuss debugging the char primitive datatype.
In this lesson we will discuss hacking the char primitive datatype.
In this lesson we will discuss the boolean primitive datatype.
In this lesson we will discuss debugging the boolean primitive datatype.
In this lesson we will discuss hacking the boolean primitive datatype.
In this lesson we will discuss the float primitive datatype.
In this lesson we will discuss debugging the float primitive datatype.
In this lesson we will discuss hacking the float primitive datatype.
In this lesson we will discuss the double primitive datatype.
In this lesson we will discuss debugging the double primitive datatype.
In this lesson we will discuss hacking the double primitive datatype.
In this lesson we will discuss the basic setup of the development environment for the Raspberry Pi Pico.
In this lesson we will discuss the basic Hello World program.
In this lesson we will discuss debugging the basic Hello World program.
In this lesson we will discuss hacking the basic Hello World program.
In this lesson we will discuss the char data type.
In this lesson we will discuss debugging the char data type.
In this lesson we will discuss hacking the char data type.
In this lesson we will discuss the int data type.
In this lesson we will discuss debugging the int data type.
In this lesson we will discuss hacking the int data type.
In this lesson we will discuss the float data type.
In this lesson we will discuss debugging the float data type.
In this lesson we will discuss hacking the float data type.
In this lesson we will discuss the double data type.
In this lesson we will discuss debugging the double data type.
In this lesson we will discuss hacking the double data type.
In this lesson we will discuss the concept of proper input handling.
In this lesson we will discuss the importance of proper input handling in addition to breaking down our custom input function.
In this lesson we will discuss creating an effective input architecture.
In this lesson we will discuss debugging input.
This chapter covers the basics of designing a very simple Windows Assembly Language message box program in pure Assembly for both x86 and x64 architectures.
-> Click HERE to read the FREE pdf book.
This chapter covers the dynamic reverse engineering analysis, debugging, of the Hello World app in x86 Assembly.
This chapter covers the dynamic reverse engineering analysis, hacking, of the Hello World app in x86 Assembly.
This chapter covers the dynamic reverse engineering analysis, debugging, of the Hello World app in x64 Assembly.
This chapter covers the dynamic reverse engineering analysis, hacking, of the Hello World app in x64 Assembly.
This chapter covers reviewing the Windows API CreateDirectoryW and RemoveDirectoryW functions in C.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API CreateDirectoryW and RemoveDirectoryW functions in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API CreateDirectoryW and RemoveDirectoryW functions in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API CreateDirectoryW and RemoveDirectoryW functions in x64 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API CreateDirectoryW and RemoveDirectoryW functions in x64 Assembly.
This chapter covers reviewing the Windows API CopyFileW function in C.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API CopyFileW function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API CopyFileW function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API CopyFileW function in x64 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API CopyFileW function in x64 Assembly.
This chapter covers reviewing the Windows API MoveFileW function in C.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API MoveFileW function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API MoveFileW function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API MoveFileW function in x64 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API MoveFileW function in x64 Assembly.
This chapter covers reviewing the Windows API CreateFileW function in C.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API CreateFileW function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API CreateFileW function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API CreateFileW function in x64 Assembly.
This chapter covers reviewing the Windows API WriteFile function in C.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API WriteFile function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API WriteFile function in x86 Assembly.
This chapter covers dynamic reverse engineering analysis, debugging, the Windows API WriteFile function in x64 Assembly.
This chapter covers dynamic reverse engineering analysis, hacking, the Windows API WriteFile function in x64 Assembly.
This chapter covers the basics of setting up a dev environment and basic hello world style Go program for the x64 architecture.
This chapter covers debugging of the basic hello world style Go program for the x64 architecture.
This chapter covers hacking of the basic hello world style Go program for the x64 architecture.
This chapter covers Golang primitive types for the x64 architecture.
This chapter covers Golang debugging of the primitive types for the x64 architecture.
This chapter covers Golang hacking of the primitive types for the x64 architecture.
This chapter covers Golang control flow for the x64 architecture.
This chapter covers Golang debugging control flow for the x64 architecture.
This chapter covers Golang hacking control flow for the x64 architecture.
This chapter covers Golang advanced control flow for the x64 architecture.
This chapter covers Golang debugging advanced control flow for the x64 architecture.
This chapter covers Golang hacking advanced control flow for the x64 architecture.
This chapter covers the basics of setting up a dev environment and basic hello world style Rust program for the x64 architecture.
This chapter covers debugging the basic hello world style Rust program for the x64 architecture.
This chapter covers hacking the basic hello world style Rust program for the x64 architecture.
This chapter covers scalar data types within a Rust program for the x64 architecture.
This chapter covers debugging scalar data types within a Rust program for the x64 architecture.
This chapter covers hacking scalar data types within a Rust program for the x64 architecture.
This chapter covers compound data types within a Rust program for the x64 architecture.
This chapter covers debugging compound data types within a Rust program for the x64 architecture.
This chapter covers hacking compound data types within a Rust program for the x64 architecture.
This chapter covers functions within a Rust program for the x64 architecture.
This chapter covers debugging functions within a Rust program for the x64 architecture.
This chapter covers hacking functions within a Rust program for the x64 architecture.
This chapter covers control flow within a Rust program for the x64 architecture.
This chapter covers debugging control flow within a Rust program for the x64 architecture.
This chapter covers hacking control flow within a Rust program for the x64 architecture.
This chapter covers the basics of setting up wiring for an embedded Rust Pico.
This chapter covers the features of Reverse Engineering Rust Pico.
This chapter covers the project structure of Reverse Engineering Rust Pico.
This chapter covers the project step-by-step of Reverse Engineering Rust Pico.
This chapter covers the project step-by-step enqueue/dequeue of Reverse Engineering Rust Pico.
This chapter covers the project step-by-step of building and flashing Reverse Engineering Rust Pico.
This chapter covers the foundation analysis and binary structure for an embedded Rust microbit.
This chapter covers the Embassy async runtime for an embedded Rust microbit.
This chapter covers the interrupt handlers and hardware abstraction for an embedded Rust microbit.
This chapter covers the advanced system components for an embedded Rust microbit.
This chapter covers the exploitation and security assessment for an embedded Rust microbit.
This chapter covers the basics of setting up a dev environment and basic template firmware for the STM32F401CCU6 MCU.
This chapter covers the basics of the STM32F401CCU6 architecture.
This chapter covers the concept and development of the vector table within the STM32F401CCU6 architecture.
This chapter covers the linker script concept and development within the STM32F401CCU6 architecture.
This chapter covers ELF file analysis and tools within the STM32F401CCU6 architecture.
This chapter covers the ARM Cortex-M registers within the STM32F401CCU6 architecture.
This chapter covers the ARM Thumb2 instruction set within the STM32F401CCU6 architecture.
This chapter covers the basic load & store instructions in addition to real-time hacking within the STM32F401CCU6 architecture.
This chapter covers the basic constants & literal value examples within the STM32F401CCU6 architecture.
This chapter covers the basic conditional execution within the STM32F401CCU6 architecture.
This chapter covers functions, interrupts, UART and a simple STUXNET simulation within the STM32F401CCU6 architecture.
This chapter covers the basics of setting up a dev environment and basic template firmware for the Pico 2 MCU in addition to printing hello, world.
This chapter covers the debugging of our firmware for the Pico 2 MCU hello, world program.
This chapter covers the hacking of our firmware for the Pico 2 MCU hello, world program.
This chapter covers a comprehensive embedded system analysis reviewing parts of the RP2350 datasheet and helpful firmware analysis tools.
This chapter covers an introduction to variables as it relates to embedded development on the Pico 2.
This chapter covers debugging an introduction to variables as it relates to embedded development on the Pico 2.
This chapter covers hacking an introduction to variables as it relates to embedded development on the Pico 2.
This chapter covers uninitialized variables as well as an intro to GPIO outputs as we blink an LED as it relates to embedded development on the Pico 2.
This chapter covers debugging uninitialized variables as well as an intro to GPIO outputs as we blink an LED as it relates to embedded development on the Pico 2.
This chapter covers hacking uninitialized variables as well as an intro to GPIO outputs as we blink an LED as it relates to embedded development on the Pico 2.
This chapter covers the integer data type in addition to a deeper assembler dive into GPIO outputs as it relates to embedded development on the Pico 2.
This chapter covers debugging the integer data type in addition to a deeper assembler dive into GPIO outputs as it relates to embedded development on the Pico 2.
This chapter covers hacking the integer data type in addition to a deeper assembler dive into GPIO outputs as it relates to embedded development on the Pico 2.
This chapter covers the floating-point data type as it relates to embedded development on the Pico 2.
This chapter covers debugging the floating-point data type as it relates to embedded development on the Pico 2.
This chapter covers hacking the floating-point data type as it relates to embedded development on the Pico 2.
This chapter covers the double floating-point data type as it relates to embedded development on the Pico 2.
This chapter covers debugging the double floating-point data type as it relates to embedded development on the Pico 2.
This chapter covers hacking the double floating-point data type as it relates to embedded development on the Pico 2.
This chapter covers static variables as well as an intro to GPIO inputs as we work with push buttons as it relates to embedded development on the Pico 2.
This chapter covers debugging static variables as well as an intro to GPIO inputs as we work with push buttons as it relates to embedded development on the Pico 2.
This chapter covers hacking static variables as well as an intro to GPIO inputs as we work with push buttons as it relates to embedded development on the Pico 2.
This chapter covers constants as well as an intro to I2C as we work a 1602 LCD as it relates to embedded development on the Pico 2.
This chapter covers debugging constants as well as an intro to I2C as we work a 1602 LCD as it relates to embedded development on the Pico 2.
This chapter covers hacking constants as well as an intro to I2C as we work a 1602 LCD as it relates to embedded development on the Pico 2.
This chapter covers operators as well as an intro to single-wire protocol as we work a DHT11 temperature and humidity sensor as it relates to embedded development on the Pico 2.
This chapter covers debugging operators as well as an intro to single-wire protocol as we work a DHT11 temperature and humidity sensor as it relates to embedded development on the Pico 2.
This chapter covers hacking operators as well as an intro to single-wire protocol as we work a DHT11 temperature and humidity sensor as it relates to embedded development on the Pico 2.
This chapter covers static conditionals as well as an intro to PWM as we work a SG90 servo motor as it relates to embedded development on the Pico 2.
This chapter covers debugging static conditionals as well as an intro to PWM as we work a SG90 servo motor as it relates to embedded development on the Pico 2.
This chapter covers hacking static conditionals as well as an intro to PWM as we work a SG90 servo motor as it relates to embedded development on the Pico 2.
This chapter covers dynamic conditionals as well as additional PWM examples as we work a SG90 servo motor as it relates to embedded development on the Pico 2.
This chapter covers debugging dynamic conditionals as well as additional PWM examples as we work a SG90 servo motor as it relates to embedded development on the Pico 2.
This chapter covers hacking dynamic conditionals as well as additional PWM examples as we work a SG90 servo motor as it relates to embedded development on the Pico 2.
This chapter covers structures as well as an intro to infrared basics as we work a infrared receiver and infrared remote controller as it relates to embedded development on the Pico 2.
This chapter covers debugging structures as well as an intro to infrared basics as we work a infrared receiver and infrared remote controller as it relates to embedded development on the Pico 2.
This chapter covers hacking structures as well as an intro to infrared basics as we work a infrared receiver and infrared remote controller as it relates to embedded development on the Pico 2.
This chapter covers functions, w/ params and w/ a return value as well as additional infrared examples as we work a infrared receiver and infrared remote controller it relates to embedded development on the Pico 2.
This chapter covers debugging functions, w/ params and w/ a return value as well as additional infrared examples as we work a infrared receiver and infrared remote controller as it relates to embedded development on the Pico 2.
This chapter covers hacking functions, w/ params and w/ a return value as it relates to embedded development on the Pico 2.
This chapter covers the basics Ohm's Law and basic electronics.
This chapter covers the basics of the binary number system.
This chapter covers the basics of the hexadecimal number system.
This chapter covers the basics of the ATmega328P Architecture.
This chapter covers the basics of setting up a toolchain and development environment.
This chapter covers the basics of the ATmega328P datasheet.
This chapter covers the development and reverse engineering of a blink driver in AVR C.
This chapter covers the development of a blink driver in AVR Assembler.
This chapter covers the development and reverse engineering of an IO driver in C.
This chapter covers the development and reverse engineering of an servo motor in C including a mock STUXNET hack.
This chapter covers the "why" of learning RISC-V hacking as we discuss the rise of RISC-V and introduce our ESP32-C3 dev board.
This chapter covers setting up your development environment including everything you need to purchase and download including setup.
This chapter covers creating your first project in PlatformIO and creating your first Assembler file to interact with your C environment.
This chapter covers the basics of binary numbers and their general application for embedded systems.
This chapter covers the basics of hexadecimal numbers and their general application for embedded systems.
This chapter covers the advanced operations using hex and binary in addition to memory manipulation and bit-level operations for the RISC-V ESP32-C3.
This chapter covers the registers for the RISC-V ESP32-C3.
This chapter covers how to add within the RISC-V ESP32-C3.
This chapter covers how to debug add within the RISC-V ESP32-C3.
A line-by-line, function-by-function guide through every Rust source file in the Wasm project covering how a WebAssembly component is compiled, deployed, and executed on a general-purpose computer entirely Rust.
-> Click HERE to read the FREE tutorial on GitHub.
-> Click HERE to read the FREE Reverse Engineering tutorial on GitHub.
A line-by-line, function-by-function guide through every Rust source file in the embedded-wasm-uart project covering how a WebAssembly component is compiled, deployed, and executed on an RP2350 microcontroller to echo UART characters entirely in bare-metal Rust with no operating system.
A line-by-line, function-by-function guide through every Rust source file in the embedded-wasm-blinky project covering how a WebAssembly component is compiled, deployed, and executed on an RP2350 microcontroller to blink an LED entirely in bare-metal Rust with no operating system.
A line-by-line, function-by-function guide through every Rust source file in the embedded-wasm-button project covering how a WebAssembly component is compiled, deployed, and executed on an RP2350 microcontroller to read a button and control an LED entirely in bare-metal Rust with no operating system.
A line-by-line, function-by-function guide through every Rust source file in the embedded-wasm-servo project covering how a WebAssembly component is compiled, deployed, and executed on an RP2350 microcontroller to control a servo motor entirely in bare-metal Rust with no operating system.
This lesson will teach you how to implement the Serial demo on an ATmega328P using pure AVR assembly.
This lesson will teach you how to blink the built-in LED on an ATmega328P using pure AVR assembly.
This lesson will teach you how to use Timer 1 and Pulse Width Modulation (PWM) to smoothly fade an LED on an ATmega328P using pure AVR assembly.
This lesson will teach you how to control an RGB LED by manipulating multiple output pins simultaneously using pure AVR assembly.
This lesson will teach you how to read digital inputs and use internal pull-up resistors to control an LED based on push buttons using pure AVR assembly.
This lesson will teach you how to generate a beeping sound using an active buzzer and pure AVR assembly.
This lesson will teach you how to generate musical tones (frequencies) using a passive buzzer and Timer1 CTC mode in pure AVR assembly.
This lesson will teach you how to detect physical orientation and gravity using a digital tilt switch in pure AVR assembly.
This lesson will teach you how to control a mechanical Servo Motor by generating precise Pulse Width Modulation (PWM) signals using Timer1 in pure AVR assembly.
This lesson will teach you how to implement sub-millisecond precision timing loops to measure physical distance using an HC-SR04 ultrasonic sensor in pure AVR assembly.
This lesson will teach you how to write a software driver for a single-wire digital communications protocol to read humidity and temperature from a DHT11 sensor in pure AVR assembly.
This lesson will teach you how to write a high-speed assembly loop to visualize the invisible digital data packets transmitted through the air by a TV remote control.
This lesson will teach you how to write a software driver for a 16x2 Character LCD Display (HD44780), utilizing advanced bit manipulation (BST/BLD) to correct hardware wiring inconsistencies in pure AVR assembly.
This lesson will teach you how to read a 10-bit analog Thermistor value via the ADC and implement a "repeated subtraction" algorithm to convert the 16-bit binary integer into ASCII text digits for display on a 16x2 LCD screen.
This lesson will teach you how to expand your microcontroller's outputs by implementing a custom Serial Peripheral interface driver (bit-banging) to drive an 8-bit Shift Register, animating a "Knight Rider" LED chaser.
This lesson will teach you how to implement a full two-way Serial Communications (USART) interface in bare metal assembly, parsing incoming byte commands from a desktop computer to remotely control the 8-bit Shift Register array.
This lesson will teach you how to divide ADC sensor data using a "repeated subtraction" algorithm and use the SEC (Set Carry) and ROL (Rotate Left through Carry) instructions to dynamically build and display an LED bar graph on a Shift Register.
This lesson introduces Harvard Architecture memory spaces by teaching you how to permanently bake data arrays into the ATmega328P's Flash Program Memory (.text) and retrieve them using 16-bit pointer arithmetic and the Z-Pointer (LPM) to draw numbers on a 7-Segment Display.
This lesson will teach you how to write time-critical execution loops to achieve time-domain multiplexing, using the Persistence of Vision (POV) optical illusion to drive a 4-Digit 7-Segment Display with a minimal number of pins.
This lesson will teach you how to configure 16-bit Timer Peripherals in Fast PWM Mode to generate high-frequency logic signals that control the speed and direction of a physical DC Motor via an L293D H-Bridge driver.
This lesson will teach you how to use Galvanic Isolation and Electromechanical Relays to safely control high-voltage, high-current appliances using low-voltage logic signals from your ATmega328P.
This lesson will teach you the physics of Stepper Motors and how to write a manual "Wave Drive" sequence algorithm in assembly to control a ULN2003 Darlington Array Driver.
This final lesson combines hardware interrupts, peripheral polling, and wave-drive sequence algorithms to build a completely wireless, remote-controlled motorized system in pure assembly.
This lesson will teach you what is a computer with the fundamental model of computation that every computer shares with an intro to the RP2350 and ARM Cortex-M33.
This lesson will teach the basics of the three main number systems which are decimal, binary and hexadecimal.
This lesson will teach the basics addresses, bytes, words and endianness within the MCU.
This lesson will teach the general purpose registers within the MCU.
This lesson will teach how ARM accesses memory with load and store architecture within the MCU.
This lesson will teach the fetch and decode cycle in more detail within the MCU.
This lesson will teach the ARM Cortex-M33 ISA overview within the MCU.
This lesson will teach ARM immediate and move instructions within the MCU.
This lesson will teach ARM arithmetic and logic instructions within the MCU.
This lesson will teach ARM memory access instructions within the MCU.
This lesson will teach ARM branch instructions within the MCU.
This lesson will teach ARM calls, returns and the stack frame within the MCU.
This lesson will teach assembler directives within the MCU.
This lesson will teach labels, symbols and the symbol table within the MCU.
This lesson will teach sections, memory layout, and the linker script within the MCU.
This lesson will teach system registers and coprocessor interface within the MCU.
This lesson will teach bit manipulation patterns within the MCU.
This lesson will teach RP2350 hardware architecture within the MCU.
This lesson will teach the linker script within the MCU.
This lesson will teach the build system within the MCU.
This lesson will teach the PICOBIN boot block within the MCU.
This lesson will teach memory addresses and constants within the MCU.
This lesson will teach the boot foundation within the MCU.
This lesson will teach the boot sequence within the MCU.
This lesson will teach the crystal oscillator and clock configuration within the MCU.
This lesson will teach releasing peripherals from reset within the MCU.
This lesson will teach GPIO config within the MCU.
This lesson will teach output control and timing within the MCU.
This lesson will teach the blink loop within the MCU.
This lesson will teach the full source to blinking LED within the MCU.
This lesson will teach you what is a computer with the fundamental model of computation that every computer shares with an intro to the RP2350 and RISC-V.
This lesson will teach the basics of addresses, bytes, words and endianness within the MCU.
This lesson will teach how RISC-V accesses memory with load and store architecture within the MCU.
This lesson will teach the fetch, decode and execute cycle in detail within the MCU.
This lesson will teach the RISC-V Hazard3 ISA overview within the MCU.
This lesson will teach RISC-V immediate and upper-immediate instructions within the MCU.
This lesson will teach RISC-V arithmetic and logic instructions within the MCU.
This lesson will teach RISC-V memory access load and store instructions in deep detail within the MCU.
This lesson will teach RISC-V branch instructions within the MCU.
This lesson will teach RISC-V jumps, calls and returns within the MCU.
This lesson will teach RISC-V pseudo-instructions within the MCU.
This lesson will teach the calling convention and stack frames within the MCU.
This lesson will teach bitwise operations for hardware programming within the MCU.
This lesson will teach memory-mapped I/O within the MCU.
This lesson will teach the RP2350 architecture and hardware within the MCU.
This lesson will teach the linker script and how code is placed in memory within the MCU.
This lesson will teach the build pipeline from assembly to flashable binary within the MCU.
This lesson will teach the image_def.s boot metadata within the MCU.
This lesson will teach the constants.s file within the MCU.
This lesson will teach the stack and vector table within the MCU.
This lesson will teach the reset_handler.s boot sequence within the MCU.
This lesson will teach the xosc.s oscillator initialization within the MCU.
This lesson will teach the reset.s reset controller within the MCU.
This lesson will teach the gpio.s GPIO configuration part 1 within the MCU.
This lesson will teach the gpio.s GPIO set/clear, delay.s and coprocessor.s within the MCU.
This lesson will teach the main.s application entry point within the MCU.
This lesson will teach the full build, flash, wire and test integration within the MCU.
This lesson will teach what embedded Rust is within the MCU.
This lesson will teach number systems and memory within the MCU.
This lesson will teach the Rust essentials within the MCU.
This lesson will teach ownership, borrowing and lifetimes within the MCU.
This lesson will teach structs, enums and pattern matching within the MCU.
This lesson will teach traits and generics within the MCU.
This lesson will teach no_std and no_main within the MCU.
This lesson will teach cargo, targets and the toolchain within the MCU.
This lesson will teach the memory.x linker script within the MCU.
This lesson will teach the build.rs, Makefile and flashing process within the MCU.
This lesson will teach real-time and concurrency within the MCU.
This lesson will teach futures and async/await within the MCU.
This lesson will teach the Embassy executor within the MCU.
This lesson will teach embassy-time within the MCU.
This lesson will teach the embassy-rp HAL within the MCU.
This lesson will teach GPIO with embassy-rp within the MCU.
This lesson will teach the driver architecture within the MCU.
This lesson will teach the config.rs blink configuration within the MCU.
This lesson will teach the led.rs LED state machine within the MCU.
This lesson will teach the main.rs async blink loop within the MCU.
This lesson will teach button hardware and debouncing within the MCU.
This lesson will teach the button.rs button controller within the MCU.
This lesson will teach the main.rs button polling loop within the MCU.
This lesson will teach host testing with cargo test within the MCU.
This lesson will teach UART fundamentals and the echo protocol within the MCU.
This lesson will teach the uart.rs echo state machine within the MCU.
This lesson will teach interrupts and DMA interrupt-driven UART within the MCU.
This lesson will teach the main.rs UART echo loop within the MCU.
This lesson will teach the complete integration within the MCU.
This lesson will teach the Central Limit Theorem, the standard error of the mean, and confidence intervals.
This lesson will teach exploratory data analysis on the Penguins dataset.
This lesson will teach KMeans clustering and principal component analysis.
This lesson will teach simple linear regression with a linear relationship.
This lesson will teach simple linear regression with a non-linear relationship.
This lesson will teach fitting a linear feature.
This lesson will teach fitting a non-linear feature.
This lesson will teach fitting linear feature predictions.
This lesson will teach fitting non-linear feature predictions.
This lesson will teach measuring linear feature performance.
This lesson will teach fitting multiple models.
This lesson will teach multiple linear regression with additive features.
This lesson will teach multiple linear regression with interactive features.
This lesson will teach linear regression, cross-validation, and a complete inference engine.
This lesson will teach logistic regression, ROC, and AUC.
This lesson will teach a multilayer perceptron in PyTorch.
This lesson will teach a convolutional neural network on Fashion-MNIST.
This lesson will teach a recurrent neural network on Tiny Shakespeare.
This lesson will teach attention and a transformer block from scratch.
This lesson will teach building TinyGPT from scratch.
This lesson will teach regularization and early stopping.
This lesson will teach model evaluation, calibration, and threshold tuning.
This lesson will teach an autoencoder, latent space, and anomaly detection.
This lesson will teach a generative adversarial network.
This lesson will teach a vision transformer from scratch.
This lesson will teach model deployment with ONNX and a command-line interface.
This lesson will teach U-Net semantic segmentation.
This lesson will teach a deep Q-network on CartPole.
This lesson will teach fine-tuning a pretrained language model.
This lesson will teach creating a Kaggle project from scratch with EDA and a binary classifier.