Lab 1 - Modifying Code

 7. Change the code to fill the display with light blue instead of yellow.


lda #$00	; set a pointer in memory location $40 to point to $0200
 	sta $40		; ... low byte ($00) goes in address $40
 	lda #$02	
 	sta $41		; ... high byte ($02) goes into address $41
 	lda #$06	; colour changes to blue from yellow
 	ldy #$00	; set index to 0
 loop:	sta ($40),y	; set pixel colour at the address (pointer)+Y
 	iny		; increment index
 	bne loop	; continue until done the page (256 pixels)
 	inc $41		; increment the page
 	ldx $41		; get the current page number
 	cpx #$06	; compare with 6
 	bne loop	; continue until done all pages


 8. Change the code to fill the display with a different colour on each page (each “page” will be one-quarter of the bitmapped display).


This program fills the screen with alternating colors using indexed addressing and loops. It begins by setting up a pointer at $40-$41 to start at the memory location $0200 and storing four color codes in addresses $42-$45. A second pointer, $46-$47, is used to reference the current color.

In the Colorloop, the code fetches the current color using the $46-$47 pointer and writes it to the screen at the location specified by $40-$41 + Y. The Y register increments to move to the next pixel on the current page. Once a page (256 pixels) is complete, the high byte of the pointer ($41) is incremented to move to the next page, while $46 updates to the next color code, creating a cycling color effect. The loop continues until all six pages are filled, efficiently alternating colors across the screen.


lda #$00        ; Load low byte of the address $0200 into the accumulator
sta $40         ; Store low byte ($00) in memory address $40
lda #$02        ; Load high byte of the address $0200 into the accumulator
sta $41         ; Store high byte ($02) in memory address $41
lda #$e         ; Load light blue color code (#$e) into the accumulator
sta $42         ; Store light blue color code in memory address $42
lda #$2         ; Load red color code (#$2) into the accumulator
sta $43         ; Store red color code in memory address $43
lda #$5         ; Load green color code (#$5) into the accumulator
sta $44         ; Store green color code in memory address $44
lda #$7         ; Load yellow color code (#$7) into the accumulator
sta $45         ; Store yellow color code in memory address $45
lda #$42        ; Load the high byte of the color pointer into the accumulator
sta $46         ; Store the high byte in memory address $46
lda #$00        ; Load the low byte of the color pointer into the accumulator
sta $47         ; Store the low byte in memory address $47
ldy #$00        ; Initialize the index register Y to 0

Colorloop:
lda ($46),y     ; Load the current color code using the pointer at $46-$47, offset by Y

loop:
sta ($40),y     ; Store the color code at the current pixel address (pointer $40-$41 + Y)
iny             ; Increment the index register Y
bne loop        ; If Y hasn’t overflowed, continue the loop for the current page
inc $46         ; Increment the color pointer (move to the next color)
inc $41         ; Increment the page number (high byte of the address pointer)
ldx $41         ; Load the current page number into the index register X
cpx #$06        ; Compare the current page number with 6 (stop condition)
bne Colorloop   ; If not done with all pages, repeat the color loop



9. Make each pixel a random colour. (Hint: use the psudo-random number generator mentioned on the 6502 Emulator page).

lda #$00        ; Load the low byte of the address $0200 into the accumulator
sta $40         ; Store the low byte ($00) in memory address $40
lda #$02        ; Load the high byte of the address $0200 into the accumulator
sta $41         ; Store the high byte ($02) in memory address $41

ldy #$00        ; Initialize the index register Y to 0
loop:
lda $fe         ; Fetch a random color number from the PRNG at memory address $fe
sta ($40),y     ; Store the fetched color at the current pixel address (pointer $40-$41 + Y)
iny             ; Increment the index register Y
bne loop        ; If Y hasn’t overflowed, continue setting pixels for the current page
inc $41         ; Increment the page number (high byte of the address pointer)
ldx $41         ; Load the current page number into the index register X
cpx #$06        ; Compare the current page number with 6 (stop condition)
bne loop        ; If not done with all pages, repeat the loop for the next page
This code was designed to efficiently fill the screen with random colors on a 6502 processor. First, the pointer at $40-$41 is set to start at the screen's memory address, $0200. A random color is fetched from the pseudo-random number generator at $fe and stored at the current pixel's address. The Y register is used to navigate through each page of 256 pixels, looping until the page is complete. Once a page is filled, the high byte of the pointer ($41) is updated to move to the next page. This process continues for all six pages, ensuring the entire screen is filled with random colors. It’s a simple yet efficient approach that leverages the PRNG and structured looping for dynamic results.

Comments

Post a Comment

Popular posts from this blog

Project Stage 1

Image
In this project, I set out to create a custom GCC pass that analyzed GIMPLE files by iterating through every function, counting the basic blocks, and tallying the number of GIMPLE statements. I successfully integrated this pass into the GCC build system and tested it on a simple C program. Here’s how I did it. 1. Writing the Pass Code I began by writing the pass code in C++ and saved it in a file named tree-my-new-pass.cc within the gcc subdirectory of my GCC source. My pass, which I named "my_new_pass", was designed to run during the GIMPLE phase. The code looked like this: #include "config.h" #include "system.h" #include "coretypes.h" #include "backend.h" #include "tree-pass.h" #include "pass_manager.h" #include "context.h" #include "diagnostic-core.h" #include "tree.h" #include "tree-core.h" #include "basic-block.h" #include "gimple.h" #include "gimp...
Read more

Lab 2 - Lab Results

Introduction In this blog post, I will share my experience working on a lab where we animated a small 5x5 graphic to move diagonally across the screen and bounce off the edges. The lab required an understanding of low-level memory manipulation, conditional logic, and efficient screen rendering. I'll walk you through the code, the changes made to implement bouncing logic, and my reflections on the learning process. **Since we collaborated as a group on optimizing the code, my work may resemble that of my teammates =================================================================== Initial Code The following code moves a 5×5 graphic diagonally across the screen: ; ; 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 diagon...
Read more

Lab 5 - Part 1 - Aarch 64

Image
In this lab, my goal is to dive into assembly programming on both the x86_64 and AArch64 platforms. For Task 1, 1. I will closely examine how the AArch64 assembly source code—written in a human-readable format—is transformed into an object file containing machine code. This investigation will help me understand the assembly process by highlighting the differences between the high-level source instructions and the low-level binary output generated by the assembler. Source file Object file 2 : Constructing a Loop That Prints “Loop” Six Times In this task, I need to adapt the assembly code on the aarch64 server so that it outputs the word “Loop” exactly six times. Starting with the provided code, I will introduce a counter in one of the general-purpose registers, initialize it to zero, and increment it after each print. Once the counter reaches six, the loop will terminate. This requires adjusting the assembly instructions to compare the loop counter against a maximum value, calling the a...
Read more