LAB 02

Exploring Mob Programming with 6502 Assembly Language

What is Mob Programming?

Mob Programming is an advanced form of Pair Programming where the entire team works together on the same problem at the same time, sharing a single computer and screen. While one person acts as the "Driver" and types the code, the others, known as "Observers," provide suggestions, guidance, and feedback. The role of the Driver rotates regularly to ensure that everyone contributes to the solution and gains experience.

How to Implement Mob Programming in 6502 Assembly

Step 1: Team Roles and Setup

  • The Driver: The Driver is the person who actively writes the code. They are responsible for typing out the instructions and maintaining the structure of the program.
  • Observers: These are the team members who aren't typing but are actively involved in the process. They provide input, suggest improvements, discuss ideas, and review code as it’s written. Their primary job is to ensure the code is of high quality.

Step 2: Collaborate and Code Together

While the Driver is working, the Observers will help with key decisions, such as:

  • Choosing how to structure the code: 6502 Assembly can be tricky in terms of managing variables, memory locations, and subroutines. The team can brainstorm the best way to structure the program.
  • Problem-solving: The Observers should point out any mistakes or inefficiencies as the Driver types, helping to ensure high-quality, optimized code.
  • Improving readability: Assembly can often become cryptic, so the team should discuss ways to make the code more readable and maintainable for others.

Step 3: Testing and Debugging

After writing and compiling the code, the team should test it in the emulator. During testing, the Driver can execute the program while the Observers note any bugs or areas for improvement. 6502

Bouncing Graphic Challenge in 6502 Assembly

A great way to experience Mob Programming in 6502 Assembly is to create a "Bouncing Graphic" program. Here’s a simplified outline of the process:

  1. Initialize Variables: Define the starting coordinates for the graphic, such as X = $20 and Y = $21, and set their increments (either +1 or -1).

  2. Move the Graphic: Add the X and Y increments to move the graphic across the screen. The graphic should move diagonally, adjusting its X and Y positions with each frame.

  3. Handle Screen Boundaries: Make sure the graphic "bounces" when it reaches the edge of the screen. This involves checking if the graphic’s position exceeds the screen boundaries (both horizontally and vertically) and adjusting the direction of movement accordingly.

  4. Testing and Adjustments: Test the program and adjust the logic as needed to ensure smooth animation and proper bouncing behavior.


Benefits of Mob Programming in 6502 Assembly

  • Collective Knowledge
  • Improved Code Quality
  • Enhanced Problem Solving
  • Effective Learning

Challenges of Mob Programming in Assembly

  • Communication Overload
  • Steep Learning Curve
  • Time-Intensive

Conclusion

Mob Programming is an excellent approach for tackling challenging tasks like 6502 Assembly programming. By leveraging collective knowledge and collaborative problem-solving, teams can overcome the complexities of low-level programming while improving code quality and sharing valuable insights. 

OUTPUTS & CODE






;
; draw-image-subroutine.6502
;
; This is a routine that can place an arbitrary 
; rectangular image on to the screen at given
; coordinates.
;
; Chris Tyler 2024-09-17
; Licensed under GPLv2+
;

;
; The subroutine is below starting at the 
; label "DRAW:"
;

; Test code for our subroutine
; Moves an image diagonally across the screen

; Zero-page variables
define XPOS $20
define YPOS $21


START:

; Set up the width and height elements of the data structure
  LDA #$05
  STA $12       ; IMAGE WIDTH
  STA $13       ; IMAGE HEIGHT

; Set initial position X=Y=0
  LDA #$00
  STA XPOS
  STA YPOS

; Main loop for diagonal animation
MAINLOOP:

  ; Set pointer to the image
  ; Use G_O or G_X as desired
  ; The syntax #<LABEL returns the low byte of LABEL
  ; The syntax #>LABEL returns the high byte of LABEL

  LDA #<G_O
  STA $10
  LDA #>G_O
  STA $11

  ; Place the image on the screen
  LDA #$10  ; Address in zeropage of the data structure
  LDX XPOS  ; X position
  LDY YPOS  ; Y position
  JSR DRAW  ; Call the subroutine

  ; Delay to show the image
  LDY #$00
  LDX #$50
