DEV Community: Alexey Medvecky

Building a Fraction Calculator for the Commodore 64 in Assembly Language

Alexey Medvecky — Wed, 04 Oct 2023 06:46:48 +0000

I will guide you through creating a fraction calculator for the Commodore 64 using assembly language in this article. We will utilize KickAssembler, primarily its macros, to simplify the process.

Formulating the Problem

My journey through the 80s using the Commodore 64 to tackle mathematical problems continues. Previous parts of my journey:

A Retro Adventure: Implementing an Aspect Ratio Calculator for the Commodore 64 in Multiple Programming Languages
80s Time Travel: Commodore 64 Math with Square Root Approximation & Factorization using Assembly
Creating a Fraction Converter for the Commodore 64 in Assembly Language (6510/6502

Fractions have always been a challenge for calculators, and even in the 80s, their support was limited.

Let’s leverage the power of the Commodore 64 to solve this mathematical puzzle.
In this part, we’ll dive into creating a fraction calculator, a task that was particularly challenging back in the 80s. Follow along to see how I use the Commodore 64’s capabilities to overcome this challenge.

Solution.

As previously mentioned, the 6510 processor lacks support for floating-point operations, so we’ll rely on the software implementation from BASIC ROM. I’ll use KickAssembler and its macro capabilities to expedite the development process, a luxury that may not have been available with assemblers of the 80s.
The most commonly used macros for arithmetic operations and a macro for modulo division will be essential components of our solution.

The source file, complete with macro definitions and constants, is in this [link to git gist].

The program begins by displaying and processing menu selections, where the active use of macros becomes apparent.

Entering a String Representation of a Number

In this project, I’ve revamped the routine for the string representation of numbers, ensuring it processes only valid characters for our program. This includes the numbers 0 to 9, “-”, “return”, and “del”.

Here, in addition to the exact comparison based on the zero flag, a comparison of “more” and “less” is used based on the carry flag.
This level of detail highlights the need for a deep understanding of the processor’s operation. It’s moments like these that make me love it.

Fraction Simplification and Result Display

Simplifying a fraction is the core routine we’ve implemented first because other routines rely on it. The key to simplifying fractions is finding the greatest common divisor (GCD), which we accomplish using the Euclidean algorithm.

The simplification function handles several steps:

The routine receives arguments from the user.
The routine checks whether the denominator is zero.
The routine copies them and passes them to the GCD routine.
The routine divides the numerator and denominator by the GCD result.
The routine outputs the result with the following function :

Check whether the fraction is proper or not.
If improper, convert it to mixed:

Prints the result of the transformation

Converting a Mixed Fraction to an Improper Fraction

Our program also supports converting mixed fractions to improper fractions using a well-defined algorithm. The implementation details are provided there:

Multiplying and Dividing Fractions

Multiplication and division of fractions are relatively straightforward operations, each with its dedicated function:

Adding and Subtracting Fractions

Adding and subtracting fractions are more complex due to the need to find a common denominator. We’ve tackled this challenge by implementing a casting operation based on GCD, enabling us to perform addition and subtraction efficiently.

The casting operation is done using the following formula:

It is implemented with the following code:

The next happens in the code:

Entering the numerator and denominator of both fractions.
Denominators are checked for zero.
Denominators are passed as arguments to the GCD routine.
The common denominator and multipliers for the numerators are found based on the resulting GCD.
Fractions are reduced to a common denominator.

When the casting function is ready, addition and subtraction are implemented by this code:

Conclusion

The final executable file is 8322 bytes in size, which may seem significant for a calculator, but future optimization is possible.

The program works as follows:

The complete source code can be found here:

Main: [link to gist]
Subroutines: [link to gist]
Definitions: [link to gist]
Data: [link to gist]

This program not only serves as a powerful tool but also brings back memories of school mathematics. I’ve thoroughly enjoyed this journey into the 80s and plan to continue exploring the capabilities of the Commodore 64 for mathematical challenges. If you’re interested, stay tuned for more adventures.

In this endeavor, I’ve deviated from the norm using macros, which greatly expedited development and made the process more enjoyable. I’ve created a tool I missed during my school days, and it’s a testament to the power of the Commodore 64. Join me in this journey through the 80s, where we continue to harness the capabilities of this remarkable machine for mathematical purposes.

Creating a Fraction Converter for the Commodore 64 in Assembly Language (6510/6502)

Alexey Medvecky — Wed, 06 Sep 2023 07:31:18 +0000

In this article, we’ll delve into the process of creating a fraction to decimal, percentage, and back converter for the Commodore 64 using Assembly language (6510/6502). This project not only provides a practical application of assembly programming skills but also allows us to explore the nostalgic charm of 80s computing.

Problem Statement

Embracing the 80s Nostalgia

As we traverse through the time machine, we find ourselves in the 80s, where writing mathematical programs for the Commodore 64 is not just a hobby but part of a school course. In this article, we embark on our journey to create a fraction converter, a seemingly simple yet insightful project to sharpen our Assembly language skills.

This article continues the topic that I began in previous articles:

Solution

Building a BASIC Prototype

Traditionally, we commence our implementation with a prototype in BASIC. Prototype serves as a foundation, allowing us to visualize the program’s structure and overall design.

Two noteworthy aspects of the prototype include:

Menu Implementation: We determine menu options.
Exponent Calculation: Utilizing the length of textual number representation to compute the exponent.

Transitioning to Assembly Language

Having covered numerous details in previous articles, we will focus on the high-level logic of our Assembly solution, along with the innovative approaches we’ve adopted.

Menu Handling

After the screen setup and tooltip display, the menu display function takes centre stage as the program’s initial function. This function efficiently displays menu items and handles user input. If the user enters an invalid option, the program gracefully ignores it. Subsequently, it invokes the relevant procedure based on the user’s input.

main:
        jsr     prepare_screen
        jsr     main_usage
menu:
        jsr     show_menu
wait_for_continue:
        jsr     getin
        beq     wait_for_continue
        cmp     #q_sym
        beq     go_to_exit
        cmp     #one_sym
        beq     handle_decimal
        cmp     #two_sym
        beq     handle_fraction
        cmp     #three_sym
        beq     handle_percent
        jsr     clearscreen
        jmp     menu
handle_decimal:
        jsr     decimal_handler
        jmp     continue_or_exit
handle_fraction:
        jsr     fraction_handler
        jmp     continue_or_exit
handle_percent:
        jsr     percent_handler
        jmp     continue_or_exit
go_to_exit:
        jmp     restore_and_exit

continue_or_exit:
        jsr     usage_at_exit
wait_for_input:
        jsr     getin
        beq     wait_for_input
        cmp     #q_sym
        bne     continue
        jmp     restore_and_exit
continue:
        jsr     clearscreen
        jmp     menu

restore_and_exit:
        jsr     restore_screen

        rts

Decimal Conversion

decimal_handler:
        jsr     input_decimal
        jsr     cursor_blink_off
        jsr     calculate_den
        lda     #<n
        ldy     #>n
        jsr     fp_load_ram_to_fac
        lda     #<den
        ldy     #>den
        jsr     fp_mult
        ldx     #<num
        ldy     #>num
        jsr     fp_store_fac_to_ram
        lda     #<hundred
        ldy     #>hundred
        jsr     fp_load_ram_to_fac
        lda     #<n
        ldy     #>n
        jsr     fp_mult
        ldx     #<per
        ldy     #>per
        jsr     fp_store_fac_to_ram
        jsr     show_results
        rts

input_decimal:
        jsr     input_decimal_prompt
        jsr     input_string_proc
        jsr     string_to_fp
        ldx     #<n
        ldy     #>n
        jsr     fp_store_fac_to_ram
        jsr     get_exponent_by_counter
        lda     #space_sym
        jsr     print_char
        lda     #new_line
        jsr     print_char
        rts

Our decimal handler routine takes a decimal as an argument and converts it into a fraction and a percentage. This routine initiates with an input procedure similar to our earlier discussion. The key difference lies in calculating the exponent based on the entered character count.

get_exponent_by_counter:
        ldx     counter
        dex
        txa
        sta     e_counter
        lda     number_strings
        clc
        adc     counter
        sta     address
        dec     address
        lda     #<(address)
        sta     $22
        lda     #>(address)
        sta     $23
        lda     #string_length
        jsr     fp_string_to_fac
        ldx     #<e
        ldy     #>e
        jsr     fp_store_fac_to_ram
        rts

This procedure does the following:

Decrements the counter value by one and stores the resulting value in the exponent counters.
Loads into the accumulator the address of the beginning of the array of string representation of numbers.
Adds to the result the counter of entered characters saved in a variable.
Since the offset counts from 0 reduces the value by one.
Next, the full address of the array element is loaded with an offset.
The string at the specified address is converted to a floating point number and stored in the variable e (exponent).

The number string array looks like the following:

number_strings:
        .text   "0"
        .byte   $0
        .text   "1"
        .byte   $0
        .text   "2"
        .byte   $0
        .text   "3"
        .byte   $0
        .text   "4"
        .byte   $0
        .text   "5"
        .byte   $0
        .text   "6"
        .byte   $0
        .text   "7"
        .byte   $0
        .text   "8"
        .byte   $0
        .text   "9"
        .byte   $0
        .text   "10"
        .byte   $0
        .text   "11"
        .byte   $0
        .text   "12"
        .byte   $0
        .text   "13"
        .byte   $0
        .text   "14"
        .byte   $0
        .text   "15"
        .byte   $0

Next, in the decimal handler, a procedure is called to calculate the denominator.

calculate_den:
        ldx     e_counter
        dex
        beq     handle_tenth
        txa
        sta     counter
        lda     #<ten
        ldy     #>ten
        jsr     fp_load_ram_to_fac
mult_loop:
        lda     #<ten
        ldy     #>ten
        jsr     fp_mult
        ldx     counter
        dex
        beq     end_loop
        txa
        sta     counter
        jmp     mult_loop
end_loop:
        ldx     #<den
        ldy     #>den
        jsr     fp_store_fac_to_ram
        jmp     end_mult
handle_tenth:
        lda     #<ten
        ldy     #>ten
        jsr     fp_load_ram_to_fac
        ldx     #<den
        ldy     #>den
        jsr     fp_store_fac_to_ram

end_mult:
        rts

This routine calculates ten powered by exponent using multiplication and the e_counter value obtained in the previous routine.

Further, I get the numerator by multiplying the entered number by the denominator.
And by multiplying the entered number by 100, I get the percentage.

Next, I display the result by a separate procedure.

show_results:
        lda     #space_sym
        jsr     print_char
        lda     #new_line
        jsr     print_char
        lda     #<result_1
        ldy     #>result_1
        jsr     print_str
        lda     #<n
        ldy     #>n
        jsr     fp_load_ram_to_fac
        jsr     fp_to_str
        jsr     print_str
        lda     #new_line
        jsr     print_char
        lda     #<result_2
        ldy     #>result_2
        jsr     print_str
        lda     #<num
        ldy     #>num
        jsr     fp_load_ram_to_fac
        jsr     fp_to_str
        jsr     print_str
        lda     #<result_3
        ldy     #>result_3
        jsr     print_str
        lda     #<den
        ldy     #>den
        jsr     fp_load_ram_to_fac
        jsr     fp_to_str
        jsr     print_str
        lda     #new_line
        jsr     print_char
        lda     #<result_4
        ldy     #>result_4
        jsr     print_str
        lda     #<per
        ldy     #>per
        jsr     fp_load_ram_to_fac
        jsr     fp_to_str
        jsr     print_str
        lda     #new_line
        jsr     print_char
        lda     #new_line
        jsr     print_char
        rts

Limitations of this implementation:

The function only works with fractions < 1.
Input format “.123” without leading zero.

Fraction Processing

The fraction processor takes numerator and denominator arguments, converting them into decimals and percentages.

fraction_handler:
        jsr     input_num_den
        jsr     cursor_blink_off
        lda     #<den
        ldy     #>den
        jsr     fp_load_ram_to_fac
        lda     #<num
        ldy     #>num
        jsr     fp_div
        ldx     #<n
        ldy     #>n
        jsr     fp_store_fac_to_ram
        lda     #<hundred
        ldy     #>hundred
        jsr     fp_load_ram_to_fac
        lda     #<n
        ldy     #>n
        jsr     fp_mult
        ldx     #<per
        ldy     #>per
        jsr     fp_store_fac_to_ram
        jsr     show_results
        rts

A decimal is obtained by dividing the numerator by the denominator.
Percentages are obtained by multiplying a decimal by 100.

Percentage Conversion

The percentage handler takes percentage values as input and converts them into fractions and decimals.

percent_handler:
        jsr     input_percents
        lda     #<hundred
        ldy     #>hundred
        jsr     fp_load_ram_to_fac
        lda     #<per
        ldy     #>per
        jsr     fp_div
        ldx     #<n
        ldy     #>n
        jsr     fp_store_fac_to_ram
        lda     #<per
        ldy     #>per
        jsr     fp_load_ram_to_fac
        ldx     #<num
        ldy     #>num
        jsr     fp_store_fac_to_ram
        lda     #<hundred
        ldy     #>hundred
        jsr     fp_load_ram_to_fac
        ldx     #<den
        ldy     #>den
        jsr     fp_store_fac_to_ram
        jsr     show_results
        rts

A decimal is obtained by dividing a percentage by 100.
Normal: numerator percentage entered denominator 100.

This function has a limitation: it can correct handle only whole percent.

Conclusion

In this journey through the Commodore 64’s mathematical realm, we’ve developed a fraction converter in assembly language. You can find the complete source code for this program [here].

Here is an example of execution

The binary file has a size of 3220 bytes.

While school mathematics may seem basic, it provides an excellent playground for honing assembly programming skills. This project has showcased the creative possibilities that the 80s era and Commodore 64 offer.

As we continue this exciting journey, I invite you to stay with me for more mathematical adventures in the world of Commodore 64 programming.

Embarking on an 80s Time Travel Adventure: Commodore 64 Machine Code Programming with BASIC

Alexey Medvecky — Mon, 07 Aug 2023 10:43:18 +0000

In this article, we delve into the captivating realm of Commodore 64 programming, journeying back to the 80s to uncover the art of crafting machine code using the trusty BASIC language.

Unveiling the Challenge

As alluded to in a prior piece, my quest led me to an assembly book, reigniting my quest for knowledge.

The first thing that impressed me was the ability to memorize machine codes and then call them for execution using only BASIC. While this may seem commonplace to some, it was a revelation for me. In an era where disk drives and assemblers weren’t always at hand, BASIC stood as a steadfast companion.

Harnessing BASIC Magic

To showcase BASIC’s prowess, I’ll guide you through crafting a “HELLO WORLD” program in machine code, and the method behind the magic is surprisingly simple.

Key BASIC Commands:

PEEK(): Retrieves memory cell contents at a given address.
POOKE , : Writes a value to a specific memory cell.
READ, DATA: Creates and sequentially reads an array of data.

Our initial venture involves writing a character to video memory, achieved through a concise program structure.

The BASIC part here acts as a program loader in machine codes.

Employing the READ command, we extract machine code values one by one until completion.
The POKE statement diligently transfers these segments to memory, starting at address 49152 with incremental offsets.

Upon completing the loop, a SYS instruction calls the stored machine code procedure, initiating execution. The machine code itself is elegantly straightforward. We inscribe character code “x” (24) into the accumulator, preserving it at the video memory’s onset (address 1024).

Our exploration doesn’t halt here. The process extends to outputting entire words, data transfer from BASIC to machine code, and dynamic memory interaction.

I can also transfer data from BASIC to the program in machine codes.

Here, the letter code is requested via INPUT and then, via POKE, the resulting value is written to a specific memory cell.
The machine code program takes data from this memory location.

Here is such programming in machine codes straight from BASIC.

A Journey of Rediscovery

Reflecting on my initial tryst with BASIC on a Z80-based home computer, I’ve come to respect its capabilities anew. BASIC’s techniques seamlessly transition to assembly programming, and the language itself emerges as a potent tool, especially through the methodologies detailed in this article.

The Continuation of an Odyssey

Armed with newfound insights, I’m poised to continue my 80s odyssey. The quest persists as I delve deeper into the potential of C64 and Assembly, particularly in tackling intriguing mathematical challenges.

Join me as we traverse the enthralling landscape of 80s programming, unearthing gems from the past to enrich our present journey.

80s Time Travel: Commodore 64 Math with Square Root Approximation & Factorization using Assembly

Alexey Medvecky — Mon, 07 Aug 2023 09:51:00 +0000

In this article, I embark on a nostalgic journey back to the 80s, using the Commodore 64 (C64) to solve mathematical challenges. Building on the success of my previous article, where I tackled proportion problems, I now dive into creating a calculator capable of computing approximate square roots and factoring them into factors using Assembly language.

Formulation of the Problem.

I was inspired to push the boundaries further after successfully solving proportion problems in my last article. I aimed to harness the power of the C64 to develop a calculator that efficiently calculates square roots, a frequently demanded operation in various mathematical domains.

Additionally, I sought to enable the factorization of square roots, a more accurate solution, which proves valuable in fields like trigonometry, signal processing, electrical circuit calculations, and optimization calculations. Function for calculation of square root numerical approximate value have every calculator.

To factorize the square root into factors, special tools are already needed. So the corresponding program for C64 is handy.

The Solution

Algorithm

The core algorithm I adopted is as follows:

Obtain the root of the number ‘x’.
Find an approximate answer using the built-in BASIC SQR function.

For factorization in the loop, do the following:

Traverse integers from 1 to ‘x’ and identify the maximum number whose square is a factor of ‘x’.
Determine the second multiplier as ‘x’ divided by the square of the maximum factor.

Prepare answer:

The first part of the answer is the square root of the square of the maximum factor.
The second part lies under the square root and is the second factor.

Implementation on BASIC

On BASIC, the program takes shape as follows:

To simulate the modulo operation in BASIC, I used the following construction: A % B = A — INT(A / B) * B. Modulo is used to determine whether a number is a factor of the argument or not. The result of running the program looks like this:

The cycle is already noticeable in the delay between the approximate answer and the factorized one, even on big numbers.

Implementation On Assembly

Building on the procedures developed in my previous article, I focused on the primary algorithm implementation.

The implementation is as follows:

        *= $1000
main:
        jsr     prepare_screen
        jsr     main_usage

wait_for_continue:
        jsr     getin
 beq     wait_for_continue
        cmp     #q_sym
        beq     go_to_exit
        jmp     get_args
go_to_exit:
        jmp     restore_and_exit

get_args:
        jsr     get_argument
        jsr     init_variables

        //calculate and print sqr(argument)
        lda     #<argument
        ldy     #>argument
        jsr     fp_load_ram_to_fac
        jsr     fp_sqr
        ldx     #<ul
        ldy     #>ul
        jsr     fp_store_fac_to_ram
        jsr     fp_fac_print

        //ul = int(sqr(argument)) + 1
        lda     #<ul
        ldy     #>ul
        jsr     fp_load_ram_to_fac
        jsr     fp_int
        lda     #<one
        ldy     #>one
        jsr     fp_add
        ldx     #<ul
        ldy     #>ul
        jsr     fp_store_fac_to_ram

The first block involves:

Preparing screen.
Retrieving the argument from the user.
Initializing variables with a value of 1.
Calculating the approximate square root value using the BASIC function.
Setting the upper limit for the factorization loop.

The subsequent block features the factorization loop:

loop:   // for mf=1 to ul

        //x = mf^2
        lda     #<mf
        ldy     #>mf
        jsr     fp_load_ram_to_fac
        lda     #<mf
        ldy     #>mf
        jsr     fp_mult
        ldx     #<x
        ldy     #>x
        jsr     fp_store_fac_to_ram

        //y = int(argument) / int(x)
        lda     #<argument
        ldy     #>argument 
        jsr     fp_load_ram_to_fac
        jsr     fp_int
        ldx     #<y
        ldy     #>y
        jsr     fp_store_fac_to_ram

        lda     #<x
        ldy     #>x
        jsr     fp_load_ram_to_fac
        jsr     fp_int 

        lda     #<y
        ldy     #>y
        jsr     fp_div
        ldx     #<y
        ldy     #>y
        jsr     fp_store_fac_to_ram

        //if argument - int(y) * x <> 0 goto next iteration
        lda     #<y
        ldy     #>y
        jsr     fp_load_ram_to_fac
        jsr     fp_int
        lda     #<x
        ldy     #>x
        jsr     fp_mult
        lda     #<argument
        ldy     #>argument
        jsr     fp_subst
        lda     #<zero
        ldy     #>zero
        jsr     fp_cmp
        cmp     #$0
        bne     not_factor

        lda     #<x
        ldy     #>x
        jsr     fp_load_ram_to_fac
        ldx     #<maxf
        ldy     #>maxf
        jsr     fp_store_fac_to_ram        
not_factor:
        lda     #<mf
        ldy     #>mf
        jsr     fp_load_ram_to_fac
        lda     #<one
        ldy     #>one
        jsr     fp_add
        ldx     #<mf
        ldy     #>mf
        jsr     fp_store_fac_to_ram
        lda     #<ul
        ldy     #>ul
        jsr     fp_cmp
        cmp     #$1
        bne     go_to_loop
        jmp     end_loop
go_to_loop:
        jmp     loop

end_loop:

The Assembly code mirrors the functionality of the corresponding BASIC loop. Floating-point number comparisons are conducted using a BASIC function, and the results in register A are tested using a simple comparison operator.

Then I calculate and store both parts of the result.

  //sr = int(sqr(maxf))
        lda     #<maxf
        ldy     #>maxf
        jsr     fp_load_ram_to_fac
        jsr     fp_sqr
        jsr     fp_int
        ldx     #<sr
        ldy     #>sr
        jsr     fp_store_fac_to_ram 

        //of = int(argument)/int(maxf)
        lda     #<argument
        ldy     #>argument
        jsr     fp_load_ram_to_fac
        jsr     fp_int
        ldx     #<of
        ldy     #>of
        jsr     fp_store_fac_to_ram

        lda     #<maxf
        ldy     #>maxf
        jsr     fp_load_ram_to_fac
        jsr     fp_int
        lda     #<of
        ldy     #>of
        jsr     fp_div
        jsr     fp_int
        ldx     #<of
        ldy     #>of
        jsr     fp_store_fac_to_ram

Results output:

//result output
        lda     #<sr
        ldy     #>sr
        jsr     fp_load_ram_to_fac
        lda     #<one
        ldy     #>one
        jsr     fp_cmp
        cmp     #$1
        bne     next_part
        lda     #<sr
        ldy     #>sr
        jsr     fp_load_ram_to_fac
        jsr     fp_to_str
        jsr     print_str
next_part:
        lda     #<of
        ldy     #>of
        jsr     fp_load_ram_to_fac
        lda     #<one
        ldy     #>one
        jsr     fp_cmp
        cmp     #$1
        bne     end_of_output
        lda     #<result_string_1
        ldy     #>result_string_1
        jsr     print_str
        lda     #<of
        ldy     #>of
        jsr     fp_load_ram_to_fac
        jsr     fp_to_str
        jsr     print_str
        lda     #right_p_sym
        jsr     print_char
end_of_output:
        lda     #new_line
        jsr     print_char

Here I’m ignoring the part of the result which equals one because it doesn’t matter when factoring.

Here is the output of the program:

Assembly program compiles to 2864 byte binary file. The delay is also visible in large numbers but much less than in the BASIC implementation.

Here is the complete source code of the program.

Conclusion.

While BASIC provides valuable tools for solving simple mathematical problems, the ability to call BASIC functions from Assembly code saves effort and allows for compact, fast programs.

My journey through the 80s, reviving mathematical programming on the C64, has been enjoyable and rewarding. To further improve my skills, I aim to delve into assembly 6510 (6502) and find relevant books to fill any knowledge gaps.

As I continue my exploration of mathematical programs for C64, I invite you to stay tuned for my future posts. The excitement of revisiting the 80s has given me ample reasons not to return to our time.

Until next time, warm regards and happy programming!

A Retro Adventure: Implementing an Aspect Ratio Calculator for the Commodore 64 in Multiple Programming Languages

Alexey Medvecky — Mon, 07 Aug 2023 09:38:58 +0000

In this article, I explore the possibility of using C64 to solve mathematical problems. Using the example of solving the proportion, I will show how BASIC, C, and MOS 6510 (6502) Assembly can be used for these purposes using the BASIC functions for the floating point operation.

What do I want to do?

And so I continue my journey through time in the 80s. I’m trying to settle down here and use C64 as a tool for study and work.

In past articles:

Time-Travelling to Commodore 64: Hello World Program on C.

Time-Travelling to Commodore 64: Hello World Program on Assembly.

I learned a little about the tools I can use: BASIC, Assembly, C. Contrary to my expectations, C could have been better here than BASIC and Assembly. It’s time to do something more exciting and valuable than just “Hello, world”.

Problems from the school mathematics course for solving proportions are best suited for this. The formula for equivalent ratios looks like this.

Given three knowns and one unknown, the unknown can continuously be computed. For example, in the formula n1 / d1 = n2 / d2, if d1 is unknown, it can be calculated as follows d1 = n1 * d2 / n2.

The proportions are simple enough to solve without mastering programming tools. At the same time, the proportion calculator is quite a helpful thing.

It can be used for various calculations:

The ratio in proportions in the preparation of recipes
Conversion from one unit of measurement to another
Percent-related problems.
etc

First Approach

I made the prototype in BASIC.

Works well enough.

There is implemented following algorithm. nj

I read the parameters and used 0 to sign that the parameter is unknown.
Using branching, I select the desired formula for the calculation.
I bring out the result.
I offer the choice to continue the work or exit the program.

Now I want to make a more compact program version with my design.

Since I still feel unsure about the MOS 6510(6502) Assembly, I decide to try C again on C64.

Of course, I can also do the screen design in BASIC, but I need to be more active to remember all this again. Still, I want to use more advanced tools.

Big fail with C.

And so the implementation in C.

void setUpScreen( void )
{
   clrscr();
   defaultBGColor = bgcolor( COLOR_BLACK );
   defaultBorderColor = bordercolor( COLOR_BLACK );
   defaultTextColor = textcolor( COLOR_GREEN );
}

I started by setting screen parameters using library functions. Functions have an exemplary implementation. When selecting new parameters, they return the original ones. It is very convenient to save them to restore the settings when I exit the program.

Usage hint output function

void usage( void )
{
   cputsxy( 12, 0, "RATIO CALCULATOR" );
   cputsxy( 12, 2, "N1/D1 = N2/D2" );
   gotoxy( 0, 4 );
   puts( "Input ratio pramams by prompt" );
   puts( "Press any key to continue" );
   puts( "or q to exit" );
}

Here I use both library functions for C64 and standard C functions for text output and positioning.

Argument input function.

void getArgs( int * n1, int * d1, int * n2, int * d2 )
{
   cursor( 1 );
   printf( "%s? ", "n1 (zero if unknown)" );
   scanf( "%d", n1 );
   printf( "%s? ", "d1 (zero if unknown)" );
   scanf( "%d", d1 );
   printf( "%s? ", "n2 (zero if unknown)" );
   scanf( "%d", n2 );
   printf( "%s? ", "d2 (zero if unknown)" );
   scanf( "%d", d2 );
   cursor( 0 );
}

I use a library function for C64 to turn the cursor blinking on and off.

Response Calculation Function

char getAnswer( int n1, int d1, int n2, int d2 )
{
   int answer = 0;

   if ( n2 == 0 )
   {
      answer = d2 * n1 / d1;
      printf( "n2 = %d\n", answer );    
   }
   else if ( d2 == 0 )
   {
      answer = n2 * d1 / n1;
      printf( "d2 = %d\n", answer );    
   }
   else if ( n1 == 0 )
   {
      answer = d1 * n2 / d2;
      printf( "n1 = %d\n", answer );    
   }
   else if ( d1 == 0 )
   {
      answer = n1 * d2 / n2;
      printf( "d1 = %d\n", answer );    
   }
   else
   {
      puts( "Wrong params" );
   }

   puts( "Press any key to continue" );
   puts( "or q to exit" );

   return cgetc();
}

An unpleasant surprise awaited me, the C compiler available does not support floating point numbers.
This is one more point in favour of using Assembly for development under C64.

In this function, I violated the principle of sole responsibility
Because in addition to calculating the answer, the operator’s choice to continue the calculations or exit is returned here and also displays a hint.
I’ll probably fix this in the future.

The last function I wrote is to restore the screen state before exiting the program.

void resetDefaultScreen( void )
{
   clrscr();
   bgcolor( defaultBGColor );
   bordercolor( defaultBorderColor );
   textcolor( defaultTextColor );
   * ( char *  ) 0xD018 = 0x15;
}

Here I use the same functions as in the screen settings.
I also use the system variable setting.
This command is equivalent to POKE 53272.21, which sets the output mode of letters to uppercase.

The main function looks like this.

int main ( void )
{
   int n1 = 0;
   int d1 = 0;
   int n2 = 0;
   int d2 = 0;
   unsigned character = 0;
   int answer = 0;

   setUpScreen();

   usage();
   character = cgetc();

   while ( character != 'q' )
   {
      getArgs( &n1, &d1, &n2, &d2 );
      character = getAnswer( n1, d1, n2, d2 );

      clrscr();
   }

   resetDefaultScreen();

   return EXIT_SUCCESS;
}

It uses the C64 library function to clear the screen.

Here is a working example

The complete source code of the program is available here.

The executable file turned out to be 7167 bytes.

Calculating the proportions of the possibility of a floating point operation could be more helpful. So I take up the implementation in Assembly.

Assembly Saves the World.

I’ll start as before with the preparation of the screen.

prepare_screen:
// set gren text color
        lda     #5
        sta     text_color
        jsr     clearscreen

// set border and background black
        lda     #$00
        sta     border
        sta     background
        rts

Here, the same thing happens as in the analogue in C. I write to the system variables at the desired addresses and values through the accumulator.

Here is the main hint.

main_usage:
        ldx     #$00
        ldy     #$0a
        jsr     set_cursor

        lda     #<usage_1
        ldy     #>usage_1
        jsr     print_str

        lda     #new_line
        jsr     print_char
        jsr     print_char

        lda     #<usage_1_1
        ldy     #>usage_1_1
        jsr     print_str

        lda     #new_line
        jsr     print_char
        jsr     print_char

        lda     #<usage_2
        ldy     #>usage_2
        jsr     print_str

        lda     #new_line
        jsr     print_char

        lda     #<usage_3
        ldy     #>usage_3
        jsr     print_str
        lda     #new_line
        jsr     print_char
        rts

Here I use three kernal functions

set_cursor (0xE50C) Arguments are passed through X Y registers
print_char (0xFFD2) character code for output must be in the accumulator
print_str(0xAB1E) in register A low byte of row address in Y high byte

The string must end with ‘\0’ as in this example.

usage_1:
        .text   "RATIOS CALCULATOR"
        .byte   $00

Next comes a piece of code responsible for waiting and processing the user’s reaction.

wait_for_continue:
        jsr     getin
        beq     wait_for_continue
        cmp     #q_sym
        beq     restore_and_exit_jmp
        jmp     get_args

restore_and_exit_jmp:
        jmp     restore_and_exit

To read a character into the accumulator, I use the getin(0xFFE4) function

Three checks follow.

If the accumulator is 0, the user did not enter anything. Repeat the entry procedure.
If a user selects “Q “ as an exit, I proceed to the appropriate procedure.
If any other character, I jump to calculations.

Calculations begin with the collection of arguments

The following function performs them.

get_arguments:
        jsr     input_n1_proc
        jsr     input_d1_proc
        jsr     input_n2_proc
        jsr     input_d2_proc
        jsr     cursor_blink_off
        rts

Functions run similar functions for receiving each argument and, in the end, call the function to turn off the cursor blinking.

cursor_blink_off:
        lda     $00cf
        beq     cursor_blink_off
        lda     #$01
        sta     $cc
        rts

According to the state of the system variable 0x00CF, this function waits for the moment when the cursor will go out and then writing one to the system variable 0x00CC disables the cursor blinking.

The function for getting an argument is already more complicated.

input_n1_proc:
        jsr     input_n1_prompt
        jsr     input_string_proc
        jsr     string_to_fp
        ldx     #<n1
        ldy     #>n1
        jsr     fp_store_fac_to_ram
        lda     #space_sym
        jsr     print_char
        lda     #new_line
        jsr     print_char
        rts

The input_prompt function prints an input prompt to the screen as described.
Next, the operation of reading the string representation of the argument from the keyboard starts.

input_string_proc:
        ldy #$00
        ldx     #$00
        lda     #$00
        sta     counter
input_get:
        jsr     getin
        beq     input_get
        cmp     #$0d
        beq     input_string_end
        cmp     #$14
        bne     increase_counter
        jsr     print_char
        ldx     counter
        dex
        stx     counter
        lda     #$00
        sta     input_string,x
        jmp     input_get
increase_counter:
        ldx     counter
        sta     input_string,x
        jsr     print_char
        inx
        stx     counter
        cpx     #string_length
        bne input_get
input_string_end:
        rts

In this function, I first reset the accumulator, all index registers, and the counter.

I call the get_in function

Next, I check for the following cases

If the user presses return, the input is complete.
If the user has entered backspace, I display the backspace character. Showing this character causes the cursor to jump back one character visually. Next, I decrease the counter of entered characters and delete the previously entered character in the buffer by writing zero in its place. After that, I return to the beginning of the procedure.

When entering any other character, I perform the following actions.

I store the character in the buffer with an offset equal to the counter of the entered characters.
I display the character on the screen.
I increment the counter.
I check the counter. If the maximum is reached, then an entry is terminated.
Otherwise, I proceed to the processing of the next entered character.

Further, the function input_n1_proc continues to be executed.
After the input of the string is completed, I use the following function
to convert the string to float.

string_to_fp:
        lda     #<input_string
        sta     $22
        lda     #>input_string
        sta     $23
        lda     #string_length
        jsr     fp_string_to_fac 
        jsr     clear_input_string
        rts

To do this, I use the existing BASIC function that can be called through the address (0xB7B5). As arguments at addresses 0x22 0x23, I need to place the low and high byte of the address of the buffer with the string, in register A, the length of the entered string. Next, I call the conversion function. The function puts the received number in the FAC, which is located at the following addresses in the RAM:

Address 97/$61 is the exponent byte.
Addresses 98–101/$62–$65 hold the four-byte (32 bit) mantissa.
Address 102/$66 stores the sign in its most significant bit; 0 for positive, $FF (-1) for negative.
Address 112/$70 contains rounding bits for intermediate calculations.

Then I clear the buffer by writing 0 to it.

After that, I write the number from the FAC to a variable using the function (0xBBD4) . Funcion needs address of 5 bytes variable as argument where will store value from FAC.

One important point some of operations with FAC corupt data in FAC. Fro example function for print FAC to scree. That’s why need in first store data from FAC before any operation with FAC.

Next, I output space to overwrite the courses and translate the line.

Similarly, I get and save all the necessary variables.

Next block of code

//check n1 
        lda     #<n1
        ldy     #>n1
        jsr     fp_load_ram_to_fac
        lda     #<fp_zero
        ldy     #>fp_zero
        jsr     fp_cmp
        cmp     #$00
        beq     solve_for_n1

..................................

        lda     #<wrong_params
        ldy     #>wrong_params
        jsr     print_str
        lda     #new_line
        jsr     print_char

        jmp     wait_to_exit

solve_for_n1:
        jsr     solve_for_n1_proc
        jmp     wait_to_exit

The entered variables will be checked for 0 one by one using the floating point comparison function (0xBC55B), which compares the FAC with the number in memory at A Y.
After the unknown variable is found, control is transferred to the corresponding calculation function.
If the operator has not entered an unknown value, an error message and a suggestion to exit the program or continue calculations are displayed.

The calculation function looks like this.

solve_for_n1_proc:
        lda     #<d1
        ldy     #>d1
        jsr     fp_load_ram_to_fac

        lda     #<n2
        ldy     #>n2
        jsr     fp_mult

        ldx     #<n2
        ldy     #>n2
        jsr     fp_store_fac_to_ram

        lda     #<d2
        ldy     #>d2
        jsr     fp_load_ram_to_fac

        lda     #<n2
        ldy     #>n2
        jsr     fp_div

        ldx     #<n1
        ldy     #>n1
        jsr     fp_store_fac_to_ram

        jsr     result_n1_prompt

        lda     #<n1
        ldy     #>n1
        jsr     fp_load_ram_to_fac

        jsr     fp_fac_print
        lda     #new_line
        jsr     print_char
        rts

The function performs multiplication and division of floating point numbers using the functions provided by BASIC. Further, using the previously described function, the result is output.

The final block of the program.

wait_to_exit:
        jsr     usage_at_exit
wait_for_input:    
        jsr     getin
 beq     wait_for_input
        cmp     #q_sym
        bne     continue
        jmp     restore_and_exit
continue:
        jsr     clearscreen
        jmp     get_args
restore_and_exit:
        jsr     restore_screen

        rts

Displays a hint prompting a user to continue computing or exit.
Depending on the user’s choice, respectively returns to the parameter input stage or restores the initial state of the screen and exits to BASIC.

Screen recovery.

estore_screen:
// restore border and background colors
        lda     #$0f6
        sta     background
        lda     #$fe
        sta     border

// restore text color
        lda     #$e
        sta     text_color
        jsr     clearscreen

// restore text mode
        lda     #$015
        sta     $d018
        rts

The program works like this.

The full text of the program is available here
The executable file size is 3137 bytes.
Approximately two times less than the option on C.

Final conclusion of today’s journey.

What conclusions can be drawn from the work done?

C in the realities of C64 in the 80s is not as good as in our time.
BASIC is quite good and has extensive features, but it needs to be faster, and programs come out large.
Assembly, on the one hand, looks like a leader. Learning and using it is easier than it seemed, mainly if you use the ready-made functions that kernal and BASIC provide. But the development speed still needs to be improved, especially if you write something more voluminous.

If you look closely at Assembly, learning BASIC seems more valid now. BASIC is just fine for writing program prototypes before they are implemented in Assembly.

It was a good day in the 80s. I am more and more immersed in the realities of programming at this time. When you try something with your hands, many mental distortions dissipate.

I like it here more and more, and I’m still in no hurry to return. Thank you for being a part of this journey.

I hope it was at least fun.

Warm regards.

Stay tuned for my next posts.

Time-Travelling to Commodore 64: Hello World Program on Assembly.

Alexey Medvecky — Mon, 07 Aug 2023 08:13:31 +0000

In this article, I continue my journey into the 80s, which I started in the previous article and will further explore the programming tools that the Commodore 64 offered in those years. In this article, I will look at the possibilities of programming on assembly using Turbo Macro Pro.

After experimenting with C, described in the last article, I concluded that there are more convenient tools for c64.
Therefore, the following tool is assembly.

To start programming on assembly, I must understand the MOS 65xx processor instructions, the C64 memory map, and how the peek and poke operators work.

Also, I need a tool to compile assembly code. I used Turbo Macro Pro. Turbo Macro Pro has good documentation and can highlight syntax errors almost immediately.

I can load TMP from the disk with the familiar ‘LOAD’ command. Run the TMP command with ‘sys 32768’; this command transfers control to the code at the specified address.

After starting, I got into the code editor.
The editor is pretty handy.

I will try to write a “hello world” program.
To do this, I need to place a line with text in memory and display it in video memory.
For this, I am using the following code.

Here I am using 0x01000 as an entry point
I initialize register x to zero.
In the loop, I will perform the following actions:

I read a character from a string at index x into the accumulator.
I store the contents of the accumulator at the beginning of the video memory with an offset x.
I increment x
Checking if x is not equal to the length of the string If not, the cycle repeats.

After the end of the program, the control goes back to the BASIC, and the program’s results are not visible.
Therefore, after the output of the line, I add an infinite loop.

To start the program, I need to press the back arrow key, which locates in the top left corner. It is a command button. After it, I need to enter the command for the editor.
I enter a “3” after the command button to compile the program. Appears a screen with the results of the compilation. The ‘s’ button runs the code.

My string appeared at the beginning of the screen on top of everything already on screen.

Not very pretty. I need to clear the screen.
To do this, I stop the program with the key combination run/stop + restore and return to BASIC. With the sys 32768 commands, I return to TMP, where my source code persists, which is convenient.

The next step is screen cleaning.
For this, I have added the following code.

This code does the following:

Writes 0 to register x
Writes 0x020 ( space code ) to the accumulator
Then, in a loop:
Writes the accumulator’s value to a region of video memory that starts at addresses 0x0400 0x0500 0x0600 0x0700 with an x offset.
Decreases x by one.
In this case, the ‘bne’ operator will work when x not equals 0. Accordingly, the code will write spaces to all specified areas with an offset from FF to 0. That is the entire visible area of the screen. Now the output looks like this.

It seems better, but I want to display the inscription in the middle of the screen. Everything is simple here. I change the starting address of the output to ‘0x054e’, in which the text will be approximately in the centre.

Here is a new output.

I also wanted to make the output green like in classic terminals.
After studying the documentation, I realized I needed to write the code for the colour, 5 for green, into memory at 0x0286.
And also, call the system program to update the screen.
Here is the relevant code.

Execution result.

Everything is beautiful now. I decided to compile an independent program and run it from BASIC. According to the documentation, I again enter the command mode to do this. Only instead of 3 I need to press 5.
TMP prompts me to enter the name of the executable file. Also, I saved the source for this. I used the s command. To run the finished program, I load it and run it with the sys command 4096 (0x0100 ). This address that I set as the entry point.

Something went wrong.

As I understand from the documentation, after the output, I need to restore the screen mode to LOWER / UPPER CASE
to do this, I need to write value 0x017 at the address 0x0d018 analogue
poke 53272,23

It looks better, but I want a strict black background. To do this, according to the documentation, I need to write 0 (black code) into memory at addresses 0x0d020 (for the border) and 0x0d021 (for the background)

lda #$00
sta $d020
sta $d021

Now It looks as I wish.

Yeah, now I have prepared the workbench for assembly programming.

What can be the conclusion?
On the one hand, programming on assembly requires a lot of immersion in the architecture of mos 65xx processors, understanding the C64 memory map and knowledge of its system routines.
It is easier than it looks at the first time.
On the other hand, I get faster and more convenient compilation instead of constant disk juggling, as in Power C.

It is clear why the programmers of the 80s on the Commodore 64 preferred assembly.

I’m still in no hurry to return from the 80s.

Thank you for being a part of this journey.
I hope it was at least fun.
Warm regards.
Stay tuned for my next posts.

Time-Travelling to Commodore 64: Hello World Program on C.

Alexey Medvecky — Mon, 07 Aug 2023 06:14:19 +0000

This time I will review the possibilities of programming on the Commodore 64 and try to understand how a modern programmer would feel in the realities of the mid-80s.

In those years, I did not have a Commodore 64 but had a ZX Spectrum clone.

There was no Internet, and there were few programming books.
So the maximum I then did on the Spectrum was writing simple scripts in BASIC to solve problems in mathematics and physics and games like Landing on the Moon.

Therefore, I have always been interested in the stories of my acquaintances who did more exciting things on 8-bit computers. I wanted to do it myself using the knowledge now available.

I'm starting an experiment. I'm in my mid-80s; I have a Commdore64 with a disk drive, some set of programs and books, there is no Internet, but the grass is greener, the sun is brighter, and the girls are more beautiful, and there is also a lot of time for experiments.

From the beginning, I needed to understand what the Commodore 64 offered for programming and try to write a "hello world" program.

The first thing that catches my eye is a different layout of special characters on the keyboard and a tiny resolution by modern standards.

If I get used to the layout, it's a matter of time, but how the developers in these conditions viewed and debugged extended programs; so far, the question is.

After turning on the C64, BASIC is launched. This is a programming environment and a shell with essential OS functions.
I can save and delete files to disk and make some adjustments by changing the values of variables in memory using the poke statement.

// There is a command examples
SAVE "MY_PRG",8
LOAD "MY_PRG",8,1
LIST
RUN
POKE 53280,1

Since BASIC starts immediately, let's try to do something about it, for example, "Hello world".
In BASIC, everything is simple. Compared to Spectrum, the C64 has a more advanced ability to edit text within the screen.
The first program looks like this.

I can save a program to disk and then load it back.
I figured out the BASIC, but there are too few tools here.

What else can I try? Assembly is still tricky because I need to learn a set of commands.
The C should be better here because I know it.
I have a set of two floppy disks for C with the "power c" compiler.

After a short study of the manual, I started the shell.

Compared to BASIC, it's much more comfortable; at least there are several Unix-like commands like 'ls' and 'rm'.

I launch the editor and enter the program's text. The non-standard layout still interferes, but it's not so scary anymore. Curly braces are placed on the "+" and "-" keys. I know it from the manual.

// command to launch editor with spell checking

ced

I have entered the program. The separate command performs a syntax check
Command mode is invoked by key (Hi VIM)

// to enter command mode press [run/stop] button
// command to start spelcheking 

check

//command to exit to shell

quit

From the same mode, we save the program's text to disk just to the same disk where power c is located. It's worth saving to a separate floppy disk for more complex projects.

I exit the editor and start the compiler. Here is a suggestion to use separate source and object file disks.

I run the linker to create a simple shell executable.

Then I enter a special character — arrow to top. At this stage, I need to change the disk to the second one because that is where the necessary libraries are located. After the prompt, change the disk back. Save the executable file. Everything is ready. Now I can run my program as a shell script.

Yes, the programmer is almost a DJ here, but if the project is large and the source and object files are stored on separate disks…..

This most straightforward program's compilation, linking and loading time could be more encouraging. I had time to read the manual during the process, but what will happen on a more advanced project?

I add the key -s to the link command, repeat the linking process, and get an independent executable file.

This executable I can now load and run from BASIC.

The inscription became an upper case for some reason, but this looks like some feature. I will deal with this later.

The "Hello World" program is not just a string output. It means
the developer knows how to use the editor, compiler and linker. These days when it's all done automatically or in one command, it doesn't seem very relevant, but on C64, "hello world" is still an important step to start programming.

The first step is done, now I still need to make hello world in Assembly, and then it will be possible to say that I have all the tools in my hands.

I don't want to return from the 80s, so I'll rest here and take a walk.

Thank you for being a part of this journey.
I hope it was at least fun.
Warm regards.
Stay tuned for my next posts.