Assembly Language Programming

Set up the assembly environment by installing Visual Studio Code, downloading code-the-machine files, and configuring paths and tasks for Windows or Mac; then load the assembled code in Logisim.

Learn to add two numbers in assembly by loading literals into registers R0 and R1, performing add, and ending the program at 8000 hexadecimal, with assembly and machine code steps.

Learn basic arithmetic in assembly by coding add, subtract, multiply, and divide routines for registers r0 and r1, using a memory origin and validating with a logic sim.

Explore how to implement loops in assembly language using labels to jump back and increment r0, with cmp and jump if equal to stop.

Learn how memory and registers interact in assembly language, using data, load, store, and the stack with push and pop.

Explore the assembly language instruction set with examples of load, store, jump, push, pop, move, and boolean operations; learn addressing modes, subroutines, and a pixel-based graphics starter for shapes.

Explore dc and origin directives to define constants, allocate data memory at a start address, define storage with rds, then load values into registers and add them together.

Develop and test a simple add subroutine using jsr and ret, compare it with gmp jump, and examine stack-based return addresses in a memory model.

Split the subroutine from the calling function, place the subroutine in rom (bios) and the caller in ram, and demonstrate passing by value or by reference via the stack.

Explore how assembly libraries group subroutines into graphics, string, mathematics, and fixed-point libraries stored in ROM, accessed via a calling function and stack-based arguments.

Explore the ROM graphics library, starting with the pixel command to plot pixels and build lines, triangles, and circles, then use the plot subroutine for easy on-screen plotting.

Explore how to call graphics subroutines and push coordinates and colors on the stack. Apply Bresenham-based line and circle algorithms to render lines, circles, triangles, and rectangles.

Learn the basic mathematics library with integer-only functions: power, modulo, factorial (recursive), and square root, implemented as subroutines that pass values via the stack and return results to memory.

Learn to generate and manipulate vectors using arrays, perform addition, subtraction, scalar multiplication, dot and cross products, and store results in dedicated memory arrays.

Learn to generate and manipulate matrices in the assembly language, including addition, subtraction, determinants, transpose, and multiplication, with practical on-machine demonstrations.

Represent complex numbers as a two-element array (real and imaginary parts) and perform add, subtract, conjugate, and multiply (scalar and complex) via subroutines in a stack-based assembly workflow.

Explore the string library in assembly language, including string literals in double quotes, the string delimiter, and ascii conversion. Demonstrates length calculation, concatenation, and copy via stack and subroutines.

Explore the fixed point library, using fixed point numbers with F, add, subtract, multiply, divide, and a power function, then derive sine, cosine, tangent, and exponential via Taylor series.

Explore the sine function by generating and comparing values from 0 to 2 pi radians in 0.1 radian steps, using an 8.8 fixed-point system and analyzing small systematic errors.

Explore building an assembly language integer calculator that performs add, subtract, multiply, divide, and modulo for positive and negative integers.

Demonstrate a three-term Fourier series in assembly language to approximate square wave, using 4/pi sin x, 4/(3 pi) sin 3x, 4/(5 pi) sin 5x, evaluated from 0 to 2 pi.

Develop a three-term Fourier series approximation of a triangular wave and implement it in assembly language, loading into ROM and RAM for a CPU simulation and result comparison.

Demonstrate least-squares linear regression on the CPU, using five points to derive the gradient and intercept of y = mx + c and plot the result via Bresenham's algorithm.

Apply the rectangular rule to numerical integration with dx and n rectangles. Explore center-point heights and an assembly language implementation using floating point calculations for area under a curve.

Explains the trapezoidal rule for numerical integration of y = x^2 from 1 to 3 using four subintervals, showing height averaging, dx, and a result of 8.75 in assembly language.

Explore numerical differentiation using central difference, forward and backward differences, and implement the simple algorithm for f(x)=x^2 at x=1 with h=0.1 to obtain the derivative of 2.

Apply the Newton-Raphson method to approximate roots of x squared minus two, starting from the initial guess of two, using tangent lines to converge toward 1.414.

Use the Newton-Raphson method to compute the square root of c by iterating I_next = (I + c/I)/2, with an initial guess, mirroring the Babylonian approach in assembly.

Tackle a coding challenge to compute the sum of the first n terms of an arithmetic progression, illustrated by 1 to 100, yielding 5050, with assembly language implementation.

This lecture demonstrates summing the first ten terms with fixed-point arithmetic to handle odd n, contrasts integer and fixed-point methods, and presents a stack-based assembly approach showing zero cross 3700.