DELAY:
  DEY
  BNE DELAY
  DEX
  BNE DELAY

  ; Set pointer to the blank graphic
  LDA #<G_BLANK
  STA $10
  LDA #>G_BLANK
  STA $11

  ; Draw the blank graphic to clear the old image
  LDA #$10 ; LOCATION OF DATA STRUCTURE
  LDX XPOS
  LDY YPOS
  JSR DRAW

  ; Increment the position
  INC XPOS
  INC YPOS

  ; Continue for 29 frames of animation
  LDA #28
  CMP XPOS
  BNE MAINLOOP

  ; Repeat infinitely
  JMP START

; ==========================================
;
; DRAW :: Subroutine to draw an image on 
;         the bitmapped display
;
; Entry conditions:
;    A - location in zero page of: 
;        a pointer to the image (2 bytes)
;        followed by the image width (1 byte)
;        followed by the image height (1 byte)
;    X - horizontal location to put the image
;    Y - vertical location to put the image
;
; Exit conditions:
;    All registers are undefined
;
; Zero-page memory locations
define IMGPTR    $A0
define IMGPTRH   $A1
define IMGWIDTH  $A2
define IMGHEIGHT $A3
define SCRPTR    $A4
define SCRPTRH   $A5
define SCRX      $A6
define SCRY      $A7

DRAW:
  ; SAVE THE X AND Y REG VALUES
  STY SCRY
  STX SCRX

  ; GET THE DATA STRUCTURE
  TAY
  LDA $0000,Y
  STA IMGPTR
  LDA $0001,Y
  STA IMGPTRH
  LDA $0002,Y
  STA IMGWIDTH
  LDA $0003,Y
  STA IMGHEIGHT

  ; CALCULATE THE START OF THE IMAGE ON
  ; SCREEN AND PLACE IN SCRPTRH
  ;
  ; THIS IS $0200 (START OF SCREEN) +
  ; SCRX + SCRY * 32
  ; 
  ; WE'LL DO THE MULTIPLICATION FIRST
  ; START BY PLACING SCRY INTO SCRPTR
  LDA #$00
  STA SCRPTRH
  LDA SCRY
  STA SCRPTR
  ; NOW DO 5 LEFT SHIFTS TO MULTIPLY BY 32
  LDY #$05     ; NUMBER OF SHIFTS
MULT:
  ASL SCRPTR   ; PERFORM 16-BIT LEFT SHIFT
  ROL SCRPTRH
  DEY
  BNE MULT

  ; NOW ADD THE X VALUE
  LDA SCRX
  CLC
  ADC SCRPTR
  STA SCRPTR
  LDA #$00
  ADC SCRPTRH
  STA SCRPTRH

  ; NOW ADD THE SCREEN BASE ADDRESS OF $0200
  ; SINCE THE LOW BYTE IS $00 WE CAN IGNORE IT
  LDA #$02
  CLC
  ADC SCRPTRH
  STA SCRPTRH
  ; NOTE WE COULD HAVE DONE TWO: INC SCRPTRH

  ; NOW WE HAVE A POINTER TO THE IMAGE IN MEM
  ; COPY A ROW OF IMAGE DATA
COPYROW:
  LDY #$00
ROWLOOP:
  LDA (IMGPTR),Y
  STA (SCRPTR),Y
  INY
  CPY IMGWIDTH
  BNE ROWLOOP

  ; NOW WE NEED TO ADVANCE TO THE NEXT ROW
  ; ADD IMGWIDTH TO THE IMGPTR
  LDA IMGWIDTH
  CLC
  ADC IMGPTR
  STA IMGPTR
  LDA #$00
  ADC IMGPTRH
  STA IMGPTRH
 
  ; ADD 32 TO THE SCRPTR
  LDA #32
  CLC
  ADC SCRPTR
  STA SCRPTR
  LDA #$00
  ADC SCRPTRH
  STA SCRPTRH

  ; DECREMENT THE LINE COUNT AND SEE IF WE'RE
  ; DONE
  DEC IMGHEIGHT
  BNE COPYROW

  RTS

; ==========================================

; 5x5 pixel images

; Image of a blue "O" on black background
G_O:
DCB $00,$0e,$0e,$0e,$00
DCB $0e,$00,$00,$00,$0e
DCB $0e,$00,$00,$00,$0e
DCB $0e,$00,$00,$00,$0e
DCB $00,$0e,$0e,$0e,$00

; Image of a yellow "X" on a black background
G_X:
DCB $07,$00,$00,$00,$07
DCB $00,$07,$00,$07,$00
DCB $00,$00,$07,$00,$00
DCB $00,$07,$00,$07,$00
DCB $07,$00,$00,$00,$07

; Image of a black square
G_BLANK:
DCB $00,$00,$00,$00,$00
DCB $00,$00,$00,$00,$00
DCB $00,$00,$00,$00,$00
DCB $00,$00,$00,$00,$00
DCB $00,$00,$00,$00,$00













Comments

Post a Comment

Popular posts from this blog

Project Stage 1: Create a GCC pass

Image
  🎬SPO600 2025 Winter Project - Project Stage 1: Create a Basic GCC Pass SUMMARY: A GCC pass is a step in the compilation process that processes intermediate representations (IR) of the source code, performing various optimizations and analyses before generating the final machine code. The objective of this project is to extend the GCC compiler by adding a custom pass that can analyze the functions being compiled. 一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一 💣How Is This Custom Pass Going to Work?  Iterates through all of the compiled code's functions. Outputs the name of the function under analysis. Determines how many fundamental blocks there are in the function. Determines how many GIMPLE statements are there in each function. 一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一 ⭐STEP 1 =================>  VEFIRFYING DETAILS💬 Lab 04 ✅ GCC source and build directories were correctly set up✅ Command to verify : ls  -l ~✅ 一一一一一一一一一一一一一一一一一一一一一一一一一一...
Read more

LAB 03

Image
6502 Assembly Programming Lab: Creating a Simple Number Guessing Game Introduction In this lab, I had the opportunity to dive into 6502 assembly programming by creating a simple program that meets a set of criteria for outputting both on the character screen and the graphics screen, accepting user input, and utilizing arithmetic operations. The task was part of a larger effort to explore the 6502 microprocessor, with the goal of building the skills needed for more complex x86_64 and AArch64 assembly language programming. Requirements The lab had the following main requirements: The program must work in the 6502 Emulator. It must output to both the character (text) screen and the graphics (bitmapped) screen. It must accept user input from the keyboard. It must incorporate arithmetic/math instructions (e.g., adding, subtracting, bitwise operations, etc.). Plan I planned the following structure for the Number Guessing Game : Generate a random number : Use the 6502's random byte genera...
Read more

Project Stage 2: Part 2( The End)

Image
In this part of the project, I will be analyzing the cloned functions to demonstrate how the Clone-Prune Analysis Pass works in practice. Specifically, I’ll take a closer look at the scale_samples functions from the clone-test-prune and clone-test-noprune test files, which were provided for testing and not created by me. The goal here is to show how the pass successfully identifies substantially identical cloned functions (for pruning) and highlights differences that should prevent pruning. Clone-Prune Test Files Comparison: Let’s start by reviewing the clone-test-prune files. These contain the functions scale_samples.default , scale_samples.Mrng , and scale_samples.resolver . Our goal is to compare scale_samples.default and scale_samples.Mrng , which should be identical and therefore should be pruned. scale_samples.default: scale_samples.Mrng: As you can see, scale_samples.default and scale_samples.Mrng are nearly identical, except for their memory addresses (as highlighte...
Read more